.f:
  movq %rax, %rdx
  addl $0x3e3, %edx
  andl $0xfffffffb, %edx
  cmpl $0x1, %edx
  setbe %dl
  movzbl %dl, %edx
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    22 bytes

# Text             #  Line  RIP  Bytes  Opcode
.f:                #        0    0      OPC=<label>
  xorq %rdx, %rdx  #  1     0    3      OPC=xorq_r64_r64
  retq             #  2     0x3  1      OPC=retq

.size f, .-f


.f:
  addl $0x7, %eax
  cltq
  addq $0x3, %rax
  shlq $0x4, %rax
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    14 bytes

# Text                         #  Line  RIP  Bytes  Opcode
.f:                            #        0    0      OPC=<label>
  cltq                         #  1     0    2      OPC=cltq
  leaq 0x4(%rax,%rax,1), %rax  #  2     0x2  5      OPC=leaq_r64_m64
  leaq 0x80(,%rax,8), %rax     #  3     0x7  8      OPC=leaq_r64_m64
  retq                         #  4     0xf  1      OPC=retq

.size f, .-f


.f:
movq $0xffffffffffffffc0, %rsi
movswq %ax, %rcx
xchgl %ecx, %eax
retq


.f:
  addl $0x1, %eax
  cltq
  negq %rax
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    9 bytes

# Text       #  Line  RIP  Bytes  Opcode
.f:          #        0    0      OPC=<label>
  notl %eax  #  1     0    2      OPC=notl_r32
  cltq       #  2     0x2  2      OPC=cltq
  retq       #  3     0x4  1      OPC=retq

.size f, .-f


.f:
movq $0xfffffffffffffffd, %r11
xorl %r11d, %eax
shrw $0x1, %r11w
retq


.f:
  addl $0x1, %eax
  cltq
  xchgw %ax, %ax
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    8 bytes

# Text                    #  Line  RIP  Bytes  Opcode
.f:                       #        0    0      OPC=<label>
  cltq                    #  1     0    2      OPC=cltq
  subq $0xffffffff, %rax  #  2     0x2  7      OPC=subq_r64_imm32
  retq                    #  3     0x9  1      OPC=retq

.size f, .-f


.f:
subl $0xffffffff, %eax
cltq
cmpq $0xffffffff, %rax
retq


.f:
subl $0xfffffffd, %eax
cltq
cmpq $0xfffffffa, %rax
retq


.f:
  movq %rax, %rsi
  addl $0x1, %esi
  imull $0x3e8, %esi, %esi
  sarl $0x8, %esi
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    16 bytes

# Text                       #  Line  RIP   Bytes  Opcode
.f:                          #        0     0      OPC=<label>
  imulq $0x3e8, %rax, %rax   #  1     0     7      OPC=imulq_r64_r64_imm32
  leal 0x3e8(,%eax,1), %esi  #  2     0x7   8      OPC=leal_r32_m64
  sarl $0xe8, %esi           #  3     0xf   3      OPC=sarl_r32_imm8
  retq                       #  4     0x12  1      OPC=retq

.size f, .-f


.f:
imulq $0x3e8, %rax, %rax
leal 0x3e8(,%eax,1), %esi
sarl $0xe8, %esi
retq


.f:
orl $0xfffffff9, %eax
leaq 0x3(,%eax,8), %r8
xorq %rsi, %rsi
retq


.f:
popcntl %eax, %eax
movl $0xfffffff0, %esi
movl $0x20, %r11d
retq


.f:
  movq %rax, %rdx
  addl $0x1, %edx
  notq %rdx
  addq %rax, %rdx
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    13 bytes

# Text                     #  Line  RIP  Bytes  Opcode
.f:                        #        0    0      OPC=<label>
  leal 0x2(,%rax,1), %edx  #  1     0    7      OPC=leal_r32_m16
  subq %rdx, %rax          #  2     0x7  3      OPC=subq_r64_r64
  xchgq %rax, %rdx         #  3     0xa  3      OPC=xchgq_r64_r64
  retq                     #  4     0xd  1      OPC=retq

.size f, .-f


.f:
btcq $0x20, %rax
movq $0xfffffffffffffffe, %rdx
movw %dx, %ax
retq


.f:
  movq %rax, %rcx
  addl %ecx, %ecx
  subl %ecx, %eax
  movl %eax, %edx
  shrl $0x1f, %edx
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    13 bytes

# Text       #  Line  RIP  Bytes  Opcode
.f:          #        0    0      OPC=<label>
  cltd       #  1     0    1      OPC=cltd
  incl %edx  #  2     0x1  2      OPC=incl_r32
  retq       #  3     0x3  1      OPC=retq

.size f, .-f


.f:
  addq $0x1f4, %rcx
  sarq $0x3f, %rcx
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    12 bytes

# Text              #  Line  RIP  Bytes  Opcode
.f:                 #        0    0      OPC=<label>
  sarq $0xff, %rcx  #  1     0    4      OPC=sarq_r64_imm8
  retq              #  2     0x4  1      OPC=retq

.size f, .-f


.f:
movsbq %cl, %r11
sarq $0xfe, %rcx
retq


.f:
  movq %rax, %rdx
  addq %rax, %rax
  xorq %rdx, %rax
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    10 bytes

# Text                   #  Line  RIP  Bytes  Opcode
.f:                      #        0    0      OPC=<label>
  imulq $0x2, %rax, %r8  #  1     0    4      OPC=imulq_r64_r64_imm8
  xorq %r8, %rax         #  2     0x4  3      OPC=xorq_r64_r64
  retq                   #  3     0x7  1      OPC=retq

.size f, .-f


.f:
leaq (,%rax,1), %r8
leaq (%r8,%rax,1), %rax
xorq %r8, %rax
retq


.f:
imulq $0x2, %rax, %r8
xorq %r8, %rax
retq


.f:
leaq -0x5(,%rax,1), %r8
leaq (%r8,%rax,1), %rax
xorq %r8, %rax
retq


.f:
leaq 0x20(,%rax,1), %r8
leaq (%r8,%rax,1), %rax
xorq %r8, %rax
retq


.f:
leaq 0x10(,%rax,1), %r8
leaq (%r8,%rax,1), %rax
xorq %r8, %rax
retq


.f:
  andb $0xfe, %ah
  cmpq $0x4, %rax
  setne %dl
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    11 bytes

# Text             #  Line  RIP  Bytes  Opcode
.f:                #        0    0      OPC=<label>
  movq $0x1, %rdx  #  1     0    7      OPC=movq_r64_imm32
  retq             #  2     0x7  1      OPC=retq

.size f, .-f


.f:
  movl %eax, %edx
  andl $0x7f, %edx
  addl $0x41, %edx
  movslq %edx, %rdx
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    12 bytes

# Text                      #  Line  RIP  Bytes  Opcode
.f:                         #        0    0      OPC=<label>
  andl $0x7f, %eax          #  1     0    3      OPC=andl_r32_imm8
  leaq 0x41(,%rax,1), %rdx  #  2     0x3  8      OPC=leaq_r64_m16
  retq                      #  3     0xb  1      OPC=retq

.size f, .-f


.f:
andl $0x7f, %eax
movzbq %al, %r8
leaq 0x41(,%r8d,1), %rdx
retq


.f:
andl $0x7f, %eax
leaq 0x41(,%rax,1), %rdx
retq


.f:
subl $0xffffffff, %eax
movzbl %al, %r10d
xorl %edx, %edx
retq


.f:
movzbl %al, %r8d
xorl %edx, %edx
leal 0x41(,%r8d,1), %edx
retq


.f:
movzbl %al, %r8d
leaq 0x41(,%r8d,1), %rdx
sarb $0x1, %dh
retq


.f:
  movl %eax, %edx
  andl $0x2, %edx
  andl $0x1, %eax
  cmpw $0x1, %ax
  sbbl %edx, %edx
  andl $0x2, %edx
  addl $0x2b, %edx
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    21 bytes

# Text                     #  Line  RIP   Bytes  Opcode
.f:                        #        0     0      OPC=<label>
  leal 0x6(,%eax,2), %edx  #  1     0     8      OPC=leal_r32_m32
  andq $0x2, %rdx          #  2     0x8   4      OPC=andq_r64_imm8
  addq $0x2b, %rdx         #  3     0xc   7      OPC=addq_r64_imm32
  retq                     #  4     0x13  1      OPC=retq

.size f, .-f


.f:
movl $0x2b, %edx
shrb $0x1, %ah
leaq 0x2(,%rdx,1), %r11
retq


.f:
  movl %esi, %eax
  andl $0x2, %eax
  cmpb $0x1, %al
  sbbl %eax, %eax
  notl %eax
  andl $0x40, %eax
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    15 bytes

# Text                     #  Line  RIP  Bytes  Opcode
.f:                        #        0    0      OPC=<label>
  imull $0x20, %esi, %eax  #  1     0    6      OPC=imull_r32_r32_imm32
  cwtd                     #  2     0x6  2      OPC=cwtd
  andq $0x40, %rax         #  3     0x8  6      OPC=andq_rax_imm32
  retq                     #  4     0xe  1      OPC=retq

.size f, .-f


.f:
imull $0x20, %esi, %eax
cwtd
andq $0x40, %rax
retq


.f:
orb %sil, %sil
movq $0x40, %rax
retq


.f:
  movl %eax, %ecx
  andl $0xfffffff8, %ecx
  cmpb $0xf0, %cl
  sete %cl
  movzbl %cl, %ecx
  shlq $0x2, %rcx
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    19 bytes

# Text             #  Line  RIP  Bytes  Opcode
.f:                #        0    0      OPC=<label>
  xorq %rcx, %rcx  #  1     0    3      OPC=xorq_r64_r64
  retq             #  2     0x3  1      OPC=retq

.size f, .-f


.f:
  andl $0x4, %eax
  cmpl $0x1, %eax
  sbbl %eax, %eax
  addl $0x3, %eax
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    12 bytes

# Text             #  Line  RIP  Bytes  Opcode
.f:                #        0    0      OPC=<label>
  andl $0x4, %eax  #  1     0    5      OPC=andl_eax_imm32
  shrw $0x2, %ax   #  2     0x5  4      OPC=shrw_r16_imm8
  btsl $0x1, %eax  #  3     0x9  4      OPC=btsl_r32_imm8
  retq             #  4     0xd  1      OPC=retq

.size f, .-f


.f:
andl $0x4, %eax
shrw $0x2, %ax
btsl $0x1, %eax
retq


.f:
subw %ax, %ax
movzbl %ah, %eax
addl $0x2, %eax
retq


.f:
xorl %eax, %eax
addl $0x2, %eax
retq


