[svn] / ecrypt / trunk / submissions / salsa20 / reduced / 8-rounds / x86-1 / salsa20.s  

svn: ecrypt/trunk/submissions/salsa20/reduced/8-rounds/x86-1/salsa20.s

Diff for /ecrypt/trunk/submissions/salsa20/reduced/8-rounds/x86-1/salsa20.s between version 210 and 211

version 210, Thu Feb 14 05:23:22 2008 UTC version 211, Thu Feb 14 05:39:03 2008 UTC
Line 269 
Line 269 
 rep stosb  rep stosb
   
 # qhasm: out -= bytes  # qhasm: out -= bytes
 # asm 1: sub  <bytes=int32#4,<out=int32#6  # asm 1: subl <bytes=int32#4,<out=int32#6
 # asm 2: sub  <bytes=%ebx,<out=%edi  # asm 2: subl <bytes=%ebx,<out=%edi
 sub  %ebx,%edi  subl %ebx,%edi
 # comment:fp stack unchanged by jump  # comment:fp stack unchanged by jump
   
 # qhasm: goto start  # qhasm: goto start
Line 802 
Line 802 
 movl %ebx,164(%esp)  movl %ebx,164(%esp)
   
 # qhasm:   i = 8  # qhasm:   i = 8
 # asm 1: mov  $8,>i=int32#2  # asm 1: mov  $8,>i=int32#1
 # asm 2: mov  $8,>i=%ecx  # asm 2: mov  $8,>i=%eax
 mov  $8,%ecx  mov  $8,%eax
   
 # qhasm:   mainloop:  # qhasm:   mainloop:
 ._mainloop:  ._mainloop:
   
 # qhasm: a = x12  # qhasm: a = x12
 # asm 1: movl <x12=stack32#39,>a=int32#1  # asm 1: movl <x12=stack32#39,>a=int32#2
 # asm 2: movl <x12=152(%esp),>a=%eax  # asm 2: movl <x12=152(%esp),>a=%ecx
 movl 152(%esp),%eax  movl 152(%esp),%ecx
   
 # qhasm: b = x0  # qhasm: b = x0
 # asm 1: movl <x0=stack32#27,>b=int32#3  # asm 1: movl <x0=stack32#27,>b=int32#3
Line 830 
Line 830 
 movl 108(%esp),%esi  movl 108(%esp),%esi
   
 # qhasm: e = a + b  # qhasm: e = a + b
 # asm 1: lea  (<a=int32#1,<b=int32#3),>e=int32#6  # asm 1: lea  (<a=int32#2,<b=int32#3),>e=int32#6
 # asm 2: lea  (<a=%eax,<b=%edx),>e=%edi  # asm 2: lea  (<a=%ecx,<b=%edx),>e=%edi
 lea  (%eax,%edx),%edi  lea  (%ecx,%edx),%edi
   
 # qhasm: e <<<= 7  # qhasm: e <<<= 7
 # asm 1: rol  $7,<e=int32#6  # asm 1: rol  $7,<e=int32#6
Line 840 
Line 840 
 rol  $7,%edi  rol  $7,%edi
   
 # qhasm: c ^= e  # qhasm: c ^= e
 # asm 1: xor  <e=int32#6,<c=int32#4  # asm 1: xorl <e=int32#6,<c=int32#4
 # asm 2: xor  <e=%edi,<c=%ebx  # asm 2: xorl <e=%edi,<c=%ebx
 xor  %edi,%ebx  xorl %edi,%ebx
   
 # qhasm: x4 = c  # qhasm: x4 = c
 # asm 1: movl <c=int32#4,>x4=stack32#27  # asm 1: movl <c=int32#4,>x4=stack32#27
Line 865 
Line 865 
 rol  $9,%ebp  rol  $9,%ebp
   
 # qhasm: d ^= e  # qhasm: d ^= e
 # asm 1: xor  <e=int32#7,<d=int32#6  # asm 1: xorl <e=int32#7,<d=int32#6
 # asm 2: xor  <e=%ebp,<d=%edi  # asm 2: xorl <e=%ebp,<d=%edi
 xor  %ebp,%edi  xorl %ebp,%edi
   
 # qhasm:                s = x5  # qhasm:                s = x5
 # asm 1: movl <x5=stack32#32,>s=int32#7  # asm 1: movl <x5=stack32#32,>s=int32#7
Line 880 
Line 880 
 movl %edi,108(%esp)  movl %edi,108(%esp)
   
 # qhasm: c += d  # qhasm: c += d
 # asm 1: add  <d=int32#6,<c=int32#4  # asm 1: addl <d=int32#6,<c=int32#4
 # asm 2: add  <d=%edi,<c=%ebx  # asm 2: addl <d=%edi,<c=%ebx
 add  %edi,%ebx  addl %edi,%ebx
   
 # qhasm: c <<<= 13  # qhasm: c <<<= 13
 # asm 1: rol  $13,<c=int32#4  # asm 1: rol  $13,<c=int32#4
Line 890 
Line 890 
 rol  $13,%ebx  rol  $13,%ebx
   
 # qhasm: a ^= c  # qhasm: a ^= c
 # asm 1: xor  <c=int32#4,<a=int32#1  # asm 1: xorl <c=int32#4,<a=int32#2
 # asm 2: xor  <c=%ebx,<a=%eax  # asm 2: xorl <c=%ebx,<a=%ecx
 xor  %ebx,%eax  xorl %ebx,%ecx
   
 # qhasm:                t = x9  # qhasm:                t = x9
 # asm 1: movl <x9=stack32#36,>t=int32#4  # asm 1: movl <x9=stack32#36,>t=int32#4
Line 900 
Line 900 
 movl 140(%esp),%ebx  movl 140(%esp),%ebx
   
 # qhasm: x12 = a  # qhasm: x12 = a
 # asm 1: movl <a=int32#1,>x12=stack32#31  # asm 1: movl <a=int32#2,>x12=stack32#31
 # asm 2: movl <a=%eax,>x12=120(%esp)  # asm 2: movl <a=%ecx,>x12=120(%esp)
 movl %eax,120(%esp)  movl %ecx,120(%esp)
   
 # qhasm: a += d  # qhasm: a += d
 # asm 1: add  <d=int32#6,<a=int32#1  # asm 1: addl <d=int32#6,<a=int32#2
 # asm 2: add  <d=%edi,<a=%eax  # asm 2: addl <d=%edi,<a=%ecx
 add  %edi,%eax  addl %edi,%ecx
   
 # qhasm: a <<<= 18  # qhasm: a <<<= 18
 # asm 1: rol  $18,<a=int32#1  # asm 1: rol  $18,<a=int32#2
 # asm 2: rol  $18,<a=%eax  # asm 2: rol  $18,<a=%ecx
 rol  $18,%eax  rol  $18,%ecx
   
 # qhasm:                v = r + s  # qhasm:                v = r + s
 # asm 1: lea  (<r=int32#5,<s=int32#7),>v=int32#6  # asm 1: lea  (<r=int32#5,<s=int32#7),>v=int32#6
Line 925 
Line 925 
 rol  $7,%edi  rol  $7,%edi
   
 # qhasm:                t ^= v  # qhasm:                t ^= v
 # asm 1: xor  <v=int32#6,<t=int32#4  # asm 1: xorl <v=int32#6,<t=int32#4
 # asm 2: xor  <v=%edi,<t=%ebx  # asm 2: xorl <v=%edi,<t=%ebx
 xor  %edi,%ebx  xorl %edi,%ebx
   
 # qhasm:                x9 = t  # qhasm:                x9 = t
 # asm 1: movl <t=int32#4,>x9=stack32#32  # asm 1: movl <t=int32#4,>x9=stack32#32
Line 940 
Line 940 
 movl 156(%esp),%edi  movl 156(%esp),%edi
   
 # qhasm: b ^= a  # qhasm: b ^= a
 # asm 1: xor  <a=int32#1,<b=int32#3  # asm 1: xorl <a=int32#2,<b=int32#3
 # asm 2: xor  <a=%eax,<b=%edx  # asm 2: xorl <a=%ecx,<b=%edx
 xor  %eax,%edx  xorl %ecx,%edx
   
 # qhasm:                v = s + t  # qhasm:                v = s + t
 # asm 1: lea  (<s=int32#7,<t=int32#4),>v=int32#1  # asm 1: lea  (<s=int32#7,<t=int32#4),>v=int32#2
 # asm 2: lea  (<s=%ebp,<t=%ebx),>v=%eax  # asm 2: lea  (<s=%ebp,<t=%ebx),>v=%ecx
 lea  (%ebp,%ebx),%eax  lea  (%ebp,%ebx),%ecx
   
 # qhasm:                v <<<= 9  # qhasm:                v <<<= 9
 # asm 1: rol  $9,<v=int32#1  # asm 1: rol  $9,<v=int32#2
 # asm 2: rol  $9,<v=%eax  # asm 2: rol  $9,<v=%ecx
 rol  $9,%eax  rol  $9,%ecx
   
 # qhasm:                u ^= v  # qhasm:                u ^= v
 # asm 1: xor  <v=int32#1,<u=int32#6  # asm 1: xorl <v=int32#2,<u=int32#6
 # asm 2: xor  <v=%eax,<u=%edi  # asm 2: xorl <v=%ecx,<u=%edi
 xor  %eax,%edi  xorl %ecx,%edi
   
 # qhasm:                x13 = u  # qhasm:                x13 = u
 # asm 1: movl <u=int32#6,>x13=stack32#35  # asm 1: movl <u=int32#6,>x13=stack32#35
Line 965 
Line 965 
 movl %edi,136(%esp)  movl %edi,136(%esp)
   
 # qhasm:                                a = x6  # qhasm:                                a = x6
 # asm 1: movl <x6=stack32#33,>a=int32#1  # asm 1: movl <x6=stack32#33,>a=int32#2
 # asm 2: movl <x6=128(%esp),>a=%eax  # asm 2: movl <x6=128(%esp),>a=%ecx
 movl 128(%esp),%eax  movl 128(%esp),%ecx
   
 # qhasm: x0 = b  # qhasm: x0 = b
 # asm 1: movl <b=int32#3,>x0=stack32#33  # asm 1: movl <b=int32#3,>x0=stack32#33
Line 980 
Line 980 
 movl 144(%esp),%edx  movl 144(%esp),%edx
   
 # qhasm:                t += u  # qhasm:                t += u
 # asm 1: add  <u=int32#6,<t=int32#4  # asm 1: addl <u=int32#6,<t=int32#4
 # asm 2: add  <u=%edi,<t=%ebx  # asm 2: addl <u=%edi,<t=%ebx
 add  %edi,%ebx  addl %edi,%ebx
   
 # qhasm:                t <<<= 13  # qhasm:                t <<<= 13
 # asm 1: rol  $13,<t=int32#4  # asm 1: rol  $13,<t=int32#4
Line 990 
Line 990 
 rol  $13,%ebx  rol  $13,%ebx
   
 # qhasm:                r ^= t  # qhasm:                r ^= t
 # asm 1: xor  <t=int32#4,<r=int32#5  # asm 1: xorl <t=int32#4,<r=int32#5
 # asm 2: xor  <t=%ebx,<r=%esi  # asm 2: xorl <t=%ebx,<r=%esi
 xor  %ebx,%esi  xorl %ebx,%esi
   
 # qhasm:                                c = x14  # qhasm:                                c = x14
 # asm 1: movl <x14=stack32#41,>c=int32#4  # asm 1: movl <x14=stack32#41,>c=int32#4
Line 1005 
Line 1005 
 movl %esi,140(%esp)  movl %esi,140(%esp)
   
 # qhasm:                r += u  # qhasm:                r += u
 # asm 1: add  <u=int32#6,<r=int32#5  # asm 1: addl <u=int32#6,<r=int32#5
 # asm 2: add  <u=%edi,<r=%esi  # asm 2: addl <u=%edi,<r=%esi
 add  %edi,%esi  addl %edi,%esi
   
 # qhasm:                r <<<= 18  # qhasm:                r <<<= 18
 # asm 1: rol  $18,<r=int32#5  # asm 1: rol  $18,<r=int32#5
Line 1015 
Line 1015 
 rol  $18,%esi  rol  $18,%esi
   
 # qhasm:                                e = a + b  # qhasm:                                e = a + b
 # asm 1: lea  (<a=int32#1,<b=int32#3),>e=int32#6  # asm 1: lea  (<a=int32#2,<b=int32#3),>e=int32#6
 # asm 2: lea  (<a=%eax,<b=%edx),>e=%edi  # asm 2: lea  (<a=%ecx,<b=%edx),>e=%edi
 lea  (%eax,%edx),%edi  lea  (%ecx,%edx),%edi
   
 # qhasm:                                e <<<= 7  # qhasm:                                e <<<= 7
 # asm 1: rol  $7,<e=int32#6  # asm 1: rol  $7,<e=int32#6
Line 1025 
Line 1025 
 rol  $7,%edi  rol  $7,%edi
   
 # qhasm:                                c ^= e  # qhasm:                                c ^= e
 # asm 1: xor  <e=int32#6,<c=int32#4  # asm 1: xorl <e=int32#6,<c=int32#4
 # asm 2: xor  <e=%edi,<c=%ebx  # asm 2: xorl <e=%edi,<c=%ebx
 xor  %edi,%ebx  xorl %edi,%ebx
   
 # qhasm:                                x14 = c  # qhasm:                                x14 = c
 # asm 1: movl <c=int32#4,>x14=stack32#37  # asm 1: movl <c=int32#4,>x14=stack32#37
Line 1040 
Line 1040 
 movl 112(%esp),%edi  movl 112(%esp),%edi
   
 # qhasm:                s ^= r  # qhasm:                s ^= r
 # asm 1: xor  <r=int32#5,<s=int32#7  # asm 1: xorl <r=int32#5,<s=int32#7
 # asm 2: xor  <r=%esi,<s=%ebp  # asm 2: xorl <r=%esi,<s=%ebp
 xor  %esi,%ebp  xorl %esi,%ebp
   
 # qhasm:                                e = b + c  # qhasm:                                e = b + c
 # asm 1: lea  (<b=int32#3,<c=int32#4),>e=int32#5  # asm 1: lea  (<b=int32#3,<c=int32#4),>e=int32#5
Line 1055 
Line 1055 
 rol  $9,%esi  rol  $9,%esi
   
 # qhasm:                                d ^= e  # qhasm:                                d ^= e
 # asm 1: xor  <e=int32#5,<d=int32#6  # asm 1: xorl <e=int32#5,<d=int32#6
 # asm 2: xor  <e=%esi,<d=%edi  # asm 2: xorl <e=%esi,<d=%edi
 xor  %esi,%edi  xorl %esi,%edi
   
 # qhasm:                                x2 = d  # qhasm:                                x2 = d
 # asm 1: movl <d=int32#6,>x2=stack32#29  # asm 1: movl <d=int32#6,>x2=stack32#29
Line 1080 
Line 1080 
 movl 164(%esp),%ebp  movl 164(%esp),%ebp
   
 # qhasm:                                c += d  # qhasm:                                c += d
 # asm 1: add  <d=int32#6,<c=int32#4  # asm 1: addl <d=int32#6,<c=int32#4
 # asm 2: add  <d=%edi,<c=%ebx  # asm 2: addl <d=%edi,<c=%ebx
 add  %edi,%ebx  addl %edi,%ebx
   
 # qhasm:                                c <<<= 13  # qhasm:                                c <<<= 13
 # asm 1: rol  $13,<c=int32#4  # asm 1: rol  $13,<c=int32#4
Line 1090 
Line 1090 
 rol  $13,%ebx  rol  $13,%ebx
   
 # qhasm:                                a ^= c  # qhasm:                                a ^= c
 # asm 1: xor  <c=int32#4,<a=int32#1  # asm 1: xorl <c=int32#4,<a=int32#2
 # asm 2: xor  <c=%ebx,<a=%eax  # asm 2: xorl <c=%ebx,<a=%ecx
 xor  %ebx,%eax  xorl %ebx,%ecx
   
 # qhasm:                                                t = x3  # qhasm:                                                t = x3
 # asm 1: movl <x3=stack32#30,>t=int32#4  # asm 1: movl <x3=stack32#30,>t=int32#4
Line 1100 
Line 1100 
 movl 116(%esp),%ebx  movl 116(%esp),%ebx
   
 # qhasm:                                x6 = a  # qhasm:                                x6 = a
 # asm 1: movl <a=int32#1,>x6=stack32#30  # asm 1: movl <a=int32#2,>x6=stack32#30
 # asm 2: movl <a=%eax,>x6=116(%esp)  # asm 2: movl <a=%ecx,>x6=116(%esp)
 movl %eax,116(%esp)  movl %ecx,116(%esp)
   
 # qhasm:                                a += d  # qhasm:                                a += d
 # asm 1: add  <d=int32#6,<a=int32#1  # asm 1: addl <d=int32#6,<a=int32#2
 # asm 2: add  <d=%edi,<a=%eax  # asm 2: addl <d=%edi,<a=%ecx
 add  %edi,%eax  addl %edi,%ecx
   
 # qhasm:                                a <<<= 18  # qhasm:                                a <<<= 18
 # asm 1: rol  $18,<a=int32#1  # asm 1: rol  $18,<a=int32#2
 # asm 2: rol  $18,<a=%eax  # asm 2: rol  $18,<a=%ecx
 rol  $18,%eax  rol  $18,%ecx
   
 # qhasm:                                                v = r + s  # qhasm:                                                v = r + s
 # asm 1: lea  (<r=int32#5,<s=int32#7),>v=int32#6  # asm 1: lea  (<r=int32#5,<s=int32#7),>v=int32#6
Line 1125 
Line 1125 
 rol  $7,%edi  rol  $7,%edi
   
 # qhasm:                                                t ^= v  # qhasm:                                                t ^= v
 # asm 1: xor  <v=int32#6,<t=int32#4  # asm 1: xorl <v=int32#6,<t=int32#4
 # asm 2: xor  <v=%edi,<t=%ebx  # asm 2: xorl <v=%edi,<t=%ebx
 xor  %edi,%ebx  xorl %edi,%ebx
   
 # qhasm:                                                u = x7  # qhasm:                                                u = x7
 # asm 1: movl <x7=stack32#34,>u=int32#6  # asm 1: movl <x7=stack32#34,>u=int32#6
Line 1135 
Line 1135 
 movl 132(%esp),%edi  movl 132(%esp),%edi
   
 # qhasm:                                b ^= a  # qhasm:                                b ^= a
 # asm 1: xor  <a=int32#1,<b=int32#3  # asm 1: xorl <a=int32#2,<b=int32#3
 # asm 2: xor  <a=%eax,<b=%edx  # asm 2: xorl <a=%ecx,<b=%edx
 xor  %eax,%edx  xorl %ecx,%edx
   
 # qhasm:                                                v = s + t  # qhasm:                                                v = s + t
 # asm 1: lea  (<s=int32#7,<t=int32#4),>v=int32#1  # asm 1: lea  (<s=int32#7,<t=int32#4),>v=int32#2
 # asm 2: lea  (<s=%ebp,<t=%ebx),>v=%eax  # asm 2: lea  (<s=%ebp,<t=%ebx),>v=%ecx
 lea  (%ebp,%ebx),%eax  lea  (%ebp,%ebx),%ecx
   
 # qhasm:                                                v <<<= 9  # qhasm:                                                v <<<= 9
 # asm 1: rol  $9,<v=int32#1  # asm 1: rol  $9,<v=int32#2
 # asm 2: rol  $9,<v=%eax  # asm 2: rol  $9,<v=%ecx
 rol  $9,%eax  rol  $9,%ecx
   
 # qhasm:                                                u ^= v  # qhasm:                                                u ^= v
 # asm 1: xor  <v=int32#1,<u=int32#6  # asm 1: xorl <v=int32#2,<u=int32#6
 # asm 2: xor  <v=%eax,<u=%edi  # asm 2: xorl <v=%ecx,<u=%edi
 xor  %eax,%edi  xorl %ecx,%edi
   
 # qhasm:                                                x7 = u  # qhasm:                                                x7 = u
 # asm 1: movl <u=int32#6,>x7=stack32#34  # asm 1: movl <u=int32#6,>x7=stack32#34
Line 1160 
Line 1160 
 movl %edi,132(%esp)  movl %edi,132(%esp)
   
 # qhasm: a = t  # qhasm: a = t
 # asm 1: mov  <t=int32#4,>a=int32#1  # asm 1: mov  <t=int32#4,>a=int32#2
 # asm 2: mov  <t=%ebx,>a=%eax  # asm 2: mov  <t=%ebx,>a=%ecx
 mov  %ebx,%eax  mov  %ebx,%ecx
   
 # qhasm:                                x10 = b  # qhasm:                                x10 = b
 # asm 1: movl <b=int32#3,>x10=stack32#39  # asm 1: movl <b=int32#3,>x10=stack32#39
Line 1175 
Line 1175 
 movl 128(%esp),%edx  movl 128(%esp),%edx
   
 # qhasm:                                                t += u  # qhasm:                                                t += u
 # asm 1: add  <u=int32#6,<t=int32#4  # asm 1: addl <u=int32#6,<t=int32#4
 # asm 2: add  <u=%edi,<t=%ebx  # asm 2: addl <u=%edi,<t=%ebx
 add  %edi,%ebx  addl %edi,%ebx
   
 # qhasm:                                                t <<<= 13  # qhasm:                                                t <<<= 13
 # asm 1: rol  $13,<t=int32#4  # asm 1: rol  $13,<t=int32#4
Line 1185 
Line 1185 
 rol  $13,%ebx  rol  $13,%ebx
   
 # qhasm:                                                r ^= t  # qhasm:                                                r ^= t
 # asm 1: xor  <t=int32#4,<r=int32#5  # asm 1: xorl <t=int32#4,<r=int32#5
 # asm 2: xor  <t=%ebx,<r=%esi  # asm 2: xorl <t=%ebx,<r=%esi
 xor  %ebx,%esi  xorl %ebx,%esi
   
 # qhasm: c = x1  # qhasm: c = x1
 # asm 1: movl <x1=stack32#36,>c=int32#4  # asm 1: movl <x1=stack32#36,>c=int32#4
Line 1200 
Line 1200 
 movl %esi,128(%esp)  movl %esi,128(%esp)
   
 # qhasm:                                                r += u  # qhasm:                                                r += u
 # asm 1: add  <u=int32#6,<r=int32#5  # asm 1: addl <u=int32#6,<r=int32#5
 # asm 2: add  <u=%edi,<r=%esi  # asm 2: addl <u=%edi,<r=%esi
 add  %edi,%esi  addl %edi,%esi
   
 # qhasm:                                                r <<<= 18  # qhasm:                                                r <<<= 18
 # asm 1: rol  $18,<r=int32#5  # asm 1: rol  $18,<r=int32#5
Line 1210 
Line 1210 
 rol  $18,%esi  rol  $18,%esi
   
 # qhasm: e = a + b  # qhasm: e = a + b
 # asm 1: lea  (<a=int32#1,<b=int32#3),>e=int32#6  # asm 1: lea  (<a=int32#2,<b=int32#3),>e=int32#6
 # asm 2: lea  (<a=%eax,<b=%edx),>e=%edi  # asm 2: lea  (<a=%ecx,<b=%edx),>e=%edi
 lea  (%eax,%edx),%edi  lea  (%ecx,%edx),%edi
   
 # qhasm: e <<<= 7  # qhasm: e <<<= 7
 # asm 1: rol  $7,<e=int32#6  # asm 1: rol  $7,<e=int32#6
Line 1220 
Line 1220 
 rol  $7,%edi  rol  $7,%edi
   
 # qhasm: c ^= e  # qhasm: c ^= e
 # asm 1: xor  <e=int32#6,<c=int32#4  # asm 1: xorl <e=int32#6,<c=int32#4
 # asm 2: xor  <e=%edi,<c=%ebx  # asm 2: xorl <e=%edi,<c=%ebx
 xor  %edi,%ebx  xorl %edi,%ebx
   
 # qhasm: x1 = c  # qhasm: x1 = c
 # asm 1: movl <c=int32#4,>x1=stack32#36  # asm 1: movl <c=int32#4,>x1=stack32#36
Line 1235 
Line 1235 
 movl 112(%esp),%edi  movl 112(%esp),%edi
   
 # qhasm:                                                s ^= r  # qhasm:                                                s ^= r
 # asm 1: xor  <r=int32#5,<s=int32#7  # asm 1: xorl <r=int32#5,<s=int32#7
 # asm 2: xor  <r=%esi,<s=%ebp  # asm 2: xorl <r=%esi,<s=%ebp
 xor  %esi,%ebp  xorl %esi,%ebp
   
 # qhasm: e = b + c  # qhasm: e = b + c
 # asm 1: lea  (<b=int32#3,<c=int32#4),>e=int32#5  # asm 1: lea  (<b=int32#3,<c=int32#4),>e=int32#5
Line 1250 
Line 1250 
 rol  $9,%esi  rol  $9,%esi
   
 # qhasm: d ^= e  # qhasm: d ^= e
 # asm 1: xor  <e=int32#5,<d=int32#6  # asm 1: xorl <e=int32#5,<d=int32#6
 # asm 2: xor  <e=%esi,<d=%edi  # asm 2: xorl <e=%esi,<d=%edi
 xor  %esi,%edi  xorl %esi,%edi
   
 # qhasm: x2 = d  # qhasm: x2 = d
 # asm 1: movl <d=int32#6,>x2=stack32#29  # asm 1: movl <d=int32#6,>x2=stack32#29
Line 1275 
Line 1275 
 movl 148(%esp),%ebp  movl 148(%esp),%ebp
   
 # qhasm: c += d  # qhasm: c += d
 # asm 1: add  <d=int32#6,<c=int32#4  # asm 1: addl <d=int32#6,<c=int32#4
 # asm 2: add  <d=%edi,<c=%ebx  # asm 2: addl <d=%edi,<c=%ebx
 add  %edi,%ebx  addl %edi,%ebx
   
 # qhasm: c <<<= 13  # qhasm: c <<<= 13
 # asm 1: rol  $13,<c=int32#4  # asm 1: rol  $13,<c=int32#4
Line 1285 
Line 1285 
 rol  $13,%ebx  rol  $13,%ebx
   
 # qhasm: a ^= c  # qhasm: a ^= c
 # asm 1: xor  <c=int32#4,<a=int32#1  # asm 1: xorl <c=int32#4,<a=int32#2
 # asm 2: xor  <c=%ebx,<a=%eax  # asm 2: xorl <c=%ebx,<a=%ecx
 xor  %ebx,%eax  xorl %ebx,%ecx
   
 # qhasm:                t = x6  # qhasm:                t = x6
 # asm 1: movl <x6=stack32#30,>t=int32#4  # asm 1: movl <x6=stack32#30,>t=int32#4
Line 1295 
Line 1295 
 movl 116(%esp),%ebx  movl 116(%esp),%ebx
   
 # qhasm: x3 = a  # qhasm: x3 = a
 # asm 1: movl <a=int32#1,>x3=stack32#30  # asm 1: movl <a=int32#2,>x3=stack32#30
 # asm 2: movl <a=%eax,>x3=116(%esp)  # asm 2: movl <a=%ecx,>x3=116(%esp)
 movl %eax,116(%esp)  movl %ecx,116(%esp)
   
 # qhasm: a += d  # qhasm: a += d
 # asm 1: add  <d=int32#6,<a=int32#1  # asm 1: addl <d=int32#6,<a=int32#2
 # asm 2: add  <d=%edi,<a=%eax  # asm 2: addl <d=%edi,<a=%ecx
 add  %edi,%eax  addl %edi,%ecx
   
 # qhasm: a <<<= 18  # qhasm: a <<<= 18
 # asm 1: rol  $18,<a=int32#1  # asm 1: rol  $18,<a=int32#2
 # asm 2: rol  $18,<a=%eax  # asm 2: rol  $18,<a=%ecx
 rol  $18,%eax  rol  $18,%ecx
   
 # qhasm:                v = r + s  # qhasm:                v = r + s
 # asm 1: lea  (<r=int32#5,<s=int32#7),>v=int32#6  # asm 1: lea  (<r=int32#5,<s=int32#7),>v=int32#6
Line 1320 
Line 1320 
 rol  $7,%edi  rol  $7,%edi
   
 # qhasm:                t ^= v  # qhasm:                t ^= v
 # asm 1: xor  <v=int32#6,<t=int32#4  # asm 1: xorl <v=int32#6,<t=int32#4
 # asm 2: xor  <v=%edi,<t=%ebx  # asm 2: xorl <v=%edi,<t=%ebx
 xor  %edi,%ebx  xorl %edi,%ebx
   
 # qhasm:                x6 = t  # qhasm:                x6 = t
 # asm 1: movl <t=int32#4,>x6=stack32#38  # asm 1: movl <t=int32#4,>x6=stack32#38
Line 1335 
Line 1335 
 movl 132(%esp),%edi  movl 132(%esp),%edi
   
 # qhasm: b ^= a  # qhasm: b ^= a
 # asm 1: xor  <a=int32#1,<b=int32#3  # asm 1: xorl <a=int32#2,<b=int32#3
 # asm 2: xor  <a=%eax,<b=%edx  # asm 2: xorl <a=%ecx,<b=%edx
 xor  %eax,%edx  xorl %ecx,%edx
   
 # qhasm:                v = s + t  # qhasm:                v = s + t
 # asm 1: lea  (<s=int32#7,<t=int32#4),>v=int32#1  # asm 1: lea  (<s=int32#7,<t=int32#4),>v=int32#2
 # asm 2: lea  (<s=%ebp,<t=%ebx),>v=%eax  # asm 2: lea  (<s=%ebp,<t=%ebx),>v=%ecx
 lea  (%ebp,%ebx),%eax  lea  (%ebp,%ebx),%ecx
   
 # qhasm:                v <<<= 9  # qhasm:                v <<<= 9
 # asm 1: rol  $9,<v=int32#1  # asm 1: rol  $9,<v=int32#2
 # asm 2: rol  $9,<v=%eax  # asm 2: rol  $9,<v=%ecx
 rol  $9,%eax  rol  $9,%ecx
   
 # qhasm:                u ^= v  # qhasm:                u ^= v
 # asm 1: xor  <v=int32#1,<u=int32#6  # asm 1: xorl <v=int32#2,<u=int32#6
 # asm 2: xor  <v=%eax,<u=%edi  # asm 2: xorl <v=%ecx,<u=%edi
 xor  %eax,%edi  xorl %ecx,%edi
   
 # qhasm:                x7 = u  # qhasm:                x7 = u
 # asm 1: movl <u=int32#6,>x7=stack32#34  # asm 1: movl <u=int32#6,>x7=stack32#34
Line 1360 
Line 1360 
 movl %edi,132(%esp)  movl %edi,132(%esp)
   
 # qhasm:                                a = x9  # qhasm:                                a = x9
 # asm 1: movl <x9=stack32#32,>a=int32#1  # asm 1: movl <x9=stack32#32,>a=int32#2
 # asm 2: movl <x9=124(%esp),>a=%eax  # asm 2: movl <x9=124(%esp),>a=%ecx
 movl 124(%esp),%eax  movl 124(%esp),%ecx
   
 # qhasm: x0 = b  # qhasm: x0 = b
 # asm 1: movl <b=int32#3,>x0=stack32#32  # asm 1: movl <b=int32#3,>x0=stack32#32
Line 1375 
Line 1375 
 movl 152(%esp),%edx  movl 152(%esp),%edx
   
 # qhasm:                t += u  # qhasm:                t += u
 # asm 1: add  <u=int32#6,<t=int32#4  # asm 1: addl <u=int32#6,<t=int32#4
 # asm 2: add  <u=%edi,<t=%ebx  # asm 2: addl <u=%edi,<t=%ebx
 add  %edi,%ebx  addl %edi,%ebx
   
 # qhasm:                t <<<= 13  # qhasm:                t <<<= 13
 # asm 1: rol  $13,<t=int32#4  # asm 1: rol  $13,<t=int32#4
Line 1385 
Line 1385 
 rol  $13,%ebx  rol  $13,%ebx
   
 # qhasm:                r ^= t  # qhasm:                r ^= t
 # asm 1: xor  <t=int32#4,<r=int32#5  # asm 1: xorl <t=int32#4,<r=int32#5
 # asm 2: xor  <t=%ebx,<r=%esi  # asm 2: xorl <t=%ebx,<r=%esi
 xor  %ebx,%esi  xorl %ebx,%esi
   
 # qhasm:                                c = x11  # qhasm:                                c = x11
 # asm 1: movl <x11=stack32#33,>c=int32#4  # asm 1: movl <x11=stack32#33,>c=int32#4
Line 1400 
Line 1400 
 movl %esi,128(%esp)  movl %esi,128(%esp)
   
 # qhasm:                r += u  # qhasm:                r += u
 # asm 1: add  <u=int32#6,<r=int32#5  # asm 1: addl <u=int32#6,<r=int32#5
 # asm 2: add  <u=%edi,<r=%esi  # asm 2: addl <u=%edi,<r=%esi
 add  %edi,%esi  addl %edi,%esi
   
 # qhasm:                r <<<= 18  # qhasm:                r <<<= 18
 # asm 1: rol  $18,<r=int32#5  # asm 1: rol  $18,<r=int32#5
Line 1410 
Line 1410 
 rol  $18,%esi  rol  $18,%esi
   
 # qhasm:                                e = a + b  # qhasm:                                e = a + b
 # asm 1: lea  (<a=int32#1,<b=int32#3),>e=int32#6  # asm 1: lea  (<a=int32#2,<b=int32#3),>e=int32#6
 # asm 2: lea  (<a=%eax,<b=%edx),>e=%edi  # asm 2: lea  (<a=%ecx,<b=%edx),>e=%edi
 lea  (%eax,%edx),%edi  lea  (%ecx,%edx),%edi
   
 # qhasm:                                e <<<= 7  # qhasm:                                e <<<= 7
 # asm 1: rol  $7,<e=int32#6  # asm 1: rol  $7,<e=int32#6
Line 1420 
Line 1420 
 rol  $7,%edi  rol  $7,%edi
   
 # qhasm:                                c ^= e  # qhasm:                                c ^= e
 # asm 1: xor  <e=int32#6,<c=int32#4  # asm 1: xorl <e=int32#6,<c=int32#4
 # asm 2: xor  <e=%edi,<c=%ebx  # asm 2: xorl <e=%edi,<c=%ebx
 xor  %edi,%ebx  xorl %edi,%ebx
   
 # qhasm:                                x11 = c  # qhasm:                                x11 = c
 # asm 1: movl <c=int32#4,>x11=stack32#39  # asm 1: movl <c=int32#4,>x11=stack32#39
Line 1435 
Line 1435 
 movl 108(%esp),%edi  movl 108(%esp),%edi
   
 # qhasm:                s ^= r  # qhasm:                s ^= r
 # asm 1: xor  <r=int32#5,<s=int32#7  # asm 1: xorl <r=int32#5,<s=int32#7
 # asm 2: xor  <r=%esi,<s=%ebp  # asm 2: xorl <r=%esi,<s=%ebp
 xor  %esi,%ebp  xorl %esi,%ebp
   
 # qhasm:                                e = b + c  # qhasm:                                e = b + c
 # asm 1: lea  (<b=int32#3,<c=int32#4),>e=int32#5  # asm 1: lea  (<b=int32#3,<c=int32#4),>e=int32#5
Line 1450 
Line 1450 
 rol  $9,%esi  rol  $9,%esi
   
 # qhasm:                                d ^= e  # qhasm:                                d ^= e
 # asm 1: xor  <e=int32#5,<d=int32#6  # asm 1: xorl <e=int32#5,<d=int32#6
 # asm 2: xor  <e=%esi,<d=%edi  # asm 2: xorl <e=%esi,<d=%edi
 xor  %esi,%edi  xorl %esi,%edi
   
 # qhasm:                                x8 = d  # qhasm:                                x8 = d
 # asm 1: movl <d=int32#6,>x8=stack32#28  # asm 1: movl <d=int32#6,>x8=stack32#28
Line 1475 
Line 1475 
 movl 104(%esp),%ebp  movl 104(%esp),%ebp
   
 # qhasm:                                c += d  # qhasm:                                c += d
 # asm 1: add  <d=int32#6,<c=int32#4  # asm 1: addl <d=int32#6,<c=int32#4
 # asm 2: add  <d=%edi,<c=%ebx  # asm 2: addl <d=%edi,<c=%ebx
 add  %edi,%ebx  addl %edi,%ebx
   
 # qhasm:                                c <<<= 13  # qhasm:                                c <<<= 13
 # asm 1: rol  $13,<c=int32#4  # asm 1: rol  $13,<c=int32#4
Line 1485 
Line 1485 
 rol  $13,%ebx  rol  $13,%ebx
   
 # qhasm:                                a ^= c  # qhasm:                                a ^= c
 # asm 1: xor  <c=int32#4,<a=int32#1  # asm 1: xorl <c=int32#4,<a=int32#2
 # asm 2: xor  <c=%ebx,<a=%eax  # asm 2: xorl <c=%ebx,<a=%ecx
 xor  %ebx,%eax  xorl %ebx,%ecx
   
 # qhasm:                                                t = x12  # qhasm:                                                t = x12
 # asm 1: movl <x12=stack32#31,>t=int32#4  # asm 1: movl <x12=stack32#31,>t=int32#4
Line 1495 
Line 1495 
 movl 120(%esp),%ebx  movl 120(%esp),%ebx
   
 # qhasm:                                x9 = a  # qhasm:                                x9 = a
 # asm 1: movl <a=int32#1,>x9=stack32#27  # asm 1: movl <a=int32#2,>x9=stack32#27
 # asm 2: movl <a=%eax,>x9=104(%esp)  # asm 2: movl <a=%ecx,>x9=104(%esp)
 movl %eax,104(%esp)  movl %ecx,104(%esp)
   
 # qhasm:                                a += d  # qhasm:                                a += d
 # asm 1: add  <d=int32#6,<a=int32#1  # asm 1: addl <d=int32#6,<a=int32#2
 # asm 2: add  <d=%edi,<a=%eax  # asm 2: addl <d=%edi,<a=%ecx
 add  %edi,%eax  addl %edi,%ecx
   
 # qhasm:                                a <<<= 18  # qhasm:                                a <<<= 18
 # asm 1: rol  $18,<a=int32#1  # asm 1: rol  $18,<a=int32#2
 # asm 2: rol  $18,<a=%eax  # asm 2: rol  $18,<a=%ecx
 rol  $18,%eax  rol  $18,%ecx
   
 # qhasm:                                                v = r + s  # qhasm:                                                v = r + s
 # asm 1: lea  (<r=int32#5,<s=int32#7),>v=int32#6  # asm 1: lea  (<r=int32#5,<s=int32#7),>v=int32#6
Line 1520 
Line 1520 
 rol  $7,%edi  rol  $7,%edi
   
 # qhasm:                                                t ^= v  # qhasm:                                                t ^= v
 # asm 1: xor  <v=int32#6,<t=int32#4  # asm 1: xorl <v=int32#6,<t=int32#4
 # asm 2: xor  <v=%edi,<t=%ebx  # asm 2: xorl <v=%edi,<t=%ebx
 xor  %edi,%ebx  xorl %edi,%ebx
   
 # qhasm:                                                u = x13  # qhasm:                                                u = x13
 # asm 1: movl <x13=stack32#35,>u=int32#6  # asm 1: movl <x13=stack32#35,>u=int32#6
Line 1530 
Line 1530 
 movl 136(%esp),%edi  movl 136(%esp),%edi
   
 # qhasm:                                b ^= a  # qhasm:                                b ^= a
 # asm 1: xor  <a=int32#1,<b=int32#3  # asm 1: xorl <a=int32#2,<b=int32#3
 # asm 2: xor  <a=%eax,<b=%edx  # asm 2: xorl <a=%ecx,<b=%edx
 xor  %eax,%edx  xorl %ecx,%edx
   
 # qhasm:                                                v = s + t  # qhasm:                                                v = s + t
 # asm 1: lea  (<s=int32#7,<t=int32#4),>v=int32#1  # asm 1: lea  (<s=int32#7,<t=int32#4),>v=int32#2
 # asm 2: lea  (<s=%ebp,<t=%ebx),>v=%eax  # asm 2: lea  (<s=%ebp,<t=%ebx),>v=%ecx
 lea  (%ebp,%ebx),%eax  lea  (%ebp,%ebx),%ecx
   
 # qhasm:                                                v <<<= 9  # qhasm:                                                v <<<= 9
 # asm 1: rol  $9,<v=int32#1  # asm 1: rol  $9,<v=int32#2
 # asm 2: rol  $9,<v=%eax  # asm 2: rol  $9,<v=%ecx
 rol  $9,%eax  rol  $9,%ecx
   
 # qhasm:                                                u ^= v  # qhasm:                                                u ^= v
 # asm 1: xor  <v=int32#1,<u=int32#6  # asm 1: xorl <v=int32#2,<u=int32#6
 # asm 2: xor  <v=%eax,<u=%edi  # asm 2: xorl <v=%ecx,<u=%edi
 xor  %eax,%edi  xorl %ecx,%edi
   
 # qhasm:                                                x13 = u  # qhasm:                                                x13 = u
 # asm 1: movl <u=int32#6,>x13=stack32#31  # asm 1: movl <u=int32#6,>x13=stack32#31
Line 1555 
Line 1555 
 movl %edi,120(%esp)  movl %edi,120(%esp)
   
 # qhasm: a = t  # qhasm: a = t
 # asm 1: mov  <t=int32#4,>a=int32#1  # asm 1: mov  <t=int32#4,>a=int32#2
 # asm 2: mov  <t=%ebx,>a=%eax  # asm 2: mov  <t=%ebx,>a=%ecx
 mov  %ebx,%eax  mov  %ebx,%ecx
   
 # qhasm:                                x10 = b  # qhasm:                                x10 = b
 # asm 1: movl <b=int32#3,>x10=stack32#35  # asm 1: movl <b=int32#3,>x10=stack32#35
Line 1570 
Line 1570 
 movl 124(%esp),%edx  movl 124(%esp),%edx
   
 # qhasm:                                                t += u  # qhasm:                                                t += u
 # asm 1: add  <u=int32#6,<t=int32#4  # asm 1: addl <u=int32#6,<t=int32#4
 # asm 2: add  <u=%edi,<t=%ebx  # asm 2: addl <u=%edi,<t=%ebx
 add  %edi,%ebx  addl %edi,%ebx
   
 # qhasm:                                                t <<<= 13  # qhasm:                                                t <<<= 13
 # asm 1: rol  $13,<t=int32#4  # asm 1: rol  $13,<t=int32#4
Line 1580 
Line 1580 
 rol  $13,%ebx  rol  $13,%ebx
   
 # qhasm:                                                r ^= t  # qhasm:                                                r ^= t
 # asm 1: xor  <t=int32#4,<r=int32#5  # asm 1: xorl <t=int32#4,<r=int32#5
 # asm 2: xor  <t=%ebx,<r=%esi  # asm 2: xorl <t=%ebx,<r=%esi
 xor  %ebx,%esi  xorl %ebx,%esi
   
 # qhasm: c = x4  # qhasm: c = x4
 # asm 1: movl <x4=stack32#33,>c=int32#4  # asm 1: movl <x4=stack32#33,>c=int32#4
Line 1595 
Line 1595 
 movl %esi,124(%esp)  movl %esi,124(%esp)
   
 # qhasm:                                                r += u  # qhasm:                                                r += u
 # asm 1: add  <u=int32#6,<r=int32#5  # asm 1: addl <u=int32#6,<r=int32#5
 # asm 2: add  <u=%edi,<r=%esi  # asm 2: addl <u=%edi,<r=%esi
 add  %edi,%esi  addl %edi,%esi
   
 # qhasm:                                                r <<<= 18  # qhasm:                                                r <<<= 18
 # asm 1: rol  $18,<r=int32#5  # asm 1: rol  $18,<r=int32#5
Line 1605 
Line 1605 
 rol  $18,%esi  rol  $18,%esi
   
 # qhasm: e = a + b  # qhasm: e = a + b
 # asm 1: lea  (<a=int32#1,<b=int32#3),>e=int32#6  # asm 1: lea  (<a=int32#2,<b=int32#3),>e=int32#6
 # asm 2: lea  (<a=%eax,<b=%edx),>e=%edi  # asm 2: lea  (<a=%ecx,<b=%edx),>e=%edi
 lea  (%eax,%edx),%edi  lea  (%ecx,%edx),%edi
   
 # qhasm: e <<<= 7  # qhasm: e <<<= 7
 # asm 1: rol  $7,<e=int32#6  # asm 1: rol  $7,<e=int32#6
Line 1615 
Line 1615 
 rol  $7,%edi  rol  $7,%edi
   
 # qhasm: c ^= e  # qhasm: c ^= e
 # asm 1: xor  <e=int32#6,<c=int32#4  # asm 1: xorl <e=int32#6,<c=int32#4
 # asm 2: xor  <e=%edi,<c=%ebx  # asm 2: xorl <e=%edi,<c=%ebx
 xor  %edi,%ebx  xorl %edi,%ebx
   
 # qhasm: x4 = c  # qhasm: x4 = c
 # asm 1: movl <c=int32#4,>x4=stack32#33  # asm 1: movl <c=int32#4,>x4=stack32#33
Line 1625 
Line 1625 
 movl %ebx,128(%esp)  movl %ebx,128(%esp)
   
 # qhasm:                                                s ^= r  # qhasm:                                                s ^= r
 # asm 1: xor  <r=int32#5,<s=int32#7  # asm 1: xorl <r=int32#5,<s=int32#7
 # asm 2: xor  <r=%esi,<s=%ebp  # asm 2: xorl <r=%esi,<s=%ebp
 xor  %esi,%ebp  xorl %esi,%ebp
   
 # qhasm: d = x8  # qhasm: d = x8
 # asm 1: movl <x8=stack32#28,>d=int32#5  # asm 1: movl <x8=stack32#28,>d=int32#5
Line 1645 
Line 1645 
 rol  $9,%edi  rol  $9,%edi
   
 # qhasm: d ^= e  # qhasm: d ^= e
 # asm 1: xor  <e=int32#6,<d=int32#5  # asm 1: xorl <e=int32#6,<d=int32#5
 # asm 2: xor  <e=%edi,<d=%esi  # asm 2: xorl <e=%edi,<d=%esi
 xor  %edi,%esi  xorl %edi,%esi
   
 # qhasm:                r = x1  # qhasm:                r = x1
 # asm 1: movl <x1=stack32#36,>r=int32#6  # asm 1: movl <x1=stack32#36,>r=int32#6
Line 1670 
Line 1670 
 movl %esi,140(%esp)  movl %esi,140(%esp)
   
 # qhasm: c += d  # qhasm: c += d
 # asm 1: add  <d=int32#5,<c=int32#4  # asm 1: addl <d=int32#5,<c=int32#4
 # asm 2: add  <d=%esi,<c=%ebx  # asm 2: addl <d=%esi,<c=%ebx
 add  %esi,%ebx  addl %esi,%ebx
   
 # qhasm: c <<<= 13  # qhasm: c <<<= 13
 # asm 1: rol  $13,<c=int32#4  # asm 1: rol  $13,<c=int32#4
Line 1680 
Line 1680 
 rol  $13,%ebx  rol  $13,%ebx
   
 # qhasm: a ^= c  # qhasm: a ^= c
 # asm 1: xor  <c=int32#4,<a=int32#1  # asm 1: xorl <c=int32#4,<a=int32#2
 # asm 2: xor  <c=%ebx,<a=%eax  # asm 2: xorl <c=%ebx,<a=%ecx
 xor  %ebx,%eax  xorl %ebx,%ecx
   
 # qhasm:                t = x9  # qhasm:                t = x9
 # asm 1: movl <x9=stack32#27,>t=int32#4  # asm 1: movl <x9=stack32#27,>t=int32#4
Line 1690 
Line 1690 
 movl 104(%esp),%ebx  movl 104(%esp),%ebx
   
 # qhasm: x12 = a  # qhasm: x12 = a
 # asm 1: movl <a=int32#1,>x12=stack32#37  # asm 1: movl <a=int32#2,>x12=stack32#37
 # asm 2: movl <a=%eax,>x12=144(%esp)  # asm 2: movl <a=%ecx,>x12=144(%esp)
 movl %eax,144(%esp)  movl %ecx,144(%esp)
   
 # qhasm: a += d  # qhasm: a += d
 # asm 1: add  <d=int32#5,<a=int32#1  # asm 1: addl <d=int32#5,<a=int32#2
 # asm 2: add  <d=%esi,<a=%eax  # asm 2: addl <d=%esi,<a=%ecx
 add  %esi,%eax  addl %esi,%ecx
   
 # qhasm: a <<<= 18  # qhasm: a <<<= 18
 # asm 1: rol  $18,<a=int32#1  # asm 1: rol  $18,<a=int32#2
 # asm 2: rol  $18,<a=%eax  # asm 2: rol  $18,<a=%ecx
 rol  $18,%eax  rol  $18,%ecx
   
 # qhasm:                v = r + s  # qhasm:                v = r + s
 # asm 1: lea  (<r=int32#6,<s=int32#7),>v=int32#5  # asm 1: lea  (<r=int32#6,<s=int32#7),>v=int32#5
Line 1715 
Line 1715 
 rol  $7,%esi  rol  $7,%esi
   
 # qhasm:                t ^= v  # qhasm:                t ^= v
 # asm 1: xor  <v=int32#5,<t=int32#4  # asm 1: xorl <v=int32#5,<t=int32#4
 # asm 2: xor  <v=%esi,<t=%ebx  # asm 2: xorl <v=%esi,<t=%ebx
 xor  %esi,%ebx  xorl %esi,%ebx
   
 # qhasm:                x9 = t  # qhasm:                x9 = t
 # asm 1: movl <t=int32#4,>x9=stack32#27  # asm 1: movl <t=int32#4,>x9=stack32#27
Line 1730 
Line 1730 
 movl 120(%esp),%esi  movl 120(%esp),%esi
   
 # qhasm: b ^= a  # qhasm: b ^= a
 # asm 1: xor  <a=int32#1,<b=int32#3  # asm 1: xorl <a=int32#2,<b=int32#3
 # asm 2: xor  <a=%eax,<b=%edx  # asm 2: xorl <a=%ecx,<b=%edx
 xor  %eax,%edx  xorl %ecx,%edx
   
 # qhasm:                v = s + t  # qhasm:                v = s + t
 # asm 1: lea  (<s=int32#7,<t=int32#4),>v=int32#1  # asm 1: lea  (<s=int32#7,<t=int32#4),>v=int32#2
 # asm 2: lea  (<s=%ebp,<t=%ebx),>v=%eax  # asm 2: lea  (<s=%ebp,<t=%ebx),>v=%ecx
 lea  (%ebp,%ebx),%eax  lea  (%ebp,%ebx),%ecx
   
 # qhasm:                v <<<= 9  # qhasm:                v <<<= 9
 # asm 1: rol  $9,<v=int32#1  # asm 1: rol  $9,<v=int32#2
 # asm 2: rol  $9,<v=%eax  # asm 2: rol  $9,<v=%ecx
 rol  $9,%eax  rol  $9,%ecx
   
 # qhasm:                u ^= v  # qhasm:                u ^= v
 # asm 1: xor  <v=int32#1,<u=int32#5  # asm 1: xorl <v=int32#2,<u=int32#5
 # asm 2: xor  <v=%eax,<u=%esi  # asm 2: xorl <v=%ecx,<u=%esi
 xor  %eax,%esi  xorl %ecx,%esi
   
 # qhasm:                x13 = u  # qhasm:                x13 = u
 # asm 1: movl <u=int32#5,>x13=stack32#40  # asm 1: movl <u=int32#5,>x13=stack32#40
Line 1755 
Line 1755 
 movl %esi,156(%esp)  movl %esi,156(%esp)
   
 # qhasm:                                a = x6  # qhasm:                                a = x6
 # asm 1: movl <x6=stack32#38,>a=int32#1  # asm 1: movl <x6=stack32#38,>a=int32#2
 # asm 2: movl <x6=148(%esp),>a=%eax  # asm 2: movl <x6=148(%esp),>a=%ecx
 movl 148(%esp),%eax  movl 148(%esp),%ecx
   
 # qhasm: x0 = b  # qhasm: x0 = b
 # asm 1: movl <b=int32#3,>x0=stack32#31  # asm 1: movl <b=int32#3,>x0=stack32#31
Line 1770 
Line 1770 
 movl 136(%esp),%edx  movl 136(%esp),%edx
   
 # qhasm:                t += u  # qhasm:                t += u
 # asm 1: add  <u=int32#5,<t=int32#4  # asm 1: addl <u=int32#5,<t=int32#4
 # asm 2: add  <u=%esi,<t=%ebx  # asm 2: addl <u=%esi,<t=%ebx
 add  %esi,%ebx  addl %esi,%ebx
   
 # qhasm:                t <<<= 13  # qhasm:                t <<<= 13
 # asm 1: rol  $13,<t=int32#4  # asm 1: rol  $13,<t=int32#4
Line 1780 
Line 1780 
 rol  $13,%ebx  rol  $13,%ebx
   
 # qhasm:                r ^= t  # qhasm:                r ^= t
 # asm 1: xor  <t=int32#4,<r=int32#6  # asm 1: xorl <t=int32#4,<r=int32#6
 # asm 2: xor  <t=%ebx,<r=%edi  # asm 2: xorl <t=%ebx,<r=%edi
 xor  %ebx,%edi  xorl %ebx,%edi
   
 # qhasm:                                c = x14  # qhasm:                                c = x14
 # asm 1: movl <x14=stack32#32,>c=int32#4  # asm 1: movl <x14=stack32#32,>c=int32#4
Line 1795 
Line 1795 
 movl %edi,124(%esp)  movl %edi,124(%esp)
   
 # qhasm:                r += u  # qhasm:                r += u
 # asm 1: add  <u=int32#5,<r=int32#6  # asm 1: addl <u=int32#5,<r=int32#6
 # asm 2: add  <u=%esi,<r=%edi  # asm 2: addl <u=%esi,<r=%edi
 add  %esi,%edi  addl %esi,%edi
   
 # qhasm:                r <<<= 18  # qhasm:                r <<<= 18
 # asm 1: rol  $18,<r=int32#6  # asm 1: rol  $18,<r=int32#6
Line 1805 
Line 1805 
 rol  $18,%edi  rol  $18,%edi
   
 # qhasm:                                e = a + b  # qhasm:                                e = a + b
 # asm 1: lea  (<a=int32#1,<b=int32#3),>e=int32#5  # asm 1: lea  (<a=int32#2,<b=int32#3),>e=int32#5
 # asm 2: lea  (<a=%eax,<b=%edx),>e=%esi  # asm 2: lea  (<a=%ecx,<b=%edx),>e=%esi
 lea  (%eax,%edx),%esi  lea  (%ecx,%edx),%esi
   
 # qhasm:                                e <<<= 7  # qhasm:                                e <<<= 7
 # asm 1: rol  $7,<e=int32#5  # asm 1: rol  $7,<e=int32#5
Line 1815 
Line 1815 
 rol  $7,%esi  rol  $7,%esi
   
 # qhasm:                                c ^= e  # qhasm:                                c ^= e
 # asm 1: xor  <e=int32#5,<c=int32#4  # asm 1: xorl <e=int32#5,<c=int32#4
 # asm 2: xor  <e=%esi,<c=%ebx  # asm 2: xorl <e=%esi,<c=%ebx
 xor  %esi,%ebx  xorl %esi,%ebx
   
 # qhasm:                                x14 = c  # qhasm:                                x14 = c
 # asm 1: movl <c=int32#4,>x14=stack32#41  # asm 1: movl <c=int32#4,>x14=stack32#41
Line 1830 
Line 1830 
 movl 112(%esp),%esi  movl 112(%esp),%esi
   
 # qhasm:                s ^= r  # qhasm:                s ^= r
 # asm 1: xor  <r=int32#6,<s=int32#7  # asm 1: xorl <r=int32#6,<s=int32#7
 # asm 2: xor  <r=%edi,<s=%ebp  # asm 2: xorl <r=%edi,<s=%ebp
 xor  %edi,%ebp  xorl %edi,%ebp
   
 # qhasm:                                e = b + c  # qhasm:                                e = b + c
 # asm 1: lea  (<b=int32#3,<c=int32#4),>e=int32#6  # asm 1: lea  (<b=int32#3,<c=int32#4),>e=int32#6
Line 1845 
Line 1845 
 rol  $9,%edi  rol  $9,%edi
   
 # qhasm:                                d ^= e  # qhasm:                                d ^= e
 # asm 1: xor  <e=int32#6,<d=int32#5  # asm 1: xorl <e=int32#6,<d=int32#5
 # asm 2: xor  <e=%edi,<d=%esi  # asm 2: xorl <e=%edi,<d=%esi
 xor  %edi,%esi  xorl %edi,%esi
   
 # qhasm:                                x2 = d  # qhasm:                                x2 = d
 # asm 1: movl <d=int32#5,>x2=stack32#29  # asm 1: movl <d=int32#5,>x2=stack32#29
Line 1870 
Line 1870 
 movl 108(%esp),%ebp  movl 108(%esp),%ebp
   
 # qhasm:                                c += d  # qhasm:                                c += d
 # asm 1: add  <d=int32#5,<c=int32#4  # asm 1: addl <d=int32#5,<c=int32#4
 # asm 2: add  <d=%esi,<c=%ebx  # asm 2: addl <d=%esi,<c=%ebx
 add  %esi,%ebx  addl %esi,%ebx
   
 # qhasm:                                c <<<= 13  # qhasm:                                c <<<= 13
 # asm 1: rol  $13,<c=int32#4  # asm 1: rol  $13,<c=int32#4
Line 1880 
Line 1880 
 rol  $13,%ebx  rol  $13,%ebx
   
 # qhasm:                                a ^= c  # qhasm:                                a ^= c
 # asm 1: xor  <c=int32#4,<a=int32#1  # asm 1: xorl <c=int32#4,<a=int32#2
 # asm 2: xor  <c=%ebx,<a=%eax  # asm 2: xorl <c=%ebx,<a=%ecx
 xor  %ebx,%eax  xorl %ebx,%ecx
   
 # qhasm:                                                t = x3  # qhasm:                                                t = x3
 # asm 1: movl <x3=stack32#30,>t=int32#4  # asm 1: movl <x3=stack32#30,>t=int32#4
Line 1890 
Line 1890 
 movl 116(%esp),%ebx  movl 116(%esp),%ebx
   
 # qhasm:                                x6 = a  # qhasm:                                x6 = a
 # asm 1: movl <a=int32#1,>x6=stack32#30  # asm 1: movl <a=int32#2,>x6=stack32#30
 # asm 2: movl <a=%eax,>x6=116(%esp)  # asm 2: movl <a=%ecx,>x6=116(%esp)
 movl %eax,116(%esp)  movl %ecx,116(%esp)
   
 # qhasm:                                a += d  # qhasm:                                a += d
 # asm 1: add  <d=int32#5,<a=int32#1  # asm 1: addl <d=int32#5,<a=int32#2
 # asm 2: add  <d=%esi,<a=%eax  # asm 2: addl <d=%esi,<a=%ecx
 add  %esi,%eax  addl %esi,%ecx
   
 # qhasm:                                a <<<= 18  # qhasm:                                a <<<= 18
 # asm 1: rol  $18,<a=int32#1  # asm 1: rol  $18,<a=int32#2
 # asm 2: rol  $18,<a=%eax  # asm 2: rol  $18,<a=%ecx
 rol  $18,%eax  rol  $18,%ecx
   
 # qhasm:                                                v = r + s  # qhasm:                                                v = r + s
 # asm 1: lea  (<r=int32#6,<s=int32#7),>v=int32#5  # asm 1: lea  (<r=int32#6,<s=int32#7),>v=int32#5
Line 1915 
Line 1915 
 rol  $7,%esi  rol  $7,%esi
   
 # qhasm:                                                t ^= v  # qhasm:                                                t ^= v
 # asm 1: xor  <v=int32#5,<t=int32#4  # asm 1: xorl <v=int32#5,<t=int32#4
 # asm 2: xor  <v=%esi,<t=%ebx  # asm 2: xorl <v=%esi,<t=%ebx
 xor  %esi,%ebx  xorl %esi,%ebx
   
 # qhasm:                                                u = x7  # qhasm:                                                u = x7
 # asm 1: movl <x7=stack32#34,>u=int32#5  # asm 1: movl <x7=stack32#34,>u=int32#5
Line 1925 
Line 1925 
 movl 132(%esp),%esi  movl 132(%esp),%esi
   
 # qhasm:                                b ^= a  # qhasm:                                b ^= a
 # asm 1: xor  <a=int32#1,<b=int32#3  # asm 1: xorl <a=int32#2,<b=int32#3
 # asm 2: xor  <a=%eax,<b=%edx  # asm 2: xorl <a=%ecx,<b=%edx
 xor  %eax,%edx  xorl %ecx,%edx
   
 # qhasm:                                                v = s + t  # qhasm:                                                v = s + t
 # asm 1: lea  (<s=int32#7,<t=int32#4),>v=int32#1  # asm 1: lea  (<s=int32#7,<t=int32#4),>v=int32#2
 # asm 2: lea  (<s=%ebp,<t=%ebx),>v=%eax  # asm 2: lea  (<s=%ebp,<t=%ebx),>v=%ecx
 lea  (%ebp,%ebx),%eax  lea  (%ebp,%ebx),%ecx
   
 # qhasm:                                                v <<<= 9  # qhasm:                                                v <<<= 9
 # asm 1: rol  $9,<v=int32#1  # asm 1: rol  $9,<v=int32#2
 # asm 2: rol  $9,<v=%eax  # asm 2: rol  $9,<v=%ecx
 rol  $9,%eax  rol  $9,%ecx
   
 # qhasm:                                                u ^= v  # qhasm:                                                u ^= v
 # asm 1: xor  <v=int32#1,<u=int32#5  # asm 1: xorl <v=int32#2,<u=int32#5
 # asm 2: xor  <v=%eax,<u=%esi  # asm 2: xorl <v=%ecx,<u=%esi
 xor  %eax,%esi  xorl %ecx,%esi
   
 # qhasm:                                                x7 = u  # qhasm:                                                x7 = u
 # asm 1: movl <u=int32#5,>x7=stack32#34  # asm 1: movl <u=int32#5,>x7=stack32#34
Line 1950 
Line 1950 
 movl %esi,132(%esp)  movl %esi,132(%esp)
   
 # qhasm: a = t  # qhasm: a = t
 # asm 1: mov  <t=int32#4,>a=int32#1  # asm 1: mov  <t=int32#4,>a=int32#2
 # asm 2: mov  <t=%ebx,>a=%eax  # asm 2: mov  <t=%ebx,>a=%ecx
 mov  %ebx,%eax  mov  %ebx,%ecx
   
 # qhasm:                                x10 = b  # qhasm:                                x10 = b
 # asm 1: movl <b=int32#3,>x10=stack32#38  # asm 1: movl <b=int32#3,>x10=stack32#38
Line 1965 
Line 1965 
 movl 120(%esp),%edx  movl 120(%esp),%edx
   
 # qhasm:                                                t += u  # qhasm:                                                t += u
 # asm 1: add  <u=int32#5,<t=int32#4  # asm 1: addl <u=int32#5,<t=int32#4
 # asm 2: add  <u=%esi,<t=%ebx  # asm 2: addl <u=%esi,<t=%ebx
 add  %esi,%ebx  addl %esi,%ebx
   
 # qhasm:                                                t <<<= 13  # qhasm:                                                t <<<= 13
 # asm 1: rol  $13,<t=int32#4  # asm 1: rol  $13,<t=int32#4
Line 1975 
Line 1975 
 rol  $13,%ebx  rol  $13,%ebx
   
 # qhasm:                                                r ^= t  # qhasm:                                                r ^= t
 # asm 1: xor  <t=int32#4,<r=int32#6  # asm 1: xorl <t=int32#4,<r=int32#6
 # asm 2: xor  <t=%ebx,<r=%edi  # asm 2: xorl <t=%ebx,<r=%edi
 xor  %ebx,%edi  xorl %ebx,%edi
   
 # qhasm: c = x1  # qhasm: c = x1
 # asm 1: movl <x1=stack32#32,>c=int32#4  # asm 1: movl <x1=stack32#32,>c=int32#4
Line 1990 
Line 1990 
 movl %edi,120(%esp)  movl %edi,120(%esp)
   
 # qhasm:                                                r += u  # qhasm:                                                r += u
 # asm 1: add  <u=int32#5,<r=int32#6  # asm 1: addl <u=int32#5,<r=int32#6
 # asm 2: add  <u=%esi,<r=%edi  # asm 2: addl <u=%esi,<r=%edi
 add  %esi,%edi  addl %esi,%edi
   
 # qhasm:                                                r <<<= 18  # qhasm:                                                r <<<= 18
 # asm 1: rol  $18,<r=int32#6  # asm 1: rol  $18,<r=int32#6
Line 2000 
Line 2000 
 rol  $18,%edi  rol  $18,%edi
   
 # qhasm: e = a + b  # qhasm: e = a + b
 # asm 1: lea  (<a=int32#1,<b=int32#3),>e=int32#5  # asm 1: lea  (<a=int32#2,<b=int32#3),>e=int32#5
 # asm 2: lea  (<a=%eax,<b=%edx),>e=%esi  # asm 2: lea  (<a=%ecx,<b=%edx),>e=%esi
 lea  (%eax,%edx),%esi  lea  (%ecx,%edx),%esi
   
 # qhasm: e <<<= 7  # qhasm: e <<<= 7
 # asm 1: rol  $7,<e=int32#5  # asm 1: rol  $7,<e=int32#5
Line 2010 
Line 2010 
 rol  $7,%esi  rol  $7,%esi
   
 # qhasm: c ^= e  # qhasm: c ^= e
 # asm 1: xor  <e=int32#5,<c=int32#4  # asm 1: xorl <e=int32#5,<c=int32#4
 # asm 2: xor  <e=%esi,<c=%ebx  # asm 2: xorl <e=%esi,<c=%ebx
 xor  %esi,%ebx  xorl %esi,%ebx
   
 # qhasm: x1 = c  # qhasm: x1 = c
 # asm 1: movl <c=int32#4,>x1=stack32#28  # asm 1: movl <c=int32#4,>x1=stack32#28
Line 2025 
Line 2025 
 movl 112(%esp),%esi  movl 112(%esp),%esi
   
 # qhasm:                                                s ^= r  # qhasm:                                                s ^= r
 # asm 1: xor  <r=int32#6,<s=int32#7  # asm 1: xorl <r=int32#6,<s=int32#7
 # asm 2: xor  <r=%edi,<s=%ebp  # asm 2: xorl <r=%edi,<s=%ebp
 xor  %edi,%ebp  xorl %edi,%ebp
   
 # qhasm: e = b + c  # qhasm: e = b + c
 # asm 1: lea  (<b=int32#3,<c=int32#4),>e=int32#6  # asm 1: lea  (<b=int32#3,<c=int32#4),>e=int32#6
Line 2040 
Line 2040 
 rol  $9,%edi  rol  $9,%edi
   
 # qhasm: d ^= e  # qhasm: d ^= e
 # asm 1: xor  <e=int32#6,<d=int32#5  # asm 1: xorl <e=int32#6,<d=int32#5
 # asm 2: xor  <e=%edi,<d=%esi  # asm 2: xorl <e=%edi,<d=%esi
 xor  %edi,%esi  xorl %edi,%esi
   
 # qhasm: x2 = d  # qhasm: x2 = d
 # asm 1: movl <d=int32#5,>x2=stack32#29  # asm 1: movl <d=int32#5,>x2=stack32#29
Line 2065 
Line 2065 
 movl 136(%esp),%ebp  movl 136(%esp),%ebp
   
 # qhasm: c += d  # qhasm: c += d
 # asm 1: add  <d=int32#5,<c=int32#4  # asm 1: addl <d=int32#5,<c=int32#4
 # asm 2: add  <d=%esi,<c=%ebx  # asm 2: addl <d=%esi,<c=%ebx
 add  %esi,%ebx  addl %esi,%ebx
   
 # qhasm: c <<<= 13  # qhasm: c <<<= 13
 # asm 1: rol  $13,<c=int32#4  # asm 1: rol  $13,<c=int32#4
Line 2075 
Line 2075 
 rol  $13,%ebx  rol  $13,%ebx
   
 # qhasm: a ^= c  # qhasm: a ^= c
 # asm 1: xor  <c=int32#4,<a=int32#1  # asm 1: xorl <c=int32#4,<a=int32#2
 # asm 2: xor  <c=%ebx,<a=%eax  # asm 2: xorl <c=%ebx,<a=%ecx
 xor  %ebx,%eax  xorl %ebx,%ecx
   
 # qhasm:                t = x6  # qhasm:                t = x6
 # asm 1: movl <x6=stack32#30,>t=int32#4  # asm 1: movl <x6=stack32#30,>t=int32#4
Line 2085 
Line 2085 
 movl 116(%esp),%ebx  movl 116(%esp),%ebx
   
 # qhasm: x3 = a  # qhasm: x3 = a
 # asm 1: movl <a=int32#1,>x3=stack32#30  # asm 1: movl <a=int32#2,>x3=stack32#30
 # asm 2: movl <a=%eax,>x3=116(%esp)  # asm 2: movl <a=%ecx,>x3=116(%esp)
 movl %eax,116(%esp)  movl %ecx,116(%esp)
   
 # qhasm: a += d  # qhasm: a += d
 # asm 1: add  <d=int32#5,<a=int32#1  # asm 1: addl <d=int32#5,<a=int32#2
 # asm 2: add  <d=%esi,<a=%eax  # asm 2: addl <d=%esi,<a=%ecx
 add  %esi,%eax  addl %esi,%ecx
   
 # qhasm: a <<<= 18  # qhasm: a <<<= 18
 # asm 1: rol  $18,<a=int32#1  # asm 1: rol  $18,<a=int32#2
 # asm 2: rol  $18,<a=%eax  # asm 2: rol  $18,<a=%ecx
 rol  $18,%eax  rol  $18,%ecx
   
 # qhasm:                v = r + s  # qhasm:                v = r + s
 # asm 1: lea  (<r=int32#6,<s=int32#7),>v=int32#5  # asm 1: lea  (<r=int32#6,<s=int32#7),>v=int32#5
Line 2110 
Line 2110 
 rol  $7,%esi  rol  $7,%esi
   
 # qhasm:                t ^= v  # qhasm:                t ^= v
 # asm 1: xor  <v=int32#5,<t=int32#4  # asm 1: xorl <v=int32#5,<t=int32#4
 # asm 2: xor  <v=%esi,<t=%ebx  # asm 2: xorl <v=%esi,<t=%ebx
 xor  %esi,%ebx  xorl %esi,%ebx
   
 # qhasm:                x6 = t  # qhasm:                x6 = t
 # asm 1: movl <t=int32#4,>x6=stack32#33  # asm 1: movl <t=int32#4,>x6=stack32#33
Line 2125 
Line 2125 
 movl 132(%esp),%esi  movl 132(%esp),%esi
   
 # qhasm: b ^= a  # qhasm: b ^= a
 # asm 1: xor  <a=int32#1,<b=int32#3  # asm 1: xorl <a=int32#2,<b=int32#3
 # asm 2: xor  <a=%eax,<b=%edx  # asm 2: xorl <a=%ecx,<b=%edx
 xor  %eax,%edx  xorl %ecx,%edx
   
 # qhasm:                v = s + t  # qhasm:                v = s + t
 # asm 1: lea  (<s=int32#7,<t=int32#4),>v=int32#1  # asm 1: lea  (<s=int32#7,<t=int32#4),>v=int32#2
 # asm 2: lea  (<s=%ebp,<t=%ebx),>v=%eax  # asm 2: lea  (<s=%ebp,<t=%ebx),>v=%ecx
 lea  (%ebp,%ebx),%eax  lea  (%ebp,%ebx),%ecx
   
 # qhasm:                v <<<= 9  # qhasm:                v <<<= 9
 # asm 1: rol  $9,<v=int32#1  # asm 1: rol  $9,<v=int32#2
 # asm 2: rol  $9,<v=%eax  # asm 2: rol  $9,<v=%ecx
 rol  $9,%eax  rol  $9,%ecx
   
 # qhasm:                u ^= v  # qhasm:                u ^= v
 # asm 1: xor  <v=int32#1,<u=int32#5  # asm 1: xorl <v=int32#2,<u=int32#5
 # asm 2: xor  <v=%eax,<u=%esi  # asm 2: xorl <v=%ecx,<u=%esi
 xor  %eax,%esi  xorl %ecx,%esi
   
 # qhasm:                x7 = u  # qhasm:                x7 = u
 # asm 1: movl <u=int32#5,>x7=stack32#34  # asm 1: movl <u=int32#5,>x7=stack32#34
Line 2150 
Line 2150 
 movl %esi,132(%esp)  movl %esi,132(%esp)
   
 # qhasm:                                a = x9  # qhasm:                                a = x9
 # asm 1: movl <x9=stack32#27,>a=int32#1  # asm 1: movl <x9=stack32#27,>a=int32#2
 # asm 2: movl <x9=104(%esp),>a=%eax  # asm 2: movl <x9=104(%esp),>a=%ecx
 movl 104(%esp),%eax  movl 104(%esp),%ecx
   
 # qhasm: x0 = b  # qhasm: x0 = b
 # asm 1: movl <b=int32#3,>x0=stack32#27  # asm 1: movl <b=int32#3,>x0=stack32#27
Line 2165 
Line 2165 
 movl 148(%esp),%edx  movl 148(%esp),%edx
   
 # qhasm:                t += u  # qhasm:                t += u
 # asm 1: add  <u=int32#5,<t=int32#4  # asm 1: addl <u=int32#5,<t=int32#4
 # asm 2: add  <u=%esi,<t=%ebx  # asm 2: addl <u=%esi,<t=%ebx
 add  %esi,%ebx  addl %esi,%ebx
   
 # qhasm:                t <<<= 13  # qhasm:                t <<<= 13
 # asm 1: rol  $13,<t=int32#4  # asm 1: rol  $13,<t=int32#4
Line 2175 
Line 2175 
 rol  $13,%ebx  rol  $13,%ebx
   
 # qhasm:                r ^= t  # qhasm:                r ^= t
 # asm 1: xor  <t=int32#4,<r=int32#6  # asm 1: xorl <t=int32#4,<r=int32#6
 # asm 2: xor  <t=%ebx,<r=%edi  # asm 2: xorl <t=%ebx,<r=%edi
 xor  %ebx,%edi  xorl %ebx,%edi
   
 # qhasm:                                c = x11  # qhasm:                                c = x11
 # asm 1: movl <x11=stack32#31,>c=int32#4  # asm 1: movl <x11=stack32#31,>c=int32#4
Line 2190 
Line 2190 
 movl %edi,120(%esp)  movl %edi,120(%esp)
   
 # qhasm:                r += u  # qhasm:                r += u
 # asm 1: add  <u=int32#5,<r=int32#6  # asm 1: addl <u=int32#5,<r=int32#6
 # asm 2: add  <u=%esi,<r=%edi  # asm 2: addl <u=%esi,<r=%edi
 add  %esi,%edi  addl %esi,%edi
   
 # qhasm:                r <<<= 18  # qhasm:                r <<<= 18
 # asm 1: rol  $18,<r=int32#6  # asm 1: rol  $18,<r=int32#6
Line 2200 
Line 2200 
 rol  $18,%edi  rol  $18,%edi
   
 # qhasm:                                e = a + b  # qhasm:                                e = a + b
 # asm 1: lea  (<a=int32#1,<b=int32#3),>e=int32#5  # asm 1: lea  (<a=int32#2,<b=int32#3),>e=int32#5
 # asm 2: lea  (<a=%eax,<b=%edx),>e=%esi  # asm 2: lea  (<a=%ecx,<b=%edx),>e=%esi
 lea  (%eax,%edx),%esi  lea  (%ecx,%edx),%esi
   
 # qhasm:                                e <<<= 7  # qhasm:                                e <<<= 7
 # asm 1: rol  $7,<e=int32#5  # asm 1: rol  $7,<e=int32#5
Line 2210 
Line 2210 
 rol  $7,%esi  rol  $7,%esi
   
 # qhasm:                                c ^= e  # qhasm:                                c ^= e
 # asm 1: xor  <e=int32#5,<c=int32#4  # asm 1: xorl <e=int32#5,<c=int32#4
 # asm 2: xor  <e=%esi,<c=%ebx  # asm 2: xorl <e=%esi,<c=%ebx
 xor  %esi,%ebx  xorl %esi,%ebx
   
 # qhasm:                                x11 = c  # qhasm:                                x11 = c
 # asm 1: movl <c=int32#4,>x11=stack32#38  # asm 1: movl <c=int32#4,>x11=stack32#38
Line 2225 
Line 2225 
 movl 140(%esp),%esi  movl 140(%esp),%esi
   
 # qhasm:                s ^= r  # qhasm:                s ^= r
 # asm 1: xor  <r=int32#6,<s=int32#7  # asm 1: xorl <r=int32#6,<s=int32#7
 # asm 2: xor  <r=%edi,<s=%ebp  # asm 2: xorl <r=%edi,<s=%ebp
 xor  %edi,%ebp  xorl %edi,%ebp
   
 # qhasm:                                e = b + c  # qhasm:                                e = b + c
 # asm 1: lea  (<b=int32#3,<c=int32#4),>e=int32#6  # asm 1: lea  (<b=int32#3,<c=int32#4),>e=int32#6
Line 2240 
Line 2240 
 rol  $9,%edi  rol  $9,%edi
   
 # qhasm:                                d ^= e  # qhasm:                                d ^= e
 # asm 1: xor  <e=int32#6,<d=int32#5  # asm 1: xorl <e=int32#6,<d=int32#5
 # asm 2: xor  <e=%edi,<d=%esi  # asm 2: xorl <e=%edi,<d=%esi
 xor  %edi,%esi  xorl %edi,%esi
   
 # qhasm:                                x8 = d  # qhasm:                                x8 = d
 # asm 1: movl <d=int32#5,>x8=stack32#35  # asm 1: movl <d=int32#5,>x8=stack32#35
Line 2265 
Line 2265 
 movl 152(%esp),%ebp  movl 152(%esp),%ebp
   
 # qhasm:                                c += d  # qhasm:                                c += d
 # asm 1: add  <d=int32#5,<c=int32#4  # asm 1: addl <d=int32#5,<c=int32#4
 # asm 2: add  <d=%esi,<c=%ebx  # asm 2: addl <d=%esi,<c=%ebx
 add  %esi,%ebx  addl %esi,%ebx
   
 # qhasm:                                c <<<= 13  # qhasm:                                c <<<= 13
 # asm 1: rol  $13,<c=int32#4  # asm 1: rol  $13,<c=int32#4
Line 2275 
Line 2275 
 rol  $13,%ebx  rol  $13,%ebx
   
 # qhasm:                                a ^= c  # qhasm:                                a ^= c
 # asm 1: xor  <c=int32#4,<a=int32#1  # asm 1: xorl <c=int32#4,<a=int32#2
 # asm 2: xor  <c=%ebx,<a=%eax  # asm 2: xorl <c=%ebx,<a=%ecx
 xor  %ebx,%eax  xorl %ebx,%ecx
   
 # qhasm:                                                t = x12  # qhasm:                                                t = x12
 # asm 1: movl <x12=stack32#37,>t=int32#4  # asm 1: movl <x12=stack32#37,>t=int32#4
Line 2285 
Line 2285 
 movl 144(%esp),%ebx  movl 144(%esp),%ebx
   
 # qhasm:                                x9 = a  # qhasm:                                x9 = a
 # asm 1: movl <a=int32#1,>x9=stack32#36  # asm 1: movl <a=int32#2,>x9=stack32#36
 # asm 2: movl <a=%eax,>x9=140(%esp)  # asm 2: movl <a=%ecx,>x9=140(%esp)
 movl %eax,140(%esp)  movl %ecx,140(%esp)
   
 # qhasm:                                a += d  # qhasm:                                a += d
 # asm 1: add  <d=int32#5,<a=int32#1  # asm 1: addl <d=int32#5,<a=int32#2
 # asm 2: add  <d=%esi,<a=%eax  # asm 2: addl <d=%esi,<a=%ecx
 add  %esi,%eax  addl %esi,%ecx
   
 # qhasm:                                a <<<= 18  # qhasm:                                a <<<= 18
 # asm 1: rol  $18,<a=int32#1  # asm 1: rol  $18,<a=int32#2
 # asm 2: rol  $18,<a=%eax  # asm 2: rol  $18,<a=%ecx
 rol  $18,%eax  rol  $18,%ecx
   
 # qhasm:                                                v = r + s  # qhasm:                                                v = r + s
 # asm 1: lea  (<r=int32#6,<s=int32#7),>v=int32#5  # asm 1: lea  (<r=int32#6,<s=int32#7),>v=int32#5
Line 2310 
Line 2310 
 rol  $7,%esi  rol  $7,%esi
   
 # qhasm:                                                t ^= v  # qhasm:                                                t ^= v
 # asm 1: xor  <v=int32#5,<t=int32#4  # asm 1: xorl <v=int32#5,<t=int32#4
 # asm 2: xor  <v=%esi,<t=%ebx  # asm 2: xorl <v=%esi,<t=%ebx
 xor  %esi,%ebx  xorl %esi,%ebx
   
 # qhasm:                                                x12 = t  # qhasm:                                                x12 = t
 # asm 1: movl <t=int32#4,>x12=stack32#39  # asm 1: movl <t=int32#4,>x12=stack32#39
Line 2325 
Line 2325 
 movl 156(%esp),%esi  movl 156(%esp),%esi
   
 # qhasm:                                b ^= a  # qhasm:                                b ^= a
 # asm 1: xor  <a=int32#1,<b=int32#3  # asm 1: xorl <a=int32#2,<b=int32#3
 # asm 2: xor  <a=%eax,<b=%edx  # asm 2: xorl <a=%ecx,<b=%edx
 xor  %eax,%edx  xorl %ecx,%edx
   
 # qhasm:                                                v = s + t  # qhasm:                                                v = s + t
 # asm 1: lea  (<s=int32#7,<t=int32#4),>v=int32#1  # asm 1: lea  (<s=int32#7,<t=int32#4),>v=int32#2
 # asm 2: lea  (<s=%ebp,<t=%ebx),>v=%eax  # asm 2: lea  (<s=%ebp,<t=%ebx),>v=%ecx
 lea  (%ebp,%ebx),%eax  lea  (%ebp,%ebx),%ecx
   
 # qhasm:                                                v <<<= 9  # qhasm:                                                v <<<= 9
 # asm 1: rol  $9,<v=int32#1  # asm 1: rol  $9,<v=int32#2
 # asm 2: rol  $9,<v=%eax  # asm 2: rol  $9,<v=%ecx
 rol  $9,%eax  rol  $9,%ecx
   
 # qhasm:                                                u ^= v  # qhasm:                                                u ^= v
 # asm 1: xor  <v=int32#1,<u=int32#5  # asm 1: xorl <v=int32#2,<u=int32#5
 # asm 2: xor  <v=%eax,<u=%esi  # asm 2: xorl <v=%ecx,<u=%esi
 xor  %eax,%esi  xorl %ecx,%esi
   
 # qhasm:                                                x13 = u  # qhasm:                                                x13 = u
 # asm 1: movl <u=int32#5,>x13=stack32#40  # asm 1: movl <u=int32#5,>x13=stack32#40
Line 2350 
Line 2350 
 movl %esi,156(%esp)  movl %esi,156(%esp)
   
 # qhasm:                                                t += u  # qhasm:                                                t += u
 # asm 1: add  <u=int32#5,<t=int32#4  # asm 1: addl <u=int32#5,<t=int32#4
 # asm 2: add  <u=%esi,<t=%ebx  # asm 2: addl <u=%esi,<t=%ebx
 add  %esi,%ebx  addl %esi,%ebx
   
 # qhasm:                                x10 = b  # qhasm:                                x10 = b
 # asm 1: movl <b=int32#3,>x10=stack32#37  # asm 1: movl <b=int32#3,>x10=stack32#37
Line 2365 
Line 2365 
 rol  $13,%ebx  rol  $13,%ebx
   
 # qhasm:                                                r ^= t  # qhasm:                                                r ^= t
 # asm 1: xor  <t=int32#4,<r=int32#6  # asm 1: xorl <t=int32#4,<r=int32#6
 # asm 2: xor  <t=%ebx,<r=%edi  # asm 2: xorl <t=%ebx,<r=%edi
 xor  %ebx,%edi  xorl %ebx,%edi
   
 # qhasm:                                                x14 = r  # qhasm:                                                x14 = r
 # asm 1: movl <r=int32#6,>x14=stack32#41  # asm 1: movl <r=int32#6,>x14=stack32#41
Line 2375 
Line 2375 
 movl %edi,160(%esp)  movl %edi,160(%esp)
   
 # qhasm:                                                r += u  # qhasm:                                                r += u
 # asm 1: add  <u=int32#5,<r=int32#6  # asm 1: addl <u=int32#5,<r=int32#6
 # asm 2: add  <u=%esi,<r=%edi  # asm 2: addl <u=%esi,<r=%edi
 add  %esi,%edi  addl %esi,%edi
   
 # qhasm:                                                r <<<= 18  # qhasm:                                                r <<<= 18
 # asm 1: rol  $18,<r=int32#6  # asm 1: rol  $18,<r=int32#6
Line 2385 
Line 2385 
 rol  $18,%edi  rol  $18,%edi
   
 # qhasm:                                                s ^= r  # qhasm:                                                s ^= r
 # asm 1: xor  <r=int32#6,<s=int32#7  # asm 1: xorl <r=int32#6,<s=int32#7
 # asm 2: xor  <r=%edi,<s=%ebp  # asm 2: xorl <r=%edi,<s=%ebp
 xor  %edi,%ebp  xorl %edi,%ebp
   
 # qhasm:                                                x15 = s  # qhasm:                                                x15 = s
 # asm 1: movl <s=int32#7,>x15=stack32#42  # asm 1: movl <s=int32#7,>x15=stack32#42
Line 2395 
Line 2395 
 movl %ebp,164(%esp)  movl %ebp,164(%esp)
   
 # qhasm:                  unsigned>? i -= 4  # qhasm:                  unsigned>? i -= 4
 # asm 1: sub  $4,<i=int32#2  # asm 1: sub  $4,<i=int32#1
 # asm 2: sub  $4,<i=%ecx  # asm 2: sub  $4,<i=%eax
 sub  $4,%ecx  sub  $4,%eax
 # comment:fp stack unchanged by jump  # comment:fp stack unchanged by jump
   
 # qhasm: goto mainloop if unsigned>  # qhasm: goto mainloop if unsigned>
Line 2454 
Line 2454 
 movl %ecx,4(%edi)  movl %ecx,4(%edi)
   
 # qhasm:   in2 = x2  # qhasm:   in2 = x2
 # asm 1: movl <x2=stack32#29,>in2=int32#7  # asm 1: movl <x2=stack32#29,>in2=int32#1
 # asm 2: movl <x2=112(%esp),>in2=%ebp  # asm 2: movl <x2=112(%esp),>in2=%eax
 movl 112(%esp),%ebp  movl 112(%esp),%eax
   
 # qhasm:   in3 = x3  # qhasm:   in3 = x3
 # asm 1: movl <x3=stack32#30,>in3=int32#1  # asm 1: movl <x3=stack32#30,>in3=int32#2
 # asm 2: movl <x3=116(%esp),>in3=%eax  # asm 2: movl <x3=116(%esp),>in3=%ecx
 movl 116(%esp),%eax  movl 116(%esp),%ecx
   
 # qhasm:   in2 += j2  # qhasm:   in2 += j2
 # asm 1: addl <j2=stack32#8,<in2=int32#7  # asm 1: addl <j2=stack32#8,<in2=int32#1
 # asm 2: addl <j2=28(%esp),<in2=%ebp  # asm 2: addl <j2=28(%esp),<in2=%eax
 addl 28(%esp),%ebp  addl 28(%esp),%eax
   
 # qhasm:   in3 += j3  # qhasm:   in3 += j3
 # asm 1: addl <j3=stack32#9,<in3=int32#1  # asm 1: addl <j3=stack32#9,<in3=int32#2
 # asm 2: addl <j3=32(%esp),<in3=%eax  # asm 2: addl <j3=32(%esp),<in3=%ecx
 addl 32(%esp),%eax  addl 32(%esp),%ecx
   
 # qhasm:   in2 ^= *(uint32 *) (m + 8)  # qhasm:   in2 ^= *(uint32 *) (m + 8)
 # asm 1: xorl 8(<m=int32#5),<in2=int32#7  # asm 1: xorl 8(<m=int32#5),<in2=int32#1
 # asm 2: xorl 8(<m=%esi),<in2=%ebp  # asm 2: xorl 8(<m=%esi),<in2=%eax
 xorl 8(%esi),%ebp  xorl 8(%esi),%eax
   
 # qhasm:   in3 ^= *(uint32 *) (m + 12)  # qhasm:   in3 ^= *(uint32 *) (m + 12)
 # asm 1: xorl 12(<m=int32#5),<in3=int32#1  # asm 1: xorl 12(<m=int32#5),<in3=int32#2
 # asm 2: xorl 12(<m=%esi),<in3=%eax  # asm 2: xorl 12(<m=%esi),<in3=%ecx
 xorl 12(%esi),%eax  xorl 12(%esi),%ecx
   
 # qhasm:   *(uint32 *) (out + 8) = in2  # qhasm:   *(uint32 *) (out + 8) = in2
 # asm 1: movl <in2=int32#7,8(<out=int32#6)  # asm 1: movl <in2=int32#1,8(<out=int32#6)
 # asm 2: movl <in2=%ebp,8(<out=%edi)  # asm 2: movl <in2=%eax,8(<out=%edi)
 movl %ebp,8(%edi)  movl %eax,8(%edi)
   
 # qhasm:   *(uint32 *) (out + 12) = in3  # qhasm:   *(uint32 *) (out + 12) = in3
 # asm 1: movl <in3=int32#1,12(<out=int32#6)  # asm 1: movl <in3=int32#2,12(<out=int32#6)
 # asm 2: movl <in3=%eax,12(<out=%edi)  # asm 2: movl <in3=%ecx,12(<out=%edi)
 movl %eax,12(%edi)  movl %ecx,12(%edi)
   
 # qhasm:   in4 = x4  # qhasm:   in4 = x4
 # asm 1: movl <x4=stack32#31,>in4=int32#2  # asm 1: movl <x4=stack32#31,>in4=int32#1
 # asm 2: movl <x4=120(%esp),>in4=%ecx  # asm 2: movl <x4=120(%esp),>in4=%eax
 movl 120(%esp),%ecx  movl 120(%esp),%eax
   
 # qhasm:   in5 = x5  # qhasm:   in5 = x5
 # asm 1: movl <x5=stack32#32,>in5=int32#7  # asm 1: movl <x5=stack32#32,>in5=int32#2
 # asm 2: movl <x5=124(%esp),>in5=%ebp  # asm 2: movl <x5=124(%esp),>in5=%ecx
 movl 124(%esp),%ebp  movl 124(%esp),%ecx
   
 # qhasm:   in4 += j4  # qhasm:   in4 += j4
 # asm 1: addl <j4=stack32#10,<in4=int32#2  # asm 1: addl <j4=stack32#10,<in4=int32#1
 # asm 2: addl <j4=36(%esp),<in4=%ecx  # asm 2: addl <j4=36(%esp),<in4=%eax
 addl 36(%esp),%ecx  addl 36(%esp),%eax
   
 # qhasm:   in5 += j5  # qhasm:   in5 += j5
 # asm 1: addl <j5=stack32#11,<in5=int32#7  # asm 1: addl <j5=stack32#11,<in5=int32#2
 # asm 2: addl <j5=40(%esp),<in5=%ebp  # asm 2: addl <j5=40(%esp),<in5=%ecx
 addl 40(%esp),%ebp  addl 40(%esp),%ecx
   
 # qhasm:   in4 ^= *(uint32 *) (m + 16)  # qhasm:   in4 ^= *(uint32 *) (m + 16)
 # asm 1: xorl 16(<m=int32#5),<in4=int32#2  # asm 1: xorl 16(<m=int32#5),<in4=int32#1
 # asm 2: xorl 16(<m=%esi),<in4=%ecx  # asm 2: xorl 16(<m=%esi),<in4=%eax
 xorl 16(%esi),%ecx  xorl 16(%esi),%eax
   
 # qhasm:   in5 ^= *(uint32 *) (m + 20)  # qhasm:   in5 ^= *(uint32 *) (m + 20)
 # asm 1: xorl 20(<m=int32#5),<in5=int32#7  # asm 1: xorl 20(<m=int32#5),<in5=int32#2
 # asm 2: xorl 20(<m=%esi),<in5=%ebp  # asm 2: xorl 20(<m=%esi),<in5=%ecx
 xorl 20(%esi),%ebp  xorl 20(%esi),%ecx
   
 # qhasm:   *(uint32 *) (out + 16) = in4  # qhasm:   *(uint32 *) (out + 16) = in4
 # asm 1: movl <in4=int32#2,16(<out=int32#6)  # asm 1: movl <in4=int32#1,16(<out=int32#6)
 # asm 2: movl <in4=%ecx,16(<out=%edi)  # asm 2: movl <in4=%eax,16(<out=%edi)
 movl %ecx,16(%edi)  movl %eax,16(%edi)
   
 # qhasm:   *(uint32 *) (out + 20) = in5  # qhasm:   *(uint32 *) (out + 20) = in5
 # asm 1: movl <in5=int32#7,20(<out=int32#6)  # asm 1: movl <in5=int32#2,20(<out=int32#6)
 # asm 2: movl <in5=%ebp,20(<out=%edi)  # asm 2: movl <in5=%ecx,20(<out=%edi)
 movl %ebp,20(%edi)  movl %ecx,20(%edi)
   
 # qhasm:   in6 = x6  # qhasm:   in6 = x6
 # asm 1: movl <x6=stack32#33,>in6=int32#1  # asm 1: movl <x6=stack32#33,>in6=int32#1
Line 2614 
Line 2614 
 movl %ecx,36(%edi)  movl %ecx,36(%edi)
   
 # qhasm:   in10 = x10  # qhasm:   in10 = x10
 # asm 1: movl <x10=stack32#37,>in10=int32#2  # asm 1: movl <x10=stack32#37,>in10=int32#1
 # asm 2: movl <x10=144(%esp),>in10=%ecx  # asm 2: movl <x10=144(%esp),>in10=%eax
 movl 144(%esp),%ecx  movl 144(%esp),%eax
   
 # qhasm:   in11 = x11  # qhasm:   in11 = x11
 # asm 1: movl <x11=stack32#38,>in11=int32#7  # asm 1: movl <x11=stack32#38,>in11=int32#2
 # asm 2: movl <x11=148(%esp),>in11=%ebp  # asm 2: movl <x11=148(%esp),>in11=%ecx
 movl 148(%esp),%ebp  movl 148(%esp),%ecx
   
 # qhasm:   in10 += j10  # qhasm:   in10 += j10
 # asm 1: addl <j10=stack32#16,<in10=int32#2  # asm 1: addl <j10=stack32#16,<in10=int32#1
 # asm 2: addl <j10=60(%esp),<in10=%ecx  # asm 2: addl <j10=60(%esp),<in10=%eax
 addl 60(%esp),%ecx  addl 60(%esp),%eax
   
 # qhasm:   in11 += j11  # qhasm:   in11 += j11
 # asm 1: addl <j11=stack32#17,<in11=int32#7  # asm 1: addl <j11=stack32#17,<in11=int32#2
 # asm 2: addl <j11=64(%esp),<in11=%ebp  # asm 2: addl <j11=64(%esp),<in11=%ecx
 addl 64(%esp),%ebp  addl 64(%esp),%ecx
   
 # qhasm:   in10 ^= *(uint32 *) (m + 40)  # qhasm:   in10 ^= *(uint32 *) (m + 40)
 # asm 1: xorl 40(<m=int32#5),<in10=int32#2  # asm 1: xorl 40(<m=int32#5),<in10=int32#1
 # asm 2: xorl 40(<m=%esi),<in10=%ecx  # asm 2: xorl 40(<m=%esi),<in10=%eax
 xorl 40(%esi),%ecx  xorl 40(%esi),%eax
   
 # qhasm:   in11 ^= *(uint32 *) (m + 44)  # qhasm:   in11 ^= *(uint32 *) (m + 44)
 # asm 1: xorl 44(<m=int32#5),<in11=int32#7  # asm 1: xorl 44(<m=int32#5),<in11=int32#2
 # asm 2: xorl 44(<m=%esi),<in11=%ebp  # asm 2: xorl 44(<m=%esi),<in11=%ecx
 xorl 44(%esi),%ebp  xorl 44(%esi),%ecx
   
 # qhasm:   *(uint32 *) (out + 40) = in10  # qhasm:   *(uint32 *) (out + 40) = in10
 # asm 1: movl <in10=int32#2,40(<out=int32#6)  # asm 1: movl <in10=int32#1,40(<out=int32#6)
 # asm 2: movl <in10=%ecx,40(<out=%edi)  # asm 2: movl <in10=%eax,40(<out=%edi)
 movl %ecx,40(%edi)  movl %eax,40(%edi)
   
 # qhasm:   *(uint32 *) (out + 44) = in11  # qhasm:   *(uint32 *) (out + 44) = in11
 # asm 1: movl <in11=int32#7,44(<out=int32#6)  # asm 1: movl <in11=int32#2,44(<out=int32#6)
 # asm 2: movl <in11=%ebp,44(<out=%edi)  # asm 2: movl <in11=%ecx,44(<out=%edi)
 movl %ebp,44(%edi)  movl %ecx,44(%edi)
   
 # qhasm:   in12 = x12  # qhasm:   in12 = x12
 # asm 1: movl <x12=stack32#39,>in12=int32#1  # asm 1: movl <x12=stack32#39,>in12=int32#1
Line 2694 
Line 2694 
 movl %ecx,52(%edi)  movl %ecx,52(%edi)
   
 # qhasm:   in14 = x14  # qhasm:   in14 = x14
 # asm 1: movl <x14=stack32#41,>in14=int32#7  # asm 1: movl <x14=stack32#41,>in14=int32#1
 # asm 2: movl <x14=160(%esp),>in14=%ebp  # asm 2: movl <x14=160(%esp),>in14=%eax
 movl 160(%esp),%ebp  movl 160(%esp),%eax
   
 # qhasm:   in15 = x15  # qhasm:   in15 = x15
 # asm 1: movl <x15=stack32#42,>in15=int32#1  # asm 1: movl <x15=stack32#42,>in15=int32#2
 # asm 2: movl <x15=164(%esp),>in15=%eax  # asm 2: movl <x15=164(%esp),>in15=%ecx
 movl 164(%esp),%eax  movl 164(%esp),%ecx
   
 # qhasm:   in14 += j14  # qhasm:   in14 += j14
 # asm 1: addl <j14=stack32#20,<in14=int32#7  # asm 1: addl <j14=stack32#20,<in14=int32#1
 # asm 2: addl <j14=76(%esp),<in14=%ebp  # asm 2: addl <j14=76(%esp),<in14=%eax
 addl 76(%esp),%ebp  addl 76(%esp),%eax
   
 # qhasm:   in15 += j15  # qhasm:   in15 += j15
 # asm 1: addl <j15=stack32#21,<in15=int32#1  # asm 1: addl <j15=stack32#21,<in15=int32#2
 # asm 2: addl <j15=80(%esp),<in15=%eax  # asm 2: addl <j15=80(%esp),<in15=%ecx
 addl 80(%esp),%eax  addl 80(%esp),%ecx
   
 # qhasm:   in14 ^= *(uint32 *) (m + 56)  # qhasm:   in14 ^= *(uint32 *) (m + 56)
 # asm 1: xorl 56(<m=int32#5),<in14=int32#7  # asm 1: xorl 56(<m=int32#5),<in14=int32#1
 # asm 2: xorl 56(<m=%esi),<in14=%ebp  # asm 2: xorl 56(<m=%esi),<in14=%eax
 xorl 56(%esi),%ebp  xorl 56(%esi),%eax
   
 # qhasm:   in15 ^= *(uint32 *) (m + 60)  # qhasm:   in15 ^= *(uint32 *) (m + 60)
 # asm 1: xorl 60(<m=int32#5),<in15=int32#1  # asm 1: xorl 60(<m=int32#5),<in15=int32#2
 # asm 2: xorl 60(<m=%esi),<in15=%eax  # asm 2: xorl 60(<m=%esi),<in15=%ecx
 xorl 60(%esi),%eax  xorl 60(%esi),%ecx
   
 # qhasm:   *(uint32 *) (out + 56) = in14  # qhasm:   *(uint32 *) (out + 56) = in14
 # asm 1: movl <in14=int32#7,56(<out=int32#6)  # asm 1: movl <in14=int32#1,56(<out=int32#6)
 # asm 2: movl <in14=%ebp,56(<out=%edi)  # asm 2: movl <in14=%eax,56(<out=%edi)
 movl %ebp,56(%edi)  movl %eax,56(%edi)
   
 # qhasm:   *(uint32 *) (out + 60) = in15  # qhasm:   *(uint32 *) (out + 60) = in15
 # asm 1: movl <in15=int32#1,60(<out=int32#6)  # asm 1: movl <in15=int32#2,60(<out=int32#6)
 # asm 2: movl <in15=%eax,60(<out=%edi)  # asm 2: movl <in15=%ecx,60(<out=%edi)
 movl %eax,60(%edi)  movl %ecx,60(%edi)
   
 # qhasm:   bytes = bytes_backup  # qhasm:   bytes = bytes_backup
 # asm 1: movl <bytes_backup=stack32#26,>bytes=int32#4  # asm 1: movl <bytes_backup=stack32#26,>bytes=int32#4
Line 2739 
Line 2739 
 movl 100(%esp),%ebx  movl 100(%esp),%ebx
   
 # qhasm:   in8 = j8  # qhasm:   in8 = j8
 # asm 1: movl <j8=stack32#14,>in8=int32#7  # asm 1: movl <j8=stack32#14,>in8=int32#1
 # asm 2: movl <j8=52(%esp),>in8=%ebp  # asm 2: movl <j8=52(%esp),>in8=%eax
 movl 52(%esp),%ebp  movl 52(%esp),%eax
   
 # qhasm:   in9 = j9  # qhasm:   in9 = j9
 # asm 1: movl <j9=stack32#15,>in9=int32#1  # asm 1: movl <j9=stack32#15,>in9=int32#2
 # asm 2: movl <j9=56(%esp),>in9=%eax  # asm 2: movl <j9=56(%esp),>in9=%ecx
 movl 56(%esp),%eax  movl 56(%esp),%ecx
   
 # qhasm:   in8 += 1  # qhasm:   carry? in8 += 1
 # asm 1: add  $1,<in8=int32#7  # asm 1: add  $1,<in8=int32#1
 # asm 2: add  $1,<in8=%ebp  # asm 2: add  $1,<in8=%eax
 add  $1,%ebp  add  $1,%eax
   
 # qhasm:   in9 += 0 + carry  # qhasm:   in9 += 0 + carry
 # asm 1: adc  $0,<in9=int32#1  # asm 1: adc $0,<in9=int32#2
 # asm 2: adc  $0,<in9=%eax  # asm 2: adc $0,<in9=%ecx
 adc  $0,%eax  adc $0,%ecx
   
 # qhasm:   j8 = in8  # qhasm:   j8 = in8
 # asm 1: movl <in8=int32#7,>j8=stack32#14  # asm 1: movl <in8=int32#1,>j8=stack32#14
 # asm 2: movl <in8=%ebp,>j8=52(%esp)  # asm 2: movl <in8=%eax,>j8=52(%esp)
 movl %ebp,52(%esp)  movl %eax,52(%esp)
   
 # qhasm:   j9 = in9  # qhasm:   j9 = in9
 # asm 1: movl <in9=int32#1,>j9=stack32#15  # asm 1: movl <in9=int32#2,>j9=stack32#15
 # asm 2: movl <in9=%eax,>j9=56(%esp)  # asm 2: movl <in9=%ecx,>j9=56(%esp)
 movl %eax,56(%esp)  movl %ecx,56(%esp)
   
 # qhasm:                          unsigned>? unsigned<? bytes - 64  # qhasm:                          unsigned>? unsigned<? bytes - 64
 # asm 1: cmp  $64,<bytes=int32#4  # asm 1: cmp  $64,<bytes=int32#4
Line 2804 
Line 2804 
 ._bytesatleast64:  ._bytesatleast64:
   
 # qhasm:     x = x_backup  # qhasm:     x = x_backup
 # asm 1: movl <x_backup=stack32#22,>x=int32#3  # asm 1: movl <x_backup=stack32#22,>x=int32#1
 # asm 2: movl <x_backup=84(%esp),>x=%edx  # asm 2: movl <x_backup=84(%esp),>x=%eax
 movl 84(%esp),%edx  movl 84(%esp),%eax
   
 # qhasm:     in8 = j8  # qhasm:     in8 = j8
 # asm 1: movl <j8=stack32#14,>in8=int32#1  # asm 1: movl <j8=stack32#14,>in8=int32#2
 # asm 2: movl <j8=52(%esp),>in8=%eax  # asm 2: movl <j8=52(%esp),>in8=%ecx
 movl 52(%esp),%eax  movl 52(%esp),%ecx
   
 # qhasm:     in9 = j9  # qhasm:     in9 = j9
 # asm 1: movl <j9=stack32#15,>in9=int32#2  # asm 1: movl <j9=stack32#15,>in9=int32#3
 # asm 2: movl <j9=56(%esp),>in9=%ecx  # asm 2: movl <j9=56(%esp),>in9=%edx
 movl 56(%esp),%ecx  movl 56(%esp),%edx
   
 # qhasm:     *(uint32 *) (x + 32) = in8  # qhasm:     *(uint32 *) (x + 32) = in8
 # asm 1: movl <in8=int32#1,32(<x=int32#3)  # asm 1: movl <in8=int32#2,32(<x=int32#1)
 # asm 2: movl <in8=%eax,32(<x=%edx)  # asm 2: movl <in8=%ecx,32(<x=%eax)
 movl %eax,32(%edx)  movl %ecx,32(%eax)
   
 # qhasm:     *(uint32 *) (x + 36) = in9  # qhasm:     *(uint32 *) (x + 36) = in9
 # asm 1: movl <in9=int32#2,36(<x=int32#3)  # asm 1: movl <in9=int32#3,36(<x=int32#1)
 # asm 2: movl <in9=%ecx,36(<x=%edx)  # asm 2: movl <in9=%edx,36(<x=%eax)
 movl %ecx,36(%edx)  movl %edx,36(%eax)
 # comment:fp stack unchanged by fallthrough  # comment:fp stack unchanged by fallthrough
   
 # qhasm:     done:  # qhasm:     done:

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

Powered by ViewCVS 1.0-dev 		(Powered by Apache)

ViewCVS and CVS Help