[svn] / ecrypt / trunk / submissions / salsa20 / reduced / 12-rounds / amd64-2 / salsa20.s  

svn: ecrypt/trunk/submissions/salsa20/reduced/12-rounds/amd64-2/salsa20.s

Diff for /ecrypt/trunk/submissions/salsa20/reduced/12-rounds/amd64-2/salsa20.s between version 182 and 211

version 182, Fri Jan 5 18:10:12 2007 UTC version 211, Thu Feb 14 05:39:03 2008 UTC
Line 536 
Line 536 
 movq 64(%rsp),%rsi  movq 64(%rsp),%rsi
   
 # qhasm:                x2 = x3  # qhasm:                x2 = x3
 # asm 1: mov  <x3=int64#2,>x2=int64#5  # asm 1: mov  <x3=int64#2,>x2=int64#4
 # asm 2: mov  <x3=%rsi,>x2=%r8  # asm 2: mov  <x3=%rsi,>x2=%rcx
 mov  %rsi,%r8  mov  %rsi,%rcx
   
 # qhasm:                (uint64) x3 >>= 32  # qhasm:                (uint64) x3 >>= 32
 # asm 1: shr  $32,<x3=int64#2  # asm 1: shr  $32,<x3=int64#2
Line 546 
Line 546 
 shr  $32,%rsi  shr  $32,%rsi
   
 # qhasm:   x5 = j4  # qhasm:   x5 = j4
 # asm 1: movq <j4=stack64#10,>x5=int64#4  # asm 1: movq <j4=stack64#10,>x5=int64#5
 # asm 2: movq <j4=72(%rsp),>x5=%rcx  # asm 2: movq <j4=72(%rsp),>x5=%r8
 movq 72(%rsp),%rcx  movq 72(%rsp),%r8
   
 # qhasm:   x4 = x5  # qhasm:   x4 = x5
 # asm 1: mov  <x5=int64#4,>x4=int64#6  # asm 1: mov  <x5=int64#5,>x4=int64#6
 # asm 2: mov  <x5=%rcx,>x4=%r9  # asm 2: mov  <x5=%r8,>x4=%r9
 mov  %rcx,%r9  mov  %r8,%r9
   
 # qhasm:   (uint64) x5 >>= 32  # qhasm:   (uint64) x5 >>= 32
 # asm 1: shr  $32,<x5=int64#4  # asm 1: shr  $32,<x5=int64#5
 # asm 2: shr  $32,<x5=%rcx  # asm 2: shr  $32,<x5=%r8
 shr  $32,%rcx  shr  $32,%r8
   
 # qhasm:   x5_stack = x5  # qhasm:   x5_stack = x5
 # asm 1: movq <x5=int64#4,>x5_stack=stack64#21  # asm 1: movq <x5=int64#5,>x5_stack=stack64#21
 # asm 2: movq <x5=%rcx,>x5_stack=160(%rsp)  # asm 2: movq <x5=%r8,>x5_stack=160(%rsp)
 movq %rcx,160(%rsp)  movq %r8,160(%rsp)
   
 # qhasm:                x7 = j6  # qhasm:                x7 = j6
 # asm 1: movq <j6=stack64#11,>x7=int64#7  # asm 1: movq <j6=stack64#11,>x7=int64#5
 # asm 2: movq <j6=80(%rsp),>x7=%rax  # asm 2: movq <j6=80(%rsp),>x7=%r8
 movq 80(%rsp),%rax  movq 80(%rsp),%r8
   
 # qhasm:                x6 = x7  # qhasm:                x6 = x7
 # asm 1: mov  <x7=int64#7,>x6=int64#8  # asm 1: mov  <x7=int64#5,>x6=int64#7
 # asm 2: mov  <x7=%rax,>x6=%r10  # asm 2: mov  <x7=%r8,>x6=%rax
 mov  %rax,%r10  mov  %r8,%rax
   
 # qhasm:                (uint64) x7 >>= 32  # qhasm:                (uint64) x7 >>= 32
 # asm 1: shr  $32,<x7=int64#7  # asm 1: shr  $32,<x7=int64#5
 # asm 2: shr  $32,<x7=%rax  # asm 2: shr  $32,<x7=%r8
 shr  $32,%rax  shr  $32,%r8
   
 # qhasm:   x9 = j8  # qhasm:   x9 = j8
 # asm 1: movq <j8=stack64#12,>x9=int64#9  # asm 1: movq <j8=stack64#12,>x9=int64#8
 # asm 2: movq <j8=88(%rsp),>x9=%r11  # asm 2: movq <j8=88(%rsp),>x9=%r10
 movq 88(%rsp),%r11  movq 88(%rsp),%r10
   
 # qhasm:   x8 = x9  # qhasm:   x8 = x9
 # asm 1: mov  <x9=int64#9,>x8=int64#10  # asm 1: mov  <x9=int64#8,>x8=int64#9
 # asm 2: mov  <x9=%r11,>x8=%r12  # asm 2: mov  <x9=%r10,>x8=%r11
 mov  %r11,%r12  mov  %r10,%r11
   
 # qhasm:   (uint64) x9 >>= 32  # qhasm:   (uint64) x9 >>= 32
 # asm 1: shr  $32,<x9=int64#9  # asm 1: shr  $32,<x9=int64#8
 # asm 2: shr  $32,<x9=%r11  # asm 2: shr  $32,<x9=%r10
 shr  $32,%r11  shr  $32,%r10
   
 # qhasm:                x11 = j10  # qhasm:                x11 = j10
 # asm 1: movq <j10=stack64#13,>x11=int64#11  # asm 1: movq <j10=stack64#13,>x11=int64#10
 # asm 2: movq <j10=96(%rsp),>x11=%r13  # asm 2: movq <j10=96(%rsp),>x11=%r12
 movq 96(%rsp),%r13  movq 96(%rsp),%r12
   
 # qhasm:                x10 = x11  # qhasm:                x10 = x11
 # asm 1: mov  <x11=int64#11,>x10=int64#4  # asm 1: mov  <x11=int64#10,>x10=int64#11
 # asm 2: mov  <x11=%r13,>x10=%rcx  # asm 2: mov  <x11=%r12,>x10=%r13
 mov  %r13,%rcx  mov  %r12,%r13
   
 # qhasm:                x10_stack = x10  # qhasm:                x10_stack = x10
 # asm 1: movq <x10=int64#4,>x10_stack=stack64#22  # asm 1: movq <x10=int64#11,>x10_stack=stack64#22
 # asm 2: movq <x10=%rcx,>x10_stack=168(%rsp)  # asm 2: movq <x10=%r13,>x10_stack=168(%rsp)
 movq %rcx,168(%rsp)  movq %r13,168(%rsp)
   
 # qhasm:                (uint64) x11 >>= 32  # qhasm:                (uint64) x11 >>= 32
 # asm 1: shr  $32,<x11=int64#11  # asm 1: shr  $32,<x11=int64#10
 # asm 2: shr  $32,<x11=%r13  # asm 2: shr  $32,<x11=%r12
 shr  $32,%r13  shr  $32,%r12
   
 # qhasm:   x13 = j12  # qhasm:   x13 = j12
 # asm 1: movq <j12=stack64#14,>x13=int64#12  # asm 1: movq <j12=stack64#14,>x13=int64#11
 # asm 2: movq <j12=104(%rsp),>x13=%r14  # asm 2: movq <j12=104(%rsp),>x13=%r13
 movq 104(%rsp),%r14  movq 104(%rsp),%r13
   
 # qhasm:   x12 = x13  # qhasm:   x12 = x13
 # asm 1: mov  <x13=int64#12,>x12=int64#13  # asm 1: mov  <x13=int64#11,>x12=int64#12
 # asm 2: mov  <x13=%r14,>x12=%r15  # asm 2: mov  <x13=%r13,>x12=%r14
 mov  %r14,%r15  mov  %r13,%r14
   
 # qhasm:   (uint64) x13 >>= 32  # qhasm:   (uint64) x13 >>= 32
 # asm 1: shr  $32,<x13=int64#12  # asm 1: shr  $32,<x13=int64#11
 # asm 2: shr  $32,<x13=%r14  # asm 2: shr  $32,<x13=%r13
 shr  $32,%r14  shr  $32,%r13
   
 # qhasm:                x15 = j14  # qhasm:                x15 = j14
 # asm 1: movq <j14=stack64#15,>x15=int64#4  # asm 1: movq <j14=stack64#15,>x15=int64#13
 # asm 2: movq <j14=112(%rsp),>x15=%rcx  # asm 2: movq <j14=112(%rsp),>x15=%r15
 movq 112(%rsp),%rcx  movq 112(%rsp),%r15
   
 # qhasm:                x14 = x15  # qhasm:                x14 = x15
 # asm 1: mov  <x15=int64#4,>x14=int64#14  # asm 1: mov  <x15=int64#13,>x14=int64#14
 # asm 2: mov  <x15=%rcx,>x14=%rbx  # asm 2: mov  <x15=%r15,>x14=%rbx
 mov  %rcx,%rbx  mov  %r15,%rbx
   
 # qhasm:                (uint64) x15 >>= 32  # qhasm:                (uint64) x15 >>= 32
 # asm 1: shr  $32,<x15=int64#4  # asm 1: shr  $32,<x15=int64#13
 # asm 2: shr  $32,<x15=%rcx  # asm 2: shr  $32,<x15=%r15
 shr  $32,%rcx  shr  $32,%r15
   
 # qhasm:                x15_stack = x15  # qhasm:                x15_stack = x15
 # asm 1: movq <x15=int64#4,>x15_stack=stack64#23  # asm 1: movq <x15=int64#13,>x15_stack=stack64#23
 # asm 2: movq <x15=%rcx,>x15_stack=176(%rsp)  # asm 2: movq <x15=%r15,>x15_stack=176(%rsp)
 movq %rcx,176(%rsp)  movq %r15,176(%rsp)
   
 # qhasm:   i = 12  # qhasm:   i = 12
 # asm 1: mov  $12,>i=int64#4  # asm 1: mov  $12,>i=int64#13
 # asm 2: mov  $12,>i=%rcx  # asm 2: mov  $12,>i=%r15
 mov  $12,%rcx  mov  $12,%r15
   
 # qhasm:   mainloop:  # qhasm:   mainloop:
 ._mainloop:  ._mainloop:
   
 # qhasm:   i_backup = i  # qhasm:   i_backup = i
 # asm 1: movq <i=int64#4,>i_backup=stack64#24  # asm 1: movq <i=int64#13,>i_backup=stack64#24
 # asm 2: movq <i=%rcx,>i_backup=184(%rsp)  # asm 2: movq <i=%r15,>i_backup=184(%rsp)
 movq %rcx,184(%rsp)  movq %r15,184(%rsp)
   
 # qhasm: a = x12 + x0  # qhasm: a = x12 + x0
 # asm 1: lea  (<x12=int64#13,<x0=int64#3),>a=int64#4  # asm 1: lea  (<x12=int64#12,<x0=int64#3),>a=int64#13
 # asm 2: lea  (<x12=%r15,<x0=%rdx),>a=%rcx  # asm 2: lea  (<x12=%r14,<x0=%rdx),>a=%r15
 lea  (%r15,%rdx),%rcx  lea  (%r14,%rdx),%r15
   
 # qhasm: (uint32) a <<<= 7  # qhasm: (uint32) a <<<= 7
 # asm 1: rol  $7,<a=int64#4d  # asm 1: rol  $7,<a=int64#13d
 # asm 2: rol  $7,<a=%ecx  # asm 2: rol  $7,<a=%r15d
 rol  $7,%ecx  rol  $7,%r15d
   
 # qhasm: x4 ^= a  # qhasm: x4 ^= a
 # asm 1: xor  <a=int64#4,<x4=int64#6  # asm 1: xor  <a=int64#13,<x4=int64#6
 # asm 2: xor  <a=%rcx,<x4=%r9  # asm 2: xor  <a=%r15,<x4=%r9
 xor  %rcx,%r9  xor  %r15,%r9
   
 # qhasm: a = x0 + x4  # qhasm: a = x0 + x4
 # asm 1: lea  (<x0=int64#3,<x4=int64#6),>a=int64#4  # asm 1: lea  (<x0=int64#3,<x4=int64#6),>a=int64#13
 # asm 2: lea  (<x0=%rdx,<x4=%r9),>a=%rcx  # asm 2: lea  (<x0=%rdx,<x4=%r9),>a=%r15
 lea  (%rdx,%r9),%rcx  lea  (%rdx,%r9),%r15
   
 # qhasm: (uint32) a <<<= 9  # qhasm: (uint32) a <<<= 9
 # asm 1: rol  $9,<a=int64#4d  # asm 1: rol  $9,<a=int64#13d
 # asm 2: rol  $9,<a=%ecx  # asm 2: rol  $9,<a=%r15d
 rol  $9,%ecx  rol  $9,%r15d
   
 # qhasm: x8 ^= a  # qhasm: x8 ^= a
 # asm 1: xor  <a=int64#4,<x8=int64#10  # asm 1: xor  <a=int64#13,<x8=int64#9
 # asm 2: xor  <a=%rcx,<x8=%r12  # asm 2: xor  <a=%r15,<x8=%r11
 xor  %rcx,%r12  xor  %r15,%r11
   
 # qhasm: a = x4 + x8  # qhasm: a = x4 + x8
 # asm 1: lea  (<x4=int64#6,<x8=int64#10),>a=int64#4  # asm 1: lea  (<x4=int64#6,<x8=int64#9),>a=int64#13
 # asm 2: lea  (<x4=%r9,<x8=%r12),>a=%rcx  # asm 2: lea  (<x4=%r9,<x8=%r11),>a=%r15
 lea  (%r9,%r12),%rcx  lea  (%r9,%r11),%r15
   
 # qhasm: (uint32) a <<<= 13  # qhasm: (uint32) a <<<= 13
 # asm 1: rol  $13,<a=int64#4d  # asm 1: rol  $13,<a=int64#13d
 # asm 2: rol  $13,<a=%ecx  # asm 2: rol  $13,<a=%r15d
 rol  $13,%ecx  rol  $13,%r15d
   
 # qhasm: x12 ^= a  # qhasm: x12 ^= a
 # asm 1: xor  <a=int64#4,<x12=int64#13  # asm 1: xor  <a=int64#13,<x12=int64#12
 # asm 2: xor  <a=%rcx,<x12=%r15  # asm 2: xor  <a=%r15,<x12=%r14
 xor  %rcx,%r15  xor  %r15,%r14
   
 # qhasm: a = x8 + x12  # qhasm: a = x8 + x12
 # asm 1: lea  (<x8=int64#10,<x12=int64#13),>a=int64#4  # asm 1: lea  (<x8=int64#9,<x12=int64#12),>a=int64#13
 # asm 2: lea  (<x8=%r12,<x12=%r15),>a=%rcx  # asm 2: lea  (<x8=%r11,<x12=%r14),>a=%r15
 lea  (%r12,%r15),%rcx  lea  (%r11,%r14),%r15
   
 # qhasm: (uint32) a <<<= 18  # qhasm: (uint32) a <<<= 18
 # asm 1: rol  $18,<a=int64#4d  # asm 1: rol  $18,<a=int64#13d
 # asm 2: rol  $18,<a=%ecx  # asm 2: rol  $18,<a=%r15d
 rol  $18,%ecx  rol  $18,%r15d
   
 # qhasm: x0 ^= a  # qhasm: x0 ^= a
 # asm 1: xor  <a=int64#4,<x0=int64#3  # asm 1: xor  <a=int64#13,<x0=int64#3
 # asm 2: xor  <a=%rcx,<x0=%rdx  # asm 2: xor  <a=%r15,<x0=%rdx
 xor  %rcx,%rdx  xor  %r15,%rdx
   
 # qhasm:                x5 = x5_stack  # qhasm:                x5 = x5_stack
 # asm 1: movq <x5_stack=stack64#21,>x5=int64#4  # asm 1: movq <x5_stack=stack64#21,>x5=int64#13
 # asm 2: movq <x5_stack=160(%rsp),>x5=%rcx  # asm 2: movq <x5_stack=160(%rsp),>x5=%r15
 movq 160(%rsp),%rcx  movq 160(%rsp),%r15
   
 # qhasm:                b = x1 + x5  # qhasm:                b = x1 + x5
 # asm 1: lea  (<x1=int64#1,<x5=int64#4),>b=int64#15  # asm 1: lea  (<x1=int64#1,<x5=int64#13),>b=int64#15
 # asm 2: lea  (<x1=%rdi,<x5=%rcx),>b=%rbp  # asm 2: lea  (<x1=%rdi,<x5=%r15),>b=%rbp
 lea  (%rdi,%rcx),%rbp  lea  (%rdi,%r15),%rbp
   
 # qhasm:                (uint32) b <<<= 7  # qhasm:                (uint32) b <<<= 7
 # asm 1: rol  $7,<b=int64#15d  # asm 1: rol  $7,<b=int64#15d