.f:
  movq %rax, %rdx
  andl $0x2, %edx
  cmpl $0x1, %edx
  sbbq %rax, %rax
  andq $0xfffffffe, %rax
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    17 bytes

# Text                    #  Line  RIP  Bytes  Opcode
.f:                       #        0    0      OPC=<label>
  andq $0x2, %rax         #  1     0    6      OPC=andq_rax_imm32
  adcq $0xfffffffe, %rax  #  2     0x6  4      OPC=adcq_r64_imm8
  retq                    #  3     0xa  1      OPC=retq

.size f, .-f


.f:
andl $0x2, %eax
movl %eax, %ecx
adcq $0xfffffffe, %rax
retq


.f:
andq $0x2, %rax
adcq $0xfffffffe, %rax
retq


.f:
xorq %rax, %rax
cltd
addq $0xfffffffe, %rax
retq


.f:
subq %rax, %rax
cltd
addq $0xfffffffe, %rdx
retq


.f:
subl %eax, %eax
movq $0xfffffffffffffffe, %r10
retq


.f:
  andl $0x8, %eax
  cmpl $0x1, %eax
  sbbq %rax, %rax
  andq $0xffffffd8, %rax
  addq $0x38, %rax
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    18 bytes

# Text                         #  Line  RIP  Bytes  Opcode
.f:                            #        0    0      OPC=<label>
  andl $0x8, %eax              #  1     0    6      OPC=andl_r32_imm32
  leaw 0x10(%rax,%rax,4), %ax  #  2     0x6  5      OPC=leaw_r16_m32
  retq                         #  3     0xb  1      OPC=retq

.size f, .-f


.f:
xorb $0x40, %al
andl $0x8, %eax
leal 0x10(%rax,%rax,4), %eax
retq


.f:
andl $0x8, %eax
leaw 0x10(%rax,%rax,4), %ax
retq


.f:
movq $0x38, %r10
xorl %eax, %eax
xorb $0x10, %al
retq


.f:
btsl $0x4, %eax
andq $0x38, %rax
retq


.f:
  movl %eax, %edx
  andl $0xfffffffd, %edx
  cmpl $0x4, %edx
  sete %dl
  cmpl $0x8, %eax
  sete %al
  orl %eax, %edx
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    20 bytes

# Text           #  Line  RIP  Bytes  Opcode
.f:              #        0    0      OPC=<label>
  xorb %dl, %dl  #  1     0    2      OPC=xorb_r8_r8
  retq           #  2     0x2  1      OPC=retq

.size f, .-f


.f:
  movq %rax, %rdx
  movl %edx, %eax
  andl $0xfffffffd, %eax
  cmpw $0x18, %ax
  sete %cl
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    16 bytes

# Text             #  Line  RIP  Bytes  Opcode
.f:                #        0    0      OPC=<label>
  xorl %ecx, %ecx  #  1     0    2      OPC=xorl_r32_r32
  retq             #  2     0x2  1      OPC=retq

.size f, .-f


.f:
  movq %r8, %r14
  andl $0x1, %r8d
  shrq $0x1, %r14
  addq %r14, %r8
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    14 bytes

# Text            #  Line  RIP  Bytes  Opcode
.f:               #        0    0      OPC=<label>
  addq $0x1, %r8  #  1     0    7      OPC=addq_r64_imm32
  shrq $0x1, %r8  #  2     0x7  3      OPC=shrq_r64_one
  retq            #  3     0xa  1      OPC=retq

.size f, .-f


.f:
  andl $0xf000, %eax
  subl $0x6000, %eax
  testl $0xffffd000, %eax
  setne %al
  movzbl %al, %eax
  negl %eax
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    24 bytes

# Text               #  Line  RIP  Bytes  Opcode
.f:                  #        0    0      OPC=<label>
  andb $0x10, %ah    #  1     0    3      OPC=andb_rh_imm8
  addw $0xffc0, %ax  #  2     0x3  4      OPC=addw_r16_imm8
  sbbl %eax, %eax    #  3     0x7  2      OPC=sbbl_r32_r32_1
  retq               #  4     0x9  1      OPC=retq

.size f, .-f


.f:
orl $0xffffffff, %eax
xorl %r9d, %r9d
retq


.f:
  movq %rax, %rcx
  movl %ecx, %eax
  movl %ecx, %edx
  andw $0xfff, %ax
  shrw $0xd, %dx
  cmpw $0x502, %ax
  sete %al
  andl %edx, %eax
  movl %ecx, %edx
  shrw $0xe, %dx
  xorl $0x1, %edx
  andb %dl, %al
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    36 bytes

# Text              #  Line  RIP  Bytes  Opcode
.f:                 #        0    0      OPC=<label>
  subw %ax, %ax     #  1     0    3      OPC=subw_r16_r16
  sall $0x80, %eax  #  2     0x3  3      OPC=sall_r32_imm8
  retq              #  3     0x6  1      OPC=retq

.size f, .-f


.f:
cbtw
subb %ah, %ah
btrl $0x80, %eax
retq


.f:
  movq %rax, %rsi
  bswap %esi
  movl %esi, %edi
  andl $0x1fffff, %edi
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    14 bytes

# Text                  #  Line  RIP  Bytes  Opcode
.f:                     #        0    0      OPC=<label>
  bswap %eax            #  1     0    2      OPC=bswap_r32
  movq $0x1fffff, %rdi  #  2     0x2  7      OPC=movq_r64_imm32
  andq %rax, %rdi       #  3     0x9  3      OPC=andq_r64_r64_1
  retq                  #  4     0xc  1      OPC=retq

.size f, .-f


.f:
bswap %eax
movq $0x1fffff, %rdi
andq %rax, %rdi
retq


.f:
shrb $0xfe, %al
bswap %eax
leal (,%rax,1), %edi
retq


.f:
xorl %edi, %edi
sbbb %ah, %al
bswap %eax
retq


.f:
  movq %rdx, %rcx
  movq %rcx, %rax
  movq %rax, %rdx
  bswap %ecx
  bswap %eax
  addl %ecx, %eax
  bswap %edx
  leal (%rax,%rcx,4), %eax
  leal (%rax,%rdx,4), %eax
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    24 bytes

# Text                         #  Line  RIP  Bytes  Opcode
.f:                            #        0    0      OPC=<label>
  bswap %edx                   #  1     0    2      OPC=bswap_r32
  leal -0x6(,%edx,2), %eax     #  2     0x2  8      OPC=leal_r32_m16
  leal 0x6(%eax,%edx,8), %eax  #  3     0xa  5      OPC=leal_r32_m16
  retq                         #  4     0xf  1      OPC=retq

.size f, .-f


.f:
bswap %edx
leal -0x6(,%edx,2), %eax
leal 0x6(%eax,%edx,8), %eax
retq


.f:
xorl %eax, %eax
leaq 0x40(,%edx,8), %rdx
leaq -0x4(,%eax,8), %rcx
retq


.f:
xorl %eax, %eax
leal 0x40(,%edx,8), %r10d
addl $0xfffffffc, %edx
retq


.f:
  movl $0x51eb851f, %esi
  movq %rax, %rdx
  bswap %edx
  movl %edx, %eax
  mull %esi
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    15 bytes

# Text                           #  Line  RIP  Bytes  Opcode
.f:                              #        0    0      OPC=<label>
  bswap %eax                     #  1     0    2      OPC=bswap_r32
  imull $0x51eb851f, %eax, %eax  #  2     0x2  6      OPC=imull_r32_r32_imm32
  retq                           #  3     0x8  1      OPC=retq

.size f, .-f


.f:
bswap %eax
imull $0x51eb851f, %eax, %r9d
xchgl %r9d, %eax
retq


.f:
bswap %eax
imull $0x51eb851f, %eax, %eax
retq


.f:
cqto
subl %edx, %eax
imull $0xffffffc0, %eax, %r11d
retq


.f:
cqto
imull $0xfffffffc, %eax, %esi
subl %edx, %eax
retq


.f:
cqto
subl %edx, %eax
imull $0xfffffffc, %eax, %esi
retq


.f:
  movq %rax, %rdx
  bswap %edx
  subl $0x1, %edx
  bswap %edx
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    11 bytes

# Text                            #  Line  RIP   Bytes  Opcode
.f:                               #        0     0      OPC=<label>
  movq $0xffffffffffffffff, %rdx  #  1     0     10     OPC=movq_r64_imm64
  btcl $0xf8, %edx                #  2     0xa   4      OPC=btcl_r32_imm8
  adcl %eax, %edx                 #  3     0xe   2      OPC=adcl_r32_r32_1
  retq                            #  4     0x10  1      OPC=retq

.size f, .-f


.f:
  cltd
  shrl $0x1d, %edx
  addl %edx, %eax
  andl $0x7, %eax
  subl %edx, %eax
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    12 bytes

# Text                         #  Line  RIP  Bytes  Opcode
.f:                            #        0    0      OPC=<label>
  cltd                         #  1     0    1      OPC=cltd
  orl $0xfffffff8, %eax        #  2     0x1  6      OPC=orl_r32_imm32
  leaq 0x8(%eax,%edx,8), %rax  #  3     0x7  6      OPC=leaq_r64_m32
  retq                         #  4     0xd  1      OPC=retq

.size f, .-f


.f:
movl $0x1, %r9d
orb $0xfd, %ah
orl $0xfffffffc, %eax
retq


.f:
  movq %rax, %rdx
  cltq
  leaq (%rdx,%rdx,4), %rdx
  leaq (%rax,%rdx,2), %rax
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    14 bytes

# Text                          #  Line  RIP  Bytes  Opcode
.f:                             #        0    0      OPC=<label>
  movslq %eax, %rdi             #  1     0    3      OPC=movslq_r64_r32
  leaq -0x1(%rdi,%rax,2), %rdx  #  2     0x3  5      OPC=leaq_r64_m16
  leaq 0x1(%rdx,%rax,8), %rax   #  3     0x8  5      OPC=leaq_r64_m32
  retq                          #  4     0xd  1      OPC=retq

.size f, .-f


.f:
movslq %eax, %rdi
leaq -0x1(%rdi,%rax,2), %rdx
leaq 0x1(%rdx,%rax,8), %rax
retq


.f:
movl $0xfffffffe, %r8d
rolq $0x1, %rax
retq


.f:
rolq $0x1, %rax
movq $0xfffffffffffffffe, %r8
retq


.f:
  movq %rax, %r11
  cltq
  movzwl %r11w, %r8d
  addq %rax, %r8
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    13 bytes

