LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/radforddc[P]icpc_siggen/fields.c
// Function: set_temp
void set_temp(float temp, MJD_Siggen_Setup *setup){
  if (temp < MIN_TEMP || temp > MAX_TEMP){
    error("temperature out of range: %f\n", temp);
  }else{
    setup->xtal_temp = temp;
    error("temperature set to %f\n", temp);
    /* re-read velocities and correct them to the new temperature value */
    setup_velo(setup);
  }
}

// Assembly:
movaps %xmm0, %xmm1
cvtss2sd %xmm0, %xmm0
movss 0x2a74(%rip), %xmm2     # 0x84d0
ucomiss %xmm1, %xmm2
ja 0x5a8d
ucomiss 0x2a6c(%rip), %xmm1     # 0x84d4
ja 0x5a8d
pushq %rbx
movq %rdi, %rbx
movss %xmm1, 0x388(%rdi)
leaq 0x2c13(%rip), %rdi      # 0x8690
movb $0x1, %al
callq 0x255d
movq %rbx, %rdi
popq %rbx
jmp 0x4617
leaq 0x2bde(%rip), %rdi      # 0x8672
movb $0x1, %al
jmp 0x255d
nop
// File: /workspace/github_c_makefile_star2_O2/radforddc[P]icpc_siggen/point.c
// Function: vector_norm
float vector_norm(vector v, vector *e){
  float length;
  
  length = vector_length(v);

  e->x = v.x / length;
  e->y = v.y / length;
  e->z = v.z / length;
  
  return length;
}

// Assembly:
movaps %xmm0, %xmm2
mulps %xmm0, %xmm2
shufps $0x55, %xmm2, %xmm2     # xmm2 = xmm2[1,1,1,1]
movaps %xmm0, %xmm3
mulss %xmm0, %xmm3
addss %xmm2, %xmm3
movaps %xmm1, %xmm2
mulss %xmm1, %xmm2
addss %xmm3, %xmm2
sqrtss %xmm2, %xmm2
divss %xmm2, %xmm1
movaps %xmm2, %xmm3
unpcklps %xmm2, %xmm3            # xmm3 = xmm3[0],xmm2[0],xmm3[1],xmm2[1]
divps %xmm3, %xmm0
movlps %xmm0, (%rdi)
movss %xmm1, 0x8(%rdi)
movaps %xmm2, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O2/radforddc[P]icpc_siggen/point.c
// Function: cross_prod
vector cross_prod(vector v1, vector v2){
  vector v;
  
  v.x = v1.y*v2.z - v1.z*v2.y;
  v.y = v1.z*v2.x - v1.x*v2.z;
  v.z = v1.x*v2.y - v1.y*v2.x;

  return v;
}

// Assembly:
movaps %xmm1, %xmm4
movaps %xmm2, %xmm1
shufps $0x55, %xmm2, %xmm1     # xmm1 = xmm1[1,1],xmm2[1,1]
movaps %xmm0, %xmm6
movaps %xmm2, %xmm5
shufps $0x10, %xmm0, %xmm5     # xmm5 = xmm5[0,0],xmm0[1,0]
shufps $0xe2, %xmm0, %xmm5     # xmm5 = xmm5[2,0],xmm0[2,3]
mulss %xmm0, %xmm1
shufps $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
shufps $0x10, %xmm2, %xmm6     # xmm6 = xmm6[0,0],xmm2[1,0]
shufps $0xe2, %xmm2, %xmm6     # xmm6 = xmm6[2,0],xmm2[2,3]
unpcklps %xmm3, %xmm4            # xmm4 = xmm4[0],xmm3[0],xmm4[1],xmm3[1]
mulps %xmm4, %xmm6
shufps $0xe1, %xmm4, %xmm4     # xmm4 = xmm4[1,0,2,3]
mulps %xmm4, %xmm5
subps %xmm6, %xmm5
mulss %xmm2, %xmm0
subss %xmm0, %xmm1
movaps %xmm5, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O2/radforddc[P]icpc_siggen/point.c
// Function: vector_rotate_z
vector vector_rotate_z(vector v, float angle_deg){
  float angle_rad;
  vector res;
  angle_rad = angle_deg/180.0*M_PI;

  res.x = cos(angle_rad)*v.x - sin(angle_rad)*v.y;
  res.y = sin(angle_rad)*v.x + cos(angle_rad)*v.y;
  res.z = v.z;

  return res;
}

