DMDX Help.


Multi-Scrambling Scramble Keyword

<MultiScrambleS N1,N2>
<mss N1,N2>
<MultiScrambleScramble N1,N2>

    Scramble parameter S to be used on iteration N1 in a multi-scramble. On iteration N1 of the multi-scrambling this keyword will be replaced with SN2.

    In addition to the normal scrambling (see Scrambling) DMDX provides the ability to pass an item file through the scrambling routines multiple times to perform scrambles that would otherwise not be possible (for example counterbalancing and categorization tasks). Basically you provide a set of scramble parameters and delimiters for each iteration in the scrambling, see the Multi-Scrambling Group Keyword, the Multi-Scrambling Variable Group Keyword, the Multi-Scrambling Scramble Seed Keyword, the Multi-Scrambling Dollar Keyword and the Multi-Scrambling Backslash Keyword.
   
        When multi-scrambling is used there are additional temporary files left behind so you can attempt to figure out from the aftermath just what happened, multiscrambleN.itm, one for each iteration. These files are the input to scramble at each iteration, scramble overwrites it's output each time it is used so scrambled.itm only has the final result.

    You cannot use macros to expand multi-scrambling keywords (macro expansion is done at the item read stage of DMDX well after the scrambling) and you need to be aware that scramble can loose chunks of the item file that don't end in a semi-colon (usually between dollars that have moved after the first iteration). Scramble has always had this feature, it doesn't come into play too often with regular scrambling but in designing the examples below I hit it at least once so it is something to be aware of when using multi-scrambling at any rate.

    Sounds straight forward doesn't it? Well if you thought getting a regular scramble to work was tough this is not just squared but cubed toughness -- on steroids (although I did have one recent request that was surprisingly straight forward that's listed at the end of this page). The first trick is that for each piece of the file that you want to stay put you have to provide dollars for each iteration of the scramble, but, and this is the kicker that took me a while to figure out, they have to be nested so that the earlier scrambles don't screw up the later scrambles. So in the following the order of those <ms#> keywords around the instructions and the last line are not arbitrary and getting them wrong can lead to some very unintuitive results. The second trick which I leave as an exercise for the reader is figuring out just how the scramble parameters move with each scramble and how that affects later scrambles.
    The first example involves doing a categorization task where the first item of a block tells the subject which category they're working with for the next 3 items, essentially a regular scramble with a block size of 4 but with the caveat that the first item in each block not move within the block. The solution is to do two scrambles, the first using a block size of 1 and group size 4 to move the blocks around and the second scramble just scrambling the three items of each block (emitting after each block with a back slash). In the following item file I've added some blank lines for ease of viewing (scramble in all likelihood would move them):
   

<ep> <msg 1,4> <mss 1,1> <mss 2,3>
F10 <vm 1024 768 768 16 0 > </ep>
<ms# 1> <ms# 2>
0 "Instructions";
<ms# 2> <ms# 1>

<ms\ 2>
<ms# 2>
0 "The first category";
<ms# 2>
+101 * "target" /;
+102 * "target" /;
+103 * "target" /;

<ms\ 2>
<ms# 2>
0 "The second category";
<ms# 2>
+201 * "target" /;
+202 * "target" /;
+203 * "target" /;

<ms\ 2>
<ms# 2>
0 "The third category";
<ms# 2>
+301 * "target" /;
+302 * "target" /;
+303 * "target" /;

<ms# 1> <ms# 2>
0 "The end" l;
<ms# 2> <ms# 1>


    As an example of just how tricky this stuff is note that the instruction items include the backslash and dollar keywords and they will move with that item:
   

<ms\ 2>
<ms# 2>
0 "The first category";
   
    As will the second dollar keyword move with the first RT item, however as the first scramble moves the whole block as one unit (the <msg 1,4>) this is not an problem:
   

<ms# 2>
+101 * "target" /;

   
    The first iteration produces the following output and you can see the dollars symbols around the extended parameter line are nesting the next iteration's latent dollars symbols (this is multiscramble1.itm):
   

<ep> G4 S1 <mss 2,3>
F10 <vm 1024 768 768 16 0 > </ep>
$ <ms# 2>
0 "Instructions";
<ms# 2> $

<ms\ 2>
<ms# 2>
0 "{\fs24 The first category";
<ms# 2>
+101 * "{\fs24 target" /;
+102 * "{\fs24 target" /;
+103 * "{\fs24 target" /;