# Text              #  Line  RIP  Bytes  Opcode
.f:                 #        0    0      OPC=<label>
  movzwl %ax, %r8d  #  1     0    4      OPC=movzwl_r32_r16
  addl %r8d, %eax   #  2     0x4  3      OPC=addl_r32_r32_1
  movslq %eax, %r8  #  3     0x7  3      OPC=movslq_r64_r32
  retq              #  4     0xa  1      OPC=retq

.size f, .-f


.f:
salw $0x1, %ax
xorq %r8, %r8
orl %eax, %r8d
retq


.f:
  cltq
  notq %rax
  shrq $0x3f, %rax
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    10 bytes

# Text              #  Line  RIP  Bytes  Opcode
.f:                 #        0    0      OPC=<label>
  sarl $0x3f, %eax  #  1     0    3      OPC=sarl_r32_imm8
  addl $0x1, %eax   #  2     0x3  3      OPC=addl_r32_imm8
  retq              #  3     0x6  1      OPC=retq

.size f, .-f


.f:
sarl $0x3f, %eax
addl $0x1, %eax
retq


.f:
xaddl %eax, %eax
movl $0x40, %eax
setg %al
retq


.f:
  movq %rax, %r8
  cmpl $0x3b, %r8d
  setbe %dl
  andb %dl, %al
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    13 bytes

# Text             #  Line  RIP  Bytes  Opcode
.f:                #        0    0      OPC=<label>
  xorl %eax, %eax  #  1     0    2      OPC=xorl_r32_r32_1
  retq             #  2     0x2  1      OPC=retq

.size f, .-f


.f:
  cmpl $0x100, %eax
  sete %r12b
  movzbl %r12b, %r12d
  leal (%r12,%r12,8), %r12d
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    18 bytes

# Text               #  Line  RIP  Bytes  Opcode
.f:                  #        0    0      OPC=<label>
  xorl %r12d, %r12d  #  1     0    3      OPC=xorl_r32_r32
  retq               #  2     0x3  1      OPC=retq

.size f, .-f


.f:
  cmpl $0xffffffff, %eax
  sete %al
  movzbl %al, %eax
  negl %eax
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    12 bytes

# Text             #  Line  RIP  Bytes  Opcode
.f:                #        0    0      OPC=<label>
  xorq %rax, %rax  #  1     0    3      OPC=xorq_r64_r64
  retq             #  2     0x3  1      OPC=retq

.size f, .-f


.f:
  movq %rcx, %rax
  movq %rax, %rcx
  cmpq $0x1, %rax
  sbbl $0xffffffff, %ecx
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    14 bytes

# Text                    #  Line  RIP  Bytes  Opcode
.f:                       #        0    0      OPC=<label>
  subl $0xffffffff, %ecx  #  1     0    3      OPC=subl_r32_imm8
  retq                    #  2     0x3  1      OPC=retq

.size f, .-f


.f:
  movl $0x5, %edx
  cmpq $0x1, %r14
  sbbq %rdx, %rdx
  andl $0x5, %edx
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    16 bytes

# Text             #  Line  RIP  Bytes  Opcode
.f:                #        0    0      OPC=<label>
  xorq %rdx, %rdx  #  1     0    3      OPC=xorq_r64_r64
  retq             #  2     0x3  1      OPC=retq

.size f, .-f


.f:
  movq %rax, %rsi
  movq $0x7fffffffffffffff, %rdx
  cmpq %rdx, %rsi
  setne %dl
  movzbl %dl, %edx
  addq %rsi, %rdx
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    26 bytes

# Text                     #  Line  RIP  Bytes  Opcode
.f:                        #        0    0      OPC=<label>
  leaq 0x1(,%rax,1), %rdx  #  1     0    8      OPC=leaq_r64_m16
  retq                     #  2     0x8  1      OPC=retq

.size f, .-f


.f:
  cmpq $0x1, %rax
  setne %al
  movzbl %al, %eax
  negl %eax
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    13 bytes

# Text                   #  Line  RIP  Bytes  Opcode
.f:                      #        0    0      OPC=<label>
  orl $0xffffffff, %eax  #  1     0    6      OPC=orl_r32_imm32
  retq                   #  2     0x6  1      OPC=retq

.size f, .-f


.f:
btsl $0x1, %eax
subb %al, %ah
cltd
retq


.f:
  cmpw $0xbfff, %ax
  setbe %sil
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    9 bytes

# Text             #  Line  RIP  Bytes  Opcode
.f:                #        0    0      OPC=<label>
  cmpb $0xc0, %ah  #  1     0    3      OPC=cmpb_rh_imm8
  setnae %sil      #  2     0x3  4      OPC=setnae_r8
  retq             #  3     0x7  1      OPC=retq

.size f, .-f


.f:
addw %ax, %ax
setae %sil
movb $0xfb, %dl
retq


.f:
cmpb $0xc0, %ah
movsbl %ah, %eax
setbe %sil
retq


.f:
  movq %rax, %r11
  cwtl
  movl %r11d, %edx
  addl %eax, %edx
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    10 bytes

# Text             #  Line  RIP  Bytes  Opcode
.f:                #        0    0      OPC=<label>
  addw %ax, %ax    #  1     0    3      OPC=addw_r16_r16
  movl %eax, %edx  #  2     0x3  2      OPC=movl_r32_r32
  retq             #  3     0x5  1      OPC=retq

.size f, .-f


.f:
addw %ax, %ax
cltd
movl %eax, %edx
retq


.f:
xorq %rdx, %rdx
shldl $0x40, %eax, %eax
retq


.f:
cqto
sarb $0xf8, %al
shrdl $0x80, %eax, %eax
retq


.f:
addw %ax, %ax
cltd
shldl $0x80, %edx, %eax
retq


.f:
  cwtl
  imull $0xe10, %eax, %eax
  cltq
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    10 bytes

# Text                     #  Line  RIP  Bytes  Opcode
.f:                        #        0    0      OPC=<label>
  movswq %ax, %r9          #  1     0    4      OPC=movswq_r64_r16
  imulq $0xe10, %r9, %rax  #  2     0x4  7      OPC=imulq_r64_r64_imm32
  retq                     #  3     0xb  1      OPC=retq

.size f, .-f


.f:
movswq %ax, %r9
imulq $0xf0, %r9, %rax
imulq $0xe10, %r9, %rax
retq


.f:
movswq %ax, %r9
imulq $0xe10, %r9, %rax
retq


.f:
movq $0xf0, %rax
orb $0xf8, %ah
movq $0xffffffffffffffc0, %rsi
retq


.f:
movq $0x10, %rax
movb %al, %ah
movq $0xffffffffffffffc0, %rsi
retq


.f:
movq $0xffffffffffffffc0, %rcx
subb %al, %ch
movq $0x10, %rax
retq


.f:
  decl %eax
  sete %al
  movzbl %al, %eax
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    9 bytes

# Text             #  Line  RIP  Bytes  Opcode
.f:                #        0    0      OPC=<label>
  xorq %rax, %rax  #  1     0    3      OPC=xorq_r64_r64
  retq             #  2     0x3  1      OPC=retq

.size f, .-f


.f:
  decl %eax
  setne %al
  movzbl %al, %eax
  negl %eax
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    11 bytes

# Text                    #  Line  RIP  Bytes  Opcode
.f:                       #        0    0      OPC=<label>
  movl $0xffffffff, %eax  #  1     0    5      OPC=movl_r32_imm32
  retq                    #  2     0x5  1      OPC=retq

.size f, .-f


.f:
movl $0x7, %eax
subl $0x8, %eax
cmc
retq


.f:
  movq %rax, %rsi
  imull $0xcccd, %esi, %esi
  shrl $0x14, %esi
  movzwl %si, %esi
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    16 bytes

# Text                       #  Line  RIP  Bytes  Opcode
.f:                          #        0    0      OPC=<label>
  imull $0xcccd, %eax, %esi  #  1     0    6      OPC=imull_r32_r32_imm32
  sarq $0x14, %rsi           #  2     0x6  4      OPC=sarq_r64_imm8
  retq                       #  3     0xa  1      OPC=retq

.size f, .-f


.f:
imull $0xcccd, %eax, %esi
orb %ah, %ah
shrl $0x14, %esi
retq


.f:
imull $0xcccd, %eax, %esi
sarq $0x14, %rsi
retq


.f:
movzbl %ah, %edi
movq $0xff, %rsi
popcntq %rsi, %r9
retq


.f:
sarb $0x7, %al
movzbq %al, %rsi
imulq $0x20, %rsi, %rax
retq


.f:
movzbl %al, %esi
leaq -0x6(,%rsi,4), %rdi
sarb $0xfd, %sil
retq


.f:
  movq $0x8888888888888889, %rcx
  movq %rdi, %rax
  imulq %rcx
  movq %rdi, %r13
  sarq $0x3f, %r13
  leaq (%rdx,%rdi,1), %rbx
  sarq $0x5, %rbx
  subq %r13, %rbx
  movq %rbx, %rax
  sarq $0x3f, %rax
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    42 bytes

# Text               #  Line  RIP  Bytes  Opcode
.f:                  #        0    0      OPC=<label>
  sarq $0x3f, %rdi   #  1     0    4      OPC=sarq_r64_imm8
  movsbq %dil, %rax  #  2     0x4  4      OPC=movsbq_r64_r8
  retq               #  3     0x8  1      OPC=retq

.size f, .-f


.f:
imull $0x5, %edi, %eax
sbbq %rax, %rax
sarq $0x3f, %rdi
retq


.f:
  movq %rcx, %rax
  movq %rax, %rbx
  movq %rbx, %rdi
  imulq %rax, %rcx
  subq %rcx, %rdi
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    17 bytes

# Text              #  Line  RIP  Bytes  Opcode
.f:                 #        0    0      OPC=<label>
  movl $0x1, %edi   #  1     0    5      OPC=movl_r32_imm32
  subq %rcx, %rdi   #  2     0x5  3      OPC=subq_r64_r64
  imulq %rcx, %rdi  #  3     0x8  4      OPC=imulq_r64_r64
  retq              #  4     0xc  1      OPC=retq

.size f, .-f


.f:
movsbq %cl, %rdi
shldq $0x7, %rdi, %rcx
btrw $0x20, %di
retq


.f:
  movq %rax, %rcx
  incq %rcx
  andq $0xff, %rcx
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    14 bytes

# Text             #  Line  RIP  Bytes  Opcode
.f:                #        0    0      OPC=<label>
  movl $0x1, %ecx  #  1     0    5      OPC=movl_r32_imm32
  addb %al, %cl    #  2     0x5  2      OPC=addb_r8_r8_1
  retq             #  3     0x7  1      OPC=retq

.size f, .-f


