diff --git a/seaofnodes/src/main/java/com/compilerprogramming/ezlang/compiler/IterPeeps.java b/seaofnodes/src/main/java/com/compilerprogramming/ezlang/compiler/IterPeeps.java
index f58ae9f..c18aa90 100644
--- a/seaofnodes/src/main/java/com/compilerprogramming/ezlang/compiler/IterPeeps.java
+++ b/seaofnodes/src/main/java/com/compilerprogramming/ezlang/compiler/IterPeeps.java
@@ -49,6 +49,7 @@ public class IterPeeps {
 
     public IterPeeps( long seed ) { _work = new WorkList<>(seed); }
 
+    @SuppressWarnings("unchecked")
     public <N extends Node> N add( N n ) { return (N)_work.push(n); }
 
     public void addAll( Ary<Node> ary ) { _work.addAll(ary); }
@@ -126,6 +127,7 @@ private boolean progressOnList(CodeGen code) {
      * Classic WorkList, with a fast add/remove, dup removal, random pull.
      * The Node's nid is used to check membership in the worklist.
      */
+    @SuppressWarnings("unchecked")
     public static class WorkList<E extends Node> {
 
         private Node[] _es;
diff --git a/seaofnodes/src/main/java/com/compilerprogramming/ezlang/compiler/SB.java b/seaofnodes/src/main/java/com/compilerprogramming/ezlang/compiler/SB.java
index fe7f97d..0ed652d 100644
--- a/seaofnodes/src/main/java/com/compilerprogramming/ezlang/compiler/SB.java
+++ b/seaofnodes/src/main/java/com/compilerprogramming/ezlang/compiler/SB.java
@@ -29,21 +29,28 @@ else if( Double.isInfinite(s) ) {
   public SB p( int    s ) { _sb.append(s); return this; }
   public SB p( long   s ) { _sb.append(s); return this; }
   public SB p( boolean s) { _sb.append(s); return this; }
-  // 4 hex digits
-  public SB hex4(int s) {
-    assert (s>>4*4)==0; // Fits in 16 bits
-    for( int i=0; i<4; i++ ) {
-      int digit = (s>>((3-i)*4)) & 0xf;
-      _sb.append((char)((digit <= 9 ? '0' : ('A'-10))+digit));
-    }
+  // 1 byte, 2 hex digits, 8 bits
+  public SB hex1(int s) {
+    int digit = (s>>4) & 0xf;
+    _sb.append((char)((digit <= 9 ? '0' : ('A'-10))+digit));
+    digit = s & 0xf;
+    _sb.append((char)((digit <= 9 ? '0' : ('A'-10))+digit));
     return this;
   }
+  // 2 bytes, 4 hex digits, 16 bits, Big Endian
+  public SB hex2(int s) { return hex1(s>> 8).hex1(s); }
+  // 4 bytes, 8 hex digits, 32 bits, Big Endian
+  public SB hex4(int s) { return hex2(s>>16).hex2(s); }
+  // 8 bytes, 16 hex digits, 64 bits, Big Endian
+    public SB hex8(long s) { return hex4((int)(s>>32)).hex4((int)s); }
+
   // Fixed width field
   public SB fix( int sz, String s ) {
     for( int i=0; i<sz; i++ )
       _sb.append( i < s.length() ? s.charAt(i) : ' ');
     return this;
   }
+  public char at(int idx ) { return _sb.charAt(idx); }
 
   // Not spelled "p" on purpose: too easy to accidentally say "p(1.0)" and
   // suddenly call the autoboxed version.
@@ -83,6 +90,8 @@ public boolean was_nl() {
   //
   public SB unchar() { return unchar(1); }
   public SB unchar(int x) { _sb.setLength(_sb.length()-x); return this; }
+  public SB setLen(int len) { _sb.setLength(len); return this; }
+  public String subString(int start, int end ) { return _sb.substring(start,end); }
 
   public SB clear() { _sb.setLength(0); return this; }
   public int len() { return _sb.length(); }
diff --git a/seaofnodes/src/main/java/com/compilerprogramming/ezlang/compiler/print/ASMPrinter.java b/seaofnodes/src/main/java/com/compilerprogramming/ezlang/compiler/print/ASMPrinter.java
index f620244..1a93013 100644
--- a/seaofnodes/src/main/java/com/compilerprogramming/ezlang/compiler/print/ASMPrinter.java
+++ b/seaofnodes/src/main/java/com/compilerprogramming/ezlang/compiler/print/ASMPrinter.java
@@ -6,6 +6,8 @@
 import com.compilerprogramming.ezlang.compiler.nodes.*;
 import com.compilerprogramming.ezlang.compiler.sontypes.*;
 
+import java.util.HashSet;
+
 public abstract class ASMPrinter {
 
     public static SB print(SB sb, CodeGen code) {
@@ -17,17 +19,70 @@ public static SB print(SB sb, CodeGen code) {
         for( int i=0; i<code._cfg._len; i++ )
             if( code._cfg.at(i) instanceof FunNode fun )
                 iadr = print(iadr,sb,code,fun,i);
+
+        // Skip padding
+        while( ((iadr+7) & -8) > iadr )
+            iadr++;
+
+        // constant pool
+        Encoding enc = code._encoding;
+        if(  enc!=null && !enc._bigCons.isEmpty() ) {
+            iadr = (iadr+15)&-16; // pad to 16
+            HashSet<SONType> targets = new HashSet<>();
+            sb.p("--- Constant Pool ------").nl();
+            // By log size
+            for( int log = 3; log >= 0; log-- ) {
+                for( Node op : enc._bigCons.keySet() ) {
+                    Encoding.Relo relo = enc._bigCons.get(op);
+                    if( targets.contains(relo._t) ) continue;
+                    targets.add(relo._t);
+                    if( relo._t.log_size()==log ) {
+                        sb.hex2(iadr).p("  ");
+                        if( relo._t instanceof SONTypeTuple tt ) {
+                            for( SONType tx : tt._types ) {
+                                switch( log ) {
+                                case 0: sb.hex1(enc.read1(iadr)); break;
+                                case 1: sb.hex2(enc.read2(iadr)); break;
+                                case 2: sb.hex4(enc.read4(iadr)); break;
+                                case 3: sb.hex8(enc.read8(iadr)); break;
+                                }
+                                iadr += (1<<log);
+                                sb.p(" ");
+                            }
+                        } else {
+                            switch( log ) {
+                            case 0: sb.hex1(enc.read1(iadr)).fix(9-1,""); break;
+                            case 1: sb.hex2(enc.read2(iadr)).fix(9-2,""); break;
+                            case 2: sb.hex4(enc.read4(iadr)).fix(9-4,""); break;
+                            case 3: sb.hex8(enc.read8(iadr)).p(" "); break;
+                            }
+                            iadr += (1<<log);
+                        }
+                        relo._t.print(sb).nl();
+                    }
+                }
+            }
+        }
+
+
         return sb;
     }
 
     private static int print(int iadr, SB sb, CodeGen code, FunNode fun, int cfgidx) {
+        FunNode old=null;
+        if( code._encoding!=null ) {
+            old = code._encoding._fun;
+            code._encoding._fun = fun; // Useful printing after RA
+        }
         // Function header
         sb.nl().p("---");
         if( fun._name != null ) sb.p(fun._name).p(" ");
         fun.sig().print(sb);
         sb.p("---------------------------").nl();
+        iadr = (iadr + 15)&-16; // All function entries padded to 16 align
 
-
+        if( fun._frameAdjust != 0 )
+            iadr = doInst(iadr,sb,code,fun,cfgidx,fun,true,true);
         while( !(code._cfg.at(cfgidx) instanceof ReturnNode) )
             iadr = doBlock(iadr,sb,code,fun,cfgidx++);
 
@@ -35,69 +90,74 @@ private static int print(int iadr, SB sb, CodeGen code, FunNode fun, int cfgidx)
         sb.p("---");
         fun.sig().print(sb);
         sb.p("---------------------------").nl();
+        if( code._encoding != null )
+            code._encoding._fun = old;
         return iadr;
     }
 
-    static private final int encWidth = 8;
     static private final int opWidth = 5;
     static private final int argWidth = 30;
     static int doBlock(int iadr, SB sb, CodeGen code, FunNode fun, int cfgidx) {
+        final int encWidth = code._mach==null ? 2 : code._mach.defaultOpSize()*2;
         CFGNode bb = code._cfg.at(cfgidx);
         if( bb != fun && !(bb instanceof IfNode) && !(bb instanceof CallEndNode) && !(bb instanceof CallNode)  && !(bb instanceof CProjNode && bb.in(0) instanceof CallEndNode ))
-            sb.p(bb instanceof LoopNode ? "LOOP" : "L").p(bb._nid).p(":").nl();
+            sb.p(label(bb)).p(":").nl();
         if( bb instanceof CallNode ) return iadr;
         final boolean postAlloc = code._phase.ordinal() > CodeGen.Phase.RegAlloc.ordinal();
+        final boolean postEncode= code._phase.ordinal() >=CodeGen.Phase.Encoding.ordinal();
 
-        // Count Phis
-        int nPhi=0;
-        for( ; nPhi<bb.nOuts(); nPhi++ )
-            if( !(bb.out(nPhi) instanceof PhiNode) )
-                break;
-
-        if( nPhi>0 ) {
-            // Post-alloc phi prints all on one line
+        boolean once=false;
+        for( Node n : bb.outs() ) {
+            if( !(n instanceof PhiNode phi) ) continue;
+            if( phi._type instanceof SONTypeMem || phi._type instanceof SONTypeRPC ) continue; // Nothing for the hidden ones
+            // Post-RegAlloc phi prints all on one line
             if( postAlloc ) {
-                sb.fix(4," ").p(" ").fix(encWidth,"").p("  ");
-                for( int i=0; i<nPhi; i++ ) {
-                    PhiNode phi = (PhiNode)bb.out(i);
-                    if( !(phi._type instanceof SONTypeMem || phi._type instanceof SONTypeRPC) ) // Nothing for the hidden ones
-                        sb.p(phi._label).p(':').p(code.reg(phi)).p(',');
-                }
-                sb.unchar().nl();
-
+                if( !once ) { once=true; sb.fix(4," ").p(" ").fix(encWidth,"").p("  "); }
+                sb.p(phi._label).p(':').p(code.reg(phi,fun)).p(',');
             } else {
-                for( int j=0; j<nPhi; j++ ) {
-                    PhiNode phi = (PhiNode)bb.out(j);
-                    if( phi._type instanceof SONTypeMem || phi._type instanceof SONTypeRPC ) continue; // Nothing for the hidden ones
-                    sb.fix(4," ").p(" ").fix(encWidth,"").p("  ").fix(opWidth,phi._label).p(" ");
-                    sb.p(code.reg(phi));
-                    if( !(phi instanceof ParmNode) ) {
-                        sb.p(" = phi( ");
-                        for( int i=1; i<phi.nIns(); i++ )
-                            sb.p("N").p(phi.in(i)._nid).p(",");
-                        sb.unchar().p(" )");
-                    }
-                    sb.nl();
+                // Pre-RegAlloc phi prints one line per
+                sb.fix(4," ").p(" ").fix(encWidth,"").p("  ").fix(opWidth,phi._label).p(" ").p(code.reg(phi,fun));
+                if( phi.getClass() == PhiNode.class ) {
+                    sb.p(" = phi( ");
+                    for( int i=1; i<phi.nIns(); i++ )
+                        sb.p("N").p(phi.in(i)._nid).p(",");
+                    sb.unchar().p(" )");
                 }
+                sb.nl();
             }
         }
+        if( once ) sb.unchar().nl();
 
         // All the non-phis
-        for( int i=nPhi; i<bb.nOuts(); i++ )
-            iadr = doInst(iadr, sb,code,fun,bb,bb.out(i),postAlloc );
+        for( int i=0; i<bb.nOuts(); i++ )
+            if( !(bb.out(i) instanceof PhiNode) )
+                iadr = doInst(iadr, sb,code, fun, cfgidx, bb.out(i),postAlloc, postEncode );
 
         return iadr;
     }
 
-    static int doInst(int iadr, SB sb, CodeGen code, FunNode fun, CFGNode bb, Node n, boolean postAlloc ) {
-        if( n instanceof CProjNode ) return iadr;
-        if( n instanceof CalleeSaveNode && postAlloc ) return iadr;
+    static int doInst( int iadr, SB sb, CodeGen code, FunNode fun, int cfgidx, Node n, boolean postAlloc, boolean postEncode ) {
+        if( n==null || n instanceof CProjNode ) return iadr;
+        if( postAlloc && n instanceof CalleeSaveNode ) return iadr;
+        if( postEncode && n instanceof ProjNode ) return iadr;
+        if( n instanceof MemMergeNode ) return iadr;
+        if( n.getClass() == ConstantNode.class ) return iadr; // Default placeholders
+        final int dopz = code._mach==null ? 2 : code._mach.defaultOpSize();
+        final int encWidth = dopz*2;
 
         // All blocks ending in a Region will need to either fall into or jump
         // to this block.  Until the post-reg-alloc block layout cleanup, we
         // need to assume a jump.  There's no real hardware op here, yet.
-        if( n instanceof RegionNode && !(n instanceof FunNode) ) {
-            sb.hex4(iadr++).p(" ").fix(encWidth,"??").p("  ").fix(opWidth,"JMP").p(" ").fix(argWidth,"L"+n._nid).nl();
+        if( n instanceof RegionNode cfg && !(n instanceof FunNode) ) {
+            if( postEncode ) return iadr; // All jumps inserted already
+            while( cfgidx < code._cfg._len-1 ) {
+                CFGNode next = code._cfg.at(++cfgidx);
+                if( next == n ) return iadr; // Fall-through, no branch
+                if( next.nOuts()>1 )
+                    break;      // Has code in the block, need to jump around
+                // No code in the block, can fall through it
+            }
+            sb.hex2(iadr++).p(" ").fix(encWidth,"??").p("  ").fix(opWidth,"JMP").p(" ").fix(argWidth,label(cfg)).nl();
             return iadr;
         }
 
@@ -105,30 +165,44 @@ static int doInst(int iadr, SB sb, CodeGen code, FunNode fun, CFGNode bb, Node n
         // get indent slightly and just print their index & node#
         if( n instanceof ProjNode proj ) {
             if( proj._type instanceof SONTypeMem ) return iadr; // Nothing for the hidden ones
-            sb.fix(4," ").p(" ").fix(encWidth,"").p("    ").fix(opWidth,proj._label==null ? "---" : proj._label).p(" ").p(code.reg(n)).nl();
+            sb.fix(4," ").p(" ").fix(encWidth,"").p("    ").fix(opWidth,proj._label==null ? "---" : proj._label).p(" ").p(code.reg(n,fun)).nl();
             return iadr;
         }
 
         // ADDR ENCODING  Op--- dst = src op src       // Comment
         // 1234 abcdefgh  ld4   RAX = [Rbase + off]    // Comment
-        sb.hex4(iadr);
-        sb.p(" ");
+        sb.hex2(iadr).p(" ");
 
         // Encoding
-        int size = 1;           // TODO: Fake encoding size
-        iadr += size;
-        sb.fix(encWidth,"??");
+        int fatEncoding = 0;
+        if( code._encoding != null ) {
+            int size = code._encoding._opLen[n._nid];
+            if( code._asmLittle )
+                for( int i=0; i<Math.min(size,dopz); i++ )
+                    sb.hex1(code._encoding._bits.buf()[iadr++]);
+            else {
+                iadr += Math.min(size,dopz);
+                for( int i=0; i<Math.min(size,dopz); i++ )
+                    sb.hex1(code._encoding._bits.buf()[iadr-i-1]);
+            }
+            for( int i=size*2; i<encWidth; i++ )
+                sb.p(" ");
+            fatEncoding = size - (encWidth>>1); // Not-printed parts of encoding
+        } else
+            sb.fix(encWidth,"");
         sb.p("  ");
 
         // Op; generally "ld4" or "call"
-        sb.fix(opWidth, n instanceof MachNode mach ? mach.op() : n.label());
-        sb.p(" ");
+        sb.fix(opWidth, n instanceof MachNode mach ? mach.op() : n.label()).p(" ");
 
         // General asm args
+        String isMultiOp = null;
         if( n instanceof MachNode mach ) {
             int old = sb.len();
             mach.asm(code,sb);
-            sb.fix(argWidth-(sb.len()-old),""); // Pad out
+            int len = sb.len();
+            isMultiOp = isMultiOp(sb,old,len);
+            sb.fix(argWidth-(len-old),""); // Pad out
 
         } else if( !(n._type instanceof SONTypeMem) ) {
             // Room for some inputs
@@ -149,14 +223,64 @@ static int doInst(int iadr, SB sb, CodeGen code, FunNode fun, CFGNode bb, Node n
 
         sb.nl();
 
+        // Printing more op bits than fit
+        if( isMultiOp != null && code._encoding != null ) {
+            // Multiple ops, template style, no RA, no scheduling.  Print out
+            // one-line-per-newline, with encoding bits up front.
+            int size = code._encoding._opLen[n._nid];
+            int off = Math.min(size,dopz);
+            while( isMultiOp!=null ) {
+                sb.hex2(iadr).p(" ");
+                int len = Math.min(size-off,dopz);
+                for( int i=0; i<len; i++ )
+                    sb.hex1(code._encoding._bits.buf()[iadr++]);
+                off += len;
+                for( int i=len; i<dopz; i++ ) sb.p("  ");
+                sb.p("  ");
+                int x = isMultiOp.indexOf('\n');
+                if( x== -1 ) {  // Last line
+                    sb.p(isMultiOp).nl();
+                    isMultiOp = null;
+                } else {
+                    sb.p(isMultiOp.substring(0,x+1)); // Includes the newline
+                    isMultiOp = isMultiOp.substring(x+1);
+                }
+
+            }
+
+        } else if( fatEncoding > 0 ) {
+            // Extra bytes past the default encoding width, all put on a line by
+            // themselves.  X86 special for super long encodings
+            sb.hex2(iadr).p(" ");
+            for( int i=0; i<fatEncoding; i++ )
+                sb.hex1(code._encoding._bits.buf()[iadr++]);
+            sb.nl();
+        }
+
+
         // MultiNodes are immediately followed by projection(s)
         if( !(n instanceof CFGNode) && n instanceof MultiNode ) {
             for( Node proj : n._outputs ) {
-                assert proj instanceof ProjNode;
-                doInst(iadr,sb,code,fun,bb,proj,postAlloc);
+                if( proj instanceof ProjNode ) // it could also be an ante-dep
+                    doInst(iadr,sb,code,fun, cfgidx, proj,postAlloc,postEncode);
             }
         }
 
         return iadr;
     }
+
+    private static String label( CFGNode bb ) {
+        return (bb instanceof LoopNode ? "LOOP" : "L")+bb._nid;
+    }
+
+    private static String isMultiOp(SB sb, int old, int len) {
+        for( int i=old; i<len; i++ )
+            if( sb.at(i)=='\n' ) {
+                String s = sb.subString(i+1,len);
+                sb.setLen(i);
+                return s;
+            }
+        return null;
+    }
+
 }
diff --git a/seaofnodes/src/main/java/com/compilerprogramming/ezlang/compiler/print/IRPrinter.java b/seaofnodes/src/main/java/com/compilerprogramming/ezlang/compiler/print/IRPrinter.java
index a69581d..0d40c70 100644
--- a/seaofnodes/src/main/java/com/compilerprogramming/ezlang/compiler/print/IRPrinter.java
+++ b/seaofnodes/src/main/java/com/compilerprogramming/ezlang/compiler/print/IRPrinter.java
@@ -15,6 +15,7 @@ public abstract class IRPrinter {
     // NNID NNAME DDEF DDEF  [[  UUSE UUSE  ]]  TYPE
     // 1234 sssss 1234 1234 1234 1234 1234 1234 tttttt
     public static SB printLine( Node n, SB sb ) {
+        if( n==null ) return sb;
         sb.p("%4d %-7.7s ".formatted(n._nid,n.label()));
         if( n._inputs==null )
             return sb.p("DEAD\n");
@@ -210,7 +211,8 @@ public static String _prettyPrint( CodeGen code ) {
                 printLine(n,sb);
                 if( !(n instanceof CFGNode) && n instanceof MultiNode )
                     for( Node use : n._outputs )
-                        printLine(use,sb);
+                        if( use instanceof ProjNode )
+                            printLine(use,sb);
             }
         }
 
@@ -280,7 +282,8 @@ else if( blk instanceof RegionNode || blk instanceof StopNode )
                         printLine( n, sb, bns, i--, ds,ns );
                         if( n instanceof MultiNode && !(n instanceof CFGNode) ) {
                             for( Node use : n._outputs ) {
-                                printLine(use,sb,bns,bns.indexOf(use),ds,ns);
+                                if( use instanceof ProjNode )
+                                    printLine(use,sb,bns,bns.indexOf(use),ds,ns);
                             }
                         }
                     }
diff --git a/seaofnodes/src/main/java/com/compilerprogramming/ezlang/compiler/sontypes/SONTypeFunPtr.java b/seaofnodes/src/main/java/com/compilerprogramming/ezlang/compiler/sontypes/SONTypeFunPtr.java
index 07b06df..484c1d7 100644
--- a/seaofnodes/src/main/java/com/compilerprogramming/ezlang/compiler/sontypes/SONTypeFunPtr.java
+++ b/seaofnodes/src/main/java/com/compilerprogramming/ezlang/compiler/sontypes/SONTypeFunPtr.java
@@ -35,8 +35,7 @@ public SONTypeFunPtr(byte nil, SONTypeTuple sig, SONType ret, long fidxs) {
 
     public static SONTypeFunPtr make(byte nil, SONTypeTuple sig, SONType ret, long fidxs ) { return new SONTypeFunPtr(nil,sig,ret,fidxs).intern(); }
     public static SONTypeFunPtr make(boolean nil, SONTypeTuple sig, SONType ret ) { return make((byte)(nil ? 3 : 2),sig,ret,-1); }
-    @Override
-    SONTypeFunPtr makeFrom(byte nil ) { return  nil ==_nil   ? this : make(  nil,_sig,_ret,   _fidxs); }
+    @Override SONTypeFunPtr makeFrom(byte nil ) { return  nil ==_nil   ? this : make(  nil,_sig,_ret,   _fidxs); }
     public SONTypeFunPtr makeFrom(SONType ret ) { return     ret ==_ret   ? this : make( _nil,_sig, ret,   _fidxs); }
     public SONTypeFunPtr makeFrom(int fidx ) { return make((byte)2, _sig,_ret,1L<<fidx ); }
 
diff --git a/seaofnodes/src/test/cases/mergsort/sort_ez.out b/seaofnodes/src/test/cases/mergsort/sort_ez.out
index 946e758..b4cc2a5 100644
--- a/seaofnodes/src/test/cases/mergsort/sort_ez.out
+++ b/seaofnodes/src/test/cases/mergsort/sort_ez.out
@@ -1,716 +1,250 @@
-START:                            [[   ]]
-  10 Start   ____ ____ ____       [[    15   52   55   61  158   12   67    9  102  179  ]]  [  Ctrl, #TOP, int]
-
-L9:                               [[  START      ]]
-   9 merge_s ____   10            [[    50   51   54   56   60  321  320  319  318  317  316  315  314  313  312  311  310  309  308  307  306  305  304  401  398  362  364  400  403  405    8  ]]  Ctrl
-  50 $mem       9   15            [[     8       ]]  #BOT
-  51 a          9   52            [[   398       ]]  *[int]
-  54 n          9   55            [[   401       ]]  int
-  56 b          9   52            [[   362       ]]  *[int]
-  60 $rpc       9   61            [[     2       ]]  $[ALL]
- 405 #0         9                 [[     8       ]]  0
- 403 mov        9  401            [[     8       ]]
- 400 mov        9  398            [[     8       ]]
- 364 mov        9  362            [[     8       ]]
-   8 call       9   50  400  405  403  364  [[     7  ]]  Ctrl
- 362 mov        9   56            [[   363  364  ]]
- 398 mov        9   51            [[   399  400  ]]
- 401 mov        9   54            [[   402  403  ]]
- 305 rbp        9                 [[     2       ]]
- 309 r13        9                 [[     2       ]]
- 310 r14        9                 [[     2       ]]
- 311 r15        9                 [[     2       ]]
- 312 xmm6       9                 [[     2       ]]
- 313 xmm7       9                 [[     2       ]]
- 314 xmm8       9                 [[     2       ]]
- 315 xmm9       9                 [[     2       ]]
- 316 xmm10      9                 [[     2       ]]
- 317 xmm11      9                 [[     2       ]]
- 318 xmm12      9                 [[     2       ]]
- 319 xmm13      9                 [[     2       ]]
- 320 xmm14      9                 [[     2       ]]
- 321 xmm15      9                 [[     2       ]]
- 304 rbx        9                 [[     2       ]]
- 308 r12        9                 [[     2       ]]
- 307 rdi        9                 [[     2       ]]
- 306 rsi        9                 [[     2       ]]
-
-L12:                              [[  START      ]]
-  12 main    ____   10            [[    14  208  303  302  301  300  299  298  297  296  295  294  293  292  291  290  289  288  287  286  409  394   22  345  347   32  348   31  349   30  350   29  351   28  352   27  353   26  354   25  355   24  356   23  393   20  397  392   17  360   45   44   43   42   41   40   39   38   37   36   13  357  359  396   11  ]]  Ctrl
-  14 $mem      12   15            [[    13   22   22  ]]  #BOT
- 208 $rpc      12   61            [[   203       ]]  $[ALL]
- 347 mov       12  345            [[    32       ]]
-  32 st8       12   33  347 ____ ____  [[    31  ]]  #3:int
- 348 mov       12  345            [[    31       ]]
-  31 st8       12   32  348 ____ ____  [[    30  ]]  #3:int
- 349 mov       12  345            [[    30       ]]
-  30 st8       12   31  349 ____ ____  [[    29  ]]  #3:int
- 350 mov       12  345            [[    29       ]]
-  45 st8       12   46  360 ____ ____  [[    44  ]]  #3:int
-  29 st8       12   30  350 ____ ____  [[    28  ]]  #3:int
- 351 mov       12  345            [[    28       ]]
-  44 st8       12   45  360 ____ ____  [[    43  ]]  #3:int
-  28 st8       12   29  351 ____ ____  [[    27  ]]  #3:int
-  43 st8       12   44  360 ____ ____  [[    42  ]]  #3:int
- 352 mov       12  345            [[    27       ]]
-  42 st8       12   43  360 ____ ____  [[    41  ]]  #3:int
-  27 st8       12   28  352 ____ ____  [[    26  ]]  #3:int
- 353 mov       12  345            [[    26       ]]
-  41 st8       12   42  360 ____ ____  [[    40  ]]  #3:int
-  26 st8       12   27  353 ____ ____  [[    25  ]]  #3:int
- 354 mov       12  345            [[    25       ]]
-  40 st8       12   41  360 ____ ____  [[    39  ]]  #3:int
-  25 st8       12   26  354 ____ ____  [[    24  ]]  #3:int
- 355 mov       12  345            [[    24       ]]
-  39 st8       12   40  360 ____ ____  [[    38  ]]  #3:int
-  24 st8       12   25  355 ____ ____  [[    23  ]]  #3:int
- 356 mov       12  345            [[    23       ]]
-  38 st8       12   39  360 ____ ____  [[    37  ]]  #3:int
-  23 st8       12   24  356 ____ ____  [[    20  ]]  #3:int
- 393 #88       12                 [[    20       ]]  88
-  37 st8       12   38  360 ____ ____  [[    36  ]]  #3:int
-  20 new_ary   12  393   21   23  [[    19   35   48  ]]  [  Ctrl, *![int], #2:u32, #3:int]
-  19 $2        20                 [[    17       ]]  #2:u32
-  35 $3        20                 [[    17       ]]  #3:int
-  48 [int]     20                 [[   397       ]]  *[int]
- 394 #88       12                 [[    22       ]]  88
-  36 st8       12   37  360 ____ ____  [[    13  ]]  #3:int
- 392 #88       12                 [[    17       ]]  88
- 397 mov       12   48            [[   359       ]]
- 396 #10       12                 [[    11       ]]  10
-  17 new_ary   12  392   19   35  [[    16   46   47  ]]  [  Ctrl, *![int], #2:u32, #3:int]
-  16 $2        17                 [[    13       ]]  #2:u32
-  46 $3        17                 [[    45       ]]  #3:int
-  47 [int]     17                 [[   360       ]]  *[int]
-  13 ALLMEM    12   14   16   36  [[    11       ]]  #BOT
- 357 mov       12  345            [[    11       ]]
- 359 mov       12  397            [[    11       ]]
-  22 new_ary   12  394   14   14  [[    21   33   34  ]]  [  Ctrl, *![int], #2:u32, #3:int]
-  21 $2        22                 [[    20       ]]  #2:u32
-  33 $3        22                 [[    32       ]]  #3:int
-  34 [int]     22                 [[   345       ]]  *[int]
-  11 call      12   13  357  359  396  [[   182  ]]  Ctrl
- 345 mov       12   34            [[   346  357  356  355  354  353  352  351  350  349  348  347  ]]
- 360 mov       12   47            [[   361   36   37   38   39   40   41   42   43   44   45  ]]
- 286 rbx       12                 [[   409       ]]
- 409 mov       12  286            [[   410       ]]
- 288 rsi       12                 [[   203       ]]
- 289 rdi       12                 [[   203       ]]
- 290 r12       12                 [[   203       ]]
- 291 r13       12                 [[   203       ]]
- 292 r14       12                 [[   203       ]]
- 293 r15       12                 [[   203       ]]
- 294 xmm6      12                 [[   203       ]]
- 295 xmm7      12                 [[   203       ]]
- 296 xmm8      12                 [[   203       ]]
- 297 xmm9      12                 [[   203       ]]
- 298 xmm10     12                 [[   203       ]]
- 299 xmm11     12                 [[   203       ]]
- 300 xmm12     12                 [[   203       ]]
- 301 xmm13     12                 [[   203       ]]
- 302 xmm14     12                 [[   203       ]]
- 303 xmm15     12                 [[   203       ]]
- 287 rbp       12                 [[   203       ]]
-
-L179:                             [[  START      ]]
- 179 eq      ____   10            [[   189  190  194  197  201  285  284  283  282  281  280  279  278  277  276  275  274  273  272  271  270  269  268  390  178  ]]  Ctrl
- 189 $mem     179   15            [[   187  193  199  199  ]]  #BOT
- 190 a        179   52            [[   187       ]]  *[int]
- 194 b        179   52            [[   193       ]]  *[int]
- 197 n        179   55            [[   195       ]]  int
- 201 $rpc     179   61            [[   174       ]]  $[ALL]
- 390 #0       179                 [[   191       ]]  0
- 272 r12      179                 [[   174       ]]
- 273 r13      179                 [[   174       ]]
- 274 r14      179                 [[   174       ]]
- 275 r15      179                 [[   174       ]]
- 276 xmm6     179                 [[   174       ]]
- 277 xmm7     179                 [[   174       ]]
- 278 xmm8     179                 [[   174       ]]
- 279 xmm9     179                 [[   174       ]]
- 280 xmm10    179                 [[   174       ]]
- 281 xmm11    179                 [[   174       ]]
- 282 xmm12    179                 [[   174       ]]
- 283 xmm13    179                 [[   174       ]]
- 284 xmm14    179                 [[   174       ]]
- 285 xmm15    179                 [[   174       ]]
- 271 rdi      179                 [[   174       ]]
- 270 rsi      179                 [[   174       ]]
- 269 rbp      179                 [[   174       ]]
- 268 rbx      179                 [[   174       ]]
-
-L158:                             [[  START      ]]
- 158 copy_ar ____   10            [[   163  165  167  170  172  173  249  248  247  246  245  244  243  242  241  240  239  238  237  236  235  234  233  232  157  ]]  Ctrl
- 163 begin    158   55            [[   162       ]]  int
- 165 end      158   55            [[   160       ]]  int
- 167 $mem     158   15            [[   166  168  ]]  #BOT
- 170 b        158   52            [[   169       ]]  *[int]
- 172 a        158   52            [[   171       ]]  *[int]
- 173 $rpc     158   61            [[   154       ]]  $[ALL]
- 232 rbx      158                 [[   154       ]]
- 238 r14      158                 [[   154       ]]
- 239 r15      158                 [[   154       ]]
- 240 xmm6     158                 [[   154       ]]
- 241 xmm7     158                 [[   154       ]]
- 242 xmm8     158                 [[   154       ]]
- 243 xmm9     158                 [[   154       ]]
- 244 xmm10    158                 [[   154       ]]
- 245 xmm11    158                 [[   154       ]]
- 246 xmm12    158                 [[   154       ]]
- 247 xmm13    158                 [[   154       ]]
- 248 xmm14    158                 [[   154       ]]
- 249 xmm15    158                 [[   154       ]]
- 237 r13      158                 [[   154       ]]
- 236 r12      158                 [[   154       ]]
- 235 rdi      158                 [[   154       ]]
- 234 rsi      158                 [[   154       ]]
- 233 rbp      158                 [[   154       ]]
-
-L67:                              [[  START      ]]
-  67 split_m ____   10            [[    70   73   74   75   78   95  267  266  265  264  263  262  261  260  259  258  257  256  255  254  253  252  251  250  383  332  328  324  338  387   84   82   66  ]]  Ctrl
-  70 $mem      67   15            [[    68   91  ]]  #BOT
-  73 a         67   52            [[   324       ]]  *[int]
-  74 b         67   52            [[   328       ]]  *[int]
-  75 begin     67   55            [[   383       ]]  int
-  78 end       67   55            [[   332       ]]  int
-  95 $rpc      67   61            [[    63       ]]  $[ALL]
- 387 mov       67  383            [[    84       ]]
- 328 mov       67   74            [[   331  330  329  ]]
- 332 mov       67   78            [[   338  336  333  335  ]]
- 383 mov       67   75            [[   387  386  384  385  ]]
- 338 mov       67  332            [[    84       ]]
- 324 mov       67   73            [[   327  325  326  ]]
-  84 sub       67  338  387       [[    82       ]]  int
-  82 cmp       67   84            [[    66       ]]  bool
-  66 j<=       67   82            [[    65   69  ]]  [  Ctrl, Ctrl]
- 255 r13       67                 [[    63       ]]
- 256 r14       67                 [[    63       ]]
- 257 r15       67                 [[    63       ]]
- 258 xmm6      67                 [[    63       ]]
- 259 xmm7      67                 [[    63       ]]
- 260 xmm8      67                 [[    63       ]]
- 261 xmm9      67                 [[    63       ]]
- 262 xmm10     67                 [[    63       ]]
- 263 xmm11     67                 [[    63       ]]
- 264 xmm12     67                 [[    63       ]]
- 265 xmm13     67                 [[    63       ]]
- 266 xmm14     67                 [[    63       ]]
- 267 xmm15     67                 [[    63       ]]
- 252 rsi       67                 [[    63       ]]
- 251 rbp       67                 [[    63       ]]
- 250 rbx       67                 [[    63       ]]
- 253 rdi       67                 [[    63       ]]
- 254 r12       67                 [[    63       ]]
-
-L102:                             [[  START      ]]
- 102 merge   ____   10            [[   119  122  125  132  134  139  153  231  230  229  228  227  226  225  224  223  222  221  220  219  218  217  216  215  214  406  322  368  373  101  ]]  Ctrl
- 119 begin    102   55            [[   368  135  ]]  int
- 122 middle   102   55            [[   116  373  ]]  int
- 125 end      102   55            [[   123  150  ]]  int
- 132 $mem     102   15            [[   131  152  ]]  #BOT
- 134 b        102   52            [[   133       ]]  *[int]
- 139 a        102   52            [[   322       ]]  *[int]
- 153 $rpc     102   61            [[    98       ]]  $[ALL]
- 373 mov      102  122            [[   126       ]]
- 368 mov      102  119            [[   118       ]]
- 322 mov      102  139            [[   323  129  140  138  ]]
- 214 rbx      102                 [[   406       ]]
- 406 mov      102  214            [[   407       ]]
- 217 rdi      102                 [[    98       ]]
- 222 xmm6     102                 [[    98       ]]
- 223 xmm7     102                 [[    98       ]]
- 224 xmm8     102                 [[    98       ]]
- 225 xmm9     102                 [[    98       ]]
- 226 xmm10    102                 [[    98       ]]
- 227 xmm11    102                 [[    98       ]]
- 228 xmm12    102                 [[    98       ]]
- 229 xmm13    102                 [[    98       ]]
- 230 xmm14    102                 [[    98       ]]
- 231 xmm15    102                 [[    98       ]]
- 216 rsi      102                 [[    98       ]]
- 215 rbp      102                 [[    98       ]]
- 220 r14      102                 [[    98       ]]
- 221 r15      102                 [[    98       ]]
- 219 r13      102                 [[    98       ]]
- 218 r12      102                 [[    98       ]]
-
-LOOP178:                          [[  L179      L184       ]]
- 178 Loop    ____  179  419       [[   191  195  177  ]]  Ctrl
- 191 Phi_i    178  390  192       [[   195  187  192  193  ]]  int
- 195 cmp      178  191  197       [[   177       ]]  bool
- 177 j>=      178  195            [[   176  186  ]]  [  Ctrl, Ctrl]
-
-LOOP157:                          [[  L158      L159       ]]
- 157 Loop    ____  158  411       [[   162  168  160  156  ]]  Ctrl
- 162 Phi_k    157  163  164       [[   160  164  169  171  ]]  int
- 168 Phi_$3   157  167  169       [[   166  169  171  ]]  #BOT
- 160 cmp      157  162  165       [[   156       ]]  bool
- 156 j>=      157  160            [[   155  159  ]]  [  Ctrl, Ctrl]
-
-LOOP101:                          [[  L102      L103       ]]
- 101 Loop    ____  102  413       [[   118  126  131  135  150  100  ]]  Ctrl
- 118 Phi_i    101  368  120       [[   129  116  121  120  138  ]]  int
- 126 Phi_j    101  373  127       [[   142  123  127  128  140  ]]  int
- 131 Phi_$3   101  132  133       [[   129  133  138  140  142  152  ]]  #BOT
- 135 Phi_k    101  119  136       [[   150  133  136  ]]  int
- 150 cmp      101  135  125       [[   100       ]]  bool
- 100 j>=      101  150            [[    99  115  ]]  [  Ctrl, Ctrl]
-
-L7:                               [[  L9         ]]
-   7 CallEnd    8                 [[     6   57  ]]  [  Ctrl, #BOT, int]
-  57 $mem       7                 [[     5       ]]  #BOT
-
-L182:                             [[  L12        ]]
- 182 CallEnd   11                 [[   181  183  ]]  [  Ctrl, #BOT, int]
- 183 $mem     182                 [[   180       ]]  #BOT
-
-L65:                              [[  L67        ]]
-  65 True      66                 [[    53   64  ]]  Ctrl
-  53 #0        65                 [[    93       ]]  0
-
-L69:                              [[  L67        ]]
-  69 False     66                 [[   335  386   77   79   76  341  326  331  344  385   68  ]]  Ctrl
- 326 mov       69  324            [[    68       ]]
- 331 mov       69  328            [[    68       ]]
- 385 mov       69  383            [[    68       ]]
- 344 mov       69  341            [[    68       ]]
-  68 call      69   70  326  385  344  331  [[    72  ]]  Ctrl
- 335 mov       69  332            [[    77       ]]
- 386 mov       69  383            [[    77       ]]
-  77 add       69  335  386       [[    76       ]]  int
-  79 #2        69                 [[    76       ]]  2
-  76 div       69   77   79       [[   341       ]]  int
- 341 mov       69   76            [[   344  342  343  ]]
-
-L6:                               [[  L7         ]]
-   6 $ctrl      7                 [[   363  399  402  404    5  ]]  Ctrl
- 363 mov        6  362            [[     5       ]]
- 399 mov        6  398            [[     5       ]]
- 404 #0         6                 [[     5       ]]  0
- 402 mov        6  401            [[     5       ]]
-   5 call       6   57  399  404  402  363  [[     4  ]]  Ctrl
-
-L186:                             [[  LOOP178    ]]
- 186 False    177                 [[   193  187  185  ]]  Ctrl
- 193 ld8      186  189  194  191  [[   187       ]]  int
- 187 cmp8     186  189  190  191  193  [[   185  ]]  bool
- 185 j!=      186  187            [[   184  198  ]]  [  Ctrl, Ctrl]
-
-L176:                             [[  LOOP178    ]]
- 176 True     177                 [[   149  175  ]]  Ctrl
- 149 #1       176                 [[   200       ]]  1
-
-L181:                             [[  L182       ]]
- 181 $ctrl    182                 [[   346  361  395  180  ]]  Ctrl
- 346 mov      181  345            [[   180       ]]
- 361 mov      181  360            [[   180       ]]
- 395 #10      181                 [[   180       ]]  10
- 180 call     181  183  346  361  395  [[   205  ]]  Ctrl
-
-L159:                             [[  LOOP157    ]]
- 159 False    156                 [[   171  169  164  411  ]]  Ctrl
- 164 inc      159  162            [[   162       ]]  int
- 171 ld8      159  168  172  162  [[   169       ]]  int
- 169 st8      159  168  170  162  171  [[   168  ]]  #3:Bot
-
-L115:                             [[  LOOP101    ]]
- 115 False    100                 [[   116  114  ]]  Ctrl
- 116 cmp      115  118  122       [[   114       ]]  bool
- 114 j<       115  116            [[   113  143  ]]  [  Ctrl, Ctrl]
-
-L99:                              [[  LOOP101    ]]
-  99 True     100                 [[   152  407  408   98  ]]  Ctrl
- 152 ALLMEM    99  132 ____  131  [[    98       ]]  #BOT
- 407 mov       99  406            [[    98       ]]
- 408 #0        99                 [[    98       ]]  0
-  98 Return    99  152  408  153  407  215  216  217  218  219  220  221  222  223  224  225  226  227  228  229  230  231  [[     1  ]]  [  Ctrl, #BOT, 0]
-
-L155:                             [[  LOOP157    ]]
- 155 True     156                 [[   166  212  154  ]]  Ctrl
- 166 ALLMEM   155  167 ____  168  [[   154       ]]  #BOT
- 212 #0       155                 [[   154       ]]  0
- 154 Return   155  166  212  173  232  233  234  235  236  237  238  239  240  241  242  243  244  245  246  247  248  249  [[     1  ]]  [  Ctrl, #BOT, 0]
-
-L4:                               [[  L6         ]]
-   4 CallEnd    5                 [[     3   58   59  ]]  [  Ctrl, #BOT, int]
-  58 $mem       4                 [[     2       ]]  #BOT
-  59 #2         4                 [[     2       ]]  int
-
-L198:                             [[  L186       ]]
- 198 True     185                 [[   391  418  ]]  Ctrl
- 391 #0       198                 [[   200       ]]  0
- 418 jmp      198                 [[   175       ]]
-
-L184:                             [[  L186       ]]
- 184 False    185                 [[   192  419  ]]  Ctrl
- 192 inc      184  191            [[   191       ]]  int
-
-L143:                             [[  L115       ]]
- 143 False    114                 [[   381  417  ]]  Ctrl
- 381 #0       143                 [[   148       ]]  0
- 417 jmp      143                 [[   108       ]]
-
-L205:                             [[  L181       ]]
- 205 CallEnd  180                 [[   204  206  207  ]]  [  Ctrl, #BOT, bool]
- 206 $mem     205                 [[   203       ]]  #BOT
- 207 #2       205                 [[   203       ]]  bool
-
-L113:                             [[  L115       ]]
- 113 True     114                 [[   123  112  ]]  Ctrl
- 123 cmp      113  125  126       [[   112       ]]  bool
- 112 j<=      113  123            [[   111  144  ]]  [  Ctrl, Ctrl]
-
-L72:                              [[  L69        ]]
-  72 CallEnd   68                 [[    71   81  ]]  [  Ctrl, #BOT, int]
-  71 $mem      72                 [[    80       ]]  #BOT
-
-L3:                               [[  L4         ]]
-   3 $ctrl      4                 [[     2       ]]  Ctrl
-   2 Return     3   58   59   60  304  305  306  307  308  309  310  311  312  313  314  315  316  317  318  319  320  321  [[     1  ]]  [  Ctrl, #BOT, int]
-
-L81:                              [[  L72        ]]
-  81 $ctrl     72                 [[   327  330  336  343   80  ]]  Ctrl
- 327 mov       81  324            [[    80       ]]
- 330 mov       81  328            [[    80       ]]
- 343 mov       81  341            [[    80       ]]
- 336 mov       81  332            [[    80       ]]
-  80 call      81   71  327  343  336  330  [[    89  ]]  Ctrl
-
-L204:                             [[  L205       ]]
- 204 $ctrl    205                 [[   410  203  ]]  Ctrl
- 410 mov      204  409            [[   203       ]]
- 203 Return   204  206  207  208  410  287  288  289  290  291  292  293  294  295  296  297  298  299  300  301  302  303  [[     1  ]]  [  Ctrl, #BOT, bool]
-
-L175:                             [[  L176      L198       ]]
- 175 Region  ____  176  418       [[   200  199  174  ]]  Ctrl
- 200 Phi_res  175  149  391       [[   174       ]]  bool
- 199 ALLMEM   175  189 ____  189  [[   174       ]]  #BOT
- 174 Return   175  199  200  201  268  269  270  271  272  273  274  275  276  277  278  279  280  281  282  283  284  285  [[     1  ]]  [  Ctrl, #BOT, bool]
-
-L111:                             [[  L113       ]]
- 111 False    112                 [[   323  142  129  110  ]]  Ctrl
- 323 mov      111  322            [[   142       ]]
- 142 ld8      111  131  323  126  [[   129       ]]  int
- 129 cmp8     111  131  322  118  142  [[   110  ]]  bool
- 110 j<=      111  129            [[   109  145  ]]  [  Ctrl, Ctrl]
-
-L144:                             [[  L113       ]]
- 144 True     112                 [[   380  108  ]]  Ctrl
- 380 #1       144                 [[   148       ]]  1
-
-L89:                              [[  L81        ]]
-  89 CallEnd   80                 [[    88   90  ]]  [  Ctrl, #BOT, int]
-  90 $mem      89                 [[    87       ]]  #BOT
-
-L88:                              [[  L89        ]]
-  88 $ctrl     89                 [[   325  329  333  342  384   87  ]]  Ctrl
- 325 mov       88  324            [[    87       ]]
- 329 mov       88  328            [[    87       ]]
- 384 mov       88  383            [[    87       ]]
- 342 mov       88  341            [[    87       ]]
- 333 mov       88  332            [[    87       ]]
-  87 call      88   90  329  384  342  333  325  [[    86  ]]  Ctrl
-
-L109:                             [[  L111       ]]
- 109 True     110                 [[   379  415  ]]  Ctrl
- 379 #1       109                 [[   148       ]]  1
- 415 jmp      109                 [[   108       ]]
-
-L145:                             [[  L111       ]]
- 145 False    110                 [[   382  416  ]]  Ctrl
- 382 #0       145                 [[   148       ]]  0
- 416 jmp      145                 [[   108       ]]
-
-L108:                             [[  L109      L143      L144      L145       ]]
- 108 Region  ____  415  417  144  416  [[   148  146  107  ]]  Ctrl
- 148 Phi_con  108  379  381  380  382  [[   146  ]]  bool
- 146 test     108  148            [[   107       ]]
- 107 j!=      108  146            [[   104  141  ]]  [  Ctrl, Ctrl]
-
-L86:                              [[  L88        ]]
-  86 CallEnd   87                 [[    85   92   94  ]]  [  Ctrl, #BOT, int]
-  92 $mem      86                 [[    91       ]]  #BOT
-  94 #2        86                 [[    93       ]]  int
-
-L141:                             [[  L108       ]]
- 141 False    107                 [[   140  128  414  ]]  Ctrl
- 128 inc      141  126            [[   127       ]]  int
- 140 ld8      141  131  322  126  [[   137       ]]  int
- 414 jmp      141                 [[   103       ]]
-
-L104:                             [[  L108       ]]
- 104 True     107                 [[   138  121  103  ]]  Ctrl
- 121 inc      104  118            [[   120       ]]  int
- 138 ld8      104  131  322  118  [[   137       ]]  int
-
-L85:                              [[  L86        ]]
-  85 $ctrl     86                 [[   412       ]]  Ctrl
- 412 jmp       85                 [[    64       ]]
-
-L103:                             [[  L104      L141       ]]
- 103 Region  ____  104  414       [[   120  127  137  133  136  413  ]]  Ctrl
- 120 Phi_i    103  121  118       [[   118       ]]  int
- 127 Phi_j    103  126  128       [[   126       ]]  int
- 137 Phi_$3   103  138  140       [[   133       ]]  int
- 136 inc      103  135            [[   135       ]]  int
- 133 st8      103  131  134  135  137  [[   131  ]]  #3:Bot
-
-L64:                              [[  L65       L85        ]]
-  64 Region  ____   65  412       [[    91   93   63  ]]  Ctrl
-  91 Phi_$me   64   70   92       [[    63       ]]  #BOT
-  93 Phi_arg   64   53   94       [[    63       ]]  int
-  63 Return    64   91   93   95  250  251  252  253  254  255  256  257  258  259  260  261  262  263  264  265  266  267  [[     1  ]]  [  Ctrl, #BOT, int]
-
-L1:                               [[  L155      L175      L204       ]]
-   1 Stop       2   63   98  154  174  203  [[   ]]  Bot
-
-
+---split_merge { *![int] int int *![int] -> int #0}---------------------------
+00F0 4883EC38    subi  rsp -= #56
+                 a:r9,b:rcx,begin:rdx,end:r8
+00F4 4889542428  mov   [rsp+40] = rdx                 // def/loop #1
+00F9 4C89442458  mov   [rsp+88] = r8                  // def/loop #0
+00FE 48894C2450  mov   [rsp+80] = rcx                 // def/loop #0
+0103 4C894C2448  mov   [rsp+72] = r9                  // def/loop #0
+0108 4C8B442458  mov   r8 = [rsp+88]                  // use/loop/use #0
+010D 4C8B542428  mov   r10 = [rsp+40]                 // use/loop/use #1
+0112 4D2BC2      sub   r8 -= r10
+0115 4983F801    cmp   r8, #1
+0119 7E71        j<=   L65                            // L69
+L69:
+011B 488B442458  mov   rax = [rsp+88]                 // use/loop/use #0
+0120 488B542428  mov   rdx = [rsp+40]                 // use/loop/use #1
+0125 4803C2      add   rax += rdx
+0128 B902000000  ldi   rcx = #2
+012D 489948F7F9  div   rax = rax / rcx                // kill rdx
+0132 4889442440  mov   [rsp+64] = rax                 // def/loop #0
+0137 488B4C2448  mov   rcx = [rsp+72]                 // use/loop/use #0
+013C 4C8B4C2450  mov   r9 = [rsp+80]                  // use/loop/use #0
+0141 4C8B442440  mov   r8 = [rsp+64]                  // use/loop/use #0
+0146 488B542428  mov   rdx = [rsp+40]                 // use/loop/use #1
+014B E8A0FFFFFF  call  split_merge  rcx  rdx  r8  r9
+0150 488B4C2448  mov   rcx = [rsp+72]                 // use/loop/use #0
+0155 4C8B4C2450  mov   r9 = [rsp+80]                  // use/loop/use #0
+015A 4C8B442458  mov   r8 = [rsp+88]                  // use/loop/use #0
+015F 488B542440  mov   rdx = [rsp+64]                 // use/loop/use #0
+0164 E887FFFFFF  call  split_merge  rcx  rdx  r8  r9
+0169 FF7424488F  mov   [rsp+32] = [rsp+72]            // use/loop/use #0
+016E 442420
+0171 488B4C2450  mov   rcx = [rsp+80]                 // use/loop/use #0
+0176 4C8B4C2458  mov   r9 = [rsp+88]                  // use/loop/use #0
+017B 4C8B442440  mov   r8 = [rsp+64]                  // use/loop/use #0
+0180 488B542428  mov   rdx = [rsp+40]                 // use/loop/use #1
+0185 E8A6FEFFFF  call  merge  rcx  rdx  r8  r9  [stk#42]
+018A EB02        jmp   L64
+L412:
+L65:
+018C 33C0        xor   rax,rax
+L64:
+                 arg:rax
+018E 4883C438C3  addi  rsp += #56
+0193             ret
+---{ *![int] int int *![int] -> int #0}---------------------------
 
----eq { *![int] *![int] int -> int #1}---------------------------
-               a:rcx,b:rdx,n:r8
-0000 ??        xor   rax,rax
-0001 ??        JMP   L178
-LOOP178:
-               i:rax
-0002 ??        cmp   rax, r8
-0003 ??        j>=   L176                           // L186
-L186:
-0004 ??        ld8   r9,[rdx+rax*8+8]
-0005 ??        cmp8  r9, [rcx+rax*8+8]
-0006 ??        j!=   L198                           // L184
-L184:
-0007 ??        inc   rax += #1
-0008 ??        jmp   LOOP178
-L419:
-0009 ??        JMP   L178
-L198:
-000A ??        xor   rax,rax
-000B ??        jmp   L175
-L418:
-000C ??        JMP   L175
-L176:
-000D ??        ldi   rax = #1
-000E ??        JMP   L175
-L175:
-               result:rax
-000F ??        ALLME
-0010 ??        ret
----{ *![int] *![int] int -> int #1}---------------------------
+---copy_array { *![int] int int *![int] -> int #1}---------------------------
+                 begin:rdx,end:r8,b:r9,a:rcx
+LOOP157:
+                 k:rdx
+02F0 493BD0      cmp   rdx, r8
+02F3 7D10        j>=   L155                           // L159
+L159:
+02F5 488B44D108  ld8   rax,[rcx+rdx*8+8]
+02FA 498944D108  st8   [r9+rdx*8+8],rax
+02FF 4883C201    inc   rdx += #1
+0303 EBEB        jmp   LOOP157
+L411:
+L155:
+0305 33C0        xor   rax,rax
+0307 C3          ret
+---{ *![int] int int *![int] -> int #1}---------------------------
 
 ---merge { *![int] int int int *![int] -> int #0}---------------------------
-               begin:rdx,middle:r8,end:r9,b:rcx,a:[stk#38]
-0011 ??        mov   xmm0 = rbx                     // def/loop #2
-0012 ??        mov   rbx = [rsp+0]                  // def/empty1 #0
-0013 ??        mov   r11 = rdx                      // use/self/phi #1
-0014 ??        mov   r10 = r8                       // use/self/use #1
-0015 ??        JMP   L101
+                 begin:rdx,middle:r8,end:r9,b:rcx,a:[rsp+40]
+0030 66480F6EC3  mov   xmm0 = rbx                     // def/loop #2
+0035 488B5C2428  mov   rbx = [rsp+40]                 // def/empty1 #0
+003A 4C8BDA      mov   r11 = rdx                      // use/self/phi #1
+003D 4D8BD0      mov   r10 = r8                       // use/self/use #1
 LOOP101:
-               i:r11,j:r10,k:rdx
-0016 ??        cmp   rdx, r9
-0017 ??        j>=   L99                            // L115
+                 i:r11,j:r10,k:rdx
+0040 493BD1      cmp   rdx, r9
+0043 7D52        j>=   L99                            // L115
 L115:
-0018 ??        cmp   r11, r8
-0019 ??        j<    L113                           // L143
+0045 4D3BD8      cmp   r11, r8
+0048 7C04        j<    L113                           // L143
 L143:
-001A ??        xor   rax,rax
-001B ??        jmp   L108
+004A 33C0        xor   rax,rax
+004C EB24        jmp   L108
 L417:
-001C ??        JMP   L108
 L113:
-001D ??        cmp   r9, r10
-001E ??        j<=   L144                           // L111
+004E 4D3BCA      cmp   r9, r10
+0051 7E1A        j<=   L144                           // L111
 L111:
-001F ??        mov   rax = rbx                      // use/empty1 #0
-0020 ??        ld8   rax,[rax+r10*8+8]
-0021 ??        cmp8  rax, [rbx+r11*8+8]
-0022 ??        j<=   L109                           // L145
+0053 488BC3      mov   rax = rbx                      // use/empty1 #0
+0056 4A8B44D008  ld8   rax,[rax+r10*8+8]
+005B 4A3944DB08  cmp8  rax, [rbx+r11*8+8]
+0060 7E04        j<=   L109                           // L145
 L145:
-0023 ??        xor   rax,rax
-0024 ??        jmp   L108
+0062 33C0        xor   rax,rax
+0064 EB0C        jmp   L108
 L416:
-0025 ??        JMP   L108
 L109:
-0026 ??        ldi   rax = #1
-0027 ??        jmp   L108
+0066 B801000000  ldi   rax = #1
+006B EB05        jmp   L108
 L415:
-0028 ??        JMP   L108
 L144:
-0029 ??        ldi   rax = #1
-002A ??        JMP   L108
+006D B801000000  ldi   rax = #1
 L108:
-               cond:rax
-002B ??        test  rax
-002C ??        j!=   L104                           // L141
+                 cond:rax
+0072 4883F800    test  rax
+0076 750B        j!=   L104                           // L141
 L141:
-002D ??        ld8   rax,[rbx+r10*8+8]
-002E ??        inc   r10 += #1
-002F ??        jmp   L103
+0078 4A8B44D308  ld8   rax,[rbx+r10*8+8]
+007D 4983C201    inc   r10 += #1
+0081 EB09        jmp   L103
 L414:
-0030 ??        JMP   L103
 L104:
-0031 ??        ld8   rax,[rbx+r11*8+8]
-0032 ??        inc   r11 += #1
-0033 ??        JMP   L103
+0083 4A8B44DB08  ld8   rax,[rbx+r11*8+8]
+0088 4983C301    inc   r11 += #1
 L103:
-               i:r11,j:r10,$3:rax
-0034 ??        st8   [rcx+rdx*8+8],rax
-0035 ??        inc   rdx += #1
-0036 ??        jmp   LOOP101
+                 i:r11,j:r10,$3:rax
+008C 488944D108  st8   [rcx+rdx*8+8],rax
+0091 4883C201    inc   rdx += #1
+0095 EBA9        jmp   LOOP101
 L413:
-0037 ??        JMP   L101
 L99:
-0038 ??        ALLME
-0039 ??        mov   rbx = xmm0                     // use/loop/use #2
-003A ??        xor   rax,rax
-003B ??        ret
+0097 66480F7EC3  mov   rbx = xmm0                     // use/loop/use #2
+009C 33C0        xor   rax,rax
+009E C3          ret
 ---{ *![int] int int int *![int] -> int #0}---------------------------
 
----merge_sort { *![int] *![int] int -> int #0}---------------------------
-               a:rcx,n:r8,b:rdx
-003C ??        mov   [rsp+24] = r8                  // def/loop #1
-003D ??        mov   [rsp+16] = rcx                 // def/loop #1
-003E ??        mov   [rsp+8] = rdx                  // def/loop #0
-003F ??        mov   r9 = [rsp+8]                   // use/loop/use #0
-0040 ??        mov   rcx = [rsp+16]                 // use/loop/use #1
-0041 ??        mov   r8 = [rsp+24]                  // use/loop/use #1
-0042 ??        xor   rdx,rdx
-0043 ??        call  copy_array  rcx  rdx  r8  r9
-0044 ??        mov   r9 = [rsp+8]                   // use/loop/use #0
-0045 ??        mov   rcx = [rsp+16]                 // use/loop/use #1
-0046 ??        mov   r8 = [rsp+24]                  // use/loop/use #1
-0047 ??        xor   rdx,rdx
-0048 ??        call  split_merge  rcx  rdx  r8  r9
-                 #2    rax
-0049 ??        addi  rsp += #40
-ret
----{ *![int] *![int] int -> int #0}---------------------------
 
----split_merge { *![int] int int *![int] -> int #0}---------------------------
-               a:r9,b:rcx,begin:rdx,end:r8
-004A ??        mov   [rsp+40] = rdx                 // def/loop #1
-004B ??        mov   [rsp+32] = r8                  // def/loop #0
-004C ??        mov   [rsp+24] = rcx                 // def/loop #0
-004D ??        mov   [rsp+16] = r9                  // def/loop #0
-004E ??        mov   r8 = [rsp+32]                  // use/loop/use #0
-004F ??        mov   r10 = [rsp+40]                 // use/loop/use #1
-0050 ??        sub   r8 -= r10
-0051 ??        cmp   r8, #1
-0052 ??        j<=   L65                            // L69
-L69:
-0053 ??        mov   rax = [rsp+32]                 // use/loop/use #0
-0054 ??        mov   rdx = [rsp+40]                 // use/loop/use #1
-0055 ??        add   rax += rdx
-0056 ??        ldi   rcx = #2
-0057 ??        div   rax = rax / rcx                // kill rdx
-0058 ??        mov   [rsp+8] = rax                  // def/loop #0
-0059 ??        mov   rcx = [rsp+16]                 // use/loop/use #0
-005A ??        mov   r9 = [rsp+24]                  // use/loop/use #0
-005B ??        mov   r8 = [rsp+8]                   // use/loop/use #0
-005C ??        mov   rdx = [rsp+40]                 // use/loop/use #1
-005D ??        call  split_merge  rcx  rdx  r8  r9
-005E ??        mov   rcx = [rsp+16]                 // use/loop/use #0
-005F ??        mov   r9 = [rsp+24]                  // use/loop/use #0
-0060 ??        mov   r8 = [rsp+32]                  // use/loop/use #0
-0061 ??        mov   rdx = [rsp+8]                  // use/loop/use #0
-0062 ??        call  split_merge  rcx  rdx  r8  r9
-0063 ??        mov   [rsp+32] = [rsp+16]            // use/loop/use #0
-0064 ??        mov   rcx = [rsp+24]                 // use/loop/use #0
-0065 ??        mov   r9 = [rsp+32]                  // use/loop/use #0
-0066 ??        mov   r8 = [rsp+8]                   // use/loop/use #0
-0067 ??        mov   rdx = [rsp+40]                 // use/loop/use #1
-0068 ??        call  merge  rcx  rdx  r8  r9  [stk#42]
-                 #2    rax
-0069 ??        jmp   L64
-L412:
-006A ??        JMP   L64
-L65:
-006B ??        xor   rax,rax
-006C ??        JMP   L64
-L64:
-               arg:rax
-006D ??        addi  rsp += #56
-ret
----{ *![int] int int *![int] -> int #0}---------------------------
+---eq { *![int] *![int] int -> int #1}---------------------------
+                 a:rcx,b:rdx,n:r8
+0000 33C0        xor   rax,rax
+LOOP178:
+                 i:rax
+0002 493BC0      cmp   rax, r8
+0005 7D16        j>=   L176                           // L186
+L186:
+0007 4C8B4CC208  ld8   r9,[rdx+rax*8+8]
+000C 4C394CC108  cmp8  r9, [rcx+rax*8+8]
+0011 7506        j!=   L198                           // L184
+L184:
+0013 4883C001    inc   rax += #1
+0017 EBE9        jmp   LOOP178
+L419:
+L198:
+0019 33C0        xor   rax,rax
+001B EB05        jmp   L175
+L418:
+L176:
+001D B801000000  ldi   rax = #1
+L175:
+                 result:rax
+0022 C3          ret
+---{ *![int] *![int] int -> int #1}---------------------------
 
 ---main { -> int #0}---------------------------
-
-006E ??        mov   [rsp+0] = rbx                  // def/loop #2
-006F ??        ldi   rdx = #88
-0070 ??        alloc ldi   rcx = #1
-call  #calloc
-                 [int] rax
-0071 ??        mov   [rsp+32] = rax                 // def/loop #0
-0072 ??        mov   rdx = [rsp+32]                 // use/loop/use #0
-0073 ??        st8   [rdx+8],#10
-0074 ??        mov   rcx = [rsp+32]                 // use/loop/use #0
-0075 ??        st8   [rcx+16],#9
-0076 ??        mov   rax = [rsp+32]                 // use/loop/use #0
-0077 ??        st8   [rax+24],#8
-0078 ??        mov   r11 = [rsp+32]                 // use/loop/use #0
-0079 ??        st8   [r11+32],#7
-007A ??        mov   r10 = [rsp+32]                 // use/loop/use #0
-007B ??        st8   [r10+40],#6
-007C ??        mov   r9 = [rsp+32]                  // use/loop/use #0
-007D ??        st8   [r9+48],#5
-007E ??        mov   r8 = [rsp+32]                  // use/loop/use #0
-007F ??        st8   [r8+56],#4
-0080 ??        mov   rdx = [rsp+32]                 // use/loop/use #0
-0081 ??        st8   [rdx+64],#3
-0082 ??        mov   rcx = [rsp+32]                 // use/loop/use #0
-0083 ??        st8   [rcx+72],#2
-0084 ??        mov   rax = [rsp+32]                 // use/loop/use #0
-0085 ??        st8   [rax+80],#1
-0086 ??        ldi   rdx = #88
-0087 ??        alloc ldi   rcx = #1
-call  #calloc
-                 [int] rax
-0088 ??        mov   [rsp+24] = rax                 // def/empty1 #1
-0089 ??        ldi   rdx = #88
-008A ??        alloc ldi   rcx = #1
-call  #calloc
-                 [int] rax
-008B ??        mov   rbx = rax                      // def/empty1 #0
-008C ??        st8   [rbx+8],#1
-008D ??        st8   [rbx+16],#2
-008E ??        st8   [rbx+24],#3
-008F ??        st8   [rbx+32],#4
-0090 ??        st8   [rbx+40],#5
-0091 ??        st8   [rbx+48],#6
-0092 ??        st8   [rbx+56],#7
-0093 ??        st8   [rbx+64],#8
-0094 ??        st8   [rbx+72],#9
-0095 ??        st8   [rbx+80],#10
-0096 ??        ALLME
-0097 ??        mov   rcx = [rsp+32]                 // use/loop/use #0
-0098 ??        mov   rdx = [rsp+24]                 // use/empty1 #0
-0099 ??        ldi   r8 = #10
-009A ??        call  merge_sort  rcx  rdx  r8
-009B ??        mov   rcx = [rsp+32]                 // use/loop/use #0
-009C ??        mov   rdx = rbx                      // use/empty1 #0
-009D ??        ldi   r8 = #10
-009E ??        call  eq  rcx  rdx  r8
-                 #2    rax
-009F ??        mov   rbx = [rsp+0]                  // use/loop/use #2
-00A0 ??        addi  rsp += #40
-ret
+01A0 4883EC28    subi  rsp -= #40
+01A4 48895C2420  mov   [rsp+32] = rbx                 // def/loop #2
+01A9 BA58000000  ldi   rdx = #88
+01AE B901000000  alloc ldi   rcx = #1
+01B3 E800000000  call  #calloc
+01B8 4889442418  mov   [rsp+24] = rax                 // def/loop #0
+01BD 488B542418  mov   rdx = [rsp+24]                 // use/loop/use #0
+01C2 48C742080A  st8   [rdx+8],#10
+01C7 000000
+01CA 488B4C2418  mov   rcx = [rsp+24]                 // use/loop/use #0
+01CF 48C7411009  st8   [rcx+16],#9
+01D4 000000
+01D7 488B442418  mov   rax = [rsp+24]                 // use/loop/use #0
+01DC 48C7401808  st8   [rax+24],#8
+01E1 000000
+01E4 4C8B5C2418  mov   r11 = [rsp+24]                 // use/loop/use #0
+01E9 49C7432007  st8   [r11+32],#7
+01EE 000000
+01F1 4C8B542418  mov   r10 = [rsp+24]                 // use/loop/use #0
+01F6 49C7422806  st8   [r10+40],#6
+01FB 000000
+01FE 4C8B4C2418  mov   r9 = [rsp+24]                  // use/loop/use #0
+0203 49C7413005  st8   [r9+48],#5
+0208 000000
+020B 4C8B442418  mov   r8 = [rsp+24]                  // use/loop/use #0
+0210 49C7403804  st8   [r8+56],#4
+0215 000000
+0218 488B542418  mov   rdx = [rsp+24]                 // use/loop/use #0
+021D 48C7424003  st8   [rdx+64],#3
+0222 000000
+0225 488B4C2418  mov   rcx = [rsp+24]                 // use/loop/use #0
+022A 48C7414802  st8   [rcx+72],#2
+022F 000000
+0232 488B442418  mov   rax = [rsp+24]                 // use/loop/use #0
+0237 48C7405001  st8   [rax+80],#1
+023C 000000
+023F BA58000000  ldi   rdx = #88
+0244 B901000000  alloc ldi   rcx = #1
+0249 E800000000  call  #calloc
+024E 4889442410  mov   [rsp+16] = rax                 // def/empty1 #1
+0253 BA58000000  ldi   rdx = #88
+0258 B901000000  alloc ldi   rcx = #1
+025D E800000000  call  #calloc
+0262 488BD8      mov   rbx = rax                      // def/empty1 #0
+0265 48C7430801  st8   [rbx+8],#1
+026A 000000
+026D 48C7431002  st8   [rbx+16],#2
+0272 000000
+0275 48C7431803  st8   [rbx+24],#3
+027A 000000
+027D 48C7432004  st8   [rbx+32],#4
+0282 000000
+0285 48C7432805  st8   [rbx+40],#5
+028A 000000
+028D 48C7433006  st8   [rbx+48],#6
+0292 000000
+0295 48C7433807  st8   [rbx+56],#7
+029A 000000
+029D 48C7434008  st8   [rbx+64],#8
+02A2 000000
+02A5 48C7434809  st8   [rbx+72],#9
+02AA 000000
+02AD 48C743500A  st8   [rbx+80],#10
+02B2 000000
+02B5 488B4C2418  mov   rcx = [rsp+24]                 // use/loop/use #0
+02BA 488B542410  mov   rdx = [rsp+16]                 // use/empty1 #0
+02BF 41B80A0000  ldi   r8 = #10
+02C4 00
+02C5 E8D6FDFFFF  call  merge_sort  rcx  rdx  r8
+02CA 488B4C2418  mov   rcx = [rsp+24]                 // use/loop/use #0
+02CF 488BD3      mov   rdx = rbx                      // use/empty1 #0
+02D2 41B80A0000  ldi   r8 = #10
+02D7 00
+02D8 E823FDFFFF  call  eq  rcx  rdx  r8
+02DD 488B5C2420  mov   rbx = [rsp+32]                 // use/loop/use #2
+02E2 4883C428C3  addi  rsp += #40
+02E7             ret
 ---{ -> int #0}---------------------------
 
----copy_array { *![int] int int *![int] -> int #1}---------------------------
-               begin:rdx,end:r8,b:r9,a:rcx
-00A1 ??        JMP   L157
-LOOP157:
-               k:rdx
-00A2 ??        cmp   rdx, r8
-00A3 ??        j>=   L155                           // L159
-L159:
-00A4 ??        ld8   rax,[rcx+rdx*8+8]
-00A5 ??        st8   [r9+rdx*8+8],rax
-00A6 ??        inc   rdx += #1
-00A7 ??        jmp   LOOP157
-L411:
-00A8 ??        JMP   L157
-L155:
-00A9 ??        ALLME
-00AA ??        xor   rax,rax
-00AB ??        ret
----{ *![int] int int *![int] -> int #1}---------------------------
+---merge_sort { *![int] *![int] int -> int #0}---------------------------
+00A0 4883EC28    subi  rsp -= #40
+                 a:rcx,n:r8,b:rdx
+00A4 4C89442440  mov   [rsp+64] = r8                  // def/loop #1
+00A9 48894C2438  mov   [rsp+56] = rcx                 // def/loop #1
+00AE 4889542430  mov   [rsp+48] = rdx                 // def/loop #0
+00B3 4C8B4C2430  mov   r9 = [rsp+48]                  // use/loop/use #0
+00B8 488B4C2438  mov   rcx = [rsp+56]                 // use/loop/use #1
+00BD 4C8B442440  mov   r8 = [rsp+64]                  // use/loop/use #1
+00C2 33D2        xor   rdx,rdx
+00C4 E827020000  call  copy_array  rcx  rdx  r8  r9
+00C9 4C8B4C2430  mov   r9 = [rsp+48]                  // use/loop/use #0
+00CE 488B4C2438  mov   rcx = [rsp+56]                 // use/loop/use #1
+00D3 4C8B442440  mov   r8 = [rsp+64]                  // use/loop/use #1
+00D8 33D2        xor   rdx,rdx
+00DA E811000000  call  split_merge  rcx  rdx  r8  r9
+00DF 4883C428C3  addi  rsp += #40
+00E4             ret
+---{ *![int] *![int] int -> int #0}---------------------------
+
+
diff --git a/seaofnodes/src/test/cases/mergsort/sort_smp.out b/seaofnodes/src/test/cases/mergsort/sort_smp.out
index e5edda1..c06e3ab 100644
--- a/seaofnodes/src/test/cases/mergsort/sort_smp.out
+++ b/seaofnodes/src/test/cases/mergsort/sort_smp.out
@@ -1,473 +1,3 @@
-START:                            [[   ]]
-  10 Start   ____ ____ ____       [[    13   61   64   86   58    9  190  121   70   93  ]]  [  Ctrl, #TOP, int]
-
-L9:                               [[  START      ]]
-   9 main    ____   10            [[    12  212  325  324  323  322  321  320  319  318  317  316  315  314  313  312  311  310  309  308  416  408   23  355  358   34  359   33  360   32  361   31  362   30  363   29  364   28  365   27  366   26  357   21  367   25  407   20  411   18  406   16  371   48   47   46   45   44   43   42   41   40   14   39   11  368  370  410    8  ]]  Ctrl
-  12 $mem       9   13            [[    11   23   23  ]]  #BOT
- 212 $rpc       9   86            [[     2       ]]  $[ALL]
- 358 mov        9  355            [[    34       ]]
-  34 st8        9   35  358 ____ ____  [[    33  ]]  #3:int
- 359 mov        9  355            [[    33       ]]
-  33 st8        9   34  359 ____ ____  [[    32  ]]  #3:int
- 360 mov        9  355            [[    32       ]]
-  32 st8        9   33  360 ____ ____  [[    31  ]]  #3:int
- 361 mov        9  355            [[    31       ]]
-  48 st8        9   49  371 ____ ____  [[    47  ]]  #3:int
-  31 st8        9   32  361 ____ ____  [[    30  ]]  #3:int
- 362 mov        9  355            [[    30       ]]
-  47 st8        9   48  371 ____ ____  [[    46  ]]  #3:int
-  30 st8        9   31  362 ____ ____  [[    29  ]]  #3:int
-  46 st8        9   47  371 ____ ____  [[    45  ]]  #3:int
- 363 mov        9  355            [[    29       ]]
-  45 st8        9   46  371 ____ ____  [[    44  ]]  #3:int
-  29 st8        9   30  363 ____ ____  [[    28  ]]  #3:int
- 364 mov        9  355            [[    28       ]]
-  44 st8        9   45  371 ____ ____  [[    43  ]]  #3:int
-  28 st8        9   29  364 ____ ____  [[    27  ]]  #3:int
- 365 mov        9  355            [[    27       ]]
-  43 st8        9   44  371 ____ ____  [[    42  ]]  #3:int
-  27 st8        9   28  365 ____ ____  [[    26  ]]  #3:int
- 366 mov        9  355            [[    26       ]]
-  42 st8        9   43  371 ____ ____  [[    41  ]]  #3:int
- 367 mov        9  355            [[    25       ]]
- 357 mov        9  355            [[    21       ]]
-  26 st8        9   27  366 ____ ____  [[    25  ]]  #3:int
-  41 st8        9   42  371 ____ ____  [[    40  ]]  #3:int
-  25 st8        9   26  367 ____ ____  [[    20  ]]  #3:int
- 407 #88        9                 [[    20       ]]  88
-  21 st4        9   22  357 ____ ____  [[    20  ]]  #2:u32
-  40 st8        9   41  371 ____ ____  [[    39  ]]  #3:int
-  20 new_ary    9  407   21   25  [[    19   36   37  ]]  [  Ctrl, *![int], #2:u32, #3:int]
-  19 $2        20                 [[    18       ]]  #2:u32
-  36 [int]     20                 [[   411   18  ]]  *[int]
-  37 $3        20                 [[    16       ]]  #3:int
- 408 #88        9                 [[    23       ]]  88
-  39 st8        9   40  371 ____ ____  [[    11  ]]  #3:int
-  18 st4        9   19   36 ____ ____  [[    16  ]]  #2:u32
- 411 mov        9   36            [[   370       ]]
- 406 #88        9                 [[    16       ]]  88
-  14 st4        9   15  371 ____ ____  [[    11  ]]  #2:u32
- 410 #10        9                 [[     8       ]]  10
-  16 new_ary    9  406   18   37  [[    15   38   49  ]]  [  Ctrl, *![int], #2:u32, #3:int]
-  15 $2        16                 [[    14       ]]  #2:u32
-  38 [int]     16                 [[   371       ]]  *[int]
-  49 $3        16                 [[    48       ]]  #3:int
-  11 ALLMEM     9   12   14   39  [[     8       ]]  #BOT
- 368 mov        9  355            [[     8       ]]
- 370 mov        9  411            [[     8       ]]
-  23 new_ary    9  408   12   12  [[    22   24   35  ]]  [  Ctrl, *![int], #2:u32, #3:int]
-  22 $2        23                 [[    21       ]]  #2:u32
-  24 [int]     23                 [[   355       ]]  *[int]
-  35 $3        23                 [[    34       ]]  #3:int
-   8 call       9   11  368  370  410  [[     7  ]]  Ctrl
- 371 mov        9   38            [[   372   39   40   41   42   43   44   45   46   47   48   14  ]]
- 355 mov        9   24            [[   356  368  367  366  365  364  363  362  361  360  359  358  357  ]]
- 308 rbx        9                 [[   416       ]]
- 416 mov        9  308            [[   417       ]]
- 310 rsi        9                 [[     2       ]]
- 311 rdi        9                 [[     2       ]]
- 312 r12        9                 [[     2       ]]
- 313 r13        9                 [[     2       ]]
- 314 r14        9                 [[     2       ]]
- 315 r15        9                 [[     2       ]]
- 316 xmm6       9                 [[     2       ]]
- 317 xmm7       9                 [[     2       ]]
- 318 xmm8       9                 [[     2       ]]
- 319 xmm9       9                 [[     2       ]]
- 320 xmm10      9                 [[     2       ]]
- 321 xmm11      9                 [[     2       ]]
- 322 xmm12      9                 [[     2       ]]
- 323 xmm13      9                 [[     2       ]]
- 324 xmm14      9                 [[     2       ]]
- 325 xmm15      9                 [[     2       ]]
- 309 rbp        9                 [[     2       ]]
-
-L70:                              [[  START      ]]
-  70 copy_ar ____   10            [[    75   77   79   82   84   85  289  288  287  286  285  284  283  282  281  280  279  278  277  276  275  274  273  272   69  ]]  Ctrl
-  75 begin     70   64            [[    74       ]]  int
-  77 end       70   64            [[    72       ]]  int
-  79 $mem      70   13            [[    78   80  ]]  #BOT
-  82 b         70   61            [[    81       ]]  *[int]
-  84 a         70   61            [[    83       ]]  *[int]
-  85 $rpc      70   86            [[    66       ]]  $[ALL]
- 272 rbx       70                 [[    66       ]]
- 278 r14       70                 [[    66       ]]
- 279 r15       70                 [[    66       ]]
- 280 xmm6      70                 [[    66       ]]
- 281 xmm7      70                 [[    66       ]]
- 282 xmm8      70                 [[    66       ]]
- 283 xmm9      70                 [[    66       ]]
- 284 xmm10     70                 [[    66       ]]
- 285 xmm11     70                 [[    66       ]]
- 286 xmm12     70                 [[    66       ]]
- 287 xmm13     70                 [[    66       ]]
- 288 xmm14     70                 [[    66       ]]
- 289 xmm15     70                 [[    66       ]]
- 277 r13       70                 [[    66       ]]
- 276 r12       70                 [[    66       ]]
- 275 rdi       70                 [[    66       ]]
- 274 rsi       70                 [[    66       ]]
- 273 rbp       70                 [[    66       ]]
-
-L121:                             [[  START      ]]
- 121 merge   ____   10            [[   138  141  144  151  154  158  173  235  234  233  232  231  230  229  228  227  226  225  224  223  222  221  220  219  218  413  326  376  381  120  ]]  Ctrl
- 138 begin    121   64            [[   376  155  ]]  int
- 141 middle   121   64            [[   135  381  ]]  int
- 144 end      121   64            [[   142  170  ]]  int
- 151 $mem     121   13            [[   150  172  ]]  #BOT
- 154 b        121   61            [[   153  159  ]]  *[int]
- 158 a        121   61            [[   326       ]]  *[int]
- 173 $rpc     121   86            [[   117       ]]  $[ALL]
- 381 mov      121  141            [[   145       ]]
- 376 mov      121  138            [[   137       ]]
- 326 mov      121  158            [[   327  148  161  157  ]]
- 218 rbx      121                 [[   413       ]]
- 413 mov      121  218            [[   414       ]]
- 221 rdi      121                 [[   117       ]]
- 226 xmm6     121                 [[   117       ]]
- 227 xmm7     121                 [[   117       ]]
- 228 xmm8     121                 [[   117       ]]
- 229 xmm9     121                 [[   117       ]]
- 230 xmm10    121                 [[   117       ]]
- 231 xmm11    121                 [[   117       ]]
- 232 xmm12    121                 [[   117       ]]
- 233 xmm13    121                 [[   117       ]]
- 234 xmm14    121                 [[   117       ]]
- 235 xmm15    121                 [[   117       ]]
- 220 rsi      121                 [[   117       ]]
- 219 rbp      121                 [[   117       ]]
- 224 r14      121                 [[   117       ]]
- 225 r15      121                 [[   117       ]]
- 223 r13      121                 [[   117       ]]
- 222 r12      121                 [[   117       ]]
-
-L190:                             [[  START      ]]
- 190 eq      ____   10            [[   196  197  201  204  208  271  270  269  268  267  266  265  264  263  262  261  260  259  258  257  256  255  254  398  189  ]]  Ctrl
- 196 $mem     190   13            [[   194  200  206  206  ]]  #BOT
- 197 a        190   61            [[   194       ]]  *[int]
- 201 b        190   61            [[   200       ]]  *[int]
- 204 n        190   64            [[   202       ]]  int
- 208 $rpc     190   86            [[   185       ]]  $[ALL]
- 398 #0       190                 [[   198       ]]  0
- 258 r12      190                 [[   185       ]]
- 259 r13      190                 [[   185       ]]
- 260 r14      190                 [[   185       ]]
- 261 r15      190                 [[   185       ]]
- 262 xmm6     190                 [[   185       ]]
- 263 xmm7     190                 [[   185       ]]
- 264 xmm8     190                 [[   185       ]]
- 265 xmm9     190                 [[   185       ]]
- 266 xmm10    190                 [[   185       ]]
- 267 xmm11    190                 [[   185       ]]
- 268 xmm12    190                 [[   185       ]]
- 269 xmm13    190                 [[   185       ]]
- 270 xmm14    190                 [[   185       ]]
- 271 xmm15    190                 [[   185       ]]
- 257 rdi      190                 [[   185       ]]
- 256 rsi      190                 [[   185       ]]
- 255 rbp      190                 [[   185       ]]
- 254 rbx      190                 [[   185       ]]
-
-L58:                              [[  START      ]]
-  58 merge_s ____   10            [[    59   60   63   65  182  307  306  305  304  303  302  301  300  299  298  297  296  295  294  293  292  291  290  403  400  349  351  353  402  405   57  ]]  Ctrl
-  59 $mem      58   13            [[    57       ]]  #BOT
-  60 a         58   61            [[   400       ]]  *[int]
-  63 n         58   64            [[   403       ]]  int
-  65 b         58   61            [[   349       ]]  *[int]
- 182 $rpc      58   86            [[    51       ]]  $[ALL]
- 405 mov       58  403            [[    57       ]]
- 402 mov       58  400            [[    57       ]]
- 353 #0        58                 [[    57       ]]  0
- 351 mov       58  349            [[    57       ]]
-  57 call      58   59  402  353  405  351  [[    56  ]]  Ctrl
- 349 mov       58   65            [[   350  351  ]]
- 400 mov       58   60            [[   401  402  ]]
- 403 mov       58   63            [[   404  405  ]]
- 291 rbp       58                 [[    51       ]]
- 295 r13       58                 [[    51       ]]
- 296 r14       58                 [[    51       ]]
- 297 r15       58                 [[    51       ]]
- 298 xmm6      58                 [[    51       ]]
- 299 xmm7      58                 [[    51       ]]
- 300 xmm8      58                 [[    51       ]]
- 301 xmm9      58                 [[    51       ]]
- 302 xmm10     58                 [[    51       ]]
- 303 xmm11     58                 [[    51       ]]
- 304 xmm12     58                 [[    51       ]]
- 305 xmm13     58                 [[    51       ]]
- 306 xmm14     58                 [[    51       ]]
- 307 xmm15     58                 [[    51       ]]
- 290 rbx       58                 [[    51       ]]
- 294 r12       58                 [[    51       ]]
- 293 rdi       58                 [[    51       ]]
- 292 rsi       58                 [[    51       ]]
-
-L93:                              [[  START      ]]
-  93 split_m ____   10            [[    99  101  102  103  106  177  253  252  251  250  249  248  247  246  245  244  243  242  241  240  239  238  237  236  391  336  332  328  342  395  110  108   92  ]]  Ctrl
-  99 $mem      93   13            [[    97  175  ]]  #BOT
- 101 a         93   61            [[   328       ]]  *[int]
- 102 b         93   61            [[   332       ]]  *[int]
- 103 begin     93   64            [[   391       ]]  int
- 106 end       93   64            [[   336       ]]  int
- 177 $rpc      93   86            [[    89       ]]  $[ALL]
- 395 mov       93  391            [[   110       ]]
- 332 mov       93  102            [[   335  333  334  ]]
- 336 mov       93  106            [[   342  340  337  339  ]]
- 391 mov       93  103            [[   395  392  394  393  ]]
- 342 mov       93  336            [[   110       ]]
- 328 mov       93  101            [[   329  331  330  ]]
- 110 sub       93  342  395       [[   108       ]]  int
- 108 cmp       93  110            [[    92       ]]  bool
-  92 j<=       93  108            [[    91   98  ]]  [  Ctrl, Ctrl]
- 241 r13       93                 [[    89       ]]
- 242 r14       93                 [[    89       ]]
- 243 r15       93                 [[    89       ]]
- 244 xmm6      93                 [[    89       ]]
- 245 xmm7      93                 [[    89       ]]
- 246 xmm8      93                 [[    89       ]]
- 247 xmm9      93                 [[    89       ]]
- 248 xmm10     93                 [[    89       ]]
- 249 xmm11     93                 [[    89       ]]
- 250 xmm12     93                 [[    89       ]]
- 251 xmm13     93                 [[    89       ]]
- 252 xmm14     93                 [[    89       ]]
- 253 xmm15     93                 [[    89       ]]
- 238 rsi       93                 [[    89       ]]
- 237 rbp       93                 [[    89       ]]
- 236 rbx       93                 [[    89       ]]
- 239 rdi       93                 [[    89       ]]
- 240 r12       93                 [[    89       ]]
-
-LOOP120:                          [[  L121      L122       ]]
- 120 Loop    ____  121  420       [[   137  145  150  155  170  119  ]]  Ctrl
- 137 Phi_i    120  376  139       [[   148  135  140  139  157  ]]  int
- 145 Phi_j    120  381  146       [[   162  142  146  147  161  ]]  int
- 150 Phi_$3   120  151  152       [[   148  153  157  159  161  162  172  ]]  #BOT
- 155 Phi_k    120  138  156       [[   170  153  156  159  ]]  int
- 170 cmp      120  155  144       [[   119       ]]  bool
- 119 j>=      120  170            [[   118  134  ]]  [  Ctrl, Ctrl]
-
-LOOP189:                          [[  L190      L191       ]]
- 189 Loop    ____  190  419       [[   198  202  188  ]]  Ctrl
- 198 Phi_i    189  398  199       [[   202  194  199  200  ]]  int
- 202 cmp      189  198  204       [[   188       ]]  bool
- 188 j>=      189  202            [[   187  193  ]]  [  Ctrl, Ctrl]
-
-LOOP69:                           [[  L70       L71        ]]
-  69 Loop    ____   70  425       [[    74   80   72   68  ]]  Ctrl
-  74 Phi_k     69   75   76       [[    72   76   81   83  ]]  int
-  80 Phi_$3    69   79   81       [[    78   81   83  ]]  #BOT
-  72 cmp       69   74   77       [[    68       ]]  bool
-  68 j>=       69   72            [[    67   71  ]]  [  Ctrl, Ctrl]
-
-L7:                               [[  L9         ]]
-   7 CallEnd    8                 [[     6  184  ]]  [  Ctrl, #BOT, 0]
- 184 $mem       7                 [[     5       ]]  #BOT
-
-L98:                              [[  L93        ]]
-  98 False     92                 [[   339  394  105  107  104  345  330  335  348  393   97  ]]  Ctrl
- 330 mov       98  328            [[    97       ]]
- 335 mov       98  332            [[    97       ]]
- 393 mov       98  391            [[    97       ]]
- 348 mov       98  345            [[    97       ]]
-  97 call      98   99  330  393  348  335  [[    96  ]]  Ctrl
- 339 mov       98  336            [[   105       ]]
- 394 mov       98  391            [[   105       ]]
- 105 add       98  339  394       [[   104       ]]  int
- 107 #2        98                 [[   104       ]]  2
- 104 div       98  105  107       [[   345       ]]  int
- 345 mov       98  104            [[   348  347  346  ]]
-
-L56:                              [[  L58        ]]
-  56 CallEnd   57                 [[    55   88  ]]  [  Ctrl, #BOT, 0]
-  88 $mem      56                 [[    54       ]]  #BOT
-
-L91:                              [[  L93        ]]
-  91 True      92                 [[    90       ]]  Ctrl
-
-L6:                               [[  L7         ]]
-   6 $ctrl      7                 [[   356  372  409    5  ]]  Ctrl
- 356 mov        6  355            [[     5       ]]
- 372 mov        6  371            [[     5       ]]
- 409 #10        6                 [[     5       ]]  10
-   5 call       6  184  356  372  409  [[     4  ]]  Ctrl
-
-L55:                              [[  L56        ]]
-  55 $ctrl     56                 [[   350  354  401  404   54  ]]  Ctrl
- 350 mov       55  349            [[    54       ]]
- 354 #0        55                 [[    54       ]]  0
- 404 mov       55  403            [[    54       ]]
- 401 mov       55  400            [[    54       ]]
-  54 call      55   88  401  354  404  350  [[    53  ]]  Ctrl
-
-L118:                             [[  LOOP120    ]]
- 118 True     119                 [[   172  414  415  117  ]]  Ctrl
- 172 ALLMEM   118  151 ____  150  [[   117       ]]  #BOT
- 414 mov      118  413            [[   117       ]]
- 415 #0       118                 [[   117       ]]  0
- 117 Return   118  172  415  173  414  219  220  221  222  223  224  225  226  227  228  229  230  231  232  233  234  235  [[     1  ]]  [  Ctrl, #BOT, 0]
-
-L134:                             [[  LOOP120    ]]
- 134 False    119                 [[   135  133  ]]  Ctrl
- 135 cmp      134  137  141       [[   133       ]]  bool
- 133 j<       134  135            [[   132  163  ]]  [  Ctrl, Ctrl]
-
-L187:                             [[  LOOP189    ]]
- 187 True     188                 [[   169  186  ]]  Ctrl
- 169 #1       187                 [[   207       ]]  1
-
-L193:                             [[  LOOP189    ]]
- 193 False    188                 [[   200  194  192  ]]  Ctrl
- 200 ld8      193  196  201  198  [[   194       ]]  int
- 194 cmp8     193  196  197  198  200  [[   192  ]]  bool
- 192 j!=      193  194            [[   191  205  ]]  [  Ctrl, Ctrl]
-
-L67:                              [[  LOOP69     ]]
-  67 True      68                 [[    78   62   66  ]]  Ctrl
-  78 ALLMEM    67   79 ____   80  [[    66       ]]  #BOT
-  62 #0        67                 [[    66       ]]  0
-  66 Return    67   78   62   85  272  273  274  275  276  277  278  279  280  281  282  283  284  285  286  287  288  289  [[     1  ]]  [  Ctrl, #BOT, 0]
-
-L71:                              [[  LOOP69     ]]
-  71 False     68                 [[    83   81   76  425  ]]  Ctrl
-  76 inc       71   74            [[    74       ]]  int
-  83 ld8       71   80   84   74  [[    81       ]]  int
-  81 st8       71   80   82   74   83  [[    80  ]]  #3:Bot
-
-L96:                              [[  L98        ]]
-  96 CallEnd   97                 [[    95  100  ]]  [  Ctrl, #BOT, 0]
- 100 $mem      96                 [[    94       ]]  #BOT
-
-L4:                               [[  L6         ]]
-   4 CallEnd    5                 [[     3  210  211  ]]  [  Ctrl, #BOT, bool]
- 210 $mem       4                 [[     2       ]]  #BOT
- 211 #2         4                 [[     2       ]]  bool
-
-L95:                              [[  L96        ]]
-  95 $ctrl     96                 [[   331  334  340  347   94  ]]  Ctrl
- 331 mov       95  328            [[    94       ]]
- 334 mov       95  332            [[    94       ]]
- 347 mov       95  345            [[    94       ]]
- 340 mov       95  336            [[    94       ]]
-  94 call      95  100  331  347  340  334  [[   115  ]]  Ctrl
-
-L132:                             [[  L134       ]]
- 132 True     133                 [[   142  131  ]]  Ctrl
- 142 cmp      132  144  145       [[   131       ]]  bool
- 131 j<=      132  142            [[   130  164  ]]  [  Ctrl, Ctrl]
-
-L53:                              [[  L55        ]]
-  53 CallEnd   54                 [[    52  181  ]]  [  Ctrl, #BOT, 0]
- 181 $mem      53                 [[    51       ]]  #BOT
-
-L163:                             [[  L134       ]]
- 163 False    133                 [[   389  424  ]]  Ctrl
- 389 #0       163                 [[   168       ]]  0
- 424 jmp      163                 [[   127       ]]
-
-L191:                             [[  L193       ]]
- 191 False    192                 [[   199  419  ]]  Ctrl
- 199 inc      191  198            [[   198       ]]  int
-
-L205:                             [[  L193       ]]
- 205 True     192                 [[   399  418  ]]  Ctrl
- 399 #0       205                 [[   207       ]]  0
- 418 jmp      205                 [[   186       ]]
-
-L3:                               [[  L4         ]]
-   3 $ctrl      4                 [[   417    2  ]]  Ctrl
- 417 mov        3  416            [[     2       ]]
-   2 Return     3  210  211  212  417  309  310  311  312  313  314  315  316  317  318  319  320  321  322  323  324  325  [[     1  ]]  [  Ctrl, #BOT, bool]
-
-L186:                             [[  L187      L205       ]]
- 186 Region  ____  187  418       [[   207  206  185  ]]  Ctrl
- 207 Phi_res  186  169  399       [[   185       ]]  bool
- 206 ALLMEM   186  196 ____  196  [[   185       ]]  #BOT
- 185 Return   186  206  207  208  254  255  256  257  258  259  260  261  262  263  264  265  266  267  268  269  270  271  [[     1  ]]  [  Ctrl, #BOT, bool]
-
-L52:                              [[  L53        ]]
-  52 $ctrl     53                 [[   352   51  ]]  Ctrl
- 352 #0        52                 [[    51       ]]  0
-  51 Return    52  181  352  182  290  291  292  293  294  295  296  297  298  299  300  301  302  303  304  305  306  307  [[     1  ]]  [  Ctrl, #BOT, 0]
-
-L115:                             [[  L95        ]]
- 115 CallEnd   94                 [[   114  116  ]]  [  Ctrl, #BOT, 0]
- 116 $mem     115                 [[   113       ]]  #BOT
-
-L130:                             [[  L132       ]]
- 130 False    131                 [[   327  162  148  129  ]]  Ctrl
- 327 mov      130  326            [[   162       ]]
- 162 ld8      130  150  327  145  [[   148       ]]  int
- 148 cmp8     130  150  326  137  162  [[   129  ]]  bool
- 129 j<=      130  148            [[   128  165  ]]  [  Ctrl, Ctrl]
-
-L164:                             [[  L132       ]]
- 164 True     131                 [[   388  127  ]]  Ctrl
- 388 #1       164                 [[   168       ]]  1
-
-L114:                             [[  L115       ]]
- 114 $ctrl    115                 [[   329  333  337  346  392  113  ]]  Ctrl
- 329 mov      114  328            [[   113       ]]
- 333 mov      114  332            [[   113       ]]
- 392 mov      114  391            [[   113       ]]
- 346 mov      114  345            [[   113       ]]
- 337 mov      114  336            [[   113       ]]
- 113 call     114  116  333  392  346  337  329  [[   112  ]]  Ctrl
-
-L128:                             [[  L130       ]]
- 128 True     129                 [[   387  422  ]]  Ctrl
- 387 #1       128                 [[   168       ]]  1
- 422 jmp      128                 [[   127       ]]
-
-L165:                             [[  L130       ]]
- 165 False    129                 [[   390  423  ]]  Ctrl
- 390 #0       165                 [[   168       ]]  0
- 423 jmp      165                 [[   127       ]]
-
-L112:                             [[  L114       ]]
- 112 CallEnd  113                 [[   111  176  ]]  [  Ctrl, #BOT, 0]
- 176 $mem     112                 [[   175       ]]  #BOT
-
-L127:                             [[  L128      L163      L164      L165       ]]
- 127 Region  ____  422  424  164  423  [[   168  166  126  ]]  Ctrl
- 168 Phi_con  127  387  389  388  390  [[   166  ]]  bool
- 166 test     127  168            [[   126       ]]
- 126 j!=      127  166            [[   123  160  ]]  [  Ctrl, Ctrl]
-
-L111:                             [[  L112       ]]
- 111 $ctrl    112                 [[    90       ]]  Ctrl
-
-L90:                              [[  L91       L111       ]]
-  90 Region  ____   91  111       [[   175  215   89  ]]  Ctrl
- 175 Phi_$me   90   99  176       [[    89       ]]  #BOT
- 215 #0        90                 [[    89       ]]  0
-  89 Return    90  175  215  177  236  237  238  239  240  241  242  243  244  245  246  247  248  249  250  251  252  253  [[     1  ]]  [  Ctrl, #BOT, 0]
-
-L160:                             [[  L127       ]]
- 160 False    126                 [[   161  159  147  421  ]]  Ctrl
- 147 inc      160  145            [[   146       ]]  int
- 161 ld8      160  150  326  145  [[   159       ]]  int
- 421 jmp      160                 [[   122       ]]
- 159 st8      160  150  154  155  161  [[   152  ]]  #3:Bot
-
-L123:                             [[  L127       ]]
- 123 True     126                 [[   157  153  140  122  ]]  Ctrl
- 140 inc      123  137            [[   139       ]]  int
- 157 ld8      123  150  326  137  [[   153       ]]  int
- 153 st8      123  150  154  155  157  [[   152  ]]  #3:Bot
-
-L122:                             [[  L123      L160       ]]
- 122 Region  ____  123  421       [[   139  146  152  156  420  ]]  Ctrl
- 139 Phi_i    122  140  137       [[   137       ]]  int
- 146 Phi_j    122  145  147       [[   145       ]]  int
- 152 Phi_$3   122  153  159       [[   150       ]]  #3:Bot
- 156 inc      122  155            [[   155       ]]  int
-
-L1:                               [[  L118      L67       L186       ]]
-   1 Stop       2   51   89  117   66  185  [[   ]]  Bot
-
-
-
 ---split_merge { *![int] int int *![int] -> 0 #0}---------------------------
 0000 4883EC38    subi  rsp -= #56
                  a:r9,b:rcx,begin:rdx,end:r8