LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/window.c
// Function: Window_collapse
static int Window_collapse(lua_State *L)
    {
    nk_context_t *context = checkcontext(L, 1, NULL);
    const char *name = luaL_checkstring(L, 2);
    enum nk_collapse_states state = checkcollapsestates(L, 3);
    nk_window_collapse(context, name, state);
    return 0;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0xdd2(%rip), %rcx       # 0xa7280
callq 0x130f0
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movl $0x2, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x13df0
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movl $0x4, %esi
movl $0x3, %edx
callq 0x14470
movl %eax, 0xc(%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl 0xc(%rsp), %edx
callq 0x14ff0
xorl %eax, %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/window.c
// Function: Window_collapse_if
static int Window_collapse_if(lua_State *L)
    {
    nk_context_t *context = checkcontext(L, 1, NULL);
    const char *name = luaL_checkstring(L, 2);
    enum nk_collapse_states state = checkcollapsestates(L, 3);
    int cond = checkboolean(L, 4);
    nk_window_collapse_if(context, name, state, cond);
    return 0;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0xd52(%rip), %rcx       # 0xa7280
callq 0x130f0
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movl $0x2, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x13df0
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movl $0x4, %esi
movl $0x3, %edx
callq 0x14470
movl %eax, 0xc(%rsp)
movq 0x20(%rsp), %rdi
movl $0x4, %esi
callq 0x14990
movl %eax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl 0xc(%rsp), %edx
movl 0x8(%rsp), %ecx
callq 0x154a0
xorl %eax, %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/window.c
// Function: Window_show
static int Window_show(lua_State *L)
    {
    nk_context_t *context = checkcontext(L, 1, NULL);
    const char *name = luaL_checkstring(L, 2);
    enum nk_show_states state = checkshowstates(L, 3);
    nk_window_show(context, name, state);
    return 0;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0xcc2(%rip), %rcx       # 0xa7280
callq 0x130f0
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movl $0x2, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x13df0
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movl $0x5, %esi
movl $0x3, %edx
callq 0x14470
movl %eax, 0xc(%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl 0xc(%rsp), %edx
callq 0x14b20
xorl %eax, %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/window.c
// Function: Window_show_if
static int Window_show_if(lua_State *L)
    {
    nk_context_t *context = checkcontext(L, 1, NULL);
    const char *name = luaL_checkstring(L, 2);
    enum nk_show_states state = checkshowstates(L, 3);
    int cond = checkboolean(L, 4);
    nk_window_show_if(context, name, state, cond);
    return 0;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0xc42(%rip), %rcx       # 0xa7280
callq 0x130f0
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movl $0x2, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x13df0
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movl $0x5, %esi
movl $0x3, %edx
callq 0x14470
movl %eax, 0xc(%rsp)
movq 0x20(%rsp), %rdi
movl $0x4, %esi
callq 0x14990
movl %eax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl 0xc(%rsp), %edx
movl 0x8(%rsp), %ecx
callq 0x14da0
xorl %eax, %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/window.c
// Function: Group_begin
static int Group_begin(lua_State *L)
    {
    int rc = 0;
    const char *name;
    nk_flags flags;
    nk_context_t *context = checkcontext(L, 1, NULL);
    const char *title = luaL_checkstring(L, 2);
    flags = checkflags(L, 3); /* nk_panel_flags */
    if(lua_isnoneornil(L, 4))
        rc = nk_group_begin(context, title, flags);
    else
        {
        name = luaL_checkstring(L, 4);
        rc = nk_group_begin_titled(context, name, title, flags);
        }
    lua_pushboolean(L, rc);
    return 1;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl $0x0, 0x2c(%rsp)
movq 0x30(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0xbaa(%rip), %rcx       # 0xa7280
callq 0x130f0
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rdi
movl $0x2, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x13df0
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
movl $0x3, %esi
callq 0x14070
movl %eax, 0x1c(%rsp)
movq 0x30(%rsp), %rdi
movl $0x4, %esi
callq 0x15090
cmpl $0x0, %eax
jg 0xa6738
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movl 0x1c(%rsp), %edx
callq 0x15340
movl %eax, 0x2c(%rsp)
jmp 0xa676c
movq 0x30(%rsp), %rdi
movl $0x4, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x13df0
movq %rax, 0x20(%rsp)
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x8(%rsp), %rdx
movl 0x1c(%rsp), %ecx
callq 0x15430
movl %eax, 0x2c(%rsp)
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %esi
callq 0x143e0
movl $0x1, %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/window.c
// Function: Group_scrolled_begin
static int Group_scrolled_begin(lua_State *L)
    {
    nk_scroll_t offset;
    nk_context_t *context = checkcontext(L, 1, NULL);
    const char *title = luaL_checkstring(L, 2);
    nk_flags flags = checkflags(L, 3); /* nk_panel_flags */
    if(echeckscroll(L, 4, &offset)) return argerror(L, 4);
    if(!nk_group_scrolled_begin(context, &offset, title, flags))
        {
        lua_pushboolean(L, 0);
        return 1;
        }
    lua_pushboolean(L, 1);
    return 1;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0xa92(%rip), %rcx       # 0xa7280
callq 0x130f0
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rdi
movl $0x2, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x13df0
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
movl $0x3, %esi
callq 0x14070
movl %eax, 0xc(%rsp)
movq 0x28(%rsp), %rdi
movl $0x4, %esi
leaq 0x20(%rsp), %rdx
callq 0x136e0
cmpl $0x0, %eax
je 0xa686f
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
movq 0x28(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edx
callq 0x136c0
movq (%rsp), %rdi
movq %rax, %rdx
movl $0x4, %esi
callq 0x134c0
movl %eax, 0x34(%rsp)
jmp 0xa68b9
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rdx
movl 0xc(%rsp), %ecx
leaq 0x20(%rsp), %rsi
callq 0x144b0
cmpl $0x0, %eax
jne 0xa68a2
movq 0x28(%rsp), %rdi
xorl %esi, %esi
callq 0x143e0
movl $0x1, 0x34(%rsp)
jmp 0xa68b9
movq 0x28(%rsp), %rdi
movl $0x1, %esi
callq 0x143e0
movl $0x1, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/window.c
// Function: Group_get_scroll
static int Group_get_scroll(lua_State *L)
    {
    nk_uint offset_x, offset_y;
    nk_context_t *context = checkcontext(L, 1, NULL);
    const char *title = luaL_checkstring(L, 2);
    nk_group_get_scroll(context, title, &offset_x, &offset_y);
    lua_pushinteger(L, offset_x);
    lua_pushinteger(L, offset_y);
    return 2;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0x952(%rip), %rcx       # 0xa7280
callq 0x130f0
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movl $0x2, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x13df0
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
leaq 0x1c(%rsp), %rdx
leaq 0x18(%rsp), %rcx
callq 0x132e0
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %eax
movl %eax, %esi
callq 0x13c50
movq 0x20(%rsp), %rdi
movl 0x18(%rsp), %eax
movl %eax, %esi
callq 0x13c50
movl $0x2, %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/window.c
// Function: Group_set_scroll
static int Group_set_scroll(lua_State *L)
    {
    nk_context_t *context = checkcontext(L, 1, NULL);
    const char *title = luaL_checkstring(L, 2);
    nk_uint offset_x = luaL_checkinteger(L, 3);
    nk_uint offset_y = luaL_checkinteger(L, 4);
    nk_group_set_scroll(context, title, offset_x, offset_y);
    return 0;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0x8c2(%rip), %rcx       # 0xa7280
callq 0x130f0
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movl $0x2, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x13df0
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movl $0x3, %esi
callq 0x14070
movl %eax, 0xc(%rsp)
movq 0x20(%rsp), %rdi
movl $0x4, %esi
callq 0x14070
movl %eax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl 0xc(%rsp), %edx
movl 0x8(%rsp), %ecx
callq 0x15330
xorl %eax, %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/JesseBuesking[P]omnomnum/parser.c
// Function: ParseFree
void ParseFree(
  void *p,                    /* The parser to be deleted */
  void (*freeProc)(void*)     /* Function used to reclaim memory */
){
  yyParser *pParser = (yyParser*)p;
#ifndef YYPARSEFREENEVERNULL
  if( pParser==0 ) return;
#endif
  while( pParser->yytos>pParser->yystack ) yy_pop_parser_stack(pParser);
#if YYSTACKDEPTH<=0
  if( pParser->yystack!=&pParser->yystk0 ) free(pParser->yystack);
#endif
  (*freeProc)((void*)pParser);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x12c0
jmp 0x12ec
jmp 0x12c2
movq (%rsp), %rax
movq (%rax), %rax
movq (%rsp), %rcx
addq $0x18, %rcx
cmpq %rcx, %rax
jbe 0x12e1
movq (%rsp), %rdi
callq 0x1300
jmp 0x12c2
movq 0x8(%rsp), %rax
movq (%rsp), %rdi
callq *%rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JesseBuesking[P]omnomnum/parser.c
// Function: ParseReset
void ParseReset(
  void *p                    /* The parser to be reset */
){
  yyParser *pParser = (yyParser*)p;
#ifndef YYPARSEFREENEVERNULL
  if( pParser==0 ) return;
#endif
  while( pParser->yytos>pParser->yystack ) yy_pop_parser_stack(pParser);
#if YYSTACKDEPTH<=0
  if( pParser->yystack!=&pParser->yystk0 ) free(pParser->yystack);
#endif

  if( pParser ){
#ifdef YYTRACKMAXSTACKDEPTH
    pParser->yyhwm = 0;
#endif
#if YYSTACKDEPTH<=0
    pParser->yytos = NULL;
    pParser->yystack = NULL;
    pParser->yystksz = 0;
    /*if( yyGrowStack(pParser) ){*/
      /*pParser->yystack = &pParser->yystk0;*/
      /*pParser->yystksz = 1;*/
    /*}*/
#endif
#ifndef YYNOERRORRECOVERY
    pParser->yyerrcnt = -1;
#endif
    pParser->yytos = pParser->yystack;
    pParser->yystack[0].stateno = 0;
    pParser->yystack[0].major = 0;
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x136d
jmp 0x13ca
jmp 0x136f
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rsp), %rcx
addq $0x18, %rcx
cmpq %rcx, %rax
jbe 0x1391
movq 0x8(%rsp), %rdi
callq 0x1300
jmp 0x136f
cmpq $0x0, 0x8(%rsp)
je 0x13ca
movq 0x8(%rsp), %rax
movl $0xffffffff, 0x8(%rax)  # imm = 0xFFFFFFFF
movq 0x8(%rsp), %rcx
addq $0x18, %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
movw $0x0, 0x18(%rax)
movq 0x8(%rsp), %rax
movb $0x0, 0x1a(%rax)
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/JesseBuesking[P]omnomnum/parser.c
// Function: yy_shift
static void yy_shift(
  yyParser *yypParser,          /* The parser to be shifted */
  int yyNewState,               /* The new state to shift in */
  int yyMajor,                  /* The major token to shift in */
  ParseTOKENTYPE yyMinor        /* The minor token to shift in */
){
  yyStackEntry *yytos;
  yypParser->yytos++;
#ifdef YYTRACKMAXSTACKDEPTH
  if( (int)(yypParser->yytos - yypParser->yystack)>yypParser->yyhwm ){
    yypParser->yyhwm++;
    assert( yypParser->yyhwm == (int)(yypParser->yytos - yypParser->yystack) );
  }
#endif
#if YYSTACKDEPTH>0 
  if( yypParser->yytos>=&yypParser->yystack[YYSTACKDEPTH] ){
    yyStackOverflow(yypParser);
    return;
  }
#else
  if( yypParser->yytos>=&yypParser->yystack[yypParser->yystksz] ){
    if( yyGrowStack(yypParser) ){
      yyStackOverflow(yypParser);
      return;
    }
  }
#endif
  if( yyNewState > YY_MAX_SHIFT ){
    yyNewState += YY_MIN_REDUCE - YY_MIN_SHIFTREDUCE;
  }
  yytos = yypParser->yytos;
  yytos->stateno = (YYACTIONTYPE)yyNewState;
  yytos->major = (YYCODETYPE)yyMajor;
  yytos->minor.yy0 = yyMinor;
  yyTraceShift(yypParser, yyNewState);
}

// Assembly:
subq $0x28, %rsp
leaq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rcx
addq $0x38, %rcx
movq %rcx, (%rax)
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq 0x20(%rsp), %rcx
addq $0x18, %rcx
addq $0x15e0, %rcx           # imm = 0x15E0
cmpq %rcx, %rax
jb 0x16b3
movq 0x20(%rsp), %rdi
callq 0x9760
jmp 0x1709
cmpl $0x3b, 0x1c(%rsp)
jle 0x16c7
movl 0x1c(%rsp), %eax
addl $0xf2, %eax
movl %eax, 0x1c(%rsp)
movq 0x8(%rsp), %rsi
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movl 0x1c(%rsp), %eax
movw %ax, %cx
movq 0x10(%rsp), %rax
movw %cx, (%rax)
movl 0x18(%rsp), %eax
movb %al, %cl
movq 0x10(%rsp), %rax
movb %cl, 0x2(%rax)
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
movl $0x30, %edx
callq 0x10d0
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/JesseBuesking[P]omnomnum/parser.c
// Function: yy_parse_failed
static void yy_parse_failed(
  yyParser *yypParser           /* The parser */
){
  ParseARG_FETCH;
#ifndef NDEBUG
  if( yyTraceFILE ){
    fprintf(yyTraceFILE,"%sFail!\n",yyTracePrompt);
  }
#endif
  while( yypParser->yytos>yypParser->yystack ) yy_pop_parser_stack(yypParser);
  /* Here code is inserted which will be executed whenever the
  ** parser fails */
/************ Begin %parse_failure code ***************************************/
#line 203 "parser.yy"

    state->error = PARSE_FAILURE;
#if print_errors
    fprintf(stderr,"Giving up.  Parser is hopelessly lost...\n");
#endif
#line 3221 "parser.c"
/************ End %parse_failure code *****************************************/
  ParseARG_STORE; /* Suppress warning about unused %extra_argument variable */
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rsp), %rcx
addq $0x18, %rcx
cmpq %rcx, %rax
jbe 0x9739
movq 0x10(%rsp), %rdi
callq 0x1300
jmp 0x9717
movq 0x8(%rsp), %rax
movl $0x2, 0x10(%rax)
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x10(%rax)
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JesseBuesking[P]omnomnum/parser.c
// Function: yyStackOverflow
static void yyStackOverflow(yyParser *yypParser){
   ParseARG_FETCH;
   yypParser->yytos--;
#ifndef NDEBUG
   if( yyTraceFILE ){
     fprintf(yyTraceFILE,"%sStack Overflow!\n",yyTracePrompt);
   }
#endif
   while( yypParser->yytos>yypParser->yystack ) yy_pop_parser_stack(yypParser);
   /* Here code is inserted which will execute if the parser
   ** stack every overflows */
/******** Begin %stack_overflow code ******************************************/
/******** End %stack_overflow code ********************************************/
   ParseARG_STORE; /* Suppress warning about unused %extra_argument var */
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rcx
addq $-0x38, %rcx
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rsp), %rcx
addq $0x18, %rcx
cmpq %rcx, %rax
jbe 0x97a8
movq 0x10(%rsp), %rdi
callq 0x1300
jmp 0x9786
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x10(%rax)
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JesseBuesking[P]omnomnum/omnomnum.c
// Function: yystypeToString
void yystypeToString(sds *s, YYSTYPE A, int precision) {
    if (A.is_frac) {
        dtoa(s, A.frac_num, precision);
        *s = sdscat(*s, "/");
        sds tmp = sdsempty();
        dtoa(&tmp, A.frac_denom, precision);
        *s = sdscatsds(*s, tmp);
        sdsfree(tmp);
    } else if (A.is_dbl) {
        dtoa(s, A.dbl, precision);
    } else {
        itoa(s, (uint64_t)A.dbl);
    }

    jump_table[A.suffix](s);
}

// Assembly:
subq $0x28, %rsp
leaq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
testb $0x1, 0x20(%rax)
je 0x9a66
movq 0x8(%rsp), %rax
movq 0x20(%rsp), %rdi
movsd 0x10(%rax), %xmm0
movl 0x1c(%rsp), %esi
callq 0x14a00
movq 0x20(%rsp), %rax
movq (%rax), %rdi
leaq 0x10b70(%rip), %rsi     # 0x1a578
callq 0x128b0
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, (%rax)
callq 0x11d80
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rsp)
movsd 0x18(%rax), %xmm0
movl 0x1c(%rsp), %esi
leaq 0x10(%rsp), %rdi
callq 0x14a00
movq 0x20(%rsp), %rax
movq (%rax), %rdi
movq 0x10(%rsp), %rsi
callq 0x12900
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rdi
callq 0x11ec0
jmp 0x9ac5
movq 0x8(%rsp), %rax
testb $0x1, 0x8(%rax)
je 0x9a8a
movq 0x8(%rsp), %rax
movq 0x20(%rsp), %rdi
movsd (%rax), %xmm0
movl 0x1c(%rsp), %esi
callq 0x14a00
jmp 0x9ac3
movq 0x8(%rsp), %rax
movq 0x20(%rsp), %rdi
movsd (%rax), %xmm0
movsd 0x10aa0(%rip), %xmm2    # 0x1a540
movaps %xmm0, %xmm1
subsd %xmm2, %xmm1
cvttsd2si %xmm1, %rax
cvttsd2si %xmm0, %rsi
movq %rsi, %rcx
sarq $0x3f, %rcx
andq %rcx, %rax
orq %rax, %rsi
callq 0x14820
jmp 0x9ac5
movq 0x8(%rsp), %rax
movl 0x2c(%rax), %eax
movl %eax, %ecx
leaq 0x165da(%rip), %rax     # 0x200b0
movq (%rax,%rcx,8), %rax
movq 0x20(%rsp), %rdi
callq *%rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JesseBuesking[P]omnomnum/scan.c
// Function: scanstate_init
void scanstate_init(scanstate *ss, const char *bufptr, size_t bufsiz)
{
    ss->cursor = bufptr;
    ss->marker = NULL;
    ss->token = bufptr;
    ss->limit = bufptr + bufsiz;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq -0x10(%rsp), %rcx
movq -0x8(%rsp), %rax
movq %rcx, (%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rsp), %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rsp), %rcx
addq -0x18(%rsp), %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JesseBuesking[P]omnomnum/sds.c
// Function: sdsReqType
static inline char sdsReqType(size_t string_size) {
    if (string_size < 1<<5)
        return SDS_TYPE_5;
    if (string_size < 1<<8)
        return SDS_TYPE_8;
    if (string_size < 1<<16)
        return SDS_TYPE_16;
#if (LONG_MAX == LLONG_MAX)
    if (string_size < 1ll<<32)
        return SDS_TYPE_32;
#endif
    return SDS_TYPE_64;
}

// Assembly:
movq %rdi, -0x10(%rsp)
cmpq $0x20, -0x10(%rsp)
jae 0x11cc4
movb $0x0, -0x1(%rsp)
jmp 0x11d05
cmpq $0x100, -0x10(%rsp)     # imm = 0x100
jae 0x11cd6
movb $0x1, -0x1(%rsp)
jmp 0x11d05
cmpq $0x10000, -0x10(%rsp)   # imm = 0x10000
jae 0x11ce8
movb $0x2, -0x1(%rsp)
jmp 0x11d05
movabsq $0x100000000, %rax      # imm = 0x100000000
cmpq %rax, -0x10(%rsp)
jae 0x11d00
movb $0x3, -0x1(%rsp)
jmp 0x11d05
movb $0x4, -0x1(%rsp)
movb -0x1(%rsp), %al
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JesseBuesking[P]omnomnum/dtoa.c
// Function: morphNumericString
void morphNumericString(sds *s, int n) {
    char *p = strchr(*s, '.');                    // Find decimal point, if any.
    if (p != NULL) {
        int dotPosition = (p - *s);
        int endRange = dotPosition + n;
        int lastPosition = (int) sdslen(*s) - 1;

        endRange = endRange < lastPosition ? endRange : lastPosition;

        while ((*s)[endRange] == '0') {     // Remove trailing zeros.
            endRange -= 1;
        }

        if ((*s)[endRange] == '.') {        // If all decimals were zeros, remove "."
            endRange -= 1;
        }

        sdsrange(*s, 0, endRange);          // Trim the string to the range.
    }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rdi
movl $0x2e, %esi
callq 0x1090
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x1494c
movq 0x10(%rsp), %rax
movq 0x20(%rsp), %rcx
movq (%rcx), %rcx
subq %rcx, %rax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
addl 0x1c(%rsp), %eax
movl %eax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rdi
callq 0x14960
subl $0x1, %eax
movl %eax, 0x4(%rsp)
movl 0x8(%rsp), %eax
cmpl 0x4(%rsp), %eax
jge 0x148e7
movl 0x8(%rsp), %eax
movl %eax, (%rsp)
jmp 0x148ee
movl 0x4(%rsp), %eax
movl %eax, (%rsp)
movl (%rsp), %eax
movl %eax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rax
movslq 0x8(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x30, %eax
jne 0x14918
movl 0x8(%rsp), %eax
subl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x148f5
movq 0x20(%rsp), %rax
movq (%rax), %rax
movslq 0x8(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2e, %eax
jne 0x14939
movl 0x8(%rsp), %eax
subl $0x1, %eax
movl %eax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rdi
movl 0x8(%rsp), %edx
xorl %esi, %esi
callq 0x137d0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JesseBuesking[P]omnomnum/dtoa.c
// Function: dtoa
void dtoa(sds *s, double d, int precision) {
    memset(DTOA_BUFFER, 0, 256);
    fill_double(d, DTOA_BUFFER);
    *s = sdscat(*s, DTOA_BUFFER);
    morphNumericString(s, precision);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movsd %xmm0, 0x8(%rsp)
movl %esi, 0x4(%rsp)
leaq 0xb806(%rip), %rdi      # 0x20220
xorl %esi, %esi
movl $0x100, %edx            # imm = 0x100
callq 0x10b0
movsd 0x8(%rsp), %xmm0
leaq 0xb7ed(%rip), %rdi      # 0x20220
callq 0x14f40
movq 0x10(%rsp), %rax
movq (%rax), %rdi
leaq 0xb7d9(%rip), %rsi      # 0x20220
callq 0x128b0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rdi
movl 0x4(%rsp), %esi
callq 0x14870
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JesseBuesking[P]omnomnum/scanner.def.c
// Function: insertYYSTYPE
void insertYYSTYPE(YYSTYPEList *l, YYSTYPE element) {
    if (l->used == l->size) {
        if (l->size == 0) {
            l->size = 1;
        } else {
            l->size *= 2;
        }
        l->values = (YYSTYPE *)realloc(l->values, l->size * sizeof(YYSTYPE));
    }
    l->values[l->used] = element;
    l->used += 1;
}

// Assembly:
subq $0x18, %rsp
leaq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jne 0x14b34
movq 0x10(%rsp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x14b02
movq 0x10(%rsp), %rax
movq $0x1, 0x10(%rax)
jmp 0x14b12
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rcx
shlq %rcx
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq 0x10(%rsp), %rax
imulq $0x30, 0x10(%rax), %rsi
callq 0x1100
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq 0x10(%rsp), %rax
imulq $0x30, 0x8(%rax), %rax
addq %rax, %rdi
movl $0x30, %edx
callq 0x10d0
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/JesseBuesking[P]omnomnum/scanner.def.c
// Function: resetYYSTYPElist
void resetYYSTYPElist(YYSTYPEList *l) {
    if (l->size > RESET_LIST_SIZE) {
        l->size = RESET_LIST_SIZE;
        l->values = (YYSTYPE *)realloc(l->values, l->size * sizeof(YYSTYPE));
    }
    l->used = 0;
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
movq 0x10(%rax), %rax
cmpq 0xb554(%rip), %rax      # 0x200f8
jbe 0x14bd4
movq 0xb54b(%rip), %rcx      # 0x200f8
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
movq (%rsp), %rax
movq (%rax), %rdi
movq (%rsp), %rax
imulq $0x30, 0x10(%rax), %rsi
callq 0x1100
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
movq (%rsp), %rax
movq $0x0, 0x8(%rax)
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JesseBuesking[P]omnomnum/scanner.def.c
// Function: compare
int compare(const void* a, const void* b) {
     YYSTYPE yya = * ( (YYSTYPE*) a );
     YYSTYPE yyb = * ( (YYSTYPE*) b );

     if ( yya.begin == yyb.begin ) return 0;
     else if ( yya.begin < yyb.begin ) return -1;
     else return 1;
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movq 0x68(%rsp), %rsi
leaq 0x30(%rsp), %rdi
movl $0x30, %edx
callq 0x10d0
movq 0x60(%rsp), %rsi
movq %rsp, %rdi
movl $0x30, %edx
callq 0x10d0
movl 0x54(%rsp), %eax
cmpl 0x24(%rsp), %eax
jne 0x14c38
movl $0x0, 0x74(%rsp)
jmp 0x14c54
movl 0x54(%rsp), %eax
cmpl 0x24(%rsp), %eax
jae 0x14c4c
movl $0xffffffff, 0x74(%rsp) # imm = 0xFFFFFFFF
jmp 0x14c54
movl $0x1, 0x74(%rsp)
movl 0x74(%rsp), %eax
addq $0x78, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/JesseBuesking[P]omnomnum/scanner.def.c
// Function: resetParserState
void resetParserState(ParserState *state) {
    state->precision = 6;
    sdsfree(state->result);
    state->error = NO_ERROR;
    resetYYSTYPElist(&(state->yystypeList));
    state->parse_second = false;
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
movl $0x6, (%rax)
movq (%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x11ec0
movq (%rsp), %rax
movl $0x0, 0x10(%rax)
movq (%rsp), %rdi
addq $0x18, %rdi
callq 0x14b90
movq (%rsp), %rax
movb $0x0, 0x30(%rax)
popq %rax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/JesseBuesking[P]omnomnum/util.c
// Function: remove_char_inplace
size_t remove_char_inplace(char *str, size_t str_len, const unsigned char remove) {
    size_t orig_index = 0, new_index = 0;
    for(;orig_index < str_len;) {
        if (str[orig_index] == remove) {
            orig_index += 1;
        } else {
            str[new_index] = str[orig_index];
            orig_index += 1;
            new_index += 1;
        }
    }

    str[new_index] = '\0';
    return new_index;
}

// Assembly:
movb %dl, %al
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movb %al, -0x11(%rsp)
movq $0x0, -0x20(%rsp)
movq $0x0, -0x28(%rsp)
movq -0x20(%rsp), %rax
cmpq -0x10(%rsp), %rax
jae 0x14dad
movq -0x8(%rsp), %rax
movq -0x20(%rsp), %rcx
movsbl (%rax,%rcx), %eax
movzbl -0x11(%rsp), %ecx
cmpl %ecx, %eax
jne 0x14d75
movq -0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rsp)
jmp 0x14dab
movq -0x8(%rsp), %rax
movq -0x20(%rsp), %rcx
movb (%rax,%rcx), %dl
movq -0x8(%rsp), %rax
movq -0x28(%rsp), %rcx
movb %dl, (%rax,%rcx)
movq -0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rsp)
movq -0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rsp)
jmp 0x14d42
movq -0x8(%rsp), %rax
movq -0x28(%rsp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x28(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JesseBuesking[P]omnomnum/util.c
// Function: replace_char_inplace
void replace_char_inplace(char *str, size_t str_len, const unsigned char remove, const unsigned char replacement) {
    size_t index = 0;
    for(;index < str_len; index++) {
        if (str[index] == remove) {
            str[index] = replacement;
        }
    }
}

// Assembly:
movb %cl, %al
movb %dl, %cl
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movb %cl, -0x11(%rsp)
movb %al, -0x12(%rsp)
movq $0x0, -0x20(%rsp)
movq -0x20(%rsp), %rax
cmpq -0x10(%rsp), %rax
jae 0x14e35
movq -0x8(%rsp), %rax
movq -0x20(%rsp), %rcx
movsbl (%rax,%rcx), %eax
movzbl -0x11(%rsp), %ecx
cmpl %ecx, %eax
jne 0x14e23
movb -0x12(%rsp), %dl
movq -0x8(%rsp), %rax
movq -0x20(%rsp), %rcx
movb %dl, (%rax,%rcx)
jmp 0x14e25
movq -0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rsp)
jmp 0x14def
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JesseBuesking[P]omnomnum/util.c
// Function: replace_two_byte_char_inplace
size_t replace_two_byte_char_inplace(unsigned char *str, size_t str_len, const unsigned char* remove, const unsigned char replacement) {
    size_t orig_index = 0, new_index = 0;
    for(;orig_index < str_len - 1;) {
        if (str[orig_index] == remove[0] && str[orig_index + 1] == remove[1]) {
            str[new_index] = replacement;
            orig_index += 2;
            new_index += 1;
        } else {
            str[new_index] = str[orig_index];
            orig_index += 1;
            new_index += 1;
        }
    }

    str[new_index] = '\0';
    return new_index;
}

// Assembly:
movb %cl, %al
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movb %al, -0x19(%rsp)
movq $0x0, -0x28(%rsp)
movq $0x0, -0x30(%rsp)
movq -0x28(%rsp), %rax
movq -0x10(%rsp), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0x14f1e
movq -0x8(%rsp), %rax
movq -0x28(%rsp), %rcx
movzbl (%rax,%rcx), %eax
movq -0x18(%rsp), %rcx
movzbl (%rcx), %ecx
cmpl %ecx, %eax
jne 0x14ee3
movq -0x8(%rsp), %rax
movq -0x28(%rsp), %rcx
movzbl 0x1(%rax,%rcx), %eax
movq -0x18(%rsp), %rcx
movzbl 0x1(%rcx), %ecx
cmpl %ecx, %eax
jne 0x14ee3
movb -0x19(%rsp), %dl
movq -0x8(%rsp), %rax
movq -0x30(%rsp), %rcx
movb %dl, (%rax,%rcx)
movq -0x28(%rsp), %rax
addq $0x2, %rax
movq %rax, -0x28(%rsp)
movq -0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rsp)
jmp 0x14f19
movq -0x8(%rsp), %rax
movq -0x28(%rsp), %rcx
movb (%rax,%rcx), %dl
movq -0x8(%rsp), %rax
movq -0x30(%rsp), %rcx
movb %dl, (%rax,%rcx)
movq -0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rsp)
movq -0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rsp)
jmp 0x14e67
movq -0x8(%rsp), %rax
movq -0x30(%rsp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x30(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/JesseBuesking[P]omnomnum/grisu2/grisu2.c
// Function: fill_double
bool fill_double(double v, char* buffer) {
    if (v == 0) {
        strcpy(buffer, "0.0");
        return 1;
    } else {
        if (v < 0) {
            *buffer++ = '-';
            v = -v;
        }

        int length, K;
        grisu2(v, buffer, &length, &K);
#ifndef HUMAN_READABLE
        buffer[length] = 'e';
        fill_exponent(K, &buffer[length+1]);
#else
        prettify_string(buffer, 0, length, K);
#endif
        return 1;
    }
}

// Assembly:
subq $0x28, %rsp
movsd %xmm0, 0x18(%rsp)
movq %rdi, 0x10(%rsp)
movsd 0x18(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x14f78
jp 0x14f78
movq 0x10(%rsp), %rdi
leaq 0x6a44(%rip), %rsi      # 0x1b9b0
callq 0x1040
movb $0x1, 0x27(%rsp)
jmp 0x14fed
xorps %xmm0, %xmm0
ucomisd 0x18(%rsp), %xmm0
jbe 0x14fba
movq 0x10(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rsp)
movb $0x2d, (%rax)
movsd 0x18(%rsp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x18(%rsp), %xmm0
movq 0x10(%rsp), %rdi
leaq 0xc(%rsp), %rsi
leaq 0x8(%rsp), %rdx
callq 0x15000
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %edx
movl 0x8(%rsp), %ecx
xorl %esi, %esi
callq 0x151f0
movb $0x1, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JesseBuesking[P]omnomnum/grisu2/grisu2.c
// Function: grisu2
void grisu2(double v, char* buffer, int* length, int* K) {
  diy_fp_t w_m, w_p;
  int q = 64, alpha = -59, gamma = -56; int pos;
  normalized_boundaries(v, &w_m, &w_p);
  diy_fp_t w = normalize_diy_fp(double2diy_fp(v));
  int mk = k_comp(w_p.e + q, alpha, gamma);
  diy_fp_t c_mk = cached_power(mk);
  diy_fp_t W  = multiply(w,   c_mk);
  diy_fp_t Wp = multiply(w_p, c_mk);
  diy_fp_t Wm = multiply(w_m, c_mk);
  Wm.f++; Wp.f--;
  diy_fp_t delta = minus(Wp, Wm);
  *K = -mk;
  digit_gen(W, Wp, delta, buffer, length, K);
}

// Assembly:
subq $0xe8, %rsp
movsd %xmm0, 0xe0(%rsp)
movq %rdi, 0xd8(%rsp)
movq %rsi, 0xd0(%rsp)
movq %rdx, 0xc8(%rsp)
movl $0x40, 0xa4(%rsp)
movl $0xffffffc5, 0xa0(%rsp) # imm = 0xFFFFFFC5
movl $0xffffffc8, 0x9c(%rsp) # imm = 0xFFFFFFC8
movsd 0xe0(%rsp), %xmm0
leaq 0xb8(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
callq 0x158a0
movsd 0xe0(%rsp), %xmm0
callq 0x15a40
movq %rax, 0x78(%rsp)
movl %edx, 0x80(%rsp)
movq 0x78(%rsp), %rdi
movl 0x80(%rsp), %esi
callq 0x159c0
movq %rax, 0x88(%rsp)
movl %edx, 0x90(%rsp)
movl 0xb0(%rsp), %edi
addl 0xa4(%rsp), %edi
movl 0xa0(%rsp), %esi
movl 0x9c(%rsp), %edx
callq 0x15ad0
movl %eax, 0x74(%rsp)
movl 0x74(%rsp), %edi
callq 0x15b10
movq %rax, 0x60(%rsp)
movl %edx, 0x68(%rsp)
movq 0x88(%rsp), %rdi
movl 0x90(%rsp), %esi
movq 0x60(%rsp), %rdx
movl 0x68(%rsp), %ecx
callq 0x15b60
movq %rax, 0x50(%rsp)
movl %edx, 0x58(%rsp)
movq 0xa8(%rsp), %rdi
movl 0xb0(%rsp), %esi
movq 0x60(%rsp), %rdx
movl 0x68(%rsp), %ecx
callq 0x15b60
movq %rax, 0x40(%rsp)
movl %edx, 0x48(%rsp)
movq 0xb8(%rsp), %rdi
movl 0xc0(%rsp), %esi
movq 0x60(%rsp), %rdx
movl 0x68(%rsp), %ecx
callq 0x15b60
movq %rax, 0x30(%rsp)
movl %edx, 0x38(%rsp)
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
movq 0x40(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rdi
movl 0x48(%rsp), %esi
movq 0x30(%rsp), %rdx
movl 0x38(%rsp), %ecx
callq 0x15860
movq %rax, 0x20(%rsp)
movl %edx, 0x28(%rsp)
xorl %ecx, %ecx
subl 0x74(%rsp), %ecx
movq 0xc8(%rsp), %rax
movl %ecx, (%rax)
movq 0xd8(%rsp), %r11
movq 0xd0(%rsp), %r10
movq 0xc8(%rsp), %rax
movq 0x50(%rsp), %rdi
movl 0x58(%rsp), %esi
movq 0x40(%rsp), %rdx
movl 0x48(%rsp), %ecx
movq 0x20(%rsp), %r8
movl 0x28(%rsp), %r9d
movq %r11, (%rsp)
movq %r10, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x15570
addq $0xe8, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JesseBuesking[P]omnomnum/grisu2/grisu2.c
// Function: grisu_round
void grisu_round(char* buffer, int len,
		 uint64_t delta, uint64_t rest,
		 uint64_t ten_kappa, uint64_t wp_w) {
  while (rest < wp_w &&
	 delta - rest >= ten_kappa &&
	 (rest + ten_kappa < wp_w || /// closer
	 wp_w - rest > rest+ten_kappa - wp_w))
  {
    buffer[len-1]--; rest += ten_kappa;
  }
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movq %rdx, -0x18(%rsp)
movq %rcx, -0x20(%rsp)
movq %r8, -0x28(%rsp)
movq %r9, -0x30(%rsp)
movq -0x20(%rsp), %rcx
xorl %eax, %eax
cmpq -0x30(%rsp), %rcx
movb %al, -0x31(%rsp)
jae 0x15538
movq -0x18(%rsp), %rcx
subq -0x20(%rsp), %rcx
xorl %eax, %eax
cmpq -0x28(%rsp), %rcx
movb %al, -0x31(%rsp)
jb 0x15538
movq -0x20(%rsp), %rcx
addq -0x28(%rsp), %rcx
movb $0x1, %al
cmpq -0x30(%rsp), %rcx
movb %al, -0x32(%rsp)
jb 0x15530
movq -0x30(%rsp), %rax
subq -0x20(%rsp), %rax
movq -0x20(%rsp), %rcx
addq -0x28(%rsp), %rcx
subq -0x30(%rsp), %rcx
cmpq %rcx, %rax
seta %al
movb %al, -0x32(%rsp)
movb -0x32(%rsp), %al
movb %al, -0x31(%rsp)
movb -0x31(%rsp), %al
testb $0x1, %al
jne 0x15542
jmp 0x1556e
movq -0x8(%rsp), %rax
movl -0xc(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %dl
addb $-0x1, %dl
movb %dl, (%rax,%rcx)
movq -0x28(%rsp), %rax
addq -0x20(%rsp), %rax
movq %rax, -0x20(%rsp)
jmp 0x154cd
retq
nop
// File: /workspace/github_c_makefile_star2_O0/JesseBuesking[P]omnomnum/grisu2/double.h
// Function: normalized_boundaries
static void normalized_boundaries(double d, diy_fp_t* out_m_minus, diy_fp_t* out_m_plus) {
    diy_fp_t v = double2diy_fp(d);
    diy_fp_t pl, mi;
    bool significand_is_zero = v.f == DP_HIDDEN_BIT;
    pl.f  = (v.f << 1) + 1; pl.e  = v.e - 1;
    pl = normalize_boundary(pl);
    if (significand_is_zero)
    {
	mi.f = (v.f << 2) - 1;
	mi.e = v.e - 2;
    } else {
	mi.f = (v.f << 1) - 1;
	mi.e = v.e - 1;
    }
    mi.f <<= mi.e - pl.e;
    mi.e = pl.e;
    *out_m_plus = pl;
    *out_m_minus = mi;
}

// Assembly:
subq $0x68, %rsp
movsd %xmm0, 0x60(%rsp)
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movsd 0x60(%rsp), %xmm0
callq 0x15a40
movq %rax, 0x40(%rsp)
movl %edx, 0x48(%rsp)
movabsq $0x10000000000000, %rax # imm = 0x10000000000000
cmpq %rax, 0x40(%rsp)
sete %al
andb $0x1, %al
movb %al, 0x1f(%rsp)
movq 0x40(%rsp), %rax
shlq %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
movl 0x48(%rsp), %eax
subl $0x1, %eax
movl %eax, 0x38(%rsp)
movq 0x30(%rsp), %rdi
movl 0x38(%rsp), %esi
callq 0x15df0
movq %rax, 0x8(%rsp)
movl %edx, 0x10(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x38(%rsp)
testb $0x1, 0x1f(%rsp)
je 0x1594d
movq 0x40(%rsp), %rax
shlq $0x2, %rax
subq $0x1, %rax
movq %rax, 0x20(%rsp)
movl 0x48(%rsp), %eax
subl $0x2, %eax
movl %eax, 0x28(%rsp)
jmp 0x15969
movq 0x40(%rsp), %rax
shlq %rax
subq $0x1, %rax
movq %rax, 0x20(%rsp)
movl 0x48(%rsp), %eax
subl $0x1, %eax
movl %eax, 0x28(%rsp)
movl 0x28(%rsp), %ecx
subl 0x38(%rsp), %ecx
movq 0x20(%rsp), %rax
movl %ecx, %ecx
shlq %cl, %rax
movq %rax, 0x20(%rsp)
movl 0x38(%rsp), %eax
movl %eax, 0x28(%rsp)
movq 0x50(%rsp), %rax
movq 0x30(%rsp), %rcx
movq %rcx, (%rax)
movq 0x38(%rsp), %rcx
movq %rcx, 0x8(%rax)
movq 0x58(%rsp), %rax
movq 0x20(%rsp), %rcx
movq %rcx, (%rax)
movq 0x28(%rsp), %rcx
movq %rcx, 0x8(%rax)
addq $0x68, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/JesseBuesking[P]omnomnum/grisu2/double.h
// Function: normalize_diy_fp
static diy_fp_t normalize_diy_fp(diy_fp_t in) {
    diy_fp_t res = in;
    /* Normalize now */
    /* the original number could have been a denormal. */
    while (! (res.f & DP_HIDDEN_BIT))
    {
	res.f <<= 1;
	res.e--;
    }
    /* do the final shifts in one go. Don't forget the hidden bit (the '-1') */
    res.f <<= (DIY_SIGNIFICAND_SIZE - DP_SIGNIFICAND_SIZE - 1);
    res.e = res.e - (DIY_SIGNIFICAND_SIZE - DP_SIGNIFICAND_SIZE - 1);
    return res;
}

// Assembly:
movq %rdi, -0x20(%rsp)
movl %esi, -0x18(%rsp)
movq -0x20(%rsp), %rax
movq %rax, -0x10(%rsp)
movq -0x18(%rsp), %rax
movq %rax, -0x8(%rsp)
movabsq $0x10000000000000, %rax # imm = 0x10000000000000
andq -0x10(%rsp), %rax
cmpq $0x0, %rax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x159fb
jmp 0x15a15
movq -0x10(%rsp), %rax
shlq %rax
movq %rax, -0x10(%rsp)
movl -0x8(%rsp), %eax
addl $-0x1, %eax
movl %eax, -0x8(%rsp)
jmp 0x159dd
movq -0x10(%rsp), %rax
shlq $0xb, %rax
movq %rax, -0x10(%rsp)
movl -0x8(%rsp), %eax
addl $-0xb, %eax
movl %eax, -0x8(%rsp)
movq -0x10(%rsp), %rax
movl -0x8(%rsp), %edx
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JesseBuesking[P]omnomnum/grisu2/double.h
// Function: double2diy_fp
static diy_fp_t double2diy_fp(double d) {
    uint64_t d64 = double_to_uint64(d);
    int biased_e = (d64 & DP_EXPONENT_MASK) >> DP_SIGNIFICAND_SIZE;
    uint64_t significand = (d64 & DP_SIGNIFICAND_MASK);
    diy_fp_t res;
    if (biased_e != 0)
    {
	res.f = significand + DP_HIDDEN_BIT;
	res.e = biased_e - DP_EXPONENT_BIAS;
    } else {
	res.f = significand;
	res.e = DP_MIN_EXPONENT + 1;
    }
    return res;
}

// Assembly:
subq $0x38, %rsp
movsd %xmm0, 0x20(%rsp)
movsd 0x20(%rsp), %xmm0
callq 0x15e70
movq %rax, 0x18(%rsp)
movabsq $0x7ff0000000000000, %rax # imm = 0x7FF0000000000000
andq 0x18(%rsp), %rax
shrq $0x34, %rax
movl %eax, 0x14(%rsp)
movabsq $0xfffffffffffff, %rax  # imm = 0xFFFFFFFFFFFFF
andq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpl $0x0, 0x14(%rsp)
je 0x15aaf
movabsq $0x10000000000000, %rax # imm = 0x10000000000000
addq 0x8(%rsp), %rax
movq %rax, 0x28(%rsp)
movl 0x14(%rsp), %eax
subl $0x433, %eax            # imm = 0x433
movl %eax, 0x30(%rsp)
jmp 0x15ac1
movq 0x8(%rsp), %rax
movq %rax, 0x28(%rsp)
movl $0xfffffbce, 0x30(%rsp) # imm = 0xFFFFFBCE
movq 0x28(%rsp), %rax
movl 0x30(%rsp), %edx
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/JesseBuesking[P]omnomnum/grisu2/powers_ten_round64.h
// Function: cached_power
static diy_fp_t cached_power(int k) {
  diy_fp_t res;
  int index = 343 + k;
  res.f = powers_ten[index];
  res.e = powers_ten_e[index];
  return res;
}

// Assembly:
movl %edi, -0x14(%rsp)
movl -0x14(%rsp), %eax
addl $0x157, %eax            # imm = 0x157
movl %eax, -0x18(%rsp)
movslq -0x18(%rsp), %rcx
leaq 0x5e93(%rip), %rax      # 0x1b9c0
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rsp)
movslq -0x18(%rsp), %rcx
leaq 0x73fe(%rip), %rax      # 0x1cf40
movl (%rax,%rcx,4), %eax
movl %eax, -0x8(%rsp)
movq -0x10(%rsp), %rax
movl -0x8(%rsp), %edx
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JesseBuesking[P]omnomnum/grisu2/diy_fp.h
// Function: multiply
static diy_fp_t multiply(diy_fp_t x, diy_fp_t y) {
    uint64_t a,b,c,d,ac,bc,ad,bd,tmp,h;
  diy_fp_t r; uint64_t M32 = 0xFFFFFFFF;
  a = x.f >> 32; b = x.f & M32;
  c = y.f >> 32; d = y.f & M32;
  ac = a*c; bc = b*c; ad = a*d; bd = b*d;
  tmp = (bd>>32) + (ad&M32) + (bc&M32);
  tmp += 1U << 31; /// mult_round
  r.f = ac+(ad>>32)+(bc>>32)+(tmp >>32);
  r.e = x.e + y.e + 64;
  return r;
}

// Assembly:
pushq %rax
movq %rdi, -0x18(%rsp)
movl %esi, -0x10(%rsp)
movq %rdx, -0x28(%rsp)
movl %ecx, -0x20(%rsp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movq %rax, -0x80(%rsp)
movl -0x14(%rsp), %eax
movq %rax, -0x30(%rsp)
movq -0x18(%rsp), %rax
movq -0x80(%rsp), %rcx
andq %rcx, %rax
movq %rax, -0x38(%rsp)
movl -0x24(%rsp), %eax
movq %rax, -0x40(%rsp)
movq -0x28(%rsp), %rax
movq -0x80(%rsp), %rcx
andq %rcx, %rax
movq %rax, -0x48(%rsp)
movq -0x30(%rsp), %rax
movq -0x40(%rsp), %rcx
imulq %rcx, %rax
movq %rax, -0x50(%rsp)
movq -0x38(%rsp), %rax
movq -0x40(%rsp), %rcx
imulq %rcx, %rax
movq %rax, -0x58(%rsp)
movq -0x30(%rsp), %rax
movq -0x48(%rsp), %rcx
imulq %rcx, %rax
movq %rax, -0x60(%rsp)
movq -0x38(%rsp), %rax
movq -0x48(%rsp), %rcx
imulq %rcx, %rax
movq %rax, -0x68(%rsp)
movl -0x64(%rsp), %eax
movq -0x60(%rsp), %rcx
movq -0x80(%rsp), %rdx
andq %rdx, %rcx
addq %rcx, %rax
movq -0x58(%rsp), %rcx
andq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x70(%rsp)
movq -0x70(%rsp), %rax
subq $-0x80000000, %rax      # imm = 0x80000000
movq %rax, -0x70(%rsp)
movq -0x50(%rsp), %rax
movl -0x5c(%rsp), %ecx
addq %rcx, %rax
movl -0x54(%rsp), %ecx
addq %rcx, %rax
movl -0x6c(%rsp), %ecx
addq %rcx, %rax
movq %rax, -0x8(%rsp)
movl -0x10(%rsp), %edx
movl -0x20(%rsp), %eax
movl %eax, %ecx
movl %edx, %eax
leal 0x40(%rax,%rcx), %eax
movl %eax, (%rsp)
movq -0x8(%rsp), %rax
movl (%rsp), %edx
popq %rcx
retq
nop
// File: /workspace/github_c_makefile_star2_O0/JesseBuesking[P]omnomnum/grisu2/fast_exponent.h
// Function: fill_exponent
static void fill_exponent(int K, char* buffer) {
    int i = 0;
    if (K < 0) {
	buffer[i++] = '-';
	K = -K;
    }
    if (K >= 100) {
	buffer[i++] = '0' + K / 100; K %= 100;
	buffer[i++] = '0' + K / 10; K %= 10;
	buffer[i++] = '0' + K;
    } else if (K >= 10) {
	buffer[i++] = '0' + K / 10; K %= 10;
	buffer[i++] = '0' + K;
    } else {
	buffer[i++] = '0' + K;
    }
    buffer[i] = '\0';
}

// Assembly:
movl %edi, -0x4(%rsp)
movq %rsi, -0x10(%rsp)
movl $0x0, -0x14(%rsp)
cmpl $0x0, -0x4(%rsp)
jge 0x15cab
movq -0x10(%rsp), %rax
movl -0x14(%rsp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x14(%rsp)
movslq %ecx, %rcx
movb $0x2d, (%rax,%rcx)
xorl %eax, %eax
subl -0x4(%rsp), %eax
movl %eax, -0x4(%rsp)
cmpl $0x64, -0x4(%rsp)
jl 0x15d4e
movl -0x4(%rsp), %eax
movl $0x64, %ecx
cltd
idivl %ecx
addl $0x30, %eax
movb %al, %dl
movq -0x10(%rsp), %rax
movl -0x14(%rsp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x14(%rsp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0x4(%rsp), %eax
movl $0x64, %ecx
cltd
idivl %ecx
movl %edx, -0x4(%rsp)
movl -0x4(%rsp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
addl $0x30, %eax
movb %al, %dl
movq -0x10(%rsp), %rax
movl -0x14(%rsp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x14(%rsp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0x4(%rsp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl %edx, -0x4(%rsp)
movl -0x4(%rsp), %eax
addl $0x30, %eax
movb %al, %dl
movq -0x10(%rsp), %rax
movl -0x14(%rsp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x14(%rsp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
jmp 0x15dd4
cmpl $0xa, -0x4(%rsp)
jl 0x15db1
movl -0x4(%rsp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
addl $0x30, %eax
movb %al, %dl
movq -0x10(%rsp), %rax
movl -0x14(%rsp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x14(%rsp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0x4(%rsp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl %edx, -0x4(%rsp)
movl -0x4(%rsp), %eax
addl $0x30, %eax
movb %al, %dl
movq -0x10(%rsp), %rax
movl -0x14(%rsp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x14(%rsp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
jmp 0x15dd2
movl -0x4(%rsp), %eax
addl $0x30, %eax
movb %al, %dl
movq -0x10(%rsp), %rax
movl -0x14(%rsp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x14(%rsp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
jmp 0x15dd4
movq -0x10(%rsp), %rax
movslq -0x14(%rsp), %rcx
movb $0x0, (%rax,%rcx)
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JesseBuesking[P]omnomnum/grisu2/double.h
// Function: normalize_boundary
static diy_fp_t normalize_boundary(diy_fp_t in) {
    diy_fp_t res = in;
    /* Normalize now */
    /* the original number could have been a denormal. */
    while (! (res.f & (DP_HIDDEN_BIT << 1)))
    {
	res.f <<= 1;
	res.e--;
    }
    /* do the final shifts in one go. Don't forget the hidden bit (the '-1') */
    res.f <<= (DIY_SIGNIFICAND_SIZE - DP_SIGNIFICAND_SIZE - 2);
    res.e = res.e - (DIY_SIGNIFICAND_SIZE - DP_SIGNIFICAND_SIZE - 2);
    return res;
}

// Assembly:
movq %rdi, -0x20(%rsp)
movl %esi, -0x18(%rsp)
movq -0x20(%rsp), %rax
movq %rax, -0x10(%rsp)
movq -0x18(%rsp), %rax
movq %rax, -0x8(%rsp)
movabsq $0x20000000000000, %rax # imm = 0x20000000000000
andq -0x10(%rsp), %rax
cmpq $0x0, %rax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x15e2b
jmp 0x15e45
movq -0x10(%rsp), %rax
shlq %rax
movq %rax, -0x10(%rsp)
movl -0x8(%rsp), %eax
addl $-0x1, %eax
movl %eax, -0x8(%rsp)
jmp 0x15e0d
movq -0x10(%rsp), %rax
shlq $0xa, %rax
movq %rax, -0x10(%rsp)
movl -0x8(%rsp), %eax
addl $-0xa, %eax
movl %eax, -0x8(%rsp)
movq -0x10(%rsp), %rax
movl -0x8(%rsp), %edx
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JesseBuesking[P]omnomnum/branchlut/branchlut.c
// Function: i32toa_branchlut
int i32toa_branchlut(int32_t value, char* buffer) {
    uint32_t u = (uint32_t) (value);
    if (value < 0) {
        *buffer++ = '-';
        u = ~u + 1;

        // Adding 1 to account for the negative sign.
        return u32toa_branchlut(u, buffer) + 1;
    }

    return u32toa_branchlut(u, buffer);
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movl 0x10(%rsp), %eax
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x10(%rsp)
jge 0x16415
movq 0x8(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rsp)
movb $0x2d, (%rax)
movl 0x4(%rsp), %eax
xorl $-0x1, %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %edi
movq 0x8(%rsp), %rsi
callq 0x15e90
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x16427
movl 0x4(%rsp), %edi
movq 0x8(%rsp), %rsi
callq 0x15e90
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/JesseBuesking[P]omnomnum/branchlut/branchlut.c
// Function: i64toa_branchlut
int i64toa_branchlut(int64_t value, char* buffer) {
    uint64_t u = (uint64_t) (value);
    if (value < 0) {
        *buffer++ = '-';
        u = ~u + 1;

        // Adding 1 to account for the negative sign.
        return u64toa_branchlut(u, buffer) + 1;
    }

    return u64toa_branchlut(u, buffer);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x18(%rsp)
jge 0x170ee
movq 0x10(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rsp)
movb $0x2d, (%rax)
movq 0x8(%rsp), %rax
xorq $-0x1, %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x16430
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x17101
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x16430
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)