LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/src/LuaProfiler.cpp
// Function: t2::DumpReport(_IO_FILE*)
static void DumpReport(FILE* f)
{
  fprintf(f, "Functions:\n");

  fprintf(f, " %p %s\n", &s_TopLevel, s_TopLevelString);

  HashTableWalk(&s_Profiler.m_Functions, [=](uint32_t, uint32_t, const char* str, FunctionMeta* p) -> void
  {
    fprintf(f, " %p %s\n", p, str);
  });

  fprintf(f, "Invocations:\n");

  for (uint32_t i = 0, max = s_Profiler.m_InvocationTableSize; i < max; ++i)
  {
    Invocation* chain = s_Profiler.m_InvocationTable[i];
    while (chain)
    {
      Invocation *stack = chain;
      while (stack)
      {
        fprintf(f, "%p%s", stack->m_Function, stack->m_Parent ? "<=" : "");
        stack = stack->m_Parent;
      }

      fprintf(f, ": calls=%d time=%.7f\n", chain->m_CallCount, TimerToSeconds(chain->m_Ticks));

      chain = chain->m_Next;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x429fd(%rip), %rsi     # 0x4d774
movb $0x0, %al
callq 0x6630
movq -0x8(%rbp), %rdi
leaq 0x429f7(%rip), %rsi     # 0x4d780
leaq 0x58c50(%rip), %rdx     # 0x639e0
leaq 0x42949(%rip), %rcx     # 0x4d6e0
movb $0x0, %al
callq 0x6630
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq 0x58bcf(%rip), %rdi     # 0x63980
addq $0x18, %rdi
callq 0xb0e0
movq -0x8(%rbp), %rdi
leaq 0x429c3(%rip), %rsi     # 0x4d788
movb $0x0, %al
callq 0x6630
movl $0x0, -0x14(%rbp)
movl 0x58bf3(%rip), %eax     # 0x639cc
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jae 0xaeaf
movq 0x58be1(%rip), %rax     # 0x639d0
movl -0x14(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xae9f
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xae5a
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rsi
leaq 0x4519b(%rip), %rcx     # 0x4ffca
leaq 0x42965(%rip), %rax     # 0x4d79b
cmpq $0x0, %rsi
cmovneq %rax, %rcx
leaq 0x42951(%rip), %rsi     # 0x4d796
movb $0x0, %al
callq 0x6630
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0xae0d
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movl 0x18(%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0xc210
movq -0x38(%rbp), %rdi
movl -0x2c(%rbp), %edx
leaq 0x42917(%rip), %rsi     # 0x4d79e
movb $0x1, %al
callq 0x6630
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xadfa
jmp 0xaea1
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xaddc
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/src/LuaProfiler.cpp
// Function: t2::MatchInvocation(t2::Invocation*, t2::Invocation*)
static bool MatchInvocation(Invocation* l, Invocation* r)
{
  while (l && l == r)
  {
    l = l->m_Parent;
    r = r->m_Parent;
  }

  return l == r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x8(%rbp)
movb %al, -0x11(%rbp)
je 0xaee6
movq -0x8(%rbp), %rax
cmpq -0x10(%rbp), %rax
sete %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0xaeef
jmp 0xaf09
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xaecc
movq -0x8(%rbp), %rax
cmpq -0x10(%rbp), %rax
sete %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/lua/src/ldebug.c
// Function: currentline
static int currentline (lua_State *L, CallInfo *ci) {
  int pc = currentpc(L, ci);
  if (pc < 0)
    return -1;  /* only active lua functions have current-line information */
  else
    return luadebug_getline(ci_func(ci)->l.p, pc);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2eee0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jge 0x2f0ff
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2f141
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq 0x20(%rax), %rax
cmpq $0x0, 0x28(%rax)
je 0x2f134
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq 0x20(%rax), %rax
movq 0x28(%rax), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x20(%rbp)
jmp 0x2f13b
xorl %eax, %eax
movl %eax, -0x20(%rbp)
jmp 0x2f13b
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/lua/src/liolib.c
// Function: read_number
static int read_number (lua_State *L, FILE *f) {
  lua_Number d;
  if (fscanf(f, LUA_NUMBER_SCAN, &d) == 1) {
    lua_pushnumber(L, d);
    return 1;
  }
  else return 0;  /* read fails */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x187d8(%rip), %rsi     # 0x4d043
leaq -0x20(%rbp), %rdx
movb $0x0, %al
callq 0x6830
cmpl $0x1, %eax
jne 0x34891
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x2a6a0
movl $0x1, -0x4(%rbp)
jmp 0x34898
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/lua/src/liolib.c
// Function: io_open
static int io_open (lua_State *L) {
  const char *filename = luaL_checkstring(L, 1);
  const char *mode = luaL_optstring(L, 2, "r");
  FILE **pf = newfile(L);
  *pf = fopen(filename, mode);

  /* Tundra: Track opened files. */
  if (*pf && (0 == strcmp(mode, "r") || 0 == strcmp(mode, "rb")))
    lua_on_file_opened(L, filename);

  return (*pf == NULL) ? pushresult(L, 0, filename) : 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x2c330
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
leaq 0x1bf16(%rip), %rdx     # 0x50a68
xorl %eax, %eax
movl %eax, %ecx
callq 0x2c2b0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x35000
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x6560
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
je 0x34bca
movq -0x18(%rbp), %rdi
leaq 0x1bed0(%rip), %rsi     # 0x50a68
callq 0x68c8
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0x34bbd
movq -0x18(%rbp), %rdi
leaq 0x197b3(%rip), %rsi     # 0x4e363
callq 0x68c8
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x34bca
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x35620
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x34be8
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
xorl %esi, %esi
callq 0x341c0
movl %eax, -0x24(%rbp)
jmp 0x34bf2
movl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x34bf2
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/lua/src/liolib.c
// Function: g_iofile
static int g_iofile (lua_State *L, int f, const char *mode) {
  if (!lua_isnoneornil(L, 1)) {
    const char *filename = lua_tostring(L, 1);
    if (filename) {
      FILE **pf = newfile(L);
      *pf = fopen(filename, mode);
      if (*pf == NULL)
        fileerror(L, 1, filename);
      if (0 == strcmp("r", mode) || 0 == strcmp("rb", mode))
        lua_on_file_opened(L, filename);
    }
    else {
      tofile(L);  /* check that it's a valid file handle */
      lua_pushvalue(L, 1);
    }
    lua_rawseti(L, LUA_ENVIRONINDEX, f);
  }
  /* return current value */
  lua_rawgeti(L, LUA_ENVIRONINDEX, f);
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x29e70
cmpl $0x0, %eax
jle 0x34fde
movq -0x8(%rbp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x2a310
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x34fb6
movq -0x8(%rbp), %rdi
callq 0x35000
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x6560
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x34f77
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rdx
movl $0x1, %esi
callq 0x35060
movq -0x18(%rbp), %rsi
leaq 0x1bae6(%rip), %rdi     # 0x50a68
callq 0x68c8
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0x34fa7
movq -0x18(%rbp), %rsi
leaq 0x193c9(%rip), %rdi     # 0x4e363
callq 0x68c8
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x34fb4
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x35620
jmp 0x34fcd
movq -0x8(%rbp), %rdi
callq 0x34120
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x29e10
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
movl $0xffffd8ef, %esi       # imm = 0xFFFFD8EF
callq 0x2b1a0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
movl $0xffffd8ef, %esi       # imm = 0xFFFFD8EF
callq 0x2acf0
movl $0x1, %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/lua/src/lmathlib.c
// Function: luaopen_math
LUALIB_API int luaopen_math (lua_State *L) {
  luaL_register(L, LUA_MATHLIBNAME, mathlib);
#ifdef LLONG_MAX
  lua_pushnumber(L, LLONG_MAX);
#else
  lua_pushnumber(L, _I64_MAX);
#endif
  lua_setfield(L, -2, "huge");
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x1aadb(%rip), %rsi     # 0x4fbd2
leaq 0x2d252(%rip), %rdx     # 0x62350
callq 0x2c850
movq -0x8(%rbp), %rdi
movabsq $0x7fffffffffffffff, %rsi # imm = 0x7FFFFFFFFFFFFFFF
callq 0x2a6a0
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x1abe6(%rip), %rdx     # 0x4fd0c
callq 0x2b030
movl $0x1, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/lua/src/loadlib.c
// Function: lua_on_file_opened
void lua_on_file_opened(lua_State *L, const char* fn) {
	lua_pushlightuserdata(L, &lf_callback_key); // +1
	lua_gettable(L, LUA_REGISTRYINDEX); // -1, +1
	if (!lua_istable(L, -1))
	{
    lua_pop(L, 1); // -1
    lua_newtable(L); // +1
    lua_pushlightuserdata(L, &lf_callback_key); // +1
    lua_pushvalue(L, -2); // +1
    lua_settable(L, LUA_REGISTRYINDEX); // -2
	}
  lua_pushstring(L, fn); //+1
  lua_pushboolean(L, 1); //+1
  lua_settable(L, -3); //-2
  lua_pop(L, 1); // -1
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xaf175(%rip), %rsi     # 0xe47b0
callq 0x2aaf0
movq -0x8(%rbp), %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x2ab90
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x29e70
cmpl $0x5, %eax
je 0x356a8
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x29940
movq -0x8(%rbp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x2ad70
movq -0x8(%rbp), %rdi
leaq 0xaf129(%rip), %rsi     # 0xe47b0
callq 0x2aaf0
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x29e10
movq -0x8(%rbp), %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x2afd0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2a7a0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x2aaa0
movq -0x8(%rbp), %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x2afd0
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x29940
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/lua/src/loadlib.c
// Function: ll_get_accessed_files
static int ll_get_accessed_files(lua_State *L) {
	lua_pushlightuserdata(L, &lf_callback_key);
	lua_gettable(L, LUA_REGISTRYINDEX);
  if (lua_isnil(L, -1))
  {
    lua_pop(L, 1);
    lua_newtable(L);
  }
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xae049(%rip), %rsi     # 0xe47b0
callq 0x2aaf0
movq -0x8(%rbp), %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x2ab90
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x29e70
cmpl $0x0, %eax
jne 0x367a8
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x29940
movq -0x8(%rbp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x2ad70
movl $0x1, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/lua/src/ltable.c
// Function: luaH_free
void luaH_free (lua_State *L, Table *t) {
  if (t->node != dummynode)
    luaM_freearray(L, t->node, (lua_Number)sizenode(t), Node);
  luaM_freearray(L, t->array, t->sizearray, TValue);
  luaM_free(L, t);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0x114c5(%rip), %rcx     # 0x50af0
cmpq %rcx, 0x20(%rax)
je 0x3f65b
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
movq -0x10(%rbp), %rax
movzbl 0xb(%rax), %ecx
movl $0x1, %eax
shll %cl, %eax
cltq
imulq $0x28, %rax, %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x35560
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x10(%rbp), %rax
movslq 0x38(%rax), %rdx
shlq $0x4, %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x35560
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x40, %edx
xorl %eax, %eax
movl %eax, %ecx
callq 0x35560
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/lua/src/lcode.c
// Function: luaK_goiffalse
static void luaK_goiffalse (FuncState *fs, expdesc *e) {
  int pc;  /* pc of last jump */
  luaK_dischargevars(fs, e);
  switch (e->k) {
    case VNIL: case VFALSE: {
      pc = NO_JUMP;  /* always false; do nothing */
      break;
    }
    case VTRUE: {
      pc = luaK_jump(fs);  /* always jump */
      break;
    }
    case VJMP: {
      pc = e->u.s.info;
      break;
    }
    default: {
      pc = jumponcond(fs, e, 1);
      break;
    }
  }
  luaK_concat(fs, &e->t, pc);  /* insert last jump in `t' list */
  luaK_patchtohere(fs, e->f);
  e->f = NO_JUMP;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x47ff0
movq -0x10(%rbp), %rax
movl (%rax), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x9, %eax
ja 0x48de7
movq -0x20(%rbp), %rax
leaq 0x8545(%rip), %rcx      # 0x51300
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0xffffffff, -0x14(%rbp) # imm = 0xFFFFFFFF
jmp 0x48dfc
movq -0x8(%rbp), %rdi
callq 0x47800
movl %eax, -0x14(%rbp)
jmp 0x48dfc
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x14(%rbp)
jmp 0x48dfc
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x1, %edx
callq 0x488e0
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
movl -0x14(%rbp), %edx
callq 0x478b0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x14(%rax), %esi
callq 0x479d0
movq -0x10(%rbp), %rax
movl $0xffffffff, 0x14(%rax) # imm = 0xFFFFFFFF
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Nico01[P]obj2asm/odisasm.c
// Function: inst_init
void inst_init()
{
    over_seg     = -1;              /* Setup for the next instruction */
    over_opsize  = FALSE;
    over_adrsize = FALSE;

    if ( segment_mode == 386 ) {
        size_large = TRUE;
        addr_large = TRUE;
    } else {
        size_large = FALSE;
        addr_large = FALSE;
    }
    size_bytes = segment_bytes;
    addr_bytes = segment_bytes;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0xffffffff, 0x1379a(%rip) # imm = 0xFFFFFFFF
movl $0x0, 0x16d6c(%rip)     # 0x20054
movl $0x0, 0x16d66(%rip)     # 0x20058
leaq 0x17077(%rip), %rax     # 0x20370
cmpl $0x182, (%rax)          # imm = 0x182
jne 0x9317
movl $0x1, 0x16d51(%rip)     # 0x2005c
movl $0x1, 0x16d4b(%rip)     # 0x20060
jmp 0x932b
movl $0x0, 0x16d3b(%rip)     # 0x2005c
movl $0x0, 0x16d35(%rip)     # 0x20060
leaq 0x17042(%rip), %rax     # 0x20374
movl (%rax), %eax
movl %eax, 0x13742(%rip)     # 0x1ca7c
leaq 0x17033(%rip), %rax     # 0x20374
movl (%rax), %eax
movl %eax, 0x13737(%rip)     # 0x1ca80
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Nico01[P]obj2asm/odisasm.c
// Function: check_getc
int check_getc( result )
    dword   *result;
{
    int             ch;

    ch = buff_getc();

    if ( ch == EOF ) {
        return( TRUE );
    } else {
        *result = (dword)ch;
        return( FALSE );
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
callq 0x11a60
movl %eax, -0x14(%rbp)
cmpl $-0x1, -0x14(%rbp)
jne 0x9483
movl $0x1, -0x4(%rbp)
jmp 0x9495
movslq -0x14(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Nico01[P]obj2asm/odisasm.c
// Function: check_getw
int check_getw( result )
    dword   *result;
{
    int             ch;

    ch = buff_getc();
    if ( ch == EOF ) {
        return( TRUE );
    }
    *result = ch;
    ch = buff_getc();
    if ( ch == EOF ) {
        return( TRUE );
    }
    *result += ch << 8;
    return( FALSE );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
callq 0x11a60
movl %eax, -0x14(%rbp)
cmpl $-0x1, -0x14(%rbp)
jne 0x94c3
movl $0x1, -0x4(%rbp)
jmp 0x94ff
movslq -0x14(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
callq 0x11a60
movl %eax, -0x14(%rbp)
cmpl $-0x1, -0x14(%rbp)
jne 0x94e5
movl $0x1, -0x4(%rbp)
jmp 0x94ff
movl -0x14(%rbp), %eax
shll $0x8, %eax
movslq %eax, %rcx
movq -0x10(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Nico01[P]obj2asm/odisasm.c
// Function: check_getl
int check_getl( result )
    dword   *result;
{
    int             ch;

    ch = buff_getc();
    if ( ch == EOF ) {
        return( TRUE );
    }
    *result = (dword)((uchar)ch);

    ch = buff_getc();
    if ( ch == EOF ) {
        return( TRUE );
    }
    *result += (dword)((uchar)ch) << 8;

    ch = buff_getc();
    if ( ch == EOF ) {
        return( TRUE );
    }
    *result += (dword)((uchar)ch) << 16;
    ch = buff_getc();
    if ( ch == EOF ) {
        return( TRUE );
    }
    *result += (dword)((uchar)ch) << 24;

    return( FALSE );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
callq 0x11a60
movl %eax, -0x14(%rbp)
cmpl $-0x1, -0x14(%rbp)
jne 0x9536
movl $0x1, -0x4(%rbp)
jmp 0x95d3
movl -0x14(%rbp), %eax
movzbl %al, %eax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
callq 0x11a60
movl %eax, -0x14(%rbp)
cmpl $-0x1, -0x14(%rbp)
jne 0x955c
movl $0x1, -0x4(%rbp)
jmp 0x95d3
movl -0x14(%rbp), %eax
movzbl %al, %eax
movl %eax, %ecx
shlq $0x8, %rcx
movq -0x10(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
callq 0x11a60
movl %eax, -0x14(%rbp)
cmpl $-0x1, -0x14(%rbp)
jne 0x9589
movl $0x1, -0x4(%rbp)
jmp 0x95d3
movl -0x14(%rbp), %eax
movzbl %al, %eax
movl %eax, %ecx
shlq $0x10, %rcx
movq -0x10(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
callq 0x11a60
movl %eax, -0x14(%rbp)
cmpl $-0x1, -0x14(%rbp)
jne 0x95b6
movl $0x1, -0x4(%rbp)
jmp 0x95d3
movl -0x14(%rbp), %eax
movzbl %al, %eax
movl %eax, %ecx
shlq $0x18, %rcx
movq -0x10(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Nico01[P]obj2asm/odisasm.c
// Function: check_getv
int check_getv( value, flag )
    dword   *value;
    int             flag;
{
    int             result;

    if ( flag ) {
        result = check_getl( value );
    } else {
        result = check_getw( value );
    }
    return( result );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x9603
movq -0x8(%rbp), %rdi
callq 0x9510
movl %eax, -0x10(%rbp)
jmp 0x960f
movq -0x8(%rbp), %rdi
callq 0x94a0
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Nico01[P]obj2asm/odisasm.c
// Function: get_checkc
int get_checkc( offset )
    dword   *offset;
{
    int     dcheck;

    dcheck = data_check( 1 );

    if ( dcheck != NORMAL && dcheck != BAD ) {
        return( TRUE );                 /* Must be no labels or fixups */
    }
    return( check_getc( offset ) );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x1, %edi
callq 0xe580
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x964e
cmpl $0x3, -0x14(%rbp)
je 0x964e
movl $0x1, -0x4(%rbp)
jmp 0x965a
movq -0x10(%rbp), %rdi
callq 0x9460
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Nico01[P]obj2asm/odisasm.c
// Function: instr_opcode
void instr_opcode( text )
    char    *text;
{
    if ( pass == 3 ) {
        out_opcode( text );
    }
    tab_offset = 0;
    inst_init();            /* Reset for next instruction */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x16ab5(%rip), %rax     # 0x20138
cmpl $0x3, (%rax)
jne 0x9691
movq -0x8(%rbp), %rdi
callq 0xe150
leaq 0x16a2c(%rip), %rax     # 0x200c4
movl $0x0, (%rax)
callq 0x92d0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Nico01[P]obj2asm/odisasm.c
// Function: stub
int stub( byte, text, class )
    uchar   byte;
    char            *text;
    int             class;
{
    byte = byte;               /* Prevent unused variable warnings */
    text = text;               /* Prevent unused variable warnings */
    class = class;              /* Prevent unused variable warnings */
    return( 0 );

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x1(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movb -0x1(%rbp), %al
movb %al, -0x1(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
xorl %eax, %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Nico01[P]obj2asm/odisasm.c
// Function: in_out
int in_out( byte, text, class )
    uchar   byte;
    char            *text;
    int             class;
{
    int             dir;
    int             size;
    char            temp[50];

    dir  = ( byte & 0x02 ) >> 1;
    size = ( byte & 0x01 );

    if ( size == 1 && size_large ) {
        size = 2;
    }
    instr_opcode(text);

    if ( dir == 0 ) {
        sprintf( temp, "%s,dx", regs[size][0] );
    } else {
        sprintf( temp, "dx,%s", regs[size][0] );
    }
    instr_operand(temp);

    class = class;              /* Prevent unused variable warnings */

    return(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %dil, %al
movb %al, -0x1(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movzbl -0x1(%rbp), %eax
andl $0x2, %eax
sarl %eax
movl %eax, -0x18(%rbp)
movzbl -0x1(%rbp), %eax
andl $0x1, %eax
movl %eax, -0x1c(%rbp)
cmpl $0x1, -0x1c(%rbp)
jne 0x9751
cmpl $0x0, 0x16914(%rip)     # 0x2005c
je 0x9751
movl $0x2, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x9670
cmpl $0x0, -0x18(%rbp)
jne 0x9789
leaq -0x50(%rbp), %rdi
movslq -0x1c(%rbp), %rcx
leaq 0x12991(%rip), %rax     # 0x1c100
shlq $0x6, %rcx
addq %rcx, %rax
movq (%rax), %rdx
leaq 0xdb1c(%rip), %rsi      # 0x1729c
movb $0x0, %al
callq 0x9190
jmp 0x97b0
leaq -0x50(%rbp), %rdi
movslq -0x1c(%rbp), %rcx
leaq 0x12968(%rip), %rax     # 0x1c100
shlq $0x6, %rcx
addq %rcx, %rax
movq (%rax), %rdx
leaq 0xdaf9(%rip), %rsi      # 0x172a2
movb $0x0, %al
callq 0x9190
leaq -0x50(%rbp), %rdi
callq 0x96b0
movl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl $0x1, %eax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Nico01[P]obj2asm/odisasm.c
// Function: one_byte
int one_byte( byte, text, class )
    uchar   byte;
    char            *text;
    int             class;
{
    char            line[50];

    if ( strlen(text) == 0 ) {
        return(0);
    }

    reg_format( class, line, text, "%s", "%s\t%s" );

    instr_opcode(line);
    byte = byte;               /* Prevent unused variable warnings */

    return(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %dil, %al
movb %al, -0x5(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x90a0
cmpq $0x0, %rax
jne 0x99ed
movl $0x0, -0x4(%rbp)
jmp 0x9a21
movl -0x14(%rbp), %edi
leaq -0x50(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq 0xd8bf(%rip), %rcx      # 0x172be
leaq 0xd8b5(%rip), %r8       # 0x172bb
callq 0x9350
leaq -0x50(%rbp), %rdi
callq 0x9670
movb -0x5(%rbp), %al
movb %al, -0x5(%rbp)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Nico01[P]obj2asm/odisasm.c
// Function: two_byte
int two_byte( byte, text, class )
    uchar   byte;
    char            *text;
    int             class;
{
    dword   offset;
    char            line[50];
    char            temp[50];

    if ( get_checkc( &offset ) ) {
        return( 0 );
    }

    reg_format( class, line, text, "%s\t", "%s\t%s," );

    out_hexize( offset, temp, 1 );      /* Convert 1 byte into hex */
    strcat( line, temp );

    instr_opcode( line );

    byte = byte;                   /* Prevent unused varaible warnings */

    return(2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movb %dil, %al
movb %al, -0x5(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x9620
cmpl $0x0, %eax
je 0x9a5f
movl $0x0, -0x4(%rbp)
jmp 0x9ab8
movl -0x14(%rbp), %edi
leaq -0x60(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq 0xd850(%rip), %rcx      # 0x172c1
leaq 0xd84d(%rip), %r8       # 0x172c5
callq 0x9350
movq -0x20(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
movl $0x1, %edx
callq 0xe320
leaq -0x60(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x9180
leaq -0x60(%rbp), %rdi
callq 0x9670
movb -0x5(%rbp), %al
movb %al, -0x5(%rbp)
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Nico01[P]obj2asm/odisasm.c
// Function: two_ubyte
int two_ubyte( byte, text, class )
    uchar   byte;
    char            *text;
    int             class;
{
    dword   offset;
    char            line[50];

    if ( get_checkc( &offset ) ) {
        return( 0 );
    }

    if ( offset <= 127L ) {
        sprintf( line, "%s+0%02lXh", text, offset );
    } else {
        sprintf( line, "%s-0%02lXh", text, 0x0100L - offset );
    }
    instr_opcode( line );

    byte = byte;               /* Prevent unused variable warnings */
    class = class;              /* Prevent unused variable warnings */

    return(2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb %dil, %al
movb %al, -0x5(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x9620
cmpl $0x0, %eax
je 0x9afc
movl $0x0, -0x4(%rbp)
jmp 0x9b5a
cmpq $0x7f, -0x20(%rbp)
ja 0x9b1f
leaq -0x60(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x20(%rbp), %rcx
leaq 0xd7b6(%rip), %rsi      # 0x172cc
movb $0x0, %al
callq 0x9190
jmp 0x9b3e
leaq -0x60(%rbp), %rdi
movq -0x10(%rbp), %rdx
movl $0x100, %ecx            # imm = 0x100
subq -0x20(%rbp), %rcx
leaq 0xd7a0(%rip), %rsi      # 0x172d7
movb $0x0, %al
callq 0x9190
leaq -0x60(%rbp), %rdi
callq 0x9670
movb -0x5(%rbp), %al
movb %al, -0x5(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Nico01[P]obj2asm/odisasm.c
// Function: one_a
int one_a( byte, text, class )
    uchar   byte;
    char            *text;
    int             class;
{
    char            line[50];

    if ( size_large ) {
        reg_format( class, line, text, "%s\teax", "%s\teax,%s" );
    } else {
        reg_format( class, line, text, "%s\tax", "%s\tax,%s" );
    }

    instr_opcode(line);

    byte = byte;                   /* Prevent unused varaible warnings */

    return(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %dil, %al
movb %al, -0x1(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x0, 0x16120(%rip)     # 0x2005c
je 0x9f5e
movl -0x14(%rbp), %edi
leaq -0x50(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq 0xd39d(%rip), %rcx      # 0x172ed
leaq 0xd39d(%rip), %r8       # 0x172f4
callq 0x9350
jmp 0x9f7c
movl -0x14(%rbp), %edi
leaq -0x50(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq 0xd38e(%rip), %rcx      # 0x172fe
leaq 0xd38d(%rip), %r8       # 0x17304
callq 0x9350
leaq -0x50(%rbp), %rdi
callq 0x9670
movb -0x1(%rbp), %al
movb %al, -0x1(%rbp)
movl $0x1, %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Nico01[P]obj2asm/odisasm.c
// Function: two_a
int two_a( byte, text, class )
    uchar   byte;
    char            *text;
    int             class;
{
    int             size;
    dword   offset;
    char            line[50];

    size = (byte & 0x01);

    if ( check_getc( &offset ) ) {
        return( 0 );
    }

    if ( size == 0 ) {
        sprintf( line, "0%02lXh,al", offset );
    } else {
        sprintf( line, "0%02lXh,ax", offset );
    }
    instr_opcode( text );
    instr_operand(line);

    byte = byte;               /* Prevent unused variable warnings */
    class = class;              /* Prevent unused variable warnings */

    return(2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb %dil, %al
movb %al, -0x5(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movzbl -0x5(%rbp), %eax
andl $0x1, %eax
movl %eax, -0x18(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x9460
cmpl $0x0, %eax
je 0x9fd6
movl $0x0, -0x4(%rbp)
jmp 0xa02f
cmpl $0x0, -0x18(%rbp)
jne 0x9ff4
leaq -0x60(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq 0xd322(%rip), %rsi      # 0x1730d
movb $0x0, %al
callq 0x9190
jmp 0xa00a
leaq -0x60(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq 0xd315(%rip), %rsi      # 0x17318
movb $0x0, %al
callq 0x9190
movq -0x10(%rbp), %rdi
callq 0x9670
leaq -0x60(%rbp), %rdi
callq 0x96b0
movb -0x5(%rbp), %al
movb %al, -0x5(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Nico01[P]obj2asm/odisasm.c
// Function: enter
int enter( byte, text, class )
    uchar   byte;
    char            *text;
    int             class;
{
    dword   num_bytes;
    dword   nest_level;
    char            line[50];

    switch( data_check(1) ) {
        case BAD:
        case LABEL:
        case FIXUP:
            return( 0 );
        case NORMAL:
            if ( check_getw(&num_bytes) ) {
                return( 0 );
            }
            if ( check_getc(&nest_level) ) {
                return( 0 );
            }
            sprintf( line, "0%04lXh,0%02lXh", num_bytes, nest_level );
            break;
    }
    instr_opcode( text );
    instr_operand( line );

    byte = byte;               /* Prevent unused variable warnings */
    class = class;              /* Prevent unused variable warnings */

    return(4);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movb %dil, %al
movb %al, -0x5(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x1, %edi
callq 0xe580
movl %eax, %ecx
movl %ecx, -0x64(%rbp)
testl %eax, %eax
je 0xa3bf
jmp 0xa3aa
movl -0x64(%rbp), %eax
decl %eax
subl $0x2, %eax
ja 0xa407
jmp 0xa3b6
movl $0x0, -0x4(%rbp)
jmp 0xa42c
leaq -0x20(%rbp), %rdi
callq 0x94a0
cmpl $0x0, %eax
je 0xa3d6
movl $0x0, -0x4(%rbp)
jmp 0xa42c
leaq -0x28(%rbp), %rdi
callq 0x9460
cmpl $0x0, %eax
je 0xa3ed
movl $0x0, -0x4(%rbp)
jmp 0xa42c
leaq -0x60(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
leaq 0xcf39(%rip), %rsi      # 0x17339
movb $0x0, %al
callq 0x9190
movq -0x10(%rbp), %rdi
callq 0x9670
leaq -0x60(%rbp), %rdi
callq 0x96b0
movb -0x5(%rbp), %al
movb %al, -0x5(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl $0x4, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Nico01[P]obj2asm/odisasm.c
// Function: seg_over
int seg_over( byte, text, class )
    uchar   byte;
    char            *text;
    int             class;
{
    int             valid;
    int             save_seg;

    text = text;               /* Prevent unused variable warnings */
    class = class;              /* Prevent unused variable warnings */

    save_seg = over_seg;

    if ( byte >= 0x64 ) {
        over_seg = 4 + byte - 0x64;
    } else {
        over_seg = (byte & 0x18) >> 3;
    }

    valid = check_forward( instr, 1 );
    if ( valid ) {
        return( valid+1 );
    } else {
        over_seg = save_seg;
        return( 0 );
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dil, %al
movb %al, -0x5(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl 0x124bf(%rip), %eax     # 0x1ca78
movl %eax, -0x1c(%rbp)
movzbl -0x5(%rbp), %eax
cmpl $0x64, %eax
jl 0xa5d7
movzbl -0x5(%rbp), %eax
addl $0x4, %eax
subl $0x64, %eax
movl %eax, 0x124a3(%rip)     # 0x1ca78
jmp 0xa5e7
movzbl -0x5(%rbp), %eax
andl $0x18, %eax
sarl $0x3, %eax
movl %eax, 0x12491(%rip)     # 0x1ca78
leaq 0x126a2(%rip), %rdi     # 0x1cc90
movl $0x1, %esi
callq 0xa440
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
je 0xa60c
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0xa61c
movl -0x1c(%rbp), %eax
movl %eax, 0x12463(%rip)     # 0x1ca78
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Nico01[P]obj2asm/odisasm.c
// Function: opsize_over
int opsize_over( byte, text, class )
    uchar   byte;
    char            *text;
    int             class;
{
    int             valid;
    int             save_large;
    int             save_bytes;

    byte = byte;               /* Prevent unused variable warnings */
    text = text;               /* Prevent unused variable warnings */
    class = class;              /* Prevent unused variable warnings */

    save_large = size_large;
    save_bytes = size_bytes;

    size_large = !size_large;       /* Toggle size */
    if ( size_bytes == 2 ) {
        size_bytes = 4;
    } else {
        size_bytes = 2;
    }
    over_opsize = TRUE;

    valid = check_forward( instr, 1 );
    if ( valid ) {
        return( valid+1 );
    } else {
        size_large = save_large;
        size_bytes = save_bytes;
        return( 0 );
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dil, %al
movb %al, -0x5(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movb -0x5(%rbp), %al
movb %al, -0x5(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl 0x159fd(%rip), %eax     # 0x2005c
movl %eax, -0x1c(%rbp)
movl 0x12414(%rip), %eax     # 0x1ca7c
movl %eax, -0x20(%rbp)
cmpl $0x0, 0x159ea(%rip)     # 0x2005c
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x159da(%rip)     # 0x2005c
cmpl $0x2, 0x123f3(%rip)     # 0x1ca7c
jne 0xa697
movl $0x4, 0x123e7(%rip)     # 0x1ca7c
jmp 0xa6a1
movl $0x2, 0x123db(%rip)     # 0x1ca7c
movl $0x1, 0x159a9(%rip)     # 0x20054
leaq 0x125de(%rip), %rdi     # 0x1cc90
movl $0x1, %esi
callq 0xa440
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
je 0xa6d0
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0xa6e9
movl -0x1c(%rbp), %eax
movl %eax, 0x15983(%rip)     # 0x2005c
movl -0x20(%rbp), %eax
movl %eax, 0x1239a(%rip)     # 0x1ca7c
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Nico01[P]obj2asm/odisasm.c
// Function: adrsize_over
int adrsize_over( byte, text, class )
    uchar   byte;
    char            *text;
    int             class;
{
    int             valid;
    int             save_large;
    int             save_bytes;

    byte = byte;               /* Prevent unused variable warnings */
    text = text;               /* Prevent unused variable warnings */
    class = class;              /* Prevent unused variable warnings */

    save_large = addr_large;
    save_bytes = addr_bytes;

    addr_large = !addr_large;           /* Toggle address */
    if ( addr_bytes == 2 ) {
        addr_bytes = 4;
    } else {
        addr_bytes = 2;
    }
    over_adrsize = TRUE;

    valid = check_forward( instr, 1 );
    if ( valid ) {
        return( valid+1 );
    } else {
        addr_large = save_large;
        addr_bytes = save_bytes;
        return( 0 );
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dil, %al
movb %al, -0x5(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movb -0x5(%rbp), %al
movb %al, -0x5(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl 0x15931(%rip), %eax     # 0x20060
movl %eax, -0x1c(%rbp)
movl 0x12348(%rip), %eax     # 0x1ca80
movl %eax, -0x20(%rbp)
cmpl $0x0, 0x1591e(%rip)     # 0x20060
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x1590e(%rip)     # 0x20060
cmpl $0x2, 0x12327(%rip)     # 0x1ca80
jne 0xa767
movl $0x4, 0x1231b(%rip)     # 0x1ca80
jmp 0xa771
movl $0x2, 0x1230f(%rip)     # 0x1ca80
movl $0x1, 0x158dd(%rip)     # 0x20058
leaq 0x1250e(%rip), %rdi     # 0x1cc90
movl $0x1, %esi
callq 0xa440
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
je 0xa7a0
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0xa7b9
movl -0x1c(%rbp), %eax
movl %eax, 0x158b7(%rip)     # 0x20060
movl -0x20(%rbp), %eax
movl %eax, 0x122ce(%rip)     # 0x1ca80
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Nico01[P]obj2asm/odisasm.c
// Function: wait
int wait( byte, text, class )
    uchar   byte;
    char            *text;
    int             class;
{
    int             valid;

    byte = byte;               /* Prevent unused variable warnings */
    class = class;              /* Prevent unused variable warnings */

    fp_opcode[0] = '\0';

    valid = check_forward( instr, 0 );
    if ( !valid ) {
        instr_opcode(text);
        return(1);
    } else {
        if ( strlen(fp_opcode) == 0 ) {
            instr_opcode( text );
            return( 1 );
        } else {
            fp_wait = TRUE;         /* Will be reset by "esc" routine */
            hex_finish = FALSE;
            return( 1 );
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dil, %al
movb %al, -0x5(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movb -0x5(%rbp), %al
movb %al, -0x5(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movb $0x0, 0x1586c(%rip)     # 0x20064
leaq 0x12491(%rip), %rdi     # 0x1cc90
xorl %esi, %esi
callq 0xa440
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jne 0xa821
movq -0x10(%rbp), %rdi
callq 0x9670
movl $0x1, -0x4(%rbp)
jmp 0xa860
leaq 0x1583c(%rip), %rdi     # 0x20064
callq 0x90a0
cmpq $0x0, %rax
jne 0xa845
movq -0x10(%rbp), %rdi
callq 0x9670
movl $0x1, -0x4(%rbp)
jmp 0xa860
movb $0x1, 0x15820(%rip)     # 0x2006c
leaq 0x15b2d(%rip), %rax     # 0x20380
movl $0x0, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Nico01[P]obj2asm/odisasm.c
// Function: prefix
int prefix( byte, text, class )
    uchar   byte;
    char            *text;
    int             class;
{
    int             valid;

    valid = check_forward( instr, 0 );

    byte = byte;               /* Prevent unused variable warnings */
    class = class;              /* Prevent unused variable warnings */

    if ( valid ) {
        instr_opcode( text );
        tab_offset = 1;
        hex_finish = FALSE;
        return( 1 );
    } else {
        return( 0 );
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dil, %al
movb %al, -0x5(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
leaq 0x12404(%rip), %rdi     # 0x1cc90
xorl %esi, %esi
callq 0xa440
movl %eax, -0x18(%rbp)
movb -0x5(%rbp), %al
movb %al, -0x5(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x18(%rbp)
je 0xa8d4
movq -0x10(%rbp), %rdi
callq 0x9670
leaq 0x1580c(%rip), %rax     # 0x200c4
movl $0x1, (%rax)
leaq 0x15abb(%rip), %rax     # 0x20380
movl $0x0, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0xa8db
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Nico01[P]obj2asm/odisasm.c
// Function: extra
int extra( byte, text, class )
    uchar   byte;
    char            *text;
    int             class;
{
    int             result;

    result = check_forward( ex_instr, 1 );

    byte = byte;               /* Prevent unused variable warnings */
    text = text;
    class = class;

    if ( result == 0 ) {
        return( 0 );
    } else {
        return( result+1 );
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dil, %al
movb %al, -0x5(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
leaq 0x13d84(%rip), %rdi     # 0x1e690
movl $0x1, %esi
callq 0xa440
movl %eax, -0x18(%rbp)
movb -0x5(%rbp), %al
movb %al, -0x5(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x18(%rbp)
jne 0xa93c
movl $0x0, -0x4(%rbp)
jmp 0xa945
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Nico01[P]obj2asm/odisasm.c
// Function: two_bcd
int two_bcd( byte, text, class )
    uchar   byte;
    char            *text;
    int             class;
{
    dword   offset;

    byte = byte;               /* Prevent unused variable warnings */
    class = class;              /* Prevent unused variable warnings */

    if ( check_getc( &offset ) ) {
        return( 0 );
    }

    if ( offset == 0x0AL ) {
        instr_opcode( text );
        return(2);
    } else {
        return( 0 );
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dil, %al
movb %al, -0x5(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movb -0x5(%rbp), %al
movb %al, -0x5(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x9460
cmpl $0x0, %eax
je 0xae98
movl $0x0, -0x4(%rbp)
jmp 0xaeb8
cmpq $0xa, -0x20(%rbp)
jne 0xaeb1
movq -0x10(%rbp), %rdi
callq 0x9670
movl $0x2, -0x4(%rbp)
jmp 0xaeb8
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Nico01[P]obj2asm/odisasm.c
// Function: mod3
int mod3( ref_mode, text, r_m, type, type_known )
    int             ref_mode;
    char            *text;
    uchar   r_m;
    int             type;
    int             *type_known;
{
    switch( type ) {
        case BYTE_PTR:  strcpy( text, regs[0][r_m] );   break;
        case WORD_PTR:  strcpy( text, regs[1][r_m] );   break;
        case DWORD_PTR: strcpy( text, regs[2][r_m] );   break;
        default:        strcpy( text, regs[3][r_m] );   break;
    }
    *type_known = TRUE;
    return( 0 );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movl %ecx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x24(%rbp)
subl $0x3, %eax
je 0xb7dc
jmp 0xb7c8
movl -0x24(%rbp), %eax
subl $0x4, %eax
je 0xb7f8
jmp 0xb7d2
movl -0x24(%rbp), %eax
subl $0x5, %eax
je 0xb815
jmp 0xb835
movq -0x10(%rbp), %rdi
movzbl -0x11(%rbp), %eax
movl %eax, %ecx
leaq 0x10913(%rip), %rax     # 0x1c100
movq (%rax,%rcx,8), %rsi
callq 0x9060
jmp 0xb853
movq -0x10(%rbp), %rdi
movzbl -0x11(%rbp), %eax
movl %eax, %ecx
leaq 0x108f7(%rip), %rax     # 0x1c100
movq 0x40(%rax,%rcx,8), %rsi
callq 0x9060
jmp 0xb853
movq -0x10(%rbp), %rdi
movzbl -0x11(%rbp), %eax
movl %eax, %ecx
leaq 0x108da(%rip), %rax     # 0x1c100
movq 0x80(%rax,%rcx,8), %rsi
callq 0x9060
jmp 0xb853
movq -0x10(%rbp), %rdi
movzbl -0x11(%rbp), %eax
movl %eax, %ecx
leaq 0x108ba(%rip), %rax     # 0x1c100
movq 0xc0(%rax,%rcx,8), %rsi
callq 0x9060
movq -0x20(%rbp), %rax
movl $0x1, (%rax)
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Nico01[P]obj2asm/odisasm.c
// Function: do_sib
int do_sib( text, base )
    char            *text;
    uchar   *base;
{
    dword   sib_byte;
    int             ss;
    int             idx;

    switch( data_check(2) ) {
        case LABEL:
            return( -1 );
        case FIXUP:
            return( -1 );
        case BAD:
        case NORMAL:
            if ( check_getc( &sib_byte ) ) {
                return( -1 );
            }
            ss    = (int)(sib_byte & 0xC0L) >> 6;
            idx   = (int)(sib_byte & 0x38L) >> 3;
            *base = (uchar)(sib_byte & 0x07L);
            if ( idx == 0x04 ) {            /* For special [ESP] */
                if ( ss != 0 ) {
                    return( -1 );
                } else {
                    strcpy( text, "" );
                }
            } else {
                strcat( text, regs[2][idx] );
                strcat( text, sib_scale[ss] );
            }
            return( 1 );
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x2, %edi
callq 0xe580
movl %eax, %ecx
movq %rcx, -0x30(%rbp)
subl $0x3, %eax
ja 0xb96f
movq -0x30(%rbp), %rax
leaq 0xb7f0(%rip), %rcx      # 0x17094
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xb96f
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xb96f
leaq -0x20(%rbp), %rdi
callq 0x9460
cmpl $0x0, %eax
je 0xb8df
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xb96f
movq -0x20(%rbp), %rax
andq $0xc0, %rax
sarl $0x6, %eax
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rax
andq $0x38, %rax
sarl $0x3, %eax
movl %eax, -0x28(%rbp)
movq -0x20(%rbp), %rax
andq $0x7, %rax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
cmpl $0x4, -0x28(%rbp)
jne 0xb934
cmpl $0x0, -0x24(%rbp)
je 0xb922
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xb96f
movq -0x10(%rbp), %rdi
leaq 0xc893(%rip), %rsi      # 0x181c0
callq 0x9060
jmp 0xb968
movq -0x10(%rbp), %rdi
movslq -0x28(%rbp), %rcx
leaq 0x107bd(%rip), %rax     # 0x1c100
movq 0x80(%rax,%rcx,8), %rsi
callq 0x9180
movq -0x10(%rbp), %rdi
movslq -0x24(%rbp), %rcx
leaq 0x10a41(%rip), %rax     # 0x1c3a0
movq (%rax,%rcx,8), %rsi
callq 0x9180
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)