

/*		cmpc1
*
*	Just compare two equal  8 character (9 bit) strings.
*	=  =>  zero and carry  indicators will be  on.
*/

inst	cmpc	-nt "Equal 9 bit char strings"	-io 1
	-ir  zr cr;

desc 1	-ns 8;

desc 2	-ns 8;

data 1	"abcd1234";

data 2	"abcd1234";

page	-all;

/*		cmpc2
*
*	Same as cmpc1 except move data across page boundary and add modification.
*/

inst	cmpc	-nt"Same as prev but X pg bound"	-io 2
	-ir	zr cr
	-mf1	ar reg idb
	-mf2	ar reg idb;

desc 1	-ns 8;

desc 2	-ns 8;

data 1	-do -4	"abcd"  "1234";

data 2	-do -2	"ab"  "cd1234";

page	-all;

/*		cmpc3
*
*	Same as cmpc2 except first string is >  than second string.
*/

inst	cmpc	-nt  "S1 > S2 - X pg bound"	-io 3
	-ir	cr
	-mf1	ar reg idb
	-mf2	ar reg idb;

desc 1	-ns 8;

desc 2	-ns 8;

data 1	-do -5	"abcd1"  "235";

data 2	-do -2	"ab"  "cd1234";

page	-all;

/*		cmpc4
*
*	Same as cmpc2 except first string is <  than second string.
*/

inst	cmpc	-nt  "S1 < S2 - X pg bound"	-io 1
	-mf1	ar reg idb
	-mf2	ar reg idb;

desc 1	-ns 8;

desc 2	-ns 8;

data 1	-do -4	"abcd"  "1234";

data 2	-do -2	"ab"  "cd1235";

page	-all;

/*		cmpc5
*
*	Same as cmpc2 except we will use  cn  fields.
*/

inst	cmpc	-nt  "Test use of CN fields"	-io 2
	-ir	zr cr
	-mf1	ar reg idb
	-mf2	ar reg idb;

desc 1	-ns 8	-cn 1;

desc 2	-cn 2	-ns 8;

data 1	-do -4	" abc"  "d1234";

data 2	-do -2	"**"  "abcd1234";

page	-all;

/*		cmpc6
*
*	We will test the use of the  fill character.  In this test we will fill
*	string 1.
*/

inst	cmpc	-nt "Fill in S1"	-io 1
	-ir	cr  zr
	-fc*
	-mf1	idr  ar
	-mf2	ida  ar;

desc 1	-ns  6;

desc 2	-ns  10;

data 1	-do -3  "123" "456";

data 2	-do  -6  "123456" "****";


page	-all;

/*		cmpc7
*
*	Same as  cmpc6  except the fill characters will be split across
*	a page boundary.
*/

inst	cmpc	-nt "Fill X pg bound"	-io 1
	-ir	cr  zr
	-fc*
	-mf1	idr  ar
	-mf2	ida  ar;

desc 1	-ns  6;

desc 2	-ns  10;

data 1 	-do -5	"12345"  "6";

data 2	-do -9	"123456***" "*";


page	-all;

/*		cmpc8
*
*	In this test we will test using the fill character of string 2.
*/

inst	cmpc	-nt  "Fill in S2"	-io 2
	-ir	zr cr
	-fc   	/* Fill character is a blank. */
	-mf1	idb rl 8 ar reg
	-mf2	idb rl 4 ar reg;

/*	No desc statements needed.  */

data 1	-do -4	"1234" "    ";

data 2	-do -3	"123" "4";


page	-all;

/*		cmpc9
*
*	The same as cmpc8 except  we will split the fill characters across a page boundary.
*/

inst	cmpc	-nt "Same as prev - fill X pg bound"	-io 2
	-ir	zr cr
	-fc   	/* Fill character is a blank. */
	-mf1	idb rl 8 ar reg
	-mf2	idb rl 4 ar reg;

/*	No desc statements needed.  */

data 1	-do  -5  	"1234 "  "   ";

data 2	-do -3	"123" "4";


page	-all;

/*		cmpc10
*
*	This test will compare two strings that cross two page boundaries.
*/

inst	cmpc	-nt "Both strings X pg bounds"	-io 3
	-ir	cr zr
	-mf1	idb reg ar  rl 4352
	-mf2	idb reg ar  rl 4352;

data 1	-do  -128	    (4352) "S";

data 2	-do  -128	    (4352) "S";


page	-all;

/*		cmpc11
*
*	This test will compare 3  (6 bit) characters.  We will have them
*	cross a page boundary and we will use the  cn  field of the
*	descriptors to start the string at a character other than character
*	zero of the effectively addressed word.
*/

inst	cmpc	-nt "6 bit characters"	-io 2
	-ir	cr zr
	-mf1	ar reg idb  rl 3
	-mf2	ar reg idb;

desc 1	-cn 2	-ta 6;

desc 2	-ns 3	-cn 1;		/* NOTE, ta  field taken from  desc 1 statement. */


data 1	-do -2	000020 /*Page Boundary*/ 2122;

data 2	-do -2	002021 /*Page Boundary*/ 22;


page	-all;

/*		cmpc12
*
*	This test is like  cmpc11 except that the character size will be 4.
*/

inst	cmpc	-nt "4 bit characters"
	-ir	cr zr
	-mf1	idb reg ar
	-mf2	idb reg ar;

desc 1	-ns 3	-cn 2	-ta 4;	/* This  desc  statement must be first. */

desc 2	-ns 3	-cn 1;		/* This  desc  statement can NOT have a  -ta option. */


data 1	-do -2	000232  260;	/* characters  "1001"b "1010"b "1011"b */

data 2	-do -1	011  253;		/* The same 3 characters. */


page	-all;
/*                     cmpc13

*         compare two strings of maximum length.
*         the data is six bit data and maximum
*         desc. mod. is taken
*
*/


inst       cmpc   -nt "d1,2 covers 3pp. 6bit zr cr"
          -ir          zr cr
          -mf1         idb ar reg rl 6528
          -mf2         idb ar reg rl 6528;

desc 1    -ta 6        ;


data 1    -do -128     (1088) 212121212121;

data 2    -do -128     (1088) 212121212121;

page      -all;


/*                  cmpc14

*         this is a test using 4 bit data with the
*         first string covering the maximum number of words.
*         the second string also is of maximum length
*         and the descriptors are all direct mod.
*
*/

inst      cmpc     -nt "d1,2 covers 3pp 4bit zr cr"
          -ir       cr zr
          -mf1      rl 8704
          -mf2      rl 8704;

desc 1    -ta 4;

data 1    -do -128  (1088) 232232232232;

data 2    -do -128  (1088) 232232232232;


page      -all;


/*                  cmpc15

*         the next four tests will again use the maximum
*         amount of data but will vary the desc. mod. taken.
*
*/

inst      cmpc    -io 2   -nt "d1,2 covers 3pp 6 bit zr cr"
          -mf1      ida reg rl 6528
          -mf2      idr ar rl 6528
          -ir       cr zr;

desc 1    -ta 6;

data 1    -do -128  (1088) 212223242526;

data 2    -do -128  (1088) 212223242526;

page      -all;


/*                  cmpc16

*         this is the same as test 15 but there will be not3
*         match of the data (str1 < str2 : zr=0 cr=0)
*
*/

inst      cmpc      -io 1     -nt "d1,2 covers 3 pp 6 bit"
          -mf1      ida reg rl 6528
          -mf2    idr ar rl 6528;

desc 1    -ta 6;

data 1    -do -128 (1088) 212221222122;

data 2    -do -128 (1088) 2122232422226;

page      -all;


/*                  cmpc17

*         this test is similar to test14 only the
*         maximum number of desc. mods. are taken.
*         the data is still four bit.
*
*/

inst      cmpc      -io 3    -nt "d1,2 covers 3pp 4bit zr cr"
-ir      zr cr
          -mf1      idb ar reg rl 8704
          -mf2      idb ar reg rl 8704;

desc 1    -ta 4;

data 1    -do -128  (1088)  232232232232;

data 2    -do -128  (1088) 232232232232;

page      -all;


/*                  cmpc18

*         this test will take a variety of desc. mod.
*         and will force st1 > st2 (zr =0 cr = 1).
*         the data is four bit.
*
*/

inst      cmpc -io 1       -nt "d1,2 covers 3pp 4 bit cr"
          -ir       cr
          -mf1     ida reg rl 8704
          -mf2      idr ar rl 8704;

desc 1    -ta 4;

data 1    -do -128  (1088) 232232232222;

data 2    -do -128  (1088) 227237237237;

page      -all;


/*                  cmpc19

*         the test exercises the fill char  option along with
*         the cn option.  the test also uses 6 bit data.
*
*/

inst       cmpc     -io 1        -nt "d1 split cn 6bit zr cr"
          -ir       zr cr
          -fc    /* fc = 000 */
          -mf1      reg ar rl 8
          -mf2      reg rl 5;

desc 1    -ta 6     -cn 2;

desc 2    -cn 1;

data 1    -do -2    000020  /* page bound */ 21222324000000;

data 2    002021222324;

page      -all;


/*                  cmpc20

*         this test uses 6 bit data and test a different
*         variety of desc. mods. that test 19.  the
*         data is the same as test 19 except str1 < str2).
*
*/

inst     cmpc      -io 2      -nt "d1 split fc 6bit"
          -mf1      idb ar
-mf2     ar reg
          -fc    /* fc = 000 */     /*  fc = 000 */;

desc 1    -ta 6     -ns 8     -cn 2;

desc 2    -ns 5     -cn 2;

data 1    -do -2    000020 /* paGE BOUND */ 212223220000;

data 2    002021222324;

page      -all;


/*                  cmpc21

*         the next wo tests use 4 bit data and test the use of the
*         fill character.  a variety of desc. mods. are taken.
*
**/


inst      cmpc      -io 2     -nt "fc 4bit zr cr"
          -fc    /* fc = 000 */
                 /*  fc = 000 */
          -mf1      ida ar reg rl 2
          -mf2      idr ar rl 4
          -ir       zr cr;

desc 1    -ta 4;

data 1    232;


data 2     232000;

page      -all;


/*                  cmcp22

*         this test results in str1 > str 2.
*
*/

inst      cmpc      -io 2     -nt " fc 4bit cr"
          -ir       cr
          -mf1      idb ar reg
          -mf2      rl 6
          -fc    /* fc = 000 */;
                       /* fc = 000  */

desc 1    -ta 4     -ns 4;


data 1    -do -2    237237  /* page bound */ ;

data 2    232232000;

page      -all;


/*		scd1
*
*	We will split both string 1 and  string 2 across page
*	boundaries.  We will use all mods and  use  a  cn
*	field in descriptors  1 & 2.
*/

inst	scd	-nt  "Strings X pg bound - all mods"	-io 2
	-mf1	idb ar reg  rl 8
	-mf2	idb ar reg
	-mf3	ar reg;


desc 1	-cn 1;
desc 2	-cn 3;

data 1	-do -5
	" "		/* Character skipped by  cn  field. */
	"123*"  "$678";

data 2	-do -4	"   " "*"  "$";

data 3	000 000 000 003;


page	-all;
/*                  scd2
*

*         simple test which takes no more than the minimum
*         number of page faults.  assures the instruction is
*         working correctly.
*
*/

inst      scd    -nt "simple test 9bit";

desc 1    -ns 8;     /* 9 bit char */

data 1    "abcd1234";

data 2    "cd";

data 3    000 000 000 002;

page      -all;


/*                  scd3

*         this test uses the same data as test 2
*         but splits the first string across a page
         boundary.  the maximum number of descriptor page faultd
*         for the first two descriptors are also taken.
*
*/

inst      scd    -nt "d1 split 9bit; FCOs PHAFPG179 & 181 required on L68 CPU"
          -mf1      idb ar reg rl 8
          -mf2      idb ar reg;


data 1    -do 2
          "ab" "cd1234";

data 2    "cd";

data 3    000 000 000 002;

page      -all;


/*                  scd4

*         this test mixes the page faults among descriptors
*         and splits data across a page boundary with a
*         match on the first try.
*
*/


inst      scd    -nt "d1 split match 1st try; FCOs PHAFPG179 & 181 required on L68 CPU"
          -mf1      idb ar
          -mf2      ar reg
          -mf3      ar;       /* note the data word indirection */

desc 1    -ns 8;

data 1    -do -1  "a" "bcd1234";

data 2    "ab";

data 3    000 000 000 000;


page      -all;


/*                  scd5

*         same as previous test but both strings
*         are split across page boundaries. data
*         word is also accessed directly.
*
*/


inst      scd       -io 2    -nt "d1,2 split 9bit"
          -mf1      idb ar reg
          -mf2      idb ar reg;

desc 1    -ns 8;

data 1    -do -4    "abcd" "1234";

data 2    -do -1    "d" "1";

data 3    000 000 000 003;


page      -all;


/*                  scd6

*         this test takes all the page faults
*         possible with the descriptors, and
*         tests the -cn and -rl option.
*
*/


inst      scd       -io 2   -nt "max page fault 9bit"
          -mf1      idb ar reg rl 8
          -mf2      idb ar reg
          -mf3       ar reg;
          /* that's all pssible indirections */

desc 2          -cn 2;


data 1     -do -4   "abcd" "1234";

data 2     -do -2   "  " "12";

data 3     000 000 000 004;

page          -all;


/*                  scd7

*         salient feature of this test is
*         that there is no match on the search.
*         both data strings cross page boundaries.
*
*/


inst      scd       -io 2   -nt "no match 9bit"
          -ir  tr
          /* mf1 is direct */
          -mf2      idb ar reg;


desc 1    -ns 8;


data 1    -do -4 "abcd" "1234";

data 2    -do -1   "5" "6";

data 3    000 000 000 007;

page      -all;


/*                  scd8

*         all possible indirection for descriptors
*         taken with the cn option for both tested.
*         strings both split across page.
*
*/

inst      scd       -io 3    -nt "d1,2 split 9bit"
          -mf1      idb ar reg rl 5
          -mf2      idb ar reg;

desc 1    -cn 3;

desc 2    -cn 1;

data 1    -do -3    "***" "abcde";

data 2    -do -3    "*bc" "*";

data 3    000 000 000 001;

page      -all;


/*                  scd9

*the next three tests all use the same basic


*         data but vary the type of indirection and thus
*        the type of page faults that will be taken.
*
*/

inst      scd       -io 1    -nt "desc mod d1,2 split 9bit"
          -mf1      ar
          -mf2      idb ar reg
          -mf3      ar reg;

desc 1    -ns 5     -cn 3;

desc 2     -cn 1;

data 1     -do -3"***" "abcde";

data 2     -do -3   "*bc" "*";

data 3     000 000 000 001;

page       -all;


/*                  scd10

*         swap desc1 and desc2 mod
*
*/

inst      scd       -io 1    -nt "d1,2 split 9bit"
          -mf1      idb ar reg rl 8
          -mf2      ar
          -mf3      ar reg;

desc 1    -cn 3;

desc 2     -cn 1;

data 1    -do -3    "***" "abcde";

data 2    -do -3    "*bc" "*";

data 3    000 000 000 001;

page      -all;


/*                  scd11

*         mf3 is direct :  other two indirect
*
*/

inst      scd       -io 1    -nt "mf1 direct others ind. 9b"
          -mf1      idb ar reg rl 8
          -mf2      idb ar reg;
          /* mf3 is direct */

desc 1    -cn 3;

desc 2    -cn 1;

data 1    -do -3    "***" "abcde";

data 2    -do -3    "*bc" "*";

data 3    000 000 000 001;


page      -all;


/*                  scd12

*         the data for the next two tests spans three pages.
*         this test uses all direct mod for descriptors.
*
*/

inst      scd      -io 1    -nt "d1 spans 3pp 9bit"

          -mf1         rl 4352;

data 1    -do -128   (2175) "ab" "bc";

data 2    "bc";

data 3    000 000 010376;

page      -all;


/*                   scd13

*         same data as previous test but using
*         maximum indirection on the desc.
*
*/


inst      scd       -io 2     -nt "d1 spans 3pp max desc mod 9b"
          -mf1      idb ar reg rl 4352
          -mf2      idb ar reg
          -mf3       reg ar;

          /* no desc statements are needed */

data 1    -do -128  (2175) "ab" "bc";

data 2    "bc";

data 3    000 000 010 376;

page      -all;


/*                  scd14

*         the next two tests move the two char data 2 string
*         across a page boundary using the large data field of
*         the previous two tests as data 1.
*
*/

inst     scd       -io 3    -nt "3 page d1, d2 split 9b"
          -mf1      idb ar reg rl 4352
          -mf2      idb ar reg
          -mf3       ar reg;

          /* desc statements not needed */


data 1    -do -128  (2175) "ab" "bc";

data 2    -do -1    "b" "c";

data 3    000 000 010 376;

page      -all;


/*                  scd15

*         data 2 fully contained on page 0
*
*/

inst      scd       -io 2     -nt "3page d1, d2 split 9b"
          -mf1      idb ar reg rl 4352
          -mf2      idb ar reg
          -mf3       ar reg;


data 1    -do -128(2175) "ab" "bc";

data 2    -do -2"bc";

data 3    000 000 010 376;

page      -all;


/*                  scd16

*         this starts the 6 bit char tests.

*         nothing fancy--indirect mod on desc 1 & 2
*
*/


inst      scd    -nt "mf1,2 mod 6b; FCOs PHAFPG179 & 181 required on L68 CPU"
          -mf1      idb ar reg rl 6
          -mf2      idb ar reg
          /* desc3 is direct */;

desc 1    -ta 6 /* six bit char */;

data 1    202122232425;

data 2    2425;

data 3    000 000 000 004;

page      -all;


/*                  scd17

*         same data but first string offseet by
*         3 char. full indirect mod on desc.
*
*/


inst       scd       -io 2    -nt "desc mod d1 split 6b; FCOs PHAFPG179 & 181 required on L68 CPU"
           -mf1      idb ar reg
           -mf2      idb ar reg
           -mf3       ar reg;

desc 1     -ns 6 -ta 6;


data 1     -do -2   212223 242526;

data 2     2425;

data 3     000 000 000 003;

page       -all;


/*                  scd18

*this test offsets the second data string.
*
*/

inst      scd       -io 1    -nt "desc mod d2 offset 6b; FCOs PHAFPG179 & 181 required on L68 CPU"

          -mf1      idb ar reg rl 6
          -mf2      ar reg
          -mf3      reg
          /* note the variety of indirection */;

desc 1     -ta 6;

data 1    212223242526;

data 2    -do -2    242500;

data 3    000 000 000 003;

page      -all;


/*                  scd19

*         this test specifically exercises the -cn option
*         along with multiple indirection.
*
*/

inst      scd       -io 3    -nt "cn on d2 6bit; FCOs PHAFPG179 & 181 required on L68 CPU"
          -mf1      idb ar reg rl 6
          -mf2      idb ar reg
          -mf3       ar reg;


desc 1    -ta 6     -cn 3;

desc 2     -cn 3;

data 1    -do -4    000000202122 232425000000;

data 2    -do -2    000000 212200;

data 3    000 000 000 001;

page      -all;


/*                  scd20

*         data 1 covers three pages.  match
*         is on the last pair of characters.
*
*/

inst      scd   -nt "d1 spans 3pp 6bit; FCOs PHAFPG179 & 181 required on L68 CPU"
          -mf1       idb ar reg rl 7680
          -mf2      idb ar reg
          -mf3       ar reg;

desc 1     -ta 6;


data 1    -do -128(1087) 202124252627 202122242223;

data 2    2223;

data 3    000000014576 000;

page      -all;


/*                  scd21

*the final series of tests are with 4 bit data
*         this is just a simple test of two char per string
*         crossing no page pound.
*
*/

inst      scd   -nt "d1,2 2 char 4bit; FCOs PHAFPG179 & 181 required on L68 CPU"
          -mf1      idb ar reg
          -mf2      idb ar reg
          /*   mf3 is direct */;

desc 1    -ta 4     -ns 2;

data 1    232 000 000 000 /* "1001" "1010" */;

data 2    232 000 000 000;

data 3    000 000 000 000;

page      -all;


/*                  scd22

*         split the second string across page bound.
*         test -cn option for data 2.
*
*/

inst      scd       -io 2     -nt "cn,offset for d2 4bit; FCOs PHAFPG179 & 181 required on L68 CPU"
          -mf1      idb ar reg rl 2
          -mf2      idb ar reg
          -mf3       ar reg;


desc 1    -ta 4;

desc 2    -cn 1;

data 1    232 000 000 000;


data 2    -do -1    011 240 /* "1001" "1010" */;

data 3    000 000 000 000;

page      -all;


/*                  scd23

*         this test splits both strings and tests
*         the cn option for both strings
*
*/

inst      scd       -io 2    -nt "d1,2 offset 4bit"
          -mf1      idb ar reg
          -mf2      idb ar reg
          -mf3       ar reg;

desc 1    -ta 4     -ns 2          -cn 2;

desc 2    -cn 1;

data 1    -do -2    000 232 000;

data 2    -do -1     011 24;

data 3     000 000 000 000;

page       -all;


/*                scd24

*         this test will force data to cover all
*         three pages with the first data string.
*

*/

inst      scd       -io 3    -nt "d1 covers 3pp 4bit"
          -mf1      ar rl 10240
          -mf2      reg
          -mf3      ar;

desc 1    -ta 4     ;

data 1    -do -128  (4350) 232 236;

data 2    236;

data 3    000 000 020 774;

page        -all;


/*		scdr1
*
*	Same as test for  scd.
*	We will split both string 1 and  string 2 across page
*	boundaries.  We will use all mods and  use  a  cn
*	field in descriptors  1 & 2.
*/

inst	scdr	-nt  "Same as scd test"	-io 3
	-mf1	idb ar reg  rl 8
	-mf2	idb ar reg
	-mf3	ar reg;


desc 1	-cn 1;
desc 2	-cn 3;

data 1	-do -5
	" "		/* Character skipped by  cn  field. */
	"123*"  "$678";

data 2	-do -4	"   " "*"  "$";

data 3	000 000 000 003;


page	-all;
/*                  scdr2
*

*         simple test which takes no more than the minimum
*         number of page faults.  assures the instruction is
*         working correctly.
*
*/

inst      scdr    -nt "simple test 9bit";

desc 1    -ns 8;     /* 9 bit char */

data 1    "abcd1234";

data 2    "cd";

data 3    000 000 000 004;

page      -all;


/*                  scdr3

*         this test mixes the page faults among descriptors
*         and splits data across a page boundary with a
*         match on the first try.
*
*/


inst      scdr    -nt "d1 split match first time 9b"
          -mf1      idb ar
          -mf2      ar reg
          -mf3      ar;       /* note the data word indirection */

desc 1    -ns 8;

data 1    -do -1  "a" "bcd1234";

data 2    "ab";

data 3    000 000 000 006;


page      -all;


/*                  scdr4

*         same as previous test but both strings
*         are split across page boundaries. data
*         word is also accessed directly.
*
*/


inst      scdr       -io 2   -nt "d1,2 split 9bit"
          -mf1      idb ar reg
          -mf2      idb ar reg;

desc 1    -ns 8;

data 1    -do -4    "abcd" "1234";

data 2    -do -1    "d" "1";

data 3    000 000 000 003;


page      -all;


/*                  scdr5

*         this test takes all the page faults
*         possible with the descriptors, and
*         tests the -cn and -rl option.
*
*/


inst      scdr       -io 2    -nt "max page fault 9bit"
          -mf1      idb ar reg rl 8
          -mf2      idb ar reg
          -mf3       ar reg;
          /* that's all pssible indirections */

desc 2          -cn 2;


data 1     -do -4   "abcd" "1234";

data 2     -do -2   "  " "12";

data 3     000 000 000 002;

page          -all;


/*                  scdr6

*         salient feature of this test is
*         that there is no match on the search.
*         both data strings cross page boundaries.
*
*/


inst      scdr       -io 2    -nt "no match 9bit"
          -ir  tr
          /* mf1 is direct */
          -mf2      idb ar reg;


desc 1    -ns 8;


data 1    -do -4 "abcd" "1234";

data 2    -do -1   "5" "6";

data 3    000 000 000 007;

page      -all;


/*                  scdr7

*         all possible indirection for descriptors
*         taken with the cn option for both tested.
*         strings both split across page.
*
*/

inst      scdr       -io 3    -nt "d1,2 split 9bit"
          -mf1      idb ar reg rl 5
          -mf2      idb ar reg;

desc 1    -cn 3;

desc 2    -cn 1;

data 1    -do -3    "***" "abcde";

data 2    -do -3    "*bc" "*";

data 3    000 000 000 002;

page      -all;


/*                  scdr8

*the next three tests all use the same basic


*         data but vary the type of indirection and thus
*        the type of page faults that will be taken.
*
*/

inst      scdr       -io 1     -nt "desc mod d1,2 split 9b"
          -mf1      ar
          -mf2      idb ar reg
          -mf3      ar reg;

desc 1    -ns 5     -cn 3;

desc 2     -cn 1;

data 1     -do -3"***" "abcde";

data 2     -do -3   "*bc" "*";

data 3     000 000 000 002;

page       -all;


/*                  scdr9

*         swap desc1 and desc2 mod
*
*/

inst      scdr       -io 1     -nt "desc mod d1,2 split 9b"
          -mf1      idb ar reg rl 8
          -mf2      ar
          -mf3      ar reg;

desc 1    -cn 3;

desc 2     -cn 1;

data 1    -do -3    "***" "abcde";

data 2    -do -3    "*bc" "*";

data 3    000 000 000 005;

page      -all;


/*                  scdr10

*         mf3 is direct :  other two indirect
*
*/

inst      scdr       -io 1    -nt "mf1 direct others ind 9bit"
          -mf1      idb ar reg rl 8
          -mf2      idb ar reg;
          /* mf3 is direct */

desc 1    -cn 3;

desc 2    -cn 1;

data 1    -do -3    "***" "abcde";

data 2    -do -3    "*bc" "*";

data 3    000 000 000 005;


page      -all;


/*                  scdr11

*         the data for the next two tests spans three pages.
*         this test uses all direct mod for descriptors.
*
*/

inst      scdr      -io 1   -nt "d1 spans 3 pp 9bit"

          -mf1         rl 4352;

data 1    -do -128   "bc"   (2175) "ab" ;

data 2    "bc";

data 3    000 000 010376;

page      -all;


/*                   scdr12

*         same data as previous test but using
*         maximum indirection on the desc.
*
*/


inst      scdr       -io 2    -nt "d1 spans 3pp max desc mod 9b"
          -mf1      idb ar reg rl 4352
          -mf2      idb ar reg
          -mf3       reg ar;

          /* no desc statements are needed */

data 1    -do -128  "bc"   (2175) "ab" ;

data 2    "bc";

data 3    000 000 010 376;

page      -all;


/*                  scdr13

*         the next two tests move the two char data 2 string
*         across a page boundary using the large data field of
*         the previous two tests as data 1.
*
*/

inst     scdr       -io 3    -nt "3 page d1, d2 split 9b"
          -mf1      idb ar reg rl 4352
          -mf2      idb ar reg
          -mf3       ar reg;

          /* desc statements not needed */


data 1    -do -128  (2175) "ab" "bc";

data 2    -do -1    "b" "c";

data 3    000 000 000 000;

page      -all;


/*                  scdr14

*         data 2 fully contained on page 0
*
*/

inst      scdr       -io 2     -nt "3 page d1, d2 split 9b"
          -mf1      idb ar reg rl 4352
          -mf2      idb ar reg
          -mf3       ar reg;


data 1    -do -128  "bc"  (2175) "ab" ;

data 2    -do -2"bc";

data 3    000 000 010376;

page      -all;


/*                  scdr15

*         this starts the 6 bit char tests.

*         nothing fancy--indirect mod on desc 1 & 2
*
*/


inst      scdr   -nt "desc 1,2 mod 6bit"
          -mf1      idb ar reg rl 6
          -mf2      idb ar reg
          /* desc3 is direct */;

desc 1    -ta 6 /* six bit char */;

data 1    202122232425;

data 2    2425;

data 3    000 000 000 000;

page      -all;


/*                  scdr16

*         same data but first string offseet by
*         3 char. full indirect mod on desc.
*
*/


inst       scdr       -io 2    -nt "mod d1 split 6b; FCOs PHAFPG179 & 181 required on L68 CPU"
           -mf1      idb ar reg
           -mf2      idb ar reg
           -mf3       ar reg;

desc 1     -ns 6 -ta 6;


data 1     -do -2   212223 242526;

data 2     2425;

data 3     000 000 000 001;

page       -all;


/*                  scdr17

*this test offsets the second data string.
*
*/

inst      scdr       -io 1    -nt "full desc mod d2 offset 6b"

          -mf1      idb ar reg rl 6
          -mf2      ar reg
          -mf3      reg
          /* note the variety of indirection */;

desc 1     -ta 6;

data 1    212223242526;

data 2    -do -2    242500;

data 3    000 000 000 001;

page      -all;


/*                  scdr18

*         this test specifically exercises the -cn option
*         along with multiple indirection.
*
*/

inst      scdr       -io 3   -nt "cn on d2 6bit; FCOs PHAFPG179 & 181 required on L68 CPU"
          -mf1      idb ar reg rl 6
          -mf2      idb ar reg
          -mf3       ar reg;


desc 1    -ta 6     -cn 3;

desc 2     -cn 3;

data 1    -do -4    000000202122 232425000000;

data 2    -do -2    000000 212200;

data 3    000 000 000 003;

page      -all;


/*                  scdr19

*         data 1 covers three pages.  match
*         is on the last pair of characters.
*
*/

inst      scdr   -nt "no off d1 spans 3pp 6b"
          -mf1       idb ar reg rl 7680
          -mf2      idb ar reg
          -mf3       ar reg;

desc 1     -ta 6;


data 1    -do -128(1087) 202124252627 202122242223;

data 2    2223;

data 3    000000002200 000;

page      -all;


/*                  scdr20

*the final series of tests are with 4 bit data
*         this is just a simple test of two char per string
*         crossing no page pound.
*
*/

inst      scdr   -nt "d1.2 2 char 4bit"
          -mf1      idb ar reg
          -mf2      idb ar reg
          /*   mf3 is direct */;

desc 1    -ta 4     -ns 2;

data 1    232 000 000 000 /* "1001" "1010" */;

data 2    232 000 000 000;

data 3    000 000 000 000;

page      -all;


/*                  scdr21

*         split the second string across page bound.
*         test -cn option for data 2.
*
*/

inst      scdr       -io 2   -nt "cn,offset for d2 4bit"
          -mf1      idb ar reg rl 2
          -mf2      idb ar reg
          -mf3       ar reg;


desc 1    -ta 4;

desc 2    -cn 1;

data 1    232 000 000 000;


data 2    -do -1    011 240 /* "1001" "1010" */;

data 3    000 000 000 000;

page      -all;


/*                  scdr22

*         this test splits both strings and tests
*         the cn option for both strings
*
*/

inst      scdr       -io 2    -nt "d1,2 offset 4bit; FCOs PHAFPG179 & 181 required on L68 CPU"
          -mf1      idb ar reg
          -mf2      idb ar reg
          -mf3       ar reg;

desc 1    -ta 4     -ns 2          -cn 2;

desc 2    -cn 1;

data 1    -do -2    000 232 000;

data 2    -do -1     011 24;

data 3     000 000 000 000;

page       -all;


/*                scdr23

*         this test will force data to cover all
*         three pages with the first data string.
*

*/

inst      scdr       -io 3   -nt "d1 covers 3 pp 4bit"
          -mf1      ar rl 10240
          -mf2      reg
          -mf3      ar;

desc 1    -ta 4     ;

data 1    -do -128  (4350) 232 236;

data 2    236;

data 3    000 000 003 002;

page        -all;


/*		mlr1
*
*	Just a simple test.  Move one 9 bit character to another.  */

inst	mlr	-nt  "Move 1 (9) bit char";

desc 1	-ns  1;		data 1	"a";

desc 2	-ns  1;		data 2	"a";

page	-all;
/*		mlr2
*
*	Move two characters that cross a page boundary.  Note, we need  AR
*	modification in order to set a data offset that is not a multiple
*	of the word size.  By doing this we will move the data fields to
*	segments  etd1 and etd2.
*/

inst	mlr	-nt  "2 chars X page bound"
	-mf1  ar
	-mf2  ar;

desc 1	-ns 2;		desc 2	-ns 2;

data 1	"ab"	-do -1;

data 2	"ab"	-do -1;

page	-all;
/*		mlr3
*
*	This test will move 20 characters.  The characters will start in the middle
*	of a word.  The last two characters moved will cross a page boundary.
*	The instruction word will be moved so that its descriptors cross a
*	page boundary.
*/

inst	mlr	-nt  "20 char X page bound (-io 1)"	-io 1;

desc 1	-cn 2	/* Effective address will point to a word boundary.
		*  We will start the string at character 2.  Note, when
		*  we set up the data we have to enter the two characters
		*  that we are not using.  */
	-ns 20;

desc 2	-cn 2	-ns 20;

data 1	-do  -20 	"  "  (5) "abcd" ;

data 2	-do  -20  000000  (5) "abcd" ;	/* Skipped data in a result field
					*  must be zeros since this is what
					*  et  initializes the test area
					*  to be.  */

page	-all;
/*		mlr4
*
*	This test is the same as  mlr3  except that the descriptors will be
*	referenced via indirect words.  These indirect words will use no
*	modification so the descriptors and the data will still be in
*	segment  etx.  Also we will move the instruction word back
*	so that the second descriptor is on the 2nd page.
*/

inst	mlr	-nt  "Same as prev - ind desc"	-io 2
	-mf1  id		-mf2  id;

desc 1	-ns 20	-cn 2;		/* Note the order of the terms. */

desc 2	-cn 2	-ns 20;

data 1	-do  -20 	"  "  (5) "abcd" ;

data 2	-do  -20  000 000  (5) "abcd" ;

page	-all;
/*		mlr5
*
/*	This test is the same as  mlr4  except that the indirect words will
*	use  index register modification.
*/

inst	mlr	-nt  "Same as prev - use indexes"	-io 2
	-mf2  idr		-mf1  idr;	/* Note order of mf terms. */

desc 1	-cn 2	-ns 20;

desc 2	-cn 2	-ns 20;

data 1	-do  -20 	"  "  (5) "abcd" ;

data 2	-do  -20  000 000  (5) "abcd" ;

page	-all;
/*		mlr6
*
/*	This test is the same as  mlr4  except that the indirect words will
*	use  AR modification.  This will force  ET to place the descriptors and
*	the data fields in segments  eti1 and eti2.
*/

inst	mlr	-nt  "Ind with AR mod"	-io 2
	-mf2  ida		-mf1  ida;

desc 1	-cn 2	-ns 20;

desc 2	-cn 2	-ns 20;

data 1	-do  -20 	"  "  (5) "abcd" ;

data 2	-do  -20  000 000  (5) "abcd" ;

page	-all;
/*		mlr7
*
*	This test is the same as the test  mlr3  except that the descriptors
*	will use  REG  and  RL  modification.
*/

inst	mlr	-nt  "Ind with REG 7. RL mod"		-io 1
	-mf2  reg  rl  20
	-mf1  rl  20   reg;

desc 1	-cn 2;

desc 2	-cn 2;

data 1	-do  -20 	"  "  (5) "abcd" ;

data 2	-do  -20  000 000  (5) "abcd" ;

page	-all;

/*		mlr8
*
*	This test is the same as the test  mlr3  except that the descriptors
*	will use  AR, REG  and  RL  modification.
*/

inst	mlr	-nt  "Desc use AR,REG,& RL mod"	-io 1
	-mf1  reg  ar  rl  20
	-mf2  rl  20   ar  reg;

desc 1	-cn 2;

desc 2	-cn 2;

data 1	-do  -20 	"  "  (5) "abcd" ;

data 2	-do  -20  000 000  (5) "abcd" ;

page	-all;

/*		mlr9
*
*	This test is the same as the test  mlr3  except that the descriptors
*	will use  AR, REG  and  RL  modification  AND  we will use indirect descriptors.
*	We will not have any modification in the indirect words so the descriptors
*	will still be in segment  etx.
*/

inst	mlr	-nt  "Same as prev - use ind"		-io 1
	-mf1	rl  20
		ar	/* This puts the data in  etd1. */
		reg	/* Use index register 1.. */
		id 	/* This adds indirect descriptors.  */

	-mf2	id
		rl  20
		reg
		ar;

desc 1	-cn 2;

desc 2	-cn 2;

data 1	-do  -20 	"  "  (5) "abcd" ;

data 2	-do  -20  000 000  (5) "abcd" ;

page	-all;

/*		mlr10
*
*	This test is the same as the test  mlr3  except that the descriptors
*	will use  AR, REG  and  RL  modification  AND  we will use indirect descriptors.
*	The indirect words will use both reg and ar modification.
*/

inst	mlr	-nt  "Desc: AR,RL,REG  Ind: AR,REG"	-io 1
	-mf1	rl  20
		ar	/* This puts the data in  etd1. */
		reg	/* Use index register 1.. */
		idb 	/* This adds indirect descriptors.  Descriptors will go in
			*  segments  eti1 and eti2.  */

	-mf2	idb
		rl  20
		reg
		ar;

desc 1	-cn 2;

desc 2	-cn 2;

data 1	-do  -20 	"  "  (5) "abcd" ;

data 2	-do  -20  000 000  (5) "abcd" ;

page 	-all;

/*		mlr11
*
*	This test will move  6  6 bit characters.  Both strings will have  3 characters
*	on each side of the page boundary.  The descriptor 2 data will be offset 4
*	9 bit characters but will specify a  "cn" field of 3 so the effective starting
*	address will be the same as descriptor 1.   All possible modification will be
*	used.  Descriptor 1 will also use  RL  modification.
*/

inst	mlr	-nt  "6 bit chars X pg bound"

	-mf1	rl  6	idb	ar  reg

	-mf2	reg   ar   idb;


desc 1	-ta  6;

desc 2	-cn 3	-ta 6	-ns  6;


data 1	-do  -2  	212223242526;

data 2	-do  -4	
	(2) 000		/* We must fill in the unused 3 six bit characters. */
	212223242526;	/* The actual data result field. */


page	-all;

/*		mlr12
*
*	This test will move 3  4 bit characters.  Below is a description of what is
*	going on.  EA is the effective address of the descriptor.
*
*	string 1	                  EA  1  |  2  3
*		---------------------------------------------------
*	char addr  0  1  2  3  4  5  6  7  |  0  1  2  3  4  5  6  7
*		---------------------------------------------------
*	string 2  EA                 1  2  |  3
*
*	All possible modification will be used.  Descriptor 2 will use  RL  mod.
*/

inst	mlr	-nt  "4 bit chars"

	-mf1	idb	ar  reg

	-mf2	reg   ar   idb	rl  3;


desc 1	-ta  4	-cn 1	-ns  3;

desc 2	-cn 6	-ta 4;


data 1	011  253	-do -1;

data 2	-do  -4	000000000 232  26;


page	-all;

/*		mlr13
*
*	This test will move  6  9 bit characters into  6  6 bit characters.
*	Both strings will be split in the middle across a page boundary.
*/

inst	mlr	-nt "9 bit chars into 6 bit chars"
	-mf1  ar reg idr
	-mf2  reg ar idb;

data 1	-do -3  " te"  "st ";

data 2	-do -2	406445 636440;


desc 1	-ns 6;

desc 2	-ns 6	-ta 6;


page 	-all;

/*		mlr14
*
*	This test will test the fill character function.
*	Also the  truncation bit will be turned ON but we will specify that
*	we do not expect a truncation fault.
*/

inst	mlr	-nt  "Use fill char"	-io 3

	-fc*	-tbn

	-mf1  idr  ar   rl 4
	-mf2  ida  reg  rl 8;

/*	No  desc  statements are needed because all the defaults are correct.  */

data 1	"abcd"	-do -2;	/* Split the 4 characters across a page boundary. */

data 2	"abcd" "****"
	-do -4;		/* The fill characters go on a different page.  */


page	-all;

/*		mlr15
*
*	This is the same test as  mlr14  except the  fill characters will start on
*	one page and end on the next page.
*	we do not expect a truncation fault.
*/

inst	mlr	-nt  "Fill X pg bound"	-io 1

	-fc*	-tbn

	-mf1  idr  ar   rl 4
	-mf2  ida  reg ar   rl 8;

/*	No  desc  statements are needed because all the defaults are correct.  */

data 1	"abcd"	-do -2;	/* Split the 4 characters across a page boundary. */

data 2	"abcd**"  "**"
	-do -6;		/* The fill characters are split across a  page boundary.  */


page	-all;

/*		mlr16
*
*	This test is designed to test truncation.  We will expect the truncation
*	indicator to be  ON.  The truncation bit will be left OFF and so we will not
*	expect a truncation fault.
*/


inst	mlr	-nt  "Trunc Ind ON"
	-mf2 ar	-io 2	-ir tn;

desc 1	-ns 8;		desc 2	-ns 4;


data 1	-do  -4	"abcd"  "1234";

data 2	-do  -2	"abcd";


page	-all;

/*		mlr17
*
*	This test is designed to test truncation.  We will expect the truncation
*	indicator to be  ON.  This test is the same as  mlr16 except that the
*	truncation bit in the instruction word will be set  ON.  This should
*	cause a truncation fault.  We should be ready for it.
*/


inst	mlr	-nt  "Take trunc fault"	-tby
	-mf2 ar	-io 2	-ir tn;

desc 1	-ns 8;		desc 2	-ns 4;


data 1	-do  -4	"abcd"  "1234";

data 2	-do  -2	"abcd";


page	-all;

/*		mlr18
*
*	This test will try to move  over a page of data.  We will move  1088 words
*	containing the characters  "cisl".
*/


inst	mlr	-nt  "Move over 1 page"	-io 1
	-mf1  rl  4352	idb ar reg
	-mf2  rl  4352	idbar reg;

data 1 	-do  -128	  (1088) "cisl";

data 2	-do  -128	  (1088) "cisl";

page	-all;


/*		mrl1
*
*	Just a simple test.  Move one 9 bit character to another.  */

inst	mrl	-nt  "Move 1 (9) bit char";

desc 1	-ns  1;		data 1	"a";

desc 2	-ns  1;		data 2	"a";

page	-all;

/*		mrl2
*
*	Move two characters that cross a page boundary.  Note, we need  AR
*	modification in order to set a data offset that is not a multiple
*	of the word size.  By doing this we will move the data fields to
*	segments  etd1 and etd2.
*/

inst	mrl	-nt  "2 chars X page bound"
	-mf1  ar
	-mf2  ar;

desc 1	-ns 2;		desc 2	-ns 2;

data 1	"ab"	-do -1;

data 2	"ab"	-do -1;

page	-all;

/*		mrl3
*
*	This test will move 20 characters.  The characters will start in the middle
*	of a word.  The last two characters moved will cross a page boundary.
*	The instruction word will be moved so that its descriptors cross a
*	page boundary.
*/

inst	mrl	-nt  "20 char X page bound (-io 1)"	-io 1;

desc 1	-cn 2	/* Effective address will point to a word boundary.
		*  We will start the string at character 2.  Note, when
		*  we set up the data we have to enter the two characters
		*  that we are not using.  */
	-ns 20;

desc 2	-cn 2	-ns 20;

data 1	-do  -20 	"  "  (5) "abcd" ;

data 2	-do  -20  000000  (5) "abcd" ;	/* Skipped data in a result field
					*  must be zeros since this is what
					*  et  initializes the test area
					*  to be.  */

page	-all;

/*		mrl4
*
*	This test is the same as  mrl3  except that the descriptors will be
*	referenced via indirect words.  These indirect words will use no
*	modification so the descriptors and the data will still be in
*	segment  etx.  Also we will move the instruction word back
*	so that the second descriptor is on the 2nd page.
*/

inst	mrl	-nt  "Same as prev - ind desc"	-io 2
	-mf1  id		-mf2  id;

desc 1	-ns 20	-cn 2;		/* Note the order of the terms. */

desc 2	-cn 2	-ns 20;

data 1	-do  -20 	"  "  (5) "abcd" ;

data 2	-do  -20  000 000  (5) "abcd" ;

page	-all;

/*		mrl5
*
/*	This test is the same as  mrl4  except that the indirect words will
*	use  index register modification.
*/

inst	mrl	-nt  "Same as prev - use indexes"	-io 2
	-mf2  idr		-mf1  idr;	/* Note order of mf terms. */

desc 1	-cn 2	-ns 20;

desc 2	-cn 2	-ns 20;

data 1	-do  -20 	"  "  (5) "abcd" ;

data 2	-do  -20  000 000  (5) "abcd" ;

page	-all;

/*		mrl6
*
/*	This test is the same as  mrl4  except that the indirect words will
*	use  AR modification.  This will force  ET to place the descriptors and
*	the data fields in segments  eti1 and eti2.
*/

inst	mrl	-nt  "Ind with AR mod"	-io 2
	-mf2  ida		-mf1  ida;

desc 1	-cn 2	-ns 20;

desc 2	-cn 2	-ns 20;

data 1	-do  -20 	"  "  (5) "abcd" ;

data 2	-do  -20  000 000  (5) "abcd" ;

page	-all;

/*		mrl7
*
*	This test is the same as the test  mrl3  except that the descriptors
*	will use  REG  and  RL  modification.
*/

inst	mrl	-nt  "Ind with REG 7. RL mod"		-io 1
	-mf2  reg  rl  20
	-mf1  rl  20   reg;

desc 1	-cn 2;

desc 2	-cn 2;

data 1	-do  -20 	"  "  (5) "abcd" ;

data 2	-do  -20  000 000  (5) "abcd" ;

page	-all;

/*		mrl8
*
*	This test is the same as the test  mrl3  except that the descriptors
*	will use  AR, REG  and  RL  modification.
*/

inst	mrl	-nt  "Desc use AR,REG,& RL mod"	-io 1
	-mf1  reg  ar  rl  20
	-mf2  rl  20   ar  reg;

desc 1	-cn 2;

desc 2	-cn 2;

data 1	-do  -20 	"  "  (5) "abcd" ;

data 2	-do  -20  000 000  (5) "abcd" ;

page	-all;

/*		mrl9
*
*	This test is the same as the test  mrl3  except that the descriptors
*	will use  AR, REG  and  RL  modification  AND  we will use indirect descriptors.
*	We will not have any modification in the indirect words so the descriptors
*	will still be in segment  etx.
*/

inst	mrl	-nt  "Same as prev - use ind"		-io 1
	-mf1	rl  20
		ar	/* This puts the data in  etd1. */
		reg	/* Use index register 1.. */
		id 	/* This adds indirect descriptors.  */

	-mf2	id
		rl  20
		reg
		ar;

desc 1	-cn 2;

desc 2	-cn 2;

data 1	-do  -20 	"  "  (5) "abcd" ;

data 2	-do  -20  000 000  (5) "abcd" ;

page	-all;

/*		mrl10
*
*	This test is the same as the test  mrl3  except that the descriptors
*	will use  AR, REG  and  RL  modification  AND  we will use indirect descriptors.
*	The indirect words will use both reg and ar modification.
*/

inst	mrl	-nt  "Desc: AR,RL,REG  Ind: AR,REG"	-io 1
	-mf1	rl  20
		ar	/* This puts the data in  etd1. */
		reg	/* Use index register 1.. */
		idb 	/* This adds indirect descriptors.  Descriptors will go in
			*  segments  eti1 and eti2.  */

	-mf2	idb
		rl  20
		reg
		ar;

desc 1	-cn 2;

desc 2	-cn 2;

data 1	-do  -20 	"  "  (5) "abcd" ;

data 2	-do  -20  000 000  (5) "abcd" ;

page 	-all;

/*		mrl11
*
*	This test will move  6  6 bit characters.  Both strings will have  3 characters
*	on each side of the page boundary.  The descriptor 2 data will be offset 4
*	9 bit characters but will specify a  "cn" field of 3 so the effective starting
*	address will be the same as descriptor 1.   All possible modification will be
*	used.  Descriptor 1 will also use  RL  modification.
*/

inst	mrl	-nt  "6 bit chars X pg bound"

	-mf1	rl  6	idb	ar  reg

	-mf2	reg   ar   idb;


desc 1	-ta  6;

desc 2	-cn 3	-ta 6	-ns  6;


data 1	-do  -2  	212223242526;

data 2	-do  -4	
	(2) 000		/* We must fill in the unused 3 six bit characters. */
	212223242526;	/* The actual data result field. */


page	-all;

/*		mrl12
*
*	This test will move 3  4 bit characters.  Below is a description of what is
*	going on.  EA is the effective address of the descriptor.
*
*	string 1	                  EA  1  |  2  3
*		---------------------------------------------------
*	char addr  0  1  2  3  4  5  6  7  |  0  1  2  3  4  5  6  7
*		---------------------------------------------------
*	string 2  EA                 1  2  |  3
*
*	All possible modification will be used.  Descriptor 2 will use  RL  mod.
*/

inst	mrl	-nt  "4 bit chars"

	-mf1	idb	ar  reg

	-mf2	reg   ar   idb	rl  3;


desc 1	-ta  4	-cn 1	-ns  3;

desc 2	-cn 6	-ta 4;


data 1	011  253	-do -1;

data 2	-do  -4	000000000 232  26;


page	-all;

/*		mrl13
*
*	This test will move  6  9 bit characters into  6  6 bit characters.
*	Both strings will be split in the middle across a page boundary.
*/

inst	mrl	-nt "9 bit chars into 6 bit chars"
	-mf1  ar reg idr
	-mf2  reg ar idb;

data 1	-do -3  " te"  "st ";

data 2	-do -2	406445 636440;


desc 1	-ns 6;

desc 2	-ns 6	-ta 6;


page 	-all;

/*		mrl14
*
*	This test will test the fill character function.
*	Also the  truncation bit will be turned ON but we will specify that
*	we do not expect a truncation fault.
*/

inst	mrl	-nt  "Use fill char"	-io 3

	-fc*	-tbn

	-mf1  idr  ar   rl 4
	-mf2  ida  reg  rl 8;

/*	No  desc  statements are needed because all the defaults are correct.  */

data 1	"abcd"	-do -2;	/* Split the 4 characters across a page boundary. */

data 2    "****" "abcd"
	-do -4;		/* The fill characters go on a different page.  */


page	-all;

/*		mrl15
*
*	This is the same test as  mrl14  except the  fill characters will start on
*	one page and end on the next page.
*	we do not expect a truncation fault.
*/

inst	mrl	-nt  "Fill X pg bound"	-io 1

	-fc*	-tbn

	-mf1  idr  ar   rl 4
	-mf2  ida  reg ar   rl 8;

/*	No  desc  statements are needed because all the defaults are correct.  */

data 1	"abcd"	-do -2;	/* Split the 4 characters across a page boundary. */

data 2    "**" "**abcd"
	-do -2;		/* The fill characters are split across a  page boundary.  */


page	-all;

/*		mrl16
*
*	This test is designed to test truncation.  We will expect the truncation
*	indicator to be  ON.  The truncation bit will be left OFF and so we will not
*	expect a truncation fault.
*/


inst	mrl	-nt  "Trunc Ind ON"
	-mf2 ar	-io 2	-ir tn;

desc 1	-ns 8;		desc 2	-ns 4;


data 1	-do  -4	"abcd"  "1234";

data 2	-do  -2	"1234";


page	-all;

/*		mrl17
*
*	This test is designed to test truncation.  We will expect the truncation
*	indicator to be  ON.  This test is the same as  mrl16 except that the
*	truncation bit in the instruction word will be set  ON.  This should
*	cause a truncation fault.  We should be ready for it.
*/


inst	mrl	-nt  "Take trunc fault"	-tby
	-mf2 ar	-io 2	-ir tn;

desc 1	-ns 8;		desc 2	-ns 4;


data 1	-do  -4	"abcd"  "1234";

data 2	-do  -2	"1234";


page	-all;

/*		mrl18
*
*	This test will try to move  over a page of data.  We will move  1088 words
*	containing the characters  "cisl".
*/


inst	mrl	-nt  "Move over 1 page"	-io 1
	-mf1  rl  4352	idb ar reg
	-mf2  rl  4352	idbar reg;

data 1 	-do  -128	  (1088) "cisl";

data 2	-do  -128	  (1088) "cisl";

page	-all;


/*		mvt 1
*
*	Just a simple test.    Table is "0123".  result = "01233210".
*/

inst	mvt	-nt  "Simple test with 9 bit chars";

desc 1	-ns	8;
desc 2	-ns	8;

data 1	000 001 002 003 003 002 001 000;	/* 9 bit characters used as indexes. */

data 2	"01233210";

data 3	"0123";


page	-all;
/*		mvt 2
*
*	Same test as  mvt 1 except that the data fields have been move across
*	a page boundary.
*/

inst	mvt	-nt  "Same as prev - fields X pg bound"	-io 1;

desc 1	-ns	8;
desc 2	-ns	8;

data 1	-do -4	000 001 002 003   003 002 001 000;

data 2	-do  -4	"0123"  "3210";

data 3	"0123";


page	-all;
/*		mvt 3
*
*	Same test as  mvt 2 except we will add a lot of modification  and adjust
*	that data fields so that they do not begin on WORD boundaries.
*/

inst	mvt	-nt  "Same as prev - with mod"	-io 3
	-mf1	rl  8  ar reg idb
	-mf2	rl  8  ar reg idb
	-mf3	ar reg;

/*	No desc statements needed since  rl  mod specified and other defaults OK. */

data 1	-do -2	000 001   002 003 003 002 001 000;

data 2	-do -2	"01"  "233210";

data 3		"0123";


page	-all;
/*		mvt 4
*
*	This test will use a fill character.   The table will have  110  characters
*	but we should only reference  5  of them.
*/

inst	mvt	-nt  "Use fill characters"
	-io 1
	-fce	/* Fill character is "e"  =  145 octal.  */
	-mf1	ar
	-mf2	ar
	-mf3	ar;

desc 1	-ns  3;

desc 2	-ns 8;		/* L2 > L1  =>  use of fill character. */

/*	There are no legal fields we can specify with a  desc 3  statement
*	for this instruction.
*/


data 1	-do -1	"c"  "ba";

data 2	-do  -5	"32155"  "555";

data 3	-do -100
	(97) "*"		/* These characters in table never used. */
	"123"  "45"
	(9)  "*";


page	-all;

/*  mvt 5
*
*  Test page faults when first character of desc 1 and 2 are
*  at  the  end  of  a  page.
*/

inst mvt -nt"check special page fault 1"
         -io 1;

desc 1  -ns 9 -cn 3 ;
desc 2  -ns 9 -cn 3 ;

data 1 -do -4  "   " 000 001 002 003 002 000 004 005 003 ;
data 2 -do -4 000 000 000  "character" ;
data 3 "charted" ;

page   -all ;


/*   mvt 6
*
*  Test page faults when last character of desc 1 and 2 are on a new page.
*
*/

inst  mvt  -nt "check special page fault 2"
           -io 1 ;

desc 1  -ns 9 ;

desc 2  -ns 9 ;

data 1  -do -8  000 001 002 003 002 000 004 005 003 ;

data 2  -do -8  "character" ;

data 3  "charte" ;

page    -all ;


/*   mvt 7
*
*  Test direct data movement for data 1 and 2 .
*  Also test moving data across 3 pages.  To move more than
*  4096 characters of data register length modification must be used.
*/

inst  mvt  -nt  "dir desc. 3 page move; FCOs PHAFPG179 & 181 required on L68 CPU"
         -mf1 rl 4112
         -mf2 rl 4112 ;

desc 1  -cn 1 ;

data 1  -do -4  " " (257) 000001002003004005006007010011012013014015016017 ;

data 2  -do -4  (257) "abcdefghijklmnop" ;

data 3    "abcdefghijklmnop" ;

page    -all ;

/*   mvt 8
*
* Test address register usage for data 1 and 2.  Also test moving data across
* 3 pages.  All descriptors are direct.
* Also use register length modification.
*/

inst mvt -nt "tst ar1&ar2. 3 pg move;FCOs PHAFPG179 & 181 required on L68 CPU"
         -io 2
         -mf1 ar rl 4112
         -mf2 ar rl 4112 ;

desc 1  -cn 1 ;


data 1  -do -4  " " (257) 000001002003004005006007010011012013014015016017 ;

data 2  -do -4  (257) "abcdefghijklmnop" ;

data 3    "abcdefghijklmnop" ;

page    -all ;


/* mvt  9
* Test ar, reg, and register length modification for data 1 and 2.
* Also test data movement of three pages.
*/

inst mvt  -nt "tst ar,rg,rl. 3 pg mv; FCOs PHAFPG179 & 181 required on L68 CPU"
         -io 2
         -mf1 ar reg rl 4112
         -mf2 ar reg rl 4112 ;

desc 1  -cn 1 ;

data 1  -do -4  " " (257) 000001002003004005006007010011012013014015016017 ;

data 2  -do -4  (257) "abcdefghijklmnop" ;

data 3    "abcdefghijklmnop" ;

page    -all ;


/*   mvt 10
*
*   Test indirect referencing of descriptors 1 and 2.
*   Test register length modification and move data from 3 pages.
*/

inst mvt -nt  "tst ind descs; FCOs PHAFPG179 & 181 required on L68 CPU"
         -io 1
         -mf1 id rl 4112
         -mf2 id rl 4112 ;

desc 1  -cn 1 ;

data 1  -do -4  " " (257) 000001002003004005006007010011012013014015016017 ;

data 2  -do -4  (257) "abcdefghijklmnop" ;

data 3    "abcdefghijklmnop" ;

page    -all ;

/*   mvt 11
*
*  Test indirect referencing of descriptors 1 and 2 with ar modification
*  of the indirect word.  Also data is moved from 3 pages.
*/

inst mvt -nt "tst ida. 3 pgs moved; FCOs PHAFPG179 & 181 required on L68 CPU"
         -io 2
         -mf1 ida rl 4112
         -mf2 ida rl 4112 ;

desc 1  -cn 1 ;

data 1  -do -4  " " (257) 000001002003004005006007010011012013014015016017 ;

data 2  -do -4  (257) "abcdefghijklmnop" ;

data 3    "abcdefghijklmnop" ;

page    -all ;


/*   mvt 12
*
*  Test indirect referencing of descriptors 1 and 2 with reg modification
*  of the indirect word.  Also data is moved from 3 pages.
*/

inst  mvt  -nt  "tst idr, 3 pgs moved; FCOs PHAFPG179 & 181 required on L68 CPU"
         -io 1
         -mf1 idr rl 4112
         -mf2 idr rl 4112 ;

desc 1  -cn 1 ;

data 1  -do -4  " " (257) 000001002003004005006007010011012013014015016017 ;

data 2  -do -4  (257) "abcdefghijklmnop" ;

data 3    "abcdefghijklmnop" ;

page    -all ;


/*   mvt 13
*
*  Test indirect referencing of descriptors 1 and 2 with both
*  ar and reg modification of the indirect word.  Also data is
*  moved from three pages.
*/

inst  mvt  -nt  "tst idb. 3 pgs moved; FCOs PHAFPG179 & 181 required on L68 CPU"
         -io 2
         -mf1 idb rl 4112
         -mf2 idb rl 4112 ;

desc 1  -cn 1 ;

data 1  -do -4  " " (257) 000001002003004005006007010011012013014015016017 ;

data 2  -do -4  (257) "abcdefghijklmnop" ;

data 3    "abcdefghijklmnop" ;

page    -all ;


/*   mvt 14
*
*  Test indirect referencing of of descriptors 1 and 2 with
*  ar, reg, and reg length modification of the descriptors.
*  Data is moved from 3 pages.
*/

inst  mvt  -nt  "tst ar,reg,rl,id.; FCOs PHAFPG179 & 181 required on L68 CPU"
         -mf1 id ar reg rl 4112
         -mf2 id ar reg rl 4112 ;

desc 1  -cn 1 ;

data 1  -do -4  " " (257) 000001002003004005006007010011012013014015016017 ;

data 2  -do -4  (257) "abcdefghijklmnop" ;

data 3    "abcdefghijklmnop" ;

page    -all ;


/*   mvt 15
*
*  Test indirect referencing of descriptors 1 and 2 with ar
*  and reg modification of the indirect word.  Also ar, reg,
*  and register length modification is applied to the
*  descriptors.  Three pages of data is moved.
*/

inst  mvt  -nt  "tst ar,reg,rl,idb; FCOs PHAFPG179 & 181 required on L68 CPU"
         -io 2
         -mf1 idb ar reg rl 4112
         -mf2 idb ar reg rl 4112 ;

desc 1  -cn 1 ;

data 1  -do -4  " " (257) 000001002003004005006007010011012013014015016017 ;

data 2  -do -4  (257) "abcdefghijklmnop" ;

data 3    "abcdefghijklmnop" ;

page    -all ;


/*   mvt 16
*
*  Test translation of 9 bit to 6 bit characters.  Only direct descriptors
*  with no modification are used.  All forms of modification and
*  indirection have been tested in previous tests.
*  This test has no truncation.
*
*/

inst  mvt  -nt "9 to 6 bit chars"
           -fc  ;

desc 1  -ns 50
        -cn 2  ;

desc 2  -ns 50
        -cn 5
        -ta 6  ;

data 1  -do 4068
        "  " (6) 000001002003004005006007010 ;

data 2  -do 20
        000000000060 (5) 616263414243440060  61626341 ;

data 3  "0123abcd"  (23) 000  020  ;

page -all;


/*   mvt 17
*
*  Test translation of 9 to 6 `bit characters.
*  L1 is less than L2.  String 2 is `blank filled.
*
*/

inst  mvt  -nt "9 to 6 bit chars"
           -fc  ;

desc 1  -ns 28
        -cn 2  ;

desc 2  -ns 50
        -cn 5
        -ta 6  ;

data 1  -do 4068
        "  " (6) 000001002003004005006007010 ;

data 2  -do 20
        000000000060 (3) 616263414243440060  (7) 202020  20  ;

data 3  "0123abcd"  (24) 000  020  ;

page -all;


/*   mvt 18
*
*  Test translation of 9 to 6 bit characters.
*  L1 is greater than L2.  Truncation fault is not taken.
*
*/

inst  mvt  -nt  "truncation but no fault"
           -ir tn  ;


desc 1  -ns 50
        -cn 2  ;

desc 2  -ns 28
        -cn 5
        -ta 6  ;

data 1  -do 4068
        "  " (6) 000001002003004005006007010 ;

data 2  -do 20
        000000000060 (3) 616263414243440060  ;

data 3  "0123abcd"  (24) 000  020  ;

page -all;


/*   mvt 19
*
*  Test translation of 6 bit to 9 bit characters.  Only direct
*  descriptors with no modification are used.
*  This test has no truncation.
*
*/

inst  mvt  -nt "6-9 bit. no truncation"
           -fc   ;

desc 1  -ns 63
        -cn 3
        -ta 6  ;

desc 2  -ns 63 ;

data 1  -do -20
        000000  (7)  000102030405060710  ;

data 2  -do -28
        (7)  141142143144060061062063000  ;

data 3  "abcd0123"  (24) 000  040  ;

page -all;


/*   mvt 20
*
*  Test translation of 6 bit to 9 bit characters.
*  L1 is less than L2.  String 2 is blank filled.
*
*/

inst  mvt  -nt "6-9 bit. blank fill"
           -fc   ;

desc 1  -ns 29
        -cn 3
        -ta 6  ;

desc 2  -ns 63 ;

data 1  -do -20
        000000  (7)  000102030405060710  ;

data 2  -do -28
        (3)  141142143144060061062063000  141142  (34) 040  ;

data 3  "abcd0123"  (24) 000  040  ;

page -all;


/*   mvt 21
*
*  Test translation of 6 bit to 9 bit characters.
*  L1 is greater than L2.  Truncation fault is not taken.
*
*/

inst  mvt  -nt "6-9 bit. truncation"
           -ir tn
           -fc   ;

desc 1  -ns 63
        -cn 3
        -ta 6  ;

desc 2  -ns 29 ;

data 1  -do -20
        000000  (7)  000102030405060710  ;

data 2  -do -28
        (3)  141142143144060061062063000  141142  ;

data 3  "abcd0123"  (24) 000  040  ;

page -all;


/*   mvt 22
*
*  Test translation of 4 bit characters. The test is made
*  with full descriptor modification.  Data is placed across a
*  page boundary.
*
*/

inst  mvt  -nt "4 bit char translation"
           -io 1
           -mf1 idb ar reg rl 16
           -mf2 idb ar reg rl 16
           -mf3 ar reg  ;

desc 1  -ta 4 ;

desc 2  -ta 4 ;

data 1  -do -4  (2) 002215053176  ;

data 2  -do -4  (2) 002215053176  ;

data 3  000 001 002 003 004 005 006 007 010 011 012 013 014 015 016 017  ;

page -all;


/*		mve1
*
*	Move  6  (9 bit) characters with zero -> "*" replacement.
*	All the fields including the  micro op string will take faults
*	and cross a page boundary.
*/

inst	mve	-nt  "zero rep, mod, faults"	-io 3
	-mf1	idb ar reg  rl 6
	-mf2	idb ar reg  rl 2
	-mf3	idb ar reg  rl 6;

/*	No desc statements needed.  */

data 1	-do -4	"0010" "23";

data 2	-do -1	124		/*  mvza 4 */
		322;		/*   mvc 2 */

data 3	-do -3	"**1" "023";


page	-all;
/*                  mve2

*         this test uses a sequence of micro op strings
*         that are appropriate for alpha numeric data.
*         each string is input to et such that it is
*         explained via a comment after each mop.
*         this particular mop sequence and the sending string is
*         used for all 6 and 9 bit tests with mod done
*         on descriptor access and data placement.
*
*/

inst      mve -nt "9-9 simple test with no mod"
          -mf3      rl 31;

desc 1    -ns 27;

desc 2    -ns 26;


data 1    /* arranged according mop use */
          "0012"
          "0012"
          "0012"
          "1234"
          "4567"
          "-123"
          "123";

data 2     /* mops arranged in order */
          104       /* mvzb */
          060       /* ses es reset */
          124       /* mvza */
          060       /* ses es reset */
          050       /* enf for $ insert */
          064       /* ses es reset and bz set */
          164       /* mflc */
          200075    /* insb with = */
          060       /* ses es reset */
          220076    /* insa with " not used since es=0 */
          304       /* ign */
          324       /* mvc */
          420 "* +-    "    /* change table with string shown */
          024       /* insm */
          344       /* mses sn is set */
          364;


data 3    "  12"
          "**12"
          "$"
          "  $12"
          "="
          "*"
          "4567"
          "****"
          "-123"
          ";;;";

page      -all;
/*                  mve3

*         this test uses a sequence of micro op strings
*         that are appropriate for alpha numeric data.
*         each string is input to et such that it is
*         explained via a comment after each mop.
*         this particular mop sequence and the sending string is
*         used for all 6 and 9 bit tests with mod done
*         on descriptor access and data placement.
*
*/

inst      mve -nt "9-9offset inst. and desc mod"     -io 2
          -mf1      ida ar
          -mf2      reg
          -mf3      rl 31;

desc 1    -ns 27;

desc 2    -ns 26;


data 1    /* arranged according mop use */
          "0012"
          "0012"
          "0012"
          "1234"
          "4567"
          "-123"
          "123";

data 2     /* mops arranged in order */
          104       /* mvzb */
          060       /* ses es reset */
          124       /* mvza */
          060       /* ses es reset */
          050       /* enf for $ insert */
          064       /* ses es reset and bz set */
          164       /* mflc */
          200075    /* insb with = */
          060       /* ses es reset */
          220076    /* insa with " not used since es=0 */
          304       /* ign */
          324       /* mvc */
          420 "* +-    "    /* change table with string shown */
          024       /* insm */
          344       /* mses sn is set */
          364;     /* mors */


data 3    "  12"
          "**12"
          "$"
          "  $12"
          "="
          "*"
          "4567"
          "****"
          "-123"
          ";;;";

page      -all;
 /*                  mve4

*         this test uses a sequence of micro op strings
*         that are appropriate for alpha numeric data.
*         each string is input to et such that it is
*         explained via a comment after each mop.
*         this particular mop sequence and the sending string is
*         used for all 6 and 9 bit tests with mod done
*         on descriptor access and data placement.
*
*/

inst      mve -nt "9-9 off inst desc mod d1 off"     -io 2
          -mf1      ida ar
          -mf2      idb ar
          -mf3      rl 31;

desc 1    -ns 27;

desc 2    -ns 26;


data 1    /* arranged according mop use */
          -do -7
          "0012"
          "0012"
          "0012"
          "1234"
          "4567"
          "-123"
          "123";

data 2     /* mops arranged in order */
          104       /* mvzb */
          060       /* ses es reset */
          124       /* mvza */
          060       /* ses es reset */
          050       /* enf for $ insert */
          064       /* ses es reset and bz set */
          164       /* mflc */
          200075    /* insb with = */
          060       /* ses es reset */
          220076    /* insa with " not used since es=0 */
          304       /* ign */
          324       /* mvc */
          420 "* +-    "    /* change table with string shown */
          024       /* insm */
          344       /* mses sn is set */
          364;     /* mors */


data 3    "  12"
          "**12"
          "$"
          "  $12"
          "="
          "*"
          "4567"
          "****"
          "-123"
          ";;;";

page      -all;


/*                  mve5

*         this test uses a sequence of micro op strings
*         that are appropriate for alpha numeric data.
*         each string is input to et such that it is
*         explained via a comment after each mop.
*         this particular mop sequence and the sending string is
*         used for all 6 and 9 bit tests with mod done
*         on descriptor access and data placement.
*
*/

inst      mve -nt "9-9 d2 offset d1 offset"     -io 2
          -mf1      ida ar
          -mf2      idb ar
          -mf3      rl 31;

desc 1    -ns 27;

desc 2    -ns 26;


data 1    /* arranged according mop use */
          -do -7
          "0012"
          "0012"
          "0012"
          "1234"
          "4567"
          "-123"
          "123";

data 2     /* mops arranged in order */
          -do -13
          104       /* mvzb */
          060       /* ses es reset */
          124       /* mvza */
          060       /* ses es reset */
          050       /* enf for $ insert */
          064       /* ses es reset and bz set */
          164       /* mflc */
          200075    /* insb with = */
          060       /* ses es reset */
          220076    /* insa with " not used since es=0 */
          304       /* ign */
          324       /* mvc */
          420 "* +-    "    /* change table with string shown */
          024       /* insm */
          344       /* mses sn is set */
          364;     /* mors */


data 3    "  12"
          "**12"
          "$"
          "  $12"
          "="
          "*"
          "4567"
          "****"
          "-123"
          ";;;";

page      -all;
 /*                  mve6

*         this test uses a sequence of micro op strings
*         that are appropriate for alpha numeric data.
*         each string is input to et such that it is
*         explained via a comment after each mop.
*         this particular mop sequence and the sending string is
*         used for all 6 and 9 bit tests with mod done
*         on descriptor access and data placement.
*
*/

inst      mve -nt "9-9d3 offset d2 offset d1 offset"     -io 3
          -mf1      ida ar reg
          -mf2      idb ar
          -mf3      rl 31;

desc 1    -ns 27;

desc 2    -ns 26;


data 1    /* arranged according mop use */
          -do -7
          "0012"
          "0012"
          "0012"
          "1234"
          "4567"
          "-123"
          "123";

data 2     /* mops arranged in order */
          -do -13
          104       /* mvzb */
          060       /* ses es reset */
          124       /* mvza */
          060       /* ses es reset */
          050       /* enf for $ insert */
          064       /* ses es reset and bz set */
          164       /* mflc */
          200075    /* insb with = */
          060       /* ses es reset */
          220076    /* insa with " not used since es=0 */
          304       /* ign */
          324       /* mvc */
          420 "* +-    "    /* change table with string shown */
          024       /* insm */
          344       /* mses sn is set */
          364;     /* mors */


data 3    -do -28
          "  12"
          "**12"
          "$"
          "  $12"
          "="
          "*"
          "4567"
          "****"
          "-123"
          ";;;";

page      -all;

/*                  mve7

*         this test uses a sequence of micro op strings
*         that are appropriate for alpha numeric data.
*         each string is input to et such that it is
*         explained via a comment after each mop.
*         this particular mop sequence and the sending string is
*         used for all 6 and 9 bit tests with mod done
*         on descriptor access and data placement.
*
*/

inst      mve -nt "9-9data 1 totally on p0"     -io 3
          -mf1      ida ar reg rl 27
          -mf2      idb ar
          -mf3      ar reg rl 31;


desc 2    -ns 26;


data 1    /* arranged according mop use */
          -do -27
          "0012"
          "0012"
          "0012"
          "1234"
          "4567"
          "-123"
          "123";

data 2     /* mops arranged in order */
          -do -13
          104       /* mvzb */
          060       /* ses es reset */
          124       /* mvza */
          060       /* ses es reset */
          050       /* enf for $ insert */
          064       /* ses es reset and bz set */
          164       /* mflc */
          200075    /* insb with = */
          060       /* ses es reset */
          220076    /* insa with " not used since es=0 */
          304       /* ign */
          324       /* mvc */
          420 "* +-    "    /* change table with string shown */
          024       /* insm */
          344       /* mses sn is set */
          364;     /* mors */


data 3    -do 30
          "  12"
          "**12"
          "$"
          "  $12"
          "="
          "*"
          "4567"
          "****"
          "-123"
          ";;;";

page      -all;
 /*                  mve8

*         this test uses a sequence of micro op strings
*         that are appropriate for alpha numeric data.
*         each string is input to et such that it is
*         explained via a comment after each mop.
*         this particular mop sequence and the sending string is
*         used for all 6 and 9 bit tests with mod done
*         on descriptor access and data placement.
*
*/

inst      mve -nt "9-9data 2 totally on p0"     -io 3
          -mf1      ida ar reg rl 27
          -mf2      idb ar rl 26
          -mf3      ar reg rl 31;


           /* no desc needed */


data 1    /* arranged according mop use */
          -do -27
          "0012"
          "0012"
          "0012"
          "1234"
          "4567"
          "-123"
          "123";

data 2     /* mops arranged in order */
          -do -26
          104       /* mvzb */
          060       /* ses es reset */
          124       /* mvza */
          060       /* ses es reset */
          050       /* enf for $ insert */
          064       /* ses es reset and bz set */
          164       /* mflc */
          200075    /* insb with = */
          060       /* ses es reset */
          220076    /* insa with " not used since es=0 */
          304       /* ign */
          324       /* mvc */
          420 "* +-    "    /* change table with string shown */
          024       /* insm */
          344       /* mses sn is set */
          364;     /* mors */


data 3    -do 30
          "  12"
          "**12"
          "$"
          "  $12"
          "="
          "*"
          "4567"
          "****"
          "-123"
          ";;;";

page      -all;
 /*                  mve9

*         this test uses a sequence of micro op strings
*         that are appropriate for alpha numeric data.
*         each string is input to et such that it is
*         explained via a comment after each mop.
*         this particular mop sequence and the sending string is
*         used for all 6 and 9 bit tests with mod done
*         on descriptor access and data placement.
*
*/

inst      mve -nt "9-9all data totally on p0"     -io 3
          -mf1      ida ar reg rl 27
          -mf2      idb ar rl 26
          -mf3      ar reg rl 31;


           /* no desc needed */


data 1    /* arranged according mop use */
          -do -27
          "0012"
          "0012"
          "0012"
          "1234"
          "4567"
          "-123"
          "123";

data 2     /* mops arranged in order */
          -do -26
          104       /* mvzb */
          060       /* ses es reset */
          124       /* mvza */
          060       /* ses es reset */
          050       /* enf for $ insert */
          064       /* ses es reset and bz set */
          164       /* mflc */
          200075    /* insb with = */
          060       /* ses es reset */
          220076    /* insa with " not used since es=0 */
          304       /* ign */
          324       /* mvc */
          420 "* +-    "    /* change table with string shown */
          024       /* insm */
          344       /* mses sn is set */
          364;     /* mors */


data 3    -do -31
          "  12"
          "**12"
          "$"
          "  $12"
          "="
          "*"
          "4567"
          "****"
          "-123"
          ";;;";

page      -all;
 /*                  mve10

*         this test uses a sequence of micro op strings
*         that are appropriate for alpha numeric data.
*         each string is input to et such that it is
*         explained via a comment after each mop.
*         this particular mop sequence and the sending string is
*         used for all 6 and 9 bit tests with mod done
*         on descriptor access and data placement.
*
*/

inst      mve -nt "9-9 all data  on p0 all mod"     -io 3
          -mf1      idb ar reg rl 27
          -mf2      idb ar reg rl 26
          -mf3      ar reg rl 31;


           /* no desc needed */


data 1    /* arranged according mop use */
          -do -27
          "0012"
          "0012"
          "0012"
          "1234"
          "4567"
          "-123"
          "123";

data 2     /* mops arranged in order */
          -do -26
          104       /* mvzb */
          060       /* ses es reset */
          124       /* mvza */
          060       /* ses es reset */
          050       /* enf for $ insert */
          064       /* ses es reset and bz set */
          164       /* mflc */
          200075    /* insb with = */
          060       /* ses es reset */
          220076    /* insa with " not used since es=0 */
          304       /* ign */
          324       /* mvc */
          420 "* +-    "    /* change table with string shown */
          024       /* insm */
          344       /* mses sn is set */
          364;     /* mors */


data 3    -do -31
          "  12"
          "**12"
          "$"
          "  $12"
          "="
          "*"
          "4567"
          "****"
          "-123"
          ";;;";

page      -all;
 /*                  mve11

*         this test uses a sequence of micro op strings
*         that are appropriate for alpha numeric data.
*         each string is input to et such that it is
*         explained via a comment after each mop.
*         this particular mop sequence and the sending string is
*         used for all 6 and 9 bit tests with mod done
*         on descriptor access and data placement.
*
*/

inst      mve -nt "6-9  simple test with no mod"
          -mf3      rl 31;

desc 1    -ta 6    -ns 27;

desc 2    -ns 26;

desc 3    -ta 9;


data 1    /* arranged according mop use */
          606061626060616260606162616263646465666752616263616263;

data 2     /* mops arranged in order */
          104       /* mvzb */
          060       /* ses es reset */
          124       /* mvza */
          060       /* ses es reset */
          050       /* enf for $ insert */
          064       /* ses es reset and bz set */
          164       /* mflc */
          200075    /* insb with = */
          060       /* ses es reset */
          220076    /* insa with " not used since es=0 */
          304       /* ign */
          324       /* mvc */
          420 "* +-    "    /* change table with string shown */
          024       /* insm */
          344       /* mses sn is set */
          364;


data 3    "  12"
          "**12"
          "$"
          "  $12"
          "="
          "*"
          "4567"
          "****"
          "*123"
          ";;;";

page      -all;
/*                  mve12

*         this test uses a sequence of micro op strings
*         that are appropriate for alpha numeric data.
*         each string is input to et such that it is
*         explained via a comment after each mop.
*         this particular mop sequence and the sending string is
*         used for all 6 and 9 bit tests with mod done
*         on descriptor access and data placement.
*
*/

inst      mve -nt "6-9 offset inst. and desc mod"     -io 2
          -mf1      ida ar
          -mf2      reg
          -mf3      rl 31;

desc 1    -ta 6    -ns 27;

desc 2    -ns 26;


data 1    /* arranged according mop use */
          606061626060616260606162616263646465666752616263616263;

data 2     /* mops arranged in order */
          104       /* mvzb */
          060       /* ses es reset */
          124       /* mvza */
          060       /* ses es reset */
          050       /* enf for $ insert */
          064       /* ses es reset and bz set */
          164       /* mflc */
          200075    /* insb with = */
          060       /* ses es reset */
          220076    /* insa with " not used since es=0 */
          304       /* ign */
          324       /* mvc */
          420 "* +-    "    /* change table with string shown */
          024       /* insm */
          344       /* mses sn is set */
          364;     /* mors */


data 3    "  12"
          "**12"
          "$"
          "  $12"
          "="
          "*"
          "4567"
          "****"
          "*123"
          ";;;";

page      -all;
 /*                  mve13

*         this test uses a sequence of micro op strings
*         that are appropriate for alpha numeric data.
*         each string is input to et such that it is
*         explained via a comment after each mop.
*         this particular mop sequence and the sending string is
*         used for all 6 and 9 bit tests with mod done
*         on descriptor access and data placement.
*
*/

inst      mve -nt "6-9  desc mod d1 offset"     -io 2
          -mf1      ida ar
          -mf2      idb ar
          -mf3      rl 31;

desc 1    -ta 6    -ns 27;

desc 2    -ns 26;


data 1    /* arranged according mop use */
          -do -6
          606061626060616260606162616263646465666752616263616263;

data 2     /* mops arranged in order */
          104       /* mvzb */
          060       /* ses es reset */
          124       /* mvza */
          060       /* ses es reset */
          050       /* enf for $ insert */
          064       /* ses es reset and bz set */
          164       /* mflc */
          200075    /* insb with = */
          060       /* ses es reset */
          220076    /* insa with " not used since es=0 */
          304       /* ign */
          324       /* mvc */
          420 "* +-    "    /* change table with string shown */
          024       /* insm */
          344       /* mses sn is set */
          364;     /* mors */


data 3    "  12"
          "**12"
          "$"
          "  $12"
          "="
          "*"
          "4567"
          "****"
          "*123"
          ";;;";

page      -all;


/*                  mve14

*         this test uses a sequence of micro op strings
*         that are appropriate for alpha numeric data.
*         each string is input to et such that it is
*         explained via a comment after each mop.
*         this particular mop sequence and the sending string is
*         used for all 6 and 9 bit tests with mod done
*         on descriptor access and data placement.
*
*/

inst      mve -nt "6-9  d2 offset d1 offset"     -io 2
          -mf1      ida ar
          -mf2      idb ar
          -mf3      rl 31;

desc 1    -ta 6    -ns 27;

desc 2    -ns 26;


data 1    /* arranged according mop use */
          -do -6
          606061626060616260606162616263646465666752616263616263;

data 2     /* mops arranged in order */
          -do -13
          104       /* mvzb */
          060       /* ses es reset */
          124       /* mvza */
          060       /* ses es reset */
          050       /* enf for $ insert */
          064       /* ses es reset and bz set */
          164       /* mflc */
          200075    /* insb with = */
          060       /* ses es reset */
          220076    /* insa with " not used since es=0 */
          304       /* ign */
          324       /* mvc */
          420 "* +-    "    /* change table with string shown */
          024       /* insm */
          344       /* mses sn is set */
          364;     /* mors */


data 3    "  12"
          "**12"
          "$"
          "  $12"
          "="
          "*"
          "4567"
          "****"
          "*123"
          ";;;";

page      -all;
 /*                  mve15

*         this test uses a sequence of micro op strings
*         that are appropriate for alpha numeric data.
*         each string is input to et such that it is
*         explained via a comment after each mop.
*         this particular mop sequence and the sending string is
*         used for all 6 and 9 bit tests with mod done
*         on descriptor access and data placement.
*
*/

inst      mve -nt "6-9 d3 offset and d2 and d1"     -io 3
          -mf1      ida ar reg
          -mf2      idb ar
          -mf3      rl 31;

desc 1    -ta 6    -ns 27;

desc 2    -ns 26;


data 1    /* arranged according mop use */
          -do -6
          606061626060616260606162616263646465666752616263616263;

data 2     /* mops arranged in order */
          -do -13
          104       /* mvzb */
          060       /* ses es reset */
          124       /* mvza */
          060       /* ses es reset */
          050       /* enf for $ insert */
          064       /* ses es reset and bz set */
          164       /* mflc */
          200075    /* insb with = */
          060       /* ses es reset */
          220076    /* insa with " not used since es=0 */
          304       /* ign */
          324       /* mvc */
          420 "* +-    "    /* change table with string shown */
          024       /* insm */
          344       /* mses sn is set */
          364;     /* mors */


data 3    -do -28
          "  12"
          "**12"
          "$"
          "  $12"
          "="
          "*"
          "4567"
          "****"
          "*123"
          ";;;";

page      -all;

/*                  mve16

*         this test uses a sequence of micro op strings
*         that are appropriate for alpha numeric data.
*         each string is input to et such that it is
*         explained via a comment after each mop.
*         this particular mop sequence and the sending string is
*         used for all 6 and 9 bit tests with mod done
*         on descriptor access and data placement.
*
*/

inst      mve -nt "6-9 data 1 totally on p0"     -io 3
          -mf1      ida ar reg rl 27
          -mf2      idb ar
          -mf3      ar reg rl 31;


desc 1    -ta 6;

desc 2    -ns 26;


data 1    /* arranged according mop use */
          -do -28
          606061626060616260606162616263646465666752616263616263;

data 2     /* mops arranged in order */
          -do -13
          104       /* mvzb */
          060       /* ses es reset */
          124       /* mvza */
          060       /* ses es reset */
          050       /* enf for $ insert */
          064       /* ses es reset and bz set */
          164       /* mflc */
          200075    /* insb with = */
          060       /* ses es reset */
          220076    /* insa with " not used since es=0 */
          304       /* ign */
          324       /* mvc */
          420 "* +-    "    /* change table with string shown */
          024       /* insm */
          344       /* mses sn is set */
          364;     /* mors */


data 3    -do 30
          "  12"
          "**12"
          "$"
          "  $12"
          "="
          "*"
          "4567"
          "****"
          "*123"
          ";;;";

page      -all;
  /*                  mve17

*         this test uses a sequence of micro op strings
*         that are appropriate for alpha numeric data.
*         each string is input to et such that it is
*         explained via a comment after each mop.
*         this particular mop sequence and the sending string is
*         used for all 6 and 9 bit tests with mod done
*         on descriptor access and data placement.
*
*/

inst      mve -nt "6-9 data 2 totally on p0"     -io 3
          -mf1      ida ar reg rl 27
          -mf2      idb ar rl 26
          -mf3      ar reg rl 31;


desc 1    -ta 6;


data 1    /* arranged according mop use */
          606061626060616260606162616263646465666752616263616263;

data 2     /* mops arranged in order */
          -do -26
          104       /* mvzb */
          060       /* ses es reset */
          124       /* mvza */
          060       /* ses es reset */
          050       /* enf for $ insert */
          064       /* ses es reset and bz set */
          164       /* mflc */
          200075    /* insb with = */
          060       /* ses es reset */
          220076    /* insa with " not used since es=0 */
          304       /* ign */
          324       /* mvc */
          420 "* +-    "    /* change table with string shown */
          024       /* insm */
          344       /* mses sn is set */
          364;     /* mors */


data 3    -do 30
          "  12"
          "**12"
          "$"
          "  $12"
          "="
          "*"
          "4567"
          "****"
          "*123"
          ";;;";

page      -all;
 /*                  mve18

*         this test uses a sequence of micro op strings
*         that are appropriate for alpha numeric data.
*         each string is input to et such that it is
*         explained via a comment after each mop.
*         this particular mop sequence and the sending string is
*         used for all 6 and 9 bit tests with mod done
*         on descriptor access and data placement.
*
*/

inst      mve -nt "6-9 all data totally on p0"     -io 3
          -mf1      ida ar reg rl 27
          -mf2      idb ar rl 26
          -mf3      ar reg rl 31;


desc 1    -ta 6;


data 1    /* arranged according mop use */
          -do -28
          606061626060616260606162616263646465666752616263616263;

data 2     /* mops arranged in order */
          -do -26
          104       /* mvzb */
          060       /* ses es reset */
          124       /* mvza */
          060       /* ses es reset */
          050       /* enf for $ insert */
          064       /* ses es reset and bz set */
          164       /* mflc */
          200075    /* insb with = */
          060       /* ses es reset */
          220076    /* insa with " not used since es=0 */
          304       /* ign */
          324       /* mvc */
          420 "* +-    "    /* change table with string shown */
          024       /* insm */
          344       /* mses sn is set */
          364;     /* mors */


data 3    -do -31
          "  12"
          "**12"
          "$"
          "  $12"
          "="
          "*"
          "4567"
          "****"
          "*123"
          ";;;";

page      -all;
 /*                  mve19

*         this test uses a sequence of micro op strings
*         that are appropriate for alpha numeric data.
*         each string is input to et such that it is
*         explained via a comment after each mop.
*         this particular mop sequence and the sending string is
*         used for all 6 and 9 bit tests with mod done
*         on descriptor access and data placement.
*
*/

inst      mve -nt "6-9 all data  on p0 all mod"     -io 3
          -mf1      idb ar reg rl 27
          -mf2      idb ar reg rl 26
          -mf3      ar reg rl 31;


desc 1    -ta 6;


data 1    /* arranged according mop use */
          -do -28
          606061626060616260606162616263646465666752616263616263;

data 2     /* mops arranged in order */
          -do -26
          104       /* mvzb */
          060       /* ses es reset */
          124       /* mvza */
          060       /* ses es reset */
          050       /* enf for $ insert */
          064       /* ses es reset and bz set */
          164       /* mflc */
          200075    /* insb with = */
          060       /* ses es reset */
          220076    /* insa with " not used since es=0 */
          304       /* ign */
          324       /* mvc */
          420 "* +-    "    /* change table with string shown */
          024       /* insm */
          344       /* mses sn is set */
          364;     /* mors */


data 3    -do -31
          "  12"
          "**12"
          "$"
          "  $12"
          "="
          "*"
          "4567"
          "****"
          "*123"
          ";;;";

page      -all;
 /*                  mve20

*         this test uses a sequence of micro op strings
*         that are appropriate for alpha numeric data.
*         each string is input to et such that it is
*         explained via a comment after each mop.
*         this particular mop sequence and the sending string is
*         used for all 6 and 9 bit tests with mod done
*         on descriptor access and data placement.
*
*/

inst      mve -nt "9-6  simple test with no mod"
          -mf3      rl 31;

desc 1    -ns 27;

desc 2         -ns 26;

desc 3    -ta 6;


data 1    /* arranged according mop use */
          "0012"
          "0012"
          "0012"
          "1234"
          "4567"
          "-123"
          "123";

data 2     /* mops arranged in order */
          /* change table and mvzb */ 420020054060052053073033000 104
          060       /* ses es reset */
          124       /* mvza */
          060       /* ses es reset */
          050       /* enf for $ insert */
          064       /* ses es reset and bz set */
          164       /* mflc */
          200075    /* insb with = */
          060       /* ses es reset */
          220076    /* insa with " not used since es=0 */
          304       /* ign */
          324       /* mvc */
          024       /* insm */
          344       /* mses sn is set */
          364;


data 3    20206162545461625320205361627554646566672020202055616263616263;

page      -all;
/*                  mve21

*         this test uses a sequence of micro op strings
*         that are appropriate for alpha numeric data.
*         each string is input to et such that it is
*         explained via a comment after each mop.
*         this particular mop sequence and the sending string is
*         used for all 6 and 9 bit tests with mod done
*         on descriptor access and data placement.
*
*/

inst      mve -nt "9-6 offset inst. and desc mod"     -io 2
          -mf1      ida ar
          -mf2      reg
          -mf3      rl 31;

desc 1    -ns 27;

desc 2         -ns 26;

desc 3    -ta 6;

data 1    /* arranged according mop use */
          "0012"
          "0012"
          "0012"
          "1234"
          "4567"
          "-123"
          "123";

data 2     /* mops arranged in order */
          /* change table and mvzb */ 420020054060052053073033000 104
          060       /* ses es reset */
          124       /* mvza */
          060       /* ses es reset */
          050       /* enf for $ insert */
          064       /* ses es reset and bz set */
          164       /* mflc */
          200075    /* insb with = */
          060       /* ses es reset */
          220076    /* insa with " not used since es=0 */
          304       /* ign */
          324       /* mvc */
          024       /* insm */
          344       /* mses sn is set */
          364;     /* mors */


data 3    20206162545461625320205361627554646566672020202055616263616263;
page      -all;

 /*                  mve22

*         this test uses a sequence of micro op strings
*         that are appropriate for alpha numeric data.
*         each string is input to et such that it is
*         explained via a comment after each mop.
*         this particular mop sequence and the sending string is
*         used for all 6 and 9 bit tests with mod done
*         on descriptor access and data placement.
*
*/

inst      mve -nt "9-6  desc mod d1 offset"     -io 2
          -mf1      ida ar
          -mf2      idb ar
          -mf3      rl 31;

desc 1    -ns 27;

desc 2         -ns 26;

desc 3    -ta 6;


data 1    /* arranged according mop use */
          -do -7
          "0012"
          "0012"
          "0012"
          "1234"
          "4567"
          "-123"
          "123";

data 2     /* mops arranged in order */
          /* change table and mvzb */ 420020054060052053073033000 104
          060       /* ses es reset */
          124       /* mvza */
          060       /* ses es reset */
          050       /* enf for $ insert */
          064       /* ses es reset and bz set */
          164       /* mflc */
          200075    /* insb with = */
          060       /* ses es reset */
          220076    /* insa with " not used since es=0 */
          304       /* ign */
          324       /* mvc */
          024       /* insm */
          344       /* mses sn is set */
          364;     /* mors */


data 3    20206162545461625320205361627554646566672020202055616263616263;

page      -all;


/*                  mve23

*         this test uses a sequence of micro op strings
*         that are appropriate for alpha numeric data.
*         each string is input to et such that it is
*         explained via a comment after each mop.
*         this particular mop sequence and the sending string is
*         used for all 6 and 9 bit tests with mod done
*         on descriptor access and data placement.
*
*/

inst      mve -nt "9-6  d2 offset d1 offset"     -io 2
          -mf1      ida ar
          -mf2      idb ar
          -mf3      rl 31;

desc 1    -ns 27;

desc 2         -ns 26;

desc 3    -ta 6;


data 1    /* arranged according mop use */
          -do -7
          "0012"
          "0012"
          "0012"
          "1234"
          "4567"
          "-123"
          "123";

data 2     /* mops arranged in order */
          -do -13
          /* change table and mvzb */ 420020054060052053073033000 104
          060       /* ses es reset */
          124       /* mvza */
          060       /* ses es reset */
          050       /* enf for $ insert */
          064       /* ses es reset and bz set */
          164       /* mflc */
          200075    /* insb with = */
          060       /* ses es reset */
          220076    /* insa with " not used since es=0 */
          304       /* ign */
          324       /* mvc */
          024       /* insm */
          344       /* mses sn is set */
          364;     /* mors */


data 3    20206162545461625320205361627554646566672020202055616263616263;

page      -all;
 /*                  mve24

*         this test uses a sequence of micro op strings
*         that are appropriate for alpha numeric data.
*         each string is input to et such that it is
*         explained via a comment after each mop.
*         this particular mop sequence and the sending string is
*         used for all 6 and 9 bit tests with mod done
*         on descriptor access and data placement.
*
*/

inst      mve -nt "9-6 d3 offset d2 and d1"     -io 3
          -mf1      ida ar reg
          -mf2      idb ar
          -mf3      rl 31;

desc 1    -ns 27;

desc 2         -ns 26;

desc 3    -ta 6;


data 1    /* arranged according mop use */
          -do -7
          "0012"
          "0012"
          "0012"
          "1234"
          "4567"
          "-123"
          "123";

data 2     /* mops arranged in order */
          -do -13
          /* change table and mvzb */ 420020054060052053073033000 104
          060       /* ses es reset */
          124       /* mvza */
          060       /* ses es reset */
          050       /* enf for $ insert */
          064       /* ses es reset and bz set */
          164       /* mflc */
          200075    /* insb with = */
          060       /* ses es reset */
          220076    /* insa with " not used since es=0 */
          304       /* ign */
          324       /* mvc */
          024       /* insm */
          344       /* mses sn is set */
          364;     /* mors */


data 3    -do -28
          20206162545461625320205361627554646566672020202055616263616263;

page      -all;

/*                  mve25

*         this test uses a sequence of micro op strings
*         that are appropriate for alpha numeric data.
*         each string is input to et such that it is
*         explained via a comment after each mop.
*         this particular mop sequence and the sending string is
*         used for all 6 and 9 bit tests with mod done
*         on descriptor access and data placement.
*
*/

inst      mve -nt "9-6 data 1 totally on p0"     -io 3
          -mf1      ida ar reg rl 27
          -mf2      idb ar
          -mf3      ar reg rl 31;


desc 2         -ns 26;

desc 3    -ta 6;


data 1    /* arranged according mop use */
          -do -27
          "0012"
          "0012"
          "0012"
          "1234"
          "4567"
          "-123"
          "123";

data 2     /* mops arranged in order */
          -do -13
          /* change table and mvzb */ 420020054060052053073033000 104
          060       /* ses es reset */
          124       /* mvza */
          060       /* ses es reset */
          050       /* enf for $ insert */
          064       /* ses es reset and bz set */
          164       /* mflc */
          200075    /* insb with = */
          060       /* ses es reset */
          220076    /* insa with " not used since es=0 */
          304       /* ign */
          324       /* mvc */
          024       /* insm */
          344       /* mses sn is set */
          364;     /* mors */


data 3    -do 30
          20206162545461625320205361627554646566672020202055616263616263;

page      -all;
 /*                  mve26

*         this test uses a sequence of micro op strings
*         that are appropriate for alpha numeric data.
*         each string is input to et such that it is
*         explained via a comment after each mop.
*         this particular mop sequence and the sending string is
*         used for all 6 and 9 bit tests with mod done
*         on descriptor access and data placement.
*
*/

inst      mve -nt "9-6 data 2 totally on p0"     -io 3
          -mf1      ida ar reg rl 27
          -mf2      idb ar rl 26
          -mf3      ar reg rl 31;


desc 3    -ta 6;


data 1    /* arranged according mop use */
          -do -27
          "0012"
          "0012"
          "0012"
          "1234"
          "4567"
          "-123"
          "123";

data 2     /* mops arranged in order */
          -do -26
          /* change table and mvzb */ 420020054060052053073033000 104
          060       /* ses es reset */
          124       /* mvza */
          060       /* ses es reset */
          050       /* enf for $ insert */
          064       /* ses es reset and bz set */
          164       /* mflc */
          200075    /* insb with = */
          060       /* ses es reset */
          220076    /* insa with " not used since es=0 */
          304       /* ign */
          324       /* mvc */
          024       /* insm */
          344       /* mses sn is set */
          364;     /* mors */


data 3    -do -12
          20206162545461625320205361627554646566672020202055616263616263;

page      -all;
 /*                  mve27

*         this test uses a sequence of micro op strings
*         that are appropriate for alpha numeric data.
*         each string is input to et such that it is
*         explained via a comment after each mop.
*         this particular mop sequence and the sending string is
*         used for all 6 and 9 bit tests with mod done
*         on descriptor access and data placement.
*
*/

inst      mve -nt "9-6 all data totally on p0"     
          -mf1      ida ar reg rl 27
          -mf2      idb ar rl 26
          -mf3      ar reg rl 31;

desc 3    -ta 6;


data 1    /* arranged according mop use */
          -do -27
          "0012"
          "0012"
          "0012"
          "1234"
          "4567"
          "-123"
          "123";

data 2     /* mops arranged in order */
          -do -26
          /* change table and mvzb */ 420020054060052053073033000 104
          060       /* ses es reset */
          124       /* mvza */
          060       /* ses es reset */
          050       /* enf for $ insert */
          064       /* ses es reset and bz set */
          164       /* mflc */
          200075    /* insb with = */
          060       /* ses es reset */
          220076    /* insa with " not used since es=0 */
          304       /* ign */
          324       /* mvc */
          024       /* insm */
          344       /* mses sn is set */
          364;     /* mors */


data 3    -do -32
          20206162545461625320205361627554646566672020202055616263616263;

page      -all;
 /*                  mve28

*         this test uses a sequence of micro op strings
*         that are appropriate for alpha numeric data.
*         each string is input to et such that it is
*         explained via a comment after each mop.
*         this particular mop sequence and the sending string is
*         used for all 6 and 9 bit tests with mod done
*         on descriptor access and data placement.
*
*/

inst      mve -nt "9-6 all data  on p0 all mod"     -io 3
          -mf1      idb ar reg rl 27
          -mf2      idb ar reg rl 26
          -mf3      ar reg rl 31;

desc 3    -ta 6;


data 1    /* arranged according mop use */
          -do -27
          "0012"
          "0012"
          "0012"
          "1234"
          "4567"
          "-123"
          "123";

data 2     /* mops arranged in order */
          -do -26
          /* change table and mvzb */ 420020054060052053073033000 104
          060       /* ses es reset */
          124       /* mvza */
          060       /* ses es reset */
          050       /* enf for $ insert */
          064       /* ses es reset and bz set */
          164       /* mflc */
          200075    /* insb with = */
          060       /* ses es reset */
          220076    /* insa with " not used since es=0 */
          304       /* ign */
          324       /* mvc */
          024       /* insm */
          344       /* mses sn is set */
          364;     /* mors */


data 3    -do -32
          20206162545461625320205361627554646566672020202055616263616263;

page      -all;
 /*                  mve29

*         this test uses a sequence of micro op strings
*         that are appropriate for alpha numeric data.
*         each string is input to et such that it is
*         explained via a comment after each mop.
*         this particular mop sequence and the sending string is
*         used for all 6 and 9 bit tests with mod done
*         on descriptor access and data placement.
*
*/

inst      mve -nt "6-6  simple test with no mod"
          -mf3      rl 31;

desc 1    -ta 6    -ns 27;

desc 2         -ns 26;

desc 3    -ta 6;


data 1    /* arranged according mop use */
     000001020000010200000102010203040405060752010203010203;
data 2     /* mops arranged in order */
          /* change table and mvzb */ 420020054060052053073033000 104
          060       /* ses es reset */
          124       /* mvza */
          060       /* ses es reset */
          050       /* enf for $ insert */
          064       /* ses es reset and bz set */
          164       /* mflc */
          200075    /* insb with = */
          060       /* ses es reset */
          220076    /* insa with " not used since es=0 */
          304       /* ign */
          324       /* mvc */
          024       /* insm */
          344       /* mses sn is set */
          364;


data 3    20200102545401025320205301027554040506072020202052010203616263;

page      -all;
/*                  mve30

*         this test uses a sequence of micro op strings
*         that are appropriate for alpha numeric data.
*         each string is input to et such that it is
*         explained via a comment after each mop.
*         this particular mop sequence and the sending string is
*         used for all 6 and 9 bit tests with mod done
*         on descriptor access and data placement.
*
*/

inst      mve -nt "6-6 offset inst. and desc mod"     -io 2
          -mf1      ida ar
          -mf2      reg
          -mf3      rl 31;

desc 1      -ta 6    -ns 27;

desc 2         -ns 26;

desc 3    -ta 6;

data 1    /* arranged according mop use */
     000001020000010200000102010203040405060752010203010203;
data 2     /* mops arranged in order */
          /* change table and mvzb */ 420020054060052053073033000 104
          060       /* ses es reset */
          124       /* mvza */
          060       /* ses es reset */
          050       /* enf for $ insert */
          064       /* ses es reset and bz set */
          164       /* mflc */
          200075    /* insb with = */
          060       /* ses es reset */
          220076    /* insa with " not used since es=0 */
          304       /* ign */
          324       /* mvc */
          024       /* insm */
          344       /* mses sn is set */
          364;     /* mors */


data 3    20200102545401025320205301027554040506072020202052010203616263;
page      -all;

 /*                  mve31

*         this test uses a sequence of micro op strings
*         that are appropriate for alpha numeric data.
*         each string is input to et such that it is
*         explained via a comment after each mop.
*         this particular mop sequence and the sending string is
*         used for all 6 and 9 bit tests with mod done
*         on descriptor access and data placement.
*
*/

inst      mve -nt "6-6  desc mod d1 offset"     -io 2
          -mf1      ida ar
          -mf2      idb ar
          -mf3      rl 31;

desc 1      -ta 6    -ns 27;

desc 2         -ns 26;

desc 3    -ta 6;


data 1    /* arranged according mop use */
          -do -6
     000001020000010200000102010203040405060752010203010203;
data 2     /* mops arranged in order */
          /* change table and mvzb */ 420020054060052053073033000 104
          060       /* ses es reset */
          124       /* mvza */
          060       /* ses es reset */
          050       /* enf for $ insert */
          064       /* ses es reset and bz set */
          164       /* mflc */
          200075    /* insb with = */
          060       /* ses es reset */
          220076    /* insa with " not used since es=0 */
          304       /* ign */
          324       /* mvc */
          024       /* insm */
          344       /* mses sn is set */
          364;     /* mors */


data 3    20200102545401025320205301027554040506072020202052010203616263;

page      -all;


/*                  mve32

*         this test uses a sequence of micro op strings
*         that are appropriate for alpha numeric data.
*         each string is input to et such that it is
*         explained via a comment after each mop.
*         this particular mop sequence and the sending string is
*         used for all 6 and 9 bit tests with mod done
*         on descriptor access and data placement.
*
*/

inst      mve -nt "6-6  d2 offset d1 offset"     -io 2
          -mf1      ida ar
          -mf2      idb ar
          -mf3      rl 31;

desc 1      -ta 6    -ns 27;

desc 2         -ns 26;

desc 3    -ta 6;


data 1    /* arranged according mop use */
          -do -6
     000001020000010200000102010203040405060752010203010203;
data 2     /* mops arranged in order */
          -do -13
          /* change table and mvzb */ 420020054060052053073033000 104
          060       /* ses es reset */
          124       /* mvza */
          060       /* ses es reset */
          050       /* enf for $ insert */
          064       /* ses es reset and bz set */
          164       /* mflc */
          200075    /* insb with = */
          060       /* ses es reset */
          220076    /* insa with " not used since es=0 */
          304       /* ign */
          324       /* mvc */
          024       /* insm */
          344       /* mses sn is set */
          364;     /* mors */


data 3    20200102545401025320205301027554040506072020202052010203616263;

page      -all;
 /*                  mve33

*         this test uses a sequence of micro op strings
*         that are appropriate for alpha numeric data.
*         each string is input to et such that it is
*         explained via a comment after each mop.
*         this particular mop sequence and the sending string is
*         used for all 6 and 9 bit tests with mod done
*         on descriptor access and data placement.
*
*/

inst      mve -nt "6-6 d3 offset and d1 and d2"     -io 3
          -mf1      ida ar reg
          -mf2      idb ar
          -mf3      rl 31;

desc 1      -ta 6    -ns 27;

desc 2         -ns 26;

desc 3    -ta 6;


data 1    /* arranged according mop use */
          -do -6
     000001020000010200000102010203040405060752010203010203;
data 2     /* mops arranged in order */
          -do -13
          /* change table and mvzb */ 420020054060052053073033000 104
          060       /* ses es reset */
          124       /* mvza */
          060       /* ses es reset */
          050       /* enf for $ insert */
          064       /* ses es reset and bz set */
          164       /* mflc */
          200075    /* insb with = */
          060       /* ses es reset */
          220076    /* insa with " not used since es=0 */
          304       /* ign */
          324       /* mvc */
          024       /* insm */
          344       /* mses sn is set */
          364;     /* mors */


data 3    -do -28
          20200102545401025320205301027554040506072020202052010203616263;

page      -all;

/*                  mve34

*         this test uses a sequence of micro op strings
*         that are appropriate for alpha numeric data.
*         each string is input to et such that it is
*         explained via a comment after each mop.
*         this particular mop sequence and the sending string is
*         used for all 6 and 9 bit tests with mod done
*         on descriptor access and data placement.
*
*/

inst      mve -nt "6-6 data 1 totally on p0"     -io 3
          -mf1      ida ar reg rl 27
          -mf2      idb ar
          -mf3      ar reg rl 31;


desc 1    -ta 6;
desc 2         -ns 26;

desc 3    -ta 6;


data 1    /* arranged according mop use */
          -do -28
     000001020000010200000102010203040405060752010203010203;
data 2     /* mops arranged in order */
          -do -13
          /* change table and mvzb */ 420020054060052053073033000 104
          060       /* ses es reset */
          124       /* mvza */
          060       /* ses es reset */
          050       /* enf for $ insert */
          064       /* ses es reset and bz set */
          164       /* mflc */
          200075    /* insb with = */
          060       /* ses es reset */
          220076    /* insa with " not used since es=0 */
          304       /* ign */
          324       /* mvc */
          024       /* insm */
          344       /* mses sn is set */
          364;     /* mors */


data 3    -do 30
          20200102545401025320205301027554040506072020202052010203616263;

page      -all;
 /*                  mve35

*         this test uses a sequence of micro op strings
*         that are appropriate for alpha numeric data.
*         each string is input to et such that it is
*         explained via a comment after each mop.
*         this particular mop sequence and the sending string is
*         used for all 6 and 9 bit tests with mod done
*         on descriptor access and data placement.
*
*/

inst      mve -nt "6-6 data 2 totally on p0"     -io 3
          -mf1      ida ar reg rl 27
          -mf2      idb ar rl 26
          -mf3      ar reg rl 31;


desc 1    -ta 6;

desc 3    -ta 6;


data 1    /* arranged according mop use */
          -do -28
     000001020000010200000102010203040405060752010203010203;
data 2     /* mops arranged in order */
          -do -26
          /* change table and mvzb */ 420020054060052053073033000 104
          060       /* ses es reset */
          124       /* mvza */
          060       /* ses es reset */
          050       /* enf for $ insert */
          064       /* ses es reset and bz set */
          164       /* mflc */
          200075    /* insb with = */
          060       /* ses es reset */
          220076    /* insa with " not used since es=0 */
          304       /* ign */
          324       /* mvc */
          024       /* insm */
          344       /* mses sn is set */
          364;     /* mors */


data 3    -do -12
          20200102545401025320205301027554040506072020202052010203616263;

page      -all;
 /*                  mve36

*         this test uses a sequence of micro op strings
*         that are appropriate for alpha numeric data.
*         each string is input to et such that it is
*         explained via a comment after each mop.
*         this particular mop sequence and the sending string is
*         used for all 6 and 9 bit tests with mod done
*         on descriptor access and data placement.
*
*/

inst      mve -nt "6-6 all data totally on p0"     
          -mf1      ida ar reg rl 27
          -mf2      idb ar rl 26
          -mf3      ar reg rl 31;

desc 1    -ta 6;

desc 3    -ta 6;


data 1    /* arranged according mop use */
          -do -28
     000001020000010200000102010203040405060752010203010203;
data 2     /* mops arranged in order */
          -do -26
          /* change table and mvzb */ 420020054060052053073033000 104
          060       /* ses es reset */
          124       /* mvza */
          060       /* ses es reset */
          050       /* enf for $ insert */
          064       /* ses es reset and bz set */
          164       /* mflc */
          200075    /* insb with = */
          060       /* ses es reset */
          220076    /* insa with " not used since es=0 */
          304       /* ign */
          324       /* mvc */
          024       /* insm */
          344       /* mses sn is set */
          364;     /* mors */


data 3    -do -32
          20200102545401025320205301027554040506072020202052010203616263;

page      -all;
 /*                  mve37

*         this test uses a sequence of micro op strings
*         that are appropriate for alpha numeric data.
*         each string is input to et such that it is
*         explained via a comment after each mop.
*         this particular mop sequence and the sending string is
*         used for all 6 and 9 bit tests with mod done
*         on descriptor access and data placement.
*
*/

inst      mve -nt "6-6 all data  on p0 all mod"     -io 3
          -mf1      idb ar reg rl 27
          -mf2      idb ar reg rl 26
          -mf3      ar reg rl 31;

desc 1     -ta 6;

desc 3    -ta 6;


data 1    /* arranged according mop use */
          -do -28
     000001020000010200000102010203040405060752010203010203;
data 2     /* mops arranged in order */
          -do -26
          /* change table and mvzb */ 420020054060052053073033000 104
          060       /* ses es reset */
          124       /* mvza */
          060       /* ses es reset */
          050       /* enf for $ insert */
          064       /* ses es reset and bz set */
          164       /* mflc */
          200075    /* insb with = */
          060       /* ses es reset */
          220076    /* insa with " not used since es=0 */
          304       /* ign */
          324       /* mvc */
          024       /* insm */
          344       /* mses sn is set */
          364;     /* mors */


data 3    -do -32
          20200102545401025320205301027554040506072020202052010203616263;

page      -all;


/*		tct1
*
*	Out table will be indexed by the characters  "abcde".   "b" & "e" are the two
*	non zero entries.  Start off with a simple test
*/

inst	tct	-nt "Simple test";

desc 1	-ns 4;

data 1	"aceb";

data 2	(97) "*"		/* These characters should never be referenced. */
	000		/* "a" */
	"b"
	000		/* "c" */
	"d"
	000 ;		/* "e" */

data 3	"b" 000 000 003;

page	-all;
/*		tct2
*
*	Same as  tct1  only we will move the data fields across page boundaries and
*	add modification.
*/

inst	tct	-nt  "Same as prev - fields X pg bound"	-io 3
	-mf1	rl  4	ar reg idb
	-mf2	ar reg		/* RL and ID mod NOT allowed for descriptors 2 & 3. */

	-mf3	reg ar;

data 1	-do -3	"aceb";

data 2	-do -100	(97) "*"		/* These characters should never be referenced. */
	000		/* "a" */
	"b"
	000		/* "c" */
	"d"
	000 ;		/* "e" */

data 3	"b" 000 000 003;

page	-all;
/*		tct3
*
*	Same as  tct2  except  string 1 will be changed  so we will have a
*	tally runout.
*/


inst	tct	-nt  "Test tally runout"	-io 2
	-ir	tr
	-mf1	ar idb reg rl 18
	-mf2	ar reg
	-mf3	ar reg;

data 1	-do -9 	(6) "ace";

data 2	-do -100
	(97) "*" 000 "b" 000 "d" 000;

data 3	000 000 000 022;


page	-all;
/*		tct4
*
*	Test using  6  bit characters.  The  -cn  field will specify that the string
*	starts at the  5th  character of the word (last character).
*/

inst	tct	-nt  "Use 6 bit characters"	-io 1
	-mf1	idb reg ar
	-mf2	reg ar
	-mf3	ar reg;

desc 1	-ns  10	-cn 5	-ta 6;

data 1	-do  -6		/* Test string is  0 1 2 3 4 5 6 7 10 11  */
	0606060606	/* Filler, not part of string, 1st 5 characters of word. */
	010203		/* Page boundary. */
	040506 071011;

data 2	-do -4
	000 000 000 000
	000 000 006 000 000 000;

data 3	-do 4	006 000000 006;


page	-all;
/*		tct5
*
*	The indexes in string 1 will be  4  bit characters.
*/

inst	tct	-nt  "Use 4 bit characters"	-io 2
	-mf1	idb ar reg
	-mf2	ar reg
	-mf3	ar reg;


desc 1	-ns 8
	-ta 4	/* 4 bit characters. */
	-cn 2;	/* First 2 characters of word not used.
		*  This is the first 9 bit character.  */

data 1	-do -2
	000		/* The first two characters of the word - skipped. */
	001		/* Characters "0" and "1".  In page 1. */
	043 105 147;	/* "234567" (4 bit)  in page 2. */

data 2	-do -4
	000 000 000 000	/* All in page 1.  Represent index values 0,1,2,3 */
	000 "*" 000 000;	/* In page 2. Correspond to index values 4,5,6,7  */

data 3	"*" 000 000 005;


page	-all;


/*   tct 6
*
*  Test loading across three pages.  One character loaded from
*  page 1 and 3.  Test 6146 characters.  Tally runout indicator
*  is set.
*/

inst  tct  -nt  "(6 bit)no modif. tally is set"
           -io 1
           -ir tr
           -mf1 rl 6146 ;

desc 1  -cn 5 -ta 6 ;

data 1  -do -4 "   " 000 (128) 010203040506071011121314151617202122232425262700
                000102030405
                (128) 000102030405060710111213141516172021222324252627 ;

data 2  -do -4  (24) 000 000 141 ;

data 3          000 000 014 002 ;

page    -all ;

/*   tct 7
*
*  Test loading data across three pages.  One character is loaded
*  from page 1 and 3 with 6146 characters tested.  A nonzero
*  character is found in the test table.
*/

inst  tct  -nt  "(6 bit)no mod. a nonzero entry"
           -mf1 rl 6146 ;

desc 1  -cn 5 -ta 6 ;

data 1  -do -4 "   " 000 (128) 010203040506071011121314151617202122232425262700
               310102030405
                (128) 000102030405060710111213141516172021222324252627 ;

data 2  -do -4  (24) 000 000 141 ;

data 3          141 000 006 001 ;

page    -all ;


/*   tct 8
*
*  Test similiar to tct 6.  Test ar, reg, and rl for descriptor 1.
*
*/

inst  tct  -nt  "(6 bit)ar,reg,rl. tally runout"
           -io 2
           -ir tr
           -mf1 ar reg rl 6146 ;

desc 1  -cn 5 -ta 6 ;

data 1  -do -4 "   " 000 (128) 010203040506071011121314151617202122232425262700
                000102030405
                (128) 000102030405060710111213141516172021222324252627 ;

data 2  -do -4  (24) 000 000 141 ;

data 3          000 000 014 002 ;

page    -all ;


/*   tct 9
*
*  Test similiar to tct 7.  Test ar, reg, and rl modification
*  for descriptor 1.  Test ar and reg modification for descriptor 1 and 2.
*
*/

inst  tct  -nt  "(6 bit)ar,reg,rl.no tally runout"
           -io 1
           -mf1 ar reg rl 6146
           -mf2 ar reg
           -mf3 ar reg ;

desc 1  -cn 5 -ta 6 ;

data 1  -do -4 "   " 000 (128) 010203040506071011121314151617202122232425262700
               310102030405
               (128) 000102030405060710111213141516172021222324252627 ;

data 2  -do -4  (24) 000 000 141 ;

data 3          141 000 006 001 ;

page    -all ;


/*   tct 10
*
*  Test similiar to tct 6.  Test indirect referencing
*  of descriptor 1.  Test ar and reg modification for descriptors 2 and 3.
*/

inst  tct  -nt  "(6 bit)test id. tally runout"
           -ir tr
           -mf1 id rl 6146
           -mf2 ar reg
           -mf3 ar reg ;

desc 1  -cn 5 -ta 6 ;

data 1  -do -4 "   " 000 (128) 010203040506071011121314151617202122232425262700
                000102030405
                (128) 000102030405060710111213141516172021222324252627 ;

data 2  -do -4  (24) 000 000 141 ;

data 3          000 000 014 002 ;

page    -all ;


/*   tct 11
*
*  Test similiar to tct 7.  Test indirect referencing of
*  descriptor 1.
*
*/

inst  tct  -nt  "(6 bit)test id. no tally runout"
           -io 2
           -mf1 id rl 6146 ;

desc 1  -cn 5 -ta 6 ;

data 1  -do -4 "   " 000 (128) 010203040506071011121314151617202122232425262700
               310102030405
               (128) 000102030405060710111213141516172021222324252627 ;

data 2  -do -4  (24) 000 000 141 ;

data 3          141 000 006 001 ;

page    -all ;


/*   tct 12
*
*  Test similiar to tct 6.  Test indirect referencing of descriptor 1
*  with ar modification of the indirect word.  Also test reg
*  modification of descriptors 2 and 3.
*
*/

inst  tct  -nt  "(6 bit)test ida. tally runout"
           -io 1
           -ir tr
           -mf1 ida rl 6146
           -mf2 reg
           -mf3 reg ;

desc 1  -cn 5 -ta 6 ;

data 1  -do -4 "   " 000 (128) 010203040506071011121314151617202122232425262700
                000102030405
                (128) 000102030405060710111213141516172021222324252627 ;

data 2  -do -4  (24) 000 000 141 ;

data 3          000 000 014 002 ;

page    -all ;


/*   tct 13
*
*  Test similiar to tct 7.  Test indirect referencing of descriptor 1
*  with ar modification of the indirect word.  Also test ar
*  modification of descriptors 2 and 3.
*
*/

inst  tct  -nt  "(6 bit)test ida. no tally runout"
           -mf1 ida rl 6146
           -mf2 ar
           -mf3 ar ;

desc 1  -cn 5 -ta 6 ;

data 1  -do -4 "   " 000 (128) 010203040506071011121314151617202122232425262700
               310102030405
               (128) 000102030405060710111213141516172021222324252627 ;

data 2  -do -4  (24) 000 000 141 ;

data 3          141 000 006 001 ;

page    -all ;


/*   tct 14
*
*  Test similiar to tct 6.  Test indirect referencing of decriptor 1
*  with ar and reg modification of the indirect word.
*
*/

inst  tct  -nt  "(6 bit)test idb. tally runout"
           -io 2
           -ir tr
           -mf1 idb rl 6146 ;

desc 1  -cn 5 -ta 6 ;

data 1  -do -4 "   " 000 (128) 010203040506071011121314151617202122232425262700
                000102030405
                (128) 000102030405060710111213141516172021222324252627 ;

data 2  -do -4  (24) 000 000 141 ;

data 3          000 000 014 002 ;

page    -all ;


/*   tct 15
*
*  Test similiar to tct 7.  Test indirect referencing of descriptor 1
*  with ar and reg modification of the indirect word.
*
*/

inst  tct  -nt  "(6 bit)test idb. no tally runout"
           -mf1 idb rl 6146 ;

desc 1  -cn 5 -ta 6 ;

data 1  -do -4 "   " 000 (128) 010203040506071011121314151617202122232425262700
               310102030405
               (128) 000102030405060710111213141516172021222324252627 ;

data 2  -do -4  (24) 000 000 141 ;

data 3          141 000 006 001 ;

page    -all ;


/*   tct 16
*
*  Test similiar to tct 6.  Test indirect referencing of descriptor 1
*  with ar and reg modification of the indirect word.  Further the
*  descriptor has ar, reg, and rl modification.
*
*/

inst  tct  -nt  "(6 bit)idb,ar,reg. tally runout"
           -io 1
           -ir tr
           -mf1 idb ar reg rl 6146 ;

desc 1  -cn 5 -ta 6 ;

data 1  -do -4 "   " 000 (128) 010203040506071011121314151617202122232425262700
                000102030405
                (128) 000102030405060710111213141516172021222324252627 ;

data 2  -do -4  (24) 000 000 141 ;

data 3          000 000 014 002 ;

page    -all ;


/*   tct 17
*
*  Test similiar to tct 7.  Test indirect referencing of descriptor 1
*  with ar and reg modification of the indirect word.  Further the
*  descriptor has ar, reg, and rl modification.
*
*/

inst  tct  -nt  "(6bit)idb,ar,reg.no tally runout"
           -io 2
           -mf1 idb ar reg rl 6146 ;

desc 1  -cn 5 -ta 6 ;

data 1  -do -4 "   " 000 (128) 010203040506071011121314151617202122232425262700
               310102030405
               (128) 000102030405060710111213141516172021222324252627 ;

data 2  -do -4  (24) 000 000 141 ;

data 3          141 000 006 001 ;

page    -all ;

/*   tct 18
*
*  Test for character match on the first character of page 3.
*  Also, test idb, ar, reg, and rl of descriptor 1.  Also, test
*  ar and reg modification of descriptors 2 and 3.
*
*/

inst  tct  -nt  "(6 bit)match 1st char of page 3"
           -io 1
           -mf1 idb ar reg rl 6146
           -mf2 reg ar
           -mf3 reg ar ;

desc 1  -cn 5 -ta 6 ;

data 1  -do -4 "   " 000 (128) 010203040506071011121314151617202122232425262700
                (128) 000102030405060710111213141516172021222324252627 
                31  ;

data 2  -do -4  (24) 000 000 141 ;

data 3          141 000 014 001 ;

page    -all ;


/*   tct 19
*
*  Test for character match on the last character of page 1.
*  Also, test idb, ar, reg, and rl of descriptor 1.  Also, test
*  ar and reg modification of descriptors 2 and 3.
*
*/

inst  tct  -nt  "(6 bit)match last char of page 1"
           -io 1
           -mf1 idb ar reg rl 6146
           -mf2 reg ar
           -mf3 reg ar ;

desc 1  -cn 5 -ta 6 ;

data 1  -do -4 "   " 031 (128) 010203040506071011121314151617202122232425262700
                (128) 000102030405060710111213141516172021222324252627 
                00  ;

data 2  -do -4  (24) 000 000 141 ;

data 3          141 000 000 000 ;

page    -all ;


/*		tctr1
*
*	Out table will be indexed by the characters  "abcde".   "b" & "e" are the two
*	non zero entries.  Start off with a simple test
*/

inst	tctr	-nt "Simple test";

desc 1	-ns 4;

data 1	"bace";

data 2	(97) "*"		/* These characters should never be referenced. */
	000		/* "a" */
	"b"
	000		/* "c" */
	"d"
	000 ;		/* "e" */

data 3	"b" 000 000 003;

page	-all;
/*		tctr2
*
*	Same as  tctr1  only we will move the data fields across page boundaries and
*	add modification.
*/

inst	tctr	-nt  "Same as prev - fields X pg bound"	-io 3
	-mf1	rl  4	ar reg idb
	-mf2	ar reg		/* RL and ID mod NOT allowed for descriptors 2 & 3. */

	-mf3	reg ar;

data 1	-do -3	"bace";

data 2	-do -100	(97) "*"		/* These characters should never be referenced. */
	000		/* "a" */
	"b"
	000		/* "c" */
	"d"
	000 ;		/* "e" */

data 3	"b" 000 000 003;

page	-all;
/*		tctr3
*
*	Same as  tctr2  except  string 1 will be changed  so we will have a
*	tally runout.
*/


inst	tctr	-nt  "Test tally runout"	-io 2
	-ir	tr
	-mf1	ar idb reg rl 18
	-mf2	ar reg
	-mf3	ar reg;

data 1	-do -9 	(6) "ace";

data 2	-do -100
	(97) "*" 000 "b" 000 "d" 000;

data 3	000 000 000 022;


page	-all;
/*		tctr4
*
*	Test using  6  bit characters.  The  -cn  field will specify that the string
*	starts at the  5th  character of the word (last character).
*/

inst	tctr	-nt  "Use 6 bit characters"	-io 1
	-mf1	idb reg ar
	-mf2	reg ar
	-mf3	ar reg;

desc 1	-ns  10	-cn 5	-ta 6;

data 1	-do  -6		/* Test string is  0 1 2 3 4 5 6 7 10 11  */
	0606060606	/* Filler, not part of string, 1st 5 characters of word. */
	010203		/* Page boundary. */
	040506 071011;

data 2	-do -4
	000 000 000 000
	000 000 006 000 000 000;

data 3	-do 4	006 000000 003;


page	-all;
/*		tctr5
*
*	The indexes in string 1 will be  4  bit characters.
*/

inst	tctr	-nt  "Use 4 bit characters"	-io 2
	-mf1	idb ar reg
	-mf2	ar reg
	-mf3	ar reg;


desc 1	-ns 8
	-ta 4	/* 4 bit characters. */
	-cn 2;	/* First 2 characters of word not used.
		*  This is the first 9 bit character.  */

data 1	-do -2
	000		/* The first two characters of the word - skipped. */
	001		/* Characters "0" and "1".  In page 1. */
	043 105 147;	/* "234567" (4 bit)  in page 2. */

data 2	-do -4
	000 000 000 000	/* All in page 1.  Represent index values 0,1,2,3 */
	000 "*" 000 000;	/* In page 2. Correspond to index values 4,5,6,7  */

data 3	"*" 000 000 002;


page	-all;


/*   tctr 6
*
*  Test loading across three pages.  One character loaded from
*  page 1 and 3.  Test 6146 characters.  Tally runout indicator
*  is set.
*/

inst  tctr  -nt  "(6bit)no modif. tally is set"
           -io 1
           -ir tr
           -mf1 rl 6146 ;

desc 1  -cn 5 -ta 6 ;

data 1  -do -4 "   " 000 (128) 010203040506071011121314151617202122232425262700
                000102030405
                (128) 000102030405060710111213141516172021222324252627 ;

data 2  -do -4  (24) 000 000 141 ;

data 3          000 000 014 002 ;

page    -all ;

/*   tctr 7
*
*  Test loading data across three pages.  One character is loaded
*  from page 1 and 3 with 6146 characters tested.  A nonzero
*  character is found in the test table.
*/

inst  tctr  -nt  "(6bit)no modif. a nonzero entry"
           -mf1 rl 6146 ;

desc 1  -cn 5 -ta 6 ;

data 1  -do -4 "   " 000 (128) 010203040506071011121314151617202122232425262700
               310102030405
                (128) 000102030405060710111213141516172021222324252627 ;

data 2  -do -4  (24) 000 000 141 ;

data 3          141 000 006 000 ;

page    -all ;


/*   tctr 8
*
*  Test similiar to tctr 6.  Test ar, reg, and rl for descriptor 1.
*
*/

inst  tctr  -nt  "(6bit)ar,reg,rl. tally runout"
           -io 2
           -ir tr
           -mf1 ar reg rl 6146 ;

desc 1  -cn 5 -ta 6 ;

data 1  -do -4 "   " 000 (128) 010203040506071011121314151617202122232425262700
                000102030405
                (128) 000102030405060710111213141516172021222324252627 ;

data 2  -do -4  (24) 000 000 141 ;

data 3          000 000 014 002 ;

page    -all ;


/*   tctr 9
*
*  Test similiar to tctr 7.  Test ar, reg, and rl modification
*  for descriptor 1.  Test ar and reg modification for descriptor 1 and 2.
*
*/

inst  tctr  -nt  "(6bit)ar,reg,rl. no tally runout"
           -io 1
           -mf1 ar reg rl 6146
           -mf2 ar reg
           -mf3 ar reg ;

desc 1  -cn 5 -ta 6 ;

data 1  -do -4 "   " 000 (128) 010203040506071011121314151617202122232425262700
               310102030405
               (128) 000102030405060710111213141516172021222324252627 ;

data 2  -do -4  (24) 000 000 141 ;

data 3          141 000 006 000 ;

page    -all ;


/*   tctr 10
*
*  Test similiar to tctr 6.  Test indirect referencing
*  of descriptor 1.  Test ar and reg modification for descriptors 2 and 3.
*/

inst  tctr  -nt  "(6bit)test id. tally runout"
           -ir tr
           -mf1 id rl 6146
           -mf2 ar reg
           -mf3 ar reg ;

desc 1  -cn 5 -ta 6 ;

data 1  -do -4 "   " 000 (128) 010203040506071011121314151617202122232425262700
                000102030405
                (128) 000102030405060710111213141516172021222324252627 ;

data 2  -do -4  (24) 000 000 141 ;

data 3          000 000 014 002 ;

page    -all ;


/*   tctr 11
*
*  Test similiar to tctr 7.  Test indirect referencing of
*  descriptor 1.
*
*/

inst  tctr  -nt  "(6bit)test id. no tally runout"
           -io 2
           -mf1 id rl 6146 ;

desc 1  -cn 5 -ta 6 ;

data 1  -do -4 "   " 000 (128) 010203040506071011121314151617202122232425262700
               310102030405
               (128) 000102030405060710111213141516172021222324252627 ;

data 2  -do -4  (24) 000 000 141 ;

data 3          141 000 006 000 ;

page    -all ;


/*   tctr 12
*
*  Test similiar to tctr 6.  Test indirect referencing of descriptor 1
*  with ar modification of the indirect word.  Also test reg
*  modification of descriptors 2 and 3.
*
*/

inst  tctr  -nt  "(6bit)test ida. tally runout"
           -io 1
           -ir tr
           -mf1 ida rl 6146
           -mf2 reg
           -mf3 reg ;

desc 1  -cn 5 -ta 6 ;

data 1  -do -4 "   " 000 (128) 010203040506071011121314151617202122232425262700
                000102030405
                (128) 000102030405060710111213141516172021222324252627 ;

data 2  -do -4  (24) 000 000 141 ;

data 3          000 000 014 002 ;

page    -all ;


/*   tctr 13
*
*  Test similiar to tctr 7.  Test indirect referencing of descriptor 1
*  with ar modification of the indirect word.  Also test ar
*  modification of descriptors 2 and 3.
*
*/

inst  tctr  -nt  "(6bit)test ida. no tally runout"
           -mf1 ida rl 6146
           -mf2 ar
           -mf3 ar ;

desc 1  -cn 5 -ta 6 ;

data 1  -do -4 "   " 000 (128) 010203040506071011121314151617202122232425262700
               310102030405
               (128) 000102030405060710111213141516172021222324252627 ;

data 2  -do -4  (24) 000 000 141 ;

data 3          141 000 006 000 ;

page    -all ;


/*   tctr 14
*
*  Test similiar to tctr 6.  Test indirect referencing of decriptor 1
*  with ar and reg modification of the indirect word.
*
*/

inst  tctr  -nt  "(6bit)test idb. tally runout"
           -io 2
           -ir tr
           -mf1 idb rl 6146 ;

desc 1  -cn 5 -ta 6 ;

data 1  -do -4 "   " 000 (128) 010203040506071011121314151617202122232425262700
                000102030405
                (128) 000102030405060710111213141516172021222324252627 ;

data 2  -do -4  (24) 000 000 141 ;

data 3          000 000 014 002 ;

page    -all ;


/*   tctr 15
*
*  Test similiar to tctr 7.  Test indirect referencing of descriptor 1
*  with ar and reg modification of the indirect word.
*
*/

inst  tctr  -nt  "(6bit)test idb. no tally runout"
           -mf1 idb rl 6146 ;

desc 1  -cn 5 -ta 6 ;

data 1  -do -4 "   " 000 (128) 010203040506071011121314151617202122232425262700
               310102030405
               (128) 000102030405060710111213141516172021222324252627 ;

data 2  -do -4  (24) 000 000 141 ;

data 3          141 000 006 000 ;

page    -all ;


/*   tctr 16
*
*  Test similiar to tctr 6.  Test indirect referencing of descriptor 1
*  with ar and reg modification of the indirect word.  Further the
*  descriptor has ar, reg, and rl modification.
*
*/

inst  tctr  -nt  "(6bit)idb,ar,reg. tally runout"
           -io 1
           -ir tr
           -mf1 idb ar reg rl 6146 ;

desc 1  -cn 5 -ta 6 ;

data 1  -do -4 "   " 000 (128) 010203040506071011121314151617202122232425262700
                000102030405
                (128) 000102030405060710111213141516172021222324252627 ;

data 2  -do -4  (24) 000 000 141 ;

data 3          000 000 014 002 ;

page    -all ;


/*   tctr 17
*
*  Test similiar to tctr 7.  Test indirect referencing of descriptor 1
*  with ar and reg modification of the indirect word.  Further the
*  descriptor has ar, reg, and rl modification.
*
*/

inst  tctr  -nt  "(6bit)idb,ar,reg.no tally runout"
           -io 2
           -mf1 idb ar reg rl 6146 ;

desc 1  -cn 5 -ta 6 ;

data 1  -do -4 "   " 000 (128) 010203040506071011121314151617202122232425262700
               310102030405
               (128) 000102030405060710111213141516172021222324252627 ;

data 2  -do -4  (24) 000 000 141 ;

data 3          141 000 006 000 ;

page    -all ;

/*   tctr 18
*
*  Test for character match on the first character of page 3.
*  Also, test idb, ar, reg, and rl of descriptor 1.  Also, test
*  ar and reg modification of descriptors 2 and 3.
*
*/

inst  tctr  -nt  "(6bit)match 1st char of page 3"
           -io 1
           -mf1 idb ar reg rl 6146
           -mf2 reg ar
           -mf3 reg ar ;

desc 1  -cn 5 -ta 6 ;

data 1  -do -4 "   " 000 (128) 010203040506071011121314151617202122232425262700
                (128) 000102030405060710111213141516172021222324252627 
                31  ;

data 2  -do -4  (24) 000 000 141 ;

data 3          141 000 000 000 ;

page    -all ;


/*   tctr 19
*
*  Test for character match on the last character of page 1.
*  Also, test idb, ar, reg, and rl of descriptor 1.  Also, test
*  ar and reg modification of descriptors 2 and 3.
*
*/

inst  tctr  -nt  "(6bit)match last char of page 1"
           -io 1
           -mf1 idb ar reg rl 6146
           -mf2 reg ar
           -mf3 reg ar ;

desc 1  -cn 5 -ta 6 ;

data 1  -do -4 "   " 031 (128) 010203040506071011121314151617202122232425262700
                (128) 000102030405060710111213141516172021222324252627 
                00  ;

data 2  -do -4  (24) 000 000 141 ;

data 3          141 000 014 001 ;

page    -all ;


/*		scm1
*
*	No match found in data 1 field so  tally runout indicator will be  ON.
*	CN field used in descriptor 1 and its data will cross a page boundary.
*/

inst	scm	-nt  "Tally runout"	-io 3
	-mc		/* Mask =  (007) octal.  */
	-ir	tr
	-mf1	ida
	-mf2	ar
	-mf3	ar reg;


desc 1	-ns 3	-cn 3	-ta 9;

desc 2	-ns 4	-cn 1;


data 1	-do -4
	000 000 000		/* Fill due to  cn 3.  */
	011			/* Part of string on page 1. */
	021 031;			/* Part of string on page 2. */

data 2	-do -1	   000  001;

data 3	000 000 000 003;

page	-all;
/*                   scm2

*         simple test to determine if instruction
*         is working correctly.  data is 9 bit
*         written in octal format to allow easy
*         comparison with the mask.  this test
*         accesses all descriptors directly.
*
*/

inst     scm     -nt "mc 8 9bit" 
         -mc8;

desc 1     -ns 8          -ta 9;

data 1    060061062063064065066067;

data 2    047;

data 3    000 000 000 007;

page      -all;


/*                  scm3

*         same data as test 2 but with data 1
*         split across page boundary.  indirect
*         mod on desc 1 and 2.
*
*/

inst      scm       -io 1     -nt "d1 split mc 8 9bit"
          -mc8
          -mf1      idb
          -mf2      idb;

desc 1    -ns 8     -ta 9;

data 1    -do -4    060061062063 064065066067;

data 2    047;

data 3    000 000 000 007;

page      -all;

/*                  scm4

*         same data config as test 2 but with
*         full desc mod.
*
*/

inst      scm       -io 3     -nt "d1 split mc8 9bit"
          -mc8
          -mf1      idb ar reg rl 8
          -mf2      idb ar reg
          -mf3       ar reg;

desc 1    -ta 9;

data 1    060061062063064065066067;

data 2    047;

data 3    000 000 000 007;

page      -all;


/*                  scm5

*         test of the -cn option for desc 1 and 2
*         along with a varied of """mode of desc mod.
*         both data strings are split across page bound.
*
*/

inst      scm       -io 2       -nt "mc8 no match 9bit"
       -ir     tr
          -mc8
          -mf1      idb ar reg rl 6
          -mf2      ar
          -mf3      ar;

desc 1    -ta 9;

desc 2    -cn 3;

data 1    -do -2    000000 060061062063064066;

data 2    -do -1    000 000 000 047;

data 3    000 000 000 006  /* no match */;

page      -all;


/*                  scm6

*         data 1 wholey contained on page 0 and
*         data  starting on word 0 of page 1; char 0.
*         all desc mod.
*
*/

inst      scm       -io 1      -nt "mc8 d1 on p0 9bit"
          -mc8
          -mf1      idb ar reg
          -mf2      idb ar reg
          -mf3       ar reg;

desc 1    -ta 9     -ns 2          -cn 2;

data 1    -do  -4   000000060067;

data 2    047;

data 3    000 000 000 001;

page      -all;


/*                  scm7

*         a variety of desc mod are used~ and the mask
*         is set so that there is no match.  using the
*         using the same data as test 6.
*
*/

inst      scm       -io 3     -nt "mc777 no match 9 bit"
	-mc�
                /*  mc = 777 */
          -mf1      idr ar rl 2
          -mf2      ar reg
          -mf3      ar;

desc 1    -ta 9     -cn 2;

data 1    -do -4    000000060067;

data 2    047;

data 3    000 000 000 000;

page      -all;


/*                  scm 8

*          the next four tests use the maximum amount of
*         data for string 1 to test the paging of the data
*         strings.  this test will make sure the inst is operating
*         correctly using no desc mod.
*
*/

inst      scm     -nt "d1 covers 3pp 9bit"
          -mc     /*    mc = 001  */
               /* mc = 001 */
          -mf1      rl 4352
          /* no desc mod.--all direct */;

desc 1    -ta 9          ;

data 1    -do -128  (4351) 062 066;

data 2    067;

data 3    000 000 010 377;

page      -all;


/*                   scm9

*         uses same data setup as test 8 but applies
*         maximum mod to descriptors.
*
*/

inst      scm       -io 3      -nt "d1 covers 3 pp max desc mod 9b"
          -mc     /*    mc = 001  */
          -mf1      idb ar reg rl 4352
          -mf2      idb ar reg
          -mf3       ar reg;

desc 1    -ta 9;

data 1    -do -128  (4351) 062 066;

data 2    067;

data 3    000 000 010 377;

page      -all;


/*                  scm10

*         this test specifically tests the -cn option
**        for data 2 along with forcing it to cross
*         a page boundary.  all desc mods are taken.
*
*/


inst      scm       -io 1      -nt "d1 covers 3pp d2 split 9b"
          -mc     /*    mc = 001  */
          -mf1      idb ar reg rl 4352
          -mf2      idb ar reg
          -mf3       ar reg;

desc 1    -ta 9;

desc 2    -cn 1;

data 1     -do -128       (4351) 062 066;

data 2    -do -2         000067 000000;

data 3    000 000 010 377;

page      -all;


/*                  scm11

*         there will be no match on this test.  also,
*         a variety of desc mods are taken.  note
*         tr indicator will be on.
*
*/

inst      scm       -io 1      -nt "no match d1 covers 3pp 9bit"
          -mc     /*    mc = 001  */
          -ir       tr
          -mf1      idb rl 4352
          -mf2      ar reg
          /* mf3 is direct */;

desc 1    -ta 9; 

desc 2    -cn 1;

data 1    -do -128  (4352) 062;

data 2    -do -2    000067 000000;

data 3    000 000 010 400;

page      -all;
    /*               scm12

*          this starts the sequence of seven
*          four bit data tests.  this first
*          test makes sure that the inst is working
*          correctly without any desc. mod.
*
*/

inst       scm    -nt "simple test 4 bit"
           -mc     /*    mc = 001  */
               /* mc = 001 */
           /*  all the desc. are direct */;

desc 1     -ta 4      -ns 8;


data 1    237 323 070 361  /* 1001 1111 1101 0011 0011 1000 1111 00001 */;

data 2     360    /* 1111 */;


data 3     000 000 000 001;

page       -all;


/*                    scm13

*          same as previous test but taking all of the
*          possible desc. mod.
*
*/

inst       scm        -io 1      -nt " full desc mod 4bit"
           -mc     /*    mc = 001  */
                  /* mc = 001 */
           -mf1       idb ar reg rl 8
           -mf2       idb ar reg
           -mf3       ar reg;

desc 1     -ta 4;

data 1     237 323 070 361;

data 2     360;

data 3     000 000 000 001;

page      -all;


/*                    scm14

*          changing the mask characters and offsetting
*          the first data string across a page boundary
*          with a variety of desc. mod.
*
*/

inst       scm        -io 3    -nt "d1 split 4 bit"
           -mc?
           -mf1       ar
           -mf2       idb
           /* mf3 is direct */;

desc 1     -ta 4      -ns 8;

data 1     -do -2      237 323 /* page bound */ 070 361;

data 2                              360;

data 3     000 000 000 000;

page       -all;


/*                     scm15

*          again using the same data but this time splitting
*          both strings across page bound. and exercising
*          the -cn option.  all desc. mod. are taken.
*
*/

inst       scm         -io 1     -nt "d1 and d2 split 4 bit"
           -mc?
           -mf1        idb ar reg
           -mf2        idb ar reg
           -mf3       ar reg;

desc 1     -ta 4       -ns 6         -cn 1;

desc 2     -cn 3;

data 1     -do -2      237 323  /* page boun. */  070 361;

data 2     -do  -3    000 000 360  /* page bound. */  000;

data 3       000 000 000 000;

page       -all;


/*                     scm16

*          this time there will be no match with
*          the same parameters as test 15 with a mask of
*         777.
*
*/

inst       scm         -io 2   -nt "match on first char 4bit"
         -mc�
           -mf1        idb ar reg
           -mf2        idb ar reg
           -mf3       ar reg;

desc 1     -ta 4       -ns 8        -cn 1;

desc 2     -cn 3;

data 1     -do -2      237 323 070 361;

data 2     -do -3      000 000 360 000;

data 3     000 000 000 000;

page       -all;


/*                     scm17

*          the next three tests use the maximum amount
*          of data for string 1.  this test uses a mask
*          of 000 but searches for a char which will not
*          match ( tr ind).  no desc. mod.
*
*/

inst       scm    -nt "mc=000 no mat d1 covers 3pp 4b"
           -mc    /*   mc = 000  */
           -ir   tr
           -mf1        rl 8704
           /*  all desc. are direct */;

desc 1     -ta 4;

data 1     -do -128    (1088) 237323070361;

data 2     000;

data 3     000 000 021 000;

page       -all;


/*                     scm18

*          this test will force a match on a middle
*          char.  all desc mods. are taken.
*
*/

inst       scm         -io 2     -nt "d1 covers 3pp 4bit"
           -mc     /*    mc = 001  */
           -mf1        idb ar reg rl 8704
           -mf2        idb ar reg
           -mf3       ar reg;

desc 1     -ta 4;

data 1     -do -128     (1087) 237323070361 237 323 070 000;

data 2     000;

data 3     000 000 000 007;

page       -all;


/*                      scm19

*          this test puts the second string on page 0
*           and tests the -cn option.
*
*/

inst       scm          -io 2     -nt "d1 covers 3pp 4bit"
           -mc     /*    mc = 001  */
           -mf1         ida ar reg rl 8704
           -mf2         idr ar
           /* mf3 is direct */;

desc 1     -ta 4        ;

desc 2     -cn 3;

data 1     -do -128     (1087) 237323070361 237323070000;

data 2     -do -3       000 000 000 000;

data 3     000 000 000 007;


page       -all;


/*                      scm20

*          the following tests use 6 bit data.
*          this test merely makes sure the instruction
*          is working correctly.  direct mod on descriptors.
*
*/

inst       scm    -nt "6bit"
           -mc 
           /* all desc. are direct */;

desc 1     -ta 6        -ns 12;

data 1     414243444546 575051525353;

data 2     57;

data 3     000 000 000 006;

page       -all;


/*                     scm21

*          same as previous test but with first string
*          split across page bound. and a variety
*          of desc. mods taken.
*
*/

inst       scm         -io 1     -nt "di split 6bit"
          -mc    /*   mc = 020  */
           -mf1        ar reg
           -mf2        idb
           /* mf3 is direct */;

desc 1     -ta 6       -ns 12;

data 1     -do -4      414243444546  /*page bound */  475051525354;

data 2     67;

data 3     000 000 000 006;

page       -all;

/*                     scm22

*          this is the same as test 22 except the mask
*          has been set to preclude a match (tr on)
          and different desc. mods. are taken.
*
*/

inst       scm         -io 2    -nt "no match 6bit"
           -mc
           -ir   tr
           -mf1        idb ar
           -mf2        ar reg
           -mf3        ar reg;

desc 1     -ta 6       -ns 12;

data 1     -do -4      414243444546 475051525354;

data 2     67;

data 3    000 000 000 014;

page       -all;


/*                     scm23

*this test exercises all the desc. mods.
*          and tests the rl and -cn options.  it also
*          changes the mask char .
*          
*
*/

inst       scm         -io 3    -nt "full desc mod 6bit"
           -mc    /*  mc = 025  */
           -mf1        idb ar reg rl 12
           -mf2        idb ar reg
           -mf3       ar reg;

desc 1     -ta 6;

desc 2     -cn 3;

data 1     -do -6      414243444546475051 525354;

data 2     -do -4      000000720000 /* page bound. */;

data 3     000 000 000 011;

page       -all;


/*                     scm24

*         using the -cn option on both descriptors
*         direct mod on mf3 desc.
*
*/

inst      scm          -io 2     -nt "d1 split 6bit"
          -mc    /*  mc = 025  */
          -mf1         ar rl 5
          -mf2      ar
          /* mf3 is direct */;

desc 1    -ta 6        -cn 4;

desc 2    -cn 2;

data 1    -do -4      000000005100  /*page bound. */  525354;

data 2    -do -2        00007200   /* page bound.  */;

data 3    000 000 000 002;

page      -all;


/*                     scm25

*         this test and the next one uses the maximum amount
*         of char for string 1.  this test forces a "no match"
*         condition (ir tr on) and takes the maximum mod.
*         on the desc.
*
*/

inst      scm          -io 3    -nt "d1 covers 3pp no match 6b"
         -mc000
          -ir  tr
          -mf1         idb ar reg rl 6528
          -mf2      idb ar reg
          -mf3       ar reg;

desc 1    -ta 6;

data 1    -do -128          (1087) 515151515151 515151515153;

data 2    52;

data 3    000 000 014 600;

page      -all;


/*                     scm26

*         same as previous test but a match occurs
*         on the last char.
*
*/

inst      scm          -io 2    -nt "d1 covers 3pp 6bit"
          -mc    /*   mc = 000  */
          -mf1         idb ar reg rl 6528
          -mf2         idb ar reg
          -mf3       ar reg;


desc 1    -ta 6;

data 1    -do -128     (1087) 515151515151 515151515152;

data 2    52;

data 3    000 000 014 577;

page      -all;


/*		scmr1
*
*	Same  as  scm  only we will change the data  of string 2 so that there is
*	a match.
*/

inst	scmr	-nt  "Same as scm but strings match"	-io 2
	-mc		/* Mask =  (007) octal.  */
	-mf1	ida
	-mf2	ar
	-mf3	ar reg;


desc 1	-ns 3	-cn 3	-ta 9;

desc 2	-cn 1;


data 1	-do -4
	000 000 000		/* Fill due to  cn 3.  */
	011			/* Part of string on page 1. */
	021 033;			/* Part of string on page 2. */

data 2	-do -1	   000  013;

data 3	000 000 000 002;

page	-all;
/*                   scmr2

*         simple test to determine if instruction
*         is working correctly.  data is 9 bit
*         written in octal format to allow easy
*         comparison with the mask.  this test
*         accesses all descriptors directly.
*
*/

inst     scmr    -nt "mc8 simple test 9 bit" 
         -mc8;

desc 1     -ns 8          -ta 9;

data 1    060061062063064065066067;

data 2    047;

data 3    000 000 000 000;

page      -all;


/*                  scmr3

*         same data as test 2 but with data 1
*         split across page boundary.  indirect
*         mod on desc 1 and 2.
*
*/

inst      scmr       -io 1    -nt "d1 split 9bit"
          -mc8
          -mf1      idb
          -mf2      idb;

desc 1    -ns 8     -ta 9;

data 1    -do -4    060061062063 064065066067;

data 2    047;

data 3    000 000 000 000;

page      -all;

/*                  scmr4

*         same data config as test 2 but with
*         full desc mod.
*
*/

inst      scmr       -io 3    -nt "d1 split 9bit"
          -mc8
          -mf1      idb ar reg rl 8
          -mf2      idb ar reg
          -mf3       ar reg;

desc 1    -ta 9;

data 1    060061062063064065066067;

data 2    047;

data 3    000 000 000 000;

page      -all;


/*                  scmr5

*         test of the -cn option for desc 1 and 2
*         along with a varied of """mode of desc mod.
*         both data strings are split across page bound.
*
*/

inst      scmr       -io 2    -nt "no match 9bit"
       -ir     tr
          -mc8
          -mf1      idb ar reg rl 6
          -mf2      ar
          -mf3      ar;

desc 1    -ta 9;

desc 2    -cn 3;

data 1    -do -2    000000 060061062063064066;

data 2    -do -1    000 000 000 047;

data 3    000 000 000 006  /* no match */;

page      -all;


/*                  scmr6

*         data 1 wholey contained on page 0 and
*         data  starting on word 0 of page 1; char 0.
*         all desc mod.
*
*/

inst      scmr       -io 1    -nt "d1 on p0 9bit"
          -mc8
          -mf1      idb ar reg
          -mf2      idb ar reg
          -mf3       ar reg;

desc 1    -ta 9     -ns 2          -cn 2;

data 1    -do  -4   000000060067;

data 2    047;

data 3    000 000 000 000;

page      -all;


/*                  scmr7

*         a variety of desc mod are used~ and the mask
*         is set so that there is no match.  using the
*         using the same data as test 6.
*
*/

inst      scmr       -io 3    -nt "no match 9bit"
	-mc�
             /* mc = 777 */
          -mf1      idr ar rl 2
          -mf2      ar reg
          -mf3      ar;

desc 1    -ta 9     -cn 2;

data 1    -do -4    000000060067;

data 2    047;

data 3    000 000 000 000;

page      -all;


/*                  scmr 8

*          the next four tests use the maximum amount of
*         data for string 1 to test the paging of the data
*         strings.  this test will make sure the inst is operating
*         correctly using no desc mod.
*
*/

inst      scmr    -nt "d1 covers 3pp 9bit"
          -mc    /*  mc = 001 */
                /* mc = 001 */
          -mf1      rl 4352
          /* no desc mod.--all direct */;

desc 1    -ta 9          ;

data 1    -do -128  066 (4351) 062;

data 2    067;

data 3    000 000 010 377;

page      -all;


/*                   scmr9

*         uses same data setup as test 8 but applies
*         maximum mod to descriptors.
*
*/

inst      scmr       -io 3     -nt "d1 covers 3pp max desc mod 9b"
          -mc    /*  mc = 001 */
          -mf1      idb ar reg rl 4352
          -mf2      idb ar reg
          -mf3       ar reg;

desc 1    -ta 9;

data 1    -do -128  (4351) 062 066;

data 2    067;

data 3    000 000 000 000;

page      -all;


/*                  scmr10

*         this test specifically tests the -cn option
**        for data 2 along with forcing it to cross
*         a page boundary.  all desc mods are taken.
*
*/


inst      scmr       -io 1      -nt "d1 covers 3pp d2 split 9b"
          -mc    /*  mc = 001 */
          -mf1      idb ar reg rl 4352
          -mf2      idb ar reg
          -mf3       ar reg;

desc 1    -ta 9;

desc 2    -cn 1;

data 1     -do -128       066    (4351) 062; 

data 2    -do -2         000067 000000;

data 3    000 000 010 377;

page      -all;


/*                  scmr11

*         there will be no match on this test.  also,
*         a variety of desc mods are taken.  note
*         tr indicator will be on.
*
*/

inst      scmr       -io 1    -nt "no match d1 covers 3pp 9bit"
          -mc    /*  mc = 001 */
          -ir       tr
          -mf1      idb rl 4352
          -mf2      ar reg
          /* mf3 is direct */;

desc 1    -ta 9; 

desc 2    -cn 1;

data 1    -do -128  (4352) 062;

data 2    -do -2    000067 000000;

data 3    000 000 010 400;

page      -all;
    /*               scmr12

*          this starts the sequence of seven
*          four bit data tests.  this first
*          test makes sure that the inst is working
*          correctly without any desc. mod.
*
*/

inst       scmr    -nt "4bit simple test"
           -mc    /*  mc = 001 */
           /*  all the desc. are direct */;

desc 1     -ta 4      -ns 8;


data 1    237 323 070 361  /* 1001 1111 1101 0011 0011 1000 1111 00001 */;

data 2     360    /* 1111 */;


data 3     000 000 000 001;

page       -all;


/*                    scmr13

*          same as previous test but taking all of the
*          possible desc. mod.
*
*/

inst       scmr        -io 1     -nt "full desc mod 4bit"
           -mc    /*  mc = 001 */
           -mf1       idb ar reg rl 8
           -mf2       idb ar reg
           -mf3       ar reg;

desc 1     -ta 4;

data 1     237 323 070 361;

data 2     360;

data 3     000 000 000 001;

page      -all;


/*                    scmr14

*          changing the mask characters and offsetting
*          the first data string across a page boundary
*          with a variety of desc. mod.
*
*/

inst       scmr        -io 3    -nt "d1 split 4bit"
           -mc?
           -mf1       ar
           -mf2       idb
           /* mf3 is direct */;

desc 1     -ta 4      -ns 8;

data 1     -do -2      237 323 /* page bound */ 070 361;

data 2                              360;

data 3     000 000 000 000;

page       -all;


/*                     scmr15

*          again using the same data but this time splitting
*          both strings across page bound. and exercising
*          the -cn option.  all desc. mod. are taken.
*
*/

inst       scmr         -io 1     -nt " d1,d" split 4 bit"
           -mc?
           -mf1        idb ar reg
           -mf2        idb ar reg
           -mf3       ar reg;

desc 1     -ta 4       -ns 6         -cn 1;

desc 2     -cn 3;

data 1     -do -2      237 323  /* page boun. */  070 361;

data 2     -do  -3    000 000 360  /* page bound. */  000;

data 3       000 000 000 000;

page       -all;


/*                     scmr16

*          this time there will be no match with
*          the same parameters as test 15 with a mask of
*          777. the tr indicator will be on.
*
*/

inst       scmr         -io 2    -nt "match on first try 4 bit"
         -mc�
           -mf1        idb ar reg
           -mf2        idb ar reg
           -mf3       ar reg;

desc 1     -ta 4       -ns 8        -cn 1;

desc 2     -cn 3;

data 1     -do -2      237 323 070 361;

data 2     -do -3      000 000 360 000;

data 3     000 000 000 000;

page       -all;


/*                     scmr17

*          the next three tests use the maximum amount
*          of data for string 1.  this test uses a mask
*          of 000 but searches for a char which will not
*          match ( tr ind).  no desc. mod.
*
*/

inst       scmr     -nt "no mat d1 covers 3pp 4b"
           -mc    /*  mc = 000 */
           -ir   tr
           -mf1        rl 8704
           /*  all desc. are direct */;

desc 1     -ta 4;

data 1     -do -128    (1088) 237323070361;

data 2     000;

data 3     000 000 021 000;

page       -all;


/*                     scmr18

*          this test will force a match on a middle
*          char.  all desc mods. are taken.
*
*/

inst       scmr         -io 2    -nt "d1 covers 3 pp 4bit"
           -mc    /*  mc = 001 */
           -mf1        idb ar reg rl 8704
           -mf2        idb ar reg
           -mf3       ar reg;

desc 1     -ta 4;

data 1     -do -128     (1087) 237323070361 237 323 070 000;

data 2     000;

data 3     000 000 000 000;

page       -all;


/*                      scmr19

*          this test puts the second string on page 0
*           and tests the -cn option.
*
*/

inst       scmr          -io 2    -nt "d1 covers 3pp 4 bit"
           -mc    /*  mc = 001 */
           -mf1         ida ar reg rl 8704
           -mf2         idr ar
           /* mf3 is direct */;

desc 1     -ta 4        ;

desc 2     -cn 3;

data 1     -do -128     237323070000   (1087) 237323070361 ;

data 2     -do -3       000 000 000 000;

data 3     000 000 000 000;


page       -all;


/*                      scmr20

*          the following tests use 6 bit data.
*          this test merely makes sure the instruction
*          is working correctly.  direct mod on descriptors.
*
*/

inst       scmr    -nt "simple test 6 bit"
           -mc 
           /* all desc. are direct */;

desc 1     -ta 6        -ns 12;

data 1     414243444546 575051525353;

data 2     57;

data 3     000 000 000 005;

page       -all;


/*                     scmr21

*          same as previous test but with first string
*          split across page bound. and a variety
*          of desc. mods taken.
*
*/

inst       scmr         -io 1    -nt "d1 split 6bit"
          -mc   /*  mc - 020 */
           -mf1        ar reg
           -mf2        idb
           /* mf3 is direct */;

desc 1     -ta 6       -ns 12;

data 1     -do -4      414243444546  /*page bound */  475051525354;

data 2     67;

data 3     000 000 000 005;

page       -all;

/*                     scmr22

*          this is the same as test 22 except the mask
*          has been set to preclude a match (tr on)
          and different desc. mods. are taken.
*
*/

inst       scmr         -io 2      -nt "no match 6bit"
           -mc
           -ir   tr
           -mf1        idb ar
           -mf2        ar reg
           -mf3        ar reg;

desc 1     -ta 6       -ns 12;

data 1     -do -4      414243444546 475051525354;

data 2     67;

data 3    000 000 000 014;

page       -all;


/*                     scmr23

*this test exercises all the desc. mods.
*          and tests the rl and -cn options.  it also
*          changes the mask char .
*          
*
*/

inst       scmr         -io 3   -nt "full desc mod 6bit"
           -mc   /* mc = 025  */
           -mf1        idb ar reg rl 12
           -mf2        idb ar reg
           -mf3       ar reg;

desc 1     -ta 6;

desc 2     -cn 3;

data 1     -do -6      414243444546475051 525354;

data 2     -do -4      000000720000 /* page bound. */;

data 3     000 000 000 001;

page       -all;


/*                     scmr24

*         using the -cn option on both descriptors
*         direct mod on mf3 desc.
*
*/

inst      scmr          -io 2    -nt "d1 split 6bit"
          -mc   /* mc = 025  */
          -mf1         ar rl 5
          -mf2      ar
          /* mf3 is direct */;

desc 1    -ta 6        -cn 4;

desc 2    -cn 2;

data 1    -do -4      000000005100  /*page bound. */  525354;

data 2    -do -2        00007200   /* page bound.  */;

data 3    000 000 000 001;

page      -all;


/*                     scmr25

*         this test and the next one uses the maximum amount
*         of char for string 1.  this test forces a "no match"
*         condition (ir tr on) and takes the maximum mod.
*         on the desc.
*
*/

inst      scmr          -io 3      -nt "d1 covers 3pp no mat 6bit"
         -mc000
          -ir  tr
          -mf1         idb ar reg rl 6528
          -mf2      idb ar reg
          -mf3       ar reg;

desc 1    -ta 6;

data 1    -do -128          (1087) 515151515151 515151515153;

data 2    52;

data 3    000 000 014 600;

page      -all;


/*                     scmr26

*         same as previous test but a match occurs
*         on the last char.
*
*/

inst      scmr          -io 2    -nt "d1 covers 3pp 6bit"
          -mc    /*  mc = 000 */
          -mf1         idb ar reg rl 6528
          -mf2         idb ar reg
          -mf3       ar reg;


desc 1    -ta 6;

data 1    -do -128     515151515152   (1087) 515151515151 ;

data 2    52;

data 3    000 000 014 572;

page      -all;


/*		mvn1
*
*		a simple test to see if it works
*		9 bit scaled leading sign to 9 bit scaled trailing sign
*
*/

inst	mvn	-nt "simple"
-io 2;

desc1 -nn 13 -sd l;
desc2 -nn 14 -sd t;

data 1 -do 12 "+" (12) "9";
data 2 "0" (12) "9" "+";

page -all;


/*		mvn2
*		truncation fault taken
*		all page faults taken
*		integer to floating
*/

inst 	mvn	-nt "truncation fault"
-io 1 -tby -ir tn
-mf1 ar rl 63 idb reg
-mf2 ar rl 63 idb reg;

desc1  -cn 1 -sd l;
desc2 -cn 1 -sd f;

data 1 -do -63 " " "+98" (15) "7435";
data 2 000 "+" "98" (14) "7435" "743" 001;

page -all;


/*		mvn3
*		this is a good test
*		all page faults taken
*		legal floating word developed
*		 9 bit scaled to 9 bit float
*
*/

inst	mvn	-nt "int -> float"
-io 1

-mf1 ar rl 23 idb reg
-mf2 ar rl 28 idb reg;

desc1 -sf 13 -sd l -cn 3;
desc2 -sd f -cn 2;

data 1 -do 25 "   " "+" (5) "00" (12) "1";
data 2 000000 "+" (4) "000"  "00" (12) "1" 015;

page -all;


/*		mvn4
*		all page faults taken
*		float to integer scale factor 12
*		9 bit to 9 bit
*
*/

inst	mvn	-nt "float to int"
-io 1 -ir ng
-mf1 ar rl 28 idb reg
-mf2 ar rl 23 idb reg;

desc1 -sd f -cn 2;
desc2 -sf 12 -sd l -cn 3;

data 1 -do 27 "  -" (14) "0" (12) "1" 015;
data 2 000000000 "-" (9) "0" (12) "1" "0";

page -all;


/*		mvn5
*		9 bit scaled to floating 9 bit
*
*/

inst	mvn	-nt "scaled to floating"
-io 1 -rb
-mf1 ar rl 63 idb reg
-mf2 ar rl 3 idb reg;

desc1 -sd n -sf 31;
desc2 -sd f;

data 1 -do 62 "1" (62) "0";
data 2 "+" "1" 135;

page -all;


/*		mvn6
*		convert float 4 bit to
*		floating 9 bit
*
*/

inst	mvn	-nt "float 9 -> float 4"
-io 2
-mf1 ar rl 3 idb reg
-mf2 ar rl 4 idb;

desc1 -sd f;
desc2 -sd f -tn 4;

data 1 -do -3 "+1" 135;
data 2  301135;

page -all;


/*		mvn7
*		9 bit scaled to 4 bit floating
*		 all page faults taken
*
*/
inst	mvn	-nt "9 scaled to 4 float"
-io 3 -ir ng
-mf1 ar rl 25 ida reg
-mf2 ar rl 23 idb;

desc1 -sd t ;
desc2 -sd f -cn 3 -tn 4;

data 1 -do -1  (20) "0" (4) "3" "-";
data 2 (3) 000 320 (7) 000 003 063 0600;

page -all;


/*		mvn8
*		convert 9bit floating point to 4 bit scaled
*
*/
inst	mvn	-nt "9bit float to 4bit scaled"
-io 2
-mf1 ar rl 22 idb reg
-mf2 ar rl 33 ida;

desc1 -sd f;
desc2 -sd t -sf 5 -tn 4;

data 1 -do -8 "+" (11) "0" (3) "123" 006;
data 2 (11) 000 022 061043022060 300;

page -all;


/*		mvn9
*		 convert 9 bit floating to 4 bit scaled
*
*/
inst	mvn	-nt "9bitfloat to 4 bit scaled"
-io 1
-mf1 ar rl 20 idb reg
-mf2 ar rl 63 ida;

desc1 -sd f -cn 2;
desc2 -sd l -tn 4 -cn 1;

data 1 "  +" (9) "0" (4) "45" 060000;
data 2 000300 (26) 000 105105105105 (8) 000;

page -all;


/*		mvn10
*		9 bit scaled trailing sign to
*		9 bit scaled leading sign
*/
inst	mvn	-nt "simple"
-io 1;
desc1 -nn 14 -sd t;
desc2 -nn 13 -sd l;

data 1 -do 12 "0" (12) "9" "+";
data 2 "+" (12) "9";

page -all;


/*		 mvn11
*		9 bit float to 9 bit scaled leading sign
*/

inst	mvn	-nt "float to int"
-io 1
-mf1 ar rl 63 idb reg
-mf2 ar rl 63 idb reg;

desc1 -cn 1 -sd f;
desc2 -cn 1 -sd l;

data 1 -do -63 " " "+98" (14) "7435" "743" 001;
data 2 000 "+98" (14) "7435" "7430";

page -all;


/*		mvn12
*		 9 bit float to 9 bit scaled negative indicator
*/

inst	mvn	-nt "float -> int"
-io 2
-mf1 ar rl 28 idb reg
-mf2 ar rl 23 idb reg;

desc1 -sd f -cn 2;
desc2 -sf 13 -sd l -cn 3;

data 1 -do 29 "  +" (4) "000" "00" (12) "1" 015;
data 2 000000000 "+" (5) "00" (12) "1";

page -all;


/*		mvn13
*		 9 bit scaled to 9 bit float
*		 negative indicator on
*/

inst	mvn	-nt "int to float"
-io 2 -ir ng
-mf1 ar rl 23 idb reg
-mf2 ar rl 28 idb reg;

desc1 -sf 12 -sd l -cn 3;
desc2 -sd f -cn 2;

data 1 -do 25 "   -" (9) "0" (12) "1" "0";
data 2 000000 "-" (13) "0" (12) "1"  "0" 014;

page -all;


/*		mvn14
*		9 bit float to 9 bit scaled
*
*/

inst	mvn	-nt "float to scaled"
-io 2 -rb
-mf1 ar rl 3 idb reg
-mf2 ar rl 63 idb reg;

desc1 -sd f;
desc2 -sd n -sf 31;

data 1 "+1" 135;
data 2 "1" (62) "0";

page -all;


/*		mvn15
*		4 bit float to 9 bit float
*
*/

inst	mvn	-nt "float 4 -> float 9"
-io 1
-mf1 ar rl 4 idb
-mf2 ar rl 3 idb reg;

desc1 -sd f -tn 4;
desc2 -sd f;

data 1 -do 3 301135;
data 2 "+1" 135;

page -all;


/*		mvn16
*		4 bit floating to 9 bit scaled
*		truncation and negative indicators on
*
*/

inst	mvn	-nt "4 float to 9 scaled"
-io 1 -ir ng tn
-mf1 ar rl 23 idb 
-mf2 ar rl 25 ida reg;

desc1 -sd f -cn 3 -tn 4;
desc2 -sd t -sf 2;

data 1 -do 1 "   " 320 (7) 000 003 063060000;
data 2 (22) "0" (2) "3" "-";

page -all;


/*		mvn17
*		4 bit scaled to 9 bit floating
*
*/

inst	mvn	-nt "4bit scaled to 9 bit float"
-io 3
-mf1 ar rl 33 ida
-mf2 ar rl 22 idb reg;

desc1 -sd t -sf 5 -tn 4;
desc2 -sd f;

data 1 (11) 000 022 061043022060 300;
data 2 "+" (10) "0" (3) "123" "0" 005;

page -all;


/*		mvn18
*		4 bit scaled to 9 bit floating
:
*/
inst	mvn	-nt "4bit scaled to 9 bit float"
-io 2
-mf1 ar rl 63 ida
-mf2 ar rl 20 idb reg;

desc1 -sd l -tn 4 -cn 1;
desc2 -sd f -cn 2;

data 1 " " 300 (26) 000 (4) 105 (8) 000;
data 2 000000 "+" (9) "0" (4) "45" "0" 000;

page -all;


/*		mvn19
*		9 bit scaled to 4 bit floating
*
*/

inst 	mvn	 -nt "9 bit to 4 bit float"
-io 3
-mf1 ar rl 10 ida reg
-mf2 ar rl 10 ;

desc1 -sd l -cn 1;
desc2 -sd f -tn 4;

data 1 " +" (5) "0" (4) "1";
data 2 300 000 021 021 000;

page -all;


/*		mvn20
*		9 bit scaled to 4 bit floating
*
*/

inst	mvn	-nt "9bit to 4 bit float"
-mf1 ar rl 10 idb reg
-mf2 ar rl 10;

desc1 -sd t -cn 2;
desc2 -sd f-tn 4;

data 1 "  " (5) "0" (4) "2" "+";
data 2 300 000 042 042 000;

page -all;


/*		mvn21
*
*	Move  +12.34  into  12.3400+.  Length of string 2 will be too short to handle
*	increased scaling factor so there will be significant digit overflow.
*/

inst	mvn	-nt "Sig digit overflow"  -io 1
	-ir	ov
	-mf1	ar  rl 5
	-mf2	idr;


desc 1	-cn 2	-sd l	-sf -2;

desc 2	-sd t	-sf -3	-nn 5;


data 1	-do -5
	000 000		/* Fill for  cn.  */
	053 "12"		/* Page 1. */
	"34";		/* Page 2. */

data 2	-do -4
	"2340"  053;


page	-all;


/*                           CMPN
*
*     The CMPN instruction algebtaically compares two numbers and sets the
* zero, negative, and carry indicators to indicate the results of the
* comparison.  The five possible settings of the indicators and the inputs
* which cause the settings are shown below:
*
* ZR NG CR        INPUTS          INPUT
*                              COMBINATION
*                                NUMBER
*

*  0 0 1     neg,pos,[N1]<[N2]     1
*  0 0 1     pos,pos,[N1]<[N2]     2
*  1 0 1     neg,neg,[N1]=[N2]     3
*  1 0 1     pos,pos,[N1]=[N2]     4
*  0 1 1     neg,neg,[N1]<[N2]     5
*  0 1 1     pos,neg,[N1]<[N2]     6
*  0 1 0     pos,neg,[N1]>[N2]     7
*  0 1 0     pos,pos,[N1]>[N2]     8
*  0 0 0     neg,neg,[N1]>[N2]     9
*  0 0 0     neg,pos,[N1]>[N2]    10
*
*
* where neg,neg,[N1]<[N2] means that the 1st operand is negative,
* the second operand is negative, and the absolute value of the ist
* operand is less than the absolute value of the 2nd.
*
*
*     Each of the even numbered input combinations is tested with:
*
*  1).  both of the numbers 9-bit decimal and floating point,
*  2).  both of the numbers 9-bit decimal with leading sign,
*  3)   both of the numbers 9-bit decimal with trailing sign,
*  4).  where possible, both of the numbers 9-bit decimal and unsigned.
*
*
*     Each of the odd numbered input combinations is tested with:
*
*  1).  both of the numbers 4-bit decimal and floating point,
*  2).  both of the numbers 4-bit decimal with leading sign,
*  3).  both of the numbers 4-bit decimal with trailing sign,
*  4).  where possible, both of the numbers 4-bit decimal and unsigned.
*
*
*/


/*     cmpn1
*  The carry indicator is set.
*  Two 4-bit trailing sign operands are used.
*  The maximum number of page faults is taken.
*  Indirect descriptors are used for all operands.
*  Address register modification is used for all operands.  */

inst cmpn
-nt "Compare 4-bit neg with 4-bit pos"
-ir cr
-mf1 idb ar
-mf2 idb ar rl 5
-io 2;

desc 1 -tn 4 -sd t -nn 5;
desc 2 -tn 4 -sd t;

data 1 -do -2 "76" 32;
data 2 -do -2 "98" 26;

page -all;


/*     cmpn2
*  The carry indicator is set.
*  Two 4-bit leading sign operands are used.
*  The maximum number of page faults is taken.
*  Indirect descriptors are used for all operands.
*  Address register modification is used for all operands.  */

inst cmpn
-nt "Compare 4-bit neg with 4-bit pos"
-ir cr
-mf1 idb ar rl 13
-mf2 idb ar
-io 1;

desc 1 -tn 4 -sd l -sf -1;
desc 2 -tn 4 -sd l -sf -2 -nn 16;

data 1 -do -2 325 "98642" 00;
data 2 -do -3 262 "3278411";

page -all;


/*     cmpn3
*  The carry indicator is set.
*  Two 4-bit floating point operands are used.
*  The maximum number of page faults is taken.
*  Indirect descriptors are used for all operands.
*  Address register modification is used for all operands.  */

inst cmpn
-nt "Compare 4-bit neg with 4-bit pos"
-ir cr
-mf1 idb ar
-mf2 idb ar
-io 2;

desc 1 -tn 4 -sd f -nn 12;
desc 2 -tn 4 -sd f -nn 12;

data 1 -do -2 323 "98762";
data 2 -do -1 264 "32943";

page -all;


/*     cmpn4
*  The carry indicator is set.
*  Two 9-bit unsigned operands are used.
*  The maximum number of page faults is taken.
*  Indirect descriptors are used for all operands.
*  Address register modification is used for all operands.  */

inst cmpn
-nt "Compare 9-bit pos with 9-bit pos"
-ir cr
-mf1 idb ar reg
-mf2 idb ar reg
-io 1;

desc 1 -sd n -sf 4 -nn 63;
desc 2 -sd n -sf 5 -nn 63;

data 1 -do -1 (15)"9834" "395";
data 2 -do -62 (15)"8765" "147";

page -all;


/*     cmpn5
*  The carry indicator is set.
*  Two 9-bit trailing sign operands are used.
*  The maximum number of page faults is taken.
*  Indirect descriptors are used for all operands.
*  Address register modification is used for all operands.  */

inst cmpn
-nt "Compare 9-bit pos with 9-bit pos"
-ir cr
-mf1 idb ar reg
-mf2 idb ar reg
-io 3;

desc 1 -sd t -sf -2 -nn 14;
desc 2 -sd t -sf 12 -nn 14;

data 1 -do -13 (4)"298" "3" 053;
data 2 -do -13 (4)"687" "2" 053;

page -all;


/*     cmpn6
*  The carry indicator is set.
*  Two 9-bit leading sign operands are used.
*  The maximum number of page faults is taken.
*  Indirect descriptors are used for all operands.
*  Address register modification is used for all operands.  */

inst cmpn
-nt "Compare 9-bit pos with 9-bit pos"
-ir cr
-mf1 idb ar reg
-mf2 idb ar reg
-io 2;

desc 1 -sd l -sf 2 -nn 12;
desc 2 -sd l -sf 3 -nn 12;

data 1 -do -4 053 (11)"3";
data 2 -do -4 053 (11)"2";

page -all;


/*     cmpn7
*  The carry indicator is set.
*  Two 9-bit floating point operands are used.
*  The maximum number of page faults is taken.
*  Indirect descriptors are used for all operands.
*  Address register modification is used for all operands.  */

inst cmpn
-nt "Compare 9-bit pos with 9-bit pos"
-ir cr
-mf1 idb ar reg rl 9
-mf2 idb ar reg
-io 1;

desc 1 -sd f;
desc 2 -sd f -nn 8;

data 1 -do -8 053 "7654321" 377;
data 2 -do -1 053 "987654" 002;

page -all;


/*     cmpn8
*  The zero indicator is set.
*  The carry indicator is set.
*  Two 4-bit trailing sign operands are used.
*  The maximum number of page faults is taken.
*  Indirect descriptors are used for all operands.
*  Address register modification is used for all operands.  */

inst cmpn
-nt "Compare 4-bit neg with 4-bit neg"
-ir zr cr
-mf1 idb ar
-mf2 idb ar rl 4
-io 2;

desc 1 -tn 4 -sd t -nn 4;
desc 2 -tn 4 -sd t;

data 1 -do -1 "7" 035;
data 2 -do -1 "7" 035;

page -all;


/*     cmpn9
*  The zero indicator is set.
*  The carry indicator is set.
*  Two 4-bit leading sign operands are used.
*  The maximum number of page faults is taken.
*  Indirect descriptors are used for all operands.
*  Address register modification is used for all operands.  */

inst cmpn
-nt "Compare 4-bit neg with 4-bit neg"
-ir zr cr
-mf1 idb ar rl 63
-mf2 idb ar rl 63
-io 1;

desc 1 -tn 4 -sd l -sf 3;
desc 2 -tn 4 -sd l -sf 3;

data 1 -do -31 32 (31)"5";
data 2 -do -1  32 (31)"5";

page -all;


/*     cmpn10
*  The zero indicator is set.
*  The carry indicator is set.
*  Two 4-bit floating point operands are used.
*  The maximum number of page faults is taken.
*  Indirect descriptors are used for all operands.
*  Address register modification is used for all operands.  */

inst cmpn
-nt "Compare 4-bit neg with 4-bit neg"
-ir zr cr
-mf1 idb ar
-mf2 idb ar
-io 2;

desc 1 -tn 4 -sd f -nn 8;
desc 2 -tn 4 -sd f -nn 8;

data 1 -do -1 325 "495";
data 2 -do -2 325 "495";

page -all;


/*     cmpn11
*  The zero indicator is set.
*  The carry indicator is set.
*  Two 9-bit unsigned operands are used.
*  The maximum number of page faults is taken.
*  Indirect descriptors are used for all operands.
*  Address register modification is used for all operands.  */

inst cmpn
-nt "Compare 9-bit pos with 9-bit pos"
-ir zr cr
-mf1 idb ar reg rl 3
-mf2 idb ar reg
-io 1;

desc 1 -sd n -sf 1;
desc 2 -sd n -sf 1 -nn 3;

data 1 -do -2 "432";
data 2 -do -1 "432";

page -all;


/*     cmpn12
*  The zero indicator is set.
*  The carry indicator is set.
*  Two 9-bit trailing sign operands are used.
*  The maximum number of page faults is taken.
*  Indirect descriptors are used for all operands.
*  Address register modification is used for all operands.  */

inst cmpn
-nt "Compare 9-bit pos with 9-bit pos"
-ir zr cr
-mf1 idb ar reg rl 63
-mf2 idb ar reg rl 63
-io 2;

desc 1 -sd t;
desc 2 -sd t;

data 1 -do -62 (12)"98765" "28" 053;
data 2 -do -61 (12)"98765" "28" 053;

page -all;


/*     cmpn13
*  The zero indicator is set.
*  The carry indicator is set.
*  Two 9-bit leading sign operands are used.
*  The maximum number of page faults is taken.
*  Indirect descriptors are used for all operands.
*  Address register modification is used for all operands.  */

inst cmpn
-nt "Compare 9-bit pos with 9-bit pos"
-ir zr cr
-mf1 idb ar reg
-mf2 idb ar reg
-io 2;

desc 1 -sd l -sf -8 -nn 18;
desc 2 -sd l -sf -8 -nn 18;

data 1 -do -16 053 (5)"369" "00";
data 2 -do -15 053 (5)"369" "00";

page -all;


/*     cmpn14
*  The zero indicator is set.
*  The carry indicator is set.
*  Two 9-bit floating point operands are used.
*  The maximum number of page faults is taken.
*  Indirect descriptors are used for all operands.
*  Address register modification is used for all operands.  */

inst cmpn
-nt "Compare 9-bit pos with 9-bit pos"
-ir zr cr
-mf1 idb ar reg
-mf2 idb ar reg
-io 1;

desc 1 -sd f -nn 39;
desc 2 -sd f -nn 39;

data 1 -do -30 053 (6)"125897" "4" 017;
data 2 -do -24 053 (6)"125897" "4" 017;

page -all;


/*     cmpn15
*  The negative indicator is set.
*  The carry indicator is set.
*  Two 4-bit trailing sign operands are used.
*  The maximum number of page faults is taken.
*  Indirect descriptors are used for all operands.
*  Address register modification is used for all operands.  */

inst cmpn
-nt "Compare 4-bit neg with 4-bit neg"
-ir ng cr
-mf1 idb ar
-mf2 idb ar
-io 3;

desc 1 -tn 4 -sd t -sf -1 -nn 13;
desc 2 -tn 4 -sd t -sf 1  -nn 63;

data 1 -do -1  "123456" 32;
data 2 -do -30 (15)"12" "9" 32;

page -all;


/*     cmpn16
*  The negative indicator is set.
*  The carry indicator is set.
*  Two 4-bit leading sign operands are used.
*  The maximum number of page faults is taken.
*  Indirect descriptors are used for all operands.
*  Address register modification is used for all operands.  */

inst cmpn
-nt "Compare 4-bit neg with 4-bit neg"
-ir ng cr
-mf1 idb ar
-mf2 idb ar
-io 2;

desc 1 -tn 4 -sd l -sf 1 -nn 6;
desc 2 -tn 4 -sd l -sf 2 -nn 6;

data 1 -do -2 321 "44";
data 2 -do -2 321 "44";

page -all;


/*     cmpn17
*  The negative indicator is set.
*  The carry indicator is set.
*  Two 4-bit floating point operands are used.
*  The maximum number of page faults is taken.
*  Indirect descriptors are used for all operands.
*  Address register modification is used for all operands.  */

inst cmpn
-nt "Compare 4-bit neg with 4-bit neg"
-ir ng cr
-mf1 idb ar
-mf2 idb ar
-io 2;

desc 1 -tn 4 -sd f -nn 5;
desc 2 -tn 4 -sd f -nn 5;

data 1 -do -1 324 "5" 00;
data 2 -do -1 327 "6" 00;

page -all;


/*     cmpn18
*  The negative indicator is set.
*  The carry indicator is set.
*  Two 9-bit trailing sign operands are used.
*  The maximum number of page faults is taken.
*  Indirect descriptors are used for all operands.
*  Address register modification is used for all operands.  */

inst cmpn
-nt "Compare 9-bit pos with 9-bit neg"
-ir ng cr
-mf1 idb ar reg
-mf2 idb ar reg
-io 1;

desc 1 -sd t -nn 8;
desc 2 -sd t -nn 9;

data 1 -do -4 "4567821" 053;
data 2 -do -8 "92814372" 055;

page -all;


/*     cmpn19
*  The negative indicator is set.
*  The carry indicator is set.
*  Two 9-bit leading sign operands are used.
*  The maximum number of page faults is taken.
*  Indirect descriptors are used for all operands.
*  Address register modification is used for all operands.  */

inst cmpn
-nt "Compare 9-bit pos with 9-bit neg"
-ir ng cr
-mf1 idb ar reg
-mf2 idb ar reg
-io 2;

desc 1 -sd l -sf -5 -nn 63;
desc 2 -sd l -sf -4 -nn 63;

data 1 -do -60 053 "92" (15)"6391";
data 2 -do -4  055 "82" (15)"7482";

page -all;


/*     cmpn20
*  The negative indicator is set.
*  The carry indicator is set.
*  Two 9-bit floating point operands are used.
*  The maximum number of page faults is taken.
*  Indirect descriptors are used for all operands.
*  Address register modification is used for all operands.  */

inst cmpn
-nt "Compare 9-bit pos with 9-bit neg"
-ir ng cr
-mf1 idb ar reg
-mf2 idb ar reg
-io3;

desc 1 -sd f -nn 11;
desc 2 -sd f -nn 11;

data 1 -do -10 053  "345678901" 001;
data 2 -do -1  055  "456789012" 002;

page -all;


/*     cmpn21
*  The negative indicator is set.
*  Two 4-bit trailing sign operands are used.
*  The maximum number of page faults is taken.
*  Indirect descriptors are used for all operands.
*  Address register modification is used for all operands.  */

inst cmpn
-nt "Compare 4-bit pos with 4-bit neg"
-ir ng
-mf1 idb ar
-mf2 idb ar
-io 1;

desc 1 -tn 4 -sd t -nn 3;
desc 2 -tn 4 -sd t -nn 3;

data 1 -do -1 "4" 26;
data 2 -do -1 "3" 32;

page -all;


/*     cmpn22
*  The negative indicator is set.
*  Two 4-bit leading sign operands are used.
*  The maximum number of page faults is taken.
*  Indirect descriptors are used for all operands.
*  Address register modification is used for all operands.  */

inst cmpn
-nt "Compare 9-bit pos with 9-bit neg"
-ir ng
-mf1 idb ar
-mf2 idb ar
-io 1;

desc 1 -tn 4 -sd l -nn 5;
desc 2 -tn 4 -sd l -nn 4;

data 1 -do -2 267 000  00;
data 2 -do -1 324 000;

page -all;


/*     cmpn23
*  The negative indicator is set.
*  Two 4-bit floating point operands are used.
*  The maximum number of page faults is taken.
*  Indirect descriptors are used for all operands.
*  Address register modification is used for all operands.  */

inst cmpn
-nt "Compare 9-bit pos with 9-bit neg"
-ir ng
-mf1 idb ar
-mf2 idb ar
-io 1;

desc 1 -tn 4 -sd f -nn 63;
desc 2 -tn 4 -sd f -nn 63;

data 1 -do -4 270 (14)"10" 00000000;
data 2 -do -4 321 (14)"10" 00000000;

page -all;


/*     cmpn24
*  The negative indicator is set.
*  Two 9-bit unsigned operands are used.
*  The maximum number of page faults is taken.
*  Indirect descriptors are used for all operands.
*  Address register modification is used for all operands.  */

inst cmpn
-nt "Compare 9-bit pos with 9-bit pos"
-ir ng
-mf1 idb ar reg
-mf2 idb ar reg
-io 3;

desc 1 -sd n -sf 4 -nn 5;
desc 2 -sd n -sf 1 -nn 4;

data 1 -do -1 "12345";
data 2 -do -3 "2345";

page -all;


/*     cmpn25
*  The negative indicator is set.
*  Two 9-bit trailing sign operands are used.
*  The maximum number of page faults is taken.
*  Indirect descriptors are used for all operands.
*  Address register modification is used for all operands.  */

inst cmpn
-nt "Compare 9-bit pos with 9-bit pos"
-ir ng
-mf1 idb ar reg
-mf2 idb ar reg
-io 1;

desc 1 -sd t  -sf 4  -nn 37;
desc 2 -sd t  -sf 3  -nn 37;

data 1 -do -36 (12)"965" 053;
data 2 -do -1  (12)"965" 053;

page -all;


/*     cmpn26
*  The negative indicator is set.
*  Two 9-bit leading sign operands are used.
*  The maximum number of page faults is taken.
*  Indirect descriptors are used for all operands.
*  Address register modification is used for all operands.  */

inst cmpn
-nt "Compare 9-bit pos with 9-bit pos"
-ir ng
-mf1 idb ar reg
-mf2 idb ar reg
-io 1;

desc 1 -sd l  -sf 2  -nn 63;
desc 2 -sd l  -sf 2  -nn 63;

data 1 -do -3  053 "95" (15)"2398";
data 2 -do -4  053 "68" (15)"4782";

page -all;


/*     cmpn27
*  The negative indicator is set.
*  Two 9-bit floating point operands are used.
*  The maximum number of page faults is taken.
*  Indirect descriptors are used for all operands.
*  Address register modification is used for all operands.  */

inst cmpn
-nt "Compare 9-bit pos with 9-bit pos"

-ir ng
-mf1 idb ar reg
-mf2 idb ar reg
-io 2;

desc 1 -sd f  -nn 63;
desc 2 -sd f  -nn 63;

data 1 -do -4  053 "4"  (15)"8901"  002;
data 2 -do -3  053 "4"  (15)"8901"  001;

page -all;


/*     cmpn28
*  Two 4-bit trailing sign operands are used.
*  The maximum number of page faults is taken.
*  Indirect descriptors are used for all operands.
*  Address register modification is used for all operands.  */

inst cmpn
-nt "Compare 4-bit neg with 4-bit neg"
-mf1 idb ar
-mf2 idb ar
-io 1;

desc 1 -tn 4 -sd t -nn 39;
desc 2 -tn 4 -sd t -nn 39;

data 1 -do -19 (19)"5" 32;
data 2 -do -19 (19)"4" 32;

page -all;


/*     cmpn29
*  Two 4-bit leading sign operands are used.
*  The maximum number of page faults is taken.
*  Indirect descriptors are used for all operands.
*  Address register modification is used for all operands.  */

inst cmpn
-nt "Compare 4-bit neg with 4-bit neg"
-mf1 idb ar rl 7
-mf2 idb ar
-io 2;

desc 1 -tn 4 -sd l -sf 5 ;
desc 2 -tn 4 -sd l -sf 1 -nn 7;

data 1 -do -3 324 "98" 00;
data 2 -do -1 323 "64" 00;

page -all;


/*     cmpn30
*  Two 4-bit floating point operands are used.
*  The maximum number of page faults is taken.
*  Indirect descriptors are used for all operands.
*  Address register modification is used for all operands.  */

inst cmpn
-nt "Compare 4-bit neg with 4-bit neg"
-mf1 idb ar
-mf2 idb ar  rl 60
-io 2;

desc 1 -tn 4 -sd f -nn 63;
desc 2 -tn 4 -sd f;

data 1 -do -1 321 (15)"892" 00;
data 2 -do -29 322 (14)"98" 000;

page -all;


/*     cmpn31
*  Two 9-bit trailing sign operands are used.
*  The maximum number of page faults is taken.
*  Indirect descriptors are used for all operands.
*  Address register modification is used for all operands.  */

inst cmpn
-nt "Compare 9-bit neg with 9-bit pos"
-mf1 idb ar reg rl 63
-mf2 idb ar reg
-io 2;

desc 1 -sd t -sf 12;
desc 2 -sd t -sf -1 -nn 5;

data 1 -do -62 (31)"98" 055;
data 2 -do -4  "5432" 053;

page -all;


/*     cmpn32
*  Two 9-bit leading sign operands are used.
*  The maximum number of page faults is taken.
*  Indirect descriptors are used for all operands.
*  Address register modification is used for all operands.  */

inst cmpn
-nt "Compare 9-bit neg with 9-bit pos"
-mf1 idb ar reg
-mf2 idb ar reg
-io 2;

desc 1 -sd l -sf -4 -nn 6;
desc 2 -sd l -sf -6 -nn 6;

data 1 -do -4 055 "42816";
data 2 -do -5 053 "98321";

page -all;


/*     cmpn33
*  Two 9-bit floating point operands are used.
*  The maximum number of page faults is taken.
*  Indirect descriptors are used for all operands.
*  Address register modification is used for all operands.  */

inst cmpn

-nt "Compare 9-bit neg with 9-bit pos"
-mf1 idb ar reg rl 63
-mf2 idb ar reg rl 63
-io 1;

desc 1 -sd f ;
desc 2 -sd f ;

data 1 -do -8 055 (15)"9999" "8" 004;
data 2 -do -9 053 (15)"8777" "4" 002;

page -all;


/*               mvne1

*       these tests exercise the mvne instruction
*       using the 4 to 9 bit option and the 9 to 9
*       bit options on the data.  the same template
*       for the mop sequence will be used for all
*       tests with various desc and data mod.
*
*/

inst    mvne   -nt "simple test no mod 9-9"
          -mf2 rl 29;

desc 1    -nn 24  -sd n;


desc 3    -nn 33  ;

data 1 /* the 9 bit data arranged in sequence of use */
          /* the strings are 0012 0012 3456 3456 0012 3456 */

        "001200123456345600123456";

data 2  /* ***mop sequence arranged in order *** */

       104    /* mvzb */
       060    /* ses es reset */
       124    /* mvza */
       064    /* ses es reset bz set */
       144    /* mfls */
       064    /* ses */
       040    /* enf for "+" insert. */
       200 "="  /* insb */
          220 "q"   /* insa insert "q" */
       260 "q"  /* insp */
       304    /* ign */
       344    /* mvc */
       420 "12345678"   /* change table with string shown */
       024    /* insm */
       401 "2"   /* load table entry 1 with "2" */
       024    /* insm */
       364    /* mors */
      /* end of mop string */;

data 3  /* arranged in order */

       "  12"
       "**12"
       "+3456"
       "+"
       "="
       "q"
       "q"
       "0012"
      "1111"
       "2222"
       "3777";

page   -all;

/*               mvne2

*       these tests exercise the mvne instruction
*       using the 4 to 9 bit option and the 9 to 9
*       bit options on the data.  the same template
*       for the mop sequence will be used for all
*       tests with various desc and data mod.
*
*/

inst     mvne    -nt "offset inst and desc mod 9-9"   -io 3
          -mf1 idr reg
          -mf2 reg rl 29
          -mf3 idb;

desc 1    -nn 24  -sd n;


desc 3    -nn 33  ;

data 1 /* the 9 bit data arranged in sequence of use */
          /* the strings are 0012 0012 3456 3456 0012 3456 */

        "001200123456345600123456";

data 2  /* ***mop sequence arranged in order *** */

       104    /* mvzb */
       060    /* ses es reset */
       124    /* mvza */
       064    /* ses es reset bz set */
       144    /* mfls */
       064    /* ses */
       040    /* enf for "+" insert. */
       200 "="  /* insb */
          220 "q"   /* insa insert "q" */
       260 "q"  /* insp */
       304    /* ign */
       344    /* mvc */
       420 "12345678"   /* change table with string shown */
       024    /* insm */
       401 "2"   /* load table entry 1 with "2" */
       024    /* insm */
       364    /* mors */
      /* end of mop string */;

data 3  /* arranged in order */

       "  12"
       "**12"
       "+3456"
       "+"
       "="
       "q"
       "q"
       "0012"
      "1111"
       "2222"
       "3777";

page   -all;

/*               mvne3

*       these tests exercise the mvne instruction
*       using the 4 to 9 bit option and the 9 to 9
*       bit options on the data.  the same template
*       for the mop sequence will be used for all
*       tests with various desc and data mod.
*
*/

inst     mvne    -nt "offset inst and d1 offset 9-9"   -io 3
          -mf1 idr reg
          -mf2 reg rl 29
          -mf3 idb;

desc 1    -nn 24  -sd n;


desc 3    -nn 33  ;


data 1 /* the 9 bit data arranged in sequence of use */
          -do -16
          /* the strings are 0012 0012 3456 3456 0012 3456 */

        "001200123456345600123456";

data 2  /* ***mop sequence arranged in order *** */

       104    /* mvzb */
       060    /* ses es reset */
       124    /* mvza */
       064    /* ses es reset bz set */
       144    /* mfls */
       064    /* ses */
       040    /* enf for "+" insert. */
       200 "="  /* insb */
          220 "q"   /* insa insert "q" */
       260 "q"  /* insp */
       304    /* ign */
       344    /* mvc */
       420 "12345678"   /* change table with string shown */
       024    /* insm */
       401 "2"   /* load table entry 1 with "2" */
       024    /* insm */
       364    /* mors */
      /* end of mop string */;

data 3  /* arranged in order */

       "  12"
       "**12"
       "+3456"
       "+"
       "="
       "q"
       "q"
       "0012"
      "1111"
       "2222"
       "3777";

page   -all;

/*               mvne4

*       these tests exercise the mvne instruction
*       using the 4 to 9 bit option and the 9 to 9
*       bit options on the data.  the same template
*       for the mop sequence will be used for all
*       tests with various desc and data mod.
*
*/

inst     mvne    -nt "offset d2 and d1 offset 9-9"   -io 3
          -mf1 idr reg
          -mf2 reg rl 29
          -mf3 idb;

desc 1    -nn 24  -sd n;


desc 3    -nn 33  ;


data 1 /* the 9 bit data arranged in sequence of use */
          -do -16
          /* the strings are 0012 0012 3456 3456 0012 3456 */

        "001200123456345600123456";

data 2  /* ***mop sequence arranged in order *** */
          -do -20

       104    /* mvzb */
       060    /* ses es reset */
       124    /* mvza */
       064    /* ses es reset bz set */
       144    /* mfls */
       064    /* ses */
       040    /* enf for "+" insert. */
       200 "="  /* insb */
          220 "q"   /* insa insert "q" */
       260 "q"  /* insp */
       304    /* ign */
       344    /* mvc */
       420 "12345678"   /* change table with string shown */
       024    /* insm */
       401 "2"   /* load table entry 1 with "2" */
       024    /* insm */
       364    /* mors */
      /* end of mop string */;

data 3  /* arranged in order */

       "  12"
       "**12"
       "+3456"
       "+"
       "="
       "q"
       "q"
       "0012"
      "1111"
       "2222"
       "3777";

page   -all;

/*               mvne5

*       these tests exercise the mvne instruction
*       using the 4 to 9 bit option and the 9 to 9
*       bit options on the data.  the same template
*       for the mop sequence will be used for all
*       tests with various desc and data mod.
*
*/

inst     mvne    -nt "offset d2 and d1 and d3 9-9"   -io 3
          -mf1 idr reg
          -mf2 reg rl 29
          -mf3 idb;

desc 1    -nn 24  -sd n;


desc 3    -nn 33  ;


data 1 /* the 9 bit data arranged in sequence of use */
          -do -16
          /* the strings are 0012 0012 3456 3456 0012 3456 */

        "001200123456345600123456";

data 2  /* ***mop sequence arranged in order *** */
          -do -20

       104    /* mvzb */
       060    /* ses es reset */
       124    /* mvza */
       064    /* ses es reset bz set */
       144    /* mfls */
       064    /* ses */
       040    /* enf for "+" insert. */
       200 "="  /* insb */
          220 "q"   /* insa insert "q" */
       260 "q"  /* insp */
       304    /* ign */
       344    /* mvc */
       420 "12345678"   /* change table with string shown */
       024    /* insm */
       401 "2"   /* load table entry 1 with "2" */
       024    /* insm */
       364    /* mors */
      /* end of mop string */;

data 3  /* arranged in order */
          -do -8

       "  12"
       "**12"
       "+3456"
       "+"
       "="
       "q"
       "q"
       "0012"
      "1111"
       "2222"
       "3777";

page   -all;
    
/*               mvne6

*       these tests exercise the mvne instruction
*       using the 4 to 9 bit option and the 9 to 9
*       bit options on the data.  the same template
*       for the mop sequence will be used for all
*       tests with various desc and data mod.
*
*/

inst     mvne    -nt "offset d2 and d1 and d3 9-9"   -io 3
          -mf1 idr reg
          -mf2 reg rl 29
          -mf3 idb;

desc 1    -cn 3     -nn 24  -sd n;


desc 3    -nn 33  ;


data 1 /* the 9 bit data arranged in sequence of use */
          -do -16
          /* the strings are 0012 0012 3456 3456 0012 3456 */

        "***"  /* for cn */   "001200123456345600123456";

data 2  /* ***mop sequence arranged in order *** */
          -do -20

       104    /* mvzb */
       060    /* ses es reset */
       124    /* mvza */
       064    /* ses es reset bz set */
       144    /* mfls */
       064    /* ses */
       040    /* enf for "+" insert. */
       200 "="  /* insb */
          220 "q"   /* insa insert "q" */
       260 "q"  /* insp */
       304    /* ign */
       344    /* mvc */
       420 "12345678"   /* change table with string shown */
       024    /* insm */
       401 "2"   /* load table entry 1 with "2" */
       024    /* insm */
       364    /* mors */
      /* end of mop string */;

data 3  /* arranged in order */
          -do -8

       "  12"
       "**12"
       "+3456"
       "+"
       "="
       "q"
       "q"
       "0012"
      "1111"
       "2222"
       "3777";

page   -all;
 
/*               mvne7

*       these tests exercise the mvne instruction
*       using the 4 to 9 bit option and the 9 to 9
*       bit options on the data.  the same template
*       for the mop sequence will be used for all
*       tests with various desc and data mod.
*
*/

inst      mvne      -nt "d1 totally on p0 9-9"    -io 2
          -mf1 idr ar
          -mf2 reg rl 29
          -mf3 ida ar reg;

desc 1    -cn 3     -nn 24  -sd n;


desc 3    -nn 33  ;


data 1 /* the 9 bit data arranged in sequence of use */
          -do -24
          /* the strings are 0012 0012 3456 3456 0012 3456 */

        "***"  /* for cn */   "001200123456345600123456";

data 2  /* ***mop sequence arranged in order *** */
          -do -20

       104    /* mvzb */
       060    /* ses es reset */
       124    /* mvza */
       064    /* ses es reset bz set */
       144    /* mfls */
       064    /* ses */
       040    /* enf for "+" insert. */
       200 "="  /* insb */
          220 "q"   /* insa insert "q" */
       260 "q"  /* insp */
       304    /* ign */
       344    /* mvc */
       420 "12345678"   /* change table with string shown */
       024    /* insm */
       401 "2"   /* load table entry 1 with "2" */
       024    /* insm */
       364    /* mors */
      /* end of mop string */;

data 3  /* arranged in order */
          -do -8

       "  12"
       "**12"
       "+3456"
       "+"
       "="
       "q"
       "q"
       "0012"
      "1111"
       "2222"
       "3777";

page   -all;


/*               mvne8

*       these tests exercise the mvne instruction
*       using the 4 to 9 bit option and the 9 to 9
*       bit options on the data.  the same template
*       for the mop sequence will be used for all
*       tests with various desc and data mod.
*
*/

inst      mvne      -nt "d2 totally on p0 9-9"    -io 2
          -mf1 idr ar
          -mf2 ar reg rl 29
          -mf3 ida ar reg;

desc 1    -cn 3     -nn 24  -sd n;


desc 3    -nn 33  ;


data 1 /* the 9 bit data arranged in sequence of use */
          -do -20
          /* the strings are 0012 0012 3456 3456 0012 3456 */

        "***"  /* for cn */   "001200123456345600123456";

data 2  /* ***mop sequence arranged in order *** */
          -do -30

       104    /* mvzb */
       060    /* ses es reset */
       124    /* mvza */
       064    /* ses es reset bz set */
       144    /* mfls */
       064    /* ses */
       040    /* enf for "+" insert. */
       200 "="  /* insb */
          220 "q"   /* insa insert "q" */
       260 "q"  /* insp */
       304    /* ign */
       344    /* mvc */
       420 "12345678"   /* change table with string shown */
       024    /* insm */
       401 "2"   /* load table entry 1 with "2" */
       024    /* insm */
       364    /* mors */
      /* end of mop string */;

data 3  /* arranged in order */
          -do -8

       "  12"
       "**12"
       "+3456"
       "+"
       "="
       "q"
       "q"
       "0012"
      "1111"
       "2222"
       "3777";

page   -all;
 
/*               mvne9

*       these tests exercise the mvne instruction
*       using the 4 to 9 bit option and the 9 to 9
*       bit options on the data.  the same template
*       for the mop sequence will be used for all
*       tests with various desc and data mod.
*
*/

inst      mvne      -nt "d3 totally on p0 9-9"    -io 2
          -mf1 idr ar
          -mf2 reg ar rl 29
          -mf3 ida ar reg;

desc 1    -cn 3     -nn 24  -sd n;


desc 3    -nn 33  ;


data 1 /* the 9 bit data arranged in sequence of use */
          -do -20
          /* the strings are 0012 0012 3456 3456 0012 3456 */

        "***"  /* for cn */   "001200123456345600123456";

data 2  /* ***mop sequence arranged in order *** */
          -do -10

       104    /* mvzb */
       060    /* ses es reset */
       124    /* mvza */
       064    /* ses es reset bz set */
       144    /* mfls */
       064    /* ses */
       040    /* enf for "+" insert. */
       200 "="  /* insb */
          220 "q"   /* insa insert "q" */
       260 "q"  /* insp */
       304    /* ign */
       344    /* mvc */
       420 "12345678"   /* change table with string shown */
       024    /* insm */
       401 "2"   /* load table entry 1 with "2" */
       024    /* insm */
       364    /* mors */
      /* end of mop string */;

data 3  /* arranged in order */
          -do -34

       "  12"
       "**12"
       "+3456"
       "+"
       "="
       "q"
       "q"
       "0012"
      "1111"
       "2222"
       "3777";

page   -all;
 
/*               mvne10

*       these tests exercise the mvne instruction
*       using the 4 to 9 bit option and the 9 to 9
*       bit options on the data.  the same template
*       for the mop sequence will be used for all
*       tests with various desc and data mod.
*
*/

inst      mvne      -nt "all data totally on p0 9-9"    -io 2
          -mf1 idr ar
          -mf2 reg ar rl 29
          -mf3 ida ar reg;

desc 1    -cn 3     -nn 24  -sd n;


desc 3    -nn 33  ;


data 1 /* the 9 bit data arranged in sequence of use */
          -do -30
          /* the strings are 0012 0012 3456 3456 0012 3456 */

        "***"  /* for cn */   "001200123456345600123456";

data 2  /* ***mop sequence arranged in order *** */
          -do -30

       104    /* mvzb */
       060    /* ses es reset */
       124    /* mvza */
       064    /* ses es reset bz set */
       144    /* mfls */
       064    /* ses */
       040    /* enf for "+" insert. */
       200 "="  /* insb */
          220 "q"   /* insa insert "q" */
       260 "q"  /* insp */
       304    /* ign */
       344    /* mvc */
       420 "12345678"   /* change table with string shown */
       024    /* insm */
       401 "2"   /* load table entry 1 with "2" */
       024    /* insm */
       364    /* mors */
      /* end of mop string */;

data 3  /* arranged in order */
          -do -34

       "  12"
       "**12"
       "+3456"
       "+"
       "="
       "q"
       "q"
       "0012"
      "1111"
       "2222"
       "3777";

page   -all;
 
/*               mvne11

*       these tests exercise the mvne instruction
*       using the 4 to 9 bit option and the 9 to 9
*       bit options on the data.  the same template
*       for the mop sequence will be used for all
*       tests with various desc and data mod.
*
*/

inst    mvne   -nt "simple test no mod 4-9"
          -mf2 rl 29;

desc 1     -tn 4    -nn 24  -sd n;


desc 3    -nn 33  ;

data 1 /* the 9 bit data arranged in sequence of use */
          /* the strings are 0012 0012 3456 3456 0012 3456 */

        000022000022064126064126000022064126;

data 2  /* ***mop sequence arranged in order *** */

       104    /* mvzb */
       060    /* ses es reset */
       124    /* mvza */
       064    /* ses es reset bz set */
       144    /* mfls */
       064    /* ses */
       040    /* enf for "+" insert. */
       200 "="  /* insb */
          220 "q"   /* insa insert "q" */
       260 "q"  /* insp */
       304    /* ign */
       344    /* mvc */
       420 "12345678"   /* change table with string shown */
       024    /* insm */
       401 "2"   /* load table entry 1 with "2" */
       024    /* insm */
       364    /* mors */
      /* end of mop string */;

data 3  /* arranged in order */

       "  12"
       "**12"
       "+3456"
       "+"
       "="
       "q"
       "q"
       "0012"
      "1111"
       "2222"
       "3777";

page   -all;

/*               mvne12

*       these tests exercise the mvne instruction
*       using the 4 to 9 bit option and the 9 to 9
*       bit options on the data.  the same template
*       for the mop sequence will be used for all
*       tests with various desc and data mod.
*
*/

inst     mvne    -nt "offset inst and desc mod 4-9"   -io 2
          
          -mf2 reg rl 29
          -mf3 ida;

desc 1     -tn 4    -nn 24  -sd n;


desc 3    -nn 33  ;

data 1 /* the 9 bit data arranged in sequence of use */
          /* the strings are 0012 0012 3456 3456 0012 3456 */

        000022000022064126064126000022064126;

data 2  /* ***mop sequence arranged in order *** */

       104    /* mvzb */
       060    /* ses es reset */
       124    /* mvza */
       064    /* ses es reset bz set */
       144    /* mfls */
       064    /* ses */
       040    /* enf for "+" insert. */
       200 "="  /* insb */
          220 "q"   /* insa insert "q" */
       260 "q"  /* insp */
       304    /* ign */
       344    /* mvc */
       420 "12345678"   /* change table with string shown */
       024    /* insm */
       401 "2"   /* load table entry 1 with "2" */
       024    /* insm */
       364    /* mors */
      /* end of mop string */;

data 3  /* arranged in order */

       "  12"
       "**12"
       "+3456"
       "+"
       "="
       "q"
       "q"
       "0012"
      "1111"
       "2222"
       "3777";

page   -all;

/*               mvne13

*       these tests exercise the mvne instruction
*       using the 4 to 9 bit option and the 9 to 9
*       bit options on the data.  the same template
*       for the mop sequence will be used for all
*       tests with various desc and data mod.
*
*/

inst     mvne    -nt "offset inst and d1 offset 4-9"   -io 3
          
          -mf2 reg rl 29
          -mf3 ida;

desc 1     -tn 4    -nn 24  -sd n;


desc 3    -nn 33  ;


data 1 /* the 9 bit data arranged in sequence of use */
          -do -16
          /* the strings are 0012 0012 3456 3456 0012 3456 */

        000022000022064126064126000022064126;

data 2  /* ***mop sequence arranged in order *** */

       104    /* mvzb */
       060    /* ses es reset */
       124    /* mvza */
       064    /* ses es reset bz set */
       144    /* mfls */
       064    /* ses */
       040    /* enf for "+" insert. */
       200 "="  /* insb */
          220 "q"   /* insa insert "q" */
       260 "q"  /* insp */
       304    /* ign */
       344    /* mvc */
       420 "12345678"   /* change table with string shown */
       024    /* insm */
       401 "2"   /* load table entry 1 with "2" */
       024    /* insm */
       364    /* mors */
      /* end of mop string */;

data 3  /* arranged in order */

       "  12"
       "**12"
       "+3456"
       "+"
       "="
       "q"
       "q"
       "0012"
      "1111"
       "2222"
       "3777";

page   -all;

/*               mvne14

*       these tests exercise the mvne instruction
*       using the 4 to 9 bit option and the 9 to 9
*       bit options on the data.  the same template
*       for the mop sequence will be used for all
*       tests with various desc and data mod.
*
*/

inst     mvne    -nt "offset d2 and d1 offset 4-9"   -io 3
          
          -mf2 reg rl 29
          -mf3 ida;

desc 1     -tn 4    -nn 24  -sd n;


desc 3    -nn 33  ;


data 1 /* the 9 bit data arranged in sequence of use */
          -do -16
          /* the strings are 0012 0012 3456 3456 0012 3456 */

        000022000022064126064126000022064126;

data 2  /* ***mop sequence arranged in order *** */
          -do -20

       104    /* mvzb */
       060    /* ses es reset */
       124    /* mvza */
       064    /* ses es reset bz set */
       144    /* mfls */
       064    /* ses */
       040    /* enf for "+" insert. */
       200 "="  /* insb */
          220 "q"   /* insa insert "q" */
       260 "q"  /* insp */
       304    /* ign */
       344    /* mvc */
       420 "12345678"   /* change table with string shown */
       024    /* insm */
       401 "2"   /* load table entry 1 with "2" */
       024    /* insm */
       364    /* mors */
      /* end of mop string */;

data 3  /* arranged in order */

       "  12"
       "**12"
       "+3456"
       "+"
       "="
       "q"
       "q"
       "0012"
      "1111"
       "2222"
       "3777";

page   -all;

/*               mvne15

*       these tests exercise the mvne instruction
*       using the 4 to 9 bit option and the 9 to 9
*       bit options on the data.  the same template
*       for the mop sequence will be used for all
*       tests with various desc and data mod.
*
*/

inst     mvne    -nt "offset d2 and d1 and d3 4-9"   -io 3
          
          -mf2 reg rl 29
          -mf3 ida;

desc 1     -tn 4    -nn 24  -sd n;


desc 3    -nn 33  ;


data 1 /* the 9 bit data arranged in sequence of use */
          -do -16
          /* the strings are 0012 0012 3456 3456 0012 3456 */

        000022000022064126064126000022064126;

data 2  /* ***mop sequence arranged in order *** */
          -do -20

       104    /* mvzb */
       060    /* ses es reset */
       124    /* mvza */
       064    /* ses es reset bz set */
       144    /* mfls */
       064    /* ses */
       040    /* enf for "+" insert. */
       200 "="  /* insb */
          220 "q"   /* insa insert "q" */
       260 "q"  /* insp */
       304    /* ign */
       344    /* mvc */
       420 "12345678"   /* change table with string shown */
       024    /* insm */
       401 "2"   /* load table entry 1 with "2" */
       024    /* insm */
       364    /* mors */
      /* end of mop string */;

data 3  /* arranged in order */
          -do -8

       "  12"
       "**12"
       "+3456"
       "+"
       "="
       "q"
       "q"
       "0012"
      "1111"
       "2222"
       "3777";

page   -all;
    
/*               mvne16

*       these tests exercise the mvne instruction
*       using the 4 to 9 bit option and the 9 to 9
*       bit options on the data.  the same template
*       for the mop sequence will be used for all
*       tests with various desc and data mod.
*
*/

inst     mvne    -nt "offset d2 and d1 and d3 4-9"   -io 3
          
          -mf2 reg rl 29
          -mf3 ida;

desc 1     -tn 4         -nn 24  -sd n;


desc 3    -nn 33  ;


data 1 /* the 9 bit data arranged in sequence of use */
          -do -16
          /* the strings are 0012 0012 3456 3456 0012 3456 */

           000022000022064126064126000022064126;

data 2  /* ***mop sequence arranged in order *** */
          -do -20

       104    /* mvzb */
       060    /* ses es reset */
       124    /* mvza */
       064    /* ses es reset bz set */
       144    /* mfls */
       064    /* ses */
       040    /* enf for "+" insert. */
       200 "="  /* insb */
          220 "q"   /* insa insert "q" */
       260 "q"  /* insp */
       304    /* ign */
       344    /* mvc */
       420 "12345678"   /* change table with string shown */
       024    /* insm */
       401 "2"   /* load table entry 1 with "2" */
       024    /* insm */
       364    /* mors */
      /* end of mop string */;

data 3  /* arranged in order */
          -do -8

       "  12"
       "**12"
       "+3456"
       "+"
       "="
       "q"
       "q"
       "0012"
      "1111"
       "2222"
       "3777";

page   -all;
 
/*               mvne17

*       these tests exercise the mvne instruction
*       using the 4 to 9 bit option and the 9 to 9
*       bit options on the data.  the same template
*       for the mop sequence will be used for all
*       tests with various desc and data mod.
*
*/

inst      mvne      -nt "d1 totally on p0 4-9"    -io 2
          -mf1 idr ar
          -mf2 reg rl 29
          -mf3 ida ar reg;

desc 1     -tn 4         -nn 24  -sd n;


desc 3    -nn 33  ;


data 1 /* the 9 bit data arranged in sequence of use */
          -do -24
          /* the strings are 0012 0012 3456 3456 0012 3456 */

           000022000022064126064126000022064126;

data 2  /* ***mop sequence arranged in order *** */
          -do -20

       104    /* mvzb */
       060    /* ses es reset */
       124    /* mvza */
       064    /* ses es reset bz set */
       144    /* mfls */
       064    /* ses */
       040    /* enf for "+" insert. */
       200 "="  /* insb */
          220 "q"   /* insa insert "q" */
       260 "q"  /* insp */
       304    /* ign */
       344    /* mvc */
       420 "12345678"   /* change table with string shown */
       024    /* insm */
       401 "2"   /* load table entry 1 with "2" */
       024    /* insm */
       364    /* mors */
      /* end of mop string */;

data 3  /* arranged in order */
          -do -8

       "  12"
       "**12"
       "+3456"
       "+"
       "="
       "q"
       "q"
       "0012"
      "1111"
       "2222"
       "3777";

page   -all;


/*               mvne18

*       these tests exercise the mvne instruction
*       using the 4 to 9 bit option and the 9 to 9
*       bit options on the data.  the same template
*       for the mop sequence will be used for all
*       tests with various desc and data mod.
*
*/

inst      mvne      -nt "d2 totally on p0 4-9"    -io 2
          -mf1 idr ar
          -mf2 ar reg rl 29
          -mf3 ida ar reg;

desc 1     -tn 4         -nn 24  -sd n;


desc 3    -nn 33  ;


data 1 /* the 9 bit data arranged in sequence of use */
          -do -20
          /* the strings are 0012 0012 3456 3456 0012 3456 */

           000022000022064126064126000022064126;

data 2  /* ***mop sequence arranged in order *** */
          -do -30

       104    /* mvzb */
       060    /* ses es reset */
       124    /* mvza */
       064    /* ses es reset bz set */
       144    /* mfls */
       064    /* ses */
       040    /* enf for "+" insert. */
       200 "="  /* insb */
          220 "q"   /* insa insert "q" */
       260 "q"  /* insp */
       304    /* ign */
       344    /* mvc */
       420 "12345678"   /* change table with string shown */
       024    /* insm */
       401 "2"   /* load table entry 1 with "2" */
       024    /* insm */
       364    /* mors */
      /* end of mop string */;

data 3  /* arranged in order */
          -do -8

       "  12"
       "**12"
       "+3456"
       "+"
       "="
       "q"
       "q"
       "0012"
      "1111"
       "2222"
       "3777";

page   -all;
 
/*               mvne19

*       these tests exercise the mvne instruction
*       using the 4 to 9 bit option and the 9 to 9
*       bit options on the data.  the same template
*       for the mop sequence will be used for all
*       tests with various desc and data mod.
*
*/

inst      mvne      -nt "d3 totally on p0 4-9"    -io 2
          -mf1 idr ar
          -mf2 reg ar rl 29
          -mf3 ida ar reg;

desc 1     -tn 4         -nn 24  -sd n;


desc 3    -nn 33  ;


data 1 /* the 9 bit data arranged in sequence of use */
          -do -20
          /* the strings are 0012 0012 3456 3456 0012 3456 */

           000022000022064126064126000022064126;

data 2  /* ***mop sequence arranged in order *** */
          -do -10

       104    /* mvzb */
       060    /* ses es reset */
       124    /* mvza */
       064    /* ses es reset bz set */
       144    /* mfls */
       064    /* ses */
       040    /* enf for "+" insert. */
       200 "="  /* insb */
          220 "q"   /* insa insert "q" */
       260 "q"  /* insp */
       304    /* ign */
       344    /* mvc */
       420 "12345678"   /* change table with string shown */
       024    /* insm */
       401 "2"   /* load table entry 1 with "2" */
       024    /* insm */
       364    /* mors */
      /* end of mop string */;

data 3  /* arranged in order */
          -do -34

       "  12"
       "**12"
       "+3456"
       "+"
       "="
       "q"
       "q"
       "0012"
      "1111"
       "2222"
       "3777";

page   -all;
 
/*               mvne20

*       these tests exercise the mvne instruction
*       using the 4 to 9 bit option and the 9 to 9
*       bit options on the data.  the same template
*       for the mop sequence will be used for all
*       tests with various desc and data mod.
*
*/

inst      mvne      -nt "all data totally on p0 4-9"    -io 2
          -mf1 idr ar
          -mf2 reg ar rl 29
          -mf3 ida ar reg;

desc 1     -tn 4         -nn 24  -sd n;


desc 3    -nn 33  ;


data 1 /* the 9 bit data arranged in sequence of use */
          -do -30
          /* the strings are 0012 0012 3456 3456 0012 3456 */

           000022000022064126064126000022064126;

data 2  /* ***mop sequence arranged in order *** */
          -do -30

       104    /* mvzb */
       060    /* ses es reset */
       124    /* mvza */
       064    /* ses es reset bz set */
       144    /* mfls */
       064    /* ses */
       040    /* enf for "+" insert. */
       200 "="  /* insb */
          220 "q"   /* insa insert "q" */
       260 "q"  /* insp */
       304    /* ign */
       344    /* mvc */
       420 "12345678"   /* change table with string shown */
       024    /* insm */
       401 "2"   /* load table entry 1 with "2" */
       024    /* insm */
       364    /* mors */
      /* end of mop string */;

data 3  /* arranged in order */
          -do -34

       "  12"
       "**12"
       "+3456"
       "+"
       "="
       "q"
       "q"
       "0012"
      "1111"
       "2222"
       "3777";

page   -all;


/*     ad3d1
*  The zero indicator is set.
*  Three 9-bit floating point operands are used.
*  Indirect descriptors are used for all operands.
*  Address register modification is used for all operands.  */

inst ad3d -nt "9 bit + 9 bit -> 9 bit"
-ir zr
-mf1 idb ar reg
-mf2 idb ar reg
-mf3 idb ar reg
-io 1;

desc 1  -sd f -nn 63;
desc 2 -sd f -nn 60;
desc 3 -sd f -nn 63;

data 1 -do -1 "+" (14)"2583" "00000" 005;
data 2 -do -60 "-" (14)"2583" "00" 010;
data 3 -do -8 "+" (61)"0" 177;

page -all;


/*     ad3d2
*  The zero indicator is set.
*  Three 9-bit leading sign operands are used.
*  The maximum number of page faults is taken.
*  Indirect descriptors are used for all operands.
*  Address register modification is used for all operands.  */

inst ad3d -nt "9 bit + 9 bit -> 9 bit"
-ir zr tn
-mf1 idb ar reg
-mf2 idb ar reg
-mf3 idb ar reg
-io 2;

desc 1 -sd l -nn 13 -sf 4;
desc 2 -sd l -nn 13 -sf 4;
desc 3 -sd l -nn 5 -sf 6;

data 1 -do -12 "-" (2)"392457";
data 2 -do -4 "+" (2)"392457";
data 3 -do -4 "+" (4)"0";

page -all;


/*     ad3d3
*  The negative indicator is set.
*  Three 4-bit floating point operands are used.
*  Indirect descriptors are used for all operands.
*  Address register modification is used for all operands.  */

inst ad3d -nt "4 bit + 4 bit -> 4 bit"
-ir ng
-mf1 idb ar
-mf2 idb ar
-mf3 idb ar
-io 3;

desc 1 -tn 4 -sd f -nn 22;
desc 2 -tn 4 -sd f -nn 22;
desc 3 -tn 4 -sd f -nn 22;

data 1 -do -11 320 (5)000 "8888" 005;
data 2 -do -1 260 (5) 000 "7777" 005;
data 3 -do -4 320 (5)000 (4)001 005;

page -all;


/*     ad3d4
* The negative indicator is set.
*  Three 4-bit trailing sign operands are used.
*  Indirect descriptors are used for all operands.
*  Address register modification is used for all operands.  */

inst ad3d -nt "4 bit + 4 bit -> 4 bit"
-ir ng
-mf1 idb ar
-mf2 idb ar
-mf3 idb ar
-io 1;

desc 1 -tn 4 -sd t -sf -1 -nn 8;
desc 2 -tn 4 -sd t -sf -1 -nn 8;
desc 3 -tn 4 -sd t -sf -1 -nn 8;

data 1 -do -4 "555+";
data 2 -do -4 "777-";
data 3 -do -4 (3)002 015;

page -all;


/*     ad3d5
*  The truncation indicator is set.
*  Three 9-bit floating point operands are used.
*  The maximum number of page faults is taken.
*  Indirect descriptors are used for all operands.
*  Address register modification is used for all operands.  */

inst ad3d -nt "9 bit + 9 bit -> 9 bit"
-ir tn
-mf1 idb ar reg
-mf2 idb ar reg
-mf3 idb ar reg
-io 2;

desc 1  -sd f -nn 63;
desc 2 -sd f -nn 63;
desc 3 -sd f -nn 50;

data 1 -do -1 "+" (61)"4" 003;
data 2 -do -62 "+" (61)"5" 003;
data 3 -do -48 "+" (48)"9" 020;

page -all;


/*     ad3d6
*  The truncation indicator is set.
*  Three 9-bit leading sign operands are used.
*  The maximum number of page faults is taken.
*  Indirect descriptors are used for all operands.
*  Address register modification is used for all operands.  */

inst ad3d -nt "9 bit + 9 bit -> 9 bit"
-ir tn
-mf1 idb ar reg
-mf2 idb ar reg
-mf3 idb ar reg
-io 3;

desc 1 -sd l -sf 5 -nn 37;
desc 2 -sd l -sf 5 -nn 37;
desc 3 -sd l -sf 10 -nn 37;

data 1 -do -20 "+" (6)"121212";
data 2 -do -20 "+" (6)"212121";
data 3 -do -32 "+" (5)"0" (31)"3";

page -all;


/*     ad3d7
*  Rounding is tested.
*  Three 9-bit trailing sign operands are used.
*  The maximum number of page faults is taken.
*  Indirect descriptors are used for all operands.
*  Address register modification is used for all operands.  */

inst ad3d -nt "9 bit + 9 bit -> 9 bit"
-rb
-mf1 idb ar reg
-mf2 idb ar reg
-mf3 idb ar reg
-io 1;

desc 1 -sd t -sf 5 -nn 37;
desc 2 -sd t -sf 5 -nn 37;
desc 3 -sd t -sf 10 -nn 37;

data 1 -do -36 (6)"121212" "+";
data 2 -do -1  (6)"212121" "+";
data 3 -do -35 (5)"0" (31)"3" "+";

page -all;


/*     ad3d8
*  The overflow indicator is set.
*  Three 4-bit unsigned operands are used.
*  Indirect descriptors are used for all operands.
*  Address register modification is used for all operands.  */

inst ad3d -nt "4 bit + 4 bit -> 4 bit"
-ir ov
-mf1 idb ar
-mf2 idb ar
-mf3 idb ar
-io 2;

desc 1 -tn 4 -sd n -sf 8 -nn 16;
desc 2 -tn 4 -sd n -sf 8 -nn 16;
desc 3 -tn 4 -sd n -sf 5 -nn 16;

data 1 -do -15 (8) 042;
data 2 -do -1  (8) 063;
data 3 -do -8 (6) 125 120 000;

page -all;


/*     ad3d9
*  The exponent overflow indicator is set.
*  Three 9-bit floating point operands are used.
*  The maximum number of page faults is taken.
*  Indirect descriptors are used for all operands.
*  Address register modification is used for all operands.  */

inst ad3d -nt "9 bit + 9 bit -> 9 bit"
-ir eo tn
-mf1 idb ar reg
-mf2 idb ar reg
-mf3 idb ar reg
-io 3;

desc 1 -sd f -nn 6;
desc 2 -sd f -nn 6;
desc 3 -sd f -nn 6;

data 1 -do -1 "+" (4)"9" 177;
data 2 -do -5 "+" (4)"2" 177;
data 3 -do -4 "+" "1222" 200;

page -all;


/*     ad3d10
*  A 9-bit operand is added to a 9-bit operand and stored in a 4-bit operand.
*  The maximum number of page faults is taken.
*  Indirect descriptors are used for all operands.
*  Address register modification is used for all operands.  */

inst ad3d -nt "9 bit + 9 bit -> 4 bit"
-mf1 idb ar reg
-mf2 idb ar reg
-mf3 idb ar
-io 1;

desc 1 -sd l -nn 10;
desc 2 -sd l -nn 10;
desc 3 -sd l -tn 4 -nn 11 -cn 1;

data 1 -do -1 "+" "987654321";
data 2 -do -8 "+" "123456789";
data 3 -do -1 00 301 (4)021 00;

page -all;


/*     ad3d11
*  A 4-bit operand is added to a 4-bit operand and stored in a 9-bit operand.
*  Indirect descriptors are used for all operands.
*  Address register modification is used for all operands.  */

inst ad3d -nt "4 bit + 4 bit -> 9 bit"
-mf1 idb ar
-mf2 idb ar
-mf3 idb ar reg
-io 2;

desc 1 -sd t -tn 4 -sf -1 -nn 10 -cn 1;
desc 2 -sd t -tn 4 -sf -1 -nn 10 -cn 1;
desc 3 -sd t -sf -1 -nn 11;

data 1 -do -1 00 230 166 124 062 033;
data 2 -do -5 00 022 064 126 170 233;
data 3 -do -10 (9)"1" "0" "+";

page -all;


/*     ad3d12
*  A 9-bit operand is added to a 4-bit operand and stored in a 4-bit operand.
*  The maximum number of page faults is taken.
*  Indirect descriptors are used for all operands.
*  Address register modification is used for all operands.  */

inst ad3d -nt "9 bit + 4 bit -> 4 bit"
-mf1 idb ar reg
-mf2 idb ar
-mf3 idb ar
-io 3;

desc 1 -sd f -nn 11;
desc 2 -sd f -tn 4 -nn 12;
desc 3 -sd f -tn 4 -nn 13;

data 1 -do -9 "+" "987654321" 036;
data 2 -do -5 261 043 105 147 211 036;
data 3 -do -6 301 (4)021 001 34;

page -all;


/*     ad3d13
*  A 9-bit operand is added to a 4-bit operand and stored in a 9-bit operand.
*  The maximum number of page faults is taken.
*  Indirect descriptors are used for all operands.
*  Address register modification is used for all operands.  */

inst ad3d -nt "9 bit + 4 bit -> 9 bit"
-mf1 idb ar reg
-mf2 idb ar
-mf3 idb ar reg
-io 1;

desc 1 -sd n -sf -5 -nn 9;
desc 2 -sd n -tn 4 -sf -5 -nn 9;
desc 3 -sd n -sf -5 -nn 10;

data 1 -do -8 "987654321";
data 2 -do -1 022 064 126 170 22;
data 3 -do -5 (9)"1" "0";

page -all;


/*     ad3d14
*  Leading, trailing, and floating point operands are mixed.
*  The maximum number of page faults is taken.
*  Indirect descriptors are used for all operands.
*  Address register modification is used for all operands.  */

inst ad3d -nt "9 bit + 9 bit -> 9 bit"
-mf1 idb ar reg
-mf2 idb ar reg
-mf3 idb ar reg
-io 2;

desc 1 -sd l -sf 7 -nn 10;
desc 2 -sd t -sf 7 -nn 10;
desc 3 -sd f -nn 12;

data 1 -do -9 "+" "987654321";
data 2 -do -4 "123456789" "+";
data 3 -do -8 "+" (9)"1" "0" 007;

page -all;


/*     ad3d15
*  Floating point, unsigned, and leading sign operands are mixed.
*  Indirect descriptors are used for all operands.
*  Address register modification is used for all operands.  */

inst ad3d -nt "4 bit + 4 bit -> 4 bit"
-mf1 idb ar
-mf2 idb ar
-mf3 idb ar
-io 3;

desc 1 -tn 4 -sd f -nn 12;
desc 2 -tn 4 -sd n -nn 9;
desc 3 -tn 4 -sd l -nn 13 -sf -2;

data 1 -do -6 271 207 145 103 041 000;
data 2 -do -4 022 064 126 170 22;
data 3 -do -5 301 (4)021 00000;

page -all;


/*		ad2d1
*		Use RL mod and cn field with indirect descriptors
*		add 9 bit scaled to 9 bit scaled
*		two character offset
*
*/


inst	ad2d	-nt "9scaled+9scal->9scaled"
-io 2  -ir ng
-mf1 ar rl 10 idb reg
-mf2 ar rl 10 idb reg;

desc1 -cn 1  -sd t ;
desc2 -cn 1  -sd t ;

data 1 -do -9 " " (9) "2" "-";
data 2 -do -9 "*" (9) "1" "+";
data 3 "*" (9) "1" "-";

page -all;


/*		ad2d2
*		Use RL mod and cn field with indirect descriptors
*		9 bit scaled to 9 bit scaled
*		one character offset
*
*/


inst	ad2d	-nt "9scaled+9scaled->9scaled"
-io 2  -ir ng
-mf1 ar rl 10 idb reg
-mf2 ar rl 10 idb reg;

desc1 -cn 1  -sd t ;
desc2 -cn 1  -sd t ;

data 1 -do -10 " " (9) "2" "-";
data 2 -do -10 "*" (9) "1" "+";
data 3 "*" (9) "1" "-";

page -all;


/*		ad2d3
*		Use RL mod and cn field 
*		9 bit scaled to 9 bit scaled
*		no indirect descriptors
*
*/

inst	ad2d	-nt "9scaled+9scaled->9scaled"
-io 2  -ir ng
-mf1 ar rl 10  reg
-mf2 ar rl 10 reg;

desc1 -cn 1  -sd t ;
desc2 -cn 1  -sd t ;

data 1 -do -9 " " (9) "2" "-";
data 2 -do -9 "*" (9) "1" "+";
data 3 "*" (9) "1" "-";

page -all;


/*		ad2d4
*		Use no modification
*		9bit scaled added to 9 bit scaled
*
*/

inst	ad2d	-nt "9scaled+9scaled->9scaled"
-io 2  -ir ng;

desc1 -cn 1  -sd t  -nn 12;
desc2 -cn 1  -sd t  -nn 12;

data 1 -do -12 " " (11) "2" "-";
data 2 -do -12 "*" (11) "1" "+";
data 3 "*" (11) "1" "-";

page -all;


/*		ad2d5
*		Use ar and rl
*		9 bit scaled to 9 bit scaled
*
*/


inst	ad2d	-nt "ar and rl modification"
-io 2  -ir ng
-mf1 ar rl 10 
-mf2 ar rl 10 ;

desc1 -cn 1  -sd t ;
desc2 -cn 1  -sd t ;

data 1 -do -9 " " (9) "2" "-";
data 2 -do -9 "*" (9) "1" "+";
data 3 "*" (9) "1" "-";

page -all;


/*		ad2d6
*		Use ar and rl modification, desc1
*		Use ar rl idb reg on desc2
*		9 bit scaled to 9 bit scaled
*
*/


inst	ad2d	-nt "9scaled+9scaled->9scaled"
-io 2  -ir ng
-mf1 ar rl 10
-mf2 ar rl 10 idb reg;

desc1 -cn 1  -sd t ;
desc2 -cn 1  -sd t ;

data 1 -do -9 " " (9) "2" "-";
data 2 -do -9 "*" (9) "1" "+";
data 3 "*" (9) "1" "-";

page -all;


/*		ad2d7
*		maximum length add, leading sign
*		one character over next page
*		all modification taken
*/
inst	ad2d	-nt "9scaled+9scaled->9scaled"
-io 2
-mf1 ar rl 63 idb reg
-mf2 ar rl 63 idb reg;

desc1 -cn 1 -sd l ;
desc2 -cn 1 -sd l ;

data 1 -do 4033 " " "+33" (15) "8642";
data 2 -do 4033 "*" "+11" (15) "2357";
data 3 "*" "+45" (14) "1000" "0999";

page -all;


/*		ad2d8
*		This is a simple test
*		9 bit add to 9 bit all scaled trailing sign
*
*/

inst	ad2d	-nt "simple test";

desc1  -sd t -sf 10 -nn 63;
desc2  -sd t -sf 10 -nn 63;

data 1 "11" (15) "1111" "-";
data 2 "22" (15) "2222" "+";
data 3 "11" (15) "1111" "+";

page -all;


/*		ad2d9
*		maximum length add resulting
*		in an overflow
*		all modification taken
*		9 bit scaled to 9 bit scaled
*/
inst	ad2d	-nt "truncation fault"
-io 1  -ir ov
-mf1 ar rl 63 idb reg
-mf2 ar rl 63 idb reg;

desc1 -sd l -cn 1;
desc2 -sd l -cn 1;

data 1 -do 4033 " " "+33" (15) "8642";
data 2 -do 4033 "*" "+71" (15) "2357";
data 3  "*" "+" "05" (14) "1000" "0999";

page -all;


/*		ad2d10
*		maximum length over two pages
*		no faults, 9 bit to 4 bit
*
*/

inst	ad2d	-nt "9 bit -> 4 bit"
-io 1
-mf1 ar rl 63 
-mf2 ar rl 63 ;

desc1 -sd t ;
desc2 -sd t  -tn 4;

data 1 -do 4033  "33" (15) "3333" "+";
data 2 -do 4064  021021 (7) 021021021021 02126;
data 3   104104 (7) 104104104104 1043;

page -all;


/*		ad2d11
*		9 bit to 4 bit all page faults possible
*		 no reg modification on desc2
*
*/

inst	ad2d	-nt "9bit ->4bit"
-io 2
-mf1 ar rl 63 idb reg
-mf2 ar rl 63 idb ;

desc1 -cn 1 -sd l;
desc2   -cn 1 -sd t -tn 4;

data 1 -do 4033 " " "+33" (15) "3333";
data 2 -do 4068 "*" 021021 (7) 021021021021  0213;
data 3 "*" 104104 (7) 104104104104 1043;

page -all;


/*		ad2d12
*		4 bit added to 4 bit
*		maximum length
*		all page faults taken
*		no reg modification
*/

inst	ad2d	-nt "4 bit + 4bit"
-io 1
-mf1 ar rl 63 idb
-mf2 ar rl 63 idb;

desc1 -cn 1 -sd t -tn 4;
desc2 -cn 1 -sd t -tn 4;

data 1 -do 4065 " " 021021 (7) 021021021021 0213;
data 2 -do 4065 "*" 021021 (7) 021021021021 0213;
data 3 "*" 042042 (7) 042042042042 0423;

page -all;


/*		ad2d13
*		floating point add
*		 9 bit to 9bit
*		 all page faults taken
*
*/

inst	ad2d	-nt "9bit float add"
-io 1
-mf1 ar rl 63 reg idb
-mf2 ar rl 63 reg idb;

desc1 -sd f;
desc2 -sd f;

data 1 -do -1 "+" (20) "0" (10) "1" (30) "0" "1" 005;
data 2 -do -1 "+" (20) "0" (10) "1" (30) "0" "1" 006;
data 3 "+" (19) "0" "1" (9) "2" "1" (29) "0" "11" 005;

page -all;


/*		ad2d14
*		4 bit floating added to
*		4 bit floating
*
*/

inst	ad2d	-nt "4 float to 4 float"
-io 1
-mf1 ar rl 10 ida
-mf2 ar rl 10 ida;

desc1 -sd f -tn 4;
desc2 -sd f -tn 4;

data 1 -do -1 300 000 021 021 000;
data 2 -do -1 300 000 021 021 000;
data 3 300 000 042 042 000;

page -all;


/*		ad2d15
*		test 4bit scaled to 9 bit
*
*/

inst	ad2d	-nt "4bit->9bit"
-io 1
-mf1 ar rl 5 idb
-mf2 ar rl 5 idb reg;

desc 1 -tn 4 -sd l;
desc 2 -sd n;

data 1 30102100;
data 2 -do 4 "02222";
data 3  "03332";

page -all;


/*		ad2d16
*		test 9 floating to 4 floating
*
*/

inst	ad2d	-nt "9float->4 float"
-io 1
-mf1 ar rl 5 idb reg
-mf2 ar rl 7 idb;

desc 1 -sd f;
desc 2 -sd f -tn 4;

data 1 "+" (3) "1" 000;
data 2 300 042 040 00;
data 3 30006306000;

page -all;


/*		ad2d17
*		4 float to 9 float
*
*/

inst	ad2d	-nt "4float -> 9float"
-io 1
-mf1 ar rl 7 idb
-mf2 ar rl 7 idb reg;

desc 1 -sd f -tn 4 ;
desc 2 -sd f;

data 1 300 042 040 00;
data 2 "+0" (3) "1" "0" 000;
data 3 "+01332" 000;

page -all;


/*		ad2d18
*		9 scaled to 9 float
*
*/

inst	ad2d	-nt "9sacled to 9 float"
-io 2
-mf1 ar rl 5 idb reg
-mf2 ar rl 6 idb reg;

desc1 -sd l;
desc2 -sd f;

data 1 "+" (4) "3";
data 2 "+" "0" (3) "2" 000;
data 3 "+" "3555" 000;

page -all;


/*		ad2d19
*		9 float to 9 scaled
*
*/

inst	ad2d	-nt "9 float to 9 scaled"
-io 2
-mf1 ar rl 6 idb reg
-mf2 ar rl 5 idb reg;

desc1 -sd f;
desc2 -sd l;

data 1 "+" "0" (3) "2" 000;
data 2 "+" (4) "3";
data 3 "+"  "3555";

page -all;


/*		ad2d20
*		9 scaled to 4 float
*
*/

inst	ad2d	-nt "9scaled->4float"
-io 2

-mf1 ar rl 5 idb reg
-mf2 ar rl 6 idb;

desc 1 -sd l;
desc 2 -sd f -tn 4;

data 1 "+0" (3) "2";
data 2 303063 000;
data 3 305125000;

page -all;


/*		ad2d21
*		9 float to 4 scaled
*
*/

inst	ad2d	-nt "9float->4scaled"
-io 1
-mf1 ar rl 6 idb reg
-mf2 ar rl 4 idb;

desc 1 -sd f;
desc 2 -sd l -tn 4;

data 1 -do -1 "+0" (3) "2" 000;
data 2 -do -2 303 063;
data 3 305125;

page -all;


/*		ad2d22
*		4scaled to 9 float
*
*/

inst	ad2d	-nt "4scaled-.9float"
-io 1
-mf1 ar rl 4 idb
-mf2 ar rl 6 idb reg;

desc 1 -sd l -tn 4;
desc 2 -sd f;

data 1 -do -1 303063;
data 2 -do -1 "+0" (3) "2" 000;
data 3 "+0" (3) "5" 000;

page -all;


/*		ad2d23
*		4 floating to 9 scaled
*
*/

inst	ad2d	 -nt "4float->9scaled"
-io 1
-mf1 ar rl 6 idb
-mf2 ar rl 5 idb reg;

desc 1 -sd f -tn 4;
desc 2 -sd n;

data 1 -do -1 303 063 000;
data 2 -do -2 "00" "555";
data 3 "00" "888";

page -all;


/*		ad2d24
*		4 scaled to 4 float
*
*/

inst	ad2d	-nt "4scaled to 4 float"
-io 1
-mf1 ar rl 4 idb
-mf2 ar rl 6 idb;

desc 1 -tn 4 -sd l;
desc 2 -tn 4 -sd f;

data 1 -do -1 303 063;
data 2 -do -1 302042000;
data 3 305125 000;

page -all;


/*		ad2d25
*		4 floating to 4 scaled
*
*/

inst	ad2d	-nt "4 floating to 4 scaled"
-io 2
-mf1 ar rl 6 idb
-mf2 ar rl 4 idb;

desc 1 -tn 4 -sd f;
desc 2 -tn 4 -sd l;

data 1 -do -1 302042000;
data 2 -do -1 303 063;
data 3 305125;

page -all;


/*		ad2d26
*
*	Use  RL  mod and strings of length 63  and  cn  fields.
*/


inst	ad2d	-nt "63 char string"	-io 2
	-mf1	rl 63	idb reg ar
	-mf2	rl 63	idb reg ar;

desc 1	-sd n	-cn 1;
desc 2	-sd n	-cn 2;

data 1	-do -21	" " 	"234"  (15) "1234";
data 2	-do -22	"**"	"345"  (15) "2345";
data 3	"**"  "579"  (15) "3579";	/* This is just test data.  This is how  descriptor 2
				*  data is going to look after the  ad2d.  */


page	-all;


/*		sb3d1
*		a simple test
*		no modification used
 - 		9 bit - 9 bit to 9 bit
*
*/

inst	sb3d	-nt"9bit-9bit->9bit"
-io 2;

desc1 -sd l -cn 1 -nn 10;
desc2 -sd l -cn 1 -nn 10;
desc3 -sd l -cn 1 -nn 10;

data 1 " -" (9) "1";
data 2 " +" (9) "1";
data 3 000 "+" (9) "2";

page -all;


/*		sb3d2
*		9 bit - 9 bit to 9 bit
*		negative indicator on
*		all page faults taken
*
*/

inst	sb3d	-nt "9 bit - 9bit to 9 bit"
-io 1 -ir ng
-mf1 ar rl 23 idb reg
-mf2 ar rl 24 idb reg
-mf3 ar rl 24 idb reg;

desc1 -sd t -cn 2;
desc2 -sd t -cn 1;
desc3 -sd l -cn 3;

data 1 -do -9 "  " (5) "0" (8) "12" "1+";
data 2 -do -11 " " (6) "0" (8) "23" "2-";
data 3 000000000 "-"  (6) "0" (8) "35" "3";

page -all;


/*		sb3d3
*		9 bit scaled to 4 bit float to
*		 4 bit float
*
*/

inst	sb3d	-nt "4bit float-9bit to 4bit"
-io 2 -ir ng
-mf1 ar rl 10 idb reg
-mf2 ar rl 10 idb
-mf3 ar rl 10 idb;

desc1 -sd t -cn 1;
desc2 -sd f -tn 4;
desc3 -sd f -tn 4;

data 1 -do -10 " " (5) "0" (4) "2" "+";
data 2 -do -4 300 000 021 021 000;
data 3  -do -4 320 000 021 021 000;

page -all;


/*		sb3d4
*		9 bit scaled - 9 bit scaled to
*		9 bit scaled
*		all page faults taken
*		truncation indicator set
*
*/

inst	sb3d	-nt "9bit-9bit to 9bit"
-io 2 -ir tn
-mf1 ar rl 63 idb reg
-mf2 ar rl 63 idb reg
-mf3 ar rl 63 idb reg;

desc1 -cn 1 -sd l -sf 5;
desc2 -cn 2 -sd l -sf 10;
desc3 -cn 3 -sd l -sf 10;

data 1 -do 4033 " -" (5) "0" (19) "543";
data 2 -do 4034 "  +" (5) "0" (19) "765";
data 3 -do 4035 (3) 000 "+"  (5) "0" "76577" (17) "120" "0";

page -all;


/*		sb3d5
*		9 bit scaled - 9 bit scaled tp
*		9 bit scaled
*		 all page faults taken
*		rounding desired, therefore no truncation
*
*/

inst	sb3d	-nt "no truncation"
-io 3
-mf1 ar rl 63 idb reg
-mf2 ar rl 63 idb reg
-mf3 ar rl 63 idb reg
-rb;

desc1 -cn 1 -sd l -sf 5;
desc2 -cn 2 -sd l -sf 10;
desc3 -cn 1 -sd l -sf 10;

data 1 -do 4033 " -" (5) "0" (19) "543";
data 2 -do 4034 "  +" (5) "0" (19) "765";
data 3 -do 4033 000 "+" (5) "0" "76577" (17) "120" "0";

page -all;


/*		sb3d6
*		all operands 4 bit scaled
*		all page faults taken
*		 negative indicator set
*
*/

inst	sb3d	-nt "4 bit-4bit to 4bit scaled"
-io 1 -ir ng
-mf1 ar rl 63 idb
-mf2 ar rl 63 idb
-mf3 ar rl 63 idb;

desc1 -sd l -tn 4 -cn 1;
desc2 -sd l -tn 4 -cn 1;
desc3 -sd l -tn 4 -cn 1;

data 1 " " 300 (26) 000 (4) 105 (8) 000;
data 2 " " 300 (26) 000 (3) 105 104 (7) 000;
data 3 000320 (29) 000 001 (8) 000;

page -all;


/*		sb3d7
*		9 bit scaled - 9 bit scaled to
*		9 bit scaled
*		all page faults taken
*		 rounding desired and it occurs
*
*/

inst	sb3d	-nt "rounded result"
-io 2 -rb
-mf1 ar rl 63 idb reg
-mf2 ar rl 63 idb reg
-mf3 ar rl 63 idb reg;

desc1 -cn 1 -sd l -sf 5;
desc2 -cn 1 -sd l -sf 10;
desc3 -sd l -cn 1 -sf 10;

data 1 -do 4033 " -" (5) "0" (17) "543" "043543";
data 2 -do 4033 " +" (5) "0" (19) "765";
data 3 -do 4033 000 "+" (5) "0" "76577" (16) "120" "1195";

page -all;


/*		sb3d8
*		all operands 9 bit float
*		all page faults taken
*		no rounding needed
:
*/

inst	sb3d	-nt "9 bit floating"
-io 1
-mf1 ar rl 10 idb reg
-mf2 ar rl 10 idb reg
-mf3 ar rl 10 idb reg;

desc1 -sd f -cn 1;
desc2 -sd f -cn 1;
desc3 -sd f -cn 1;

data 1 -do -10 " -" (8) "1" 001;
data 2 -do -10 " +" (8) "2" 001;
data 3 -do -10 000 "+" (8) "3" 001;

page -all;


/*		sb3d9
*		all operands 9 bit floating
*		rounding not desired, but required
*		set round bit
*
*/

inst	sb3d	-nt "round floating"
-io 2 -rb
-mf1 ar rl 10 ida
-mf2 ar rl 10 ida
-mf3 ar rl 10 ida;

desc1 -cn 1 -sd f;
desc2 -cn 1 -sd f;
desc3 -sd f;

data 1 " +" (8) "3" 000;
data 2 " +" (8) "9" 001;
data 3 "+" "9" (7) "6" 001;

page -all;


/*		sb3d10
*		all operands 9 bit floating
*		truncation will occur
*
*/

inst	sb3d	-nt "truncation"
-io 3 -ir tn
-mf1 ar rl 10
-mf2 ar rl 10
-mf3 ar rl 10;

desc1 -sd f;
desc2 -sd f;
desc3 -sd f;

data 1 "+" (8) "3" 000;
data 2 "+" (8) "9" 001;
data 3 "+" "9" (6) "6" "5" 001;

page -all;


/*		sb3d11
*		all operands 9 bit floating
*		truncation will occur
:
*/

inst	sb3d	-nt "truncation"
-ir ng tn 
-mf1 ar rl 10
-mf2 ar rl 10
-mf3 ar rl 10;

desc1 -sd f;
desc2 -sd f;
desc3 -sd f;

data 1 -do -4 "+" (8) "3" 000;
data 2 -do -4 "-" (8) "9" 001;
data 3 -do -4 "-" "10" (6) "3" 002;

page -all;


/*		sb3d12
*		4 scaled - 4 scaled to 4 float
*
*/

inst	sb3d	-nt "4sc-4sc->4float"
-io 3
-mf1 ar rl 4 idb
-mf2 ar rl 4 idb
-mf3 ar rl 6 idb;

desc 1 -tn 4 -sd l;
desc 2 -tn 4 -sd l;
desc 3 -tn 4 -sd f;

data 1 -do -1  323 063;
data 2 -do -1 302 042;
data 3 -do -1  305 125 000;

page -all;


/*		sb3d13
*		4 scaled -4 float to 4 scaled
*
*/

inst	sb3d	-nt "4scaled-4float to 4 scaled"
-io 2
-mf1 ar rl 6 idb
-mf2 ar rl 4 idb
-mf3 ar rl 4 idb;

desc 1 -tn 4 -sd f;
desc 2 -tn 4 -sd l;
desc 3 -tn 4 -sd l;

data 1 -do -1 323 063 000;
data 2 -do -1 302 042;
data 3 -do -1 305 125;

page -all;


/*		sb3d14
*		4 floating - 9 scaled to 9 floating
*
*/

inst	sb3d	 -nt "4float-9scaled->9float"
-io 1
-mf1 ar  rl 4 idb reg
-mf2 ar rl 6 idb
-mf3 ar rl 5 idb reg;

desc 1 -sd t;
desc 2 -sd f -tn 4;
desc 3 -sd f;

data 1 -do -3 "333-";
data 2 -do -2 302 042 000;
data 3 -do -4 "+555" 000;

page -all;


/*		sb3d15
*		9 scaled - 4 bit to 9 scaled
*
*/

inst	sb3d	-nt "9bit-4bit->9bit"
-io 1
-mf1 ar rl 5 idb
-mf2 ar rl 5 idb reg
-mf3 ar rl 5 idb reg;

desc 1 -tn 4 -sd l;
desc 2 -sd n;
desc 3 -sd n;

data 1 -do -1 321 02100;
data 2 -do 4 "02222";
data 3 -do -1 "03332";

page -all;


/*		sb3d16
*		4float-9float to 4 float
*
*/

inst	sb3d	-nt "4flo-9flo->4flo"
-io 1
-mf1 ar rl 5 idb reg
-mf2 ar rl 7 idb
-mf3 ar rl 7 idb;

desc 1 -sd f;
desc 2 -sd f -tn 4;
desc 3 -sd f -tn 4;

data 1 -do -1 "-" (3) "1" 000;
data 2 -do -1 300 042 040 00;
data 3 -do -1 30006306000;

page -all;


/*		sb3d17
*		9 float - 4 float to 9 float
*
*/

inst	sb3d	-nt "9flo-4flo->9flo"
-io 1
-mf1 ar rl 7 idb
-mf2 ar rl 7 idb reg
-mf3 ar rl 7 idb reg;

desc 1 -sd f -tn 4 ;
desc 2 -sd f;
desc 3 -sd f;

data 1 -do -1 320 042 040 00;
data 2 -do -1 "+0" (3) "1" "0" 000;
data 3 -do -1 "+01332" 000;

page -all;


/*		sb3d18
*		9 float-9 scaled to 9 float
*
*/

inst	sb3d	-nt "9flo-9sca->9flo"
-io 2
-mf1 ar rl 5 idb reg
-mf2 ar rl 6 idb reg
-mf3 ar rl 6 idb reg;

desc1 -sd l;
desc2 -sd f;

data 1 -do -1 "-" (4) "3";
data 2  -do -1 "+" "0" (3) "2" 000;
data  3 -do -1 "+" "3555" 000;

page -all;


/*		sb3d19
*		9scaled - 9 floating to 9 scaled
*
*/

inst	sb3d	-nt "9sca-9flo->9sca"
-io 2
-mf1 ar rl 6 idb reg
-mf2 ar rl 5 idb reg
-mf3 ar rl 5 idb reg;

desc1 -sd f;
desc2 -sd l;
desc 3 -sd l;

data 1 -do -1 "-" "0" (3) "2" 000;
data 2  -do -1 "+" (4) "3";
data 3  -do -1 "+"  "3555";

page -all;


/*		sb3d20
*		4 float - 9 scaled to 4 float
*
*/

inst	sb3d	-nt "4flo-9sca->9sca"
-io 2

-mf1 ar rl 5 idb reg
-mf2 ar rl 6 idb
-mf3 ar rl 6 idb;

desc 1 -sd l;
desc 2 -sd f -tn 4;
desc 3 -sd f -tn 4;

data 1 -do -1 "-0" (3) "2";
data 2 -do -1 303063 000;
data 3 -do -1 305125000;

page -all;


/*		sb3d21
*		4scaled - 9 float to 4 scaled
*
*/

inst	sb3d	-nt "4sca-9flo->4sca"
-io 1
-mf1 ar rl 6 idb reg
-mf2 ar rl 4 idb
-mf3 ar rl 4 idb;

desc 1 -sd f;
desc 2 -sd l -tn 4;
desc 3 -sd l -tn 4;

data 1 -do -1 "-0" (3) "2" 000;
data 2 -do -2 303 063;
data 3 305125;

page -all;


/*		sb3d22
*		9 float - 4 scaled to 9 float
*
*/

inst	sb3d	-nt "9flo-4sca->9flo"
-io 1
-mf1 ar rl 4 idb
-mf2 ar rl 6 idb reg
-mf3 ar rl 6 idb reg;

desc 1 -sd l -tn 4;
desc 2 -sd f;
desc 3 -sd f;

data 1 -do -1 323063;
data 2 -do -1 "+0" (3) "2" 000;
data 3 "+0" (3) "5" 000;

page -all;


/*		sb3d23
*		9 scaled - 4 floating to 9 scaled
*
*/

inst	sb3d	 -nt "9sca-4flo->9sca"
-io 1
-mf1 ar rl 6 idb
-mf2 ar rl 5 idb reg
-mf3 ar rl 5 idb reg;

desc 1 -sd f -tn 4;
desc 2 -sd n;
desc 3 -sd n;

data 1 -do -1 323 063 000;
data 2 -do -2 "00" "555";
data 3 "00" "888";

page -all;


/*		sb3d24
*		4 float - 4 scaled to 4 float
*
*/

inst	sb3d	-nt "4flo-4sca->4flo"
-io 1
-mf1 ar rl 4 idb
-mf2 ar rl 6 idb
-mf3 ar rl 6 idb;

desc 1 -tn 4 -sd l;
desc 2 -tn 4 -sd f;
desc 3 -tn 4 -sd f;

data 1 -do -1 323 063;
data 2 -do -1 302042000;
data 3 305125 000;

page -all;


/*		sb3d25
*		4 scaled - 4 floatint to 4 scaled
*
*/

inst	sb3d	-nt "4sca-4flo->4flo"
-io 2
-mf1 ar rl 6 idb
-mf2 ar rl 4 idb
-mf3 ar rl 4 idb;

desc 1 -tn 4 -sd f;
desc 2 -tn 4 -sd l;
desc 3 -tn 4 -sd l;

data 1 -do -1 322042000;
data 2 -do -1 303 063;
data 3 305125;

page -all;


/*		sb3d26
*
*	Subtraction yields a zero number.
*/

inst	sb3d	-nt "Result = zero"  -io 1
	-ir	zr
	-mf1	ar
	-mf2	ida
	-mf3	ar reg idb  rl 12;

desc 1	-sd l	-nn 7	-sf 2;

desc 2	-sd t	-nn 6	-sf 3;

desc 3	-sd n	-sf -4;


data 1	-do -3	053 "55"  "5550";

data 2	-do -4	"5555"  "5" 053;

data 3	-do -2	"00"  "0000000000";


page	-all;


/*     sb2d1
*  The zero indicator is set.
*  Two 4-bit floating point operands are used.
*  The maximum number of page faults is taken.
*  Indirect descriptors are used for all operands.  
*  Address register modification is used for all operands.  */

inst sb2d -nt "4 bit - 4 bit -> 4 bit"
-ir zr
-mf1 idb ar
-mf2 idb ar
-io 1;

desc 1 -tn 4 -sd f -nn 63;
desc 2 -tn 4 -sd f -nn 63;

data 1 -do -1 261 (30)021 00;
data 2 -do -31 261 (30)021 00;
data 3 300 (29)000 007 36;

page -all;


/*     sb2d2
*  The zero indicator is set.
*  Two 4-bit operands with leading sign are used.
*  The maximum number of page faults is taken.
*  Indirect descriptors are used for all operands.  
*  Address register modification is used for all operands.  */

inst sb2d -nt "4 bit - 4 bit -> 4 bit"
-ir zr
-mf1 idb ar
-mf2 idb ar
-io 2;

desc 1 -tn 4 -sd l -sf 5 -nn 4;
desc 2 -tn 4 -sd l -sf 4 -nn 5;

data 1 -do -1 263 222;
data 2 -do -2 263 222;
data 3 300 000 00;

page -all;


/*     sb2d3
*  The negative indicator is set.
*  Two 9-bit floating point operands are used.
*  The maximum number of page faults is taken.
*  Indirect descriptors are used for all operands.  
*  Address register modification is used for all operands.  */

inst sb2d -nt "9 bit - 9 bit -> 9 bit"
-ir ng
-mf1 idb ar reg
-mf2 idb ar reg
-io 1;

desc 1 -sd f -nn 18;
desc 2 -sd f -nn 18;

data 1 -do -14 "+" (3)"98765" "8" 007;
data 2 -do -4  "+" (3)"32411" "7" 007;
data 3 "-" (3)"66354" "1" 007;

page -all;


/*     sb2d4
*  The negative indicator is set.
*  Two 9-bit operands with trailing sign are used.
*  The maximum number of page faults is taken.
*  Indirect descriptors are used for all operands.  
*  Address register modification is used for all operands.  */

inst sb2d -nt "9 bit - 9 bit -> 9 bit"
-ir ng
-mf1 idb ar reg
-mf2 idb ar reg
-io 2;

desc 1 -sd t -sf 5 -nn 25;
desc 2 -sd t -sf 5 -nn 25;

data 1 -do -23 (24) "5" "+";
data 2 -do -4  (24) "4" "-";
data 3 (24) "9" "-";

page -all;


/*     sb2d5
*  The truncation indicator is set.
*  Two 4-bit floating point operands are used.
*  The maximum number of page faults is taken.
*  Indirect descriptors are used for all operands.  
*  Address register modification is used for all operands.  */

inst sb2d -nt "4 bit - 4 bit -> 4 bit"
-ir tn
-mf1 idb ar
-mf2 idb ar
-io 2;

desc 1 -tn 4 -sd f -nn 8;
desc 2 -tn 4 -sd f -nn 8;

data 1 -do -2 331 231 231 004;
data 2 -do -2 270 166 124 003;
data 3     301 010 166 005;

page -all;


/*     sb2d6
*  The truncation indicator is set.
*  Two 9-bit leading sign operands are used.
*  The maximum number of page faults is taken.
*  Indirect descriptors are used for all operands.  
*  Address register modification is used for all operands.  */

inst sb2d -nt "9 bit - 9 bit -> 9 bit"
-ir tn
-mf1 idb ar reg
-mf2 idb ar reg
-io 2;

desc 1 -sd l -sf 4 -nn 63;
desc 2 -sd l -sf 5 -nn 62;

data 1 -do -60 "+" (62)"3";
data 2 -do -3 "+" (61)"9";
data 3 "+" (60)"6" "5";

page -all;


/*     sb2d7
*  Rounding is tested.
*  Two 9-bit trailing sign operands are used.
*  The maximum number of page faults is taken.
*  Indirect descriptors are used for all operands.  
*  Address register modification is used for all operands.  */

inst sb2d -nt "9 bit - 9 bit -> 9 bit"
-rb
-mf1 idb ar reg
-mf2 idb ar reg
-io 1;

desc 1 -sd t -sf 4 -nn 63;
desc 2 -sd t -sf 5 -nn 62;

data 1 -do -38 (62)"3" "+";
data 2 -do -36 (61)"9" "+";
data 3 (61)"6" "+";

page -all;


/*     sb2d8
* The overflow indicator is set.
*  Two 4-bit trailing sign operands are used.
*  Indirect descriptors are used for all operands.  
*  Address register modification is used for all operands.  */

inst sb2d -nt "4 bit - 4 bit -> 4 bit"
-ir ov
-mf1 idb ar
-mf2 idb ar
-io 2;

desc 1 -tn 4 -sd t -sf 3 -nn 7;
desc 2 -tn 4 -sd t -sf 3 -nn 7;

data 1 (3)163 32;
data 2 (3)231 26;
data 3 163 163 162 300;

page -all;


/*     sb2d9
*  The exponent overflow indicator is set.
*  Two  4-bit  floating point operands are used.
*  Indirect descriptors are used for all operands.  
*  Address register modification is used for all operands.  */

inst sb2d -nt "4 bit - 4 bit -> 4 bit"
-ir eo tn
-mf1 idb ar
-mf2 idb ar
-io 1;

desc 1 -tn 4 -sd f -nn 8 -cn 1;
desc 2 -tn 4 -sd f -nn 8 -cn 1;

data 1 -do -1 00 330 210 210 177;
data 2 -do -4 00 267 167 167 177;
data 3 00 301 146 146 200;

page -all;


/*     sb2d10
*  Leading and trailing signs are mixed.
*  Two 9-bit operands are used.
*  The maximum number of page faults is taken.
*  Indirect descriptors are used for all operands.  
*  Address register modification is used for all operands.  */

inst sb2d -nt "9 bit - 9 bit -> 9 bit"
-mf1 idb ar reg
-mf2 idb ar reg
-io 2;

desc 1 -sd l -sf -8 -nn 42;
desc 2 -sd t -sf -8 -nn 42;

data 1 -do -40 "+" (4)"1234000000" "9";
data 2 -do -2 (4)"9876543210" "9" "+";
data 3 (4) "8642543210" "0+";

page -all;


/*     sb2d11
*  Leading sign and floating point operands are mixed.
*  Two 4-bit operands are used.
*  The maximum number of page faults is taken.
*  Indirect descriptors are used for all operands.  
*  Address register modification is used for all operands.  */

inst sb2d -nt "4 bit - 4 bit -> 4 bit"
-mf1 idb ar
-mf2 idb ar
-io 1;

desc 1 -tn 4 -sd l -nn 8;
desc 2 -tn 4 -sd f -nn 10;

data 1 -do -1 271 043 064 000;
data 2 -do -1 271 207 145 000 000;
data 3 300 144 061 000 000;

page -all;


/*     sb2d12
*  A leading sign 9-bit and an unsigned 4-bit operand are mixed.
*  The maximum number of page faults is taken.
*  Indirect descriptors are used for all operands.  
*  Address register modification is used for all operands.  */

inst sb2d -nt "9 bit - 4 bit -> 4 bit"
-mf1 idb ar reg
-mf2 idb ar
-io 2;

desc 1 -sd l -nn 8;
desc 2 -sd n -tn 4 -nn 7;

data 1 -do -1  "+" "1234500";
data 2 -do -1 230 166 120 00;
data 3 206 102 000 00;

page -all;


/*     sb2d13
*  Unsigned 4-bit and 9-bit operands are mixed.
*  The maximum number of page faults is taken.
*  Indirect descriptors are used for all operands.  
*  Address register modification is used for all operands.  */

inst sb2d -nt "4 bit - 9 bit -> 9 bit"
-mf1 idb ar
-mf2 idb ar reg
-io 1;

desc 1 -sd n -sf 31 -tn 4 -nn 7;
desc 2 -sd n -sf 31 -nn 7;

data 1 -do -1 022 064 120 00 ;
data 2 -do -3 "9876500";
data 3 "8642000";

page -all;


/*     sb2d14
*  Floating point and trailing sign operands are mixed.
*  Two 9-bit operands are used.
*  The maximum number of page faults is taken.
*  Indirect descriptors are used for all operands.  
*  Address register modification is used for all operands.  */

inst sb2d -nt "9 bit - 9 bit -> 9 bit"
-mf1 idb ar reg
-mf2 idb ar reg
-io 2;

desc 1 -sd f -nn 9;
desc 2 -sd t -sf 12 -nn 8;

data 1 -do -7 "+" "1234500" 014;
data 2 -do -3  "9876500" "+";
data 3 "8642000" "+";

page -all;


/*     sb2d15
*  The special plus sign capability for 4-bit operands is tested.
*  Indirect descriptors are used for all operands.  
*  Address register modification is used for all operands.  */

inst sb2d -nt "4 bit - 4 bit -> 4 bit"
-pb
-mf1 idb ar
-mf2 idb ar
-io 1;

desc 1 -sd l -nn 7;
desc 2 -sd l -tn 4 -nn 8;

data 1 -do -7 "+" "1234500";
data 2 -do -2  261 043 105 000;
data 3 261 021 020 120;

page -all;


/*		mp3d1
*		9 bit scaled * 9 bit scaled to
*		9 bit scaled
*		all page faults taken
*		 rounding desired and it occurs
*
*/

inst	mp3d	-nt "rounded result"
-io 2 -rb
-mf1 ar rl 63 idb reg
-mf2 ar rl 63 idb reg
-mf3 ar rl 63 idb reg;

desc1 -cn 1 -sd l -sf 5;
desc2 -cn 1 -sd l -sf 10;
desc3 -sd l -cn 1 -sf 20;

data 1 -do 4033 " +" (20) "0" (12) "543" "043543";
data 2 -do 4033 " +" (47) "0" (5) "765";
data 3 -do 4033 000 "+000000000041622703784865905405405405405405405"
          "36711707549441337";

page -all;


/*		mp3d2
*		a simple test
*		no modification used
*		9 bit*9 bit to 9 bit
*
*/

inst	mp3d	-nt"9bit*9bit->9bit"
-io 2 -ir ov ng;

desc1 -sd l -cn 1 -nn 10;
desc2 -sd l -cn 1 -nn 10;
desc3 -sd l -cn 1 -nn 10;

data 1 " -" (9) "1";
data 2 " +" (9) "1";
data 3 000 "-"  "987654321";

page -all;


/*		mp3d3
*		9 bit*9 bit to 9 bit
*		negative indicator on
*		all page faults taken
*
*/

inst	mp3d	-nt "9 bit*9bit to 9 bit"
-io 1 -ir ng
-mf1 ar rl 23 idb reg
-mf2 ar rl 24 idb reg
-mf3 ar rl 24 idb reg;

desc1 -sd t -cn 2;
desc2 -sd t -cn 1;
desc3 -sd l -cn 3;

data 1 -do -9 "  " (15) "0" (3) "12" "1+";
data 2 -do -11 " " (16) "0" (3) "23" "2-";
data 3 (3) 000 "-" (10) "0" "2816038295072";

page -all;


/*		mp3d4
*		9 bit scaled to 4 bit float to
*		 4 bit float
*
*/

inst	mp3d	-nt "4bit float*9bit to 4bit"
-io 2 
-mf1 ar rl 10 idb reg
-mf2 ar rl 10 idb
-mf3 ar rl 10 idb;

desc1 -sd t -cn 1;
desc2 -sd f -tn 4;
desc3 -sd f -tn 4;

data 1 -do -10 " " (5) "0" (4) "2" "+";
data 2 -do -4 300 000 000 021 000;
data 3 -do -4 300 002 104 102 000;

page -all;


/*		mp3d5
*		9 bit scaled*9 bit scaled to
*		9 bit scaled
*		all page faults taken
*		truncation indicator set
*
*/

inst	mp3d	-nt "9bit*9bit to 9bit"
-io 2 
-mf1 ar rl 63 idb reg
-mf2 ar rl 63 idb reg
-mf3 ar rl 63 idb reg;

desc1 -cn 1 -sd l  ;
desc2 -cn 2 -sd l -sf 1;
desc3 -cn 3 -sd l -sf 1;

data 1 -do 4033 " +" (5) "0" (19) "543";
data 2 -do 4034 "  +" (60) "0" "11";
data 3 -do 4035 (3) 000 "+" (4) "0" "5" (18) "978" "973";

page -all;


/*		mp3d6
*		9 bit scaled*9 bit scaled tp
*		9 bit scaled
*		 all page faults taken
*		rounding desired, therefore no truncation
*
*/

inst	mp3d	-nt "no truncation"
-io 3 -ir ng
-mf1 ar rl 63 idb reg
-mf2 ar rl 63 idb reg
-mf3 ar rl 63 idb reg
-rb;

desc1 -cn 1 -sd l -sf 5;
desc2 -cn 2 -sd l -sf 10;
desc3 -cn 1 -sd l -sf 10;

data 1 -do 4033 " -" (53) "0" (3) "543";
data 2 -do 4034 "  +" (53) "0" (3) "765";
data 3 -do 4033 000 "-" (39) "0" "416227037016205395" (5) "0";

page -all;


/*		mp3d7
*		all operands 4 bit scaled
*		all page faults taken
*		 negative indicator set
*
*/

inst	mp3d	-nt "4 bit*4bit to 4bit scaled"
-io 1 
-mf1 ar rl 63 idb
-mf2 ar rl 63 idb
-mf3 ar rl 63 idb;

desc1 -sd l -tn 4 -cn 1;
desc2 -sd l -tn 4 -cn 1;
desc3 -sd l -tn 4 -cn 1;

data 1 " " 300 (26) 000 (4) 105 (8) 000;
data 2 " " 300 (26) 000 (3) 105 104 (7) 000;
data 3 000300 (21) 000 002 006 141 025 141 127 002 110 (9) 000;

page -all;


/*		mp3d8
*		all operands 9 bit float
*		all page faults taken
*		no rounding needed
*
*/

inst	mp3d	-nt "9 bit floating"
-io 1
-mf1 ar rl 10 idb reg
-mf2 ar rl 10 idb reg
-mf3 ar rl 10 idb reg;

desc1 -sd f -cn 1;
desc2 -sd f -cn 1;
desc3 -sd f -cn 1;

data 1 -do -10 " +" (4) "0" (4) "1" 001;
data 2 -do -10 " +" (4) "0" (4) "2" 001;
data 3 -do -10 000 "+" "02468642" 002;

page -all;


/*		mp3d9
*		all operands 9 bit floating
*		rounding not desired, but required
*		set round bit
*
*/

inst	mp3d	-nt "round floating"
-io 2 -rb
-mf1 ar rl 10 ida
-mf2 ar rl 10 ida
-mf3 ar rl 10 ida;

desc1 -cn 1 -sd f;
desc2 -cn 1 -sd f;
desc3 -sd f;

data 1 " +" (4) "0" (4) "3" 002;
data 2 " +" (4) "0" (4) "9" 001;
data 3 "+"  (3) "3" "26667" 003;

page -all;


/*		mp3d10
*		all operands 9 bit floating
*		truncation will occur
*
*/

inst	mp3d	-nt "truncation"
-io 3 -ir tn
-mf1 ar rl 10
-mf2 ar rl 10
-mf3 ar rl 10;

desc1 -sd f;
desc2 -sd f;
desc3 -sd f;

data 1 "+" (3) "0" (5) "3" 000;
data 2 "+" (4) "0" (4) "9" 001;
data 3 "+" (3) "3" "29666" 002;

page -all;


/*		mp3d11
*		 set zero indicator, use three 9-bit operands  
*
*/
inst	mp3d	-nt"9sca*9sca->9sca"
-ir zr
-mf1 idb ar reg
-mf2 idb ar reg
-mf3 idb ar reg
-io 1;

desc 1 -sd f -nn 63;
desc 2 -sd f -nn 63;
desc 3 -sd f -nn 63;

data 1 "+" (61)"0" 000 -do -62;
data 2 "-" (61)"9" 034 -do -34;
data 3 "+" (61)"0" 177;

page -all;


/*		mp3d12
*
 set zero indicator, use  three 9-bit leading sign operands  
*
*/
inst	mp3d	-nt"9sca*9sca->9sca"
-ir zr
-mf1 idb ar
-mf2 idb ar
-mf3 idb ar
-io 2;

desc 1 -sd l -sf 10 -nn 7;
desc 2 -sd l -sf 10 -nn 28;
desc3 -sd l -sf 10 -nn 28;

data 1 -do -4 "-" (6)"4";
data 2 -do -24 "+" (27)"0";
data 3 "+" (27)"0";

page -all;


/*		mp3d13
*
*		 set negative indicator, use three 4-bit floating operands  
*
*/

inst	 mp3d	-nt "4float*4float->4float"
-ir ng
-mf1 idb ar
-mf2 idb ar
-mf3 idb ar
-io 1;

desc 1 -tn 4 -sd f -nn 6;
desc 2 -tn 4 -sd f -nn 6;
desc 3 -tn 4 -sd f -nn 6;

data 1 260  061 004;
data 2 320 050 004;
data 3 330 150 010;

page -all;


/*		mp3d14
*
*		set negative indicator, use three  4-bit leading sign operands  
*
*/

inst	mp3d	-nt "4sca*4sca->4sca"
-ir ng
-mf1 idb ar
-mf2 idb ar
-mf3 idb ar
-io 2;

desc 1 -tn 4 -sd l -sf 2 -nn 4;
desc 2 -tn 4 -sd l -sf 2 -nn 6;
desc 3 -tn 4 -sd l -sf 2 -nn 6;

data 1 260 061;
data 2 320 000 050;
data 3 330 150 000;

page -all;


/*		mp3d15
*
*		set truncation indicator, use three 4-bit floating operands  
*
*/

inst	mp3d	-nt "4float*4float->4float"
-ir tn
-mf1 idb ar
-mf2 idb ar
-mf3 idb ar
-io 1;

desc 1 -tn 4 -sd f -nn 6;
desc 2 -tn 4 -sd f -nn 6;
desc 3 -tn 4 -sd f -nn 6;

data 1 266 130 012;
data 2 260 022 013;
data 3 307 211 026;

page -all;


/*		mp3d16
*
*		set truncation indicator, use three 4-bit leading sign operands  
*
*/

inst	mp3d	-nt "4sca*4sca->4sca"
-ir tn
-mf1 idb ar
-mf2 idb ar
-mf3 idb ar
-io 2;

desc 1 -tn 4 -sd l -sf -1 -nn 2 -cn 1;
desc 2 -tn 4 -sd l -sf 4  -nn 5 -cn 1;
desc 3 -tn 4 -sd l -sf 4 -nn 5;

data 1 00 271;
data 2 00 261 043 10;
data 3 301 021 00;

page -all;


/*		mp3d17
*
*		test rounding, use three 4-bit trailing sign operands  
*
*/

inst	mp3d	-nt "4sca*4sca->4sca"
-rb
-mf1 idb ar
-mf2 idb ar
-mf3 idb ar
-io 1;

desc 1 -tn 4 -sd t -sf -1 -cn 1 -nn 2;
desc 2 -tn 4 -sd t -sf 4 -nn 5;
desc 3 -tn 4 -sd t -sf 4 -nn 5;

data 1 -do -1 00 233;
data 2 -do -2 022 064 30;
data 3 021 021 30;

page -all;


/*		mp3d18
*
*		 set overflow indicator, use three 9-bit unsigned operands  
*
*/

inst	mp3d	-nt "9sca*9sca->9sca"
-ir ov
-mf1 idb ar reg
-mf2 idb ar reg
-mf3 idb ar reg
-io 2;

desc 1 -sd n -nn 3;
desc 2 -sd n -nn 5;
desc 3 -sd n -nn 5;

data 1 -do -1 "999";
data 2 -do -4 "00999";
data 3 "98001";

page -all;


/*		mp3d19
*
*		set exponent overflow indicator, use three 9-bit floating operands  
*
*/

inst	mp3d	-nt "9flo*9flo->9flo"
-ir eo tn
-mf1 idb ar reg
-mf2 idb ar reg
-mf3 idb ar reg
-io 1;

desc 1 -sd f -nn 6;
desc 2 -sd f -nn 6;
desc 3 -sd f -nn 6;

data 1 -do -4 "+" "0900" 100;
data 2 -do -1 "+" "0756" 076;
data 3  "+" "6804" 200;

page -all;


/*		mp3d20
*
*		set exponent underflow indicator, use three 4-bit trailing
*		sign operands  
*
*/

inst	mp3d	-nt "4sca*4sca->4sca"
-ir eu
-mf1 idb ar
-mf2 idb ar
-mf3 idb ar
-io 2;

desc 1 -tn 4 -sd f -nn 6 -cn 1;
desc 2 -tn 4 -sd f -nn 6 -cn 1;
desc 3 -tn 4 -sd f -nn 6 -cn 1;

data 1 -do -1 00 260 042 200;
data 2 -do -2 00 260 063 300;
data 3 00 307 046 100;

page -all;


/*		mp3d21
*
*		mix leading and traling signs with 4-bit operands  
*
*/

inst	mp3d	-nt "4sca*4sca->4sca"
-mf1 idb ar
-mf2 idb ar
-mf3 idb ar
-io 1;

desc 1 -tn 4 -sd l  -nn 63;
desc 2 -tn 4 -sd t -sf 3 -nn 63;
desc 3 -tn 4 -sd t -sf 3 -nn 63;

data 1 -do -62 260 (30)000 22;
data 2 -do -1 010 (30)210 26;
data 3 171 (29)231 222 30;

page -all;


/*		mp3d22
*
*		mix floating point  and leading sign with 9-bit operands 
*
*/

inst	mp3d	-nt "9flo*9sca->9sca"
-mf1 idb ar reg
-mf2 idb ar reg
-mf3 idb ar reg
-io 2;

desc 1 -sd f -nn 5;
desc 2 -sd l -sf -3 -nn 63;
desc 3 -sd l -sf -3 -nn 63;

data 1 -do -4 "+" "009" 001;
data 2 -do -17 "+" "00" (60)"8";
data 3 "+" "7" (59)"9" "20";

page -all;


/*		mp3d23
*
*		mix 9-bit and 4-bit operands, use  leading sign and unsigned scaled 
*		decimals  
*
*/

inst	mp3d	-nt "9sca*4sca->4sca"
-mf1 idb ar reg
-mf2 idb ar
-mf3 idb ar
 -io 1;

desc 1 -sd l -sf 2 -nn 11;
desc 2 -sd n -sf 2 -nn 15 -tn 4;
desc 3 -sd n -sf 2 -nn 15 -tn 4;

data 1 -do -7 "+" "2271658432";
data 2 -do -1 (6)000 124 04;
data 3 022 061 043 210 160 024 100 000;

page -all;


/*		mp3d24
*
*		mix 4-bit and 9-bit unsigned operands  
*
*/

inst	mp3d	-nt "4sca*9sca->9sca"
-mf1 idb ar
-mf2 idb ar reg
-mf3 idb ar reg
-io 2;

desc 1 -sd n -tn 4 -sf 2 -nn 10;
desc 2 -sd n -sf 2 -nn 15;
desc 3 -sd n -sf 2 -nn 15;

data 1 -do -1  042 161 145 204 142;
data 2 -do -13  (12)"0" "542";
data 3 "123123888640400";

page -all;


/*		mp3d25
*
*		mix floating point and trailing sign 9-bit operands  
*
*/

inst	mp3d 	-nt "9-bit f -> 4 bit trailing sign"
-ir ng
-mf1 idb ar reg
-mf2 idb ar reg
-mf3 idb ar reg
-io 1;

desc 1 -sd f -nn 16;
desc 2 -sd t -sf 4 -nn 16;
desc 3 -sd t -sf 4 -nn 16;

data 1 -do -5 "+" "0000" "2271658432" 002;
data 2 -do -6 (12)"0" "542" "-";
data 3 "123123887014400" "-";

page -all;


/*		mp3d26
*
*	Multiply  505.05+  by  floating +2.2  and get the  4 bit number
*	+1111.11000
*/

inst	mp3d	-nt "Result is 4 bit num"	  -io 3
	-mf1	ida
	-mf2	reg ar idb
	-mf3	ar idb;


desc 1	-nn 6 	-sd t	-sf -2	-cn 1;

data 1	-do -4
	" " "505"  "05" 053;


desc 2	-nn 4	-sd f	-cn 2;

data 2	-do -3
	"  " 053  "22" 377;		/* Exponent = -1  */


desc 3	-nn 10	-sd l	-tn 4	-sf -5;

data 3		301 021   021 020 000;


page	-all;

/*		mp3d27
*		9 bit scaled * 9 bit scaled to
*		9 bit scaled
*		all page faults taken
*
*/

inst	mp3d	-nt "rounded result"
-io 2 -rb
-mf1 ar rl 63 idb reg
-mf2 ar rl 63 idb reg
-mf3 ar rl 63 idb reg;

desc1 -cn 1 -sd l ;
desc2 -cn 1 -sd l ;
desc3 -sd l -cn 1 ;

data 1 -do 4033 " +" (20) "0" (12) "111" "111111";
data 2 -do 4033 " +" (53) "0" (9) "1";
data 3 -do 4033 000 "+" (12) "0" "12345678" (34) "9" "87654321";

page -all;


/*     mp2d1
*  The zero indicator is set.
*  Two 9-bit operands are used.
*  Indirect descriptors are used for all operands.
*  Address register modification is used for all operands.  */

inst mp2d -nt "9-bit x 9-bit -> 9-bit"
-ir zr
-mf1 idb ar reg
-mf2 idb ar reg
-io 1;

desc 1 -sd f -nn 63;
desc 2 -sd f -nn 63;

data 1 "+" (61)"0" 000 -do -62;
data 2 "-" (61)"9" 034 -do -34;
data 3 "+" (61)"0" 177;

page -all;


/*     mp2d2
*  The zero indicator is set.
*  Two 9-bit leading sign operands are used.
*  The maximum number of page faults is taken.
*  Indirect descriptors are used for all operands.
*  Address register modification is used for all operands.  */

inst mp2d -nt "9-bit x 9-bit -> 9-bit"
-ir zr
-mf1 idb ar
-mf2 idb ar
-io 2;

desc 1 -sd l -sf 10 -nn 7;
desc 2 -sd l -sf 10 -nn 28;

data 1 -do -4 "-" (6)"4";
data 2 -do -24 "+" (27)"0";
data 3 "+" (27)"0";

page -all;


/*     mp2d3
*  The negative indicator is set.
*  Two 4-bit floating point operands are used.
*  Indirect descriptors are used for all operands.
*  Address register modification is used for all operands.  */

inst mp2d -nt "4-bit x 4-bit -> 4-bit"
-ir ng
-mf1 idb ar
-mf2 idb ar
-io 1;

desc 1 -tn 4 -sd f -nn 6;
desc 2 -tn 4 -sd f -nn 6;

data 1 260  061 004;
data 2 320 050 004;
data 3 330 150 010;

page -all;


/*     mp2d4
*  The negative indicator is set.
*  Two  4-bit leading sign operands are used.
*  Indirect descriptors are used for all operands.
*  Address register modification is used for all operands.  */

inst mp2d -nt "4-bit x 4-bit -> 4-bit"
-ir ng
-mf1 idb ar
-mf2 idb ar
-io 2;

desc 1 -tn 4 -sd l -sf 2 -nn 4;
desc 2 -tn 4 -sd l -sf 2 -nn 6;

data 1 260 061;
data 2 320 000 050;
data 3 330 150 000;

page -all;


/*     mp2d5
*  The truncation indicator is set.
*  Two 4-bit floating point operands are used.
*  Indirect descriptors are used for all operands.
*  Address register modification is used for all operands.  */

inst mp2d -nt "4-bit x 4-bit -> 4-bit"
-ir tn
-mf1 idb ar
-mf2 idb ar
-io 1;

desc 1 -tn 4 -sd f -nn 6;
desc 2 -tn 4 -sd f -nn 6;

data 1 266 130 012;
data 2 260 022 013;
data 3 307 211 026;

page -all;


/*     mp2d6
*  The truncation indicator is set.
*  Two 4-bit leading sign operands are used.
*  Indirect descriptors are used for all operands.
*  Address register modification is used for all operands.  */

inst mp2d -nt "4-bit x 4-bit -> 4-bit"
-ir tn
-mf1 idb ar
-mf2 idb ar
-io 2;

desc 1 -tn 4 -sd l -sf -1 -nn 2 -cn 1;
desc 2 -tn 4 -sd l -sf 4  -nn 5 -cn 1;

data 1 00 271;
data 2 00 261 043 10;
data 3 00 301 021 00;

page -all;


/*     mp2d7
*  Rounding is tested.
*  Two 4-bit trailing sign operands are used.
*  The maximum number of page faults is taken.
*  Indirect descriptors are used for all operands.
*  Address register modification is used for all operands.  */

inst mp2d -nt "4-bit x 4-bit -> 4-bit"
-rb
-mf1 idb ar
-mf2 idb ar
-io 1;

desc 1 -tn 4 -sd t -sf -1 -cn 1 -nn 2;
desc 2 -tn 4 -sd t -sf 4 -nn 5;

data 1 -do -1 00 233;
data 2 -do -2 022 064 30;
data 3 021 021 30;

page -all;


/*     mp2d8
*  The overflow indicator is set.
*  Two 9-bit unsigned operands are used.
*  The maximum number of page faults is taken.
*  Indirect descriptors are used for all operands.
*  Address register modification is used for all operands.  */

inst mp2d -nt "9-bit x 9-bit -> 9-bit"
-ir ov
-mf1 idb ar reg
-mf2 idb ar reg
-io 2;

desc 1 -sd n -nn 3;
desc 2 -sd n -nn 5;

data 1 -do -1 "999";
data 2 -do -4 "00999";
data 3 "98001";

page -all;


/*     mp2d9
*  The exponent overflow indicator is set.
*  Two 9-bit floating point operands
*  The maximum number of page faults is taken.
*  Indirect descriptors are used for all operands.
*  Address register modification is used for all operands.  */

inst mp2d -nt "9-bit x 9-bit -> 9-bit"
-ir eo tn
-mf1 idb ar reg
-mf2 idb ar reg
-io 1;

desc 1 -sd f -nn 6;
desc 2 -sd f -nn 6;

data 1 -do -4 "+" "0900" 100;
data 2 -do -1 "+" "0756" 076;
data 3  "+" "6804" 200;

page -all;


/*     mp2d10
*  The exponent underflow indicator is set.
*  Two 4-bit trailing sign operands are used.
*  The maximum number of page faults is taken.
*  Indirect descriptors are used for all operands.
*  Address register modification is used for all operands.  */

inst mp2d -nt "4-bit x 4-bit -> 4-bit"
-ir eu
-mf1 idb ar
-mf2 idb ar
-io 2;

desc 1 -tn 4 -sd f -nn 6 -cn 1;
desc 2 -tn 4 -sd f -nn 6 -cn 1;

data 1 -do -1 00 260 042 200;
data 2 -do -2 00 260 063 300;
data 3 00 307 046 100;

page -all;


/*     mp2d11
*  Leading and trailing signs are mixed.
*  Two 4-bit operands are used.
*  Indirect descriptors are used for all operands.
*  Address register modification is used for all operands.  */

inst mp2d -nt "4-bit x 4-bit -> 4-bit"
-mf1 idb ar
-mf2 idb ar
-io 1;

desc 1 -tn 4 -sd l  -nn 63;
desc 2 -tn 4 -sd t -sf 3 -nn 63;

data 1 -do -62 260 (30)000 22;
data 2 -do -1 010 (30)210 26;
data 3 171 (29)231 222 30;

page -all;


/*     mp2d12
*  A floating point operand and a leading sign operand are used.
*  Two 9-bit operands are used.
*  The maximum number of page faults is taken.
*  Indirect descriptors are used for all operands.
*  Address register modification is used for all operands.  */

inst mp2d -nt "4-bit x 4-bit -> 4-bit"
-mf1 idb ar reg
-mf2 idb ar reg
-io 2;

desc 1 -sd f -nn 5;
desc 2 -sd l -sf -3 -nn 63;

data 1 -do -4 "+" "009" 001;
data 2 -do -17 "+" "00" (60)"8";
data 3 "+" "7" (59)"9" "20";

page -all;


/*     mp2d13
*  A leading sign 9-bit operand and an unsigned 4-bit operand are used.
*  The maximum number of page faults is taken.
*  Indirect descriptors are used for all operands.
*  Address register modification is used for all operands.  */


inst mp2d -nt "9-bit x 4-bit -> 4-bit"
-mf1 idb ar reg
-mf2 idb ar
 -io 1;

desc 1 -sd l -sf 2 -nn 11;
desc 2 -sd n -sf 2 -nn 15 -tn 4;

data 1 -do -7 "+" "2271658432";
data 2 -do -1 (6)000 124 04;
data 3 022 061 043 210 160 024 100 000;

page -all;


/*     mp2d14
*  Unsigned 4-bit and 9-bit operands are used.
*  The maximum number of page faults is taken.
*  Indirect descriptors are used for all operands.
*  Address register modification is used for all operands.  */

inst mp2d -nt "4-bit x 9-bit -> 9-bit"
-mf1 idb ar
-mf2 idb ar reg
-io 2;

desc 1 -sd n -tn 4 -sf 2 -nn 10;
desc 2 -sd n -sf 2 -nn 15;

data 1 -do -1  042 161 145 204 142;
data 2 -do -13  (12)"0" "542";
data 3 "123123888640400";

page -all;


/*     mp2d15
*  A floating point operand and a trailing sign operand are used.
*  Two 9-bit operands are used.
*  The maximum number of page faults is taken.
*  Indirect descriptors are used for all operands.
*  Address register modification is used for all operands.  */

inst mp2d -nt "9-bit x 9-bit -> 9-bit"
-ir ng
-mf1 idb ar reg
-mf2 idb ar reg
-io 1;

desc 1 -sd f -nn 16;
desc 2 -sd t -sf 4 -nn 16;

data 1 -do -5 "+" "0000" "2271658432" 002;
data 2 -do -6 (12)"0" "542" "-";
data 3 "123123887014400" "-";

page -all;


/*     dv3d1
*  The zero indicator is set.
*  Three 9-bit floating point operands are used.
*  The maximum number of page faults is taken.
*  Indirect descriptors are used for all operands.
*  Address register modification is used for all operands.  */

inst dv3d -nt "(9 bit / 9 bit) -> 9 bit"
-ir zr
-mf1 idb ar reg
-mf2 idb ar reg
-mf3 idb ar reg
-io 1;

desc 1  -sd f -nn 6;
desc 2 -sd f -nn 55;
desc 3 -sd f -nn 31;

data 1 -do -2 "+" "4275" 377;
data 2 -do -50  "+" (53)"0" 374;
data 3 -do -25  "+" (29)"0" 177;

page -all;


/*     dv3d2
*  The negative indicator is set.
*  Three 4-bit floating point operands are used.
*  The maximum number of page faults is taken.
*  Indirect descriptors are used for all operands.
*  Address register modification is used for all operands.  */

inst dv3d -nt "(4 bit / 4 bit) -> 4 bit"
-ir ng -mf1 idb ar
-mf2 idb ar
-mf3 idb ar
-io 2;

desc 1 -tn 4 -sd f -nn 8 -cn 1;
desc 2 -tn 4 -sd f -nn 8 -cn 1;
desc 3 -tn 4 -sd f -nn 8 -cn 1;

data 1 -do -1 00 260 000 002 004;
data 2 -do -4 00 320 225 120 004;
data 3 -do -2 00 324 167 120 377;

page -all;


/*     dv3d3
*  The negative indicator is set.
*  Three 4-bit trailing sign operands are used.
*  Indirect descriptors are used for all operands.
*  Address register modification is used for all operands.  */

inst dv3d -nt "(4 bit / 4 bit) -> 4 bit"
-ir ng
-mf1 idb ar
-mf2 idb ar
-mf3 idb ar
-io 3;

desc 1 -tn 4 -sd t -sf 4 -nn 4;
desc 2 -tn 4 -sd t -sf 8 -nn 3;
desc 3 -tn 4 -sd t -sf 3 -nn3;

data 1 000 055;
data 2 010 26;
data 3 100 32;

page -all;


/*     dv3d4
*  The overflow indicator is set.
*  Three 4-bit floating point operands are used.
*  The maximum number of page faults is taken.
*  Indirect descriptors are used for all operands.
*  Address register modification is used for all operands.  */

inst dv3d -nt "(4 bit / 4 bit) -> 4 bit"
-ir ov
-mf1 idb ar
-mf2 idb ar
-mf3 idb ar
-io 1;

desc 1 -tn 4 -sd n -sf 1 -nn 63;
desc 2 -tn 4 -sd n -sf 1 -nn63;
desc 3 -tn 4 -sd n -sf 10 -nn 50;

data 1 -do -12 (31)000 10;
data 2 -do -15 (31)167 16;
data 3 -do -18 (25)104;

page -all;


/*     dv3d5
*  A 9-bit operand is divided by a 9-bit operand & stored in a 4-bit operand.
*  All operands are unsigned.
*  The maximum number of page faults is taken.
*  Indirect descriptors are used for all operands.
*  Address register modification is used for all operands.  */

inst dv3d -nt "(9 bit / 9 bit) -> 4 bit"
-mf1 idb ar reg
-mf2 idb ar reg
-mf3 idb ar
-io 1;

desc 1 -sd n -nn 8;
desc 2 -sd n -nn 10;
desc 3 -sd n -tn 4 -nn 8;

data 1 -do -7 "30144196";
data 2 -do -3 "1567498217";
data 3 -do -2 (3)000 122;

page -all;


/*     dv3d6
*  A 4-bit operand is divided by a 4-bit operand & stored in a 9-bit operand.
*  All operands are floating point.
*  The maximum number of page faults is taken.
*  Indirect descriptors are used for all operands.
*  Address register modification is used for all operands.  */

inst dv3d -nt "(4 bit / 4 bit) -> 9 bit"
-mf1 idb ar
-mf2 idb ar
-mf3 idb ar reg
-io 2;

desc 1 -tn 4 -sd f -nn 11;
desc 2 -tn 4 -sd f -nn 13;
desc 3 -sd f -nn 10;

data 1 -do -4 323 001 104 031 140 00;
data 2 -do -3 321 126 164 230 041 160 00;
data 3 -do -1 "+" "052" (5)"0" 373;

page -all;


/*     dv3d7
*  A 9-bit operand is divided by a 4-bit operand & stored in a 4-bit operand.
*  All operands are trailing sign.
*  The maximum number of page faults is taken.
*  Indirect descriptors are used for all operands.
*  Address register modification is used for all operands.  */

inst dv3d -nt "(9 bit / 4 bit) -> 4 bit"
-mf1 idb ar reg
-mf2 idb ar
-mf3 idb ar
-io 3;

desc 1 -sd t -nn 10;
desc 2 -tn 4 -sd t -nn 11;
desc 3 -tn 4 -sd t -nn 10;

data 1 -do -8 "030144196" "-";
data 2 -do -5 025 147 111 202 027 320;
data 3 -do -3 (3)000 005 054;

page -all;


/*     dv3d8
*  A 9-bit operand is divided by a 4-bit operand & stored in a 9-bit operand.
*  All operands are leading sign.
*  Indirect descriptors are used for all operands.
*  Address register modification is used for all operands.  */

inst dv3d -nt "(9 bit / 4 bit) -> 9 bit"
-mf1 idb ar reg
-mf2 idb ar
-mf3 idb ar reg
-io 2;

desc 1  -sd l -sf 6 -nn 20;
desc 2 -sd l -sf 6 -tn 4 -nn 20;
desc 3 -sd l -nn 20;

data 1 "+" (11)"0" "30144196";
data 2 260 (4) 000 025 147 111 202 027;
data 3 "+" (17)"0" "52";

page -all;


/*     dv3d9
*  Leading sign, trailing sign, and floating point operands are used.
*  Three 9-bit operands are used.
*  Indirect descriptors are used for all operands.
*  Address register modification is used for all operands.  */

inst dv3d -nt "(9 bit / 9 bit) -> 9 bit"
-mf1 idb ar reg
-mf2 idb ar reg
-mf3 idb ar reg
-io 3;

desc 1 -sd l -sf 1 -nn 8;
desc 2 -sd t -sf 2 -nn 8;
desc 3 -sd f -nn 8;

data 1 "+" (5)"0" "58";
data 2 "000" "1234" "+";
data 3 "+" "021275" 376;

page -all;


/*     dv3d10
*  Floating point, unsigned, and leading sign operands are used.
*  Three 4-bit operands are used.
*  Indirect descriptors are  used for all operands.
*  Address register modification is used for all operands.  */

inst dv3d -nt "(4 bit / 4 bit -> 4 bit"
-mf1 idb ar
-mf2 idb ar
-mf3 idb ar
-io 1;

desc 1 -tn 4 -sd f -nn 8;
desc 2 -tn 4 -sd n -sf 1 -nn 8;
desc 3 -tn 4 -sd l -nn 8;

data 1 260 002 022 000;
data 2 000 000 022 064;
data 3 300 000 000 130;

page -all;


/*		dv3d11
*		Use RL mod and cn field with indirect descriptors
*		Use three 9-bit trailing sign operands.
*
*/


inst	dv3d	-nt "two character offset"
-io 2  -ir ng
-mf1 ar rl 10 idb reg
-mf2 ar rl 10 idb reg
-mf3 ar rl 10 idb reg;

desc1 -cn 1  -sd t ;
desc2 -cn 1  -sd t ;
desc 3 -cn 1 -sd t;

data 1 -do -9 " " (9) "1" "-";
data 2 -do -9 "*" (9) "2" "+";
data 3 000 (8)"0" "2" "-";

page -all;

/*		dv3d12
*		Use RL mod and cn field with indirect descriptors
*		Use three 9-bit trailing sign operands.
*
*/


inst	dv3d	-nt "one character offset"
-io 2  -ir ng
-mf1 ar rl 10 idb reg
-mf2 ar rl 10 idb reg
-mf3 ar rl 10 idb reg;

desc1 -cn 1  -sd t ;
desc2 -cn 1  -sd t ;
desc3 -cn 1 -sd t;

data 1 -do -10 " " (9) "1" "-";
data 2 -do -20 "*" (9) "2" "+";
data 3 000 (8) "0" "2" "-";

page -all;

/*		dv3d13
*		Use RL mod and cn field 
*		Use three 9-bit trailing sign operands.
*		no indirect descriptors
*
*/

inst	dv3d	-nt "no indirect descriptors"
-io 2  -ir ng
-mf1 ar rl 10  reg
-mf2 ar rl 10 reg
-mf3 ar rl 10 reg;

desc1 -cn 1  -sd t ;
desc2 -cn 1  -sd t ;
desc3 -cn 1 -sd t;

data 1 -do -9 " " (9) "1" "-";
data 2 -do -9 "*" (9) "2" "+";
data 3 000 (8) "0" "2" "-";

page -all;

/*		dv3d14
*		Use no modification
*		Use three 9 bit trailing sign operands.
*
*/

inst	dv3d	-nt "no mf modification"
-io 2  -ir ng;

desc1 -cn 1  -sd t  -nn 12;
desc2 -cn 1  -sd t  -nn 12;
desc3 -cn 1 -sd t -nn 12;

data 1 -do -12 " " (11) "1" "-";
data 2 -do -12 "*" (11) "2" "+";
data 3 000 (10) "0" "2" "-";

page -all;

/*		dv3d15
*		Use ar and rl
*		Use three 9-bit trailing sign operands.
*
*/


inst	dv3d	-nt "ar and rl modification"
-io 2  -ir ng
-mf1 ar rl 10 
-mf2 ar rl 10
-mf3 ar rl 10 ;

desc1 -cn 1  -sd t ;
desc2 -cn 1  -sd t ;
desc3 -cn 1 -sd t;

data 1 -do -9 " " (9) "1" "-";
data 2 -do -9 "*" (9) "2" "+";
data 3 000 (8)"0" "2" "-";

page -all;

/*		dv3d16
*		Use ar and rl modification on desc1
*		Use ar rl idb reg on desc2
*		Use three 9-bit trailing sign operands.
*
*/


inst	dv3d	-nt "two character offset"
-io 2  -ir ng
-mf1 ar rl 10
-mf2 ar rl 10 idb reg
-mf3 ar rl 10 idb reg;

desc1 -cn 1  -sd t ;
desc2 -cn 1  -sd t ;
desc3 -cn 1 -sd t;

data 1 -do -9 " " (9) "1" "-";
data 2 -do -9 "*" (9) "2" "+";
data 3 000 (8) "0" "2" "-";

page -all;


/*		dv3d17
*		maximum length divide leading sign
*		one character over next page
*		all modification taken
*/
inst	dv3d	-nt "maximum length "
-io 2
-mf1 ar rl 63 idb reg
-mf2 ar rl 63 idb reg
-mf3 ar rl 63 idb reg;

desc1 -cn 1 -sd l ;
desc2 -cn 1 -sd l ;
desc3 -cn 1 -sd l;

data 1 -do 4033 " " "+33" (15) "8642";
data 2 -do 4033 "*" "+33" (15) "8642";
data 3 000 "+" (61) "0" "1";

page -all;


/*		dv3d18
*		This is a simple test
*		Use three 9-bit trailing sign operands.
*
*/

inst	dv3d	-nt "simple test";

desc1  -sd t -nn 63;
desc2  -sd t -sf 10 -nn 63;
desc3 -sd t -sf 10 -nn 63;

data 1 "11" (12) "1111" "11" (10) "0" "+";
data 2 "22" (12) "2222" "22" (10) "0" "+";
data 3 (61) "0" "2" "+";

page -all;


/*		dv3d19
*		maximum length divide resulting
*		in an overflow
*		all modification taken
*		Use three 9-bit leading sign operands.
*/
inst	dv3d	-nt "truncation fault"
-io 1  
-mf1 ar rl 63 idb reg
-mf2 ar rl 63 idb reg
-mf3 ar rl 63 idb reg;

desc1 -sd l -cn 1;
desc2 -sd l -cn 1;
desc3 -sd l -cn 1;

data 1 -do 4033 " " "+33" (15) "8642";
data 2 -do 4033 "*" "+71" (15) "2357";
data 3 000 "+" (61) "0" "2";

page -all;


/*		dv3d20
*		maximum length over two pages
*		no faults, (9 bit / 4 bit) -> 4 bit
*
*/

inst dv3d -nt "(9 bit / 4 bit) -> 4 bit"
-io 1
-mf1 ar rl 63 
-mf2 ar rl 63
-mf3 ar rl 63 ;

desc1 -sd t ;
desc2 -sd t  -tn 4;
desc3 -sd t -tn 4;

data 1 -do 4033  "33" (15) "3333" "+";
data 2 -do 4064  104104 (7) 104104104104 10426;
data 3 (28) 000 000000001300;

page -all;


/*		dv3d21
*		(9 bit / 4 bit) -> 4 bit  ; all page faults possible
*		 no reg modification on desc2
*
*/

inst dv3d -nt "(9 bit / 4 bit) -> 4 bit"
-io 2
-mf1 ar rl 63 idb reg
-mf2 ar rl 63 idb
-mf3 ar rl 63 idb ;

desc1 -cn 1 -sd l;
desc2   -cn 1 -sd t -tn 4;
desc3 -cn 1 -sd t -tn 4;

data 1 -do 4033 " " "+" (15) "0000" "22";
data 2 -do 4068 "*" (28) 000 104104 1043;
data 3 000 (28) 000 002 002 002 300;

page -all;


/*		dv3d22
*		Use three 4-bit trailing sign operands.
*		maximum length
*		all page faults taken
*		no reg modification
*/

inst dv3d -nt "(4 bit / 4 bit) -> 4 bit"
-io 1
-mf1 ar rl 63 idb
-mf2 ar rl 63 idb
-mf3 ar rl 63 idb;

desc1 -cn 1 -sd t -tn 4;
desc2 -cn 1 -sd t -tn 4;
desc3 -cn 1 -sd t -tn 4;

data 1 -do 4065 " " (28) 000 000 000 0013;
data 2 -do 4065 "*" 021021 (7) 021021021021 0213;
data 3 000 021021 (7) 021021021021 0213;

page -all;


/*		dv3d23
*		floating point divide
*		 Use three 9-bit floatinf point operands.
*		 all page faults taken
*
*/

inst	dv3d	-nt "9bit float divide"
-io 1
-mf1 ar rl 63 reg idb
-mf2 ar rl 63 reg idb
-mf3 ar rl 63 reg idb;

desc1 -sd f;
desc2 -sd f;
desc3 -sd f;

data 1 -do -1 "+" (20) "0" (10) "1" (30) "0" "1" 005;
data 2 -do -1 "+" (20) "0" (10) "1" (30) "0" "1" 006;
data 3 "+" "1" (60) "0" 305;

page -all;


/*		dv3d24
*		Use three 4-bit floating point operands.
*
*/

inst dv3d -nt "(4 bit / 4 bit) -> 4 bit"
-io 1
-mf1 ar rl 10 ida
-mf2 ar rl 10 ida
-mf3 ar rl 10 ida;

desc1 -sd f -tn 4;
desc2 -sd f -tn 4;
desc3 -sd f -tn 4;

data 1 -do -1 300 000 000 001 000;
data 2 -do -1 300 000 021 021 000;
data 3 301 021 020 000 375;

page -all;


/*		dv3d25
*		(4 bit / 9 bit) -> 9 bit
*
*/

inst dv3d -nt "(4 bit / 9 bit) -> 9 bit"
-io 1
-mf1 ar rl 5 idb
-mf2 ar rl 5 idb reg
-mf3 ar rl 5 idb reg;

desc 1 -tn 4 -sd l;
desc 2 -sd n;
desc 3 -sd n;

data 1 30102100;
data 2 -do 4 "02222";
data 3 "00002";

page -all;


/*     dv3d26
*  The zero indicator is set.
*  Three 9-bit floating point operands are used.
*  No indirect descriptors are used.
*  Address register modification is used for all operands.  */

inst dv3d -nt "(9 bit / 9 bit) -> 9 bit"
-ir zr
-mf1 ar reg
-mf2 ar reg
-mf3 ar reg
-io 1;

desc 1  -sd f -nn 6;
desc 2 -sd f -nn 55;
desc 3 -sd f -nn 31;

data 1 -do -2 "+" "4275" 377;
data 2 -do -50  "+" (53)"0" 374;
data 3 -do -25  "+" (29)"0" 177;

page -all;


/*     dv3d27
*  The negative indicator is set.
*  Three 4-bit floating point operands are used.
*  No indirect descriptors are used.
*  Address register modification is used for all operands.  */

inst dv3d -nt "(4 bit / 4 bit) -> 4 bit"
-ir ng -mf1 ar
-mf2 ar
-mf3 ar
-io 2;

desc 1 -tn 4 -sd f -nn 8 -cn 1;
desc 2 -tn 4 -sd f -nn 8 -cn 1;
desc 3 -tn 4 -sd f -nn 8 -cn 1;

data 1 -do -1 00 260 000 002 004;
data 2 -do -4 00 320 225 120 004;
data 3 -do -2 00 324 167 120 377;

page -all;


/*     dv3d28
*  The negative indicator is set.
*  Three 4-bit trailing sign operands are used.
*  No indirect descriptors are used.
*  Address register modification is used for all operands.  */

inst dv3d -nt "(4 bit / 4 bit) -> 4 bit"
-ir ng
-mf1 ar
-mf2 ar
-mf3 ar
-io 3;

desc 1 -tn 4 -sd t -sf 4 -nn 4;
desc 2 -tn 4 -sd t -sf 8 -nn 3;
desc 3 -tn 4 -sd t -sf 3 -nn3;

data 1 000 055;
data 2 010 26;
data 3 100 32;

page -all;


/*     dv3d29
*  The overflow indicator is set.
*  Three 4-bit floating point operands are used.
*  No indirect descriptors are used.
*  Address register modification is used for all operands.  */

inst dv3d -nt "(4 bit / 4 bit) -> 4 bit"
-ir ov
-mf1 ar
-mf2 ar
-mf3 ar
-io 1;

desc 1 -tn 4 -sd n -sf 1 -nn 63;
desc 2 -tn 4 -sd n -sf 1 -nn63;
desc 3 -tn 4 -sd n -sf 10 -nn 50;

data 1 -do -12 (31)000 10;
data 2 -do -15 (31)167 16;
data 3 -do -18 (25)104;

page -all;


/*     dv3d30
*  A 9-bit operand is divided by a 9-bit operand & stored in a 4-bit operand.
*  All operands are unsigned.
*  No indirect descriptors are used.
*  Address register modification is used for all operands.  */

inst dv3d -nt "(9 bit / 9 bit) -> 4 bit"
-mf1 ar reg
-mf2 ar reg
-mf3 ar
-io 1;

desc 1 -sd n -nn 8;
desc 2 -sd n -nn 10;
desc 3 -sd n -tn 4 -nn 8;

data 1 -do -7 "30144196";
data 2 -do -3 "1567498217";
data 3 -do -2 (3)000 122;

page -all;


/*     dv3d31
*  A 4-bit operand is divided by a 4-bit operand & stored in a 9-bit operand.
*  All operands are floating point.
*  No indirect descriptors are used.
*  Address register modification is used for all operands.  */

inst dv3d -nt "(4 bit / 4 bit) -> 9 bit"
-mf1 ar
-mf2 ar
-mf3 ar reg
-io 2;

desc 1 -tn 4 -sd f -nn 11;
desc 2 -tn 4 -sd f -nn 13;
desc 3 -sd f -nn 10;

data 1 -do -4 323 001 104 031 140 00;
data 2 -do -3 321 126 164 230 041 160 00;
data 3 -do -1 "+" "052" (5)"0" 373;

page -all;


/*     dv3d32
*  A 9-bit operand is divided by a 4-bit operand & stored in a 4-bit operand.
*  All operands are trailing sign.
*  No indirect descriptors are used.
*  Address register modification is used for all operands.  */

inst dv3d -nt "(9 bit / 4 bit) -> 4 bit"
-mf1 ar reg
-mf2 ar
-mf3 ar
-io 3;

desc 1 -sd t -nn 10;
desc 2 -tn 4 -sd t -nn 11;
desc 3 -tn 4 -sd t -nn 10;

data 1 -do -8 "030144196" "-";
data 2 -do -5 025 147 111 202 027 320;
data 3 -do -3 (3)000 005 054;

page -all;


/*     dv3d33
*  A 9-bit operand is divided by a 4-bit operand & stored in a 9-bit operand.
*  All operands are leading sign.
*  No indirect descriptors are used.
*  Address register modification is used for all operands.  */

inst dv3d -nt "(9 bit / 4 bit) -> 9 bit"
-mf1 ar reg
-mf2 ar
-mf3 ar reg
-io 2;

desc 1  -sd l -sf 6 -nn 20;
desc 2 -sd l -sf 6 -tn 4 -nn 20;
desc 3 -sd l -nn 20;

data 1 "+" (11)"0" "30144196";
data 2 260 (4) 000 025 147 111 202 027;
data 3 "+" (17)"0" "52";

page -all;


/*     dv3d34
*  Leading sign, trailing sign, and floating point operands are used.
*  Three 9-bit operands are used.
*  No indirect descriptors are used.
*  Address register modification is used for all operands.  */

inst dv3d -nt "(9 bit / 9 bit) -> 9 bit"
-mf1 ar reg
-mf2 ar reg
-mf3 ar reg
-io 3;

desc 1 -sd l -sf 1 -nn 8;
desc 2 -sd t -sf 2 -nn 8;
desc 3 -sd f -nn 8;

data 1 "+" (5)"0" "58";
data 2 "000" "1234" "+";
data 3 "+" "021275" 376;

page -all;


/*     dv3d35
*  Floating point, unsigned, and leading sign operands are used.
*  Three 4-bit operands are used.
*  Indirect descriptors are  used for all operands.
*  Address register modification is used for all operands.  */

inst dv3d -nt "(4 bit / 4 bit -> 4 bit"
-mf1 ar
-mf2 ar
-mf3 ar
-io 1;

desc 1 -tn 4 -sd f -nn 8;
desc 2 -tn 4 -sd n -sf 1 -nn 8;
desc 3 -tn 4 -sd l -nn 8;

data 1 260 002 022 000;
data 2 000 000 022 064;
data 3 300 000 000 130;

page -all;


/*		dv2d1
*		Use RL mod and cn field with indirect descriptors
*		divide 9 bit scaled to 9 bit scaled
*
*/


inst	dv2d	-nt "two character offset"
-io 2  -ir ng
-mf1 ar rl 10 idb reg
-mf2 ar rl 10 idb reg;

desc1 -cn 1  -sd t ;
desc2 -cn 1  -sd t ;

data 1 -do -9 " " (9) "1" "-";
data 2 -do -9 "*" (9) "2" "+";
data 3 "*" (8) "0" "2" "-";

page -all;


/*		dv2d2
*		Use RL mod and cn field with indirect descriptors
*		9 bit scaled to 9 bit scaled
*
*/


inst	dv2d	-nt "one character offset"
-io 2  -ir ng
-mf1 ar rl 10 idb reg
-mf2 ar rl 10 idb reg;

desc1 -cn 1  -sd t ;
desc2 -cn 1  -sd t ;

data 1 -do -10 " " (9) "1" "-";
data 2 -do -20 "*" (9) "2" "+";
data 3 "*" (8) "0" "2" "-";

page -all;


/*		dv2d3
*		Use RL mod and cn field 
*		9 bit scaled to 9 bit scaled
*		no indirect descriptors
*
*/

inst	dv2d	-nt "no indirect descriptors"
-io 2  -ir ng
-mf1 ar rl 10  reg
-mf2 ar rl 10 reg;

desc1 -cn 1  -sd t ;
desc2 -cn 1  -sd t ;

data 1 -do -9 " " (9) "1" "-";
data 2 -do -9 "*" (9) "2" "+";
data 3 "*" (8) "0" "2" "-";

page -all;


/*		dv2d4
*		Use no modification
*		9bit scaled divideed to 9 bit scaled
*
*/

inst	dv2d	-nt "no mf modification"
-io 2  -ir ng;

desc1 -cn 1  -sd t  -nn 12;
desc2 -cn 1  -sd t  -nn 12;

data 1 -do -12 " " (11) "1" "-";
data 2 -do -12 "*" (11) "2" "+";
data 3 "*" (10) "0" "2" "-";

page -all;


/*		dv2d5
*		Use ar and rl
*		9 bit scaled to 9 bit scaled
*
*/


inst	dv2d	-nt "ar and rl modification"
-io 2  -ir ng
-mf1 ar rl 10 
-mf2 ar rl 10 ;

desc1 -cn 1  -sd t ;
desc2 -cn 1  -sd t ;

data 1 -do -9 " " (9) "1" "-";
data 2 -do -9 "*" (9) "2" "+";
data 3 "*" (8)"0" "2" "-";

page -all;


/*		dv2d6
*		Use aar and rl modification, desc1
*		Use ar rl idb reg on desc2
*		9 bit scaled to 9 bit scaled
*
*/


inst	dv2d	-nt "two character offset"
-io 2  -ir ng
-mf1 ar rl 10
-mf2 ar rl 10 idb reg;

desc1 -cn 1  -sd t ;
desc2 -cn 1  -sd t ;

data 1 -do -9 " " (9) "1" "-";
data 2 -do -9 "*" (9) "2" "+";
data 3 "*" (8) "0" "2" "-";

page -all;


/*		dv2d7
*		maximum length divide leading sign
*		one character over next page
*		all modification taken
*/
inst	dv2d	-nt "maximum length "
-io 2
-mf1 ar rl 63 idb reg
-mf2 ar rl 63 idb reg;

desc1 -cn 1 -sd l ;
desc2 -cn 1 -sd l ;

data 1 -do 4033 " " "+33" (15) "8642";
data 2 -do 4033 "*" "+33" (15) "8642";
data 3 "*" "+" (61) "0" "1";

page -all;


/*		dv2d8
*		This is a simple test
*		9 bit divide to 9 bit all scaled trailing sign
*
*/

inst	dv2d	-nt "simple test";

desc1  -sd t -nn 63;
desc2  -sd t -sf 10 -nn 63;

data 1 "11" (12) "1111" "11" (10) "0" "+";
data 2 "22" (12) "2222" "22" (10) "0" "+";
data 3 (61) "0" "2" "+";

page -all;


/*		dv2d9
*		maximum length divide resulting
*		in an overflow
*		all modification taken
*		9 bit scaled to 9 bit scaled
*/

inst	dv2d	-nt "truncation fault"
-io 1  
-mf1 ar rl 63 idb reg
-mf2 ar rl 63 idb reg;

desc1 -sd l -cn 1;
desc2 -sd l -cn 1;

data 1 -do 4033 " " "+33" (15) "8642";
data 2 -do 4033 "*" "+71" (15) "2357";
data 3 "*" "+" (61) "0" "2";

page -all;


/*		dv2d10
*		maximum length over two pages
*		no faults, 9 bit to 4 bit
*
*/

inst	dv2d	-nt "9 bit -> 4 bit"
-io 1
-mf1 ar rl 63 
-mf2 ar rl 63 ;

desc1 -sd t ;
desc2 -sd t  -tn 4;

data 1 -do 4033  "33" (15) "3333" "+";
data 2 -do 4064  104104 (7) 104104104104 10426;
data 3 (28) 000 000000001300;

page -all;


/*		dv2d11
*		9 bit to 4 bit all page faults possible
*		 no reg modification on desc2
*
*/

inst	dv2d	-nt "9bit ->4bit"
-io 2
-mf1 ar rl 63 idb reg
-mf2 ar rl 63 idb ;

desc1 -cn 1 -sd l;
desc2   -cn 1 -sd t -tn 4;

data 1 -do 4033 " " "+" (15) "0000" "22";
data 2 -do 4068 "*" (28) 000 104104 1043;
data 3 "*" (28) 000 002 002 002 300;

page -all;


/*		dv2d12
*		4 bit divideed to 4 bit
*		maximum length
*		all page faults taken
*		no reg modification
*/

inst	dv2d	-nt "4 bit + 4bit"
-io 1
-mf1 ar rl 63 idb
-mf2 ar rl 63 idb;

desc1 -cn 1 -sd t -tn 4;
desc2 -cn 1 -sd t -tn 4;

data 1 -do 4065 " " (28) 000 000 000 0013;
data 2 -do 4065 "*" 021021 (7) 021021021021 0213;
data 3 "*" 021021 (7) 021021021021 0213;

page -all;


/*		dv2d13
*		floating point divide
*		 9 bit to 9bit
*		 all page faults taken
*
*/

inst	dv2d	-nt "9bit float divide"
-io 1
-mf1 ar rl 63 reg idb
-mf2 ar rl 63 reg idb;

desc1 -sd f;
desc2 -sd f;

data 1 -do -1 "+" (20) "0" (10) "1" (30) "0" "1" 005;
data 2 -do -1 "+" (20) "0" (10) "1" (30) "0" "1" 006;
data 3 "+" "1" (60) "0" 305;

page -all;


/*		dv2d14
*		4 bit floating divided to
*		4 bit floating
*
*/

inst	dv2d	-nt "4 float to 4 float"
-io 1
-mf1 ar rl 10 ida
-mf2 ar rl 10 ida;

desc1 -sd f -tn 4;
desc2 -sd f -tn 4;

data 1 -do -1 300 000 000 001 000;
data 2 -do -1 300 000 021 021 000;
data 3 301 021 020 000 375;

page -all;


/*		dv2d15
*		test 4bit scaled to 9 bit
*
*/

inst	dv2d	-nt "4bit->9bit"
-io 1
-mf1 ar rl 5 idb
-mf2 ar rl 5 idb reg;

desc 1 -tn 4 -sd l;
desc 2 -sd n;

data 1 30102100;
data 2 -do 4 "02222";
data 3 "00002";

page -all;


/*		dv2d16
*		test 9 floating to 4 floating
*
*/

inst	dv2d	-nt "9float->4 float"
-io 1
-mf1 ar rl 5 idb reg
-mf2 ar rl 7 idb;

desc 1 -sd f;
desc 2 -sd f -tn 4;

data 1 "+" (3) "1" 000;
data 2 300 042 040 00;
data 3 302 000 017 320;

page -all;


/*		dv2d17
*		4 float to 9 float
*
*/

inst	dv2d	-nt "4float -> 9float"
-io 1
-mf1 ar rl 7 idb
-mf2 ar rl 7 idb reg;

desc 1 -sd f -tn 4 ;
desc 2 -sd f;

data 1 300 042 040 00;
data 2 "+0" (3) "1" "0" 000;
data 3 "+05000" 375;

page -all;


/*		dv2d18
*		9 scaled to 9 float
*
*/

inst	dv2d	-nt "9sacled to 9 float"
-io 2
-mf1 ar rl 5 idb reg
-mf2 ar rl 6 idb reg;

desc1 -sd l;
desc2 -sd f;

data 1 "+" (4) "3";
data 2 "+" "0" (3) "2" 000;
data 3 "+" "0666" 374;

page -all;


/*		dv2d19
*		9 float to 9 scaled
*
*/

inst	dv2d	-nt "9 float to 9 scaled"
-io 2
-mf1 ar rl 6 idb reg
-mf2 ar rl 5 idb reg;

desc1 -sd f;
desc2 -sd l;

data 1 "+" "0" (3) "2" 000;
data 2 "+" (4) "3";
data 3 "+0015";

page -all;


/*		dv2d20
*		9 scaled to 4 float
*
*/

inst	dv2d	-nt "9scaled->4float"
-io 2

-mf1 ar rl 5 idb reg
-mf2 ar rl 6 idb;

desc 1 -sd l;
desc 2 -sd f -tn 4;

data 1 "+0" (3) "2";
data 2 303063 000;
data 3 301 120 376;

page -all;


/*		dv2d21
*		9 float to 4 scaled
*
*/

inst	dv2d	-nt "9float->4scaled"
-io 1
-mf1 ar rl 6 idb reg
-mf2 ar rl 4 idb;

desc 1 -sd f;
desc 2 -sd l -tn 4;

data 1 -do -1 "+0" (3) "2" 000;
data 2 -do -2 303 063;
data 3 300 001;

page -all;


/*		dv2d22
*		4scaled to 9 float
*
*/

inst	dv2d	-nt "4scaled-.9float"
-io 1
-mf1 ar rl 4 idb
-mf2 ar rl 6 idb reg;

desc 1 -sd l -tn 4;
desc 2 -sd f;

data 1 -do -1 303063;
data 2 -do -1 "+0" (3) "2" 000;
data 3 "+0" (3) "6" 375;

page -all;


/*		dv2d23
*		4 floating to 9 scaled
*
*/

inst	dv2d	 -nt "4float->9scaled"
-io 1
-mf1 ar rl 6 idb
-mf2 ar rl 5 idb reg;

desc 1 -sd f -tn 4;
desc 2 -sd n;

data 1 -do -1 303 063 000;
data 2 -do -2 "00" "555";
data 3 (4) "0" "1";

page -all;


/*		dv2d24
*		4 scaled to 4 float
*
*/

inst	dv2d	-nt "4scaled to 4 float"
-io 1
-mf1 ar rl 4 idb
-mf2 ar rl 6 idb;

desc 1 -tn 4 -sd l;
desc 2 -tn 4 -sd f;

data 1 -do -1 303 063;
data 2 -do -1 302042000;
data 3 300 146 376;

page -all;


/*		dv2d25
*		4 floating to 4 scaled
*
*/

inst	dv2d	-nt "4 floating to 4 scaled"
-io 2
-mf1 ar rl 6 idb
-mf2 ar rl 4 idb;

desc 1 -tn 4 -sd f;
desc 2 -tn 4 -sd l;

data 1 -do -1 302042000;
data 2 -do -1 303 063;
data 3 300 001;

page -all;


/*		dv2d26
*
*/

inst	dv2d	-nt "Simple divide"  -io 3
	-mf1	ar reg idb
	-mf2	ar reg idb;


desc 1	-sd n	-nn 3;
desc 2	-sd n	-nn 4;


data 1	-do -1	"060";
data 2	-do -3	"0120";
data 3	"0002";

page	-all;


/*   csl 1
*
*  Simple test of instruction to see if its functions.
*  Move 72 bits, cross no boundaries, and use no modification.
*
*/

inst  csl  -nt  "simple test"
           -bo mov ;

desc 1  -ns 72 ;

desc 2  -ns 72 ;

data 1  -do -8  "abcdefgh"  ;

data 2  -do -8  "wwwwwwww"  ;

data 3  "abcdefgh"  ;

page    -all  ;


/*   csl 2
*
*  Move two bits one on each side of a page boundary.
*  No modification is used.
*
*/

inst  csl  -nt  "invert 2 bits across boundary"
           -bo inv  ;

desc 1  -ns 2  -cp 3  -bp 8  ;

desc 2  -ns 2  -cp 3  -bp 8  ;

data 1  -do 4  000 000 000 001 000  ;

data 2  -do 4  000 000 000 001 000  ;

data 3  000 000 000 000 400  ;

page    -all  ;


/*   csl 3
*
*  Test moving data across 3 pages.  This requires register
*  length modification.
*
*/

inst  csl  -nt  "move data across 3 pages"
           -bo mov
           -io 1
           -mf1  rl 36946
           -mf2  rl 36946  ;

desc 1  -cp 3  -bp 4  ;

desc 2  -cp 3  -bp 4  ;

data 1  -do -8  000 000 000 006
        (513)  146531265234623214653126  760  ;

data 2  -do -8  000 000 000 037
        (513)  254315456312465146515314  600  ;

data 3  000 000 000 006
        (513)  146531265234623214653126  760  ;

page    -all  ;


/*   csl 4
*
*  AND bit strings using ar and reg modification in addition to
*  reg length modification.  Use data across 3 pages.
*
*/

inst  csl  -nt  "ar,reg mod. AND across 3 pages"
           -bo and
           -io 2
           -mf1  ar  reg  rl 36946
           -mf2  ar  reg  rl 36946  ;

desc 1  -cp 3  -bp 4  ;

desc 2  -cp 3  -bp 4  ;

data 1  -do -8  000 000 000 006
        (513)  146531265234623214653126  760  ;

data 2  -do -8  000 000 000 037
        (513)  254315456312465146515314  600  ;

data 3  000 000 000 006
        (513)  044111044210421004411104  600  ;

page    -all  ;


/*   csl 5
*
*  OR bit strings using indirect modification in addition to register
*  length modification.  Use data across 3 pages.
*
*/

inst  csl  -nt  "id mod.  OR across 3 pages"
           -bo or 
           -io 1
           -mf1  id  rl 36946
           -mf2  id  rl 36946  ;

desc 1  -cp 3  -bp 4  ;

desc 2  -cp 3  -bp 4  ;

data 1  -do -8  000 000 000 006
        (513)  146531265234623214653126  760  ;

data 2  -do -8  000 000 000 037
        (513)  254315456312465146515314  600  ;

data 3  000 000 000 037
        (513)  356735677336667356757336  760  ;

page    -all  ;


/*   csl 6
*
*  NAND bit strings using indirect ar and reg modification and
*  reg length modification.  Use data across 3 pages.
*
*/

inst  csl  -nt  "idb mod. NAND across 3 pages"
           -bo nan
           -mf1  idb  rl 36946
           -mf2  idb  rl 36946  ;

desc 1  -cp 3  -bp 4  ;

desc 2  -cp 3  -bp 4  ;

data 1  -do -8  000 000 000 006
        (513)  146531265234623214653126  760  ;

data 2  -do -8  000 000 000 037
        (513)  254315456312465146515314  600  ;

data 3  000 000 000 031
        (513)  733666733567356773366673  160  ;

page    -all  ;


/*   csl 7
*
*  XOR bit strings using indirect ar and reg modification and direct
*  ar, reg, and register length modification.  User data across 3 pages.
*
*/

inst  csl  -nt  "idb,ar,reg mod. XOR across 3 pgs"
           -bo xor
           -io 2
           -mf1  idb  ar  reg  rl 36946
           -mf2  idb  ar  reg  rl 36946  ;

desc 1  -cp 3  -bp 4  ;

desc 2  -cp 3  -bp 4  ;

data 1  -do -8  000 000 000 006
        (513)  146531265234623214653126  760  ;

data 2  -do -8  000 000 000 037
        (513)  254315456312465146515314  600  ;

data 3  000 000 000 031
        (513)  312624633126246352346232  160  ;

page    -all  ;

/*   csl 8
*
*  Test bit string CLEAR operator. Data is moved across 3 pages with
*  full address modification. The zero indicator will be set.
*
*/

inst  csl  -nt "CLEAR string. 3 pages moved"
           -bo zer
           -ir zr
           -io 3
           -mf1  idb  ar  reg  rl 36946
           -mf2  rl 36946  ;

desc 1  -cp 3  -bp 4  ;

desc 2  -cp 3  -bp 4  ;

data 1  -do -8  000 000 000 006
        (513)  146531265234623214653126  760  ;

data 2  -do -8  000 000 000 037
        (513)  254315456312465146515314  600  ;

data 3  000 000 000 000
        (513)  000000000000000000000000
        000  ;

page    -all  ;


/*   csl 9
*
*  Test truncation with INVERT operator.  Use full modification
*  and move data across 3 pages.
*
*/

inst  csl  -nt  "INVERT truncation is set"
           -bo inv
           -ir tn
           -io 1
           -mf1  idb  ar  reg  rl 36946
           -mf2  idb  ar  reg  rl 36943  ;

desc 1  -cp 3  -bp 4  ;

desc 2  -cp 3  -bp 4  ;

data 1  -do -8  000 000 000 006
        (513)  146531265234623214653126  760  ;

data 2  -do -8  000 000 000 037
        (513)  254315456312465146515314  700  ;

data 3  000 000 000 031
        (513)  631246512543154563124651  100  ;

page    -all  ;


/*   csl 10
*
*  Test the use of bit file with the COINcidence operator.  Use full
*  modification across 3 pages.  The fill bit is zero.
*
*/

inst  csl  -nt  "COIN. bit fill(0)"
           -bo nox
           -mf1  idb  ar  reg  rl 36943
           -mf2  idb  ar  reg  rl 36946  ;

desc 1  -cp 3  -bp 4  ;

desc 2  -cp 3  -bp 4  ;

data 1  -do -8  000 000 000 006
        (513)  146531265234623214653126  760  ;

data 2  -do -8  000 000 000 037
        (513)  254315456312465146515314  600  ;

data 3  000 000 000 006
        (513)  465153144651531425431545  760  ;

page    -all  ;


/*   csr 1
*
*  Simple test of instruction to see if its functions.
*  Move 72 bits, cross no boundaries, and use no modification.
*
*/

inst  csr  -nt  "simple test"
           -bo mov ;

desc 1  -ns 72 ;

desc 2  -ns 72 ;

data 1  -do -8  "abcdefgh"  ;

data 2  -do -8  "wwwwwwww"  ;

data 3  "abcdefgh"  ;

page    -all  ;


/*   csr 2
*
*  Move two bits one on each side of a page boundary.
*  No modification is used.
*
*/

inst  csr  -nt  "invert 2 bits across boundary"
           -bo inv  ;

desc 1  -ns 2  -cp 3  -bp 8  ;

desc 2  -ns 2  -cp 3  -bp 8  ;

data 1  -do 4  000 000 000 001 000  ;

data 2  -do 4  000 000 000 001 000  ;

data 3  000 000 000 000 400  ;

page    -all  ;

/*   csr 3
*
*  Test moving data across 3 pages.  This requires register
*  length modification.
*
*/

inst  csr  -nt  "move data across 3 pages"
           -bo mov
           -io 1
           -mf1  rl 36946
           -mf2  rl 36946  ;

desc 1  -cp 3  -bp 4  ;

desc 2  -cp 3  -bp 4  ;

data 1  -do -8  000 000 000 006
        (513)  146531265234623214653126  760  ;

data 2  -do -8  000 000 000 037
        (513)  254315456312465146515314  600  ;

data 3  000 000 000 006
        (513)  146531265234623214653126  760  ;

page    -all  ;


/*   csr 4
*
*  AND bit strings using ar and reg modification in addition to
*  reg length modification.  Use data across 3 pages.
*
*/

inst  csr  -nt  "ar,reg mod. AND across 3 pages"
           -bo and
           -io 2
           -mf1  ar  reg  rl 36946

           -mf2  ar  reg  rl 36946  ;
desc 1  -cp 3  -bp 4  ;

desc 2  -cp 3  -bp 4  ;

data 1  -do -8  000 000 000 006
        (513)  146531265234623214653126  760  ;

data 2  -do -8  000 000 000 037
        (513)  254315456312465146515314  600  ;

data 3  000 000 000 006
        (513)  044111044210421004411104  600  ;

page    -all  ;


/*   csr 5
*
*  OR bit strings using indirect modification in addition to register
*  length modification.  Use data across 3 pages.
*
*/

inst  csr  -nt  "id mod.  OR across 3 pages"
           -bo or 
           -io 1
           -mf1  id  rl 36946
           -mf2  id  rl 36946  ;

desc 1  -cp 3  -bp 4  ;

desc 2  -cp 3  -bp 4  ;

data 1  -do -8  000 000 000 006
        (513)  146531265234623214653126  760  ;

data 2  -do -8  000 000 000 037
        (513)  254315456312465146515314  600  ;

data 3  000 000 000 037
        (513)  356735677336667356757336  760  ;

page    -all  ;


/*   csr 6
*  NAND bit strings using indirect ar and reg modification and
*  reg length modification.  Use data across 3 pages.
*
*/

inst  csr  -nt  "idb mod. NAND across 3 pages"
           -bo nan
           -mf1  idb  rl 36946
           -mf2  idb  rl 36946  ;

desc 1  -cp 3  -bp 4  ;

desc 2  -cp 3  -bp 4  ;

data 1  -do -8  000 000 000 006
        (513)  146531265234623214653126  760  ;

data 2  -do -8  000 000 000 037
        (513)  254315456312465146515314  600  ;

data 3  000 000 000 031
        (513)  733666733567356773366673  160  ;

page    -all  ;


/*   csr 7
*

*  XOR bit strings using indirect ar and reg modification and direct
*  ar, reg, and register length modification.  User data across 3 pages.
*
*/

inst  csr  -nt  "idb,ar,reg mod. XOR across 3 pgs"
           -bo xor
           -io 2
           -mf1  idb  ar  reg  rl 36946
           -mf2  idb  ar  reg  rl 36946  ;

desc 1  -cp 3  -bp 4  ;

desc 2  -cp 3  -bp 4  ;

data 1  -do -8  000 000 000 006
        (513)  146531265234623214653126  760  ;

data 2  -do -8  000 000 000 037
        (513)  254315456312465146515314  600  ;

data 3  000 000 000 031
        (513)  312624633126246352346232  160  ;

page    -all  ;

/*   csr 8
*
*  Test bit string CLEAR operator. Data is moved across 3 pages with
*  full address modification. The zero indicator will be set.
*
*/

inst  csr  -nt "CLEAR string. 3 pages moved"
           -bo zer
           -ir zr
           -io 3
           -mf1  idb  ar  reg  rl 36946
           -mf2  rl 36946  ;

desc 1  -cp 3  -bp 4  ;

desc 2  -cp 3  -bp 4  ;

data 1  -do -8  000 000 000 006
        (513)  146531265234623214653126  760  ;

data 2  -do -8  000 000 000 037
        (513)  254315456312465146515314  600  ;

data 3  000 000 000 000
        (513)  000000000000000000000000
        000  ;

page    -all  ;


/*   csr 9
*
*  Test truncation with INVERT operator.  Use full modification
*  and move data across 3 pages.
*
*/

inst  csr  -nt  "INVERT truncation is set"
           -bo inv
           -ir tn
           -io 1
           -mf1  idb  ar  reg  rl 36946
           -mf2  idb  ar  reg  rl 36943  ;

desc 1  -cp 3  -bp 4  ;

desc 2  -cp 3  -bp 7  ;

data 1  -do -8  000 000 000 006
        (513)  146531265234623214653126  760  ;

data 2  -do -8  000 000 000 037
        (513)  254315456312465146515314  700  ;

data 3  000 000 000 035
        (513)  631246512543154563124651  000  ;

page    -all  ;


/*   csr 10
*
*  Test the use of bit file with the COINcidence operator.  Use full
*  modification across 3 pages.  The fill bit is zero.
*
*/

inst  csr  -nt  "COIN. bit fill(0)"
           -bo nox
           -mf1  idb  ar  reg  rl 36943
           -mf2  idb  ar  reg  rl 36946  ;

desc 1  -cp 3  -bp 7  ;

desc 2  -cp 3  -bp 4  ;

data 1  -do -8  000 000 000 006
        (513)  146531265234623214653126  760  ;

data 2  -do -8  000 000 000 037
        (513)  254315456312465146515314  600  ;

data 3  000 000 000 002
        (513)  465153144651531425431545  600  ;

page    -all  ;


/*     sztl1
*  Use two maximum length strings (4352 chrs or 39168 bits).
*  The zero indicator will be on since a bool code of "zer"
*  is used. Take maximum number of page faults.  */

inst sztl -nt "Both strings are the same length"
-bo zer
-ir zr
-mf1 idb ar reg rl 39168
-mf2 idb ar reg rl 39168
-io 1;

data 1 -do -10 (4352)"5";
data 2 -do -30 (4352)"7";

page -all;


/*     sztl2
*  Both the truncation and the zero indicators will be turned
*  on.  The 1st string will begin on the last bit of a page and
*  the 2nd string will end on the 1st bit of a page.  */

inst sztl -nt "Both strings cross page bounds"
-bo zer
-ir tn zr
-mf1 ar
-mf2 ar;

desc 1 -bp 8 -ns 23;
desc 2 -bp 1 -ns 18;

data 1 -do -1 074 321 64;
data 2 -do -4 023 776 4;

page -all;


/*     sztl3
*  No indicators are turned on. The zero fill bit is used. Bit strings
*  begin in the middle of a byte  */

inst sztl -nt "Both strings cross page bounds"
-bo and
-mf1 ida ar
-mf2 idb ar;

desc 1 -bp 4 -ns 70;
desc 2 -bp 5 -ns 80;

data 1 -do -2 "3274" "1958" 0;
data 2 -do -4 "4875" "7329" 326 0;

page -all;


/*     sztl4
*  The zero indicator will be turned on. Both strings
are of the same length and begin and end on word boundaries.  */

inst sztl -nt "only rl modification is used"
-bo and
-ir zr
-mf1 rl 144
-mf2 rl 144
-io 2;

data 1 (4)123 (12)075;
data 2 (4)654 (12)402;

page -all;


/*     sztl5
*  Test the axr bool code.  Set the zero and truncation
*  indicators. Bit strings begin in the middle of a byte
*  straddling a page boundary.  */

inst sztl -nt "1st string is longer than 2nd"
-bo axr
-ir zr tn
-mf1 ar reg rl 40
-mf2 ar idr rl 31;

desc 1 -bp 5;
desc 2 -bp 5;

data 1 -do -1 074 321 652 403 777;
data 2 -do -3 777 777 676 603;

page -all;


/*     sztl6
*  Test the axr bool code. No indicators will be set  */

inst sztl -nt "Both strings are the same length"

-bo axr
-mf1 rl 7866
-mf2 rl 7866;

data 1 (874)"321";
data 2 (874) "604";

page -all;


/*     sztl7
*  Test the mov bool code. Use a maximum length string and the
*  zero fill bit.  Take the maximum number of page faults.  */

inst sztl -nt "2nd string is longer than 1st"
-bo mov
-mf1 ida ar rl 36000
-mf2 idb ar reg rl 39168
-io 1;

data 1 -do -40 (1000)"9874";
data 2 -do -20 (1088) "0000";

page -all;


/*     sztl8
*  Test the move bool code. Set the zero indicator.
*  The first string is all zeroes.  */

inst sztl -nt "2nd string is longer than 1st"
-bo mov
-ir zr
-mf1 ar id
-mf2 ar
-io 2;

desc 1 -bp 7 -ns 99;
desc 2 -bp 1 -ns 100;

data 1 -do 20 (12)000;
data 2 -do 3 "abcde123456" 4;

page -all;


/*     sztl9
*  Test xra bool code. Set zero and truncation indicators.
*  Use two short bit strings which cross page boundaries.  */

inst sztl -nt "1st string is longer than 2nd"
-bo xra
-ir tn zr
-mf1 ar idr
-mf2 ar idb;

desc 1 -ns 3 -bp 7;
desc 2 -ns 2 -bp 8;

data 1 -do -1 777 4;
data 2 -do -1 235 0;

page -all;


/*     sztl10
* Test xra bool code.  Use the zero fill bit. No indicators are set */

inst sztl -nt "2nd string is longer than 1st"
-bo xra
-mf1 idr reg
-mf2 idr
-io 2;

desc 1 -ns 400;
desc 2 -ns 500;

data 1 (44)"9" 72;
data 2 (55)"8" 36;

page -all;


/*     sztl11
*  Test ra2 bool code. Set the zero indicator. This means
*  that the 2nd bit string must be all zeroes.  */

inst sztl -nt "2nd string is longer than 1st"
-bo ra2
-mf1 ar rl 36
-mf2 reg
-ir zr
-io 1;

desc 1 -bp 4;
desc 2 -ns 36;

data 1 -do -1 "abcd" 70;
data 2 (4)000;

page -all;


/*     sztl12
*  Test ra2 bool code. No indicators are set.  */

inst sztl -nt "Both strings are the same length"
-bo ra2
-mf1 reg
-mf2 ar rl 36
-io 2;

desc 1 -ns 36;
desc 2 -bp 4;

data 1 (4)000;
data 2 -do -1 "abcd" 70;

page -all;


/*     sztl13
*  Test xor bool code. Set the zero indicator. Use zero fill.  */

inst sztl -nt "2nd string is longer than 1st"
-bo xor
-mf1 id reg
-mf2 ar;

desc 1 -ns 3600;
desc 2 -ns 3672 -bp 7;

data 1 -do -8 (100)3526;
data 2 -do -63 000 (100)7254 (7)000;

page -all;


/*     sztl14
*  Test xor bool code. use strings of identical length.
*  No indicators are set.  */

inst sztl -nt "Both strings are the same length"
-bo xor;

desc  1 -ns 900;
desc 2 -ns 900;

data 1 -do -12 (10) "abcdefghij";
data 2 -do -4  (10) "1234567890";

page -all;


/*     sztl15
*  Test the or bool code. Set zero and truncation indicators.
*  This means that both bit strings must be all zeroes.  The
*   first bit string must be longer than the second  */

inst sztl -nt "1st string is longer than 2nd"
-bo or 
-ir zr tn
-mf1 rl 30 idb ar
-mf2 rl 20 ar ida;

data 1 000 000 000 0;
data 2  000 000 0;

page -all;


/*     sztl16
*  Test the or bool code. No indicators are set.
*  The one fill bit is used.  */

inst sztl -nt "2nd string is longer than 1st"
-bo or 
-fb
-mf1 rl 3000 ar id
-mf2 rl 3900 ar idr
-io 1;

data 1 (1000)7;
data 2 (325)"x" (325)3 ;

page -all;


/*     sztl17
* Test the nor bool code. No indicators are set.  */

inst sztl -nt "2nd string is longer than 1st"
-bo nor
-mf1 ida ar rl 14
-mf2 id ar rl 28
-io 2;

data 1 342 22;
data 2 234 760 621 0;

page -all;


/*     sztl18
*  Test the nor bool code.  Set the zero indicator.
*  Use the one fill bit */

inst sztl -nt "2nd string is longer than 1st"
-ir zr
-bo nor
-fb
-mf1 ar
-mf2 rl 19;

desc 1 -ns 8 -bp 1;

data 1 777;
data 2 326 417 0;

page -all;


/*     sztl19
*  Test the nox bool code.  Set the zero indicator.
*  For the indicator to be set, no two bits may matc.  */

inst sztl -nt "Both strings are the same length"
-ir zr
-bo nox
-mf1 id
-mf2 ida;

desc 1 -ns 54;
desc 2 -ns 54;

data 1 124 235 647 211 000 777;
data 2 -do -4 653 542 130 566 777 000;

page -all;


/*     sztl20
*  Test the Nox bool code. Only the truncation indicator is set.  */

inst sztl -nt "1st string is longer than 2nd"
-bo nox -ir tn
-mf1 ar rl 36000
-mf2 ar id
-io 1;


desc 1 -bp 7;
desc 2 -bp 3 -ns 3600;

data 1 003 (1000)"axyr";
data 2 024 (100)"rjqf";

page -all;


/*     sztl21
*  Test the iv2 bool code. Both the zero and the truncation
*  indicators will be set.  For the zero indicator to be set,
*  the 2nd bit string must be all ones.  */

inst sztl -nt "1st string is longer than 2nd"
-bo iv2  -ir zr tn
-mf1 rl 64 ar reg
-mf2 ar id
-io 1;

desc 1 -bp 6;
desc 2 -ns 32 -bp 3;

data 1 -do -1  "abpstuv" 4;
data 2 077 777 777 776;

page -all;


/*     sztl22
*  Test the iv2 bool code.  Use the zero fill bit. No indicators are set.  */

inst sztl -nt "2nd string is longer than 1st"
-bo iv2
-mf1 ar id
-mf2 rl 64 ar reg
-io 1;

desc 1 -ns 32 -bp 3;
desc 2 -bp 6;

data 1 077 777 777 776;
data 2 -do -1  "abpstuv" 4;

page -all;


/*     sztl23
*  Test the xrx bool code.  The zero indicator will be set.
*  This can occur only when every bit in the first string is zero
* and every bit in the 2nd string is one.  */

inst sztl -nt "Both strings are the same length"
-bo xrx -ir zr
-mf1 reg
-mf2 id;

desc 1 -ns 108;
desc 2 -ns 108;

data 1 -do -4 (12)000;
data 2 -do 4  (12)777;

page -all;


/*     sztl24
*  Test the xrx bool code.  No indicators are set.  The zero fill bit is used  */

inst sztl -nt "2nd string is longer than 1st"
-bo xrx
-mf1 rl 720 idr ar
-mf2 id
-io 2;

desc 2 -ns 1080  -bp 4;

data 1 -do -3  (20)"ijkl";
data 2 -do 8  054  (30)"9832";

page -all;


/*     sztl25
*  Test the inv bool code.  Set the zero indicator.
*  To set the indicator, the first bit string must be
*  all ones.  */

inst sztl -nt "Both string are the same length"
-ir zr
-bo inv
-mf1 idb ar reg
-mf2 idb ar;

desc 1 -bp 5 -ns 13;
desc 2 -bp 2 -ns 13;

data 1 777 777;
data 2 265 43;

page -all;


/*     sztl26
*   Test the inv bool code. No indicators are set  */

inst sztl -nt "Both strings are the same length"
-bo inv
-mf1 idb ar
-mf2 idb ar reg;

desc 1 -bp 2 -ns 13;
desc 2 -bp 5 -ns 13;

data 1 265 43;
data 2 777 777;

page -all;


/*     sztl27
*  Test the xxr bool code. This test sets the zero indicator.
*  The zero indicator is set only when the 1st string is all ones and
*  the second string is all zeroes.  The one fill bit is used.  */

inst sztl -nt "2nd string is longer than 1st"
-ir zr
-fb
-bo xxr
-io2;

desc 1 -ns 1;
desc 2 -ns 2;

data 1 4;
data 2 0;

page -all;


/*     sztl28
*  Test the xxr bool code. No indicators are set   */

inst sztl -nt "2nd string is longer than 1st"
-bo xxr
-mf1 ar
-mf2 reg rl 59;

desc 1 -ns 43 -bp 5;

data 1 -do -2 "tsrkv" 3;
data 2 -do -4 "mnopqrs";

page -all;


/*     sztl29
*  Test the nan bool code. The zero and truncation indicators
*  are set.  For the zero indicator to be set, both bit strings
* must be all ones.  */

inst sztl -nt "1st string is longer than 2nd"
-bo nan
-ir zr tn
-mf1 rl 39168 ar
-mf2 rl 33000;

data 1 (4352)777;
data 2 (3667)777;

page -all;


/*     sztl30
*  Test the nan bool code. No indicators are set.
*  The one fill bit is set.  */

inst sztl -nt "2nd string is longer than 1st"
-fb
-bo nan
-mf1 ar
-mf2 ar rl 436;

desc 1 -bp 3 -ns 274;

data 1 (7)"tack" "rgm";
data 2 (12)"mike" 023;

page -all;


/*     sztl31
*  Test the "set" bool code. The zero indicator cannot be set
*  when the "set" code is used. This test sets the truncation
indicator.  */

inst sztl -nt "1st string is longer than 2nd"
-ir tn
-bo set;

desc 1 -ns 50;
desc 2 -ns 49;

data 1 023 571 725 152 111 243;
data 2 023 571 777 043 121 000;

page -all;


/*     sztl32
*  Test the "set" bool code. No indicators are set.
*  The maximum number of page faults is taken  */

inst sztl -nt "2nd string is longer than 1st"
-bo set
-mf1 idb ar reg rl 39159
-mf2 idb ar reg rl 39168
-io 1
-fb;

data 1 (4351)000;
data 2 (4352)071;

page -all;


/*     sztr1
*  Use two maximum length strings (4352 chrs or 39168 bits).
*  The zero indicator will be on since a bool code of "zer"
*  is used. Take maximum number of page faults.  */

inst sztr -nt "Both strings are the same length"
-bo zer
-ir zr
-mf1 idb ar reg rl 39168
-mf2 idb ar reg rl 39168
-io 1;

data 1 -do -10 (4352)"5";
data 2 -do -30 (4352)"7";

page -all;


/*     sztr2
*  Both the truncation and the zero indicators will be turned
*  on.  The 1st string will begin on the last bit of a page and
*  the 2nd string will end on the 1st bit of a page.  */

inst sztr -nt "Both strings cross page bounds"
-bo zer
-ir tn zr
-mf1 ar
-mf2 ar;

desc 1 -bp 8 -ns 23;
desc 2 -bp 1 -ns 18;

data 1 -do -1 074 321 64;
data 2 -do -4 023 776 4;

page -all;


/*     sztr3
*  No indicators are turned on. The zero fill bit is used. Bit strings
*  begin in the middle of a byte  */

inst sztr -nt "Both strings cross page bounds"
-bo and
-mf1 ida ar
-mf2 idb ar;

desc 1 -bp 4 -ns 70;
desc 2 -bp 5 -ns 80;

data 1 -do -2 "3274" "1958" 0;
data 2 -do -4 "4875" "7329" 326 0;

page -all;


/*     sztr4
*  The zero indicator will be turned on. Both strings
are of the same length and begin and end on word boundaries.  */

inst sztr -nt "only rl modification is used"
-bo and
-ir zr
-mf1 rl 144
-mf2 rl 144
-io 2;

data 1 (4)123 (12)075;
data 2 (4)654 (12)402;

page -all;


/*     sztr5
*  Test the axr bool code.  Set the zero and truncation
*  indicators. Bit strings begin in the middle of a byte
*  straddling a page boundary.  */

inst sztr -nt "1st string is longer than 2nd"
-bo axr
-ir tn
-mf1 ar reg rl 40
-mf2 ar idr rl 31;

desc 1 -bp 5;
desc 2 -bp 5;

data 1 -do -1 074 321 652 403 777;
data 2 -do -3 777 777 676 603;

page -all;


/*     sztr6
*  Test the axr bool code. No indicators will be set  */

inst sztr -nt "Both strings are the same length"

-bo axr
-mf1 rl 7866
-mf2 rl 7866;

data 1 (874)"321";
data 2 (874) "604";

page -all;


/*     sztr7
*  Test the mov bool code. Use a maximum length string and the
*  zero fill bit.  Take the maximum number of page faults.  */

inst sztr -nt "2nd string is longer than 1st"
-bo mov
-mf1 ida ar rl 36000
-mf2 idb ar reg rl 39168
-io 1;

data 1 -do -40 (1000)"9874";
data 2 -do -20 (1088) "0000";

page -all;


/*     sztr8
*  Test the move bool code. Set the zero indicator.
*  The first string is all zeroes.  */

inst sztr -nt "2nd string is longer than 1st"
-bo mov
-ir zr
-mf1 ar id
-mf2 ar
-io 2;

desc 1 -bp 7 -ns 99;
desc 2 -bp 1 -ns 100;

data 1 -do 20 (12)000;
data 2 -do 3 "abcde123456" 4;

page -all;


/*     sztr9
*  Test xra bool code. Set zero and truncation indicators.
*  Use two short bit strings which cross page boundaries.  */

inst sztr -nt "1st string is longer than 2nd"
-bo xra
-ir tn zr
-mf1 ar idr
-mf2 ar idb;

desc 1 -ns 3 -bp 7;
desc 2 -ns 2 -bp 8;

data 1 -do -1 777 4;
data 2 -do -1 235 0;

page -all;


/*     sztr10
* Test xra bool code.  Use the zero fill bit. No indicators are set */

inst sztr -nt "2nd string is longer than 1st"
-bo xra
-mf1 idr reg
-mf2 idr
-io 2;

desc 1 -ns 400;
desc 2 -ns 500;

data 1 (44)"9" 72;
data 2 (55)"8" 36;

page -all;


/*     sztr11
*  Test ra2 bool code. Set the zero indicator. This means
*  that the 2nd bit string must be all zeroes.  */

inst sztr -nt "2nd string is longer than 1st"
-bo ra2
-mf1 ar rl 36
-mf2 reg
-ir zr
-io 1;

desc 1 -bp 4;
desc 2 -ns 36;

data 1 -do -1 "abcd" 70;
data 2 (4)000;

page -all;


/*     sztr12
*  Test ra2 bool code. No indicators are set.  */

inst sztr -nt "Both strings are the same length"
-bo ra2
-mf1 reg
-mf2 ar rl 36
-io 2;

desc 1 -ns 36;
desc 2 -bp 4;

data 1 (4)000;
data 2 -do -1 "abcd" 70;

page -all;


/*     sztr13
*  Test xor bool code. Set the zero indicator. Use zero fill.  */

inst sztr -nt "2nd string is longer than 1st"
-bo xor
-mf1 id reg
-mf2 ar;

desc 1 -ns 3600;
desc 2 -ns 3672 -bp 7;

data 1 -do -8 (100)3526;
data 2 -do -63 000 (100)7254 (7)000;

page -all;


/*     sztr14
*  Test xor bool code. use strings of identical length.
*  No indicators are set.  */

inst sztr -nt "Both strings are the same length"
-bo xor;

desc  1 -ns 900;
desc 2 -ns 900;

data 1 -do -12 (10) "abcdefghij";
data 2 -do -4  (10) "1234567890";

page -all;


/*     sztr15
*  Test the or bool code. Set zero and truncation indicators.
*  This means that both bit strings must be all zeroes.  The
*   first bit string must be longer than the second  */

inst sztr -nt "1st string is longer than 2nd"
-bo or 
-ir zr tn
-mf1 rl 30 idb ar
-mf2 rl 20 ar ida;

data 1 000 000 000 0;
data 2  000 000 0;

page -all;


/*     sztr16
*  Test the or bool code. No indicators are set.
*  The one fill bit is used.  */

inst sztr -nt "2nd string is longer than 1st"
-bo or 
-fb
-mf1 rl 3000 ar id
-mf2 rl 3900 ar idr
-io 1;

data 1 (1000)7;
data 2 (325)"x" (325)3 ;

page -all;


/*     sztr17
* Test the nor bool code. No indicators are set.  */

inst sztr -nt "2nd string is longer than 1st"
-bo nor
-mf1 ida ar rl 14
-mf2 id ar rl 28
-io 2;

data 1 342 22;
data 2 234 760 621 0;

page -all;


/*     sztr18
*  Test the nor bool code.  Set the zero indicator.
*  Use the one fill bit */

inst sztr -nt "2nd string is longer than 1st"
-ir zr
-bo nor
-fb
-mf1 ar
-mf2 rl 19;

desc 1 -ns 8 -bp 1;

data 1 777;
data 2 326 417 0;

page -all;


/*     sztr19
*  Test the nox bool code.  Set the zero indicator.
*  For the indicator to be set, no two bits may matc.  */

inst sztr -nt "Both strings are the same length"
-ir zr
-bo nox
-mf1 id
-mf2 ida;

desc 1 -ns 54;
desc 2 -ns 54;

data 1 124 235 647 211 000 777;
data 2 -do -4 653 542 130 566 777 000;

page -all;


/*     sztr20
*  Test the Nox bool code. Only the truncation indicator is set.  */

inst sztr -nt "1st string is longer than 2nd"
-bo nox -ir tn
-mf1 ar rl 36000
-mf2 ar id
-io 1;


desc 1 -bp 7;
desc 2 -bp 3 -ns 3600;

data 1 003 (1000)"axyr";
data 2 024 (100)"rjqf";

page -all;


/*     sztr21
*  Test the iv2 bool code. Both the zero and the truncation
*  indicators will be set.  For the zero indicator to be set,
*  the 2nd bit string must be all ones.  */

inst sztr -nt "1st string is longer than 2nd"
-bo iv2  -ir zr tn
-mf1 rl 64 ar reg
-mf2 ar id
-io 1;

desc 1 -bp 6;
desc 2 -ns 32 -bp 3;

data 1 -do -1  "abpstuv" 4;
data 2 077 777 777 776;

page -all;


/*     sztr22
*  Test the iv2 bool code.  Use the zero fill bit. No indicators are set.  */

inst sztr -nt "2nd string is longer than 1st"
-bo iv2
-mf1 ar id
-mf2 rl 64 ar reg
-io 1;

desc 1 -ns 32 -bp 3;
desc 2 -bp 6;

data 1 077 777 777 776;
data 2 -do -1  "abpstuv" 4;

page -all;


/*     sztr23
*  Test the xrx bool code.  The zero indicator will be set.
*  This can occur only when every bit in the first string is zero
* and every bit in the 2nd string is one.  */

inst sztr -nt "Both strings are the same length"
-bo xrx -ir zr
-mf1 reg
-mf2 id;

desc 1 -ns 108;
desc 2 -ns 108;

data 1 -do -4 (12)000;
data 2 -do 4  (12)777;

page -all;


/*     sztr24
*  Test the xrx bool code.  No indicators are set.  The zero fill bit is used  */

inst sztr -nt "2nd string is longer than 1st"
-bo xrx
-mf1 rl 720 idr ar
-mf2 id
-io 2;

desc 2 -ns 1080  -bp 4;

data 1 -do -3  (20)"ijkl";
data 2 -do 8  054  (30)"9832";

page -all;


/*     sztr25
*  Test the inv bool code.  Set the zero indicator.
*  To set the indicator, the first bit string must be
*  all ones.  */

inst sztr -nt "Both string are the same length"
-ir zr
-bo inv
-mf1 idb ar reg
-mf2 idb ar;

desc 1 -bp 5 -ns 13;
desc 2 -bp 2 -ns 13;

data 1 777 777;
data 2 265 43;

page -all;


/*     sztr26
*   Test the inv bool code. No indicators are set  */

inst sztr -nt "Both strings are the same length"
-bo inv
-mf1 idb ar
-mf2 idb ar reg;

desc 1 -bp 2 -ns 13;
desc 2 -bp 5 -ns 13;

data 1 265 43;
data 2 777 777;

page -all;


/*     sztr27
*  Test the xxr bool code. This test sets the zero indicator.
*  The zero indicator is set only when the 1st string is all ones and
*  the second string is all zeroes.  The one fill bit is used.  */

inst sztr -nt "2nd string is longer than 1st"
-ir zr
-fb
-bo xxr
-io2;

desc 1 -ns 1;
desc 2 -ns 2;

data 1 4;
data 2 0;

page -all;


/*     sztr28
*  Test the xxr bool code. No indicators are set   */

inst sztr -nt "2nd string is longer than 1st"
-bo xxr
-mf1 ar
-mf2 reg rl 59;

desc 1 -ns 43 -bp 5;

data 1 -do -2 "tsrkv" 3;
data 2 -do -4 "mnopqrs";

page -all;


/*     sztr29
*  Test the nan bool code. The zero and truncation indicators
*  are set.  For the zero indicator to be set, both bit strings
* must be all ones.  */

inst sztr -nt "1st string is longer than 2nd"
-bo nan
-ir zr tn
-mf1 rl 39168 ar
-mf2 rl 33000;

data 1 (4352)777;
data 2 (3667)777;

page -all;


/*     sztr30
*  Test the nan bool code. No indicators are set.
*  The one fill bit is set.  */

inst sztr -nt "2nd string is longer than 1st"
-fb
-bo nan
-mf1 ar
-mf2 ar rl 436;

desc 1 -bp 3 -ns 274;

data 1 (7)"tack" "rgm";
data 2 (12)"mike" 023;

page -all;


/*     sztr31
*  Test the "set" bool code. The zero indicator cannot be set
*  when the "set" code is used. This test sets the truncation
indicator.  */

inst sztr -nt "1st string is longer than 2nd"
-ir tn
-bo set;

desc 1 -ns 50;
desc 2 -ns 49;

data 1 023 571 725 152 111 243;
data 2 023 571 777 043 121 000;

page -all;


/*     sztr32
*  Test the "set" bool code. No indicators are set.
*  The maximum number of page faults is taken  */

inst sztr -nt "2nd string is longer than 1st"
-bo set
-mf1 idb ar reg rl 39159
-mf2 idb ar reg rl 39168
-io 1
-fb;

data 1 (4351)000;
data 2 (4352)071;

page -all;


/*     cmpb1
*  Use two maximum length strings (4352 chrs or 39168 bits)
*  with the first string less than the 2nd. Take the maximum
*  number of page faults.  */

inst cmpb
-nt "both strings cross page bounds"
-mf1 idb ar reg rl 39168
-mf2 idb ar reg rl 39168
-io 1;

data 1 -do -10 (4352)"5";
data 2 -do -30 (4352)"7";

page -all;


/*     cmpb2
*  The first string begins on the last bit of a page and the
*  2nd string ends on the first bit of a page. The first string is
*  greater than the 2nd.  */

inst cmpb -nt "both strings cross page bounds"
-ir cr
-mf1 ar
-mf2 ar;

desc 1 -bp 8 -ns 23;
desc 2 -bp 1 -ns 18;

data 1 -do -1 074 321 64;
data 2 -do -4 023 776 4;

page -all;


/*     cmpb3
*  Both strings begin in the middle of a byte and span page boundaries.
*  The first string is greater than the 2nd.  */

inst cmpb -nt "both strings cross page bounds"
-ir cr
-mf1 ida ar
-mf2 idb ar;

desc 1 -bp 4 -ns 70;
desc 2 -bp 5 -ns 80;

data 1 -do -2 "3274" "1958" 0;
data 2 -do -4 "4875" "7329" 326 0;

page -all;


/*     cmpb4
*  Both strings are 4 words in length and neither
string spans a page boundary. The first string is
*  less than the 2nd.  */

inst cmpb -nt "both strings are the same length"
-mf1 rl 144
-mf2 rl 144
-io 2;

data 1 (4)123 (12)075;
data 2 (4)654 (12)402;

page -all;


/*     cmpb5
*  Both strings begin in the middle of a byte and span a
* page boundary. The first string is less than the 2nd.  */

inst cmpb -nt "2nd string has indirect desc"
-mf1 ar reg rl 40
-mf2 ar idr rl 31;

desc 1 -bp 5;
desc 2 -bp 5;

data 1 -do -1 074 321 652 403 777;
data 2 -do -3 777 777 676 603;

page -all;


/*     cmpb6
*  Both strings are 874 bytes in length and the first string
*  is less than the 2nd. Only 3 page faults occur.  */

inst cmpb -nt "both strings are the same length"

-mf1 rl 7866
-mf2 rl 7866;

data 1 (874)"321";
data 2 (874) "604";

page -all;


/*     cmpb7
*  The first string is l000 words in length and the
*  2nd string is 1088 words of all zeroes. The first
*  string is greater than the 2nd.  */

inst cmpb -nt "both strings cross page bounds"
-ir cr
-mf1 ida ar rl 36000
-mf2 idb ar reg rl 39168
-io 1;

data 1 -do -40 (1000)"9874";
data 2 -do -20 (1088) "0000";

page -all;


/*     cmpb8
*  Both strings begin in the middle of a byte and
* neither string spans a page boundary. The first string is less
* than the 2nd.  */

inst cmpb -nt "2nd string is longer than 1st"
-mf1 ar id
-mf2 ar
-io 2;

desc 1 -bp 7 -ns 99;
desc 2 -bp 1 -ns 100;

data 1 -do 20 (12)000;
data 2 -do 3 "abcde123456" 4;

page -all;


/*     cmpb9
*  Both strings begin in the middle of a byte and span pages.
*  The first string is all ones and is greater than the 2nd.  */

inst cmpb -nt "1st string is longer than 2nd"
-ir cr
-mf1 ar idr
-mf2 ar idb;

desc 1 -ns 3 -bp 7;
desc 2 -ns 2 -bp 8;

data 1 -do -1 777 4;
data 2 -do -1 235 0;

page -all;


/*     cmpb10
*  The first string is greater than the 2nd, although it is
shorter in length.  */

inst cmpb -nt "2nd string is longer than 1st"
-ir cr
-mf1 idr reg
-mf2 idr
-io 2;

desc 1 -ns 400;
desc 2 -ns 500;

data 1 (44)"9" 72;
data 2 (55)"8" 36;

page -all;


/*     cmpb11
*  Both strings are 1 word in length and only the 1st
* string spans a page boundary. The first string is greater
*  than the 2nd.  */

inst cmpb -nt "2nd string is longer than 1st"
-mf1 ar rl 36
-mf2 reg
-ir cr
-io 1;

desc 1 -bp 4;
desc 2 -ns 36;

data 1 -do -1 "abcd" 70;
data 2 (4)000;

page -all;


/*     cmpb12
*  Both strings are 1 word in length and only
*  the 2nd string spans a page boundary.  The 2nd string
*  is greater than the first.  */

inst cmpb -nt "both strings are the same length"
-mf1 reg
-mf2 ar rl 36
-io 2;

desc 1 -ns 36;
desc 2 -bp 4;

data 1 (4)000;
data 2 -do -1 "abcd" 70;

page -all;


/*     cmpb13
*  The first string is 100 words in length and the  2nd
string is 102 words long. Both strings span a page and the
first string is greater than the 2nd.  */


inst cmpb -nt "2nd string is longer than 1st"
-ir cr
-mf1 id reg
-mf2 ar;

desc 1 -ns 3600;
desc 2 -ns 3672 -bp 7;

data 1 -do -8 (100)3526;
data 2 -do -63 000 (100)7254 (7)000;

page -all;


/*     cmpb14
*  Both strings are 100 bytes long and span a page.  The
first string is larger than the 2nd.  */

inst cmpb -nt "both strings are the same length"
-ir cr;

desc  1 -ns 900;
desc 2 -ns 900;

data 1 -do -12 (10) "abcdefghij";
data 2 -do -4  (10) "1234567890";

page -all;


/*     cmpb15
*  Both strings are all zeroes and thus they are equal.  */

inst cmpb -nt "1st string is longer than 2nd"
-ir cr zr
-mf1 rl 30 idb ar
-mf2 rl 20 ar ida;

data 1 000 000 000 0;
data 2  000 000 0;

page -all;


/*     cmpb16
*  The first string is shorter than the 2nd and the
one fill bit is used.  The first string is all ones and
is greater than the 2nd.  */

inst cmpb -nt "2nds string is longer than 1st"
-ir cr
-fb
-mf1 rl 3000 ar id
-mf2 rl 3900 ar idr
-io 1;

data 1 (1000)7;
data 2 (325)"x" (325)3 ;

page -all;


/*     cmpb17
*  The first string is greater than the 2nd although it is
shorter in length.  */

inst cmpb -nt "2nd string is longer than 1st"
-ir cr
-mf1 ida ar rl 14
-mf2 id ar rl 28
-io 2;

data 1 342 22;
data 2 234 760 621 0;

page -all;


/*     cmpb18
*  The fill bit is used to make the first string all ones.
*  The first string is greater than the second.  */

inst cmpb -nt "2nd string is longer than 1st"
-ir cr
-fb
-mf1 ar
-mf2 rl 19;

desc 1 -ns 8 -bp 1;

data 1 777;
data 2 326 417 0;

page -all;


/*     cmpb19
*  Both strings are 6 bytes in length and the 2nd string
*  spans a page boundary. The first string is less than the 2nd.  */

inst cmpb -nt "both strings are the same length"
-mf1 id
-mf2 ida;

desc 1 -ns 54;
desc 2 -ns 54;

data 1 124 235 647 211 000 777;
data 2 -do -4 653 542 130 566 777 000;

page -all;


/*     cmpb20
*  Both strings begin in the middle of a byte.  The first
*  string is 1000 words long while the 2nd string is 100
* words long. The first  string is greater than the 2nd.  */

inst cmpb -nt "1st string is longer than 2nd"
-ir cr
-mf1 ar rl 36000
-mf2 ar id
-io 1;


desc 1 -bp 7;
desc 2 -bp 3 -ns 3600;

data 1 003 (1000)"axyr";
data 2 024 (100)"rjqf";

page -all;


/*     cmpb21
*  Both strings begin in the middle of a byte and only the
first string crosses a page boundary.  The 2nd string is all
ones  and is greater than the first.  */

inst cmpb -nt "1st string is longer than 2nd"
-mf1 rl 64 ar reg
-mf2 ar id
-io 1;

desc 1 -bp 6;
desc 2 -ns 32 -bp 3;

data 1 -do -1  "abpstuv" 4;
data 2 077 777 777 776;

page -all;


/*     cmpb22
*  Both strings begin in the middle of a byte and only the 2nd
string crosses a page boundary.  The first string is all ones and
is greater than the 2nd string.  */

inst cmpb -nt "2nd string is longer than 1st"
-ir cr
-mf1 ar id
-mf2 rl 64 ar reg
-io 1;

desc 1 -ns 32 -bp 3;
desc 2 -bp 6;

data 1 077 777 777 776;
data 2 -do -1  "abpstuv" 4;

page -all;


/*     cmpb23
*  Both strings are three words in length and the 1st string
crosses a page boundary. The 2nd string is greater than the
first.  */

inst cmpb -nt "both strings are the same length"
-mf1 reg
-mf2 id;

desc 1 -ns 108;
desc 2 -ns 108;

data 1 -do -4 (12)000;
data 2 -do 4  (12)777;

page -all;


/*     cmpb24
*  The 1st string is 20 words in length and crosses a page
boundary. The 2nd string is 30 words in length and is greater
than the 1st.  */

inst cmpb -nt "2nd string is longer than 1st"
-mf1 rl 720 idr ar
-mf2 id
-io 2;

desc 2 -ns 1080  -bp 4;

data 1 -do -3  (20)"ijkl";
data 2 -do 8  054  (30)"9832";

page -all;


/*     cmpb25
*  Both strings begin in the middle of a byte. The first string is
all ones and is greater than the 2nd.  */

inst cmpb -nt "both strings are the same length"
-ir cr
-mf1 idb ar reg
-mf2 idb ar;

desc 1 -bp 5 -ns 13;
desc 2 -bp 2 -ns 13;

data 1 777 777;
data 2 265 43;

page -all;


/*     cmpb26
*  Both strings begin in the middle of a byte. The 2nd string
is all ones and is greater than the first.  */

inst cmpb -nt "both strings are the same length"
-mf1 idb ar
-mf2 idb ar reg;

desc 1 -bp 2 -ns 13;
desc 2 -bp 5 -ns 13;

data 1 265 43;
data 2 777 777;

page -all;


/*     cmpb27
*  The first string is one bit in length and the 2nd string
is two bits long. The one fill bit is used and the first string
is greater.  */

inst cmpb -nt "2nd string is longer than 1st"
-ir cr
-fb
-io2;

desc 1 -ns 1;
desc 2 -ns 2;

data 1 4;
data 2 0;

page -all;


/*     cmpb28
*  The 1st string begins in the middle of  a byte and
both strings cross page boundaries. The first string is greater
than the 2nd.  */

inst cmpb -nt "2nd string is longer than 1st"
-ir cr
-mf1 ar
-mf2 reg rl 59;

desc 1 -ns 43 -bp 5;

data 1 -do -2 "tsrkv" 3;
data 2 -do -4 "mnopqrs";

page -all;


/*     cmpb29
*  Both strings consist of all  ones but the first string
is longer and the zero fill bit is used.  Therefore, the
first string is greater than the 2nd.  */

inst cmpb -nt "1st string is longer than 2nd"
-ir cr
-mf1 rl 39168 ar
-mf2 rl 33000;

data 1 (4352)777;
data 2 (3667)777;

page -all;


/*     cmpb30
*  The first string starts in the middle of a byte and neither
string crosses a page boundary. The first string is greater than the
second.  */

inst cmpb -nt "2nd string is longer than 1st"
-ir cr
-fb
-mf1 ar
-mf2 ar rl 436;

desc 1 -bp 3 -ns 274;

data 1 (7)"tack" "rgm";
data 2 (12)"mike" 023;

page -all;


/*     cmpb31
*  Neither string crosses a page boundary and the first
string is less than the 2nd.  */

inst cmpb -nt "1st string is longer than 2nd";

desc 1 -ns 50;
desc 2 -ns 49;

data 1 023 571 725 152 111 243;
data 2 023 571 777 043 121 000;

page -all;


/*     cmpb32
*   The first string consists of all zeroes and neither
string crosses a page boundary. The second string is both
longer and greater.  */

inst cmpb -nt "2nd string is longer than 1st"
-mf1 idb ar reg rl 39159
-mf2 idb ar reg rl 39168
-io 1
-fb;

data 1 (4351)000;
data 2 (4352)071;

page -all;


/*     dtb1
* Indirect descriptors are used for both operands.
* Address register modification is used for both operands.
* The decimal operand is split across a page boundary.
*/

inst dtb
-nt "9-bit unsigned decimal -> binary"
-mf2 idb ar reg rl 1
-mf1 idb ar reg rl 2
-io 1;

desc 1 -sd n;

data 2 034;
data 1 -do -1 "28";

page -all;


/*     dtb2
* No indirect descriptors are used.
* Address register modification is used for both operands.
* Both operands cross a page boundary.
*/

inst dtb
-nt "9-bit leading sign -> binary"
-mf2 ar
-mf1 ar;

desc 2 -nn 2;
desc 1 -nn 6 -sd l;

data 2 -do -1 127 531;
data 1 -do -3 "+44889";

page -all;


/*     dtb3
* Indirect descriptors are used by both operands.
* Address register modification is used for both operands.
* Both operands cross a page boundary.
*/

inst dtb
-nt "9-bit trailing sign -> binary"
-mf2 ida ar
-mf1 idb ar;

desc 2 -nn 3;
desc 1 -nn 9 -sd t;

data 2 -do -2 211 664 372;
data 1 -do -4 "36137210+";

page -all;


/*     dtb4
* No indirect descriptors are used.
* No address register modification is used.
* The decimal operand is split across a page boundary.
* Register length modification is used by both operands.
*/

inst dtb
-nt "9-bit unsigned decimal -> binary"
-mf2 rl 4
-mf1 rl 10;

desc 1 -sd n;

data 2 111 222 333 444;
data 1 -do -8 "9836279588";

page -all;


/*     dtb5
* Address register modification is used by both operands.
* An indirect descriptor is used by the decimal operand.
* Simple register modification is used by the binary operand.
* Register length modification is used by both operands.
*/

inst dtb
-nt "9-bit leading sign -> bim"nary"
-mf2 ar reg rl 5
-mf1 ar idr rl 15;

desc 1 -sd l;

data 2 -do -4 333 444 333 222 111;
data 1 -do -12 "+15088814466121";

page -all;


/*     dtb6
* Address register modification is used by both operands.
* An indirect descriptor is used by the binary operand.
* Neither operand crosses a page boundary.
*/

inst dtb
-nt "9-bit trailing sign -> binary"
-mf2 ar id
-mf1 ar;

desc 2 -nn 6;
desc 1 -nn 17 -sd t;

data 2 123 456 765 432 123 456;
data 1 "2941123482396462+";

page -all;


/*     dtb7
* Simple register modification is used by both operands.
* An indirect descriptor is used by the decimal operand.
* Both operands begin in the middle of a page.
* Neither operand spans a page boundary.
*/

inst dtb
-nt "9-bit unsigned decimal -> binary"
-mf2 reg
-mf1 reg id;

desc 2 -nn 7;
desc 1 -nn 19 -sd n;

data 2 -do 80 321 456 372 415 210 000 000;
data 1 -do 60 "3775652184861966336";

page -all;


/*     dtb8
* Both operands use only simple register modification.
* Neither operand spans a page boundary.
* Both operands begin on the 1st byte of a page.
*/

inst dtb
-nt "9-bit leading sign -> binary"
-mf2 reg
-mf1 reg;

desc 2 -nn 8;
desc 1 -nn 22 -sd l;

data 2 124 570 642 000 000 375 125 743;
data 1 "+781551372002965892067";

page -all;


/*     dtb9
* An indirect descriptor is used by the binary operand.
* Neither operand spans a page boundary.
* Both operands begin on the 1st byte of a page.
* The eis instruction itself spans a page boundary.
* No modifications are made to the decimal operand.
*/

inst dtb
-nt "4-bit unsigned decimal -> binary"
-mf2 id
-io 1;

desc 2 -nn 1;
desc 1 -tn 4 -nn 2 -sd n;

data 2 034;
data 1 050 000;

page -all;


/*     dtb10
* Address register modification is used for the binary operand.
* No modifications are made to the decimal operand.
* Both operands span a page boundary.
*/

inst dtb
-nt "4-bit leading sign -> binary"
-mf2  ar
-io 1;

desc 2 -nn 2;
desc 1 -tn 4 -nn 6 -sd l;

data 2 -do -1 127 531;
data 1 -do -4  304110211000 000000;

page -all;


/*     dtb11
* Address register modification is used for the decimal operand.
* No modifications are made to the binary operand.
* Only the decimal operand spans a page boundary.
* The eis instruction itself spans a page boundary.
*/

inst dtb
-nt "4-bit trailing sign -> binary"
-mf1 ar
-io2;

desc 2 -nn 3;
desc 1 -tn 4 -nn 9 -sd t;

data 2 211 664 372;
data 1 -do -8  066023162020 300000000000000;

page -all;


/*     dtb12
* Indirect descriptors are used for both operands.
* No address register modification is used.
* Neither operand spans a page boundary.
* Both operands begin on the 1st byte of a page.
* The eis instruction itself spans a page boundary.
*/

inst dtb
-nt "4-bit unsigned decimal -> binary"
-mf2 id
-mf1 id
-io 2;

desc 2 -nn 4;
desc 1 -tn 4 -nn 10 -sd n;

data 2 111 222 333 444;
data 1 230066047225 210000000000;

page -all;


/*     dtb13
* No modifications are made to the binary operand.
* Address register modification is used for the decimal operand.
* An indirect descriptor is used by the decimal operand.
* Both operands span a page boundary.
*/

inst dtb
-nt "4-bit leading sign -> binary"
-mf1 ar id
-io 1;

desc 2 -nn 5;
desc 1 -tn 4 -nn 15 -sd l;

data 2 -do -4  333 444 333 222 111;
data 1 -do -8  301120210201 104146022020;

page -all;


/*     dtb14
* Indirect descriptors are used by both operands.
* Both operands span a page boundary.
*/

inst dtb
-nt "4-bit trailing sign -> binary"
-mf2 idr
-mf1 ida;

desc 2 -nn 6;
desc 1 -tn 4 -nn 17 -sd t;

data 2 -do -4  123 456 765 432 123 456;
data 1 -do -16  051101022064 202071144142 300;

page -all;


/*     dtb15
* Indirect descriptors are used for both operands.
* Address register modification is used for both operands.
* Both operands span a page boundary.
* The eis instruction itself spans a page boundary.
*/

inst dtb
-nt "4-bit unsigned decimal -> binary"
-mf2 id ar
-mf1 id ar
-io1;

desc 2 -nn 7;
desc 1 -tn 4 -nn 19 -sd n;

data 2 -do -6  321 456 372 415 210 000 000;
data 1 -do -1  067165145041 204206031146 063140;

page -all;


/*     dtb16
* Indirect descriptors are used by both operands.
* Address register modification is used by both operands.
* Neither operand spans a page boundary.
* Both operands begin in the middle of a page.
*/

inst dtb
-nt "4-bit leading sign -> binary"
-mf2 idb ar
-mf1 idb ar;

desc 2 -nn 8;
desc 1 -tn 4 -nn 22 -sd l;

data 2 -do 14  124 570 642 000 000 375 125 743;
data 1 -do 100   307201125023162000051145 211040147000;

page -all;


/*     btd1
* Indirect descriptors are used for both operands.
* Address register modification is used for both operands.
* The decimal operand is split across a page boundary.
*/

inst btd
-nt "binary -> 9-bit unsigned decimal"
-mf1 idb ar reg rl 1
-mf2 idb ar reg rl 2
-io 1;

desc 2 -sd n;

data 1 034;
data 2 -do -1 "28";

page -all;


/*     btd2
* No indirect descriptors are used.
* Address register modification is used for both operands.
* Both operands cross a page boundary.
*/

inst btd
-nt "binary -> 9-bit leading sign"
-mf1 ar
-mf2 ar;

desc 1 -nn 2;
desc 2 -nn 6 -sd l;

data 1 -do -1 127 531;
data 2 -do -3 "+44889";

page -all;


/*     btd3
* Indirect descriptors are used by both operands.
* Address register modification is used for both operands.
* Both operands cross a page boundary.
*/

inst btd
-nt "binary -> 9-bit trailing sign"
-mf1 ida ar
-mf2 idb ar;

desc 1 -nn 3;
desc 2 -nn 9 -sd t;

data 1 -do -2 211 664 372;
data 2 -do -4 "36137210+";

page -all;


/*     btd4
* No indirect descriptors are used.
* No address register modification is used.
* The decimal operand is split across a page boundary.
* Register length modification is used by both operands.
*/

inst btd
-nt "binary -> 9-bit unsigned decimal"
-mf1 rl 4
-mf2 rl 10;

desc 2 -sd n;

data 1 111 222 333 444;
data 2 -do -8 "9836279588";

page -all;


/*     btd5
* Address register modification is used by both operands.
* An indirect descriptor is used by the decimal operand.
* Simple register modification is used by the binary operand.
* Register length modification is used by both operands.
*/

inst btd
-nt "binary -> 9-bit leading sign"
-mf1 ar reg rl 5
-mf2 ar idr rl 15;

desc 2 -sd l;

data 1 -do -4 333 444 333 222 111;
data 2 -do -12 "+15088814466121";

page -all;


/*     btd6
* Address register modification is used by both operands.
* An indirect descriptor is used by the binary operand.
* Neither operand crosses a page boundary.
*/

inst btd
-nt "binary -> 9-bit trailing sign"
-mf1 ar id
-mf2 ar;

desc 1 -nn 6;
desc 2 -nn 17 -sd t;

data 1 123 456 765 432 123 456;
data 2 "2941123482396462+";

page -all;


/*     btd7
* Simple register modification is used by both operands.
* An indirect descriptor is used by the decimal operand.
* Both operands begin in the middle of a page.
* Neither operand spans a page boundary.
*/

inst btd
-nt "binary -> 9-bit unsigned decimal"
-mf1 reg
-mf2 reg id;

desc 1 -nn 7;
desc 2 -nn 19 -sd n;

data 1 -do 80 321 456 372 415 210 000 000;
data 2 -do 60 "3775652184861966336";

page -all;


/*     btd8
* Both operands use only simple register modification.
* Neither operand spans a page boundary.
* Both operands begin on the 1st byte of a page.
*/

inst btd
-nt "binary -> 9-bit leading sign"
-mf1 reg
-mf2 reg;

desc 1 -nn 8;
desc 2 -nn 22 -sd l;

data 1 124 570 642 000 000 375 125 743;
data 2 "+781551372002965892067";

page -all;


/*     btd9
* An indirect descriptor is used by the binary operand.
* Neither operand spans a page boundary.
* Both operands begin on the 1st byte of a page.
* The eis instruction itself spans a page boundary.
* No modifications are made to the decimal operand.
*/

inst btd
-nt "binary -> 4-bit unsigned decimal"
-mf1 id
-io 1;

desc 1 -nn 1;
desc 2 -tn 4 -nn 2 -sd n;

data 1 034;
data 2 050 000;

page -all;


/*     btd10
* Address register modification is used for the binary operand.
* No modifications are made to the decimal operand.
* Both operands span a page boundary.
*/

inst btd
-nt "binary to 4-bit leading sign"
-mf1  ar
-io 1;

desc 1 -nn 2;
desc 2 -tn 4 -nn 6 -sd l;

data 1 -do -1 127 531;
data 2 -do -4  304110211000 000000;

page -all;


/*     btd11
* Address register modification is used for the decimal operand.
* No modifications are made to the binary operand.
* Only the decimal operand spans a page boundary.
* The eis instruction itself spans a page boundary.
*/

inst btd
-nt "binary -> 4-bit trailing sign"
-mf2 ar
-io2;

desc 1 -nn 3;
desc 2 -tn 4 -nn 9 -sd t;

data 1 211 664 372;
data 2 -do -8  066023162020 300000000000000;

page -all;


/*     btd12
* Indirect descriptors are used for both operands.
* No address register modification is used.
* Neither operand spans a page boundary.
* Both operands begin on the 1st byte of a page.
* The eis instruction itself spans a page boundary.
*/

inst btd
-nt "binary -> 4-bit unsigned decimal"
-mf1 id
-mf2 id
-io 2;

desc 1 -nn 4;
desc 2 -tn 4 -nn 10 -sd n;

data 1 111 222 333 444;
data 2 230066047225 210000000000;

page -all;


/*     btd13
* No modifications are made to the binary operand.
* Address register modification is used for the decimal operand.
* An indirect descriptor is used by the decimal operand.
* Both operands span a page boundary.
*/

inst btd
-nt "binary -> 4-bit leading sign"
-mf2 ar id
-io 1;

desc 1 -nn 5;
desc 2 -tn 4 -nn 15 -sd l;

data 1 -do -4  333 444 333 222 111;
data 2 -do -8  301120210201 104146022020;

page -all;


/*     btd14
* Indirect descriptors are used by both operands.
* Both operands span a page boundary.
*/

inst btd
-nt "binary -> 4-bit trailing sign"
-mf1 idr
-mf2 ida;

desc 1 -nn 6;
desc 2 -tn 4 -nn 17 -sd t;

data 1 -do -4  123 456 765 432 123 456;
data 2 -do -16  051101022064 202071144142 300;

page -all;


/*     btd15
* Indirect descriptors are used for both operands.
* Address register modification is used for both operands.
* Both operands span a page boundary.
* The eis instruction itself spans a page boundary.
*/

inst btd
-nt "binary -> 4-bit unsigned decimal"
-mf1 id ar
-mf2 id ar
-io1;

desc 1 -nn 7;
desc 2 -tn 4 -nn 19 -sd n;

data 1 -do -6  321 456 372 415 210 000 000;
data 2 -do -1  067165145041 204206031146 063140;

page -all;


/*     btd16
* Indirect descriptors are used by both operands.
* Address register modification is used by both operands.
* Neither operand spans a page boundary.
* Both operands begin in the middle of a page.
*/

inst btd
-nt "binary -> 4-bit leading sign"
-mf1 idb ar
-mf2 idb ar;

desc 1 -nn 8;
desc 2 -tn 4 -nn 22 -sd l;

data 1 -do 14  124 570 642 000 000 375 125 743;
data 2 -do 100   307201125023162000051145 211040147000;

page -all;


*/
                                          -----------------------------------------------------------


Historical Background

This edition of the Multics software materials and documentation is provided and donated
to Massachusetts Institute of Technology by Group Bull including Bull HN Information Systems Inc. 
as a contribution to computer science knowledge.  
This donation is made also to give evidence of the common contributions of Massachusetts Institute of Technology,
Bell Laboratories, General Electric, Honeywell Information Systems Inc., Honeywell Bull Inc., Groupe Bull
and Bull HN Information Systems Inc. to the development of this operating system. 
Multics development was initiated by Massachusetts Institute of Technology Project MAC (1963-1970),
renamed the MIT Laboratory for Computer Science and Artificial Intelligence in the mid 1970s, under the leadership
of Professor Fernando Jose Corbato. Users consider that Multics provided the best software architecture for 
managing computer hardware properly and for executing programs. Many subsequent operating systems 
incorporated Multics principles.
Multics was distributed in 1975 to 2000 by Group Bull in Europe , and in the U.S. by Bull HN Information Systems Inc., 
as successor in interest by change in name only to Honeywell Bull Inc. and Honeywell Information Systems Inc. .

                                          -----------------------------------------------------------

Permission to use, copy, modify, and distribute these programs and their documentation for any purpose and without
fee is hereby granted,provided that the below copyright notice and historical background appear in all copies
and that both the copyright notice and historical background and this permission notice appear in supporting
documentation, and that the names of MIT, HIS, Bull or Bull HN not be used in advertising or publicity pertaining
to distribution of the programs without specific prior written permission.
    Copyright 1972 by Massachusetts Institute of Technology and Honeywell Information Systems Inc.
    Copyright 2006 by Bull HN Information Systems Inc.
    Copyright 2006 by Bull SAS
    All Rights Reserved

*/