Line 739 
Line 739 
 rol  $7,%ebp  rol  $7,%ebp
   
 # qhasm:                x9 ^= b  # qhasm:                x9 ^= b
 # asm 1: xor  <b=int64#15,<x9=int64#9  # asm 1: xor  <b=int64#15,<x9=int64#8
 # asm 2: xor  <b=%rbp,<x9=%r11  # asm 2: xor  <b=%rbp,<x9=%r10
 xor  %rbp,%r11  xor  %rbp,%r10
   
 # qhasm:                b = x5 + x9  # qhasm:                b = x5 + x9
 # asm 1: lea  (<x5=int64#4,<x9=int64#9),>b=int64#15  # asm 1: lea  (<x5=int64#13,<x9=int64#8),>b=int64#15
 # asm 2: lea  (<x5=%rcx,<x9=%r11),>b=%rbp  # asm 2: lea  (<x5=%r15,<x9=%r10),>b=%rbp
 lea  (%rcx,%r11),%rbp  lea  (%r15,%r10),%rbp
   
 # qhasm:                (uint32) b <<<= 9  # qhasm:                (uint32) b <<<= 9
 # asm 1: rol  $9,<b=int64#15d  # asm 1: rol  $9,<b=int64#15d
Line 754 
Line 754 
 rol  $9,%ebp  rol  $9,%ebp
   
 # qhasm:                x13 ^= b  # qhasm:                x13 ^= b
 # asm 1: xor  <b=int64#15,<x13=int64#12  # asm 1: xor  <b=int64#15,<x13=int64#11
 # asm 2: xor  <b=%rbp,<x13=%r14  # asm 2: xor  <b=%rbp,<x13=%r13
 xor  %rbp,%r14  xor  %rbp,%r13
   
 # qhasm:                b = x9 + x13  # qhasm:                b = x9 + x13
 # asm 1: lea  (<x9=int64#9,<x13=int64#12),>b=int64#15  # asm 1: lea  (<x9=int64#8,<x13=int64#11),>b=int64#15
 # asm 2: lea  (<x9=%r11,<x13=%r14),>b=%rbp  # asm 2: lea  (<x9=%r10,<x13=%r13),>b=%rbp
 lea  (%r11,%r14),%rbp  lea  (%r10,%r13),%rbp
   
 # qhasm:                (uint32) b <<<= 13  # qhasm:                (uint32) b <<<= 13
 # asm 1: rol  $13,<b=int64#15d  # asm 1: rol  $13,<b=int64#15d
