LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movaps %xmm0, %xmm4
movaps %xmm0, %xmm3
shufps $0x55, %xmm0, %xmm3     # xmm3 = xmm3[1,1],xmm0[1,1]
movaps %xmm3, %xmm0
mulss %xmm3, %xmm0
movaps %xmm4, %xmm2
mulss %xmm4, %xmm2
addss %xmm0, %xmm2
movaps %xmm1, %xmm0
mulss %xmm1, %xmm0
addss %xmm2, %xmm0
xorps %xmm2, %xmm2
ucomiss %xmm2, %xmm0
jb 0x616d
sqrtss %xmm0, %xmm0
jmp 0x6192
movss %xmm1, 0xc(%rsp)
movaps %xmm3, 0x20(%rsp)
movaps %xmm4, 0x10(%rsp)
callq 0x22c0
movaps 0x10(%rsp), %xmm4
movaps 0x20(%rsp), %xmm3
movss 0xc(%rsp), %xmm1
divss %xmm0, %xmm4
movss %xmm4, (%rbx)
divss %xmm0, %xmm3
movss %xmm3, 0x4(%rbx)
divss %xmm0, %xmm1
movss %xmm1, 0x8(%rbx)
addq $0x30, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %xmm0, %xmm6
shufps $0x55, %xmm0, %xmm6     # xmm6 = xmm6[1,1],xmm0[1,1]
movaps %xmm2, %xmm4
shufps $0x55, %xmm2, %xmm4     # xmm4 = xmm4[1,1],xmm2[1,1]
movaps %xmm4, %xmm7
mulss %xmm1, %xmm7
movaps %xmm6, %xmm5
mulss %xmm3, %xmm5
subss %xmm7, %xmm5
mulss %xmm0, %xmm3
mulss %xmm2, %xmm1
subss %xmm3, %xmm1
unpcklps %xmm1, %xmm5            # xmm5 = xmm5[0],xmm1[0],xmm5[1],xmm1[1]
mulss %xmm2, %xmm6
mulss %xmm0, %xmm4
subss %xmm6, %xmm4
movaps %xmm5, %xmm0
movaps %xmm4, %xmm1
retq
// File: /workspace/github_c_makefile_star2_O1/radforddc[P]icpc_siggen/point.c
// Function: vector_scale
vector vector_scale(vector v, float factor){
  vector res;

  res.x = v.x*factor;
  res.y = v.y*factor;
  res.z = v.z*factor;

  return res;
}