// Assembly:
subq $0x68, %rsp
movss %xmm1, 0xc(%rsp)
cvtss2sd %xmm2, %xmm1
divsd 0x3069(%rip), %xmm1     # 0x8c18
mulsd 0x28e9(%rip), %xmm1     # 0x84a0
movaps %xmm0, 0x10(%rsp)
cvtsd2ss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, (%rsp)
callq 0x20f0
movaps %xmm0, 0x40(%rsp)
cvtss2sd 0x10(%rsp), %xmm0
movaps %xmm0, 0x50(%rsp)
movsd (%rsp), %xmm0
callq 0x22b0
movaps 0x10(%rsp), %xmm1
shufps $0x55, %xmm1, %xmm1     # xmm1 = xmm1[1,1,1,1]
cvtss2sd %xmm1, %xmm1
movaps %xmm1, 0x10(%rsp)
xorps 0x290f(%rip), %xmm0     # 0x8510
movaps %xmm0, 0x20(%rsp)
movsd (%rsp), %xmm0
callq 0x22b0
movaps %xmm0, 0x30(%rsp)
movsd (%rsp), %xmm0
callq 0x20f0
movapd 0x10(%rsp), %xmm2
unpcklpd %xmm2, %xmm2            # xmm2 = xmm2[0,0]
movapd 0x20(%rsp), %xmm1
unpcklpd %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0]
mulpd %xmm2, %xmm1
movapd %xmm1, %xmm2
movapd 0x40(%rsp), %xmm1
unpcklpd 0x30(%rsp), %xmm1       # xmm1 = xmm1[0],mem[0]
movapd 0x50(%rsp), %xmm0
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
mulpd %xmm1, %xmm0
addpd %xmm2, %xmm0
cvtpd2ps %xmm0, %xmm0
movss 0xc(%rsp), %xmm1
addq $0x68, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/radforddc[P]icpc_siggen/signal_tester.c
// Function: main
int main(int argc, char **argv) {

  MJD_Siggen_Setup setup;

  char  ans[MAX_LINE], *cp;
  int   i, ncmds;

  
  /* read config file and initialize */
  if (argc < 2) {
    printf("Usage: %s <config_file_name>\n", argv[0]);
    return 1;
  }
  if (signal_calc_init(argv[1], &setup) != 0) return 1;
  setup.coord_type = CYL;

  ncmds = sizeof(cmds)/sizeof(cmds[0]);
  while (1) {
    rl_gets(ans, MAX_LINE);
    for (cp = ans; isspace(*cp); cp++);
    if (strlen(cp) == 0) continue;
    if (strncmp(cp, "quit", 4) == 0) return 0;
    for (i = 0; i < ncmds; i++){
      if (strncmp(cp, cmds[i].cmd, strlen(cmds[i].cmd)) == 0){
	cp += strlen(cmds[i].cmd);
	cmds[i].f(cp, &setup);
	break;
      }
    } 
    if (i == ncmds){
      printf("unknown command: %s\n", ans);
    }
  }
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x17b8, %rsp           # imm = 0x17B8
cmpl $0x1, %edi
jg 0x6b01
movq (%rsi), %rsi
leaq 0x2c68(%rip), %rdi      # 0x9760
xorl %eax, %eax
callq 0x2030
jmp 0x6b16
movq 0x8(%rsi), %rdi
leaq 0x208(%rsp), %rsi
callq 0x23cc
testl %eax, %eax
je 0x6b2b
pushq $0x1
popq %rax
addq $0x17b8, %rsp           # imm = 0x17B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x208(%rsp), %rax
andl $0x0, 0x3a8(%rax)
movq %rsp, %r15
leaq 0x564c(%rip), %r13      # 0xc190
movq 0x86f5(%rip), %rdi      # 0xf240
testq %rdi, %rdi
je 0x6b5d
callq 0x2140
andq $0x0, 0x86e3(%rip)      # 0xf240
leaq 0x2f19(%rip), %rdi      # 0x9a7d
callq 0x21f0
movq %rax, %rbx
movq %rax, 0x86cd(%rip)      # 0xf240
cmpb $0x0, (%rax)
je 0x6b87
movq %rbx, %rdi
callq 0x2270
movq 0x86b9(%rip), %rbx      # 0xf240
movl $0x200, %edx            # imm = 0x200
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2230
movb $0x0, 0x1ff(%rsp)
movq %rbx, %rdi
callq 0x2140
andq $0x0, 0x8691(%rip)      # 0xf240
callq 0x2170
movq (%rax), %rax
leaq -0x1(%rsp), %rbx
movsbq 0x1(%rbx), %rcx
incq %rbx
testb $0x20, 0x1(%rax,%rcx,2)
jne 0x6bbc
testb %cl, %cl
je 0x6b44
movq %rbx, %rdi
leaq 0x2ba1(%rip), %rsi      # 0x977e
pushq $0x4
popq %rdx
callq 0x20c0
testl %eax, %eax
je 0x6c4f
xorl %ebp, %ebp
leaq 0x408(%rbp), %r14
cmpq $0x3468, %r14           # imm = 0x3468
je 0x6c39
addq %r13, %rbp
movq %rbp, %rdi
callq 0x2160
movq %rax, %r12
movq %rbx, %rdi
movq %rbp, %rsi
movq %rax, %rdx
callq 0x20c0
movq %r14, %rbp
testl %eax, %eax
jne 0x6beb
addq %r12, %rbx
movq %rbx, %rdi
leaq 0x208(%rsp), %rsi
callq *-0x208(%r14,%r13)
jmp 0x6b44
leaq 0x2b43(%rip), %rdi      # 0x9783
movq %r15, %rsi
xorl %eax, %eax
callq 0x2030
jmp 0x6b44
xorl %eax, %eax
jmp 0x6b19
// File: /workspace/github_c_makefile_star2_O2/radforddc[P]icpc_siggen/signal_tester.c
// Function: print_signal
static int print_signal(char *cmd, MJD_Siggen_Setup *setup){
  struct point cart;
  int    i;
  static float *s;

  if (s == NULL){//first call
    if ((s = (float *) malloc(setup->ntsteps_out*sizeof(*s))) == NULL) {
      printf("Malloc failed\n");
      return 1;
    }
  }

  if (get_cart(cmd, &cart, setup->coord_type) <= 0) return 1;

  if (get_signal(cart, s, setup) < 0) {
    printf("point not in crystal or has no field: (x = %.1f, y = %.1f, z = %.1f)\n",
	   cart.x, cart.y, cart.z);
    return 1;
  }

  printf("signal: \n");
  for (i = 0; i < setup->ntsteps_out; i++){
    printf("%.3f ", s[i]);
    if (i%10 == 9) printf("\n");
  }
  printf("\n");
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x0, 0x819c(%rip)      # 0xf238
jne 0x70be
movslq 0x3ac(%rbx), %rdi
shlq $0x2, %rdi
callq 0x20d0
movq %rax, 0x8183(%rip)      # 0xf238
testq %rax, %rax
je 0x719b
movl 0x3a8(%rbx), %edx
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x76b3
pushq $0x1
popq %rbp
testl %eax, %eax
jle 0x71aa
movq 0x8155(%rip), %rdi      # 0xf238
movsd 0x10(%rsp), %xmm0
movss 0x18(%rsp), %xmm1
movaps %xmm0, 0x20(%rsp)
movss %xmm1, 0xc(%rsp)
movq %rbx, %rsi
callq 0x25f5
testl %eax, %eax
js 0x7174
leaq 0x29b0(%rip), %rdi      # 0x9abd
callq 0x2090
pushq $0x9
popq %r12
xorl %r14d, %r14d
pushq $0xa
popq %rbp
leaq 0x27a4(%rip), %r15      # 0x98c7
movl %r14d, %eax
xorl %edx, %edx
divl %ebp
movslq 0x3ac(%rbx), %rcx
cmpq %rcx, %r14
jge 0x7168
imull $0xa, %eax, %r13d
addl %r12d, %r13d
movq 0x80f4(%rip), %rax      # 0xf238
cvtss2sd (%rax,%r14,4), %xmm0
movq %r15, %rdi
movb $0x1, %al
callq 0x2030
testl %r13d, %r13d
jne 0x7160
movl %ebp, %edi
callq 0x20b0
incq %r14
decl %r12d
jmp 0x7123
pushq $0xa
popq %rdi
callq 0x20b0
xorl %ebp, %ebp
jmp 0x71aa
movaps 0x20(%rsp), %xmm1
cvtss2sd %xmm1, %xmm0
shufps $0x55, %xmm1, %xmm1     # xmm1 = xmm1[1,1,1,1]
cvtss2sd %xmm1, %xmm1
cvtss2sd 0xc(%rsp), %xmm2
leaq 0x261d(%rip), %rdi      # 0x97af
movb $0x3, %al
callq 0x2030
jmp 0x71aa
leaq 0x2924(%rip), %rdi      # 0x9ac6
callq 0x2090
pushq $0x1
popq %rbp
movl %ebp, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/radforddc[P]icpc_siggen/signal_tester.c
// Function: set_temp_local
static int set_temp_local(char *cmd, MJD_Siggen_Setup *setup){
  float t;
  char *endp;
  
  t = strtod(cmd, &endp);
  if (endp == cmd){
    printf("cannot parse temperature: %s\n", cmd);
    return 1;
  }
  set_temp(t, setup);
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rsi
callq 0x22c0
cmpq %rbx, (%r15)
je 0x744d
cvtsd2ss %xmm0, %xmm0
movq %r14, %rdi
callq 0x5a4d
xorl %eax, %eax
jmp 0x7461
leaq 0x24e7(%rip), %rdi      # 0x993b
movq %rbx, %rsi
xorl %eax, %eax
callq 0x2030
pushq $0x1
popq %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/radforddc[P]icpc_siggen/signal_tester.c
// Function: set_tau
static int set_tau(char *cmd, MJD_Siggen_Setup *setup){
  float t;
  char *endp;

  t = strtod(cmd, &endp);
  if (endp == cmd){
    printf("cannot parse tau: %s\n", cmd);
    return 1;
  }
  if (t < 0) t = 0;
  setup->preamp_tau = t;
  printf("Signals will be integrated with tau = %f ns\n", setup->preamp_tau);

  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rsi
callq 0x22c0
cmpq %rbx, (%r15)
je 0x74b6
cvtsd2ss %xmm0, %xmm0
xorps %xmm1, %xmm1
maxss %xmm0, %xmm1
movss %xmm1, 0x38c(%r14)
cvtss2sd %xmm1, %xmm0
leaq 0x24c4(%rip), %rdi      # 0x996f
movb $0x1, %al
callq 0x2030
xorl %eax, %eax
jmp 0x74ca
leaq 0x249c(%rip), %rdi      # 0x9959
movq %rbx, %rsi
xorl %eax, %eax
callq 0x2030
pushq $0x1
popq %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/radforddc[P]icpc_siggen/signal_tester.c
// Function: set_charge_size
static int set_charge_size(char *cmd, MJD_Siggen_Setup *setup){
  float cs;
  char *endp;

  cs = strtod(cmd, &endp);
  if (endp == cmd){
    printf("cannot parse charge_cloud_size: %s\n", cmd);
    return 1;
  }
  if (cs < 0) cs = 0;
  setup->charge_cloud_size = cs;
  printf("Charge cloud size set to %f mm\n", setup->charge_cloud_size);

  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rsi
callq 0x22c0
cmpq %rbx, (%r15)
je 0x751f
cvtsd2ss %xmm0, %xmm0
xorps %xmm1, %xmm1
maxss %xmm0, %xmm1
movss %xmm1, 0x39c(%r14)
cvtss2sd %xmm1, %xmm0
leaq 0x24ac(%rip), %rdi      # 0x99c0
movb $0x1, %al
callq 0x2030
xorl %eax, %eax
jmp 0x7533
leaq 0x2476(%rip), %rdi      # 0x999c
movq %rbx, %rsi
xorl %eax, %eax
callq 0x2030
pushq $0x1
popq %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/radforddc[P]icpc_siggen/signal_tester.c
// Function: set_diffusion
static int set_diffusion(char *cmd, MJD_Siggen_Setup *setup){
  int  d;
  char *endp;

  d = (int) strtol(cmd, &endp, 0);
  if (endp == cmd){
    printf("cannot parse diffusion option: %s\n", cmd);
    return 1;
  }
  if (d < 0) d = 0;
  setup->use_diffusion = d;
  if (d > 0) {
    printf("Diffusion turned on\n");
  } else {
    printf("Diffusion turned off\n");
  }

  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsp, %r15
xorl %ebp, %ebp
movq %r15, %rsi
xorl %edx, %edx
callq 0x21d0
cmpq %r14, (%r15)
je 0x7574
testl %eax, %eax
cmovgl %eax, %ebp
movl %ebp, 0x3a0(%rbx)
jle 0x758a
leaq 0x2577(%rip), %rdi      # 0x9ae9
jmp 0x7591
leaq 0x2465(%rip), %rdi      # 0x99e0
movq %r14, %rsi
xorl %eax, %eax
callq 0x2030
pushq $0x1
popq %rax
jmp 0x7598
leaq 0x2543(%rip), %rdi      # 0x9ad4
callq 0x2090
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/radforddc[P]icpc_siggen/signal_tester.c
// Function: set_energy
static int set_energy(char *cmd, MJD_Siggen_Setup *setup){
  float e;
  char *endp;

  e = strtod(cmd, &endp);
  if (endp == cmd){
    printf("cannot parse energy: %s\n", cmd);
    return 1;
  }
  if (e < 0) e = 0;
  setup->energy = e;
  printf("Interaction energy set to %.1f keV\n", e);

  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rsi
callq 0x22c0
cmpq %rbx, (%r15)
je 0x75ee
cvtsd2ss %xmm0, %xmm0
xorps %xmm1, %xmm1
maxss %xmm0, %xmm1
movss %xmm1, 0x3a4(%r14)
cvtss2sd %xmm1, %xmm0
leaq 0x2439(%rip), %rdi      # 0x9a1c
movb $0x1, %al
callq 0x2030
xorl %eax, %eax
jmp 0x7602
leaq 0x240e(%rip), %rdi      # 0x9a03
movq %rbx, %rsi
xorl %eax, %eax
callq 0x2030
pushq $0x1
popq %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/radforddc[P]icpc_siggen/signal_tester.c
// Function: set_verbosity
static int set_verbosity(char *cmd, MJD_Siggen_Setup *setup) {
  int i;
  char *endp;

  i = strtol(cmd, &endp, 0);
  if (endp == cmd) {
    printf("cannot parse verbosity level: %s\n", cmd);
    return 1;
  }
  if (i < 0) i = 0;
  if (i > 2) i = 2;
  setup->verbosity = i;
  printf("Verbosity level set to %d\n", i);

  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
movq %rsp, %r12
xorl %ebx, %ebx
movq %r12, %rsi
xorl %edx, %edx
callq 0x21d0
cmpq %r15, (%r12)
je 0x7650
testl %eax, %eax
cmovlel %ebx, %eax
cmpl $0x2, %eax
pushq $0x2
popq %rsi
cmovll %eax, %esi
movl %esi, (%r14)
leaq 0x241b(%rip), %rdi      # 0x9a62
xorl %eax, %eax
callq 0x2030
jmp 0x7664
leaq 0x23e9(%rip), %rdi      # 0x9a40
movq %r15, %rsi
xorl %eax, %eax
callq 0x2030
pushq $0x1
popq %rbx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/radforddc[P]icpc_siggen/signal_tester.c
// Function: print_help
static int print_help(char *cmd, MJD_Siggen_Setup *setup){
  int i;

  printf("available commands:\n");
  for (i = 0; i < (int) (sizeof(cmds)/sizeof(cmds[0])); i++){
    printf("%s\n",cmds[i].help_str);
  }
  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x2480(%rip), %rdi      # 0x9afd
callq 0x2090
movl $0x208, %ebx            # imm = 0x208
leaq 0x4b02(%rip), %r14      # 0xc190
cmpq $0x3268, %rbx           # imm = 0x3268
je 0x76a9
leaq (%r14,%rbx), %rdi
callq 0x2090
addq $0x408, %rbx            # imm = 0x408
jmp 0x768e
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/icepole128v2/ref/encrypt.c
// Function: crypto_aead_encrypt
int crypto_aead_encrypt(
	unsigned char *c,unsigned long long *clen,
	const unsigned char *m,unsigned long long mlen,
	const unsigned char *ad,unsigned long long adlen,
	const unsigned char *nsec,
	const unsigned char *npub,
	const unsigned char *k )
{
    ICESTATE S;
    unsigned int frameBit;
    
    /* initialize the state with secret key and nonce */
    initState(S, k, npub);

    /* ciphertext length is plaintext len + size of tag and nsec */
    *clen = mlen + ICEPOLETAGLEN + ICEPOLENSECLEN; 
    
    /* absorb and encrypt 128-bit secret message number */
    processDataBlock(S, nsec, &c, ICEPOLENSECLEN, 0);
    
    /* process auth-only associated data blocks */
    do {
        unsigned long long blocklen = ICEPOLEDATABLOCKLEN;
        frameBit = (adlen <= blocklen ? 1 : 0); /* is it the last block? */
        if (adlen < blocklen) {
            blocklen = adlen;
        }
        /* apply the permutation to the state */
        P6(S,S);
        /* absorb a data block */
        processDataBlock(S, ad, NULL, blocklen, frameBit);
        ad += blocklen;
        adlen -= blocklen;
    } while (adlen > 0);

    /* process plaintext blocks to get the ciphertext */
    do {
        unsigned long long blocklen = ICEPOLEDATABLOCKLEN;
        frameBit = (mlen <=blocklen ? 0 : 1);
        if (mlen < blocklen) {
            blocklen = mlen;
        }
        /* apply the permutation to the state */
        P6(S,S);
        /* absorb a data block and produce a ciphertext block */
        processDataBlock(S, m, &c, blocklen, frameBit);
        m += blocklen;
        mlen -= blocklen;    
    } while (mlen > 0);

    /* store authentication tag at the end of the ciphertext */
    generateTag(S, c);    
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %r9, %r15
movq %r8, %r12
movq %rcx, %rbx
movq %rdx, 0x8(%rsp)
movq %rsi, %rbp
movq 0x100(%rsp), %rsi
movq 0xf8(%rsp), %rdx
movq %rsp, %r13
movq %rdi, (%r13)
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x10c0
leaq 0x20(%rbx), %rax
movq %rax, (%rbp)
pushq $0x10
popq %rcx
movq %r14, %rdi
movq 0xf0(%rsp), %rsi
movq %r13, %rdx
xorl %r8d, %r8d
callq 0x1050
xorl %ebp, %ebp
cmpq $0x81, %r15
setb %bpl
movl $0x80, %eax
cmpq %rax, %r15
movl $0x80, %r13d
cmovbq %r15, %r13
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movq %r14, %rsi
callq 0x1110
movq %r14, %rdi
movq %r12, %rsi
xorl %edx, %edx
movq %r13, %rcx
movl %ebp, %r8d
callq 0x1050
addq %r13, %r12
subq %r13, %r15
jne 0x1293
leaq 0x10(%rsp), %r15
movq %rsp, %r12
movq 0x8(%rsp), %r14
xorl %ebp, %ebp
cmpq $0x81, %rbx
setae %bpl
movl $0x80, %eax
cmpq %rax, %rbx
movl $0x80, %r13d
cmovbq %rbx, %r13
movq %r15, %rdi
movq %r15, %rsi
callq 0x1110
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %r13, %rcx
movl %ebp, %r8d
callq 0x1050
addq %r13, %r14
subq %r13, %rbx
jne 0x12ea
movq (%rsp), %rsi
leaq 0x10(%rsp), %rdi
callq 0x10f0
xorl %eax, %eax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/icepole128v2/ref/icepole.c
// Function: load64
uint64_t load64(const unsigned char * p, unsigned int len)
{
    uint64_t v = 0;
    unsigned int i;
    assert(len <= 8);
    for(i=0; i<len; ++i) {
        v = v ^ (((uint64_t)p[i]) << (8*i));
    }
    return v;
}

// Assembly:
pushq %rax
cmpl $0x8, %esi
ja 0x14e7
movl %esi, %ecx
shlq $0x3, %rcx
xorl %edx, %edx
xorl %eax, %eax
cmpq %rdx, %rcx
je 0x14e5
movzbl (%rdi), %esi
shlxq %rdx, %rsi, %rsi
xorq %rsi, %rax
addq $0x8, %rdx
incq %rdi
jmp 0x14cc
popq %rcx
retq
leaq 0x1bb2(%rip), %rdi      # 0x30a0
leaq 0x1bb4(%rip), %rsi      # 0x30a9
leaq 0x1bd4(%rip), %rcx      # 0x30d0
pushq $0x8
popq %rdx
callq 0x1040
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/icepole128v2/ref/icepole.c
// Function: store64
void store64(unsigned char * p, uint64_t v, unsigned int len)
{
    unsigned int i;
    assert(len <= 8);
    for (i=0; i<len; ++i) {
        p[i] = (unsigned char) (v >> (8*i));
    }
}

// Assembly:
pushq %rax
cmpl $0x8, %edx
ja 0x1529
movl %edx, %eax
shlq $0x3, %rax
xorl %ecx, %ecx
cmpq %rcx, %rax
je 0x1527
shrxq %rcx, %rsi, %rdx
movb %dl, (%rdi)
addq $0x8, %rcx
incq %rdi
jmp 0x1512
popq %rax
retq
leaq 0x1b70(%rip), %rdi      # 0x30a0
leaq 0x1b72(%rip), %rsi      # 0x30a9
leaq 0x1bc7(%rip), %rcx      # 0x3105
pushq $0x13
popq %rdx
callq 0x1040
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/icepole128v2/ref/icepole.c
// Function: Pi
void Pi(ICESTATE SS, ICESTATE S)
{
    unsigned int x,y;
    for(x = 0; x < 4; ++x) {
        for (y = 0; y < 5; ++y) {
            unsigned int xx = (x + y) % 4;
            unsigned int yy = (xx + y + 1) % 5;
            SS[xx][yy] = S[x][y];
        }
    }
}

// Assembly:
xorl %eax, %eax
cmpq $0x4, %rax
je 0x1877
xorl %ecx, %ecx
movq %rax, %rdx
xorl %r8d, %r8d
cmpq $0x28, %r8
je 0x186e
movl %edx, %r9d
andl $0x3, %r9d
addl %ecx, %r9d
leal 0x1(%r9), %r10d
addl $-0x4, %r9d
cmpl $0x5, %r10d
cmovbl %r10d, %r9d
movq (%rsi,%r8), %r10
movl %edx, %r11d
andl $0x3, %r11d
imulq $0x28, %r11, %r11
addq %rdi, %r11
movq %r10, (%r11,%r9,8)
addq $0x8, %r8
incq %rdx
incl %ecx
jmp 0x182d
incq %rax
addq $0x28, %rsi
jmp 0x181f
retq
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/icepole128v2/ref/icepole.c
// Function: Psi
void Psi(ICESTATE SS, ICESTATE S)
{
    unsigned int x;
    for (x = 0; x < 4; ++x) {
        uint64_t tmp1 = S[x][0] & S[x][1] & S[x][2] & S[x][3] & S[x][4];
        uint64_t tmp2 = (~S[x][0]) & (~S[x][1]) & (~S[x][2]) & (~S[x][3]) & (~S[x][4]);
        SS[x][0] = S[x][0] ^ ((~S[x][1]) & S[x][2]) ^ tmp1 ^ tmp2;
        SS[x][1] = S[x][1] ^ ((~S[x][2]) & S[x][3]) ^ tmp1 ^ tmp2;
        SS[x][2] = S[x][2] ^ ((~S[x][3]) & S[x][4]) ^ tmp1 ^ tmp2;
        SS[x][3] = S[x][3] ^ ((~S[x][4]) & S[x][0]) ^ tmp1 ^ tmp2;
        SS[x][4] = S[x][4] ^ ((~S[x][0]) & S[x][1]) ^ tmp1 ^ tmp2;
    }
}

// Assembly:
pushq %rbx
movabsq $0x20, %rax
cmpq $0xc0, %rax
je 0x194a
movq -0x20(%rsi,%rax), %rdx
movq -0x18(%rsi,%rax), %rcx
movq -0x10(%rsi,%rax), %r8
movq %rcx, %r9
andnq %r8, %rcx, %r10
movq %rcx, %r11
andq %rdx, %r11
movq -0x8(%rsi,%rax), %rcx
movq %r8, %rbx
andq %rcx, %rbx
andq %r11, %rbx
movq (%rsi,%rax), %r11
andq %r11, %rbx
orq %rdx, %r9
orq %r8, %rcx
orq %r9, %rcx
orq %r11, %rcx
notq %rcx
xorq %rbx, %r10
xorq %rcx, %r10
xorq %rdx, %r10
movq %r10, -0x20(%rdi,%rax)
movq -0x10(%rsi,%rax), %rdx
andnq -0x8(%rsi,%rax), %rdx, %rdx
xorq -0x18(%rsi,%rax), %rdx
xorq %rbx, %rcx
xorq %rcx, %rdx
movq %rdx, -0x18(%rdi,%rax)
movq -0x8(%rsi,%rax), %rdx
andnq (%rsi,%rax), %rdx, %rdx
xorq -0x10(%rsi,%rax), %rdx
xorq %rcx, %rdx
movq %rdx, -0x10(%rdi,%rax)
movq (%rsi,%rax), %rdx
andnq -0x20(%rsi,%rax), %rdx, %rdx
xorq -0x8(%rsi,%rax), %rdx
xorq %rcx, %rdx
movq %rdx, -0x8(%rdi,%rax)
movq -0x20(%rsi,%rax), %rdx
andnq -0x18(%rsi,%rax), %rdx, %rdx
xorq (%rsi,%rax), %rdx
xorq %rcx, %rdx
movq %rdx, (%rdi,%rax)
addq $0x28, %rax
jmp 0x1883
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/icepole128v2/ref/icepole.c
// Function: Kappa
void Kappa(ICESTATE SS, ICESTATE S, int roundNo)
{
    const uint64_t constant[MAXROUND] = {
    0x0091A2B3C4D5E6F7ULL, 0x0048D159E26AF37BULL, 0x002468ACF13579BDULL, 0x00123456F89ABCDEULL,
    0x00091A2BFC4D5E6FULL, 0x00048D15FE26AF37ULL, 0x0002468AFF13579BULL, 0x000123457F89ABCDULL,
    0x000091A2BFC4D5E6ULL, 0x000048D1DFE26AF3ULL, 0x00002468EFF13579ULL, 0x00001234F7F89ABC };
    unsigned int x,y;
    for(x = 0; x < 4; ++x) {
        for(y = 0; y < 5; ++y) {
            SS[x][y] = S[x][y];
        }
    }

    SS[0][0] = SS[0][0] ^ constant[roundNo];
}

// Assembly:
xorl %eax, %eax
movq %rdi, %rcx
cmpq $0x4, %rax
je 0x197a
xorl %r8d, %r8d
cmpq $0x5, %r8
je 0x196d
movq (%rsi,%r8,8), %r9
movq %r9, (%rcx,%r8,8)
incq %r8
jmp 0x195a
incq %rax
addq $0x28, %rsi
addq $0x28, %rcx
jmp 0x1951
movslq %edx, %rax
leaq 0x18cc(%rip), %rcx      # 0x3250
movq (%rcx,%rax,8), %rax
xorq %rax, (%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/icepole128v2/ref/icepole.c
// Function: oneround
void oneround(ICESTATE SS, ICESTATE S, int roundNo)
{
    ICESTATE B;
    ICESTATE C;
    ICESTATE D;
    ICESTATE E;

    Mu(B, S);
    Rho(C, B);
    Pi(D, C);
    Psi(E, D);
    Kappa(SS, E, roundNo);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x288, %rsp            # imm = 0x288
movl %edx, %ebx
movq %rdi, %r14
leaq 0x1e0(%rsp), %r15
movq %r15, %rdi
callq 0x1080
leaq 0x140(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x1030
leaq 0xa0(%rsp), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x10e0
movq %rsp, %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x10d0
movq %r14, %rdi
movq %r12, %rsi
movl %ebx, %edx
callq 0x1140
addq $0x288, %rsp            # imm = 0x288
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/icepole128v2/ref/icepole.c
// Function: P6
void P6(ICESTATE SS, ICESTATE S)
{
    ICESTATE A;
    ICESTATE B;

    oneround(A,S,0);
    oneround(B,A,1);
    oneround(A,B,2);
    oneround(B,A,3);
    oneround(A,B,4);
    oneround(SS,A,5);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x140, %rsp            # imm = 0x140
movq %rdi, %rbx
leaq 0xa0(%rsp), %r14
movq %r14, %rdi
xorl %edx, %edx
callq 0x1100
movq %rsp, %r15
pushq $0x1
popq %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x1100
pushq $0x2
popq %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x1100
pushq $0x3
popq %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x1100
pushq $0x4
popq %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x1100
pushq $0x5
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1100
addq $0x140, %rsp            # imm = 0x140
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/icepole128v2/ref/icepole.c
// Function: P12
void P12(ICESTATE SS, ICESTATE S)
{
    ICESTATE A;
    ICESTATE B;

    oneround(A,S,0);
    oneround(B,A,1);
    oneround(A,B,2);
    oneround(B,A,3);
    oneround(A,B,4);
    oneround(B,A,5);
    oneround(A,B,6);
    oneround(B,A,7);
    oneround(A,B,8);
    oneround(B,A,9);
    oneround(A,B,10);
    oneround(SS,A,11);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x140, %rsp            # imm = 0x140
movq %rdi, %rbx
leaq 0xa0(%rsp), %r14
movq %r14, %rdi
xorl %edx, %edx
callq 0x1100
movq %rsp, %r15
pushq $0x1
popq %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x1100
pushq $0x2
popq %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x1100
pushq $0x3
popq %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x1100
pushq $0x4
popq %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x1100
pushq $0x5
popq %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x1100
pushq $0x6
popq %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x1100
pushq $0x7
popq %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x1100
pushq $0x8
popq %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x1100
pushq $0x9
popq %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x1100
pushq $0xa
popq %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x1100
pushq $0xb
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1100
addq $0x140, %rsp            # imm = 0x140
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/icepole128v2/ref/icepole.c
// Function: processDataBlock
void processDataBlock(
    ICESTATE S, 
    const unsigned char * source, 
    unsigned char ** dest,
    unsigned long long blocklen, 
    unsigned int frameBit
)
{
	uint64_t q;
	uint64_t snew;
	uint64_t padding;
	unsigned int qlen; 
	unsigned int i = 0;
	assert(blocklen <= ICEPOLEDATABLOCKLEN);
	    
    /* absorb the data block (and produce the ciphertext) */
	do {
        qlen = (blocklen < 8 ? (unsigned int) blocklen : 8); 
        q = load64(source, qlen);
        snew = S[i%4][i/4] ^ q;
        if (dest) {
            store64(*dest, snew, qlen);
            *dest += qlen;
        }        
        padding = qlen < 8 ? ((uint64_t)frameBit | 0x02ULL) << (8*qlen) : 0;
        S[i%4][i/4] ^= q ^ padding;
        ++i;
        source += qlen;
        blocklen -= qlen;
	} while (qlen == 8);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, (%rsp)
cmpq $0x80, %rcx
ja 0x1d91
movq %rcx, %r15
movq %rsi, %r12
orl $0x2, %r8d
xorl %ebx, %ebx
movq %r8, 0x8(%rsp)
cmpq $0x8, %r15
pushq $0x8
popq %rbp
cmovbq %r15, %rbp
movq %r12, %rdi
movl %ebp, %esi
movq %rdx, %r13
callq 0x1090
movq %r13, %rdx
movl %ebx, %esi
andl $0x3, %esi
movl %ebx, %ecx
shrl $0x2, %ecx
imulq $0x28, %rsi, %rsi
addq (%rsp), %rsi
leaq (%rsi,%rcx,8), %r14
testq %r13, %r13
je 0x1d43
movq (%r14), %rsi
xorq %rax, %rsi
movq %rax, 0x10(%rsp)
movq (%rdx), %rdi
movl %ebp, %edx
callq 0x1120
movq 0x10(%rsp), %rax
movq %r13, %rdx
addq %rbp, (%r13)
leal (,%rbp,8), %ecx
cmpq $0x8, %r15
movq 0x8(%rsp), %r8
shlxq %rcx, %r8, %rsi
movl $0x0, %ecx
cmovaeq %rcx, %rsi
xorq (%r14), %rsi
xorq %rax, %rsi
movq %rsi, (%r14)
incl %ebx
addq %rbp, %r12
movq %r15, %rax
subq %rbp, %rax
cmpq $0x7, %r15
movq %rax, %r15
ja 0x1cec
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x13a3(%rip), %rdi      # 0x313b
leaq 0x130a(%rip), %rsi      # 0x30a9
leaq 0x13b5(%rip), %rcx      # 0x315b
movl $0xeb, %edx
callq 0x1040
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/icepole128v2/ref/icepole.c
// Function: processDataBlockRev
void processDataBlockRev(
	ICESTATE S, 
	const unsigned char * source, 
	unsigned char ** dest,
	unsigned long long blocklen, 
	unsigned int frameBit
	)
{
	uint64_t q;
	uint64_t snew;
	uint64_t padding;
	uint64_t bitmask;
	unsigned int qlen; 
	unsigned int i = 0;
	assert(blocklen <= ICEPOLEDATABLOCKLEN);
    
	do {
		qlen = (blocklen < 8 ? (unsigned int) blocklen : 8); 
		q = load64(source, qlen);
		snew = S[i%4][i/4] ^ q;
		bitmask = (qlen==8 ? 0 : 1ULL<< 8*qlen) - 1ULL;
		snew = snew & bitmask;
		if (dest) {
			store64(*dest, snew, qlen);
			*dest += qlen;
		}        
		padding = qlen < 8 ? ((uint64_t)frameBit | 0x02ULL) << (8*qlen) : 0;
		S[i%4][i/4] ^= snew ^ padding;
		++i;
		source += qlen;
		blocklen -= qlen;
	} while (qlen == 8);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, (%rsp)
cmpq $0x80, %rcx
ja 0x1eae
movq %rcx, %r15
movq %rsi, %r12
orl $0x2, %r8d
xorl %ebx, %ebx
movq %r8, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
cmpq $0x8, %r15
pushq $0x8
popq %rbp
cmovbq %r15, %rbp
leal (,%rbp,8), %ecx
cmpq $0x8, %r15
pushq $-0x1
popq %rax
movq %rcx, 0x20(%rsp)
shlxq %rcx, %rax, %r14
notq %r14
cmovaeq %rax, %r14
movq %r12, %rdi
movl %ebp, %esi
callq 0x1090
movq %rax, %r13
movl %ebx, %eax
andl $0x3, %eax
movl %ebx, %ecx
shrl $0x2, %ecx
imulq $0x28, %rax, %rax
addq (%rsp), %rax
leaq (%rax,%rcx,8), %rsi
movq (%rsi), %rax
xorq %rax, %r13
andq %r14, %r13
movq 0x8(%rsp), %r14
testq %r14, %r14
je 0x1e62
movq (%r14), %rdi
movq %rsi, 0x18(%rsp)
movq %r13, %rsi
movl %ebp, %edx
callq 0x1120
movq 0x18(%rsp), %rsi
addq %rbp, (%r14)
movq (%rsi), %rax
cmpq $0x8, %r15
movq 0x10(%rsp), %r8
movq 0x20(%rsp), %rcx
shlxq %rcx, %r8, %rcx
movl $0x0, %edx
cmovaeq %rdx, %rcx
xorq %rax, %rcx
xorq %r13, %rcx
incl %ebx
addq %rbp, %r12
movq %r15, %rax
subq %rbp, %rax
movq %rcx, (%rsi)
cmpq $0x7, %r15
movq %rax, %r15
ja 0x1de5
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1286(%rip), %rdi      # 0x313b
leaq 0x11ed(%rip), %rsi      # 0x30a9
leaq 0x130a(%rip), %rcx      # 0x31cd
movl $0x111, %edx            # imm = 0x111
callq 0x1040
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]sassafras/sassafras.c
// Function: parse_data_stmt
void
parse_data_stmt(void)
{
	struct dataset *d;

	d = (struct dataset *) xmalloc(sizeof (struct dataset));

	bzero(d, sizeof (struct dataset));

	d->next = dd;
	dd = d;

	d->max = 1000;

	scan();

	if (token == NAME) {
		d->name = strdup(strbuf); // dataset NAME
		scan();
	}

	if (token != ';')
		expected("end of statment");

	scan();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl $0xfc0, %edi            # imm = 0xFC0
callq 0x2a9b
movq %rax, %rbx
leaq 0x8(%rax), %rdi
movl $0xfb8, %edx            # imm = 0xFB8
xorl %esi, %esi
callq 0x2100
movq 0xdce2(%rip), %rax      # 0x10080
movq %rax, (%rbx)
movq %rbx, 0xdcd8(%rip)      # 0x10080
movl $0x3e8, 0x18(%rbx)      # imm = 0x3E8
callq 0x2a45
movl 0xd4da(%rip), %eax      # 0xf894
cmpl $0x3e9, %eax            # imm = 0x3E9
jne 0x23dc
leaq 0xdcc8(%rip), %rdi      # 0x10090
callq 0x2210
movq %rax, 0x8(%rbx)
callq 0x2a45
movl 0xd4b8(%rip), %eax      # 0xf894
cmpl $0x3b, %eax
jne 0x23ec
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2a45
leaq 0x8fd9(%rip), %rdi      # 0xb3cc
callq 0x25a8
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]sassafras/sassafras.c
// Function: parse_data_body
void
parse_data_body(void)
{
	for (;;) {

		if (token == NAME) {

			// look ahead for NAME = EXPR

			while (*inp == ' ' || *inp == '\t')
				inp++;

			if (*inp == '=') {
				parse_data_expr();
				continue;
			}
		}

		keyword();

		switch (token) {
		case 0:
		case KDATA:
		case KPROC:
		case KRUN:
			if (*dfilename == 0)
				expected("infile or datalines");
			read_data_file();
			return;
		case KDATALINES:
			if (*dfilename)
				stop("Datalines after infile?");
			datalines_stmt();
			return;
		case KINPUT:
			input_stmt();
			break;
		case KINFILE:
			infile_stmt();
			break;
		default:
			parse_default();
			break;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0x8bff(%rip), %rbx      # 0xb004
cmpl $0x3e9, 0xd485(%rip)    # imm = 0x3E9
jne 0x243e
movq 0xd480(%rip), %rax      # 0xf898
incq %rax
movzbl -0x1(%rax), %ecx
cmpl $0x9, %ecx
je 0x2429
cmpl $0x20, %ecx
jne 0x2432
movq %rax, 0xd468(%rip)      # 0xf898
jmp 0x2418
cmpl $0x3d, %ecx
jne 0x243e
callq 0x24c4
jmp 0x2405
callq 0x254c
movl 0xd44b(%rip), %eax      # 0xf894
leal -0x135(%rax), %ecx
cmpl $0x6, %ecx
ja 0x246b
movslq (%rbx,%rcx,4), %rax
addq %rbx, %rax
jmpq *%rax
callq 0x2852
jmp 0x2405
callq 0x2730
jmp 0x2405
testl %eax, %eax
je 0x2484
cmpl $0x14a, %eax            # imm = 0x14A
je 0x2484
cmpl $0x147, %eax            # imm = 0x147
je 0x2484
callq 0x29bd
jmp 0x2405
cmpb $0x0, 0xcfb5(%rip)      # 0xf440
je 0x24ac
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2609
cmpb $0x0, 0xcfa1(%rip)      # 0xf440
jne 0x24b8
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x269f
leaq 0x8ecb(%rip), %rdi      # 0xb37e
callq 0x25a8
leaq 0x8ed3(%rip), %rdi      # 0xb392
callq 0x267a
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]sassafras/sassafras.c
// Function: parse_data_expr
void
parse_data_expr(void)
{
	if (dd->nvar == MAXVAR)
		stop("Too many variables");
	dd->spec[dd->nvar].name = strdup(strbuf);
	scan(); // skip over name
	scan(); // skip over equals sign
	parse_expr();
	if (token != ';')
		stop("';' expected");
	scan();
	emit(STORE);
	emit(dd->nvar);
	dd->nvar++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0xdbae(%rip), %rbx      # 0x10080
movslq 0x10(%rbx), %r14
cmpq $0x64, %r14
je 0x2534
leaq 0xdbad(%rip), %rdi      # 0x10090
callq 0x2210
imulq $0x28, %r14, %rcx
movq %rax, 0x20(%rbx,%rcx)
callq 0x2a45
callq 0x2a45
callq 0x3721
cmpl $0x3b, 0xd38d(%rip)     # 0xf894
jne 0x2540
callq 0x2a45
pushq $0xb
popq %rdi
callq 0x2ab6
movq 0xdb63(%rip), %rax      # 0x10080
movl 0x10(%rax), %edi
callq 0x2ab6
movq 0xdb54(%rip), %rax      # 0x10080
incl 0x10(%rax)
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x8e7e(%rip), %rdi      # 0xb3b9
callq 0x267a
leaq 0x8f8d(%rip), %rdi      # 0xb4d4
callq 0x267a
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]sassafras/sassafras.c
// Function: keyword
void
keyword(void)
{
	int i, n = sizeof keytab / sizeof (struct key);
	if (token != NAME)
		return;
	for (i = 0; i < n; i++)
		if (strcmp(strbuf, keytab[i].s) == 0) {
			token = keytab[i].k;
			break;
		}
}

// Assembly:
cmpl $0x3e9, 0xd33e(%rip)    # imm = 0x3E9
jne 0x25a7
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
xorl %ecx, %ecx
leaq 0xcc15(%rip), %r14      # 0xf180
leaq 0xdb1e(%rip), %rbx      # 0x10090
leaq 0x10(%rcx), %r15
cmpq $0x2b0, %r15            # imm = 0x2B0
je 0x259d
movq (%rcx,%r14), %rsi
movq %rbx, %rdi
callq 0x2160
movq %r15, %rcx
testl %eax, %eax
jne 0x2572
movl -0x8(%r15,%r14), %eax
movl %eax, 0xd2f7(%rip)      # 0xf894
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]sassafras/sassafras.c
// Function: expected
void
expected(char *s)
{
	if (token == 0)
		snprintf(errbuf, ERRBUFLEN, "Expected %s before end of program", s);
	else if (token == ';')
		snprintf(errbuf, ERRBUFLEN, "Expected %s before end of statement", s);
	else
		snprintf(errbuf, ERRBUFLEN, "Expected %s instead of \"%s\"", s, strbuf);
	stop(errbuf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rcx
movl 0xd2df(%rip), %eax      # 0xf894
leaq 0xd2f4(%rip), %rdi      # 0xf8b0
cmpl $0x3b, %eax
je 0x25ce
testl %eax, %eax
jne 0x25e3
leaq 0x94cd(%rip), %rdx      # 0xba99
jmp 0x25d5
leaq 0x94e6(%rip), %rdx      # 0xbabb
movl $0x7d0, %esi            # imm = 0x7D0
xorl %eax, %eax
callq 0x20e0
jmp 0x25fd
leaq 0x94f5(%rip), %rdx      # 0xbadf
leaq 0xda9f(%rip), %r8       # 0x10090
movl $0x7d0, %esi            # imm = 0x7D0
xorl %eax, %eax
callq 0x20e0
leaq 0xd2ac(%rip), %rdi      # 0xf8b0
callq 0x267a
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]sassafras/sassafras.c
// Function: read_data_file
void
read_data_file(void)
{
	infile = fopen(dfilename, "r");

	if (infile == NULL) {
		snprintf(errbuf, ERRBUFLEN, "Cannot open %s", dfilename);
		stop(errbuf);
	}

	get_data();

	fclose(infile);
	infile = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0xce2a(%rip), %rdi      # 0xf440
leaq 0x9264(%rip), %rsi      # 0xb881
callq 0x21d0
movq %rax, 0xd277(%rip)      # 0xf8a0
testq %rax, %rax
je 0x264e
callq 0x2a15
movq 0xd266(%rip), %rdi      # 0xf8a0
callq 0x20a0
andq $0x0, 0xd259(%rip)      # 0xf8a0
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0xd25b(%rip), %rbx      # 0xf8b0
leaq 0x8d4e(%rip), %rdx      # 0xb3aa
leaq 0xcddd(%rip), %rcx      # 0xf440
movl $0x7d0, %esi            # imm = 0x7D0
movq %rbx, %rdi
xorl %eax, %eax
callq 0x20e0
movq %rbx, %rdi
callq 0x267a
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]sassafras/sassafras.c
// Function: datalines_stmt
void
datalines_stmt(void)
{
	// don't allow garbage after datalines token

	while (isspace(*inp) && *inp != '\n' && *inp != '\r')
		inp++;

	if (*inp == ';') {
		inp++;
		while (isspace(*inp) && *inp != '\n' && *inp != '\r')
			inp++;
	}

	if (*inp != '\n' && *inp != '\r') {
		scan();
		expected("datalines data");
	}

	get_data();

	scan(); // get next token (current token is still DATALINES)
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x2230
movq 0xd1e9(%rip), %rcx      # 0xf898
incq %rcx
movq (%rax), %rsi
movsbq -0x1(%rcx), %rdx
movzwl (%rsi,%rdx,2), %esi
btl $0xd, %esi
jae 0x26da
movzbl %dl, %esi
cmpl $0xa, %esi
je 0x2707
cmpl $0xd, %esi
je 0x2707
movq %rcx, 0xd1c0(%rip)      # 0xf898
jmp 0x26af
cmpb $0x3b, %dl
jne 0x2707
movq %rcx, 0xd1b2(%rip)      # 0xf898
movq (%rax), %rsi
movsbq (%rcx), %rdx
movzwl (%rsi,%rdx,2), %esi
btl $0xd, %esi
jae 0x2707
movzbl %dl, %esi
cmpl $0xa, %esi
je 0x2707
incq %rcx
cmpl $0xd, %esi
jne 0x26df
cmpb $0xa, %dl
je 0x2714
movzbl %dl, %eax
cmpl $0xd, %eax
jne 0x271f
callq 0x2a15
popq %rbp
jmp 0x2a45
callq 0x2a45
leaq 0x8d13(%rip), %rdi      # 0xb43e
callq 0x25a8
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]sassafras/sassafras.c
// Function: input_stmt
void
input_stmt(void)
{
	int n;

	scan(); // get next token after INPUT

	// scan data specifiers

	for (;;) {

		if (token != NAME)
			break;

		if (dd->nvar == MAXVAR)
			stop("Too many variables");

		n = dd->nvar++;

		dd->spec[n].name = strdup(strbuf);

		scan();

		if (token == '$') {
			dd->spec[n].max_levels = 10;
			dd->spec[n].num_levels = 0;
			dd->spec[n].ltab = (char **) xmalloc(10 * sizeof (char *));
			emit(SCAN_STR);
			emit(n);
			scan();
		} else {
			dd->spec[n].max_levels = 0;
			dd->spec[n].num_levels = 0;
			dd->spec[n].ltab = NULL;
			emit(SCAN_NUM);
			emit(n);
		}
	}

	if (token == ATAT) {
		emit(CHKBUF);
		scan();
	} else
		emit(GETBUF);

	if (token != ';')
		expected("end of statement");

	scan();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
callq 0x2a45
leaq 0xd946(%rip), %rbx      # 0x10090
pushq $0x1
popq %r15
movl 0xd140(%rip), %eax      # 0xf894
cmpl $0x3e9, %eax            # imm = 0x3E9
jne 0x2800
movq 0xd91a(%rip), %r14      # 0x10080
movslq 0x10(%r14), %r12
cmpq $0x64, %r12
je 0x283a
leal 0x1(%r12), %eax
movl %eax, 0x10(%r14)
movq %rbx, %rdi
callq 0x2210
imulq $0x28, %r12, %r13
movq %rax, 0x20(%r14,%r13)
callq 0x2a45
movq 0xd8e6(%rip), %rax      # 0x10080
cmpl $0x24, 0xd0f3(%rip)     # 0xf894
leaq 0x28(%rax,%r13), %rcx
jne 0x27e6
addq $0x20, %rax
movl $0xa, (%rcx)
andl $0x0, 0xc(%rax,%r13)
pushq $0x50
popq %rdi
callq 0x2a9b
movq 0xd8b9(%rip), %rcx      # 0x10080
movq %rax, 0x30(%rcx,%r13)
movl %r15d, %edi
callq 0x2ab6
movl %r12d, %edi
callq 0x2ab6
callq 0x2a45
jmp 0x274e
xorps %xmm0, %xmm0
movups %xmm0, (%rcx)
xorl %edi, %edi
callq 0x2ab6
movl %r12d, %edi
callq 0x2ab6
jmp 0x274e
cmpl $0x3ec, %eax            # imm = 0x3EC
jne 0x2816
pushq $0xd
popq %rdi
callq 0x2ab6
callq 0x2a45
jmp 0x281e
pushq $0xc
popq %rdi
callq 0x2ab6
cmpl $0x3b, 0xd06f(%rip)     # 0xf894
jne 0x2846
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2a45
leaq 0x8b78(%rip), %rdi      # 0xb3b9
callq 0x267a
leaq 0x9281(%rip), %rdi      # 0xbace
callq 0x25a8
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]sassafras/sassafras.c
// Function: infile_stmt
void
infile_stmt(void)
{
	if (dfilename[0])
		stop("Multiple INFILE statements");

	get_next_token();

	switch (token) {
	case STRING:
		strcpy(dfilename, strbuf);
		break;
	case KCARDS:
	case KDATALINES:
		break;
	default:
		expected("file name");
	}

	for (;;) {

		scan();
		keyword();

		switch (token) {

		case ';':
			scan();
			return;

		case KDLM:
		case KDELIMITER:
			scan();
			if (token != '=')
				expected("equals sign");
			scan();
			if (token != STRING)
				expected("string");
			if (strlen(strbuf) >= sizeof delim)
				stop("string too long");
			strcpy(delim, strbuf);
			break;

		case KFIRSTOBS:
			scan();
			if (token != '=')
				expected("equals sign");
			scan();
			if (token != NUMBER)
				expected("number");
			if (sscanf(strbuf, "%d", &firstobs) != 1)
				stop("Error in number syntax");
			break;

		default:
			expected("end of statement");
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpb $0x0, 0xcbdd(%rip)      # 0xf440
jne 0x288e
callq 0x2aea
movl 0xd024(%rip), %eax      # 0xf894
cmpl $0x130, %eax            # imm = 0x130
je 0x28b2
cmpl $0x136, %eax            # imm = 0x136
je 0x28b2
cmpl $0x3eb, %eax            # imm = 0x3EB
jne 0x289a
leaq 0xcbb4(%rip), %rdi      # 0xf440
jmp 0x28a6
leaq 0x8b47(%rip), %rdi      # 0xb3dc
callq 0x267a
leaq 0x8b56(%rip), %rdi      # 0xb3f7
callq 0x25a8
leaq 0xd7e3(%rip), %rsi      # 0x10090
callq 0x2060
leaq 0xd7d7(%rip), %rbx      # 0x10090
leaq 0x8b64(%rip), %r14      # 0xb424
leaq 0xcb6d(%rip), %r15      # 0xf434
callq 0x2a45
callq 0x254c
movl 0xcfbd(%rip), %eax      # 0xf894
cmpl $0x139, %eax            # imm = 0x139
jne 0x2926
callq 0x2a45
cmpl $0x3d, 0xcfaa(%rip)     # 0xf894
jne 0x298d
callq 0x2a45
cmpl $0x3ea, 0xcf95(%rip)    # imm = 0x3EA
jne 0x2999
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x2190
cmpl $0x1, %eax
je 0x28c7
leaq 0x8b06(%rip), %rdi      # 0xb427
callq 0x267a
leal -0x137(%rax), %ecx
cmpl $0x2, %ecx
jae 0x2979
callq 0x2a45
cmpl $0x3d, 0xcf57(%rip)     # 0xf894
jne 0x298d
callq 0x2a45
cmpl $0x3eb, 0xcf46(%rip)    # imm = 0x3EB
jne 0x29b1
leaq 0xd739(%rip), %rdi      # 0x10090
callq 0x20b0
leaq 0xcecd(%rip), %rdi      # 0xf830
cmpq $0x64, %rax
jb 0x28a6
leaq 0x8a99(%rip), %rdi      # 0xb40d
callq 0x267a
cmpl $0x3b, %eax
jne 0x29a5
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2a45
leaq 0x8a6d(%rip), %rdi      # 0xb401
callq 0x25a8
leaq 0x8a7d(%rip), %rdi      # 0xb41d
callq 0x25a8
leaq 0x9122(%rip), %rdi      # 0xbace
callq 0x25a8
leaq 0x9168(%rip), %rdi      # 0xbb20
callq 0x25a8
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]sassafras/sassafras.c
// Function: get_data
void
get_data(void)
{
	alloc_data_vectors();
	getbuf();
	while (inb) {
		check_data_vectors();
		get_data1();
		dd->nobs++;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x2b07
callq 0x2b56
cmpq $0x0, 0xda4d(%rip)      # 0x10478
je 0x2a43
callq 0x2bf1
callq 0x2c4e
movq 0xd642(%rip), %rax      # 0x10080
incl 0x14(%rax)
jmp 0x2a23
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]sassafras/sassafras.c
// Function: scan
void
scan(void)
{
	static int t;

	if (inp == pgm)
		t = 0; // initial state
	else
		t = token;

	token = scan1();

	// ensure last token is semicolon

	if (token == 0 && t && t != ';') {
		strbuf[0] = ';';
		strbuf[1] = 0;
		token = ';';
	}
}

// Assembly:
movq 0xce4c(%rip), %rcx      # 0xf898
xorl %eax, %eax
cmpq 0x13253(%rip), %rcx     # 0x15ca8
je 0x2a5d
movl 0xce37(%rip), %eax      # 0xf894
pushq %rbp
movq %rsp, %rbp
movl %eax, 0x13249(%rip)     # 0x15cb0
callq 0x9fc8
movl %eax, 0xce22(%rip)      # 0xf894
testl %eax, %eax
popq %rbp
je 0x2a78
retq
movl 0x13232(%rip), %eax     # 0x15cb0
testl %eax, %eax
je 0x2a77
cmpl $0x3b, %eax
je 0x2a77
movw $0x3b, 0xd600(%rip)     # 0x10090
movl $0x3b, 0xcdfa(%rip)     # 0xf894
retq
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]sassafras/sassafras.c
// Function: xmalloc
void *
xmalloc(int size)
{
	void *p = malloc(size);
	if (p == NULL)
		exit(1);
	return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movslq %edi, %rdi
callq 0x2180
testq %rax, %rax
je 0x2aae
popq %rbp
retq
pushq $0x1
popq %rdi
callq 0x21f0
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]sassafras/sassafras.c
// Function: alloc_data_vectors
void
alloc_data_vectors(void)
{
	int i;
	for (i = 0; i < dd->nvar; i++)
		if (dd->spec[i].v == NULL)
			dd->spec[i].v = (double *) xmalloc(dd->max * sizeof (double));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
pushq $0x40
popq %rbx
movq 0xd568(%rip), %rax      # 0x10080
xorl %r14d, %r14d
movslq 0x10(%rax), %rcx
cmpq %rcx, %r14
jge 0x2b51
cmpq $0x0, (%rax,%rbx)
jne 0x2b48
movl 0x18(%rax), %edi
shll $0x3, %edi
callq 0x2a9b
movq 0xd543(%rip), %rcx      # 0x10080
movq %rax, (%rcx,%rbx)
movq 0xd538(%rip), %rax      # 0x10080
incq %r14
addq $0x28, %rbx
jmp 0x2b1b
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]sassafras/sassafras.c
// Function: getbuf
void
getbuf(void)
{
	do {
		if (infile)
			for (;;) {
				inb = fgets(bigbuf, BIGBUFLEN, infile);
				if (inb == NULL || firstobs < 2)
					break;
				firstobs--;
			}
		else
			inb = get_dataline(bigbuf, BIGBUFLEN);

		if (inb == NULL)
			return;

		// skip spaces

		while (isspace(*inb))
			inb++;

	} while (*inb == 0); // skip blank lines
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
leaq 0x1035c(%rip), %rbx     # 0x12ec0
movq 0xcd35(%rip), %rdx      # 0xf8a0
testq %rdx, %rdx
je 0x2ba8
movq %rbx, %rdi
movl $0xfa0, %esi            # imm = 0xFA0
callq 0x2140
movq %rax, %r14
movq %rax, 0xd8f1(%rip)      # 0x10478
testq %rax, %rax
je 0x2bbf
movl 0xc8a2(%rip), %eax      # 0xf434
cmpl $0x2, %eax
jl 0x2bbf
decl %eax
movl %eax, 0xc895(%rip)      # 0xf434
movq 0xccfa(%rip), %rdx      # 0xf8a0
jmp 0x2b70
movq %rbx, %rdi
movl $0xfa0, %esi            # imm = 0xFA0
callq 0x3445
movq %rax, %r14
movq %rax, 0xd8b9(%rip)      # 0x10478
testq %r14, %r14
je 0x2bec
callq 0x2230
incq %r14
movq (%rax), %rdx
movsbq -0x1(%r14), %rcx
testb $0x20, 0x1(%rdx,%rcx,2)
je 0x2be4
movq %r14, 0xd896(%rip)      # 0x10478
jmp 0x2bc9
testb %cl, %cl
je 0x2b64
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]sassafras/sassafras.c
// Function: check_data_vectors
void
check_data_vectors(void)
{
	int i;
	if (dd->nobs < dd->max)
		return;
	dd->max += 1000;
	for (i = 0; i < dd->nvar; i++)
		dd->spec[i].v = xrealloc(dd->spec[i].v, dd->max * sizeof (double));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0xd481(%rip), %rax      # 0x10080
movl 0x18(%rax), %ecx
cmpl %ecx, 0x14(%rax)
jge 0x2c0c
popq %rbx
popq %r14
popq %rbp
retq
addl $0x3e8, %ecx            # imm = 0x3E8
movl %ecx, 0x18(%rax)
pushq $0x40
popq %rbx
xorl %r14d, %r14d
movslq 0x10(%rax), %rcx
cmpq %rcx, %r14
jge 0x2c07
movq (%rax,%rbx), %rdi
movl 0x18(%rax), %esi
shll $0x3, %esi
callq 0x342a
movq 0xd446(%rip), %rcx      # 0x10080
movq %rax, (%rcx,%rbx)
incq %r14
movq 0xd438(%rip), %rax      # 0x10080
addq $0x28, %rbx
jmp 0x2c1b