.f:
incw %ax
xorl %ecx, %ecx
xaddb %al, %cl
retq


.f:
movl $0xf0, %esi
xorq %rcx, %rcx
orb %al, %cl
retq


.f:
andb $0xfc, %al
xorl %ecx, %ecx
addb %al, %cl
retq


.f:
xorl %ecx, %ecx
andq $0xfc, %rax
xaddb %al, %cl
retq


.f:
  leal (%rax,%rax,1), %edx
  addl $0x2, %edx
  leal (%rdx,%rdx,2), %esi
  shll $0x2, %esi
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    13 bytes

# Text                         #  Line  RIP  Bytes  Opcode
.f:                            #        0    0      OPC=<label>
  leal 0x3(%rax,%rax,2), %eax  #  1     0    4      OPC=leal_r32_m32
  imull $0x8, %eax, %esi       #  2     0x4  3      OPC=imull_r32_r32_imm8
  retq                         #  3     0x7  1      OPC=retq

.size f, .-f


.f:
leaq 0x3(%eax,%eax,2), %rax
shll $0x3, %eax
leal (,%eax,1), %esi
retq


.f:
leal 0x3(%rax,%rax,2), %eax
imull $0x8, %eax, %esi
retq


.f:
xorl %esi, %esi
imulw $0x10, %ax, %ax
orl %esi, %eax
retq


.f:
xorq %rsi, %rsi
imulw $0x10, %ax, %ax
orl %eax, %esi
retq


.f:
rorb $0x1, %ah
imulw $0x10, %ax, %ax
movl %eax, %esi
retq


.f:
  leal 0x1(%rdx), %eax
  andl $0x8, %eax
  cltq
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    9 bytes

# Text             #  Line  RIP  Bytes  Opcode
.f:                #        0    0      OPC=<label>
  andl $0x8, %edx  #  1     0    6      OPC=andl_r32_imm32
  movl %edx, %eax  #  2     0x6  2      OPC=movl_r32_r32_1
  retq             #  3     0x8  1      OPC=retq

.size f, .-f


.f:
andl $0x8, %edx
movl %edx, %eax
retq


.f:
  leal -0x24(%rbx), %esi
  andl $0xfb, %esi
  cmpb $0x60, %bl
  sete %sil
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    17 bytes

# Text             #  Line  RIP  Bytes  Opcode
.f:                #        0    0      OPC=<label>
  xorq %rsi, %rsi  #  1     0    3      OPC=xorq_r64_r64
  retq             #  2     0x3  1      OPC=retq

.size f, .-f


.f:
  leal -0x3(%rbp), %edx
  andl $0xfffffffd, %edx
  sete %r12b
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    11 bytes

# Text               #  Line  RIP  Bytes  Opcode
.f:                  #        0    0      OPC=<label>
  xorb %r12b, %r12b  #  1     0    3      OPC=xorb_r8_r8
  retq               #  2     0x3  1      OPC=retq

.size f, .-f


.f:
  leal -0x3b(%rcx), %edx
  andl $0xdf, %edx
  setne %sil
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    14 bytes

# Text                    #  Line  RIP  Bytes  Opcode
.f:                       #        0    0      OPC=<label>
  subl $0xffffffc0, %ecx  #  1     0    6      OPC=subl_r32_imm32
  setno %sil              #  2     0x6  4      OPC=setno_r8
  retq                    #  3     0xa  1      OPC=retq

.size f, .-f


.f:
subl $0xffffffc0, %ecx
setno %sil
retq


.f:
  leal -0x9(%rdx), %eax
  cmpb $0x1, %al
  setbe %al
  cmpb $0x20, %dl
  sete %r9b
  orb %r9b, %al
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    19 bytes

# Text           #  Line  RIP  Bytes  Opcode
.f:              #        0    0      OPC=<label>
  xorb %al, %al  #  1     0    2      OPC=xorb_r8_r8
  retq           #  2     0x2  1      OPC=retq

.size f, .-f


.f:
  leal 0x1(%rsi), %eax
  imulw $0x258, %ax, %ax
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    9 bytes

# Text               #  Line  RIP  Bytes  Opcode
.f:                  #        0    0      OPC=<label>
  movq $0x258, %rax  #  1     0    7      OPC=movq_r64_imm32
  imulw %ax, %si     #  2     0x7  4      OPC=imulw_r16_r16
  addl %esi, %eax    #  3     0xb  2      OPC=addl_r32_r32_1
  retq               #  4     0xd  1      OPC=retq

.size f, .-f


.f:
movb $0xff, %ah
leal 0x1(,%rsi,1), %eax
imulw $0x258, %ax, %ax
retq


.f:
leal 0x1(,%rsi,1), %eax
imulw $0x258, %ax, %ax
retq


.f:
incl %esi
movq %rsi, %rax
imulw $0x258, %si, %ax
retq


.f:
movq $0x258, %rax
imulw %ax, %si
xaddl %eax, %esi
retq


.f:
movq $0x258, %rax
imulw %ax, %si
addl %esi, %eax
retq


.f:
xorl %eax, %eax
subw %si, %si
xaddl %eax, %esi
retq


.f:
xorl %eax, %eax
xchgl %eax, %esi
addw $0x58, %ax
retq


.f:
  leal 0x1(%rax), %edx
  movslq %edx, %rdx
  leaq 0x1e(%rdx), %rax
  andq $0xfffffff0, %rax
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    15 bytes

# Text              #  Line  RIP  Bytes  Opcode
.f:                 #        0    0      OPC=<label>
  cltq              #  1     0    2      OPC=cltq
  addq $0x20, %rax  #  2     0x2  6      OPC=addq_rax_imm32
  andb $0xf0, %al   #  3     0x8  2      OPC=andb_al_imm8
  retq              #  4     0xa  1      OPC=retq

.size f, .-f


.f:
addq $0x40, %rax
andb $0x10, %al
cltq
retq


.f:
  leal -0x1(%rax), %ebx
  movslq %ebx, %rcx
  shrq $0x3f, %rcx
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    11 bytes

# Text              #  Line  RIP  Bytes  Opcode
.f:                 #        0    0      OPC=<label>
  movl %eax, %ecx   #  1     0    2      OPC=movl_r32_r32_1
  shrl $0x3f, %ecx  #  2     0x2  3      OPC=shrl_r32_imm8
  retq              #  3     0x5  1      OPC=retq

.size f, .-f


.f:
movl %eax, %ecx
shrl $0x3f, %ecx
retq


.f:
  movq %rax, %rdx
  leal -0x3(%rdx), %eax
  orw $0xb000, %ax
  movl %eax, %ecx
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    13 bytes

# Text               #  Line  RIP  Bytes  Opcode
.f:                  #        0    0      OPC=<label>
  subq $0x3, %rax    #  1     0    6      OPC=subq_rax_imm32
  orl $0xb000, %eax  #  2     0x6  5      OPC=orl_eax_imm32
  movl %eax, %ecx    #  3     0xb  2      OPC=movl_r32_r32_1
  retq               #  4     0xd  1      OPC=retq

.size f, .-f


.f:
subq $0x3, %rax
orl $0xb000, %eax
movl %eax, %ecx
retq


.f:
movl %eax, %ecx
cmpb $0x8, %al
orl $0xff, %eax
retq


.f:
movl %eax, %ecx
andw $0xfff0, %cx
addl $0xff, %eax
retq


.f:
  movq %rax, %rdx
  leal (,%rdx,8), %eax
  sarb $0x3, %al
  subl $0x1, %eax
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    17 bytes

# Text                      #  Line  RIP  Bytes  Opcode
.f:                         #        0    0      OPC=<label>
  leal -0x4(,%rax,8), %eax  #  1     0    7      OPC=leal_r32_m32
  sarb $0x3, %al            #  2     0x7  3      OPC=sarb_r8_imm8
  retq                      #  3     0xa  1      OPC=retq

.size f, .-f


.f:
imull $0x8, %eax, %eax
setnb %al
movq $0x5, %r9
retq


.f:
  leal (%rdi,%rdi,2), %ecx
  shll $0x3, %ecx
  negl %ecx
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    9 bytes

# Text                           #  Line  RIP  Bytes  Opcode
.f:                              #        0    0      OPC=<label>
  leaq (,%edi,8), %rcx           #  1     0    9      OPC=leaq_r64_m32
  imull $0xfffffffd, %ecx, %ecx  #  2     0x9  6      OPC=imull_r32_r32_imm32
  retq                           #  3     0xf  1      OPC=retq

.size f, .-f


.f:
imulq $0xfffffff8, %rdi, %r11
leaq 0x2(%r11,%r11,2), %rcx
imulq $0x3, %r11, %rcx
retq


.f:
imull $0xfffffff8, %edi, %r11d
imull $0x3, %r11d, %ecx
retq


.f:
imulq $0xfffffff8, %rdi, %r11
movq %r11, %rcx
addl %edi, %edi
retq


.f:
imulq $0xfffffff8, %rdi, %r11
movl %r11d, %ecx
leaw -0x7(%r11d,%r11d,2), %cx
retq


.f:
imull $0xfffffff8, %edi, %r11d
movl %r11d, %ecx
leal -0x7(%r11d,%r11d,2), %ecx
retq


.f:
  movq %rax, %rdx
  leal 0x80(%rax,%rdx,1), %eax
  shll $0x18, %eax
  sarl $0x1f, %eax
  movl %eax, %edi
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    19 bytes

# Text                #  Line  RIP  Bytes  Opcode
.f:                   #        0    0      OPC=<label>
  andl $0x40, %eax    #  1     0    3      OPC=andl_r32_imm8
  popcntl %eax, %edi  #  2     0x3  4      OPC=popcntl_r32_r32
  decl %edi           #  3     0x7  2      OPC=decl_r32
  retq                #  4     0x9  1      OPC=retq

.size f, .-f


.f:
andl $0x40, %eax
popcntl %eax, %edi
decl %edi
retq


.f:
xorl %edi, %edi
orl $0xffffffff, %eax
xaddl %eax, %edi
retq


.f:
xorq %rax, %rax
movl $0xffffffff, %edi
retq


.f:
  leal 0x1(%rax), %ecx
  movl $0x1, %eax
  shlq %cl, %rax
  notq %rax
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    15 bytes

# Text                            #  Line  RIP  Bytes  Opcode
.f:                               #        0    0      OPC=<label>
  movb %al, %cl                   #  1     0    2      OPC=movb_r8_r8_1
  movq $0xfffffffffffffffd, %rax  #  2     0x2  7      OPC=movq_r64_imm32
  rolq %cl, %rax                  #  3     0x9  3      OPC=rolq_r64_cl
  retq                            #  4     0xc  1      OPC=retq

