LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/Seclabs-htc[P]slip39/trezor-crypto/sha2.c
// Function: sha512_End
char *sha512_End(SHA512_CTX* context, char buffer[]) {
	sha2_byte	digest[SHA512_DIGEST_LENGTH], *d = digest;
	int		i;

	if (buffer != (char*)0) {
		sha512_Final(context, digest);

		for (i = 0; i < SHA512_DIGEST_LENGTH; i++) {
			*buffer++ = sha2_hex_digits[(*d & 0xf0) >> 4];
			*buffer++ = sha2_hex_digits[*d & 0x0f];
			d++;
		}
		*buffer = (char)0;
	} else {
		memzero(context, sizeof(SHA512_CTX));
	}
	memzero(digest, SHA512_DIGEST_LENGTH);
	return buffer;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x50(%rbp), %rax
movq %rax, -0x58(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xaf23
movq -0x8(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0xab50
movl $0x0, -0x5c(%rbp)
cmpl $0x40, -0x5c(%rbp)
jge 0xaf1a
movq 0xd1bc(%rip), %rax      # 0x18070
movq -0x58(%rbp), %rcx
movzbl (%rcx), %ecx
andl $0xf0, %ecx
sarl $0x4, %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %cl
movq -0x10(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rbp)
movb %cl, (%rax)
movq 0xd18e(%rip), %rax      # 0x18070
movq -0x58(%rbp), %rcx
movzbl (%rcx), %ecx
andl $0xf, %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %cl
movq -0x10(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rbp)
movb %cl, (%rax)
movq -0x58(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x58(%rbp)
movl -0x5c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x5c(%rbp)
jmp 0xaea7
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
jmp 0xaf31
movq -0x8(%rbp), %rdi
movl $0xd0, %esi
callq 0x81c0
leaq -0x50(%rbp), %rdi
movl $0x40, %esi
callq 0x81c0
movq -0x10(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Seclabs-htc[P]slip39/trezor-crypto/sha2.c
// Function: sha512_Raw
void sha512_Raw(const sha2_byte* data, size_t len, uint8_t digest[SHA512_DIGEST_LENGTH]) {
	SHA512_CTX	context;
	sha512_Init(&context);
	sha512_Update(&context, data, len);
	sha512_Final(&context, digest);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0xe8(%rbp), %rdi
callq 0xa250
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq -0xe8(%rbp), %rdi
callq 0xa7b0
movq -0x18(%rbp), %rsi
leaq -0xe8(%rbp), %rdi
callq 0xab50
addq $0xf0, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Seclabs-htc[P]slip39/trezor-crypto/sha2.c
// Function: sha512_Data
char* sha512_Data(const sha2_byte* data, size_t len, char digest[SHA512_DIGEST_STRING_LENGTH]) {
	SHA512_CTX	context;

	sha512_Init(&context);
	sha512_Update(&context, data, len);
	return sha512_End(&context, digest);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0xe8(%rbp), %rdi
callq 0xa250
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq -0xe8(%rbp), %rdi
callq 0xa7b0
movq -0x18(%rbp), %rsi
leaq -0xe8(%rbp), %rdi
callq 0xae70
addq $0xf0, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Seclabs-htc[P]slip39/trezor-crypto/hmac.c
// Function: hmac_sha256_Init
void hmac_sha256_Init(HMAC_SHA256_CTX *hctx, const uint8_t *key,
                      const uint32_t keylen) {
  static CONFIDENTIAL uint8_t i_key_pad[SHA256_BLOCK_LENGTH];
  memzero(i_key_pad, SHA256_BLOCK_LENGTH);
  if (keylen > SHA256_BLOCK_LENGTH) {
    sha256_Raw(key, keylen, i_key_pad);
  } else {
    memcpy(i_key_pad, key, keylen);
  }
  for (int i = 0; i < SHA256_BLOCK_LENGTH; i++) {
    hctx->o_key_pad[i] = i_key_pad[i] ^ 0x5c;
    i_key_pad[i] ^= 0x36;
  }
  sha256_Init(&(hctx->ctx));
  sha256_Update(&(hctx->ctx), i_key_pad, SHA256_BLOCK_LENGTH);
  memzero(i_key_pad, sizeof(i_key_pad));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
leaq 0xfd56(%rip), %rdi      # 0x1ad60
movl $0x40, %esi
callq 0x81c0
cmpl $0x40, -0x14(%rbp)
jbe 0xb031
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
leaq 0xfd36(%rip), %rdx      # 0x1ad60
callq 0xa1b0
jmp 0xb046
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %eax
movl %eax, %edx
leaq 0xfd1f(%rip), %rdi      # 0x1ad60
callq 0x8090
movl $0x0, -0x18(%rbp)
cmpl $0x40, -0x18(%rbp)
jge 0xb09b
movslq -0x18(%rbp), %rcx
leaq 0xfd02(%rip), %rax      # 0x1ad60
movzbl (%rax,%rcx), %eax
xorl $0x5c, %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb %dl, (%rax,%rcx)
movslq -0x18(%rbp), %rcx
leaq 0xfce3(%rip), %rax      # 0x1ad60
movzbl (%rax,%rcx), %eax
xorl $0x36, %eax
movb %al, %dl
leaq 0xfcd3(%rip), %rax      # 0x1ad60
movb %dl, (%rax,%rcx)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xb04d
movq -0x8(%rbp), %rdi
addq $0x40, %rdi
callq 0x9750
movq -0x8(%rbp), %rdi
addq $0x40, %rdi
leaq 0xfca9(%rip), %rsi      # 0x1ad60
movl $0x40, %edx
callq 0x9bd0
leaq 0xfc98(%rip), %rdi      # 0x1ad60
movl $0x40, %esi
callq 0x81c0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Seclabs-htc[P]slip39/trezor-crypto/hmac.c
// Function: hmac_sha256_Final
void hmac_sha256_Final(HMAC_SHA256_CTX *hctx, uint8_t *hmac) {
  sha256_Final(&(hctx->ctx), hmac);
  sha256_Init(&(hctx->ctx));
  sha256_Update(&(hctx->ctx), hctx->o_key_pad, SHA256_BLOCK_LENGTH);
  sha256_Update(&(hctx->ctx), hmac, SHA256_DIGEST_LENGTH);
  sha256_Final(&(hctx->ctx), hmac);
  memzero(hctx, sizeof(HMAC_SHA256_CTX));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
addq $0x40, %rdi
movq -0x10(%rbp), %rsi
callq 0x9e60
movq -0x8(%rbp), %rdi
addq $0x40, %rdi
callq 0x9750
movq -0x8(%rbp), %rdi
addq $0x40, %rdi
movq -0x8(%rbp), %rsi
movl $0x40, %edx
callq 0x9bd0
movq -0x8(%rbp), %rdi
addq $0x40, %rdi
movq -0x10(%rbp), %rsi
movl $0x20, %edx
callq 0x9bd0
movq -0x8(%rbp), %rdi
addq $0x40, %rdi
movq -0x10(%rbp), %rsi
callq 0x9e60
movq -0x8(%rbp), %rdi
movl $0xa8, %esi
callq 0x81c0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Seclabs-htc[P]slip39/trezor-crypto/hmac.c
// Function: hmac_sha256
void hmac_sha256(const uint8_t *key, const uint32_t keylen, const uint8_t *msg,
                 const uint32_t msglen, uint8_t *hmac) {
  static CONFIDENTIAL HMAC_SHA256_CTX hctx;
  hmac_sha256_Init(&hctx, key, keylen);
  hmac_sha256_Update(&hctx, msg, msglen);
  hmac_sha256_Final(&hctx, hmac);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rsi
movl -0xc(%rbp), %edx
leaq 0xfbe8(%rip), %rdi      # 0x1ada0
callq 0xaff0
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
leaq 0xfbd5(%rip), %rdi      # 0x1ada0
callq 0xb0e0
movq -0x28(%rbp), %rsi
leaq 0xfbc5(%rip), %rdi      # 0x1ada0
callq 0xb110
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Seclabs-htc[P]slip39/trezor-crypto/hmac.c
// Function: hmac_sha512_Init
void hmac_sha512_Init(HMAC_SHA512_CTX *hctx, const uint8_t *key,
                      const uint32_t keylen) {
  static CONFIDENTIAL uint8_t i_key_pad[SHA512_BLOCK_LENGTH];
  memzero(i_key_pad, SHA512_BLOCK_LENGTH);
  if (keylen > SHA512_BLOCK_LENGTH) {
    sha512_Raw(key, keylen, i_key_pad);
  } else {
    memcpy(i_key_pad, key, keylen);
  }
  for (int i = 0; i < SHA512_BLOCK_LENGTH; i++) {
    hctx->o_key_pad[i] = i_key_pad[i] ^ 0x5c;
    i_key_pad[i] ^= 0x36;
  }
  sha512_Init(&(hctx->ctx));
  sha512_Update(&(hctx->ctx), i_key_pad, SHA512_BLOCK_LENGTH);
  memzero(i_key_pad, sizeof(i_key_pad));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
leaq 0xfb76(%rip), %rdi      # 0x1af00
movl $0x80, %esi
callq 0x81c0
cmpl $0x80, -0x14(%rbp)
jbe 0xb3b4
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
leaq 0xfb53(%rip), %rdx      # 0x1af00
callq 0xaf50
jmp 0xb3c9
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %eax
movl %eax, %edx
leaq 0xfb3c(%rip), %rdi      # 0x1af00
callq 0x8090
movl $0x0, -0x18(%rbp)
cmpl $0x80, -0x18(%rbp)
jge 0xb421
movslq -0x18(%rbp), %rcx
leaq 0xfb1c(%rip), %rax      # 0x1af00
movzbl (%rax,%rcx), %eax
xorl $0x5c, %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb %dl, (%rax,%rcx)
movslq -0x18(%rbp), %rcx
leaq 0xfafd(%rip), %rax      # 0x1af00
movzbl (%rax,%rcx), %eax
xorl $0x36, %eax
movb %al, %dl
leaq 0xfaed(%rip), %rax      # 0x1af00
movb %dl, (%rax,%rcx)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xb3d0
movq -0x8(%rbp), %rdi
addq $0x80, %rdi
callq 0xa250
movq -0x8(%rbp), %rdi
addq $0x80, %rdi
leaq 0xfabd(%rip), %rsi      # 0x1af00
movl $0x80, %edx
callq 0xa7b0
leaq 0xfaac(%rip), %rdi      # 0x1af00
movl $0x80, %esi
callq 0x81c0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Seclabs-htc[P]slip39/trezor-crypto/hmac.c
// Function: hmac_sha512_Final
void hmac_sha512_Final(HMAC_SHA512_CTX *hctx, uint8_t *hmac) {
  sha512_Final(&(hctx->ctx), hmac);
  sha512_Init(&(hctx->ctx));
  sha512_Update(&(hctx->ctx), hctx->o_key_pad, SHA512_BLOCK_LENGTH);
  sha512_Update(&(hctx->ctx), hmac, SHA512_DIGEST_LENGTH);
  sha512_Final(&(hctx->ctx), hmac);
  memzero(hctx, sizeof(HMAC_SHA512_CTX));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
addq $0x80, %rdi
movq -0x10(%rbp), %rsi
callq 0xab50
movq -0x8(%rbp), %rdi
addq $0x80, %rdi
callq 0xa250
movq -0x8(%rbp), %rdi
addq $0x80, %rdi
movq -0x8(%rbp), %rsi
movl $0x80, %edx
callq 0xa7b0
movq -0x8(%rbp), %rdi
addq $0x80, %rdi
movq -0x10(%rbp), %rsi
movl $0x40, %edx
callq 0xa7b0
movq -0x8(%rbp), %rdi
addq $0x80, %rdi
movq -0x10(%rbp), %rsi
callq 0xab50
movq -0x8(%rbp), %rdi
movl $0x150, %esi            # imm = 0x150
callq 0x81c0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Seclabs-htc[P]slip39/trezor-crypto/hmac.c
// Function: hmac_sha512
void hmac_sha512(const uint8_t *key, const uint32_t keylen, const uint8_t *msg,
                 const uint32_t msglen, uint8_t *hmac) {
  HMAC_SHA512_CTX hctx;
  hmac_sha512_Init(&hctx, key, keylen);
  hmac_sha512_Update(&hctx, msg, msglen);
  hmac_sha512_Final(&hctx, hmac);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x180, %rsp            # imm = 0x180
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rsi
movl -0xc(%rbp), %edx
leaq -0x178(%rbp), %rdi
callq 0xb370
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
leaq -0x178(%rbp), %rdi
callq 0xb470
movq -0x28(%rbp), %rsi
leaq -0x178(%rbp), %rdi
callq 0xb4b0
addq $0x180, %rsp            # imm = 0x180
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Seclabs-htc[P]slip39/trezor-crypto/rand.c
// Function: random_buffer
void __attribute__((weak)) random_buffer(uint8_t *buf, size_t len) {
  uint32_t r = 0;
  for (size_t i = 0; i < len; i++) {
    if (i % 4 == 0) {
      r = random32();
    }
    buf[i] = (r >> ((i % 4) * 8)) & 0xFF;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0xb830
movq -0x20(%rbp), %rax
andq $0x3, %rax
cmpq $0x0, %rax
jne 0xb7ff
callq 0xb790
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x20(%rbp), %rcx
andq $0x3, %rcx
shlq $0x3, %rcx
shrl %cl, %eax
andl $0xff, %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xb7df
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Seclabs-htc[P]slip39/trezor-crypto/rand.c
// Function: random_permute
void random_permute(char *str, size_t len) {
  for (int i = len - 1; i >= 1; i--) {
    int j = random_uniform(i + 1);
    char t = str[j];
    str[j] = str[i];
    str[i] = t;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
subq $0x1, %rax
movl %eax, -0x14(%rbp)
cmpl $0x1, -0x14(%rbp)
jl 0xb8fc
movl -0x14(%rbp), %edi
addl $0x1, %edi
callq 0xb840
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x19(%rbp)
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb %dl, (%rax,%rcx)
movb -0x19(%rbp), %dl
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xb8ab
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Seclabs-htc[P]slip39/slip39.c
// Function: rs1024_verify_checksum
static int rs1024_verify_checksum(uint32_t *val, int val_len)
{
    int i;
    RS1024_CTX ctx;
    uint32_t cs[8], sum;

    _rs1024_polymod_init(&ctx);
    for (i = 0; i < strlen(CUSTOMIZATION_STRING); i++)
        cs[i] = CUSTOMIZATION_STRING[i];

    _rs1024_polymod_update(&ctx, cs, strlen(CUSTOMIZATION_STRING));
    _rs1024_polymod_update(&ctx, val, val_len);
    _rs1024_polymod_final(&ctx, &sum);

    return (sum == 1)? 0: -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq -0x14(%rbp), %rdi
callq 0xdc20
movl $0x0, -0x10(%rbp)
movslq -0x10(%rbp), %rax
cmpq $0x6, %rax
jae 0xcedb
movslq -0x10(%rbp), %rcx
leaq 0x25b9(%rip), %rax      # 0xf47d
movsbl (%rax,%rcx), %ecx
movslq -0x10(%rbp), %rax
movl %ecx, -0x40(%rbp,%rax,4)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xceaf
leaq -0x40(%rbp), %rsi
leaq -0x14(%rbp), %rdi
movl $0x6, %edx
callq 0xdc40
movq -0x8(%rbp), %rsi
movl -0xc(%rbp), %edx
leaq -0x14(%rbp), %rdi
callq 0xdc40
leaq -0x14(%rbp), %rdi
leaq -0x44(%rbp), %rsi
callq 0xdd00
movl -0x44(%rbp), %edx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
xorl %ecx, %ecx
cmpl $0x1, %edx
cmovel %ecx, %eax
addq $0x50, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Seclabs-htc[P]slip39/slip39.c
// Function: recover_secret
static int _recover_secret(uint8_t t, int sl, uint8_t *gsi, const uint8_t **gs, uint8_t *result)
{
    int i, j;
    uint8_t shared_secret[sl];
    uint8_t digest_share[sl];
    uint8_t hash[SHA256_DIGEST_LENGTH];

    if (t == 1)
    {
        memcpy(result, gs[0], sl);
        return 0;
    }

    if (!shamir_interpolate(shared_secret, SECRET_INDEX, gsi, gs, t, sl))
        return -1;
    if (!shamir_interpolate(digest_share, DIGEST_INDEX, gsi, gs, t, sl))
        return -2;

    /* check digest_share hash */
    hmac_sha256(&digest_share[DIGEST_LENGTH_BYTES], sl - DIGEST_LENGTH_BYTES, shared_secret, sl, hash);
    if(memcmp(digest_share, hash, DIGEST_LENGTH_BYTES) != 0)
        return -3;  // digest error

    memcpy(result, shared_secret, sl);

    memzero(shared_secret, sl);
    memzero(digest_share, sl);

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movb %dil, %al
movb %al, -0x5(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl -0xc(%rbp), %eax
movq %rsp, %rcx
movq %rcx, -0x38(%rbp)
movq %rax, %rdx
addq $0xf, %rdx
andq $-0x10, %rdx
movq %rsp, %rcx
subq %rdx, %rcx
movq %rcx, -0x88(%rbp)
movq %rcx, %rsp
movq %rax, -0x40(%rbp)
movl -0xc(%rbp), %eax
movq %rax, %rdx
addq $0xf, %rdx
andq $-0x10, %rdx
movq %rsp, %rcx
subq %rdx, %rcx
movq %rcx, -0x80(%rbp)
movq %rcx, %rsp
movq %rax, -0x48(%rbp)
movzbl -0x5(%rbp), %eax
cmpl $0x1, %eax
jne 0xd608
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
movslq -0xc(%rbp), %rdx
callq 0x8090
movl $0x0, -0x4(%rbp)
movl $0x1, -0x74(%rbp)
jmp 0xd704
movq -0x88(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movb -0x5(%rbp), %al
movslq -0xc(%rbp), %r9
movl $0xff, %esi
movzbl %al, %r8d
callq 0xdd20
testb $0x1, %al
jne 0xd643
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl $0x1, -0x74(%rbp)
jmp 0xd704
movq -0x80(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movb -0x5(%rbp), %al
movslq -0xc(%rbp), %r9
movl $0xfe, %esi
movzbl %al, %r8d
callq 0xdd20
testb $0x1, %al
jne 0xd67b
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
movl $0x1, -0x74(%rbp)
jmp 0xd704
movq -0x80(%rbp), %rdi
movq -0x88(%rbp), %rdx
addq $0x4, %rdi
movl -0xc(%rbp), %esi
subl $0x4, %esi
movl -0xc(%rbp), %ecx
leaq -0x70(%rbp), %r8
callq 0xb190
movq -0x80(%rbp), %rax
leaq -0x70(%rbp), %rcx
movl (%rcx), %ecx
movl (%rax), %eax
subl %ecx, %eax
setne %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0xd6c5
movl $0xfffffffd, -0x4(%rbp) # imm = 0xFFFFFFFD
movl $0x1, -0x74(%rbp)
jmp 0xd704
movq -0x88(%rbp), %rsi
movq -0x28(%rbp), %rdi
movslq -0xc(%rbp), %rdx
callq 0x8090
movq -0x88(%rbp), %rdi
movslq -0xc(%rbp), %rsi
callq 0x81c0
movq -0x80(%rbp), %rdi
movslq -0xc(%rbp), %rsi
callq 0x81c0
movl $0x0, -0x4(%rbp)
movl $0x1, -0x74(%rbp)
movq -0x38(%rbp), %rax
movq %rax, %rsp
movl -0x4(%rbp), %eax
movq %rbp, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Seclabs-htc[P]slip39/slip39.c
// Function: rs1024_create_checksum
static int rs1024_create_checksum(uint32_t *val, int val_len, uint32_t *sum)
{
    int i;
    RS1024_CTX ctx;
    uint32_t cs[8];

    _rs1024_polymod_init(&ctx);
    for (i = 0; i < strlen(CUSTOMIZATION_STRING); i++)
        cs[i] = CUSTOMIZATION_STRING[i];

    _rs1024_polymod_update(&ctx, cs, strlen(CUSTOMIZATION_STRING));
    _rs1024_polymod_update(&ctx, val, val_len);
    for (i = 0; i < CHECKSUM_LENGTH_WORDS; i++)
        cs[i] = 0;

    _rs1024_polymod_update(&ctx, cs, CHECKSUM_LENGTH_WORDS);
    _rs1024_polymod_final(&ctx, sum);
    *sum ^= 1;

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xdc20
movl $0x0, -0x1c(%rbp)
movslq -0x1c(%rbp), %rax
cmpq $0x6, %rax
jae 0xdb9f
movslq -0x1c(%rbp), %rcx
leaq 0x18f5(%rip), %rax      # 0xf47d
movsbl (%rax,%rcx), %ecx
movslq -0x1c(%rbp), %rax
movl %ecx, -0x40(%rbp,%rax,4)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xdb73
leaq -0x40(%rbp), %rsi
leaq -0x20(%rbp), %rdi
movl $0x6, %edx
callq 0xdc40
movq -0x8(%rbp), %rsi
movl -0xc(%rbp), %edx
leaq -0x20(%rbp), %rdi
callq 0xdc40
movl $0x0, -0x1c(%rbp)
cmpl $0x3, -0x1c(%rbp)
jge 0xdbe5
movslq -0x1c(%rbp), %rax
movl $0x0, -0x40(%rbp,%rax,4)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xdbc8
leaq -0x40(%rbp), %rsi
leaq -0x20(%rbp), %rdi
movl $0x3, %edx
callq 0xdc40
movq -0x18(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0xdd00
movq -0x18(%rbp), %rax
movl (%rax), %ecx
xorl $0x1, %ecx
movl %ecx, (%rax)
xorl %eax, %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Seclabs-htc[P]slip39/slip39.c
// Function: rs1024_polymod_update
static void _rs1024_polymod_update(RS1024_CTX* c, uint32_t *val, int val_len)
{
    uint32_t b, v;
    int i, j;
    static uint32_t GEN[] = {
        0x00E0E040,
        0x01C1C080,
        0x03838100,
        0x07070200,
        0x0E0E0009,
        0x1C0C2412,
        0x38086C24,
        0x3090FC48,
        0x21B1F890,
        0x03F3F120,
    };

    for (j = 0; j < val_len; j++)
    {
        v = *val++;
        b = c->c >> 20;
        c->c = (c->c & 0xFFFFF) << 10 ^ v;
        for (i = 0; i < 10; i++)
            if ((b >> i) & 1)
                c->c ^= GEN[i];
            else
                c->c ^= 0;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0xdcf7
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, -0x10(%rbp)
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
shrl $0x14, %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
andl $0xfffff, %ecx          # imm = 0xFFFFF
shll $0xa, %ecx
xorl -0x1c(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movl $0x0, -0x20(%rbp)
cmpl $0xa, -0x20(%rbp)
jge 0xdce7
movl -0x18(%rbp), %eax
movl -0x20(%rbp), %ecx
shrl %cl, %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0xdccf
movslq -0x20(%rbp), %rcx
leaq 0xa3be(%rip), %rax      # 0x18080
movl (%rax,%rcx,4), %ecx
movq -0x8(%rbp), %rax
xorl (%rax), %ecx
movl %ecx, (%rax)
jmp 0xdcda
movq -0x8(%rbp), %rax
movl (%rax), %ecx
xorl $0x0, %ecx
movl %ecx, (%rax)
jmp 0xdcdc
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xdca1
jmp 0xdce9
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xdc56
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Seclabs-htc[P]slip39/misc.c
// Function: memscpy
size_t memscpy(void *d, size_t ds, const void *s, size_t ss)
{
    size_t cs;

    cs = (ds < ss) ? ds : ss;
    memcpy(d, s, cs);

    return cs;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0xe35c
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0xe364
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x8090
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Cloudef[P]dwm-fork/dwm.c
// Function: wintomenu
menu_t*
wintomenu( Window win )
{
   menu_t *m;

   if(!menu) return(NULL);
   for( m = menu; m; m = m->next )
      if(m->win == win) return(m);

   return(NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
cmpq $0x0, 0x12d40(%rip)     # 0x18610
jne 0x58dc
movq $0x0, -0x8(%rbp)
jmp 0x591d
movq 0x12d2d(%rip), %rax     # 0x18610
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x5915
movq -0x18(%rbp), %rax
movq (%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x5905
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x591d
jmp 0x5907
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x58e7
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Cloudef[P]dwm-fork/dwm.c
// Function: ctxtomenu
menu_t*
ctxtomenu( const menuCtx *ctx )
{
   menu_t *m;

   if(!menu) return(NULL);
   for( m = menu; m; m = m->next )
      if(m->ctx == ctx) return(m);

   return(NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
cmpq $0x0, 0x12cd0(%rip)     # 0x18610
jne 0x594c
movq $0x0, -0x8(%rbp)
jmp 0x598e
movq 0x12cbd(%rip), %rax     # 0x18610
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x5986
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x5976
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x598e
jmp 0x5978
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x5957
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Cloudef[P]dwm-fork/dwm.c
// Function: main
int
main(int argc, char *argv[]) {
   Bool autostart = True;
   if(argc == 2)
   {
      if(!strcmp("-v", argv[1]))
         die("dwm-fork - "VERSION"\n"COMMIT"\n");
      else if(!strcmp("-r", argv[1]))
         autostart = False;
   }
   else if(argc != 1)
      die("usage: dwm [-v][-r]\n");
   if(!setlocale(LC_CTYPE, "") || !XSupportsLocale())
      fputs("warning: no locale support\n", stderr);
   if(!(dpy = XOpenDisplay(NULL)))
      die("dwm: cannot open display\n");
   checkotherwm();
   setup();
   scan();
   run(autostart);
   cleanup();
   XCloseDisplay(dpy);
   return 0;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1, -0x14(%rbp)
cmpl $0x2, -0x8(%rbp)
jne 0x5a10
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0xc855(%rip), %rdi      # 0x12227
callq 0x5530
cmpl $0x0, %eax
jne 0x59ec
leaq 0xc847(%rip), %rdi      # 0x1222a
movb $0x0, %al
callq 0x5ab0
jmp 0x5a0e
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0xc886(%rip), %rdi      # 0x12281
callq 0x5530
cmpl $0x0, %eax
jne 0x5a0c
movl $0x0, -0x14(%rbp)
jmp 0x5a0e
jmp 0x5a26
cmpl $0x1, -0x8(%rbp)
je 0x5a24
leaq 0xc867(%rip), %rdi      # 0x12284
movb $0x0, %al
callq 0x5ab0
jmp 0x5a26
xorl %edi, %edi
leaq 0xcc52(%rip), %rsi      # 0x12681
callq 0x56e0
cmpq $0x0, %rax
je 0x5a44
callq 0x5290
cmpl $0x0, %eax
jne 0x5a5a
movq 0x1159d(%rip), %rax     # 0x16fe8
movq (%rax), %rsi
leaq 0xc844(%rip), %rdi      # 0x12299
callq 0x5410
xorl %eax, %eax
movl %eax, %edi
callq 0x5260
movq %rax, 0x12bae(%rip)     # 0x18618
cmpq $0x0, %rax
jne 0x5a7e
leaq 0xc83e(%rip), %rdi      # 0x122b5
movb $0x0, %al
callq 0x5ab0
callq 0x5b60
callq 0x5c00
callq 0x60a0
movl -0x14(%rbp), %edi
callq 0x6240
callq 0x63a0
movq 0x12b77(%rip), %rdi     # 0x18618
callq 0x5330
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Cloudef[P]dwm-fork/dwm.c
// Function: die
void
die(const char *errstr, ...) {
   va_list ap;

   va_start(ap, errstr);
   vfprintf(stderr, errstr, ap);
   va_end(ap);
   exit(EXIT_FAILURE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
testb %al, %al
je 0x5ae5
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %r9, -0xa8(%rbp)
movq %r8, -0xb0(%rbp)
movq %rcx, -0xb8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rsi, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x20(%rbp), %rax
leaq -0xd0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq 0x114b1(%rip), %rax     # 0x16fe8
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x5270
leaq -0x20(%rbp), %rax
movl $0x1, %edi
callq 0x5140
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Cloudef[P]dwm-fork/dwm.c
// Function: checkotherwm
void
checkotherwm(void) {
   otherwm = False;
   xerrorxlib = XSetErrorHandler(xerrorstart);

   XSelectInput(dpy, DefaultRootWindow(dpy), SubstructureRedirectMask);
   XSync(dpy, False);
   if(otherwm)
      die("dwm: another window manager is already running\n");
   XSetErrorHandler(xerror);
   XSync(dpy, False);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x0, 0x12c7a(%rip)     # 0x187e8
leaq 0x9cb(%rip), %rdi       # 0x6540
callq 0x5690
movq %rax, 0x12c6f(%rip)     # 0x187f0
movq 0x12a90(%rip), %rdi     # 0x18618
movq 0x12a89(%rip), %rax     # 0x18618
movq 0xe8(%rax), %rax
movq 0x12a7b(%rip), %rcx     # 0x18618
movslq 0xe0(%rcx), %rcx
shlq $0x7, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rsi
movl $0x100000, %edx         # imm = 0x100000
callq 0x54a0
movq 0x12a58(%rip), %rdi     # 0x18618
xorl %esi, %esi
callq 0x54d0
cmpl $0x0, 0x12c1a(%rip)     # 0x187e8
je 0x5bde
leaq 0xc6f8(%rip), %rdi      # 0x122cf
movb $0x0, %al
callq 0x5ab0
leaq 0x97b(%rip), %rdi       # 0x6560
callq 0x5690
movq 0x12a27(%rip), %rdi     # 0x18618
xorl %esi, %esi
callq 0x54d0
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Cloudef[P]dwm-fork/dwm.c
// Function: scan
void
scan(void) {
   unsigned int i, num;
   Window d1, d2, *wins = NULL;
   XWindowAttributes wa;

   if(XQueryTree(dpy, root, &d1, &d2, &wins, &num)) {
      for(i = 0; i < num; i++) {
         if(!XGetWindowAttributes(dpy, wins[i], &wa)
               || wa.override_redirect || XGetTransientForHint(dpy, wins[i], &d1))
            continue;
         if(wa.map_state == IsViewable || getstate(wins[i]) == IconicState)
            manage(wins[i], &wa);
      }
      for(i = 0; i < num; i++) { /* now the transients */
         if(!XGetWindowAttributes(dpy, wins[i], &wa))
            continue;
         if(XGetTransientForHint(dpy, wins[i], &d1)
               && (wa.map_state == IsViewable || getstate(wins[i]) == IconicState))
            manage(wins[i], &wa);
      }
      if(wins)
         XFree(wins);
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq $0x0, -0x20(%rbp)
movq 0x1255e(%rip), %rdi     # 0x18618
movq 0x1271f(%rip), %rsi     # 0x187e0
leaq -0x10(%rbp), %rdx
leaq -0x18(%rbp), %rcx
leaq -0x20(%rbp), %r8
leaq -0x8(%rbp), %r9
callq 0x5760
cmpl $0x0, %eax
je 0x622d
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
cmpl -0x8(%rbp), %eax
jae 0x6180
movq 0x1251f(%rip), %rdi     # 0x18618
movq -0x20(%rbp), %rax
movl -0x4(%rbp), %ecx
movq (%rax,%rcx,8), %rsi
leaq -0xa8(%rbp), %rdx
callq 0x5660
cmpl $0x0, %eax
je 0x613b
cmpl $0x0, -0x30(%rbp)
jne 0x613b
movq 0x124f6(%rip), %rdi     # 0x18618
movq -0x20(%rbp), %rax
movl -0x4(%rbp), %ecx
movq (%rax,%rcx,8), %rsi
leaq -0x10(%rbp), %rdx
callq 0x56c0
cmpl $0x0, %eax
je 0x613d
jmp 0x6172
cmpl $0x2, -0x4c(%rbp)
je 0x6159
movq -0x20(%rbp), %rax
movl -0x4(%rbp), %ecx
movq (%rax,%rcx,8), %rdi
callq 0x10fb0
cmpq $0x3, %rax
jne 0x6170
movq -0x20(%rbp), %rax
movl -0x4(%rbp), %ecx
movq (%rax,%rcx,8), %rdi
leaq -0xa8(%rbp), %rsi
callq 0xfa00
jmp 0x6172
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x60e6
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
cmpl -0x8(%rbp), %eax
jae 0x621b
movq 0x1247e(%rip), %rdi     # 0x18618
movq -0x20(%rbp), %rax
movl -0x4(%rbp), %ecx
movq (%rax,%rcx,8), %rsi
leaq -0xa8(%rbp), %rdx
callq 0x5660
cmpl $0x0, %eax
jne 0x61b8
jmp 0x620d
movq 0x12459(%rip), %rdi     # 0x18618
movq -0x20(%rbp), %rax
movl -0x4(%rbp), %ecx
movq (%rax,%rcx,8), %rsi
leaq -0x10(%rbp), %rdx
callq 0x56c0
cmpl $0x0, %eax
je 0x620b
cmpl $0x2, -0x4c(%rbp)
je 0x61f4
movq -0x20(%rbp), %rax
movl -0x4(%rbp), %ecx
movq (%rax,%rcx,8), %rdi
callq 0x10fb0
cmpq $0x3, %rax
jne 0x620b
movq -0x20(%rbp), %rax
movl -0x4(%rbp), %ecx
movq (%rax,%rcx,8), %rdi
leaq -0xa8(%rbp), %rsi
callq 0xfa00
jmp 0x620d
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x6187
cmpq $0x0, -0x20(%rbp)
je 0x622b
movq -0x20(%rbp), %rdi
callq 0x5070
jmp 0x622d
addq $0xb0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Cloudef[P]dwm-fork/dwm.c
// Function: run
void
run(Bool autostart) {
   XEvent ev;
   char *XDG_CONFIG_HOME;
   char AUTOSTART[PATH_MAX];

   /* main event loop */
   XSync(dpy, False);

   if(autostart)
   {
      XDG_CONFIG_HOME = getenv("XDG_CONFIG_HOME");
      if(!XDG_CONFIG_HOME)
      {
         XDG_CONFIG_HOME = getenv("HOME");
         snprintf( AUTOSTART, PATH_MAX, "%s/.config/dwm/autostart", XDG_CONFIG_HOME );
      }
      else
      {
         snprintf( AUTOSTART, PATH_MAX, "%s/dwm/autostart", XDG_CONFIG_HOME );
      }
      if(strlen(AUTOSTART))
      {
         const char* spwncmd[] = { AUTOSTART, NULL };
         spawn(&((Arg){ .v = spwncmd }));
      }
   }

   while(running && !XNextEvent(dpy, &ev)) {
      if(handler[ev.type])
         handler[ev.type](&ev); /* call handler */
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10f0, %rsp           # imm = 0x10F0
movl %edi, -0x4(%rbp)
movq 0x123c3(%rip), %rdi     # 0x18618
xorl %esi, %esi
callq 0x54d0
cmpl $0x0, -0x4(%rbp)
je 0x6321
leaq 0xcece(%rip), %rdi      # 0x1313b
callq 0x5490
movq %rax, -0xd0(%rbp)
cmpq $0x0, -0xd0(%rbp)
jne 0x62b9
leaq 0xcebc(%rip), %rdi      # 0x13146
callq 0x5490
movq %rax, -0xd0(%rbp)
leaq -0x10d0(%rbp), %rdi
movq -0xd0(%rbp), %rcx
movl $0x1000, %esi           # imm = 0x1000
leaq 0xce9b(%rip), %rdx      # 0x1314b
movb $0x0, %al
callq 0x50b0
jmp 0x62da
leaq -0x10d0(%rbp), %rdi
movq -0xd0(%rbp), %rcx
movl $0x1000, %esi           # imm = 0x1000
leaq 0xce91(%rip), %rdx      # 0x13164
movb $0x0, %al
callq 0x50b0
leaq -0x10d0(%rbp), %rdi
callq 0x52d0
cmpq $0x0, %rax
je 0x631f
leaq -0x10d0(%rbp), %rax
movq %rax, -0x10e0(%rbp)
movq $0x0, -0x10d8(%rbp)
leaq -0x10e0(%rbp), %rax
movq %rax, -0x10e8(%rbp)
leaq -0x10e8(%rbp), %rdi
callq 0xa3b0
jmp 0x6321
jmp 0x6323
xorl %eax, %eax
cmpl $0x0, 0x122a4(%rip)     # 0x185d0
movb %al, -0x10e9(%rbp)
je 0x6355
movq 0x122dd(%rip), %rdi     # 0x18618
leaq -0xc8(%rbp), %rsi
callq 0x53d0
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
movb %al, -0x10e9(%rbp)
movb -0x10e9(%rbp), %al
testb $0x1, %al
jne 0x6361
jmp 0x6390
movslq -0xc8(%rbp), %rcx
leaq 0x11d41(%rip), %rax     # 0x180b0
cmpq $0x0, (%rax,%rcx,8)
je 0x638e
movslq -0xc8(%rbp), %rcx
leaq -0xc8(%rbp), %rdi
leaq 0x11d25(%rip), %rax     # 0x180b0
callq *(%rax,%rcx,8)
jmp 0x6323
addq $0x10f0, %rsp           # imm = 0x10F0
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Cloudef[P]dwm-fork/dwm.c
// Function: cleanup
void
cleanup(void) {
   Arg a = {.ui = ~0};
   Layout foo = { "", NULL };
   Monitor *m;

   systray_freeicons();
   view(&a);
   selmon->lt[selmon->sellt] = &foo;
   for(m = mons; m; m = m->next)
      while(m->stack)
         unmanage(m->stack, False);
#ifndef XFT
   if(dc.font.set)
      XFreeFontSet(dpy, dc.font.set);
   else
      XFreeFont(dpy, dc.font.xfont);
#endif
   XUngrabKey(dpy, AnyKey, AnyModifier, root);
   XFreePixmap(dpy, dc.drawable);
   XFreeGC(dpy, dc.gc);
   XFreeCursor(dpy, cursor[CurNormal]);
   XFreeCursor(dpy, cursor[CurResize]);
   XFreeCursor(dpy, cursor[CurMove]);
   while(mons)
      cleanupmon(mons);
   XSync(dpy, False);
   XSetInputFocus(dpy, PointerRoot, RevertToPointerRoot, CurrentTime);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0xbc81(%rip), %rax      # 0x12030
movq %rax, -0x8(%rbp)
movq 0x10966(%rip), %rax     # 0x16d20
movq %rax, -0x20(%rbp)
movq 0x10963(%rip), %rax     # 0x16d28
movq %rax, -0x18(%rbp)
movq 0x10960(%rip), %rax     # 0x16d30
movq %rax, -0x10(%rbp)
callq 0xa150
leaq -0x8(%rbp), %rdi
callq 0xb380
movq 0x12217(%rip), %rax     # 0x18600
movq 0x12210(%rip), %rcx     # 0x18600
movl 0x5c(%rcx), %ecx
leaq -0x20(%rbp), %rdx
movq %rdx, 0xa0(%rax,%rcx,8)
movq 0x121f2(%rip), %rax     # 0x185f8
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x6448
jmp 0x6413
movq -0x28(%rbp), %rax
cmpq $0x0, 0x88(%rax)
je 0x6435
movq -0x28(%rbp), %rax
movq 0x88(%rax), %rdi
xorl %esi, %esi
callq 0xf710
jmp 0x6413
jmp 0x6437
movq -0x28(%rbp), %rax
movq 0x90(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x640a
cmpq $0x0, 0x12380(%rip)     # 0x187d0
je 0x6467
movq 0x121bf(%rip), %rdi     # 0x18618
movq 0x12370(%rip), %rsi     # 0x187d0
callq 0x52a0
jmp 0x647a
movq 0x121aa(%rip), %rdi     # 0x18618
movq 0x12363(%rip), %rsi     # 0x187d8
callq 0x5160
movq 0x12197(%rip), %rdi     # 0x18618
movq 0x12358(%rip), %rcx     # 0x187e0
xorl %esi, %esi
movl $0x8000, %edx           # imm = 0x8000
callq 0x5230
movq 0x1217d(%rip), %rdi     # 0x18618
movq 0x1230e(%rip), %rsi     # 0x187b0
callq 0x56a0
movq 0x1216a(%rip), %rdi     # 0x18618
movq 0x12303(%rip), %rsi     # 0x187b8
callq 0x5390
movq 0x12157(%rip), %rdi     # 0x18618
movq 0x12348(%rip), %rsi     # 0x18810
callq 0x5090
movq 0x12144(%rip), %rdi     # 0x18618
movq 0x1233d(%rip), %rsi     # 0x18818
callq 0x5090
movq 0x12131(%rip), %rdi     # 0x18618
movq 0x12332(%rip), %rsi     # 0x18820
callq 0x5090
cmpq $0x0, 0x120fd(%rip)     # 0x185f8
je 0x650b
movq 0x120f4(%rip), %rdi     # 0x185f8
callq 0x11070
jmp 0x64f3
movq 0x12106(%rip), %rdi     # 0x18618
xorl %esi, %esi
callq 0x54d0
movq 0x120f8(%rip), %rdi     # 0x18618
movl $0x1, %esi
movl $0x1, %edx
xorl %eax, %eax
movl %eax, %ecx
callq 0x54b0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Cloudef[P]dwm-fork/dwm.c
// Function: xerror
int
xerror(Display *dpy, XErrorEvent *ee) {
   if(ee->error_code == BadWindow
         || (ee->request_code == X_SetInputFocus && ee->error_code == BadMatch)
         || (ee->request_code == X_PolyText8 && ee->error_code == BadDrawable)
         || (ee->request_code == X_PolyFillRectangle && ee->error_code == BadDrawable)
         || (ee->request_code == X_PolySegment && ee->error_code == BadDrawable)
         || (ee->request_code == X_ConfigureWindow && ee->error_code == BadMatch)
         || (ee->request_code == X_GrabButton && ee->error_code == BadAccess)
         || (ee->request_code == X_GrabKey && ee->error_code == BadAccess)
         || (ee->request_code == X_CopyArea && ee->error_code == BadDrawable))
      return 0;
   fprintf(stderr, "dwm: fatal error: request code=%d, error code=%d\n",
         ee->request_code, ee->error_code);
   return xerrorxlib(dpy, ee); /* may call exit */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movzbl 0x20(%rax), %eax
cmpl $0x3, %eax
je 0x665d
movq -0x18(%rbp), %rax
movzbl 0x21(%rax), %eax
cmpl $0x2a, %eax
jne 0x659f
movq -0x18(%rbp), %rax
movzbl 0x20(%rax), %eax
cmpl $0x8, %eax
je 0x665d
movq -0x18(%rbp), %rax
movzbl 0x21(%rax), %eax
cmpl $0x4a, %eax
jne 0x65bd
movq -0x18(%rbp), %rax
movzbl 0x20(%rax), %eax
cmpl $0x9, %eax
je 0x665d
movq -0x18(%rbp), %rax
movzbl 0x21(%rax), %eax
cmpl $0x46, %eax
jne 0x65db
movq -0x18(%rbp), %rax
movzbl 0x20(%rax), %eax
cmpl $0x9, %eax
je 0x665d
movq -0x18(%rbp), %rax
movzbl 0x21(%rax), %eax
cmpl $0x42, %eax
jne 0x65f5
movq -0x18(%rbp), %rax
movzbl 0x20(%rax), %eax
cmpl $0x9, %eax
je 0x665d
movq -0x18(%rbp), %rax
movzbl 0x21(%rax), %eax
cmpl $0xc, %eax
jne 0x660f
movq -0x18(%rbp), %rax
movzbl 0x20(%rax), %eax
cmpl $0x8, %eax
je 0x665d
movq -0x18(%rbp), %rax
movzbl 0x21(%rax), %eax
cmpl $0x1c, %eax
jne 0x6629
movq -0x18(%rbp), %rax
movzbl 0x20(%rax), %eax
cmpl $0xa, %eax
je 0x665d
movq -0x18(%rbp), %rax
movzbl 0x21(%rax), %eax
cmpl $0x21, %eax
jne 0x6643
movq -0x18(%rbp), %rax
movzbl 0x20(%rax), %eax
cmpl $0xa, %eax
je 0x665d
movq -0x18(%rbp), %rax
movzbl 0x21(%rax), %eax
cmpl $0x3e, %eax
jne 0x6666
movq -0x18(%rbp), %rax
movzbl 0x20(%rax), %eax
cmpl $0x9, %eax
jne 0x6666
movl $0x0, -0x4(%rbp)
jmp 0x66a2
movq 0x1097b(%rip), %rax     # 0x16fe8
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movzbl 0x21(%rax), %edx
movq -0x18(%rbp), %rax
movzbl 0x20(%rax), %ecx
leaq 0xbc78(%rip), %rsi      # 0x122ff
movb $0x0, %al
callq 0x5740
movq 0x1215b(%rip), %rax     # 0x187f0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq *%rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Cloudef[P]dwm-fork/dwm.c
// Function: getcolor
unsigned long
#ifndef XFT
getcolor(const char *colstr) {
#else
getcolor(const char *colstr, XftColor *color) {
#endif
   Colormap cmap = DefaultColormap(dpy, screen);
#ifndef XFT
   XColor color;

   if(!XAllocNamedColor(dpy, cmap, colstr, &color, &color))
      die("error, cannot allocate color '%s'\n", colstr);
   return color.pixel;
#else
   Visual *vis = DefaultVisual(dpy, screen);
   if(!XftColorAllocName(dpy,vis,cmap,colstr, color))
      die("error, cannot allocate color '%s'\n", colstr);

   return color->pixel;
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq 0x11aa5(%rip), %rax     # 0x18618
movq 0xe8(%rax), %rax
movslq 0x11c77(%rip), %rcx     # 0x187f8
shlq $0x7, %rcx
addq %rcx, %rax
movq 0x50(%rax), %rax
movq %rax, -0x10(%rbp)
movq 0x11a81(%rip), %rdi     # 0x18618
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rdx
leaq -0x20(%rbp), %r8
movq %r8, %rcx
callq 0x5200
cmpl $0x0, %eax
jne 0x6bc2
movq -0x8(%rbp), %rsi
leaq 0xb968(%rip), %rdi      # 0x12523
movb $0x0, %al
callq 0x5ab0
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Cloudef[P]dwm-fork/dwm.c
// Function: updatebars
void
updatebars(void) {
   Monitor *m;
   XSetWindowAttributes wa;
   int b = 0;

   wa.override_redirect = True;
   wa.background_pixmap = ParentRelative;
   wa.event_mask = ButtonPressMask|ExposureMask;
   for(m = mons; m; m = m->next) {
      m->barwin = XCreateWindow(dpy, root, m->bx, m->by, m->bw, m->bh, 0, DefaultDepth(dpy, screen),
            CopyFromParent, DefaultVisual(dpy, screen),
            CWOverrideRedirect|CWBackPixmap|CWEventMask, &wa);
      XDefineCursor(dpy, m->barwin, cursor[CurNormal]);
      XMapRaised(dpy, m->barwin);
      b++;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movl $0x0, -0x7c(%rbp)
movl $0x1, -0x20(%rbp)
movq $0x1, -0x78(%rbp)
movq $0x8004, -0x30(%rbp)    # imm = 0x8004
movq 0x119f8(%rip), %rax     # 0x185f8
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x6d0d
movq 0x11a02(%rip), %rdi     # 0x18618
movq 0x11bc3(%rip), %rsi     # 0x187e0
movq -0x8(%rbp), %rax
movl 0x18(%rax), %edx
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %ecx
movq -0x8(%rbp), %rax
movl 0x20(%rax), %r8d
movq -0x8(%rbp), %rax
movl 0x24(%rax), %r9d
movq 0x119d6(%rip), %rax     # 0x18618
movq 0xe8(%rax), %rax
movslq 0x11ba8(%rip), %r10     # 0x187f8
shlq $0x7, %r10
addq %r10, %rax
movl 0x38(%rax), %r11d
movq 0x119b6(%rip), %rax     # 0x18618
movq 0xe8(%rax), %rax
movslq 0x11b88(%rip), %r10     # 0x187f8
shlq $0x7, %r10
addq %r10, %rax
movq 0x40(%rax), %r10
xorl %eax, %eax
leaq -0x78(%rbp), %rax
movl $0x0, (%rsp)
movl %r11d, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
movq %r10, 0x18(%rsp)
movq $0xa01, 0x20(%rsp)      # imm = 0xA01
movq %rax, 0x28(%rsp)
callq 0x5240
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x98(%rax)
movq 0x11956(%rip), %rdi     # 0x18618
movq -0x8(%rbp), %rax
movq 0x98(%rax), %rsi
movq 0x11b3c(%rip), %rdx     # 0x18810
callq 0x55b0
movq 0x11938(%rip), %rdi     # 0x18618
movq -0x8(%rbp), %rax
movq 0x98(%rax), %rsi
callq 0x5720
movl -0x7c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x7c(%rbp)
movq -0x8(%rbp), %rax
movq 0x90(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x6c04
addq $0xb0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Cloudef[P]dwm-fork/dwm.c
// Function: updatestatus
void
updatestatus(void) {
   if(!gettextprop(root, XA_WM_NAME, stext, sizeof(stext)))
      strcpy(stext, VERSION);
#ifndef STATUS_MONITOR
   if(!alwaysdrawstatus && !inversestatus)
      drawbar(selmon);
   else
      drawbars();
#else
   drawbars();
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x11ab5(%rip), %rdi     # 0x187e0
movl $0x27, %esi
leaq 0x11b29(%rip), %rdx     # 0x18860
movl $0x100, %ecx            # imm = 0x100
callq 0x89c0
cmpl $0x0, %eax
jne 0x6d59
leaq 0x11b13(%rip), %rdi     # 0x18860
leaq 0xb7f2(%rip), %rsi      # 0x12546
callq 0x5560
callq 0x8ad0
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Cloudef[P]dwm-fork/dwm.c
// Function: grabkeys
void
grabkeys(void) {
   updatenumlockmask();
   {
      unsigned int i, j;
      unsigned int modifiers[] = { 0, LockMask, numlockmask, numlockmask|LockMask };
      KeyCode code;

      XUngrabKey(dpy, AnyKey, AnyModifier, root);
      for(i = 0; i < LENGTH(keys); i++) {
         if((code = XKeysymToKeycode(dpy, keys[i].keysym)))
            for(j = 0; j < LENGTH(modifiers); j++)
               XGrabKey(dpy, code, keys[i].mod | modifiers[j], root,
                     True, GrabModeAsync, GrabModeAsync);
      }
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
callq 0xa2f0
movl $0x0, -0x20(%rbp)
movl $0x2, -0x1c(%rbp)
movl 0x11987(%rip), %eax     # 0x18968
movl %eax, -0x18(%rbp)
movl 0x1197e(%rip), %eax     # 0x18968
orl $0x2, %eax
movl %eax, -0x14(%rbp)
movq 0x11621(%rip), %rdi     # 0x18618
movq 0x117e2(%rip), %rcx     # 0x187e0
xorl %esi, %esi
movl $0x8000, %edx           # imm = 0x8000
callq 0x5230
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
cmpq $0x49, %rax
jae 0x70b8
movq 0x115f3(%rip), %rdi     # 0x18618
movl -0x4(%rbp), %eax
movl %eax, %ecx
leaq 0x1057f(%rip), %rax     # 0x175b0
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rsi
callq 0x5640
movb %al, -0x21(%rbp)
cmpb $0x0, %al
je 0x70a8
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpq $0x4, %rax
jae 0x70a6
movq 0x115b9(%rip), %rdi     # 0x18618
movzbl -0x21(%rbp), %esi
movl -0x4(%rbp), %eax
movl %eax, %ecx
leaq 0x10541(%rip), %rax     # 0x175b0
shlq $0x5, %rcx
addq %rcx, %rax
movl (%rax), %edx
movl -0x8(%rbp), %eax
orl -0x20(%rbp,%rax,4), %edx
movq 0x1175a(%rip), %rcx     # 0x187e0
movl $0x1, %r9d
movl %r9d, %r8d
movl $0x1, (%rsp)
callq 0x5680
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x704f
jmp 0x70a8
jmp 0x70aa
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x7011
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Cloudef[P]dwm-fork/dwm.c
// Function: createmon
Monitor *
createmon(void) {
   Monitor *m;

   if(!(m = (Monitor *)calloc(1, sizeof(Monitor))))
      die("fatal: could not malloc() %u bytes\n", sizeof(Monitor));
   m->tagset[0] = m->tagset[1] = 1;
   m->mfact = mfact;
   m->showbar = showbar;
   m->topbar = topbar;
   m->primary = 0;
   m->status  = 0;
   m->lt[0] = &layouts[0];
   m->lt[1] = &layouts[1 % LENGTH(layouts)];
   m->olt   = NULL;
   m->edge   = &DEDGE;
   m->margin = &DEDGE;
   strncpy(m->ltsymbol, layouts[0].symbol, sizeof m->ltsymbol);
   return m;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x1, %edi
movl $0xd8, %esi
callq 0x55c0
movq %rax, -0x8(%rbp)
cmpq $0x0, %rax
jne 0x70f4
leaq 0xb33f(%rip), %rdi      # 0x12427
movl $0xd8, %esi
movb $0x0, %al
callq 0x5ab0
movq -0x8(%rbp), %rax
movl $0x1, 0x64(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x60(%rax)
movq -0x8(%rbp), %rax
movss 0xaeee(%rip), %xmm0     # 0x12004
movss %xmm0, 0x10(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x68(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x70(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0xb8(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0xbc(%rax)
movq -0x8(%rbp), %rax
leaq 0xf0d8(%rip), %rcx      # 0x16230
movq %rcx, 0xa0(%rax)
movq -0x8(%rbp), %rax
leaq 0xf0c6(%rip), %rcx      # 0x16230
addq $0x18, %rcx
movq %rcx, 0xa8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0xb0(%rax)
movq -0x8(%rbp), %rax
leaq 0x116c1(%rip), %rcx     # 0x18850
movq %rcx, 0xc8(%rax)
movq -0x8(%rbp), %rax
leaq 0x116af(%rip), %rcx     # 0x18850
movq %rcx, 0xc0(%rax)
movq -0x8(%rbp), %rdi
movq 0xf085(%rip), %rsi      # 0x16238
movl $0x10, %edx
callq 0x5620
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Cloudef[P]dwm-fork/dwm.c
// Function: updatebarpos
void
updatebarpos(Monitor *m) {
   /* original */
   m->by = m->oy;
   m->wy = m->oy;
   m->wh = m->oh;

   /* get right stuff */
   if(m->showbar) {
      m->wh -= m->bh;
      m->by = m->topbar ? m->wy : m->wy + m->wh;
      m->wy = m->topbar ? m->wy + bh + m->margin->y : m->wy;
      m->wh -= m->margin->h;
   }
   else
      m->by = -m->bh;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x4c(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x1c(%rax)
movq -0x8(%rbp), %rax
movl 0x4c(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x3c(%rax)
movq -0x8(%rbp), %rax
movl 0x54(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x44(%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x68(%rax)
je 0x72ae
movq -0x8(%rbp), %rax
movl 0x24(%rax), %edx
movq -0x8(%rbp), %rax
movl 0x44(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x44(%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x70(%rax)
je 0x7239
movq -0x8(%rbp), %rax
movl 0x3c(%rax), %eax
movl %eax, -0xc(%rbp)
jmp 0x724a
movq -0x8(%rbp), %rax
movl 0x3c(%rax), %eax
movq -0x8(%rbp), %rcx
addl 0x44(%rcx), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x1c(%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x70(%rax)
je 0x727e
movq -0x8(%rbp), %rax
movl 0x3c(%rax), %eax
addl 0x11599(%rip), %eax     # 0x18804
movq -0x8(%rbp), %rcx
movq 0xc0(%rcx), %rcx
addl 0x4(%rcx), %eax
movl %eax, -0x10(%rbp)
jmp 0x7288
movq -0x8(%rbp), %rax
movl 0x3c(%rax), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x3c(%rax)
movq -0x8(%rbp), %rax
movq 0xc0(%rax), %rax
movl 0xc(%rax), %edx
movq -0x8(%rbp), %rax
movl 0x44(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x44(%rax)
jmp 0x72be
movq -0x8(%rbp), %rax
xorl %ecx, %ecx
subl 0x24(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x1c(%rax)
popq %rbp
retq