LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/w4kfu[P]HommI/Sound/sound.c
// Function: save_wav
int save_wav(char *filename, unsigned char *buf, unsigned int length_buf)
{
	struct wav_header *wheader = NULL;
	FILE *fout = NULL;

	if (!(wheader = Make_wav_header(length_buf)))
		return 0;
	if (!(fout = fopen(filename, "wb")))
	{
		perror("fopen()");
		return 0;
	}
	fwrite(wheader, sizeof (struct wav_header), 1, fout);
	fwrite(buf, length_buf, 1, fout);
	fclose(fout);
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movl -0x1c(%rbp), %edi
callq 0x11c0
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x131e
movl $0x0, -0x4(%rbp)
jmp 0x138b
movq -0x10(%rbp), %rdi
leaq 0xcf8(%rip), %rsi       # 0x2021
callq 0x1090
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0x134d
leaq 0xce5(%rip), %rdi       # 0x2024
callq 0x10a0
movl $0x0, -0x4(%rbp)
jmp 0x138b
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rcx
movl $0x2c, %esi
movl $0x1, %edx
callq 0x10b0
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, %esi
movq -0x30(%rbp), %rcx
movl $0x1, %edx
callq 0x10b0
movq -0x30(%rbp), %rdi
callq 0x1040
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/w4kfu[P]HommI/Sound/main.c
// Function: getFileSize
int getFileSize(FILE *inFile)
{
        int fileSize = 0;

        fseek(inFile ,0, SEEK_END);
        fileSize = ftell(inFile);
        fseek(inFile, 0, SEEK_SET);
        return fileSize;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x1080
movq -0x8(%rbp), %rdi
callq 0x1060
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x1080
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/w4kfu[P]HommI/Sound/main.c
// Function: main
int main(int argc, char *argv[])
{
        FILE *fin = NULL;
        unsigned int filesize = 0;
        unsigned char *buf = NULL;

        if (argc != 3)
        {
                fprintf(stderr, "%s <*.82M> <outfile>\n", argv[0]);
                return EXIT_FAILURE;
        }
        if (!(fin = fopen(argv[1], "rb")))
        {
                perror("fopen()");
                return EXIT_FAILURE;
        }
        filesize = getFileSize(fin);
        if (!(buf = malloc(sizeof (char) * filesize)))
        {
                perror("malloc()");
                fclose(fin);
                return EXIT_FAILURE;
        }
        fread(buf, filesize, 1, fin);
        save_wav(argv[2], buf, filesize);
        fclose(fin);
        return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq $0x0, -0x28(%rbp)
cmpl $0x3, -0x8(%rbp)
je 0x144e
movq 0x2bce(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
leaq 0xbf1(%rip), %rsi       # 0x202c
movb $0x0, %al
callq 0x1050
movl $0x1, -0x4(%rbp)
jmp 0x14fe
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0xbe5(%rip), %rsi       # 0x2042
callq 0x1090
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x1481
leaq 0xbb1(%rip), %rdi       # 0x2024
callq 0x10a0
movl $0x1, -0x4(%rbp)
jmp 0x14fe
movq -0x18(%rbp), %rdi
callq 0x13a0
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, %edi
shlq $0x0, %rdi
callq 0x1070
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x14c3
leaq 0xb58(%rip), %rdi       # 0x2004
callq 0x10a0
movq -0x18(%rbp), %rdi
callq 0x1040
movl $0x1, -0x4(%rbp)
jmp 0x14fe
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, %esi
movq -0x18(%rbp), %rcx
movl $0x1, %edx
callq 0x1030
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x28(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0x12e0
movq -0x18(%rbp), %rdi
callq 0x1040
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/aes128poetv2aes128ni/ref/encrypt.c
// Function: crypto_aead_encrypt
int crypto_aead_encrypt(unsigned char *c, unsigned long long *clen,
                        const unsigned char *m, unsigned long long mlen,
                        const unsigned char *ad, unsigned long long adlen,
                        const unsigned char *nsec,
                        const unsigned char *npub,
                        const unsigned char *k)
{
    poet_ctx_t ctx;
    (void)nsec;
    
    keysetup_encrypt_only(&ctx, k);
    
    if (npub) {
        unsigned char *header = malloc((size_t)(adlen + CRYPTO_NPUBBYTES));
        memcpy(header, ad, adlen);
        memcpy(header + adlen, npub, CRYPTO_NPUBBYTES);
        process_header(&ctx, header, adlen + CRYPTO_NPUBBYTES);
        free(header);
    } else {
        process_header(&ctx, ad, adlen);
    }
    
    unsigned char *tag = c + mlen;
    encrypt_final(&ctx, m, mlen, c, clen, tag);

    if (clen) {
        *clen = mlen + CRYPTO_ABYTES;
    }

    return 0;
}

// Assembly:
subq $0x2a8, %rsp            # imm = 0x2A8
movq 0x2c0(%rsp), %rax
movq 0x2b8(%rsp), %rax
movq 0x2b0(%rsp), %rax
movq %rdi, 0x2a0(%rsp)
movq %rsi, 0x298(%rsp)
movq %rdx, 0x290(%rsp)
movq %rcx, 0x288(%rsp)
movq %r8, 0x280(%rsp)
movq %r9, 0x278(%rsp)
movq 0x2c0(%rsp), %rsi
leaq 0x10(%rsp), %rdi
callq 0x1050
cmpq $0x0, 0x2b8(%rsp)
je 0x12a8
movq 0x278(%rsp), %rdi
addq $0x10, %rdi
callq 0x1030
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq 0x280(%rsp), %rsi
movq 0x278(%rsp), %rdx
callq 0x10c0
movq 0x8(%rsp), %rax
movq 0x278(%rsp), %rcx
movq 0x2b8(%rsp), %rdx
movq (%rdx), %rsi
movq %rsi, (%rax,%rcx)
movq 0x8(%rdx), %rdx
movq %rdx, 0x8(%rax,%rcx)
movq 0x8(%rsp), %rsi
movq 0x278(%rsp), %rdx
addq $0x10, %rdx
leaq 0x10(%rsp), %rdi
callq 0x10b0
movq 0x8(%rsp), %rdi
callq 0x1070
jmp 0x12c2
movq 0x280(%rsp), %rsi
movq 0x278(%rsp), %rdx
leaq 0x10(%rsp), %rdi
callq 0x10b0
movq 0x2a0(%rsp), %rax
addq 0x288(%rsp), %rax
movq %rax, (%rsp)
movq 0x290(%rsp), %rsi
movq 0x288(%rsp), %rdx
movq 0x2a0(%rsp), %rcx
movq 0x298(%rsp), %r8
movq (%rsp), %r9
leaq 0x10(%rsp), %rdi
callq 0x1060
cmpq $0x0, 0x298(%rsp)
je 0x1326
movq 0x288(%rsp), %rcx
addq $0x10, %rcx
movq 0x298(%rsp), %rax
movq %rcx, (%rax)
xorl %eax, %eax
addq $0x2a8, %rsp            # imm = 0x2A8
retq
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/aes128poetv2aes128ni/ref/encrypt.c
// Function: crypto_aead_decrypt
int crypto_aead_decrypt(unsigned char *m, unsigned long long *mlen,
                        unsigned char *nsec,
                        const unsigned char *c, unsigned long long clen,
                        const unsigned char *ad, unsigned long long adlen,
                        const unsigned char *npub,
                        const unsigned char *k)
{
    poet_ctx_t ctx;
    (void)nsec;
    
    if (clen < CRYPTO_ABYTES) {
        return -1;
    }

    keysetup(&ctx, k);
    
    if (npub) {
        unsigned char *header = malloc((size_t)(adlen + CRYPTO_NPUBBYTES));
        memcpy(header, ad, adlen);
        memcpy(header + adlen, npub, CRYPTO_NPUBBYTES);
        process_header(&ctx, header, adlen + CRYPTO_NPUBBYTES);
        free(header);
    } else {
        process_header(&ctx, ad, adlen);
    }
    
    unsigned char tag[CRYPTO_ABYTES];
    memcpy(tag, c + (clen - CRYPTO_ABYTES), CRYPTO_ABYTES);
    return decrypt_final(&ctx, c, clen - CRYPTO_ABYTES, tag, m, mlen);
}

// Assembly:
subq $0x2b8, %rsp            # imm = 0x2B8
movq 0x2d0(%rsp), %rax
movq 0x2c8(%rsp), %rax
movq 0x2c0(%rsp), %rax
movq %rdi, 0x2a8(%rsp)
movq %rsi, 0x2a0(%rsp)
movq %rdx, 0x298(%rsp)
movq %rcx, 0x290(%rsp)
movq %r8, 0x288(%rsp)
movq %r9, 0x280(%rsp)
cmpq $0x10, 0x288(%rsp)
jae 0x139a
movl $0xffffffff, 0x2b4(%rsp) # imm = 0xFFFFFFFF
jmp 0x14ab
movq 0x2d0(%rsp), %rsi
leaq 0x20(%rsp), %rdi
callq 0x10d0
cmpq $0x0, 0x2c8(%rsp)
je 0x1433
movq 0x2c0(%rsp), %rdi
addq $0x10, %rdi
callq 0x1030
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movq 0x280(%rsp), %rsi
movq 0x2c0(%rsp), %rdx
callq 0x10c0
movq 0x18(%rsp), %rax
movq 0x2c0(%rsp), %rcx
movq 0x2c8(%rsp), %rdx
movq (%rdx), %rsi
movq %rsi, (%rax,%rcx)
movq 0x8(%rdx), %rdx
movq %rdx, 0x8(%rax,%rcx)
movq 0x18(%rsp), %rsi
movq 0x2c0(%rsp), %rdx
addq $0x10, %rdx
leaq 0x20(%rsp), %rdi
callq 0x10b0
movq 0x18(%rsp), %rdi
callq 0x1070
jmp 0x144d
movq 0x280(%rsp), %rsi
movq 0x2c0(%rsp), %rdx
leaq 0x20(%rsp), %rdi
callq 0x10b0
movq 0x290(%rsp), %rax
movq 0x288(%rsp), %rcx
subq $0x10, %rcx
movq (%rax,%rcx), %rdx
movq %rdx, (%rsp)
movq 0x8(%rax,%rcx), %rax
movq %rax, 0x8(%rsp)
movq 0x290(%rsp), %rsi
movq 0x288(%rsp), %rdx
subq $0x10, %rdx
movq %rsp, %rcx
movq 0x2a8(%rsp), %r8
movq 0x2a0(%rsp), %r9
leaq 0x20(%rsp), %rdi
callq 0x1080
movl %eax, 0x2b4(%rsp)
movl 0x2b4(%rsp), %eax
addq $0x2b8, %rsp            # imm = 0x2B8
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/aes128poetv2aes128ni/ref/poet.c
// Function: load_n_bytes
static __m128i load_n_bytes(const uint8_t* p, const size_t num_bytes)
{
    if (num_bytes == 0) {
        return zero;
    } else if (num_bytes % 16 == 0) {
        return _mm_loadu_si128((__m128i*)p);
    } else {
        __m128i tmp;
        unsigned i;

        for (i = 0; i < num_bytes; ++i) {
            ((char*)&tmp)[i] = ((char*)p)[i];
        }

        return tmp;
    }
}

// Assembly:
movq %rdi, -0x30(%rsp)
movq %rsi, -0x38(%rsp)
cmpq $0x0, -0x38(%rsp)
jne 0x256a
vpxor %xmm0, %xmm0, %xmm0
vmovdqa %xmm0, -0x18(%rsp)
vmovdqa -0x18(%rsp), %xmm0
vmovdqa %xmm0, -0x28(%rsp)
jmp 0x25d4
movq -0x38(%rsp), %rax
andq $0xf, %rax
cmpq $0x0, %rax
jne 0x2594
movq -0x30(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
vmovdqu (%rax), %xmm0
vmovdqa %xmm0, -0x28(%rsp)
jmp 0x25d4
movl $0x0, -0x4c(%rsp)
movl -0x4c(%rsp), %eax
cmpq -0x38(%rsp), %rax
jae 0x25c8
movq -0x30(%rsp), %rax
movl -0x4c(%rsp), %ecx
movb (%rax,%rcx), %cl
movl -0x4c(%rsp), %eax
movb %cl, -0x48(%rsp,%rax)
movl -0x4c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rsp)
jmp 0x259c
vmovdqa -0x48(%rsp), %xmm0
vmovdqa %xmm0, -0x28(%rsp)
vmovdqa -0x28(%rsp), %xmm0
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/aes128poetv2aes128ni/ref/poet.c
// Function: aes_create_decryption_key
static void aes_create_decryption_key(const AES_KEY enc_key, AES_KEY dec_key)
{
    dec_key[10] = enc_key[0];
    dec_key[9] = _mm_aesimc_si128(enc_key[1]);
    dec_key[8] = _mm_aesimc_si128(enc_key[2]);
    dec_key[7] = _mm_aesimc_si128(enc_key[3]);
    dec_key[6] = _mm_aesimc_si128(enc_key[4]);
    dec_key[5] = _mm_aesimc_si128(enc_key[5]);
    dec_key[4] = _mm_aesimc_si128(enc_key[6]);
    dec_key[3] = _mm_aesimc_si128(enc_key[7]);
    dec_key[2] = _mm_aesimc_si128(enc_key[8]);
    dec_key[1] = _mm_aesimc_si128(enc_key[9]);
    dec_key[0] = enc_key[10];
}

// Assembly:
subq $0x28, %rsp
movq %rdi, -0x78(%rsp)
movq %rsi, -0x80(%rsp)
movq -0x78(%rsp), %rax
vmovdqa (%rax), %xmm0
movq -0x80(%rsp), %rax
vmovdqa %xmm0, 0xa0(%rax)
movq -0x78(%rsp), %rax
vmovdqa 0x10(%rax), %xmm0
vmovdqa %xmm0, 0x10(%rsp)
vmovdqa 0x10(%rsp), %xmm0
vaesimc %xmm0, %xmm0
movq -0x80(%rsp), %rax
vmovdqa %xmm0, 0x90(%rax)
movq -0x78(%rsp), %rax
vmovdqa 0x20(%rax), %xmm0
vmovdqa %xmm0, (%rsp)
vmovdqa (%rsp), %xmm0
vaesimc %xmm0, %xmm0
movq -0x80(%rsp), %rax
vmovdqa %xmm0, 0x80(%rax)
movq -0x78(%rsp), %rax
vmovdqa 0x30(%rax), %xmm0
vmovdqa %xmm0, -0x10(%rsp)
vmovdqa -0x10(%rsp), %xmm0
vaesimc %xmm0, %xmm0
movq -0x80(%rsp), %rax
vmovdqa %xmm0, 0x70(%rax)
movq -0x78(%rsp), %rax
vmovdqa 0x40(%rax), %xmm0
vmovdqa %xmm0, -0x20(%rsp)
vmovdqa -0x20(%rsp), %xmm0
vaesimc %xmm0, %xmm0
movq -0x80(%rsp), %rax
vmovdqa %xmm0, 0x60(%rax)
movq -0x78(%rsp), %rax
vmovdqa 0x50(%rax), %xmm0
vmovdqa %xmm0, -0x30(%rsp)
vmovdqa -0x30(%rsp), %xmm0
vaesimc %xmm0, %xmm0
movq -0x80(%rsp), %rax
vmovdqa %xmm0, 0x50(%rax)
movq -0x78(%rsp), %rax
vmovdqa 0x60(%rax), %xmm0
vmovdqa %xmm0, -0x40(%rsp)
vmovdqa -0x40(%rsp), %xmm0
vaesimc %xmm0, %xmm0
movq -0x80(%rsp), %rax
vmovdqa %xmm0, 0x40(%rax)
movq -0x78(%rsp), %rax
vmovdqa 0x70(%rax), %xmm0
vmovdqa %xmm0, -0x50(%rsp)
vmovdqa -0x50(%rsp), %xmm0
vaesimc %xmm0, %xmm0
movq -0x80(%rsp), %rax
vmovdqa %xmm0, 0x30(%rax)
movq -0x78(%rsp), %rax
vmovdqa 0x80(%rax), %xmm0
vmovdqa %xmm0, -0x60(%rsp)
vmovdqa -0x60(%rsp), %xmm0
vaesimc %xmm0, %xmm0
movq -0x80(%rsp), %rax
vmovdqa %xmm0, 0x20(%rax)
movq -0x78(%rsp), %rax
vmovdqa 0x90(%rax), %xmm0
vmovdqa %xmm0, -0x70(%rsp)
vmovdqa -0x70(%rsp), %xmm0
vaesimc %xmm0, %xmm0
movq -0x80(%rsp), %rax
vmovdqa %xmm0, 0x10(%rax)
movq -0x78(%rsp), %rax
vmovdqa 0xa0(%rax), %xmm0
movq -0x80(%rsp), %rax
vmovdqa %xmm0, (%rax)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/aes128poetv2aes128ni/ref/poet.c
// Function: shift_left
static __m128i shift_left(__m128i a, const size_t num_bytes) {
    if (num_bytes == 0) {
        return a;
    } else if (num_bytes >= 16) {
        return zero;
    } else if (num_bytes < 8) {
        return shift_left_in(a, num_bytes);
    } else if (num_bytes == 8) { 
        return _mm_slli_si128(a,  8); 
    } else {
        a = _mm_slli_si128(a,  8);
        return _mm_slli_epi64(a, (num_bytes-8) * 8);
    }
}

// Assembly:
subq $0x68, %rsp
vmovdqa %xmm0, 0x10(%rsp)
movq %rdi, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x7a88
vmovdqa 0x10(%rsp), %xmm0
vmovdqa %xmm0, 0x20(%rsp)
jmp 0x7b2c
cmpq $0x10, 0x8(%rsp)
jb 0x7aab
vpxor %xmm0, %xmm0, %xmm0
vmovdqa %xmm0, 0x30(%rsp)
vmovdqa 0x30(%rsp), %xmm0
vmovdqa %xmm0, 0x20(%rsp)
jmp 0x7b2c
cmpq $0x8, 0x8(%rsp)
jae 0x7acb
vmovdqa 0x10(%rsp), %xmm0
movq 0x8(%rsp), %rdi
callq 0xbe60
vmovdqa %xmm0, 0x20(%rsp)
jmp 0x7b2c
cmpq $0x8, 0x8(%rsp)
jne 0x7ae6
vmovdqa 0x10(%rsp), %xmm0
vpslldq $0x8, %xmm0, %xmm0      # xmm0 = zero,zero,zero,zero,zero,zero,zero,zero,xmm0[0,1,2,3,4,5,6,7]
vmovdqa %xmm0, 0x20(%rsp)
jmp 0x7b2c
vmovdqa 0x10(%rsp), %xmm0
vpslldq $0x8, %xmm0, %xmm0      # xmm0 = zero,zero,zero,zero,zero,zero,zero,zero,xmm0[0,1,2,3,4,5,6,7]
vmovdqa %xmm0, 0x10(%rsp)
vmovdqa 0x10(%rsp), %xmm0
movq 0x8(%rsp), %rax
subq $0x8, %rax
shlq $0x3, %rax
vmovdqa %xmm0, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
vmovdqa 0x50(%rsp), %xmm0
movl 0x4c(%rsp), %eax
vmovd %eax, %xmm1
vpsllq %xmm1, %xmm0, %xmm0
vmovdqa %xmm0, 0x20(%rsp)
vmovdqa 0x20(%rsp), %xmm0
addq $0x68, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/aes128poetv2aes128ni/ref/poet.c
// Function: store_partial_left
static void store_partial_left(const uint8_t* p, 
                               __m128i x, 
                               const size_t num_bytes)
{
    if (num_bytes == 0) {
        return;
    } else if (num_bytes >= 16) {
        storeu(p, x);
    } else {
        size_t i;
        char* p_ = (char*)p;
        char* x_ = (char*)&x;

        for (i = 0; i < num_bytes; ++i) {
            p_[i] = x_[i];
        }
    }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
vmovdqa %xmm0, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x7b5e
jmp 0x7bcd
cmpq $0x10, 0x18(%rsp)
jb 0x7b78
movq 0x30(%rsp), %rdi
vmovdqa 0x20(%rsp), %xmm0
callq 0x79a0
jmp 0x7bcb
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x18(%rsp), %rax
jae 0x7bc9
movq (%rsp), %rax
movq 0x10(%rsp), %rcx
movb (%rax,%rcx), %dl
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movb %dl, (%rax,%rcx)
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x7b94
jmp 0x7bcb
jmp 0x7bcd
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/aes128poetv2aes128ni/ref/poet.c
// Function: store_partial_right
static void store_partial_right(const uint8_t* p, 
                                __m128i x, 
                                const size_t num_bytes)
{
    if (num_bytes == 0) {
        return;
    } else if (num_bytes >= 16) {
        storeu(p, x);
    } else {
        size_t i;
        char* p_ = (char*)p;
        char* x_ = (char*)&x;

        for (i = 0; i < num_bytes; ++i) {
            p_[i] = x_[(16 - num_bytes) + i];
        }
    }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
vmovdqa %xmm0, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x7bfe
jmp 0x7c77
cmpq $0x10, 0x18(%rsp)
jb 0x7c18
movq 0x30(%rsp), %rdi
vmovdqa 0x20(%rsp), %xmm0
callq 0x79a0
jmp 0x7c75
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x18(%rsp), %rax
jae 0x7c73
movq (%rsp), %rax
movl $0x10, %ecx
subq 0x18(%rsp), %rcx
addq 0x10(%rsp), %rcx
movb (%rax,%rcx), %dl
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movb %dl, (%rax,%rcx)
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x7c34
jmp 0x7c75
jmp 0x7c77
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/aes128poetv2aes128ni/ref/poet.c
// Function: store_partial_from_left_to_right
static void store_partial_from_left_to_right(const uint8_t* p,
        __m128i x,
        const size_t num_bytes)
{
    if (num_bytes == 0) {
        return;
    } else if (num_bytes >= 16) {
        storeu(p, x);
    } else {
        size_t i;
        char* p_ = (char*)p;
        char* x_ = (char*)&x;

        for (i = 0; i < num_bytes; ++i) {
            p_[(16 - num_bytes) + i] = x_[i];
        }
    }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
vmovdqa %xmm0, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x7c9e
jmp 0x7d17
cmpq $0x10, 0x18(%rsp)
jb 0x7cb8
movq 0x30(%rsp), %rdi
vmovdqa 0x20(%rsp), %xmm0
callq 0x79a0
jmp 0x7d15
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x18(%rsp), %rax
jae 0x7d13
movq (%rsp), %rax
movq 0x10(%rsp), %rcx
movb (%rax,%rcx), %dl
movq 0x8(%rsp), %rax
movl $0x10, %ecx
subq 0x18(%rsp), %rcx
addq 0x10(%rsp), %rcx
movb %dl, (%rax,%rcx)
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x7cd4
jmp 0x7d15
jmp 0x7d17
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/aes128poetv2aes128ni/ref/poet.c
// Function: shift_right
static __m128i shift_right(__m128i a, const size_t num_bytes) {
    if (num_bytes == 0) {
        return a;
    } else if (num_bytes >= 16) {
        return zero;
    } else if (num_bytes < 8) {
        return shift_right_in(a, num_bytes);
    } else if (num_bytes == 8) { 
        return _mm_srli_si128(a,  8); 
    } else {
        a = _mm_srli_si128(a,  8);
        return _mm_srli_epi64(a, (num_bytes-8) * 8);
    }
}

// Assembly:
subq $0x68, %rsp
vmovdqa %xmm0, 0x10(%rsp)
movq %rdi, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0xba58
vmovdqa 0x10(%rsp), %xmm0
vmovdqa %xmm0, 0x20(%rsp)
jmp 0xbafc
cmpq $0x10, 0x8(%rsp)
jb 0xba7b
vpxor %xmm0, %xmm0, %xmm0
vmovdqa %xmm0, 0x30(%rsp)
vmovdqa 0x30(%rsp), %xmm0
vmovdqa %xmm0, 0x20(%rsp)
jmp 0xbafc
cmpq $0x8, 0x8(%rsp)
jae 0xba9b
vmovdqa 0x10(%rsp), %xmm0
movq 0x8(%rsp), %rdi
callq 0xbf20
vmovdqa %xmm0, 0x20(%rsp)
jmp 0xbafc
cmpq $0x8, 0x8(%rsp)
jne 0xbab6
vmovdqa 0x10(%rsp), %xmm0
vpsrldq $0x8, %xmm0, %xmm0      # xmm0 = xmm0[8,9,10,11,12,13,14,15],zero,zero,zero,zero,zero,zero,zero,zero
vmovdqa %xmm0, 0x20(%rsp)
jmp 0xbafc
vmovdqa 0x10(%rsp), %xmm0
vpsrldq $0x8, %xmm0, %xmm0      # xmm0 = xmm0[8,9,10,11,12,13,14,15],zero,zero,zero,zero,zero,zero,zero,zero
vmovdqa %xmm0, 0x10(%rsp)
vmovdqa 0x10(%rsp), %xmm0
movq 0x8(%rsp), %rax
subq $0x8, %rax
shlq $0x3, %rax
vmovdqa %xmm0, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
vmovdqa 0x50(%rsp), %xmm0
movl 0x4c(%rsp), %eax
vmovd %eax, %xmm1
vpsrlq %xmm1, %xmm0, %xmm0
vmovdqa %xmm0, 0x20(%rsp)
vmovdqa 0x20(%rsp), %xmm0
addq $0x68, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/aes128poetv2aes128ni/ref/poet.c
// Function: bit_revert
static __m128i bit_revert(__m128i block)
{
    uint64_t bytes[2];
    store(bytes, block);
    bytes[0] = reverse_bits(bytes[0]);
    bytes[1] = reverse_bits(bytes[1]);
    return load(bytes);
}

// Assembly:
subq $0x28, %rsp
vmovdqa %xmm0, 0x10(%rsp)
movq %rsp, %rdi
vmovdqa 0x10(%rsp), %xmm0
callq 0xbc80
movq (%rsp), %rdi
callq 0xbcc0
movq %rax, (%rsp)
movq 0x8(%rsp), %rdi
callq 0xbcc0
movq %rax, 0x8(%rsp)
movq %rsp, %rdi
callq 0x2490
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/aes128poetv2aes128ni/ref/poet.c
// Function: double_block_in
static __m128i double_block_in(__m128i block) {
    const __m128i mask = _mm_set_epi32(135, 1, 1, 1);
    __m128i tmp = _mm_srai_epi32(block, 31);
    tmp = _mm_and_si128(tmp, mask);
    tmp = _mm_shuffle_epi32(tmp, _MM_SHUFFLE(2, 1, 0, 3));
    block = _mm_slli_epi32(block, 1);
    return vxor(block, tmp);
}

// Assembly:
subq $0x58, %rsp
vmovdqa %xmm0, -0x60(%rsp)
movl $0x87, -0x8(%rsp)
movl $0x1, -0xc(%rsp)
movl $0x1, -0x10(%rsp)
movl $0x1, -0x14(%rsp)
movl -0x10(%rsp), %edx
movl -0xc(%rsp), %ecx
movl -0x8(%rsp), %eax
vmovd -0x14(%rsp), %xmm0
vpinsrd $0x1, %edx, %xmm0, %xmm0
vpinsrd $0x2, %ecx, %xmm0, %xmm0
vpinsrd $0x3, %eax, %xmm0, %xmm0
vmovdqa %xmm0, -0x30(%rsp)
vmovdqa -0x30(%rsp), %xmm0
vmovdqa %xmm0, -0x70(%rsp)
vmovdqa -0x60(%rsp), %xmm0
vmovdqa %xmm0, (%rsp)
movl $0x1f, -0x4(%rsp)
vmovdqa (%rsp), %xmm0
vmovd -0x4(%rsp), %xmm1
vpsrad %xmm1, %xmm0, %xmm0
vmovdqa %xmm0, -0x80(%rsp)
vmovdqa -0x80(%rsp), %xmm1
vmovdqa -0x70(%rsp), %xmm0
vmovdqa %xmm1, 0x20(%rsp)
vmovdqa %xmm0, 0x10(%rsp)
vmovdqa 0x20(%rsp), %xmm0
vmovdqa 0x10(%rsp), %xmm1
vpand %xmm1, %xmm0, %xmm0
vmovdqa %xmm0, -0x80(%rsp)
vmovdqa -0x80(%rsp), %xmm0
vpshufd $0x93, %xmm0, %xmm0     # xmm0 = xmm0[3,0,1,2]
vmovdqa %xmm0, -0x80(%rsp)
vmovdqa -0x60(%rsp), %xmm0
vmovdqa %xmm0, 0x40(%rsp)
movl $0x1, 0x3c(%rsp)
vmovdqa 0x40(%rsp), %xmm0
movl 0x3c(%rsp), %eax
vmovd %eax, %xmm1
vpslld %xmm1, %xmm0, %xmm0
vmovdqa %xmm0, -0x60(%rsp)
vmovdqa -0x60(%rsp), %xmm1
vmovdqa -0x80(%rsp), %xmm0
vmovdqa %xmm1, -0x40(%rsp)
vmovdqa %xmm0, -0x50(%rsp)
vmovdqa -0x40(%rsp), %xmm0
vpxor -0x50(%rsp), %xmm0, %xmm0
addq $0x58, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/aes128poetv2aes128ni/ref/poet.c
// Function: reverse_bits
static unsigned long long reverse_bits(unsigned long long x)
{
    x = ((x & UINT64_C(0x0f0f0f0f0f0f0f0f)) << 4)
        | ((x & UINT64_C(0xf0f0f0f0f0f0f0f0)) >> 4);
    x = ((x & UINT64_C(0x3333333333333333)) << 2)
        | ((x & UINT64_C(0xcccccccccccccccc)) >> 2);
    x = ((x & UINT64_C(0x5555555555555555)) << 1)
        | ((x & UINT64_C(0xaaaaaaaaaaaaaaaa)) >> 1);
    return x;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movabsq $0xf0f0f0f0f0f0f0f, %rax # imm = 0xF0F0F0F0F0F0F0F
andq -0x8(%rsp), %rax
shlq $0x4, %rax
movabsq $-0xf0f0f0f0f0f0f10, %rcx # imm = 0xF0F0F0F0F0F0F0F0
andq -0x8(%rsp), %rcx
shrq $0x4, %rcx
orq %rcx, %rax
movq %rax, -0x8(%rsp)
movabsq $0x3333333333333333, %rax # imm = 0x3333333333333333
andq -0x8(%rsp), %rax
shlq $0x2, %rax
movabsq $-0x3333333333333334, %rcx # imm = 0xCCCCCCCCCCCCCCCC
andq -0x8(%rsp), %rcx
shrq $0x2, %rcx
orq %rcx, %rax
movq %rax, -0x8(%rsp)
movabsq $0x5555555555555555, %rax # imm = 0x5555555555555555
andq -0x8(%rsp), %rax
shlq %rax
movabsq $-0x5555555555555556, %rcx # imm = 0xAAAAAAAAAAAAAAAA
andq -0x8(%rsp), %rcx
shrq %rcx
orq %rcx, %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/aes128poetv2aes128ni/ref/poet.c
// Function: aes_keygen_assist
static __m128i aes_keygen_assist(__m128i temp1, __m128i temp2)
{
    __m128i temp3;
    temp2 = _mm_shuffle_epi32(temp2, 0xff);
    temp3 = _mm_slli_si128(temp1, 0x4);
    temp1 = _mm_xor_si128(temp1, temp3);
    temp3 = _mm_slli_si128(temp3, 0x4);
    temp1 = _mm_xor_si128(temp1, temp3);
    temp3 = _mm_slli_si128(temp3, 0x4);
    temp1 = _mm_xor_si128(temp1, temp3);
    return _mm_xor_si128(temp1, temp2);
}

// Assembly:
subq $0x38, %rsp
vmovdqa %xmm0, -0x60(%rsp)
vmovdqa %xmm1, -0x70(%rsp)
vpbroadcastd -0x64(%rsp), %xmm0
vmovdqa %xmm0, -0x70(%rsp)
vmovdqa -0x60(%rsp), %xmm0
vpslldq $0x4, %xmm0, %xmm0      # xmm0 = zero,zero,zero,zero,xmm0[0,1,2,3,4,5,6,7,8,9,10,11]
vmovdqa %xmm0, -0x80(%rsp)
vmovdqa -0x60(%rsp), %xmm1
vmovdqa -0x80(%rsp), %xmm0
vmovdqa %xmm1, 0x20(%rsp)
vmovdqa %xmm0, 0x10(%rsp)
vmovdqa 0x20(%rsp), %xmm0
vmovdqa 0x10(%rsp), %xmm1
vpxor %xmm1, %xmm0, %xmm0
vmovdqa %xmm0, -0x60(%rsp)
vmovdqa -0x80(%rsp), %xmm0
vpslldq $0x4, %xmm0, %xmm0      # xmm0 = zero,zero,zero,zero,xmm0[0,1,2,3,4,5,6,7,8,9,10,11]
vmovdqa %xmm0, -0x80(%rsp)
vmovdqa -0x60(%rsp), %xmm1
vmovdqa -0x80(%rsp), %xmm0
vmovdqa %xmm1, (%rsp)
vmovdqa %xmm0, -0x10(%rsp)
vmovdqa (%rsp), %xmm0
vmovdqa -0x10(%rsp), %xmm1
vpxor %xmm1, %xmm0, %xmm0
vmovdqa %xmm0, -0x60(%rsp)
vmovdqa -0x80(%rsp), %xmm0
vpslldq $0x4, %xmm0, %xmm0      # xmm0 = zero,zero,zero,zero,xmm0[0,1,2,3,4,5,6,7,8,9,10,11]
vmovdqa %xmm0, -0x80(%rsp)
vmovdqa -0x60(%rsp), %xmm1
vmovdqa -0x80(%rsp), %xmm0
vmovdqa %xmm1, -0x20(%rsp)
vmovdqa %xmm0, -0x30(%rsp)
vmovdqa -0x20(%rsp), %xmm0
vpxor -0x30(%rsp), %xmm0, %xmm0
vmovdqa %xmm0, -0x60(%rsp)
vmovdqa -0x60(%rsp), %xmm1
vmovdqa -0x70(%rsp), %xmm0
vmovdqa %xmm1, -0x40(%rsp)
vmovdqa %xmm0, -0x50(%rsp)
vmovdqa -0x40(%rsp), %xmm0
vpxor -0x50(%rsp), %xmm0, %xmm0
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/aes128poetv2aes128ni/ref/poet.c
// Function: shift_left_in
static __m128i shift_left_in(__m128i a, const size_t num_bytes) {
    size_t count = num_bytes * 8;
    __m128i result, tmp;
    result = _mm_slli_epi64(a, count);
    tmp = _mm_slli_si128(a, 8);
    tmp = _mm_srli_epi64(tmp, 64 - (count));
    result = _mm_or_si128(result, tmp);
    return result;
}

// Assembly:
subq $0x28, %rsp
vmovdqa %xmm0, -0x50(%rsp)
movq %rdi, -0x58(%rsp)
movq -0x58(%rsp), %rax
shlq $0x3, %rax
movq %rax, -0x60(%rsp)
vmovdqa -0x50(%rsp), %xmm0
movl -0x60(%rsp), %eax
vmovdqa %xmm0, -0x10(%rsp)
movl %eax, -0x14(%rsp)
vmovdqa -0x10(%rsp), %xmm0
vmovd -0x14(%rsp), %xmm1
vpsllq %xmm1, %xmm0, %xmm0
vmovdqa %xmm0, -0x70(%rsp)
vmovdqa -0x50(%rsp), %xmm0
vpslldq $0x8, %xmm0, %xmm0      # xmm0 = zero,zero,zero,zero,zero,zero,zero,zero,xmm0[0,1,2,3,4,5,6,7]
vmovdqa %xmm0, -0x80(%rsp)
vmovdqa -0x80(%rsp), %xmm0
movl $0x40, %eax
subq -0x60(%rsp), %rax
vmovdqa %xmm0, 0x10(%rsp)
movl %eax, 0xc(%rsp)
vmovdqa 0x10(%rsp), %xmm0
movl 0xc(%rsp), %eax
vmovd %eax, %xmm1
vpsrlq %xmm1, %xmm0, %xmm0
vmovdqa %xmm0, -0x80(%rsp)
vmovdqa -0x70(%rsp), %xmm1
vmovdqa -0x80(%rsp), %xmm0
vmovdqa %xmm1, -0x30(%rsp)
vmovdqa %xmm0, -0x40(%rsp)
vmovdqa -0x30(%rsp), %xmm0
vpor -0x40(%rsp), %xmm0, %xmm0
vmovdqa %xmm0, -0x70(%rsp)
vmovdqa -0x70(%rsp), %xmm0
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/aes128poetv2aes128ni/ref/poet.c
// Function: shift_right_in
static __m128i shift_right_in(__m128i a, const size_t num_bytes) {
    size_t count = num_bytes * 8;
    __m128i result, tmp;
    result = _mm_srli_epi64(a, count);
    tmp = _mm_srli_si128(a, 8);
    tmp = _mm_slli_epi64(tmp, 64 - (count));
    result = _mm_or_si128(result, tmp);
    return result;
}

// Assembly:
subq $0x28, %rsp
vmovdqa %xmm0, -0x50(%rsp)
movq %rdi, -0x58(%rsp)
movq -0x58(%rsp), %rax
shlq $0x3, %rax
movq %rax, -0x60(%rsp)
vmovdqa -0x50(%rsp), %xmm0
movl -0x60(%rsp), %eax
vmovdqa %xmm0, 0x10(%rsp)
movl %eax, 0xc(%rsp)
vmovdqa 0x10(%rsp), %xmm0
vmovd 0xc(%rsp), %xmm1
vpsrlq %xmm1, %xmm0, %xmm0
vmovdqa %xmm0, -0x70(%rsp)
vmovdqa -0x50(%rsp), %xmm0
vpsrldq $0x8, %xmm0, %xmm0      # xmm0 = xmm0[8,9,10,11,12,13,14,15],zero,zero,zero,zero,zero,zero,zero,zero
vmovdqa %xmm0, -0x80(%rsp)
vmovdqa -0x80(%rsp), %xmm0
movl $0x40, %eax
subq -0x60(%rsp), %rax
vmovdqa %xmm0, -0x10(%rsp)
movl %eax, -0x14(%rsp)
vmovdqa -0x10(%rsp), %xmm0
movl -0x14(%rsp), %eax
vmovd %eax, %xmm1
vpsllq %xmm1, %xmm0, %xmm0
vmovdqa %xmm0, -0x80(%rsp)
vmovdqa -0x70(%rsp), %xmm1
vmovdqa -0x80(%rsp), %xmm0
vmovdqa %xmm1, -0x30(%rsp)
vmovdqa %xmm0, -0x40(%rsp)
vmovdqa -0x30(%rsp), %xmm0
vpor -0x40(%rsp), %xmm0, %xmm0
vmovdqa %xmm0, -0x70(%rsp)
vmovdqa -0x70(%rsp), %xmm0
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/motet-a[P]libforks/examples/communication.c
// Function: main
int main() {
  libforks_ServerConn conn;
  assert(libforks_start(&conn) == libforks_OK);

  int socket_fd;

  assert(libforks_fork(
    conn,
    NULL, // pid_ptr
    &socket_fd, // socket_fd_ptr
    NULL, // exit_fd_ptr
    child_main
  ) == libforks_OK);

  puts("Type text and press enter");
  puts("Exit with Ctrl+D");

  while (true) {
    char c;
    int read_res = read(STDIN_FILENO, &c, 1);
    if (read_res == 0) { // EOF
      break;
    }
    assert(read_res == 1);

    assert(write(socket_fd, &c, 1) == 1);
    assert(read(socket_fd, &c, 1) == 1);
    assert(write(STDOUT_FILENO, &c, 1) == 1);
  }

  assert(libforks_stop(conn) == libforks_OK);
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x1b70
cmpl $0x0, %eax
jne 0x132f
jmp 0x134e
leaq 0x2cce(%rip), %rdi      # 0x4004
leaq 0x2cec(%rip), %rsi      # 0x4029
movl $0x1c, %edx
leaq 0x2cf9(%rip), %rcx      # 0x4042
callq 0x10d0
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %ecx
leaq -0x14(%rbp), %rdx
leaq 0x17f(%rip), %r8        # 0x14e0
movq %rcx, %rsi
callq 0x2340
cmpl $0x0, %eax
jne 0x1370
jmp 0x138f
leaq 0x2cd6(%rip), %rdi      # 0x404d
leaq 0x2cab(%rip), %rsi      # 0x4029
movl $0x26, %edx
leaq 0x2cb8(%rip), %rcx      # 0x4042
callq 0x10d0
leaq 0x2d00(%rip), %rdi      # 0x4096
callq 0x1080
leaq 0x2d0e(%rip), %rdi      # 0x40b0
callq 0x1080
xorl %edi, %edi
leaq -0x15(%rbp), %rsi
movl $0x1, %edx
callq 0x1120
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x13c5
jmp 0x149b
cmpl $0x1, -0x1c(%rbp)
jne 0x13cd
jmp 0x13ec
leaq 0x2ced(%rip), %rdi      # 0x40c1
leaq 0x2c4e(%rip), %rsi      # 0x4029
movl $0x31, %edx
leaq 0x2c5b(%rip), %rcx      # 0x4042
callq 0x10d0
movl -0x14(%rbp), %edi
leaq -0x15(%rbp), %rsi
movl $0x1, %edx
callq 0x10a0
cmpq $0x1, %rax
jne 0x1405
jmp 0x1424
leaq 0x2cc3(%rip), %rdi      # 0x40cf
leaq 0x2c16(%rip), %rsi      # 0x4029
movl $0x33, %edx
leaq 0x2c23(%rip), %rcx      # 0x4042
callq 0x10d0
movl -0x14(%rbp), %edi
leaq -0x15(%rbp), %rsi
movl $0x1, %edx
callq 0x1120
cmpq $0x1, %rax
jne 0x143d
jmp 0x145c
leaq 0x2ca8(%rip), %rdi      # 0x40ec
leaq 0x2bde(%rip), %rsi      # 0x4029
movl $0x34, %edx
leaq 0x2beb(%rip), %rcx      # 0x4042
callq 0x10d0
movl $0x1, %edi
leaq -0x15(%rbp), %rsi
movl $0x1, %edx
callq 0x10a0
cmpq $0x1, %rax
jne 0x1477
jmp 0x1496
leaq 0x2c8a(%rip), %rdi      # 0x4108
leaq 0x2ba4(%rip), %rsi      # 0x4029
movl $0x35, %edx
leaq 0x2bb1(%rip), %rcx      # 0x4042
callq 0x10d0
jmp 0x13a7
movq -0x10(%rbp), %rdi
callq 0x25d0
cmpl $0x0, %eax
jne 0x14ab
jmp 0x14ca
leaq 0x2c77(%rip), %rdi      # 0x4129
leaq 0x2b70(%rip), %rsi      # 0x4029
movl $0x38, %edx
leaq 0x2b7d(%rip), %rcx      # 0x4042
callq 0x10d0
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/motet-a[P]libforks/examples/communication.c
// Function: child_main
static void child_main(libforks_ServerConn conn, int socket_fd) {
  (void)conn;

  // We could use seccomp(2) (on Linux) or pledge(2) (on OpenBSD) here.

  while (true) {
    char c;
    assert(read(socket_fd, &c, 1) == 1);
    c = toupper(c);
    assert(write(socket_fd, &c, 1) == 1);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %edi
leaq -0xd(%rbp), %rsi
movl $0x1, %edx
callq 0x1120
cmpq $0x1, %rax
jne 0x1508
jmp 0x1527
leaq 0x2bdd(%rip), %rdi      # 0x40ec
leaq 0x2b13(%rip), %rsi      # 0x4029
movl $0x14, %edx
leaq 0x2c2a(%rip), %rcx      # 0x414c
callq 0x10d0
movsbl -0xd(%rbp), %edi
callq 0x1070
movb %al, -0xd(%rbp)
movl -0xc(%rbp), %edi
leaq -0xd(%rbp), %rsi
movl $0x1, %edx
callq 0x10a0
cmpq $0x1, %rax
jne 0x154c
jmp 0x156b
leaq 0x2b7c(%rip), %rdi      # 0x40cf
leaq 0x2acf(%rip), %rsi      # 0x4029
movl $0x16, %edx
leaq 0x2be6(%rip), %rcx      # 0x414c
callq 0x10d0
jmp 0x14ef
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/dxwc[P]sfeed/sfeed_twtxt.c
// Function: main
int
main(int argc, char *argv[])
{
	FILE *fp;
	char *name;
	int i;

	if (pledge(argc == 1 ? "stdio" : "stdio rpath", NULL) == -1)
		err(1, "pledge");

	if (argc == 1) {
		printfeed(stdin, "");
	} else {
		for (i = 1; i < argc; i++) {
			if (!(fp = fopen(argv[i], "r")))
				err(1, "fopen: %s", argv[i]);
			name = ((name = strrchr(argv[i], '/'))) ? name + 1 : argv[i];
			printfeed(fp, name);
			if (ferror(fp))
				err(1, "ferror: %s", argv[i]);
			fclose(fp);
		}
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x1, -0x8(%rbp)
jne 0x1317
movq 0x3cdd(%rip), %rax      # 0x4fe0
movq (%rax), %rdi
leaq 0x1d37(%rip), %rsi      # 0x3044
callq 0x1410
jmp 0x1404
movl $0x1, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x1402
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x1cc7(%rip), %rsi      # 0x3004
callq 0x1180
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x136b
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movl $0x1, %edi
leaq 0x1ca2(%rip), %rsi      # 0x3006
movb $0x0, %al
callq 0x1170
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movl $0x2f, %esi
callq 0x10c0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x1399
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x13a9
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1410
movq -0x18(%rbp), %rdi
callq 0x1060
cmpl $0x0, %eax
je 0x13eb
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movl $0x1, %edi
leaq 0x1c2c(%rip), %rsi      # 0x3010
movb $0x0, %al
callq 0x1170
movq -0x18(%rbp), %rdi
callq 0x1070
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x131e
jmp 0x1404
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/dxwc[P]sfeed/sfeed_twtxt.c
// Function: printfeed
static void
printfeed(FILE *fp, const char *feedname)
{
	char *fields[FieldLast];
	struct tm *tm;
	time_t parsedtime;
	ssize_t linelen;

	while ((linelen = getline(&line, &linesize, fp)) > 0) {
		if (line[linelen - 1] == '\n')
			line[--linelen] = '\0';
		if (!parseline(line, fields))
			break;

		parsedtime = 0;
		if (strtotime(fields[FieldUnixTimestamp], &parsedtime))
			continue;
		if (!(tm = gmtime(&parsedtime)))
			err(1, "localtime");

		fprintf(stdout, "%04d-%02d-%02dT%02d:%02d:%02dZ\t",
		        tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
		        tm->tm_hour, tm->tm_min, tm->tm_sec);
		if (feedname[0])
			printf("[%s] ", feedname);
		fputs(fields[FieldTitle], stdout);
		if (fields[FieldLink][0]) {
			fputs(": ", stdout);
			fputs(fields[FieldLink], stdout);
		}
		putchar('\n');
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdx
leaq 0x3ce2(%rip), %rdi      # 0x5110
leaq 0x3ce3(%rip), %rsi      # 0x5118
callq 0x11b0
movq %rax, -0x68(%rbp)
cmpq $0x0, %rax
jle 0x159f
movq 0x3cc1(%rip), %rax      # 0x5110
movq -0x68(%rbp), %rcx
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
jne 0x147b
movq 0x3ca9(%rip), %rax      # 0x5110
movq -0x68(%rbp), %rcx
movq %rcx, %rdx
addq $-0x1, %rdx
movq %rdx, -0x68(%rbp)
movb $0x0, -0x1(%rax,%rcx)
movq 0x3c8e(%rip), %rdi      # 0x5110
leaq -0x50(%rbp), %rsi
callq 0x1f00
cmpq $0x0, %rax
jne 0x1496
jmp 0x159f
movq $0x0, -0x60(%rbp)
movq -0x50(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x1fe0
cmpl $0x0, %eax
je 0x14b5
jmp 0x1423
leaq -0x60(%rbp), %rdi
callq 0x1190
movq %rax, -0x58(%rbp)
cmpq $0x0, %rax
jne 0x14db
movl $0x1, %edi
leaq 0x1b47(%rip), %rsi      # 0x301b
movb $0x0, %al
callq 0x1170
movq 0x3af6(%rip), %rax      # 0x4fd8
movq (%rax), %rdi
movq -0x58(%rbp), %rax
movl 0x14(%rax), %edx
addl $0x76c, %edx            # imm = 0x76C
movq -0x58(%rbp), %rax
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movq -0x58(%rbp), %rax
movl 0xc(%rax), %r8d
movq -0x58(%rbp), %rax
movl 0x8(%rax), %r9d
movq -0x58(%rbp), %rax
movl 0x4(%rax), %r10d
movq -0x58(%rbp), %rax
movl (%rax), %eax
leaq 0x1b04(%rip), %rsi      # 0x3025
movl %r10d, (%rsp)
movl %eax, 0x8(%rsp)
movb $0x0, %al
callq 0x1130
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0x154b
movq -0x10(%rbp), %rsi
leaq 0x1b01(%rip), %rdi      # 0x3045
movb $0x0, %al
callq 0x10a0
movq -0x48(%rbp), %rdi
movq 0x3a82(%rip), %rax      # 0x4fd8
movq (%rax), %rsi
callq 0x10d0
movq -0x40(%rbp), %rax
cmpb $0x0, (%rax)
je 0x1590
movq 0x3a6a(%rip), %rax      # 0x4fd8
movq (%rax), %rsi
leaq 0x1ad3(%rip), %rdi      # 0x304b
callq 0x10d0
movq -0x40(%rbp), %rdi
movq 0x3a50(%rip), %rax      # 0x4fd8
movq (%rax), %rsi
callq 0x10d0
movl $0xa, %edi
callq 0x1030
jmp 0x1423
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cyb70289[P]tt/tests/dft.c
// Function: sample_sine
static void sample_sine(double freq, double rate, int N, double (*s)[2])
{
	double phase = 0;
	double delta = 2 * 3.14159265 * freq / rate;

	for (int i = 0; i < N; i++) {
		s[i][0] = sin(phase);
		s[i][1] = 0;
		phase += delta;
	}
}

// Assembly:
subq $0x38, %rsp
movsd %xmm0, 0x30(%rsp)
movsd %xmm1, 0x28(%rsp)
movl %edi, 0x24(%rsp)
movq %rsi, 0x18(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x67c6(%rip), %xmm0     # 0x8020
mulsd 0x30(%rsp), %xmm0
divsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
cmpl 0x24(%rsp), %eax
jge 0x18d6
movsd 0x10(%rsp), %xmm0
callq 0x1150
movq 0x18(%rsp), %rax
movslq 0x4(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movsd %xmm0, (%rax)
movq 0x18(%rsp), %rax
movslq 0x4(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rax)
movsd 0x8(%rsp), %xmm0
addsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x1874
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cyb70289[P]tt/tests/dft.c
// Function: sample_rect
static void sample_rect(int ones, int N, double(*s)[2])
{
	int i;
	for (i = 0; i < ones; i++) {
		s[i][0] = 1;
		s[i][1] = 0;
	}
	for (; i < N; i++)
		s[i][0]= s[i][1] = 0;
}

// Assembly:
movl %edi, -0x4(%rsp)
movl %esi, -0x8(%rsp)
movq %rdx, -0x10(%rsp)
movl $0x0, -0x14(%rsp)
movl -0x14(%rsp), %eax
cmpl -0x4(%rsp), %eax
jge 0x1942
movq -0x10(%rsp), %rax
movslq -0x14(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movsd 0x6710(%rip), %xmm0     # 0x8028
movsd %xmm0, (%rax)
movq -0x10(%rsp), %rax
movslq -0x14(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rax)
movl -0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rsp)
jmp 0x18f5
jmp 0x1944
movl -0x14(%rsp), %eax
cmpl -0x8(%rsp), %eax
jge 0x198c
movq -0x10(%rsp), %rax
movslq -0x14(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rax)
movq -0x10(%rsp), %rax
movslq -0x14(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
movl -0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rsp)
jmp 0x1944
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/baileywjohnson[P]mpi-matrix-mult/print-matrix.c
// Function: main
int main(int argc, char *argv[]){

	int rows, columns;
	double *A;
	char *in;

	int c;
	if(argc != 3){
		printf("USAGE: print-matrix -i <your filename>\n");
		exit(1);
	}
	while((c = getopt(argc, argv, "i:")) != -1){
		switch(c){
			case 'i':
				in = optarg;	
				break;
			case '?':
				exit(1);
				break;
			default:
				break;
		}
	}

	read_matrix(in, &rows, &columns, &A);
	print_matrix(rows, columns, A);
	free(A);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x3, -0x8(%rbp)
je 0x1224
leaq 0xdf1(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1030
movl $0x1, %edi
callq 0x1040
jmp 0x1226
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
leaq 0xdf8(%rip), %rdx       # 0x202c
callq 0x1050
movl %eax, -0x2c(%rbp)
cmpl $-0x1, %eax
je 0x1276
movl -0x2c(%rbp), %eax
movl %eax, -0x30(%rbp)
subl $0x3f, %eax
je 0x1268
jmp 0x124e
movl -0x30(%rbp), %eax
subl $0x69, %eax
jne 0x1272
jmp 0x1258
movq 0x2d91(%rip), %rax      # 0x3ff0
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x1274
movl $0x1, %edi
callq 0x1040
jmp 0x1274
jmp 0x1226
movq -0x28(%rbp), %rdi
leaq -0x14(%rbp), %rsi
leaq -0x18(%rbp), %rdx
leaq -0x20(%rbp), %rcx
callq 0x14a0
movl -0x14(%rbp), %edi
movl -0x18(%rbp), %esi
movq -0x20(%rbp), %rdx
callq 0x1380
movq -0x20(%rbp), %rdi
callq 0x1080
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/baileywjohnson[P]mpi-matrix-mult/functions.c
// Function: make_matrix
void make_matrix(int m, int n, int l, int u, double **A){
	*A = malloc(sizeof(double) * (n * m));
	int i;
	srand(time(0));
	for(i = 0; i < (n * m); i++){
		double myRand = rand()/(1.0 + RAND_MAX);
		int range = u - l + 1;
		double myRand_scaled = (myRand * range) + l;
		(*A)[i] = myRand_scaled;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl %ecx, -0x10(%rbp)
movq %r8, -0x18(%rbp)
movl -0x8(%rbp), %eax
imull -0x4(%rbp), %eax
movslq %eax, %rdi
shlq $0x3, %rdi
callq 0x1060
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
xorl %eax, %eax
movl %eax, %edi
callq 0x10e0
movl %eax, %edi
callq 0x10a0
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl -0x8(%rbp), %ecx
imull -0x4(%rbp), %ecx
cmpl %ecx, %eax
jge 0x136c
callq 0x10d0
cvtsi2sd %eax, %xmm0
movsd 0xd15(%rip), %xmm1      # 0x2030
divsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movl -0x10(%rbp), %eax
subl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
movsd -0x28(%rbp), %xmm0
cvtsi2sdl -0x2c(%rbp), %xmm2
cvtsi2sdl -0xc(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x38(%rbp), %xmm0
movq -0x18(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x12fc
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/baileywjohnson[P]mpi-matrix-mult/functions.c
// Function: print_matrix
void print_matrix(int m, int n, double* A){
	int i, j;
	int index = 0;
	for(i=0; i<m; i++){
		for(j=0; j<n; j++){
			printf("%f\t", A[index]);
			index += 1;
		}
		printf("\n");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x13ff
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x13e6
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
leaq 0xc6d(%rip), %rdi       # 0x2038
movb $0x1, %al
callq 0x1030
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x13af
leaq 0xc3d(%rip), %rdi       # 0x202a
movb $0x0, %al
callq 0x1030
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x13a0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/baileywjohnson[P]mpi-matrix-mult/functions.c
// Function: write_matrix
void write_matrix(char* out, int m, int n, double* A){
	FILE *fp = fopen(out, "wb");
	//write m to first location in file
	fwrite(&m, sizeof(int), 1, fp);
	//write n to second location in file
	fwrite(&n, sizeof(int), 1, fp);
	//write n integers from A into it ALL IN ONE fwrite()
	fwrite(A, sizeof(double), (n * m), fp);
	fclose(fp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xc0b(%rip), %rsi       # 0x203c
callq 0x1070
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
leaq -0xc(%rbp), %rdi
movl $0x4, %esi
movl $0x1, %edx
callq 0x10c0
movq -0x20(%rbp), %rcx
leaq -0x10(%rbp), %rdi
movl $0x4, %esi
movl $0x1, %edx
callq 0x10c0
movq -0x18(%rbp), %rdi
movl -0x10(%rbp), %eax
imull -0xc(%rbp), %eax
movslq %eax, %rdx
movq -0x20(%rbp), %rcx
movl $0x8, %esi
callq 0x10c0
movq -0x20(%rbp), %rdi
callq 0x10b0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/baileywjohnson[P]mpi-matrix-mult/functions.c
// Function: read_matrix
void read_matrix(char* out, int *m, int *n, double** A){
	int rows, columns;
	FILE *fp = fopen(out, "rb");
	//fread() once to get the rows out of the file
	fread(&rows, sizeof(int), 1, fp);
	*m = rows;
	//fread() again to get the columns out of the file
	fread(&columns, sizeof(int), 1, fp);
	*n = columns;
	//malloc a buffer of the right size to hold the rest of the remaining data
	*A = malloc(sizeof(double) * (rows * columns));
	//fread() the remaining data into buffer
	fread(*A, sizeof(double), (rows * columns), fp);
	fclose(fp);
}

// 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 -0x8(%rbp), %rdi
leaq 0xb7c(%rip), %rsi       # 0x203f
callq 0x1070
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rcx
leaq -0x24(%rbp), %rdi
movl $0x4, %esi
movl $0x1, %edx
callq 0x1090
movl -0x24(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x30(%rbp), %rcx
leaq -0x28(%rbp), %rdi
movl $0x4, %esi
movl $0x1, %edx
callq 0x1090
movl -0x28(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl -0x24(%rbp), %eax
imull -0x28(%rbp), %eax
movslq %eax, %rdi
shlq $0x3, %rdi
callq 0x1060
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movl -0x24(%rbp), %eax
imull -0x28(%rbp), %eax
movslq %eax, %rdx
movq -0x30(%rbp), %rcx
movl $0x8, %esi
callq 0x1090
movq -0x30(%rbp), %rdi
callq 0x10b0
addq $0x30, %rsp
popq %rbp
retq