.size f, .-f


.f:
movb %al, %cl
movq $0xfffffffffffffffd, %rax
rolq %cl, %rax
retq


.f:
stc
adcb $0x4, %al
movsbl %al, %ecx
retq


.f:
stc
movsbl %al, %r8d
adcb $0x4, %al
retq


.f:
  movq %rax, %rbx
  leal -0x2b(%rbx), %eax
  testb $0xfd, %al
  sete %al
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    12 bytes

# Text              #  Line  RIP  Bytes  Opcode
.f:                 #        0    0      OPC=<label>
  subq $0x6, %rax   #  1     0    6      OPC=subq_rax_imm32
  sbbl $0x20, %eax  #  2     0x6  3      OPC=sbbl_r32_imm8
  shlb $0xf9, %al   #  3     0x9  3      OPC=shlb_r8_imm8
  retq              #  4     0xc  1      OPC=retq

.size f, .-f


.f:
subl $0x20, %eax
andb $0x80, %al
andb %ah, %al
retq


.f:
  leal -0x2(%rbp), %eax
  xorl %esi, %esi
  cmpl $0x1, %eax
  setbe %sil
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    13 bytes

# Text             #  Line  RIP  Bytes  Opcode
.f:                #        0    0      OPC=<label>
  xorq %rsi, %rsi  #  1     0    3      OPC=xorq_r64_r64
  retq             #  2     0x3  1      OPC=retq

.size f, .-f


.f:
  movq %rax, %r10
  movl %eax, %edi
  leal -0x2(%r10), %r9d
  movl %edi, %eax
  xorl %edx, %edx
  divl %r9d
  addl $0x1, %edx
  movl %edx, %edi
  subl %r10d, %edi
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    25 bytes

# Text             #  Line  RIP  Bytes  Opcode
.f:                #        0    0      OPC=<label>
  movl $0x3, %edi  #  1     0    6      OPC=movl_r32_imm32_1
  subl %eax, %edi  #  2     0x6  2      OPC=subl_r32_r32
  retq             #  3     0x8  1      OPC=retq

.size f, .-f


.f:
movl $0x3, %edi
subl %eax, %edi
retq


.f:
  leaq (%rdi,%rdi,1), %rax
  movq %rax, %r8
  addq %rdi, %rax
  shlq $0x4, %rax
  leaq 0x8(%r8,%rax,1), %rcx
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    20 bytes

# Text                          #  Line  RIP   Bytes  Opcode
.f:                             #        0     0      OPC=<label>
  leaq 0x4(,%rdi,2), %rcx       #  1     0     8      OPC=leaq_r64_m32
  leaq -0x3(%rcx,%rdi,8), %rcx  #  2     0x8   5      OPC=leaq_r64_m32
  leaq 0x3(%rcx,%rcx,4), %rcx   #  3     0xd   5      OPC=leaq_r64_m64
  retq                          #  4     0x12  1      OPC=retq

.size f, .-f


.f:
leaq 0x4(,%rdi,2), %rcx
leaq -0x3(%rcx,%rdi,8), %rcx
leaq 0x3(%rcx,%rcx,4), %rcx
retq


.f:
xorl %ecx, %ecx
subw $0x10, %cx
sarl $0x1, %edi
retq


.f:
xorl %ecx, %ecx
subq $0x10, %rcx
sarl $0x1, %edi
retq


.f:
  leaq 0x8(%rcx), %rdx
  andq $0xfffffff8, %rdx
  subq %rdx, %rcx
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    12 bytes

# Text                   #  Line  RIP  Bytes  Opcode
.f:                      #        0    0      OPC=<label>
  orq $0xfffffff8, %rcx  #  1     0    4      OPC=orq_r64_imm8
  retq                   #  2     0x4  1      OPC=retq

.size f, .-f


.f:
movzbq %cl, %r9
orq $0xfffffff8, %rcx
movsbq %cl, %rdi
retq


.f:
movsbw %cl, %cx
orq $0xfffffff8, %rcx
retq


.f:
movsbq %cl, %r11
movswq %cx, %r8
movzbl %r11b, %r9d
retq


.f:
movzbl %cl, %r9d
orw $0xfff8, %cx
movsbq %r9b, %r10
retq


.f:
movzbq %cl, %r9
orw $0xfff8, %cx
movsbq %cl, %rdi
retq


.f:
  leaq 0x3f(%rsi), %rbp
  shrq $0x6, %rbp
  shlq $0x3, %rbp
  movq %rbp, %rdi
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    16 bytes

# Text                      #  Line  RIP   Bytes  Opcode
.f:                         #        0     0      OPC=<label>
  andb $0xc0, %sil          #  1     0     4      OPC=andb_r8_imm8
  leaq 0x40(,%rsi,1), %rdi  #  2     0x4   8      OPC=leaq_r64_m16
  rorq $0x3, %rdi           #  3     0xc   4      OPC=rorq_r64_imm8
  retq                      #  4     0x10  1      OPC=retq

.size f, .-f


.f:
movl $0xffffff80, %edi
addb $0xf0, %dil
leaq -0x10(%rdi,%rsi,8), %rax
retq


.f:
  leaq 0xff(%rdx), %rbx
  xorb %bl, %bl
  movq %rbx, %rsi
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    13 bytes

# Text                      #  Line  RIP  Bytes  Opcode
.f:                         #        0    0      OPC=<label>
  movb $0x80, %dl           #  1     0    2      OPC=movb_r8_imm8
  leaq 0x80(,%rdx,1), %rsi  #  2     0x2  8      OPC=leaq_r64_m16
  retq                      #  3     0xa  1      OPC=retq

.size f, .-f


.f:
andb %dl, %dh
xorq %rsi, %rsi
andw %si, %dx
retq


.f:
  movl $0x1, %eax
  movb %sil, %cl
  shll %cl, %eax
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    11 bytes

# Text               #  Line  RIP  Bytes  Opcode
.f:                  #        0    0      OPC=<label>
  movzbq %sil, %rdx  #  1     0    4      OPC=movzbq_r64_r8
  movzbl %sil, %eax  #  2     0x4  3      OPC=movzbl_r32_r8
  btsl %edx, %eax    #  3     0x7  3      OPC=btsl_r32_r32
  retq               #  4     0xa  1      OPC=retq

.size f, .-f


.f:
movzbq %sil, %rdx
movzbl %sil, %eax
btsl %edx, %eax
retq


.f:
  movslq %esi, %r8
  addq $0x1, %r8
  shrq $0x1, %r8
  addq $0x1, %r8
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    15 bytes

# Text              #  Line  RIP  Bytes  Opcode
.f:                 #        0    0      OPC=<label>
  movslq %esi, %r8  #  1     0    3      OPC=movslq_r64_r32
  addq $0x3, %r8    #  2     0x3  7      OPC=addq_r64_imm32
  shrq $0x1, %r8    #  3     0xa  4      OPC=shrq_r64_imm8
  retq              #  4     0xe  1      OPC=retq

.size f, .-f


.f:
movsbq %sil, %rsi
rorb $0x1, %sil
xorq %r8, %r8
retq


.f:
  movslq %r8d, %rbx
  movl $0x1000, %eax
  cltd
  idivl %ebx
  movl %eax, %edi
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    14 bytes

# Text             #  Line  RIP  Bytes  Opcode
.f:                #        0    0      OPC=<label>
  xorq %rdi, %rdi  #  1     0    3      OPC=xorq_r64_r64
  retq             #  2     0x3  1      OPC=retq

.size f, .-f


.f:
  movslq %eax, %r14
  leal 0x1(%r14), %edi
  movslq %edi, %rdi
  shlq $0x3, %rdi
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    15 bytes

# Text                    #  Line  RIP  Bytes  Opcode
.f:                       #        0    0      OPC=<label>
  movslq %eax, %rdi       #  1     0    3      OPC=movslq_r64_r32
  addq $0x1, %rdi         #  2     0x3  4      OPC=addq_r64_imm8
  imulq $0x8, %rdi, %rdi  #  3     0x7  4      OPC=imulq_r64_r64_imm8
  retq                    #  4     0xb  1      OPC=retq

.size f, .-f


.f:
xorq %rdi, %rdi
imull $0x8, %eax, %ecx
movq $0xffffffffffffffe0, %r9
retq


.f:
  movzbl %ch, %eax
  cmpl $0x7, %eax
  setg %r8b
  movzbl %r8b, %r8d
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    15 bytes

# Text             #  Line  RIP  Bytes  Opcode
.f:                #        0    0      OPC=<label>
  movl $0x1, %r8d  #  1     0    7      OPC=movl_r32_imm32_1
  retq             #  2     0x7  1      OPC=retq

.size f, .-f


.f:
  movzbl %al, %r8d
  leal -0x1(%r8), %edi
  addq $0x1, %rdi
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    13 bytes

# Text              #  Line  RIP  Bytes  Opcode
.f:                 #        0    0      OPC=<label>
  movzbl %al, %edi  #  1     0    3      OPC=movzbl_r32_r8
  retq              #  2     0x3  1      OPC=retq

.size f, .-f


.f:
  movzbl %dl, %esi
  orw $0x4000, %si
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    9 bytes

# Text              #  Line  RIP  Bytes  Opcode
.f:                 #        0    0      OPC=<label>
  movzbq %dl, %rsi  #  1     0    4      OPC=movzbq_r64_r8
  btcw $0xfe, %si   #  2     0x4  5      OPC=btcw_r16_imm8
  retq              #  3     0x9  1      OPC=retq

.size f, .-f


.f:
xorq %rax, %rax
movzbq %dl, %rsi
btsw $0xfe, %si
retq


.f:
movzbq %dl, %rsi
btcw $0xfe, %si
retq


.f:
xorw %si, %si
setc %al
seto %dh
retq


.f:
xorw %si, %si
movb %dl, %sil
setnae %dh
retq


.f:
movzbq %dl, %rsi
movb %dl, %dil
retq


.f:
  movl %eax, %edx
  movzbl %al, %eax
  shll $0x8, %edx
  movzwl %dx, %edx
  orl %edx, %eax
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    14 bytes

# Text              #  Line  RIP  Bytes  Opcode
.f:                 #        0    0      OPC=<label>
  movzbq %al, %rax  #  1     0    4      OPC=movzbq_r64_r8
  movb %al, %ah     #  2     0x4  2      OPC=movb_rh_r8
  retq              #  3     0x6  1      OPC=retq

.size f, .-f


.f:
orb %ah, %ah
movzbq %al, %rax
xorb %al, %ah
retq


.f:
movsbl %al, %r8d
xorl %eax, %eax
retq