Line 774 
Line 774 
 xor  %rbp,%rdi  xor  %rbp,%rdi
   
 # qhasm:                b = x13 + x1  # qhasm:                b = x13 + x1
 # asm 1: lea  (<x13=int64#12,<x1=int64#1),>b=int64#15  # asm 1: lea  (<x13=int64#11,<x1=int64#1),>b=int64#15
 # asm 2: lea  (<x13=%r14,<x1=%rdi),>b=%rbp  # asm 2: lea  (<x13=%r13,<x1=%rdi),>b=%rbp
 lea  (%r14,%rdi),%rbp  lea  (%r13,%rdi),%rbp
   
 # qhasm:                (uint32) b <<<= 18  # qhasm:                (uint32) b <<<= 18
 # asm 1: rol  $18,<b=int64#15d  # asm 1: rol  $18,<b=int64#15d
Line 784 
Line 784 
 rol  $18,%ebp  rol  $18,%ebp
   
 # qhasm:                x5 ^= b  # qhasm:                x5 ^= b
 # asm 1: xor  <b=int64#15,<x5=int64#4  # asm 1: xor  <b=int64#15,<x5=int64#13
 # asm 2: xor  <b=%rbp,<x5=%rcx  # asm 2: xor  <b=%rbp,<x5=%r15
 xor  %rbp,%rcx  xor  %rbp,%r15
   
 # qhasm:                x5_stack = x5  # qhasm:                x5_stack = x5
 # asm 1: movq <x5=int64#4,>x5_stack=stack64#21  # asm 1: movq <x5=int64#13,>x5_stack=stack64#21
 # asm 2: movq <x5=%rcx,>x5_stack=160(%rsp)  # asm 2: movq <x5=%r15,>x5_stack=160(%rsp)
 movq %rcx,160(%rsp)  movq %r15,160(%rsp)
   
 # qhasm:                                x10 = x10_stack  # qhasm:                                x10 = x10_stack
 # asm 1: movq <x10_stack=stack64#22,>x10=int64#4  # asm 1: movq <x10_stack=stack64#22,>x10=int64#13
 # asm 2: movq <x10_stack=168(%rsp),>x10=%rcx  # asm 2: movq <x10_stack=168(%rsp),>x10=%r15
 movq 168(%rsp),%rcx  movq 168(%rsp),%r15
   
 # qhasm:                                c = x6 + x10  # qhasm:                                c = x6 + x10
 # asm 1: lea  (<x6=int64#8,<x10=int64#4),>c=int64#15  # asm 1: lea  (<x6=int64#7,<x10=int64#13),>c=int64#15
 # asm 2: lea  (<x6=%r10,<x10=%rcx),>c=%rbp  # asm 2: lea  (<x6=%rax,<x10=%r15),>c=%rbp
 lea  (%r10,%rcx),%rbp  lea  (%rax,%r15),%rbp
   
 # qhasm:                                (uint32) c <<<= 7  # qhasm:                                (uint32) c <<<= 7
 # asm 1: rol  $7,<c=int64#15d  # asm 1: rol  $7,<c=int64#15d
Line 814 
Line 814 
 xor  %rbp,%rbx  xor  %rbp,%rbx
   
 # qhasm:                                c = x10 + x14  # qhasm:                                c = x10 + x14
 # asm 1: lea  (<x10=int64#4,<x14=int64#14),>c=int64#15  # asm 1: lea  (<x10=int64#13,<x14=int64#14),>c=int64#15
 # asm 2: lea  (<x10=%rcx,<x14=%rbx),>c=%rbp  # asm 2: lea  (<x10=%r15,<x14=%rbx),>c=%rbp
 lea  (%rcx,%rbx),%rbp  lea  (%r15,%rbx),%rbp
   
 # qhasm:                                (uint32) c <<<= 9  # qhasm:                                (uint32) c <<<= 9
 # asm 1: rol  $9,<c=int64#15d  # asm 1: rol  $9,<c=int64#15d
Line 824 
Line 824 
 rol  $9,%ebp  rol  $9,%ebp
   
 # qhasm:                                x2 ^= c  # qhasm:                                x2 ^= c
 # asm 1: xor  <c=int64#15,<x2=int64#5  # asm 1: xor  <c=int64#15,<x2=int64#4
 # asm 2: xor  <c=%rbp,<x2=%r8  # asm 2: xor  <c=%rbp,<x2=%rcx
 xor  %rbp,%r8  xor  %rbp,%rcx
   
 # qhasm:                                c = x14 + x2  # qhasm:                                c = x14 + x2
 # asm 1: lea  (<x14=int64#14,<x2=int64#5),>c=int64#15  # asm 1: lea  (<x14=int64#14,<x2=int64#4),>c=int64#15
 # asm 2: lea  (<x14=%rbx,<x2=%r8),>c=%rbp  # asm 2: lea  (<x14=%rbx,<x2=%rcx),>c=%rbp
 lea  (%rbx,%r8),%rbp  lea  (%rbx,%rcx),%rbp
   
 # qhasm:                                (uint32) c <<<= 13  # qhasm:                                (uint32) c <<<= 13
 # asm 1: rol  $13,<c=int64#15d  # asm 1: rol  $13,<c=int64#15d
Line 839 
Line 839 
 rol  $13,%ebp  rol  $13,%ebp
   
 # qhasm:                                x6 ^= c  # qhasm:                                x6 ^= c
 # asm 1: xor  <c=int64#15,<x6=int64#8  # asm 1: xor  <c=int64#15,<x6=int64#7
 # asm 2: xor  <c=%rbp,<x6=%r10  # asm 2: xor  <c=%rbp,<x6=%rax
 xor  %rbp,%r10  xor  %rbp,%rax
   
 # qhasm:                                c = x2 + x6  # qhasm:                                c = x2 + x6
 # asm 1: lea  (<x2=int64#5,<x6=int64#8),>c=int64#15  # asm 1: lea  (<x2=int64#4,<x6=int64#7),>c=int64#15
 # asm 2: lea  (<x2=%r8,<x6=%r10),>c=%rbp  # asm 2: lea  (<x2=%rcx,<x6=%rax),>c=%rbp
 lea  (%r8,%r10),%rbp  lea  (%rcx,%rax),%rbp
   
 # qhasm:                                (uint32) c <<<= 18  # qhasm:                                (uint32) c <<<= 18
 # asm 1: rol  $18,<c=int64#15d  # asm 1: rol  $18,<c=int64#15d
Line 854 
Line 854 
 rol  $18,%ebp  rol  $18,%ebp
   
 # qhasm:                                x10 ^= c  # qhasm:                                x10 ^= c
 # asm 1: xor  <c=int64#15,<x10=int64#4  # asm 1: xor  <c=int64#15,<x10=int64#13
 # asm 2: xor  <c=%rbp,<x10=%rcx  # asm 2: xor  <c=%rbp,<x10=%r15
 xor  %rbp,%rcx  xor  %rbp,%r15
   
 # qhasm:                                x10_stack = x10  # qhasm:                                x10_stack = x10
 # asm 1: movq <x10=int64#4,>x10_stack=stack64#22  # asm 1: movq <x10=int64#13,>x10_stack=stack64#22
 # asm 2: movq <x10=%rcx,>x10_stack=168(%rsp)  # asm 2: movq <x10=%r15,>x10_stack=168(%rsp)
 movq %rcx,168(%rsp)  movq %r15,168(%rsp)
   
 # qhasm:                                                x15 = x15_stack  # qhasm:                                                x15 = x15_stack
 # asm 1: movq <x15_stack=stack64#23,>x15=int64#4  # asm 1: movq <x15_stack=stack64#23,>x15=int64#13
 # asm 2: movq <x15_stack=176(%rsp),>x15=%rcx  # asm 2: movq <x15_stack=176(%rsp),>x15=%r15
 movq 176(%rsp),%rcx  movq 176(%rsp),%r15
   
 # qhasm:                                                d = x11 + x15  # qhasm:                                                d = x11 + x15
 # asm 1: lea  (<x11=int64#11,<x15=int64#4),>d=int64#15  # asm 1: lea  (<x11=int64#10,<x15=int64#13),>d=int64#15
 # asm 2: lea  (<x11=%r13,<x15=%rcx),>d=%rbp  # asm 2: lea  (<x11=%r12,<x15=%r15),>d=%rbp
 lea  (%r13,%rcx),%rbp  lea  (%r12,%r15),%rbp
   
 # qhasm:                                                (uint32) d <<<= 7  # qhasm:                                                (uint32) d <<<= 7
 # asm 1: rol  $7,<d=int64#15d  # asm 1: rol  $7,<d=int64#15d
Line 884 
Line 884 
 xor  %rbp,%rsi  xor  %rbp,%rsi
   
 # qhasm:                                                d = x15 + x3  # qhasm:                                                d = x15 + x3
 # asm 1: lea  (<x15=int64#4,<x3=int64#2),>d=int64#15  # asm 1: lea  (<x15=int64#13,<x3=int64#2),>d=int64#15
 # asm 2: lea  (<x15=%rcx,<x3=%rsi),>d=%rbp  # asm 2: lea  (<x15=%r15,<x3=%rsi),>d=%rbp
 lea  (%rcx,%rsi),%rbp  lea  (%r15,%rsi),%rbp
   
 # qhasm:                                                (uint32) d <<<= 9  # qhasm:                                                (uint32) d <<<= 9
 # asm 1: rol  $9,<d=int64#15d  # asm 1: rol  $9,<d=int64#15d
