LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/MartinDrab[P]netpipe/netpipe.c
// Function: usage
void usage(void)
{
	fprintf(stderr, "Usage: netpipe <mode> [options]\n");
	fprintf(stderr, "Supported modes:\n");
	fprintf(stderr, "  aa - accept connection from both source and destination\n");
	fprintf(stderr, "  ac - accept connection from the source, make connection to the target\n");
	fprintf(stderr, "  ca - make connection to the source, accept connection from the target\n");
	fprintf(stderr, "  cc - connect to both source and target\n");
	fprintf(stderr, "The connection to the target is established only after the source connection\n");
	fprintf(stderr, "Options:\n");
	for (const COMMAND_LINE_OPTION *c = _cmdOptions; c->Type != otUnknown; c++) {
		fprintf(stderr, "  %s", c->Names[0]);
		for (int i = 1 ; i < c->NameCount; i++)
			fprintf(stderr, ", %s", c->Names[i]);

		if (c->ArgumentType != NULL)
			fprintf(stderr, " <%s>", c->ArgumentType);

		if (c->Description)
			fprintf(stderr, " - %s", c->Description);

		fputc('\n', stderr);
	}

	return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0xbd8c(%rip), %r13      # 0x10ff8
movq (%r13), %rcx
leaq 0x85f1(%rip), %rdi      # 0xd868
pushq $0x20
popq %rsi
pushq $0x1
popq %rbx
movq %rbx, %rdx
callq 0x2210
movq (%r13), %rcx
leaq 0x85f9(%rip), %rdi      # 0xd889
pushq $0x11
popq %rsi
movq %rbx, %rdx
callq 0x2210
movq (%r13), %rcx
leaq 0x85f5(%rip), %rdi      # 0xd89b
pushq $0x3a
popq %rsi
movq %rbx, %rdx
callq 0x2210
movq (%r13), %rcx
leaq 0x861a(%rip), %rdi      # 0xd8d6
pushq $0x48
popq %r14
movq %r14, %rsi
movq %rbx, %rdx
callq 0x2210
movq (%r13), %rcx
leaq 0x8649(%rip), %rdi      # 0xd91f
movq %r14, %rsi
movq %rbx, %rdx
callq 0x2210
movq (%r13), %rcx
leaq 0x867c(%rip), %rdi      # 0xd968
pushq $0x29
popq %rsi
movq %rbx, %rdx
callq 0x2210
movq (%r13), %rcx
leaq 0x8690(%rip), %rdi      # 0xd992
pushq $0x4d
popq %rsi
movq %rbx, %rdx
callq 0x2210
movq (%r13), %rcx
leaq 0x86c8(%rip), %rdi      # 0xd9e0
pushq $0x9
popq %rsi
movq %rbx, %rdx
callq 0x2210
leaq 0xbe36(%rip), %r15      # 0x11160
pushq $0x4
popq %rbx
leaq 0x86bb(%rip), %r14      # 0xd9ef
pushq $0xa
popq %rbp
cmpl $0x0, (%r15)
je 0x53c7
movq (%r13), %rdi
movq 0x18(%r15), %rdx
leaq 0x869a(%rip), %rsi      # 0xd9ea
xorl %eax, %eax
callq 0x2160
movq %rbx, %r12
jmp 0x5371
movq (%r13), %rdi
movq (%r15,%r12,8), %rdx
movq %r14, %rsi
xorl %eax, %eax
callq 0x2160
incq %r12
leaq -0x3(%r12), %rax
cmpq %rax, 0x10(%r15)
ja 0x535c
movq 0x28(%r15), %rdx
testq %rdx, %rdx
jne 0x539f
movq 0x30(%r15), %rdx
testq %rdx, %rdx
jne 0x53b3
movq (%r13), %rsi
movl %ebp, %edi
callq 0x2120
addq $0x38, %r15
jmp 0x5337
movq (%r13), %rdi
leaq 0x864a(%rip), %rsi      # 0xd9f4
xorl %eax, %eax
callq 0x2160
jmp 0x5385
movq (%r13), %rdi
leaq 0x863c(%rip), %rsi      # 0xd9fa
xorl %eax, %eax
callq 0x2160
jmp 0x538e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/MartinDrab[P]netpipe/netpipe.c
// Function: recv_fixed
static int _recv_fixed(SOCKET Socket, void *Buffer, size_t Length, int Flags)
{
	int ret = 0;

	if ((size_t)recv(Socket, Buffer, Length, Flags) != Length) {
		ret = errno;
		if (ret == 0)
			ret = EINTR;
	}

	return ret;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
xorl %ebx, %ebx
xorl %ecx, %ecx
callq 0x2040
cmpq %r14, %rax
je 0x6463
callq 0x2050
movl (%rax), %eax
testl %eax, %eax
pushq $0x4
popq %rbx
cmovnel %eax, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/MartinDrab[P]netpipe/netpipe.c
// Function: StreamData
static int _StreamData(SOCKET Source, SOCKET Dest, uint32_t Flags)
{
	int ret = 0;
	ssize_t len = 0;
	char dataBuffer[4096];

	do {
		len = recv(Source, dataBuffer, sizeof(dataBuffer), 0);
		if (len > 0) {
			LogPacket("<<< %zu bytes received", len);
			len = send(Dest, dataBuffer, len, 0);
			if (len >= 0)
				LogPacket(">>> %zu bytes sent", len);
		}

		if (len == -1)
			ret = -1;
	} while (len > 0);

	return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1008, %rsp           # imm = 0x1008
movl %esi, %ebx
movl %edi, %ebp
movq %rsp, %r14
pushq $0x8
popq %r12
xorl %r15d, %r15d
movl $0x1000, %edx           # imm = 0x1000
movl %ebp, %edi
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x2040
movq %rax, %r13
testq %rax, %rax
jle 0x64f9
callq 0x2090
movl %r12d, %edi
leaq 0x7a68(%rip), %rsi      # 0xdf1c
movl %eax, %edx
movq %r13, %rcx
xorl %eax, %eax
callq 0x5054
movl %ebx, %edi
movq %r14, %rsi
movq %r13, %rdx
xorl %ecx, %ecx
callq 0x20d0
movq %rax, %r13
testq %rax, %rax
js 0x64f9
callq 0x2090
movl %r12d, %edi
leaq 0x7a54(%rip), %rsi      # 0xdf3a
movl %eax, %edx
movq %r13, %rcx
xorl %eax, %eax
callq 0x5054
testq %r13, %r13
jne 0x648c
jmp 0x6507
xorl %r15d, %r15d
cmpq $-0x1, %r13
sete %r15b
negl %r15d
movl %r15d, %eax
addq $0x1008, %rsp           # imm = 0x1008
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/MartinDrab[P]netpipe/randomness.c
// Function: RandomBuffer
int RandomBuffer(void *Buffer, uint32_t Size)
{
	int ret = 0;
#ifdef _WIN32
	HCRYPTPROV hCryptProv = 0;

	if (CryptAcquireContextW(&hCryptProv, NULL, L"Microsoft Base Cryptographic Provider v1.0", PROV_RSA_FULL, CRYPT_VERIFYCONTEXT)) {
		if (!CryptGenRandom(hCryptProv, Size, Buffer))
			ret = GetLastError();

		CryptReleaseContext(hCryptProv, 0);
	} else ret = GetLastError();
#else
	FILE *f = NULL;

	f = fopen("/dev/urandom", "r");
	if (f == NULL) {
		ret = errno;
		goto Exit;
	}

	if (fread(Buffer, 1, Size, f) != Size)
		ret = errno;

	fclose(f);
Exit:
#endif
	return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %r14
leaq 0x7a1d(%rip), %rdi      # 0xdf54
leaq 0x71ae(%rip), %rsi      # 0xd6ec
callq 0x21e0
testq %rax, %rax
je 0x6577
movq %rax, %rbx
movl %ebp, %r15d
pushq $0x1
popq %rsi
movq %r14, %rdi
movq %r15, %rdx
movq %rax, %rcx
callq 0x2060
xorl %ebp, %ebp
cmpq %r15, %rax
je 0x656d
callq 0x2050
movl (%rax), %ebp
movq %rbx, %rdi
callq 0x20a0
jmp 0x657e
callq 0x2050
movl (%rax), %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/MartinDrab[P]netpipe/sha2.c
// Function: sha256_update
void sha256_update(sha256_ctx *ctx, const unsigned char *message,
                   unsigned int len)
{
    unsigned int block_nb;
    unsigned int new_len, rem_len, tmp_len;
    const unsigned char *shifted_message;

    tmp_len = SHA256_BLOCK_SIZE - ctx->len;
    rem_len = len < tmp_len ? len : tmp_len;

    memcpy(&ctx->block[ctx->len], message, rem_len);

    if (ctx->len + len < SHA256_BLOCK_SIZE) {
        ctx->len += len;
        return;
    }

    new_len = len - rem_len;
    block_nb = new_len / SHA256_BLOCK_SIZE;

    shifted_message = message + rem_len;

    sha256_transf(ctx, ctx->block, 1);
    sha256_transf(ctx, shifted_message, block_nb);

    rem_len = new_len % SHA256_BLOCK_SIZE;

    memcpy(ctx->block, &shifted_message[block_nb << 6],
           rem_len);

    ctx->len = rem_len;
    ctx->tot_len += (block_nb + 1) << 6;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
movl 0x4(%rdi), %eax
pushq $0x40
popq %r12
subl %eax, %r12d
cmpl %edx, %r12d
cmovael %edx, %r12d
addq %rax, %rdi
addq $0x8, %rdi
movq %r12, %rdx
callq 0x2170
movl 0x4(%rbx), %r13d
addl %r14d, %r13d
cmpl $0x40, %r13d
jb 0x686d
leaq 0x8(%rbx), %rbp
subl %r12d, %r14d
movl %r14d, %r13d
shrl $0x6, %r13d
addq %r12, %r15
pushq $0x1
popq %rdx
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x658c
movq %rbx, %rdi
movq %r15, %rsi
movl %r13d, %edx
callq 0x658c
movl %r14d, %r13d
andl $0x3f, %r13d
andl $-0x40, %r14d
leaq (%r14,%r15), %rsi
movq %rbp, %rdi
movq %r13, %rdx
callq 0x2170
movl (%rbx), %eax
addl %r14d, %eax
addl $0x40, %eax
movl %eax, (%rbx)
movl %r13d, 0x4(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/MartinDrab[P]netpipe/sha2.c
// Function: sha512_update
void sha512_update(sha512_ctx *ctx, const unsigned char *message,
                   unsigned int len)
{
    unsigned int block_nb;
    unsigned int new_len, rem_len, tmp_len;
    const unsigned char *shifted_message;

    tmp_len = SHA512_BLOCK_SIZE - ctx->len;
    rem_len = len < tmp_len ? len : tmp_len;

    memcpy(&ctx->block[ctx->len], message, rem_len);

    if (ctx->len + len < SHA512_BLOCK_SIZE) {
        ctx->len += len;
        return;
    }

    new_len = len - rem_len;
    block_nb = new_len / SHA512_BLOCK_SIZE;

    shifted_message = message + rem_len;

    sha512_transf(ctx, ctx->block, 1);
    sha512_transf(ctx, shifted_message, block_nb);

    rem_len = new_len % SHA512_BLOCK_SIZE;

    memcpy(ctx->block, &shifted_message[block_nb << 7],
           rem_len);

    ctx->len = rem_len;
    ctx->tot_len += (block_nb + 1) << 7;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
movl 0x4(%rdi), %eax
movl $0x80, %ebp
movl $0x80, %r12d
subl %eax, %r12d
cmpl %edx, %r12d
cmovael %edx, %r12d
addq %rax, %rdi
addq $0x8, %rdi
movq %r12, %rdx
callq 0x2170
movl 0x4(%rbx), %r13d
addl %r14d, %r13d
cmpl %ebp, %r13d
jb 0x6c77
leaq 0x8(%rbx), %rbp
subl %r12d, %r14d
movl %r14d, %r13d
shrl $0x7, %r13d
addq %r12, %r15
pushq $0x1
popq %rdx
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x696f
movq %rbx, %rdi
movq %r15, %rsi
movl %r13d, %edx
callq 0x696f
movl %r14d, %r13d
andl $0x7f, %r13d
andl $-0x80, %r14d
leaq (%r14,%r15), %rsi
movq %rbp, %rdi
movq %r13, %rdx
callq 0x2170
movl (%rbx), %eax
addl %r14d, %eax
addl $0x80, %eax
movl %eax, (%rbx)
movl %r13d, 0x4(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/MartinDrab[P]netpipe/utils.c
// Function: UtilsSetTimeouts
int UtilsSetTimeouts(SOCKET Socket, uint32_t Miliseconds)
{
	int ret = 0;
#ifdef _WIN32
	uint32_t timeout;
#else
	struct timeval timeout;
#endif

	memset(&timeout, 0, sizeof(timeout));
#ifdef _WIN32
	timeout = Miliseconds;
#else
	timeout.tv_sec = Miliseconds / 1000;
	timeout.tv_usec = (Miliseconds * 1000) % 1000000;
#endif
	ret = setsockopt(Socket, SOL_SOCKET, SO_RCVTIMEO, (char *)&timeout, sizeof(timeout));
	if (ret != 0) {
		ret = errno;
		goto Exit;
	}

	ret = setsockopt(Socket, SOL_SOCKET, SO_SNDTIMEO, (char *)&timeout, sizeof(timeout));
	if (ret != 0) {
		ret = errno;
		goto Exit;
	}

Exit:
	return ret;
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x18, %rsp
movl %edi, %ebp
xorl %ebx, %ebx
movl $0x3e8, %ecx            # imm = 0x3E8
movl %esi, %eax
xorl %edx, %edx
divl %ecx
leaq 0x8(%rsp), %rcx
movq %rax, (%rcx)
imull $0x3e8, %esi, %eax      # imm = 0x3E8
movl $0xf4240, %esi          # imm = 0xF4240
xorl %edx, %edx
divl %esi
movq %rdx, 0x8(%rcx)
pushq $0x1
popq %rsi
pushq $0x14
popq %rdx
pushq $0x10
popq %r8
callq 0x2080
testl %eax, %eax
jne 0x7245
pushq $0x1
popq %rsi
pushq $0x15
popq %rdx
leaq 0x8(%rsp), %rcx
pushq $0x10
popq %r8
movl %ebp, %edi
callq 0x2080
testl %eax, %eax
je 0x724c
callq 0x2050
movl (%rax), %ebx
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/adelciotto[P]plasma/src/rgb_plasma.c
// Function: InitSDL
int InitSDL(void) {
    SDL_Init(SDL_INIT_VIDEO);

    if (SDL_GetDesktopDisplayMode(0, &displayMode) != 0) {
        return -1;
    }

    window = SDL_CreateWindow(
        WINDOW_TITLE, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED,
        width * scale, height * scale, SDL_WINDOW_SHOWN | SDL_WINDOW_RESIZABLE);
    if (window == NULL) {
        return -1;
    }
    LogInfo("window created with size %dx%d", width, height);

    if (fullscreen) {
        SDL_SetWindowFullscreen(window, SDL_WINDOW_FULLSCREEN_DESKTOP);
    }

    if (!interactive) {
        SDL_ShowCursor(SDL_DISABLE);
    }

    renderer = SDL_CreateRenderer(
        window, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC);
    if (renderer == NULL) {
        return -1;
    }
    LogInfo("renderer created with logical size %dx%d", width, height);

    SDL_RenderSetLogicalSize(renderer, width, height);

    texture = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGB888,
                                SDL_TEXTUREACCESS_STREAMING, width, height);
    if (texture == NULL) {
        return -1;
    }

    return 0;
}

// Assembly:
pushq %rbx
pushq $0x20
popq %rdi
callq 0x1140
leaq 0x2d45(%rip), %rsi      # 0x4180
xorl %edi, %edi
callq 0x11f0
pushq $-0x1
popq %rbx
testl %eax, %eax
je 0x144d
movl %ebx, %eax
popq %rbx
retq
movl 0x2ce4(%rip), %r8d      # 0x4138
movl 0x2cd6(%rip), %ecx      # 0x4130
imull %r8d, %ecx
imull 0x2cce(%rip), %r8d      # 0x4134
leaq 0xc33(%rip), %rdi       # 0x20a0
pushq $0x24
popq %r9
movl $0x2fff0000, %esi       # imm = 0x2FFF0000
movl $0x2fff0000, %edx       # imm = 0x2FFF0000
callq 0x1060
movq %rax, 0x2cd1(%rip)      # 0x4158
testq %rax, %rax
je 0x1449
movl 0x2c9e(%rip), %edx      # 0x4130
movl 0x2c9c(%rip), %ecx      # 0x4134
leaq 0xc0c(%rip), %rsi       # 0x20ab
xorl %edi, %edi
xorl %eax, %eax
callq 0x1200
cmpl $0x0, 0x2cc9(%rip)      # 0x4178
je 0x14c2
movq 0x2ca0(%rip), %rdi      # 0x4158
movl $0x1001, %esi           # imm = 0x1001
callq 0x1170
cmpl $0x0, 0x2cb3(%rip)      # 0x417c
jne 0x14d2
xorl %edi, %edi
callq 0x1230
movq 0x2c7f(%rip), %rdi      # 0x4158
pushq $-0x1
popq %rbx
pushq $0x6
popq %rdx
movl %ebx, %esi
callq 0x1040
movq %rax, 0x2c73(%rip)      # 0x4160
testq %rax, %rax
je 0x1449
movl 0x2c34(%rip), %edx      # 0x4130
movl 0x2c32(%rip), %ecx      # 0x4134
leaq 0xbc1(%rip), %rsi       # 0x20ca
xorl %ebx, %ebx
xorl %edi, %edi
xorl %eax, %eax
callq 0x1200
movq 0x2c45(%rip), %rdi      # 0x4160
movl 0x2c0f(%rip), %esi      # 0x4130
movl 0x2c0d(%rip), %edx      # 0x4134
callq 0x10b0
movq 0x2c2d(%rip), %rdi      # 0x4160
movl 0x2bf7(%rip), %ecx      # 0x4130
movl 0x2bf4(%rip), %r8d      # 0x4134
pushq $0x1
popq %rdx
movl $0x16161804, %esi       # imm = 0x16161804
callq 0x1210
movq %rax, 0x2c14(%rip)      # 0x4168
cmpq $0x1, %rax
sbbl %ebx, %ebx
jmp 0x1449
// File: /workspace/github_c_makefile_star2_O2/Sigabort42[P]WoodyWoodPacker/main.c
// Function: run
int	run(char *file, char *payload, char *name)
{
  t_env		env;
  int		r;
  
  env.name_output = ft_strdup(name);
  if ((env.fd = open(file, O_RDWR)) < 0)
    return (1);
  if (fstat(env.fd, &env.buf) < 0)
    return (2);
  if ((env.ptr = mmap(0, env.buf.st_size, PROT_READ | PROT_WRITE,
  MAP_PRIVATE, env.fd, 0)) == MAP_FAILED)
    return (3);
  if (ft_strcmp(payload, ""))
    {
      if ((env.fd2 = open(payload, O_RDWR)) < 0)
	return (4);
      if (fstat(env.fd2, &env.buf_payload) < 0)
	return (5);
      if ((env.ptr_payload = mmap(0, env.buf_payload.st_size,
      PROT_READ | PROT_WRITE, MAP_PRIVATE, env.fd2, 0)) == MAP_FAILED)
	return (6);
    }
  r = woody(&env);
  if (munmap(env.ptr, env.buf.st_size) < 0)
    return (7);
  return (r);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x170, %rsp            # imm = 0x170
movq %rsi, %rbx
movq %rdi, %r14
movq %rdx, %rdi
callq 0x3d58
movq %rax, (%rsp)
pushq $0x2
popq %rbp
movq %r14, %rdi
movl %ebp, %esi
xorl %eax, %eax
callq 0x10c0
movl %eax, 0x168(%rsp)
testl %eax, %eax
js 0x12f1
leaq 0x8(%rsp), %rsi
movl %eax, %edi
callq 0x10d0
testl %eax, %eax
js 0x12f4
movq 0x38(%rsp), %rsi
movl 0x168(%rsp), %r8d
pushq $0x3
popq %rbp
pushq $0x2
popq %rcx
xorl %edi, %edi
movl %ebp, %edx
xorl %r9d, %r9d
callq 0x1060
movq %rax, 0x128(%rsp)
cmpq $-0x1, %rax
je 0x12f4
leaq 0x3df6(%rip), %rsi      # 0x5059
movq %rbx, %rdi
callq 0x3d30
testl %eax, %eax
je 0x12c8
pushq $0x2
popq %rsi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x10c0
movl %eax, 0x16c(%rsp)
testl %eax, %eax
js 0x1302
leaq 0x98(%rsp), %rsi
movl %eax, %edi
callq 0x10d0
testl %eax, %eax
js 0x1306
movq 0xc8(%rsp), %rsi
movl 0x16c(%rsp), %r8d
pushq $0x3
popq %rdx
pushq $0x2
popq %rcx
xorl %edi, %edi
xorl %r9d, %r9d
callq 0x1060
movq %rax, 0x130(%rsp)
cmpq $-0x1, %rax
je 0x130a
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x147f
movl %eax, %r14d
movq 0x38(%rbx), %rsi
movq 0x128(%rbx), %rdi
callq 0x10b0
testl %eax, %eax
pushq $0x7
popq %rbp
cmovnsl %r14d, %ebp
jmp 0x12f4
pushq $0x1
popq %rbp
movl %ebp, %eax
addq $0x170, %rsp            # imm = 0x170
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x4
jmp 0x12f3
pushq $0x5
jmp 0x12f3
pushq $0x6
jmp 0x12f3
// File: /workspace/github_c_makefile_star2_O2/Sigabort42[P]WoodyWoodPacker/main.c
// Function: main
int	main(int ac, char **av)
{	
  if (ac < 2)
    {
      ft_printf("%s FILE [PAYLOAD] [NAME OUTPUT]", av[0]);
      return (1);
    }
  else if (ac > 3)
    return run(av[1], av[2], av[3]);
  else if (ac > 2)
    return run(av[1], av[2], "woody");
  else
    return run(av[1], "", "woody");
}

// Assembly:
cmpl $0x1, %edi
jg 0x132a
pushq %rax
movq (%rsi), %rsi
leaq 0x3ce6(%rip), %rdi      # 0x5004
xorl %eax, %eax
callq 0x19bb
pushq $0x1
popq %rax
popq %rcx
retq
cmpl $0x4, %edi
jb 0x1343
movq 0x8(%rsi), %rdi
movq 0x10(%rsi), %rax
movq 0x18(%rsi), %rdx
movq %rax, %rsi
jmp 0x11dc
movq 0x8(%rsi), %rax
cmpl $0x2, %edi
jne 0x1355
leaq 0x3d06(%rip), %rsi      # 0x5059
jmp 0x1359
movq 0x10(%rsi), %rsi
leaq 0x3cc4(%rip), %rdx      # 0x5024
movq %rax, %rdi
jmp 0x11dc
// File: /workspace/github_c_makefile_star2_O2/Sigabort42[P]WoodyWoodPacker/woody.c
// Function: find_section
Elf64_Shdr      *find_section(void *data, char *name)
{
  char		*sname;
  int		i;
  Elf64_Ehdr	*elf_hdr;
  Elf64_Shdr	*shdr;
  Elf64_Shdr	*sh_strtab;
  char		*sh_strtab_p;
  
  elf_hdr = (Elf64_Ehdr *)data;
  shdr = (Elf64_Shdr *)(data + elf_hdr->e_shoff);
  sh_strtab = &shdr[elf_hdr->e_shstrndx];
  sh_strtab_p = data + sh_strtab->sh_offset;
  ft_printf ("+ %d section in file. Looking for section '%s'\n", elf_hdr->e_shnum, name);
  for (i = 0; i < elf_hdr->e_shnum; i++)
    {
      sname = (char*) (sh_strtab_p + shdr[i].sh_name);
      if (!strcmp (sname, name))
	  return &shdr[i];
    }

  return (0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x28(%rdi), %r13
leaq (%rdi,%r13), %rax
movzwl 0x3e(%rdi), %ecx
shll $0x6, %ecx
movq 0x18(%rcx,%rax), %r15
addq %rdi, %r15
movzwl 0x3c(%rdi), %esi
leaq 0x3c6d(%rip), %rdi      # 0x502a
movq %rbx, %rdx
xorl %eax, %eax
callq 0x19bb
movzwl 0x3c(%r14), %r12d
addq %r13, %r14
addq $-0x40, %r14
pushq $-0x1
popq %r13
incq %r13
cmpq %r12, %r13
jae 0x13f8
movl 0x40(%r14), %edi
addq $0x40, %r14
addq %r15, %rdi
movq %rbx, %rsi
callq 0x1080
testl %eax, %eax
jne 0x13d7
jmp 0x13fb
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/Sigabort42[P]WoodyWoodPacker/woody.c
// Function: packing64
int	packing64(t_env *env)
{
  Elf64_Phdr    *seg;
  int           i;

  i = 0;
  seg = (Elf64_Phdr*)((char*)env->ptr + (unsigned int)env->elf64->e_phoff);
  env->old_vaddr64 = env->elf64->e_entry;
  while (i < env->elf64->e_phnum)
    {
      if (seg->p_type == PT_LOAD && seg->p_flags & PF_W)
	break;
      seg = (Elf64_Phdr*)((char*)seg + (unsigned int) env->elf64->e_phentsize);
      i++;
    }
  env->sec64 = find_section(env->ptr_payload, ".text");
  //  xor_block (env->ptr + env->sec64->sh_offset, env->sec64->sh_size);
  if ((i = inject(env)) != 0)
    return (i);
  ft_printf("++ FILE CREATED: %s\n++ KEY: %s\n", key, env->name_output);
  return (0);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x130(%rdi), %rdi
movq 0x138(%rbx), %rax
movq 0x18(%rax), %rax
movq %rax, 0x148(%rbx)
leaq 0x3c28(%rip), %rsi      # 0x506c
callq 0x138c
movq %rax, 0x140(%rbx)
movq %rbx, %rdi
callq 0x16c3
movl %eax, %ebp
testl %eax, %eax
jne 0x1476
movq (%rbx), %rdx
leaq 0x3c0a(%rip), %rdi      # 0x5072
leaq 0x6c11(%rip), %rsi      # 0x8080
xorl %eax, %eax
callq 0x19bb
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/Sigabort42[P]WoodyWoodPacker/woody.c
// Function: woody
int     woody(t_env *env)
{
  env->elf64 = (Elf64_Ehdr*)env->ptr;
  if (env->elf64->e_ident[0] == ELFMAG0 &&
      env->elf64->e_ident[1] == ELFMAG1 &&
      env->elf64->e_ident[2] == ELFMAG2 &&
      env->elf64->e_ident[3] == ELFMAG3 &&
      env->elf64->e_type == ET_EXEC)
    {
      if (env->elf64->e_ident[EI_CLASS] == ELFCLASS64)
	return packing64(env);
      else if (env->elf64->e_ident[EI_CLASS] == ELFCLASS32)
	return packing32(env);
    }
  else
    {
      ft_printf("%s\n", "Error: File is not ELF Executable or PIE activate");
      return (-1);
    }
  return (0);
}

// Assembly:
pushq %rbx
movq 0x128(%rdi), %rax
movq %rax, 0x138(%rdi)
cmpb $0x7f, (%rax)
jne 0x14c2
cmpb $0x45, 0x1(%rax)
jne 0x14c2
cmpb $0x4c, 0x2(%rax)
jne 0x14c2
cmpb $0x46, 0x3(%rax)
jne 0x14c2
cmpw $0x2, 0x10(%rax)
jne 0x14c2
movzbl 0x4(%rax), %eax
xorl %ebx, %ebx
cmpl $0x1, %eax
je 0x14de
cmpl $0x2, %eax
jne 0x14da
popq %rbx
jmp 0x141e
leaq 0x3bc5(%rip), %rdi      # 0x508e
leaq 0x3bc2(%rip), %rsi      # 0x5092
xorl %eax, %eax
callq 0x19bb
pushq $-0x1
popq %rbx
movl %ebx, %eax
popq %rbx
retq
callq 0x1408
jmp 0x14da
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/Sigabort42[P]WoodyWoodPacker/inject.c
// Function: infect_section
void		infect_section(t_env *env, Elf64_Addr text_end,
			       Elf64_Addr payload_vaddr)
{
  Elf64_Shdr* shdr;
  int		payload_len;

  payload_len = env->sec64->sh_size;
  shdr = (Elf64_Shdr*) (env->ptr + env->elf64->e_shoff);
  env->elf64->e_shoff += PAGE_SZ64;
  for(int i=0; i < env->elf64->e_shnum; i++)
    {
      if(shdr[i].sh_offset > text_end)
	shdr[i].sh_offset += PAGE_SZ64;       
      else if(shdr[i].sh_addr + shdr[i].sh_size == payload_vaddr)
	shdr[i].sh_size += payload_len;
    }

}

// Assembly:
movq 0x140(%rdi), %rax
movslq 0x20(%rax), %rax
movq 0x128(%rdi), %r8
movq 0x138(%rdi), %rcx
movq 0x28(%rcx), %rdi
leaq 0x2000(%rdi), %r9
movq %r9, 0x28(%rcx)
movzwl 0x3c(%rcx), %ecx
addq %r8, %rdi
addq $0x20, %rdi
xorl %r8d, %r8d
cmpq %rcx, %r8
jae 0x1557
movq -0x8(%rdi), %r9
cmpq %rsi, %r9
jbe 0x1539
addq $0x2000, %r9            # imm = 0x2000
movq %r9, -0x8(%rdi)
jmp 0x154e
movq (%rdi), %r9
movq -0x10(%rdi), %r10
addq %r9, %r10
cmpq %rdx, %r10
jne 0x154e
addq %rax, %r9
movq %r9, (%rdi)
incq %r8
addq $0x40, %rdi
jmp 0x151e
retq
// File: /workspace/github_c_makefile_star2_O2/Sigabort42[P]WoodyWoodPacker/inject.c
// Function: infect_segment
Elf64_Addr	infect_segment(t_env *env, Elf64_Addr *text_end)
{
  Elf64_Phdr	*phdr;
  Elf64_Addr	payload_vaddr;
  int		payload_len;

  payload_vaddr = 0;
  payload_len = env->sec64->sh_size;
  phdr = (Elf64_Phdr*) (env->ptr + env->elf64->e_phoff);
  for(int i=0; i < env->elf64->e_phnum; i++)
    {
      if(phdr[i].p_type == PT_LOAD && phdr[i].p_flags == (PF_R | PF_X))
	{
	  *text_end = phdr[i].p_offset + phdr[i].p_filesz;
	  payload_vaddr = phdr[i].p_vaddr + phdr[i].p_filesz;
	  env->elf64->e_entry = payload_vaddr;
	  phdr[i].p_filesz += payload_len;
	  phdr[i].p_memsz += payload_len;
	  for(int j=i+1; j < env->elf64->e_phnum; j++)
	    phdr[j].p_offset += PAGE_SZ64;
	  break;
	}
    }
  return (payload_vaddr);
}

// Assembly:
movq 0x140(%rdi), %rax
movq 0x20(%rax), %r9
movq 0x128(%rdi), %rax
movq 0x138(%rdi), %r10
movq 0x20(%r10), %rdi
leaq (%rax,%rdi), %rcx
movzwl 0x38(%r10), %edx
leaq (%rax,%rdi), %r8
addq $0x28, %r8
xorl %eax, %eax
xorl %edi, %edi
cmpq %rdi, %rdx
je 0x15ef
cmpl $0x1, -0x28(%r8)
jne 0x159d
cmpl $0x5, -0x24(%r8)
je 0x15a6
incq %rdi
addq $0x38, %r8
jmp 0x158a
movq -0x8(%r8), %rax
addq -0x20(%r8), %rax
movq %rax, (%rsi)
movq -0x8(%r8), %rsi
movq -0x18(%r8), %rax
addq %rsi, %rax
movq %rax, 0x18(%r10)
movslq %r9d, %r9
addq %r9, %rsi
movq %rsi, -0x8(%r8)
leaq 0x1(%rdi), %rsi
addq %r9, (%r8)
cmpq %rdx, %rsi
jae 0x15ef
incq %rdi
imulq $0x38, %rdi, %r8
addq %rcx, %r8
addq $0x8, %r8
incq %rsi
movl $0x2000, %r9d           # imm = 0x2000
jmp 0x15ce
retq
// File: /workspace/github_c_makefile_star2_O2/Sigabort42[P]WoodyWoodPacker/inject.c
// Function: infect
char	*infect(t_env *env, int elf_len, char* payload, int payload_len)
{
  Elf64_Addr	entry;
  Elf64_Addr	payload_vaddr;
  Elf64_Addr	text_end;
  char		*new_file;
  int		jmp_len;

  char jmp_entry[] = "\x48\xb8\x41\x41\x41\x41\x41\x41\x41\x41" //mov rax,0x4141414141414141
    "\xff\xe0"; // jmp rax
  jmp_len = 12;
  new_file = malloc(elf_len + PAGE_SZ64);
  payload_len += jmp_len;
  entry = env->elf64->e_entry;
  payload_vaddr = infect_segment(env, &text_end);
  infect_section(env, text_end, payload_vaddr);
  memcpy(&jmp_entry[2], (char*)&entry, 8);
  memcpy(new_file, env->ptr, (size_t) text_end);
  memcpy(new_file + text_end, payload, payload_len - jmp_len);
  memcpy(new_file + text_end + payload_len - jmp_len, jmp_entry, jmp_len);
  memcpy(new_file + text_end + PAGE_SZ64, env->ptr + text_end, elf_len - text_end);

  return new_file;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %ebp
movq %rdx, 0x8(%rsp)
movl %esi, %r14d
movq %rdi, %r12
leal 0x2000(%r14), %eax
movslq %eax, %rdi
callq 0x10a0
movq %rax, %rbx
movq 0x138(%r12), %rax
movq 0x18(%rax), %rax
movq %rax, (%rsp)
leaq 0x10(%rsp), %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0x1558
movq (%r13), %r13
movq %r12, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x14e8
movq 0x128(%r12), %r12
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x1090
leaq (%rbx,%r13), %r15
movslq %ebp, %rbp
movq %r15, %rdi
movq 0x8(%rsp), %rsi
movq %rbp, %rdx
callq 0x1090
movw $0xb848, (%rbp,%r15)    # imm = 0xB848
movq (%rsp), %rax
movq %rax, 0x2(%rbp,%r15)
movw $0xe0ff, 0xa(%rbp,%r15) # imm = 0xE0FF
leaq (%rbx,%r13), %rdi
addq $0x2000, %rdi           # imm = 0x2000
addq %r13, %r12
movslq %r14d, %rdx
subq %r13, %rdx
movq %r12, %rsi
callq 0x1090
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/Sigabort42[P]WoodyWoodPacker/inject.c
// Function: inject
int	inject(t_env *env)
{
  char	*new_file;
  int	fd;

  new_file = infect(env, env->buf.st_size,
  env->ptr_payload + env->sec64->sh_offset, env->sec64->sh_size);
  if ((fd = open(env->name_output, O_RDWR | O_CREAT,
  S_IRWXU | S_IRWXG | S_IRWXO)) < 0)
    return (2);
  write(fd, new_file, env->buf.st_size + PAGE_SZ64);
  return (0);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0x38(%rdi), %esi
movq 0x130(%rdi), %rdx
movq 0x140(%rdi), %rax
addq 0x18(%rax), %rdx
movl 0x20(%rax), %ecx
callq 0x15f0
movq %rax, %r14
movq (%rbx), %rdi
xorl %ebp, %ebp
pushq $0x42
popq %rsi
movl $0x1ff, %edx            # imm = 0x1FF
xorl %eax, %eax
callq 0x10c0
testl %eax, %eax
js 0x1717
movl $0x2000, %edx           # imm = 0x2000
addq 0x38(%rbx), %rdx
movl %eax, %edi
movq %r14, %rsi
callq 0x1040
jmp 0x171a
pushq $0x2
popq %rbp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/Sigabort42[P]WoodyWoodPacker/libft/ft_printf/ft_printf.c
// Function: ft_printf
int					ft_printf(const char *format, ...)
{
	t_var			var;
	va_list			ap;

	ft_init_var(&var);
	va_start(ap, format);
	if (ft_return_printf2(format, ap, &var))
		return (-1);
	if (ft_verif_wchar_nb(&var))
		return (-1);
	else if (var.type == TYPE_WCHAR && var.nb_conv && var.nb.u_i > 1114111)
	{
		var.ret = var.ret - 1 - ft_strlen(var.flags_stock) - 1;
		while (format[var.ret--] != '%')
			var.i_buf--;
		var.i_buf++;
		write(var.fd, var.buf, var.i_buf);
		ft_free(&var);
		return (-1);
	}
	va_end(ap);
	write(var.fd, var.buf, var.i_buf);
	ft_free(&var);
	return (var.i_buf);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x178, %rsp            # imm = 0x178
movq %rdi, %r14
leaq 0xc0(%rsp), %r15
movq %rsi, 0x8(%r15)
movq %rdx, 0x10(%r15)
movq %rcx, 0x18(%r15)
movq %r8, 0x20(%r15)
movq %r9, 0x28(%r15)
testb %al, %al
je 0x1a2c
movaps %xmm0, 0xf0(%rsp)
movaps %xmm1, 0x100(%rsp)
movaps %xmm2, 0x110(%rsp)
movaps %xmm3, 0x120(%rsp)
movaps %xmm4, 0x130(%rsp)
movaps %xmm5, 0x140(%rsp)
movaps %xmm6, 0x150(%rsp)
movaps %xmm7, 0x160(%rsp)
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x3c94
leaq 0xa0(%rsp), %rsi
movq %r15, 0x10(%rsi)
leaq 0x1a0(%rsp), %rax
movq %rax, 0x8(%rsi)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rsi)
movq %r14, %rdi
movq %rbx, %rdx
callq 0x3d00
pushq $-0x1
popq %rbx
testl %eax, %eax
jne 0x1b2b
movq %rsp, %rdi
callq 0x3cd4
testl %eax, %eax
jne 0x1b2b
cmpl $0x3, 0x78(%rsp)
jne 0x1ae2
cmpl $0x0, 0x98(%rsp)
je 0x1ae2
cmpl $0x110000, 0x70(%rsp)   # imm = 0x110000
jb 0x1ae2
leaq 0x18(%rsp), %r15
movl 0x44(%r15), %r12d
movq %r15, %rdi
callq 0x3d20
movl %eax, %ecx
notl %ecx
leal (%r12,%rcx), %edx
decl %edx
movl 0x48(%r15), %ecx
movslq %edx, %rdx
addq %rdx, %r14
subl %eax, %r12d
addl $-0x3, %r12d
incl %ecx
cmpb $0x25, (%r14)
je 0x1b05
leal -0x2(%rcx), %eax
movl %eax, 0x60(%rsp)
decq %r14
decl %r12d
decl %ecx
jmp 0x1acb
movq %rsp, %rbx
movl 0x94(%rbx), %edi
movq 0x8(%rbx), %rsi
movslq 0x60(%rbx), %rdx
callq 0x1040
movq %rbx, %rdi
callq 0x3c7c
movl 0x60(%rbx), %ebx
jmp 0x1b2b
movq %rsp, %r14
movl %r12d, 0x5c(%r14)
movl %ecx, 0x60(%r14)
movl 0x94(%r14), %edi
movq 0x8(%r14), %rsi
movslq %ecx, %rdx
callq 0x1040
movq %r14, %rdi
callq 0x3c7c
movl %ebx, %eax
addq $0x178, %rsp            # imm = 0x178
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/Sigabort42[P]WoodyWoodPacker/libft/ft_printf/ft_flags.c
// Function: ft_flags
int					ft_flags(char *flags, t_flags *s_flags)
{
	int				i;

	i = 0;
	if (flags[0] == 0)
		return (0);
	s_flags->c = 0;
	while (flags[i] && (!(flags[i] >= '1' && flags[i] <= '9')) &&
		flags[i] != '.' && ft_verif_mod(flags[i]))
	{
		if (flags[i] == '0')
			s_flags->c = s_flags->c | (1 << 0);
		if (flags[i] == '+')
			s_flags->c = s_flags->c | (1 << 1);
		if (flags[i] == '-')
			s_flags->c = s_flags->c | (1 << 2);
		if (flags[i] == ' ')
			s_flags->c = s_flags->c | (1 << 3);
		if (flags[i] == '#')
			s_flags->c = s_flags->c | (1 << 4);
		i++;
	}
	ft_flags2(flags, s_flags, &i);
	return (1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpb $0x0, (%rdi)
je 0x20f6
movq %rsi, %rbx
movq %rdi, %r14
movb $0x0, (%rsi)
xorl %eax, %eax
movl $0x207, %ecx            # imm = 0x207
xorl %r13d, %r13d
movb (%r14,%r13), %dl
testb %dl, %dl
je 0x1fe0
cmpb $0x2e, %dl
je 0x1fe0
leal -0x31(%rdx), %esi
cmpb $0x9, %sil
jb 0x1fe0
leal -0x68(%rdx), %esi
rorb %sil
cmpb $0x9, %sil
ja 0x1f9e
movzbl %sil, %esi
btl %esi, %ecx
jb 0x1fe0
cmpb $0x30, %dl
jne 0x1fab
orb $0x1, %al
movb %al, (%rbx)
movb (%r14,%r13), %dl
cmpb $0x2b, %dl
jne 0x1fb8
orb $0x2, %al
movb %al, (%rbx)
movb (%r14,%r13), %dl
cmpb $0x2d, %dl
jne 0x1fc5
orb $0x4, %al
movb %al, (%rbx)
movb (%r14,%r13), %dl
cmpb $0x20, %dl
jne 0x1fd2
orb $0x8, %al
movb %al, (%rbx)
movb (%r14,%r13), %dl
cmpb $0x23, %dl
jne 0x1fdb
orb $0x10, %al
movb %al, (%rbx)
incq %r13
jmp 0x1f73
leaq (%r14,%r13), %r12
movq %r12, %rdi
callq 0x3e64
xorl %ebp, %ebp
testl %eax, %eax
cmovlel %ebp, %eax
movl %eax, 0x4(%rbx)
movb (%r14,%r13), %al
addb $-0x30, %al
movl $0x0, %r15d
cmpb $0x9, %al
ja 0x2019
movq %r12, %rdi
callq 0x3e64
movslq %eax, %rdi
callq 0x4030
movl %eax, %r15d
leal (%r15,%r13), %eax
cltq
leaq (%r14,%rax), %r12
cmpb $0x2e, (%r14,%rax)
jne 0x203b
leaq 0x1(%r12), %rdi
callq 0x3e64
xorl %ebp, %ebp
testl %eax, %eax
cmovgl %eax, %ebp
movl %ebp, 0x8(%rbx)
leaq 0x1(%r12), %rdi
callq 0x3e64
movslq %eax, %rdi
callq 0x4030
xorl %ecx, %ecx
cmpb $0x2e, (%r12)
cmovel %eax, %ecx
addl %r13d, %r15d
addl %ecx, %r15d
movslq %r15d, %rax
addq %rax, %r14
movb $0x0, 0xc(%rbx)
leaq 0x311d(%rip), %rsi      # 0x518e
movq %r14, %rdi
callq 0x3df4
movb $0x1, %cl
pushq $0x1
popq %rbp
testq %rax, %rax
jne 0x20f1
leaq 0x3105(%rip), %rsi      # 0x518f
movq %r14, %rdi
callq 0x3df4
movb $0x2, %cl
testq %rax, %rax
jne 0x20f1
leaq 0x30f1(%rip), %rsi      # 0x5191
movq %r14, %rdi
callq 0x3df4
movb $0x8, %cl
testq %rax, %rax
jne 0x20f1
leaq 0x30dc(%rip), %rsi      # 0x5192
movq %r14, %rdi
callq 0x3df4
movb $0x4, %cl
testq %rax, %rax
jne 0x20f1
leaq 0x30c8(%rip), %rsi      # 0x5194
movq %r14, %rdi
callq 0x3df4
movb $0x10, %cl
testq %rax, %rax
jne 0x20f1
leaq 0x30b4(%rip), %rsi      # 0x5196
movq %r14, %rdi
callq 0x3df4
movb $0x20, %cl
testq %rax, %rax
je 0x20f8
orb %cl, 0xc(%rbx)
jmp 0x20f8
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/Sigabort42[P]WoodyWoodPacker/libft/ft_printf/ft_wchar.c
// Function: ft_wchar2
void		ft_wchar2(wchar_t chr, t_var *var, int i)
{
	if (chr > 0)
		var->i_buf -= i;
	if (chr <= 127)
		var->buf[var->i_buf++] = chr;
	else if (chr <= 2047)
	{
		var->buf[var->i_buf++] = (chr >> 6) + 192;
		var->buf[var->i_buf++] = (chr & 63) + 128;
	}
	else if (chr <= 65535)
	{
		var->buf[var->i_buf++] = (chr >> 12) + 224;
		var->buf[var->i_buf++] = ((chr >> 6) & 63) + 128;
		var->buf[var->i_buf++] = (chr & 63) + 128;
	}
	else if (chr <= 1114111)
	{
		var->buf[var->i_buf++] = (chr >> 18) + 240;
		var->buf[var->i_buf++] = ((chr >> 12) & 63) + 128;
		var->buf[var->i_buf++] = ((chr >> 6) & 63) + 128;
		var->buf[var->i_buf++] = (chr & 63) + 128;
	}
}

// Assembly:
leaq 0x60(%rsi), %rax
movl 0x60(%rsi), %ecx
testl %edi, %edi
jle 0x27f4
subl %edx, %ecx
movl %ecx, (%rax)
cmpl $0x7f, %edi
ja 0x27fd
addq $0x8, %rsi
jmp 0x28ba
cmpl $0x7ff, %edi            # imm = 0x7FF
ja 0x2825
movl %edi, %edx
shrl $0x6, %edx
orb $-0x40, %dl
movq 0x8(%rsi), %r8
leal 0x1(%rcx), %r9d
movl %r9d, 0x60(%rsi)
movslq %ecx, %rcx
movb %dl, (%r8,%rcx)
jmp 0x28ab
cmpl $0xffff, %edi           # imm = 0xFFFF
ja 0x284a
movl %edi, %edx
shrl $0xc, %edx
orb $-0x20, %dl
movq 0x8(%rsi), %r8
leal 0x1(%rcx), %r9d
movl %r9d, 0x60(%rsi)
movslq %ecx, %rcx
movb %dl, (%r8,%rcx)
jmp 0x288c
cmpl $0x10ffff, %edi         # imm = 0x10FFFF
ja 0x28c9
movl %edi, %edx
shrl $0x12, %edx
orb $-0x10, %dl
movq 0x8(%rsi), %r8
leal 0x1(%rcx), %r9d
movl %r9d, 0x60(%rsi)
movslq %ecx, %rcx
movb %dl, (%r8,%rcx)
movl %edi, %ecx
shrl $0xc, %ecx
andb $0x3f, %cl
orb $-0x80, %cl
movq 0x8(%rsi), %rdx
movslq 0x60(%rsi), %r8
leal 0x1(%r8), %r9d
movl %r9d, 0x60(%rsi)
movb %cl, (%rdx,%r8)
movl %edi, %ecx
shrl $0x6, %ecx
andb $0x3f, %cl
orb $-0x80, %cl
movq 0x8(%rsi), %rdx
movslq 0x60(%rsi), %r8
leal 0x1(%r8), %r9d
movl %r9d, 0x60(%rsi)
movb %cl, (%rdx,%r8)
movl 0x60(%rsi), %ecx
addq $0x8, %rsi
andb $0x3f, %dil
orb $-0x80, %dil
movq (%rsi), %rdx
leal 0x1(%rcx), %esi
movl %esi, (%rax)
movslq %ecx, %rax
movb %dil, (%rdx,%rax)
retq
// File: /workspace/github_c_makefile_star2_O2/Sigabort42[P]WoodyWoodPacker/libft/ft_printf/ft_wchar.c
// Function: ft_wchar
char		*ft_wchar(wchar_t chr)
{
	char	*c;

	c = ft_strnew(4);
	if (chr <= 127)
		c[0] = chr;
	else if (chr <= 2047)
	{
		c[0] = (chr >> 6) + 192;
		c[1] = (chr & 63) + 128;
	}
	else if (chr <= 65535)
	{
		c[0] = (chr >> 12) + 224;
		c[1] = ((chr >> 6) & 63) + 128;
		c[2] = (chr & 63) + 128;
	}
	else if (chr <= 1114111)
	{
		c[0] = (chr >> 18) + 240;
		c[1] = ((chr >> 12) & 63) + 128;
		c[2] = ((chr >> 6) & 63) + 128;
		c[3] = (chr & 63) + 128;
	}
	return (c);
}

// Assembly:
pushq %rbx
movl %edi, %ebx
pushq $0x4
popq %rdi
callq 0x3ec4
cmpl $0x7f, %ebx
jg 0x28de
movb %bl, (%rax)
jmp 0x295d
cmpl $0x7ff, %ebx            # imm = 0x7FF
ja 0x28fb
movl %ebx, %ecx
shrl $0x6, %ecx
orb $-0x40, %cl
movb %cl, (%rax)
andb $0x3f, %bl
orb $-0x80, %bl
movb %bl, 0x1(%rax)
jmp 0x295d
cmpl $0xffff, %ebx           # imm = 0xFFFF
ja 0x2926
movl %ebx, %ecx
shrl $0xc, %ecx
orb $-0x20, %cl
movb %cl, (%rax)
movl %ebx, %ecx
shrl $0x6, %ecx
andb $0x3f, %cl
orb $-0x80, %cl
movb %cl, 0x1(%rax)
andb $0x3f, %bl
orb $-0x80, %bl
movb %bl, 0x2(%rax)
jmp 0x295d
cmpl $0x10ffff, %ebx         # imm = 0x10FFFF
ja 0x295d
movl %ebx, %ecx
shrl $0x12, %ecx
orb $-0x10, %cl
movb %cl, (%rax)
movl %ebx, %ecx
shrl $0xc, %ecx
andb $0x3f, %cl
orb $-0x80, %cl
movb %cl, 0x1(%rax)
movl %ebx, %ecx
shrl $0x6, %ecx
andb $0x3f, %cl
orb $-0x80, %cl
movb %cl, 0x2(%rax)
andb $0x3f, %bl
orb $-0x80, %bl
movb %bl, 0x3(%rax)
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O2/Sigabort42[P]WoodyWoodPacker/libft/ft_printf/ft_wstrlen.c
// Function: ft_wstrlen
int	ft_wstrlen(wchar_t chr)
{
	if (chr <= 0x7F)
		return (1);
	else if (chr <= 0x7FF)
		return (2);
	else if (chr <= 0xFFFF)
		return (3);
	else if (chr <= 0x10FFFF)
		return (4);
	return (0);
}

// Assembly:
cmpl $0x80, %edi
jge 0x296c
pushq $0x1
jmp 0x2982
cmpl $0x800, %edi            # imm = 0x800
jae 0x2978
pushq $0x2
jmp 0x2982
cmpl $0x10000, %edi          # imm = 0x10000
jae 0x2984
pushq $0x3
popq %rax
retq
xorl %eax, %eax
cmpl $0x110000, %edi         # imm = 0x110000
setb %al
shll $0x2, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O2/Sigabort42[P]WoodyWoodPacker/libft/ft_printf/ft_conv_envoi_maj.c
// Function: ft_conv_envoi_maj3
void	ft_conv_envoi_maj3(va_list ap, t_var *var, t_flags *s_flags, int base)
{
	if ((s_flags->m & (1 << 5)))
		ft_flags_stock(var, s_flags,
						ft_ltoa_base_maj(va_arg(ap, size_t), base));
	else
	{
		if (var->type <= TYPE_INT && s_flags->m == 0)
			ft_flags_stock(var, s_flags,
						ft_itoa_base_maj(va_arg(ap, int), base));
		else
			ft_flags_stock(var, s_flags,
					ft_lltoa_base_maj(va_arg(ap, unsigned int), base));
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movb 0xc(%rdx), %dl
testb $0x20, %dl
jne 0x29c6
movl (%rdi), %eax
testb %dl, %dl
jne 0x29dc
cmpl $0x7, 0x78(%r14)
jg 0x29dc
cmpl $0x28, %eax
ja 0x2a1e
movq %rax, %rdx
addq 0x10(%rdi), %rdx
addl $0x8, %eax
movl %eax, (%rdi)
jmp 0x2a2a
movl (%rdi), %edx
cmpq $0x28, %rdx
ja 0x29ef
movq %rdx, %rax
addq 0x10(%rdi), %rax
addl $0x8, %edx
movl %edx, (%rdi)
jmp 0x29fb
cmpl $0x28, %eax
ja 0x2a07
movq %rax, %rdx
addq 0x10(%rdi), %rdx
addl $0x8, %eax
movl %eax, (%rdi)
jmp 0x2a13
movq 0x8(%rdi), %rax
leaq 0x8(%rax), %rdx
movq %rdx, 0x8(%rdi)
movq (%rax), %rdi
movl %ecx, %esi
callq 0x41ac
jmp 0x2a33
movq 0x8(%rdi), %rdx
leaq 0x8(%rdx), %rax
movq %rax, 0x8(%rdi)
movl (%rdx), %edi
movl %ecx, %esi
callq 0x429c
jmp 0x2a33
movq 0x8(%rdi), %rdx
leaq 0x8(%rdx), %rax
movq %rax, 0x8(%rdi)
movl (%rdx), %edi
movl %ecx, %esi
callq 0x40c8
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2414
// File: /workspace/github_c_makefile_star2_O2/Sigabort42[P]WoodyWoodPacker/libft/ft_printf/ft_conv_envoi_maj.c
// Function: ft_conv_envoi_maj2
void	ft_conv_envoi_maj2(va_list ap, t_var *var, t_flags *s_flags, int base)
{
	if ((s_flags->m & (1 << 1)))
		ft_flags_stock(var, s_flags,
						ft_itoa_base_maj((short)va_arg(ap, int), base));
	else if ((s_flags->m & (1 << 2)) && (var->type >= TYPE_UNSIGNED &&
										var->type <= TYPE_HEXA_MAJ))
		ft_flags_stock(var, s_flags,
						ft_lltoa_base_maj(va_arg(ap, long long), base));
	else if ((s_flags->m & (1 << 2)))
		ft_flags_stock(var, s_flags,
						ft_ltoa_base_maj(va_arg(ap, long), base));
	else if ((s_flags->m & (1 << 4)))
		ft_flags_stock(var, s_flags,
						ft_ui_maxtoa_base_maj(va_arg(ap, uintmax_t), base));
	else if ((s_flags->m & (1 << 5)) && (var->type >= TYPE_UNSIGNED &&
										var->type <= TYPE_HEXA_MAJ))
		ft_flags_stock(var, s_flags,
						ft_ui_maxtoa_base_maj(va_arg(ap, ssize_t), base));
	else
		ft_conv_envoi_maj3(ap, var, s_flags, base);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movzbl 0xc(%rdx), %eax
testb $0x2, %al
jne 0x2a93
testb $0x4, %al
jne 0x2aa9
testb $0x10, %al
jne 0x2a76
testb $0x20, %al
je 0x2af5
movl 0x78(%r14), %eax
addl $-0x9, %eax
cmpl $0x5, %eax
ja 0x2af5
movl (%rdi), %edx
cmpq $0x28, %rdx
ja 0x2b07
movq %rdx, %rax
addq 0x10(%rdi), %rax
addl $0x8, %edx
movl %edx, (%rdi)
jmp 0x2b13
movl (%rdi), %edx
cmpq $0x28, %rdx
ja 0x2aca
movq %rdx, %rax
addq 0x10(%rdi), %rax
addl $0x8, %edx
movl %edx, (%rdi)
jmp 0x2ad6
movl 0x78(%r14), %edx
addl $-0x9, %edx
movl (%rdi), %eax
cmpl $0x5, %edx
ja 0x2ae2
cmpl $0x28, %eax
ja 0x2b1f
movq %rax, %rdx
addq 0x10(%rdi), %rdx
addl $0x8, %eax
movl %eax, (%rdi)
jmp 0x2b2b
movq 0x8(%rdi), %rax
leaq 0x8(%rax), %rdx
movq %rdx, 0x8(%rdi)
movswl (%rax), %edi
movl %ecx, %esi
callq 0x40c8
jmp 0x2b4d
cmpl $0x28, %eax
ja 0x2b37
movq %rax, %rdx
addq 0x10(%rdi), %rdx
addl $0x8, %eax
movl %eax, (%rdi)
jmp 0x2b43
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2994
movq 0x8(%rdi), %rax
leaq 0x8(%rax), %rdx
movq %rdx, 0x8(%rdi)
movq (%rax), %rdi
movl %ecx, %esi
callq 0x43fc
jmp 0x2b4d
movq 0x8(%rdi), %rdx
leaq 0x8(%rdx), %rax
movq %rax, 0x8(%rdi)
movq (%rdx), %rdi
movl %ecx, %esi
callq 0x429c
jmp 0x2b4d
movq 0x8(%rdi), %rdx
leaq 0x8(%rdx), %rax
movq %rax, 0x8(%rdi)
movq (%rdx), %rdi
movl %ecx, %esi
callq 0x41ac
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2414
// File: /workspace/github_c_makefile_star2_O2/Sigabort42[P]WoodyWoodPacker/libft/ft_printf/ft_conv_envoi_maj.c
// Function: ft_conv_envoi_maj
void	ft_conv_envoi_maj(va_list ap, t_var *var, t_flags *s_flags, int base)
{
	if ((s_flags->m & (1 << 3)) && (var->type >= TYPE_OCTAL &&
									var->type <= TYPE_HEXA_MAJ))
		ft_flags_stock(var, s_flags,
					ft_lltoa_base_maj(va_arg(ap, unsigned long long), base));
	else if ((s_flags->m & (1 << 3)))
		ft_flags_stock(var, s_flags,
					ft_ltoa_base_maj(va_arg(ap, long long), base));
	else if ((s_flags->m & (1 << 0)) && (var->type == TYPE_OCTAL_MAJ ||
										var->type == TYPE_UNSIGNED_MAJ))
		ft_flags_stock(var, s_flags,
					ft_itoa_base_maj((unsigned short)va_arg(ap, int), base));
	else if ((s_flags->m & (1 << 0)) && (var->type >= TYPE_UNSIGNED &&
										var->type <= TYPE_HEXA_MAJ))
		ft_flags_stock(var, s_flags,
					ft_itoa_base_maj((unsigned char)va_arg(ap, int), base));
	else if ((s_flags->m & (1 << 0)))
		ft_flags_stock(var, s_flags,
					ft_itoa_base_maj((char)va_arg(ap, int), base));
	else if ((s_flags->m & (1 << 1)) && (var->type >= TYPE_UNSIGNED &&
										var->type <= TYPE_HEXA_MAJ))
		ft_flags_stock(var, s_flags,
					ft_itoa_base_maj((unsigned short)va_arg(ap, int), base));
	else
		ft_conv_envoi_maj2(ap, var, s_flags, base);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movzbl 0xc(%rdx), %eax
testb $0x8, %al
je 0x2b9d
movl 0x78(%r14), %edx
addl $-0xb, %edx
cmpl $0x3, %edx
ja 0x2b9d
movl (%rdi), %edx
cmpq $0x28, %rdx
ja 0x2c3b
movq %rdx, %rax
addq 0x10(%rdi), %rax
addl $0x8, %edx
movl %edx, (%rdi)
jmp 0x2c47
testb $0x8, %al
jne 0x2be0
testb $0x1, %al
je 0x2bb3
movl 0x78(%r14), %edx
cmpl $0xc, %edx
je 0x2c25
cmpl $0xa, %edx
je 0x2c25
testb $0x1, %al
je 0x2c11
movl 0x78(%r14), %edx
addl $-0x9, %edx
cmpl $0x5, %edx
ja 0x2c11
movl (%rdi), %edx
cmpq $0x28, %rdx
ja 0x2c9d
movq %rdx, %rax
addq 0x10(%rdi), %rax
addl $0x8, %edx
movl %edx, (%rdi)
jmp 0x2ca9
movl (%rdi), %edx
cmpq $0x28, %rdx
ja 0x2bf6
movq %rdx, %rax
addq 0x10(%rdi), %rax
addl $0x8, %edx
movl %edx, (%rdi)
jmp 0x2c02
movq 0x8(%rdi), %rax
leaq 0x8(%rax), %rdx
movq %rdx, 0x8(%rdi)
movq (%rax), %rdi
movl %ecx, %esi
callq 0x41ac
jmp 0x2cb3
testb $0x1, %al
jne 0x2c53
testb $0x2, %al
je 0x2c7a
movl 0x78(%r14), %eax
addl $-0x9, %eax
cmpl $0x5, %eax
ja 0x2c7a
movl (%rdi), %edx
cmpq $0x28, %rdx
ja 0x2c69
movq %rdx, %rax
addq 0x10(%rdi), %rax
addl $0x8, %edx
movl %edx, (%rdi)
jmp 0x2c75
movq 0x8(%rdi), %rax
leaq 0x8(%rax), %rdx
movq %rdx, 0x8(%rdi)
movq (%rax), %rdi
movl %ecx, %esi
callq 0x429c
jmp 0x2cb3
movl (%rdi), %edx
cmpq $0x28, %rdx
ja 0x2c8c
movq %rdx, %rax
addq 0x10(%rdi), %rax
addl $0x8, %edx
movl %edx, (%rdi)
jmp 0x2c98
movq 0x8(%rdi), %rax
leaq 0x8(%rax), %rdx
movq %rdx, 0x8(%rdi)
movzwl (%rax), %edi
jmp 0x2cac
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2a48
movq 0x8(%rdi), %rax
leaq 0x8(%rax), %rdx
movq %rdx, 0x8(%rdi)
movsbl (%rax), %edi
jmp 0x2cac
movq 0x8(%rdi), %rax
leaq 0x8(%rax), %rdx
movq %rdx, 0x8(%rdi)
movzbl (%rax), %edi
movl %ecx, %esi
callq 0x40c8
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2414
// File: /workspace/github_c_makefile_star2_O2/Sigabort42[P]WoodyWoodPacker/libft/ft_printf/ft_conv_envoi.c
// Function: ft_conv_envoi3
void	ft_conv_envoi3(va_list ap, t_var *var, t_flags *s_flags, int base)
{
	if ((s_flags->m & (1 << 5)) && (var->type >= TYPE_UNSIGNED &&
					var->type <= TYPE_HEXA_MAJ))
		ft_flags_stock(var, s_flags,
			ft_ui_maxtoa_base(va_arg(ap, ssize_t), base));
	else if ((s_flags->m & (1 << 5)))
		ft_flags_stock(var, s_flags,
			ft_ltoa_base(va_arg(ap, ssize_t), base));
	else
	{
		if (var->type <= TYPE_INT && s_flags->m == 0)
			ft_flags_stock(var, s_flags,
				ft_itoa_base(va_arg(ap, int), base));
		else
			ft_flags_stock(var, s_flags,
				ft_lltoa_base(va_arg(ap, unsigned int), base));
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movb 0xc(%rdx), %al
movl 0x78(%rsi), %edx
testb $0x20, %al
jne 0x2d02
cmpl $0x8, %edx
setge %dl
testb %al, %al
setne %sil
movl (%rdi), %eax
orb %dl, %sil
jne 0x2d1f
cmpl $0x28, %eax
ja 0x2d45
movq %rax, %rdx
addq 0x10(%rdi), %rdx
addl $0x8, %eax
movl %eax, (%rdi)
jmp 0x2d51
addl $-0x9, %edx
movl (%rdi), %eax
cmpl $0x5, %edx
ja 0x2d32
cmpl $0x28, %eax
ja 0x2d5c
movq %rax, %rdx
addq 0x10(%rdi), %rdx
addl $0x8, %eax
movl %eax, (%rdi)
jmp 0x2d68
cmpl $0x28, %eax
ja 0x2d74
movq %rax, %rdx
addq 0x10(%rdi), %rdx
addl $0x8, %eax
movl %eax, (%rdi)
jmp 0x2d80
cmpl $0x28, %eax
ja 0x2d8b
movq %rax, %rdx
addq 0x10(%rdi), %rdx
addl $0x8, %eax
movl %eax, (%rdi)
jmp 0x2d97
movq 0x8(%rdi), %rdx
leaq 0x8(%rdx), %rax
movq %rax, 0x8(%rdi)
movl (%rdx), %edi
movl %ecx, %esi
callq 0x405c
jmp 0x2da1
movq 0x8(%rdi), %rdx
leaq 0x8(%rdx), %rax
movq %rax, 0x8(%rdi)
movq (%rdx), %rdi
movl %ecx, %esi
callq 0x438c
jmp 0x2da1
movq 0x8(%rdi), %rdx
leaq 0x8(%rdx), %rax
movq %rax, 0x8(%rdi)
movl (%rdx), %edi
movl %ecx, %esi
callq 0x4224
jmp 0x2da1
movq 0x8(%rdi), %rdx
leaq 0x8(%rdx), %rax
movq %rax, 0x8(%rdi)
movq (%rdx), %rdi
movl %ecx, %esi
callq 0x4134
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2414
// File: /workspace/github_c_makefile_star2_O2/Sigabort42[P]WoodyWoodPacker/libft/ft_printf/ft_conv_envoi.c
// Function: ft_conv_envoi2
void	ft_conv_envoi2(va_list ap, t_var *var, t_flags *s_flags, int base)
{
	if ((s_flags->m & (1 << 1)))
		ft_flags_stock(var, s_flags, ft_itoa_base((short)va_arg(ap, int),
							base));
	else if ((s_flags->m & (1 << 2)) && (var->type >= TYPE_UNSIGNED &&
					var->type <= TYPE_HEXA_MAJ))
		ft_flags_stock(var, s_flags, ft_lltoa_base(va_arg(ap, long long),
						base));
	else if ((s_flags->m & (1 << 2)))
		ft_flags_stock(var, s_flags, ft_ltoa_base(va_arg(ap, long long),
						base));
	else if ((s_flags->m & (1 << 4)) && (var->type >= TYPE_UNSIGNED &&
						var->type <= TYPE_HEXA_MAJ))
		ft_flags_stock(var, s_flags, ft_ui_maxtoa_base(va_arg(ap, uintmax_t),
						base));
	else if ((s_flags->m & (1 << 4)))
		ft_flags_stock(var, s_flags, ft_i_maxtoa_base(va_arg(ap, intmax_t),
						base));
	else
		ft_conv_envoi3(ap, var, s_flags, base);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movzbl 0xc(%rdx), %eax
testb $0x2, %al
jne 0x2dfd
testb $0x4, %al
jne 0x2e13
testb $0x10, %al
je 0x2e5f
movl 0x78(%r14), %edx
addl $-0x9, %edx
cmpl $0x5, %edx
ja 0x2e5f
movl (%rdi), %edx
cmpq $0x28, %rdx
ja 0x2eec
movq %rdx, %rax
addq 0x10(%rdi), %rax
addl $0x8, %edx
movl %edx, (%rdi)
jmp 0x2ef8
movl (%rdi), %edx
cmpq $0x28, %rdx
ja 0x2e34
movq %rdx, %rax
addq 0x10(%rdi), %rax
addl $0x8, %edx
movl %edx, (%rdi)
jmp 0x2e40
movl 0x78(%r14), %edx
addl $-0x9, %edx
movl (%rdi), %eax
cmpl $0x5, %edx
ja 0x2e75
cmpl $0x28, %eax
ja 0x2e9e
movq %rax, %rdx
addq 0x10(%rdi), %rdx
addl $0x8, %eax
movl %eax, (%rdi)
jmp 0x2eaa
movq 0x8(%rdi), %rax
leaq 0x8(%rax), %rdx
movq %rdx, 0x8(%rdi)
movswl (%rax), %edi
movl %ecx, %esi
callq 0x405c
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2414
testb $0x10, %al
jne 0x2e88
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2cc8
cmpl $0x28, %eax
ja 0x2eb6
movq %rax, %rdx
addq 0x10(%rdi), %rdx
addl $0x8, %eax
movl %eax, (%rdi)
jmp 0x2ec2
movl (%rdi), %edx
cmpq $0x28, %rdx
ja 0x2ed1
movq %rdx, %rax
addq 0x10(%rdi), %rax
addl $0x8, %edx
movl %edx, (%rdi)
jmp 0x2edd
movq 0x8(%rdi), %rdx
leaq 0x8(%rdx), %rax
movq %rax, 0x8(%rdi)
movq (%rdx), %rdi
movl %ecx, %esi
callq 0x4224
jmp 0x2e4a
movq 0x8(%rdi), %rdx
leaq 0x8(%rdx), %rax
movq %rax, 0x8(%rdi)
movq (%rdx), %rdi
movl %ecx, %esi
callq 0x4134
jmp 0x2e4a
movq 0x8(%rdi), %rax
leaq 0x8(%rax), %rdx
movq %rdx, 0x8(%rdi)
movq (%rax), %rdi
movl %ecx, %esi
callq 0x4314
jmp 0x2e4a
movq 0x8(%rdi), %rax
leaq 0x8(%rax), %rdx
movq %rdx, 0x8(%rdi)
movq (%rax), %rdi
movl %ecx, %esi
callq 0x438c
jmp 0x2e4a