.f:
movzbl %al, %r8d
xorl %eax, %eax
retq


.f:
xchgl %eax, %eax
movzbq %al, %rax
retq


.f:
  movl %eax, %r10d
  movzbl %al, %eax
  shll $0x8, %r10d
  orl %r10d, %eax
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    14 bytes

# Text             #  Line  RIP  Bytes  Opcode
.f:                #        0    0      OPC=<label>
  shll $0x8, %eax  #  1     0    3      OPC=shll_r32_imm8
  orb %ah, %al     #  2     0x3  2      OPC=orb_r8_rh_1
  retq             #  3     0x5  1      OPC=retq

.size f, .-f


.f:
movsbw %al, %dx
shll $0x8, %eax
xchgb %al, %dl
retq


.f:
movl %eax, %edx
subl %eax, %eax
orb %dl, %al
retq


.f:
movb %al, %dl
negl %eax
xaddb %al, %dl
retq


.f:
movb %al, %dl
bswap %eax
xaddb %al, %dl
retq


.f:
  movl %esi, %eax
  movzbl %ah, %edx
  shll $0x18, %eax
  shll $0x10, %edx
  orl %edx, %eax
  movl %esi, %edx
  sarl $0x18, %esi
  shll $0x8, %edx
  sarl $0x18, %edx
  movb %dl, %ah
  movb %sil, %al
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    30 bytes

# Text             #  Line  RIP  Bytes  Opcode
.f:                #        0    0      OPC=<label>
  bswap %esi       #  1     0    2      OPC=bswap_r32
  movq %rsi, %rax  #  2     0x2  3      OPC=movq_r64_r64_1
  retq             #  3     0x5  1      OPC=retq

.size f, .-f


.f:
bswap %esi
movq %rsi, %rax
salw $0x3, %si
retq


.f:
roll $0x18, %esi
xorl %eax, %eax
cmpl $0x7, %eax
retq


.f:
xorq %rax, %rax
roll $0x18, %esi
sbbl %eax, %eax
retq


.f:
xorq %rax, %rax
roll $0x18, %esi
xorl %esi, %eax
retq


.f:
  movzwl %cx, %eax
  cmpl $0x1999, %eax
  setg %r8b
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    13 bytes

# Text                     #  Line  RIP  Bytes  Opcode
.f:                        #        0    0      OPC=<label>
  imulw $0xfff9, %cx, %cx  #  1     0    4      OPC=imulw_r16_r16_imm8
  setnae %r8b              #  2     0x4  4      OPC=setnae_r8
  retq                     #  3     0x8  1      OPC=retq

.size f, .-f


.f:
imulw $0xfff9, %cx, %cx
setnae %r8b
retq


.f:
  movzwl %di, %ebx
  leal 0x7(%rbx), %edx
  sarl $0x3, %edx
  movslq %edx, %rdx
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    13 bytes

# Text              #  Line  RIP  Bytes  Opcode
.f:                 #        0    0      OPC=<label>
  addb $0x8, %dil   #  1     0    4      OPC=addb_r8_imm8
  shrw $0x3, %di    #  2     0x4  4      OPC=shrw_r16_imm8
  movswl %di, %edx  #  3     0x8  3      OPC=movswl_r32_r16
  retq              #  4     0xb  1      OPC=retq

.size f, .-f


.f:
shrw $0x3, %di
movl $0x10, %r10d
movzwl %di, %edx
retq


.f:
  movl %esi, %eax
  movl $0x51eb851f, %edx
  mull %edx
  shrl $0x7, %edx
  imull $0x190, %edx, %eax
  cmpl %eax, %esi
  sete %al
  movzbl %al, %eax
  leaq (%rax,%rax,1), %rdx
  addq %rax, %rdx
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    34 bytes

# Text             #  Line  RIP  Bytes  Opcode
.f:                #        0    0      OPC=<label>
  xorq %rdx, %rdx  #  1     0    3      OPC=xorq_r64_r64
  retq             #  2     0x3  1      OPC=retq

.size f, .-f


.f:
  negl %eax
  movl $0x4, %edx
  andl $0x3, %eax
  subl %eax, %edx
  movl %edx, %eax
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    15 bytes

# Text             #  Line  RIP  Bytes  Opcode
.f:                #        0    0      OPC=<label>
  addl $0x3, %eax  #  1     0    3      OPC=addl_r32_imm8
  andl $0x3, %eax  #  2     0x3  3      OPC=andl_r32_imm8
  sbbb $0xff, %al  #  3     0x6  3      OPC=sbbb_r8_imm8
  retq             #  4     0x9  1      OPC=retq

.size f, .-f


.f:
addl $0x3, %eax
andl $0x3, %eax
sbbb $0xff, %al
retq


.f:
subl %eax, %eax
setne %ah
subl $0xfffffffe, %eax
retq


.f:
  movq %rdx, %rdi
  negq %rdi
  shlq $0x4, %rdi
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    11 bytes

# Text                           #  Line  RIP  Bytes  Opcode
.f:                              #        0    0      OPC=<label>
  imulq $0xfffffff0, %rdx, %rdi  #  1     0    4      OPC=imulq_r64_r64_imm8
  retq                           #  2     0x4  1      OPC=retq

.size f, .-f


.f:
imulq $0xfffffff0, %rdx, %rsi
movq %rsi, %rdi
bswap %edx
retq


.f:
imulq $0xfffffff0, %rdx, %rsi
movq %rsi, %rdi
retq


.f:
movzwq %dx, %rdi
xorl %edi, %edi
shldw $0x6, %di, %dx
retq


.f:
movl %edx, %edi
subq %rdx, %rdi
shldw $0x6, %di, %dx
retq


.f:
rorb $0x1, %dh
xorl %edi, %edi
imull $0xfffffff0, %edx, %eax
retq


.f:
xorl %edi, %edi
imull $0xfffffff0, %edx, %ecx
rorb $0x1, %dh
retq


.f:
  movq %rcx, %rax
  movq %rax, %r9
  orq %r9, %rax
  notq %rax
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    13 bytes

# Text                            #  Line  RIP  Bytes  Opcode
.f:                               #        0    0      OPC=<label>
  movq $0xffffffffffffffff, %rax  #  1     0    7      OPC=movq_r64_imm32
  xorq %rcx, %rax                 #  2     0x7  3      OPC=xorq_r64_r64_1
  retq                            #  3     0xa  1      OPC=retq

.size f, .-f


.f:
movq $0xffffffffffffffff, %rax
xorq %rcx, %rax
retq


.f:
movq $0xffffffffffffffff, %rdx
movsbq %dl, %rax
xorq %rcx, %rax
retq


.f:
xorl %eax, %eax
movq $0xfffffffffffffffd, %rdx
xorl %ecx, %edx
retq


.f:
xorl %eax, %eax
movq $0xffffffffffffffff, %rdx
xorl %ecx, %edx
retq


.f:
movq $0xffffffffffffffff, %rdx
xorq %rcx, %rdx
xorl %eax, %eax
retq


.f:
  rolw $0x8, %ax
  andw $0xf000, %ax
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    9 bytes

# Text                    #  Line  RIP  Bytes  Opcode
.f:                       #        0    0      OPC=<label>
  andq $0xfffffff0, %rax  #  1     0    6      OPC=andq_rax_imm32
  salw $0x8, %ax          #  2     0x6  4      OPC=salw_r16_imm8
  retq                    #  3     0xa  1      OPC=retq

.size f, .-f


.f:
andw $0xfff0, %ax
xchgb %al, %ah
shrb $0xfd, %al
retq


.f:
andq $0xfffffff0, %rax
salw $0x8, %ax
retq


.f:
andb %al, %ah
setnle %al
andb %ah, %al
retq


.f:
andb %al, %ah
setb %al
andb %ah, %al
retq


.f:
shlb $0x6, %ah
andb %al, %ah
setc %al
retq


.f:
  movq %rax, %r8
  rolw $0x8, %r8w
  movzwl %r8w, %esi
  leal 0x1(%rsi), %edi
  shlq $0x2, %rdi
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    20 bytes

# Text                     #  Line  RIP  Bytes  Opcode
.f:                        #        0    0      OPC=<label>
  xchgb %ah, %al           #  1     0    2      OPC=xchgb_r8_rh_1
  movzwq %ax, %rax         #  2     0x2  4      OPC=movzwq_r64_r16
  leal 0x4(,%rax,4), %edi  #  3     0x6  7      OPC=leal_r32_m32
  retq                     #  4     0xd  1      OPC=retq

.size f, .-f


.f:
xchgb %ah, %al
movzwq %ax, %rax
leal 0x4(,%rax,4), %edi
retq


.f:
rorw $0x6, %ax
andl $0xffffff80, %eax
movzwl %ax, %edi
retq


.f:
rorw $0x6, %ax
andl $0xfffffff8, %eax
movzwl %ax, %edi
retq


.f:
  rorw $0x8, %ax
  andw $0x7fff, %ax
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    9 bytes

# Text             #  Line  RIP  Bytes  Opcode
.f:                #        0    0      OPC=<label>
  xchgb %ah, %al   #  1     0    2      OPC=xchgb_r8_rh_1
  btrw $0xff, %ax  #  2     0x2  5      OPC=btrw_r16_imm8
  retq             #  3     0x7  1      OPC=retq

.size f, .-f


.f:
xchgb %ah, %al
btrw $0xff, %ax
testb $0xfc, %al
retq


.f:
popcntw %ax, %r8w
xorl %edx, %edx
movb %al, %dh
retq


.f:
popcntw %ax, %r8w
movb %al, %spl
xaddb %r8b, %al
retq


.f:
movb %al, %spl
popcntw %ax, %r8w
xaddb %r8b, %al
retq


.f:
  movl %ecx, %edx
  sarl $0x1f, %edx
  shrl $0x1e, %edx
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    9 bytes

# Text               #  Line  RIP  Bytes  Opcode
.f:                  #        0    0      OPC=<label>
  movslq %ecx, %rdx  #  1     0    3      OPC=movslq_r64_r32
  shrq $0xfe, %rdx   #  2     0x3  4      OPC=shrq_r64_imm8
  retq               #  3     0x7  1      OPC=retq

.size f, .-f


.f:
movslq %ecx, %rdx
bsfl %edx, %r11d
shrq $0xfe, %rdx
retq


.f:
movl $0x0, %edx
movl $0xfc, %r10d
shrw $0x6, %r10w
retq


.f:
xorl %edx, %edx
movq $0x3, %rdi
retq


.f:
  movl %eax, %esi
  sarl $0x1f, %esi
  shrl $0x1b, %esi
  addl %esi, %eax
  andl $0x1f, %eax
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    14 bytes