Line 894 
Line 894 
 rol  $9,%ebp  rol  $9,%ebp
   
 # qhasm:                                                x7 ^= d  # qhasm:                                                x7 ^= d
 # asm 1: xor  <d=int64#15,<x7=int64#7  # asm 1: xor  <d=int64#15,<x7=int64#5
 # asm 2: xor  <d=%rbp,<x7=%rax  # asm 2: xor  <d=%rbp,<x7=%r8
 xor  %rbp,%rax  xor  %rbp,%r8
   
 # qhasm:                                                d = x3 + x7  # qhasm:                                                d = x3 + x7
 # asm 1: lea  (<x3=int64#2,<x7=int64#7),>d=int64#15  # asm 1: lea  (<x3=int64#2,<x7=int64#5),>d=int64#15
 # asm 2: lea  (<x3=%rsi,<x7=%rax),>d=%rbp  # asm 2: lea  (<x3=%rsi,<x7=%r8),>d=%rbp
 lea  (%rsi,%rax),%rbp  lea  (%rsi,%r8),%rbp
   
 # qhasm:                                                (uint32) d <<<= 13  # qhasm:                                                (uint32) d <<<= 13
 # asm 1: rol  $13,<d=int64#15d  # asm 1: rol  $13,<d=int64#15d
Line 909 
Line 909 
 rol  $13,%ebp  rol  $13,%ebp
   
 # qhasm:                                                x11 ^= d  # qhasm:                                                x11 ^= d
 # asm 1: xor  <d=int64#15,<x11=int64#11  # asm 1: xor  <d=int64#15,<x11=int64#10
 # asm 2: xor  <d=%rbp,<x11=%r13  # asm 2: xor  <d=%rbp,<x11=%r12
 xor  %rbp,%r13  xor  %rbp,%r12
   
 # qhasm:                                                d = x7 + x11  # qhasm:                                                d = x7 + x11
 # asm 1: lea  (<x7=int64#7,<x11=int64#11),>d=int64#15  # asm 1: lea  (<x7=int64#5,<x11=int64#10),>d=int64#15
 # asm 2: lea  (<x7=%rax,<x11=%r13),>d=%rbp  # asm 2: lea  (<x7=%r8,<x11=%r12),>d=%rbp
 lea  (%rax,%r13),%rbp  lea  (%r8,%r12),%rbp
   
 # qhasm:                                                (uint32) d <<<= 18  # qhasm:                                                (uint32) d <<<= 18
 # asm 1: rol  $18,<d=int64#15d  # asm 1: rol  $18,<d=int64#15d
Line 924 
Line 924 
 rol  $18,%ebp  rol  $18,%ebp
   
 # qhasm:                                                x15 ^= d  # qhasm:                                                x15 ^= d
 # asm 1: xor  <d=int64#15,<x15=int64#4  # asm 1: xor  <d=int64#15,<x15=int64#13
 # asm 2: xor  <d=%rbp,<x15=%rcx  # asm 2: xor  <d=%rbp,<x15=%r15
 xor  %rbp,%rcx  xor  %rbp,%r15
   
 # qhasm:                                                x15_stack = x15  # qhasm:                                                x15_stack = x15
 # asm 1: movq <x15=int64#4,>x15_stack=stack64#23  # asm 1: movq <x15=int64#13,>x15_stack=stack64#23
 # asm 2: movq <x15=%rcx,>x15_stack=176(%rsp)  # asm 2: movq <x15=%r15,>x15_stack=176(%rsp)
 movq %rcx,176(%rsp)  movq %r15,176(%rsp)
   
 # qhasm: a = x3 + x0  # qhasm: a = x3 + x0
 # asm 1: lea  (<x3=int64#2,<x0=int64#3),>a=int64#4  # asm 1: lea  (<x3=int64#2,<x0=int64#3),>a=int64#13
 # asm 2: lea  (<x3=%rsi,<x0=%rdx),>a=%rcx  # asm 2: lea  (<x3=%rsi,<x0=%rdx),>a=%r15
 lea  (%rsi,%rdx),%rcx  lea  (%rsi,%rdx),%r15
   
 # qhasm: (uint32) a <<<= 7  # qhasm: (uint32) a <<<= 7
 # asm 1: rol  $7,<a=int64#4d  # asm 1: rol  $7,<a=int64#13d
 # asm 2: rol  $7,<a=%ecx  # asm 2: rol  $7,<a=%r15d
 rol  $7,%ecx  rol  $7,%r15d
   
 # qhasm: x1 ^= a  # qhasm: x1 ^= a
 # asm 1: xor  <a=int64#4,<x1=int64#1  # asm 1: xor  <a=int64#13,<x1=int64#1
 # asm 2: xor  <a=%rcx,<x1=%rdi  # asm 2: xor  <a=%r15,<x1=%rdi
 xor  %rcx,%rdi  xor  %r15,%rdi
   
 # qhasm: a = x0 + x1  # qhasm: a = x0 + x1
 # asm 1: lea  (<x0=int64#3,<x1=int64#1),>a=int64#4  # asm 1: lea  (<x0=int64#3,<x1=int64#1),>a=int64#13
 # asm 2: lea  (<x0=%rdx,<x1=%rdi),>a=%rcx  # asm 2: lea  (<x0=%rdx,<x1=%rdi),>a=%r15
 lea  (%rdx,%rdi),%rcx  lea  (%rdx,%rdi),%r15
   
 # qhasm: (uint32) a <<<= 9  # qhasm: (uint32) a <<<= 9
 # asm 1: rol  $9,<a=int64#4d  # asm 1: rol  $9,<a=int64#13d
 # asm 2: rol  $9,<a=%ecx  # asm 2: rol  $9,<a=%r15d
 rol  $9,%ecx  rol  $9,%r15d
   
 # qhasm: x2 ^= a  # qhasm: x2 ^= a
 # asm 1: xor  <a=int64#4,<x2=int64#5  # asm 1: xor  <a=int64#13,<x2=int64#4
 # asm 2: xor  <a=%rcx,<x2=%r8  # asm 2: xor  <a=%r15,<x2=%rcx
 xor  %rcx,%r8  xor  %r15,%rcx
   
 # qhasm: a = x1 + x2  # qhasm: a = x1 + x2
 # asm 1: lea  (<x1=int64#1,<x2=int64#5),>a=int64#4  # asm 1: lea  (<x1=int64#1,<x2=int64#4),>a=int64#13
 # asm 2: lea  (<x1=%rdi,<x2=%r8),>a=%rcx  # asm 2: lea  (<x1=%rdi,<x2=%rcx),>a=%r15
 lea  (%rdi,%r8),%rcx  lea  (%rdi,%rcx),%r15
   
 # qhasm: (uint32) a <<<= 13  # qhasm: (uint32) a <<<= 13
 # asm 1: rol  $13,<a=int64#4d  # asm 1: rol  $13,<a=int64#13d
 # asm 2: rol  $13,<a=%ecx  # asm 2: rol  $13,<a=%r15d
 rol  $13,%ecx  rol  $13,%r15d
   
 # qhasm: x3 ^= a  # qhasm: x3 ^= a
 # asm 1: xor  <a=int64#4,<x3=int64#2  # asm 1: xor  <a=int64#13,<x3=int64#2
 # asm 2: xor  <a=%rcx,<x3=%rsi  # asm 2: xor  <a=%r15,<x3=%rsi
 xor  %rcx,%rsi  xor  %r15,%rsi
   
 # qhasm: a = x2 + x3  # qhasm: a = x2 + x3
 # asm 1: lea  (<x2=int64#5,<x3=int64#2),>a=int64#4  # asm 1: lea  (<x2=int64#4,<x3=int64#2),>a=int64#13
 # asm 2: lea  (<x2=%r8,<x3=%rsi),>a=%rcx  # asm 2: lea  (<x2=%rcx,<x3=%rsi),>a=%r15
 lea  (%r8,%rsi),%rcx  lea  (%rcx,%rsi),%r15
   
 # qhasm: (uint32) a <<<= 18  # qhasm: (uint32) a <<<= 18
 # asm 1: rol  $18,<a=int64#4d  # asm 1: rol  $18,<a=int64#13d
 # asm 2: rol  $18,<a=%ecx  # asm 2: rol  $18,<a=%r15d
 rol  $18,%ecx  rol  $18,%r15d
   
 # qhasm: x0 ^= a  # qhasm: x0 ^= a
 # asm 1: xor  <a=int64#4,<x0=int64#3  # asm 1: xor  <a=int64#13,<x0=int64#3
 # asm 2: xor  <a=%rcx,<x0=%rdx  # asm 2: xor  <a=%r15,<x0=%rdx
 xor  %rcx,%rdx  xor  %r15,%rdx
   
 # qhasm:                x5 = x5_stack  # qhasm:                x5 = x5_stack
 # asm 1: movq <x5_stack=stack64#21,>x5=int64#4  # asm 1: movq <x5_stack=stack64#21,>x5=int64#13
 # asm 2: movq <x5_stack=160(%rsp),>x5=%rcx  # asm 2: movq <x5_stack=160(%rsp),>x5=%r15
 movq 160(%rsp),%rcx  movq 160(%rsp),%r15
   
 # qhasm:                b = x4 + x5  # qhasm:                b = x4 + x5
 # asm 1: lea  (<x4=int64#6,<x5=int64#4),>b=int64#15  # asm 1: lea  (<x4=int64#6,<x5=int64#13),>b=int64#15
 # asm 2: lea  (<x4=%r9,<x5=%rcx),>b=%rbp  # asm 2: lea  (<x4=%r9,<x5=%r15),>b=%rbp
 lea  (%r9,%rcx),%rbp  lea  (%r9,%r15),%rbp
   
 # qhasm:                (uint32) b <<<= 7  # qhasm:                (uint32) b <<<= 7
 # asm 1: rol  $7,<b=int64#15d  # asm 1: rol  $7,<b=int64#15d
