LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/yancanchen[P]mc-bloom-filter/mc_bloom_filter.c
// Function: save_pid
void save_pid(pid_t pid,char *pid_file) {
    FILE *fp;
    if (!pid_file)
        return;

    if (!(fp = fopen(pid_file,"w"))) {
        fprintf(stderr,"Could not open the pid file %s for writing\n",pid_file);
        return;
    }

    fprintf(fp,"%ld\n",(long) pid);
    if (fclose(fp) == -1) {
        fprintf(stderr,"Could not close the pid file %s.\n",pid_file);
        return;
    }
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
movq %rsi, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x5e57
jmp 0x5ed3
movq 0x8(%rsp), %rdi
leaq 0x1b0e(%rip), %rsi      # 0x7971
callq 0x2360
movq %rax, (%rsp)
cmpq $0x0, %rax
jne 0x5e91
movq 0x417f(%rip), %rax      # 0x9ff8
movq (%rax), %rdi
movq 0x8(%rsp), %rdx
leaq 0x1aeb(%rip), %rsi      # 0x7973
movb $0x0, %al
callq 0x2250
jmp 0x5ed3
movq (%rsp), %rdi
movslq 0x14(%rsp), %rdx
leaq 0x1afe(%rip), %rsi      # 0x799f
movb $0x0, %al
callq 0x2250
movq (%rsp), %rdi
callq 0x20f0
cmpl $-0x1, %eax
jne 0x5ed3
movq 0x413b(%rip), %rax      # 0x9ff8
movq (%rax), %rdi
movq 0x8(%rsp), %rdx
leaq 0x1ad8(%rip), %rsi      # 0x79a4
movb $0x0, %al
callq 0x2250
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/yancanchen[P]mc-bloom-filter/mc_bloom_filter.c
// Function: remove_pidfile
void remove_pidfile(char *pid_file) {
    if (!pid_file)
        return;

    if (unlink(pid_file)) {
        fprintf(stderr,"Could not remove the pid file %s.\n",pid_file);
    }

}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
jne 0x5eee
jmp 0x5f18
movq (%rsp), %rdi
callq 0x2050
cmpl $0x0, %eax
je 0x5f18
movq 0x40f5(%rip), %rax      # 0x9ff8
movq (%rax), %rdi
movq (%rsp), %rdx
leaq 0x1ab5(%rip), %rsi      # 0x79c6
movb $0x0, %al
callq 0x2250
popq %rax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/yancanchen[P]mc-bloom-filter/mc_bloom_filter.c
// Function: usage
void usage(){
    printf("PACKAGE %s VERSION %s \n",PACKAGE_NAME,PACKAGE_VERSION);
    printf("-p <num>      port number to listen on,default is 12345\n");
    printf("-l <ip_addr>  interface to listen on, default is INDRR_ANY\n");
    printf("-d            run as a daemon\n");
    //printf("-r            maximize core file limit\n");
    printf("-u <username> assume identity of <username> (only when run as root)\n");
    //printf("-m <num>      max memory to use for items in megabytes, default is 64 MB\n");
    printf("-c <num>      max simultaneous connections, default is 1024\n");
    printf("-v            verbose (print errors/warnings while in event loop)\n");
    printf("-vv           very verbose (also print client commands/reponses)\n");
    printf("-h            print this help and exit\n");
    printf("-i            print memcached and libevent license\n");
    printf("-P <file>     save PID in <file>, only used with -d option\n");
    return;
}

// Assembly:
pushq %rax
leaq 0x1ac1(%rip), %rdi      # 0x79e9
leaq 0x1ad2(%rip), %rsi      # 0x7a01
leaq 0x1adb(%rip), %rdx      # 0x7a11
movb $0x0, %al
callq 0x2170
leaq 0x1ad3(%rip), %rdi      # 0x7a17
movb $0x0, %al
callq 0x2170
leaq 0x1afe(%rip), %rdi      # 0x7a50
movb $0x0, %al
callq 0x2170
leaq 0x1b2c(%rip), %rdi      # 0x7a8c
movb $0x0, %al
callq 0x2170
leaq 0x1b3d(%rip), %rdi      # 0x7aab
movb $0x0, %al
callq 0x2170
leaq 0x1b74(%rip), %rdi      # 0x7af0
movb $0x0, %al
callq 0x2170
leaq 0x1ba3(%rip), %rdi      # 0x7b2d
movb $0x0, %al
callq 0x2170
leaq 0x1bd8(%rip), %rdi      # 0x7b70
movb $0x0, %al
callq 0x2170
leaq 0x1c0c(%rip), %rdi      # 0x7bb2
movb $0x0, %al
callq 0x2170
leaq 0x1c26(%rip), %rdi      # 0x7bda
movb $0x0, %al
callq 0x2170
leaq 0x1c4c(%rip), %rdi      # 0x7c0e
movb $0x0, %al
callq 0x2170
popq %rax
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/yancanchen[P]mc-bloom-filter/murmur.c
// Function: fmix64
FORCE_INLINE uint64_t fmix64(uint64_t k)
{
	k ^= k >> 33;
	k *= BIG_CONSTANT(0xff51afd7ed558ccd);
	k ^= k >> 33;
	k *= BIG_CONSTANT(0xc4ceb9fe1a85ec53);
	k ^= k >> 33;

	return k;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
shrq $0x21, %rax
xorq -0x8(%rsp), %rax
movq %rax, -0x8(%rsp)
movabsq $-0xae502812aa7333, %rax # imm = 0xFF51AFD7ED558CCD
imulq -0x8(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
shrq $0x21, %rax
xorq -0x8(%rsp), %rax
movq %rax, -0x8(%rsp)
movabsq $-0x3b314601e57a13ad, %rax # imm = 0xC4CEB9FE1A85EC53
imulq -0x8(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
shrq $0x21, %rax
xorq -0x8(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
// File: /workspace/github_c_makefile_star2_O0/snej[P]zdelta/zdu.c
// Function: main
int main(int argc, char *argv[]){
  int i;

  if(argc<2 || argc>(REFNUM+3))   /* check command line parameters */
  {
    fprintf(stderr,"%s",usage_single);
    if(REFNUM>1){
      fprintf(stderr," |\n%s",usage_multi);
      for(i=3;i<=REFNUM;++i) fprintf (stderr," %s%d", "[Reference",i);
      for(i=3;i<=REFNUM;++i) fprintf (stderr,"%s", "]");
      fprintf(stderr," %s\n",usage_multi_end);
    }
    else{
      fprintf(stderr,"\n");
    }
    exit(0);
  }

  if(argc <= 4){
    return main_single(argc,argv);
  }
  else{
    return MainMulti(argc, argv);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x2, -0x8(%rbp)
jl 0x1422
cmpl $0x4, -0x8(%rbp)
jle 0x1460
movq 0x12bcf(%rip), %rax     # 0x13ff8
movq (%rax), %rdi
leaq 0xebdd(%rip), %rsi      # 0x10010
leaq 0xebe6(%rip), %rdx      # 0x10020
movb $0x0, %al
callq 0x10b0
movq 0x12bb0(%rip), %rax     # 0x13ff8
movq (%rax), %rdi
leaq 0xec8b(%rip), %rsi      # 0x100dd
movb $0x0, %al
callq 0x10b0
xorl %edi, %edi
callq 0x1120
cmpl $0x4, -0x8(%rbp)
jg 0x1477
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x1240
movl %eax, -0x4(%rbp)
jmp 0x147e
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/snej[P]zdelta/zd_mem.c
// Function: zd_alloc
size_t zd_alloc(zd_mem_buffer *m, size_t n){

  if(n>0){
    if((m->buffer= (Bytef *) malloc(n * sizeof(Byte))) == NULL){
      perror("zd_alloc: could not allocate");
      return 0;
    }

    m->pos= m->buffer;
    m->size= n;
    return n;
  }

  m->size = 0;
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jbe 0x14fc
movq -0x18(%rbp), %rdi
shlq $0x0, %rdi
callq 0x10e0
movq -0x10(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0x14d7
leaq 0xeb7e(%rip), %rdi      # 0x10046
callq 0x1110
movq $0x0, -0x8(%rbp)
jmp 0x1510
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1510
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/snej[P]zdelta/zd_mem.c
// Function: zd_realloc
size_t zd_realloc(zd_mem_buffer *m, size_t n){

  Bytef *p;
  int tmp_pos= (m->pos - m->buffer);

  if(n >0){
    p= (Bytef *) realloc(m->buffer, (m->size+n));
    if(p == NULL){
      perror("zd_realloc: could not realloc");
      return 0;
    }
    /* reset newly allocated memory*/
    if (m->buffer != p)
    {
       m->pos = p + tmp_pos;
       m->buffer= p;
    }

    m->size += n;
    return n;
  }
  
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
subq %rcx, %rax
movl %eax, -0x24(%rbp)
cmpq $0x0, -0x18(%rbp)
jbe 0x15ca
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
addq -0x18(%rbp), %rsi
callq 0x10f0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x1585
leaq 0xeaed(%rip), %rdi      # 0x10063
callq 0x1110
movq $0x0, -0x8(%rbp)
jmp 0x15d2
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpq -0x20(%rbp), %rax
je 0x15b0
movq -0x20(%rbp), %rcx
movslq -0x24(%rbp), %rax
addq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
addq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x15d2
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/snej[P]zdelta/zd_mem.c
// Function: zd_free
size_t zd_free(zd_mem_buffer *m){

  int n=0;
  
  if(m->size >0){
    free(m->buffer);
    m->pos= NULL;
    n= m->size; m->size=0;
    /*m->buffer= NULL;*/
  }
  
  return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jbe 0x162d
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movslq -0xc(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/snej[P]zdelta/zd_mem.c
// Function: zd_memcpy
size_t zd_memcpy(zd_mem_buffer *m, void *data, size_t n){

  size_t avail=0;
  avail = (m->size - (m->pos - m->buffer));
  if(avail < n)
    if(zd_realloc(m, (n-avail)+1)== 0)
      return 0;
  
  memcpy(m->pos, data, n);
  m->pos += n;
  return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq -0x10(%rbp), %rdx
movq (%rdx), %rdx
subq %rdx, %rcx
subq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x16ae
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
subq -0x28(%rbp), %rsi
addq $0x1, %rsi
callq 0x1520
cmpq $0x0, %rax
jne 0x16ac
movq $0x0, -0x8(%rbp)
jmp 0x16db
jmp 0x16ae
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x10d0
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/snej[P]zdelta/zd_mem.c
// Function: dread_file
int ZEXPORT dread_file(FILE *input, zd_mem_buffer* buffer){

  int nbread;

  assert(input!=NULL);
  assert(buffer!=NULL);
  zd_alloc(buffer, ZD_BUF_SIZE);
  for(;;){

    /* read data */
    nbread = fread((void *) buffer->pos, 
		   sizeof(Byte), (size_t) ZD_BUF_SIZE, input); 
    buffer->pos=buffer->pos+nbread;

    /* check for end of file */
    if(feof(input)){
      return (buffer->pos - buffer->buffer);
    }

    /* check for io error */
    if(ferror(input)){
      zd_free(buffer);
      return ZD_ERRNO;
    }

    /* increase the buffer */
    if(!zd_realloc(buffer, ZD_BUF_SIZE)){
      zd_free(buffer);
      /* not enough memory */
      return ZD_MEM_ERROR;
    }
  }		
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1709
jmp 0x1728
leaq 0xe971(%rip), %rdi      # 0x10081
leaq 0xe976(%rip), %rsi      # 0x1008d
movl $0x53, %edx
leaq 0xe973(%rip), %rcx      # 0x10096
callq 0x1070
cmpq $0x0, -0x18(%rbp)
je 0x1731
jmp 0x1750
leaq 0xe986(%rip), %rdi      # 0x100be
leaq 0xe94e(%rip), %rsi      # 0x1008d
movl $0x54, %edx
leaq 0xe94b(%rip), %rcx      # 0x10096
callq 0x1070
movq -0x18(%rbp), %rdi
movl $0x20000, %esi          # imm = 0x20000
callq 0x1490
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rcx
movl $0x1, %esi
movl $0x20000, %edx          # imm = 0x20000
callq 0x1050
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
movslq -0x1c(%rbp), %rax
addq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rdi
callq 0x10c0
cmpl $0x0, %eax
je 0x17b8
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
subq %rcx, %rax
movl %eax, -0x4(%rbp)
jmp 0x1803
movq -0x10(%rbp), %rdi
callq 0x1040
cmpl $0x0, %eax
je 0x17d8
movq -0x18(%rbp), %rdi
callq 0x15e0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1803
movq -0x18(%rbp), %rdi
movl $0x20000, %esi          # imm = 0x20000
callq 0x1520
cmpq $0x0, %rax
jne 0x17fe
movq -0x18(%rbp), %rdi
callq 0x15e0
movl $0xfffffffc, -0x4(%rbp) # imm = 0xFFFFFFFC
jmp 0x1803
jmp 0x175e
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/snej[P]zdelta/zdelta.c
// Function: zd_compress
int ZEXPORT zd_compress(const Bytef *ref,  uLong rsize,
			const Bytef *tar,  uLong tsize,
			Bytef *delta, uLongf *dsize)
{
  int rval;
  zd_stream strm;   

  /* init io buffers */
  strm.base[0]  = (Bytef*) ref;
  strm.base_avail[0] = rsize;
  strm.base_out[0] = 0;
  strm.refnum      = 1;

  strm.next_in  = (Bytef*) tar;
  strm.total_in = 0;
  strm.avail_in = tsize;

  strm.next_out  = delta; 
  strm.total_out = 0;
  strm.avail_out = *dsize; 

  /* init the rest of the stream structure */
  strm.zalloc = (alloc_func)0;
  strm.zfree = (free_func)0;
  strm.opaque = (voidpf)0;
  rval = zd_deflateInit(&strm, ZD_DEFAULT_COMPRESSION);
  if (rval != ZD_OK)
  {
    fprintf(stderr, "%s error: %d\n", "deflateInit", rval);
    return rval;
  }

  /* compress the data */
  rval = zd_deflate(&strm,ZD_FINISH);
  if(rval != ZD_STREAM_END){
    zd_deflateEnd(&strm);
    return rval == ZD_OK ? ZD_BUF_ERROR : rval;
  }

  *dsize = strm.total_out;
  /* release memory */
  return zd_deflateEnd(&strm);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x90(%rbp)
movq $0x0, -0x98(%rbp)
movl $0x1, -0x88(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0xd0(%rbp)
movq $0x0, -0xc0(%rbp)
movq -0x28(%rbp), %rax
movl %eax, -0xc8(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq $0x0, -0xa8(%rbp)
movq -0x38(%rbp), %rax
movq (%rax), %rax
movl %eax, -0xb0(%rbp)
movq $0x0, -0x70(%rbp)
movq $0x0, -0x68(%rbp)
movq $0x0, -0x60(%rbp)
leaq -0xd0(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
leaq 0xe7ff(%rip), %rdx      # 0x100cb
movl $0x90, %ecx
callq 0x2aa0
movl %eax, -0x3c(%rbp)
cmpl $0x0, -0x3c(%rbp)
je 0x1909
movq 0x12712(%rip), %rax     # 0x13ff8
movq (%rax), %rdi
movl -0x3c(%rbp), %ecx
leaq 0xe7de(%rip), %rsi      # 0x100d1
leaq 0xe7e5(%rip), %rdx      # 0x100df
movb $0x0, %al
callq 0x10b0
movl -0x3c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1973
leaq -0xd0(%rbp), %rdi
movl $0x4, %esi
callq 0x26c0
movl %eax, -0x3c(%rbp)
cmpl $0x1, -0x3c(%rbp)
je 0x1956
leaq -0xd0(%rbp), %rdi
callq 0x3070
cmpl $0x0, -0x3c(%rbp)
jne 0x1942
movl $0xfffffffb, %eax       # imm = 0xFFFFFFFB
movl %eax, -0xd4(%rbp)
jmp 0x194b
movl -0x3c(%rbp), %eax
movl %eax, -0xd4(%rbp)
movl -0xd4(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1973
movq -0xa8(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
leaq -0xd0(%rbp), %rdi
callq 0x3070
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xe0, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/snej[P]zdelta/zdelta.c
// Function: zd_uncompress
int ZEXPORT zd_uncompress(const Bytef *ref, uLong rsize,
			  Bytef *tar, uLongf* tsize,
			  const Bytef *delta, uLong dsize)
{
  int rval;
  int f = ZD_FINISH;
  zd_stream strm;  
 
  /* init io buffers */
  strm.base[0]       = (Bytef*) ref;
  strm.base_avail[0] = rsize;
  strm.refnum        = 1;

  strm.next_out  = (Bytef*) tar;
  strm.total_out = 0;
  strm.avail_out = *tsize;

  strm.next_in  = (Bytef*) delta;
  strm.total_in = 0;
  strm.avail_in = dsize;

  strm.zalloc = (alloc_func)0;
  strm.zfree  = (free_func)0;
  strm.opaque = (voidpf)0;
  rval = zd_inflateInit(&strm);

  if (rval != ZD_OK)
  {
    fprintf(stderr, "%s error: %d\n", "zd_InflateInit", rval);
    return rval;
  }

  /* decompress the data */
  rval = zd_inflate(&strm,f);
 
  if(rval != ZD_STREAM_END){
    zd_inflateEnd(&strm);
    return rval;
  }
  *tsize = strm.total_out;
  return zd_inflateEnd(&strm);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movl $0x4, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x90(%rbp)
movl $0x1, -0x88(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq $0x0, -0xa8(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movl %eax, -0xb0(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0xd0(%rbp)
movq $0x0, -0xc0(%rbp)
movq -0x38(%rbp), %rax
movl %eax, -0xc8(%rbp)
movq $0x0, -0x70(%rbp)
movq $0x0, -0x68(%rbp)
movq $0x0, -0x60(%rbp)
leaq -0xd0(%rbp), %rdi
leaq 0xe478(%rip), %rsi      # 0x100cb
movl $0x90, %edx
callq 0x6af0
movl %eax, -0x3c(%rbp)
cmpl $0x0, -0x3c(%rbp)
je 0x1c90
movq 0x1238b(%rip), %rax     # 0x13ff8
movq (%rax), %rdi
movl -0x3c(%rbp), %ecx
leaq 0xe457(%rip), %rsi      # 0x100d1
leaq 0xe46a(%rip), %rdx      # 0x100eb
movb $0x0, %al
callq 0x10b0
movl -0x3c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1cd9
movl -0x40(%rbp), %esi
leaq -0xd0(%rbp), %rdi
callq 0x6b20
movl %eax, -0x3c(%rbp)
cmpl $0x1, -0x3c(%rbp)
je 0x1cbc
leaq -0xd0(%rbp), %rdi
callq 0x6890
movl -0x3c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1cd9
movq -0xa8(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
leaq -0xd0(%rbp), %rdi
callq 0x6890
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xd0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/snej[P]zdelta/deflate.c
// Function: init_ref_window
local void 
init_ref_window(s, rw)
    deflate_state *s;
    int rw;
{
    uInt i;
    uInt n;

    n = read_ref_buf(s->strm, s->ref_window[rw], s->ref_window_size[rw], rw);
    s->ref_window_size[rw] = n;
    /* clear memory */
    CLEAR_REF_HASH(s,rw);	
    
    s->ref_h = s->ref_window[rw][0];
    UPDATE_HASH(s, s->ref_h, s->ref_window[rw][1]);

    for(i = 0;i <= n - MIN_MATCH ;i++){
        INSERT_REF_STRING(s, i, rw);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq 0x50(%rax,%rcx,8), %rsi
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq 0x60(%rax,%rcx,8), %rax
movl %eax, %edx
movl -0xc(%rbp), %ecx
callq 0x6720
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, %edx
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq %rdx, 0x60(%rax,%rcx,8)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq 0x80(%rax,%rcx,8), %rax
movq -0x8(%rbp), %rcx
movl 0x90(%rcx), %ecx
subl $0x1, %ecx
movl %ecx, %ecx
movw $0x0, (%rax,%rcx,2)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq 0x80(%rax,%rcx,8), %rdi
movq -0x8(%rbp), %rax
movl 0x90(%rax), %eax
subl $0x1, %eax
movl %eax, %eax
movl %eax, %edx
shlq %rdx
xorl %esi, %esi
callq 0x1080
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq 0x50(%rax,%rcx,8), %rax
movzbl (%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x8c(%rax)
movq -0x8(%rbp), %rax
movl 0x8c(%rax), %eax
movq -0x8(%rbp), %rcx
movl 0x9c(%rcx), %ecx
shll %cl, %eax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rdx
movq 0x50(%rax,%rdx,8), %rax
movzbl 0x1(%rax), %eax
xorl %eax, %ecx
movq -0x8(%rbp), %rax
andl 0x98(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x8c(%rax)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl -0x14(%rbp), %ecx
subl $0x3, %ecx
cmpl %ecx, %eax
ja 0x2457
movq -0x8(%rbp), %rax
movl 0x8c(%rax), %eax
movq -0x8(%rbp), %rcx
movl 0x9c(%rcx), %ecx
shll %cl, %eax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rdx
movq 0x50(%rax,%rdx,8), %rax
movl -0x10(%rbp), %edx
addl $0x2, %edx
movl %edx, %edx
movzbl (%rax,%rdx), %eax
xorl %eax, %ecx
movq -0x8(%rbp), %rax
andl 0x98(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x8c(%rax)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq 0x80(%rax,%rcx,8), %rax
movq -0x8(%rbp), %rcx
movl 0x8c(%rcx), %ecx
movw (%rax,%rcx,2), %dx
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq 0x70(%rax,%rcx,8), %rax
movl -0x10(%rbp), %ecx
movzwl %cx, %ecx
movq -0x8(%rbp), %rsi
andl 0x44(%rsi), %ecx
movl %ecx, %ecx
movw %dx, (%rax,%rcx,2)
movl -0x10(%rbp), %eax
movw %ax, %dx
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq 0x80(%rax,%rcx,8), %rax
movq -0x8(%rbp), %rcx
movl 0x8c(%rcx), %ecx
movw %dx, (%rax,%rcx,2)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x238f
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/snej[P]zdelta/deflate.c
// Function: init_window
local void 
init_window(s)
    deflate_state *s;
{

    s->lookahead = read_buf(s->strm, s->window, (unsigned) s->window_size);

    /* zdelta: Initialize the hash value now that we have some input: */
    if (s->lookahead >= MIN_MATCH) {
        s->ins_h = s->window[s->strstart];
        UPDATE_HASH(s, s->ins_h, s->window[s->strstart+1]);
#if MIN_MATCH != 3
            Call UPDATE_HASH() MIN_MATCH-3 more times
#endif
    }

    /* If the whole input has less than MIN_MATCH bytes, ins_h is garbage,
     * but this is not important since only literal bytes will be emitted.
     */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rsi
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movl %eax, %edx
callq 0x5440
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xbc(%rax)
movq -0x8(%rbp), %rax
cmpl $0x3, 0xbc(%rax)
jb 0x250c
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x8(%rbp), %rcx
movl 0xb4(%rcx), %ecx
movzbl (%rax,%rcx), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x88(%rax)
movq -0x8(%rbp), %rax
movl 0x88(%rax), %eax
movq -0x8(%rbp), %rcx
movl 0x9c(%rcx), %ecx
shll %cl, %eax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x8(%rbp), %rdx
movl 0xb4(%rdx), %edx
addl $0x1, %edx
movl %edx, %edx
movzbl (%rax,%rdx), %eax
xorl %eax, %ecx
movq -0x8(%rbp), %rax
andl 0x98(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x88(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/snej[P]zdelta/deflate.c
// Function: zd_deflateInit_
int ZEXPORT zd_deflateInit_(strm, level, version, stream_size)
    zd_streamp strm;
    int level;
    const char *version;
    int stream_size;
{
  return zd_deflateInit2_(strm, level, ZD_DEFLATED, MAX_WBITS, 
			  DEF_MEM_LEVEL, ZD_DEFAULT_STRATEGY, version, 
			  stream_size);
    /* To do: ignore strm->next_in if we use it as window */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %r10
movl -0x1c(%rbp), %eax
movl $0x5, %edx
movl $0xf, %ecx
movl $0x8, %r8d
movl $0x7, %r9d
movq %r10, (%rsp)
movl %eax, 0x8(%rsp)
callq 0x2af0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/snej[P]zdelta/deflate.c
// Function: flush_pending
local void flush_pending(strm)
     zd_streamp strm;
{
  unsigned len = strm->state->pending;
  
  if (len > strm->avail_out) len = strm->avail_out;
  if (len == 0) return;
  
  zmemcpy(strm->next_out, strm->state->pending_out, len);
  strm->next_out  += len;
  strm->state->pending_out  += len;
  strm->total_out += len;
  strm->avail_out  -= len;
  strm->state->pending -= len;
  if (strm->state->pending == 0) {
    strm->state->pending_out = strm->state->pending_buf;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movl 0x28(%rax), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x20(%rcx), %eax
jbe 0x32b0
movq -0x8(%rbp), %rax
movl 0x20(%rax), %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x32bb
jmp 0x335e
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq 0x20(%rax), %rsi
movl -0xc(%rbp), %eax
movl %eax, %edx
callq 0x10d0
movl -0xc(%rbp), %edx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
movl %edx, %edx
addq %rdx, %rcx
movq %rcx, 0x18(%rax)
movl -0xc(%rbp), %edx
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq 0x20(%rax), %rcx
movl %edx, %edx
addq %rdx, %rcx
movq %rcx, 0x20(%rax)
movl -0xc(%rbp), %eax
movl %eax, %ecx
movq -0x8(%rbp), %rax
addq 0x28(%rax), %rcx
movq %rcx, 0x28(%rax)
movl -0xc(%rbp), %edx
movq -0x8(%rbp), %rax
movl 0x20(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x20(%rax)
movl -0xc(%rbp), %edx
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movl 0x28(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x28(%rax)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
cmpl $0x0, 0x28(%rax)
jne 0x335e
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq 0x10(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq %rcx, 0x20(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/snej[P]zdelta/deflate.c
// Function: read_buf
local int read_buf(strm, buf, size)
     zd_streamp strm;
     Bytef *buf;
     unsigned size;
{
  unsigned len = strm->avail_in;

  if (len > size) len = size;
  if (len == 0) return 0;

  strm->avail_in  -= len;

  if (!strm->state->noheader) {
    strm->adler = zd_adler32(strm->adler, strm->next_in, len);
  }

  zmemcpy(buf, strm->next_in, len);
  strm->next_in  += len;
  strm->total_in += len;
  
  return (int)len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jbe 0x546b
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jne 0x547d
movl $0x0, -0x4(%rbp)
jmp 0x5500
movl -0x20(%rbp), %edx
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
cmpl $0x0, 0x2c(%rax)
jne 0x54c2
movq -0x10(%rbp), %rax
movq 0x80(%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movl -0x20(%rbp), %edx
callq 0xade0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x80(%rax)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movl -0x20(%rbp), %eax
movl %eax, %edx
callq 0x10d0
movl -0x20(%rbp), %edx
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movl %edx, %edx
addq %rdx, %rcx
movq %rcx, (%rax)
movl -0x20(%rbp), %eax
movl %eax, %ecx
movq -0x10(%rbp), %rax
addq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/snej[P]zdelta/deflate.c
// Function: read_ref_buf
local int read_ref_buf(strm, buf, size, rw)
     zd_streamp strm;
     Bytef *buf;
     unsigned size;
     int rw;
{
  unsigned len = strm->base_avail[rw]; 

  if (len > size) len = size;
  if (len == 0) return 0;
  strm->base_avail[rw]  -= len;

  zmemcpy(buf, strm->base[rw], len);

  strm->base[rw]     += len;
  strm->base_out[rw] += len;

  return (int)len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq 0x40(%rax,%rcx,8), %rax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jbe 0x6754
movl -0x1c(%rbp), %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jne 0x6763
movl $0x0, -0x4(%rbp)
jmp 0x67cf
movl -0x24(%rbp), %eax
movl %eax, %esi
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq 0x40(%rax,%rcx,8), %rdx
subq %rsi, %rdx
movq %rdx, 0x40(%rax,%rcx,8)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq 0x30(%rax,%rcx,8), %rsi
movl -0x24(%rbp), %eax
movl %eax, %edx
callq 0x10d0
movl -0x24(%rbp), %esi
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq 0x30(%rax,%rcx,8), %rdx
movl %esi, %esi
addq %rsi, %rdx
movq %rdx, 0x30(%rax,%rcx,8)
movl -0x24(%rbp), %eax
movl %eax, %edx
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
addq 0x38(%rax,%rcx,8), %rdx
movq %rdx, 0x38(%rax,%rcx,8)
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/snej[P]zdelta/inflate.c
// Function: zd_inflateReset
int ZEXPORT zd_inflateReset(z)
     zd_streamp z;
{
  if (z == ZD_NULL || z->state == ZD_NULL ||
      z->refnum<0 || z->refnum>REFNUM)
    return ZD_STREAM_ERROR;
  z->total_in = z->total_out = 0;
  z->msg = ZD_NULL;
  z->state->mode = z->state->nowrap ? BLOCKS : METHOD;
  inflate_blocks_reset(z->state->blocks, z, ZD_NULL);
  Tracev((stderr, "inflate: reset\n"));
  return ZD_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x6812
movq -0x10(%rbp), %rax
cmpq $0x0, 0x58(%rax)
je 0x6812
movq -0x10(%rbp), %rax
cmpl $0x0, 0x48(%rax)
jl 0x6812
movq -0x10(%rbp), %rax
cmpl $0x1, 0x48(%rax)
jle 0x681b
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x6881
movq -0x10(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x50(%rax)
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movl 0x18(%rax), %edx
xorl %ecx, %ecx
movl $0x7, %eax
cmpl $0x0, %edx
cmovnel %eax, %ecx
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movq 0x20(%rax), %rdi
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0xb0c0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/snej[P]zdelta/inflate.c
// Function: zd_inflateEnd
int ZEXPORT zd_inflateEnd(z)
     zd_streamp z;
{
  if (z == ZD_NULL || z->state == ZD_NULL || z->zfree == ZD_NULL)
    return ZD_STREAM_ERROR;
  if (z->state->blocks != ZD_NULL)
    inflate_blocks_free(z->state->blocks, z);
  ZFREE(z, z->state);
  z->state = ZD_NULL;
  Tracev((stderr, "inflate: end\n"));
  return ZD_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x68b9
movq -0x10(%rbp), %rax
cmpq $0x0, 0x58(%rax)
je 0x68b9
movq -0x10(%rbp), %rax
cmpq $0x0, 0x68(%rax)
jne 0x68c2
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x6913
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
cmpq $0x0, 0x20(%rax)
je 0x68e6
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movq 0x20(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xcaf0
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x70(%rcx), %rdi
movq -0x10(%rbp), %rcx
movq 0x58(%rcx), %rsi
callq *%rax
movq -0x10(%rbp), %rax
movq $0x0, 0x58(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/snej[P]zdelta/trees.c
// Function: zd_tr_init
void zd_tr_init(s)
    deflate_state *s;
{
  tr_static_init();

  s->l_desc.dyn_tree  = s->dyn_ltree;
  s->l_desc.stat_desc = &static_l_desc;
  
  s->d_desc.dyn_tree  = s->dyn_dtree;
  s->d_desc.stat_desc = &static_d_desc;
  
  s->z_desc.dyn_tree  = s->dyn_ztree;
  s->z_desc.stat_desc = &static_z_desc;
  /* zdelta: initialize additional trees */
  
  s->bl_desc.dyn_tree  = s->bl_tree;
  s->bl_desc.stat_desc = &static_bl_desc;
  
  s->bi_buf = 0;
  s->bi_valid = 0;
  s->last_eob_len = 8; /* enough lookahead for inflate */
  
#ifdef DEBUG
  s->compressed_len = 0L;
  s->bits_sent      = 0L;
#endif

  /* Initialize the first block of the first file: */
  init_block(s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
callq 0x72e0
movq -0x8(%rbp), %rcx
addq $0x104, %rcx            # imm = 0x104
movq -0x8(%rbp), %rax
movq %rcx, 0xe30(%rax)
movq -0x8(%rbp), %rax
leaq 0xce96(%rip), %rcx      # 0x140b8
movq %rcx, 0xe40(%rax)
movq -0x8(%rbp), %rcx
addq $0x480, %rcx            # imm = 0x480
movq -0x8(%rbp), %rax
movq %rcx, 0xe58(%rax)
movq -0x8(%rbp), %rax
leaq 0xce8e(%rip), %rcx      # 0x140d8
movq %rcx, 0xe68(%rax)
movq -0x8(%rbp), %rcx
addq $0xd7c, %rcx            # imm = 0xD7C
movq -0x8(%rbp), %rax
movq %rcx, 0xe80(%rax)
movq -0x8(%rbp), %rax
leaq 0xce86(%rip), %rcx      # 0x140f8
movq %rcx, 0xe90(%rax)
movq -0x8(%rbp), %rcx
addq $0xd90, %rcx            # imm = 0xD90
movq -0x8(%rbp), %rax
movq %rcx, 0xea8(%rax)
movq -0x8(%rbp), %rax
leaq 0xce7e(%rip), %rcx      # 0x14118
movq %rcx, 0xeb8(%rax)
movq -0x8(%rbp), %rax
movw $0x0, 0x1a70(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x1a74(%rax)
movq -0x8(%rbp), %rax
movl $0x8, 0x1a6c(%rax)
movq -0x8(%rbp), %rdi
callq 0x72f0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/snej[P]zdelta/trees.c
// Function: init_block
local void init_block(s)
    deflate_state *s;
{
  int n; /* iterates over tree elements */

  /* Initialize the trees. */    
  for (n = 0; n < L_CODES;  n++)  s->dyn_ltree[n].Freq  = 0;
  for (n = 0; n < D_CODES;  n++)  s->dyn_dtree[n].Freq  = 0;
  for (n = 0; n < Z_CODES; n++)  s->dyn_ztree[n].Freq  = 0; /* zdelta */
  for (n = 0; n < BL_CODES; n++)  s->bl_tree[n].Freq    = 0;
    
  s->dyn_dtree[END_BLOCK].Freq = 1;
  s->opt_len = s->static_len = 0L;
  s->last_lit = s->matches = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x6f, -0xc(%rbp)
jge 0x7322
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movw $0x0, 0x104(%rax,%rcx,4)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x72ff
movl $0x0, -0xc(%rbp)
cmpl $0x11f, -0xc(%rbp)      # imm = 0x11F
jge 0x734f
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movw $0x0, 0x480(%rax,%rcx,4)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x7329
movl $0x0, -0xc(%rbp)
cmpl $0x2, -0xc(%rbp)
jge 0x7379
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movw $0x0, 0xd7c(%rax,%rcx,4)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x7356
movl $0x0, -0xc(%rbp)
cmpl $0x13, -0xc(%rbp)
jge 0x73a3
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movw $0x0, 0xd90(%rax,%rcx,4)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x7380
movq -0x8(%rbp), %rax
movw $0x1, 0x880(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x1a60(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x1a58(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x1a68(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x1a44(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/snej[P]zdelta/trees.c
// Function: copy_block
local void copy_block(s, buf, len, header)
    deflate_state *s;
    charf    *buf;    /* the input data */
    unsigned len;     /* its length */
    int      header;  /* true if block header must be written */
{
  bi_windup(s);        /* align on byte boundary */
  s->last_eob_len = 8; /* enough lookahead for inflate */
  
  if (header) {
      put_short(s, (ush)len);   
      put_short(s, (ush)~len);
#ifdef DEBUG
      s->bits_sent += 2*16;
#endif
  }
#ifdef DEBUG
  s->bits_sent += (ulg)len<<3;
#endif
  while (len--) {
    put_byte(s, *buf++);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x9950
movq -0x8(%rbp), %rax
movl $0x8, 0x1a6c(%rax)
cmpl $0x0, -0x18(%rbp)
je 0x7691
movl -0x14(%rbp), %eax
movzwl %ax, %eax
andl $0xff, %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rsi
movl 0x28(%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, 0x28(%rsi)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0x14(%rbp), %eax
movzwl %ax, %eax
sarl $0x8, %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rsi
movl 0x28(%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, 0x28(%rsi)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0x14(%rbp), %eax
xorl $-0x1, %eax
movzwl %ax, %eax
andl $0xff, %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rsi
movl 0x28(%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, 0x28(%rsi)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0x14(%rbp), %eax
xorl $-0x1, %eax
movzwl %ax, %eax
sarl $0x8, %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rsi
movl 0x28(%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, 0x28(%rsi)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
jmp 0x7693
movl -0x14(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x14(%rbp)
cmpl $0x0, %eax
je 0x76d3
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb (%rax), %dl
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rsi
movl 0x28(%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, 0x28(%rsi)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
jmp 0x7693
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/snej[P]zdelta/trees.c
// Function: bi_flush
local void bi_flush(s)
     deflate_state *s;
{
  if (s->bi_valid == 16) {
    put_short(s, s->bi_buf);
    s->bi_buf = 0;
    s->bi_valid = 0;
  } else if (s->bi_valid >= 8) {
    put_byte(s, (Byte)s->bi_buf);
    s->bi_buf >>= 8;
    s->bi_valid -= 8;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x10, 0x1a74(%rax)
jne 0x7c6e
movq -0x8(%rbp), %rax
movzwl 0x1a70(%rax), %eax
andl $0xff, %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rsi
movl 0x28(%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, 0x28(%rsi)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movq -0x8(%rbp), %rax
movzwl 0x1a70(%rax), %eax
sarl $0x8, %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rsi
movl 0x28(%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, 0x28(%rsi)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movq -0x8(%rbp), %rax
movw $0x0, 0x1a70(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x1a74(%rax)
jmp 0x7ccf
movq -0x8(%rbp), %rax
cmpl $0x8, 0x1a74(%rax)
jl 0x7ccd
movq -0x8(%rbp), %rax
movw 0x1a70(%rax), %ax
movb %al, %dl
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rsi
movl 0x28(%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, 0x28(%rsi)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movq -0x8(%rbp), %rax
movzwl 0x1a70(%rax), %ecx
sarl $0x8, %ecx
movw %cx, 0x1a70(%rax)
movq -0x8(%rbp), %rax
movl 0x1a74(%rax), %ecx
subl $0x8, %ecx
movl %ecx, 0x1a74(%rax)
jmp 0x7ccf
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/snej[P]zdelta/trees.c
// Function: build_bl_tree
local int build_bl_tree(s)
    deflate_state *s;
{
  int max_blindex;  /* index of last bit length code of non zero freq */
  
  /* Determine the bit length frequencies for literal and distance trees */
  scan_tree(s, (ct_data *)s->dyn_ltree,  s->l_desc.max_code);
  scan_tree(s, (ct_data *)s->dyn_dtree,  s->d_desc.max_code);
#if REFNUM>1
  scan_tree(s, (ct_data *)s->dyn_ztree,  s->z_desc.max_code); /* zdelta */
#endif
  /* opt_len now includes the length of the tree representations, except
   * the lengths of the bit lengths codes and the 5+5+4 bits for the counts.
   */

  /* Build the bit length tree: */
  build_tree(s, (tree_desc *)(&(s->bl_desc)));

  /* Determine the number of bit length codes to send. The pkzip format
   * requires that at least 4 bit length codes be sent. (appnote.txt says
   * 3 but the actual value used is 4.)
   */
  for (max_blindex = BL_CODES-1; max_blindex >= 3; max_blindex--) {
    if (s->bl_tree[bl_order[max_blindex]].Len != 0) break;
  }
  /* Update opt_len to include the bit length tree and counts */
#if REFNUM>1
  s->opt_len += 3*(max_blindex+1) +7+5+3+4; /* zdelta */
#else
  s->opt_len += 3*(max_blindex+1) +7+5+4; /* zdelta */
#endif

  Tracev((stderr, "\ndyn trees: dyn %ld, stat %ld",
	  s->opt_len, s->static_len));
  
  return max_blindex;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x104, %rsi            # imm = 0x104
movq -0x8(%rbp), %rax
movl 0xe38(%rax), %edx
callq 0xa080
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x480, %rsi            # imm = 0x480
movq -0x8(%rbp), %rax
movl 0xe60(%rax), %edx
callq 0xa080
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0xea8, %rsi            # imm = 0xEA8
callq 0x8220
movl $0x12, -0xc(%rbp)
cmpl $0x3, -0xc(%rbp)
jl 0x8668
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rdx
leaq 0x87b8(%rip), %rcx      # 0x10e00
movzbl (%rcx,%rdx), %ecx
movzwl 0xd92(%rax,%rcx,4), %eax
cmpl $0x0, %eax
je 0x865b
jmp 0x8668
jmp 0x865d
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x8633
movl -0xc(%rbp), %eax
addl $0x1, %eax
imull $0x3, %eax, %eax
addl $0x7, %eax
addl $0x5, %eax
addl $0x4, %eax
movslq %eax, %rcx
movq -0x8(%rbp), %rax
addq 0x1a58(%rax), %rcx
movq %rcx, 0x1a58(%rax)
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/snej[P]zdelta/trees.c
// Function: bi_windup
local void bi_windup(s)
     deflate_state *s;
{
  if (s->bi_valid > 8) {
    put_short(s, s->bi_buf);
  } else if (s->bi_valid > 0) {
    put_byte(s, (Byte)s->bi_buf);
  }
  s->bi_buf = 0;
  s->bi_valid = 0;
#ifdef DEBUG
  s->bits_sent = (s->bits_sent+7) & ~7;
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x8, 0x1a74(%rax)
jle 0x99c3
movq -0x8(%rbp), %rax
movzwl 0x1a70(%rax), %eax
andl $0xff, %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rsi
movl 0x28(%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, 0x28(%rsi)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movq -0x8(%rbp), %rax
movzwl 0x1a70(%rax), %eax
sarl $0x8, %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rsi
movl 0x28(%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, 0x28(%rsi)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
jmp 0x99fc
movq -0x8(%rbp), %rax
cmpl $0x0, 0x1a74(%rax)
jle 0x99fa
movq -0x8(%rbp), %rax
movw 0x1a70(%rax), %ax
movb %al, %dl
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rsi
movl 0x28(%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, 0x28(%rsi)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
jmp 0x99fc
movq -0x8(%rbp), %rax
movw $0x0, 0x1a70(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x1a74(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/snej[P]zdelta/trees.c
// Function: gen_codes
local void gen_codes (tree, max_code, bl_count)
     ct_data *tree;             /* the tree to decorate */
     int max_code;              /* largest code with non zero frequency */
     ushf *bl_count;            /* number of codes at each bit length */
{
  ush next_code[MAX_BITS+1]; /* next code value for each bit length */
  ush code = 0;              /* running code value */
  int bits;                  /* bit index */
  int n;                     /* code index */
  
  /* The distribution counts are first used to generate the code values
   * without bit reversal.
   */
  for (bits = 1; bits <= MAX_BITS; bits++) {
    next_code[bits] = code = (code + bl_count[bits-1]) << 1;
  }
  /* Check that the bit counts in bl_count are consistent. The last code
   * must be all ones.
   */
  Assert (code + bl_count[MAX_BITS]-1 == (1<<MAX_BITS)-1,
	  "inconsistent bit counts");
  Tracev((stderr,"\ngen_codes: max_code %d ", max_code));

  for (n = 0;  n <= max_code; n++) {
    int len = tree[n].Len;
    if (len == 0) continue;
    /* Now reverse the bits */
    tree[n].Code = bi_reverse(next_code[len]++, len);
    
    Tracecv(tree != static_ltree, (stderr,"\nn %3d %c l %2d c %4x (%x) ",\
				   n, (isgraph(n) ? n : ' '), len, \
				   tree[n].Code, next_code[len]-1));
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movw $0x0, -0x42(%rbp)
movl $0x1, -0x48(%rbp)
cmpl $0xf, -0x48(%rbp)
jg 0x9fba
movzwl -0x42(%rbp), %eax
movq -0x18(%rbp), %rcx
movl -0x48(%rbp), %edx
subl $0x1, %edx
movslq %edx, %rdx
movzwl (%rcx,%rdx,2), %ecx
addl %ecx, %eax
shll %eax
movw %ax, %cx
movw %cx, -0x42(%rbp)
movslq -0x48(%rbp), %rax
movw %cx, -0x40(%rbp,%rax,2)
movl -0x48(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
jmp 0x9f80
movl $0x0, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jg 0xa01b
movq -0x8(%rbp), %rax
movslq -0x4c(%rbp), %rcx
movzwl 0x2(%rax,%rcx,4), %eax
movl %eax, -0x50(%rbp)
cmpl $0x0, -0x50(%rbp)
jne 0x9fe1
jmp 0xa010
movslq -0x50(%rbp), %rcx
movw -0x40(%rbp,%rcx,2), %ax
movw %ax, %dx
addw $0x1, %dx
movw %dx, -0x40(%rbp,%rcx,2)
movzwl %ax, %edi
movl -0x50(%rbp), %esi
callq 0xa030
movw %ax, %dx
movq -0x8(%rbp), %rax
movslq -0x4c(%rbp), %rcx
movw %dx, (%rax,%rcx,4)
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0x9fc1
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/snej[P]zdelta/trees.c
// Function: bi_reverse
local unsigned bi_reverse(code, len)
     unsigned code; /* the value to invert */
     int len;       /* its bit length */
{
  register unsigned res = 0;
  do {
    res |= code & 1;
    code >>= 1, res <<= 1;
  } while (--len > 0);
  return res >> 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0x4(%rbp), %eax
andl $0x1, %eax
orl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x4(%rbp), %eax
shrl %eax
movl %eax, -0x4(%rbp)
movl -0xc(%rbp), %eax
shll %eax
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x8(%rbp)
cmpl $0x0, %eax
jg 0xa041
movl -0xc(%rbp), %eax
shrl %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/snej[P]zdelta/infblock.c
// Function: inflate_blocks_reset
void inflate_blocks_reset(s, z, c)
inflate_blocks_statef *s;
zd_streamp z;
uLongf *c;
{
  int i;
  if (c != ZD_NULL)
    *c = s->check;
  if (s->mode == BTREE || s->mode == DTREE)
    ZFREE(z, s->sub.trees.blens);
  if (s->mode == CODES)
    inflate_codes_free(s->sub.decode.codes, z);
  s->mode = TYPE;
  s->bitk = 0;
  s->bitb = 0;
  s->read = s->write = s->window;
  if (s->checkfn != ZD_NULL)
    z->adler = s->check = (*s->checkfn)(0L, (const Bytef *)ZD_NULL, 0);
  Tracev((stderr, "inflate:   blocks reset\n"));

  /* zdelta: initialize reference window pointers 
   * this should be called only ONCE during the inflation process
   */
  for(i=0; i< 2*z->refnum; ++i){
    s->rwptr[i]  = 0;
    s->stable[i] = 0;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xb0ea
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
cmpl $0x4, (%rax)
je 0xb0fc
movq -0x8(%rbp), %rax
cmpl $0x5, (%rax)
jne 0xb116
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x70(%rcx), %rdi
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rsi
callq *%rax
movq -0x8(%rbp), %rax
cmpl $0x6, (%rax)
jne 0xb130
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xe250
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x2c(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x58(%rax)
movq -0x8(%rbp), %rax
movq %rcx, 0x50(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x60(%rax)
je 0xb19a
movq -0x8(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %esi
xorl %edx, %edx
movq %rsi, %rdi
callq *0x60(%rax)
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x68(%rax)
movq -0x10(%rbp), %rax
movq %rcx, 0x80(%rax)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
movl 0x48(%rcx), %ecx
shll %ecx
cmpl %ecx, %eax
jge 0xb1e1
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq $0x0, 0x70(%rax,%rcx,8)
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq $0x0, 0x80(%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xb1a1
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)