<ms\ 2>
<ms# 2>
0 "{\fs24 The second category";
<ms# 2>
+201 * "{\fs24 target" /;
+202 * "{\fs24 target" /;
+203 * "{\fs24 target" /;

<ms\ 2>
<ms# 2>
0 "{\fs24 The third category";
<ms# 2>
+301 * "{\fs24 target" /;
+302 * "{\fs24 target" /;
+303 * "{\fs24 target" /;

$ <ms# 2>
0 "{\fs24 The end" l;
<ms# 2> $



    For the second iteration the following is produced, a more or less straight forward scramble (this is multiscramble2.itm):
   

<ep> S3
F10 <vm 1024 768 768 16 0 > </ep>
$
0 "Instructions";
$

\ $ 0 "{\fs24 The first category";
$ +101 * "{\fs24 target" /;
+102 * "{\fs24 target" /;
+103 * "{\fs24 target" /;

\ $ 0 "{\fs24 The third category";
$ +301 * "{\fs24 target" /;
+302 * "{\fs24 target" /;
+303 * "{\fs24 target" /;

\ $ 0 "{\fs24 The second category";
$ +201 * "{\fs24 target" /;
+202 * "{\fs24 target" /;
+203 * "{\fs24 target" /;

$
0 "{\fs24 The end" l;
$


    Which finally produces scrambled.itm (minus some of the blank lines scramble has produced):

<ep> S3
F10 <vm 1024 768 768 16 0 > </ep>
0 "Instructions";

0 "{\fs24 The first category";
+102 * "{\fs24 target" /;
+101 * "{\fs24 target" /;
+103 * "{\fs24 target" /;

0 "{\fs24 The third category";
+302 * "{\fs24 target" /;
+301 * "{\fs24 target" /;
+303 * "{\fs24 target" /;

0 "{\fs24 The second category";
+203 * "{\fs24 target" /;
+201 * "{\fs24 target" /;
+202 * "{\fs24 target" /;