Line 1009 
Line 1009 
 rol  $7,%ebp  rol  $7,%ebp
   
 # qhasm:                x6 ^= b  # qhasm:                x6 ^= b
 # asm 1: xor  <b=int64#15,<x6=int64#8  # asm 1: xor  <b=int64#15,<x6=int64#7
 # asm 2: xor  <b=%rbp,<x6=%r10  # asm 2: xor  <b=%rbp,<x6=%rax
 xor  %rbp,%r10  xor  %rbp,%rax
   
 # qhasm:                b = x5 + x6  # qhasm:                b = x5 + x6
 # asm 1: lea  (<x5=int64#4,<x6=int64#8),>b=int64#15  # asm 1: lea  (<x5=int64#13,<x6=int64#7),>b=int64#15
 # asm 2: lea  (<x5=%rcx,<x6=%r10),>b=%rbp  # asm 2: lea  (<x5=%r15,<x6=%rax),>b=%rbp
 lea  (%rcx,%r10),%rbp  lea  (%r15,%rax),%rbp
   
 # qhasm:                (uint32) b <<<= 9  # qhasm:                (uint32) b <<<= 9
 # asm 1: rol  $9,<b=int64#15d  # asm 1: rol  $9,<b=int64#15d
Line 1024 
Line 1024 
 rol  $9,%ebp  rol  $9,%ebp
   
 # qhasm:                x7 ^= b  # qhasm:                x7 ^= b
 # asm 1: xor  <b=int64#15,<x7=int64#7  # asm 1: xor  <b=int64#15,<x7=int64#5
 # asm 2: xor  <b=%rbp,<x7=%rax  # asm 2: xor  <b=%rbp,<x7=%r8
 xor  %rbp,%rax  xor  %rbp,%r8
   
 # qhasm:                b = x6 + x7  # qhasm:                b = x6 + x7
 # asm 1: lea  (<x6=int64#8,<x7=int64#7),>b=int64#15  # asm 1: lea  (<x6=int64#7,<x7=int64#5),>b=int64#15
 # asm 2: lea  (<x6=%r10,<x7=%rax),>b=%rbp  # asm 2: lea  (<x6=%rax,<x7=%r8),>b=%rbp
 lea  (%r10,%rax),%rbp  lea  (%rax,%r8),%rbp
   
 # qhasm:                (uint32) b <<<= 13  # qhasm:                (uint32) b <<<= 13
 # asm 1: rol  $13,<b=int64#15d  # asm 1: rol  $13,<b=int64#15d
Line 1044 
Line 1044 
 xor  %rbp,%r9  xor  %rbp,%r9
   
 # qhasm:                b = x7 + x4  # qhasm:                b = x7 + x4
 # asm 1: lea  (<x7=int64#7,<x4=int64#6),>b=int64#15  # asm 1: lea  (<x7=int64#5,<x4=int64#6),>b=int64#15
 # asm 2: lea  (<x7=%rax,<x4=%r9),>b=%rbp  # asm 2: lea  (<x7=%r8,<x4=%r9),>b=%rbp
 lea  (%rax,%r9),%rbp  lea  (%r8,%r9),%rbp
   
 # qhasm:                (uint32) b <<<= 18  # qhasm:                (uint32) b <<<= 18
 # asm 1: rol  $18,<b=int64#15d  # asm 1: rol  $18,<b=int64#15d
Line 1054 
Line 1054 
 rol  $18,%ebp  rol  $18,%ebp
   
 # qhasm:                x5 ^= b  # qhasm:                x5 ^= b
 # asm 1: xor  <b=int64#15,<x5=int64#4  # asm 1: xor  <b=int64#15,<x5=int64#13
 # asm 2: xor  <b=%rbp,<x5=%rcx  # asm 2: xor  <b=%rbp,<x5=%r15
 xor  %rbp,%rcx  xor  %rbp,%r15
   
 # qhasm:                x5_stack = x5  # qhasm:                x5_stack = x5
 # asm 1: movq <x5=int64#4,>x5_stack=stack64#21  # asm 1: movq <x5=int64#13,>x5_stack=stack64#21
 # asm 2: movq <x5=%rcx,>x5_stack=160(%rsp)  # asm 2: movq <x5=%r15,>x5_stack=160(%rsp)
 movq %rcx,160(%rsp)  movq %r15,160(%rsp)
   
 # qhasm:                                x10 = x10_stack  # qhasm:                                x10 = x10_stack
 # asm 1: movq <x10_stack=stack64#22,>x10=int64#4  # asm 1: movq <x10_stack=stack64#22,>x10=int64#13
 # asm 2: movq <x10_stack=168(%rsp),>x10=%rcx  # asm 2: movq <x10_stack=168(%rsp),>x10=%r15
 movq 168(%rsp),%rcx  movq 168(%rsp),%r15
   
 # qhasm:                                c = x9 + x10  # qhasm:                                c = x9 + x10
 # asm 1: lea  (<x9=int64#9,<x10=int64#4),>c=int64#15  # asm 1: lea  (<x9=int64#8,<x10=int64#13),>c=int64#15
 # asm 2: lea  (<x9=%r11,<x10=%rcx),>c=%rbp  # asm 2: lea  (<x9=%r10,<x10=%r15),>c=%rbp
 lea  (%r11,%rcx),%rbp  lea  (%r10,%r15),%rbp
   
 # qhasm:                                (uint32) c <<<= 7  # qhasm:                                (uint32) c <<<= 7
 # asm 1: rol  $7,<c=int64#15d  # asm 1: rol  $7,<c=int64#15d
Line 1079 
Line 1079 
 rol  $7,%ebp  rol  $7,%ebp
   
 # qhasm:                                x11 ^= c  # qhasm:                                x11 ^= c
 # asm 1: xor  <c=int64#15,<x11=int64#11  # asm 1: xor  <c=int64#15,<x11=int64#10
 # asm 2: xor  <c=%rbp,<x11=%r13  # asm 2: xor  <c=%rbp,<x11=%r12
 xor  %rbp,%r13  xor  %rbp,%r12
   
 # qhasm:                                c = x10 + x11  # qhasm:                                c = x10 + x11
 # asm 1: lea  (<x10=int64#4,<x11=int64#11),>c=int64#15  # asm 1: lea  (<x10=int64#13,<x11=int64#10),>c=int64#15
 # asm 2: lea  (<x10=%rcx,<x11=%r13),>c=%rbp  # asm 2: lea  (<x10=%r15,<x11=%r12),>c=%rbp
 lea  (%rcx,%r13),%rbp  lea  (%r15,%r12),%rbp
   
 # qhasm:                                (uint32) c <<<= 9  # qhasm:                                (uint32) c <<<= 9
 # asm 1: rol  $9,<c=int64#15d  # asm 1: rol  $9,<c=int64#15d
Line 1094 
Line 1094 
 rol  $9,%ebp  rol  $9,%ebp
   
 # qhasm:                                x8 ^= c  # qhasm:                                x8 ^= c
 # asm 1: xor  <c=int64#15,<x8=int64#10  # asm 1: xor  <c=int64#15,<x8=int64#9
 # asm 2: xor  <c=%rbp,<x8=%r12  # asm 2: xor  <c=%rbp,<x8=%r11
 xor  %rbp,%r12  xor  %rbp,%r11
   
 # qhasm:                                c = x11 + x8  # qhasm:                                c = x11 + x8
 # asm 1: lea  (<x11=int64#11,<x8=int64#10),>c=int64#15  # asm 1: lea  (<x11=int64#10,<x8=int64#9),>c=int64#15
 # asm 2: lea  (<x11=%r13,<x8=%r12),>c=%rbp  # asm 2: lea  (<x11=%r12,<x8=%r11),>c=%rbp
 lea  (%r13,%r12),%rbp  lea  (%r12,%r11),%rbp
   
 # qhasm:                                (uint32) c <<<= 13  # qhasm:                                (uint32) c <<<= 13
 # asm 1: rol  $13,<c=int64#15d  # asm 1: rol  $13,<c=int64#15d
Line 1109 
Line 1109 
 rol  $13,%ebp  rol  $13,%ebp
   
 # qhasm:                                x9 ^= c  # qhasm:                                x9 ^= c
 # asm 1: xor  <c=int64#15,<x9=int64#9  # asm 1: xor  <c=int64#15,<x9=int64#8
 # asm 2: xor  <c=%rbp,<x9=%r11  # asm 2: xor  <c=%rbp,<x9=%r10
 xor  %rbp,%r11  xor  %rbp,%r10
   
 # qhasm:                                c = x8 + x9  # qhasm:                                c = x8 + x9
 # asm 1: lea  (<x8=int64#10,<x9=int64#9),>c=int64#15  # asm 1: lea  (<x8=int64#9,<x9=int64#8),>c=int64#15
 # asm 2: lea  (<x8=%r12,<x9=%r11),>c=%rbp  # asm 2: lea  (<x8=%r11,<x9=%r10),>c=%rbp
 lea  (%r12,%r11),%rbp  lea  (%r11,%r10),%rbp
   
 # qhasm:                                (uint32) c <<<= 18  # qhasm:                                (uint32) c <<<= 18
 # asm 1: rol  $18,<c=int64#15d  # asm 1: rol  $18,<c=int64#15d