# Text              #  Line  RIP   Bytes  Opcode
.f:                 #        0     0      OPC=<label>
  btl $0xff, %eax   #  1     0     4      OPC=btl_r32_imm8
  sbbl $0x80, %eax  #  2     0x4   6      OPC=sbbl_r32_imm32
  andq $0x1f, %rax  #  3     0xa   6      OPC=andq_rax_imm32
  retq              #  4     0x10  1      OPC=retq

.size f, .-f


.f:
btl $0xff, %eax
sbbl $0xffffffc0, %eax
andq $0x1f, %rax
retq


.f:
addl $0xffffffff, %eax
andl $0x1f, %eax
retq


.f:
rorb $0x1, %ah
adcl $0x1f, %eax
andq $0x1f, %rax
retq


.f:
  movq %rax, %rcx
  movq $0x6666666666666667, %rsi
  movq %rcx, %rax
  movq %rcx, %rdi
  sarq $0x3f, %rdi
  imulq %rsi
  sarq $0x2, %rdx
  movq %rdx, %rbx
  subq %rdi, %rbx
  movq %rbx, %rax
  sarq $0x3f, %rax
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    44 bytes

# Text              #  Line  RIP  Bytes  Opcode
.f:                 #        0    0      OPC=<label>
  sarq $0xff, %rax  #  1     0    4      OPC=sarq_r64_imm8
  retq              #  2     0x4  1      OPC=retq

.size f, .-f


.f:
  sarq $0x6, %rax
  testq %rax, %rax
  setne %bpl
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    12 bytes

# Text             #  Line  RIP  Bytes  Opcode
.f:                #        0    0      OPC=<label>
  movq $0x1, %rbp  #  1     0    7      OPC=movq_r64_imm32
  retq             #  2     0x7  1      OPC=retq

.size f, .-f


.f:
  movq %rcx, %rax
  movq %rax, %rsi
  shll $0x8, %eax
  addl %esi, %eax
  orb $0x80, %al
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    14 bytes

# Text                      #  Line  RIP   Bytes  Opcode
.f:                         #        0     0      OPC=<label>
  imull $0x40, %ecx, %eax   #  1     0     6      OPC=imull_r32_r32_imm32
  orq $0x80, %rcx           #  2     0x6   7      OPC=orq_r64_imm32
  leaq (%ecx,%eax,4), %rax  #  3     0xd   5      OPC=leaq_r64_m32
  retq                      #  4     0x12  1      OPC=retq

.size f, .-f


.f:
imull $0x40, %ecx, %eax
orq $0x80, %rcx
leaq (%ecx,%eax,4), %rax
retq


.f:
btsl $0xfc, %ecx
movq %rcx, %rax
addb %cl, %ah
retq


.f:
  shll $0xc, %eax
  andl $0xf000, %eax
  cmpl $0x4000, %eax
  sete %al
  movzbl %al, %eax
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    20 bytes

# Text               #  Line  RIP  Bytes  Opcode
.f:                  #        0    0      OPC=<label>
  cmpb $0x7, %al     #  1     0    3      OPC=cmpb_r8_imm8
  crc32l %eax, %eax  #  2     0x3  5      OPC=crc32l_r32_r32
  adcw %ax, %ax      #  3     0x8  3      OPC=adcw_r16_r16_1
  retq               #  4     0xb  1      OPC=retq

.size f, .-f


.f:
  movl %edx, %r9d
  shll $0x10, %r9d
  andl $0xff0000, %r9d
  movl %edx, %eax
  shrl $0x10, %edx
  andl $0xff00, %eax
  movzbl %dl, %edx
  orl %eax, %r9d
  addl %edx, %r9d
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    34 bytes

# Text               #  Line  RIP  Bytes  Opcode
.f:                  #        0    0      OPC=<label>
  bswap %edx         #  1     0    2      OPC=bswap_r32
  movq %rdx, %r9     #  2     0x2  3      OPC=movq_r64_r64_1
  crc32b %r9b, %r9d  #  3     0x5  6      OPC=crc32b_r32_r8
  retq               #  4     0xb  1      OPC=retq

.size f, .-f


.f:
xorb %sil, %sil
movl %edx, %r9d
rorl $0x10, %r9d
retq


.f:
  movq %rcx, %rax
  movq %rax, %rdx
  shll $0x8, %eax
  orw %dx, %ax
  movzwl %ax, %edx
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    16 bytes

# Text              #  Line  RIP  Bytes  Opcode
.f:                 #        0    0      OPC=<label>
  movzwq %cx, %rdx  #  1     0    4      OPC=movzwq_r64_r16
  orb %dl, %dh      #  2     0x4  2      OPC=orb_rh_r8
  retq              #  3     0x6  1      OPC=retq

.size f, .-f


.f:
xorq %rdx, %rdx
addw %cx, %dx
orb %cl, %dh
retq


.f:
xorq %rdx, %rdx
adcb $0x6, %dl
xaddl %edx, %edx
retq


.f:
xorq %rdx, %rdx
addl $0x6, %edx
xaddw %dx, %cx
retq


.f:
  shll $0x4, %eax
  sarb $0x4, %al
  movl %eax, %edx
  andl $0xf, %edx
  leal (,%rdx,4), %ecx
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    19 bytes

# Text                    #  Line  RIP  Bytes  Opcode
.f:                       #        0    0      OPC=<label>
  andl $0xf, %eax         #  1     0    5      OPC=andl_eax_imm32
  imull $0x4, %eax, %ecx  #  2     0x5  6      OPC=imull_r32_r32_imm32
  retq                    #  3     0xb  1      OPC=retq

.size f, .-f


.f:
andl $0xf, %eax
imull $0x4, %eax, %ecx
adcb %al, %al
retq


.f:
andl $0xf, %eax
imull $0x4, %eax, %ecx
retq


.f:
subl %eax, %eax
adcb $0x4, %al
imull $0x5, %eax, %ecx
retq


.f:
movq $0x4, %rax
imull $0x5, %eax, %ecx
adcb %al, %al
retq


.f:
andl $0x4, %eax
imulq $0x5, %rax, %rcx
addq %rcx, %rax
retq


.f:
  movq %rax, %rdx
  shll $0x7, %edx
  sarw $0x7, %dx
  movzwl %dx, %edx
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    14 bytes

# Text              #  Line  RIP  Bytes  Opcode
.f:                 #        0    0      OPC=<label>
  rorb $0x1, %ah    #  1     0    2      OPC=rorb_rh_one
  sarb $0x7, %ah    #  2     0x2  3      OPC=sarb_rh_imm8
  movzwl %ax, %edx  #  3     0x5  3      OPC=movzwl_r32_r16
  retq              #  4     0x8  1      OPC=retq

.size f, .-f


.f:
rorb $0x1, %ah
sarb $0x7, %ah
movzwl %ax, %edx
retq


.f:
xorl %edx, %edx
notb %dh
movzbl %al, %edi
retq


.f:
movzbq %al, %rax
xorq %rdx, %rdx
notb %ah
retq


.f:
  movq %r9, %rax
  shlq $0x4, %rax
  addq %rax, %r9
  shlq $0x4, %r9
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    15 bytes

# Text                        #  Line  RIP  Bytes  Opcode
.f:                           #        0    0      OPC=<label>
  leaq 0x6(%r9,%r9,8), %rdi   #  1     0    5      OPC=leaq_r64_m16
  leaq -0x6(%rdi,%r9,8), %r9  #  2     0x5  5      OPC=leaq_r64_m16
  shlq $0x4, %r9              #  3     0xa  4      OPC=shlq_r64_imm8
  retq                        #  4     0xe  1      OPC=retq

.size f, .-f


.f:
incb %r9b
popcntq %r9, %rcx
movq $0xffffffffffffff80, %rsi
retq


.f:
incb %r9b
popcntq %r9, %rcx
movq $0xffffffffffffff80, %r9
retq


.f:
  movq %rax, %rbp
  shlq $0x3, %rbp
  leal 0x1(%rbp), %edi
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    11 bytes

# Text                     #  Line  RIP  Bytes  Opcode
.f:                        #        0    0      OPC=<label>
  leaq 0x1(,%eax,8), %rdi  #  1     0    9      OPC=leaq_r64_m32
  retq                     #  2     0x9  1      OPC=retq

.size f, .-f


.f:
movb $0xfd, %r9b
leal 0x1(,%rax,8), %edi
movb $0x4, %r9b
retq


.f:
leal 0x1(,%rax,8), %edi
andl $0xfffffff0, %eax
retq


.f:
addl %eax, %eax
xorq %rdi, %rdi
retq


.f:
leaq 0x3(,%eax,8), %r11
xorq %rdi, %rdi
seta %dil
retq


.f:
xorq %rdi, %rdi
shlw $0x1, %di
leal 0x3(,%eax,8), %edi
retq


.f:
  movq %rax, %rcx
  movq %rcx, %rax
  shlq $0x9, %rax
  subq %rcx, %rax
  shrq $0x9, %rax
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    18 bytes

# Text                          #  Line  RIP  Bytes  Opcode
.f:                             #        0    0      OPC=<label>
  imulq $0xffffffff, %rax, %r8  #  1     0    7      OPC=imulq_r64_r64_imm32
  sarq $0x9, %r8                #  2     0x7  4      OPC=sarq_r64_imm8
  xaddl %r8d, %eax              #  3     0xb  4      OPC=xaddl_r32_r32
  retq                          #  4     0xf  1      OPC=retq

.size f, .-f


.f:
imulq $0xffffffff, %rax, %r8
sarq $0x9, %r8
xaddl %r8d, %eax
retq


.f:
cltd
andl %eax, %eax
subq $0x20, %rdx
retq


.f:
cqto
subw $0x20, %dx
setnge %r8b
retq


.f:
  movq %rax, %rcx
  shrb $0x4, %cl
  andl $0x1, %ecx
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    10 bytes

# Text              #  Line  RIP  Bytes  Opcode
.f:                 #        0    0      OPC=<label>
  testb $0x10, %al  #  1     0    3      OPC=testb_r8_imm8
  setnz %cl         #  2     0x3  3      OPC=setnz_r8
  retq              #  3     0x6  1      OPC=retq

.size f, .-f


.f:
xorq $0x0, %rax
andl $0x10, %eax
setnp %cl
retq


.f:
shrb $0x1, %ah
setb %cl
setnc %dil
retq


.f:
  movl %eax, %esi
  shrb $0x4, %sil
  leal 0x1(%rsi), %ecx
  andl $0xf, %ecx
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    13 bytes

