LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/blasphemy[P]mmc-utils/lsmmc.c
// Function: speed_class_name
char speed_class_name(unsigned char id)
{
	switch (id) {
	case 0x00: return '?';
	case 0x08: return 'A';
	case 0x0a: return 'B';
	case 0x0f: return 'C';
	case 0x14: return 'D';
	case 0x1e: return 'E';
	case 0x28: return 'F';
	case 0x32: return 'G';
	case 0x3c: return 'H';
	case 0x46: return 'J';
	case 0x50: return 'K';
	case 0x64: return 'M';
	case 0x78: return 'O';
	case 0x8c: return 'R';
	case 0xa0: return 'T';
	default: return '?';
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x2(%rbp)
movzbl -0x2(%rbp), %eax
movl %eax, -0x8(%rbp)
testl %eax, %eax
je 0xec9b
jmp 0xebfb
movl -0x8(%rbp), %eax
subl $0x8, %eax
je 0xeca1
jmp 0xec09
movl -0x8(%rbp), %eax
subl $0xa, %eax
je 0xeca7
jmp 0xec17
movl -0x8(%rbp), %eax
subl $0xf, %eax
je 0xecad
jmp 0xec25
movl -0x8(%rbp), %eax
subl $0x14, %eax
je 0xecb3
jmp 0xec33
movl -0x8(%rbp), %eax
subl $0x1e, %eax
je 0xecb9
jmp 0xec3d
movl -0x8(%rbp), %eax
subl $0x28, %eax
je 0xecbf
jmp 0xec47
movl -0x8(%rbp), %eax
subl $0x32, %eax
je 0xecc5
jmp 0xec51
movl -0x8(%rbp), %eax
subl $0x3c, %eax
je 0xeccb
jmp 0xec5b
movl -0x8(%rbp), %eax
subl $0x46, %eax
je 0xecd1
jmp 0xec65
movl -0x8(%rbp), %eax
subl $0x50, %eax
je 0xecd7
jmp 0xec6f
movl -0x8(%rbp), %eax
subl $0x64, %eax
je 0xecdd
jmp 0xec79
movl -0x8(%rbp), %eax
subl $0x78, %eax
je 0xece3
jmp 0xec83
movl -0x8(%rbp), %eax
subl $0x8c, %eax
je 0xece9
jmp 0xec8f
movl -0x8(%rbp), %eax
subl $0xa0, %eax
je 0xecef
jmp 0xecf5
movb $0x3f, -0x1(%rbp)
jmp 0xecf9
movb $0x41, -0x1(%rbp)
jmp 0xecf9
movb $0x42, -0x1(%rbp)
jmp 0xecf9
movb $0x43, -0x1(%rbp)
jmp 0xecf9
movb $0x44, -0x1(%rbp)
jmp 0xecf9
movb $0x45, -0x1(%rbp)
jmp 0xecf9
movb $0x46, -0x1(%rbp)
jmp 0xecf9
movb $0x47, -0x1(%rbp)
jmp 0xecf9
movb $0x48, -0x1(%rbp)
jmp 0xecf9
movb $0x4a, -0x1(%rbp)
jmp 0xecf9
movb $0x4b, -0x1(%rbp)
jmp 0xecf9
movb $0x4d, -0x1(%rbp)
jmp 0xecf9
movb $0x4f, -0x1(%rbp)
jmp 0xecf9
movb $0x52, -0x1(%rbp)
jmp 0xecf9
movb $0x54, -0x1(%rbp)
jmp 0xecf9
movb $0x3f, -0x1(%rbp)
movb -0x1(%rbp), %al
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/blasphemy[P]mmc-utils/lsmmc.c
// Function: sleep_consumption
char *sleep_consumption(unsigned int id)
{
	switch (id) {
	case 0x00: return "not defined";
	case 0x01: return "2uA";
	case 0x02: return "4uA";
	case 0x03: return "8uA";
	case 0x04: return "16uA";
	case 0x05: return "32uA";
	case 0x06: return "64uA";
	case 0x07: return "128uA";
	case 0x08: return "0.256mA";
	case 0x09: return "0.512mA";
	case 0x0a: return "1.024mA";
	case 0x0b: return "2.048mA";
	case 0x0c: return "4.096mA";
	case 0x0d: return "8.192mA";
	default: return "reserved";
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0xd, %rax
ja 0xefc1
movq -0x18(%rbp), %rax
leaq 0x7e1d(%rip), %rcx      # 0x16d10
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x9535(%rip), %rax      # 0x18438
movq %rax, -0x8(%rbp)
jmp 0xefcc
leaq 0x9537(%rip), %rax      # 0x1844a
movq %rax, -0x8(%rbp)
jmp 0xefcc
leaq 0x952c(%rip), %rax      # 0x1844f
movq %rax, -0x8(%rbp)
jmp 0xefcc
leaq 0x9522(%rip), %rax      # 0x18455
movq %rax, -0x8(%rbp)
jmp 0xefcc
leaq 0x9501(%rip), %rax      # 0x18444
movq %rax, -0x8(%rbp)
jmp 0xefcc
leaq 0x94f6(%rip), %rax      # 0x18449
movq %rax, -0x8(%rbp)
jmp 0xefcc
leaq 0x94ee(%rip), %rax      # 0x1844e
movq %rax, -0x8(%rbp)
jmp 0xefcc
leaq 0x94e6(%rip), %rax      # 0x18453
movq %rax, -0x8(%rbp)
jmp 0xefcc
leaq 0x94df(%rip), %rax      # 0x18459
movq %rax, -0x8(%rbp)
jmp 0xefcc
leaq 0x94da(%rip), %rax      # 0x18461
movq %rax, -0x8(%rbp)
jmp 0xefcc
leaq 0x94d5(%rip), %rax      # 0x18469
movq %rax, -0x8(%rbp)
jmp 0xefcc
leaq 0x94d0(%rip), %rax      # 0x18471
movq %rax, -0x8(%rbp)
jmp 0xefcc
leaq 0x94cb(%rip), %rax      # 0x18479
movq %rax, -0x8(%rbp)
jmp 0xefcc
leaq 0x94c6(%rip), %rax      # 0x18481
movq %rax, -0x8(%rbp)
jmp 0xefcc
leaq 0x942f(%rip), %rax      # 0x183f7
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/blasphemy[P]mmc-utils/lsmmc.c
// Function: print_info
void print_info(struct config *config, char *type,
	char *cid, char *csd, char *scr, char *ext_csd)
{
	printf("type: '%s'\n", type);

	if (!strcmp(type, "SD") && cid)
		print_sd_cid(config, cid);
	else if (!strcmp(type, "MMC") && cid)
		print_mmc_cid(config, cid);

	if (!strcmp(type, "SD") && scr)
		print_sd_scr(config, scr);

	if (!strcmp(type, "MMC") && csd)
		print_mmc_csd(config, csd);
	else if (!strcmp(type, "SD") && csd)
		print_sd_csd(config, csd);
}

// 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 %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x10(%rbp), %rsi
leaq 0x92f8(%rip), %rdi      # 0x18723
movb $0x0, %al
callq 0x30c0
movq -0x10(%rbp), %rdi
leaq 0x9268(%rip), %rsi      # 0x186a5
callq 0x3170
cmpl $0x0, %eax
jne 0xf45d
cmpq $0x0, -0x18(%rbp)
je 0xf45d
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xaea0
jmp 0xf488
movq -0x10(%rbp), %rdi
leaq 0x9240(%rip), %rsi      # 0x186a8
callq 0x3170
cmpl $0x0, %eax
jne 0xf486
cmpq $0x0, -0x18(%rbp)
je 0xf486
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xb0c0
jmp 0xf488
movq -0x10(%rbp), %rdi
leaq 0x9212(%rip), %rsi      # 0x186a5
callq 0x3170
cmpl $0x0, %eax
jne 0xf4b1
cmpq $0x0, -0x28(%rbp)
je 0xf4b1
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0xefe0
movq -0x10(%rbp), %rdi
leaq 0x91ec(%rip), %rsi      # 0x186a8
callq 0x3170
cmpl $0x0, %eax
jne 0xf4dc
cmpq $0x0, -0x20(%rbp)
je 0xf4dc
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xcd50
jmp 0xf507
movq -0x10(%rbp), %rdi
leaq 0x91be(%rip), %rsi      # 0x186a5
callq 0x3170
cmpl $0x0, %eax
jne 0xf505
cmpq $0x0, -0x20(%rbp)
je 0xf505
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xb350
jmp 0xf507
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/blasphemy[P]mmc-utils/lsmmc.c
// Function: lsmmc_main
int lsmmc_main(struct config *config, int argc, char **argv)
{
	int ret;

	memset(config, 0, sizeof(*config));
	config->mmc_ids = calloc(IDS_MAX, sizeof(char *));
	config->sd_ids = calloc(IDS_MAX, sizeof(char *));
	if (!config->mmc_ids || !config->sd_ids) {
		fprintf(stderr, "Could not allocate memory for lsmmc.\n");
		return -1;
	}

	ret = parse_opts(argc, argv, config);
	if (ret)
		return ret;

	return parse_ids(config);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x58, %edx
callq 0x30f0
movl $0x100, %edi            # imm = 0x100
movl $0x8, %esi
callq 0x3160
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movl $0x100, %edi            # imm = 0x100
movl $0x8, %esi
callq 0x3160
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0xf85d
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jne 0xf87e
movq 0xb78c(%rip), %rax      # 0x1aff0
movq (%rax), %rdi
leaq 0x8fa8(%rip), %rsi      # 0x18816
movb $0x0, %al
callq 0x3180
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xf8ab
movl -0x14(%rbp), %edi
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0xa2c0
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0xf89f
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xf8ab
movq -0x10(%rbp), %rdi
callq 0xa420
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/blasphemy[P]mmc-utils/lsmmc.c
// Function: do_read_csd
int do_read_csd(int argc, char **argv)
{
	struct config config;
	int ret;

	if (argc != 2 && argc != 3) {
		fprintf(stderr, "Usage: Print CSD data from <device path>.\n");
		exit(1);
	}

	ret = lsmmc_main(&config, argc, argv);
	if (ret)
		goto out;

	if (config.dir)
		ret = process_dir(&config, CSD);

out:
	lsmmc_free(&config);

	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x2, -0x4(%rbp)
je 0xf93d
cmpl $0x3, -0x4(%rbp)
je 0xf93d
movq 0xb6ce(%rip), %rax      # 0x1aff0
movq (%rax), %rdi
leaq 0x8f10(%rip), %rsi      # 0x1883c
movb $0x0, %al
callq 0x3180
movl $0x1, %edi
callq 0x3240
movl -0x4(%rbp), %esi
movq -0x10(%rbp), %rdx
leaq -0x68(%rbp), %rdi
callq 0xf7f0
movl %eax, -0x6c(%rbp)
cmpl $0x0, -0x6c(%rbp)
je 0xf958
jmp 0xf972
cmpq $0x0, -0x60(%rbp)
je 0xf970
leaq -0x68(%rbp), %rdi
movl $0x1, %esi
callq 0xf510
movl %eax, -0x6c(%rbp)
jmp 0xf972
leaq -0x68(%rbp), %rdi
callq 0xf8c0
movl -0x6c(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/blasphemy[P]mmc-utils/lsmmc.c
// Function: do_read_cid
int do_read_cid(int argc, char **argv)
{
	struct config config;
	int ret;

	if (argc != 2 && argc != 3) {
		fprintf(stderr, "Usage: Print CID data from <device path>.\n");
		exit(1);
	}

	ret = lsmmc_main(&config, argc, argv);
	if (ret)
		goto out;

	if (config.dir)
		ret = process_dir(&config, CID);

out:
	lsmmc_free(&config);

	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x2, -0x4(%rbp)
je 0xf9cd
cmpl $0x3, -0x4(%rbp)
je 0xf9cd
movq 0xb63e(%rip), %rax      # 0x1aff0
movq (%rax), %rdi
leaq 0x8eab(%rip), %rsi      # 0x18867
movb $0x0, %al
callq 0x3180
movl $0x1, %edi
callq 0x3240
movl -0x4(%rbp), %esi
movq -0x10(%rbp), %rdx
leaq -0x68(%rbp), %rdi
callq 0xf7f0
movl %eax, -0x6c(%rbp)
cmpl $0x0, -0x6c(%rbp)
je 0xf9e8
jmp 0xf9ff
cmpq $0x0, -0x60(%rbp)
je 0xf9fd
leaq -0x68(%rbp), %rdi
xorl %esi, %esi
callq 0xf510
movl %eax, -0x6c(%rbp)
jmp 0xf9ff
leaq -0x68(%rbp), %rdi
callq 0xf8c0
movl -0x6c(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/blasphemy[P]mmc-utils/3rdparty/hmac_sha/hmac_sha2.c
// Function: hmac_sha224_final
void hmac_sha224_final(hmac_sha224_ctx *ctx, unsigned char *mac,
                       unsigned int mac_size)
{
    unsigned char digest_inside[SHA224_DIGEST_SIZE];
    unsigned char mac_temp[SHA224_DIGEST_SIZE];

    sha224_final(&ctx->ctx_inside, digest_inside);
    sha224_update(&ctx->ctx_outside, digest_inside, SHA224_DIGEST_SIZE);
    sha224_final(&ctx->ctx_outside, mac_temp);
    memcpy(mac, mac_temp, mac_size);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x11e00
movq -0x8(%rbp), %rdi
addq $0xa8, %rdi
leaq -0x30(%rbp), %rsi
movl $0x1c, %edx
callq 0x11cf0
movq -0x8(%rbp), %rdi
addq $0xa8, %rdi
leaq -0x50(%rbp), %rsi
callq 0x11e00
movq -0x10(%rbp), %rdi
leaq -0x50(%rbp), %rsi
movl -0x14(%rbp), %eax
movl %eax, %edx
callq 0x31b0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/blasphemy[P]mmc-utils/3rdparty/hmac_sha/hmac_sha2.c
// Function: hmac_sha256_final
void hmac_sha256_final(hmac_sha256_ctx *ctx, unsigned char *mac,
                       unsigned int mac_size)
{
    unsigned char digest_inside[SHA256_DIGEST_SIZE];
    unsigned char mac_temp[SHA256_DIGEST_SIZE];

    sha256_final(&ctx->ctx_inside, digest_inside);
    sha256_update(&ctx->ctx_outside, digest_inside, SHA256_DIGEST_SIZE);
    sha256_final(&ctx->ctx_outside, mac_temp);
    memcpy(mac, mac_temp, mac_size);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x10d10
movq -0x8(%rbp), %rdi
addq $0xa8, %rdi
leaq -0x40(%rbp), %rsi
movl $0x20, %edx
callq 0x10c00
movq -0x8(%rbp), %rdi
addq $0xa8, %rdi
leaq -0x60(%rbp), %rsi
callq 0x10d10
movq -0x10(%rbp), %rdi
leaq -0x60(%rbp), %rsi
movl -0x14(%rbp), %eax
movl %eax, %edx
callq 0x31b0
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/blasphemy[P]mmc-utils/3rdparty/hmac_sha/hmac_sha2.c
// Function: hmac_sha384_final
void hmac_sha384_final(hmac_sha384_ctx *ctx, unsigned char *mac,
                       unsigned int mac_size)
{
    unsigned char digest_inside[SHA384_DIGEST_SIZE];
    unsigned char mac_temp[SHA384_DIGEST_SIZE];

    sha384_final(&ctx->ctx_inside, digest_inside);
    sha384_update(&ctx->ctx_outside, digest_inside, SHA384_DIGEST_SIZE);
    sha384_final(&ctx->ctx_outside, mac_temp);
    memcpy(mac, mac_temp, mac_size);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x11a00
movq -0x8(%rbp), %rdi
addq $0x148, %rdi            # imm = 0x148
leaq -0x50(%rbp), %rsi
movl $0x30, %edx
callq 0x118e0
movq -0x8(%rbp), %rdi
addq $0x148, %rdi            # imm = 0x148
leaq -0x80(%rbp), %rsi
callq 0x11a00
movq -0x10(%rbp), %rdi
leaq -0x80(%rbp), %rsi
movl -0x14(%rbp), %eax
movl %eax, %edx
callq 0x31b0
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/blasphemy[P]mmc-utils/3rdparty/hmac_sha/hmac_sha2.c
// Function: hmac_sha512_final
void hmac_sha512_final(hmac_sha512_ctx *ctx, unsigned char *mac,
                       unsigned int mac_size)
{
    unsigned char digest_inside[SHA512_DIGEST_SIZE];
    unsigned char mac_temp[SHA512_DIGEST_SIZE];

    sha512_final(&ctx->ctx_inside, digest_inside);
    sha512_update(&ctx->ctx_outside, digest_inside, SHA512_DIGEST_SIZE);
    sha512_final(&ctx->ctx_outside, mac_temp);
    memcpy(mac, mac_temp, mac_size);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x115f0
movq -0x8(%rbp), %rdi
addq $0x148, %rdi            # imm = 0x148
leaq -0x60(%rbp), %rsi
movl $0x40, %edx
callq 0x114d0
movq -0x8(%rbp), %rdi
addq $0x148, %rdi            # imm = 0x148
leaq -0xa0(%rbp), %rsi
callq 0x115f0
movq -0x10(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
movl -0x14(%rbp), %eax
movl %eax, %edx
callq 0x31b0
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/test/test_khash.c
// Function: make_keys
char * make_keys(size_t num, size_t kl) {
    size_t i;
    char *keys;

    if (num > MAX_ENTRIES) return NULL;
    keys = malloc(kl * num);
    if (!keys) {
        perror(NULL);
        return NULL;
    }
    for (i = 0; i < num; i++) {
        if (snprintf(keys + kl * i, kl, "test%zu", i) >= kl) {
            free(keys);
            return NULL;
        }
    }

    return keys;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x5f5e0ff, -0x10(%rbp) # imm = 0x5F5E0FF
jbe 0x12a7
movq $0x0, -0x8(%rbp)
jmp 0x133e
movq -0x18(%rbp), %rdi
imulq -0x10(%rbp), %rdi
callq 0x10f0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x12d3
xorl %eax, %eax
movl %eax, %edi
callq 0x1090
movq $0x0, -0x8(%rbp)
jmp 0x133e
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x1336
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rax
imulq -0x20(%rbp), %rax
addq %rax, %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rcx
leaq 0x2d90(%rip), %rdx      # 0x4094
movb $0x0, %al
callq 0x1130
cltq
cmpq -0x18(%rbp), %rax
jb 0x1326
movq -0x28(%rbp), %rdi
callq 0x10e0
movq $0x0, -0x8(%rbp)
jmp 0x133e
jmp 0x1328
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x12db
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/test/test_khash.c
// Function: show_usage
static void show_usage(FILE *out, char *prog) {
    fprintf(out, "Usage : %s [-t <test>] [-i <file>]\n", prog);
    fprintf(out, " Options:\n");
    fprintf(out, "  -t <TEST>   Test to run (str2int, benchmark)\n");
    fprintf(out, "  -i <FILE>   Optional input file for benchmark\n");
    fprintf(out, "  -n <INT>    Number of items to add\n");
    fprintf(out, "  -f <FRAC>   Fraction to delete and re-insert\n");
    fprintf(out, "  -d          Dump hash table stats\n");
    fprintf(out, "  -h          Show this help\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq 0x2b05(%rip), %rsi      # 0x4104
movb $0x0, %al
callq 0x1110
movq -0x8(%rbp), %rdi
leaq 0x2b17(%rip), %rsi      # 0x4128
movb $0x0, %al
callq 0x1110
movq -0x8(%rbp), %rdi
leaq 0x2b10(%rip), %rsi      # 0x4133
movb $0x0, %al
callq 0x1110
movq -0x8(%rbp), %rdi
leaq 0x2b2e(%rip), %rsi      # 0x4163
movb $0x0, %al
callq 0x1110
movq -0x8(%rbp), %rdi
leaq 0x2b4d(%rip), %rsi      # 0x4194
movb $0x0, %al
callq 0x1110
movq -0x8(%rbp), %rdi
leaq 0x2b61(%rip), %rsi      # 0x41ba
movb $0x0, %al
callq 0x1110
movq -0x8(%rbp), %rdi
leaq 0x2b7f(%rip), %rsi      # 0x41ea
movb $0x0, %al
callq 0x1110
movq -0x8(%rbp), %rdi
leaq 0x2b92(%rip), %rsi      # 0x420f
movb $0x0, %al
callq 0x1110
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/test/test_khash.c
// Function: add_str2int_entry
static int add_str2int_entry(khash_t(str2int) *h, char *key, khint_t val) {
    int ret = 0;
    khint_t k = kh_put(str2int, h, key, &ret);

    if (ret != 1 && ret != 2) {
        fprintf(stderr, "Unexpected return from kh_put(%s) : %d\n", key, ret);
        return -1;
    }
    kh_val(h, k) = val;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x21c0
movl %eax, -0x24(%rbp)
cmpl $0x1, -0x20(%rbp)
je 0x1eb2
cmpl $0x2, -0x20(%rbp)
je 0x1eb2
movq 0x414f(%rip), %rax      # 0x5fe0
movq (%rax), %rdi
movq -0x18(%rbp), %rdx
movl -0x20(%rbp), %ecx
leaq 0x23bf(%rip), %rsi      # 0x4261
movb $0x0, %al
callq 0x1110
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1eca
movl -0x1c(%rbp), %edx
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movl -0x24(%rbp), %ecx
movl %edx, (%rax,%rcx,4)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/test/test_khash.c
// Function: check_str2int_entry
static int check_str2int_entry(khash_t(str2int) *h, char *key, khint_t val,
                               uint8_t is_deleted) {
    khint_t k = kh_get(str2int, h, key);
    if (is_deleted) {
        if (k < kh_end(h)) {
            fprintf(stderr, "Found deleted entry %s in hash table\n", key);
            return -1;
        } else {
            return 0;
        }
    }

    if (k >= kh_end(h)) {
        fprintf(stderr, "Couldn't find %s in hash table\n", key);
        return -1;
    }
    if (strcmp(kh_key(h, k), key) != 0) {
        fprintf(stderr, "Wrong key in hash table, expected %s got %s\n",
                key, kh_key(h, k));
        return -1;
    }
    if (kh_val(h, k) != val) {
        fprintf(stderr, "Wrong value in hash table, expected %u got %u\n",
                val, kh_val(h, k));
        return -1;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %cl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movb %al, -0x1d(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2a70
movl %eax, -0x24(%rbp)
cmpb $0x0, -0x1d(%rbp)
je 0x1f4d
movl -0x24(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jae 0x1f41
movq 0x40c0(%rip), %rax      # 0x5fe0
movq (%rax), %rdi
movq -0x18(%rbp), %rdx
leaq 0x235b(%rip), %rsi      # 0x4289
movb $0x0, %al
callq 0x1110
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x201d
movl $0x0, -0x4(%rbp)
jmp 0x201d
movl -0x24(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jb 0x1f80
movq 0x4081(%rip), %rax      # 0x5fe0
movq (%rax), %rdi
movq -0x18(%rbp), %rdx
leaq 0x2342(%rip), %rsi      # 0x42af
movb $0x0, %al
callq 0x1110
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x201d
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movl -0x24(%rbp), %ecx
movq (%rax,%rcx,8), %rdi
movq -0x18(%rbp), %rsi
callq 0x1100
cmpl $0x0, %eax
je 0x1fd1
movq 0x403c(%rip), %rax      # 0x5fe0
movq (%rax), %rdi
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movl -0x24(%rbp), %ecx
movq (%rax,%rcx,8), %rcx
leaq 0x230e(%rip), %rsi      # 0x42cf
movb $0x0, %al
callq 0x1110
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x201d
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movl -0x24(%rbp), %ecx
movl (%rax,%rcx,4), %eax
cmpl -0x1c(%rbp), %eax
je 0x2016
movq 0x3ff5(%rip), %rax      # 0x5fe0
movq (%rax), %rdi
movl -0x1c(%rbp), %edx
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movl -0x24(%rbp), %ecx
movl (%rax,%rcx,4), %ecx
leaq 0x22f6(%rip), %rsi      # 0x42fc
movb $0x0, %al
callq 0x1110
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x201d
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/test/test_khash.c
// Function: write_stats_str2int
static void write_stats_str2int(khash_t(str2int) *h) {
    khint_t empty = 0, deleted = 0, hist_size = 0, *hist = NULL;

    if (kh_stats(str2int, h, &empty, &deleted, &hist_size, &hist) == 0) {
        khint_t i;
        printf("n_buckets = %u\n",
                kh_n_buckets(h));
        printf("empty     = %u\n", empty);
        printf("deleted   = %u\n", deleted);
        for (i = 0; i < hist_size; i++) {
            printf("dist[ %8u ] = %u\n", i, hist[i]);
        }
        free(hist);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rdi
leaq -0xc(%rbp), %rsi
leaq -0x10(%rbp), %rdx
leaq -0x14(%rbp), %rcx
leaq -0x20(%rbp), %r8
callq 0x2bc0
cmpl $0x0, %eax
jne 0x20eb
movq -0x8(%rbp), %rax
movl (%rax), %esi
leaq 0x22a7(%rip), %rdi      # 0x432b
movb $0x0, %al
callq 0x1030
movl -0xc(%rbp), %esi
leaq 0x22a6(%rip), %rdi      # 0x433b
movb $0x0, %al
callq 0x1030
movl -0x10(%rbp), %esi
leaq 0x22a5(%rip), %rdi      # 0x434b
movb $0x0, %al
callq 0x1030
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x20e2
movl -0x24(%rbp), %esi
movq -0x20(%rbp), %rax
movl -0x24(%rbp), %ecx
movl (%rax,%rcx,4), %edx
leaq 0x228b(%rip), %rdi      # 0x435b
movb $0x0, %al
callq 0x1030
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x20b4
movq -0x20(%rbp), %rdi
callq 0x10e0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/test/test_khash.c
// Function: del_str2int_entry
static int del_str2int_entry(khash_t(str2int) *h, char *key) {
    khint_t k = kh_get(str2int, h, key);
    if (k >= kh_end(h)) {
        fprintf(stderr, "Couldn't find %s to delete from hash table\n", key);
        return -1;
    }
    kh_del(str2int, h, k);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2a70
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jb 0x2150
movq 0x3eae(%rip), %rax      # 0x5fe0
movq (%rax), %rdi
movq -0x18(%rbp), %rdx
leaq 0x222d(%rip), %rsi      # 0x436d
movb $0x0, %al
callq 0x1110
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2163
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x2dd0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/test/test_khash.c
// Function: get_time
static long long get_time(void) {
#ifdef HAVE_CLOCK_GETTIME_CPUTIME
    struct timespec ts;
    if (clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &ts) < 0) {
        perror("clock_gettime");
        return -1;
    }
    return ts.tv_sec * 1000000000LL + ts.tv_nsec;
#else
    struct timeval tv;
    if (gettimeofday(&tv, NULL) < 0) {
        perror("gettimeofday");
        return -1;
    }
    return tv.tv_sec * 1000000LL + tv.tv_usec;
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1140
cmpl $0x0, %eax
jge 0x31a0
leaq 0x1228(%rip), %rdi      # 0x43b9
callq 0x1090
movq $-0x1, -0x8(%rbp)
jmp 0x31b0
imulq $0xf4240, -0x18(%rbp), %rax # imm = 0xF4240
addq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/test/test_khash.c
// Function: fmt_time
static char * fmt_time(long long elapsed) {
    static char buf[64];
#ifdef HAVE_CLOCK_GETTIME_CPUTIME
    long long sec = elapsed / 1000000000;
    long long nsec = elapsed % 1000000000;
    snprintf(buf, sizeof(buf), "%lld.%09lld processor seconds", sec, nsec);
#else
    long long sec = elapsed / 1000000;
    long long usec = elapsed % 1000000;
    snprintf(buf, sizeof(buf), "%lld.%06lld wall-time seconds", sec, usec);
#endif
    return buf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0xf4240, %ecx          # imm = 0xF4240
cqto
idivq %rcx
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl $0xf4240, %ecx          # imm = 0xF4240
cqto
idivq %rcx
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %r8
leaq 0x2ee1(%rip), %rdi      # 0x60e0
movl $0x40, %esi
leaq 0x11bb(%rip), %rdx      # 0x43c6
movb $0x0, %al
callq 0x1130
leaq 0x2ec7(%rip), %rax      # 0x60e0
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/leiradel[P]zx48k-libretro/src/ay38910.h
// Function: ay38910_init
void ay38910_init(ay38910_t* ay, const ay38910_desc_t* desc) {
    CHIPS_ASSERT(ay && desc);
    CHIPS_ASSERT(desc->tick_hz > 0);
    CHIPS_ASSERT(desc->sound_hz > 0);
    memset(ay, 0, sizeof(*ay));
    /* note: input and output callbacks are optional */
    ay->in_cb = desc->in_cb;
    ay->out_cb = desc->out_cb;
    ay->user_data = desc->user_data;
    ay->type = desc->type;
    ay->noise.rng = 1;
    ay->sample_period = (desc->tick_hz * AY38910_FIXEDPOINT_SCALE) / desc->sound_hz;
    ay->sample_counter = ay->sample_period;
    ay->mag = desc->magnitude;
    _ay38910_update_values(ay);
    _ay38910_restart_env_shape(ay);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3670
cmpq $0x0, -0x10(%rbp)
je 0x3670
jmp 0x368f
leaq 0x21629(%rip), %rdi     # 0x24ca0
leaq 0x2162d(%rip), %rsi     # 0x24cab
movl $0x191, %edx            # imm = 0x191
leaq 0x2162f(%rip), %rcx     # 0x24cb9
callq 0x3180
movq -0x10(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jle 0x369b
jmp 0x36ba
leaq 0x2164e(%rip), %rdi     # 0x24cf0
leaq 0x21602(%rip), %rsi     # 0x24cab
movl $0x192, %edx            # imm = 0x192
leaq 0x21604(%rip), %rcx     # 0x24cb9
callq 0x3180
movq -0x10(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jle 0x36c6
jmp 0x36e5
leaq 0x21635(%rip), %rdi     # 0x24d02
leaq 0x215d7(%rip), %rsi     # 0x24cab
movl $0x193, %edx            # imm = 0x193
leaq 0x215d9(%rip), %rcx     # 0x24cb9
callq 0x3180
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x8a0, %edx            # imm = 0x8A0
callq 0x31c0
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movl (%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x6c(%rax)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
shll $0x4, %eax
movq -0x10(%rbp), %rcx
cltd
idivl 0x8(%rcx)
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x88(%rax)
movq -0x8(%rbp), %rax
movl 0x88(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x8c(%rax)
movq -0x10(%rbp), %rax
movss 0xc(%rax), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x90(%rax)
movq -0x8(%rbp), %rdi
callq 0x37a0
movq -0x8(%rbp), %rdi
callq 0x38c0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/leiradel[P]zx48k-libretro/src/ay38910.h
// Function: ay38910_update_values
static void _ay38910_update_values(ay38910_t* ay) {
    for (int i = 0; i < AY38910_NUM_CHANNELS; i++) {
        ay38910_tone_t* chn = &ay->tone[i];
        /* "...Note also that due to the design technique used in the Tone Period
           count-down, the lowest period value is 000000000001 (divide by 1)
           and the highest period value is 111111111111 (divide by 4095)
        */
        chn->period = (ay->reg[2*i+1]<<8)|(ay->reg[2*i]);
        if (0 == chn->period) {
            chn->period = 1;
        }
        /* a set 'enable bit' actually means 'disabled' */
        chn->tone_disable = (ay->enable>>i) & 1;
        chn->noise_disable = (ay->enable>>(3+i)) & 1;
    }
    /* noise generator values */
    ay->noise.period = ay->period_noise;
    if (ay->noise.period == 0) {
        ay->noise.period = 1;
    }
    /* envelope generator values */
    ay->env.period = (ay->period_env_coarse<<8)|ay->period_env_fine;
    if (ay->env.period == 0) {
        ay->env.period = 1;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x3, -0xc(%rbp)
jge 0x385d
movq -0x8(%rbp), %rax
addq $0x38, %rax
movslq -0xc(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
shll %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movzbl 0x25(%rax,%rcx), %eax
shll $0x8, %eax
movq -0x8(%rbp), %rcx
movl -0xc(%rbp), %edx
shll %edx
movslq %edx, %rdx
movzbl 0x25(%rcx,%rdx), %ecx
orl %ecx, %eax
movw %ax, %cx
movq -0x18(%rbp), %rax
movw %cx, (%rax)
movq -0x18(%rbp), %rax
movzwl (%rax), %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x381a
movq -0x18(%rbp), %rax
movw $0x1, (%rax)
movq -0x8(%rbp), %rax
movzbl 0x2c(%rax), %eax
movl -0xc(%rbp), %ecx
sarl %cl, %eax
movl %eax, %ecx
andl $0x1, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x8(%rbp), %rax
movzbl 0x2c(%rax), %eax
movl -0xc(%rbp), %ecx
addl $0x3, %ecx
sarl %cl, %eax
movl %eax, %ecx
andl $0x1, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0xc(%rax)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x37af
movq -0x8(%rbp), %rax
movzbl 0x2b(%rax), %eax
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, 0x68(%rax)
movq -0x8(%rbp), %rax
movzwl 0x68(%rax), %eax
cmpl $0x0, %eax
jne 0x3887
movq -0x8(%rbp), %rax
movw $0x1, 0x68(%rax)
movq -0x8(%rbp), %rax
movzbl 0x31(%rax), %eax
shll $0x8, %eax
movq -0x8(%rbp), %rcx
movzbl 0x30(%rcx), %ecx
orl %ecx, %eax
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, 0x74(%rax)
movq -0x8(%rbp), %rax
movzwl 0x74(%rax), %eax
cmpl $0x0, %eax
jne 0x38be
movq -0x8(%rbp), %rax
movw $0x1, 0x74(%rax)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/leiradel[P]zx48k-libretro/src/ay38910.h
// Function: ay38910_restart_env_shape
static void _ay38910_restart_env_shape(ay38910_t* ay) {
    ay->env.shape_holding = false;
    ay->env.shape_counter = 0;
    if (!(ay->env_shape_cycle & AY38910_ENV_CONTINUE) || (ay->env_shape_cycle & AY38910_ENV_HOLD)) {
        ay->env.shape_hold = true;
    }
    else {
        ay->env.shape_hold = false;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movb $0x0, 0x78(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x7a(%rax)
movq -0x8(%rbp), %rax
movzbl 0x32(%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x38f8
movq -0x8(%rbp), %rax
movzbl 0x32(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x3902
movq -0x8(%rbp), %rax
movb $0x1, 0x79(%rax)
jmp 0x390a
movq -0x8(%rbp), %rax
movb $0x0, 0x79(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/leiradel[P]zx48k-libretro/src/ay38910.h
// Function: ay38910_reset
void ay38910_reset(ay38910_t* ay) {
    CHIPS_ASSERT(ay);
    ay->addr = 0;
    ay->tick = 0;
    for (int i = 0; i < AY38910_NUM_REGISTERS; i++) {
        ay->reg[i] = 0;
    }
    _ay38910_update_values(ay);
    _ay38910_restart_env_shape(ay);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3925
jmp 0x3944
leaq 0x213e9(%rip), %rdi     # 0x24d15
leaq 0x21378(%rip), %rsi     # 0x24cab
movl $0x1a3, %edx            # imm = 0x1A3
leaq 0x213d9(%rip), %rcx     # 0x24d18
callq 0x3180
movq -0x8(%rbp), %rax
movb $0x0, 0x24(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x20(%rax)
movl $0x0, -0xc(%rbp)
cmpl $0x10, -0xc(%rbp)
jge 0x397c
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movb $0x0, 0x25(%rax,%rcx)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x395e
movq -0x8(%rbp), %rdi
callq 0x37a0
movq -0x8(%rbp), %rdi
callq 0x38c0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/leiradel[P]zx48k-libretro/src/ay38910.h
// Function: ay38910_dcadjust
static float _ay38910_dcadjust(ay38910_t* ay, float s) {
    ay->dcadj_sum -= ay->dcadj_buf[ay->dcadj_pos];
    ay->dcadj_sum += s;
    ay->dcadj_buf[ay->dcadj_pos] = s;
    ay->dcadj_pos = (ay->dcadj_pos + 1) & (AY38910_DCADJ_BUFLEN-1);
    return s - (ay->dcadj_sum / AY38910_DCADJ_BUFLEN);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
movl 0x9c(%rcx), %ecx
movss 0xa0(%rax,%rcx,4), %xmm1
movq -0x8(%rbp), %rax
movss 0x98(%rax), %xmm0
subss %xmm1, %xmm0
movss %xmm0, 0x98(%rax)
movss -0xc(%rbp), %xmm0
movq -0x8(%rbp), %rax
addss 0x98(%rax), %xmm0
movss %xmm0, 0x98(%rax)
movss -0xc(%rbp), %xmm0
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
movl 0x9c(%rcx), %ecx
movss %xmm0, 0xa0(%rax,%rcx,4)
movq -0x8(%rbp), %rax
movl 0x9c(%rax), %ecx
addl $0x1, %ecx
andl $0x1ff, %ecx            # imm = 0x1FF
movq -0x8(%rbp), %rax
movl %ecx, 0x9c(%rax)
movss -0xc(%rbp), %xmm0
movq -0x8(%rbp), %rax
movss 0x98(%rax), %xmm1
movss 0x202a9(%rip), %xmm2    # 0x24000
divss %xmm2, %xmm1
subss %xmm1, %xmm0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/leiradel[P]zx48k-libretro/src/beeper.h
// Function: beeper_init
void beeper_init(beeper_t* b, int tick_hz, int sound_hz, float magnitude) {
    CHIPS_ASSERT(b);
    CHIPS_ASSERT((tick_hz > 0) && (sound_hz > 0));
    memset(b, 0, sizeof(*b));
    b->period = (tick_hz * BEEPER_FIXEDPOINT_SCALE) / sound_hz;
    b->counter = b->period;
    b->mag = magnitude;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movss %xmm0, -0x14(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x4070
jmp 0x408f
leaq 0x2119b(%rip), %rdi     # 0x25212
leaq 0x20cba(%rip), %rsi     # 0x24d38
movl $0x4c, %edx
leaq 0x20cbb(%rip), %rcx     # 0x24d45
callq 0x3180
cmpl $0x0, -0xc(%rbp)
jle 0x409d
cmpl $0x0, -0x10(%rbp)
jle 0x409d
jmp 0x40bc
leaq 0x20ccf(%rip), %rdi     # 0x24d73
leaq 0x20c8d(%rip), %rsi     # 0x24d38
movl $0x4d, %edx
leaq 0x20c8e(%rip), %rcx     # 0x24d45
callq 0x3180
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x81c, %edx            # imm = 0x81C
callq 0x31c0
movl -0xc(%rbp), %eax
shll $0x4, %eax
cltd
idivl -0x10(%rbp)
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x8(%rax)
movss -0x14(%rbp), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0xc(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/leiradel[P]zx48k-libretro/src/beeper.h
// Function: beeper_reset
void beeper_reset(beeper_t* b) {
    CHIPS_ASSERT(b);
    b->state = 0;
    b->counter = b->period;
    b->sample = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x4125
jmp 0x4144
leaq 0x210e6(%rip), %rdi     # 0x25212
leaq 0x20c05(%rip), %rsi     # 0x24d38
movl $0x55, %edx
leaq 0x20c54(%rip), %rcx     # 0x24d93
callq 0x3180
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x10(%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/leiradel[P]zx48k-libretro/src/beeper.h
// Function: beeper_tick
bool beeper_tick(beeper_t* bp) {
    /* generate a new sample? */
    bp->counter -= BEEPER_FIXEDPOINT_SCALE;
    if (bp->counter <= 0) {
        bp->counter += bp->period;
        bp->sample = _beeper_dcadjust(bp, (float)bp->state) * bp->mag;
        return true;
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
subl $0x10, %ecx
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jg 0x41cd
movq -0x10(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x10(%rbp), %rax
addl 0x8(%rax), %ecx
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
cvtsi2ssl (%rax), %xmm0
callq 0x41e0
movq -0x10(%rbp), %rax
mulss 0xc(%rax), %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, 0x10(%rax)
movb $0x1, -0x1(%rbp)
jmp 0x41d1
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/leiradel[P]zx48k-libretro/src/beeper.h
// Function: beeper_dcadjust
static float _beeper_dcadjust(beeper_t* bp, float s) {
    bp->dcadj_sum -= bp->dcadj_buf[bp->dcadj_pos];
    bp->dcadj_sum += s;
    bp->dcadj_buf[bp->dcadj_pos] = s;
    bp->dcadj_pos = (bp->dcadj_pos + 1) & (BEEPER_DCADJ_BUFLEN-1);
    return s - (bp->dcadj_sum / BEEPER_DCADJ_BUFLEN);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
movl 0x18(%rcx), %ecx
movss 0x1c(%rax,%rcx,4), %xmm1
movq -0x8(%rbp), %rax
movss 0x14(%rax), %xmm0
subss %xmm1, %xmm0
movss %xmm0, 0x14(%rax)
movss -0xc(%rbp), %xmm0
movq -0x8(%rbp), %rax
addss 0x14(%rax), %xmm0
movss %xmm0, 0x14(%rax)
movss -0xc(%rbp), %xmm0
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
movl 0x18(%rcx), %ecx
movss %xmm0, 0x1c(%rax,%rcx,4)
movq -0x8(%rbp), %rax
movl 0x18(%rax), %ecx
addl $0x1, %ecx
andl $0x1ff, %ecx            # imm = 0x1FF
movq -0x8(%rbp), %rax
movl %ecx, 0x18(%rax)
movss -0xc(%rbp), %xmm0
movq -0x8(%rbp), %rax
movss 0x14(%rax), %xmm1
movss 0x1fd9a(%rip), %xmm2    # 0x24000
divss %xmm2, %xmm1
subss %xmm1, %xmm0
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/leiradel[P]zx48k-libretro/src/clk.h
// Function: clk_ticks_to_run
uint32_t clk_ticks_to_run(clk_t* clk, uint32_t micro_seconds) {
    CHIPS_ASSERT(clk && (micro_seconds > 0));
    int ticks = (int) ((clk->freq_hz * micro_seconds) / 1000000);
    clk->ticks_to_run = ticks - clk->overrun_ticks;
    if (clk->ticks_to_run < 1) {
        clk->ticks_to_run = 1;
    }
    return clk->ticks_to_run;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x431e
cmpl $0x0, -0xc(%rbp)
jbe 0x431e
jmp 0x433d
leaq 0x20acc(%rip), %rdi     # 0x24df1
leaq 0x20a9a(%rip), %rsi     # 0x24dc6
movl $0x84, %edx
leaq 0x20ad4(%rip), %rcx     # 0x24e0c
callq 0x3180
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl -0xc(%rbp), %ecx
imulq %rcx, %rax
movl $0xf4240, %ecx          # imm = 0xF4240
cqto
idivq %rcx
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
subl 0xc(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x8(%rbp), %rax
cmpl $0x1, 0x8(%rax)
jge 0x437e
movq -0x8(%rbp), %rax
movl $0x1, 0x8(%rax)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/leiradel[P]zx48k-libretro/src/clk.h
// Function: clk_ticks_executed
void clk_ticks_executed(clk_t* clk, uint32_t ticks_executed) {
    if ((int)ticks_executed > clk->ticks_to_run) {
        clk->overrun_ticks = (int)ticks_executed - clk->ticks_to_run;
    }
    else {
        clk->overrun_ticks = 0;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jle 0x43ba
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
subl 0x8(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xc(%rax)
jmp 0x43c5
movq -0x8(%rbp), %rax
movl $0x0, 0xc(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/leiradel[P]zx48k-libretro/src/kbd.h
// Function: kbd_register_modifier
void kbd_register_modifier(kbd_t* kbd, int layer, int column, int line) {
    CHIPS_ASSERT(kbd);
    CHIPS_ASSERT((column >= 0) && (column < KBD_MAX_COLUMNS));
    CHIPS_ASSERT((line >= 0) && (line < KBD_MAX_LINES));
    CHIPS_ASSERT((layer >= 0) && (layer < KBD_MAX_MOD_KEYS));
    kbd->mod_masks[layer] = (1<<(layer+KBD_MAX_COLUMNS+KBD_MAX_LINES)) | (1<<(column+KBD_MAX_LINES)) | (1<<line);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x444e
jmp 0x446d
leaq 0x209e4(%rip), %rdi     # 0x24e39
leaq 0x209e1(%rip), %rsi     # 0x24e3d
movl $0xbc, %edx
leaq 0x209fb(%rip), %rcx     # 0x24e63
callq 0x3180
cmpl $0x0, -0x10(%rbp)
jl 0x447b
cmpl $0xc, -0x10(%rbp)
jge 0x447b
jmp 0x449a
leaq 0x20a14(%rip), %rdi     # 0x24e96
leaq 0x209b4(%rip), %rsi     # 0x24e3d
movl $0xbd, %edx
leaq 0x209ce(%rip), %rcx     # 0x24e63
callq 0x3180
cmpl $0x0, -0x14(%rbp)
jl 0x44a8
cmpl $0xc, -0x14(%rbp)
jge 0x44a8
jmp 0x44c7
leaq 0x20a08(%rip), %rdi     # 0x24eb7
leaq 0x20987(%rip), %rsi     # 0x24e3d
movl $0xbe, %edx
leaq 0x209a1(%rip), %rcx     # 0x24e63
callq 0x3180
cmpl $0x0, -0xc(%rbp)
jl 0x44d5
cmpl $0x4, -0xc(%rbp)
jge 0x44d5
jmp 0x44f4
leaq 0x209f8(%rip), %rdi     # 0x24ed4
leaq 0x2095a(%rip), %rsi     # 0x24e3d
movl $0xbf, %edx
leaq 0x20974(%rip), %rcx     # 0x24e63
callq 0x3180
movl -0xc(%rbp), %ecx
addl $0xc, %ecx
addl $0xc, %ecx
movl $0x1, %edx
shll %cl, %edx
movl -0x10(%rbp), %ecx
addl $0xc, %ecx
movl $0x1, %eax
shll %cl, %eax
orl %eax, %edx
movl -0x14(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
orl %eax, %edx
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movl %edx, 0x410(%rax,%rcx,4)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/leiradel[P]zx48k-libretro/src/kbd.h
// Function: kbd_register_modifier_line
void kbd_register_modifier_line(kbd_t* kbd, int layer, int line) {
    CHIPS_ASSERT(kbd);
    CHIPS_ASSERT((line >= 0) && (line < KBD_MAX_LINES));
    CHIPS_ASSERT((layer >= 0) && (layer < KBD_MAX_MOD_KEYS));
    kbd->mod_masks[layer] = (1<<(layer+KBD_MAX_COLUMNS+KBD_MAX_LINES)) | (1<<line);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x455b
jmp 0x457a
leaq 0x208d7(%rip), %rdi     # 0x24e39
leaq 0x208d4(%rip), %rsi     # 0x24e3d
movl $0xc4, %edx
leaq 0x2097d(%rip), %rcx     # 0x24ef2
callq 0x3180
cmpl $0x0, -0x10(%rbp)
jl 0x4588
cmpl $0xc, -0x10(%rbp)
jge 0x4588
jmp 0x45a7
leaq 0x20928(%rip), %rdi     # 0x24eb7
leaq 0x208a7(%rip), %rsi     # 0x24e3d
movl $0xc5, %edx
leaq 0x20950(%rip), %rcx     # 0x24ef2
callq 0x3180
cmpl $0x0, -0xc(%rbp)
jl 0x45b5
cmpl $0x4, -0xc(%rbp)
jge 0x45b5
jmp 0x45d4
leaq 0x20918(%rip), %rdi     # 0x24ed4
leaq 0x2087a(%rip), %rsi     # 0x24e3d
movl $0xc6, %edx
leaq 0x20923(%rip), %rcx     # 0x24ef2
callq 0x3180
movl -0xc(%rbp), %ecx
addl $0xc, %ecx
addl $0xc, %ecx
movl $0x1, %edx
shll %cl, %edx
movl -0x10(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
orl %eax, %edx
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movl %edx, 0x410(%rax,%rcx,4)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/leiradel[P]zx48k-libretro/src/kbd.h
// Function: kbd_register_modifier_column
void kbd_register_modifier_column(kbd_t* kbd, int layer, int column) {
    CHIPS_ASSERT(kbd);
    CHIPS_ASSERT((column >= 0) && (column < KBD_MAX_COLUMNS));
    CHIPS_ASSERT((layer >= 0) && (layer < KBD_MAX_MOD_KEYS));
    kbd->mod_masks[layer] = (1<<(layer+KBD_MAX_COLUMNS+KBD_MAX_LINES)) | (1<<(column+KBD_MAX_LINES));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x462b
jmp 0x464a
leaq 0x20807(%rip), %rdi     # 0x24e39
leaq 0x20804(%rip), %rsi     # 0x24e3d
movl $0xcb, %edx
leaq 0x208e0(%rip), %rcx     # 0x24f25
callq 0x3180
cmpl $0x0, -0x10(%rbp)
jl 0x4658
cmpl $0xc, -0x10(%rbp)
jge 0x4658
jmp 0x4677
leaq 0x20837(%rip), %rdi     # 0x24e96
leaq 0x207d7(%rip), %rsi     # 0x24e3d
movl $0xcc, %edx
leaq 0x208b3(%rip), %rcx     # 0x24f25
callq 0x3180
cmpl $0x0, -0xc(%rbp)
jl 0x4685
cmpl $0x4, -0xc(%rbp)
jge 0x4685
jmp 0x46a4
leaq 0x20848(%rip), %rdi     # 0x24ed4
leaq 0x207aa(%rip), %rsi     # 0x24e3d
movl $0xcd, %edx
leaq 0x20886(%rip), %rcx     # 0x24f25
callq 0x3180
movl -0xc(%rbp), %ecx
addl $0xc, %ecx
addl $0xc, %ecx
movl $0x1, %edx
shll %cl, %edx
movl -0x10(%rbp), %ecx
addl $0xc, %ecx
movl $0x1, %eax
shll %cl, %eax
orl %eax, %edx
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movl %edx, 0x410(%rax,%rcx,4)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/leiradel[P]zx48k-libretro/src/kbd.h
// Function: kbd_register_key
void kbd_register_key(kbd_t* kbd, int key, int column, int line, int mod_mask) {
    CHIPS_ASSERT(kbd);
    CHIPS_ASSERT((key >= 0) && (key < KBD_MAX_KEYS));
    CHIPS_ASSERT((column >= 0) && (column < KBD_MAX_COLUMNS));
    CHIPS_ASSERT((line >= 0) && (line < KBD_MAX_LINES));
    kbd->key_masks[key] = (mod_mask << (KBD_MAX_COLUMNS+KBD_MAX_LINES)) | (1<<(column+KBD_MAX_LINES)) | (1<<line);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x4702
jmp 0x4721
leaq 0x20730(%rip), %rdi     # 0x24e39
leaq 0x2072d(%rip), %rsi     # 0x24e3d
movl $0xd2, %edx
leaq 0x2083e(%rip), %rcx     # 0x24f5a
callq 0x3180
cmpl $0x0, -0xc(%rbp)
jl 0x4732
cmpl $0x100, -0xc(%rbp)      # imm = 0x100
jge 0x4732
jmp 0x4751
leaq 0x2087e(%rip), %rdi     # 0x24fb7
leaq 0x206fd(%rip), %rsi     # 0x24e3d
movl $0xd3, %edx
leaq 0x2080e(%rip), %rcx     # 0x24f5a
callq 0x3180
cmpl $0x0, -0x10(%rbp)
jl 0x475f
cmpl $0xc, -0x10(%rbp)
jge 0x475f
jmp 0x477e
leaq 0x20730(%rip), %rdi     # 0x24e96
leaq 0x206d0(%rip), %rsi     # 0x24e3d
movl $0xd4, %edx
leaq 0x207e1(%rip), %rcx     # 0x24f5a
callq 0x3180
cmpl $0x0, -0x14(%rbp)
jl 0x478c
cmpl $0xc, -0x14(%rbp)
jge 0x478c
jmp 0x47ab
leaq 0x20724(%rip), %rdi     # 0x24eb7
leaq 0x206a3(%rip), %rsi     # 0x24e3d
movl $0xd5, %edx
leaq 0x207b4(%rip), %rcx     # 0x24f5a
callq 0x3180
movl -0x18(%rbp), %edx
shll $0x18, %edx
movl -0x10(%rbp), %ecx
addl $0xc, %ecx
movl $0x1, %eax
shll %cl, %eax
orl %eax, %edx
movl -0x14(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
orl %eax, %edx
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movl %edx, 0x10(%rax,%rcx,4)
addq $0x20, %rsp
popq %rbp
retq
nop