LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/statgen[P]statgen/lib/samtools-0.1.7a-hybrid/misc/maq2sam.c
// Function: main
int main(int argc, char *argv[])
{
	gzFile fp;
	if (argc == 1) {
		fprintf(stderr, "Version: %s\n", PACKAGE_VERSION);
		fprintf(stderr, "Usage: maq2sam <in.map> [<readGroup>]\n");
		return 1;
	}
	fp = strcmp(argv[1], "-")? gzopen(argv[1], "r") : gzdopen(fileno(stdin), "r");
	maq2tam_core(fp, argc > 2? argv[2] : 0);
	gzclose(fp);
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x1, %edi
je 0x1821
movq %rsi, %rbx
movl %edi, %ebp
movq 0x8(%rsi), %rdi
cmpb $0x2d, (%rdi)
jne 0x17c5
cmpb $0x0, 0x1(%rdi)
je 0x1802
leaq 0x9bd(%rip), %rsi       # 0x2189
callq 0x10f0
movq %rax, %r15
xorl %r14d, %r14d
cmpl $0x3, %ebp
jl 0x17e2
movq 0x10(%rbx), %rsi
jmp 0x17e4
xorl %esi, %esi
movq %r15, %rdi
callq 0x140e
movq %r15, %rdi
callq 0x1030
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x27cf(%rip), %rax      # 0x3fd8
movq (%rax), %rdi
callq 0x10d0
leaq 0x971(%rip), %rsi       # 0x2189
movl %eax, %edi
callq 0x1060
jmp 0x17d1
callq 0x1177
movl $0x1, %r14d
jmp 0x17f4
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/apps/msh2pts/../../pkgs/R3Shapes/R3Kdtree.cpp
// Function: gaps::R3Kdtree<Point*>::FindAny(gaps::R3Point const&, double, double) const
PtrType R3Kdtree<PtrType>::
FindAny(const R3Point& query_position, 
  RNScalar min_distance, RNScalar max_distance) const
{
  // Check root
  if (!root) return NULL;

  // Use squared distances for efficiency
  if (max_distance < 0) return NULL;
  if (min_distance < 0) min_distance = 0;
  RNLength min_distance_squared = min_distance * min_distance;
  RNLength max_distance_squared = max_distance * max_distance;

  // Search nodes recursively
  return FindAny(root, bbox, 
    NULL, query_position, 
    min_distance_squared, max_distance_squared,
    NULL, NULL);
}

// Assembly:
movapd %xmm0, %xmm2
movq 0x50(%rdi), %rax
testq %rax, %rax
sete %cl
xorpd %xmm0, %xmm0
ucomisd %xmm1, %xmm0
seta %dl
orb %cl, %dl
je 0x1593a
xorl %eax, %eax
retq
pushq %rax
movq %rsi, %r8
maxsd %xmm2, %xmm0
mulsd %xmm0, %xmm0
mulsd %xmm1, %xmm1
movq $0x0, (%rsp)
movq %rax, %rsi
movq %rdi, %rdx
xorl %ecx, %ecx
xorl %r9d, %r9d
callq 0x15a12
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O3/dmonaldo[P]simple-network-file-system/BasicFileSys.cpp
// Function: BasicFileSys::mount()
void BasicFileSys::mount()
{
  // mount the disk
  bool new_disk = disk.mount("DISK");

  // if the disk exists, return as no further initialization is needed
  if (!new_disk) return;

  // initialize the superblock
  struct superblock_t super_block;
  super_block.bitmap[0] = 0x3;		// mark blocks 0 and 1 as used
  for (int i = 1; i < BLOCK_SIZE; i++) {
    super_block.bitmap[i] = 0;
  }
  disk.write_block(0, (void *) &super_block);

  // initialize the root directory
  struct dirblock_t dir_block;
  dir_block.magic = DIR_MAGIC_NUM;
  dir_block.num_entries = 0;
  for (int i = 0; i < MAX_DIR_ENTRIES; i++) {
    dir_block.dir_entries[i].block_num = 0;
  }
  disk.write_block(1, (void *) &dir_block);

  // write a zeroed-out data block to all other blocks on disk
  struct datablock_t data_block;
  for (int i = 0; i < BLOCK_SIZE; i++) {
    data_block.data[i] = 0;
  }
  for (int i = 2; i < NUM_BLOCKS; i++) {
    disk.write_block(i, (void *) &data_block);
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x180, %rsp            # imm = 0x180
movq %rdi, %rbx
leaq 0x690f(%rip), %rsi      # 0xa050
callq 0x3964
testb %al, %al
je 0x386d
leaq 0x100(%rsp), %rdx
movb $0x3, (%rdx)
xorps %xmm0, %xmm0
movups %xmm0, 0x1(%rdx)
movups %xmm0, 0x11(%rdx)
movups %xmm0, 0x21(%rdx)
movups %xmm0, 0x31(%rdx)
movups %xmm0, 0x41(%rdx)
movups %xmm0, 0x51(%rdx)
movups %xmm0, 0x61(%rdx)
movups %xmm0, 0x70(%rdx)
movq %rbx, %rdi
xorl %esi, %esi
callq 0x3a68
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movq %rax, (%rsp)
movdqa 0x6879(%rip), %xmm0     # 0xa010
movl $0x1e, %eax
movdqa 0x687c(%rip), %xmm1     # 0xa020
movdqa 0x6884(%rip), %xmm2     # 0xa030
pshufd $0xf5, %xmm2, %xmm3     # xmm3 = xmm2[1,1,3,3]
movdqa 0x6887(%rip), %xmm4     # 0xa040
movdqa %xmm0, %xmm5
pxor %xmm1, %xmm5
movdqa %xmm2, %xmm6
pcmpgtd %xmm5, %xmm6
pshufd $0xf5, %xmm5, %xmm5     # xmm5 = xmm5[1,1,3,3]
pcmpeqd %xmm3, %xmm5
pand %xmm6, %xmm5
movd %xmm5, %ecx
testb $0x1, %cl
je 0x37e6
movw $0x0, -0xc(%rsp,%rax)
pextrw $0x4, %xmm5, %ecx
testb $0x1, %cl
je 0x37f6
movw $0x0, (%rsp,%rax)
paddq %xmm4, %xmm0
addq $0x18, %rax
cmpq $0x96, %rax
jne 0x37b9
movq %rsp, %rdx
movq %rbx, %rdi
movl $0x1, %esi
callq 0x3a68
pxor %xmm0, %xmm0
leaq 0x80(%rsp), %r14
movdqa %xmm0, 0x70(%r14)
movdqa %xmm0, 0x60(%r14)
movdqa %xmm0, 0x50(%r14)
movdqa %xmm0, 0x40(%r14)
movdqa %xmm0, 0x30(%r14)
movdqa %xmm0, 0x20(%r14)
movdqa %xmm0, 0x10(%r14)
movdqa %xmm0, (%r14)
movl $0x2, %ebp
movq %rbx, %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0x3a68
incl %ebp
cmpl $0x400, %ebp            # imm = 0x400
jne 0x3856
addq $0x180, %rsp            # imm = 0x180
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/dmonaldo[P]simple-network-file-system/BasicFileSys.cpp
// Function: BasicFileSys::get_free_block()
short BasicFileSys::get_free_block()
{
  // get superblock
  struct superblock_t super_block;
  disk.read_block(0, (void *) &super_block);
  
  // look for first available block
  for (int byte = 0; byte < BLOCK_SIZE; byte++) {

    // check to see if byte has available slot
    if (super_block.bitmap[byte] != 0xFF) {
 
      // loop to check each bit
      for (int bit = 0; bit < 8; bit++) {
        int mask = 1 << bit;
	if (mask & ~super_block.bitmap[byte]) {

          // Available block is found: set bit in bitmap, write result back
	  // to superblock, and return block number.
	  super_block.bitmap[byte] |= mask;
	  disk.write_block(0, (void *) &super_block);
	  return (byte * 8) + bit;
	}
      }
    }
  }

  // disk is full
  return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rdi, %rbx
xorl %r14d, %r14d
movq %rsp, %rdx
xorl %esi, %esi
callq 0x39da
xorl %eax, %eax
movzbl (%rsp,%rax), %edx
cmpl $0xff, %edx
je 0x38c0
xorl %ebp, %ebp
movl $0x1, %esi
movl %ebp, %ecx
shll %cl, %esi
btl %ebp, %edx
jae 0x38d3
incl %ebp
cmpl $0x8, %ebp
jne 0x38ab
incq %rax
addl $-0x8, %r14d
cmpq $0x80, %rax
jne 0x389d
xorl %ebp, %ebp
jmp 0x38e8
orl %esi, %edx
movb %dl, (%rsp,%rax)
movq %rsp, %rdx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x3a68
subl %r14d, %ebp
movl %ebp, %eax
addq $0x80, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/dmonaldo[P]simple-network-file-system/BasicFileSys.cpp
// Function: BasicFileSys::reclaim_block(short)
void BasicFileSys::reclaim_block(short block_num)
{
  // get superblock
  struct superblock_t super_block;
  disk.read_block(0, (void *) &super_block);

  // clear bit
  int byte = block_num / 8;		// byte number
  int bit = block_num % 8;		// bit number
  unsigned char mask = ~(1 << bit);	// mask to clear bit
  super_block.bitmap[byte] &= mask;

  // write back superblock
  disk.write_block(0, (void *) &super_block);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
movl %esi, %r15d
movq %rdi, %rbx
movq %rsp, %r14
xorl %esi, %esi
movq %r14, %rdx
callq 0x39da
leal 0x7(%r15), %eax
testw %r15w, %r15w
cmovnsl %r15d, %eax
cwtl
shrl $0x3, %eax
andb $0x7, %r15b
movl $0x1, %edx
movl %r15d, %ecx
shll %cl, %edx
movswq %ax, %rax
notb %dl
andb %dl, (%rsp,%rax)
movq %rbx, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x3a68
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/dmonaldo[P]simple-network-file-system/Disk.cpp
// Function: Disk::mount(char const*)
bool Disk::mount(const char *file_name)
{
  fd = open(file_name, O_RDWR);
  if (fd != -1) return false;

  fd = open(file_name, O_RDWR | O_CREAT | O_EXCL, S_IRUSR | S_IWUSR);
  if (fd == -1) {
    cerr << "Could not create disk" << endl;
    exit(-1);
  }

  return true;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movl $0x2, %esi
xorl %eax, %eax
callq 0x3200
movl %eax, %ebp
movl %eax, (%rbx)
cmpl $-0x1, %eax
jne 0x39a1
movq %r14, %rdi
movl $0xc2, %esi
movl $0x180, %edx            # imm = 0x180
xorl %eax, %eax
callq 0x3200
movl %eax, (%rbx)
cmpl $-0x1, %eax
je 0x39ac
cmpl $-0x1, %ebp
sete %al
popq %rbx
popq %r14
popq %rbp
retq
movq 0x963d(%rip), %rdi      # 0xcff0
leaq 0x669b(%rip), %rsi      # 0xa055
callq 0x3290
movq %rax, %rdi
callq 0x3170
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x3330
nop
// File: /workspace/github_cpp_makefile_star2_O3/dmonaldo[P]simple-network-file-system/Disk.cpp
// Function: Disk::read_block(int, void*)
void Disk::read_block(int block_num, void *block)
{
  off_t offset;
  off_t new_offset;
  ssize_t size; 

  if (block_num < 0 || block_num >= NUM_BLOCKS) {
    cerr << "Invalid block size" << endl;
    exit(-1);
  }

  offset = block_num * BLOCK_SIZE;
  new_offset = lseek(fd, offset, SEEK_SET);
  if (offset != new_offset) {
    cerr << "Seek failure" << endl;
    exit(-1);
  }

  size = read(fd, block, BLOCK_SIZE);
  if (size != BLOCK_SIZE) {
    cerr << "Failed to read entire block" << endl;
    exit(-1);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
cmpl $0x400, %esi            # imm = 0x400
jae 0x3a23
movq %rdx, %rbx
movl %esi, %r15d
movq %rdi, %r14
shll $0x7, %r15d
movl (%rdi), %edi
movq %r15, %rsi
xorl %edx, %edx
callq 0x3480
cmpq %r15, %rax
jne 0x3a33
movl (%r14), %edi
movl $0x80, %edx
movq %rbx, %rsi
callq 0x33a0
cmpq $0x80, %rax
jne 0x3a43
popq %rbx
popq %r14
popq %r15
retq
movq 0x95c6(%rip), %rdi      # 0xcff0
leaq 0x663a(%rip), %rsi      # 0xa06b
jmp 0x3a51
movq 0x95b6(%rip), %rdi      # 0xcff0
leaq 0x663d(%rip), %rsi      # 0xa07e
jmp 0x3a51
movq 0x95a6(%rip), %rdi      # 0xcff0
leaq 0x663a(%rip), %rsi      # 0xa08b
callq 0x3290
movq %rax, %rdi
callq 0x3170
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O3/dmonaldo[P]simple-network-file-system/Disk.cpp
// Function: Disk::write_block(int, void*)
void Disk::write_block(int block_num, void *block)
{
  off_t offset;
  off_t new_offset;
  ssize_t size; 

  if (block_num < 0 || block_num >= NUM_BLOCKS) {
    cerr << "Invalid block size" << endl;
    exit(-1);
  }

  offset = block_num * BLOCK_SIZE;
  new_offset = lseek(fd, offset, SEEK_SET);
  if (offset != new_offset) {
    cerr << "Seek failure" << endl;
    exit(-1);
  }

  size = write(fd, block, BLOCK_SIZE);
  if (size != BLOCK_SIZE) {
    cerr << "Failed to write entire block" << endl;
    exit(-1);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
cmpl $0x400, %esi            # imm = 0x400
jae 0x3ab1
movq %rdx, %rbx
movl %esi, %r15d
movq %rdi, %r14
shll $0x7, %r15d
movl (%rdi), %edi
movq %r15, %rsi
xorl %edx, %edx
callq 0x3480
cmpq %r15, %rax
jne 0x3ac1
movl (%r14), %edi
movl $0x80, %edx
movq %rbx, %rsi
callq 0x3130
cmpq $0x80, %rax
jne 0x3ad1
popq %rbx
popq %r14
popq %r15
retq
movq 0x9538(%rip), %rdi      # 0xcff0
leaq 0x65ac(%rip), %rsi      # 0xa06b
jmp 0x3adf
movq 0x9528(%rip), %rdi      # 0xcff0
leaq 0x65af(%rip), %rsi      # 0xa07e
jmp 0x3adf
movq 0x9518(%rip), %rdi      # 0xcff0
leaq 0x65c8(%rip), %rsi      # 0xa0a7
callq 0x3290
movq %rax, %rdi
callq 0x3170
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x3330
nop
// File: /workspace/github_cpp_makefile_star2_O3/dmonaldo[P]simple-network-file-system/FileSys.cpp
// Function: FileSys::cd(char const*)
void FileSys::cd(const char *name)
{
  bool error = false;
  bool found = false;
  char buffer[256];

  //retrieve current directory data block
  dirblock_t dir_ptr;
  bfs.read_block(curr_dir, (void *) &dir_ptr);

  //check if any sub directories exist in current directory
  if(dir_ptr.num_entries > 0){
    //check each sub directory and check directory names for match
    for(int i= 1; i <= dir_ptr.num_entries; i++){
      if(strcmp(dir_ptr.dir_entries[i].name, name) == 0){
        found = true;
        if(!is_directory(dir_ptr.dir_entries[i].block_num)){
          error = true;
          strcat(buffer, "500 File is not a directory\r\n");
        }
        else{
          strcat(buffer, "200 OK\r\n");
          curr_dir = dir_ptr.dir_entries[i].block_num;
        }
      }
    }
  }
  // if this point reached, no matching directory found
  if(found && !error){
    strcat(buffer, "503 File does not exist\r\n");
  }
  cout << buffer << endl;
  send(fs_sock, buffer, sizeof(buffer), 0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rsi, %r14
movq %rdi, %rbx
movswl 0x4(%rdi), %esi
leaq 0x108(%rsp), %r15
movq %r15, %rdx
callq 0x3956
cmpl $0x0, 0x4(%r15)
je 0x3e48
leaq 0x11c(%rsp), %r15
xorl %ebp, %ebp
xorl %r13d, %r13d
xorl %r12d, %r12d
movq %r15, %rdi
movq %r14, %rsi
callq 0x3370
testl %eax, %eax
jne 0x3e06
movswl 0xa(%r15), %esi
movq %rbx, %rdi
leaq 0x188(%rsp), %rdx
callq 0x3956
movl 0x188(%rsp), %r13d
movq %rsp, %rdi
callq 0x3160
addq %rsp, %rax
cmpl $-0x1, %r13d
je 0x3de9
movups 0x636f(%rip), %xmm0     # 0xa145
movups %xmm0, 0xe(%rax)
movups 0x6356(%rip), %xmm0     # 0xa137
movups %xmm0, (%rax)
movb $0x1, %r12b
jmp 0x3e03
movabsq $0xa0d4b4f20303032, %rcx # imm = 0xA0D4B4F20303032
movq %rcx, (%rax)
movb $0x0, 0x8(%rax)
movzwl 0xa(%r15), %eax
movw %ax, 0x4(%rbx)
movb $0x1, %r13b
movl 0x10c(%rsp), %eax
incq %rbp
addq $0xc, %r15
cmpq %rax, %rbp
jb 0x3d92
notb %r13b
orb %r12b, %r13b
testb $0x1, %r13b
jne 0x3e48
movq %rsp, %rdi
callq 0x3160
movups 0x631d(%rip), %xmm0     # 0xa155
movups %xmm0, (%rsp,%rax)
movups 0x631c(%rip), %xmm0     # 0xa15f
movups %xmm0, 0xa(%rsp,%rax)
movq %rsp, %r14
movq %r14, %rdi
callq 0x3160
movq 0x916e(%rip), %r15      # 0xcfc8
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x3310
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x3280
movsbl %al, %esi
movq %r15, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x31e0
movl 0x8(%rbx), %edi
movl $0x100, %edx            # imm = 0x100
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x3180
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/dmonaldo[P]simple-network-file-system/FileSys.cpp
// Function: FileSys::home()
void FileSys::home(){
  char buffer[1024];
  curr_dir = 1;
  strcpy(buffer, "200 OK\r\n Length: 0\r\n\r\n");
  send(fs_sock, buffer, sizeof(buffer), 0);
}

// Assembly:
subq $0x408, %rsp            # imm = 0x408
movw $0x1, 0x4(%rdi)
movups 0x6285(%rip), %xmm0     # 0xa16f
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movabsq $0xa0d0a0d30203a, %rax  # imm = 0xA0D0A0D30203A
movq %rax, 0xf(%rsi)
movl 0x8(%rdi), %edi
movl $0x400, %edx            # imm = 0x400
xorl %ecx, %ecx
callq 0x3180
addq $0x408, %rsp            # imm = 0x408
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/dmonaldo[P]simple-network-file-system/FileSys.cpp
// Function: FileSys::rm(char const*)
void FileSys::rm(const char *name)
{
  char buffer[MAX_FNAME_SIZE+256];
  dirblock_t curr_block;
  bool error = false;
  bool found = false;
  bfs.read_block(curr_dir,(void*)& curr_block);

  for (unsigned int i = 0; i < MAX_DIR_ENTRIES; i++){
    if (strcmp(curr_block.dir_entries[i].name, name) == 0){
      if (!is_directory(curr_block.dir_entries[i].block_num)){
        found = true;
        inode_t inode_block;
        bfs.read_block(curr_block.dir_entries[i].block_num,
                       (void*)&inode_block);
        for (size_t j = 0; j < (inode_block.size / BLOCK_SIZE) + 1; j++){
          bfs.reclaim_block(inode_block.blocks[i]);
          inode_block.blocks[i] = 0;
          inode_block.size = 0;
        }
        bfs.reclaim_block(curr_block.dir_entries[i].block_num);

        curr_block.dir_entries[i].name[0] = '\0';
        curr_block.dir_entries[i].block_num = 0;

        curr_block.num_entries--;
        bfs.write_block(curr_dir,(void*)& curr_block);
      }
      else{
        strcpy(buffer, "501: File is a directory\r\n");
        error = true;
      }
    }
  }
  if(!found && !error){
    strcpy(buffer, "503 File does not exist\r\n");
    error = true;
  }else{
    strcpy(buffer, "200 OK\r\nLength: 0\r\n\r\n");
  }
  //send buffer to client
  send(fs_sock, buffer, sizeof(buffer), 0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x228, %rsp            # imm = 0x228
movq %rsi, %r14
movq %rdi, %rbx
movswl 0x4(%rdi), %esi
leaq 0x90(%rsp), %rdx
callq 0x3956
movl $0x4, %ebp
leaq 0x98(%rsp), %r12
leaq 0x10(%rsp), %r13
xorl %r15d, %r15d
movl $0x0, 0xc(%rsp)
movq %r12, %rdi
movq %r14, %rsi
callq 0x3370
testl %eax, %eax
jne 0x4606
movswl 0xa(%r12), %esi
movq %rbx, %rdi
movq %r13, %rdx
callq 0x3956
cmpl $-0x1, 0x10(%rsp)
je 0x45e2
movswl 0xa(%r12), %esi
movq %rbx, %rdi
movq %r13, %rdx
callq 0x3956
movswl 0x10(%rsp,%rbp,2), %esi
movq %rbx, %rdi
callq 0x38f6
xorl %r15d, %r15d
movw %r15w, 0x10(%rsp,%rbp,2)
movl $0x0, 0x14(%rsp)
movswl 0xa(%r12), %esi
movq %rbx, %rdi
callq 0x38f6
movb $0x0, (%r12)
movw %r15w, 0xa(%r12)
decl 0x94(%rsp)
movswl 0x4(%rbx), %esi
movq %rbx, %rdi
leaq 0x90(%rsp), %rdx
callq 0x395c
movb $0x1, %r15b
jmp 0x4606
movups 0x5c22(%rip), %xmm0     # 0xa20b
movups %xmm0, 0x11b(%rsp)
movups 0x5c08(%rip), %xmm0     # 0xa200
movaps %xmm0, 0x110(%rsp)
movb $0x1, %al
movl %eax, 0xc(%rsp)
addq $0xc, %r12
incq %rbp
cmpq $0xe, %rbp
jne 0x454f
orb 0xc(%rsp), %r15b
testb $0x1, %r15b
je 0x4645
movups 0x5af8(%rip), %xmm0     # 0xa121
movaps %xmm0, 0x110(%rsp)
movabsq $0xa0d0a0d30203a, %rax  # imm = 0xA0D0A0D30203A
movq %rax, 0x11e(%rsp)
jmp 0x4663
movups 0x5b13(%rip), %xmm0     # 0xa15f
movups %xmm0, 0x11a(%rsp)
movups 0x5afa(%rip), %xmm0     # 0xa155
movaps %xmm0, 0x110(%rsp)
movl 0x8(%rbx), %edi
leaq 0x110(%rsp), %rsi
movl $0x109, %edx            # imm = 0x109
xorl %ecx, %ecx
callq 0x3180
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/dmonaldo[P]simple-network-file-system/Shell.cpp
// Function: Shell::mkdir_rpc(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Shell::mkdir_rpc(string dname) {
  string command = "mkdir " + dname + "\r\n";
  char message[2048];
  char received[2048];
  strcpy(message, command.c_str());

  // send to server
  send(cs_sock, message, sizeof(message), 0);
  recv(cs_sock, received, sizeof(received), 0);

  // print
  print_response("mkdir", received);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1068, %rsp           # imm = 0x1068
movq %rsi, %rdx
movq %rdi, %rbx
leaq 0x4290(%rip), %rsi      # 0xa53b
leaq 0x60(%rsp), %r14
movq %r14, %rdi
callq 0x8b2c
leaq 0x3e75(%rip), %rsi      # 0xa134
movq %r14, %rdi
callq 0x3490
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
je 0x62ed
movq %rsi, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
jmp 0x62f7
movups (%rcx), %xmm0
movups %xmm0, (%r15)
movq %r15, %rsi
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x70(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x632e
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x32c0
movq (%rsp), %rsi
leaq 0x60(%rsp), %r14
movq %r14, %rdi
callq 0x3270
movl (%rbx), %edi
movl $0x800, %edx            # imm = 0x800
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x3180
movl (%rbx), %edi
leaq 0x860(%rsp), %rsi
movl $0x800, %edx            # imm = 0x800
xorl %ecx, %ecx
callq 0x3110
leaq 0x50(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x3f28(%rip), %rsi      # 0xa29a
leaq 0x3f26(%rip), %rdx      # 0xa29f
leaq 0x40(%rsp), %rdi
callq 0x5d7e
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x860(%rsp), %rbx
movq %rbx, %rdi
callq 0x3160
leaq (%rsp,%rax), %rdx
addq $0x860, %rdx            # imm = 0x860
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
callq 0x5d7e
leaq 0x40(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0x648a
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x63db
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x32c0
movq 0x40(%rsp), %rdi
cmpq %r14, %rdi
je 0x63f2
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x32c0
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x6408
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x32c0
addq $0x1068, %rsp           # imm = 0x1068
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x6436
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x32c0
jmp 0x6436
movq %rax, %rbx
movq 0x40(%rsp), %rdi
cmpq %r14, %rdi
je 0x646c
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x32c0
jmp 0x646c
jmp 0x6469
movq %rax, %rbx
leaq 0x70(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6482
movq 0x70(%rsp), %rsi
jmp 0x647a
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x6482
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x32c0
movq %rbx, %rdi
callq 0x3440
// File: /workspace/github_cpp_makefile_star2_O3/dmonaldo[P]simple-network-file-system/Shell.cpp
// Function: Shell::cd_rpc(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Shell::cd_rpc(string dname) {
  string command = "cd " + dname + "\r\n";
  char message[2048];
  char received[2048];
  strcpy(message, command.c_str());

  // send to server
  send(cs_sock, message, sizeof(message), 0);
  recv(cs_sock, received, sizeof(received), 0);

  // print
  print_response("cd", received);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1068, %rsp           # imm = 0x1068
movq %rsi, %rdx
movq %rdi, %rbx
leaq 0x3de9(%rip), %rsi      # 0xa542
leaq 0x60(%rsp), %r14
movq %r14, %rdi
callq 0x8b2c
leaq 0x39c7(%rip), %rsi      # 0xa134
movq %r14, %rdi
callq 0x3490
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
je 0x679b
movq %rsi, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
jmp 0x67a5
movups (%rcx), %xmm0
movups %xmm0, (%r15)
movq %r15, %rsi
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x70(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x67dc
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x32c0
movq (%rsp), %rsi
leaq 0x60(%rsp), %r14
movq %r14, %rdi
callq 0x3270
movl (%rbx), %edi
movl $0x800, %edx            # imm = 0x800
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x3180
movl (%rbx), %edi
leaq 0x860(%rsp), %rsi
movl $0x800, %edx            # imm = 0x800
xorl %ecx, %ecx
callq 0x3110
leaq 0x50(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x3a80(%rip), %rsi      # 0xa2a0
leaq 0x3a7b(%rip), %rdx      # 0xa2a2
leaq 0x40(%rsp), %rdi
callq 0x5d7e
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x860(%rsp), %rbx
movq %rbx, %rdi
callq 0x3160
leaq (%rsp,%rax), %rdx
addq $0x860, %rdx            # imm = 0x860
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
callq 0x5d7e
leaq 0x40(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0x648a
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x6889
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x32c0
movq 0x40(%rsp), %rdi
cmpq %r14, %rdi
je 0x68a0
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x32c0
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x68b6
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x32c0
addq $0x1068, %rsp           # imm = 0x1068
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x68e4
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x32c0
jmp 0x68e4
movq %rax, %rbx
movq 0x40(%rsp), %rdi
cmpq %r14, %rdi
je 0x691a
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x32c0
jmp 0x691a
jmp 0x6917
movq %rax, %rbx
leaq 0x70(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6930
movq 0x70(%rsp), %rsi
jmp 0x6928
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x6930
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x32c0
movq %rbx, %rdi
callq 0x3440
// File: /workspace/github_cpp_makefile_star2_O3/dmonaldo[P]simple-network-file-system/Shell.cpp
// Function: Shell::home_rpc()
void Shell::home_rpc() {
  string command = "home\r\n";
  char message[200];
  char received[2048];
  strcpy(message, command.c_str());

  // send to server
  send(cs_sock, message, sizeof(message), 0);
  recv(cs_sock, received, sizeof(received), 0);

  // print
  print_response("home", received);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x938, %rsp            # imm = 0x938
movq %rdi, %rbx
leaq 0x50(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x3bed(%rip), %rsi      # 0xa546
leaq 0x3bec(%rip), %rdx      # 0xa54c
leaq 0x40(%rsp), %r14
movq %r14, %rdi
callq 0x5d7e
movq (%r14), %rsi
leaq 0x60(%rsp), %r14
movq %r14, %rdi
callq 0x3270
movl (%rbx), %edi
movl $0xc8, %edx
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x3180
movl (%rbx), %edi
leaq 0x130(%rsp), %rsi
movl $0x800, %edx            # imm = 0x800
xorl %ecx, %ecx
callq 0x3110
leaq 0x30(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x38ef(%rip), %rsi      # 0xa2a3
leaq 0x38ec(%rip), %rdx      # 0xa2a7
leaq 0x20(%rsp), %rdi
callq 0x5d7e
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x130(%rsp), %rbx
movq %rbx, %rdi
callq 0x3160
leaq (%rsp,%rax), %rdx
addq $0x130, %rdx            # imm = 0x130
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x5d7e
leaq 0x20(%rsp), %rsi
movq %rsp, %rdx
callq 0x648a
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x6a18
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x32c0
movq 0x20(%rsp), %rdi
cmpq %r14, %rdi
je 0x6a2f
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x32c0
movq 0x40(%rsp), %rdi
cmpq %r15, %rdi
je 0x6a46
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x32c0
addq $0x938, %rsp            # imm = 0x938
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x6a73
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x32c0
jmp 0x6a73
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r14, %rdi
je 0x6a91
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x32c0
jmp 0x6a91
jmp 0x6a8e
movq %rax, %rbx
movq 0x40(%rsp), %rdi
cmpq %r15, %rdi
je 0x6aa8
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x32c0
movq %rbx, %rdi
callq 0x3440
// File: /workspace/github_cpp_makefile_star2_O3/dmonaldo[P]simple-network-file-system/Shell.cpp
// Function: Shell::rmdir_rpc(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Shell::rmdir_rpc(string dname) {
  string command = "rmdir " + dname + "\r\n";
  char message[2048];
  char received[2048];
  strcpy(message, command.c_str());

  // send to server
  send(cs_sock, message, sizeof(message), 0);
  recv(cs_sock, received, sizeof(received), 0);

  // print
  print_response("rmdir", received);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1068, %rsp           # imm = 0x1068
movq %rsi, %rdx
movq %rdi, %rbx
leaq 0x3a82(%rip), %rsi      # 0xa54d
leaq 0x60(%rsp), %r14
movq %r14, %rdi
callq 0x8b2c
leaq 0x3655(%rip), %rsi      # 0xa134
movq %r14, %rdi
callq 0x3490
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
je 0x6b0d
movq %rsi, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
jmp 0x6b17
movups (%rcx), %xmm0
movups %xmm0, (%r15)
movq %r15, %rsi
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x70(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6b4e
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x32c0
movq (%rsp), %rsi
leaq 0x60(%rsp), %r14
movq %r14, %rdi
callq 0x3270
movl (%rbx), %edi
movl $0x800, %edx            # imm = 0x800
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x3180
movl (%rbx), %edi
leaq 0x860(%rsp), %rsi
movl $0x800, %edx            # imm = 0x800
xorl %ecx, %ecx
callq 0x3110
leaq 0x50(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x3716(%rip), %rsi      # 0xa2a8
leaq 0x3714(%rip), %rdx      # 0xa2ad
leaq 0x40(%rsp), %rdi
callq 0x5d7e
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x860(%rsp), %rbx
movq %rbx, %rdi
callq 0x3160
leaq (%rsp,%rax), %rdx
addq $0x860, %rdx            # imm = 0x860
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
callq 0x5d7e
leaq 0x40(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0x648a
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x6bfb
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x32c0
movq 0x40(%rsp), %rdi
cmpq %r14, %rdi
je 0x6c12
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x32c0
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x6c28
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x32c0
addq $0x1068, %rsp           # imm = 0x1068
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x6c56
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x32c0
jmp 0x6c56
movq %rax, %rbx
movq 0x40(%rsp), %rdi
cmpq %r14, %rdi
je 0x6c8c
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x32c0
jmp 0x6c8c
jmp 0x6c89
movq %rax, %rbx
leaq 0x70(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6ca2
movq 0x70(%rsp), %rsi
jmp 0x6c9a
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x6ca2
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x32c0
movq %rbx, %rdi
callq 0x3440
// File: /workspace/github_cpp_makefile_star2_O3/dmonaldo[P]simple-network-file-system/Shell.cpp
// Function: Shell::ls_rpc()
void Shell::ls_rpc() {
  string command = "ls\r\n";
  char message[2048];
  char received[2048];
  strcpy(message, command.c_str());

  // send to server
  send(cs_sock, message, sizeof(message), 0);
  recv(cs_sock, received, sizeof(received), 0);

  // print
  print_response("ls", received);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1068, %rsp           # imm = 0x1068
movq %rdi, %rbx
leaq 0x50(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x3889(%rip), %rsi      # 0xa554
leaq 0x3886(%rip), %rdx      # 0xa558
leaq 0x40(%rsp), %r14
movq %r14, %rdi
callq 0x5d7e
movq (%r14), %rsi
leaq 0x860(%rsp), %r14
movq %r14, %rdi
callq 0x3270
movl (%rbx), %edi
movl $0x800, %edx            # imm = 0x800
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x3180
movl (%rbx), %edi
leaq 0x60(%rsp), %rsi
movl $0x800, %edx            # imm = 0x800
xorl %ecx, %ecx
callq 0x3110
leaq 0x30(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x3588(%rip), %rsi      # 0xa2ae
leaq 0x3583(%rip), %rdx      # 0xa2b0
leaq 0x20(%rsp), %rdi
callq 0x5d7e
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x60(%rsp), %rbx
movq %rbx, %rdi
callq 0x3160
leaq (%rsp,%rax), %rdx
addq $0x60, %rdx
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x5d7e
leaq 0x20(%rsp), %rsi
movq %rsp, %rdx
callq 0x648a
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x6d84
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x32c0
movq 0x20(%rsp), %rdi
cmpq %r14, %rdi
je 0x6d9b
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x32c0
movq 0x40(%rsp), %rdi
cmpq %r15, %rdi
je 0x6db2
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x32c0
addq $0x1068, %rsp           # imm = 0x1068
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x6ddf
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x32c0
jmp 0x6ddf
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r14, %rdi
je 0x6dfd
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x32c0
jmp 0x6dfd
jmp 0x6dfa
movq %rax, %rbx
movq 0x40(%rsp), %rdi
cmpq %r15, %rdi
je 0x6e14
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x32c0
movq %rbx, %rdi
callq 0x3440
// File: /workspace/github_cpp_makefile_star2_O3/dmonaldo[P]simple-network-file-system/Shell.cpp
// Function: Shell::create_rpc(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Shell::create_rpc(string fname) {
  string command = "create " + fname + "\r\n";
  char message[2048];
  char received[2048];
  strcpy(message, command.c_str());

  // send to server
  send(cs_sock, message, sizeof(message), 0);
  recv(cs_sock, received, sizeof(received), 0);

  // print
  print_response("create", received);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1068, %rsp           # imm = 0x1068
movq %rsi, %rdx
movq %rdi, %rbx
leaq 0x3722(%rip), %rsi      # 0xa559
leaq 0x60(%rsp), %r14
movq %r14, %rdi
callq 0x8b2c
leaq 0x32e9(%rip), %rsi      # 0xa134
movq %r14, %rdi
callq 0x3490
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
je 0x6e79
movq %rsi, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
jmp 0x6e83
movups (%rcx), %xmm0
movups %xmm0, (%r15)
movq %r15, %rsi
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x70(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6eba
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x32c0
movq (%rsp), %rsi
leaq 0x60(%rsp), %r14
movq %r14, %rdi
callq 0x3270
movl (%rbx), %edi
movl $0x800, %edx            # imm = 0x800
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x3180
movl (%rbx), %edi
leaq 0x860(%rsp), %rsi
movl $0x800, %edx            # imm = 0x800
xorl %ecx, %ecx
callq 0x3110
leaq 0x50(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x33b3(%rip), %rsi      # 0xa2b1
leaq 0x33b2(%rip), %rdx      # 0xa2b7
leaq 0x40(%rsp), %rdi
callq 0x5d7e
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x860(%rsp), %rbx
movq %rbx, %rdi
callq 0x3160
leaq (%rsp,%rax), %rdx
addq $0x860, %rdx            # imm = 0x860
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
callq 0x5d7e
leaq 0x40(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0x648a
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x6f67
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x32c0
movq 0x40(%rsp), %rdi
cmpq %r14, %rdi
je 0x6f7e
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x32c0
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x6f94
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x32c0
addq $0x1068, %rsp           # imm = 0x1068
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x6fc2
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x32c0
jmp 0x6fc2
movq %rax, %rbx
movq 0x40(%rsp), %rdi
cmpq %r14, %rdi
je 0x6ff8
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x32c0
jmp 0x6ff8
jmp 0x6ff5
movq %rax, %rbx
leaq 0x70(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x700e
movq 0x70(%rsp), %rsi
jmp 0x7006
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x700e
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x32c0
movq %rbx, %rdi
callq 0x3440
// File: /workspace/github_cpp_makefile_star2_O3/dmonaldo[P]simple-network-file-system/Shell.cpp
// Function: Shell::cat_rpc(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Shell::cat_rpc(string fname) {
  // to implement
  string command = "cat " + fname + "\r\n";
  char message[2048];
  char received[2048];
  strcpy(message, command.c_str());

  // send to server
  send(cs_sock, message, sizeof(message), 0);
  recv(cs_sock, received, sizeof(received), 0);

  // print
  print_response("cat", received);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1068, %rsp           # imm = 0x1068
movq %rsi, %rdx
movq %rdi, %rbx
leaq 0x352e(%rip), %rsi      # 0xa561
leaq 0x60(%rsp), %r14
movq %r14, %rdi
callq 0x8b2c
leaq 0x30ed(%rip), %rsi      # 0xa134
movq %r14, %rdi
callq 0x3490
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
je 0x7075
movq %rsi, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
jmp 0x707f
movups (%rcx), %xmm0
movups %xmm0, (%r15)
movq %r15, %rsi
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x70(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x70b6
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x32c0
movq (%rsp), %rsi
leaq 0x60(%rsp), %r14
movq %r14, %rdi
callq 0x3270
movl (%rbx), %edi
movl $0x800, %edx            # imm = 0x800
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x3180
movl (%rbx), %edi
leaq 0x860(%rsp), %rsi
movl $0x800, %edx            # imm = 0x800
xorl %ecx, %ecx
callq 0x3110
leaq 0x50(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x31c5(%rip), %rsi      # 0xa2bf
leaq 0x31c1(%rip), %rdx      # 0xa2c2
leaq 0x40(%rsp), %rdi
callq 0x5d7e
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x860(%rsp), %rbx
movq %rbx, %rdi
callq 0x3160
leaq (%rsp,%rax), %rdx
addq $0x860, %rdx            # imm = 0x860
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
callq 0x5d7e
leaq 0x40(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0x648a
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x7163
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x32c0
movq 0x40(%rsp), %rdi
cmpq %r14, %rdi
je 0x717a
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x32c0
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x7190
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x32c0
addq $0x1068, %rsp           # imm = 0x1068
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x71be
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x32c0
jmp 0x71be
movq %rax, %rbx
movq 0x40(%rsp), %rdi
cmpq %r14, %rdi
je 0x71f4
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x32c0
jmp 0x71f4
jmp 0x71f1
movq %rax, %rbx
leaq 0x70(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x720a
movq 0x70(%rsp), %rsi
jmp 0x7202
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x720a
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x32c0
movq %rbx, %rdi
callq 0x3440
// File: /workspace/github_cpp_makefile_star2_O3/dmonaldo[P]simple-network-file-system/Shell.cpp
// Function: Shell::rm_rpc(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Shell::rm_rpc(string fname) {
  string command = "rm " + fname + "\r\n";
  char message[2048];
  char received[2048];
  strcpy(message, command.c_str());

  // send to server
  send(cs_sock, message, sizeof(message), 0);
  recv(cs_sock, received, sizeof(received), 0);

  // print
  print_response("rm", received);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1068, %rsp           # imm = 0x1068
movq %rsi, %rdx
movq %rdi, %rbx
leaq 0x2f73(%rip), %rsi      # 0xa56c
leaq 0x60(%rsp), %r14
movq %r14, %rdi
callq 0x8b2c
leaq 0x2b27(%rip), %rsi      # 0xa134
movq %r14, %rdi
callq 0x3490
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
je 0x763b
movq %rsi, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
jmp 0x7645
movups (%rcx), %xmm0
movups %xmm0, (%r15)
movq %r15, %rsi
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x70(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x767c
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x32c0
movq (%rsp), %rsi
leaq 0x60(%rsp), %r14
movq %r14, %rdi
callq 0x3270
movl (%rbx), %edi
movl $0x800, %edx            # imm = 0x800
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x3180
movl (%rbx), %edi
leaq 0x860(%rsp), %rsi
movl $0x800, %edx            # imm = 0x800
xorl %ecx, %ecx
callq 0x3110
leaq 0x50(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x2c3f(%rip), %rsi      # 0xa2ff
leaq 0x2c3a(%rip), %rdx      # 0xa301
leaq 0x40(%rsp), %rdi
callq 0x5d7e
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x860(%rsp), %rbx
movq %rbx, %rdi
callq 0x3160
leaq (%rsp,%rax), %rdx
addq $0x860, %rdx            # imm = 0x860
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
callq 0x5d7e
leaq 0x40(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0x648a
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x7729
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x32c0
movq 0x40(%rsp), %rdi
cmpq %r14, %rdi
je 0x7740
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x32c0
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x7756
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x32c0
addq $0x1068, %rsp           # imm = 0x1068
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x7784
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x32c0
jmp 0x7784
movq %rax, %rbx
movq 0x40(%rsp), %rdi
cmpq %r14, %rdi
je 0x77ba
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x32c0
jmp 0x77ba
jmp 0x77b7
movq %rax, %rbx
leaq 0x70(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x77d0
movq 0x70(%rsp), %rsi
jmp 0x77c8
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x77d0
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x32c0
movq %rbx, %rdi
callq 0x3440
// File: /workspace/github_cpp_makefile_star2_O3/dmonaldo[P]simple-network-file-system/Shell.cpp
// Function: Shell::stat_rpc(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Shell::stat_rpc(string fname)
{
  string command = "stat " + fname + "\r\n";
  char* buffer[2048];
  send(cs_sock, command.c_str(), strlen(command.c_str()), 0);
  recv(cs_sock, buffer, sizeof(buffer), 0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x4028, %rsp           # imm = 0x4028
movq %rsi, %rdx
movq %rdi, %rbx
leaq 0x2d7e(%rip), %rsi      # 0xa570
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x8b2c
leaq 0x292e(%rip), %rsi      # 0xa134
movq %r14, %rdi
callq 0x3490
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %r14
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %r14
je 0x7834
movq %r14, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
jmp 0x783e
movups (%rcx), %xmm0
movups %xmm0, (%r15)
movq %r15, %r14
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7875
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x32c0
movq (%rsp), %r14
movl (%rbx), %ebp
movq %r14, %rdi
callq 0x3160
movl %ebp, %edi
movq %r14, %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x3180
movl (%rbx), %edi
leaq 0x20(%rsp), %rsi
movl $0x4000, %edx           # imm = 0x4000
xorl %ecx, %ecx
callq 0x3110
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x78b7
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x32c0
addq $0x4028, %rsp           # imm = 0x4028
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x78f6
movq 0x30(%rsp), %rsi
jmp 0x78ee
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x78f6
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x32c0
movq %rbx, %rdi
callq 0x3440
// File: /workspace/github_cpp_makefile_star2_O3/dmonaldo[P]simple-network-file-system/Shell.cpp
// Function: Shell::run()
void Shell::run()
{
  // make sure that the file system is mounted
  if (!is_mounted)
 	return;

  // continue until the user quits
  bool user_quit = false;
  while (!user_quit) {

    // print prompt and get command line
    string command_str;
    cout << PROMPT_STRING;
    getline(cin, command_str);

    // execute the command
    user_quit = execute_command(command_str);
  }

  // unmount the file system
  unmountNFS();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
cmpb $0x1, 0x4(%rdi)
jne 0x79ef
movq %rdi, %rbx
leaq 0x18(%rsp), %r14
leaq 0x38(%rsp), %r12
movq 0x56ae(%rip), %r15      # 0xcfd8
leaq 0x28(%rsp), %r13
movq %r14, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movb $0x0, 0x18(%rsp)
movq 0x5937(%rip), %rsi      # 0xd280
movq 0x5938(%rip), %rdx      # 0xd288
movq 0x5671(%rip), %rdi      # 0xcfc8
callq 0x3310
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x3280
movsbl %al, %edx
movq %r15, %rdi
leaq 0x8(%rsp), %rsi
callq 0x3470
movq %r12, 0x28(%rsp)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
addq %rsi, %rdx
movq %r13, %rdi
callq 0x5ce8
movq %rbx, %rdi
movq %r13, %rsi
callq 0x7a3c
movl %eax, %ebp
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x79be
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x32c0
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x79d5
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32c0
testb %bpl, %bpl
je 0x792f
cmpb $0x1, 0x4(%rbx)
jne 0x79ef
movl (%rbx), %edi
callq 0x34a0
movb $0x0, 0x4(%rbx)
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x7a1d
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x32c0
jmp 0x7a1d
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x7a34
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32c0
movq %rbx, %rdi
callq 0x3440
// File: /workspace/github_cpp_makefile_star2_O3/myudelson[P]hmm-scalable/utilsSt.cpp
// Function: writeSolverInfo(_IO_FILE*, task*)
void writeSolverInfo(FILE *fid, struct task *task) {
    // solver id
    if( task->solver_setting>0 ) {
        fprintf(fid,"SolverId\t%d.%d.%d\n",task->structure,task->solver,task->solver_setting);
    } else {
        fprintf(fid,"SolverId\t%d.%d\n",task->structure,task->solver);
    }
	// nK
    fprintf(fid,"nK\t%d\n",task->nK);
    // nG
    fprintf(fid,"nG\t%d\n",task->nG);
    // nS
    fprintf(fid,"nS\t%d\n",task->nS);
    // nO
    fprintf(fid,"nO\t%d\n",task->nO);
    // nZ
    fprintf(fid,"nZ\t%d\n",task->nZ);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movsbl 0x50(%rsi), %r8d
testl %r8d, %r8d
jle 0x7449
movsbl 0x4e(%r14), %edx
movsbl 0x4f(%r14), %ecx
leaq 0xb724(%rip), %rsi      # 0x12b61
movq %rbx, %rdi
xorl %eax, %eax
callq 0x22b0
jmp 0x7464
movsbl 0x4e(%r14), %edx
movsbl 0x4f(%r14), %ecx
leaq 0xb71a(%rip), %rsi      # 0x12b74
movq %rbx, %rdi
xorl %eax, %eax
callq 0x22b0
movl 0x908(%r14), %edx
leaq 0xb712(%rip), %rsi      # 0x12b84
movq %rbx, %rdi
xorl %eax, %eax
callq 0x22b0
movl 0x904(%r14), %edx
leaq 0xb701(%rip), %rsi      # 0x12b8b
movq %rbx, %rdi
xorl %eax, %eax
callq 0x22b0
movsbl 0x900(%r14), %edx
leaq 0xb6ef(%rip), %rsi      # 0x12b92
movq %rbx, %rdi
xorl %eax, %eax
callq 0x22b0
movsbl 0x901(%r14), %edx
leaq 0xb6dd(%rip), %rsi      # 0x12b99
movq %rbx, %rdi
xorl %eax, %eax
callq 0x22b0
movsbl 0x910(%r14), %edx
leaq 0xb6cb(%rip), %rsi      # 0x12ba0
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x22b0
// File: /workspace/github_cpp_makefile_star2_O3/myudelson[P]hmm-scalable/utilsSt.cpp
// Function: readSolverInfo(_IO_FILE*, task*, int*)
void readSolverInfo(FILE *fid, struct task *task, NDAT *line_no) {
    string s;
    int c, i1, i2;
    // SolverId
    fscanf(fid,"SolverId\t%i.%i", &i1, &i2);
    task->structure = (NPAR) i1;
    task->solver    = (NPAR) i2;
    fscanf(fid,"SolverId\t%hhu.%hhu", &task->structure, &task->solver);
    c = fscanf(fid,".%hhu\n", &task->solver_setting);
    if( c<1 ) {
        fscanf(fid,"\n");
        task->solver_setting = -1;
    }
    (*line_no)++;
	// nK
    fscanf(fid,"nK\t%i\n",&task->nK);
    (*line_no)++;
    // nG
    fscanf(fid,"nG\t%i\n",&task->nG);
    (*line_no)++;
    // nS
    fscanf(fid,"nS\t%hhu\n",&task->nS);
    (*line_no)++;
    // nO
    fscanf(fid,"nO\t%hhu\n",&task->nO);
    (*line_no)++;
    // nZ
    fscanf(fid,"nZ\t%hhu\n",&task->nZ);
    (*line_no)++;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x20(%rsp), %r13
movq %r13, -0x10(%r13)
movq $0x0, -0x8(%r13)
movb $0x0, (%r13)
leaq 0xb68e(%rip), %rsi      # 0x12ba7
leaq 0xc(%rsp), %rdx
leaq 0x8(%rsp), %rcx
xorl %eax, %eax
callq 0x23a0
movb 0xc(%rsp), %al
leaq 0x4e(%r14), %rdx
movb %al, 0x4e(%r14)
movb 0x8(%rsp), %al
leaq 0x4f(%r14), %rcx
movb %al, 0x4f(%r14)
leaq 0xb66d(%rip), %rsi      # 0x12bb6
movq %r15, %rdi
xorl %eax, %eax
callq 0x23a0
leaq 0x50(%r14), %r12
leaq 0xb66b(%rip), %rsi      # 0x12bc9
movq %r15, %rdi
movq %r12, %rdx
xorl %eax, %eax
callq 0x23a0
testl %eax, %eax
jg 0x7585
leaq 0xad04(%rip), %rsi      # 0x1227a
movq %r15, %rdi
xorl %eax, %eax
callq 0x23a0
movb $-0x1, (%r12)
incl (%rbx)
leaq 0x908(%r14), %rdx
leaq 0xb63b(%rip), %rsi      # 0x12bd0
movq %r15, %rdi
xorl %eax, %eax
callq 0x23a0
incl (%rbx)
leaq 0x904(%r14), %rdx
leaq 0xb628(%rip), %rsi      # 0x12bd7
movq %r15, %rdi
xorl %eax, %eax
callq 0x23a0
incl (%rbx)
leaq 0x900(%r14), %rdx
leaq 0xb615(%rip), %rsi      # 0x12bde
movq %r15, %rdi
xorl %eax, %eax
callq 0x23a0
incl (%rbx)
leaq 0x901(%r14), %rdx
leaq 0xb604(%rip), %rsi      # 0x12be7
movq %r15, %rdi
xorl %eax, %eax
callq 0x23a0
incl (%rbx)
addq $0x910, %r14            # imm = 0x910
leaq 0xb5f3(%rip), %rsi      # 0x12bf0
movq %r15, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x23a0
incl (%rbx)
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0x7623
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x21d0
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0x764b
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x21d0
movq %rbx, %rdi
callq 0x2370
// File: /workspace/github_cpp_makefile_star2_O3/myudelson[P]hmm-scalable/utilsSt.cpp
// Function: getSkillsAtRow(task*, int, int**, signed char*)
void getSkillsAtRow(struct task *task, NDAT t, NCAT **ar, NPAR *n){
    NCAT k;
    if(task->multiskill==0) {
        k = task->dat_skill[t];
        *ar = &k;
        *n = 1;
    } else {
        k = task->dat_skill_stacked[ task->dat_skill_rix[t] ];
        *ar = &task->dat_skill_stacked[ task->dat_skill_rix[t] ];
        *n = (NPAR)task->dat_skill_rcount[t];
    }
}

// Assembly:
cmpb $0x0, 0x920(%rdi)
je 0x77c8
movq 0x8b0(%rdi), %rax
movslq %esi, %rsi
movslq (%rax,%rsi,4), %rax
shlq $0x2, %rax
addq 0x8a0(%rdi), %rax
movq %rax, (%rdx)
movq 0x8a8(%rdi), %rax
movb (%rax,%rsi,4), %al
jmp 0x77d2
leaq -0x4(%rsp), %rax
movq %rax, (%rdx)
movb $0x1, %al
movb %al, (%rcx)
retq