LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/radforddc[P]icpc_siggen/signal_tester.c
// Function: rl_gets
static int rl_gets(char *line, int MAX_LEN){
  static char *line_read = (char *) NULL;

  if (line_read != NULL){
    FREE(line_read);
    line_read = (char *) NULL;
  }

  line_read = readline(PROMPT);
  if (line_read != NULL && *line_read != '\0'){
    add_history(line_read);
  }
  strncpy(line,line_read,MAX_LEN);
  line[MAX_LEN -1] = '\0';
  FREE(line_read);

  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpq $0x0, 0x95b9(%rip)      # 0x14220
je 0xac8d
jmp 0xac6b
movq 0x95ae(%rip), %rdi      # 0x14220
callq 0x2110
movq $0x0, 0x959e(%rip) # 0x14220
movq $0x0, 0x9593(%rip) # 0x14220
leaq 0x3e28(%rip), %rdi      # 0xeabc
callq 0x21c0
movq %rax, 0x9580(%rip)      # 0x14220
cmpq $0x0, 0x9578(%rip)      # 0x14220
je 0xacc5
movq 0x956f(%rip), %rax      # 0x14220
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0xacc5
movq 0x9560(%rip), %rdi      # 0x14220
callq 0x2230
movq -0x8(%rbp), %rdi
movq 0x9550(%rip), %rsi      # 0x14220
movslq -0xc(%rbp), %rdx
callq 0x21f0
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
movq 0x952f(%rip), %rdi      # 0x14220
callq 0x2110
movq $0x0, 0x951f(%rip) # 0x14220
movl $0x1, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, 0x8f40(%rip)      # 0x14218
jne 0xb317
movq -0x18(%rbp), %rax
movslq 0x3ac(%rax), %rdi
shlq $0x2, %rdi
callq 0x20b0
movq %rax, 0x8f23(%rip)      # 0x14218
cmpq $0x0, %rax
jne 0xb315
leaq 0x3474(%rip), %rdi      # 0xe776
movb $0x0, %al
callq 0x2030
movl $0x1, -0x4(%rbp)
jmp 0xb427
jmp 0xb317
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x3a8(%rax), %edx
leaq -0x24(%rbp), %rsi
callq 0xbc40
cmpl $0x0, %eax
jg 0xb33f
movl $0x1, -0x4(%rbp)
jmp 0xb427
movq 0x8ed2(%rip), %rdi      # 0x14218
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %eax
movl %eax, -0x30(%rbp)
movq -0x24(%rbp), %rax
movq %rax, -0x38(%rbp)
movsd -0x38(%rbp), %xmm0
movss -0x30(%rbp), %xmm1
callq 0x2670
cmpl $0x0, %eax
jge 0xb3a1
movss -0x24(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movss -0x20(%rbp), %xmm1
cvtss2sd %xmm1, %xmm1
movss -0x1c(%rbp), %xmm2
cvtss2sd %xmm2, %xmm2
leaq 0x340e(%rip), %rdi      # 0xe79c
movb $0x3, %al
callq 0x2030
movl $0x1, -0x4(%rbp)
jmp 0xb427
leaq 0x3514(%rip), %rdi      # 0xe8bc
movb $0x0, %al
callq 0x2030
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x3ac(%rcx), %eax
jge 0xb412
movq 0x8e4c(%rip), %rax      # 0x14218
movslq -0x28(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0x34e6(%rip), %rdi      # 0xe8c6
movb $0x1, %al
callq 0x2030
movl -0x28(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
cmpl $0x9, %edx
jne 0xb405
leaq 0x329d(%rip), %rdi      # 0xe69b
movb $0x0, %al
callq 0x2030
jmp 0xb407
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0xb3b6
leaq 0x3282(%rip), %rdi      # 0xe69b
movb $0x0, %al
callq 0x2030
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x2280
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x1c(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x10(%rbp), %rax
jne 0xb89b
movq -0x10(%rbp), %rsi
leaq 0x30af(%rip), %rdi      # 0xe93a
movb $0x0, %al
callq 0x2030
movl $0x1, -0x4(%rbp)
jmp 0xb8b0
movss -0x1c(%rbp), %xmm0
movq -0x18(%rbp), %rdi
callq 0x8880
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x2280
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x1c(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x10(%rbp), %rax
jne 0xb90b
movq -0x10(%rbp), %rsi
leaq 0x305d(%rip), %rdi      # 0xe958
movb $0x0, %al
callq 0x2030
movl $0x1, -0x4(%rbp)
jmp 0xb952
xorps %xmm0, %xmm0
ucomiss -0x1c(%rbp), %xmm0
jbe 0xb91c
xorps %xmm0, %xmm0
movss %xmm0, -0x1c(%rbp)
movss -0x1c(%rbp), %xmm0
movq -0x18(%rbp), %rax
movss %xmm0, 0x38c(%rax)
movq -0x18(%rbp), %rax
movss 0x38c(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0x302a(%rip), %rdi      # 0xe96e
movb $0x1, %al
callq 0x2030
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x2280
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x1c(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x10(%rbp), %rax
jne 0xb9ab
movq -0x10(%rbp), %rsi
leaq 0x3000(%rip), %rdi      # 0xe99b
movb $0x0, %al
callq 0x2030
movl $0x1, -0x4(%rbp)
jmp 0xb9f2
xorps %xmm0, %xmm0
ucomiss -0x1c(%rbp), %xmm0
jbe 0xb9bc
xorps %xmm0, %xmm0
movss %xmm0, -0x1c(%rbp)
movss -0x1c(%rbp), %xmm0
movq -0x18(%rbp), %rax
movss %xmm0, 0x39c(%rax)
movq -0x18(%rbp), %rax
movss 0x39c(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0x2fdb(%rip), %rdi      # 0xe9bf
movb $0x1, %al
callq 0x2030
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
xorl %edx, %edx
callq 0x21a0
movl %eax, -0x1c(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x10(%rbp), %rax
jne 0xba47
movq -0x10(%rbp), %rsi
leaq 0x2fa8(%rip), %rdi      # 0xe9df
movb $0x0, %al
callq 0x2030
movl $0x1, -0x4(%rbp)
jmp 0xba8c
cmpl $0x0, -0x1c(%rbp)
jge 0xba54
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x3a0(%rax)
cmpl $0x0, -0x1c(%rbp)
jle 0xba77
leaq 0x2f94(%rip), %rdi      # 0xea02
movb $0x0, %al
callq 0x2030
jmp 0xba85
leaq 0x2f99(%rip), %rdi      # 0xea17
movb $0x0, %al
callq 0x2030
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x2280
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x1c(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x10(%rbp), %rax
jne 0xbaeb
movq -0x10(%rbp), %rsi
leaq 0x2f52(%rip), %rdi      # 0xea2d
movb $0x0, %al
callq 0x2030
movl $0x1, -0x4(%rbp)
jmp 0xbb2b
xorps %xmm0, %xmm0
ucomiss -0x1c(%rbp), %xmm0
jbe 0xbafc
xorps %xmm0, %xmm0
movss %xmm0, -0x1c(%rbp)
movss -0x1c(%rbp), %xmm0
movq -0x18(%rbp), %rax
movss %xmm0, 0x3a4(%rax)
movss -0x1c(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0x2f29(%rip), %rdi      # 0xea46
movb $0x1, %al
callq 0x2030
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
xorl %edx, %edx
callq 0x21a0
movl %eax, -0x1c(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x10(%rbp), %rax
jne 0xbb87
movq -0x10(%rbp), %rsi
leaq 0x2ef3(%rip), %rdi      # 0xea6a
movb $0x0, %al
callq 0x2030
movl $0x1, -0x4(%rbp)
jmp 0xbbc2
cmpl $0x0, -0x1c(%rbp)
jge 0xbb94
movl $0x0, -0x1c(%rbp)
cmpl $0x2, -0x1c(%rbp)
jle 0xbba1
movl $0x2, -0x1c(%rbp)
movl -0x1c(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl -0x1c(%rbp), %esi
leaq 0x2ed8(%rip), %rdi      # 0xea8c
movb $0x0, %al
callq 0x2030
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x2ec0(%rip), %rdi      # 0xeaa7
movb $0x0, %al
callq 0x2030
movl $0x0, -0x14(%rbp)
cmpl $0xc, -0x14(%rbp)
jge 0xbc30
movslq -0x14(%rbp), %rax
leaq 0x556a(%rip), %rsi      # 0x11170
imulq $0x408, %rax, %rax      # imm = 0x408
addq %rax, %rsi
addq $0x208, %rsi            # imm = 0x208
leaq 0x2b16(%rip), %rdi      # 0xe734
movb $0x0, %al
callq 0x2030
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xbbf5
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq $0x0, 0x10(%rsp)
cmpl $0x8, 0x1c(%rsp)
ja 0x175f
jmp 0x177e
leaq 0x289a(%rip), %rdi      # 0x4000
leaq 0x289c(%rip), %rsi      # 0x4009
movl $0x8, %edx
leaq 0x28b7(%rip), %rcx      # 0x4030
callq 0x1040
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jae 0x17c8
movq 0x10(%rsp), %rax
movq 0x20(%rsp), %rcx
movl 0xc(%rsp), %edx
movzbl (%rcx,%rdx), %ecx
movl %ecx, %edx
movl 0xc(%rsp), %ecx
shll $0x3, %ecx
movl %ecx, %ecx
shlq %cl, %rdx
movq %rdx, %rcx
xorq %rcx, %rax
movq %rax, 0x10(%rsp)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x1786
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movl %edx, 0x4(%rsp)
cmpl $0x8, 0x4(%rsp)
ja 0x17fb
jmp 0x181a
leaq 0x27fe(%rip), %rdi      # 0x4000
leaq 0x2800(%rip), %rsi      # 0x4009
movl $0x13, %edx
leaq 0x2850(%rip), %rcx      # 0x4065
callq 0x1040
movl $0x0, (%rsp)
movl (%rsp), %eax
cmpl 0x4(%rsp), %eax
jae 0x1852
movq 0x8(%rsp), %rax
movl (%rsp), %ecx
shll $0x3, %ecx
movl %ecx, %ecx
shrq %cl, %rax
movb %al, %dl
movq 0x10(%rsp), %rax
movl (%rsp), %ecx
movb %dl, (%rax,%rcx)
movl (%rsp), %eax
addl $0x1, %eax
movl %eax, (%rsp)
jmp 0x1821
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl $0x0, -0x14(%rsp)
cmpl $0x4, -0x14(%rsp)
jae 0x2022
movl $0x0, -0x18(%rsp)
cmpl $0x5, -0x18(%rsp)
jae 0x2010
movl -0x14(%rsp), %eax
addl -0x18(%rsp), %eax
andl $0x3, %eax
movl %eax, -0x1c(%rsp)
movl -0x1c(%rsp), %eax
addl -0x18(%rsp), %eax
addl $0x1, %eax
movl $0x5, %ecx
xorl %edx, %edx
divl %ecx
movl %edx, -0x20(%rsp)
movq -0x10(%rsp), %rax
movl -0x14(%rsp), %ecx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movl -0x18(%rsp), %ecx
movq (%rax,%rcx,8), %rdx
movq -0x8(%rsp), %rax
movl -0x1c(%rsp), %ecx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movl -0x20(%rsp), %ecx
movq %rdx, (%rax,%rcx,8)
movl -0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rsp)
jmp 0x1fa5
jmp 0x2012
movl -0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rsp)
jmp 0x1f92
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movl %edx, 0x74(%rsp)
leaq 0x10(%rsp), %rdi
leaq 0x1e5c(%rip), %rsi      # 0x41b0
movl $0x60, %edx
callq 0x1150
movl $0x0, 0xc(%rsp)
cmpl $0x4, 0xc(%rsp)
jae 0x23cb
movl $0x0, 0x8(%rsp)
cmpl $0x5, 0x8(%rsp)
jae 0x23bc
movq 0x78(%rsp), %rax
movl 0xc(%rsp), %ecx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movl 0x8(%rsp), %ecx
movq (%rax,%rcx,8), %rdx
movq 0x80(%rsp), %rax
movl 0xc(%rsp), %ecx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movl 0x8(%rsp), %ecx
movq %rdx, (%rax,%rcx,8)
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x2375
jmp 0x23be
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x2366
movq 0x80(%rsp), %rax
movq (%rax), %rcx
movslq 0x74(%rsp), %rax
xorq 0x10(%rsp,%rax,8), %rcx
movq 0x80(%rsp), %rax
movq %rcx, (%rax)
addq $0x88, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x298, %rsp            # imm = 0x298
movq %rdi, 0x290(%rsp)
movq %rsi, 0x288(%rsp)
movl %edx, 0x284(%rsp)
leaq 0x1e0(%rsp), %rdi
movq 0x288(%rsp), %rsi
callq 0x1080
leaq 0x140(%rsp), %rdi
leaq 0x1e0(%rsp), %rsi
callq 0x1030
leaq 0xa0(%rsp), %rdi
leaq 0x140(%rsp), %rsi
callq 0x10e0
movq %rsp, %rdi
leaq 0xa0(%rsp), %rsi
callq 0x10d0
movq 0x290(%rsp), %rdi
movq %rsp, %rsi
movl 0x284(%rsp), %edx
callq 0x1140
addq $0x298, %rsp            # imm = 0x298
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x158, %rsp            # imm = 0x158
movq %rdi, 0x150(%rsp)
movq %rsi, 0x148(%rsp)
leaq 0xa0(%rsp), %rdi
movq 0x148(%rsp), %rsi
xorl %edx, %edx
callq 0x1100
movq %rsp, %rdi
leaq 0xa0(%rsp), %rsi
movl $0x1, %edx
callq 0x1100
leaq 0xa0(%rsp), %rdi
movq %rsp, %rsi
movl $0x2, %edx
callq 0x1100
movq %rsp, %rdi
leaq 0xa0(%rsp), %rsi
movl $0x3, %edx
callq 0x1100
leaq 0xa0(%rsp), %rdi
movq %rsp, %rsi
movl $0x4, %edx
callq 0x1100
movq 0x150(%rsp), %rdi
leaq 0xa0(%rsp), %rsi
movl $0x5, %edx
callq 0x1100
addq $0x158, %rsp            # imm = 0x158
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x158, %rsp            # imm = 0x158
movq %rdi, 0x150(%rsp)
movq %rsi, 0x148(%rsp)
leaq 0xa0(%rsp), %rdi
movq 0x148(%rsp), %rsi
xorl %edx, %edx
callq 0x1100
movq %rsp, %rdi
leaq 0xa0(%rsp), %rsi
movl $0x1, %edx
callq 0x1100
leaq 0xa0(%rsp), %rdi
movq %rsp, %rsi
movl $0x2, %edx
callq 0x1100
movq %rsp, %rdi
leaq 0xa0(%rsp), %rsi
movl $0x3, %edx
callq 0x1100
leaq 0xa0(%rsp), %rdi
movq %rsp, %rsi
movl $0x4, %edx
callq 0x1100
movq %rsp, %rdi
leaq 0xa0(%rsp), %rsi
movl $0x5, %edx
callq 0x1100
leaq 0xa0(%rsp), %rdi
movq %rsp, %rsi
movl $0x6, %edx
callq 0x1100
movq %rsp, %rdi
leaq 0xa0(%rsp), %rsi
movl $0x7, %edx
callq 0x1100
leaq 0xa0(%rsp), %rdi
movq %rsp, %rsi
movl $0x8, %edx
callq 0x1100
movq %rsp, %rdi
leaq 0xa0(%rsp), %rsi
movl $0x9, %edx
callq 0x1100
leaq 0xa0(%rsp), %rdi
movq %rsp, %rsi
movl $0xa, %edx
callq 0x1100
movq 0x150(%rsp), %rdi
leaq 0xa0(%rsp), %rsi
movl $0xb, %edx
callq 0x1100
addq $0x158, %rsp            # imm = 0x158
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movl %r8d, 0x34(%rsp)
movl $0x0, 0x10(%rsp)
cmpq $0x80, 0x38(%rsp)
ja 0x2a82
jmp 0x2aa1
leaq 0x1612(%rip), %rdi      # 0x409b
leaq 0x1579(%rip), %rsi      # 0x4009
movl $0xeb, %edx
leaq 0x161f(%rip), %rcx      # 0x40bb
callq 0x1040
jmp 0x2aa3
cmpq $0x8, 0x38(%rsp)
jae 0x2ab6
movq 0x38(%rsp), %rax
movl %eax, 0xc(%rsp)
jmp 0x2ac1
movl $0x8, %eax
movl %eax, 0xc(%rsp)
jmp 0x2ac1
movl 0xc(%rsp), %eax
movl %eax, 0x14(%rsp)
movq 0x48(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x1090
movq %rax, 0x28(%rsp)
movq 0x50(%rsp), %rax
movl 0x10(%rsp), %ecx
andl $0x3, %ecx
movl %ecx, %ecx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movl 0x10(%rsp), %ecx
shrl $0x2, %ecx
movl %ecx, %ecx
movq (%rax,%rcx,8), %rax
xorq 0x28(%rsp), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x40(%rsp)
je 0x2b3a
movq 0x40(%rsp), %rax
movq (%rax), %rdi
movq 0x20(%rsp), %rsi
movl 0x14(%rsp), %edx
callq 0x1120
movl 0x14(%rsp), %edx
movq 0x40(%rsp), %rax
movq (%rax), %rcx
movl %edx, %edx
addq %rdx, %rcx
movq %rcx, (%rax)
cmpl $0x8, 0x14(%rsp)
jae 0x2b5b
movl 0x34(%rsp), %eax
orq $0x2, %rax
movl 0x14(%rsp), %ecx
shll $0x3, %ecx
movl %ecx, %ecx
shlq %cl, %rax
movq %rax, (%rsp)
jmp 0x2b63
xorl %eax, %eax
movq %rax, (%rsp)
jmp 0x2b63
movq (%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rdx
xorq 0x18(%rsp), %rdx
movq 0x50(%rsp), %rax
movl 0x10(%rsp), %ecx
andl $0x3, %ecx
movl %ecx, %ecx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movl 0x10(%rsp), %ecx
shrl $0x2, %ecx
movl %ecx, %ecx
xorq (%rax,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
movl 0x14(%rsp), %ecx
movq 0x48(%rsp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, 0x48(%rsp)
movl 0x14(%rsp), %eax
movl %eax, %ecx
movq 0x38(%rsp), %rax
subq %rcx, %rax
movq %rax, 0x38(%rsp)
cmpl $0x8, 0x14(%rsp)
je 0x2aa3
addq $0x58, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movl %r8d, 0x44(%rsp)
movl $0x0, 0x18(%rsp)
cmpq $0x80, 0x48(%rsp)
ja 0x2c12
jmp 0x2c31
leaq 0x1482(%rip), %rdi      # 0x409b
leaq 0x13e9(%rip), %rsi      # 0x4009
movl $0x111, %edx            # imm = 0x111
leaq 0x1501(%rip), %rcx      # 0x412d
callq 0x1040
jmp 0x2c33
cmpq $0x8, 0x48(%rsp)
jae 0x2c46
movq 0x48(%rsp), %rax
movl %eax, 0x14(%rsp)
jmp 0x2c51
movl $0x8, %eax
movl %eax, 0x14(%rsp)
jmp 0x2c51
movl 0x14(%rsp), %eax
movl %eax, 0x1c(%rsp)
movq 0x58(%rsp), %rdi
movl 0x1c(%rsp), %esi
callq 0x1090
movq %rax, 0x38(%rsp)
movq 0x60(%rsp), %rax
movl 0x18(%rsp), %ecx
andl $0x3, %ecx
movl %ecx, %ecx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movl 0x18(%rsp), %ecx
shrl $0x2, %ecx
movl %ecx, %ecx
movq (%rax,%rcx,8), %rax
xorq 0x38(%rsp), %rax
movq %rax, 0x30(%rsp)
cmpl $0x8, 0x1c(%rsp)
jne 0x2ca8
xorl %eax, %eax
movq %rax, 0x8(%rsp)
jmp 0x2cc0
movl 0x1c(%rsp), %eax
shll $0x3, %eax
movl %eax, %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
subq $0x1, %rax
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rax
andq 0x20(%rsp), %rax
movq %rax, 0x30(%rsp)
cmpq $0x0, 0x50(%rsp)
je 0x2d0f
movq 0x50(%rsp), %rax
movq (%rax), %rdi
movq 0x30(%rsp), %rsi
movl 0x1c(%rsp), %edx
callq 0x1120
movl 0x1c(%rsp), %edx
movq 0x50(%rsp), %rax
movq (%rax), %rcx
movl %edx, %edx
addq %rdx, %rcx
movq %rcx, (%rax)
cmpl $0x8, 0x1c(%rsp)
jae 0x2d30
movl 0x44(%rsp), %eax
orq $0x2, %rax
movl 0x1c(%rsp), %ecx
shll $0x3, %ecx
movl %ecx, %ecx
shlq %cl, %rax
movq %rax, (%rsp)
jmp 0x2d38
xorl %eax, %eax
movq %rax, (%rsp)
jmp 0x2d38
movq (%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rdx
xorq 0x28(%rsp), %rdx
movq 0x60(%rsp), %rax
movl 0x18(%rsp), %ecx
andl $0x3, %ecx
movl %ecx, %ecx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movl 0x18(%rsp), %ecx
shrl $0x2, %ecx
movl %ecx, %ecx
xorq (%rax,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
movl 0x1c(%rsp), %ecx
movq 0x58(%rsp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, 0x58(%rsp)
movl 0x1c(%rsp), %eax
movl %eax, %ecx
movq 0x48(%rsp), %rax
subq %rcx, %rax
movq %rax, 0x48(%rsp)
cmpl $0x8, 0x1c(%rsp)
je 0x2c33
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/georgeweigt[P]sassafras/sassafras.c
// Function: data_step
void
data_step(void)
{
	ctrl = 0;
	firstobs = 1;
	nbytecode = 0;
	*dfilename = 0;

	strcpy(delim, "\t ,");

	parse_data_stmt();

	parse_data_body();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x0, 0x110f2(%rip)     # 0x13420
movl $0x1, 0x110ec(%rip)     # 0x13424
movl $0x0, 0x110e6(%rip)     # 0x13428
movb $0x0, 0x110e7(%rip)     # 0x13430
leaq 0x114d0(%rip), %rdi     # 0x13820
leaq 0xcf3f(%rip), %rsi      # 0xf296
callq 0x2040
callq 0x2370
callq 0x2410
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movl $0xfc0, %edi            # imm = 0xFC0
callq 0x2da0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0xfc0, %edx            # imm = 0xFC0
callq 0x20e0
movq 0x11cd3(%rip), %rcx     # 0x14070
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq %rax, 0x11cc1(%rip)     # 0x14070
movq -0x8(%rbp), %rax
movl $0x3e8, 0x18(%rax)      # imm = 0x3E8
callq 0x2d30
cmpl $0x3e9, 0x114bb(%rip)   # imm = 0x3E9
jne 0x23e7
leaq 0x11cae(%rip), %rdi     # 0x14080
callq 0x21f0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
callq 0x2d30
cmpl $0x3b, 0x11496(%rip)    # 0x13884
je 0x23fc
leaq 0xcef1(%rip), %rdi      # 0xf2e8
callq 0x2670
callq 0x2d30
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
jmp 0x241a
cmpl $0x3e9, 0x11460(%rip)   # imm = 0x3E9
jne 0x2484
jmp 0x2428
movq 0x11459(%rip), %rax     # 0x13888
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x20, %ecx
movb %al, -0x1(%rbp)
je 0x244f
movq 0x11445(%rip), %rax     # 0x13888
movsbl (%rax), %eax
cmpl $0x9, %eax
sete %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
testb $0x1, %al
jne 0x2458
jmp 0x246c
movq 0x11429(%rip), %rax     # 0x13888
addq $0x1, %rax
movq %rax, 0x1141e(%rip)     # 0x13888
jmp 0x2428
movq 0x11415(%rip), %rax     # 0x13888
movsbl (%rax), %eax
cmpl $0x3d, %eax
jne 0x2482
callq 0x2540
jmp 0x241a
jmp 0x2484
callq 0x25e0
movl 0x113f5(%rip), %eax     # 0x13884
movl %eax, -0x8(%rbp)
testl %eax, %eax
je 0x24e0
jmp 0x2498
movl -0x8(%rbp), %eax
subl $0x135, %eax            # imm = 0x135
je 0x24e0
jmp 0x24a4
movl -0x8(%rbp), %eax
subl $0x136, %eax            # imm = 0x136
je 0x24ff
jmp 0x24b0
movl -0x8(%rbp), %eax
subl $0x13a, %eax            # imm = 0x13A
je 0x2522
jmp 0x24bc
movl -0x8(%rbp), %eax
subl $0x13b, %eax            # imm = 0x13B
je 0x251b
jmp 0x24c8
movl -0x8(%rbp), %eax
subl $0x147, %eax            # imm = 0x147
je 0x24e0
jmp 0x24d4
movl -0x8(%rbp), %eax
subl $0x14a, %eax            # imm = 0x14A
jne 0x2529
jmp 0x24e0
movsbl 0x10f49(%rip), %eax     # 0x13430
cmpl $0x0, %eax
jne 0x24f8
leaq 0xcda7(%rip), %rdi      # 0xf29a
callq 0x2670
callq 0x2710
jmp 0x2533
cmpb $0x0, 0x10f2a(%rip)     # 0x13430
je 0x2514
leaq 0xcd9f(%rip), %rdi      # 0xf2ae
callq 0x2790
callq 0x27c0
jmp 0x2533
callq 0x2910
jmp 0x252e
callq 0x2ac0
jmp 0x252e
callq 0x2c60
jmp 0x241a
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq 0x11b25(%rip), %rax     # 0x14070
cmpl $0x64, 0x10(%rax)
jne 0x255d
leaq 0xcd7d(%rip), %rdi      # 0xf2d5
callq 0x2790
leaq 0x11b1c(%rip), %rdi     # 0x14080
callq 0x21f0
movq %rax, %rcx
movq 0x11afd(%rip), %rax     # 0x14070
addq $0x20, %rax
movq 0x11af2(%rip), %rdx     # 0x14070
movslq 0x10(%rdx), %rdx
imulq $0x28, %rdx, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
callq 0x2d30
callq 0x2d30
callq 0x4200
cmpl $0x3b, 0x112e2(%rip)    # 0x13884
je 0x25b0
leaq 0xce45(%rip), %rdi      # 0xf3f0
callq 0x2790
callq 0x2d30
movl $0xb, %edi
callq 0x2de0
movq 0x11aaa(%rip), %rax     # 0x14070
movl 0x10(%rax), %edi
callq 0x2de0
movq 0x11a9b(%rip), %rax     # 0x14070
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x2a, -0x8(%rbp)
cmpl $0x3e9, 0x1128b(%rip)   # imm = 0x3E9
je 0x25fd
jmp 0x265c
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x265c
movslq -0x4(%rbp), %rcx
leaq 0x10b59(%rip), %rax     # 0x13170
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rsi
leaq 0x11a58(%rip), %rdi     # 0x14080
callq 0x2140
cmpl $0x0, %eax
jne 0x264f
movslq -0x4(%rbp), %rcx
leaq 0x10b33(%rip), %rax     # 0x13170
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
movl %eax, 0x11237(%rip)     # 0x13884
jmp 0x265c
jmp 0x2651
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x2604
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpl $0x0, 0x11201(%rip)     # 0x13884
jne 0x26a5
movq -0x8(%rbp), %rcx
leaq 0x11210(%rip), %rdi     # 0x138a0
movl $0x7d0, %esi            # imm = 0x7D0
leaq 0xd338(%rip), %rdx      # 0xf9d4
movb $0x0, %al
callq 0x20c0
jmp 0x26f5
cmpl $0x3b, 0x111d8(%rip)    # 0x13884
jne 0x26ce
movq -0x8(%rbp), %rcx
leaq 0x111e7(%rip), %rdi     # 0x138a0
movl $0x7d0, %esi            # imm = 0x7D0
leaq 0xd331(%rip), %rdx      # 0xf9f6
movb $0x0, %al
callq 0x20c0
jmp 0x26f3
movq -0x8(%rbp), %rcx
leaq 0x111c7(%rip), %rdi     # 0x138a0
movl $0x7d0, %esi            # imm = 0x7D0
leaq 0xd335(%rip), %rdx      # 0xfa1a
leaq 0x11994(%rip), %r8      # 0x14080
movb $0x0, %al
callq 0x20c0
jmp 0x26f5
leaq 0x111a4(%rip), %rdi     # 0x138a0
callq 0x2790
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
leaq 0x10d15(%rip), %rdi     # 0x13430
leaq 0xd09a(%rip), %rsi      # 0xf7bc
callq 0x21b0
movq %rax, 0x11162(%rip)     # 0x13890
cmpq $0x0, 0x1115a(%rip)     # 0x13890
jne 0x2765
leaq 0x11161(%rip), %rdi     # 0x138a0
movl $0x7d0, %esi            # imm = 0x7D0
leaq 0xcb7b(%rip), %rdx      # 0xf2c6
leaq 0x10cde(%rip), %rcx     # 0x13430
movb $0x0, %al
callq 0x20c0
leaq 0x11140(%rip), %rdi     # 0x138a0
callq 0x2790
callq 0x2cf0
movq 0x1111f(%rip), %rdi     # 0x13890
callq 0x2080
movq $0x0, 0x1110f(%rip) # 0x13890
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
jmp 0x27ca
callq 0x2210
movq (%rax), %rax
movq 0x110af(%rip), %rcx     # 0x13888
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %ecx
andl $0x2000, %ecx           # imm = 0x2000
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x1(%rbp)
je 0x281a
movq 0x1108e(%rip), %rax     # 0x13888
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0xa, %ecx
movb %al, -0x1(%rbp)
je 0x281a
movq 0x1107a(%rip), %rax     # 0x13888
movsbl (%rax), %eax
cmpl $0xd, %eax
setne %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
testb $0x1, %al
jne 0x2823
jmp 0x2837
movq 0x1105e(%rip), %rax     # 0x13888
addq $0x1, %rax
movq %rax, 0x11053(%rip)     # 0x13888
jmp 0x27ca
movq 0x1104a(%rip), %rax     # 0x13888
movsbl (%rax), %eax
cmpl $0x3b, %eax
jne 0x28cb
movq 0x11037(%rip), %rax     # 0x13888
addq $0x1, %rax
movq %rax, 0x1102c(%rip)     # 0x13888
callq 0x2210
movq (%rax), %rax
movq 0x1101d(%rip), %rcx     # 0x13888
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %ecx
andl $0x2000, %ecx           # imm = 0x2000
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x2(%rbp)
je 0x28ac
movq 0x10ffc(%rip), %rax     # 0x13888
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0xa, %ecx
movb %al, -0x2(%rbp)
je 0x28ac
movq 0x10fe8(%rip), %rax     # 0x13888
movsbl (%rax), %eax
cmpl $0xd, %eax
setne %al
movb %al, -0x2(%rbp)
movb -0x2(%rbp), %al
testb $0x1, %al
jne 0x28b5
jmp 0x28c9
movq 0x10fcc(%rip), %rax     # 0x13888
addq $0x1, %rax
movq %rax, 0x10fc1(%rip)     # 0x13888
jmp 0x285c
jmp 0x28cb
movq 0x10fb6(%rip), %rax     # 0x13888
movsbl (%rax), %eax
cmpl $0xa, %eax
je 0x28fa
movq 0x10fa7(%rip), %rax     # 0x13888
movsbl (%rax), %eax
cmpl $0xd, %eax
je 0x28fa
callq 0x2d30
leaq 0xca65(%rip), %rdi      # 0xf35a
callq 0x2670
callq 0x2cf0
callq 0x2d30
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
callq 0x2d30
cmpl $0x3e9, 0x10f5d(%rip)   # imm = 0x3E9
je 0x292e
jmp 0x2a78
movq 0x1173b(%rip), %rax     # 0x14070
cmpl $0x64, 0x10(%rax)
jne 0x2947
leaq 0xc993(%rip), %rdi      # 0xf2d5
callq 0x2790
movq 0x11722(%rip), %rcx     # 0x14070
movl 0x10(%rcx), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, 0x10(%rcx)
movl %eax, -0x4(%rbp)
leaq 0x1171d(%rip), %rdi     # 0x14080
callq 0x21f0
movq %rax, %rcx
movq 0x116fe(%rip), %rax     # 0x14070
addq $0x20, %rax
movslq -0x4(%rbp), %rdx
imulq $0x28, %rdx, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
callq 0x2d30
cmpl $0x24, 0x10ef4(%rip)    # 0x13884
jne 0x2a0c
movq 0x116d7(%rip), %rax     # 0x14070
addq $0x20, %rax
movslq -0x4(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movl $0xa, 0x8(%rax)
movq 0x116ba(%rip), %rax     # 0x14070
addq $0x20, %rax
movslq -0x4(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movl $0x0, 0xc(%rax)
movl $0x50, %edi
callq 0x2da0
movq %rax, %rcx
movq 0x11690(%rip), %rax     # 0x14070
addq $0x20, %rax
movslq -0x4(%rbp), %rdx
imulq $0x28, %rdx, %rdx
addq %rdx, %rax
movq %rcx, 0x10(%rax)
movl $0x1, %edi
callq 0x2de0
movl -0x4(%rbp), %edi
callq 0x2de0
callq 0x2d30
jmp 0x2a73
movq 0x1165d(%rip), %rax     # 0x14070
addq $0x20, %rax
movslq -0x4(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movl $0x0, 0x8(%rax)
movq 0x11640(%rip), %rax     # 0x14070
addq $0x20, %rax
movslq -0x4(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movl $0x0, 0xc(%rax)
movq 0x11623(%rip), %rax     # 0x14070
addq $0x20, %rax
movslq -0x4(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq $0x0, 0x10(%rax)
xorl %edi, %edi
callq 0x2de0
movl -0x4(%rbp), %edi
callq 0x2de0
jmp 0x291d
cmpl $0x3ec, 0x10e02(%rip)   # imm = 0x3EC
jne 0x2a95
movl $0xd, %edi
callq 0x2de0
callq 0x2d30
jmp 0x2a9f
movl $0xc, %edi
callq 0x2de0
cmpl $0x3b, 0x10dde(%rip)    # 0x13884
je 0x2ab4
leaq 0xcf5a(%rip), %rdi      # 0xfa09
callq 0x2670
callq 0x2d30
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
cmpb $0x0, 0x10961(%rip)     # 0x13430
je 0x2add
leaq 0xc820(%rip), %rdi      # 0xf2f8
callq 0x2790
callq 0x2e30
movl 0x10d9c(%rip), %eax     # 0x13884
movl %eax, -0x4(%rbp)
subl $0x130, %eax            # imm = 0x130
je 0x2b21
jmp 0x2af4
movl -0x4(%rbp), %eax
subl $0x136, %eax            # imm = 0x136
je 0x2b21
jmp 0x2b00
movl -0x4(%rbp), %eax
subl $0x3eb, %eax            # imm = 0x3EB
jne 0x2b23
jmp 0x2b0c
leaq 0x1091d(%rip), %rdi     # 0x13430
leaq 0x11566(%rip), %rsi     # 0x14080
callq 0x2040
jmp 0x2b2f
jmp 0x2b2f
leaq 0xc7e9(%rip), %rdi      # 0xf313
callq 0x2670
jmp 0x2b31
callq 0x2d30
callq 0x25e0
movl 0x10d43(%rip), %eax     # 0x13884
movl %eax, -0x8(%rbp)
subl $0x3b, %eax
je 0x2b69
jmp 0x2b4b
movl -0x8(%rbp), %eax
addl $0xfffffec9, %eax       # imm = 0xFFFFFEC9
subl $0x2, %eax
jb 0x2b74
jmp 0x2b5a
movl -0x8(%rbp), %eax
subl $0x139, %eax            # imm = 0x139
je 0x2bde
jmp 0x2c44
callq 0x2d30
addq $0x10, %rsp
popq %rbp
retq
callq 0x2d30
cmpl $0x3d, 0x10d04(%rip)    # 0x13884
je 0x2b8e
leaq 0xc794(%rip), %rdi      # 0xf31d
callq 0x2670
callq 0x2d30
cmpl $0x3eb, 0x10ce7(%rip)   # imm = 0x3EB
je 0x2bab
leaq 0xceb5(%rip), %rdi      # 0xfa5b
callq 0x2670
leaq 0x114ce(%rip), %rdi     # 0x14080
callq 0x2090
cmpq $0x64, %rax
jb 0x2bc9
leaq 0xc765(%rip), %rdi      # 0xf329
callq 0x2790
leaq 0x10c50(%rip), %rdi     # 0x13820
leaq 0x114a9(%rip), %rsi     # 0x14080
callq 0x2040
jmp 0x2c50
callq 0x2d30
cmpl $0x3d, 0x10c9a(%rip)    # 0x13884
je 0x2bf8
leaq 0xc72a(%rip), %rdi      # 0xf31d
callq 0x2670
callq 0x2d30
cmpl $0x3ea, 0x10c7d(%rip)   # imm = 0x3EA
je 0x2c15
leaq 0xc729(%rip), %rdi      # 0xf339
callq 0x2670
leaq 0x11464(%rip), %rdi     # 0x14080
leaq 0xc71d(%rip), %rsi      # 0xf340
leaq 0x107fa(%rip), %rdx     # 0x13424
movb $0x0, %al
callq 0x2170
cmpl $0x1, %eax
je 0x2c42
leaq 0xc706(%rip), %rdi      # 0xf343
callq 0x2790
jmp 0x2c50
leaq 0xcdbe(%rip), %rdi      # 0xfa09
callq 0x2670
jmp 0x2b31
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/georgeweigt[P]sassafras/sassafras.c
// Function: parse_default
void
parse_default(void)
{
	switch (token) {
	case ';':
		scan();
		break;
	case '*':
		parse_comment_stmt();
		break;
	case KTITLE:
		title_stmt();
		break;
	case KTITLE1:
		title1_stmt();
		break;
	case KTITLE2:
		title2_stmt();
		break;
	case KTITLE3:
		title3_stmt();
		break;
	default:
		stop("Unexpected token, did you mean proc?");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl 0x10c16(%rip), %eax     # 0x13884
movl %eax, -0x4(%rbp)
subl $0x2a, %eax
je 0x2cb9
jmp 0x2c78
movl -0x4(%rbp), %eax
subl $0x3b, %eax
je 0x2cb2
jmp 0x2c82
movl -0x4(%rbp), %eax
subl $0x151, %eax            # imm = 0x151
je 0x2cc0
jmp 0x2c8e
movl -0x4(%rbp), %eax
subl $0x152, %eax            # imm = 0x152
je 0x2cc7
jmp 0x2c9a
movl -0x4(%rbp), %eax
subl $0x153, %eax            # imm = 0x153
je 0x2cce
jmp 0x2ca6
movl -0x4(%rbp), %eax
subl $0x154, %eax            # imm = 0x154
je 0x2cd5
jmp 0x2cdc
callq 0x2d30
jmp 0x2ce8
callq 0x4c90
jmp 0x2ce8
callq 0x4cf0
jmp 0x2ce8
callq 0x4d80
jmp 0x2ce8
callq 0x4e10
jmp 0x2ce8
callq 0x4ea0
jmp 0x2ce8
leaq 0xc7c3(%rip), %rdi      # 0xf4a6
callq 0x2790
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 0x2e50
callq 0x2ee0
cmpq $0x0, 0x11762(%rip)     # 0x14468
je 0x2d24
callq 0x2fb0
callq 0x3060
movq 0x11357(%rip), %rax     # 0x14070
movl 0x14(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x14(%rax)
jmp 0x2cfe
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq 0x10b4d(%rip), %rax     # 0x13888
cmpq 0x16f56(%rip), %rax     # 0x19c98
jne 0x2d50
movl $0x0, 0x16f52(%rip)     # 0x19ca0
jmp 0x2d5c
movl 0x10b2e(%rip), %eax     # 0x13884
movl %eax, 0x16f44(%rip)     # 0x19ca0
callq 0xdc30
movl %eax, 0x10b1d(%rip)     # 0x13884
cmpl $0x0, 0x10b16(%rip)     # 0x13884
jne 0x2d9a
cmpl $0x0, 0x16f29(%rip)     # 0x19ca0
je 0x2d9a
cmpl $0x3b, 0x16f20(%rip)    # 0x19ca0
je 0x2d9a
movb $0x3b, 0x112f7(%rip)    # 0x14080
movb $0x0, 0x112f1(%rip)     # 0x14081
movl $0x3b, 0x10aea(%rip)    # 0x13884
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movslq -0x4(%rbp), %rdi
callq 0x2160
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x2dc9
movl $0x1, %edi
callq 0x21d0
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
movq 0x11207(%rip), %rcx     # 0x14070
cmpl 0x10(%rcx), %eax
jge 0x2ecb
movq 0x111fb(%rip), %rax     # 0x14070
addq $0x20, %rax
movslq -0x4(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, 0x20(%rax)
jne 0x2ebe
movq 0x111de(%rip), %rax     # 0x14070
movslq 0x18(%rax), %rax
shlq $0x3, %rax
movl %eax, %edi
callq 0x2da0
movq %rax, %rcx
movq 0x111c5(%rip), %rax     # 0x14070
addq $0x20, %rax
movslq -0x4(%rbp), %rdx
imulq $0x28, %rdx, %rdx
addq %rdx, %rax
movq %rcx, 0x20(%rax)
jmp 0x2ec0
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x2e5f
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
jmp 0x2ee6
cmpq $0x0, 0x109a2(%rip)     # 0x13890
je 0x2f39
jmp 0x2ef2
movq 0x10997(%rip), %rdx     # 0x13890
leaq 0x13fb0(%rip), %rdi     # 0x16eb0
movl $0xfa0, %esi            # imm = 0xFA0
callq 0x2120
movq %rax, 0x11557(%rip)     # 0x14468
cmpq $0x0, 0x1154f(%rip)     # 0x14468
je 0x2f24
cmpl $0x2, 0x10502(%rip)     # 0x13424
jge 0x2f26
jmp 0x2f37
movl 0x104f8(%rip), %eax     # 0x13424
addl $-0x1, %eax
movl %eax, 0x104ef(%rip)     # 0x13424
jmp 0x2ef2
jmp 0x2f51
leaq 0x13f70(%rip), %rdi     # 0x16eb0
movl $0xfa0, %esi            # imm = 0xFA0
callq 0x3c60
movq %rax, 0x11517(%rip)     # 0x14468
cmpq $0x0, 0x1150f(%rip)     # 0x14468
jne 0x2f5d
jmp 0x2fab
jmp 0x2f5f
callq 0x2210
movq (%rax), %rax
movq 0x114fa(%rip), %rcx     # 0x14468
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
je 0x2f96
movq 0x114df(%rip), %rax     # 0x14468
addq $0x1, %rax
movq %rax, 0x114d4(%rip)     # 0x14468
jmp 0x2f5f
jmp 0x2f98
movq 0x114c9(%rip), %rax     # 0x14468
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x2ee6
popq %rbp
retq
nopl (%rax)