// Assembly:
movaps %xmm0, %xmm3
mulss %xmm2, %xmm3
shufps $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
mulss %xmm2, %xmm0
unpcklps %xmm0, %xmm3            # xmm3 = xmm3[0],xmm0[0],xmm3[1],xmm0[1]
mulss %xmm2, %xmm1
movaps %xmm3, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O1/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 $0x38, %rsp
movss %xmm1, 0x14(%rsp)
xorps %xmm1, %xmm1
cvtss2sd %xmm2, %xmm1
divsd 0x2913(%rip), %xmm1     # 0x8bd0
mulsd 0x21db(%rip), %xmm1     # 0x84a0
movaps %xmm0, 0x20(%rsp)
xorps %xmm0, %xmm0
cvtsd2ss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
callq 0x20f0
movsd %xmm0, (%rsp)
xorps %xmm0, %xmm0
cvtss2sd 0x20(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x22a0
movaps 0x20(%rsp), %xmm1
shufps $0x55, %xmm1, %xmm1     # xmm1 = xmm1[1,1,1,1]
cvtss2sd %xmm1, %xmm1
movsd %xmm1, 0x30(%rsp)
mulsd %xmm1, %xmm0
movsd (%rsp), %xmm1
mulsd 0x18(%rsp), %xmm1
subsd %xmm0, %xmm1
xorps %xmm0, %xmm0
cvtsd2ss %xmm1, %xmm0
movaps %xmm0, 0x20(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x22a0
movsd %xmm0, (%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x20f0
mulsd 0x30(%rsp), %xmm0
movsd (%rsp), %xmm1
mulsd 0x18(%rsp), %xmm1
addsd %xmm0, %xmm1
cvtsd2ss %xmm1, %xmm1
movaps 0x20(%rsp), %xmm0
unpcklps %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movss 0x14(%rsp), %xmm1
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x71d5
movq (%rsi), %rsi
leaq 0x2540(%rip), %rdi      # 0x9704
xorl %eax, %eax
callq 0x2030
movl $0x1, %eax
jmp 0x7331
movq 0x8(%rsi), %rdi
leaq 0x208(%rsp), %rsi
callq 0x249c
movl %eax, %ecx
movl $0x1, %eax
testl %ecx, %ecx
jne 0x7331
leaq 0x208(%rsp), %rax
movl $0x0, 0x3a8(%rax)
movq %rsp, %r15
leaq 0x4f7f(%rip), %r12      # 0xc190
movq 0x8028(%rip), %rdi      # 0xf240
testq %rdi, %rdi
je 0x722d
callq 0x2140
movq $0x0, 0x8013(%rip) # 0xf240
leaq 0x27ed(%rip), %rdi      # 0x9a21
callq 0x21f0
movq %rax, 0x8000(%rip)      # 0xf240
testq %rax, %rax
je 0x7252
cmpb $0x0, (%rax)
je 0x7252
movq %rax, %rdi
callq 0x2260
movq 0x7fe7(%rip), %rbx      # 0xf240
movl $0x200, %edx            # imm = 0x200
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2220
movb $0x0, 0x1ff(%rsp)
movq %rbx, %rdi
callq 0x2140
movq $0x0, 0x7fbc(%rip) # 0xf240
callq 0x2170
movq (%rax), %rax
leaq -0x1(%rsp), %rbp
movsbq 0x1(%rbp), %rcx
incq %rbp
testb $0x20, 0x1(%rax,%rcx,2)
jne 0x7291
testb %cl, %cl
je 0x7211
movl $0x4, %edx
movq %rbp, %rdi
leaq 0x246b(%rip), %rsi      # 0x9722
callq 0x20c0
testl %eax, %eax
je 0x732f
xorl %r14d, %r14d
leaq (%r12,%r14), %r13
movq %r13, %rdi
callq 0x2160
movq %rax, %rbx
movq %rbp, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x20c0
testl %eax, %eax
je 0x72f6
addq $0x408, %r14            # imm = 0x408
cmpq $0x3060, %r14           # imm = 0x3060
jne 0x72c3
jmp 0x7319
addq %rbx, %rbp
movq %rbp, %rdi
leaq 0x208(%rsp), %rsi
callq *0x200(%r14,%r12)
cmpq $0x3060, %r14           # imm = 0x3060
jne 0x7211
leaq 0x2407(%rip), %rdi      # 0x9727
movq %r15, %rsi
xorl %eax, %eax
callq 0x2030
jmp 0x7211
xorl %eax, %eax
addq $0x17b8, %rsp           # imm = 0x17B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x0, 0x7ab3(%rip)      # 0xf238
jne 0x77a7
movslq 0x3ac(%rbx), %rdi
shlq $0x2, %rdi
callq 0x20d0
movq %rax, 0x7a9a(%rip)      # 0xf238
testq %rax, %rax
je 0x789b
movl 0x3a8(%rbx), %edx
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x7dec
movl $0x1, %ebp
testl %eax, %eax
jle 0x78ac
movq 0x7a6a(%rip), %rdi      # 0xf238
movsd 0x10(%rsp), %xmm0
movss 0x18(%rsp), %xmm1
movss %xmm1, 0xc(%rsp)
movq %rbx, %rsi
callq 0x263a
testl %eax, %eax
js 0x7873
leaq 0x226a(%rip), %rdi      # 0x9a61
callq 0x2090
cmpl $0x0, 0x3ac(%rbx)
jle 0x7865
xorl %r14d, %r14d
movabsq $-0x3333333333333333, %r12 # imm = 0xCCCCCCCCCCCCCCCD
leaq 0x2052(%rip), %r15      # 0x986b
movq %r14, %rax
mulq %r12
shrq $0x3, %rdx
leal (%rdx,%rdx,4), %eax
leal 0x9(,%rax,2), %ebp
movq 0x7a04(%rip), %rax      # 0xf238
xorps %xmm0, %xmm0
cvtss2sd (%rax,%r14,4), %xmm0
movq %r15, %rdi
movb $0x1, %al
callq 0x2030
cmpl %r14d, %ebp
jne 0x7856
movl $0xa, %edi
callq 0x20b0
incq %r14
movslq 0x3ac(%rbx), %rax
cmpq %rax, %r14
jl 0x7819
movl $0xa, %edi
callq 0x20b0
xorl %ebp, %ebp
jmp 0x78ac
xorps %xmm0, %xmm0
cvtss2sd 0x10(%rsp), %xmm0
xorps %xmm1, %xmm1
cvtss2sd 0x14(%rsp), %xmm1
cvtss2sd 0xc(%rsp), %xmm2
leaq 0x1ec1(%rip), %rdi      # 0x9753
movb $0x3, %al
callq 0x2030
jmp 0x78ac
leaq 0x21c8(%rip), %rdi      # 0x9a6a
callq 0x2090
movl $0x1, %ebp
movl %ebp, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x22b0
cmpq %rbx, (%r15)
je 0x7b71
cvtsd2ss %xmm0, %xmm0
movq %r14, %rdi
callq 0x60e0
xorl %eax, %eax
jmp 0x7b87
leaq 0x1d67(%rip), %rdi      # 0x98df
movq %rbx, %rsi
xorl %eax, %eax
callq 0x2030
movl $0x1, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x22b0
cmpq %rbx, (%r15)
je 0x7bdf
cvtsd2ss %xmm0, %xmm0
xorps %xmm1, %xmm1
maxss %xmm0, %xmm1
movss %xmm1, 0x38c(%r14)
xorps %xmm0, %xmm0
cvtss2sd %xmm1, %xmm0
leaq 0x1d3f(%rip), %rdi      # 0x9913
movb $0x1, %al
callq 0x2030
xorl %eax, %eax
jmp 0x7bf5
leaq 0x1d17(%rip), %rdi      # 0x98fd
movq %rbx, %rsi
xorl %eax, %eax
callq 0x2030
movl $0x1, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x22b0
cmpq %rbx, (%r15)
je 0x7c4d
cvtsd2ss %xmm0, %xmm0
xorps %xmm1, %xmm1
maxss %xmm0, %xmm1
movss %xmm1, 0x39c(%r14)
xorps %xmm0, %xmm0
cvtss2sd %xmm1, %xmm0
leaq 0x1d22(%rip), %rdi      # 0x9964
movb $0x1, %al
callq 0x2030
xorl %eax, %eax
jmp 0x7c63
leaq 0x1cec(%rip), %rdi      # 0x9940
movq %rbx, %rsi
xorl %eax, %eax
callq 0x2030
movl $0x1, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x7ca4
testl %eax, %eax
cmovgl %eax, %ebp
movl %ebp, 0x3a0(%rbx)
jle 0x7cbc
leaq 0x1deb(%rip), %rdi      # 0x9a8d
jmp 0x7cc3
leaq 0x1cd9(%rip), %rdi      # 0x9984
movq %r14, %rsi
xorl %eax, %eax
callq 0x2030
movl $0x1, %eax
jmp 0x7cca
leaq 0x1db5(%rip), %rdi      # 0x9a78
callq 0x2090
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x22b0
cmpq %rbx, (%r15)
je 0x7d23
cvtsd2ss %xmm0, %xmm0
xorps %xmm1, %xmm1
maxss %xmm0, %xmm1
movss %xmm1, 0x3a4(%r14)
xorps %xmm0, %xmm0
cvtss2sd %xmm1, %xmm0
leaq 0x1ca8(%rip), %rdi      # 0x99c0
movb $0x1, %al
callq 0x2030
xorl %eax, %eax
jmp 0x7d39
leaq 0x1c7d(%rip), %rdi      # 0x99a7
movq %rbx, %rsi
xorl %eax, %eax
callq 0x2030
movl $0x1, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x7d89
testl %eax, %eax
cmovlel %ebx, %eax
cmpl $0x2, %eax
movl $0x2, %esi
cmovll %eax, %esi
movl %esi, (%r14)
leaq 0x1c86(%rip), %rdi      # 0x9a06
xorl %eax, %eax
callq 0x2030
jmp 0x7d9f
leaq 0x1c54(%rip), %rdi      # 0x99e4
movq %r15, %rsi
xorl %eax, %eax
callq 0x2030
movl $0x1, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1ce9(%rip), %rdi      # 0x9aa1
callq 0x2090
movl $0x208, %ebx            # imm = 0x208
leaq 0x43c7(%rip), %r14      # 0xc190
leaq (%r14,%rbx), %rdi
callq 0x2090
addq $0x408, %rbx            # imm = 0x408
cmpq $0x3268, %rbx           # imm = 0x3268
jne 0x7dc9
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x10b0
leaq 0x20(%rbx), %rax
movq %rax, (%rbp)
movl $0x10, %ecx
movq %r14, %rdi
movq 0xf0(%rsp), %rsi
movq %r13, %rdx
xorl %r8d, %r8d
callq 0x1040
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 0x10f0
movq %r14, %rdi
movq %r12, %rsi
xorl %edx, %edx
movq %r13, %rcx
movl %ebp, %r8d
callq 0x1040
addq %r13, %r12
subq %r13, %r15
jne 0x1265
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 0x10f0
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %r13, %rcx
movl %ebp, %r8d
callq 0x1040
addq %r13, %r14
subq %r13, %rbx
jne 0x12bc
movq (%rsp), %rsi
leaq 0x10(%rsp), %rdi
callq 0x10d0
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_O1/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:
cmpl $0x8, %esi
ja 0x1525
testl %esi, %esi
je 0x1522
movl %esi, %eax
addl $0x3, %esi
andl $0x1c, %esi
decq %rax
vpbroadcastq %rax, %ymm0
vpxor %xmm4, %xmm4, %xmm4
vpmovsxbq 0x1c9d(%rip), %ymm1 # 0x3160
xorl %eax, %eax
vpbroadcastq 0x1c72(%rip), %ymm3 # 0x3140
vmovdqa %ymm4, %ymm2
vpcmpleuq %ymm0, %ymm1, %k1
vmovdqu8 (%rdi,%rax), %xmm4 {%k1} {z}
vpmovzxbq %xmm4, %ymm4    # ymm4 = xmm4[0],zero,zero,zero,zero,zero,zero,zero,xmm4[1],zero,zero,zero,zero,zero,zero,zero,xmm4[2],zero,zero,zero,zero,zero,zero,zero,xmm4[3],zero,zero,zero,zero,zero,zero,zero
vpsllq $0x3, %ymm1, %ymm5
vpsllvq %ymm5, %ymm4, %ymm4
vpxor %ymm2, %ymm4, %ymm4
addq $0x4, %rax
vpaddq %ymm3, %ymm1, %ymm1
cmpq %rax, %rsi
jne 0x14ce
vmovdqa64 %ymm4, %ymm2 {%k1}
vextracti128 $0x1, %ymm2, %xmm0
vpxor %xmm0, %xmm2, %xmm0
vpshufd $0xee, %xmm0, %xmm1     # xmm1 = xmm0[2,3,2,3]
vpxor %xmm1, %xmm0, %xmm0
vmovq %xmm0, %rax
vzeroupper
retq
xorl %eax, %eax
retq
pushq %rax
leaq 0x1c73(%rip), %rdi      # 0x31a0
leaq 0x1c75(%rip), %rsi      # 0x31a9
leaq 0x1c95(%rip), %rcx      # 0x31d0
movl $0x8, %edx
callq 0x1030
// File: /workspace/github_c_makefile_star2_O1/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:
cmpl $0x8, %edx
ja 0x15a2
testl %edx, %edx
je 0x159e
movl %edx, %eax
addl $0x3, %edx
andl $0x1c, %edx
decq %rax
vpbroadcastq %rax, %ymm0
vpbroadcastq %rsi, %ymm1
vpmovsxbq 0x1bf2(%rip), %ymm2 # 0x3160
xorl %eax, %eax
vpbroadcastq 0x1bc7(%rip), %ymm3 # 0x3140
vpcmpleuq %ymm0, %ymm2, %k1
vpsllq $0x3, %ymm2, %ymm4
vpsrlvq %ymm4, %ymm1, %ymm4
vpmovqb %ymm4, (%rdi,%rax) {%k1}
addq $0x4, %rax
vpaddq %ymm3, %ymm2, %ymm2
cmpq %rax, %rdx
jne 0x1579
vzeroupper
retq
pushq %rax
leaq 0x1bf6(%rip), %rdi      # 0x31a0
leaq 0x1bf8(%rip), %rsi      # 0x31a9
leaq 0x1c4d(%rip), %rcx      # 0x3205
movl $0x13, %edx
callq 0x1030
// File: /workspace/github_c_makefile_star2_O1/mjosaarinen[P]brutus/crypto_aead/icepole128v2/ref/icepole.c
// Function: Rho
void Rho(ICESTATE SS, ICESTATE S)
{
    SS[0][0] = S[0][0]; 
    SS[0][1] = ROTL(S[0][1], 36);
    SS[0][2] = ROTL(S[0][2],  3);
    SS[0][3] = ROTL(S[0][3], 41);
    SS[0][4] = ROTL(S[0][4], 18);
    
    SS[1][0] = ROTL(S[1][0],  1); 
    SS[1][1] = ROTL(S[1][1], 44);
    SS[1][2] = ROTL(S[1][2], 10);
    SS[1][3] = ROTL(S[1][3], 45);
    SS[1][4] = ROTL(S[1][4],  2);
    
    SS[2][0] = ROTL(S[2][0], 62); 
    SS[2][1] = ROTL(S[2][1],  6);
    SS[2][2] = ROTL(S[2][2], 43);
    SS[2][3] = ROTL(S[2][3], 15);
    SS[2][4] = ROTL(S[2][4], 61);

    SS[3][0] = ROTL(S[3][0], 28); 
    SS[3][1] = ROTL(S[3][1], 55);
    SS[3][2] = ROTL(S[3][2], 25);
    SS[3][3] = ROTL(S[3][3], 21);
    SS[3][4] = ROTL(S[3][4], 56);
}

// Assembly:
movq (%rsi), %rax
movq %rax, (%rdi)
rorxq $0x1c, 0x8(%rsi), %rax
movq %rax, 0x8(%rdi)
rorxq $0x3d, 0x10(%rsi), %rax
movq %rax, 0x10(%rdi)
rorxq $0x17, 0x18(%rsi), %rax
movq %rax, 0x18(%rdi)
rorxq $0x2e, 0x20(%rsi), %rax
movq %rax, 0x20(%rdi)
rorxq $0x3f, 0x28(%rsi), %rax
movq %rax, 0x28(%rdi)
rorxq $0x14, 0x30(%rsi), %rax
movq %rax, 0x30(%rdi)
rorxq $0x36, 0x38(%rsi), %rax
movq %rax, 0x38(%rdi)
rorxq $0x13, 0x40(%rsi), %rax
movq %rax, 0x40(%rdi)
rorxq $0x3e, 0x48(%rsi), %rax
movq %rax, 0x48(%rdi)
rorxq $0x2, 0x50(%rsi), %rax
movq %rax, 0x50(%rdi)
rorxq $0x3a, 0x58(%rsi), %rax
movq %rax, 0x58(%rdi)
rorxq $0x15, 0x60(%rsi), %rax
movq %rax, 0x60(%rdi)
rorxq $0x31, 0x68(%rsi), %rax
movq %rax, 0x68(%rdi)
rorxq $0x3, 0x70(%rsi), %rax
movq %rax, 0x70(%rdi)
rorxq $0x24, 0x78(%rsi), %rax
movq %rax, 0x78(%rdi)
rorxq $0x9, 0x80(%rsi), %rax
movq %rax, 0x80(%rdi)
rorxq $0x27, 0x88(%rsi), %rax
movq %rax, 0x88(%rdi)
rorxq $0x2b, 0x90(%rsi), %rax
movq %rax, 0x90(%rdi)
rorxq $0x8, 0x98(%rsi), %rax
movq %rax, 0x98(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbx
xorl %eax, %eax
movl $0xcccccccd, %ecx       # imm = 0xCCCCCCCD
movl $0x1, %edx
movq %rax, %r8
xorl %r9d, %r9d
movl %r8d, %r10d
andl $0x3, %r10d
leal (%rdx,%r10), %r11d
movq %r11, %rbx
imulq %rcx, %rbx
shrq $0x22, %rbx
leal (%rbx,%rbx,4), %ebx
subl %ebx, %r11d
movq (%rsi,%r9), %rbx
leaq (%r10,%r10,4), %r10
leaq (%rdi,%r10,8), %r10
movq %rbx, (%r10,%r11,8)
addq $0x8, %r9
incq %r8
incl %edx
cmpq $0x28, %r9
jne 0x18ac
incq %rax
addq $0x28, %rsi
cmpq $0x4, %rax
jne 0x18a1
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x20, %eax
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
cmpq $0xc0, %rax
jne 0x18fc
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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
xorl %r8d, %r8d
movq (%rsi,%r8,8), %r9
movq %r9, (%rcx,%r8,8)
incq %r8
cmpq $0x5, %r8
jne 0x19c8
incq %rax
addq $0x28, %rsi
addq $0x28, %rcx
cmpq $0x4, %rax
jne 0x19c5
movslq %edx, %rax
leaq 0x195c(%rip), %rcx      # 0x3350
movq (%rcx,%rax,8), %rax
xorq %rax, (%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbp
pushq %r14
pushq %rbx
subq $0x280, %rsp            # imm = 0x280
movl %edx, %ebp
movq %rdi, %rbx
leaq 0x1e0(%rsp), %r14
movq %r14, %rdi
callq 0x1070
movq (%r14), %rcx
leaq 0x140(%rsp), %rax
movq %rcx, (%rax)
vmovdqu 0x8(%r14), %ymm0
vprolvq 0x15e6(%rip), %ymm0, %ymm0 # 0x3020
vmovdqu %ymm0, 0x8(%rax)
vmovdqu 0x28(%r14), %ymm0
vprolvq 0x15f1(%rip), %ymm0, %ymm0 # 0x3040
vmovdqu %ymm0, 0x28(%rax)
vmovdqu 0x48(%r14), %ymm0
vprolvq 0x15fc(%rip), %ymm0, %ymm0 # 0x3060
vmovdqu %ymm0, 0x48(%rax)
vmovdqu 0x68(%r14), %ymm0
vprolvq 0x1607(%rip), %ymm0, %ymm0 # 0x3080
vmovdqu %ymm0, 0x68(%rax)
vmovdqu 0x88(%r14), %xmm0
vprolvq 0x16ef(%rip), %xmm0, %xmm0 # 0x3180
vmovdqu %xmm0, 0x88(%rax)
rorxq $0x8, 0x98(%r14), %rcx
movq %rcx, 0x98(%rax)
vpmovsxbq 0x16ad(%rip), %ymm0 # 0x3160
vpbroadcastq 0x168c(%rip), %ymm1 # 0x3148
xorl %ecx, %ecx
vpbroadcastd 0x169d(%rip), %xmm2 # 0x3164
vpcmpeqd %xmm3, %xmm3, %xmm3
vpbroadcastd 0x1694(%rip), %xmm4 # 0x3168
vpmovsxbd 0x1693(%rip), %xmm5 # 0x3170
vpbroadcastd 0x1686(%rip), %xmm6 # 0x316c
vpbroadcastq 0x1661(%rip), %ymm7 # 0x3150
vpbroadcastq 0x1660(%rip), %ymm8 # 0x3158
leaq 0xa0(%rsp), %rdx
vpbroadcastq %rdx, %ymm9
vpbroadcastq 0x1631(%rip), %ymm10 # 0x3140
vpbroadcastq %rcx, %ymm11
xorl %edx, %edx
vmovdqa %ymm0, %ymm12
vpcmpltuq %ymm1, %ymm12, %k1
vpaddq %ymm11, %ymm12, %ymm13
vpmovqd %ymm13, %xmm14
vpand %xmm2, %xmm14, %xmm14
vpmovqd %ymm12, %xmm15
vpaddd %xmm14, %xmm15, %xmm14
vpsubd %xmm3, %xmm14, %xmm14
vpmuludq %xmm4, %xmm14, %xmm15
vpsrlq $0x20, %xmm14, %xmm16
vpmuludq %xmm4, %xmm16, %xmm16
vpermt2d %xmm16, %xmm5, %xmm15
vpandd %xmm6, %xmm15, %xmm16
vpsrld $0x2, %xmm15, %xmm15
vpaddd %xmm16, %xmm15, %xmm15
vmovdqu64 (%rax,%rdx,8), %ymm16 {%k1} {z}
vpsubd %xmm15, %xmm14, %xmm14
vpand %ymm7, %ymm13, %ymm13
vpmuldq %ymm8, %ymm13, %ymm13
vpaddq %ymm13, %ymm9, %ymm13
vpmovzxdq %xmm14, %ymm14  # ymm14 = xmm14[0],zero,xmm14[1],zero,xmm14[2],zero,xmm14[3],zero
vpsllq $0x3, %ymm14, %ymm14
vpaddq %ymm14, %ymm13, %ymm13
vpscatterqq %ymm16, (,%ymm13) {%k1}
addq $0x4, %rdx
vpaddq %ymm10, %ymm12, %ymm12
cmpq $0x8, %rdx
jne 0x1b1b
incq %rcx
addq $0x28, %rax
cmpq $0x4, %rcx
jne 0x1b0f
movq %rsp, %rdi
leaq 0xa0(%rsp), %rsi
vzeroupper
callq 0x10c0
xorl %eax, %eax
movq 0x20(%rsp,%rax), %rcx
movq %rcx, 0x20(%rbx,%rax)
vmovdqu (%rsp,%rax), %ymm0
vmovdqu %ymm0, (%rbx,%rax)
addq $0x28, %rax
cmpq $0xa0, %rax
jne 0x1bd7
movslq %ebp, %rax
leaq 0x174f(%rip), %rcx      # 0x3350
movq (%rcx,%rax,8), %rax
xorq %rax, (%rbx)
addq $0x280, %rsp            # imm = 0x280
popq %rbx
popq %r14
popq %rbp
vzeroupper
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x10e0
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0x10e0
movq %r14, %rdi
movq %r15, %rsi
movl $0x2, %edx
callq 0x10e0
movq %r15, %rdi
movq %r14, %rsi
movl $0x3, %edx
callq 0x10e0
movq %r14, %rdi
movq %r15, %rsi
movl $0x4, %edx
callq 0x10e0
movq %rbx, %rdi
movq %r14, %rsi
movl $0x5, %edx
callq 0x10e0
addq $0x140, %rsp            # imm = 0x140
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x10e0
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0x10e0
movq %r14, %rdi
movq %r15, %rsi
movl $0x2, %edx
callq 0x10e0
movq %r15, %rdi
movq %r14, %rsi
movl $0x3, %edx
callq 0x10e0
movq %r14, %rdi
movq %r15, %rsi
movl $0x4, %edx
callq 0x10e0
movq %r15, %rdi
movq %r14, %rsi
movl $0x5, %edx
callq 0x10e0
movq %r14, %rdi
movq %r15, %rsi
movl $0x6, %edx
callq 0x10e0
movq %r15, %rdi
movq %r14, %rsi
movl $0x7, %edx
callq 0x10e0
movq %r14, %rdi
movq %r15, %rsi
movl $0x8, %edx
callq 0x10e0
movq %r15, %rdi
movq %r14, %rsi
movl $0x9, %edx
callq 0x10e0
movq %r14, %rdi
movq %r15, %rsi
movl $0xa, %edx
callq 0x10e0
movq %rbx, %rdi
movq %r14, %rsi
movl $0xb, %edx
callq 0x10e0
addq $0x140, %rsp            # imm = 0x140
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x20e4
movq %rcx, %r15
movq %rsi, %r12
orl $0x2, %r8d
xorl %ebx, %ebx
movq %r8, 0x8(%rsp)
cmpq $0x8, %r15
movl $0x8, %ebp
cmovbq %r15, %rbp
movq %r12, %rdi
movl %ebp, %esi
movq %rdx, %r13
callq 0x1080
movq %r13, %rdx
movl %ebx, %esi
andl $0x3, %esi
movl %ebx, %ecx
shrl $0x2, %ecx
leaq (%rsi,%rsi,4), %rdi
movq (%rsp), %rsi
leaq (%rsi,%rdi,8), %rsi
leaq (%rsi,%rcx,8), %r14
testq %r13, %r13
je 0x2096
movq (%r14), %rsi
xorq %rax, %rsi
movq %rax, 0x10(%rsp)
movq (%rdx), %rdi
movl %ebp, %edx
callq 0x1100
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 0x2039
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1150(%rip), %rdi      # 0x323b
leaq 0x10b7(%rip), %rsi      # 0x31a9
leaq 0x1162(%rip), %rcx      # 0x325b
movl $0xeb, %edx
callq 0x1030
// File: /workspace/github_c_makefile_star2_O1/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 $0x38, %rsp
movq %rdx, 0x8(%rsp)
movq %rdi, 0x10(%rsp)
cmpq $0x80, %rcx
ja 0x2216
movq %rcx, %r15
orl $0x2, %r8d
xorl %ebx, %ebx
movq %r8, 0x18(%rsp)
cmpq $0x8, %r15
movl $0x8, %ebp
cmovbq %r15, %rbp
leal (,%rbp,8), %ecx
cmpq $0x8, %r15
movq $-0x1, %rax
movq %rcx, 0x28(%rsp)
shlxq %rcx, %rax, %r12
notq %r12
cmovaeq %rax, %r12
movq %rsi, 0x30(%rsp)
movq %rsi, %rdi
movl %ebp, %esi
callq 0x1080
movq %rax, %r13
movl %ebx, %eax
andl $0x3, %eax
movl %ebx, %r14d
shrl $0x2, %r14d
leaq (%rax,%rax,4), %rax
movq 0x10(%rsp), %rcx
leaq (%rcx,%rax,8), %rax
xorq (%rax,%r14,8), %r13
andq %r12, %r13
cmpq $0x0, 0x8(%rsp)
je 0x21c1
movq 0x8(%rsp), %r12
movq (%r12), %rdi
movq %r13, %rsi
movl %ebp, %edx
movq %rax, 0x20(%rsp)
callq 0x1100
movq 0x20(%rsp), %rax
addq %rbp, (%r12)
leaq (%rax,%r14,8), %rax
cmpq $0x8, %r15
movq 0x18(%rsp), %r8
movq 0x28(%rsp), %rcx
shlxq %rcx, %r8, %rcx
movl $0x0, %edx
cmovaeq %rdx, %rcx
xorq (%rax), %rcx
xorq %r13, %rcx
incl %ebx
movq 0x30(%rsp), %rsi
addq %rbp, %rsi
movq %r15, %rdx
subq %rbp, %rdx
movq %rcx, (%rax)
cmpq $0x7, %r15
movq %rdx, %r15
ja 0x2136
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x101e(%rip), %rdi      # 0x323b
leaq 0xf85(%rip), %rsi       # 0x31a9
leaq 0x10a2(%rip), %rcx      # 0x32cd
movl $0x111, %edx            # imm = 0x111
callq 0x1030
// File: /workspace/github_c_makefile_star2_O1/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 0x2180
testq %rax, %rax
je 0x23ed
movq %rax, %rbx
movl $0xfc0, %edx            # imm = 0xFC0
movq %rax, %rdi
xorl %esi, %esi
callq 0x2100
movq 0xdcde(%rip), %rax      # 0x10080
movq %rax, (%rbx)
movq %rbx, 0xdcd4(%rip)      # 0x10080
movl $0x3e8, 0x18(%rbx)      # imm = 0x3E8
callq 0x2b84
cmpl $0x3e9, 0xd4d2(%rip)    # imm = 0x3E9
jne 0x23d9
leaq 0xdcc5(%rip), %rdi      # 0x10090
callq 0x2210
movq %rax, 0x8(%rbx)
callq 0x2b84
cmpl $0x3b, 0xd4b4(%rip)     # 0xf894
jne 0x23f7
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2b84
movl $0x1, %edi
callq 0x21f0
leaq 0x8ffe(%rip), %rdi      # 0xb3fc
callq 0x25f2
// File: /workspace/github_c_makefile_star2_O1/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 0x8bf4(%rip), %rbx      # 0xb004
cmpl $0x3e9, 0xd47a(%rip)    # imm = 0x3E9
jne 0x2449
movq 0xd475(%rip), %rax      # 0xf898
incq %rax
movzbl -0x1(%rax), %ecx
cmpl $0x9, %ecx
je 0x2434
cmpl $0x20, %ecx
jne 0x243d
movq %rax, 0xd45d(%rip)      # 0xf898
jmp 0x2423
cmpl $0x3d, %ecx
jne 0x2449
callq 0x24f1
jmp 0x2410
callq 0x2593
movl 0xd440(%rip), %eax      # 0xf894
cmpl $0x146, %eax            # imm = 0x146
jg 0x247d
leal -0x135(%rax), %ecx
cmpl $0x6, %ecx
ja 0x248d
movslq (%rbx,%rcx,4), %rax
addq %rbx, %rax
jmpq *%rax
callq 0x2927
jmp 0x2410
callq 0x27da
jmp 0x2410
cmpl $0x14a, %eax            # imm = 0x14A
je 0x249b
cmpl $0x147, %eax            # imm = 0x147
jne 0x2491
jmp 0x249b
testl %eax, %eax
je 0x249b
callq 0x2ac5
jmp 0x2410
cmpb $0x0, 0xcf9e(%rip)      # 0xf440
je 0x24c3
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2669
cmpb $0x0, 0xcf8a(%rip)      # 0xf440
jne 0x24cf
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x271a
leaq 0x8ee4(%rip), %rdi      # 0xb3ae
callq 0x25f2
callq 0xa74a
leaq 0x8ee7(%rip), %rdi      # 0xb3c2
callq 0x4081
leaq 0x136f9(%rip), %rdi     # 0x15be0
movl $0x1, %esi
callq 0x21b0
// File: /workspace/github_c_makefile_star2_O1/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 0xdb81(%rip), %rbx      # 0x10080
movslq 0x10(%rbx), %r14
cmpq $0x64, %r14
je 0x2563
leaq 0xdb80(%rip), %rdi      # 0x10090
callq 0x2210
leaq (%r14,%r14,4), %rcx
movq %rax, 0x20(%rbx,%rcx,8)
callq 0x2b84
callq 0x2b84
callq 0x3951
cmpl $0x3b, 0xd360(%rip)     # 0xf894
jne 0x2571
callq 0x2b84
movl $0xb, %edi
callq 0x2bf7
movq 0xdb34(%rip), %rax      # 0x10080
movl 0x10(%rax), %edi
callq 0x2bf7
movq 0xdb25(%rip), %rax      # 0x10080
incl 0x10(%rax)
popq %rbx
popq %r14
popq %rbp
retq
callq 0xa74a
leaq 0x8e7a(%rip), %rdi      # 0xb3e9
jmp 0x257d
callq 0xa74a
leaq 0x8f87(%rip), %rdi      # 0xb504
callq 0x4081
leaq 0x13657(%rip), %rdi     # 0x15be0
movl $0x1, %esi
callq 0x21b0
// File: /workspace/github_c_makefile_star2_O1/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, 0xd2f7(%rip)    # imm = 0x3E9
jne 0x25f1
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl $0x8, %r14d
leaq 0xcbca(%rip), %r15      # 0xf180
leaq 0xdad3(%rip), %rbx      # 0x10090
movq -0x8(%r14,%r15), %rsi
movq %rbx, %rdi
callq 0x2160
testl %eax, %eax
je 0x25dd
addq $0x10, %r14
cmpq $0x2a8, %r14            # imm = 0x2A8
jne 0x25bd
jmp 0x25e7
movl (%r14,%r15), %eax
movl %eax, 0xd2ad(%rip)      # 0xf894
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xd295(%rip), %eax      # 0xf894
leaq 0xd2aa(%rip), %rdi      # 0xf8b0
cmpl $0x3b, %eax
je 0x2618
testl %eax, %eax
jne 0x262d
leaq 0x94b3(%rip), %rdx      # 0xbac9
jmp 0x261f
leaq 0x94cc(%rip), %rdx      # 0xbaeb
movl $0x7d0, %esi            # imm = 0x7D0
xorl %eax, %eax
callq 0x20e0
jmp 0x2647
leaq 0x94db(%rip), %rdx      # 0xbb0f
leaq 0xda55(%rip), %r8       # 0x10090
movl $0x7d0, %esi            # imm = 0x7D0
xorl %eax, %eax
callq 0x20e0
callq 0xa74a
leaq 0xd25d(%rip), %rdi      # 0xf8b0
callq 0x4081
leaq 0x13581(%rip), %rdi     # 0x15be0
movl $0x1, %esi
callq 0x21b0
// File: /workspace/github_c_makefile_star2_O1/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 0xcdca(%rip), %rdi      # 0xf440
leaq 0x9234(%rip), %rsi      # 0xb8b1
callq 0x21d0
movq %rax, 0xd217(%rip)      # 0xf8a0
testq %rax, %rax
je 0x26b1
callq 0x2b54
movq 0xd206(%rip), %rdi      # 0xf8a0
callq 0x20a0
movq $0x0, 0xd1f6(%rip) # 0xf8a0
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0xd1f8(%rip), %rbx      # 0xf8b0
leaq 0x8d1b(%rip), %rdx      # 0xb3da
leaq 0xcd7a(%rip), %rcx      # 0xf440
movl $0x7d0, %esi            # imm = 0x7D0
movq %rbx, %rdi
xorl %eax, %eax
callq 0x20e0
callq 0xa74a
movq %rbx, %rdi
callq 0x4081
leaq 0x134f7(%rip), %rdi     # 0x15be0
movl $0x1, %esi
callq 0x21b0
// File: /workspace/github_c_makefile_star2_O1/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 (%rax), %rsi
movq 0xd16b(%rip), %rcx      # 0xf898
movsbq (%rcx), %rdx
movzwl (%rsi,%rdx,2), %esi
btl $0xd, %esi
jae 0x277a
movzbl %dl, %esi
cmpl $0xa, %esi
je 0x277a
cmpl $0xd, %esi
je 0x277a
incq %rcx
movq %rcx, %rsi
movq %rsi, %rcx
movq %rsi, 0xd140(%rip)      # 0xf898
movq (%rax), %rsi
movsbq (%rcx), %rdx
movzwl (%rsi,%rdx,2), %esi
btl $0xd, %esi
jae 0x277a
movzbl %dl, %edi
cmpl $0xd, %edi
je 0x277a
leaq 0x1(%rcx), %rsi
cmpl $0xa, %edi
jne 0x274e
cmpb $0x3b, %dl
jne 0x27aa
incq %rcx
movq %rcx, 0xd10f(%rip)      # 0xf898
movq (%rax), %rsi
movsbq (%rcx), %rdx
movzwl (%rsi,%rdx,2), %esi
btl $0xd, %esi
jae 0x27aa
movzbl %dl, %edx
cmpl $0xd, %edx
je 0x27aa
incq %rcx
cmpl $0xa, %edx
jne 0x2782
movq 0xd0e7(%rip), %rax      # 0xf898
movzbl (%rax), %eax
cmpl $0xa, %eax
je 0x27be
cmpl $0xd, %eax
jne 0x27c9
callq 0x2b54
popq %rbp
jmp 0x2b84
callq 0x2b84
leaq 0x8c99(%rip), %rdi      # 0xb46e
callq 0x25f2
// File: /workspace/github_c_makefile_star2_O1/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 %r12
pushq %rbx
callq 0x2b84
leaq 0xd89f(%rip), %rbx      # 0x10090
movl 0xd09d(%rip), %eax      # 0xf894
cmpl $0x3e9, %eax            # imm = 0x3E9
jne 0x28b7
movq 0xd877(%rip), %r15      # 0x10080
movslq 0x10(%r15), %r14
cmpq $0x64, %r14
je 0x28ef
leal 0x1(%r14), %eax
movl %eax, 0x10(%r15)
movq %rbx, %rdi
callq 0x2210
leaq (,%r14,8), %rcx
leaq (%rcx,%rcx,4), %r12
movq %rax, 0x20(%r15,%r12)
callq 0x2b84
movq 0xd83c(%rip), %r15      # 0x10080
cmpl $0x24, 0xd049(%rip)     # 0xf894
leaq 0x28(%r15,%r12), %rax
jne 0x289d
addq $0x20, %r15
movl $0xa, (%rax)
leaq (%r14,%r14,4), %r12
movl $0x0, 0xc(%r15,%r12,8)
movl $0x50, %edi
callq 0x2180
testq %rax, %rax
je 0x2911
movq %rax, 0x10(%r15,%r12,8)
movl $0x1, %edi
callq 0x2bf7
movl %r14d, %edi
callq 0x2bf7
callq 0x2b84
jmp 0x27f1
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
xorl %edi, %edi
callq 0x2bf7
movl %r14d, %edi
callq 0x2bf7
jmp 0x27f1
cmpl $0x3ec, %eax            # imm = 0x3EC
jne 0x28cf
movl $0xd, %edi
callq 0x2bf7
callq 0x2b84
jmp 0x28d9
movl $0xc, %edi
callq 0x2bf7
cmpl $0x3b, 0xcfb4(%rip)     # 0xf894
jne 0x291b
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2b84
callq 0xa74a
leaq 0x8aee(%rip), %rdi      # 0xb3e9
callq 0x4081
leaq 0x132d9(%rip), %rdi     # 0x15be0
movl $0x1, %esi
callq 0x21b0
movl $0x1, %edi
callq 0x21f0
leaq 0x91dc(%rip), %rdi      # 0xbafe
callq 0x25f2