LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_name.c
// Function: name_map_s_create_self
static bcore_self_s* name_map_s_create_self( void )
{
    sc_t def = "\
        bcore_name_map_s = bcore_inst \
            { \
                aware_t _; \
                private bcore_name_s* data; \
                private bl_t* flags; \
                private uz_t size; \
                private uz_t depth_limit; \
                private uz_t size_limit; \
                shell { bcore_name_s []; } data; } \
            }";
    bcore_self_s* self = BCORE_SELF_S_BUILD_PARSE_SC( def, bcore_name_map_s );
    bcore_self_s_push_ns_func( self, ( fp_t )bcore_name_map_s_init,    "bcore_fp_init",  "init"     );
    bcore_self_s_push_ns_func( self, ( fp_t )bcore_name_map_s_down,    "bcore_fp_down",  "down"     );
    bcore_self_s_push_ns_func( self, ( fp_t )bcore_name_map_s_copy,    "bcore_fp_copy",  "copy"     );
    bcore_self_s_push_ns_func( self, ( fp_t )name_map_s_get_data,      "bcore_fp_get",   "get_data" );
    bcore_self_s_push_ns_func( self, ( fp_t )name_map_s_set_data,      "bcore_fp_set",   "set_data" );
    return self;
}

// Assembly:
pushq %rbx
leaq 0x245c7(%rip), %rdi     # 0xcd1e1
pushq $0x30
popq %rsi
pushq $0x8
popq %rdx
callq 0x64356
movq %rax, %rbx
leaq -0x636(%rip), %rsi      # 0xa85f9
leaq 0x17b85(%rip), %rdx     # 0xc07bb
leaq 0x17b87(%rip), %rcx     # 0xc07c4
movq %rax, %rdi
callq 0x63a2b
leaq -0x5d0(%rip), %rsi      # 0xa867c
leaq 0x17b76(%rip), %rdx     # 0xc07c9
leaq 0xb98e(%rip), %rcx      # 0xb45e8
movq %rbx, %rdi
callq 0x63a2b
leaq -0x5e8(%rip), %rsi      # 0xa8681
leaq 0x17b67(%rip), %rdx     # 0xc07d7
leaq 0x130dd(%rip), %rcx     # 0xbbd54
movq %rbx, %rdi
callq 0x63a2b
leaq 0x1b1(%rip), %rsi       # 0xa8e37
leaq 0x18c9a(%rip), %rdx     # 0xc1927
leaq 0xe548(%rip), %rcx      # 0xb71dc
movq %rbx, %rdi
callq 0x63a2b
leaq 0x2aa(%rip), %rsi       # 0xa8f4d
leaq 0x18c70(%rip), %rdx     # 0xc191a
leaq 0x1ab81(%rip), %rcx     # 0xc3832
movq %rbx, %rdi
callq 0x63a2b
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_name.c
// Function: name_s_set_name_st
static void name_s_set_name_st( bcore_name_s* o, sr_s sr )
{
    bcore_release( o->name );
    assert( sr_s_type( &sr ) == TYPEOF_st_s );
    o->name = bcore_strcpy( NULL, ( ( st_s* )sr.o )->sc );
    sr_down( sr );
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x60272
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rsi
xorl %edi, %edi
callq 0x6036a
movq %rax, 0x10(%rbx)
testb $0x2, 0x20(%rsp)
jne 0xa8e31
popq %rbx
retq
popq %rbx
jmp 0x8cdc1
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_name.c
// Function: name_map_s_get_data
static sr_s name_map_s_get_data( const bcore_name_map_s* o )
{
    tp_t t_data = bcore_flect_type_parse_sc( "{ bcore_name_s []; }" );
    tp_t t_node = typeof( "bcore_name_s" );
    sr_s data = sr_cp( sr_create( t_data ), TYPEOF_bcore_array_s );
    for( uz_t i = 0; i < o->size; i++ )
    {
        if( o->data[ i ].key ) bcore_array_r_push( &data, sr_twc( t_node, &o->data[ i ] ) );
    }
    return data;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x244e6(%rip), %rdi     # 0xcd338
callq 0x65033
movq %rax, %r13
leaq 0x1c2ff(%rip), %rdi     # 0xc5160
callq 0xa849f
movq %rax, %r15
movq %r13, %rdi
callq 0x8cd0a
movq %rax, 0x20(%rsp)
testq %r13, %r13
je 0xa8e88
movq %r13, %rdi
callq 0x8cd25
movq %rax, %rdi
jmp 0xa8e8a
xorl %edi, %edi
movabsq $-0x5073d588c3beb52e, %rsi # imm = 0xAF8C2A773C414AD2
callq 0x7abc8
movq %rax, %rbp
movq 0x20(%rsp), %rax
movq %rax, (%rbx)
movq %rbp, 0x8(%rbx)
movq %rbx, 0x28(%rsp)
movq $0x2, 0x10(%rbx)
xorl %ebx, %ebx
xorl %r13d, %r13d
cmpq 0x18(%r14), %r13
jae 0xa8f39
movq 0x8(%r14), %r12
cmpq $0x0, (%r12,%rbx)
je 0xa8f30
testq %r15, %r15
je 0xa8eda
movq %r15, %rdi
callq 0x8cd25
jmp 0xa8edc
xorl %eax, %eax
addq %rbx, %r12
movq %r12, 0x30(%rsp)
movq %rax, 0x38(%rsp)
movq $0x1, 0x40(%rsp)
movq 0x8(%rbp), %rax
movq %rbp, %rdi
movabsq $-0x5073d588c3beb52e, %rcx # imm = 0xAF8C2A773C414AD2
cmpq %rcx, %rax
je 0xa8f13
movq %rax, %rdi
callq 0xa9023
movq %rax, %rdi
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x30(%rsp), %xmm0
movups %xmm0, (%rsp)
movq 0x20(%rsp), %rsi
callq 0x7c34a
incq %r13
addq $0x18, %rbx
jmp 0xa8eba
movq 0x28(%rsp), %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_name.c
// Function: name_map_s_set_data
static void name_map_s_set_data( bcore_name_map_s* o, sr_s data )
{
    bcore_name_map_s_clear( o );
    assert( sr_s_type( &data ) == bcore_flect_type_parse_sc( "{ bcore_name_s []; }" ) );
    data = sr_cp( data, TYPEOF_bcore_array_s );
    uz_t size = bcore_array_r_get_size( &data );
    bcore_name_s* src = bcore_array_r_get_d_data( &data );
    for( uz_t i = 0; i < size; i++ )
    {
        bcore_name_map_s_set( o, src[ i ] );
        src[ i ].name = NULL;
    }
    sr_down( data );
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %r14
leaq 0x70(%rsp), %rbx
callq 0xa861d
movq (%rbx), %r15
movq 0x8(%rbx), %rdi
movq 0x10(%rbx), %r13
movabsq $-0x5073d588c3beb52e, %r12 # imm = 0xAF8C2A773C414AD2
movq %r12, %rsi
callq 0x7abc8
movq %r15, (%rbx)
movq %rax, 0x8(%rbx)
movq %r13, 0x10(%rbx)
movq 0x8(%rax), %rdi
cmpq %r12, %rdi
je 0xa8f9d
callq 0xa9023
movq %rax, %rdi
movq %r15, %rsi
callq 0x7c954
movq %rax, %r15
movq %rbx, %rdi
callq 0x7e717
movq %rax, %r12
addq $0x10, %r12
subq $0x1, %r15
jb 0xa8ffa
movq (%r12), %rax
movq %rax, 0x30(%rsp)
movups -0x10(%r12), %xmm0
movaps %xmm0, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movaps 0x20(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %r14, %rdi
callq 0xa8752
andq $0x0, (%r12)
addq $0x18, %r12
jmp 0xa8fba
testb $0x2, 0x10(%rbx)
je 0xa9015
movq 0x10(%rbx), %rax
movq %rax, 0x10(%rsp)
movups (%rbx), %xmm0
movups %xmm0, (%rsp)
callq 0x8cdc1
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/./bcore_spect_array.h
// Function: bcore_array_s_get_typed
BCORE_DECLARE_SPECT( bcore_array )
{
    bcore_spect_header_s header;

    tp_t type_caps;
    uz_t size_fix;    // >0 indicating fixed size array
    uz_t caps_offset; // location of low-level array structure in object

    const bcore_inst_s* item_p;  // item-perspective; NULL for typed or aware arrays

    sr_s ( *get )( const bcore_array_s* p, vc_t o, uz_t index ); // returns indexed item; NULL reference if index is out of range or the linked item is NULL
    void ( *set )( const bcore_array_s* p, vd_t o, uz_t index, sr_s src ); // sets item at indexed position; if index is out of size, size is increased

    /// quick-access state parameters
    bl_t is_static;     // elements are static (type of elements need not be recorded)
    bl_t is_of_aware;   // elements are all self-aware
    bl_t is_of_links;   // elements are links (means they can be NULL);
    bl_t is_mono_typed; // elements have all the same type
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x6edef(%rip), %rax     # 0x117e20
movl (%rax), %ecx
movslq %ecx, %rcx
imulq $0x18, %rcx, %rcx
movq 0x20(%rax,%rcx), %rdx
movq 0x18(%rax,%rcx), %rcx
andq %rdi, %rcx
shlq $0x4, %rcx
leaq (%rdx,%rcx), %rax
movq (%rdx,%rcx), %rcx
cmpq %rdi, %rcx
jne 0xa905c
pushq $0x8
jmp 0xa9081
movq 0x10(%rax), %rcx
cmpq %rbx, %rcx
jne 0xa9069
pushq $0x18
jmp 0xa9081
movq 0x20(%rax), %rcx
cmpq %rbx, %rcx
jne 0xa9076
pushq $0x28
jmp 0xa9081
movq 0x30(%rax), %rcx
cmpq %rbx, %rcx
jne 0xa908b
pushq $0x38
popq %rcx
movq (%rax,%rcx), %r14
testq %r14, %r14
jne 0xa90b2
movabsq $-0x5073d588c3beb52e, %rdi # imm = 0xAF8C2A773C414AD2
movq %rbx, %rsi
callq 0x79b94
movq %rax, %r14
leaq 0x6ed79(%rip), %rdi     # 0x117e20
movq %rbx, %rsi
movq %rax, %rdx
callq 0x98d4b
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_prsg.c
// Function: bcore_prsg_signal_handler
vd_t bcore_prsg_signal_handler( const bcore_signal_s* o )
{
    switch( bcore_signal_s_handle_type( o, typeof( "bcore_prsg" ) ) )
    {
        case TYPEOF_init1:
        {
        }
        break;

        case TYPEOF_selftest:
        {
            selftest();
        }
        break;

        default: break;
    }
    return NULL;
}

// Assembly:
pushq %rbx
subq $0x40, %rsp
movabsq $0x74c295dee84ee713, %rsi # imm = 0x74C295DEE84EE713
callq 0x75141
movabsq $0x7ee758bbfced33e3, %rcx # imm = 0x7EE758BBFCED33E3
cmpq %rcx, %rax
jne 0xa923a
leaq 0x6ece2(%rip), %rax     # 0x117dd0
movq (%rax), %rsi
leaq 0x10(%rsp), %rbx
movq %rbx, 0x8(%rsp)
movq %rbx, %rdi
callq 0x717f5
xorl %eax, %eax
callq 0x30f50
movabsq $-0x1804b258fae5f3f6, %rsi # imm = 0xE7FB4DA7051A0C0A
movq %rbx, %rdi
movq %rax, %rdx
callq 0x71917
movq %rax, %rbx
movq %rax, %rdi
callq 0xa9252
movl $0x4d2, %esi            # imm = 0x4D2
movq %rbx, %rdi
callq *0x88(%rax)
movq %rbx, %rdi
callq 0xa9242
movabsq $0x586800000008ae2b, %rcx # imm = 0x586800000008AE2B
cmpq %rcx, %rax
je 0xa9176
leaq 0x14f1(%rip), %rdi      # 0xaa647
leaq 0x241f0(%rip), %rsi     # 0xcd34d
leaq 0x20ab6(%rip), %rdx     # 0xc9c1a
leaq 0x24216(%rip), %rcx     # 0xcd381
pushq $0x1d
popq %r8
xorl %eax, %eax
callq 0x5ffac
movq %rbx, %rdi
callq 0xa9242
movabsq $-0x7d5bfffff05e5c90, %rcx # imm = 0x82A400000FA1A370
cmpq %rcx, %rax
je 0xa91b4
leaq 0x14b3(%rip), %rdi      # 0xaa647
leaq 0x241f3(%rip), %rsi     # 0xcd38e
leaq 0x20a78(%rip), %rdx     # 0xc9c1a
leaq 0x241d8(%rip), %rcx     # 0xcd381
pushq $0x1e
popq %r8
xorl %eax, %eax
callq 0x5ffac
movq %rbx, %rdi
callq 0xa9242
movabsq $0x4614001c261350b1, %rcx # imm = 0x4614001C261350B1
cmpq %rcx, %rax
je 0xa91f2
leaq 0x1475(%rip), %rdi      # 0xaa647
leaq 0x241e9(%rip), %rsi     # 0xcd3c2
leaq 0x20a3a(%rip), %rdx     # 0xc9c1a
leaq 0x2419a(%rip), %rcx     # 0xcd381
pushq $0x1f
popq %r8
xorl %eax, %eax
callq 0x5ffac
movq %rbx, %rdi
callq 0xa9242
movabsq $-0x2427cd4f6f37b142, %rcx # imm = 0xDBD832B090C84EBE
cmpq %rcx, %rax
je 0xa9230
leaq 0x1437(%rip), %rdi      # 0xaa647
leaq 0x241df(%rip), %rsi     # 0xcd3f6
leaq 0x209fc(%rip), %rdx     # 0xc9c1a
leaq 0x2415c(%rip), %rcx     # 0xcd381
pushq $0x20
popq %r8
xorl %eax, %eax
callq 0x5ffac
leaq 0x8(%rsp), %rdi
callq 0x71b48
xorl %eax, %eax
addq $0x40, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/neovim[P]libvterm/bin/vterm-dump.c
// Function: main
int main(int argc, char *argv[])
{
  int use_colour = isatty(1);

  int opt;
  while((opt = getopt(argc, argv, "c")) != -1) {
    switch(opt) {
      case 'c': use_colour = 1; break;
    }
  }

  const char *file = argv[optind++];

  int fd;
  if(!file || streq(file, "-"))
    fd = 0; // stdin
  else {
    fd = open(file, O_RDONLY);
    if(fd == -1) {
      fprintf(stderr, "Cannot open %s - %s\n", file, strerror(errno));
      exit(1);
    }
  }

  if(use_colour) {
    special_begin = "\x1b[7m{";
    special_end   = "}\x1b[m";
  }

  /* Size matters not for the parser */
  VTerm *vt = vterm_new(25, 80);
  vterm_set_utf8(vt, 1);
  vterm_parser_set_callbacks(vt, &parser_cbs, NULL);
  vterm_parser_set_emit_nul(vt, true);

  int len;
  char buffer[1024];
  while((len = read(fd, buffer, sizeof(buffer))) > 0) {
    vterm_input_write(vt, buffer, len);
  }

  printf("\n");

  close(fd);
  vterm_free(vt);

  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x408, %rsp            # imm = 0x408
movq %rsi, %rbx
movl %edi, %ebp
pushq $0x1
popq %rdi
callq 0x2060
testl %eax, %eax
sete %r15b
leaq 0xda1(%rip), %r14       # 0x3004
movl %ebp, %edi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x2110
cmpl $-0x1, %eax
je 0x227f
cmpl $0x63, %eax
jne 0x2263
xorl %r15d, %r15d
jmp 0x2263
movq 0x2d4a(%rip), %rax      # 0x4fd0
movslq (%rax), %rcx
leal 0x1(%rcx), %edx
movl %edx, (%rax)
movq (%rbx,%rcx,8), %r14
xorl %ebx, %ebx
testq %r14, %r14
je 0x22bd
cmpb $0x2d, (%r14)
jne 0x22a6
cmpb $0x0, 0x1(%r14)
je 0x22bd
movq %r14, %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x20f0
movl %eax, %ebx
cmpl $-0x1, %eax
je 0x2367
testb $0x1, %r15b
jne 0x22df
leaq 0xd51(%rip), %rax       # 0x301b
movq %rax, 0x2ddf(%rip)      # 0x50b0
leaq 0xd49(%rip), %rax       # 0x3021
movq %rax, 0x2dd9(%rip)      # 0x50b8
pushq $0x19
popq %rdi
pushq $0x50
popq %rsi
callq 0x20a0
movq %rax, %r14
pushq $0x1
popq %rbp
movq %rax, %rdi
movl %ebp, %esi
callq 0x2030
leaq 0x2dbf(%rip), %rsi      # 0x50c0
movq %r14, %rdi
xorl %edx, %edx
callq 0x2080
movq %r14, %rdi
movl %ebp, %esi
callq 0x20e0
movq %rsp, %r15
movl $0x400, %edx            # imm = 0x400
movl %ebx, %edi
movq %r15, %rsi
callq 0x20c0
testl %eax, %eax
jle 0x2340
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x2070
jmp 0x2318
pushq $0xa
popq %rdi
callq 0x2040
movl %ebx, %edi
callq 0x20b0
movq %r14, %rdi
callq 0x2100
xorl %eax, %eax
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x2c82(%rip), %rax      # 0x4ff0
movq (%rax), %rbx
callq 0x2050
movl (%rax), %edi
callq 0x2130
leaq 0xc82(%rip), %rsi       # 0x3006
movq %rbx, %rdi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x20d0
pushq $0x1
popq %rdi
callq 0x2120
// File: /workspace/github_c_makefile_star2_O2/neovim[P]libvterm/bin/vterm-dump.c
// Function: parser_text
static int parser_text(const char bytes[], size_t len, void *user)
{
  unsigned char *b = (unsigned char *)bytes;

  int i;
  for(i = 0; i < len; /* none */) {
    if(b[i] < 0x20)        // C0
      break;
    else if(b[i] < 0x80)   // ASCII
      i++;
    else if(b[i] < 0xa0)   // C1
      break;
    else if(b[i] < 0xc0)   // UTF-8 continuation
      break;
    else if(b[i] < 0xe0) { // UTF-8 2-byte
      // 2-byte UTF-8
      if(len < i+2) break;
      i += 2;
    }
    else if(b[i] < 0xf0) { // UTF-8 3-byte
      if(len < i+3) break;
      i += 3;
    }
    else if(b[i] < 0xf8) { // UTF-8 4-byte
      if(len < i+4) break;
      i += 4;
    }
    else                   // otherwise invalid
      break;
  }

  printf("%.*s", i, b);
  return i;
}

// Assembly:
pushq %rbx
movq %rdi, %rdx
xorl %eax, %eax
movl %eax, %ebx
cltq
cmpq %rsi, %rax
jae 0x23e1
movb (%rdx,%rax), %al
cmpb $0x20, %al
jb 0x23e1
testb %al, %al
js 0x23bc
incl %ebx
movl %ebx, %eax
jmp 0x23a2
cmpb $-0x40, %al
jb 0x23e1
cmpb $-0x21, %al
ja 0x23c9
leal 0x2(%rbx), %eax
jmp 0x23d9
cmpb $-0x11, %al
ja 0x23d2
leal 0x3(%rbx), %eax
jmp 0x23d9
cmpb $-0x9, %al
ja 0x23e1
leal 0x4(%rbx), %eax
movslq %eax, %rcx
cmpq %rsi, %rcx
jbe 0x23a2
leaq 0xe23(%rip), %rdi       # 0x320b
movl %ebx, %esi
xorl %eax, %eax
callq 0x2090
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/neovim[P]libvterm/bin/vterm-dump.c
// Function: parser_control
static int parser_control(unsigned char control, void *user)
{
  if(control < 0x20)
    printf("%s%s%s", special_begin, name_c0[control], special_end);
  else if(control == 0x7f)
    printf("%s%s%s", special_begin, "DEL", special_end);
  else if(control >= 0x80 && control < 0xa0 && name_c1[control - 0x80])
    printf("%s%s%s", special_begin, name_c1[control - 0x80], special_end);
  else
    printf("%sCONTROL 0x%02x%s", special_begin, control, special_end);

  if(control == 0x0a)
    printf("\n");
  return 1;
}

// Assembly:
pushq %rbx
movl %edi, %ebx
cmpb $0x20, %bl
jae 0x243d
movq 0x2cac(%rip), %rsi      # 0x50b0
movzbl %bl, %eax
leaq 0xe02(%rip), %rcx       # 0x3210
movslq (%rcx,%rax,4), %rdx
addq %rcx, %rdx
movq 0x2c9c(%rip), %rcx      # 0x50b8
leaq 0xc05(%rip), %rdi       # 0x3028
xorl %eax, %eax
callq 0x2090
cmpb $0xa, %bl
jne 0x24ba
pushq $0xa
popq %rdi
callq 0x2040
jmp 0x24ba
cmpb $0x7f, %bl
jne 0x2467
movq 0x2c67(%rip), %rsi      # 0x50b0
movq 0x2c68(%rip), %rcx      # 0x50b8
leaq 0xbd1(%rip), %rdi       # 0x3028
leaq 0xbd1(%rip), %rdx       # 0x302f
xorl %eax, %eax
callq 0x2090
jmp 0x24ba
cmpb $-0x61, %bl
jg 0x249c
leal -0x80(%rbx), %eax
movl $0x2000013, %ecx        # imm = 0x2000013
btq %rax, %rcx
jb 0x249c
leaq 0x26cf(%rip), %rcx      # 0x4b50
movq (%rcx,%rax,8), %rdx
movq 0x2c24(%rip), %rsi      # 0x50b0
movq 0x2c25(%rip), %rcx      # 0x50b8
leaq 0xb8e(%rip), %rdi       # 0x3028
jmp 0x245e
movq 0x2c0d(%rip), %rsi      # 0x50b0
movq 0x2c0e(%rip), %rcx      # 0x50b8
leaq 0xb82(%rip), %rdi       # 0x3033
movl %ebx, %edx
xorl %eax, %eax
callq 0x2090
pushq $0x1
popq %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/neovim[P]libvterm/bin/vterm-dump.c
// Function: parser_escape
static int parser_escape(const char bytes[], size_t len, void *user)
{
  if(bytes[0] >= 0x20 && bytes[0] < 0x30) {
    if(len < 2)
      return -1;
    len = 2;
  }
  else {
    len = 1;
  }

  printf("%sESC %.*s%s", special_begin, (int)len, bytes, special_end);

  return len;
}

// Assembly:
pushq %rbx
movq %rdi, %rcx
movb (%rdi), %al
andb $-0x10, %al
cmpb $0x20, %al
jne 0x24d6
cmpq $0x2, %rsi
jae 0x24da
pushq $-0x1
popq %rbx
jmp 0x24fb
pushq $0x1
jmp 0x24dc
pushq $0x2
popq %rbx
movq 0x2bcc(%rip), %rsi      # 0x50b0
movq 0x2bcd(%rip), %r8       # 0x50b8
leaq 0xc28(%rip), %rdi       # 0x311a
movl %ebx, %edx
xorl %eax, %eax
callq 0x2090
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/neovim[P]libvterm/bin/vterm-dump.c
// Function: parser_osc
static int parser_osc(int command, VTermStringFragment frag, void *user)
{
  if(frag.initial) {
    if(command == -1)
      printf("%sOSC ", special_begin);
    else
      printf("%sOSC %d;", special_begin, command);
  }

  printf("%.*s", (int)frag.len, frag.str);

  if(frag.final)
    printf("%s", special_end);

  return 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
btl $0x1e, %ebx
jae 0x2748
movl %edi, %edx
movq 0x298b(%rip), %rsi      # 0x50b0
cmpl $-0x1, %edi
je 0x273a
leaq 0xaca(%rip), %rdi       # 0x31fb
xorl %eax, %eax
callq 0x2090
jmp 0x2748
leaq 0xab3(%rip), %rdi       # 0x31f4
xorl %eax, %eax
callq 0x2090
movl %ebx, %esi
andl $0x3fffffff, %esi       # imm = 0x3FFFFFFF
leaq 0xab4(%rip), %rdi       # 0x320b
movq %r14, %rdx
xorl %eax, %eax
callq 0x2090
testl %ebx, %ebx
jns 0x277a
movq 0x294c(%rip), %rsi      # 0x50b8
leaq 0x9c7(%rip), %rdi       # 0x313a
xorl %eax, %eax
callq 0x2090
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/neovim[P]libvterm/bin/vterm-dump.c
// Function: parser_dcs
static int parser_dcs(const char *command, size_t commandlen, VTermStringFragment frag, void *user)
{
  if(frag.initial)
    printf("%sDCS %.*s", special_begin, (int)commandlen, command);

  printf("%.*s", (int)frag.len, frag.str);

  if(frag.final)
    printf("%s", special_end);

  return 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
btl $0x1e, %ebx
jae 0x27b0
movq %rsi, %rdx
movq %rdi, %rcx
movq 0x290e(%rip), %rsi      # 0x50b0
leaq 0xa5c(%rip), %rdi       # 0x3205
xorl %eax, %eax
callq 0x2090
movl %ebx, %esi
andl $0x3fffffff, %esi       # imm = 0x3FFFFFFF
leaq 0xa4c(%rip), %rdi       # 0x320b
movq %r14, %rdx
xorl %eax, %eax
callq 0x2090
testl %ebx, %ebx
jns 0x27e2
movq 0x28e4(%rip), %rsi      # 0x50b8
leaq 0x95f(%rip), %rdi       # 0x313a
xorl %eax, %eax
callq 0x2090
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/google[P]multichase/multiload.c
// Function: load_memcpy_libc
static void load_memcpy_libc(per_thread_t *t) {
#define LOOP_OPS 2
  uint64_t load_loop = t->x.load_total_memory / LOOP_OPS;
  uint64_t load_bites = load_loop * LOOP_OPS;
  register char *a = (char *)t->x.load_arena;
  register char *b = a + load_loop;
  register char *tmp;

  LOAD_MEMORY_INIT_MIBPS
  do {
    tmp = a;
    a = b;
    b = tmp;
    memcpy((void *)a, (void *)b, load_loop);
    LOAD_MEMORY_SAMPLE_MIBPS
  } while (1);
#undef LOOP_OPS
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0xa8(%rdi), %r15
movq 0xb0(%rdi), %rax
movq %rax, %rcx
shrq %rcx
andq $-0x2, %rax
movq %rax, (%rsp)
movq %rcx, 0x8(%rsp)
leaq (%r15,%rcx), %r12
pushq $-0x1
popq %r13
callq 0x403630
movq 0xcb148(%rip), %xmm1    # 0x4d3010
movq %rax, %xmm0
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
subpd 0xcb147(%rip), %xmm0    # 0x4d3020
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movapd %xmm1, 0x10(%rsp)
movq (%rsp), %r14
movq %r12, %rax
movq %r15, %r12
movq %rax, %r15
movq %rax, %rdi
movq %r12, %rsi
movq 0x8(%rsp), %rdx
callq 0x401040
movq 0xc8(%rbx), %rbp
cmpq %rbp, %r13
je 0x407f1b
cmpq $0x0, 0x8(%rbx)
je 0x407f21
addq (%rsp), %r14
jmp 0x407eef
callq 0x403630
movq %rax, %xmm0
movq 0xcb0dd(%rip), %xmm1    # 0x4d3010
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movdqa %xmm1, %xmm3
movapd 0xcb0dd(%rip), %xmm2    # 0x4d3020
subpd %xmm2, %xmm0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
subsd 0x10(%rsp), %xmm1
movq %r14, %xmm0
punpckldq %xmm3, %xmm0    # xmm0 = xmm0[0],xmm3[0],xmm0[1],xmm3[1]
subpd %xmm2, %xmm0
movapd %xmm0, %xmm2
unpckhpd %xmm0, %xmm2            # xmm2 = xmm2[1],xmm0[1]
addsd %xmm0, %xmm2
mulsd 0xcb0ce(%rip), %xmm2    # 0x4d3048
movsd 0xcb0ee(%rip), %xmm0    # 0x4d3070
mulsd %xmm0, %xmm1
mulsd %xmm0, %xmm1
divsd %xmm1, %xmm2
cvttsd2si %xmm2, %rax
movq %rax, %rcx
sarq $0x3f, %rcx
subsd 0xcb0d6(%rip), %xmm2    # 0x4d3078
cvttsd2si %xmm2, %rdx
andq %rcx, %rdx
orq %rax, %rdx
lock
addq %rdx, 0x8(%rbx)
callq 0x403630
movq 0xcb051(%rip), %xmm1    # 0x4d3010
movq %rbp, %r13
jmp 0x407ec8
// File: /workspace/github_c_makefile_star2_O2/google[P]multichase/multiload.c
// Function: load_memset_libc
static void load_memset_libc(per_thread_t *t) {
#define LOOP_OPS 1
  uint64_t load_bites = t->x.load_total_memory * LOOP_OPS;
  register char *a = (char *)t->x.load_arena;

  LOAD_MEMORY_INIT_MIBPS
  do {
    memset((void *)a, 0xdeadbeef, load_bites);
    LOAD_MEMORY_SAMPLE_MIBPS
  } while (1);
#undef LOOP_OPS
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0xa8(%rdi), %r14
movq 0xb0(%rdi), %r15
pushq $-0x1
popq %r13
callq 0x403630
movq 0xcb019(%rip), %xmm1    # 0x4d3010
movq %rax, %xmm0
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
subpd 0xcb018(%rip), %xmm0    # 0x4d3020
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movapd %xmm1, (%rsp)
movq %r15, %rbp
movq %r14, %rdi
movl $0xef, %esi
movq %r15, %rdx
callq 0x4010b0
movq 0xc8(%rbx), %r12
cmpq %r12, %r13
je 0x40803f
cmpq $0x0, 0x8(%rbx)
je 0x408044
addq %r15, %rbp
jmp 0x40801c
callq 0x403630
movq %rax, %xmm0
movq 0xcafba(%rip), %xmm1    # 0x4d3010
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movdqa %xmm1, %xmm3
movapd 0xcafba(%rip), %xmm2    # 0x4d3020
subpd %xmm2, %xmm0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
subsd (%rsp), %xmm1
movq %rbp, %xmm0
punpckldq %xmm3, %xmm0    # xmm0 = xmm0[0],xmm3[0],xmm0[1],xmm3[1]
subpd %xmm2, %xmm0
movapd %xmm0, %xmm2
unpckhpd %xmm0, %xmm2            # xmm2 = xmm2[1],xmm0[1]
addsd %xmm0, %xmm2
mulsd 0xcafac(%rip), %xmm2    # 0x4d3048
movsd 0xcafcc(%rip), %xmm0    # 0x4d3070
mulsd %xmm0, %xmm1
mulsd %xmm0, %xmm1
divsd %xmm1, %xmm2
cvttsd2si %xmm2, %rax
movq %rax, %rcx
sarq $0x3f, %rcx
subsd 0xcafb4(%rip), %xmm2    # 0x4d3078
cvttsd2si %xmm2, %rdx
andq %rcx, %rdx
orq %rax, %rdx
lock
addq %rdx, 0x8(%rbx)
callq 0x403630
movq 0xcaf2f(%rip), %xmm1    # 0x4d3010
movq %r12, %r13
jmp 0x407ff7
// File: /workspace/github_c_makefile_star2_O2/google[P]multichase/multiload.c
// Function: load_memsetz_libc
static void load_memsetz_libc(per_thread_t *t) {
#define LOOP_OPS 1
  uint64_t load_bites = t->x.load_total_memory * LOOP_OPS;
  register char *a = (char *)t->x.load_arena;

  LOAD_MEMORY_INIT_MIBPS
  do {
    memset((void *)a, 0, load_bites);
    LOAD_MEMORY_SAMPLE_MIBPS
  } while (1);
#undef LOOP_OPS
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0xa8(%rdi), %r14
movq 0xb0(%rdi), %r15
pushq $-0x1
popq %r13
callq 0x403630
movq 0xcaef7(%rip), %xmm1    # 0x4d3010
movq %rax, %xmm0
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
subpd 0xcaef6(%rip), %xmm0    # 0x4d3020
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movapd %xmm1, (%rsp)
movq %r15, %rbp
movq %r14, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x4010b0
movq 0xc8(%rbx), %r12
cmpq %r12, %r13
je 0x40815e
cmpq $0x0, 0x8(%rbx)
je 0x408163
addq %r15, %rbp
jmp 0x40813e
callq 0x403630
movq %rax, %xmm0
movq 0xcae9b(%rip), %xmm1    # 0x4d3010
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movdqa %xmm1, %xmm3
movapd 0xcae9b(%rip), %xmm2    # 0x4d3020
subpd %xmm2, %xmm0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
subsd (%rsp), %xmm1
movq %rbp, %xmm0
punpckldq %xmm3, %xmm0    # xmm0 = xmm0[0],xmm3[0],xmm0[1],xmm3[1]
subpd %xmm2, %xmm0
movapd %xmm0, %xmm2
unpckhpd %xmm0, %xmm2            # xmm2 = xmm2[1],xmm0[1]
addsd %xmm0, %xmm2
mulsd 0xcae8d(%rip), %xmm2    # 0x4d3048
movsd 0xcaead(%rip), %xmm0    # 0x4d3070
mulsd %xmm0, %xmm1
mulsd %xmm0, %xmm1
divsd %xmm1, %xmm2
cvttsd2si %xmm2, %rax
movq %rax, %rcx
sarq $0x3f, %rcx
subsd 0xcae95(%rip), %xmm2    # 0x4d3078
cvttsd2si %xmm2, %rdx
andq %rcx, %rdx
orq %rax, %rdx
lock
addq %rdx, 0x8(%rbx)
callq 0x403630
movq 0xcae10(%rip), %xmm1    # 0x4d3010
movq %r12, %r13
jmp 0x408119
// File: /workspace/github_c_makefile_star2_O2/google[P]multichase/multiload.c
// Function: load_stream_copy
static void load_stream_copy(per_thread_t *t) {
#define LOOP_OPS 2
  uint64_t load_loop = t->x.load_total_memory / LOOP_OPS;
  register uint64_t N = load_loop / sizeof(double);
  uint64_t load_bites = N * sizeof(double) * LOOP_OPS;
  register uint64_t i;
  register double *a = (double *)t->x.load_arena;
  register double *b = a + N;
  register double *tmp;

  LOAD_MEMORY_INIT_MIBPS
  do {
    tmp = a;
    a = b;
    b = tmp;
    for (i = 0; i < N; ++i) {
      b[i] = a[i];
    }
    LOAD_MEMORY_SAMPLE_MIBPS
  } while (1);
#undef LOOP_OPS
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq 0xa8(%rdi), %r12
movq %rdi, 0x8(%rsp)
movq 0xb0(%rdi), %rax
movq %rax, %r15
shrq $0x4, %r15
andq $-0x10, %rax
movq %rax, (%rsp)
leaq (%r12,%r15,8), %r13
pushq $-0x1
popq %r14
callq 0x403630
movq 0xcadc3(%rip), %xmm1    # 0x4d3010
movq %rax, %xmm0
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
subpd 0xcadc2(%rip), %xmm0    # 0x4d3020
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movapd %xmm1, 0x10(%rsp)
movq %r13, %rax
xorl %ebx, %ebx
movq 0x8(%rsp), %rcx
movq %r12, %r13
movq %rax, %r12
xorl %eax, %eax
cmpq %rax, %r15
je 0x408299
movsd (%r12,%rax,8), %xmm0
movsd %xmm0, (%r13,%rax,8)
incq %rax
jmp 0x408282
incq %rbx
movq 0xc8(%rcx), %rbp
movq %r13, %rax
cmpq %rbp, %r14
je 0x40827a
cmpq $0x0, 0x8(%rcx)
movq %r13, %rax
jne 0x40827a
movq %rcx, %r14
callq 0x403630
movq %rax, %xmm0
movq 0xcad46(%rip), %xmm1    # 0x4d3010
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movdqa %xmm1, %xmm3
movapd 0xcad46(%rip), %xmm2    # 0x4d3020
subpd %xmm2, %xmm0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
subsd 0x10(%rsp), %xmm1
imulq (%rsp), %rbx
movq %rbx, %xmm0
punpckldq %xmm3, %xmm0    # xmm0 = xmm0[0],xmm3[0],xmm0[1],xmm3[1]
subpd %xmm2, %xmm0
movapd %xmm0, %xmm2
unpckhpd %xmm0, %xmm2            # xmm2 = xmm2[1],xmm0[1]
addsd %xmm0, %xmm2
mulsd 0xcad32(%rip), %xmm2    # 0x4d3048
movsd 0xcad52(%rip), %xmm0    # 0x4d3070
mulsd %xmm0, %xmm1
mulsd %xmm0, %xmm1
divsd %xmm1, %xmm2
cvttsd2si %xmm2, %rax
movq %rax, %rcx
sarq $0x3f, %rcx
subsd 0xcad3a(%rip), %xmm2    # 0x4d3078
cvttsd2si %xmm2, %rdx
andq %rcx, %rdx
orq %rax, %rdx
lock
addq %rdx, 0x8(%r14)
callq 0x403630
movq 0xcacb5(%rip), %xmm1    # 0x4d3010
movq %rbp, %r14
jmp 0x40824d
// File: /workspace/github_c_makefile_star2_O2/google[P]multichase/multiload.c
// Function: load_stream_sum
static void load_stream_sum(per_thread_t *t) {
#define LOOP_OPS 1
  uint64_t load_loop = t->x.load_total_memory / LOOP_OPS;
  register uint64_t N = load_loop / sizeof(uint64_t);
  uint64_t load_bites = N * sizeof(uint64_t) * LOOP_OPS;
  register uint64_t i;
  register uint64_t *a = (uint64_t *)t->x.load_arena;
  register uint64_t s = 0;

  LOAD_MEMORY_INIT_MIBPS
  do {
    for (i = 0; i < N; ++i) {
      s += a[i];
    }
    LOAD_MEMORY_SAMPLE_MIBPS
    use_result_dummy += s;
  } while (1);
#undef LOOP_OPS
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0xa8(%rdi), %r14
movq 0xb0(%rdi), %rax
movq %rax, %r12
shrq $0x3, %r12
andq $-0x8, %rax
movq %rax, 0x8(%rsp)
callq 0x403630
movq %rax, %xmm0
punpckldq 0xcac6c(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0xcac74(%rip), %xmm0    # 0x4d3020
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
pushq $-0x1
popq %rax
xorl %ebp, %ebp
xorl %r13d, %r13d
xorl %ecx, %ecx
cmpq %rcx, %r12
je 0x4083d0
addq (%r14,%rcx,8), %r13
incq %rcx
jmp 0x4083c2
incq %rbp
movq 0xc8(%rbx), %r15
cmpq %r15, %rax
je 0x4083e6
cmpq $0x0, 0x8(%rbx)
je 0x4083f5
movq %rax, %r15
addq %r13, 0x103d40(%rip)    # 0x50c130
movq %r15, %rax
jmp 0x4083c0
movapd %xmm1, 0x10(%rsp)
callq 0x403630
movq %rax, %xmm0
movq 0xcac03(%rip), %xmm1    # 0x4d3010
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movdqa %xmm1, %xmm2
movapd 0xcac03(%rip), %xmm1    # 0x4d3020
subpd %xmm1, %xmm0
movapd %xmm1, %xmm3
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
imulq 0x8(%rsp), %rbp
movq %rbp, %xmm0
punpckldq %xmm2, %xmm0    # xmm0 = xmm0[0],xmm2[0],xmm0[1],xmm2[1]
subpd %xmm3, %xmm0
movapd %xmm0, %xmm2
unpckhpd %xmm0, %xmm2            # xmm2 = xmm2[1],xmm0[1]
addsd %xmm0, %xmm2
subsd 0x10(%rsp), %xmm1
mulsd 0xcabea(%rip), %xmm2    # 0x4d3048
movsd 0xcac0a(%rip), %xmm0    # 0x4d3070
mulsd %xmm0, %xmm1
mulsd %xmm0, %xmm1
divsd %xmm1, %xmm2
cvttsd2si %xmm2, %rax
movq %rax, %rcx
sarq $0x3f, %rcx
subsd 0xcabf2(%rip), %xmm2    # 0x4d3078
cvttsd2si %xmm2, %rdx
andq %rcx, %rdx
orq %rax, %rdx
lock
addq %rdx, 0x8(%rbx)
callq 0x403630
movq %rax, %xmm0
punpckldq 0xcab68(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0xcab70(%rip), %xmm0    # 0x4d3020
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
xorl %ebp, %ebp
jmp 0x4083e9
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Uno/Src/heap.c
// Function: CreateHeap
Heap *
CreateHeap(unsigned int chunk_size, unsigned int chnk_hunk_ratio )
{	Heap    *heap;
	unsigned int     unit;

	heap = (Heap *) emalloc(sizeof(Heap));

	unit  = max(chunk_size, MIN_SZE);
	if (unit % ALGN_SZE != 0)
		unit += ALGN_SZE - (unit % ALGN_SZE);
	heap->chnk_sze = unit;

	if (chnk_hunk_ratio)
		heap->ch_ratio = chnk_hunk_ratio; 
	else
		heap->ch_ratio = DEFLT_RATIO;

	heap->num_alloc = 0; 
	heap->num_free  = 0; 
	heap->num_hunks = 0; 

	heap->next_chunk = 0;
	heap->hunk_array_sze = MIN_HUNK_ARRY;
	heap->free_list = (void *) NULL;

	heap->hunks = (void **) emalloc(MIN_HUNK_ARRY * PNTR_SZE);

	return(heap);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movl %edi, %ebp
pushq $0x30
popq %rdi
callq 0x4da5
movq %rax, %r14
cmpl $0x9, %ebp
pushq $0x8
popq %rax
cmovael %ebp, %eax
addl $0x7, %eax
andl $-0x8, %eax
movl %eax, (%r14)
testl %ebx, %ebx
movl $0x100, %eax            # imm = 0x100
cmovnel %ebx, %eax
movl %eax, 0x4(%r14)
andl $0x0, 0x18(%r14)
movaps 0x19175(%rip), %xmm0    # 0x1dc80
movups %xmm0, 0x8(%r14)
andq $0x0, 0x20(%r14)
pushq $0x40
popq %rdi
callq 0x4da5
movq %rax, 0x28(%r14)
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Uno/Src/heap.c
// Function: HeapAlloc_Gen
void *
HeapAlloc_Gen(Heap *heap)
{	int     asze, chnk;
	void   *avail, *pnt;

	if (!heap)
		return ((void *) NULL);

	if (free_chunks)
	{
#ifdef DEBUG
		printf("-- %p	%d\n", free_chunks, --gh_sz);
#endif
		avail = (void *) free_chunks;
		free_chunks = free_chunks->fc.nxt;
		memset(avail, 0, sizeof(void *));
		return avail;
	}

	if (heap->num_hunks)
	{	chnk = (heap->next_chunk)++;

		if (chnk == (int) heap->ch_ratio)
		{
			if (heap->num_hunks == heap->hunk_array_sze)
			{	asze = heap->hunk_array_sze * 2;	/* double array size */
				pnt = (void *) emalloc(asze * PNTR_SZE);
	
				memcpy(pnt, (void *) heap->hunks, (heap->hunk_array_sze * PNTR_SZE));
	
				efree(heap->hunks);
				heap->hunks = pnt;
				heap->hunk_array_sze = asze;
			}
	
			heap->hunks[heap->num_hunks] =
				(void *) emalloc((size_t) heap->chnk_sze * (size_t) heap->ch_ratio);
	
#ifdef DEBUG
	printf("2 chunk allocate at %p -- %d * %d bytes\n",
		heap->hunks[heap->num_hunks],
		heap->chnk_sze, heap->ch_ratio);
#endif
			(heap->num_hunks)++;
			heap->next_chunk = 1;
			(heap->num_alloc)++;
			return (heap->hunks[(heap->num_hunks)-1]);
		} else
		{	(heap->num_alloc)++;
			return((void *) ((char*) (heap->hunks[(heap->num_hunks)-1])
				+ (heap->chnk_sze * chnk))); 
		}
	} else
	{	heap->hunks[0] = (void *) emalloc((size_t) heap->chnk_sze * (size_t) heap->ch_ratio);
#ifdef DEBUG
	printf("1 chunk allocate at %p -- %d * %d bytes\n",
		heap->hunks[0], heap->chnk_sze, heap->ch_ratio);
#endif
		heap->num_hunks = 1;
		heap->next_chunk = 1;
		(heap->num_alloc)++;
		return (heap->hunks[0]);
	}
}

// Assembly:
testq %rdi, %rdi
je 0x4b95
pushq %r15
pushq %r14
pushq %rbx
movq 0x3271c(%rip), %rax     # 0x37298
testq %rax, %rax
je 0x4b98
movq (%rax), %rcx
movq %rcx, 0x3270d(%rip)     # 0x37298
andq $0x0, (%rax)
popq %rbx
popq %r14
popq %r15
retq
xorl %eax, %eax
retq
movq %rdi, %rbx
movl 0x10(%rdi), %ecx
testl %ecx, %ecx
je 0x4c2e
movl 0x18(%rbx), %eax
leal 0x1(%rax), %edx
movl %edx, 0x18(%rbx)
cmpl 0x4(%rbx), %eax
jne 0x4c5b
cmpl 0x14(%rbx), %ecx
jne 0x4bf9
addl %ecx, %ecx
movslq %ecx, %r15
leaq (,%r15,8), %rdi
callq 0x4da5
movq %rax, %r14
movq 0x28(%rbx), %rsi
movl 0x14(%rbx), %edx
shlq $0x3, %rdx
movq %rax, %rdi
callq 0x31c0
movq 0x28(%rbx), %rdi
callq 0x4da4
movq %r14, 0x28(%rbx)
movl %r15d, 0x14(%rbx)
movl 0x4(%rbx), %eax
movl (%rbx), %ecx
movl %eax, %edi
imulq %rcx, %rdi
callq 0x4da5
movq 0x28(%rbx), %rcx
movl 0x10(%rbx), %edx
movq %rax, (%rcx,%rdx,8)
leal 0x1(%rdx), %eax
movl %eax, 0x10(%rbx)
movl $0x1, 0x18(%rbx)
incl 0x8(%rbx)
movq 0x28(%rbx), %rax
movq (%rax,%rdx,8), %rax
jmp 0x4b8f
movl (%rbx), %eax
movl 0x4(%rbx), %edi
imulq %rax, %rdi
callq 0x4da5
movq 0x28(%rbx), %rcx
movq %rax, (%rcx)
pushq $0x1
popq %rax
movl %eax, 0x10(%rbx)
movl %eax, 0x18(%rbx)
incl 0x8(%rbx)
movq 0x28(%rbx), %rax
movq (%rax), %rax
jmp 0x4b8f
incl 0x8(%rbx)
movq 0x28(%rbx), %rdx
decl %ecx
imull (%rbx), %eax
addq (%rdx,%rcx,8), %rax
jmp 0x4b8f
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Uno/Src/symtab.c
// Function: emalloc
void *
emalloc(size_t m)
{	char *tmp;
	long n = m + ALGN;	/* for possible alignment */

	assert(m != 0);

#ifdef DEBUG
	tmp = calloc(n/ALGN, ALGN);
	if (!tmp)
	{	fprintf(stderr, "%s: out of memory\n", progname);
		exit(1);
	}
#else
	tmp = not_malloc(n);

	if (((unsigned long) tmp)&(ALGN-1))
	{	tmp += (long) (ALGN  - (((unsigned long) tmp)&(ALGN-1)));
		memwaste += ALGN;
	} else
	{	left += ALGN;	/* return the extra bytes */
		have -= ALGN;
	}
#endif

	memcnt += m;

	return (void *) tmp;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x4e6e
movq %rdi, %rbx
leal 0x8(%rdi), %ebp
movl 0x344e1(%rip), %r14d    # 0x392a0
cmpl %ebp, %r14d
jae 0x4e15
cmpl $0x100001, %ebp         # imm = 0x100001
movl $0x100000, %r14d        # imm = 0x100000
cmovael %ebp, %r14d
pushq $0x1
popq %rdi
movq %r14, %rsi
callq 0x3180
movq %rax, 0x344c2(%rip)     # 0x392a8
testq %rax, %rax
jne 0x4e1c
movq 0x32206(%rip), %rax     # 0x36ff8
movq (%rax), %rdi
leaq 0x32384(%rip), %rax     # 0x37180
movq (%rax), %rdx
leaq 0x18fba(%rip), %rsi     # 0x1ddc0
xorl %eax, %eax
callq 0x31a0
pushq $0x1
popq %rdi
callq 0x3270
movq 0x3448c(%rip), %rax     # 0x392a8
movl %ebp, %ecx
addq %rax, %rcx
movq %rcx, 0x34480(%rip)     # 0x392a8
subl %ebp, %r14d
movl %r14d, 0x3446e(%rip)    # 0x392a0
movq %rax, %rdx
andq $0x7, %rdx
je 0x4e4c
subq %rdx, %rax
addq $0x8, %rax
addq $0x8, 0x3444e(%rip)     # 0x39298
jmp 0x4e62
addl $0x8, %r14d
movl %r14d, 0x34449(%rip)    # 0x392a0
addq $-0x8, %rcx
movq %rcx, 0x34446(%rip)     # 0x392a8
addq %rbx, 0x34447(%rip)     # 0x392b0
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x18e3b(%rip), %rdi     # 0x1dcb0
leaq 0x18e3b(%rip), %rsi     # 0x1dcb7
leaq 0x18e3d(%rip), %rcx     # 0x1dcc0
pushq $0x5b
popq %rdx
callq 0x3130
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Uno/Src/symtab.c
// Function: new_symentry
symentry_t *
new_symentry(void)
{	symentry_t *that;

	if (fses)
	{	that = fses;
		fses = fses->next;
		memset(that, 0, sizeof(symentry_t));
	} else
		that = (symentry_t *) emalloc(sizeof(symentry_t));

	that->ln = current_linenumber();	/* gjh */
	that->fn = current_filename();		/* gjh */
	return that;
}

// Assembly:
pushq %rbx
movq 0x343ce(%rip), %rbx     # 0x392b8
testq %rbx, %rbx
je 0x4f0e
movq 0x38(%rbx), %rax
movq %rax, 0x343be(%rip)     # 0x392b8
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rbx)
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
jmp 0x4f19
pushq $0x40
popq %rdi
callq 0x4da5
movq %rax, %rbx
callq 0xe881
movl %eax, 0x24(%rbx)
callq 0xe897
movq %rax, 0x28(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Uno/Src/symtab.c
// Function: new_hashtab
hashtab_t *
new_hashtab(void)
{	hashtab_t *that;

	if (freehtab)
	{	that = freehtab;
		freehtab = that->nxt;
		if (that->tsize != INIT_HASHTAB_SIZE)
		{	fprintf(stderr, "cannot happen nht\n");
			exit(1);
		}
		memset(that->tab, 0, sizeof(symentry_t*) * that->tsize);
	} else
	{	that = (hashtab_t *) emalloc(sizeof(hashtab_t));
		that->tsize = INIT_HASHTAB_SIZE;
		that->tab = (symentry_t **) emalloc( sizeof(symentry_t*) * that->tsize );
	}
	that->nent = 0;

	return that;
}

// Assembly:
pushq %rbx
movq 0x3430c(%rip), %rbx     # 0x392c0
testq %rbx, %rbx
je 0x4fdb
movq 0x10(%rbx), %rax
movq %rax, 0x342fc(%rip)     # 0x392c0
cmpl $0x11, (%rbx)
jne 0x5003
movq 0x8(%rbx), %rdi
movl $0x88, %edx
xorl %esi, %esi
callq 0x3150
jmp 0x4ffa
pushq $0x18
popq %rdi
callq 0x4da5
movq %rax, %rbx
movl $0x11, (%rax)
movl $0x88, %edi
callq 0x4da5
movq %rax, 0x8(%rbx)
andl $0x0, 0x4(%rbx)
movq %rbx, %rax
popq %rbx
retq
movq 0x31fee(%rip), %rax     # 0x36ff8
movq (%rax), %rcx
leaq 0x18d04(%rip), %rdi     # 0x1dd18
pushq $0x12
popq %rsi
pushq $0x1
popq %rdx
callq 0x3280
pushq $0x1
popq %rdi
callq 0x3270
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Uno/Src/symtab.c
// Function: getscoop
scopetab_t **
getscoop(int n)
{	Scoop *s, *prevs = (Scoop *) 0;
	scopetab_t **g = (scopetab_t **) 0;

	for (s = scoop; s; prevs = s, s = s->nxt)
		if (s->n == n)
		{	g = s->g;
			if (!prevs)
				scoop = s->nxt;
			else
				prevs->nxt = s->nxt;
				
			s->n = 0;
			s->g = (scopetab_t **) 0;
			s->nxt = freescoop;
			freescoop = s;
			break;
		}
	if (!g)
		g = (scopetab_t **) emalloc( sizeof(scopetab_t*) * n );

	return g;
}

// Assembly:
leaq 0x340da(%rip), %rax     # 0x392c8
xorl %edx, %edx
movq (%rax), %rcx
testq %rcx, %rcx
je 0x5242
cmpl %edi, (%rcx)
je 0x5205
leaq 0x10(%rcx), %rax
movq %rcx, %rdx
jmp 0x51f0
movq 0x8(%rcx), %rax
movq 0x10(%rcx), %rsi
leaq 0x10(%rdx), %r8
testq %rdx, %rdx
leaq 0x340ad(%rip), %rdx     # 0x392c8
cmovneq %r8, %rdx
movq %rsi, (%rdx)
andl $0x0, (%rcx)
andq $0x0, 0x8(%rcx)
movq 0x3409f(%rip), %rdx     # 0x392d0
movq %rdx, 0x10(%rcx)
movq %rcx, 0x34094(%rip)     # 0x392d0
testq %rax, %rax
je 0x5242
retq
movslq %edi, %rdi
shlq $0x3, %rdi
jmp 0x4da5
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Uno/Src/symtab.c
// Function: new_scopetab
scopetab_t*
new_scopetab(scopetab_t *mom)
{	scopetab_t *that;

	if (freestab)
	{	that = freestab;
		freestab = that->parent;
		memset(that, 0, sizeof(scopetab_t));
	} else
		that = (scopetab_t *) emalloc(sizeof(scopetab_t));

	if (0)
	printf("new scope tab %p, level %d\n", that, mom?mom->level+1:EXTERN_SCOPE);

	that->size = INIT_CHILD_SIZE;

	that->children = getscoop(that->size);

	that->parent = mom;
	if (mom)
		that->level = mom->level + 1;
	else
		that->level = EXTERN_SCOPE;

	return that;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x3407c(%rip), %rbx     # 0x392d8
testq %rbx, %rbx
je 0x5281
movq 0x10(%rbx), %rax
movq %rax, 0x3406c(%rip)     # 0x392d8
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
andq $0x0, 0x30(%rbx)
jmp 0x528c
pushq $0x38
popq %rdi
callq 0x4da5
movq %rax, %rbx
movl $0x4, 0x2c(%rbx)
pushq $0x4
popq %rdi
callq 0x51e7
movq %rax, 0x30(%rbx)
movq %r14, 0x10(%rbx)
testq %r14, %r14
je 0x52b0
movl 0x4(%r14), %eax
incl %eax
jmp 0x52b3
pushq $0x1
popq %rax
movl %eax, 0x4(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Uno/Src/symtab.c
// Function: check_struct_use
void
check_struct_use(FILE *fd, scopetab_t *that)
{	scopetab_t *z;
	symentry_t *x;
	int mustcheck, j;

	vis_p = 1;
	if (that->htab)
	{	mustcheck = 0;
		for (z = that; z; z = z->parent)
			if (z->owner
			&&  strcmp(z->owner, "-") != 0)
			{	if (z->owner_t == TN_OBJ_DEF)
					mustcheck = 1;
				break;
			}

		if (mustcheck)
		for (j = 0; j < that->htab->tsize; j++)
		for (x = that->htab->tab[j]; x; x = x->next)
		{
#if DBG
			printf("%s (%u)	is %sused, owner:	%s	type: %d\n",
				x->nme->str, x, x->used?"":"un",
				that->owner?that->owner:"--",
				that->owner_t);
#endif
			if (!uno_ignore(x))	/* unused field */
			{	fprintf(fd, "%s\t%s\t%s\t%d\n",
					(x->used)?"y":"z",	/* set in dflow.c */
					x->nme->str,
					x->node->hdr.fnm,
					x->node->hdr.line);
			}
		}
	}

	for (j = 0; j < that->nchild; j++)
		check_struct_use(fd, that->children[j]);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x1, 0x33b7c(%rip)     # 0x392e0
movq 0x8(%rsi), %rax
testq %rax, %rax
je 0x5829
movq %rbx, %rcx
testq %rcx, %rcx
je 0x5829
movq 0x18(%rcx), %rdx
testq %rdx, %rdx
je 0x5791
cmpb $0x2d, (%rdx)
jne 0x5797
cmpb $0x0, 0x1(%rdx)
jne 0x5797
movq 0x10(%rcx), %rcx
jmp 0x5774
cmpl $0x18, 0x20(%rcx)
jne 0x5829
leaq 0x18601(%rip), %r13     # 0x1dda9
leaq 0x183e0(%rip), %rbp     # 0x1db8f
leaq 0x185e6(%rip), %r15     # 0x1dd9c
xorl %edx, %edx
movslq (%rax), %rcx
cmpq %rcx, %rdx
jge 0x5829
movq %rdx, (%rsp)
leaq (,%rdx,8), %r12
addq 0x8(%rax), %r12
movq (%r12), %r12
testq %r12, %r12
je 0x581c
movq %r12, %rdi
callq 0x12288
testl %eax, %eax
jne 0x5816
cmpw $0x0, 0x22(%r12)
movq %rbp, %rdx
cmoveq %r13, %rdx
movq 0x8(%r12), %rax
movq 0x10(%r12), %rsi
movq 0x8(%rax), %rcx
movq 0x8(%rsi), %r8
movl 0x10(%rsi), %r9d
movq %r14, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x31a0
addq $0x38, %r12
jmp 0x57d0
movq (%rsp), %rdx
incq %rdx
movq 0x8(%rbx), %rax
jmp 0x57b8
xorl %r15d, %r15d
movslq 0x28(%rbx), %rax
cmpq %rax, %r15
jge 0x584a
movq 0x30(%rbx), %rax
movq (%rax,%r15,8), %rsi
movq %r14, %rdi
callq 0x5749
incq %r15
jmp 0x582c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Uno/Src/symtab.c
// Function: name_scope
void
name_scope(context_t *q, char *s, int tp)
{	symtab_t *p = q->syms;

	if (0) printf("name_scope %p -- owner=%s (owner_t=%d) clevel %d, level %d\n",
		p->current,
		s, tp,
		p->clevel,
		p->current->level);

	set_owner(p->current, s, tp);

	if (Verbose&2)
	printf("SET level %d,%d, %s\n",
		p->clevel,  p->current->level,  s);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x10(%rdi), %r14
movq 0x10(%r14), %rdi
callq 0x5875
leaq 0x3195a(%rip), %rax     # 0x37238
testb $0x2, (%rax)
jne 0x58eb
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl 0x8(%r14), %esi
movq 0x10(%r14), %rax
movl 0x4(%rax), %edx
leaq 0x184ae(%rip), %rdi     # 0x1ddab
movq %rbx, %rcx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3100
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Uno/Src/symtab.c
// Function: new_symtab
symtab_t*
new_symtab(void)
{	symtab_t *that;

	if (freesymt)
	{	that = freesymt;
		freesymt = that->nxt;
		memset(that, 0, sizeof(symtab_t));
	} else
		that = (symtab_t *) emalloc(sizeof(symtab_t));

	that->root = new_scopetab(NULL);
	that->clevel = EXTERN_SCOPE;
	that->current = that->root;

	return that;
}

// Assembly:
pushq %rbx
movq 0x339d2(%rip), %rbx     # 0x392e8
testq %rbx, %rbx
je 0x5932
movq 0x18(%rbx), %rax
movq %rax, 0x339c2(%rip)     # 0x392e8
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
jmp 0x593d
pushq $0x20
popq %rdi
callq 0x4da5
movq %rax, %rbx
xorl %edi, %edi
callq 0x524e
movq %rax, (%rbx)
movl $0x1, 0x8(%rbx)
movq %rax, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Uno/Src/symtab.c
// Function: st_exit_scope
void
st_exit_scope(symtab_t *that)
{
	if (!that) return;

	(that->clevel)--;
	if (that->current->level > that->clevel)
		that->current = that->current->parent;
}

// Assembly:
testq %rdi, %rdi
je 0x5abd
movl 0x8(%rdi), %ecx
leal -0x1(%rcx), %eax
movl %eax, 0x8(%rdi)
movq 0x10(%rdi), %rax
cmpl %ecx, 0x4(%rax)
jl 0x5abd
movq 0x10(%rax), %rax
movq %rax, 0x10(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Uno/Src/symtab.c
// Function: new_context
context_t*
new_context(void)
{	context_t *that = (context_t *) emalloc( sizeof(context_t) );

	that->labels = new_symtab();
	that->tags   = new_symtab();
	that->syms   = new_symtab();

	return that;
}

// Assembly:
pushq %rbx
pushq $0x18
popq %rdi
callq 0x4da5
movq %rax, %rbx
callq 0x590e
movq %rax, (%rbx)
callq 0x590e
movq %rax, 0x8(%rbx)
callq 0x590e
movq %rax, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Uno/Src/symtab.c
// Function: free_context
void
free_context(context_t *that)
{
	if (!that) return;

	free_symtab(that->labels);
	free_symtab(that->tags);
	free_symtab(that->syms);

	efree(that);
}

// Assembly:
testq %rdi, %rdi
je 0x5b21
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x5b22
movq 0x8(%rbx), %rdi
callq 0x5b22
movq 0x10(%rbx), %rdi
popq %rbx
jmp 0x5b22
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Uno/Src/symtab.c
// Function: free_symtab
static void
free_symtab(symtab_t *that)
{
	if (!that) return;

	/* post-order traversal */ 
	po_deltabs(that->root);
	
	that->nxt = freesymt;
	freesymt = that;
}

// Assembly:
testq %rdi, %rdi
je 0x5b46
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x5ca5
movq 0x337ae(%rip), %rax     # 0x392e8
movq %rax, 0x18(%rbx)
movq %rbx, 0x337a3(%rip)     # 0x392e8
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Uno/Src/symtab.c
// Function: enter_scope
int
enter_scope(context_t *that)
{
	if (!that) return 0;

#ifdef  MORE_VERBOSE
	printf("	Enter Scope: %d\n", that->syms->clevel + 1);
#endif
	st_enter_scope(that->labels);
	st_enter_scope(that->tags);

	return st_enter_scope(that->syms);
}

// Assembly:
testq %rdi, %rdi
je 0x5b66
movq (%rdi), %rax
incl 0x8(%rax)
movq 0x8(%rdi), %rax
incl 0x8(%rax)
movq 0x10(%rdi), %rcx
movl 0x8(%rcx), %eax
incl %eax
movl %eax, 0x8(%rcx)
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Uno/Src/symtab.c
// Function: exit_scope
void
exit_scope(context_t *that)
{
#ifdef  MORE_VERBOSE
	printf("	Exit Scope: %d\n", that->syms->clevel);
#endif
	if (!that) return;

	st_exit_scope(that->labels);
	st_exit_scope(that->tags);
	st_exit_scope(that->syms);
}

// Assembly:
testq %rdi, %rdi
je 0x5b8d
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x5a9e
movq 0x8(%rbx), %rdi
callq 0x5a9e
movq 0x10(%rbx), %rdi
popq %rbx
jmp 0x5a9e
retq