Line 1124 
Line 1124 
 rol  $18,%ebp  rol  $18,%ebp
   
 # qhasm:                                x10 ^= c  # qhasm:                                x10 ^= c
 # asm 1: xor  <c=int64#15,<x10=int64#4  # asm 1: xor  <c=int64#15,<x10=int64#13
 # asm 2: xor  <c=%rbp,<x10=%rcx  # asm 2: xor  <c=%rbp,<x10=%r15
 xor  %rbp,%rcx  xor  %rbp,%r15
   
 # qhasm:                                x10_stack = x10  # qhasm:                                x10_stack = x10
 # asm 1: movq <x10=int64#4,>x10_stack=stack64#22  # asm 1: movq <x10=int64#13,>x10_stack=stack64#22
 # asm 2: movq <x10=%rcx,>x10_stack=168(%rsp)  # asm 2: movq <x10=%r15,>x10_stack=168(%rsp)
 movq %rcx,168(%rsp)  movq %r15,168(%rsp)
   
 # qhasm:                                                x15 = x15_stack  # qhasm:                                                x15 = x15_stack
 # asm 1: movq <x15_stack=stack64#23,>x15=int64#4  # asm 1: movq <x15_stack=stack64#23,>x15=int64#13
 # asm 2: movq <x15_stack=176(%rsp),>x15=%rcx  # asm 2: movq <x15_stack=176(%rsp),>x15=%r15
 movq 176(%rsp),%rcx  movq 176(%rsp),%r15
   
 # qhasm:                                                d = x14 + x15  # qhasm:                                                d = x14 + x15
 # asm 1: lea  (<x14=int64#14,<x15=int64#4),>d=int64#15  # asm 1: lea  (<x14=int64#14,<x15=int64#13),>d=int64#15
 # asm 2: lea  (<x14=%rbx,<x15=%rcx),>d=%rbp  # asm 2: lea  (<x14=%rbx,<x15=%r15),>d=%rbp
 lea  (%rbx,%rcx),%rbp  lea  (%rbx,%r15),%rbp
   
 # qhasm:                                                (uint32) d <<<= 7  # qhasm:                                                (uint32) d <<<= 7
 # asm 1: rol  $7,<d=int64#15d  # asm 1: rol  $7,<d=int64#15d
Line 1149 
Line 1149 
 rol  $7,%ebp  rol  $7,%ebp
   
 # qhasm:                                                x12 ^= d  # qhasm:                                                x12 ^= d
 # asm 1: xor  <d=int64#15,<x12=int64#13  # asm 1: xor  <d=int64#15,<x12=int64#12
 # asm 2: xor  <d=%rbp,<x12=%r15  # asm 2: xor  <d=%rbp,<x12=%r14
 xor  %rbp,%r15  xor  %rbp,%r14
   
 # qhasm:                                                d = x15 + x12  # qhasm:                                                d = x15 + x12
 # asm 1: lea  (<x15=int64#4,<x12=int64#13),>d=int64#15  # asm 1: lea  (<x15=int64#13,<x12=int64#12),>d=int64#15
 # asm 2: lea  (<x15=%rcx,<x12=%r15),>d=%rbp  # asm 2: lea  (<x15=%r15,<x12=%r14),>d=%rbp
 lea  (%rcx,%r15),%rbp  lea  (%r15,%r14),%rbp
   
 # qhasm:                                                (uint32) d <<<= 9  # qhasm:                                                (uint32) d <<<= 9
 # asm 1: rol  $9,<d=int64#15d  # asm 1: rol  $9,<d=int64#15d
Line 1164 
Line 1164 
 rol  $9,%ebp  rol  $9,%ebp
   
 # qhasm:                                                x13 ^= d  # qhasm:                                                x13 ^= d
 # asm 1: xor  <d=int64#15,<x13=int64#12  # asm 1: xor  <d=int64#15,<x13=int64#11
 # asm 2: xor  <d=%rbp,<x13=%r14  # asm 2: xor  <d=%rbp,<x13=%r13
 xor  %rbp,%r14  xor  %rbp,%r13
   
 # qhasm:                                                d = x12 + x13  # qhasm:                                                d = x12 + x13
 # asm 1: lea  (<x12=int64#13,<x13=int64#12),>d=int64#15  # asm 1: lea  (<x12=int64#12,<x13=int64#11),>d=int64#15
 # asm 2: lea  (<x12=%r15,<x13=%r14),>d=%rbp  # asm 2: lea  (<x12=%r14,<x13=%r13),>d=%rbp
 lea  (%r15,%r14),%rbp  lea  (%r14,%r13),%rbp
   
 # qhasm:                                                (uint32) d <<<= 13  # qhasm:                                                (uint32) d <<<= 13
 # asm 1: rol  $13,<d=int64#15d  # asm 1: rol  $13,<d=int64#15d
Line 1184 
Line 1184 
 xor  %rbp,%rbx  xor  %rbp,%rbx
   
 # qhasm:                                                d = x13 + x14  # qhasm:                                                d = x13 + x14
 # asm 1: lea  (<x13=int64#12,<x14=int64#14),>d=int64#15  # asm 1: lea  (<x13=int64#11,<x14=int64#14),>d=int64#15
 # asm 2: lea  (<x13=%r14,<x14=%rbx),>d=%rbp  # asm 2: lea  (<x13=%r13,<x14=%rbx),>d=%rbp
 lea  (%r14,%rbx),%rbp  lea  (%r13,%rbx),%rbp
   
 # qhasm:                                                (uint32) d <<<= 18  # qhasm:                                                (uint32) d <<<= 18
 # asm 1: rol  $18,<d=int64#15d  # asm 1: rol  $18,<d=int64#15d
Line 1194 
Line 1194 
 rol  $18,%ebp  rol  $18,%ebp
   
 # qhasm:                                                x15 ^= d  # qhasm:                                                x15 ^= d
 # asm 1: xor  <d=int64#15,<x15=int64#4  # asm 1: xor  <d=int64#15,<x15=int64#13
 # asm 2: xor  <d=%rbp,<x15=%rcx  # asm 2: xor  <d=%rbp,<x15=%r15
 xor  %rbp,%rcx  xor  %rbp,%r15
   
 # qhasm:                                                x15_stack = x15  # qhasm:                                                x15_stack = x15
 # asm 1: movq <x15=int64#4,>x15_stack=stack64#23  # asm 1: movq <x15=int64#13,>x15_stack=stack64#23
 # asm 2: movq <x15=%rcx,>x15_stack=176(%rsp)  # asm 2: movq <x15=%r15,>x15_stack=176(%rsp)
 movq %rcx,176(%rsp)  movq %r15,176(%rsp)
   
 # qhasm:   i = i_backup  # qhasm:   i = i_backup
 # asm 1: movq <i_backup=stack64#24,>i=int64#4  # asm 1: movq <i_backup=stack64#24,>i=int64#13
 # asm 2: movq <i_backup=184(%rsp),>i=%rcx  # asm 2: movq <i_backup=184(%rsp),>i=%r15
 movq 184(%rsp),%rcx  movq 184(%rsp),%r15
   
 # qhasm:                  unsigned>? i -= 2  # qhasm:                  unsigned>? i -= 2
 # asm 1: sub  $2,<i=int64#4  # asm 1: sub  $2,<i=int64#13
 # asm 2: sub  $2,<i=%rcx  # asm 2: sub  $2,<i=%r15
 sub  $2,%rcx  sub  $2,%r15
 # comment:fp stack unchanged by jump  # comment:fp stack unchanged by jump
   
 # qhasm: goto mainloop if unsigned>  # qhasm: goto mainloop if unsigned>
 ja ._mainloop  ja ._mainloop
   
 # qhasm:   (uint32) x2 += j2  # qhasm:   (uint32) x2 += j2
 # asm 1: addl <j2=stack64#9,<x2=int64#5d  # asm 1: addl <j2=stack64#9,<x2=int64#4d
 # asm 2: addl <j2=64(%rsp),<x2=%r8d  # asm 2: addl <j2=64(%rsp),<x2=%ecx
 addl 64(%rsp),%r8d  addl 64(%rsp),%ecx
   
 # qhasm:   x3 <<= 32  # qhasm:   x3 <<= 32
 # asm 1: shl  $32,<x3=int64#2  # asm 1: shl  $32,<x3=int64#2
