LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/DrYerzinia[P]C_DigiMode/src/util/Util.cpp
// Function: util::writeUInt16(std::ostream&, unsigned short)
void util::writeUInt16(std::ostream &out, uint16_t wri){
	char *tmp = (char*) &wri;
	for(int i = 0; i < 2; i++){
		out.write((char*) tmp, 1);
		tmp++;
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0xe(%rsp), %r14
movw %si, (%r14)
movb $0x1, %bpl
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2240
incq %r14
testb $0x1, %bpl
movl $0x0, %ebp
jne 0x56ff
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/DrYerzinia[P]C_DigiMode/src/util/Util.cpp
// Function: util::writeUInt32(std::ostream&, unsigned int)
void util::writeUInt32(std::ostream &out, uint32_t wri){
	char *tmp = (char*) &wri;
	for(int i = 0; i < 4; i++){
		out.write(tmp, 1);
		tmp++;
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %esi, 0x4(%rsp)
xorl %r14d, %r14d
leaq (%rsp,%r14), %rsi
addq $0x4, %rsi
movl $0x1, %edx
movq %rbx, %rdi
callq 0x2240
incq %r14
cmpq $0x4, %r14
jne 0x5734
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/DrYerzinia[P]C_DigiMode/src/util/Util.cpp
// Function: util::readInArguments(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void util::readInArguments(std::string args){
	std::stringstream ss(args);

	char buffer[100];
	while(!ss.eof()){
		ss.getline(buffer, 100, ' ');
		if(buffer[0] == '-'){
			std::string key(buffer);
			ss.getline(buffer, 100, ' ');
			std::string arg(buffer);
			commandlineargs.insert(std::make_pair(key, arg));
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x278, %rsp            # imm = 0x278
movq %rdi, %rsi
leaq 0xf0(%rsp), %rbx
movq %rbx, %rdi
movl $0x18, %edx
callq 0x22c0
movq (%rbx), %rax
movq -0x18(%rax), %rax
testb $0x2, 0x110(%rsp,%rax)
jne 0x5a21
leaq 0x30(%rsp), %rbp
leaq 0xf0(%rsp), %rbx
leaq 0x80(%rsp), %r14
movq %rsp, %r15
leaq 0x20(%rsp), %r12
leaq 0x40(%rsp), %r13
movl $0x64, %edx
movq %rbx, %rdi
movq %r14, %rsi
movl $0x20, %ecx
callq 0x2340
cmpb $0x2d, 0x80(%rsp)
jne 0x5a07
leaq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq %r14, %rdi
callq 0x2100
leaq (%rsp,%rax), %rdx
addq $0x80, %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x33f0
movl $0x64, %edx
movq %rbx, %rdi
movq %r14, %rsi
movl $0x20, %ecx
callq 0x2340
movq %rbp, 0x20(%rsp)
movq %r14, %rdi
callq 0x2100
leaq (%rsp,%rax), %rdx
addq $0x80, %rdx
movq %r12, %rdi
movq %r14, %rsi
callq 0x33f0
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x5bec
leaq 0x383b(%rip), %rdi      # 0x91d0
movq %r13, %rsi
callq 0x5d76
movq 0x60(%rsp), %rdi
leaq 0x70(%rsp), %rax
cmpq %rax, %rdi
je 0x59b9
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x21d0
movq 0x40(%rsp), %rdi
leaq 0x50(%rsp), %rax
cmpq %rax, %rdi
je 0x59d5
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x21d0
movq 0x20(%rsp), %rdi
cmpq %rbp, %rdi
je 0x59ec
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x21d0
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x5a07
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21d0
movq 0xf0(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x2, 0x110(%rsp,%rax)
je 0x58fe
movq 0x3588(%rip), %rsi      # 0x8fb0
leaq 0xf0(%rsp), %rdi
callq 0x2170
leaq 0x170(%rsp), %rdi
callq 0x20d0
addq $0x278, %rsp            # imm = 0x278
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5a5d
movq %rax, %rbx
jmp 0x5a6f
jmp 0x5aa3
movq %rax, %rbx
jmp 0x5a86
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x5bb0
movq 0x20(%rsp), %rdi
cmpq %rbp, %rdi
je 0x5a86
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x21d0
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x5aa6
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21d0
jmp 0x5aa6
movq %rax, %rbx
movq 0x3503(%rip), %rsi      # 0x8fb0
leaq 0xf0(%rsp), %rdi
callq 0x2170
leaq 0x170(%rsp), %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0x2320
nop
// File: /workspace/github_c_makefile_star2_O3/DrYerzinia[P]C_DigiMode/src/util/Util.cpp
// Function: util::writeDebugStream(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void util::writeDebugStream(std::string msg){
	if(debugfstream.is_open()){
		debugfstream << msg;
		debugfstream.flush();
	} else {
		debugfstream.open("debug");
		writeDebugStream(msg);
	}
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x378f(%rip), %rdi      # 0x9270
callq 0x2090
testb %al, %al
je 0x5b0f
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
leaq 0x3708(%rip), %rbx      # 0x9200
movq %rbx, %rdi
callq 0x2200
movq %rbx, %rdi
addq $0x28, %rsp
popq %rbx
popq %r14
jmp 0x2140
leaq 0x36ea(%rip), %rdi      # 0x9200
leaq 0x64b(%rip), %rsi       # 0x6168
movl $0x10, %edx
callq 0x2040
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x335a
movq %rbx, %rdi
callq 0x5ad0
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x5b66
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21d0
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x5b88
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21d0
movq %rbx, %rdi
callq 0x2320
// File: /workspace/github_c_makefile_star2_O3/darkautism[P]lfqueue/lfq.c
// Function: safe_free
static
void safe_free(struct lfq_ctx *ctx, struct lfq_node * lfn) {
	if (lfn->can_free && !inHP(ctx,lfn)) {
		// free is not thread-safe
		if (CAS(&ctx->is_freeing, 0, 1)) {
			lfn->next = (void*)-1;    // poison the pointer to detect use-after-free
			free(lfn);    // we got the lock; actually free
			ctx->is_freeing = false;
			smb();
		} else               // we didn't get the lock; only add to a freelist
			enpool(ctx, lfn);
	} else
		enpool(ctx, lfn);
	free_pool(ctx, false);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0x10(%rsi)
je 0x1335
movslq 0x38(%rbx), %rax
testq %rax, %rax
jle 0x130e
movq 0x10(%rbx), %rcx
cmpq %rsi, (%rcx)
je 0x1335
movl $0x1, %edi
movq %rdi, %rdx
cmpq %rdi, %rax
je 0x1309
leaq 0x1(%rdx), %rdi
cmpq %rsi, (%rcx,%rdx,8)
jne 0x12f7
cmpq %rax, %rdx
jb 0x1335
movl $0x1, %ecx
xorl %eax, %eax
lock
cmpxchgl %ecx, 0x20(%rbx)
jne 0x1335
movq $-0x1, 0x8(%rsi)
movq %rsi, %rdi
callq 0x1040
movl $0x0, 0x20(%rbx)
jmp 0x1348
movq $0x0, 0x8(%rsi)
movq %rsi, %rax
xchgq %rax, 0x30(%rbx)
movq %rsi, 0x8(%rax)
movq %rbx, %rdi
xorl %esi, %esi
popq %rbx
jmp 0x1350
// File: /workspace/github_c_makefile_star2_O3/darkautism[P]lfqueue/lfq.c
// Function: free_pool
static
void free_pool(struct lfq_ctx *ctx, bool freeall ) {
	if (!CAS(&ctx->is_freeing, 0, 1))
		return; // this pool free is not support multithreading.
	volatile struct lfq_node * p;

	for ( int i = 0 ; i < MAXFREE || freeall ; i++ ) {
		p = ctx->fph;
		if ( (!p->can_free) || (!p->free_next) || inHP(ctx, (struct lfq_node *)p) )
			goto exit;
		ctx->fph = p->free_next;
		free((void *)p);
	}
exit:
	ctx->is_freeing = false;
	smb();
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
xorl %r14d, %r14d
movl $0x1, %ecx
xorl %eax, %eax
lock
cmpxchgl %ecx, 0x20(%rdi)
jne 0x13d3
movl %esi, %ebp
movq %rdi, %rbx
movq 0x28(%rbx), %rdi
cmpl $0x0, 0x10(%rdi)
je 0x13cc
cmpq $0x0, 0x8(%rdi)
je 0x13cc
movslq 0x38(%rbx), %rax
testq %rax, %rax
jle 0x13a9
movq 0x10(%rbx), %rcx
cmpq %rdi, (%rcx)
je 0x13cc
movl $0x1, %esi
movq %rsi, %rdx
cmpq %rsi, %rax
je 0x13a4
leaq 0x1(%rdx), %rsi
cmpq %rdi, (%rcx,%rdx,8)
jne 0x1392
cmpq %rax, %rdx
jb 0x13cc
movq 0x8(%rdi), %rax
movq %rax, 0x28(%rbx)
callq 0x1040
cmpl $0x95, %r14d
leal 0x1(%r14), %eax
setb %cl
orb %bpl, %cl
movl %eax, %r14d
jne 0x136a
movl $0x0, 0x20(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/darkautism[P]lfqueue/lfq.c
// Function: lfq_dequeue
static
int alloc_tid(struct lfq_ctx *ctx) {
	for (int i = 0; i < ctx->MAXHPSIZE; i++) 
		if (ctx->tid_map[i] == 0) 
			if (CAS(&ctx->tid_map[i], 0, 1))
				return i;

	return -1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl 0x38(%rdi), %eax
testl %eax, %eax
jle 0x14af
movq %rdi, %rbx
xorl %r14d, %r14d
movl $0x1, %ecx
movq 0x18(%rbx), %rdx
cmpl $0x0, (%rdx,%r14,4)
jne 0x14a4
xorl %eax, %eax
lock
cmpxchgl %ecx, (%rdx,%r14,4)
je 0x14be
movl 0x38(%rbx), %eax
incq %r14
movslq %eax, %rdx
cmpq %rdx, %r14
jl 0x148c
movq $-0x1, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
movl %r14d, %esi
callq 0x1030
movq 0x18(%rbx), %rcx
movl $0x0, (%rcx,%r14,4)
jmp 0x14b6
// File: /workspace/github_c_makefile_star2_O3/ddrown[P]pretend-ntp/pretend-ntp.c
// Function: main
int main(int argc, char *argv[]) {
  struct sockaddr_in addr;
  struct thread_info tinfo[THREADS];
  int status;

  if(argc < 3) {
    printf("%s [ip] [port]\n", argv[0]);
    exit(EXIT_FAILURE);
  }
  if(inet_aton(argv[1], &addr.sin_addr) == INADDR_NONE) {
    printf("invalid ip %s\n", argv[1]);
    exit(EXIT_FAILURE);
  }
  addr.sin_port = htons(strtoul(argv[2], NULL, 10));
  addr.sin_family = AF_INET;

  memset(&tinfo, 0, sizeof(tinfo));

  for (uint32_t i = 0; i < THREADS; i++) {
    tinfo[i].thread_num = i;
    tinfo[i].addr = &addr;
    status = pthread_create(&tinfo[i].thread_id, NULL, &ntp_server, &tinfo[i]);
    if (status != 0) {
      errno = status;
      perror("pthread_create(ntp_server) failed");
      exit(EXIT_FAILURE);
    }
  }

  printf("threads created\n");

  for(uint32_t i = 0; i < THREADS; i++) {
    void *res;
    status = pthread_join(tinfo[i].thread_id, &res);
    if (status != 0) {
      errno = status;
      perror("pthread_join(ntp_server) failed");
      exit(EXIT_FAILURE);
    }

    printf("reader thread %d done q=%" UINT64_FMT " !v=%" UINT64_FMT " !m=%" UINT64_FMT " ~s=%" UINT64_FMT "\n", tinfo[i].thread_num, tinfo[i].thread_queries,
        tinfo[i].unknown_version, tinfo[i].unknown_mode, tinfo[i].failed_send);
  }

  exit(EXIT_SUCCESS);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x100, %rsp            # imm = 0x100
movq %rsi, %rbx
cmpl $0x2, %edi
jg 0x15b9
movq (%rbx), %rsi
leaq 0xb00(%rip), %rdi       # 0x20b7
jmp 0x15d7
movq 0x8(%rbx), %rdi
leaq 0x14(%rsp), %rsi
callq 0x10d0
cmpl $-0x1, %eax
jne 0x15e3
movq 0x8(%rbx), %rsi
leaq 0xaf0(%rip), %rdi       # 0x20c7
xorl %eax, %eax
callq 0x1080
jmp 0x16da
movq 0x10(%rbx), %rdi
xorl %r15d, %r15d
xorl %esi, %esi
movl $0xa, %edx
callq 0x1140
rolw $0x8, %ax
leaq 0x10(%rsp), %r12
movw %ax, 0x2(%r12)
movw $0x2, (%r12)
leaq 0x20(%rsp), %rbx
movl $0xe0, %edx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1090
leaq -0x3ab(%rip), %r14      # 0x127c
movl %r15d, 0x8(%rbx)
movq %r12, 0x30(%rbx)
movq %rbx, %rdi
xorl %esi, %esi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x1120
testl %eax, %eax
jne 0x16b3
incq %r15
addq $0x38, %rbx
cmpq $0x4, %r15
jne 0x1627
leaq 0xaf3(%rip), %rdi       # 0x214a
callq 0x1050
leaq 0x8(%rsp), %rbx
leaq 0xab0(%rip), %r14       # 0x2118
xorl %r15d, %r15d
movq 0x20(%rsp,%r15), %rdi
movq %rbx, %rsi
callq 0x1160
testl %eax, %eax
jne 0x16c5
movl 0x28(%rsp,%r15), %esi
movq 0x30(%rsp,%r15), %rdx
movq 0x38(%rsp,%r15), %rcx
movq 0x40(%rsp,%r15), %r8
movq 0x48(%rsp,%r15), %r9
movq %r14, %rdi
xorl %eax, %eax
callq 0x1080
addq $0x38, %r15
cmpq $0xe0, %r15
jne 0x166b
xorl %edi, %edi
callq 0x1150
movl %eax, %ebp
callq 0x1040
movl %ebp, (%rax)
leaq 0xa13(%rip), %rdi       # 0x20d6
jmp 0x16d5
movl %eax, %ebp
callq 0x1040
movl %ebp, (%rax)
leaq 0xa23(%rip), %rdi       # 0x20f8
callq 0x1130
movl $0x1, %edi
callq 0x1150
// File: /workspace/github_c_makefile_star2_O3/ddrown[P]pretend-ntp/ntp_msg.c
// Function: print_short_ntp
void print_short_ntp(const struct ntp_msg *m, const struct ntptimes *t) {
  struct timespec recv_time, trans_time;

  printf(" %u.%06u", ntohs(m->delay), ntp_frac_to_us(m->delay_fb));
  printf(" %u.%06u", ntohs(m->dispersion), ntp_frac_to_us(m->dispersion_fb));

  recv_time.tv_sec = ntp_s_to_unixtime(m->recv_time);
  recv_time.tv_nsec = ntp_frac_to_ns(m->recv_time_fb);
  if(t != NULL) {
    printf(" ");
    print_diff_ts(&t->before_sendto, &recv_time);
  }

  trans_time.tv_sec = ntp_s_to_unixtime(m->trans_time);
  trans_time.tv_nsec = ntp_frac_to_ns(m->trans_time_fb);
  if(t != NULL) {
    printf(" ");
    print_diff_ts(&trans_time, &t->after_recvmsg);
  }

  printf(" ");
  print_diff_ts(&trans_time, &recv_time);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movzwl 0x4(%rdi), %eax
movzwl 0x6(%rdi), %ecx
rolw $0x8, %ax
rolw $0x8, %cx
movzwl %ax, %esi
movzwl %cx, %eax
imull $0xf4240, %eax, %edx    # imm = 0xF4240
shrl $0x10, %edx
leaq 0x8a4(%rip), %r15       # 0x228c
movq %r15, %rdi
xorl %eax, %eax
callq 0x1080
movzwl 0x8(%r14), %eax
movzwl 0xa(%r14), %ecx
rolw $0x8, %ax
rolw $0x8, %cx
movzwl %ax, %esi
movzwl %cx, %eax
imull $0xf4240, %eax, %edx    # imm = 0xF4240
shrl $0x10, %edx
movq %r15, %rdi
xorl %eax, %eax
callq 0x1080
movl 0x20(%r14), %eax
movl %eax, %ecx
bswapl %ecx
addl $0x7c558180, %ecx       # imm = 0x7C558180
testl %eax, %eax
cmovel %eax, %ecx
movq %rcx, 0x10(%rsp)
movl 0x24(%r14), %eax
bswapl %eax
imulq $0x3b9aca00, %rax, %rax # imm = 0x3B9ACA00
shrq $0x20, %rax
movq %rax, 0x18(%rsp)
testq %rbx, %rbx
je 0x1a67
movl $0x20, %edi
callq 0x1030
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x1d03
movl 0x28(%r14), %eax
movl %eax, %ecx
bswapl %ecx
addl $0x7c558180, %ecx       # imm = 0x7C558180
testl %eax, %eax
cmovel %eax, %ecx
movq %rcx, (%rsp)
movl 0x2c(%r14), %eax
bswapl %eax
imulq $0x3b9aca00, %rax, %rax # imm = 0x3B9ACA00
shrq $0x20, %rax
movq %rax, 0x8(%rsp)
testq %rbx, %rbx
je 0x1ab2
movl $0x20, %edi
callq 0x1030
addq $0x20, %rbx
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x1d03
movl $0x20, %edi
callq 0x1030
movq %rsp, %rdi
leaq 0x10(%rsp), %rsi
callq 0x1d03
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/ddrown[P]pretend-ntp/ntp_msg.c
// Function: ntp_xchange
int ntp_xchange(int sock, struct ntp_msg *bufs, const struct sockaddr *addr, struct ntptimes *t, struct msghdr *msgs, int timeout_ms) {
  int status[6];
  struct iovec iovecs;
  struct pollfd readfd;

  iovecs.iov_base     = bufs;
  iovecs.iov_len      = sizeof(*bufs);
  msgs->msg_iov        = &iovecs;
  msgs->msg_iovlen     = 1;

  readfd.fd = sock;
  readfd.events = POLLIN;

  status[0] = clock_gettime(CLOCK_REALTIME, &t->before_sendto);
  status[1] = sendto(sock, bufs, sizeof(*bufs), 0, addr, sizeof(*addr));
  status[2] = clock_gettime(CLOCK_REALTIME, &t->after_sendto);
  status[3] = poll(&readfd, 1, timeout_ms);
  status[4] = clock_gettime(CLOCK_REALTIME, &t->after_recvmsg);
  status[5] = recvmsg(sock, msgs, MSG_DONTWAIT);
  if(status[5] < 0) {
    if(errno == EAGAIN) {
      return 0;
    }
    perror_exit("recvmsg");
  }
  if(status[4] != 0) {
    perror_exit("clock_gettime #3");
  }
  if(status[3] < 0) {
    perror_exit("poll");
  }
  if(status[2] != 0) {
    perror_exit("clock_gettime #2");
  }
  if(status[1] < 0) {
    perror_exit("sendto");
  }
  if(status[0] != 0) {
    perror_exit("clock_gettime #1");
  }

  return status[5];
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r9d, 0xc(%rsp)
movq %r8, %r15
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %rbp
movl %edi, %r13d
leaq 0x18(%rsp), %rax
movq %rsi, (%rax)
movq $0x30, 0x8(%rax)
movq %rax, 0x10(%r8)
movq $0x1, 0x18(%r8)
leaq 0x10(%rsp), %r12
movl %edi, (%r12)
movw $0x1, 0x4(%r12)
xorl %edi, %edi
movq %rcx, %rsi
callq 0x1070
movl %eax, 0x8(%rsp)
movl $0x30, %edx
movl %r13d, %edi
movq %rbp, %rsi
xorl %ecx, %ecx
movq %r14, %r8
movl $0x10, %r9d
callq 0x10a0
movq %rax, %rbp
leaq 0x10(%rbx), %rsi
xorl %edi, %edi
callq 0x1070
movl %eax, 0x4(%rsp)
movl $0x1, %esi
movq %r12, %rdi
movl 0xc(%rsp), %edx
callq 0x1100
movl %eax, %r14d
addq $0x20, %rbx
xorl %edi, %edi
movq %rbx, %rsi
callq 0x1070
movl %eax, %ebx
movl %r13d, %edi
movq %r15, %rsi
movl $0x40, %edx
callq 0x10f0
movq %rax, %r15
testl %r15d, %r15d
jns 0x1c13
callq 0x1040
cmpl $0xb, (%rax)
movl $0x0, %eax
je 0x1c6d
leaq 0x687(%rip), %rdi       # 0x2295
callq 0x1d64
testl %ebx, %ebx
je 0x1c23
leaq 0x67f(%rip), %rdi       # 0x229d
callq 0x1d64
testl %r14d, %r14d
jns 0x1c34
leaq 0x67f(%rip), %rdi       # 0x22ae
callq 0x1d64
cmpl $0x0, 0x4(%rsp)
je 0x1c47
leaq 0x671(%rip), %rdi       # 0x22b3
callq 0x1d64
testl %ebp, %ebp
jns 0x1c57
leaq 0x672(%rip), %rdi       # 0x22c4
callq 0x1d64
cmpl $0x0, 0x8(%rsp)
je 0x1c6a
leaq 0x666(%rip), %rdi       # 0x22cb
callq 0x1d64
movl %r15d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ddrown[P]pretend-ntp/timestamp.c
// Function: diff_ts
void diff_ts(const struct timespec *t1, const struct timespec *t2, struct timespec *diff) {
  diff->tv_sec = t1->tv_sec - t2->tv_sec;
  diff->tv_nsec = t1->tv_nsec - t2->tv_nsec;
  if(diff->tv_nsec < -1000000000 || (diff->tv_nsec < 0 && diff->tv_sec > 0)) {
    diff->tv_sec--;
    diff->tv_nsec += 1000000000;
  }
  if(diff->tv_nsec > 0 && diff->tv_sec < 0) {
    diff->tv_sec++;
    diff->tv_nsec -= 1000000000;
  }
}

// Assembly:
movdqu (%rdi), %xmm0
movdqu (%rsi), %xmm1
psubq %xmm1, %xmm0
movdqu %xmm0, (%rdx)
pshufd $0xee, %xmm0, %xmm1     # xmm1 = xmm0[2,3,2,3]
movq %xmm1, %rax
cmpq $-0x3b9aca00, %rax      # imm = 0xC4653600
jge 0x1cca
movq %xmm0, %rcx
decq %rcx
movq %rcx, (%rdx)
addq $0x3b9aca00, %rax       # imm = 0x3B9ACA00
movq %rax, 0x8(%rdx)
jmp 0x1cd4
movq %xmm0, %rcx
testq %rax, %rax
js 0x1cfc
testq %rax, %rax
setg %sil
testq %rcx, %rcx
sets %dil
andb %sil, %dil
cmpb $0x1, %dil
jne 0x1cfb
incq %rcx
movq %rcx, (%rdx)
addq $-0x3b9aca00, %rax      # imm = 0xC4653600
movq %rax, 0x8(%rdx)
retq
testq %rcx, %rcx
jg 0x1cb3
jmp 0x1cfb
// File: /workspace/github_c_makefile_star2_O3/ddrown[P]pretend-ntp/timestamp.c
// Function: print_diff_ts
void print_diff_ts(const struct timespec *t1, const struct timespec *t2) {
  struct timespec diff;

  diff_ts(t1, t2, &diff);

  if(diff.tv_nsec < 0 && diff.tv_sec == 0) {
    printf("-0.%09ld", diff.tv_nsec*-1);
  } else if(diff.tv_nsec < 0) {
    printf("%ld.%09ld", diff.tv_sec, diff.tv_nsec*-1);
  } else {
    printf("%ld.%09ld", diff.tv_sec, diff.tv_nsec);
  }
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rsp, %rbx
movq %rbx, %rdx
callq 0x1c91
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
testq %rdx, %rdx
sets %al
testq %rsi, %rsi
sete %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x1d46
negq %rdx
leaq 0x5af(%rip), %rdi       # 0x22e6
movq %rdx, %rsi
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
jmp 0x1080
testq %rdx, %rdx
jns 0x1d4e
negq %rdx
leaq 0x587(%rip), %rdi       # 0x22dc
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
jmp 0x1080
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/orestesleal[P]base64/b16enc.c
// Function: main
int main(int argc, char *argv[])
{
	struct finfo *fd;
	char *enc_buf;
	int ofd;
	size_t wr;

	if (argv[1]) {
		/* load the input file */
		if ((fd = get_file(argv[1])) == NULL) {
			fprintf(stderr, "get_file() failed loading %s in main memory\n", argv[1]);
			exit(EXIT_FAILURE);
		}
		if (argv[2]) {
			/* encode and write the encoded file into argv[2] */
			enc_buf = alloc(fd->size*2); /* buffer for the base32 encoding string */
			b16_enc(fd->addr, enc_buf, fd->size);

            if ((ofd = open(argv[2], O_CREAT | O_RDWR, S_IRUSR | O_TRUNC | S_IWUSR)) == -1) {
            	fprintf(stderr, "open(2) error, can't create or truncate %s\n", argv[2]);
	        	exit(EXIT_FAILURE);
			}
			if ((wr = write(ofd, enc_buf, strlen(enc_buf))) == -1) {
				fprintf(stderr, "write(2) error, can't write to %s\n", argv[2]);
				exit(EXIT_FAILURE);
			}
			close(ofd);
			free(enc_buf);
        }
		free(fd);
	}
	return EXIT_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x8(%rsi), %rdi
testq %rdi, %rdi
je 0x1530
movq %rsi, %rbx
callq 0x2109
testq %rax, %rax
je 0x153b
movq %rax, %r14
cmpq $0x0, 0x10(%rbx)
je 0x1528
addq $0x10, %rbx
movl 0x8(%r14), %edi
addl %edi, %edi
callq 0x2234
movq %rax, %r15
movq (%r14), %rdi
movl 0x8(%r14), %edx
movq %rax, %rsi
callq 0x1eea
movq (%rbx), %rdi
movl $0x42, %esi
movl $0x380, %edx            # imm = 0x380
xorl %eax, %eax
callq 0x10c0
cmpl $-0x1, %eax
je 0x1547
movl %eax, %r12d
movq %r15, %rdi
callq 0x1050
movl %r12d, %edi
movq %r15, %rsi
movq %rax, %rdx
callq 0x1040
cmpq $-0x1, %rax
je 0x154f
movl %r12d, %edi
callq 0x1070
movq %r15, %rdi
callq 0x1030
movq %r14, %rdi
callq 0x1030
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x1154
movq %rbx, %rdi
callq 0x112a
movq %rbx, %rdi
callq 0x1100
nop
// File: /workspace/github_c_makefile_star2_O3/orestesleal[P]base64/base64.c
// Function: base64url_dec
void base64url_dec(char *s, char b[])
{
	unsigned int x;
	int i,z,w;

	x = w = 0;
	for (i = 0; s[i] != PAD && s[i]; i++) {
		for (x = 0, z = 0; z < 4 && s[i] && s[i] != PAD; z++) {
			x |= get_token_pos(s[i++], 64, b64_url_alp);
			z < 3 && s[i] != PAD && s[i] ? x <<= 6 : 0;
		}
		/*  if there are less than 24 bits of input, add 0s on 
			the right to make an integral number of 6 bit groups 
			(sec. 4. rfc4648 */
		for (;z < 4; z++, x <<= 6);  
		x <<= 8;
		b[w++] = x >> 24;
		b[w++] = (x << 8) >> 24;
		b[w++] = (x << 16) >> 24;
		--i;
	}
	b[w] = '\0';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
xorl %eax, %eax
leaq 0x3b1e(%rip), %rdx      # 0x50d0
xorl %ecx, %ecx
xorl %r9d, %r9d
movslq %r9d, %r8
movzbl (%rdi,%r8), %r10d
testl %r10d, %r10d
je 0x1681
cmpl $0x3d, %r10d
je 0x1681
movb 0x3af7(%rip), %r11b     # 0x50d0
addl $0x4, %r9d
xorl %r14d, %r14d
movl $0x4, %r10d
xorl %ebx, %ebx
movzbl (%rdi,%r8), %r15d
testl %r15d, %r15d
je 0x1654
cmpl $0x3d, %r15d
je 0x1654
xorl %r12d, %r12d
cmpb %r15b, %r11b
je 0x1624
xorl %r13d, %r13d
leaq 0x1(%r13), %r12
cmpb %r15b, 0x1(%r13,%rdx)
je 0x1617
cmpb $0x3f, %r13b
movq %r12, %r13
jne 0x1603
leaq -0x1(%r12), %r15
cmpq $0x40, %r15
cmovael %eax, %r12d
orl %r12d, %ebx
cmpl $0x3, %r14d
je 0x164f
incq %r8
movzbl (%rdi,%r8), %r15d
testl %r15d, %r15d
je 0x1643
cmpl $0x3d, %r15d
je 0x1643
shll $0x6, %ebx
incl %r14d
decl %r10d
cmpl $0x4, %r14d
jne 0x15e8
movl %r9d, %r8d
jmp 0x1662
cmpl $0x3, %r14d
ja 0x1662
shll $0x6, %ebx
decl %r10d
jne 0x165a
movl %ebx, %r9d
shrl $0x10, %r9d
movb %r9b, (%rsi,%rcx)
movb %bh, 0x1(%rsi,%rcx)
movb %bl, 0x2(%rsi,%rcx)
addq $0x3, %rcx
movl %r8d, %r9d
jmp 0x15b7
movl %ecx, %eax
movb $0x0, (%rsi,%rax)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/orestesleal[P]base64/base64.c
// Function: base64url_enc
void base64url_enc(char *s, char b[])
{
	unsigned int x, npad;
	int i;

	npad = 0;
	for (i = 0; *s; i++) {
		x = s[0] == ESC ? s++[1]-'0' : s[0];
		x <<= 8;
		x |= s[1] == ESC ? s++[2]-'0' : s[1];
		x <<= 8;
		x |= s[2] == ESC ? s++[3]-'0' : s[2];
		x <<= 8;
		b[i++] = b64_url_alp[x >> 26];
		b[i++] = b64_url_alp[(x << 6) >> 26];

		if (s[1] == '\0') { /* quantum of encoding of 8 bits */
			npad = 2;
			break;
		}
		b[i++] = b64_url_alp[(x << 12) >> 26];
		
		if (s[2] == '\0') { /* quantum of 16 bits */
			npad = 1;
			break;
		}
		b[i] = b64_url_alp[(x << 18) >> 26];
		s += 3; /* point to the next 24 bit group */ 
	}
	for (;npad > 0; npad--) { /* add padding if needed */
		b[i++] = PAD;
	}
	b[i] = '\0';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
xorl %r15d, %r15d
leaq 0x3a27(%rip), %rax      # 0x50d0
xorl %r14d, %r14d
movzbl (%rdi), %ecx
cmpl $0x5c, %ecx
je 0x16c1
testl %ecx, %ecx
je 0x1779
movsbl %cl, %edx
jmp 0x16cb
movsbl 0x1(%rdi), %edx
incq %rdi
addl $-0x30, %edx
movsbl 0x1(%rdi), %ecx
cmpl $0x5c, %ecx
jne 0x16de
movsbl 0x2(%rdi), %ecx
incq %rdi
addl $-0x30, %ecx
movsbl 0x2(%rdi), %esi
cmpl $0x5c, %esi
jne 0x16f1
movsbl 0x3(%rdi), %esi
incq %rdi
addl $-0x30, %esi
shll $0x10, %edx
shll $0x8, %ecx
orl %edx, %ecx
orl %esi, %ecx
movl %ecx, %edx
shrl $0x12, %edx
andl $0x3f, %edx
movb (%rdx,%rax), %dl
movb %dl, (%rbx,%r14)
movl %ecx, %edx
shrl $0xc, %edx
andl $0x3f, %edx
movb (%rdx,%rax), %dl
movb %dl, 0x1(%rbx,%r14)
cmpb $0x0, 0x1(%rdi)
je 0x174c
shrl $0x6, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x2(%rbx,%r14)
cmpb $0x0, 0x2(%rdi)
je 0x1759
andl $0x3f, %esi
movb (%rsi,%rax), %cl
movb %cl, 0x3(%rbx,%r14)
addq $0x3, %rdi
addq $0x4, %r14
jmp 0x16ac
movl $0x1, %r15d
movl $0x2, %eax
jmp 0x175e
movl $0x3, %eax
addl %eax, %r14d
leaq (%rbx,%r14), %rdi
leaq 0x1(%r15), %rdx
movl $0x3d, %esi
callq 0x1060
addl %r15d, %r14d
incl %r14d
movslq %r14d, %rax
movb $0x0, (%rbx,%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/orestesleal[P]base64/base64.c
// Function: base64_dec
void base64_dec(char *s, char b[])
{
	unsigned int x;
	int i,z, w;

	x = w = 0;
	for (i = 0; s[i] != PAD && s[i]; i++) {
		for (x = 0, z = 0; z < 4 && s[i] && s[i] != PAD; z++) {
			x |= get_token_pos(s[i++], 64, b64_alp);
			z < 3 && s[i] != PAD && s[i] ? x <<= 6 : 0;
		}
		/*  TODO: update this to a single computation 
			less than 24 bits of input, add 0s on the right to make
			an integral number of 6 bit groups (sec. 4. rfc4648 */
		for (;z < 4; z++, x <<= 6);  
		x <<= 8;
		b[w++] = x >> 24;
		b[w++] = (x << 8) >> 24;
		b[w++] = (x << 16) >> 24;
		--i;
	}
	b[w] = '\0';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
xorl %eax, %eax
leaq 0x38ef(%rip), %rdx      # 0x5090
xorl %ecx, %ecx
xorl %r9d, %r9d
movslq %r9d, %r8
movzbl (%rdi,%r8), %r10d
testl %r10d, %r10d
je 0x1870
cmpl $0x3d, %r10d
je 0x1870
movb 0x38c8(%rip), %r11b     # 0x5090
addl $0x4, %r9d
xorl %r14d, %r14d
movl $0x4, %r10d
xorl %ebx, %ebx
movzbl (%rdi,%r8), %r15d
testl %r15d, %r15d
je 0x1843
cmpl $0x3d, %r15d
je 0x1843
xorl %r12d, %r12d
cmpb %r15b, %r11b
je 0x1813
xorl %r13d, %r13d
leaq 0x1(%r13), %r12
cmpb %r15b, 0x1(%r13,%rdx)
je 0x1806
cmpb $0x3f, %r13b
movq %r12, %r13
jne 0x17f2
leaq -0x1(%r12), %r15
cmpq $0x40, %r15
cmovael %eax, %r12d
orl %r12d, %ebx
cmpl $0x3, %r14d
je 0x183e
incq %r8
movzbl (%rdi,%r8), %r15d
testl %r15d, %r15d
je 0x1832
cmpl $0x3d, %r15d
je 0x1832
shll $0x6, %ebx
incl %r14d
decl %r10d
cmpl $0x4, %r14d
jne 0x17d7
movl %r9d, %r8d
jmp 0x1851
cmpl $0x3, %r14d
ja 0x1851
shll $0x6, %ebx
decl %r10d
jne 0x1849
movl %ebx, %r9d
shrl $0x10, %r9d
movb %r9b, (%rsi,%rcx)
movb %bh, 0x1(%rsi,%rcx)
movb %bl, 0x2(%rsi,%rcx)
addq $0x3, %rcx
movl %r8d, %r9d
jmp 0x17a6
movl %ecx, %eax
movb $0x0, (%rsi,%rax)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/orestesleal[P]base64/base64.c
// Function: base64_enc
void base64_enc(char *s, char b[])
{
	unsigned int x, npad;
	int i;

	npad = 0;
	for (i = 0; *s; i++) {
		x = s[0] == ESC ? s++[1]-'0' : s[0];
		x <<= 8;
		x |= s[1] == ESC ? s++[2]-'0' : s[1];
		x <<= 8;
		x |= s[2] == ESC ? s++[3]-'0' : s[2];
		x <<= 8;
		b[i++] = b64_alp[x >> 26];
		b[i++] = b64_alp[(x << 6) >> 26];

		if (s[1] == '\0') { /* quantum of encoding of 8 bits */
			npad = 2;
			break;
		}
		b[i++] = b64_alp[(x << 12) >> 26];
		
		if (s[2] == '\0') { /* quantum of 16 bits */
			npad = 1;
			break;
		}
		b[i] = b64_alp[(x << 18) >> 26];
		s += 3; /* point to the next 24 bit group */ 
	}
	for (;npad > 0; npad--) { /* add padding if needed */
		b[i++] = PAD;
	}
	b[i] = '\0';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
xorl %r15d, %r15d
leaq 0x37f8(%rip), %rax      # 0x5090
xorl %r14d, %r14d
movzbl (%rdi), %ecx
cmpl $0x5c, %ecx
je 0x18b0
testl %ecx, %ecx
je 0x1968
movsbl %cl, %edx
jmp 0x18ba
movsbl 0x1(%rdi), %edx
incq %rdi
addl $-0x30, %edx
movsbl 0x1(%rdi), %ecx
cmpl $0x5c, %ecx
jne 0x18cd
movsbl 0x2(%rdi), %ecx
incq %rdi
addl $-0x30, %ecx
movsbl 0x2(%rdi), %esi
cmpl $0x5c, %esi
jne 0x18e0
movsbl 0x3(%rdi), %esi
incq %rdi
addl $-0x30, %esi
shll $0x10, %edx
shll $0x8, %ecx
orl %edx, %ecx
orl %esi, %ecx
movl %ecx, %edx
shrl $0x12, %edx
andl $0x3f, %edx
movb (%rdx,%rax), %dl
movb %dl, (%rbx,%r14)
movl %ecx, %edx
shrl $0xc, %edx
andl $0x3f, %edx
movb (%rdx,%rax), %dl
movb %dl, 0x1(%rbx,%r14)
cmpb $0x0, 0x1(%rdi)
je 0x193b
shrl $0x6, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x2(%rbx,%r14)
cmpb $0x0, 0x2(%rdi)
je 0x1948
andl $0x3f, %esi
movb (%rsi,%rax), %cl
movb %cl, 0x3(%rbx,%r14)
addq $0x3, %rdi
addq $0x4, %r14
jmp 0x189b
movl $0x1, %r15d
movl $0x2, %eax
jmp 0x194d
movl $0x3, %eax
addl %eax, %r14d
leaq (%rbx,%r14), %rdi
leaq 0x1(%r15), %rdx
movl $0x3d, %esi
callq 0x1060
addl %r15d, %r14d
incl %r14d
movslq %r14d, %rax
movb $0x0, (%rbx,%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/orestesleal[P]base64/base64.c
// Function: base16_encoder
void base16_encoder(char *s, char b[])
{
	char b16_alp[] = "0123456789ABCDEF";
	int i;
	for (i = 0; *s; i++, s++) { 
		unsigned char x = (unsigned char)*s >> 4;
		unsigned char z = ((unsigned char)(*s << 4)) >> 4;
		b[i] = b16_alp[x];
		b[++i] = b16_alp[z];
	}
	b[i] = '\0';
}

// Assembly:
movb (%rdi), %dl
testb %dl, %dl
je 0x19bf
pushq %rbp
movq %rsp, %rbp
incq %rdi
xorl %eax, %eax
leaq 0x18e0(%rip), %rcx      # 0x3270
movzbl %dl, %edx
movl %edx, %r8d
shrl $0x4, %r8d
andl $0xf, %edx
movb (%r8,%rcx), %r8b
movb %r8b, (%rsi,%rax)
movb (%rdx,%rcx), %dl
movb %dl, 0x1(%rsi,%rax)
addq $0x2, %rax
movb (%rdi), %dl
incq %rdi
testb %dl, %dl
jne 0x1990
andl $-0x2, %eax
popq %rbp
jmp 0x19c1
xorl %eax, %eax
movb $0x0, (%rsi,%rax)
retq
// File: /workspace/github_c_makefile_star2_O3/orestesleal[P]base64/base64.c
// Function: b64_enc
void b64_enc(unsigned const char *s, char b[], unsigned int len)
{
	register unsigned int x,i,w;
	unsigned char rm,z;

	w = 0;
	for (i = 0; i < len; i++) {
		for (x = 0, z = 0; z < 3 && i < len; z++, i++) {
			x |= s[i];	
			(z < 2 && i+1 < len) ? x <<= 8 : 0;
		}
		for (;z < 4; z++, x <<= 8);
		b[w++] = b64_alp[x >> 26];
		b[w++] = b64_alp[(x << 6) >> 26];
		b[w++] = b64_alp[(x << 12) >> 26];
		b[w++] = b64_alp[(x << 18) >> 26];
		--i;
	}
	b[w] = '\0';
	rm = len % 3; 
	if (rm) { /* padding */ 
		for (x = rm == 1 ? 2 : 1; x; --x) {
			b[--w] = PAD;
		}
	}
}

// Assembly:
testl %edx, %edx
je 0x1b0e
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %ecx
xorl %eax, %eax
leaq 0x3655(%rip), %r8       # 0x5090
xorl %r9d, %r9d
movl %r9d, %r10d
xorl %r14d, %r14d
xorl %r15d, %r15d
movl %r14d, %ebx
movzbl (%rdi,%r10), %r11d
orl %r15d, %r11d
incq %r10
leal 0x1(%rbx), %r14d
cmpb $0x1, %bl
ja 0x1a6a
movl %r11d, %r15d
shll $0x8, %r15d
cmpq %rcx, %r10
jb 0x1a47
addl %r14d, %r9d
movl %r11d, %r14d
shll $0x8, %r11d
incb %bl
cmpb $0x3, %bl
jb 0x1a6d
movl %r11d, %ebx
shrl $0x1a, %ebx
movb (%rbx,%r8), %bl
movl %eax, %r15d
movb %bl, (%rsi,%r15)
movl %r11d, %ebx
shrl $0x14, %ebx
andl $0x3f, %ebx
movb (%rbx,%r8), %bl
movb %bl, 0x1(%rsi,%r15)
shrl $0xe, %r11d
andl $0x3f, %r11d
movb (%r11,%r8), %r11b
movb %r11b, 0x2(%rsi,%r15)
andl $0x3f, %r14d
movb (%r14,%r8), %r11b
addl $0x4, %eax
movb %r11b, 0x3(%rsi,%r15)
cmpl %edx, %r9d
movq %r10, %r9
jb 0x1a3e
movl %eax, %edi
movb $0x0, (%rsi,%rdi)
movl $0xaaaaaaab, %edi       # imm = 0xAAAAAAAB
imulq %rcx, %rdi
shrq $0x21, %rdi
leal (%rdi,%rdi,2), %ecx
subl %ecx, %edx
popq %rbx
popq %r14
popq %r15
popq %rbp
je 0x1b0d
xorl %ecx, %ecx
cmpl $0x1, %edx
sete %cl
incl %ecx
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
leal (%rax,%rdx), %edi
movb $0x3d, (%rsi,%rdi)
leal (%rcx,%rdx), %edi
decl %edi
decl %edx
cmpl $-0x1, %edi
jne 0x1afa
retq
movb $0x0, (%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/orestesleal[P]base64/base64.c
// Function: get_data_size
unsigned int get_data_size(char *s, unsigned int len)
{
	unsigned int rtsize, i;
	unsigned char pad = 0;
	for (i = len-1; s[i] == PAD; --i) {
		++pad;
		--len;
	}
	rtsize = (len >> 2) * 3;
	if (pad) {
		rtsize += pad == 2 ? 1 : 2;
	}
	return rtsize;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leal -0x1(%rsi), %eax
xorl %ecx, %ecx
cmpb $0x3d, (%rdi,%rax)
jne 0x1c6b
xorl %eax, %eax
movl %esi, %ecx
incb %al
leal -0x1(%rcx), %esi
addl $-0x2, %ecx
cmpb $0x3d, (%rdi,%rcx)
je 0x1c4b
xorl %edx, %edx
cmpb $0x2, %al
setne %dl
incl %edx
xorl %ecx, %ecx
testb %al, %al
cmovnel %edx, %ecx
shrl $0x2, %esi
leal (%rsi,%rsi,2), %eax
addl %ecx, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/orestesleal[P]base64/base64.c
// Function: b32_enc
void b32_enc(unsigned char *s, unsigned char *b, unsigned int len)
{
	unsigned long long x;	/* c99 only */
	unsigned int i,w,z;
	unsigned char ap[5] = {0,6,4,3,1};

	w = x = 0;
	/* 	in base32 per 5 bytes of input we get 40 bits that must
		be treated as eight 5 bits groups, each 5 bit number
		will be used as an index into the base32 alphabet  */
	for (i = 0; i < len; i++) {
		for (z = 0; z < 5 && i < len; z++, i++) {
			x |= s[i];
			x <<= 8;
		}
		/* compute the number of shifts needed to align all bytes
			to the most significant part of x, this avoids several
			iterations of one 'test, shift, and increment' loop */
		x <<= (7 - z) << 3; /* mul by 8 */ 

		/* 	this block could be optimized for size within a loop, but that
			will involve a and additional 'test and increment' step on a 
			loop, which will make the code a tiny fraction more slower,
			this is coded for speed, not size */
		b[w++] = b32_alp[x >> 59];
		b[w++] = b32_alp[(x << 5) >> 59];
		b[w++] = b32_alp[(x << 10) >> 59];
		b[w++] = b32_alp[(x << 15) >> 59];
		b[w++] = b32_alp[(x << 20) >> 59];
		b[w++] = b32_alp[(x << 25) >> 59];
		b[w++] = b32_alp[(x << 30) >> 59];
		b[w++] = b32_alp[(x << 35) >> 59];
		--i;
	}
	b[w] = '\0';
	for (i = ap[len % 5]; i; i--) {
		b[--w] = PAD; 
	}		
	return;
}

// Assembly:
testl %edx, %edx
je 0x1dbf
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %r8d
xorl %eax, %eax
leaq 0x347e(%rip), %r9       # 0x5110
xorl %r11d, %r11d
xorl %r10d, %r10d
movq %r11, %rbx
movl %ebx, %r11d
movl $0x38, %ecx
xorl %r14d, %r14d
movl %r14d, %r15d
movzbl (%rdi,%r11), %r14d
orq %r14, %r10
shlq $0x8, %r10
leal 0x1(%r15), %r14d
incq %r11
addq $-0x8, %rcx
cmpl $0x3, %r15d
ja 0x1ccb
cmpq %r8, %r11
jb 0x1ca6
shlq %cl, %r10
addl %r14d, %ebx
movq %r10, %rcx
shrq $0x3b, %rcx
movb (%rcx,%r9), %r14b
movl %eax, %ecx
movb %r14b, (%rsi,%rcx)
movq %r10, %r14
shrq $0x36, %r14
andl $0x1f, %r14d
movb (%r14,%r9), %r14b
movb %r14b, 0x1(%rsi,%rcx)
movq %r10, %r14
shrq $0x31, %r14
andl $0x1f, %r14d
movb (%r14,%r9), %r14b
movb %r14b, 0x2(%rsi,%rcx)
movq %r10, %r14
shrq $0x2c, %r14
andl $0x1f, %r14d
movb (%r14,%r9), %r14b
movb %r14b, 0x3(%rsi,%rcx)
movq %r10, %r14
shrq $0x27, %r14
andl $0x1f, %r14d
movb (%r14,%r9), %r14b
movb %r14b, 0x4(%rsi,%rcx)
movq %r10, %r14
shrq $0x22, %r14
andl $0x1f, %r14d
movb (%r14,%r9), %r14b
movb %r14b, 0x5(%rsi,%rcx)
movq %r10, %r14
shrq $0x1d, %r14
andl $0x1f, %r14d
movb (%r14,%r9), %r14b
movb %r14b, 0x6(%rsi,%rcx)
movl %r10d, %r14d
shrl $0x18, %r14d
andl $0x1f, %r14d
movb (%r14,%r9), %r14b
addl $0x8, %eax
movb %r14b, 0x7(%rsi,%rcx)
cmpl %edx, %ebx
jb 0x1c98
movl %eax, %ecx
movb $0x0, (%rsi,%rcx)
movl $0xcccccccd, %ecx       # imm = 0xCCCCCCCD
imulq %r8, %rcx
shrq $0x22, %rcx
leal (%rcx,%rcx,4), %ecx
subl %ecx, %edx
popq %rbx
popq %r14
popq %r15
popq %rbp
je 0x1dbe
movl %edx, %ecx
leaq 0x14be(%rip), %rdx      # 0x3260
movzbl (%rcx,%rdx), %ecx
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
leal (%rax,%rdx), %edi
movb $0x3d, (%rsi,%rdi)
leal (%rcx,%rdx), %edi
decl %edi
decl %edx
cmpl $-0x1, %edi
jne 0x1dab
retq
movb $0x0, (%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/orestesleal[P]base64/base64.c
// Function: b16_enc
void b16_enc(const unsigned char *s, char *b, unsigned int len)
{
	while (len--) {
		*b++ = b16_alp[*s >> 4];
		*b++ = b16_alp[*s++ & 0x0f]; 	
	}
	*b = '\0';
}

// Assembly:
testl %edx, %edx
je 0x1f2e
movl %edx, %ecx
xorl %eax, %eax
leaq 0x1377(%rip), %rdx      # 0x3270
xorl %r8d, %r8d
movzbl (%rdi,%r8), %r9d
shrl $0x4, %r9d
movb (%r9,%rdx), %r9b
movb %r9b, (%rsi,%r8,2)
movzbl (%rdi,%r8), %r9d
andl $0xf, %r9d
movb (%r9,%rdx), %r9b
movb %r9b, 0x1(%rsi,%r8,2)
incq %r8
addq $-0x2, %rax
cmpl %r8d, %ecx
jne 0x1efc
subq %rax, %rsi
pushq %rbp
movq %rsp, %rbp
movb $0x0, (%rsi)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/orestesleal[P]base64/base64.c
// Function: b16_dec
unsigned int b16_dec(const char *s, char *b, unsigned int len)
{
	unsigned char t[2],d;
	unsigned int i;

	d = 0;
	for (i = 0; i < len; i+=2) {
   		for (d = 0; d < 2; d++) {
			if ((s[i+d] >= '0' && s[i+d] <= '9') || 
				(s[i+d] >= 'A' && s[i+d] <= 'F')) {
				for (t[d] = 0; s[i+d] != b16_alp[t[d]]; ++t[d]); /* get position */
			}
			else { /* rfc4648 sec 3.3 paragraph #2 */ 
				fprintf(stderr, "error: non alphabet character found on encoded stream\n");
				exit(EXIT_FAILURE);
			}
		}
		t[0] <<= 4;
		t[0] |= t[1];
		*b++ = t[0];
	}	
	*b = '\0';
	return len >> 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testl %edx, %edx
je 0x1fc4
xorl %eax, %eax
leaq -0x19(%rbp), %rcx
leaq 0x131e(%rip), %r8       # 0x3270
leaq -0x1a(%rbp), %r9
movb $0x1, %r10b
movq %rcx, %r11
xorl %ebx, %ebx
orl %eax, %ebx
movb (%rdi,%rbx), %bl
leal -0x30(%rbx), %r14d
cmpb $0xa, %r14b
setae %r14b
leal -0x41(%rbx), %r15d
cmpb $0x6, %r15b
setae %r15b
testb %r15b, %r14b
jne 0x1fd6
movb $-0x1, %r14b
incb %r14b
movzbl %r14b, %r15d
cmpb (%r15,%r8), %bl
jne 0x1f83
movb %r14b, (%r11)
movl $0x1, %ebx
movq %r9, %r11
testb $0x1, %r10b
movl $0x0, %r10d
jne 0x1f5e
movb -0x19(%rbp), %r10b
shlb $0x4, %r10b
orb -0x1a(%rbp), %r10b
movb %r10b, -0x19(%rbp)
movb %r10b, (%rsi)
incq %rsi
addl $0x2, %eax
cmpl %edx, %eax
jb 0x1f56
movb $0x0, (%rsi)
shrl %edx
movl %edx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x11d0
// File: /workspace/github_c_makefile_star2_O3/orestesleal[P]base64/base64.c
// Function: encode_wr_file
void encode_wr_file(const char *src, const char *dst, unsigned char mode)
{
	struct finfo *fd;
	char *enc_buf;
	int ofd;
	size_t wr;
	int flags = O_CREAT | O_RDWR;
	int perms = S_IRUSR | O_TRUNC | S_IWUSR; 
	
	if ((fd = get_file(src)) == NULL) { /* load the input file 'src' */
		fprintf(stderr, "error: get_file() failed to load %s in main memory\n", src);
		exit(EXIT_FAILURE);
	}
	enc_buf = alloc(fd->size*2); /* buffer for the encoded string */
	switch (mode) {
		case BASE64:
			b64_enc((unsigned char *)fd->addr, enc_buf, fd->size);
			break;
		case BASE32:
			b32_enc((unsigned char *)fd->addr, (unsigned char *)enc_buf, fd->size);
			break;
		case BASE16:
			b16_enc(fd->addr, enc_buf, fd->size); 
			break;
		default:
			fprintf(stderr, "error: encoding %d mode not supported\n", mode);
			exit(EXIT_FAILURE);
	}
    if ((ofd = open(dst, flags, perms)) == -1) {
   		fprintf(stderr, "open(2) error, can't create or truncate %s\n", dst);
	    exit(EXIT_FAILURE);
	}
	if ((wr = write(ofd, enc_buf, strlen(enc_buf))) == -1) {
		fprintf(stderr, "write(2) error, can't write to %s\n", dst);
		exit(EXIT_FAILURE);
	}
	close(ofd);
	free(enc_buf);
	free(fd);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r13d
movq %rsi, %rbx
movq %rdi, %r15
callq 0x2109
testq %rax, %rax
je 0x20ec
movq %rax, %r14
movq 0x8(%rax), %r12
leal (%r12,%r12), %edi
callq 0x2234
movq %rax, %r15
cmpb $0x3, %r13b
je 0x204b
movzbl %r13b, %edi
cmpl $0x2, %edi
je 0x203b
cmpl $0x1, %edi
jne 0x2104
movq (%r14), %rdi
movq %r15, %rsi
movl %r12d, %edx
callq 0x1a1f
jmp 0x208e
movq (%r14), %rdi
movq %r15, %rsi
movl %r12d, %edx
callq 0x1c75
jmp 0x208e
movq %r15, %rax
testl %r12d, %r12d
je 0x208b
movq (%r14), %rcx
xorl %edx, %edx
leaq 0x1211(%rip), %rsi      # 0x3270
movq %r15, %rax
movzbl (%rcx,%rdx), %edi
movl %edi, %r8d
shrl $0x4, %r8d
movb (%r8,%rsi), %r8b
movb %r8b, (%rax)
andl $0xf, %edi
movb (%rdi,%rsi), %dil
movb %dil, 0x1(%rax)
addq $0x2, %rax
incq %rdx
cmpl %edx, %r12d
jne 0x2062
movb $0x0, (%rax)
movq %rbx, %rdi
movl $0x42, %esi
movl $0x380, %edx            # imm = 0x380
xorl %eax, %eax
callq 0x10c0
cmpl $-0x1, %eax
je 0x20f4
movl %eax, %r12d
movq %r15, %rdi
callq 0x1050
movl %r12d, %edi
movq %r15, %rsi
movq %rax, %rdx
callq 0x1040
cmpq $-0x1, %rax
je 0x20fc
movl %r12d, %edi
callq 0x1070
movq %r15, %rdi
callq 0x1030
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1030
movq %r15, %rdi
callq 0x126e
movq %rbx, %rdi
callq 0x121f
movq %rbx, %rdi
callq 0x11f8
callq 0x1246
// File: /workspace/github_c_makefile_star2_O3/orestesleal[P]base64/base64.c
// Function: get_file
struct finfo *get_file(const char *f)
{
	int fd;
	struct stat fp;
	char *addr; 
	struct finfo *st_addr;
	size_t rd;

	if ((fd = open(f, O_RDONLY)) == -1) {
		fprintf(stderr, "open(2) failed for file %s\n", f);
		return NULL;
	}
	stat(f, &fp); /* get file info with stat(2) */
	if ((addr = (char *)malloc(fp.st_size)) == NULL) {
		fprintf(stderr, "malloc(3) failed allocating %d bytes\n", (int)fp.st_size);
		close(fd);
		return NULL;
	}
	if ((rd = read(fd, addr, fp.st_size)) == -1) {
		fprintf(stderr, "read(2) failed reading %s with %d bytes into memory\n", f, (int)fp.st_size);
		close(fd);
		free(addr);
		return NULL;
	}
	if ((st_addr = (struct finfo *)malloc(sizeof(struct finfo))) == NULL) {
		fprintf(stderr, "malloc(3) failed allocating the returned structure\n");
		close(fd);
		free(addr);
		return NULL;
	}
	close(fd);
	st_addr->addr = addr;
	st_addr->size = fp.st_size;
	return st_addr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdi, %r15
xorl %esi, %esi
xorl %eax, %eax
callq 0x10c0
cmpl $-0x1, %eax
je 0x21a6
movl %eax, %ebx
leaq -0xb8(%rbp), %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0x10a0
movq 0x30(%r14), %r12
movq %r12, %rdi
callq 0x10b0
testq %rax, %rax
je 0x21c6
movq %rax, %r13
movl %ebx, %edi
movq %rax, %rsi
movq %r12, %rdx
callq 0x1080
cmpq $-0x1, %rax
je 0x21ed
movl $0x10, %edi
callq 0x10b0
testq %rax, %rax
je 0x2222
movq %rax, %r14
movl %ebx, %edi
callq 0x1070
movq %r13, (%r14)
movq %r12, 0x8(%r14)
movq %r14, %rax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x2e4b(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
leaq 0xfe0(%rip), %rsi       # 0x3197
xorl %r14d, %r14d
movq %r15, %rdx
xorl %eax, %eax
callq 0x1090
jmp 0x2191
movq 0x2e2b(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
leaq 0xfdc(%rip), %rsi       # 0x31b3
xorl %r14d, %r14d
movl %r12d, %edx
xorl %eax, %eax
callq 0x1090
movl %ebx, %edi
callq 0x1070
jmp 0x2191
movq 0x2e04(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
leaq 0xfdb(%rip), %rsi       # 0x31d9
xorl %r14d, %r14d
movq %r15, %rdx
movl %r12d, %ecx
xorl %eax, %eax
callq 0x1090
movl %ebx, %edi
callq 0x1070
movq %r13, %rdi
callq 0x1030
jmp 0x2191
movl %ebx, %edi
movq %r13, %rsi
callq 0x1295
xorl %r14d, %r14d
jmp 0x2191
// File: /workspace/github_c_makefile_star2_O3/orestesleal[P]base64/base64.c
// Function: alloc
char *alloc(unsigned int size)
{
    char *ptr = (char *)malloc(size);
    if (ptr == NULL) {
		fprintf(stderr, "malloc: error, can't allocate %d bytes\n", size);
		exit(EXIT_FAILURE);
	}
	return ptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %edi, %ebx
movl %edi, %edi
callq 0x10b0
testq %rax, %rax
je 0x224f
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movl %ebx, %edi
callq 0x12d2
// File: /workspace/github_c_makefile_star2_O3/orestesleal[P]base64/base64.c
// Function: decode_rd_file
void decode_rd_file(const char *src, const char *dst, unsigned char mode)
{
	struct finfo *fd;
	char *dec_buf;
	int ofd;
	size_t wr;
	size_t dec; /* number of decoded bytes */
	int flags = O_CREAT | O_RDWR;
    int perms = S_IRUSR | O_TRUNC | S_IWUSR;

	if ((fd = get_file(src)) == NULL) {
		fprintf(stderr, "get_file() failed loading %s in main memory\n", src);
		exit(EXIT_FAILURE);
	}

	dec_buf = alloc(fd->size); 
	switch (mode) {
		case BASE64:
			dec = b64_dec((unsigned char *)fd->addr, dec_buf, fd->size); 
			break;
		case BASE32:
			dec = b32_dec((unsigned char *)fd->addr, dec_buf, fd->size); 
			break;
		case BASE16:
			dec = b16_dec(fd->addr, dec_buf, fd->size); 
			break;
		default:
			fprintf(stderr,"error: mode %d not supported\n", mode);
			exit(EXIT_FAILURE);
	}

    if ((ofd = open(dst, flags, perms)) == -1) {
      	fprintf(stderr, "open(2) error, can't create or truncate %s\n", dst);
      	exit(EXIT_FAILURE);
	}
	/* write the contents of `dec_buf` into the file requested on dst */
	if ((wr = write(ofd, dec_buf, dec)) == -1) {
		fprintf(stderr, "write(2) error, can't write to %s\n", dst);
		exit(EXIT_FAILURE);
	}
	close(ofd);
	free(dec_buf);
	free(fd);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r13d
movq %rsi, %rbx
movq %rdi, %r15
callq 0x2109
testq %rax, %rax
je 0x232b
movq %rax, %r14
movl 0x8(%rax), %r12d
movl %r12d, %edi
callq 0x2234
movq %rax, %r15
cmpb $0x3, %r13b
je 0x22c5
movzbl %r13b, %edi
cmpl $0x2, %edi
je 0x22b5
cmpl $0x1, %edi
jne 0x2343
movq (%r14), %rdi
movq %r15, %rsi
movl %r12d, %edx
callq 0x1b12
jmp 0x22d3
movq (%r14), %rdi
movq %r15, %rsi
movl %r12d, %edx
callq 0x1dc3
jmp 0x22d3
movq (%r14), %rdi
movq %r15, %rsi
movl %r12d, %edx
callq 0x1f37
movl %eax, %r12d
movq %rbx, %rdi
movl $0x42, %esi
movl $0x380, %edx            # imm = 0x380
xorl %eax, %eax
callq 0x10c0
cmpl $-0x1, %eax
je 0x2333
movl %eax, %r13d
movl %r12d, %edx
movl %eax, %edi
movq %r15, %rsi
callq 0x1040
cmpq $-0x1, %rax
je 0x233b
movl %r13d, %edi
callq 0x1070
movq %r15, %rdi
callq 0x1030
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1030
movq %r15, %rdi
callq 0x136e
movq %rbx, %rdi
callq 0x131f
movq %rbx, %rdi
callq 0x12f8
callq 0x1346
// File: /workspace/github_c_makefile_star2_O3/ulisses[P]ftp-client-server/apl.c
// Function: main
int main(int argc, char *argv[]){
	if(argc ==1){
		printf("erro: ./apl endereco_ip_servidor\n");
		return 0;
	}
	else {
		int sair = 0;
		char *ip = argv[1];
		char cmd[50];
		while(!sair){
			printf(">>");
			fgets(cmd, 50, stdin);
			if(strstr(cmd, "sair")) sair = 1;
			else trataPedido(cmd, ip);
		}
	return 1;
		
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
cmpl $0x1, %edi
jne 0x1258
leaq 0xddb(%rip), %rdi       # 0x2027
callq 0x1030
xorl %eax, %eax
jmp 0x12e3
movq 0x8(%rsi), %rbx
leaq 0xdbc(%rip), %rdi       # 0x201f
xorl %eax, %eax
callq 0x1040
movq 0x2d6f(%rip), %r13      # 0x3fe0
movq (%r13), %rdx
leaq -0x60(%rbp), %r14
movq %r14, %rdi
movl $0x32, %esi
callq 0x1050
leaq 0xd95(%rip), %rsi       # 0x2022
movq %r14, %rdi
callq 0x10b0
testq %rax, %rax
jne 0x12de
leaq 0xd7e(%rip), %r15       # 0x201f
leaq 0xd7a(%rip), %r12       # 0x2022
movq %r14, %rdi
movq %rbx, %rsi
callq 0x11bc
movq %r15, %rdi
xorl %eax, %eax
callq 0x1040
movq (%r13), %rdx
movq %r14, %rdi
movl $0x32, %esi
callq 0x1050
movq %r14, %rdi
movq %r12, %rsi
callq 0x10b0
testq %rax, %rax
je 0x12a8
movl $0x1, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/rakitzis[P]rc/builtins.c
// Function: funcall
extern void funcall(char **av) {
	Jbwrap j;
	Estack e1, e2;
	Edata jreturn, star;
	if (sigsetjmp(j.j, 1))
		return;
	starassign(*av, av+1, TRUE);
	jreturn.jb = &j;
	star.name = "*";
	except(eReturn, jreturn, &e1);
	except(eVarstack, star, &e2);
	walk(treecpy(fnlookup(*av), nalloc), TRUE);
	varrm("*", TRUE);
	unexcept(eVarstack);
	unexcept(eReturn);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x100, %rsp            # imm = 0x100
movq %rdi, %r14
leaq 0x38(%rsp), %rdi
movl $0x1, %esi
callq 0x3370
testl %eax, %eax
jne 0x3597
movq (%r14), %rdi
leaq 0x8(%r14), %rsi
movl $0x1, %ebp
movl %ebp, %edx
callq 0xcbaf
movl $0x2, %ebx
leaq 0x38(%rsp), %rsi
leaq 0x20(%rsp), %rdx
movl %ebx, %edi
callq 0x44b0
leaq 0xbb15(%rip), %r12      # 0xf05c
movl $0x3, %r15d
leaq 0x8(%rsp), %rdx
movl %r15d, %edi
movq %r12, %rsi
callq 0x44b0
movq (%r14), %rdi
callq 0x4f99
leaq 0x6914(%rip), %rsi      # 0x9e80
movq %rax, %rdi
callq 0xc44b
movq %rax, %rdi
movl %ebp, %esi
callq 0xd284
movq %r12, %rdi
movl %ebp, %esi
callq 0xcb35
movl %r15d, %edi
callq 0x44e4
movl %ebx, %edi
callq 0x44e4
addq $0x100, %rsp            # imm = 0x100
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq