# qhasm: int64 r11_caller

# qhasm: int64 r12_caller

# qhasm: int64 r13_caller

# qhasm: int64 r14_caller

# qhasm: int64 r15_caller

# qhasm: int64 rbx_caller

# qhasm: int64 rbp_caller

# qhasm: caller r11_caller

# qhasm: caller r12_caller

# qhasm: caller r13_caller

# qhasm: caller r14_caller

# qhasm: caller r15_caller

# qhasm: caller rbx_caller

# qhasm: caller rbp_caller

# qhasm: stack64 r11_stack

# qhasm: stack64 r12_stack

# qhasm: stack64 r13_stack

# qhasm: stack64 r14_stack

# qhasm: stack64 r15_stack

# qhasm: stack64 rbx_stack

# qhasm: stack64 rbp_stack

# qhasm: int64 table

# qhasm: int64 c

# qhasm: int64 k

# qhasm: int64 iv

# qhasm: int64 x0

# qhasm: int64 x1

# qhasm: int64 x2

# qhasm: int64 x3

# qhasm: int64 e

# qhasm: int64 in

# qhasm: int64 out

# qhasm: stack64 out_stack

# qhasm: stack64 n0

# qhasm: stack64 n1

# qhasm: stack64 n2

# qhasm: stack64 n3

# qhasm: stack64 r0

# qhasm: stack64 r1

# qhasm: stack64 r2

# qhasm: stack64 r3

# qhasm: stack64 r4

# qhasm: stack64 r5

# qhasm: stack64 r6

# qhasm: stack64 r7

# qhasm: stack64 r8

# qhasm: stack64 r9

# qhasm: stack64 r10

# qhasm: stack64 r11

# qhasm: stack64 r12

# qhasm: stack64 r13

# qhasm: stack64 r14

# qhasm: stack64 r15

# qhasm: stack64 r16

# qhasm: stack64 r17

# qhasm: stack64 r18

# qhasm: stack64 r19

# qhasm: stack64 r20

# qhasm: stack64 r21

# qhasm: stack64 r22

# qhasm: stack64 r23

# qhasm: stack64 r24

# qhasm: stack64 r25

# qhasm: stack64 r26

# qhasm: stack64 r27

# qhasm: stack64 r28

# qhasm: stack64 r29

# qhasm: stack64 r30

# qhasm: stack64 r31

# qhasm: stack64 r32

# qhasm: stack64 r33

# qhasm: stack64 r34

# qhasm: stack64 r35

# qhasm: stack64 r36

# qhasm: stack64 r37

# qhasm: stack64 r38

# qhasm: stack64 r39

# qhasm: stack64 r40

# qhasm: stack64 r41

# qhasm: stack64 r42

# qhasm: stack64 r43

# qhasm: int64 y0

# qhasm: int64 y1

# qhasm: int64 y2

# qhasm: int64 y3

# qhasm: int64 z0

# qhasm: int64 z1

# qhasm: int64 z2

# qhasm: int64 z3

# qhasm: int64 p00

# qhasm: int64 p01

# qhasm: int64 p02

# qhasm: int64 p03

# qhasm: int64 p10

# qhasm: int64 p11

# qhasm: int64 p12

# qhasm: int64 p13

# qhasm: int64 p20

# qhasm: int64 p21

# qhasm: int64 p22

# qhasm: int64 p23

# qhasm: int64 p30

# qhasm: int64 p31

# qhasm: int64 p32

# qhasm: int64 p33

# qhasm: int64 q00

# qhasm: int64 q01

# qhasm: int64 q02

# qhasm: int64 q03

# qhasm: int64 q10

# qhasm: int64 q11

# qhasm: int64 q12

# qhasm: int64 q13

# qhasm: int64 q20

# qhasm: int64 q21

# qhasm: int64 q22

# qhasm: int64 q23

# qhasm: int64 q30

# qhasm: int64 q31

# qhasm: int64 q32

# qhasm: int64 q33

# qhasm: enter aes128_amd64_2_block stackaligned4096 aes128_amd64_2_constants
.text
.p2align 5
.globl _aes128_amd64_2_block
.globl aes128_amd64_2_block
_aes128_amd64_2_block:
aes128_amd64_2_block:
mov %rsp,%r11
sub $aes128_amd64_2_constants,%r11
and $4095,%r11
add $416,%r11
sub %r11,%rsp

# qhasm: input out

# qhasm: input in

# qhasm: input c

# qhasm: out_stack = out
# asm 1: movq <out=int64#1,>out_stack=stack64#1
# asm 2: movq <out=%rdi,>out_stack=0(%rsp)
movq %rdi,0(%rsp)

# qhasm: r11_stack = r11_caller
# asm 1: movq <r11_caller=int64#9,>r11_stack=stack64#2
# asm 2: movq <r11_caller=%r11,>r11_stack=8(%rsp)
movq %r11,8(%rsp)

# qhasm: r12_stack = r12_caller
# asm 1: movq <r12_caller=int64#10,>r12_stack=stack64#3
# asm 2: movq <r12_caller=%r12,>r12_stack=16(%rsp)
movq %r12,16(%rsp)

# qhasm: r13_stack = r13_caller
# asm 1: movq <r13_caller=int64#11,>r13_stack=stack64#4
# asm 2: movq <r13_caller=%r13,>r13_stack=24(%rsp)
movq %r13,24(%rsp)

# qhasm: r14_stack = r14_caller
# asm 1: movq <r14_caller=int64#12,>r14_stack=stack64#5
# asm 2: movq <r14_caller=%r14,>r14_stack=32(%rsp)
movq %r14,32(%rsp)

# qhasm: r15_stack = r15_caller
# asm 1: movq <r15_caller=int64#13,>r15_stack=stack64#6
# asm 2: movq <r15_caller=%r15,>r15_stack=40(%rsp)
movq %r15,40(%rsp)

# qhasm: rbx_stack = rbx_caller
# asm 1: movq <rbx_caller=int64#14,>rbx_stack=stack64#7
# asm 2: movq <rbx_caller=%rbx,>rbx_stack=48(%rsp)
movq %rbx,48(%rsp)

# qhasm: rbp_stack = rbp_caller
# asm 1: movq <rbp_caller=int64#15,>rbp_stack=stack64#8
# asm 2: movq <rbp_caller=%rbp,>rbp_stack=56(%rsp)
movq %rbp,56(%rsp)

# qhasm: x0 = *(uint32 *) (c + 0)
# asm 1: movl   0(<c=int64#3),>x0=int64#1d
# asm 2: movl   0(<c=%rdx),>x0=%edi
movl   0(%rdx),%edi

# qhasm: x1 = *(uint32 *) (c + 4)
# asm 1: movl   4(<c=int64#3),>x1=int64#4d
# asm 2: movl   4(<c=%rdx),>x1=%ecx
movl   4(%rdx),%ecx

# qhasm: x2 = *(uint32 *) (c + 8)
# asm 1: movl   8(<c=int64#3),>x2=int64#5d
# asm 2: movl   8(<c=%rdx),>x2=%r8d
movl   8(%rdx),%r8d

# qhasm: x3 = *(uint32 *) (c + 12)
# asm 1: movl   12(<c=int64#3),>x3=int64#6d
# asm 2: movl   12(<c=%rdx),>x3=%r9d
movl   12(%rdx),%r9d

# qhasm: r0 = x0
# asm 1: movq <x0=int64#1,>r0=stack64#9
# asm 2: movq <x0=%rdi,>r0=64(%rsp)
movq %rdi,64(%rsp)

# qhasm: r1 = x1
# asm 1: movq <x1=int64#4,>r1=stack64#10
# asm 2: movq <x1=%rcx,>r1=72(%rsp)
movq %rcx,72(%rsp)

# qhasm: r2 = x2
# asm 1: movq <x2=int64#5,>r2=stack64#11
# asm 2: movq <x2=%r8,>r2=80(%rsp)
movq %r8,80(%rsp)

# qhasm: r3 = x3
# asm 1: movq <x3=int64#6,>r3=stack64#12
# asm 2: movq <x3=%r9,>r3=88(%rsp)
movq %r9,88(%rsp)

# qhasm: x0 = *(uint32 *) (c + 16)
# asm 1: movl   16(<c=int64#3),>x0=int64#1d
# asm 2: movl   16(<c=%rdx),>x0=%edi
movl   16(%rdx),%edi

# qhasm: x1 ^= x0
# asm 1: xor  <x0=int64#1,<x1=int64#4
# asm 2: xor  <x0=%rdi,<x1=%rcx
xor  %rdi,%rcx

# qhasm: x2 ^= x1
# asm 1: xor  <x1=int64#4,<x2=int64#5
# asm 2: xor  <x1=%rcx,<x2=%r8
xor  %rcx,%r8

# qhasm: x3 ^= x2
# asm 1: xor  <x2=int64#5,<x3=int64#6
# asm 2: xor  <x2=%r8,<x3=%r9
xor  %r8,%r9

# qhasm: r4 = x0
# asm 1: movq <x0=int64#1,>r4=stack64#13
# asm 2: movq <x0=%rdi,>r4=96(%rsp)
movq %rdi,96(%rsp)

# qhasm: r5 = x1
# asm 1: movq <x1=int64#4,>r5=stack64#14
# asm 2: movq <x1=%rcx,>r5=104(%rsp)
movq %rcx,104(%rsp)

# qhasm: r6 = x2
# asm 1: movq <x2=int64#5,>r6=stack64#15
# asm 2: movq <x2=%r8,>r6=112(%rsp)
movq %r8,112(%rsp)

# qhasm: r7 = x3
# asm 1: movq <x3=int64#6,>r7=stack64#16
# asm 2: movq <x3=%r9,>r7=120(%rsp)
movq %r9,120(%rsp)

# qhasm: x0 = *(uint32 *) (c + 20)
# asm 1: movl   20(<c=int64#3),>x0=int64#1d
# asm 2: movl   20(<c=%rdx),>x0=%edi
movl   20(%rdx),%edi

# qhasm: x1 ^= x0
# asm 1: xor  <x0=int64#1,<x1=int64#4
# asm 2: xor  <x0=%rdi,<x1=%rcx
xor  %rdi,%rcx

# qhasm: x2 ^= x1
# asm 1: xor  <x1=int64#4,<x2=int64#5
# asm 2: xor  <x1=%rcx,<x2=%r8
xor  %rcx,%r8

# qhasm: x3 ^= x2
# asm 1: xor  <x2=int64#5,<x3=int64#6
# asm 2: xor  <x2=%r8,<x3=%r9
xor  %r8,%r9

# qhasm: r8 = x0
# asm 1: movq <x0=int64#1,>r8=stack64#17
# asm 2: movq <x0=%rdi,>r8=128(%rsp)
movq %rdi,128(%rsp)

# qhasm: r9 = x1
# asm 1: movq <x1=int64#4,>r9=stack64#18
# asm 2: movq <x1=%rcx,>r9=136(%rsp)
movq %rcx,136(%rsp)

# qhasm: r10 = x2
# asm 1: movq <x2=int64#5,>r10=stack64#19
# asm 2: movq <x2=%r8,>r10=144(%rsp)
movq %r8,144(%rsp)

# qhasm: r11 = x3
# asm 1: movq <x3=int64#6,>r11=stack64#20
# asm 2: movq <x3=%r9,>r11=152(%rsp)
movq %r9,152(%rsp)

# qhasm: x0 = *(uint32 *) (c + 24)
# asm 1: movl   24(<c=int64#3),>x0=int64#1d
# asm 2: movl   24(<c=%rdx),>x0=%edi
movl   24(%rdx),%edi

# qhasm: x1 ^= x0
# asm 1: xor  <x0=int64#1,<x1=int64#4
# asm 2: xor  <x0=%rdi,<x1=%rcx
xor  %rdi,%rcx

# qhasm: x2 ^= x1
# asm 1: xor  <x1=int64#4,<x2=int64#5
# asm 2: xor  <x1=%rcx,<x2=%r8
xor  %rcx,%r8

# qhasm: x3 ^= x2
# asm 1: xor  <x2=int64#5,<x3=int64#6
# asm 2: xor  <x2=%r8,<x3=%r9
xor  %r8,%r9

# qhasm: r12 = x0
# asm 1: movq <x0=int64#1,>r12=stack64#21
# asm 2: movq <x0=%rdi,>r12=160(%rsp)
movq %rdi,160(%rsp)

# qhasm: r13 = x1
# asm 1: movq <x1=int64#4,>r13=stack64#22
# asm 2: movq <x1=%rcx,>r13=168(%rsp)
movq %rcx,168(%rsp)

# qhasm: r14 = x2
# asm 1: movq <x2=int64#5,>r14=stack64#23
# asm 2: movq <x2=%r8,>r14=176(%rsp)
movq %r8,176(%rsp)

# qhasm: r15 = x3
# asm 1: movq <x3=int64#6,>r15=stack64#24
# asm 2: movq <x3=%r9,>r15=184(%rsp)
movq %r9,184(%rsp)

# qhasm: x0 = *(uint32 *) (c + 28)
# asm 1: movl   28(<c=int64#3),>x0=int64#1d
# asm 2: movl   28(<c=%rdx),>x0=%edi
movl   28(%rdx),%edi

# qhasm: x1 ^= x0
# asm 1: xor  <x0=int64#1,<x1=int64#4
# asm 2: xor  <x0=%rdi,<x1=%rcx
xor  %rdi,%rcx

# qhasm: x2 ^= x1
# asm 1: xor  <x1=int64#4,<x2=int64#5
# asm 2: xor  <x1=%rcx,<x2=%r8
xor  %rcx,%r8

# qhasm: x3 ^= x2
# asm 1: xor  <x2=int64#5,<x3=int64#6
# asm 2: xor  <x2=%r8,<x3=%r9
xor  %r8,%r9

# qhasm: r16 = x0
# asm 1: movq <x0=int64#1,>r16=stack64#25
# asm 2: movq <x0=%rdi,>r16=192(%rsp)
movq %rdi,192(%rsp)

# qhasm: r17 = x1
# asm 1: movq <x1=int64#4,>r17=stack64#26
# asm 2: movq <x1=%rcx,>r17=200(%rsp)
movq %rcx,200(%rsp)

# qhasm: r18 = x2
# asm 1: movq <x2=int64#5,>r18=stack64#27
# asm 2: movq <x2=%r8,>r18=208(%rsp)
movq %r8,208(%rsp)

# qhasm: r19 = x3
# asm 1: movq <x3=int64#6,>r19=stack64#28
# asm 2: movq <x3=%r9,>r19=216(%rsp)
movq %r9,216(%rsp)

# qhasm: x0 = *(uint32 *) (c + 32)
# asm 1: movl   32(<c=int64#3),>x0=int64#1d
# asm 2: movl   32(<c=%rdx),>x0=%edi
movl   32(%rdx),%edi

# qhasm: x1 ^= x0
# asm 1: xor  <x0=int64#1,<x1=int64#4
# asm 2: xor  <x0=%rdi,<x1=%rcx
xor  %rdi,%rcx

# qhasm: x2 ^= x1
# asm 1: xor  <x1=int64#4,<x2=int64#5
# asm 2: xor  <x1=%rcx,<x2=%r8
xor  %rcx,%r8

# qhasm: x3 ^= x2
# asm 1: xor  <x2=int64#5,<x3=int64#6
# asm 2: xor  <x2=%r8,<x3=%r9
xor  %r8,%r9

# qhasm: r20 = x0
# asm 1: movq <x0=int64#1,>r20=stack64#29
# asm 2: movq <x0=%rdi,>r20=224(%rsp)
movq %rdi,224(%rsp)

# qhasm: r21 = x1
# asm 1: movq <x1=int64#4,>r21=stack64#30
# asm 2: movq <x1=%rcx,>r21=232(%rsp)
movq %rcx,232(%rsp)

# qhasm: r22 = x2
# asm 1: movq <x2=int64#5,>r22=stack64#31
# asm 2: movq <x2=%r8,>r22=240(%rsp)
movq %r8,240(%rsp)

# qhasm: r23 = x3
# asm 1: movq <x3=int64#6,>r23=stack64#32
# asm 2: movq <x3=%r9,>r23=248(%rsp)
movq %r9,248(%rsp)

# qhasm: x0 = *(uint32 *) (c + 36)
# asm 1: movl   36(<c=int64#3),>x0=int64#1d
# asm 2: movl   36(<c=%rdx),>x0=%edi
movl   36(%rdx),%edi

# qhasm: x1 ^= x0
# asm 1: xor  <x0=int64#1,<x1=int64#4
# asm 2: xor  <x0=%rdi,<x1=%rcx
xor  %rdi,%rcx

# qhasm: x2 ^= x1
# asm 1: xor  <x1=int64#4,<x2=int64#5
# asm 2: xor  <x1=%rcx,<x2=%r8
xor  %rcx,%r8

# qhasm: x3 ^= x2
# asm 1: xor  <x2=int64#5,<x3=int64#6
# asm 2: xor  <x2=%r8,<x3=%r9
xor  %r8,%r9

# qhasm: r24 = x0
# asm 1: movq <x0=int64#1,>r24=stack64#33
# asm 2: movq <x0=%rdi,>r24=256(%rsp)
movq %rdi,256(%rsp)

# qhasm: r25 = x1
# asm 1: movq <x1=int64#4,>r25=stack64#34
# asm 2: movq <x1=%rcx,>r25=264(%rsp)
movq %rcx,264(%rsp)

# qhasm: r26 = x2
# asm 1: movq <x2=int64#5,>r26=stack64#35
# asm 2: movq <x2=%r8,>r26=272(%rsp)
movq %r8,272(%rsp)

# qhasm: r27 = x3
# asm 1: movq <x3=int64#6,>r27=stack64#36
# asm 2: movq <x3=%r9,>r27=280(%rsp)
movq %r9,280(%rsp)

# qhasm: x0 = *(uint32 *) (c + 40)
# asm 1: movl   40(<c=int64#3),>x0=int64#1d
# asm 2: movl   40(<c=%rdx),>x0=%edi
movl   40(%rdx),%edi

# qhasm: x1 ^= x0
# asm 1: xor  <x0=int64#1,<x1=int64#4
# asm 2: xor  <x0=%rdi,<x1=%rcx
xor  %rdi,%rcx

# qhasm: x2 ^= x1
# asm 1: xor  <x1=int64#4,<x2=int64#5
# asm 2: xor  <x1=%rcx,<x2=%r8
xor  %rcx,%r8

# qhasm: x3 ^= x2
# asm 1: xor  <x2=int64#5,<x3=int64#6
# asm 2: xor  <x2=%r8,<x3=%r9
xor  %r8,%r9

# qhasm: r28 = x0
# asm 1: movq <x0=int64#1,>r28=stack64#37
# asm 2: movq <x0=%rdi,>r28=288(%rsp)
movq %rdi,288(%rsp)

# qhasm: r29 = x1
# asm 1: movq <x1=int64#4,>r29=stack64#38
# asm 2: movq <x1=%rcx,>r29=296(%rsp)
movq %rcx,296(%rsp)

# qhasm: r30 = x2
# asm 1: movq <x2=int64#5,>r30=stack64#39
# asm 2: movq <x2=%r8,>r30=304(%rsp)
movq %r8,304(%rsp)

# qhasm: r31 = x3
# asm 1: movq <x3=int64#6,>r31=stack64#40
# asm 2: movq <x3=%r9,>r31=312(%rsp)
movq %r9,312(%rsp)

# qhasm: x0 = *(uint32 *) (c + 44)
# asm 1: movl   44(<c=int64#3),>x0=int64#1d
# asm 2: movl   44(<c=%rdx),>x0=%edi
movl   44(%rdx),%edi

# qhasm: x1 ^= x0
# asm 1: xor  <x0=int64#1,<x1=int64#4
# asm 2: xor  <x0=%rdi,<x1=%rcx
xor  %rdi,%rcx

# qhasm: x2 ^= x1
# asm 1: xor  <x1=int64#4,<x2=int64#5
# asm 2: xor  <x1=%rcx,<x2=%r8
xor  %rcx,%r8

# qhasm: x3 ^= x2
# asm 1: xor  <x2=int64#5,<x3=int64#6
# asm 2: xor  <x2=%r8,<x3=%r9
xor  %r8,%r9

# qhasm: r32 = x0
# asm 1: movq <x0=int64#1,>r32=stack64#41
# asm 2: movq <x0=%rdi,>r32=320(%rsp)
movq %rdi,320(%rsp)

# qhasm: r33 = x1
# asm 1: movq <x1=int64#4,>r33=stack64#42
# asm 2: movq <x1=%rcx,>r33=328(%rsp)
movq %rcx,328(%rsp)

# qhasm: r34 = x2
# asm 1: movq <x2=int64#5,>r34=stack64#43
# asm 2: movq <x2=%r8,>r34=336(%rsp)
movq %r8,336(%rsp)

# qhasm: r35 = x3
# asm 1: movq <x3=int64#6,>r35=stack64#44
# asm 2: movq <x3=%r9,>r35=344(%rsp)
movq %r9,344(%rsp)

# qhasm: x0 = *(uint32 *) (c + 48)
# asm 1: movl   48(<c=int64#3),>x0=int64#1d
# asm 2: movl   48(<c=%rdx),>x0=%edi
movl   48(%rdx),%edi

# qhasm: x1 ^= x0
# asm 1: xor  <x0=int64#1,<x1=int64#4
# asm 2: xor  <x0=%rdi,<x1=%rcx
xor  %rdi,%rcx

# qhasm: x2 ^= x1
# asm 1: xor  <x1=int64#4,<x2=int64#5
# asm 2: xor  <x1=%rcx,<x2=%r8
xor  %rcx,%r8

# qhasm: x3 ^= x2
# asm 1: xor  <x2=int64#5,<x3=int64#6
# asm 2: xor  <x2=%r8,<x3=%r9
xor  %r8,%r9

# qhasm: r36 = x0
# asm 1: movq <x0=int64#1,>r36=stack64#45
# asm 2: movq <x0=%rdi,>r36=352(%rsp)
movq %rdi,352(%rsp)

# qhasm: r37 = x1
# asm 1: movq <x1=int64#4,>r37=stack64#46
# asm 2: movq <x1=%rcx,>r37=360(%rsp)
movq %rcx,360(%rsp)

# qhasm: r38 = x2
# asm 1: movq <x2=int64#5,>r38=stack64#47
# asm 2: movq <x2=%r8,>r38=368(%rsp)
movq %r8,368(%rsp)

# qhasm: r39 = x3
# asm 1: movq <x3=int64#6,>r39=stack64#48
# asm 2: movq <x3=%r9,>r39=376(%rsp)
movq %r9,376(%rsp)

# qhasm: x0 = *(uint32 *) (c + 52)
# asm 1: movl   52(<c=int64#3),>x0=int64#1d
# asm 2: movl   52(<c=%rdx),>x0=%edi
movl   52(%rdx),%edi

# qhasm: x1 ^= x0
# asm 1: xor  <x0=int64#1,<x1=int64#4
# asm 2: xor  <x0=%rdi,<x1=%rcx
xor  %rdi,%rcx

# qhasm: x2 ^= x1
# asm 1: xor  <x1=int64#4,<x2=int64#5
# asm 2: xor  <x1=%rcx,<x2=%r8
xor  %rcx,%r8

# qhasm: x3 ^= x2
# asm 1: xor  <x2=int64#5,<x3=int64#6
# asm 2: xor  <x2=%r8,<x3=%r9
xor  %r8,%r9

# qhasm: r40 = x0
# asm 1: movq <x0=int64#1,>r40=stack64#49
# asm 2: movq <x0=%rdi,>r40=384(%rsp)
movq %rdi,384(%rsp)

# qhasm: r41 = x1
# asm 1: movq <x1=int64#4,>r41=stack64#50
# asm 2: movq <x1=%rcx,>r41=392(%rsp)
movq %rcx,392(%rsp)

# qhasm: r42 = x2
# asm 1: movq <x2=int64#5,>r42=stack64#51
# asm 2: movq <x2=%r8,>r42=400(%rsp)
movq %r8,400(%rsp)

# qhasm: r43 = x3
# asm 1: movq <x3=int64#6,>r43=stack64#52
# asm 2: movq <x3=%r9,>r43=408(%rsp)
movq %r9,408(%rsp)

# qhasm: y0 = *(uint32 *) (in + 0)
# asm 1: movl   0(<in=int64#2),>y0=int64#3d
# asm 2: movl   0(<in=%rsi),>y0=%edx
movl   0(%rsi),%edx

# qhasm: y1 = *(uint32 *) (in + 4)
# asm 1: movl   4(<in=int64#2),>y1=int64#4d
# asm 2: movl   4(<in=%rsi),>y1=%ecx
movl   4(%rsi),%ecx

# qhasm: y2 = *(uint32 *) (in + 8)
# asm 1: movl   8(<in=int64#2),>y2=int64#7d
# asm 2: movl   8(<in=%rsi),>y2=%eax
movl   8(%rsi),%eax

# qhasm: y3 = *(uint32 *) (in + 12)
# asm 1: movl   12(<in=int64#2),>y3=int64#14d
# asm 2: movl   12(<in=%rsi),>y3=%ebx
movl   12(%rsi),%ebx

# qhasm: assign 3 to y0

# qhasm: assign 4 to y1

# qhasm: assign 7 to y2

# qhasm: assign 14 to y3

# qhasm: table = &aes128_amd64_2_tablex
# asm 1: lea  aes128_amd64_2_tablex(%rip),>table=int64#5
# asm 2: lea  aes128_amd64_2_tablex(%rip),>table=%r8
lea  aes128_amd64_2_tablex(%rip),%r8

# qhasm: y0 ^= r0
# asm 1: xorq <r0=stack64#9,<y0=int64#3
# asm 2: xorq <r0=64(%rsp),<y0=%rdx
xorq 64(%rsp),%rdx

# qhasm: y1 ^= r1
# asm 1: xorq <r1=stack64#10,<y1=int64#4
# asm 2: xorq <r1=72(%rsp),<y1=%rcx
xorq 72(%rsp),%rcx

# qhasm: y2 ^= r2
# asm 1: xorq <r2=stack64#11,<y2=int64#7
# asm 2: xorq <r2=80(%rsp),<y2=%rax
xorq 80(%rsp),%rax

# qhasm: y3 ^= r3
# asm 1: xorq <r3=stack64#12,<y3=int64#14
# asm 2: xorq <r3=88(%rsp),<y3=%rbx
xorq 88(%rsp),%rbx

# qhasm: p00 = y0 & 255
# asm 1: movzbl  <y0=int64#3b,>p00=int64#2d
# asm 2: movzbl  <y0=%dl,>p00=%esi
movzbl  %dl,%esi

# qhasm: p01 = (y0 >> 8) & 255
# asm 1: movzbl  <y0=int64#3%next8,>p01=int64#1d
# asm 2: movzbl  <y0=%dh,>p01=%edi
movzbl  %dh,%edi

# qhasm: (uint32) y0 >>= 16
# asm 1: shr  $16,<y0=int64#3d
# asm 2: shr  $16,<y0=%edx
shr  $16,%edx

# qhasm: p02 = y0 & 255
# asm 1: movzbl  <y0=int64#3b,>p02=int64#6d
# asm 2: movzbl  <y0=%dl,>p02=%r9d
movzbl  %dl,%r9d

# qhasm: p03 = (y0 >> 8) & 255
# asm 1: movzbl  <y0=int64#3%next8,>p03=int64#15d
# asm 2: movzbl  <y0=%dh,>p03=%ebp
movzbl  %dh,%ebp

# qhasm: z0 = *(uint32 *) (table + 3 + p00 * 8)
# asm 1: movl   3(<table=int64#5,<p00=int64#2,8),>z0=int64#3d
# asm 2: movl   3(<table=%r8,<p00=%rsi,8),>z0=%edx
movl   3(%r8,%rsi,8),%edx

# qhasm: assign 3 to z0

# qhasm: p10 = y1 & 255
# asm 1: movzbl  <y1=int64#4b,>p10=int64#8d
# asm 2: movzbl  <y1=%cl,>p10=%r10d
movzbl  %cl,%r10d

# qhasm: p11 = (y1 >> 8) & 255
# asm 1: movzbl  <y1=int64#4%next8,>p11=int64#2d
# asm 2: movzbl  <y1=%ch,>p11=%esi
movzbl  %ch,%esi

# qhasm: (uint32) z0 ^= *(uint32 *) (table + 2 + p11 * 8)
# asm 1: xorl 2(<table=int64#5,<p11=int64#2,8),<z0=int64#3d
# asm 2: xorl 2(<table=%r8,<p11=%rsi,8),<z0=%edx
xorl 2(%r8,%rsi,8),%edx

# qhasm: (uint32) y1 >>= 16
# asm 1: shr  $16,<y1=int64#4d
# asm 2: shr  $16,<y1=%ecx
shr  $16,%ecx

# qhasm: p12 = y1 & 255
# asm 1: movzbl  <y1=int64#4b,>p12=int64#9d
# asm 2: movzbl  <y1=%cl,>p12=%r11d
movzbl  %cl,%r11d

# qhasm: p13 = (y1 >> 8) & 255
# asm 1: movzbl  <y1=int64#4%next8,>p13=int64#2d
# asm 2: movzbl  <y1=%ch,>p13=%esi
movzbl  %ch,%esi

# qhasm: z1 = *(uint32 *) (table + 4 + p03 * 8)
# asm 1: movl   4(<table=int64#5,<p03=int64#15,8),>z1=int64#4d
# asm 2: movl   4(<table=%r8,<p03=%rbp,8),>z1=%ecx
movl   4(%r8,%rbp,8),%ecx

# qhasm: (uint32) z1 ^= *(uint32 *) (table + 3 + p10 * 8)
# asm 1: xorl 3(<table=int64#5,<p10=int64#8,8),<z1=int64#4d
# asm 2: xorl 3(<table=%r8,<p10=%r10,8),<z1=%ecx
xorl 3(%r8,%r10,8),%ecx

# qhasm: assign 4 to z1

# qhasm: p20 = y2 & 255
# asm 1: movzbl  <y2=int64#7b,>p20=int64#8d
# asm 2: movzbl  <y2=%al,>p20=%r10d
movzbl  %al,%r10d

# qhasm: p21 = (y2 >> 8) & 255
# asm 1: movzbl  <y2=int64#7%next8,>p21=int64#15d
# asm 2: movzbl  <y2=%ah,>p21=%ebp
movzbl  %ah,%ebp

# qhasm: (uint32) z1 ^= *(uint32 *) (table + 2 + p21 * 8)
# asm 1: xorl 2(<table=int64#5,<p21=int64#15,8),<z1=int64#4d
# asm 2: xorl 2(<table=%r8,<p21=%rbp,8),<z1=%ecx
xorl 2(%r8,%rbp,8),%ecx

# qhasm: (uint32) y2 >>= 16
# asm 1: shr  $16,<y2=int64#7d
# asm 2: shr  $16,<y2=%eax
shr  $16,%eax

# qhasm: p22 = y2 & 255
# asm 1: movzbl  <y2=int64#7b,>p22=int64#10d
# asm 2: movzbl  <y2=%al,>p22=%r12d
movzbl  %al,%r12d

# qhasm: (uint32) z0 ^= *(uint32 *) (table + 1 + p22 * 8)
# asm 1: xorl 1(<table=int64#5,<p22=int64#10,8),<z0=int64#3d
# asm 2: xorl 1(<table=%r8,<p22=%r12,8),<z0=%edx
xorl 1(%r8,%r12,8),%edx

# qhasm: p23 = (y2 >> 8) & 255
# asm 1: movzbl  <y2=int64#7%next8,>p23=int64#15d
# asm 2: movzbl  <y2=%ah,>p23=%ebp
movzbl  %ah,%ebp

# qhasm: z2 = *(uint32 *) (table + 1 + p02 * 8)
# asm 1: movl   1(<table=int64#5,<p02=int64#6,8),>z2=int64#7d
# asm 2: movl   1(<table=%r8,<p02=%r9,8),>z2=%eax
movl   1(%r8,%r9,8),%eax

# qhasm: (uint32) z2 ^= *(uint32 *) (table + 4 + p13 * 8)
# asm 1: xorl 4(<table=int64#5,<p13=int64#2,8),<z2=int64#7d
# asm 2: xorl 4(<table=%r8,<p13=%rsi,8),<z2=%eax
xorl 4(%r8,%rsi,8),%eax

# qhasm: (uint32) z2 ^= *(uint32 *) (table + 3 + p20 * 8)
# asm 1: xorl 3(<table=int64#5,<p20=int64#8,8),<z2=int64#7d
# asm 2: xorl 3(<table=%r8,<p20=%r10,8),<z2=%eax
xorl 3(%r8,%r10,8),%eax

# qhasm: assign 7 to z2

# qhasm: p30 = y3 & 255
# asm 1: movzbl  <y3=int64#14b,>p30=int64#6d
# asm 2: movzbl  <y3=%bl,>p30=%r9d
movzbl  %bl,%r9d

# qhasm: p31 = (y3 >> 8) & 255
# asm 1: movzbl  <y3=int64#14%next8,>p31=int64#2d
# asm 2: movzbl  <y3=%bh,>p31=%esi
movzbl  %bh,%esi

# qhasm: (uint32) z2 ^= *(uint32 *) (table + 2 + p31 * 8)
# asm 1: xorl 2(<table=int64#5,<p31=int64#2,8),<z2=int64#7d
# asm 2: xorl 2(<table=%r8,<p31=%rsi,8),<z2=%eax
xorl 2(%r8,%rsi,8),%eax

# qhasm: (uint32) y3 >>= 16
# asm 1: shr  $16,<y3=int64#14d
# asm 2: shr  $16,<y3=%ebx
shr  $16,%ebx

# qhasm: p32 = y3 & 255
# asm 1: movzbl  <y3=int64#14b,>p32=int64#2d
# asm 2: movzbl  <y3=%bl,>p32=%esi
movzbl  %bl,%esi

# qhasm: (uint32) z1 ^= *(uint32 *) (table + 1 + p32 * 8)
# asm 1: xorl 1(<table=int64#5,<p32=int64#2,8),<z1=int64#4d
# asm 2: xorl 1(<table=%r8,<p32=%rsi,8),<z1=%ecx
xorl 1(%r8,%rsi,8),%ecx

# qhasm: p33 = (y3 >> 8) & 255
# asm 1: movzbl  <y3=int64#14%next8,>p33=int64#14d
# asm 2: movzbl  <y3=%bh,>p33=%ebx
movzbl  %bh,%ebx

# qhasm: (uint32) z0 ^= *(uint32 *) (table + 4 + p33 * 8)
# asm 1: xorl 4(<table=int64#5,<p33=int64#14,8),<z0=int64#3d
# asm 2: xorl 4(<table=%r8,<p33=%rbx,8),<z0=%edx
xorl 4(%r8,%rbx,8),%edx

# qhasm: z3 = *(uint32 *) (table + 2 + p01 * 8)
# asm 1: movl   2(<table=int64#5,<p01=int64#1,8),>z3=int64#14d
# asm 2: movl   2(<table=%r8,<p01=%rdi,8),>z3=%ebx
movl   2(%r8,%rdi,8),%ebx

# qhasm: z2 ^= r6
# asm 1: xorq <r6=stack64#15,<z2=int64#7
# asm 2: xorq <r6=112(%rsp),<z2=%rax
xorq 112(%rsp),%rax

# qhasm: (uint32) z3 ^= *(uint32 *) (table + 1 + p12 * 8)
# asm 1: xorl 1(<table=int64#5,<p12=int64#9,8),<z3=int64#14d
# asm 2: xorl 1(<table=%r8,<p12=%r11,8),<z3=%ebx
xorl 1(%r8,%r11,8),%ebx

# qhasm: z1 ^= r5
# asm 1: xorq <r5=stack64#14,<z1=int64#4
# asm 2: xorq <r5=104(%rsp),<z1=%rcx
xorq 104(%rsp),%rcx

# qhasm: (uint32) z3 ^= *(uint32 *) (table + 4 + p23 * 8)
# asm 1: xorl 4(<table=int64#5,<p23=int64#15,8),<z3=int64#14d
# asm 2: xorl 4(<table=%r8,<p23=%rbp,8),<z3=%ebx
xorl 4(%r8,%rbp,8),%ebx

# qhasm: z0 ^= r4
# asm 1: xorq <r4=stack64#13,<z0=int64#3
# asm 2: xorq <r4=96(%rsp),<z0=%rdx
xorq 96(%rsp),%rdx

# qhasm: (uint32) z3 ^= *(uint32 *) (table + 3 + p30 * 8)
# asm 1: xorl 3(<table=int64#5,<p30=int64#6,8),<z3=int64#14d
# asm 2: xorl 3(<table=%r8,<p30=%r9,8),<z3=%ebx
xorl 3(%r8,%r9,8),%ebx

# qhasm: z3 ^= r7
# asm 1: xorq <r7=stack64#16,<z3=int64#14
# asm 2: xorq <r7=120(%rsp),<z3=%rbx
xorq 120(%rsp),%rbx

# qhasm: assign 14 to z3

# qhasm: q00 = z0 & 255
# asm 1: movzbl  <z0=int64#3b,>q00=int64#2d
# asm 2: movzbl  <z0=%dl,>q00=%esi
movzbl  %dl,%esi

# qhasm: q03 = (z0 >> 8) & 255
# asm 1: movzbl  <z0=int64#3%next8,>q03=int64#1d
# asm 2: movzbl  <z0=%dh,>q03=%edi
movzbl  %dh,%edi

# qhasm: (uint32) z0 >>= 16
# asm 1: shr  $16,<z0=int64#3d
# asm 2: shr  $16,<z0=%edx
shr  $16,%edx

# qhasm: q02 = z0 & 255
# asm 1: movzbl  <z0=int64#3b,>q02=int64#6d
# asm 2: movzbl  <z0=%dl,>q02=%r9d
movzbl  %dl,%r9d

# qhasm: q01 = (z0 >> 8) & 255
# asm 1: movzbl  <z0=int64#3%next8,>q01=int64#15d
# asm 2: movzbl  <z0=%dh,>q01=%ebp
movzbl  %dh,%ebp

# qhasm: y0 = *(uint32 *) (table + 3 + q00 * 8)
# asm 1: movl   3(<table=int64#5,<q00=int64#2,8),>y0=int64#3d
# asm 2: movl   3(<table=%r8,<q00=%rsi,8),>y0=%edx
movl   3(%r8,%rsi,8),%edx

# qhasm: assign 3 to y0

# qhasm: q10 = z1 & 255
# asm 1: movzbl  <z1=int64#4b,>q10=int64#8d
# asm 2: movzbl  <z1=%cl,>q10=%r10d
movzbl  %cl,%r10d

# qhasm: q11 = (z1 >> 8) & 255
# asm 1: movzbl  <z1=int64#4%next8,>q11=int64#2d
# asm 2: movzbl  <z1=%ch,>q11=%esi
movzbl  %ch,%esi

# qhasm: (uint32) y0 ^= *(uint32 *) (table + 2 + q11 * 8)
# asm 1: xorl 2(<table=int64#5,<q11=int64#2,8),<y0=int64#3d
# asm 2: xorl 2(<table=%r8,<q11=%rsi,8),<y0=%edx
xorl 2(%r8,%rsi,8),%edx

# qhasm: (uint32) z1 >>= 16
# asm 1: shr  $16,<z1=int64#4d
# asm 2: shr  $16,<z1=%ecx
shr  $16,%ecx

# qhasm: q12 = z1 & 255
# asm 1: movzbl  <z1=int64#4b,>q12=int64#9d
# asm 2: movzbl  <z1=%cl,>q12=%r11d
movzbl  %cl,%r11d

# qhasm: q13 = (z1 >> 8) & 255
# asm 1: movzbl  <z1=int64#4%next8,>q13=int64#2d
# asm 2: movzbl  <z1=%ch,>q13=%esi
movzbl  %ch,%esi

# qhasm: y1 = *(uint32 *) (table + 4 + q01 * 8)
# asm 1: movl   4(<table=int64#5,<q01=int64#15,8),>y1=int64#4d
# asm 2: movl   4(<table=%r8,<q01=%rbp,8),>y1=%ecx
movl   4(%r8,%rbp,8),%ecx

# qhasm: (uint32) y1 ^= *(uint32 *) (table + 3 + q10 * 8)
# asm 1: xorl 3(<table=int64#5,<q10=int64#8,8),<y1=int64#4d
# asm 2: xorl 3(<table=%r8,<q10=%r10,8),<y1=%ecx
xorl 3(%r8,%r10,8),%ecx

# qhasm: assign 4 to y1

# qhasm: q20 = z2 & 255
# asm 1: movzbl  <z2=int64#7b,>q20=int64#8d
# asm 2: movzbl  <z2=%al,>q20=%r10d
movzbl  %al,%r10d

# qhasm: q21 = (z2 >> 8) & 255
# asm 1: movzbl  <z2=int64#7%next8,>q21=int64#15d
# asm 2: movzbl  <z2=%ah,>q21=%ebp
movzbl  %ah,%ebp

# qhasm: (uint32) y1 ^= *(uint32 *) (table + 2 + q21 * 8)
# asm 1: xorl 2(<table=int64#5,<q21=int64#15,8),<y1=int64#4d
# asm 2: xorl 2(<table=%r8,<q21=%rbp,8),<y1=%ecx
xorl 2(%r8,%rbp,8),%ecx

# qhasm: (uint32) z2 >>= 16
# asm 1: shr  $16,<z2=int64#7d
# asm 2: shr  $16,<z2=%eax
shr  $16,%eax

# qhasm: q22 = z2 & 255
# asm 1: movzbl  <z2=int64#7b,>q22=int64#10d
# asm 2: movzbl  <z2=%al,>q22=%r12d
movzbl  %al,%r12d

# qhasm: (uint32) y0 ^= *(uint32 *) (table + 1 + q22 * 8)
# asm 1: xorl 1(<table=int64#5,<q22=int64#10,8),<y0=int64#3d
# asm 2: xorl 1(<table=%r8,<q22=%r12,8),<y0=%edx
xorl 1(%r8,%r12,8),%edx

# qhasm: q23 = (z2 >> 8) & 255
# asm 1: movzbl  <z2=int64#7%next8,>q23=int64#15d
# asm 2: movzbl  <z2=%ah,>q23=%ebp
movzbl  %ah,%ebp

# qhasm: y2 = *(uint32 *) (table + 1 + q02 * 8)
# asm 1: movl   1(<table=int64#5,<q02=int64#6,8),>y2=int64#7d
# asm 2: movl   1(<table=%r8,<q02=%r9,8),>y2=%eax
movl   1(%r8,%r9,8),%eax

# qhasm: (uint32) y2 ^= *(uint32 *) (table + 4 + q13 * 8)
# asm 1: xorl 4(<table=int64#5,<q13=int64#2,8),<y2=int64#7d
# asm 2: xorl 4(<table=%r8,<q13=%rsi,8),<y2=%eax
xorl 4(%r8,%rsi,8),%eax

# qhasm: (uint32) y2 ^= *(uint32 *) (table + 3 + q20 * 8)
# asm 1: xorl 3(<table=int64#5,<q20=int64#8,8),<y2=int64#7d
# asm 2: xorl 3(<table=%r8,<q20=%r10,8),<y2=%eax
xorl 3(%r8,%r10,8),%eax

# qhasm: assign 7 to y2

# qhasm: q30 = z3 & 255
# asm 1: movzbl  <z3=int64#14b,>q30=int64#6d
# asm 2: movzbl  <z3=%bl,>q30=%r9d
movzbl  %bl,%r9d

# qhasm: q31 = (z3 >> 8) & 255
# asm 1: movzbl  <z3=int64#14%next8,>q31=int64#2d
# asm 2: movzbl  <z3=%bh,>q31=%esi
movzbl  %bh,%esi

# qhasm: (uint32) y2 ^= *(uint32 *) (table + 2 + q31 * 8)
# asm 1: xorl 2(<table=int64#5,<q31=int64#2,8),<y2=int64#7d
# asm 2: xorl 2(<table=%r8,<q31=%rsi,8),<y2=%eax
xorl 2(%r8,%rsi,8),%eax

# qhasm: (uint32) z3 >>= 16
# asm 1: shr  $16,<z3=int64#14d
# asm 2: shr  $16,<z3=%ebx
shr  $16,%ebx

# qhasm: q32 = z3 & 255
# asm 1: movzbl  <z3=int64#14b,>q32=int64#2d
# asm 2: movzbl  <z3=%bl,>q32=%esi
movzbl  %bl,%esi

# qhasm: (uint32) y1 ^= *(uint32 *) (table + 1 + q32 * 8)
# asm 1: xorl 1(<table=int64#5,<q32=int64#2,8),<y1=int64#4d
# asm 2: xorl 1(<table=%r8,<q32=%rsi,8),<y1=%ecx
xorl 1(%r8,%rsi,8),%ecx

# qhasm: q33 = (z3 >> 8) & 255
# asm 1: movzbl  <z3=int64#14%next8,>q33=int64#14d
# asm 2: movzbl  <z3=%bh,>q33=%ebx
movzbl  %bh,%ebx

# qhasm: (uint32) y0 ^= *(uint32 *) (table + 4 + q33 * 8)
# asm 1: xorl 4(<table=int64#5,<q33=int64#14,8),<y0=int64#3d
# asm 2: xorl 4(<table=%r8,<q33=%rbx,8),<y0=%edx
xorl 4(%r8,%rbx,8),%edx

# qhasm: y3 = *(uint32 *) (table + 2 + q03 * 8)
# asm 1: movl   2(<table=int64#5,<q03=int64#1,8),>y3=int64#14d
# asm 2: movl   2(<table=%r8,<q03=%rdi,8),>y3=%ebx
movl   2(%r8,%rdi,8),%ebx

# qhasm: y2 ^= r10
# asm 1: xorq <r10=stack64#19,<y2=int64#7
# asm 2: xorq <r10=144(%rsp),<y2=%rax
xorq 144(%rsp),%rax

# qhasm: (uint32) y3 ^= *(uint32 *) (table + 1 + q12 * 8)
# asm 1: xorl 1(<table=int64#5,<q12=int64#9,8),<y3=int64#14d
# asm 2: xorl 1(<table=%r8,<q12=%r11,8),<y3=%ebx
xorl 1(%r8,%r11,8),%ebx

# qhasm: y1 ^= r9
# asm 1: xorq <r9=stack64#18,<y1=int64#4
# asm 2: xorq <r9=136(%rsp),<y1=%rcx
xorq 136(%rsp),%rcx

# qhasm: (uint32) y3 ^= *(uint32 *) (table + 4 + q23 * 8)
# asm 1: xorl 4(<table=int64#5,<q23=int64#15,8),<y3=int64#14d
# asm 2: xorl 4(<table=%r8,<q23=%rbp,8),<y3=%ebx
xorl 4(%r8,%rbp,8),%ebx

# qhasm: y0 ^= r8
# asm 1: xorq <r8=stack64#17,<y0=int64#3
# asm 2: xorq <r8=128(%rsp),<y0=%rdx
xorq 128(%rsp),%rdx

# qhasm: (uint32) y3 ^= *(uint32 *) (table + 3 + q30 * 8)
# asm 1: xorl 3(<table=int64#5,<q30=int64#6,8),<y3=int64#14d
# asm 2: xorl 3(<table=%r8,<q30=%r9,8),<y3=%ebx
xorl 3(%r8,%r9,8),%ebx

# qhasm: y3 ^= r11
# asm 1: xorq <r11=stack64#20,<y3=int64#14
# asm 2: xorq <r11=152(%rsp),<y3=%rbx
xorq 152(%rsp),%rbx

# qhasm: assign 14 to y3

# qhasm: p00 = y0 & 255
# asm 1: movzbl  <y0=int64#3b,>p00=int64#2d
# asm 2: movzbl  <y0=%dl,>p00=%esi
movzbl  %dl,%esi

# qhasm: p01 = (y0 >> 8) & 255
# asm 1: movzbl  <y0=int64#3%next8,>p01=int64#1d
# asm 2: movzbl  <y0=%dh,>p01=%edi
movzbl  %dh,%edi

# qhasm: (uint32) y0 >>= 16
# asm 1: shr  $16,<y0=int64#3d
# asm 2: shr  $16,<y0=%edx
shr  $16,%edx

# qhasm: p02 = y0 & 255
# asm 1: movzbl  <y0=int64#3b,>p02=int64#6d
# asm 2: movzbl  <y0=%dl,>p02=%r9d
movzbl  %dl,%r9d

# qhasm: p03 = (y0 >> 8) & 255
# asm 1: movzbl  <y0=int64#3%next8,>p03=int64#15d
# asm 2: movzbl  <y0=%dh,>p03=%ebp
movzbl  %dh,%ebp

# qhasm: z0 = *(uint32 *) (table + 3 + p00 * 8)
# asm 1: movl   3(<table=int64#5,<p00=int64#2,8),>z0=int64#3d
# asm 2: movl   3(<table=%r8,<p00=%rsi,8),>z0=%edx
movl   3(%r8,%rsi,8),%edx

# qhasm: assign 3 to z0

# qhasm: p10 = y1 & 255
# asm 1: movzbl  <y1=int64#4b,>p10=int64#8d
# asm 2: movzbl  <y1=%cl,>p10=%r10d
movzbl  %cl,%r10d

# qhasm: p11 = (y1 >> 8) & 255
# asm 1: movzbl  <y1=int64#4%next8,>p11=int64#2d
# asm 2: movzbl  <y1=%ch,>p11=%esi
movzbl  %ch,%esi

# qhasm: (uint32) z0 ^= *(uint32 *) (table + 2 + p11 * 8)
# asm 1: xorl 2(<table=int64#5,<p11=int64#2,8),<z0=int64#3d
# asm 2: xorl 2(<table=%r8,<p11=%rsi,8),<z0=%edx
xorl 2(%r8,%rsi,8),%edx

# qhasm: (uint32) y1 >>= 16
# asm 1: shr  $16,<y1=int64#4d
# asm 2: shr  $16,<y1=%ecx
shr  $16,%ecx

# qhasm: p12 = y1 & 255
# asm 1: movzbl  <y1=int64#4b,>p12=int64#9d
# asm 2: movzbl  <y1=%cl,>p12=%r11d
movzbl  %cl,%r11d

# qhasm: p13 = (y1 >> 8) & 255
# asm 1: movzbl  <y1=int64#4%next8,>p13=int64#2d
# asm 2: movzbl  <y1=%ch,>p13=%esi
movzbl  %ch,%esi

# qhasm: z1 = *(uint32 *) (table + 4 + p03 * 8)
# asm 1: movl   4(<table=int64#5,<p03=int64#15,8),>z1=int64#4d
# asm 2: movl   4(<table=%r8,<p03=%rbp,8),>z1=%ecx
movl   4(%r8,%rbp,8),%ecx

# qhasm: (uint32) z1 ^= *(uint32 *) (table + 3 + p10 * 8)
# asm 1: xorl 3(<table=int64#5,<p10=int64#8,8),<z1=int64#4d
# asm 2: xorl 3(<table=%r8,<p10=%r10,8),<z1=%ecx
xorl 3(%r8,%r10,8),%ecx

# qhasm: assign 4 to z1

# qhasm: p20 = y2 & 255
# asm 1: movzbl  <y2=int64#7b,>p20=int64#8d
# asm 2: movzbl  <y2=%al,>p20=%r10d
movzbl  %al,%r10d

# qhasm: p21 = (y2 >> 8) & 255
# asm 1: movzbl  <y2=int64#7%next8,>p21=int64#15d
# asm 2: movzbl  <y2=%ah,>p21=%ebp
movzbl  %ah,%ebp

# qhasm: (uint32) z1 ^= *(uint32 *) (table + 2 + p21 * 8)
# asm 1: xorl 2(<table=int64#5,<p21=int64#15,8),<z1=int64#4d
# asm 2: xorl 2(<table=%r8,<p21=%rbp,8),<z1=%ecx
xorl 2(%r8,%rbp,8),%ecx

# qhasm: (uint32) y2 >>= 16
# asm 1: shr  $16,<y2=int64#7d
# asm 2: shr  $16,<y2=%eax
shr  $16,%eax

# qhasm: p22 = y2 & 255
# asm 1: movzbl  <y2=int64#7b,>p22=int64#10d
# asm 2: movzbl  <y2=%al,>p22=%r12d
movzbl  %al,%r12d

# qhasm: (uint32) z0 ^= *(uint32 *) (table + 1 + p22 * 8)
# asm 1: xorl 1(<table=int64#5,<p22=int64#10,8),<z0=int64#3d
# asm 2: xorl 1(<table=%r8,<p22=%r12,8),<z0=%edx
xorl 1(%r8,%r12,8),%edx

# qhasm: p23 = (y2 >> 8) & 255
# asm 1: movzbl  <y2=int64#7%next8,>p23=int64#15d
# asm 2: movzbl  <y2=%ah,>p23=%ebp
movzbl  %ah,%ebp

# qhasm: z2 = *(uint32 *) (table + 1 + p02 * 8)
# asm 1: movl   1(<table=int64#5,<p02=int64#6,8),>z2=int64#7d
# asm 2: movl   1(<table=%r8,<p02=%r9,8),>z2=%eax
movl   1(%r8,%r9,8),%eax

# qhasm: (uint32) z2 ^= *(uint32 *) (table + 4 + p13 * 8)
# asm 1: xorl 4(<table=int64#5,<p13=int64#2,8),<z2=int64#7d
# asm 2: xorl 4(<table=%r8,<p13=%rsi,8),<z2=%eax
xorl 4(%r8,%rsi,8),%eax

# qhasm: (uint32) z2 ^= *(uint32 *) (table + 3 + p20 * 8)
# asm 1: xorl 3(<table=int64#5,<p20=int64#8,8),<z2=int64#7d
# asm 2: xorl 3(<table=%r8,<p20=%r10,8),<z2=%eax
xorl 3(%r8,%r10,8),%eax

# qhasm: assign 7 to z2

# qhasm: p30 = y3 & 255
# asm 1: movzbl  <y3=int64#14b,>p30=int64#6d
# asm 2: movzbl  <y3=%bl,>p30=%r9d
movzbl  %bl,%r9d

# qhasm: p31 = (y3 >> 8) & 255
# asm 1: movzbl  <y3=int64#14%next8,>p31=int64#2d
# asm 2: movzbl  <y3=%bh,>p31=%esi
movzbl  %bh,%esi

# qhasm: (uint32) z2 ^= *(uint32 *) (table + 2 + p31 * 8)
# asm 1: xorl 2(<table=int64#5,<p31=int64#2,8),<z2=int64#7d
# asm 2: xorl 2(<table=%r8,<p31=%rsi,8),<z2=%eax
xorl 2(%r8,%rsi,8),%eax

# qhasm: (uint32) y3 >>= 16
# asm 1: shr  $16,<y3=int64#14d
# asm 2: shr  $16,<y3=%ebx
shr  $16,%ebx

# qhasm: p32 = y3 & 255
# asm 1: movzbl  <y3=int64#14b,>p32=int64#2d
# asm 2: movzbl  <y3=%bl,>p32=%esi
movzbl  %bl,%esi

# qhasm: (uint32) z1 ^= *(uint32 *) (table + 1 + p32 * 8)
# asm 1: xorl 1(<table=int64#5,<p32=int64#2,8),<z1=int64#4d
# asm 2: xorl 1(<table=%r8,<p32=%rsi,8),<z1=%ecx
xorl 1(%r8,%rsi,8),%ecx

# qhasm: p33 = (y3 >> 8) & 255
# asm 1: movzbl  <y3=int64#14%next8,>p33=int64#14d
# asm 2: movzbl  <y3=%bh,>p33=%ebx
movzbl  %bh,%ebx

# qhasm: (uint32) z0 ^= *(uint32 *) (table + 4 + p33 * 8)
# asm 1: xorl 4(<table=int64#5,<p33=int64#14,8),<z0=int64#3d
# asm 2: xorl 4(<table=%r8,<p33=%rbx,8),<z0=%edx
xorl 4(%r8,%rbx,8),%edx

# qhasm: z3 = *(uint32 *) (table + 2 + p01 * 8)
# asm 1: movl   2(<table=int64#5,<p01=int64#1,8),>z3=int64#14d
# asm 2: movl   2(<table=%r8,<p01=%rdi,8),>z3=%ebx
movl   2(%r8,%rdi,8),%ebx

# qhasm: (uint32) z3 ^= *(uint32 *) (table + 1 + p12 * 8)
# asm 1: xorl 1(<table=int64#5,<p12=int64#9,8),<z3=int64#14d
# asm 2: xorl 1(<table=%r8,<p12=%r11,8),<z3=%ebx
xorl 1(%r8,%r11,8),%ebx

# qhasm: z0 ^= r12
# asm 1: xorq <r12=stack64#21,<z0=int64#3
# asm 2: xorq <r12=160(%rsp),<z0=%rdx
xorq 160(%rsp),%rdx

# qhasm: (uint32) z3 ^= *(uint32 *) (table + 4 + p23 * 8)
# asm 1: xorl 4(<table=int64#5,<p23=int64#15,8),<z3=int64#14d
# asm 2: xorl 4(<table=%r8,<p23=%rbp,8),<z3=%ebx
xorl 4(%r8,%rbp,8),%ebx

# qhasm: z1 ^= r13
# asm 1: xorq <r13=stack64#22,<z1=int64#4
# asm 2: xorq <r13=168(%rsp),<z1=%rcx
xorq 168(%rsp),%rcx

# qhasm: (uint32) z3 ^= *(uint32 *) (table + 3 + p30 * 8)
# asm 1: xorl 3(<table=int64#5,<p30=int64#6,8),<z3=int64#14d
# asm 2: xorl 3(<table=%r8,<p30=%r9,8),<z3=%ebx
xorl 3(%r8,%r9,8),%ebx

# qhasm: assign 14 to z3

# qhasm: z2 ^= r14
# asm 1: xorq <r14=stack64#23,<z2=int64#7
# asm 2: xorq <r14=176(%rsp),<z2=%rax
xorq 176(%rsp),%rax

# qhasm: z3 ^= r15
# asm 1: xorq <r15=stack64#24,<z3=int64#14
# asm 2: xorq <r15=184(%rsp),<z3=%rbx
xorq 184(%rsp),%rbx

# qhasm: q00 = z0 & 255
# asm 1: movzbl  <z0=int64#3b,>q00=int64#2d
# asm 2: movzbl  <z0=%dl,>q00=%esi
movzbl  %dl,%esi

# qhasm: q03 = (z0 >> 8) & 255
# asm 1: movzbl  <z0=int64#3%next8,>q03=int64#1d
# asm 2: movzbl  <z0=%dh,>q03=%edi
movzbl  %dh,%edi

# qhasm: (uint32) z0 >>= 16
# asm 1: shr  $16,<z0=int64#3d
# asm 2: shr  $16,<z0=%edx
shr  $16,%edx

# qhasm: q02 = z0 & 255
# asm 1: movzbl  <z0=int64#3b,>q02=int64#6d
# asm 2: movzbl  <z0=%dl,>q02=%r9d
movzbl  %dl,%r9d

# qhasm: q01 = (z0 >> 8) & 255
# asm 1: movzbl  <z0=int64#3%next8,>q01=int64#15d
# asm 2: movzbl  <z0=%dh,>q01=%ebp
movzbl  %dh,%ebp

# qhasm: y0 = *(uint32 *) (table + 3 + q00 * 8)
# asm 1: movl   3(<table=int64#5,<q00=int64#2,8),>y0=int64#3d
# asm 2: movl   3(<table=%r8,<q00=%rsi,8),>y0=%edx
movl   3(%r8,%rsi,8),%edx

# qhasm: assign 3 to y0

# qhasm: q10 = z1 & 255
# asm 1: movzbl  <z1=int64#4b,>q10=int64#8d
# asm 2: movzbl  <z1=%cl,>q10=%r10d
movzbl  %cl,%r10d

# qhasm: q11 = (z1 >> 8) & 255
# asm 1: movzbl  <z1=int64#4%next8,>q11=int64#2d
# asm 2: movzbl  <z1=%ch,>q11=%esi
movzbl  %ch,%esi

# qhasm: (uint32) y0 ^= *(uint32 *) (table + 2 + q11 * 8)
# asm 1: xorl 2(<table=int64#5,<q11=int64#2,8),<y0=int64#3d
# asm 2: xorl 2(<table=%r8,<q11=%rsi,8),<y0=%edx
xorl 2(%r8,%rsi,8),%edx

# qhasm: (uint32) z1 >>= 16
# asm 1: shr  $16,<z1=int64#4d
# asm 2: shr  $16,<z1=%ecx
shr  $16,%ecx

# qhasm: q12 = z1 & 255
# asm 1: movzbl  <z1=int64#4b,>q12=int64#9d
# asm 2: movzbl  <z1=%cl,>q12=%r11d
movzbl  %cl,%r11d

# qhasm: q13 = (z1 >> 8) & 255
# asm 1: movzbl  <z1=int64#4%next8,>q13=int64#2d
# asm 2: movzbl  <z1=%ch,>q13=%esi
movzbl  %ch,%esi

# qhasm: y1 = *(uint32 *) (table + 4 + q01 * 8)
# asm 1: movl   4(<table=int64#5,<q01=int64#15,8),>y1=int64#4d
# asm 2: movl   4(<table=%r8,<q01=%rbp,8),>y1=%ecx
movl   4(%r8,%rbp,8),%ecx

# qhasm: (uint32) y1 ^= *(uint32 *) (table + 3 + q10 * 8)
# asm 1: xorl 3(<table=int64#5,<q10=int64#8,8),<y1=int64#4d
# asm 2: xorl 3(<table=%r8,<q10=%r10,8),<y1=%ecx
xorl 3(%r8,%r10,8),%ecx

# qhasm: assign 4 to y1

# qhasm: q20 = z2 & 255
# asm 1: movzbl  <z2=int64#7b,>q20=int64#8d
# asm 2: movzbl  <z2=%al,>q20=%r10d
movzbl  %al,%r10d

# qhasm: q21 = (z2 >> 8) & 255
# asm 1: movzbl  <z2=int64#7%next8,>q21=int64#15d
# asm 2: movzbl  <z2=%ah,>q21=%ebp
movzbl  %ah,%ebp

# qhasm: (uint32) y1 ^= *(uint32 *) (table + 2 + q21 * 8)
# asm 1: xorl 2(<table=int64#5,<q21=int64#15,8),<y1=int64#4d
# asm 2: xorl 2(<table=%r8,<q21=%rbp,8),<y1=%ecx
xorl 2(%r8,%rbp,8),%ecx

# qhasm: (uint32) z2 >>= 16
# asm 1: shr  $16,<z2=int64#7d
# asm 2: shr  $16,<z2=%eax
shr  $16,%eax

# qhasm: q22 = z2 & 255
# asm 1: movzbl  <z2=int64#7b,>q22=int64#10d
# asm 2: movzbl  <z2=%al,>q22=%r12d
movzbl  %al,%r12d

# qhasm: (uint32) y0 ^= *(uint32 *) (table + 1 + q22 * 8)
# asm 1: xorl 1(<table=int64#5,<q22=int64#10,8),<y0=int64#3d
# asm 2: xorl 1(<table=%r8,<q22=%r12,8),<y0=%edx
xorl 1(%r8,%r12,8),%edx

# qhasm: q23 = (z2 >> 8) & 255
# asm 1: movzbl  <z2=int64#7%next8,>q23=int64#15d
# asm 2: movzbl  <z2=%ah,>q23=%ebp
movzbl  %ah,%ebp

# qhasm: y2 = *(uint32 *) (table + 1 + q02 * 8)
# asm 1: movl   1(<table=int64#5,<q02=int64#6,8),>y2=int64#7d
# asm 2: movl   1(<table=%r8,<q02=%r9,8),>y2=%eax
movl   1(%r8,%r9,8),%eax

# qhasm: (uint32) y2 ^= *(uint32 *) (table + 4 + q13 * 8)
# asm 1: xorl 4(<table=int64#5,<q13=int64#2,8),<y2=int64#7d
# asm 2: xorl 4(<table=%r8,<q13=%rsi,8),<y2=%eax
xorl 4(%r8,%rsi,8),%eax

# qhasm: (uint32) y2 ^= *(uint32 *) (table + 3 + q20 * 8)
# asm 1: xorl 3(<table=int64#5,<q20=int64#8,8),<y2=int64#7d
# asm 2: xorl 3(<table=%r8,<q20=%r10,8),<y2=%eax
xorl 3(%r8,%r10,8),%eax

# qhasm: assign 7 to y2

# qhasm: q30 = z3 & 255
# asm 1: movzbl  <z3=int64#14b,>q30=int64#6d
# asm 2: movzbl  <z3=%bl,>q30=%r9d
movzbl  %bl,%r9d

# qhasm: q31 = (z3 >> 8) & 255
# asm 1: movzbl  <z3=int64#14%next8,>q31=int64#2d
# asm 2: movzbl  <z3=%bh,>q31=%esi
movzbl  %bh,%esi

# qhasm: (uint32) y2 ^= *(uint32 *) (table + 2 + q31 * 8)
# asm 1: xorl 2(<table=int64#5,<q31=int64#2,8),<y2=int64#7d
# asm 2: xorl 2(<table=%r8,<q31=%rsi,8),<y2=%eax
xorl 2(%r8,%rsi,8),%eax

# qhasm: (uint32) z3 >>= 16
# asm 1: shr  $16,<z3=int64#14d
# asm 2: shr  $16,<z3=%ebx
shr  $16,%ebx

# qhasm: q32 = z3 & 255
# asm 1: movzbl  <z3=int64#14b,>q32=int64#2d
# asm 2: movzbl  <z3=%bl,>q32=%esi
movzbl  %bl,%esi

# qhasm: (uint32) y1 ^= *(uint32 *) (table + 1 + q32 * 8)
# asm 1: xorl 1(<table=int64#5,<q32=int64#2,8),<y1=int64#4d
# asm 2: xorl 1(<table=%r8,<q32=%rsi,8),<y1=%ecx
xorl 1(%r8,%rsi,8),%ecx

# qhasm: q33 = (z3 >> 8) & 255
# asm 1: movzbl  <z3=int64#14%next8,>q33=int64#14d
# asm 2: movzbl  <z3=%bh,>q33=%ebx
movzbl  %bh,%ebx

# qhasm: (uint32) y0 ^= *(uint32 *) (table + 4 + q33 * 8)
# asm 1: xorl 4(<table=int64#5,<q33=int64#14,8),<y0=int64#3d
# asm 2: xorl 4(<table=%r8,<q33=%rbx,8),<y0=%edx
xorl 4(%r8,%rbx,8),%edx

# qhasm: y3 = *(uint32 *) (table + 2 + q03 * 8)
# asm 1: movl   2(<table=int64#5,<q03=int64#1,8),>y3=int64#14d
# asm 2: movl   2(<table=%r8,<q03=%rdi,8),>y3=%ebx
movl   2(%r8,%rdi,8),%ebx

# qhasm: (uint32) y3 ^= *(uint32 *) (table + 1 + q12 * 8)
# asm 1: xorl 1(<table=int64#5,<q12=int64#9,8),<y3=int64#14d
# asm 2: xorl 1(<table=%r8,<q12=%r11,8),<y3=%ebx
xorl 1(%r8,%r11,8),%ebx

# qhasm: y0 ^= r16
# asm 1: xorq <r16=stack64#25,<y0=int64#3
# asm 2: xorq <r16=192(%rsp),<y0=%rdx
xorq 192(%rsp),%rdx

# qhasm: (uint32) y3 ^= *(uint32 *) (table + 4 + q23 * 8)
# asm 1: xorl 4(<table=int64#5,<q23=int64#15,8),<y3=int64#14d
# asm 2: xorl 4(<table=%r8,<q23=%rbp,8),<y3=%ebx
xorl 4(%r8,%rbp,8),%ebx

# qhasm: y1 ^= r17
# asm 1: xorq <r17=stack64#26,<y1=int64#4
# asm 2: xorq <r17=200(%rsp),<y1=%rcx
xorq 200(%rsp),%rcx

# qhasm: (uint32) y3 ^= *(uint32 *) (table + 3 + q30 * 8)
# asm 1: xorl 3(<table=int64#5,<q30=int64#6,8),<y3=int64#14d
# asm 2: xorl 3(<table=%r8,<q30=%r9,8),<y3=%ebx
xorl 3(%r8,%r9,8),%ebx

# qhasm: assign 14 to y3

# qhasm: y2 ^= r18
# asm 1: xorq <r18=stack64#27,<y2=int64#7
# asm 2: xorq <r18=208(%rsp),<y2=%rax
xorq 208(%rsp),%rax

# qhasm: y3 ^= r19
# asm 1: xorq <r19=stack64#28,<y3=int64#14
# asm 2: xorq <r19=216(%rsp),<y3=%rbx
xorq 216(%rsp),%rbx

# qhasm: p00 = y0 & 255
# asm 1: movzbl  <y0=int64#3b,>p00=int64#2d
# asm 2: movzbl  <y0=%dl,>p00=%esi
movzbl  %dl,%esi

# qhasm: p01 = (y0 >> 8) & 255
# asm 1: movzbl  <y0=int64#3%next8,>p01=int64#1d
# asm 2: movzbl  <y0=%dh,>p01=%edi
movzbl  %dh,%edi

# qhasm: (uint32) y0 >>= 16
# asm 1: shr  $16,<y0=int64#3d
# asm 2: shr  $16,<y0=%edx
shr  $16,%edx

# qhasm: p02 = y0 & 255
# asm 1: movzbl  <y0=int64#3b,>p02=int64#6d
# asm 2: movzbl  <y0=%dl,>p02=%r9d
movzbl  %dl,%r9d

# qhasm: p03 = (y0 >> 8) & 255
# asm 1: movzbl  <y0=int64#3%next8,>p03=int64#15d
# asm 2: movzbl  <y0=%dh,>p03=%ebp
movzbl  %dh,%ebp

# qhasm: z0 = *(uint32 *) (table + 3 + p00 * 8)
# asm 1: movl   3(<table=int64#5,<p00=int64#2,8),>z0=int64#3d
# asm 2: movl   3(<table=%r8,<p00=%rsi,8),>z0=%edx
movl   3(%r8,%rsi,8),%edx

# qhasm: assign 3 to z0

# qhasm: p10 = y1 & 255
# asm 1: movzbl  <y1=int64#4b,>p10=int64#8d
# asm 2: movzbl  <y1=%cl,>p10=%r10d
movzbl  %cl,%r10d

# qhasm: p11 = (y1 >> 8) & 255
# asm 1: movzbl  <y1=int64#4%next8,>p11=int64#2d
# asm 2: movzbl  <y1=%ch,>p11=%esi
movzbl  %ch,%esi

# qhasm: (uint32) z0 ^= *(uint32 *) (table + 2 + p11 * 8)
# asm 1: xorl 2(<table=int64#5,<p11=int64#2,8),<z0=int64#3d
# asm 2: xorl 2(<table=%r8,<p11=%rsi,8),<z0=%edx
xorl 2(%r8,%rsi,8),%edx

# qhasm: (uint32) y1 >>= 16
# asm 1: shr  $16,<y1=int64#4d
# asm 2: shr  $16,<y1=%ecx
shr  $16,%ecx

# qhasm: p12 = y1 & 255
# asm 1: movzbl  <y1=int64#4b,>p12=int64#9d
# asm 2: movzbl  <y1=%cl,>p12=%r11d
movzbl  %cl,%r11d

# qhasm: p13 = (y1 >> 8) & 255
# asm 1: movzbl  <y1=int64#4%next8,>p13=int64#2d
# asm 2: movzbl  <y1=%ch,>p13=%esi
movzbl  %ch,%esi

# qhasm: z1 = *(uint32 *) (table + 4 + p03 * 8)
# asm 1: movl   4(<table=int64#5,<p03=int64#15,8),>z1=int64#4d
# asm 2: movl   4(<table=%r8,<p03=%rbp,8),>z1=%ecx
movl   4(%r8,%rbp,8),%ecx

# qhasm: (uint32) z1 ^= *(uint32 *) (table + 3 + p10 * 8)
# asm 1: xorl 3(<table=int64#5,<p10=int64#8,8),<z1=int64#4d
# asm 2: xorl 3(<table=%r8,<p10=%r10,8),<z1=%ecx
xorl 3(%r8,%r10,8),%ecx

# qhasm: assign 4 to z1

# qhasm: p20 = y2 & 255
# asm 1: movzbl  <y2=int64#7b,>p20=int64#8d
# asm 2: movzbl  <y2=%al,>p20=%r10d
movzbl  %al,%r10d

# qhasm: p21 = (y2 >> 8) & 255
# asm 1: movzbl  <y2=int64#7%next8,>p21=int64#15d
# asm 2: movzbl  <y2=%ah,>p21=%ebp
movzbl  %ah,%ebp

# qhasm: (uint32) z1 ^= *(uint32 *) (table + 2 + p21 * 8)
# asm 1: xorl 2(<table=int64#5,<p21=int64#15,8),<z1=int64#4d
# asm 2: xorl 2(<table=%r8,<p21=%rbp,8),<z1=%ecx
xorl 2(%r8,%rbp,8),%ecx

# qhasm: (uint32) y2 >>= 16
# asm 1: shr  $16,<y2=int64#7d
# asm 2: shr  $16,<y2=%eax
shr  $16,%eax

# qhasm: p22 = y2 & 255
# asm 1: movzbl  <y2=int64#7b,>p22=int64#10d
# asm 2: movzbl  <y2=%al,>p22=%r12d
movzbl  %al,%r12d

# qhasm: (uint32) z0 ^= *(uint32 *) (table + 1 + p22 * 8)
# asm 1: xorl 1(<table=int64#5,<p22=int64#10,8),<z0=int64#3d
# asm 2: xorl 1(<table=%r8,<p22=%r12,8),<z0=%edx
xorl 1(%r8,%r12,8),%edx

# qhasm: p23 = (y2 >> 8) & 255
# asm 1: movzbl  <y2=int64#7%next8,>p23=int64#15d
# asm 2: movzbl  <y2=%ah,>p23=%ebp
movzbl  %ah,%ebp

# qhasm: z2 = *(uint32 *) (table + 1 + p02 * 8)
# asm 1: movl   1(<table=int64#5,<p02=int64#6,8),>z2=int64#7d
# asm 2: movl   1(<table=%r8,<p02=%r9,8),>z2=%eax
movl   1(%r8,%r9,8),%eax

# qhasm: (uint32) z2 ^= *(uint32 *) (table + 4 + p13 * 8)
# asm 1: xorl 4(<table=int64#5,<p13=int64#2,8),<z2=int64#7d
# asm 2: xorl 4(<table=%r8,<p13=%rsi,8),<z2=%eax
xorl 4(%r8,%rsi,8),%eax

# qhasm: (uint32) z2 ^= *(uint32 *) (table + 3 + p20 * 8)
# asm 1: xorl 3(<table=int64#5,<p20=int64#8,8),<z2=int64#7d
# asm 2: xorl 3(<table=%r8,<p20=%r10,8),<z2=%eax
xorl 3(%r8,%r10,8),%eax

# qhasm: assign 7 to z2

# qhasm: p30 = y3 & 255
# asm 1: movzbl  <y3=int64#14b,>p30=int64#6d
# asm 2: movzbl  <y3=%bl,>p30=%r9d
movzbl  %bl,%r9d

# qhasm: p31 = (y3 >> 8) & 255
# asm 1: movzbl  <y3=int64#14%next8,>p31=int64#2d
# asm 2: movzbl  <y3=%bh,>p31=%esi
movzbl  %bh,%esi

# qhasm: (uint32) z2 ^= *(uint32 *) (table + 2 + p31 * 8)
# asm 1: xorl 2(<table=int64#5,<p31=int64#2,8),<z2=int64#7d
# asm 2: xorl 2(<table=%r8,<p31=%rsi,8),<z2=%eax
xorl 2(%r8,%rsi,8),%eax

# qhasm: (uint32) y3 >>= 16
# asm 1: shr  $16,<y3=int64#14d
# asm 2: shr  $16,<y3=%ebx
shr  $16,%ebx

# qhasm: p32 = y3 & 255
# asm 1: movzbl  <y3=int64#14b,>p32=int64#2d
# asm 2: movzbl  <y3=%bl,>p32=%esi
movzbl  %bl,%esi

# qhasm: (uint32) z1 ^= *(uint32 *) (table + 1 + p32 * 8)
# asm 1: xorl 1(<table=int64#5,<p32=int64#2,8),<z1=int64#4d
# asm 2: xorl 1(<table=%r8,<p32=%rsi,8),<z1=%ecx
xorl 1(%r8,%rsi,8),%ecx

# qhasm: p33 = (y3 >> 8) & 255
# asm 1: movzbl  <y3=int64#14%next8,>p33=int64#14d
# asm 2: movzbl  <y3=%bh,>p33=%ebx
movzbl  %bh,%ebx

# qhasm: (uint32) z0 ^= *(uint32 *) (table + 4 + p33 * 8)
# asm 1: xorl 4(<table=int64#5,<p33=int64#14,8),<z0=int64#3d
# asm 2: xorl 4(<table=%r8,<p33=%rbx,8),<z0=%edx
xorl 4(%r8,%rbx,8),%edx

# qhasm: z3 = *(uint32 *) (table + 2 + p01 * 8)
# asm 1: movl   2(<table=int64#5,<p01=int64#1,8),>z3=int64#14d
# asm 2: movl   2(<table=%r8,<p01=%rdi,8),>z3=%ebx
movl   2(%r8,%rdi,8),%ebx

# qhasm: (uint32) z3 ^= *(uint32 *) (table + 1 + p12 * 8)
# asm 1: xorl 1(<table=int64#5,<p12=int64#9,8),<z3=int64#14d
# asm 2: xorl 1(<table=%r8,<p12=%r11,8),<z3=%ebx
xorl 1(%r8,%r11,8),%ebx

# qhasm: z0 ^= r20
# asm 1: xorq <r20=stack64#29,<z0=int64#3
# asm 2: xorq <r20=224(%rsp),<z0=%rdx
xorq 224(%rsp),%rdx

# qhasm: (uint32) z3 ^= *(uint32 *) (table + 4 + p23 * 8)
# asm 1: xorl 4(<table=int64#5,<p23=int64#15,8),<z3=int64#14d
# asm 2: xorl 4(<table=%r8,<p23=%rbp,8),<z3=%ebx
xorl 4(%r8,%rbp,8),%ebx

# qhasm: z1 ^= r21
# asm 1: xorq <r21=stack64#30,<z1=int64#4
# asm 2: xorq <r21=232(%rsp),<z1=%rcx
xorq 232(%rsp),%rcx

# qhasm: (uint32) z3 ^= *(uint32 *) (table + 3 + p30 * 8)
# asm 1: xorl 3(<table=int64#5,<p30=int64#6,8),<z3=int64#14d
# asm 2: xorl 3(<table=%r8,<p30=%r9,8),<z3=%ebx
xorl 3(%r8,%r9,8),%ebx

# qhasm: assign 14 to z3

# qhasm: z2 ^= r22
# asm 1: xorq <r22=stack64#31,<z2=int64#7
# asm 2: xorq <r22=240(%rsp),<z2=%rax
xorq 240(%rsp),%rax

# qhasm: z3 ^= r23
# asm 1: xorq <r23=stack64#32,<z3=int64#14
# asm 2: xorq <r23=248(%rsp),<z3=%rbx
xorq 248(%rsp),%rbx

# qhasm: q00 = z0 & 255
# asm 1: movzbl  <z0=int64#3b,>q00=int64#2d
# asm 2: movzbl  <z0=%dl,>q00=%esi
movzbl  %dl,%esi

# qhasm: q03 = (z0 >> 8) & 255
# asm 1: movzbl  <z0=int64#3%next8,>q03=int64#1d
# asm 2: movzbl  <z0=%dh,>q03=%edi
movzbl  %dh,%edi

# qhasm: (uint32) z0 >>= 16
# asm 1: shr  $16,<z0=int64#3d
# asm 2: shr  $16,<z0=%edx
shr  $16,%edx

# qhasm: q02 = z0 & 255
# asm 1: movzbl  <z0=int64#3b,>q02=int64#6d
# asm 2: movzbl  <z0=%dl,>q02=%r9d
movzbl  %dl,%r9d

# qhasm: q01 = (z0 >> 8) & 255
# asm 1: movzbl  <z0=int64#3%next8,>q01=int64#15d
# asm 2: movzbl  <z0=%dh,>q01=%ebp
movzbl  %dh,%ebp

# qhasm: y0 = *(uint32 *) (table + 3 + q00 * 8)
# asm 1: movl   3(<table=int64#5,<q00=int64#2,8),>y0=int64#3d
# asm 2: movl   3(<table=%r8,<q00=%rsi,8),>y0=%edx
movl   3(%r8,%rsi,8),%edx

# qhasm: assign 3 to y0

# qhasm: q10 = z1 & 255
# asm 1: movzbl  <z1=int64#4b,>q10=int64#8d
# asm 2: movzbl  <z1=%cl,>q10=%r10d
movzbl  %cl,%r10d

# qhasm: q11 = (z1 >> 8) & 255
# asm 1: movzbl  <z1=int64#4%next8,>q11=int64#2d
# asm 2: movzbl  <z1=%ch,>q11=%esi
movzbl  %ch,%esi

# qhasm: (uint32) y0 ^= *(uint32 *) (table + 2 + q11 * 8)
# asm 1: xorl 2(<table=int64#5,<q11=int64#2,8),<y0=int64#3d
# asm 2: xorl 2(<table=%r8,<q11=%rsi,8),<y0=%edx
xorl 2(%r8,%rsi,8),%edx

# qhasm: (uint32) z1 >>= 16
# asm 1: shr  $16,<z1=int64#4d
# asm 2: shr  $16,<z1=%ecx
shr  $16,%ecx

# qhasm: q12 = z1 & 255
# asm 1: movzbl  <z1=int64#4b,>q12=int64#9d
# asm 2: movzbl  <z1=%cl,>q12=%r11d
movzbl  %cl,%r11d

# qhasm: q13 = (z1 >> 8) & 255
# asm 1: movzbl  <z1=int64#4%next8,>q13=int64#2d
# asm 2: movzbl  <z1=%ch,>q13=%esi
movzbl  %ch,%esi

# qhasm: y1 = *(uint32 *) (table + 4 + q01 * 8)
# asm 1: movl   4(<table=int64#5,<q01=int64#15,8),>y1=int64#4d
# asm 2: movl   4(<table=%r8,<q01=%rbp,8),>y1=%ecx
movl   4(%r8,%rbp,8),%ecx

# qhasm: (uint32) y1 ^= *(uint32 *) (table + 3 + q10 * 8)
# asm 1: xorl 3(<table=int64#5,<q10=int64#8,8),<y1=int64#4d
# asm 2: xorl 3(<table=%r8,<q10=%r10,8),<y1=%ecx
xorl 3(%r8,%r10,8),%ecx

# qhasm: assign 4 to y1

# qhasm: q20 = z2 & 255
# asm 1: movzbl  <z2=int64#7b,>q20=int64#8d
# asm 2: movzbl  <z2=%al,>q20=%r10d
movzbl  %al,%r10d

# qhasm: q21 = (z2 >> 8) & 255
# asm 1: movzbl  <z2=int64#7%next8,>q21=int64#15d
# asm 2: movzbl  <z2=%ah,>q21=%ebp
movzbl  %ah,%ebp

# qhasm: (uint32) y1 ^= *(uint32 *) (table + 2 + q21 * 8)
# asm 1: xorl 2(<table=int64#5,<q21=int64#15,8),<y1=int64#4d
# asm 2: xorl 2(<table=%r8,<q21=%rbp,8),<y1=%ecx
xorl 2(%r8,%rbp,8),%ecx

# qhasm: (uint32) z2 >>= 16
# asm 1: shr  $16,<z2=int64#7d
# asm 2: shr  $16,<z2=%eax
shr  $16,%eax

# qhasm: q22 = z2 & 255
# asm 1: movzbl  <z2=int64#7b,>q22=int64#10d
# asm 2: movzbl  <z2=%al,>q22=%r12d
movzbl  %al,%r12d

# qhasm: (uint32) y0 ^= *(uint32 *) (table + 1 + q22 * 8)
# asm 1: xorl 1(<table=int64#5,<q22=int64#10,8),<y0=int64#3d
# asm 2: xorl 1(<table=%r8,<q22=%r12,8),<y0=%edx
xorl 1(%r8,%r12,8),%edx

# qhasm: q23 = (z2 >> 8) & 255
# asm 1: movzbl  <z2=int64#7%next8,>q23=int64#15d
# asm 2: movzbl  <z2=%ah,>q23=%ebp
movzbl  %ah,%ebp

# qhasm: y2 = *(uint32 *) (table + 1 + q02 * 8)
# asm 1: movl   1(<table=int64#5,<q02=int64#6,8),>y2=int64#7d
# asm 2: movl   1(<table=%r8,<q02=%r9,8),>y2=%eax
movl   1(%r8,%r9,8),%eax

# qhasm: (uint32) y2 ^= *(uint32 *) (table + 4 + q13 * 8)
# asm 1: xorl 4(<table=int64#5,<q13=int64#2,8),<y2=int64#7d
# asm 2: xorl 4(<table=%r8,<q13=%rsi,8),<y2=%eax
xorl 4(%r8,%rsi,8),%eax

# qhasm: (uint32) y2 ^= *(uint32 *) (table + 3 + q20 * 8)
# asm 1: xorl 3(<table=int64#5,<q20=int64#8,8),<y2=int64#7d
# asm 2: xorl 3(<table=%r8,<q20=%r10,8),<y2=%eax
xorl 3(%r8,%r10,8),%eax

# qhasm: assign 7 to y2

# qhasm: q30 = z3 & 255
# asm 1: movzbl  <z3=int64#14b,>q30=int64#6d
# asm 2: movzbl  <z3=%bl,>q30=%r9d
movzbl  %bl,%r9d

# qhasm: q31 = (z3 >> 8) & 255
# asm 1: movzbl  <z3=int64#14%next8,>q31=int64#2d
# asm 2: movzbl  <z3=%bh,>q31=%esi
movzbl  %bh,%esi

# qhasm: (uint32) y2 ^= *(uint32 *) (table + 2 + q31 * 8)
# asm 1: xorl 2(<table=int64#5,<q31=int64#2,8),<y2=int64#7d
# asm 2: xorl 2(<table=%r8,<q31=%rsi,8),<y2=%eax
xorl 2(%r8,%rsi,8),%eax

# qhasm: (uint32) z3 >>= 16
# asm 1: shr  $16,<z3=int64#14d
# asm 2: shr  $16,<z3=%ebx
shr  $16,%ebx

# qhasm: q32 = z3 & 255
# asm 1: movzbl  <z3=int64#14b,>q32=int64#2d
# asm 2: movzbl  <z3=%bl,>q32=%esi
movzbl  %bl,%esi

# qhasm: (uint32) y1 ^= *(uint32 *) (table + 1 + q32 * 8)
# asm 1: xorl 1(<table=int64#5,<q32=int64#2,8),<y1=int64#4d
# asm 2: xorl 1(<table=%r8,<q32=%rsi,8),<y1=%ecx
xorl 1(%r8,%rsi,8),%ecx

# qhasm: q33 = (z3 >> 8) & 255
# asm 1: movzbl  <z3=int64#14%next8,>q33=int64#14d
# asm 2: movzbl  <z3=%bh,>q33=%ebx
movzbl  %bh,%ebx

# qhasm: (uint32) y0 ^= *(uint32 *) (table + 4 + q33 * 8)
# asm 1: xorl 4(<table=int64#5,<q33=int64#14,8),<y0=int64#3d
# asm 2: xorl 4(<table=%r8,<q33=%rbx,8),<y0=%edx
xorl 4(%r8,%rbx,8),%edx

# qhasm: y3 = *(uint32 *) (table + 2 + q03 * 8)
# asm 1: movl   2(<table=int64#5,<q03=int64#1,8),>y3=int64#14d
# asm 2: movl   2(<table=%r8,<q03=%rdi,8),>y3=%ebx
movl   2(%r8,%rdi,8),%ebx

# qhasm: (uint32) y3 ^= *(uint32 *) (table + 1 + q12 * 8)
# asm 1: xorl 1(<table=int64#5,<q12=int64#9,8),<y3=int64#14d
# asm 2: xorl 1(<table=%r8,<q12=%r11,8),<y3=%ebx
xorl 1(%r8,%r11,8),%ebx

# qhasm: y0 ^= r24
# asm 1: xorq <r24=stack64#33,<y0=int64#3
# asm 2: xorq <r24=256(%rsp),<y0=%rdx
xorq 256(%rsp),%rdx

# qhasm: (uint32) y3 ^= *(uint32 *) (table + 4 + q23 * 8)
# asm 1: xorl 4(<table=int64#5,<q23=int64#15,8),<y3=int64#14d
# asm 2: xorl 4(<table=%r8,<q23=%rbp,8),<y3=%ebx
xorl 4(%r8,%rbp,8),%ebx

# qhasm: y1 ^= r25
# asm 1: xorq <r25=stack64#34,<y1=int64#4
# asm 2: xorq <r25=264(%rsp),<y1=%rcx
xorq 264(%rsp),%rcx

# qhasm: (uint32) y3 ^= *(uint32 *) (table + 3 + q30 * 8)
# asm 1: xorl 3(<table=int64#5,<q30=int64#6,8),<y3=int64#14d
# asm 2: xorl 3(<table=%r8,<q30=%r9,8),<y3=%ebx
xorl 3(%r8,%r9,8),%ebx

# qhasm: assign 14 to y3

# qhasm: y2 ^= r26
# asm 1: xorq <r26=stack64#35,<y2=int64#7
# asm 2: xorq <r26=272(%rsp),<y2=%rax
xorq 272(%rsp),%rax

# qhasm: y3 ^= r27
# asm 1: xorq <r27=stack64#36,<y3=int64#14
# asm 2: xorq <r27=280(%rsp),<y3=%rbx
xorq 280(%rsp),%rbx

# qhasm: p00 = y0 & 255
# asm 1: movzbl  <y0=int64#3b,>p00=int64#2d
# asm 2: movzbl  <y0=%dl,>p00=%esi
movzbl  %dl,%esi

# qhasm: p01 = (y0 >> 8) & 255
# asm 1: movzbl  <y0=int64#3%next8,>p01=int64#1d
# asm 2: movzbl  <y0=%dh,>p01=%edi
movzbl  %dh,%edi

# qhasm: (uint32) y0 >>= 16
# asm 1: shr  $16,<y0=int64#3d
# asm 2: shr  $16,<y0=%edx
shr  $16,%edx

# qhasm: p02 = y0 & 255
# asm 1: movzbl  <y0=int64#3b,>p02=int64#6d
# asm 2: movzbl  <y0=%dl,>p02=%r9d
movzbl  %dl,%r9d

# qhasm: p03 = (y0 >> 8) & 255
# asm 1: movzbl  <y0=int64#3%next8,>p03=int64#15d
# asm 2: movzbl  <y0=%dh,>p03=%ebp
movzbl  %dh,%ebp

# qhasm: z0 = *(uint32 *) (table + 3 + p00 * 8)
# asm 1: movl   3(<table=int64#5,<p00=int64#2,8),>z0=int64#3d
# asm 2: movl   3(<table=%r8,<p00=%rsi,8),>z0=%edx
movl   3(%r8,%rsi,8),%edx

# qhasm: assign 3 to z0

# qhasm: p10 = y1 & 255
# asm 1: movzbl  <y1=int64#4b,>p10=int64#8d
# asm 2: movzbl  <y1=%cl,>p10=%r10d
movzbl  %cl,%r10d

# qhasm: p11 = (y1 >> 8) & 255
# asm 1: movzbl  <y1=int64#4%next8,>p11=int64#2d
# asm 2: movzbl  <y1=%ch,>p11=%esi
movzbl  %ch,%esi

# qhasm: (uint32) z0 ^= *(uint32 *) (table + 2 + p11 * 8)
# asm 1: xorl 2(<table=int64#5,<p11=int64#2,8),<z0=int64#3d
# asm 2: xorl 2(<table=%r8,<p11=%rsi,8),<z0=%edx
xorl 2(%r8,%rsi,8),%edx

# qhasm: (uint32) y1 >>= 16
# asm 1: shr  $16,<y1=int64#4d
# asm 2: shr  $16,<y1=%ecx
shr  $16,%ecx

# qhasm: p12 = y1 & 255
# asm 1: movzbl  <y1=int64#4b,>p12=int64#9d
# asm 2: movzbl  <y1=%cl,>p12=%r11d
movzbl  %cl,%r11d

# qhasm: p13 = (y1 >> 8) & 255
# asm 1: movzbl  <y1=int64#4%next8,>p13=int64#2d
# asm 2: movzbl  <y1=%ch,>p13=%esi
movzbl  %ch,%esi

# qhasm: z1 = *(uint32 *) (table + 4 + p03 * 8)
# asm 1: movl   4(<table=int64#5,<p03=int64#15,8),>z1=int64#4d
# asm 2: movl   4(<table=%r8,<p03=%rbp,8),>z1=%ecx
movl   4(%r8,%rbp,8),%ecx

# qhasm: (uint32) z1 ^= *(uint32 *) (table + 3 + p10 * 8)
# asm 1: xorl 3(<table=int64#5,<p10=int64#8,8),<z1=int64#4d
# asm 2: xorl 3(<table=%r8,<p10=%r10,8),<z1=%ecx
xorl 3(%r8,%r10,8),%ecx

# qhasm: assign 4 to z1

# qhasm: p20 = y2 & 255
# asm 1: movzbl  <y2=int64#7b,>p20=int64#8d
# asm 2: movzbl  <y2=%al,>p20=%r10d
movzbl  %al,%r10d

# qhasm: p21 = (y2 >> 8) & 255
# asm 1: movzbl  <y2=int64#7%next8,>p21=int64#15d
# asm 2: movzbl  <y2=%ah,>p21=%ebp
movzbl  %ah,%ebp

# qhasm: (uint32) z1 ^= *(uint32 *) (table + 2 + p21 * 8)
# asm 1: xorl 2(<table=int64#5,<p21=int64#15,8),<z1=int64#4d
# asm 2: xorl 2(<table=%r8,<p21=%rbp,8),<z1=%ecx
xorl 2(%r8,%rbp,8),%ecx

# qhasm: (uint32) y2 >>= 16
# asm 1: shr  $16,<y2=int64#7d
# asm 2: shr  $16,<y2=%eax
shr  $16,%eax

# qhasm: p22 = y2 & 255
# asm 1: movzbl  <y2=int64#7b,>p22=int64#10d
# asm 2: movzbl  <y2=%al,>p22=%r12d
movzbl  %al,%r12d

# qhasm: (uint32) z0 ^= *(uint32 *) (table + 1 + p22 * 8)
# asm 1: xorl 1(<table=int64#5,<p22=int64#10,8),<z0=int64#3d
# asm 2: xorl 1(<table=%r8,<p22=%r12,8),<z0=%edx
xorl 1(%r8,%r12,8),%edx

# qhasm: p23 = (y2 >> 8) & 255
# asm 1: movzbl  <y2=int64#7%next8,>p23=int64#15d
# asm 2: movzbl  <y2=%ah,>p23=%ebp
movzbl  %ah,%ebp

# qhasm: z2 = *(uint32 *) (table + 1 + p02 * 8)
# asm 1: movl   1(<table=int64#5,<p02=int64#6,8),>z2=int64#7d
# asm 2: movl   1(<table=%r8,<p02=%r9,8),>z2=%eax
movl   1(%r8,%r9,8),%eax

# qhasm: (uint32) z2 ^= *(uint32 *) (table + 4 + p13 * 8)
# asm 1: xorl 4(<table=int64#5,<p13=int64#2,8),<z2=int64#7d
# asm 2: xorl 4(<table=%r8,<p13=%rsi,8),<z2=%eax
xorl 4(%r8,%rsi,8),%eax

# qhasm: (uint32) z2 ^= *(uint32 *) (table + 3 + p20 * 8)
# asm 1: xorl 3(<table=int64#5,<p20=int64#8,8),<z2=int64#7d
# asm 2: xorl 3(<table=%r8,<p20=%r10,8),<z2=%eax
xorl 3(%r8,%r10,8),%eax

# qhasm: assign 7 to z2

# qhasm: p30 = y3 & 255
# asm 1: movzbl  <y3=int64#14b,>p30=int64#6d
# asm 2: movzbl  <y3=%bl,>p30=%r9d
movzbl  %bl,%r9d

# qhasm: p31 = (y3 >> 8) & 255
# asm 1: movzbl  <y3=int64#14%next8,>p31=int64#2d
# asm 2: movzbl  <y3=%bh,>p31=%esi
movzbl  %bh,%esi

# qhasm: (uint32) z2 ^= *(uint32 *) (table + 2 + p31 * 8)
# asm 1: xorl 2(<table=int64#5,<p31=int64#2,8),<z2=int64#7d
# asm 2: xorl 2(<table=%r8,<p31=%rsi,8),<z2=%eax
xorl 2(%r8,%rsi,8),%eax

# qhasm: (uint32) y3 >>= 16
# asm 1: shr  $16,<y3=int64#14d
# asm 2: shr  $16,<y3=%ebx
shr  $16,%ebx

# qhasm: p32 = y3 & 255
# asm 1: movzbl  <y3=int64#14b,>p32=int64#2d
# asm 2: movzbl  <y3=%bl,>p32=%esi
movzbl  %bl,%esi

# qhasm: (uint32) z1 ^= *(uint32 *) (table + 1 + p32 * 8)
# asm 1: xorl 1(<table=int64#5,<p32=int64#2,8),<z1=int64#4d
# asm 2: xorl 1(<table=%r8,<p32=%rsi,8),<z1=%ecx
xorl 1(%r8,%rsi,8),%ecx

# qhasm: p33 = (y3 >> 8) & 255
# asm 1: movzbl  <y3=int64#14%next8,>p33=int64#14d
# asm 2: movzbl  <y3=%bh,>p33=%ebx
movzbl  %bh,%ebx

# qhasm: (uint32) z0 ^= *(uint32 *) (table + 4 + p33 * 8)
# asm 1: xorl 4(<table=int64#5,<p33=int64#14,8),<z0=int64#3d
# asm 2: xorl 4(<table=%r8,<p33=%rbx,8),<z0=%edx
xorl 4(%r8,%rbx,8),%edx

# qhasm: z3 = *(uint32 *) (table + 2 + p01 * 8)
# asm 1: movl   2(<table=int64#5,<p01=int64#1,8),>z3=int64#14d
# asm 2: movl   2(<table=%r8,<p01=%rdi,8),>z3=%ebx
movl   2(%r8,%rdi,8),%ebx

# qhasm: (uint32) z3 ^= *(uint32 *) (table + 1 + p12 * 8)
# asm 1: xorl 1(<table=int64#5,<p12=int64#9,8),<z3=int64#14d
# asm 2: xorl 1(<table=%r8,<p12=%r11,8),<z3=%ebx
xorl 1(%r8,%r11,8),%ebx

# qhasm: z0 ^= r28
# asm 1: xorq <r28=stack64#37,<z0=int64#3
# asm 2: xorq <r28=288(%rsp),<z0=%rdx
xorq 288(%rsp),%rdx

# qhasm: (uint32) z3 ^= *(uint32 *) (table + 4 + p23 * 8)
# asm 1: xorl 4(<table=int64#5,<p23=int64#15,8),<z3=int64#14d
# asm 2: xorl 4(<table=%r8,<p23=%rbp,8),<z3=%ebx
xorl 4(%r8,%rbp,8),%ebx

# qhasm: z1 ^= r29
# asm 1: xorq <r29=stack64#38,<z1=int64#4
# asm 2: xorq <r29=296(%rsp),<z1=%rcx
xorq 296(%rsp),%rcx

# qhasm: (uint32) z3 ^= *(uint32 *) (table + 3 + p30 * 8)
# asm 1: xorl 3(<table=int64#5,<p30=int64#6,8),<z3=int64#14d
# asm 2: xorl 3(<table=%r8,<p30=%r9,8),<z3=%ebx
xorl 3(%r8,%r9,8),%ebx

# qhasm: assign 14 to z3

# qhasm: z2 ^= r30
# asm 1: xorq <r30=stack64#39,<z2=int64#7
# asm 2: xorq <r30=304(%rsp),<z2=%rax
xorq 304(%rsp),%rax

# qhasm: z3 ^= r31
# asm 1: xorq <r31=stack64#40,<z3=int64#14
# asm 2: xorq <r31=312(%rsp),<z3=%rbx
xorq 312(%rsp),%rbx

# qhasm: q00 = z0 & 255
# asm 1: movzbl  <z0=int64#3b,>q00=int64#2d
# asm 2: movzbl  <z0=%dl,>q00=%esi
movzbl  %dl,%esi

# qhasm: q03 = (z0 >> 8) & 255
# asm 1: movzbl  <z0=int64#3%next8,>q03=int64#1d
# asm 2: movzbl  <z0=%dh,>q03=%edi
movzbl  %dh,%edi

# qhasm: (uint32) z0 >>= 16
# asm 1: shr  $16,<z0=int64#3d
# asm 2: shr  $16,<z0=%edx
shr  $16,%edx

# qhasm: q02 = z0 & 255
# asm 1: movzbl  <z0=int64#3b,>q02=int64#6d
# asm 2: movzbl  <z0=%dl,>q02=%r9d
movzbl  %dl,%r9d

# qhasm: q01 = (z0 >> 8) & 255
# asm 1: movzbl  <z0=int64#3%next8,>q01=int64#15d
# asm 2: movzbl  <z0=%dh,>q01=%ebp
movzbl  %dh,%ebp

# qhasm: y0 = *(uint32 *) (table + 3 + q00 * 8)
# asm 1: movl   3(<table=int64#5,<q00=int64#2,8),>y0=int64#3d
# asm 2: movl   3(<table=%r8,<q00=%rsi,8),>y0=%edx
movl   3(%r8,%rsi,8),%edx

# qhasm: assign 3 to y0

# qhasm: q10 = z1 & 255
# asm 1: movzbl  <z1=int64#4b,>q10=int64#8d
# asm 2: movzbl  <z1=%cl,>q10=%r10d
movzbl  %cl,%r10d

# qhasm: q11 = (z1 >> 8) & 255
# asm 1: movzbl  <z1=int64#4%next8,>q11=int64#2d
# asm 2: movzbl  <z1=%ch,>q11=%esi
movzbl  %ch,%esi

# qhasm: (uint32) y0 ^= *(uint32 *) (table + 2 + q11 * 8)
# asm 1: xorl 2(<table=int64#5,<q11=int64#2,8),<y0=int64#3d
# asm 2: xorl 2(<table=%r8,<q11=%rsi,8),<y0=%edx
xorl 2(%r8,%rsi,8),%edx

# qhasm: (uint32) z1 >>= 16
# asm 1: shr  $16,<z1=int64#4d
# asm 2: shr  $16,<z1=%ecx
shr  $16,%ecx

# qhasm: q12 = z1 & 255
# asm 1: movzbl  <z1=int64#4b,>q12=int64#9d
# asm 2: movzbl  <z1=%cl,>q12=%r11d
movzbl  %cl,%r11d

# qhasm: q13 = (z1 >> 8) & 255
# asm 1: movzbl  <z1=int64#4%next8,>q13=int64#2d
# asm 2: movzbl  <z1=%ch,>q13=%esi
movzbl  %ch,%esi

# qhasm: y1 = *(uint32 *) (table + 4 + q01 * 8)
# asm 1: movl   4(<table=int64#5,<q01=int64#15,8),>y1=int64#4d
# asm 2: movl   4(<table=%r8,<q01=%rbp,8),>y1=%ecx
movl   4(%r8,%rbp,8),%ecx

# qhasm: (uint32) y1 ^= *(uint32 *) (table + 3 + q10 * 8)
# asm 1: xorl 3(<table=int64#5,<q10=int64#8,8),<y1=int64#4d
# asm 2: xorl 3(<table=%r8,<q10=%r10,8),<y1=%ecx
xorl 3(%r8,%r10,8),%ecx

# qhasm: assign 4 to y1

# qhasm: q20 = z2 & 255
# asm 1: movzbl  <z2=int64#7b,>q20=int64#8d
# asm 2: movzbl  <z2=%al,>q20=%r10d
movzbl  %al,%r10d

# qhasm: q21 = (z2 >> 8) & 255
# asm 1: movzbl  <z2=int64#7%next8,>q21=int64#15d
# asm 2: movzbl  <z2=%ah,>q21=%ebp
movzbl  %ah,%ebp

# qhasm: (uint32) y1 ^= *(uint32 *) (table + 2 + q21 * 8)
# asm 1: xorl 2(<table=int64#5,<q21=int64#15,8),<y1=int64#4d
# asm 2: xorl 2(<table=%r8,<q21=%rbp,8),<y1=%ecx
xorl 2(%r8,%rbp,8),%ecx

# qhasm: (uint32) z2 >>= 16
# asm 1: shr  $16,<z2=int64#7d
# asm 2: shr  $16,<z2=%eax
shr  $16,%eax

# qhasm: q22 = z2 & 255
# asm 1: movzbl  <z2=int64#7b,>q22=int64#10d
# asm 2: movzbl  <z2=%al,>q22=%r12d
movzbl  %al,%r12d

# qhasm: (uint32) y0 ^= *(uint32 *) (table + 1 + q22 * 8)
# asm 1: xorl 1(<table=int64#5,<q22=int64#10,8),<y0=int64#3d
# asm 2: xorl 1(<table=%r8,<q22=%r12,8),<y0=%edx
xorl 1(%r8,%r12,8),%edx

# qhasm: q23 = (z2 >> 8) & 255
# asm 1: movzbl  <z2=int64#7%next8,>q23=int64#15d
# asm 2: movzbl  <z2=%ah,>q23=%ebp
movzbl  %ah,%ebp

# qhasm: y2 = *(uint32 *) (table + 1 + q02 * 8)
# asm 1: movl   1(<table=int64#5,<q02=int64#6,8),>y2=int64#7d
# asm 2: movl   1(<table=%r8,<q02=%r9,8),>y2=%eax
movl   1(%r8,%r9,8),%eax

# qhasm: (uint32) y2 ^= *(uint32 *) (table + 4 + q13 * 8)
# asm 1: xorl 4(<table=int64#5,<q13=int64#2,8),<y2=int64#7d
# asm 2: xorl 4(<table=%r8,<q13=%rsi,8),<y2=%eax
xorl 4(%r8,%rsi,8),%eax

# qhasm: (uint32) y2 ^= *(uint32 *) (table + 3 + q20 * 8)
# asm 1: xorl 3(<table=int64#5,<q20=int64#8,8),<y2=int64#7d
# asm 2: xorl 3(<table=%r8,<q20=%r10,8),<y2=%eax
xorl 3(%r8,%r10,8),%eax

# qhasm: assign 7 to y2

# qhasm: q30 = z3 & 255
# asm 1: movzbl  <z3=int64#14b,>q30=int64#6d
# asm 2: movzbl  <z3=%bl,>q30=%r9d
movzbl  %bl,%r9d

# qhasm: q31 = (z3 >> 8) & 255
# asm 1: movzbl  <z3=int64#14%next8,>q31=int64#2d
# asm 2: movzbl  <z3=%bh,>q31=%esi
movzbl  %bh,%esi

# qhasm: (uint32) y2 ^= *(uint32 *) (table + 2 + q31 * 8)
# asm 1: xorl 2(<table=int64#5,<q31=int64#2,8),<y2=int64#7d
# asm 2: xorl 2(<table=%r8,<q31=%rsi,8),<y2=%eax
xorl 2(%r8,%rsi,8),%eax

# qhasm: (uint32) z3 >>= 16
# asm 1: shr  $16,<z3=int64#14d
# asm 2: shr  $16,<z3=%ebx
shr  $16,%ebx

# qhasm: q32 = z3 & 255
# asm 1: movzbl  <z3=int64#14b,>q32=int64#2d
# asm 2: movzbl  <z3=%bl,>q32=%esi
movzbl  %bl,%esi

# qhasm: (uint32) y1 ^= *(uint32 *) (table + 1 + q32 * 8)
# asm 1: xorl 1(<table=int64#5,<q32=int64#2,8),<y1=int64#4d
# asm 2: xorl 1(<table=%r8,<q32=%rsi,8),<y1=%ecx
xorl 1(%r8,%rsi,8),%ecx

# qhasm: q33 = (z3 >> 8) & 255
# asm 1: movzbl  <z3=int64#14%next8,>q33=int64#14d
# asm 2: movzbl  <z3=%bh,>q33=%ebx
movzbl  %bh,%ebx

# qhasm: (uint32) y0 ^= *(uint32 *) (table + 4 + q33 * 8)
# asm 1: xorl 4(<table=int64#5,<q33=int64#14,8),<y0=int64#3d
# asm 2: xorl 4(<table=%r8,<q33=%rbx,8),<y0=%edx
xorl 4(%r8,%rbx,8),%edx

# qhasm: y3 = *(uint32 *) (table + 2 + q03 * 8)
# asm 1: movl   2(<table=int64#5,<q03=int64#1,8),>y3=int64#14d
# asm 2: movl   2(<table=%r8,<q03=%rdi,8),>y3=%ebx
movl   2(%r8,%rdi,8),%ebx

# qhasm: (uint32) y3 ^= *(uint32 *) (table + 1 + q12 * 8)
# asm 1: xorl 1(<table=int64#5,<q12=int64#9,8),<y3=int64#14d
# asm 2: xorl 1(<table=%r8,<q12=%r11,8),<y3=%ebx
xorl 1(%r8,%r11,8),%ebx

# qhasm: y0 ^= r32
# asm 1: xorq <r32=stack64#41,<y0=int64#3
# asm 2: xorq <r32=320(%rsp),<y0=%rdx
xorq 320(%rsp),%rdx

# qhasm: (uint32) y3 ^= *(uint32 *) (table + 4 + q23 * 8)
# asm 1: xorl 4(<table=int64#5,<q23=int64#15,8),<y3=int64#14d
# asm 2: xorl 4(<table=%r8,<q23=%rbp,8),<y3=%ebx
xorl 4(%r8,%rbp,8),%ebx

# qhasm: y1 ^= r33
# asm 1: xorq <r33=stack64#42,<y1=int64#4
# asm 2: xorq <r33=328(%rsp),<y1=%rcx
xorq 328(%rsp),%rcx

# qhasm: (uint32) y3 ^= *(uint32 *) (table + 3 + q30 * 8)
# asm 1: xorl 3(<table=int64#5,<q30=int64#6,8),<y3=int64#14d
# asm 2: xorl 3(<table=%r8,<q30=%r9,8),<y3=%ebx
xorl 3(%r8,%r9,8),%ebx

# qhasm: assign 14 to y3

# qhasm: y2 ^= r34
# asm 1: xorq <r34=stack64#43,<y2=int64#7
# asm 2: xorq <r34=336(%rsp),<y2=%rax
xorq 336(%rsp),%rax

# qhasm: y3 ^= r35
# asm 1: xorq <r35=stack64#44,<y3=int64#14
# asm 2: xorq <r35=344(%rsp),<y3=%rbx
xorq 344(%rsp),%rbx

# qhasm: p00 = y0 & 255
# asm 1: movzbl  <y0=int64#3b,>p00=int64#2d
# asm 2: movzbl  <y0=%dl,>p00=%esi
movzbl  %dl,%esi

# qhasm: p01 = (y0 >> 8) & 255
# asm 1: movzbl  <y0=int64#3%next8,>p01=int64#1d
# asm 2: movzbl  <y0=%dh,>p01=%edi
movzbl  %dh,%edi

# qhasm: (uint32) y0 >>= 16
# asm 1: shr  $16,<y0=int64#3d
# asm 2: shr  $16,<y0=%edx
shr  $16,%edx

# qhasm: p02 = y0 & 255
# asm 1: movzbl  <y0=int64#3b,>p02=int64#6d
# asm 2: movzbl  <y0=%dl,>p02=%r9d
movzbl  %dl,%r9d

# qhasm: p03 = (y0 >> 8) & 255
# asm 1: movzbl  <y0=int64#3%next8,>p03=int64#15d
# asm 2: movzbl  <y0=%dh,>p03=%ebp
movzbl  %dh,%ebp

# qhasm: z0 = *(uint32 *) (table + 3 + p00 * 8)
# asm 1: movl   3(<table=int64#5,<p00=int64#2,8),>z0=int64#3d
# asm 2: movl   3(<table=%r8,<p00=%rsi,8),>z0=%edx
movl   3(%r8,%rsi,8),%edx

# qhasm: assign 3 to z0

# qhasm: p10 = y1 & 255
# asm 1: movzbl  <y1=int64#4b,>p10=int64#8d
# asm 2: movzbl  <y1=%cl,>p10=%r10d
movzbl  %cl,%r10d

# qhasm: p11 = (y1 >> 8) & 255
# asm 1: movzbl  <y1=int64#4%next8,>p11=int64#2d
# asm 2: movzbl  <y1=%ch,>p11=%esi
movzbl  %ch,%esi

# qhasm: (uint32) z0 ^= *(uint32 *) (table + 2 + p11 * 8)
# asm 1: xorl 2(<table=int64#5,<p11=int64#2,8),<z0=int64#3d
# asm 2: xorl 2(<table=%r8,<p11=%rsi,8),<z0=%edx
xorl 2(%r8,%rsi,8),%edx

# qhasm: (uint32) y1 >>= 16
# asm 1: shr  $16,<y1=int64#4d
# asm 2: shr  $16,<y1=%ecx
shr  $16,%ecx

# qhasm: p12 = y1 & 255
# asm 1: movzbl  <y1=int64#4b,>p12=int64#9d
# asm 2: movzbl  <y1=%cl,>p12=%r11d
movzbl  %cl,%r11d

# qhasm: p13 = (y1 >> 8) & 255
# asm 1: movzbl  <y1=int64#4%next8,>p13=int64#2d
# asm 2: movzbl  <y1=%ch,>p13=%esi
movzbl  %ch,%esi

# qhasm: z1 = *(uint32 *) (table + 4 + p03 * 8)
# asm 1: movl   4(<table=int64#5,<p03=int64#15,8),>z1=int64#4d
# asm 2: movl   4(<table=%r8,<p03=%rbp,8),>z1=%ecx
movl   4(%r8,%rbp,8),%ecx

# qhasm: (uint32) z1 ^= *(uint32 *) (table + 3 + p10 * 8)
# asm 1: xorl 3(<table=int64#5,<p10=int64#8,8),<z1=int64#4d
# asm 2: xorl 3(<table=%r8,<p10=%r10,8),<z1=%ecx
xorl 3(%r8,%r10,8),%ecx

# qhasm: assign 4 to z1

# qhasm: p20 = y2 & 255
# asm 1: movzbl  <y2=int64#7b,>p20=int64#8d
# asm 2: movzbl  <y2=%al,>p20=%r10d
movzbl  %al,%r10d

# qhasm: p21 = (y2 >> 8) & 255
# asm 1: movzbl  <y2=int64#7%next8,>p21=int64#15d
# asm 2: movzbl  <y2=%ah,>p21=%ebp
movzbl  %ah,%ebp

# qhasm: (uint32) z1 ^= *(uint32 *) (table + 2 + p21 * 8)
# asm 1: xorl 2(<table=int64#5,<p21=int64#15,8),<z1=int64#4d
# asm 2: xorl 2(<table=%r8,<p21=%rbp,8),<z1=%ecx
xorl 2(%r8,%rbp,8),%ecx

# qhasm: (uint32) y2 >>= 16
# asm 1: shr  $16,<y2=int64#7d
# asm 2: shr  $16,<y2=%eax
shr  $16,%eax

# qhasm: p22 = y2 & 255
# asm 1: movzbl  <y2=int64#7b,>p22=int64#10d
# asm 2: movzbl  <y2=%al,>p22=%r12d
movzbl  %al,%r12d

# qhasm: (uint32) z0 ^= *(uint32 *) (table + 1 + p22 * 8)
# asm 1: xorl 1(<table=int64#5,<p22=int64#10,8),<z0=int64#3d
# asm 2: xorl 1(<table=%r8,<p22=%r12,8),<z0=%edx
xorl 1(%r8,%r12,8),%edx

# qhasm: p23 = (y2 >> 8) & 255
# asm 1: movzbl  <y2=int64#7%next8,>p23=int64#15d
# asm 2: movzbl  <y2=%ah,>p23=%ebp
movzbl  %ah,%ebp

# qhasm: z2 = *(uint32 *) (table + 1 + p02 * 8)
# asm 1: movl   1(<table=int64#5,<p02=int64#6,8),>z2=int64#7d
# asm 2: movl   1(<table=%r8,<p02=%r9,8),>z2=%eax
movl   1(%r8,%r9,8),%eax

# qhasm: (uint32) z2 ^= *(uint32 *) (table + 4 + p13 * 8)
# asm 1: xorl 4(<table=int64#5,<p13=int64#2,8),<z2=int64#7d
# asm 2: xorl 4(<table=%r8,<p13=%rsi,8),<z2=%eax
xorl 4(%r8,%rsi,8),%eax

# qhasm: (uint32) z2 ^= *(uint32 *) (table + 3 + p20 * 8)
# asm 1: xorl 3(<table=int64#5,<p20=int64#8,8),<z2=int64#7d
# asm 2: xorl 3(<table=%r8,<p20=%r10,8),<z2=%eax
xorl 3(%r8,%r10,8),%eax

# qhasm: assign 7 to z2

# qhasm: p30 = y3 & 255
# asm 1: movzbl  <y3=int64#14b,>p30=int64#6d
# asm 2: movzbl  <y3=%bl,>p30=%r9d
movzbl  %bl,%r9d

# qhasm: p31 = (y3 >> 8) & 255
# asm 1: movzbl  <y3=int64#14%next8,>p31=int64#2d
# asm 2: movzbl  <y3=%bh,>p31=%esi
movzbl  %bh,%esi

# qhasm: (uint32) z2 ^= *(uint32 *) (table + 2 + p31 * 8)
# asm 1: xorl 2(<table=int64#5,<p31=int64#2,8),<z2=int64#7d
# asm 2: xorl 2(<table=%r8,<p31=%rsi,8),<z2=%eax
xorl 2(%r8,%rsi,8),%eax

# qhasm: (uint32) y3 >>= 16
# asm 1: shr  $16,<y3=int64#14d
# asm 2: shr  $16,<y3=%ebx
shr  $16,%ebx

# qhasm: p32 = y3 & 255
# asm 1: movzbl  <y3=int64#14b,>p32=int64#2d
# asm 2: movzbl  <y3=%bl,>p32=%esi
movzbl  %bl,%esi

# qhasm: (uint32) z1 ^= *(uint32 *) (table + 1 + p32 * 8)
# asm 1: xorl 1(<table=int64#5,<p32=int64#2,8),<z1=int64#4d
# asm 2: xorl 1(<table=%r8,<p32=%rsi,8),<z1=%ecx
xorl 1(%r8,%rsi,8),%ecx

# qhasm: p33 = (y3 >> 8) & 255
# asm 1: movzbl  <y3=int64#14%next8,>p33=int64#14d
# asm 2: movzbl  <y3=%bh,>p33=%ebx
movzbl  %bh,%ebx

# qhasm: (uint32) z0 ^= *(uint32 *) (table + 4 + p33 * 8)
# asm 1: xorl 4(<table=int64#5,<p33=int64#14,8),<z0=int64#3d
# asm 2: xorl 4(<table=%r8,<p33=%rbx,8),<z0=%edx
xorl 4(%r8,%rbx,8),%edx

# qhasm: z3 = *(uint32 *) (table + 2 + p01 * 8)
# asm 1: movl   2(<table=int64#5,<p01=int64#1,8),>z3=int64#14d
# asm 2: movl   2(<table=%r8,<p01=%rdi,8),>z3=%ebx
movl   2(%r8,%rdi,8),%ebx

# qhasm: (uint32) z3 ^= *(uint32 *) (table + 1 + p12 * 8)
# asm 1: xorl 1(<table=int64#5,<p12=int64#9,8),<z3=int64#14d
# asm 2: xorl 1(<table=%r8,<p12=%r11,8),<z3=%ebx
xorl 1(%r8,%r11,8),%ebx

# qhasm: z0 ^= r36
# asm 1: xorq <r36=stack64#45,<z0=int64#3
# asm 2: xorq <r36=352(%rsp),<z0=%rdx
xorq 352(%rsp),%rdx

# qhasm: (uint32) z3 ^= *(uint32 *) (table + 4 + p23 * 8)
# asm 1: xorl 4(<table=int64#5,<p23=int64#15,8),<z3=int64#14d
# asm 2: xorl 4(<table=%r8,<p23=%rbp,8),<z3=%ebx
xorl 4(%r8,%rbp,8),%ebx

# qhasm: z1 ^= r37
# asm 1: xorq <r37=stack64#46,<z1=int64#4
# asm 2: xorq <r37=360(%rsp),<z1=%rcx
xorq 360(%rsp),%rcx

# qhasm: (uint32) z3 ^= *(uint32 *) (table + 3 + p30 * 8)
# asm 1: xorl 3(<table=int64#5,<p30=int64#6,8),<z3=int64#14d
# asm 2: xorl 3(<table=%r8,<p30=%r9,8),<z3=%ebx
xorl 3(%r8,%r9,8),%ebx

# qhasm: assign 14 to z3

# qhasm: z2 ^= r38
# asm 1: xorq <r38=stack64#47,<z2=int64#7
# asm 2: xorq <r38=368(%rsp),<z2=%rax
xorq 368(%rsp),%rax