Line 1243 
Line 1243 
 shl  $32,%rsi  shl  $32,%rsi
   
 # qhasm:   x2 += x3  # qhasm:   x2 += x3
 # asm 1: add  <x3=int64#2,<x2=int64#5  # asm 1: add  <x3=int64#2,<x2=int64#4
 # asm 2: add  <x3=%rsi,<x2=%r8  # asm 2: add  <x3=%rsi,<x2=%rcx
 add  %rsi,%r8  add  %rsi,%rcx
   
 # qhasm:   (uint32) x6 += j6  # qhasm:   (uint32) x6 += j6
 # asm 1: addl <j6=stack64#11,<x6=int64#8d  # asm 1: addl <j6=stack64#11,<x6=int64#7d
 # asm 2: addl <j6=80(%rsp),<x6=%r10d  # asm 2: addl <j6=80(%rsp),<x6=%eax
 addl 80(%rsp),%r10d  addl 80(%rsp),%eax
   
 # qhasm:   x7 <<= 32  # qhasm:   x7 <<= 32
 # asm 1: shl  $32,<x7=int64#7  # asm 1: shl  $32,<x7=int64#5
 # asm 2: shl  $32,<x7=%rax  # asm 2: shl  $32,<x7=%r8
 shl  $32,%rax  shl  $32,%r8
   
 # qhasm:   x7 += j6  # qhasm:   x7 += j6
 # asm 1: addq <j6=stack64#11,<x7=int64#7  # asm 1: addq <j6=stack64#11,<x7=int64#5
 # asm 2: addq <j6=80(%rsp),<x7=%rax  # asm 2: addq <j6=80(%rsp),<x7=%r8
 addq 80(%rsp),%rax  addq 80(%rsp),%r8
   
 # qhasm:   (uint64) x7 >>= 32  # qhasm:   (uint64) x7 >>= 32
 # asm 1: shr  $32,<x7=int64#7  # asm 1: shr  $32,<x7=int64#5
 # asm 2: shr  $32,<x7=%rax  # asm 2: shr  $32,<x7=%r8
 shr  $32,%rax  shr  $32,%r8
   
 # qhasm:   x7 <<= 32  # qhasm:   x7 <<= 32
 # asm 1: shl  $32,<x7=int64#7  # asm 1: shl  $32,<x7=int64#5
 # asm 2: shl  $32,<x7=%rax  # asm 2: shl  $32,<x7=%r8
 shl  $32,%rax  shl  $32,%r8
   
 # qhasm:   x6 += x7  # qhasm:   x6 += x7
 # asm 1: add  <x7=int64#7,<x6=int64#8  # asm 1: add  <x7=int64#5,<x6=int64#7
 # asm 2: add  <x7=%rax,<x6=%r10  # asm 2: add  <x7=%r8,<x6=%rax
 add  %rax,%r10  add  %r8,%rax
   
 # qhasm:   (uint32) x8 += j8  # qhasm:   (uint32) x8 += j8
 # asm 1: addl <j8=stack64#12,<x8=int64#10d  # asm 1: addl <j8=stack64#12,<x8=int64#9d
 # asm 2: addl <j8=88(%rsp),<x8=%r12d  # asm 2: addl <j8=88(%rsp),<x8=%r11d
 addl 88(%rsp),%r12d  addl 88(%rsp),%r11d
   
 # qhasm:   x9 <<= 32  # qhasm:   x9 <<= 32
 # asm 1: shl  $32,<x9=int64#9  # asm 1: shl  $32,<x9=int64#8
 # asm 2: shl  $32,<x9=%r11  # asm 2: shl  $32,<x9=%r10
 shl  $32,%r11  shl  $32,%r10
   
 # qhasm:   x9 += j8  # qhasm:   x9 += j8
 # asm 1: addq <j8=stack64#12,<x9=int64#9  # asm 1: addq <j8=stack64#12,<x9=int64#8
 # asm 2: addq <j8=88(%rsp),<x9=%r11  # asm 2: addq <j8=88(%rsp),<x9=%r10
 addq 88(%rsp),%r11  addq 88(%rsp),%r10
   
 # qhasm:   (uint64) x9 >>= 32  # qhasm:   (uint64) x9 >>= 32
 # asm 1: shr  $32,<x9=int64#9  # asm 1: shr  $32,<x9=int64#8
 # asm 2: shr  $32,<x9=%r11  # asm 2: shr  $32,<x9=%r10
 shr  $32,%r11  shr  $32,%r10
   
 # qhasm:   x9 <<= 32  # qhasm:   x9 <<= 32
 # asm 1: shl  $32,<x9=int64#9  # asm 1: shl  $32,<x9=int64#8
 # asm 2: shl  $32,<x9=%r11  # asm 2: shl  $32,<x9=%r10
 shl  $32,%r11  shl  $32,%r10
   
 # qhasm:   x8 += x9  # qhasm:   x8 += x9
 # asm 1: add  <x9=int64#9,<x8=int64#10  # asm 1: add  <x9=int64#8,<x8=int64#9
 # asm 2: add  <x9=%r11,<x8=%r12  # asm 2: add  <x9=%r10,<x8=%r11
 add  %r11,%r12  add  %r10,%r11
   
 # qhasm:   (uint32) x12 += j12  # qhasm:   (uint32) x12 += j12
 # asm 1: addl <j12=stack64#14,<x12=int64#13d  # asm 1: addl <j12=stack64#14,<x12=int64#12d
 # asm 2: addl <j12=104(%rsp),<x12=%r15d  # asm 2: addl <j12=104(%rsp),<x12=%r14d
 addl 104(%rsp),%r15d  addl 104(%rsp),%r14d
   
 # qhasm:   x13 <<= 32  # qhasm:   x13 <<= 32
 # asm 1: shl  $32,<x13=int64#12  # asm 1: shl  $32,<x13=int64#11
 # asm 2: shl  $32,<x13=%r14  # asm 2: shl  $32,<x13=%r13
 shl  $32,%r14  shl  $32,%r13
   
 # qhasm:   x13 += j12  # qhasm:   x13 += j12
 # asm 1: addq <j12=stack64#14,<x13=int64#12  # asm 1: addq <j12=stack64#14,<x13=int64#11
 # asm 2: addq <j12=104(%rsp),<x13=%r14  # asm 2: addq <j12=104(%rsp),<x13=%r13
 addq 104(%rsp),%r14  addq 104(%rsp),%r13
   
 # qhasm:   (uint64) x13 >>= 32  # qhasm:   (uint64) x13 >>= 32
 # asm 1: shr  $32,<x13=int64#12  # asm 1: shr  $32,<x13=int64#11
 # asm 2: shr  $32,<x13=%r14  # asm 2: shr  $32,<x13=%r13
 shr  $32,%r14  shr  $32,%r13
   
 # qhasm:   x13 <<= 32  # qhasm:   x13 <<= 32
 # asm 1: shl  $32,<x13=int64#12  # asm 1: shl  $32,<x13=int64#11
 # asm 2: shl  $32,<x13=%r14  # asm 2: shl  $32,<x13=%r13
 shl  $32,%r14  shl  $32,%r13
   
 # qhasm:   x12 += x13  # qhasm:   x12 += x13
 # asm 1: add  <x13=int64#12,<x12=int64#13  # asm 1: add  <x13=int64#11,<x12=int64#12
 # asm 2: add  <x13=%r14,<x12=%r15  # asm 2: add  <x13=%r13,<x12=%r14
 add  %r14,%r15  add  %r13,%r14
   
 # qhasm:   (uint32) x0 += j0  # qhasm:   (uint32) x0 += j0
 # asm 1: addl <j0=stack64#8,<x0=int64#3d  # asm 1: addl <j0=stack64#8,<x0=int64#3d
Line 1403 
Line 1403 
 add  %rdi,%r9  add  %rdi,%r9
   
 # qhasm:   x10 = x10_stack  # qhasm:   x10 = x10_stack
 # asm 1: movq <x10_stack=stack64#22,>x10=int64#4  # asm 1: movq <x10_stack=stack64#22,>x10=int64#5
 # asm 2: movq <x10_stack=168(%rsp),>x10=%rcx  # asm 2: movq <x10_stack=168(%rsp),>x10=%r8
 movq 168(%rsp),%rcx  movq 168(%rsp),%r8
   
 # qhasm:   (uint32) x10 += j10  # qhasm:   (uint32) x10 += j10
 # asm 1: addl <j10=stack64#13,<x10=int64#4d  # asm 1: addl <j10=stack64#13,<x10=int64#5d
 # asm 2: addl <j10=96(%rsp),<x10=%ecx  # asm 2: addl <j10=96(%rsp),<x10=%r8d
 addl 96(%rsp),%ecx  addl 96(%rsp),%r8d
   
 # qhasm:   x11 <<= 32  # qhasm:   x11 <<= 32
 # asm 1: shl  $32,<x11=int64#11  # asm 1: shl  $32,<x11=int64#10
 # asm 2: shl  $32,<x11=%r13  # asm 2: shl  $32,<x11=%r12
 shl  $32,%r13  shl  $32,%r12
   
 # qhasm:   x11 += j10  # qhasm:   x11 += j10
 # asm 1: addq <j10=stack64#13,<x11=int64#11  # asm 1: addq <j10=stack64#13,<x11=int64#10
 # asm 2: addq <j10=96(%rsp),<x11=%r13  # asm 2: addq <j10=96(%rsp),<x11=%r12
 addq 96(%rsp),%r13  addq 96(%rsp),%r12
   
 # qhasm:   (uint64) x11 >>= 32  # qhasm:   (uint64) x11 >>= 32
 # asm 1: shr  $32,<x11=int64#11  # asm 1: shr  $32,<x11=int64#10
 # asm 2: shr  $32,<x11=%r13  # asm 2: shr  $32,<x11=%r12
 shr  $32,%r13  shr  $32,%r12
   
 # qhasm:   x11 <<= 32  # qhasm:   x11 <<= 32
 # asm 1: shl  $32,<x11=int64#11  # asm 1: shl  $32,<x11=int64#10
 # asm 2: shl  $32,<x11=%r13  # asm 2: shl  $32,<x11=%r12
 shl  $32,%r13  shl  $32,%r12
   
 # qhasm:   x10 += x11  # qhasm:   x10 += x11
 # asm 1: add  <x11=int64#11,<x10=int64#4  # asm 1: add  <x11=int64#10,<x10=int64#5
 # asm 2: add  <x11=%r13,<x10=%rcx  # asm 2: add  <x11=%r12,<x10=%r8
 add  %r13,%rcx  add  %r12,%r8
   
 # qhasm:   x15 = x15_stack  # qhasm:   x15 = x15_stack
 # asm 1: movq <x15_stack=stack64#23,>x15=int64#1  # asm 1: movq <x15_stack=stack64#23,>x15=int64#1
