LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/guszejnovdavid[P]MISFIT/vectorfunctions.c
// Function: vector_dotproduct(double, double*, double*, long)
void vector_dotproduct( double res, double x1[], double x2[], long n_elements )
{
 	 //dot product of two vectors
 	   long i;
       res=0;	     
 	   for(i=0;i<n_elements;i++){
	   							 res+=x1[i]*x2[i];	   
 	   
	   }
	   return;
	   }

// Assembly:
movsd %xmm0, -0x8(%rsp)
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq %rdx, -0x20(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rsp)
movq $0x0, -0x28(%rsp)
movq -0x28(%rsp), %rax
cmpq -0x20(%rsp), %rax
jge 0x1b885
movq -0x10(%rsp), %rax
movq -0x28(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x18(%rsp), %rax
movq -0x28(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm2
movsd -0x8(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rsp)
movq -0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rsp)
jmp 0x1b837
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/guszejnovdavid[P]MISFIT/vectorfunctions.c
// Function: vector_vector_multiply(double*, double*, double*, long)
void vector_vector_multiply( double res[], double x1[], double x2[], long n_elements )
{
 	 //multiplies array with constant
 	   long i;	     
 	   for(i=0;i<n_elements;i++){
	   							 res[i]=x1[i]*x2[i];	   
 	   
	   }
	   return;
	   }

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq %rcx, -0x20(%rsp)
movq $0x0, -0x28(%rsp)
movq -0x28(%rsp), %rax
cmpq -0x20(%rsp), %rax
jge 0x1b8f6
movq -0x10(%rsp), %rax
movq -0x28(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x18(%rsp), %rax
movq -0x28(%rsp), %rcx
mulsd (%rax,%rcx,8), %xmm0
movq -0x8(%rsp), %rax
movq -0x28(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq -0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rsp)
jmp 0x1b8ad
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/guszejnovdavid[P]MISFIT/vectorfunctions.c
// Function: matrix_const_add(double**, double**, double, long, long)
void matrix_const_add( double** res, double** M, double a, long n, long m )
{
 	   long i,j;	     
 	   for(i=0;i<n;i++){
                      for(j=0;j<m;j++){
	   							         res[i][j]=M[i][j]+a;
                                         }
                    }	   
 	   
	   return;
	   }

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movsd %xmm0, -0x18(%rsp)
movq %rdx, -0x20(%rsp)
movq %rcx, -0x28(%rsp)
movq $0x0, -0x30(%rsp)
movq -0x30(%rsp), %rax
cmpq -0x20(%rsp), %rax
jge 0x1b99c
movq $0x0, -0x38(%rsp)
movq -0x38(%rsp), %rax
cmpq -0x28(%rsp), %rax
jge 0x1b98a
movq -0x10(%rsp), %rax
movq -0x30(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x38(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
addsd -0x18(%rsp), %xmm0
movq -0x8(%rsp), %rax
movq -0x30(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x38(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq -0x38(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rsp)
jmp 0x1b938
jmp 0x1b98c
movq -0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rsp)
jmp 0x1b923
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/guszejnovdavid[P]MISFIT/vectorfunctions.c
// Function: matrix_add(double**, double**, double**, long, long)
void matrix_add( double** res, double** M1, double** M2, long n, long m )
{
 	   long i,j;	     
 	   for(i=0;i<n;i++){
                      for(j=0;j<m;j++){
	   							         res[i][j]=M1[i][j]+M2[i][j];
                                         }
                    }	   
 	   
	   return;
	   }

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq %rcx, -0x20(%rsp)
movq %r8, -0x28(%rsp)
movq $0x0, -0x30(%rsp)
movq -0x30(%rsp), %rax
cmpq -0x20(%rsp), %rax
jge 0x1ba54
movq $0x0, -0x38(%rsp)
movq -0x38(%rsp), %rax
cmpq -0x28(%rsp), %rax
jge 0x1ba3f
movq -0x10(%rsp), %rax
movq -0x30(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x38(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x18(%rsp), %rax
movq -0x30(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x38(%rsp), %rcx
addsd (%rax,%rcx,8), %xmm0
movq -0x8(%rsp), %rax
movq -0x30(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x38(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq -0x38(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rsp)
jmp 0x1b9db
jmp 0x1ba41
movq -0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rsp)
jmp 0x1b9c2
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/guszejnovdavid[P]MISFIT/vectorfunctions.c
// Function: matrix_const_multiply(double**, double**, double, long, long)
void matrix_const_multiply( double** res, double** M, double factor, long n, long m)
{
 	 //multiplies matrix with constant
 	   long i,j;	     
 	   for(i=0;i<n;i++){
                      for(j=0;j<m;j++){
                                       res[i][j]=M[i][j]*factor;
                                       }
 	   
	   }
	   return;
	   }

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movsd %xmm0, -0x18(%rsp)
movq %rdx, -0x20(%rsp)
movq %rcx, -0x28(%rsp)
movq $0x0, -0x30(%rsp)
movq -0x30(%rsp), %rax
cmpq -0x20(%rsp), %rax
jge 0x1bafc
movq $0x0, -0x38(%rsp)
movq -0x38(%rsp), %rax
cmpq -0x28(%rsp), %rax
jge 0x1baea
movq -0x10(%rsp), %rax
movq -0x30(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x38(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
mulsd -0x18(%rsp), %xmm0
movq -0x8(%rsp), %rax
movq -0x30(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x38(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq -0x38(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rsp)
jmp 0x1ba98
jmp 0x1baec
movq -0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rsp)
jmp 0x1ba83
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/guszejnovdavid[P]MISFIT/vectorfunctions.c
// Function: matrix_matrix_multiply(double**, double**, double**, long, long)
void matrix_matrix_multiply(  double** res, double** M1, double** M2, long n, long m )
{
 	 //multiplies array with constant
 	   long i,j;	     
 	   for(i=0;i<n;i++){
                               for(j=0;j<m;j++){
	   							                                       res[i][j]=M1[i][j]*M2[i][j];	   
                                                         }
 	   
	   }
	   return;
	   }

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq %rcx, -0x20(%rsp)
movq %r8, -0x28(%rsp)
movq $0x0, -0x30(%rsp)
movq -0x30(%rsp), %rax
cmpq -0x20(%rsp), %rax
jge 0x1bbb4
movq $0x0, -0x38(%rsp)
movq -0x38(%rsp), %rax
cmpq -0x28(%rsp), %rax
jge 0x1bb9f
movq -0x10(%rsp), %rax
movq -0x30(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x38(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x18(%rsp), %rax
movq -0x30(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x38(%rsp), %rcx
mulsd (%rax,%rcx,8), %xmm0
movq -0x8(%rsp), %rax
movq -0x30(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x38(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq -0x38(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rsp)
jmp 0x1bb3b
jmp 0x1bba1
movq -0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rsp)
jmp 0x1bb22
retq
// File: /workspace/github_c_makefile_star2_O0/LuaJIT[P]LuaJIT/src/./../dynasm/dasm_x86.h
// Function: dasm_init
void dasm_init(Dst_DECL, int maxsection)
{
  dasm_State *D;
  size_t psz = 0;
  Dst_REF = NULL;
  DASM_M_GROW(Dst, struct dasm_State, Dst_REF, psz, DASM_PSZ(maxsection));
  D = Dst_REF;
  D->psize = psz;
  D->lglabels = NULL;
  D->lgsize = 0;
  D->pclabels = NULL;
  D->pcsize = 0;
  D->globals = NULL;
  D->maxsection = maxsection;
  memset((void *)D->sections, 0, maxsection * sizeof(dasm_Section));
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x30(%rsp), %rax
movq $0x0, (%rax)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
movl 0x2c(%rsp), %eax
subl $0x1, %eax
cltq
imulq $0x28, %rax, %rax
addq $0x78, %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x8(%rsp), %rax
jae 0x538a
cmpq $0x10, 0x10(%rsp)
jae 0x532f
movq $0x10, 0x10(%rsp)
jmp 0x5331
movq 0x10(%rsp), %rax
cmpq 0x8(%rsp), %rax
jae 0x534e
movq 0x10(%rsp), %rax
addq 0x10(%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0x5331
movq 0x30(%rsp), %rax
movq (%rax), %rdi
movq 0x10(%rsp), %rsi
callq 0x5150
movq %rax, %rcx
movq 0x30(%rsp), %rax
movq %rcx, (%rax)
movq 0x30(%rsp), %rax
cmpq $0x0, (%rax)
jne 0x5380
movl $0x1, %edi
callq 0x5190
movq 0x10(%rsp), %rax
movq %rax, 0x18(%rsp)
jmp 0x538c
movq 0x30(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x18(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, (%rax)
movq 0x20(%rsp), %rax
movq $0x0, 0x10(%rax)
movq 0x20(%rsp), %rax
movq $0x0, 0x18(%rax)
movq 0x20(%rsp), %rax
movq $0x0, 0x20(%rax)
movq 0x20(%rsp), %rax
movq $0x0, 0x28(%rax)
movq 0x20(%rsp), %rax
movq $0x0, 0x30(%rax)
movl 0x2c(%rsp), %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x48(%rax)
movq 0x20(%rsp), %rdi
addq $0x50, %rdi
movslq 0x2c(%rsp), %rax
imulq $0x28, %rax, %rdx
xorl %esi, %esi
callq 0x50c0
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/LuaJIT[P]LuaJIT/src/host/buildvm.c
// Function: sym_decorate
static const char *sym_decorate(BuildCtx *ctx,
				const char *prefix, const char *suffix)
{
  char name[256];
  char *p;
#if LJ_64
  const char *symprefix = ctx->mode == BUILD_machasm ? "_" : "";
#elif LJ_TARGET_XBOX360
  const char *symprefix = "";
#else
  const char *symprefix = ctx->mode != BUILD_elfasm ? "_" : "";
#endif
  sprintf(name, "%s%s%s", symprefix, prefix, suffix);
  p = strchr(name, '@');
  if (p) {
#if LJ_TARGET_X86ORX64
    if (!LJ_64 && (ctx->mode == BUILD_coffasm || ctx->mode == BUILD_peobj))
      name[0] = name[1] == 'R' ? '_' : '@';  /* Just for _RtlUnwind@16. */
    else
      *p = '\0';
#elif LJ_TARGET_PPC && !LJ_TARGET_CONSOLE
    /* Keep @plt etc. */
#else
    *p = '\0';
#endif
  }
  p = (char *)malloc(strlen(name)+1);  /* MSVC doesn't like strdup. */
  strcpy(p, name);
  return p;
}

// Assembly:
subq $0x128, %rsp            # imm = 0x128
movq %rdi, 0x120(%rsp)
movq %rsi, 0x118(%rsp)
movq %rdx, 0x110(%rsp)
movq 0x120(%rsp), %rax
movl 0x8(%rax), %edx
leaq 0xca9d(%rip), %rax      # 0x1541e
leaq 0xd1c8(%rip), %rcx      # 0x15b50
cmpl $0x2, %edx
cmoveq %rcx, %rax
movq %rax, (%rsp)
leaq 0x10(%rsp), %rdi
movq (%rsp), %rdx
movq 0x118(%rsp), %rcx
movq 0x110(%rsp), %r8
leaq 0xb3d0(%rip), %rsi      # 0x13d83
movb $0x0, %al
callq 0x5180
leaq 0x10(%rsp), %rdi
movl $0x40, %esi
callq 0x50b0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x89de
movq 0x8(%rsp), %rax
movb $0x0, (%rax)
leaq 0x10(%rsp), %rdi
callq 0x50a0
movq %rax, %rdi
addq $0x1, %rdi
callq 0x5130
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x5060
movq 0x8(%rsp), %rax
addq $0x128, %rsp            # imm = 0x128
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/LuaJIT[P]LuaJIT/src/host/buildvm_lib.c
// Function: libdef_lua
static void libdef_lua(BuildCtx *ctx, char *p, int arg)
{
  UNUSED(arg);
  if (ctx->mode == BUILD_libdef) {
    int i;
    for (i = 0; libbc_map[i].name != NULL; i++) {
      if (!strcmp(libbc_map[i].name, p)) {
	int ofs = libbc_map[i].ofs;
	int len = libbc_map[i+1].ofs - ofs;
	obuf[2]++;  /* Bump hash table size. */
	*optr++ = LIBINIT_LUA;
	libdef_name(p, 0);
	memcpy(optr, libbc_code + ofs, len);
	libdef_fixupbc(optr);
	optr += len;
	return;
      }
    }
    fprintf(stderr, "Error: missing libbc definition for %s\n", p);
    exit(1);
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movq 0x20(%rsp), %rax
cmpl $0x7, 0x8(%rax)
jne 0xd62d
movl $0x0, 0x10(%rsp)
movslq 0x10(%rsp), %rcx
leaq 0xc84b(%rip), %rax      # 0x19d50
shlq $0x4, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
je 0xd606
movslq 0x10(%rsp), %rcx
leaq 0xc82e(%rip), %rax      # 0x19d50
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movq 0x18(%rsp), %rsi
callq 0x50f0
cmpl $0x0, %eax
jne 0xd5f4
movslq 0x10(%rsp), %rcx
leaq 0xc805(%rip), %rax      # 0x19d50
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
movl %eax, 0xc(%rsp)
movl 0x10(%rsp), %eax
addl $0x1, %eax
movslq %eax, %rcx
leaq 0xc7e6(%rip), %rax      # 0x19d50
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
subl 0xc(%rsp), %eax
movl %eax, 0x8(%rsp)
movb 0xcca0(%rip), %al       # 0x1a222
addb $0x1, %al
movb %al, 0xcc98(%rip)       # 0x1a222
movq 0xec8f(%rip), %rax      # 0x1c220
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0xec81(%rip)      # 0x1c220
movb $-0x7, (%rax)
movq 0x18(%rsp), %rdi
xorl %esi, %esi
callq 0xdab0
movq 0xec6b(%rip), %rdi      # 0x1c220
movslq 0xc(%rsp), %rax
leaq 0x896f(%rip), %rsi      # 0x15f30
addq %rax, %rsi
movslq 0x8(%rsp), %rdx
callq 0x5120
movq 0xec4b(%rip), %rdi      # 0x1c220
callq 0xdd00
movl 0x8(%rsp), %ecx
movq 0xec3b(%rip), %rax      # 0x1c220
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, 0xec2e(%rip)      # 0x1c220
jmp 0xd62d
jmp 0xd5f6
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0xd4f9
movq 0xc9eb(%rip), %rax      # 0x19ff8
movq (%rax), %rdi
movq 0x18(%rsp), %rdx
leaq 0x87e6(%rip), %rsi      # 0x15e02
movb $0x0, %al
callq 0x5110
movl $0x1, %edi
callq 0x5190
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/LuaJIT[P]LuaJIT/src/host/buildvm_lib.c
// Function: libdef_fixupbc
static void libdef_fixupbc(uint8_t *p)
{
  uint32_t i, sizebc;
  p += 4;
  p = libdef_uleb128(p, &sizebc);
  p = libdef_uleb128(p, &sizebc);
  p = libdef_uleb128(p, &sizebc);
  for (i = 0; i < sizebc; i++, p += 4) {
    uint8_t op = p[libbc_endian ? 3 : 0];
    uint8_t ra = p[libbc_endian ? 2 : 1];
    uint8_t rc = p[libbc_endian ? 1 : 2];
    uint8_t rb = p[libbc_endian ? 0 : 3];
    if (!LJ_DUALNUM && op == BC_ISTYPE && rc == ~LJ_TNUMX+1) {
      op = BC_ISNUM; rc++;
    }
    p[LJ_ENDIAN_SELECT(0, 3)] = op;
    p[LJ_ENDIAN_SELECT(1, 2)] = ra;
    p[LJ_ENDIAN_SELECT(2, 1)] = rc;
    p[LJ_ENDIAN_SELECT(3, 0)] = rb;
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x4, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xde10
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xde10
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xde10
movq %rax, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x8(%rsp), %eax
jae 0xde08
movq 0x10(%rsp), %rax
movb (%rax), %al
movb %al, 0x7(%rsp)
movq 0x10(%rsp), %rax
movb 0x1(%rax), %al
movb %al, 0x6(%rsp)
movq 0x10(%rsp), %rax
movb 0x2(%rax), %al
movb %al, 0x5(%rsp)
movq 0x10(%rsp), %rax
movb 0x3(%rax), %al
movb %al, 0x4(%rsp)
movzbl 0x7(%rsp), %eax
cmpl $0x10, %eax
jne 0xddbb
movzbl 0x5(%rsp), %eax
cmpl $0xe, %eax
jne 0xddbb
movb $0x11, 0x7(%rsp)
movb 0x5(%rsp), %al
addb $0x1, %al
movb %al, 0x5(%rsp)
movb 0x7(%rsp), %cl
movq 0x10(%rsp), %rax
movb %cl, (%rax)
movb 0x6(%rsp), %cl
movq 0x10(%rsp), %rax
movb %cl, 0x1(%rax)
movb 0x5(%rsp), %cl
movq 0x10(%rsp), %rax
movb %cl, 0x2(%rax)
movb 0x4(%rsp), %cl
movq 0x10(%rsp), %rax
movb %cl, 0x3(%rax)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rax
addq $0x4, %rax
movq %rax, 0x10(%rsp)
jmp 0xdd5b
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/LuaJIT[P]LuaJIT/src/host/buildvm_lib.c
// Function: libdef_uleb128
static uint8_t *libdef_uleb128(uint8_t *p, uint32_t *vv)
{
  uint32_t v = *p++;
  if (v >= 0x80) {
    int sh = 0; v &= 0x7f;
    do { v |= ((*p & 0x7f) << (sh += 7)); } while (*p++ >= 0x80);
  }
  *vv = v;
  return p;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rsp)
movzbl (%rax), %eax
movl %eax, -0x14(%rsp)
cmpl $0x80, -0x14(%rsp)
jb 0xde8c
movl $0x0, -0x18(%rsp)
movl -0x14(%rsp), %eax
andl $0x7f, %eax
movl %eax, -0x14(%rsp)
movq -0x8(%rsp), %rax
movzbl (%rax), %eax
andl $0x7f, %eax
movl -0x18(%rsp), %ecx
addl $0x7, %ecx
movl %ecx, -0x18(%rsp)
shll %cl, %eax
orl -0x14(%rsp), %eax
movl %eax, -0x14(%rsp)
movq -0x8(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rsp)
movzbl (%rax), %eax
cmpl $0x80, %eax
jge 0xde4f
jmp 0xde8c
movl -0x14(%rsp), %ecx
movq -0x10(%rsp), %rax
movl %ecx, (%rax)
movq -0x8(%rsp), %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/starius[P]dna-complement/make-int-table.c
// Function: main
int main() {
    initializeTranslate();
    unsigned x, y;
    for (x = 0; x < NCHARS * NCHARS; x++) {
        unsigned int buffer[NCHARS * NCHARS];
        for (y = 0; y < NCHARS * NCHARS; y++) {
            unsigned int in_xy = (x << 16) | y;
            unsigned int out_xy =
                ((unsigned int)(short_translate[x]) << 16) |
                (unsigned int)(short_translate[y]);
            buffer[y] = out_xy;
        }
        fwrite((char*)buffer, 1, sizeof(buffer), stdout);
    }
    return 0;
}

// Assembly:
subq $0x40028, %rsp          # imm = 0x40028
movl $0x0, 0x40024(%rsp)
callq 0x1140
movl $0x0, 0x40020(%rsp)
cmpl $0x10000, 0x40020(%rsp) # imm = 0x10000
jae 0x1337
movl $0x0, 0x4001c(%rsp)
cmpl $0x10000, 0x4001c(%rsp) # imm = 0x10000
jae 0x1303
movl 0x40020(%rsp), %eax
shll $0x10, %eax
orl 0x4001c(%rsp), %eax
movl %eax, 0xc(%rsp)
movl 0x40020(%rsp), %eax
movl %eax, %ecx
leaq 0x2e80(%rip), %rax      # 0x4140
movzwl (%rax,%rcx,2), %eax
shll $0x10, %eax
movl 0x4001c(%rsp), %ecx
movl %ecx, %edx
leaq 0x2e69(%rip), %rcx      # 0x4140
movzwl (%rcx,%rdx,2), %ecx
orl %ecx, %eax
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %ecx
movl 0x4001c(%rsp), %eax
movl %ecx, 0x10(%rsp,%rax,4)
movl 0x4001c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4001c(%rsp)
jmp 0x128e
leaq 0x10(%rsp), %rdi
movq 0x2cd1(%rip), %rax      # 0x3fe0
movq (%rax), %rcx
movl $0x1, %esi
movl $0x40000, %edx          # imm = 0x40000
callq 0x1030
movl 0x40020(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x40020(%rsp)
jmp 0x1272
xorl %eax, %eax
addq $0x40028, %rsp          # imm = 0x40028
retq
// File: /workspace/github_c_makefile_star2_O0/giometti[P]mastering_UNIX_programming/chapter_06/reopen.c
// Function: main
int main(void)
{
	int mode;
	FILE *fp;

	mode = fwide(stdout, 0);
	wprintf(L"by default stdout has mode=%d\n", mode);
	mode = fwide(stdout, 0);
	wprintf(L"now stdout has mode=%d\n", mode);

	fp = freopen(NULL, "a+", stdout);
	if (!fp) {
		perror("freopen");
		return -1;
	}

	mode = fwide(stdout, 0);
	wprintf(L"after freopen() stdout has mode=%d\n", mode);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movq 0x2e5a(%rip), %rax      # 0x3fe0
movq (%rax), %rdi
xorl %esi, %esi
callq 0x1050
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %esi
leaq 0xe67(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1040
movq 0x2e35(%rip), %rax      # 0x3fe0
movq (%rax), %rdi
xorl %esi, %esi
callq 0x1050
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %esi
leaq 0xebe(%rip), %rdi       # 0x2080
movb $0x0, %al
callq 0x1040
movq 0x2e10(%rip), %rax      # 0x3fe0
movq (%rax), %rdx
xorl %eax, %eax
movl %eax, %edi
leaq 0xf92(%rip), %rsi       # 0x2170
callq 0x1030
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1203
leaq 0xf7e(%rip), %rdi       # 0x2173
callq 0x1060
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x122f
movq 0x2dd6(%rip), %rax      # 0x3fe0
movq (%rax), %rdi
xorl %esi, %esi
callq 0x1050
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %esi
leaq 0xebf(%rip), %rdi       # 0x20e0
movb $0x0, %al
callq 0x1040
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/mux/dispatch.c
// Function: dispatch_init
struct dispatch_state *
dispatch_init(const int * socks, size_t nsocks,
    struct wire_requestqueue * Q, size_t maxconn)
{
	struct dispatch_state * dstate;
	size_t i;

	/* Bake a cookie. */
	if ((dstate = malloc(sizeof(struct dispatch_state))) == NULL)
		goto err0;
	dstate->nsock_listen = nsocks;
	dstate->sock_active = NULL;
	dstate->nsock_active = 0;
	dstate->nsock_active_max = maxconn;
	dstate->Q = Q;
	dstate->failed = 0;

	/* Allocate an array of listeners. */
	if ((dstate->sock_listen =
	    malloc(nsocks * sizeof(struct sock_listen))) == NULL)
		goto err1;
	for (i = 0; i < nsocks; i++) {
		dstate->sock_listen[i].dstate = dstate;
		dstate->sock_listen[i].s = socks[i];
		dstate->sock_listen[i].accept_cookie = NULL;
	}

	/* Start accepting connections. */
	if (accept_start(dstate))
		goto err2;

	/* Success! */
	return (dstate);

err2:
	free(dstate->sock_listen);
err1:
	free(dstate);
err0:
	/* Failure! */
	return (NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl $0x38, %edi
callq 0x2290
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0x3611
jmp 0x370d
movq -0x18(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x30(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x30(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x30(%rbp), %rax
movl $0x0, 0x30(%rax)
imulq $0x18, -0x18(%rbp), %rdi
callq 0x2290
movq -0x30(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0x3674
jmp 0x3704
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x36de
movq -0x30(%rbp), %rcx
movq -0x30(%rbp), %rax
movq (%rax), %rax
imulq $0x18, -0x38(%rbp), %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq -0x38(%rbp), %rcx
movl (%rax,%rcx,4), %ecx
movq -0x30(%rbp), %rax
movq (%rax), %rax
imulq $0x18, -0x38(%rbp), %rdx
addq %rdx, %rax
movl %ecx, 0x8(%rax)
movq -0x30(%rbp), %rax
movq (%rax), %rax
imulq $0x18, -0x38(%rbp), %rcx
addq %rcx, %rax
movq $0x0, 0x10(%rax)
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x367c
movq -0x30(%rbp), %rdi
callq 0x3720
cmpl $0x0, %eax
je 0x36ee
jmp 0x36f8
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3715
movq -0x30(%rbp), %rax
movq (%rax), %rdi
callq 0x2040
movq -0x30(%rbp), %rdi
callq 0x2040
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/mux/dispatch.c
// Function: accept_start
static int
accept_start(struct dispatch_state * dstate)
{
	struct sock_listen * L;
	size_t i;

	/* Make sure we don't have any in-progress accepts. */
	for (i = 0; i < dstate->nsock_listen; i++) {
		L = &dstate->sock_listen[i];
		if (L->accept_cookie != NULL) {
			warn0("Already trying to accept a connection!");
			goto err0;
		}
	}

	/* Try to accept connections. */
	for (i = 0; i < dstate->nsock_listen; i++) {
		L = &dstate->sock_listen[i];
		if ((L->accept_cookie =
		    network_accept(L->s, callback_gotconn, L)) == NULL)
			goto err1;
	}

	/* Success! */
	return (0);

err1:
	/* Cancel the accepts we started. */
	accept_stop(dstate);
err0:
	/* Failure! */
	return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x3790
movq -0x10(%rbp), %rax
movq (%rax), %rax
imulq $0x18, -0x20(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x3780
jmp 0x3762
leaq 0xcd2a(%rip), %rdi      # 0x10493
movb $0x0, %al
callq 0xbed0
callq 0x20a0
movl $0x0, (%rax)
jmp 0x3802
jmp 0x3782
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x3734
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x37f0
movq -0x10(%rbp), %rax
movq (%rax), %rax
imulq $0x18, -0x20(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0x8(%rax), %edi
movq -0x18(%rbp), %rdx
leaq 0x135(%rip), %rsi       # 0x3900
callq 0x7900
movq -0x18(%rbp), %rcx
movq %rax, 0x10(%rcx)
cmpq $0x0, %rax
jne 0x37e0
jmp 0x37f9
jmp 0x37e2
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x3798
movl $0x0, -0x4(%rbp)
jmp 0x3809
movq -0x10(%rbp), %rdi
callq 0x3bc0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/mux/dispatch.c
// Function: dispatch_done
void
dispatch_done(struct dispatch_state * dstate)
{

	/* Sanity-check. */
	assert(dstate->failed == 1);
	assert(dstate->sock_active == NULL);
	assert(dstate->nsock_active == 0);

	/* Free memory. */
	free(dstate->sock_listen);
	free(dstate);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x1, 0x30(%rax)
jne 0x3868
jmp 0x3887
leaq 0xcba3(%rip), %rdi      # 0x10412
leaq 0xcbb0(%rip), %rsi      # 0x10426
movl $0x20e, %edx            # imm = 0x20E
leaq 0xcbaf(%rip), %rcx      # 0x10431
callq 0x21c0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x3894
jmp 0x38b3
leaq 0xcbc2(%rip), %rdi      # 0x1045d
leaq 0xcb84(%rip), %rsi      # 0x10426
movl $0x20f, %edx            # imm = 0x20F
leaq 0xcb83(%rip), %rcx      # 0x10431
callq 0x21c0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x38c0
jmp 0x38df
leaq 0xcbb2(%rip), %rdi      # 0x10479
leaq 0xcb58(%rip), %rsi      # 0x10426
movl $0x210, %edx            # imm = 0x210
leaq 0xcb57(%rip), %rcx      # 0x10431
callq 0x21c0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x2040
movq -0x8(%rbp), %rdi
callq 0x2040
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/mux/dispatch.c
// Function: accept_stop
static void
accept_stop(struct dispatch_state * dstate)
{
	struct sock_listen * L;
	size_t i;

	/* Iterate through the sockets, cancelling any accepts. */
	for (i = 0; i < dstate->nsock_listen; i++) {
		L = &dstate->sock_listen[i];
		if (L->accept_cookie != NULL) {
			network_accept_cancel(L->accept_cookie);
			L->accept_cookie = NULL;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x3c29
movq -0x8(%rbp), %rax
movq (%rax), %rax
imulq $0x18, -0x18(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x3c19
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x7a30
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
jmp 0x3c1b
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x3bd4
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/mux/dispatch.c
// Function: readreq
static int
readreq(struct sock_active * S)
{

	/* We shouldn't be waiting yet. */
	assert(S->read_cookie == NULL);

	/* Wait for request packets to arrive. */
	if ((S->read_cookie =
	    wire_readpacket_wait(S->readq, callback_gotrequests, S)) == NULL) {
		warnp("Error waiting for requests to arrive");
		goto err0;
	}

	/* Success! */
	return (0);

err0:
	/* Failure! */
	return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x30(%rax)
jne 0x3c49
jmp 0x3c68
leaq 0xc8ea(%rip), %rdi      # 0x1053a
leaq 0xc7cf(%rip), %rsi      # 0x10426
movl $0xd5, %edx
leaq 0xc8ee(%rip), %rcx      # 0x10551
callq 0x21c0
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x10(%rbp), %rdx
leaq 0x65(%rip), %rsi        # 0x3ce0
callq 0xc3b0
movq -0x10(%rbp), %rcx
movq %rax, 0x30(%rcx)
cmpq $0x0, %rax
jne 0x3cc7
jmp 0x3c90
callq 0x20a0
cmpl $0x0, (%rax)
je 0x3cb5
leaq 0xc8d2(%rip), %rdi      # 0x10573
movb $0x0, %al
callq 0xbc80
callq 0x20a0
movl $0x0, (%rax)
jmp 0x3cc3
leaq 0xc8b7(%rip), %rdi      # 0x10573
movb $0x0, %al
callq 0xbed0
jmp 0x3cc5
jmp 0x3cd0
movl $0x0, -0x4(%rbp)
jmp 0x3cd7
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/mux/dispatch.c
// Function: callback_gotrequests
static int
callback_gotrequests(void * cookie, int status)
{
	struct sock_active * S = cookie;
	struct dispatch_state * dstate = S->dstate;
	struct wire_packet P;
	struct forwardee * F;

	/* We're not waiting for a packet to be available any more. */
	S->read_cookie = NULL;

	/* If the wait failed, the connection is dying. */
	if (status)
		goto fail;

	/* Handle packets until there are no more or we encounter an error. */
	do {
		/* Grab a packet. */
		if (wire_readpacket_peek(S->readq, &P))
			goto fail;

		/* Exit the loop if no packet is available. */
		if (P.buf == NULL)
			break;

		/* Bake a cookie. */
		if ((F = mpool_forwardee_malloc()) == NULL)
			goto err0;
		F->ID = P.ID;
		F->conn = S;

		/* Send the request to the target. */
		if (wire_requestqueue_add(dstate->Q, P.buf, P.len,
		    callback_gotresponse, F))
			goto err1;

		/* We have an additional outstanding request. */
		S->nrequests++;

		/* Consume the packet. */
		wire_readpacket_consume(S->readq, &P);
	} while (1);

	/* Wait for more packets to arrive. */
	if (readreq(S))
		goto err0;

	/* Success! */
	return (0);

fail:
	/* If we have no requests in progress, drop the connection. */
	if (S->nrequests == 0) {
		if (dropconn(S))
			goto err0;
	}

	/* Return success; the connection will be reaped later. */
	return (0);

err1:
	free(F);
err0:
	/* Failure! */
	return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq $0x0, 0x30(%rax)
cmpl $0x0, -0x14(%rbp)
je 0x3d19
jmp 0x3dd7
jmp 0x3d1b
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rdi
leaq -0x40(%rbp), %rsi
callq 0xc110
cmpl $0x0, %eax
je 0x3d36
jmp 0x3dd7
cmpq $0x0, -0x30(%rbp)
jne 0x3d3f
jmp 0x3dbe
callq 0x3e20
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
jne 0x3d53
jmp 0x3e06
movq -0x40(%rbp), %rcx
movq -0x48(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x48(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq -0x48(%rbp), %r8
leaq 0xbb(%rip), %rcx        # 0x3e40
callq 0xce50
cmpl $0x0, %eax
je 0x3d91
jmp 0x3dfd
movq -0x20(%rbp), %rax
movq 0x38(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x38(%rax)
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rdi
leaq -0x40(%rbp), %rsi
callq 0xc5e0
movb $0x1, %al
testb $0x1, %al
jne 0x3d1b
jmp 0x3dbe
movq -0x20(%rbp), %rdi
callq 0x3c30
cmpl $0x0, %eax
je 0x3dce
jmp 0x3e06
movl $0x0, -0x4(%rbp)
jmp 0x3e0d
movq -0x20(%rbp), %rax
cmpq $0x0, 0x38(%rax)
jne 0x3df4
movq -0x20(%rbp), %rdi
callq 0x3f70
cmpl $0x0, %eax
je 0x3df2
jmp 0x3e06
jmp 0x3df4
movl $0x0, -0x4(%rbp)
jmp 0x3e0d
movq -0x48(%rbp), %rdi
callq 0x2040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/mux/dispatch.c
// Function: callback_gotresponse
static int
callback_gotresponse(void * cookie, uint8_t * buf, size_t buflen)
{
	struct forwardee * F = cookie;
	struct sock_active * S = F->conn;
	struct sock_active * S_next;
	struct dispatch_state * dstate = S->dstate;
	struct wire_packet P;

	/* Did this request fail? */
	if (buf == NULL)
		goto failed;

	/* Send the response back to the client. */
	P.ID = F->ID;
	P.buf = buf;
	P.len = buflen;
	if (wire_writepacket(S->writeq, &P))
		goto err1;

	/* Free the cookie. */
	mpool_forwardee_free(F);

	/* We've finished with a request. */
	if (reqdone(S))
		goto err0;

	/* Success! */
	return (0);

failed:
	/* Free our cookie. */
	mpool_forwardee_free(F);

	/* We've finished with a request. */
	if (reqdone(S))
		goto err0;

	/* Stop trying to accept connections. */
	accept_stop(dstate);

	/* The connection to the upstream server has failed. */
	dstate->failed = 1;

	/* Stop reading requests from connections. */
	for (S = dstate->sock_active; S != NULL; S = S_next) {
		S_next = S->next;
		if ((S->read_cookie != NULL) && readreq_cancel(S))
			goto err0;
	}

	/* The failed request has been successfully handled. */
	return (0);

err1:
	mpool_forwardee_free(F);
err0:
	/* Failure! */
	return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x3e7b
jmp 0x3eda
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x30(%rbp), %rax
movq 0x28(%rax), %rdi
leaq -0x58(%rbp), %rsi
callq 0xd540
cmpl $0x0, %eax
je 0x3eb2
jmp 0x3f56
movq -0x28(%rbp), %rdi
callq 0x4290
movq -0x30(%rbp), %rdi
callq 0x42c0
cmpl $0x0, %eax
je 0x3ece
jmp 0x3f5f
movl $0x0, -0x4(%rbp)
jmp 0x3f66
movq -0x28(%rbp), %rdi
callq 0x4290
movq -0x30(%rbp), %rdi
callq 0x42c0
cmpl $0x0, %eax
je 0x3ef3
jmp 0x3f5f
movq -0x40(%rbp), %rdi
callq 0x3bc0
movq -0x40(%rbp), %rax
movl $0x1, 0x30(%rax)
movq -0x40(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x3f4d
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x3f41
movq -0x30(%rbp), %rdi
callq 0x4320
cmpl $0x0, %eax
je 0x3f41
jmp 0x3f5f
jmp 0x3f43
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x3f13
movl $0x0, -0x4(%rbp)
jmp 0x3f66
movq -0x28(%rbp), %rdi
callq 0x4290
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/mux/dispatch.c
// Function: reqdone
static int
reqdone(struct sock_active * S)
{

	/* We've finished a request. */
	S->nrequests--;

	/* Is this connection dead? */
	if ((S->nrequests == 0) && (S->read_cookie == NULL)) {
		if (dropconn(S))
			goto err0;
	}

	/* Success! */
	return (0);

err0:
	/* Failure! */
	return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x38(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x38(%rax)
jne 0x4304
movq -0x10(%rbp), %rax
cmpq $0x0, 0x30(%rax)
jne 0x4304
movq -0x10(%rbp), %rdi
callq 0x3f70
cmpl $0x0, %eax
je 0x4302
jmp 0x430d
jmp 0x4304
movl $0x0, -0x4(%rbp)
jmp 0x4314
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/mux/dispatch.c
// Function: readreq_cancel
static int
readreq_cancel(struct sock_active * S)
{

	/* Stop waiting for requests. */
	wire_readpacket_wait_cancel(S->read_cookie);
	S->read_cookie = NULL;

	/* Drop the connection if it is now dead. */
	if ((S->nrequests == 0) && dropconn(S))
		goto err0;

	/* Success! */
	return (0);

err0:
	/* Failure! */
	return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0xc580
movq -0x10(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x38(%rax)
jne 0x4360
movq -0x10(%rbp), %rdi
callq 0x3f70
cmpl $0x0, %eax
je 0x4360
jmp 0x4369
movl $0x0, -0x4(%rbp)
jmp 0x4370
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stfwi[P]duktape-cc/build/duktape/mod/ext/app_attachment/././app_attachment.hh
// Function: std::vector<char, std::allocator<char>> sw::util::detail::basic_executable_attachment<void>::serialize<std::vector<char, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const*)
static inline OutContainer serialize(const InContainer& in_data, const char* boundary_mark) // @sw todo: container instead of raw pointer.
    {
      static_assert(std::is_integral<typename InContainer::value_type>::value && std::is_integral<typename OutContainer::value_type>::value, "Container elements have to be integral.");
      static_assert(sizeof(typename InContainer::value_type) == sizeof(typename OutContainer::value_type),"Container elements have to have identical sizes.");
      using element_type = typename OutContainer::value_type;
      auto xo = element_type(0);
      auto out_data = OutContainer();
      out_data.reserve(in_data.size());
      for(size_t i=0; i<in_data.size(); ++i) {
        xo = element_type(xo<<8) | element_type(boundary_mark[i & 0xff]);
        out_data.push_back(element_type(in_data[i] ^ xo));
      }
      return out_data;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
movb $0x0, -0x1a(%rbp)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
callq 0x7630
movq -0x10(%rbp), %rdi
callq 0x31d0
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x7b00
jmp 0x8121
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
callq 0x31d0
movq %rax, %rcx
movq -0x58(%rbp), %rax
cmpq %rcx, %rax
jae 0x81a3
movq -0x18(%rbp), %rax
movzbl -0x38(%rbp), %ecx
movb (%rax,%rcx), %al
movb %al, -0x19(%rbp)
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x32d0
movq -0x48(%rbp), %rdi
movzbl (%rax), %eax
movzbl -0x19(%rbp), %ecx
xorl %ecx, %eax
movb %al, -0x39(%rbp)
leaq -0x39(%rbp), %rsi
callq 0x7750
jmp 0x817c
jmp 0x817e
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x8129
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x7ee0
jmp 0x81c0
movb $0x1, -0x1a(%rbp)
testb $0x1, -0x1a(%rbp)
jne 0x81b6
movq -0x48(%rbp), %rdi
callq 0x7ee0
movq -0x50(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x3440
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/carlitosmarin[P]Sistema-Ficheros-SOII/escribir.c
// Function: main
int main (int argc, char **argv) {
	if (argc != 4) {
		printf("Número de parametros incorrectos\n");
		return -1;
	}

	char *camino = argv[2];
    if(camino[strlen(camino)-1] == '/'){
        printf("ERROR: ( %s ) no es un fichero.\n",camino);
        return -1;
    }

	bmount(argv[1]);
	int offset = atoi(argv[3]);

    int bytes = 0;
    char buffer[1000];
    strcpy (buffer, "blablablablablablablablablablabla...\n");

    int nin = 0; //= reservar_inodo ('f', 6);

    int n = strlen(buffer);
    int m = 70;
    int i, offsetActual;
    int er;

   	for(i = 0, offsetActual = offset ; i < m; i++, offsetActual += n){
   		er = mi_write(camino,&buffer,offsetActual,n);
    	if(er < 0) {
            bumount();
    		return 0;
    	}
        bytes += er;
	}

	bumount();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x430, %rsp            # imm = 0x430
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x4, -0x8(%rbp)
je 0x5e99
leaq 0x6d3(%rip), %rdi       # 0x6559
movb $0x0, %al
callq 0x1090
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5fdd
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x430(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1080
movq %rax, %rcx
movq -0x430(%rbp), %rax
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2f, %eax
jne 0x5eee
movq -0x18(%rbp), %rsi
leaq 0x6a1(%rip), %rdi       # 0x657c
movb $0x0, %al
callq 0x1090
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5fdd
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1290
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x1150
movl %eax, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
leaq -0x410(%rbp), %rdi
leaq 0x67d(%rip), %rsi       # 0x659d
callq 0x1040
movl $0x0, -0x414(%rbp)
leaq -0x410(%rbp), %rdi
callq 0x1080
movl %eax, -0x418(%rbp)
movl $0x46, -0x41c(%rbp)
movl $0x0, -0x420(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x424(%rbp)
movl -0x420(%rbp), %eax
cmpl -0x41c(%rbp), %eax
jge 0x5fd6
movq -0x18(%rbp), %rdi
movl -0x424(%rbp), %edx
movl -0x418(%rbp), %ecx
leaq -0x410(%rbp), %rsi
callq 0x5be0
movl %eax, -0x428(%rbp)
cmpl $0x0, -0x428(%rbp)
jge 0x5fa7
movb $0x0, %al
callq 0x12f0
movl $0x0, -0x4(%rbp)
jmp 0x5fdd
movl -0x428(%rbp), %eax
addl -0x20(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x420(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x420(%rbp)
movl -0x418(%rbp), %eax
addl -0x424(%rbp), %eax
movl %eax, -0x424(%rbp)
jmp 0x5f5e
movb $0x0, %al
callq 0x12f0
movl -0x4(%rbp), %eax
addq $0x430, %rsp            # imm = 0x430
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/fanf2[P]luajit-2/src/buildvm.c
// Function: collect_reloc
static int collect_reloc(BuildCtx *ctx, uint8_t *addr, int idx, int type)
{
  if (ctx->nreloc >= BUILD_MAX_RELOC) {
    fprintf(stderr, "Error: too many relocations, increase BUILD_MAX_RELOC.\n");
    exit(1);
  }
  if (relocmap[idx] < 0) {
    relocmap[idx] = ctx->nrelocsym;
    ctx->relocsym[ctx->nrelocsym] = sym_decorate(ctx, "", extnames[idx]);
    ctx->nrelocsym++;
  }
  ctx->reloc[ctx->nreloc].ofs = (int32_t)(addr - ctx->code);
  ctx->reloc[ctx->nreloc].sym = relocmap[idx];
  ctx->reloc[ctx->nreloc].type = type;
  ctx->nreloc++;
  return 0;  /* Encode symbol offset of 0. */
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movl %edx, 0x4(%rsp)
movl %ecx, (%rsp)
movq 0x10(%rsp), %rax
cmpl $0x64, 0x44(%rax)
jl 0x6212
movq 0x11e01(%rip), %rax     # 0x17ff8
movq (%rax), %rdi
leaq 0xcdba(%rip), %rsi      # 0x12fbb
movb $0x0, %al
callq 0x4110
movl $0x1, %edi
callq 0x4190
movslq 0x4(%rsp), %rcx
leaq 0x11ef2(%rip), %rax     # 0x18110
cmpl $0x0, (%rax,%rcx,4)
jge 0x6283
movq 0x10(%rsp), %rax
movl 0x48(%rax), %edx
movslq 0x4(%rsp), %rcx
leaq 0x11ed8(%rip), %rax     # 0x18110
movl %edx, (%rax,%rcx,4)
movq 0x10(%rsp), %rdi
movslq 0x4(%rsp), %rcx
leaq 0x11294(%rip), %rax     # 0x174e0
movq (%rax,%rcx,8), %rdx
leaq 0xe18c(%rip), %rsi      # 0x143e3
callq 0x7470
movq %rax, %rdx
movq 0x10(%rsp), %rax
movq 0x60(%rax), %rax
movq 0x10(%rsp), %rcx
movslq 0x48(%rcx), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x10(%rsp), %rax
movl 0x48(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x48(%rax)
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movq 0x28(%rcx), %rcx
subq %rcx, %rax
movl %eax, %ecx
movq 0x10(%rsp), %rax
addq $0x90, %rax
movq 0x10(%rsp), %rdx
movslq 0x44(%rdx), %rdx
imulq $0xc, %rdx, %rdx
addq %rdx, %rax
movl %ecx, (%rax)
movslq 0x4(%rsp), %rcx
leaq 0x11e51(%rip), %rax     # 0x18110
movl (%rax,%rcx,4), %ecx
movq 0x10(%rsp), %rax
addq $0x90, %rax
movq 0x10(%rsp), %rdx
movslq 0x44(%rdx), %rdx
imulq $0xc, %rdx, %rdx
addq %rdx, %rax
movl %ecx, 0x4(%rax)
movl (%rsp), %ecx
movq 0x10(%rsp), %rax
addq $0x90, %rax
movq 0x10(%rsp), %rdx
movslq 0x44(%rdx), %rdx
imulq $0xc, %rdx, %rdx
addq %rdx, %rax
movl %ecx, 0x8(%rax)
movq 0x10(%rsp), %rax
movl 0x44(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x44(%rax)
xorl %eax, %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/fanf2[P]luajit-2/src/buildvm.c
// Function: sym_decorate
static const char *sym_decorate(BuildCtx *ctx,
				const char *prefix, const char *suffix)
{
  char name[256];
  char *p;
#if LJ_64
  const char *symprefix = ctx->mode == BUILD_machasm ? "_" : "";
#else
  const char *symprefix = ctx->mode != BUILD_elfasm ? "_" : "";
#endif
  sprintf(name, "%s%s%s", symprefix, prefix, suffix);
  p = strchr(name, '@');
  if (p) {
    if (!LJ_64 && (ctx->mode == BUILD_coffasm || ctx->mode == BUILD_peobj))
      name[0] = '@';
    else
      *p = '\0';
  }
  p = (char *)malloc(strlen(name)+1);  /* MSVC doesn't like strdup. */
  strcpy(p, name);
  return p;
}

// Assembly:
subq $0x128, %rsp            # imm = 0x128
movq %rdi, 0x120(%rsp)
movq %rsi, 0x118(%rsp)
movq %rdx, 0x110(%rsp)
movq 0x120(%rsp), %rax
movl 0x8(%rax), %edx
leaq 0xcf42(%rip), %rax      # 0x143e3
leaq 0xd593(%rip), %rcx      # 0x14a3b
cmpl $0x2, %edx
cmoveq %rcx, %rax
movq %rax, (%rsp)
leaq 0x10(%rsp), %rdi
movq (%rsp), %rdx
movq 0x118(%rsp), %rcx
movq 0x110(%rsp), %r8
leaq 0xbb20(%rip), %rsi      # 0x12ff3
movb $0x0, %al
callq 0x4180
leaq 0x10(%rsp), %rdi
movl $0x40, %esi
callq 0x40b0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x74fe
movq 0x8(%rsp), %rax
movb $0x0, (%rax)
leaq 0x10(%rsp), %rdi
callq 0x40a0
movq %rax, %rdi
addq $0x1, %rdi
callq 0x4130
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x4060
movq 0x8(%rsp), %rax
addq $0x128, %rsp            # imm = 0x128
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/fanf2[P]luajit-2/src/./buildvm_x64.h
// Function: build_backend
static int build_backend(BuildCtx *ctx)
{
  int op;
  int cmov = 1;
  int sse = 0;
#ifdef LUAJIT_CPU_NOCMOV
  cmov = 0;
#endif
#if defined(LUAJIT_CPU_SSE2) || defined(LJ_TARGET_X64)
  sse = 1;
#endif

  dasm_growpc(Dst, BC__MAX);

  build_subroutines(ctx, cmov, sse);

  dasm_put(Dst, 14276);
  for (op = 0; op < BC__MAX; op++)
    build_ins(ctx, (BCOp)op, op, cmov, sse);

  return BC__MAX;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x1, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
movl $0x1, 0x4(%rsp)
movq 0x10(%rsp), %rdi
movl $0x5c, %esi
callq 0x4660
movq 0x10(%rsp), %rdi
movl 0x8(%rsp), %esi
movl 0x4(%rsp), %edx
callq 0x7820
movq 0x10(%rsp), %rdi
movl $0x37c4, %esi           # imm = 0x37C4
movb $0x0, %al
callq 0x4840
movl $0x0, 0xc(%rsp)
cmpl $0x5c, 0xc(%rsp)
jge 0x771a
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
movl 0xc(%rsp), %edx
movl 0x8(%rsp), %ecx
movl 0x4(%rsp), %r8d
callq 0x9520
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x76eb
movl $0x5c, %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/fanf2[P]luajit-2/src/buildvm_asm.c
// Function: emit_asm_label
static void emit_asm_label(BuildCtx *ctx, const char *name, int size, int isfunc)
{
  switch (ctx->mode) {
  case BUILD_elfasm:
    fprintf(ctx->fp,
      "\n\t.globl %s\n"
      "\t.hidden %s\n"
      "\t.type %s, @%s\n"
      "\t.size %s, %d\n"
      "%s:\n",
      name, name, name, isfunc ? "function" : "object", name, size, name);
    break;
  case BUILD_coffasm:
    fprintf(ctx->fp, "\n\t.globl %s\n", name);
    if (isfunc)
      fprintf(ctx->fp, "\t.def %s; .scl 3; .type 32; .endef\n", name);
    fprintf(ctx->fp, "%s:\n", name);
    break;
  case BUILD_machasm:
    fprintf(ctx->fp,
      "\n\t.private_extern %s\n"
      "%s:\n", name, name);
    break;
  default:
    break;
  }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movl %ecx, 0x20(%rsp)
movq 0x30(%rsp), %rax
movl 0x8(%rax), %eax
movl %eax, 0x1c(%rsp)
testl %eax, %eax
je 0xbdc5
jmp 0xbda8
movl 0x1c(%rsp), %eax
subl $0x1, %eax
je 0xbe26
jmp 0xbdb3
movl 0x1c(%rsp), %eax
subl $0x2, %eax
je 0xbe83
jmp 0xbea6
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x28(%rsp), %rdx
movq 0x28(%rsp), %rcx
movq 0x28(%rsp), %r8
movl 0x20(%rsp), %esi
leaq 0x8a78(%rip), %r9       # 0x14860
leaq 0x8768(%rip), %rax      # 0x14557
cmpl $0x0, %esi
cmovneq %rax, %r9
movq 0x28(%rsp), %r11
movl 0x24(%rsp), %r10d
movq 0x28(%rsp), %rax
leaq 0x8a1a(%rip), %rsi      # 0x14826
movq %r11, (%rsp)
movl %r10d, 0x8(%rsp)
movq %rax, 0x10(%rsp)
movb $0x0, %al
callq 0x4110
jmp 0xbea8
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x28(%rsp), %rdx
leaq 0x8a2c(%rip), %rsi      # 0x14867
movb $0x0, %al
callq 0x4110
cmpl $0x0, 0x20(%rsp)
je 0xbe65
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x28(%rsp), %rdx
leaq 0x8a16(%rip), %rsi      # 0x14874
movb $0x0, %al
callq 0x4110
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x28(%rsp), %rdx
leaq 0x89e1(%rip), %rsi      # 0x1485b
movb $0x0, %al
callq 0x4110
jmp 0xbea8
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x28(%rsp), %rdx
movq 0x28(%rsp), %rcx
leaq 0x89fb(%rip), %rsi      # 0x14898
movb $0x0, %al
callq 0x4110
jmp 0xbea8
jmp 0xbea8
addq $0x38, %rsp
retq
nopl (%rax)