# qhasm: z3 ^= r39
# asm 1: xorq <r39=stack64#48,<z3=int64#14
# asm 2: xorq <r39=376(%rsp),<z3=%rbx
xorq 376(%rsp),%rbx

# qhasm: y0 = z0 & 255
# asm 1: movzbl  <z0=int64#3b,>y0=int64#1d
# asm 2: movzbl  <z0=%dl,>y0=%edi
movzbl  %dl,%edi

# qhasm: y0 = *(uint8 *) (table + 1 + y0 * 8)
# asm 1: movzbq 1(<table=int64#5,<y0=int64#1,8),>y0=int64#2
# asm 2: movzbq 1(<table=%r8,<y0=%rdi,8),>y0=%rsi
movzbq 1(%r8,%rdi,8),%rsi

# qhasm: y3 = (z0 >> 8) & 255
# asm 1: movzbl  <z0=int64#3%next8,>y3=int64#1d
# asm 2: movzbl  <z0=%dh,>y3=%edi
movzbl  %dh,%edi

# qhasm: y3 = *(uint16 *) (table + y3 * 8)
# asm 1: movzwq (<table=int64#5,<y3=int64#1,8),>y3=int64#6
# asm 2: movzwq (<table=%r8,<y3=%rdi,8),>y3=%r9
movzwq (%r8,%rdi,8),%r9

# qhasm: (uint32) z0 >>= 16
# asm 1: shr  $16,<z0=int64#3d
# asm 2: shr  $16,<z0=%edx
shr  $16,%edx

# qhasm: y2 = z0 & 255
# asm 1: movzbl  <z0=int64#3b,>y2=int64#1d
# asm 2: movzbl  <z0=%dl,>y2=%edi
movzbl  %dl,%edi

# qhasm: y2 = *(uint32 *) (table + 3 + y2 * 8)
# asm 1: movl   3(<table=int64#5,<y2=int64#1,8),>y2=int64#8d
# asm 2: movl   3(<table=%r8,<y2=%rdi,8),>y2=%r10d
movl   3(%r8,%rdi,8),%r10d

# qhasm: (uint32) y2 &= 0x00ff0000
# asm 1: and  $0x00ff0000,<y2=int64#8d
# asm 2: and  $0x00ff0000,<y2=%r10d
and  $0x00ff0000,%r10d

# qhasm: y1 = (z0 >> 8) & 255
# asm 1: movzbl  <z0=int64#3%next8,>y1=int64#1d
# asm 2: movzbl  <z0=%dh,>y1=%edi
movzbl  %dh,%edi

# qhasm: y1 = *(uint32 *) (table + 2 + y1 * 8)
# asm 1: movl   2(<table=int64#5,<y1=int64#1,8),>y1=int64#3d
# asm 2: movl   2(<table=%r8,<y1=%rdi,8),>y1=%edx
movl   2(%r8,%rdi,8),%edx

# qhasm: (uint32) y1 &= 0xff000000
# asm 1: and  $0xff000000,<y1=int64#3d
# asm 2: and  $0xff000000,<y1=%edx
and  $0xff000000,%edx

# qhasm: y0 ^= r40
# asm 1: xorq <r40=stack64#49,<y0=int64#2
# asm 2: xorq <r40=384(%rsp),<y0=%rsi
xorq 384(%rsp),%rsi

# qhasm: y3 ^= r43
# asm 1: xorq <r43=stack64#52,<y3=int64#6
# asm 2: xorq <r43=408(%rsp),<y3=%r9
xorq 408(%rsp),%r9

# qhasm: y1 ^= r41
# asm 1: xorq <r41=stack64#50,<y1=int64#3
# asm 2: xorq <r41=392(%rsp),<y1=%rdx
xorq 392(%rsp),%rdx

# qhasm: y2 ^= r42
# asm 1: xorq <r42=stack64#51,<y2=int64#8
# asm 2: xorq <r42=400(%rsp),<y2=%r10
xorq 400(%rsp),%r10

# qhasm: q10 = z1 & 255
# asm 1: movzbl  <z1=int64#4b,>q10=int64#1d
# asm 2: movzbl  <z1=%cl,>q10=%edi
movzbl  %cl,%edi

# qhasm: q10 = *(uint8 *) (table + 1 + q10 * 8)
# asm 1: movzbq 1(<table=int64#5,<q10=int64#1,8),>q10=int64#1
# asm 2: movzbq 1(<table=%r8,<q10=%rdi,8),>q10=%rdi
movzbq 1(%r8,%rdi,8),%rdi

# qhasm: y1 ^= q10
# asm 1: xor  <q10=int64#1,<y1=int64#3
# asm 2: xor  <q10=%rdi,<y1=%rdx
xor  %rdi,%rdx

# qhasm: q11 = (z1 >> 8) & 255
# asm 1: movzbl  <z1=int64#4%next8,>q11=int64#1d
# asm 2: movzbl  <z1=%ch,>q11=%edi
movzbl  %ch,%edi

# qhasm: q11 = *(uint16 *) (table + q11 * 8)
# asm 1: movzwq (<table=int64#5,<q11=int64#1,8),>q11=int64#1
# asm 2: movzwq (<table=%r8,<q11=%rdi,8),>q11=%rdi
movzwq (%r8,%rdi,8),%rdi

# qhasm: y0 ^= q11
# asm 1: xor  <q11=int64#1,<y0=int64#2
# asm 2: xor  <q11=%rdi,<y0=%rsi
xor  %rdi,%rsi

# qhasm: (uint32) z1 >>= 16
# asm 1: shr  $16,<z1=int64#4d
# asm 2: shr  $16,<z1=%ecx
shr  $16,%ecx

# qhasm: q12 = z1 & 255
# asm 1: movzbl  <z1=int64#4b,>q12=int64#1d
# asm 2: movzbl  <z1=%cl,>q12=%edi
movzbl  %cl,%edi

# qhasm: q12 = *(uint32 *) (table + 3 + q12 * 8)
# asm 1: movl   3(<table=int64#5,<q12=int64#1,8),>q12=int64#1d
# asm 2: movl   3(<table=%r8,<q12=%rdi,8),>q12=%edi
movl   3(%r8,%rdi,8),%edi

# qhasm: (uint32) q12 &= 0x00ff0000
# asm 1: and  $0x00ff0000,<q12=int64#1d
# asm 2: and  $0x00ff0000,<q12=%edi
and  $0x00ff0000,%edi

# qhasm: y3 ^= q12
# asm 1: xor  <q12=int64#1,<y3=int64#6
# asm 2: xor  <q12=%rdi,<y3=%r9
xor  %rdi,%r9

# qhasm: q13 = (z1 >> 8) & 255
# asm 1: movzbl  <z1=int64#4%next8,>q13=int64#1d
# asm 2: movzbl  <z1=%ch,>q13=%edi
movzbl  %ch,%edi

# qhasm: q13 = *(uint32 *) (table + 2 + q13 * 8)
# asm 1: movl   2(<table=int64#5,<q13=int64#1,8),>q13=int64#1d
# asm 2: movl   2(<table=%r8,<q13=%rdi,8),>q13=%edi
movl   2(%r8,%rdi,8),%edi

# qhasm: (uint32) q13 &= 0xff000000
# asm 1: and  $0xff000000,<q13=int64#1d
# asm 2: and  $0xff000000,<q13=%edi
and  $0xff000000,%edi

# qhasm: y2 ^= q13
# asm 1: xor  <q13=int64#1,<y2=int64#8
# asm 2: xor  <q13=%rdi,<y2=%r10
xor  %rdi,%r10

# qhasm: q20 = z2 & 255
# asm 1: movzbl  <z2=int64#7b,>q20=int64#1d
# asm 2: movzbl  <z2=%al,>q20=%edi
movzbl  %al,%edi

# qhasm: q20 = *(uint8 *) (table + 1 + q20 * 8)
# asm 1: movzbq 1(<table=int64#5,<q20=int64#1,8),>q20=int64#1
# asm 2: movzbq 1(<table=%r8,<q20=%rdi,8),>q20=%rdi
movzbq 1(%r8,%rdi,8),%rdi

# qhasm: y2 ^= q20
# asm 1: xor  <q20=int64#1,<y2=int64#8
# asm 2: xor  <q20=%rdi,<y2=%r10
xor  %rdi,%r10

# qhasm: q21 = (z2 >> 8) & 255
# asm 1: movzbl  <z2=int64#7%next8,>q21=int64#1d
# asm 2: movzbl  <z2=%ah,>q21=%edi
movzbl  %ah,%edi

# qhasm: q21 = *(uint16 *) (table + q21 * 8)
# asm 1: movzwq (<table=int64#5,<q21=int64#1,8),>q21=int64#1
# asm 2: movzwq (<table=%r8,<q21=%rdi,8),>q21=%rdi
movzwq (%r8,%rdi,8),%rdi

# qhasm: y1 ^= q21
# asm 1: xor  <q21=int64#1,<y1=int64#3
# asm 2: xor  <q21=%rdi,<y1=%rdx
xor  %rdi,%rdx

# qhasm: (uint32) z2 >>= 16
# asm 1: shr  $16,<z2=int64#7d
# asm 2: shr  $16,<z2=%eax
shr  $16,%eax

# qhasm: q22 = z2 & 255
# asm 1: movzbl  <z2=int64#7b,>q22=int64#1d
# asm 2: movzbl  <z2=%al,>q22=%edi
movzbl  %al,%edi

# qhasm: q22 = *(uint32 *) (table + 3 + q22 * 8)
# asm 1: movl   3(<table=int64#5,<q22=int64#1,8),>q22=int64#1d
# asm 2: movl   3(<table=%r8,<q22=%rdi,8),>q22=%edi
movl   3(%r8,%rdi,8),%edi

# qhasm: (uint32) q22 &= 0x00ff0000
# asm 1: and  $0x00ff0000,<q22=int64#1d
# asm 2: and  $0x00ff0000,<q22=%edi
and  $0x00ff0000,%edi

# qhasm: y0 ^= q22
# asm 1: xor  <q22=int64#1,<y0=int64#2
# asm 2: xor  <q22=%rdi,<y0=%rsi
xor  %rdi,%rsi

# qhasm: q23 = (z2 >> 8) & 255
# asm 1: movzbl  <z2=int64#7%next8,>q23=int64#1d
# asm 2: movzbl  <z2=%ah,>q23=%edi
movzbl  %ah,%edi

# qhasm: q23 = *(uint32 *) (table + 2 + q23 * 8)
# asm 1: movl   2(<table=int64#5,<q23=int64#1,8),>q23=int64#1d
# asm 2: movl   2(<table=%r8,<q23=%rdi,8),>q23=%edi
movl   2(%r8,%rdi,8),%edi

# qhasm: (uint32) q23 &= 0xff000000
# asm 1: and  $0xff000000,<q23=int64#1d
# asm 2: and  $0xff000000,<q23=%edi
and  $0xff000000,%edi

# qhasm: y3 ^= q23
# asm 1: xor  <q23=int64#1,<y3=int64#6
# asm 2: xor  <q23=%rdi,<y3=%r9
xor  %rdi,%r9

# qhasm: q30 = z3 & 255
# asm 1: movzbl  <z3=int64#14b,>q30=int64#1d
# asm 2: movzbl  <z3=%bl,>q30=%edi
movzbl  %bl,%edi

# qhasm: q30 = *(uint8 *) (table + 1 + q30 * 8)
# asm 1: movzbq 1(<table=int64#5,<q30=int64#1,8),>q30=int64#1
# asm 2: movzbq 1(<table=%r8,<q30=%rdi,8),>q30=%rdi
movzbq 1(%r8,%rdi,8),%rdi

# qhasm: y3 ^= q30
# asm 1: xor  <q30=int64#1,<y3=int64#6
# asm 2: xor  <q30=%rdi,<y3=%r9
xor  %rdi,%r9

# qhasm: q31 = (z3 >> 8) & 255
# asm 1: movzbl  <z3=int64#14%next8,>q31=int64#1d
# asm 2: movzbl  <z3=%bh,>q31=%edi
movzbl  %bh,%edi

# qhasm: q31 = *(uint16 *) (table + q31 * 8)
# asm 1: movzwq (<table=int64#5,<q31=int64#1,8),>q31=int64#1
# asm 2: movzwq (<table=%r8,<q31=%rdi,8),>q31=%rdi
movzwq (%r8,%rdi,8),%rdi

# qhasm: y2 ^= q31
# asm 1: xor  <q31=int64#1,<y2=int64#8
# asm 2: xor  <q31=%rdi,<y2=%r10
xor  %rdi,%r10

# qhasm: (uint32) z3 >>= 16
# asm 1: shr  $16,<z3=int64#14d
# asm 2: shr  $16,<z3=%ebx
shr  $16,%ebx

# qhasm: q32 = z3 & 255
# asm 1: movzbl  <z3=int64#14b,>q32=int64#1d
# asm 2: movzbl  <z3=%bl,>q32=%edi
movzbl  %bl,%edi

# qhasm: q32 = *(uint32 *) (table + 3 + q32 * 8)
# asm 1: movl   3(<table=int64#5,<q32=int64#1,8),>q32=int64#1d
# asm 2: movl   3(<table=%r8,<q32=%rdi,8),>q32=%edi
movl   3(%r8,%rdi,8),%edi

# qhasm: (uint32) q32 &= 0x00ff0000
# asm 1: and  $0x00ff0000,<q32=int64#1d
# asm 2: and  $0x00ff0000,<q32=%edi
and  $0x00ff0000,%edi

# qhasm: y1 ^= q32
# asm 1: xor  <q32=int64#1,<y1=int64#3
# asm 2: xor  <q32=%rdi,<y1=%rdx
xor  %rdi,%rdx

# qhasm: q33 = (z3 >> 8) & 255
# asm 1: movzbl  <z3=int64#14%next8,>q33=int64#1d
# asm 2: movzbl  <z3=%bh,>q33=%edi
movzbl  %bh,%edi

# qhasm: q33 = *(uint32 *) (table + 2 + q33 * 8)
# asm 1: movl   2(<table=int64#5,<q33=int64#1,8),>q33=int64#1d
# asm 2: movl   2(<table=%r8,<q33=%rdi,8),>q33=%edi
movl   2(%r8,%rdi,8),%edi

# qhasm: (uint32) q33 &= 0xff000000
# asm 1: and  $0xff000000,<q33=int64#1d
# asm 2: and  $0xff000000,<q33=%edi
and  $0xff000000,%edi

# qhasm: y0 ^= q33
# asm 1: xor  <q33=int64#1,<y0=int64#2
# asm 2: xor  <q33=%rdi,<y0=%rsi
xor  %rdi,%rsi

# qhasm: out = out_stack
# asm 1: movq <out_stack=stack64#1,>out=int64#1
# asm 2: movq <out_stack=0(%rsp),>out=%rdi
movq 0(%rsp),%rdi

# qhasm: *(uint32 *) (out + 0) = y0
# asm 1: movl   <y0=int64#2d,0(<out=int64#1)
# asm 2: movl   <y0=%esi,0(<out=%rdi)
movl   %esi,0(%rdi)

# qhasm: *(uint32 *) (out + 4) = y1
# asm 1: movl   <y1=int64#3d,4(<out=int64#1)
# asm 2: movl   <y1=%edx,4(<out=%rdi)
movl   %edx,4(%rdi)

# qhasm: *(uint32 *) (out + 8) = y2
# asm 1: movl   <y2=int64#8d,8(<out=int64#1)
# asm 2: movl   <y2=%r10d,8(<out=%rdi)
movl   %r10d,8(%rdi)

# qhasm: *(uint32 *) (out + 12) = y3
# asm 1: movl   <y3=int64#6d,12(<out=int64#1)
# asm 2: movl   <y3=%r9d,12(<out=%rdi)
movl   %r9d,12(%rdi)

# qhasm: r11_caller = r11_stack
# asm 1: movq <r11_stack=stack64#2,>r11_caller=int64#9
# asm 2: movq <r11_stack=8(%rsp),>r11_caller=%r11
movq 8(%rsp),%r11

# qhasm: r12_caller = r12_stack
# asm 1: movq <r12_stack=stack64#3,>r12_caller=int64#10
# asm 2: movq <r12_stack=16(%rsp),>r12_caller=%r12
movq 16(%rsp),%r12

# qhasm: r13_caller = r13_stack
# asm 1: movq <r13_stack=stack64#4,>r13_caller=int64#11
# asm 2: movq <r13_stack=24(%rsp),>r13_caller=%r13
movq 24(%rsp),%r13

# qhasm: r14_caller = r14_stack
# asm 1: movq <r14_stack=stack64#5,>r14_caller=int64#12
# asm 2: movq <r14_stack=32(%rsp),>r14_caller=%r14
movq 32(%rsp),%r14

# qhasm: r15_caller = r15_stack
# asm 1: movq <r15_stack=stack64#6,>r15_caller=int64#13
# asm 2: movq <r15_stack=40(%rsp),>r15_caller=%r15
movq 40(%rsp),%r15

# qhasm: rbx_caller = rbx_stack
# asm 1: movq <rbx_stack=stack64#7,>rbx_caller=int64#14
# asm 2: movq <rbx_stack=48(%rsp),>rbx_caller=%rbx
movq 48(%rsp),%rbx

# qhasm: rbp_caller = rbp_stack
# asm 1: movq <rbp_stack=stack64#8,>rbp_caller=int64#15
# asm 2: movq <rbp_stack=56(%rsp),>rbp_caller=%rbp
movq 56(%rsp),%rbp

# qhasm: leave
add %r11,%rsp
mov %rdi,%rax
mov %rsi,%rdx
ret