0 "{\fs24 The end" l;

    For our second exercise in brain tumor cultivation we will consider the situation where all the even numbered items in an item file are to be scrambled with each other and all the odd numbered are to be similarly scrambled so that only even numbered items are in even slots and vice versa. Basically what we need is two scrambles, one with dollars around the even numbers and one with dollars around the odd. Sounds easy enough once again, the difficulty here is that you can't get a dollar keyword to hang around after the end of an item, it moves with the next item as it gets scrambled. I'm not even sure if I can explain why the solution below works (it's a programmer intuition kind of thing), all I can say is that I use an extra dummy iteration 2 dollars at the start to cancel an iteration 2 dollars that has to be in every item and another at the end to match the last iteration 2 dollars that moves with the items. The item file itself:

<mss 1,1> <mss 2,1> F10 <vm 1024 768 768 16 0 >
<ms# 1> <ms# 2>
0 "instructions";
<ms# 2> <ms# 2> <ms# 1>

<ms# 1> <ms# 2> +101 * "target" /; <ms# 1>
<ms# 2> +102 * "target" /;
<ms# 1> <ms# 2> +103 * "target" /; <ms# 1>
<ms# 2> +104 * "target" /;
<ms# 1> <ms# 2> +201 * "target" /; <ms# 1>
<ms# 2> +202 * "target" /;
<ms# 1> <ms# 2> +203 * "target" /; <ms# 1>
<ms# 2> +204 * "target" /;
<ms# 1> <ms# 2> +301 * "target" /; <ms# 1>
<ms# 2> +302 * "target" /;
<ms# 1> <ms# 2> +303 * "target" /; <ms# 1>
<ms# 2> +304 * "target" /;

<ms# 1> <ms# 2> <ms# 2>
0 "The end" l;
<ms# 2> <ms# 1>

    First scramble locks the odd items down and moves the even ones, the extra dollars are bold (this is multiscramble1.itm):
   
S1 <mss 2,1> F10 <vm 1024 768 768 16 0 >
$ <ms# 2>
0 "{\fs24 instructions";
<ms# 2>
<ms# 2> $

$ <ms# 2> +101 * "{\fs24 target" /; $
<ms# 2> +102 * "{\fs24 target" /;
$ <ms# 2> +103 * "{\fs24 target" /; $
<ms# 2> +104 * "{\fs24 target" /;
$ <ms# 2> +201 * "{\fs24 target" /; $
<ms# 2> +202 * "{\fs24 target" /;
$ <ms# 2> +203 * "{\fs24 target" /; $
<ms# 2> +204 * "{\fs24 target" /;
$ <ms# 2> +301 * "{\fs24 target" /; $
<ms# 2> +302 * "{\fs24 target" /;
$ <ms# 2> +303 * "{\fs24 target" /; $
<ms# 2> +304 * "{\fs24 target" /;

$
<ms# 2> <ms# 2>
0 "{\fs24 The end" l;
<ms# 2> $

    Here you can see the canceling dollars in bold leaving the odd numbered items free to be scrambled, if there was any text between those dollars and no semicolon it would be snipped/lost by scramble (this is multiscramble2.itm):

S1 F10 <vm 1024 768 768 16 0 >
$
0 "{\fs24 instructions";
$
$
$ +101 * "{\fs24 target" /;
$ +302 * "{\fs24 target" /;
$ +103 * "{\fs24 target" /;
$ +204 * "{\fs24 target" /;
$ +201 * "{\fs24 target" /;
$ +202 * "{\fs24 target" /;
$ +203 * "{\fs24 target" /;
$ +304 * "{\fs24 target" /;
$ +301 * "{\fs24 target" /;
$ +102 * "{\fs24 target" /;
$ +303 * "{\fs24 target" /;
$ +104 * "{\fs24 target" /;
$ $
0 "{\fs24 The end" l;
$

    The finished result (scrambled.itm):

S1 F10 <vm 1024 768 768 16 0 >

0 "{\fs24 instructions";

+203 * "{\fs24 target" /;
+302 * "{\fs24 target" /;
+101 * "{\fs24 target" /;
+204 * "{\fs24 target" /;
+303 * "{\fs24 target" /;
+202 * "{\fs24 target" /;
+103 * "{\fs24 target" /;
+304 * "{\fs24 target" /;
+201 * "{\fs24 target" /;
+102 * "{\fs24 target" /;
+301 * "{\fs24 target" /;
+104 * "{\fs24 target" /;

0 "{\fs24 The end" l;
 

    And then someone wanted three items scrambled... At first I didn't think it was possible but eventually I figured out all the weird multiscrambling laws again and after a three or four tries nailed it.  Basically what we need is three scrambles, one with dollars around the first and third items, one with dollars around the last two and one with dollars around the first two -- I tried other combinations and maybe there's a solution but I didn't twig to it till I tried that combination. Again I use an extra dummy iteration 2 dollars at the start to cancel an iteration 2 dollars that has to be in first of every group of three items and another at the end to match the last iteration 2 dollars that moves with the items. This is because in a multiscramble like this individual dollars have to be in ascending order otherwise they get orphaned by scramble when there's no semicolon after them.  The item file itself:
 

<vm desktop> f30 <cr> <mss 1,1> <mss 2,1> <mss 3,1> F10 

<ms# 1> <ms# 2> <ms# 3>
0 "instructions";
<ms# 3> <ms# 2> <ms# 2> <ms# 1>

<ms# 1> <ms# 2> <ms# 3>       +101 * "target" /;      <ms# 1>
<ms# 2>                       +102 * "target" /;
<ms# 1> <ms# 3>               +103 * "target" /;      <ms# 1>

<ms# 1> <ms# 2> <ms# 3>       +201 * "target" /;      <ms# 1>
<ms# 2>                       +202 * "target" /;
<ms# 1> <ms# 3>               +203 * "target" /;      <ms# 1>

<ms# 1> <ms# 2> <ms# 3>       +301 * "target" /;      <ms# 1>
<ms# 2>                       +302 * "target" /;
<ms# 1> <ms# 3>               +303 * "target" /;      <ms# 1>

<ms# 1> <ms# 2> <ms# 3>       +401 * "target" /;      <ms# 1>
<ms# 2>                       +402 * "target" /;
<ms# 1> <ms# 3>               +403 * "target" /;      <ms# 1>  

<ms# 1> <ms# 2> <ms# 2> <ms# 3>
0 "The end" l;
<ms# 3> <ms# 2> <ms# 1>


    Ideally what you'd want is something more like the following, however that last <ms# 2> in bold will be snipped in the first multiscramble between the underlined <ms# 1> before it and the <ms# 1> in item 201 (strike through text isn't there, it's only for demonstration).

...
0 "instructions";
<ms# 3> <ms# 2>
<ms# 2> <ms# 1>

<ms# 1>
<ms# 2> <ms# 3>       +101 * "target" /;      <ms# 1>
<ms# 2>                       +102 * "target" /;
<ms# 1> <ms# 3>               +103 * "target" /;      <ms# 1>
<ms# 2>

<ms# 1> <ms# 2> <ms# 3>       +201 * "target" /;      <ms# 1>
...

    So you have to put the two <ms# 1> keywords before the <ms# 2> and then you have to have an extra <ms# 2> at the start to cancel the extra one you've just added, straight forward no?

     This is multiscramble1.itm:
   
<vm desktop> f30 <cr> S1 <mss 2,1> <mss 3,1> F10

$ <ms# 2> <ms# 3>
0 "{instructions";
<ms# 3> <ms# 2> <ms# 2> $

$ <ms# 2> <ms# 3> +101 * "{target" /; $
<ms# 2> +102 * "{target" /;
$ <ms# 3> +103 * "{target" /; $

$ <ms# 2> <ms# 3> +201 * "{target" /; $
<ms# 2> +202 * "{target" /;
$ <ms# 3> +203 * "{target" /; $

$ <ms# 2> <ms# 3> +301 * "{target" /; $
<ms# 2> +302 * "{target" /;
$ <ms# 3> +303 * "{target" /; $

$ <ms# 2> <ms# 3> +401 * "{target" /; $
<ms# 2> +402 * "{target" /;
$ <ms# 3> +403 * "{target" /; $

$ <ms# 2> <ms# 2> <ms# 3>
0 "{The end" l;
<ms# 3> <ms# 2> $

     This is multiscramble2.itm:

<vm desktop> f30 <cr> S1 <mss 3,1> F10

$ <ms# 3>
0 "{instructions";
<ms# 3> $ $

$ <ms# 3> +101 * "{target" /;
$ +402 * "{target" /;
<ms# 3> +103 * "{target" /;

$ <ms# 3> +201 * "{target" /;
$ +202 * "{target" /;
<ms# 3> +203 * "{target" /;

$ <ms# 3> +301 * "{target" /;
$ +302 * "{target" /;
<ms# 3> +303 * "{target" /;

$ <ms# 3> +401 * "{target" /;
$ +102 * "{target" /;
<ms# 3> +403 * "{target" /;

$ $ <ms# 3>
0 "{The end" l;
<ms# 3> $
 

     This is multiscramble3.itm:

<vm desktop> f30 <cr> S1 F10

$
0 "{instructions";
$

$ +401 * "{target" /;
+402 * "{target" /;
$ +103 * "{target" /;

$ +201 * "{target" /;
+202 * "{target" /;
$ +203 * "{target" /;

$ +101 * "{target" /;
+302 * "{target" /;
$ +303 * "{target" /;

$ +301 * "{target" /;
+102 * "{target" /;
$ +403 * "{target" /;

$
0 "{The end" l;
$


    The finished result (scrambled.itm):

<vm desktop> f30 <cr> S1 F10

0 "{instructions";

+401 * "{target" /;
+402 * "{target" /;
+403 * "{target" /;

+201 * "{target" /;
+202 * "{target" /;
+303 * "{target" /;

+101 * "{target" /;
+302 * "{target" /;
+103 * "{target" /;

+301 * "{target" /;
+102 * "{target" /;
+203 * "{target" /;

0 "{The end" l;



    And then just to test whether I had in fact figured out the key rule (that the <ms#> keywords had to be in ascending order at the start of the items) I went ahead an tried a four way scramble and it hardly took any time to get right. Here with each multiscramble iteration it scrambles the item number of that iteration locking the others in place. A good bit of rearranging of <ms#> keywords was needed to get them in ascending order versus where one would place them at the end of items but it works, you do need an couple of extra <ms#> keywords at the start an end with the scrambling done this way but hey, it's science now and not voodoo.  As a technical note more to remind myself how this all works than anything else the extra cancelling <ms#> keywords being for interior scrambles, iterations 2 and 3, iterations 1 and 4 being on the ends themselves don't need the extra <ms#> keywords so if you wanted a 5 way scramble you'd be looking to renumber the iteration 4 keywords and duplicate the iteration 3 ones renumbering them to 4.

<vm desktop> f30 <cr> <mss 1,1> <mss 2,1> <mss 3,1> <mss 4,1> F10


<ms# 1> <ms# 2> <ms# 3> <ms# 4>
0 "instructions";
<ms# 4> <ms# 3> <ms# 3> <ms# 2> <ms# 2> <ms# 1>

<ms# 2> <ms# 2> <ms# 3> <ms# 3> <ms# 4> +101 * "target" /;
<ms# 1> <ms# 2> +102 * "target" /;
<ms# 2> <ms# 3> +103 * "target" /;
<ms# 3> <ms# 4> +104 * "target" /; <ms# 1>

<ms# 2> <ms# 2> <ms# 3> <ms# 3> <ms# 4> +201 * "target" /;
<ms# 1> <ms# 2> +202 * "target" /;
<ms# 2> <ms# 3> +203 * "target" /;
<ms# 3> <ms# 4> +204 * "target" /; <ms# 1>

<ms# 2> <ms# 2> <ms# 3> <ms# 3> <ms# 4> +301 * "target" /;
<ms# 1> <ms# 2> +302 * "target" /;
<ms# 2> <ms# 3> +303 * "target" /;
<ms# 3> <ms# 4> +304 * "target" /; <ms# 1>

<ms# 2> <ms# 2> <ms# 3> <ms# 3> <ms# 4> +401 * "target" /;
<ms# 1> <ms# 2> +402 * "target" /;
<ms# 2> <ms# 3> +403 * "target" /;
<ms# 3> <ms# 4> +404 * "target" /; <ms# 1>

<ms# 1> <ms# 2> <ms# 2> <ms# 3> <ms# 3> <ms# 4>
0 "The end" l;
<ms# 4> <ms# 3> <ms# 2> <ms# 1>



    And then someone wanted the four way multi-scramble but in two counterbalanced blocks.  So we need a fifth iteration of scrambling that does the large scale block move and all the previous four iterations need a scramble emit between the two blocks and that's where the fun begins.  First of you need an actual item in there otherwise scramble will snip the remaining multi-scramble commands (easy enough just use an empty comment item !; ) but the ordering of the dollars and the scramble emit commands took a while to latch on to.  In fact the wrong order blows scrambles brains out in singularly impressive ways with blocks of items winding up all over the place.  Basically you want to imitate the multi-scramble commands around the instructions with scramble emits in the right places.  Fortunately for you I figured it out where that is....

<ep>
<vm desktop> f30 <cr>
<mss 1,1> <mss 2,1> <mss 3,1> <mss 4,1> <mss 5,1> <msvg 5,1000>
F10
<eop>

<ms# 1> <ms# 2> <ms# 3> <ms# 4> <ms# 5>
0 "instructions";
<ms# 5> <ms# 4> <ms# 3> <ms# 3> <ms# 2> <ms# 2> <ms# 1>

<ms# 2> <ms# 2> <ms# 3> <ms# 3> <ms# 4> +101 * "target" /;
<ms# 1> <ms# 2> +102 * "target" /;
<ms# 2> <ms# 3> +103 * "target" /;
<ms# 3> <ms# 4> +104 * "target" /; <ms# 1>

<ms# 2> <ms# 2> <ms# 3> <ms# 3> <ms# 4> +201 * "target" /;
<ms# 1> <ms# 2> +202 * "target" /;
<ms# 2> <ms# 3> +203 * "target" /;
<ms# 3> <ms# 4> +204 * "target" /; <ms# 1>

<ms# 2> <ms# 2> <ms# 3> <ms# 3> <ms# 4> +301 * "target" /;
<ms# 1> <ms# 2> +302 * "target" /;
<ms# 2> <ms# 3> +303 * "target" /;
<ms# 3> <ms# 4> +304 * "target" /; <ms# 1>

<ms# 2> <ms# 2> <ms# 3> <ms# 3> <ms# 4> +401 * "target" /;
<ms# 1> <ms# 2> +402 * "target" /;
<ms# 2> <ms# 3> +403 * "target" /;
<ms# 3> <ms# 4> +404 * "target" /; <ms# 1>


<ms\ 1> <ms# 1> <ms# 2>
<ms\ 2> <ms# 2> <ms# 3>
<ms\ 3> <ms# 3>
<ms\ 4> <ms# 4>
!; <ms# 4> <ms# 3> <ms# 3> <ms# 2> <ms# 2> <ms# 1>


<ms# 2> <ms# 2> <ms# 3> <ms# 3> <ms# 4> +1101 * "target" /;
<ms# 1> <ms# 2> +1102 * "target" /;
<ms# 2> <ms# 3> +1103 * "target" /;
<ms# 3> <ms# 4> +1104 * "target" /; <ms# 1>

<ms# 2> <ms# 2> <ms# 3> <ms# 3> <ms# 4> +1201 * "target" /;
<ms# 1> <ms# 2> +1202 * "target" /;
<ms# 2> <ms# 3> +1203 * "target" /;
<ms# 3> <ms# 4> +1204 * "target" /; <ms# 1>

<ms# 2> <ms# 2> <ms# 3> <ms# 3> <ms# 4> +1301 * "target" /;
<ms# 1> <ms# 2> +1302 * "target" /;
<ms# 2> <ms# 3> +1303 * "target" /;
<ms# 3> <ms# 4> +1304 * "target" /; <ms# 1>

<ms# 2> <ms# 2> <ms# 3> <ms# 3> <ms# 4> +1401 * "target" /;
<ms# 1> <ms# 2> +1402 * "target" /;
<ms# 2> <ms# 3> +1403 * "target" /;
<ms# 3> <ms# 4> +1404 * "target" /; <ms# 1>

<ms# 1> <ms# 2> <ms# 2> <ms# 3> <ms# 3> <ms# 4> <ms# 5>
0 "The end" l;
<ms# 5> <ms# 4> <ms# 3> <ms# 2> <ms# 1>
 

    Suffice it to say that if anyone besides me ever designs a multi-scrambling item file I'll be impressed. But it's still a useful tool for me to design solutions to people's odd scrambling needs.


A more straight forward solution

    And just when I'd concluded all multiscrambling was tumor inducing along comes something that turns out to be straight forward.  The request:

The basic setup of the experiment is as follows: first there is a test block; then a training block; then a test block.  The test blocks together will comprise 36 items, of two distinct classes; I would like a way to randomly select 9 items from each class out of the 36 to go in Test Block 1, and leave the other 9+9 items in Test Block 2.  However, I want the training block to be in a fixed position between these two test blocks.  Is there a way to accomplish this?

    Basic item file will have this structure:

f60 <vm desktop>

0 "Instructions";

+1 "Nine class 1 test items";

+2 "Nine class 2 test items";

+3 "Training items";

+1 "Nine more class 1 test items";

+2 "Nine more class 2 test items";

0 "End";



    So the first time through we're only going to scramble the class 1 test items, everything else gets locked with dollars (or in a multiscramble, <ms#> keywords):

f60 <vm desktop> <mss 1,1>

<ms# 1>
0 "Instructions"; <ms# 1>

+1 "Nine class 1 test items";

<ms# 1>
+2 "Nine class 2 test items";

+3 "Training items"; <ms# 1>

+1 "Nine more class 1 test items";

<ms# 1>
+2 "Nine more class 2 test items";

0 "End"; <ms# 1>



    Then we're only going to scramble the class 2 test items:

f60 <vm desktop> <mss 1,1> <mss 2,1>

<ms# 1> <ms# 2>
0 "Instructions"; <ms# 1>

+1 "Nine class 1 test items";

<ms# 1> <ms# 2>
+2 "Nine class 2 test items";

<ms# 2>
+3 "Training items"; <ms# 1>

+1 "Nine more class 1 test items";

<ms# 1> <ms# 2>
+2 "Nine more class 2 test items";

<ms# 2>
0 "End"; <ms# 2> <ms# 1>



    Lastly we'll scramble the three sets of items one after the other. This is the actual item file structure you'd use (the others are just for show and tell):

f60 <vm desktop> <mss 1,1> <mss 2,1> <mss 3,1>

<ms# 1> <ms# 2> <ms# 3>
0 "Instructions"; <ms# 3> <ms# 1>

+1 "Nine class 1 test items";

<ms# 1> <ms# 2>
+2 "Nine class 2 test items";

<ms# 2> <ms\ 3>
+3 "Training items"; <ms\ 3> <ms# 1>

+1 "Nine more class 1 test items";

<ms# 1> <ms# 2>
+2 "Nine more class 2 test items";

<ms# 2> <ms# 3>
0 "End"; <ms# 3> <ms# 2> <ms# 1>



    Pretty easy really, no sets of cancelling dollars needed or any real trauma at all. Didn't think that ever happened with multiscrambling.

DMDX Index.