Line 1493 
Line 1493 
 movq   %rdx,0(%rdi)  movq   %rdx,0(%rdi)
   
 # qhasm:   x2 ^= *(uint64 *) (m + 8)  # qhasm:   x2 ^= *(uint64 *) (m + 8)
 # asm 1: xorq 8(<m=int64#2),<x2=int64#5  # asm 1: xorq 8(<m=int64#2),<x2=int64#4
 # asm 2: xorq 8(<m=%rsi),<x2=%r8  # asm 2: xorq 8(<m=%rsi),<x2=%rcx
 xorq 8(%rsi),%r8  xorq 8(%rsi),%rcx
   
 # qhasm:   *(uint64 *) (out + 8) = x2  # qhasm:   *(uint64 *) (out + 8) = x2
 # asm 1: movq   <x2=int64#5,8(<out=int64#1)  # asm 1: movq   <x2=int64#4,8(<out=int64#1)
 # asm 2: movq   <x2=%r8,8(<out=%rdi)  # asm 2: movq   <x2=%rcx,8(<out=%rdi)
 movq   %r8,8(%rdi)  movq   %rcx,8(%rdi)
   
 # qhasm:   x4 ^= *(uint64 *) (m + 16)  # qhasm:   x4 ^= *(uint64 *) (m + 16)
 # asm 1: xorq 16(<m=int64#2),<x4=int64#6  # asm 1: xorq 16(<m=int64#2),<x4=int64#6
Line 1513 
Line 1513 
 movq   %r9,16(%rdi)  movq   %r9,16(%rdi)
   
 # qhasm:   x6 ^= *(uint64 *) (m + 24)  # qhasm:   x6 ^= *(uint64 *) (m + 24)
 # asm 1: xorq 24(<m=int64#2),<x6=int64#8  # asm 1: xorq 24(<m=int64#2),<x6=int64#7
 # asm 2: xorq 24(<m=%rsi),<x6=%r10  # asm 2: xorq 24(<m=%rsi),<x6=%rax
 xorq 24(%rsi),%r10  xorq 24(%rsi),%rax
   
 # qhasm:   *(uint64 *) (out + 24) = x6  # qhasm:   *(uint64 *) (out + 24) = x6
 # asm 1: movq   <x6=int64#8,24(<out=int64#1)  # asm 1: movq   <x6=int64#7,24(<out=int64#1)
 # asm 2: movq   <x6=%r10,24(<out=%rdi)  # asm 2: movq   <x6=%rax,24(<out=%rdi)
 movq   %r10,24(%rdi)  movq   %rax,24(%rdi)
   
 # qhasm:   x8 ^= *(uint64 *) (m + 32)  # qhasm:   x8 ^= *(uint64 *) (m + 32)
 # asm 1: xorq 32(<m=int64#2),<x8=int64#10  # asm 1: xorq 32(<m=int64#2),<x8=int64#9
 # asm 2: xorq 32(<m=%rsi),<x8=%r12  # asm 2: xorq 32(<m=%rsi),<x8=%r11
 xorq 32(%rsi),%r12  xorq 32(%rsi),%r11
   
 # qhasm:   *(uint64 *) (out + 32) = x8  # qhasm:   *(uint64 *) (out + 32) = x8
 # asm 1: movq   <x8=int64#10,32(<out=int64#1)  # asm 1: movq   <x8=int64#9,32(<out=int64#1)
 # asm 2: movq   <x8=%r12,32(<out=%rdi)  # asm 2: movq   <x8=%r11,32(<out=%rdi)
 movq   %r12,32(%rdi)  movq   %r11,32(%rdi)
   
 # qhasm:   x10 ^= *(uint64 *) (m + 40)  # qhasm:   x10 ^= *(uint64 *) (m + 40)
 # asm 1: xorq 40(<m=int64#2),<x10=int64#4  # asm 1: xorq 40(<m=int64#2),<x10=int64#5
 # asm 2: xorq 40(<m=%rsi),<x10=%rcx  # asm 2: xorq 40(<m=%rsi),<x10=%r8
 xorq 40(%rsi),%rcx  xorq 40(%rsi),%r8
   
 # qhasm:   *(uint64 *) (out + 40) = x10  # qhasm:   *(uint64 *) (out + 40) = x10
 # asm 1: movq   <x10=int64#4,40(<out=int64#1)  # asm 1: movq   <x10=int64#5,40(<out=int64#1)
 # asm 2: movq   <x10=%rcx,40(<out=%rdi)  # asm 2: movq   <x10=%r8,40(<out=%rdi)
 movq   %rcx,40(%rdi)  movq   %r8,40(%rdi)
   
 # qhasm:   x12 ^= *(uint64 *) (m + 48)  # qhasm:   x12 ^= *(uint64 *) (m + 48)
 # asm 1: xorq 48(<m=int64#2),<x12=int64#13  # asm 1: xorq 48(<m=int64#2),<x12=int64#12
 # asm 2: xorq 48(<m=%rsi),<x12=%r15  # asm 2: xorq 48(<m=%rsi),<x12=%r14
 xorq 48(%rsi),%r15  xorq 48(%rsi),%r14
   
 # qhasm:   *(uint64 *) (out + 48) = x12  # qhasm:   *(uint64 *) (out + 48) = x12
 # asm 1: movq   <x12=int64#13,48(<out=int64#1)  # asm 1: movq   <x12=int64#12,48(<out=int64#1)
 # asm 2: movq   <x12=%r15,48(<out=%rdi)  # asm 2: movq   <x12=%r14,48(<out=%rdi)
 movq   %r15,48(%rdi)  movq   %r14,48(%rdi)
   
 # qhasm:   x14 ^= *(uint64 *) (m + 56)  # qhasm:   x14 ^= *(uint64 *) (m + 56)
 # asm 1: xorq 56(<m=int64#2),<x14=int64#14  # asm 1: xorq 56(<m=int64#2),<x14=int64#14
Line 1568 
Line 1568 
 movq 152(%rsp),%rdx  movq 152(%rsp),%rdx
   
 # qhasm:   in8 = j8  # qhasm:   in8 = j8
 # asm 1: movq <j8=stack64#12,>in8=int64#9  # asm 1: movq <j8=stack64#12,>in8=int64#4
 # asm 2: movq <j8=88(%rsp),>in8=%r11  # asm 2: movq <j8=88(%rsp),>in8=%rcx
 movq 88(%rsp),%r11  movq 88(%rsp),%rcx
   
 # qhasm:   in8 += 1  # qhasm:   in8 += 1
 # asm 1: add  $1,<in8=int64#9  # asm 1: add  $1,<in8=int64#4
 # asm 2: add  $1,<in8=%r11  # asm 2: add  $1,<in8=%rcx
 add  $1,%r11  add  $1,%rcx
   
 # qhasm:   j8 = in8  # qhasm:   j8 = in8
 # asm 1: movq <in8=int64#9,>j8=stack64#12  # asm 1: movq <in8=int64#4,>j8=stack64#12
 # asm 2: movq <in8=%r11,>j8=88(%rsp)  # asm 2: movq <in8=%rcx,>j8=88(%rsp)
 movq %r11,88(%rsp)  movq %rcx,88(%rsp)
   
 # qhasm:                          unsigned>? unsigned<? bytes - 64  # qhasm:                          unsigned>? unsigned<? bytes - 64
 # asm 1: cmp  $64,<bytes=int64#3  # asm 1: cmp  $64,<bytes=int64#3
Line 1618 
Line 1618 
 ._bytesatleast64:  ._bytesatleast64:
   
 # qhasm:     x = x_backup  # qhasm:     x = x_backup
 # asm 1: movq <x_backup=stack64#16,>x=int64#5  # asm 1: movq <x_backup=stack64#16,>x=int64#1
 # asm 2: movq <x_backup=120(%rsp),>x=%r8  # asm 2: movq <x_backup=120(%rsp),>x=%rdi
 movq 120(%rsp),%r8  movq 120(%rsp),%rdi
   
 # qhasm:     in8 = j8  # qhasm:     in8 = j8
 # asm 1: movq <j8=stack64#12,>in8=int64#1  # asm 1: movq <j8=stack64#12,>in8=int64#2
 # asm 2: movq <j8=88(%rsp),>in8=%rdi  # asm 2: movq <j8=88(%rsp),>in8=%rsi
 movq 88(%rsp),%rdi  movq 88(%rsp),%rsi
   
 # qhasm:     *(uint64 *) (x + 32) = in8  # qhasm:     *(uint64 *) (x + 32) = in8
 # asm 1: movq   <in8=int64#1,32(<x=int64#5)  # asm 1: movq   <in8=int64#2,32(<x=int64#1)
 # asm 2: movq   <in8=%rdi,32(<x=%r8)  # asm 2: movq   <in8=%rsi,32(<x=%rdi)
 movq   %rdi,32(%r8)  movq   %rsi,32(%rdi)
   
 # qhasm:     r11 = r11_stack  # qhasm:     r11 = r11_stack
 # asm 1: movq <r11_stack=stack64#1,>r11=int64#9  # asm 1: movq <r11_stack=stack64#1,>r11=int64#9

Generate output suitable for use with a patch program
Legend:
Removed from v.182  
changed lines
  Added in v.211
eSTREAM Project

Powered by ViewCVS 1.0-dev 		(Powered by Apache)

ViewCVS and CVS Help