# Text              #  Line  RIP  Bytes  Opcode
.f:                 #        0    0      OPC=<label>
  shrb $0x4, %al    #  1     0    3      OPC=shrb_r8_imm8
  addl $0x1, %eax   #  2     0x3  6      OPC=addl_r32_imm32
  movsbl %al, %ecx  #  3     0x9  3      OPC=movsbl_r32_r8
  retq              #  4     0xc  1      OPC=retq

.size f, .-f


.f:
addl $0xffffff80, %eax
movl $0x6, %ecx
andb %ah, %cl
retq


.f:
  shrb $0x3, %al
  movzbl %al, %ecx
  movq %rcx, %rax
  cltd
  idivl %ecx
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    13 bytes

# Text             #  Line  RIP  Bytes  Opcode
.f:                #        0    0      OPC=<label>
  movl $0x1, %eax  #  1     0    5      OPC=movl_r32_imm32
  retq             #  2     0x5  1      OPC=retq

.size f, .-f


.f:
  movq %rax, %rcx
  movl %ecx, %eax
  shrl $0xc, %eax
  addl $0x1, %eax
  andl $0xfffff, %eax
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    17 bytes

# Text             #  Line  RIP  Bytes  Opcode
.f:                #        0    0      OPC=<label>
  shrl $0xc, %eax  #  1     0    3      OPC=shrl_r32_imm8
  incb %al         #  2     0x3  2      OPC=incb_r8
  retq             #  3     0x5  1      OPC=retq

.size f, .-f


.f:
andq $0x1, %rax
btsw %ax, %ax
movq $0xfffff, %r8
retq


.f:
  shrl $0x1, %edx
  andl $0x1, %edx
  leal (%rdx,%rdx,1), %eax
  movq %rax, %rcx
  orl $0x1, %ecx
  movl %ecx, %edx
  andl $0xfffffffd, %edx
  orl %edx, %eax
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    22 bytes

# Text             #  Line  RIP   Bytes  Opcode
.f:                #        0     0      OPC=<label>
  movq $0x3, %rax  #  1     0     10     OPC=movq_r64_imm64
  andw %dx, %ax    #  2     0xa   3      OPC=andw_r16_r16_1
  orl $0x1, %eax   #  3     0xd   6      OPC=orl_r32_imm32
  retq             #  4     0x13  1      OPC=retq

.size f, .-f


.f:
movq $0x3, %rax
andw %dx, %ax
orl $0x1, %eax
retq


.f:
movl $0x1, %eax
btcl %eax, %edx
retq


.f:
  shrl $0x10, %eax
  rorw $0x8, %ax
  movzwl %ax, %edi
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    11 bytes

# Text              #  Line  RIP  Bytes  Opcode
.f:                 #        0    0      OPC=<label>
  bswap %eax        #  1     0    2      OPC=bswap_r32
  movzwl %ax, %edi  #  2     0x2  3      OPC=movzwl_r32_r16
  retq              #  3     0x5  1      OPC=retq

.size f, .-f


.f:
bswap %eax
movzbq %al, %rdi
xchgw %ax, %di
retq


.f:
movl $0x2, %ecx
xorb %ah, %al
movzwq %ax, %rdi
retq


.f:
movq $0x5, %rdx
popcntq %rdx, %rdi
negw %dx
retq


.f:
addl $0xffffffc0, %eax
movzwl %ax, %edi
shrl $0xf8, %eax
retq


.f:
  movl %eax, %edi
  movl %eax, %edx
  shrl $0x18, %edi
  shll $0x18, %edx
  orl %edi, %edx
  movl %eax, %edi
  shrl $0x8, %eax
  shll $0x8, %edi
  andl $0xff00, %eax
  andl $0xff0000, %edi
  orl %edi, %edx
  orl %edx, %eax
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    36 bytes

# Text        #  Line  RIP  Bytes  Opcode
.f:           #        0    0      OPC=<label>
  bswap %eax  #  1     0    2      OPC=bswap_r32
  retq        #  2     0x2  1      OPC=retq

.size f, .-f


.f:
bswap %eax
popcntl %eax, %esi
adcw %ax, %si
retq


.f:
bswap %eax
imull $0x40, %eax, %r8d
retq


.f:
orw %ax, %ax
cltd
xorl %eax, %eax
retq


.f:
cltd
subl $0xffffffff, %eax
movzbl %al, %esi
retq


.f:
cltd
movzbl %al, %esi
subl $0x7, %eax
retq


.f:
subl $0x7, %eax
movzbl %al, %esi
cltd
retq


.f:
  shrl $0x8, %edi
  xorl %eax, %eax
  cmpl $0x8e, %edi
  setne %al
  addl $0x1, %eax
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    18 bytes

# Text             #  Line  RIP  Bytes  Opcode
.f:                #        0    0      OPC=<label>
  movq $0x2, %rax  #  1     0    7      OPC=movq_r64_imm32
  retq             #  2     0x7  1      OPC=retq

.size f, .-f


.f:
  shrq $0x20, %rax
  movq %rax, %rdx
  notl %eax
  andl $0x4000000, %eax
  xorl %edx, %eax
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    17 bytes

# Text                  #  Line  RIP  Bytes  Opcode
.f:                     #        0    0      OPC=<label>
  rolq $0x20, %rax      #  1     0    4      OPC=rolq_r64_imm8
  orl $0x4000000, %eax  #  2     0x4  5      OPC=orl_eax_imm32
  retq                  #  3     0x9  1      OPC=retq

.size f, .-f


.f:
shrq $0xe0, %rax
movzwl %ax, %edi
orq $0x4000000, %rax
retq


.f:
rolq $0x20, %rax
orl $0x4000000, %eax
retq


.f:
movl $0x40, %esi
movsbl %ah, %eax
cqto
retq


.f:
imull $0xffffffe0, %eax, %r8d
movq $0x40, %rcx
movsbl %ah, %eax
retq


.f:
  shrq $0x2, %rax
  shll $0x2, %eax
  movl %eax, %edi
  negl %edi
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    12 bytes

# Text                    #  Line  RIP  Bytes  Opcode
.f:                       #        0    0      OPC=<label>
  xorl %edi, %edi         #  1     0    2      OPC=xorl_r32_r32
  andl $0xfffffffc, %eax  #  2     0x2  3      OPC=andl_r32_imm8
  subl %eax, %edi         #  3     0x5  2      OPC=subl_r32_r32
  retq                    #  4     0x7  1      OPC=retq

.size f, .-f


.f:
xorl %edi, %edi
andl $0xfffffffc, %eax
subl %eax, %edi
retq


.f:
xorq %rdi, %rdi
addb $0xfe, %al
negl %eax
retq


.f:
xorq %rdi, %rdi
andb $0xfc, %al
negl %eax
retq


.f:
  shrw $0x3, %ax
  xorl $0x1, %eax
  andl $0x1, %eax
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    11 bytes

# Text             #  Line  RIP  Bytes  Opcode
.f:                #        0    0      OPC=<label>
  andl $0x8, %eax  #  1     0    3      OPC=andl_r32_imm8
  setng %al        #  2     0x3  3      OPC=setng_r8
  retq             #  3     0x6  1      OPC=retq

.size f, .-f


.f:
xorl $0xfffffffe, %eax
shrl $0x3, %eax
andl $0x1, %eax
retq


.f:
movsbq %al, %rax
andq $0x5, %rax
andq $0x3, %rax
retq


.f:
  subl $0x1, %eax
  addq $0x1, %rax
  leaq (,%rax,8), %rcx
  subq %rax, %rcx
  shlq $0x4, %rcx
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    23 bytes

# Text                     #  Line  RIP  Bytes  Opcode
.f:                        #        0    0      OPC=<label>
  andl %eax, %eax          #  1     0    2      OPC=andl_r32_r32
  imulq $0x7, %rax, %rax   #  2     0x2  4      OPC=imulq_r64_r64_imm8
  imulq $0x10, %rax, %rcx  #  3     0x6  4      OPC=imulq_r64_r64_imm8
  retq                     #  4     0xa  1      OPC=retq

.size f, .-f


.f:
xorl $0x6, %eax
xorl %ecx, %ecx
imull $0x10, %eax, %r9d
retq


.f:
  subl $0x1, %eax
  cltq
  xchgw %ax, %ax
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    8 bytes

# Text       #  Line  RIP  Bytes  Opcode
.f:          #        0    0      OPC=<label>
  decl %eax  #  1     0    2      OPC=decl_r32
  cltq       #  2     0x2  2      OPC=cltq
  retq       #  3     0x4  1      OPC=retq

.size f, .-f


.f:
decl %eax
xchgb %al, %al
movq $0xffffffffffffff80, %r9
retq


.f:
movq $0xffffffffffffffc0, %r11
decl %eax
andb %al, %r11b
retq


.f:
  subl $0x2, %eax
  cmpl $0x2, %eax
  sbbl %eax, %eax
  andl $0x2, %eax
  addl $0x10, %eax
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    15 bytes

# Text              #  Line  RIP  Bytes  Opcode
.f:                 #        0    0      OPC=<label>
  movl $0x10, %eax  #  1     0    5      OPC=movl_r32_imm32
  retq              #  2     0x5  1      OPC=retq

.size f, .-f


.f:
  movq %rdx, %rcx
  movq %rcx, %rax
  movq %rax, %rsi
  subl %ecx, %eax
  leal (%rax,%rax,2), %edi
  movl %edi, %eax
  cltd
  idivl %esi
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    20 bytes

# Text             #  Line  RIP  Bytes  Opcode
.f:                #        0    0      OPC=<label>
  xorl %edx, %edx  #  1     0    2      OPC=xorl_r32_r32
  retq             #  2     0x2  1      OPC=retq

.size f, .-f


.f:
  movq %rcx, %rax
  movq %rax, %rdi
  subl $0x1, %eax
  movslq %edi, %rdx
  subl %edi, %eax
  leaq 0x1(%rdx,%rax,1), %rax
retq

  .text
  .globl f
  .type f, @function

#! file-offset 0
#! rip-offset  0
#! capacity    20 bytes

# Text                     #  Line  RIP  Bytes  Opcode
.f:                        #        0    0      OPC=<label>
  leaq 0x8(,%ecx,2), %rax  #  1     0    9      OPC=leaq_r64_m32
  subl %eax, %ecx          #  2     0x9  2      OPC=subl_r32_r32
  addq %rcx, %rax          #  3     0xb  3      OPC=addq_r64_r64_1
  retq                     #  4     0xe  1      OPC=retq

.size f, .-f


.f:
movl $0x20, %eax
xchgl %eax, %ecx
btcq %rcx, %rax
retq