LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/Aethlas[P]fflz4/fflz4.c
// Function: print_bookmarks
void print_bookmarks(const cJSON *child, const cJSON *children, const unsigned int flag)
{
    cJSON_ArrayForEach(child, children) {
        const cJSON *url = cJSON_GetObjectItemCaseSensitive(child, "uri");
        const cJSON *deep = cJSON_GetObjectItemCaseSensitive(child, "children");

        if (cJSON_IsString(url)) {
            const cJSON *title = cJSON_GetObjectItemCaseSensitive(child, "title");

            if (((flag & (FLAG_T | FLAG_U)) == 0) && cJSON_IsString(title))
                fprintf(stdout, "%s\n%s\n\n", title->valuestring, url->valuestring);
            if (flag & FLAG_U)
                fprintf(stdout, "%s\n", url->valuestring);
            if ((flag & FLAG_T) && cJSON_IsString(title))
                fprintf(stdout, "%s\n", title->valuestring);
        }
        else if (cJSON_IsArray(deep)) {
            print_bookmarks(child, deep, flag);
        }
    }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
cmpq $0x0, 0x28(%rsp)
je 0x25d9
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, (%rsp)
jmp 0x25e1
xorl %eax, %eax
movq %rax, (%rsp)
jmp 0x25e1
movq (%rsp), %rax
movq %rax, 0x30(%rsp)
cmpq $0x0, 0x30(%rsp)
je 0x2733
movq 0x30(%rsp), %rdi
leaq 0x4acd2(%rip), %rsi     # 0x4d2d4
callq 0x48660
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rdi
leaq 0x4ac7f(%rip), %rsi     # 0x4d297
callq 0x48660
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0x47450
cmpl $0x0, %eax
je 0x26fb
movq 0x30(%rsp), %rdi
leaq 0x4ac3d(%rip), %rsi     # 0x4d27e
callq 0x48660
movq %rax, 0x8(%rsp)
movl 0x24(%rsp), %eax
andl $0x6, %eax
cmpl $0x0, %eax
jne 0x2690
movq 0x8(%rsp), %rdi
callq 0x47450
cmpl $0x0, %eax
je 0x2690
movq 0x4e94b(%rip), %rax     # 0x50fb8
movq (%rax), %rdi
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rdx
movq 0x18(%rsp), %rax
movq 0x20(%rax), %rcx
leaq 0x4abff(%rip), %rsi     # 0x4d288
movb $0x0, %al
callq 0x1100
movl 0x24(%rsp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x26bd
movq 0x4e915(%rip), %rax     # 0x50fb8
movq (%rax), %rdi
movq 0x18(%rsp), %rax
movq 0x20(%rax), %rdx
leaq 0x4abdd(%rip), %rsi     # 0x4d293
movb $0x0, %al
callq 0x1100
movl 0x24(%rsp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x26f9
movq 0x8(%rsp), %rdi
callq 0x47450
cmpl $0x0, %eax
je 0x26f9
movq 0x4e8d9(%rip), %rax     # 0x50fb8
movq (%rax), %rdi
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rdx
leaq 0x4aba1(%rip), %rsi     # 0x4d293
movb $0x0, %al
callq 0x1100
jmp 0x271f
movq 0x10(%rsp), %rdi
callq 0x4a3d0
cmpl $0x0, %eax
je 0x271d
movq 0x30(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl 0x24(%rsp), %edx
callq 0x25b0
jmp 0x271f
jmp 0x2721
movq 0x30(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x30(%rsp)
jmp 0x25ea
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Aethlas[P]fflz4/./lib/lz4/lz4.c
// Function: LZ4_initStream
LZ4_stream_t* LZ4_initStream (void* buffer, size_t size)
{
    DEBUGLOG(5, "LZ4_initStream");
    if (buffer == NULL) { return NULL; }
    if (size < sizeof(LZ4_stream_t)) { return NULL; }
#ifndef _MSC_VER  /* for some reason, Visual fails the aligment test on 32-bit x86 :
                     it reports an aligment of 8-bytes,
                     while actually aligning LZ4_stream_t on 4 bytes. */
    if (((size_t)buffer) & (LZ4_stream_t_alignment() - 1)) { return NULL; } /* alignment check */
#endif
    MEM_INIT(buffer, 0, sizeof(LZ4_stream_t));
    return (LZ4_stream_t*)buffer;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0xbb01
movq $0x0, 0x20(%rsp)
jmp 0xbb61
cmpq $0x4020, 0x10(%rsp)     # imm = 0x4020
jae 0xbb17
movq $0x0, 0x20(%rsp)
jmp 0xbb61
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0x23320
movq %rax, %rcx
movq 0x8(%rsp), %rax
subq $0x1, %rcx
andq %rcx, %rax
cmpq $0x0, %rax
je 0xbb46
movq $0x0, 0x20(%rsp)
jmp 0xbb61
movq 0x18(%rsp), %rdi
xorl %esi, %esi
movl $0x4020, %edx           # imm = 0x4020
callq 0x10c0
movq 0x18(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Aethlas[P]fflz4/./lib/lz4/lz4.c
// Function: LZ4_createStream
LZ4_stream_t* LZ4_createStream(void)
{
    LZ4_stream_t* const lz4s = (LZ4_stream_t*)ALLOC(sizeof(LZ4_stream_t));
    LZ4_STATIC_ASSERT(LZ4_STREAMSIZE >= sizeof(LZ4_stream_t_internal));    /* A compilation error here means LZ4_STREAMSIZE is not large enough */
    DEBUGLOG(4, "LZ4_createStream %p", lz4s);
    if (lz4s == NULL) return NULL;
    LZ4_initStream(lz4s, sizeof(*lz4s));
    return lz4s;
}

// Assembly:
subq $0x18, %rsp
movl $0x4020, %edi           # imm = 0x4020
callq 0x1228
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x232f6
movq $0x0, 0x10(%rsp)
jmp 0x2330f
movq 0x8(%rsp), %rdi
movl $0x4020, %esi           # imm = 0x4020
callq 0xbae0
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Aethlas[P]fflz4/./lib/lz4/lz4.c
// Function: LZ4_attach_dictionary
void LZ4_attach_dictionary(LZ4_stream_t* workingStream, const LZ4_stream_t* dictionaryStream) {
    const LZ4_stream_t_internal* dictCtx = dictionaryStream == NULL ? NULL :
        &(dictionaryStream->internal_donotuse);

    DEBUGLOG(4, "LZ4_attach_dictionary (%p, %p, size %u)",
             workingStream, dictionaryStream,
             dictCtx != NULL ? dictCtx->dictSize : 0);

    /* Calling LZ4_resetStream_fast() here makes sure that changes will not be
     * erased by subsequent calls to LZ4_resetStream_fast() in case stream was
     * marked as having dirty context, e.g. requiring full reset.
     */
    LZ4_resetStream_fast(workingStream);

    if (dictCtx != NULL) {
        /* If the current offset is zero, we will never look in the
         * external dictionary context, since there is no value a table
         * entry can take that indicate a miss. In that case, we need
         * to bump the offset to something non-zero.
         */
        if (workingStream->internal_donotuse.currentOffset == 0) {
            workingStream->internal_donotuse.currentOffset = 64 KB;
        }

        /* Don't actually attach an empty dictionary.
         */
        if (dictCtx->dictSize == 0) {
            dictCtx = NULL;
        }
    }
    workingStream->internal_donotuse.dictCtx = dictCtx;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x236ef
xorl %eax, %eax
movq %rax, 0x8(%rsp)
jmp 0x236f9
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
callq 0x23360
cmpq $0x0, 0x10(%rsp)
je 0x2374b
movq 0x20(%rsp), %rax
cmpl $0x0, 0x4000(%rax)
jne 0x23732
movq 0x20(%rsp), %rax
movl $0x10000, 0x4000(%rax)  # imm = 0x10000
movq 0x10(%rsp), %rax
cmpl $0x0, 0x4018(%rax)
jne 0x23749
movq $0x0, 0x10(%rsp)
jmp 0x2374b
movq 0x10(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x4010(%rax)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Aethlas[P]fflz4/./lib/lz4/lz4.c
// Function: LZ4_renormDictT
static void LZ4_renormDictT(LZ4_stream_t_internal* LZ4_dict, int nextSize)
{
    assert(nextSize >= 0);
    if (LZ4_dict->currentOffset + (unsigned)nextSize > 0x80000000) {   /* potential ptrdiff_t overflow (32-bits mode) */
        /* rescale hash table */
        U32 const delta = LZ4_dict->currentOffset - 64 KB;
        const BYTE* dictEnd = LZ4_dict->dictionary + LZ4_dict->dictSize;
        int i;
        DEBUGLOG(4, "LZ4_renormDictT");
        for (i=0; i<LZ4_HASH_SIZE_U32; i++) {
            if (LZ4_dict->hashTable[i] < delta) LZ4_dict->hashTable[i]=0;
            else LZ4_dict->hashTable[i] -= delta;
        }
        LZ4_dict->currentOffset = 64 KB;
        if (LZ4_dict->dictSize > 64 KB) LZ4_dict->dictSize = 64 KB;
        LZ4_dict->dictionary = dictEnd - LZ4_dict->dictSize;
    }
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movq -0x8(%rsp), %rax
movl 0x4000(%rax), %eax
addl -0xc(%rsp), %eax
cmpl $0x80000000, %eax       # imm = 0x80000000
jbe 0x31788
movq -0x8(%rsp), %rax
movl 0x4000(%rax), %eax
subl $0x10000, %eax          # imm = 0x10000
movl %eax, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq 0x4008(%rax), %rax
movq -0x8(%rsp), %rcx
movl 0x4018(%rcx), %ecx
addq %rcx, %rax
movq %rax, -0x18(%rsp)
movl $0x0, -0x1c(%rsp)
cmpl $0x1000, -0x1c(%rsp)    # imm = 0x1000
jge 0x31733
movq -0x8(%rsp), %rax
movslq -0x1c(%rsp), %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x10(%rsp), %eax
jae 0x3170e
movq -0x8(%rsp), %rax
movslq -0x1c(%rsp), %rcx
movl $0x0, (%rax,%rcx,4)
jmp 0x31724
movl -0x10(%rsp), %esi
movq -0x8(%rsp), %rax
movslq -0x1c(%rsp), %rcx
movl (%rax,%rcx,4), %edx
subl %esi, %edx
movl %edx, (%rax,%rcx,4)
jmp 0x31726
movl -0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rsp)
jmp 0x316de
movq -0x8(%rsp), %rax
movl $0x10000, 0x4000(%rax)  # imm = 0x10000
movq -0x8(%rsp), %rax
cmpl $0x10000, 0x4018(%rax)  # imm = 0x10000
jbe 0x31762
movq -0x8(%rsp), %rax
movl $0x10000, 0x4018(%rax)  # imm = 0x10000
movq -0x18(%rsp), %rcx
movq -0x8(%rsp), %rax
movl 0x4018(%rax), %eax
movl %eax, %edx
xorl %eax, %eax
subq %rdx, %rax
addq %rax, %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x4008(%rax)
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Aethlas[P]fflz4/./lib/lz4/lz4.c
// Function: LZ4_saveDict
int LZ4_saveDict (LZ4_stream_t* LZ4_dict, char* safeBuffer, int dictSize)
{
    LZ4_stream_t_internal* const dict = &LZ4_dict->internal_donotuse;
    const BYTE* const previousDictEnd = dict->dictionary + dict->dictSize;

    if ((U32)dictSize > 64 KB) { dictSize = 64 KB; } /* useless to define a dictionary > 64 KB */
    if ((U32)dictSize > dict->dictSize) { dictSize = (int)dict->dictSize; }

    memmove(safeBuffer, previousDictEnd - dictSize, dictSize);

    dict->dictionary = (const BYTE*)safeBuffer;
    dict->dictSize = (U32)dictSize;

    return dictSize;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x4008(%rax), %rax
movq 0x8(%rsp), %rcx
movl 0x4018(%rcx), %ecx
addq %rcx, %rax
movq %rax, (%rsp)
cmpl $0x10000, 0x14(%rsp)    # imm = 0x10000
jbe 0x3618c
movl $0x10000, 0x14(%rsp)    # imm = 0x10000
movl 0x14(%rsp), %eax
movq 0x8(%rsp), %rcx
cmpl 0x4018(%rcx), %eax
jbe 0x361ac
movq 0x8(%rsp), %rax
movl 0x4018(%rax), %eax
movl %eax, 0x14(%rsp)
movq 0x18(%rsp), %rdi
movq (%rsp), %rsi
movslq 0x14(%rsp), %rcx
xorl %eax, %eax
subq %rcx, %rax
addq %rax, %rsi
movslq 0x14(%rsp), %rdx
callq 0x11a0
movq 0x18(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x4008(%rax)
movl 0x14(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x4018(%rax)
movl 0x14(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Aethlas[P]fflz4/./lib/lz4/lz4.c
// Function: LZ4_setStreamDecode
int LZ4_setStreamDecode (LZ4_streamDecode_t* LZ4_streamDecode, const char* dictionary, int dictSize)
{
    LZ4_streamDecode_t_internal* lz4sd = &LZ4_streamDecode->internal_donotuse;
    lz4sd->prefixSize = (size_t) dictSize;
    lz4sd->prefixEnd = (const BYTE*) dictionary + dictSize;
    lz4sd->externalDict = NULL;
    lz4sd->extDictSize  = 0;
    return 1;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl %edx, -0x14(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x20(%rsp)
movslq -0x14(%rsp), %rcx
movq -0x20(%rsp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rsp), %rcx
movslq -0x14(%rsp), %rax
addq %rax, %rcx
movq -0x20(%rsp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rsp), %rax
movq $0x0, (%rax)
movq -0x20(%rsp), %rax
movq $0x0, 0x8(%rax)
movl $0x1, %eax
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Aethlas[P]fflz4/./lib/lz4/lz4.c
// Function: LZ4_decoderRingBufferSize
int LZ4_decoderRingBufferSize(int maxBlockSize)
{
    if (maxBlockSize < 0) return 0;
    if (maxBlockSize > LZ4_MAX_INPUT_SIZE) return 0;
    if (maxBlockSize < 16) maxBlockSize = 16;
    return LZ4_DECODER_RING_BUFFER_SIZE(maxBlockSize);
}

// Assembly:
movl %edi, -0x8(%rsp)
cmpl $0x0, -0x8(%rsp)
jge 0x3f0f5
movl $0x0, -0x4(%rsp)
jmp 0x3f125
cmpl $0x7e000000, -0x8(%rsp) # imm = 0x7E000000
jle 0x3f109
movl $0x0, -0x4(%rsp)
jmp 0x3f125
cmpl $0x10, -0x8(%rsp)
jge 0x3f118
movl $0x10, -0x8(%rsp)
movl -0x8(%rsp), %eax
addl $0x1000e, %eax          # imm = 0x1000E
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Aethlas[P]fflz4/./lib/lz4/lz4.c
// Function: LZ4_decompress_safe_usingDict
int LZ4_decompress_safe_usingDict(const char* source, char* dest, int compressedSize, int maxOutputSize, const char* dictStart, int dictSize)
{
    if (dictSize==0)
        return LZ4_decompress_safe(source, dest, compressedSize, maxOutputSize);
    if (dictStart+dictSize == dest) {
        if (dictSize >= 64 KB - 1) {
            return LZ4_decompress_safe_withPrefix64k(source, dest, compressedSize, maxOutputSize);
        }
        assert(dictSize >= 0);
        return LZ4_decompress_safe_withSmallPrefix(source, dest, compressedSize, maxOutputSize, (size_t)dictSize);
    }
    assert(dictSize >= 0);
    return LZ4_decompress_safe_forceExtDict(source, dest, compressedSize, maxOutputSize, dictStart, (size_t)dictSize);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movl %edx, 0x1c(%rsp)
movl %ecx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movl %r9d, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jne 0x467b7
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl 0x1c(%rsp), %edx
movl 0x18(%rsp), %ecx
callq 0x36200
movl %eax, 0x34(%rsp)
jmp 0x46839
movq 0x10(%rsp), %rax
movslq 0xc(%rsp), %rcx
addq %rcx, %rax
cmpq 0x20(%rsp), %rax
jne 0x46814
cmpl $0xffff, 0xc(%rsp)      # imm = 0xFFFF
jl 0x467f2
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl 0x1c(%rsp), %edx
movl 0x18(%rsp), %ecx
callq 0x3b730
movl %eax, 0x34(%rsp)
jmp 0x46839
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl 0x1c(%rsp), %edx
movl 0x18(%rsp), %ecx
movslq 0xc(%rsp), %r8
callq 0x41010
movl %eax, 0x34(%rsp)
jmp 0x46839
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl 0x1c(%rsp), %edx
movl 0x18(%rsp), %ecx
movq 0x10(%rsp), %r8
movslq 0xc(%rsp), %r9
callq 0x3d3b0
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Aethlas[P]fflz4/./lib/lz4/lz4.c
// Function: LZ4_putPositionOnHash
static void LZ4_putPositionOnHash(const BYTE* p, U32 h,
                                  void* tableBase, tableType_t const tableType,
                            const BYTE* srcBase)
{
    switch (tableType)
    {
    case clearedTable: { /* illegal! */ assert(0); return; }
    case byPtr: { const BYTE** hashTable = (const BYTE**)tableBase; hashTable[h] = p; return; }
    case byU32: { U32* hashTable = (U32*) tableBase; hashTable[h] = (U32)(p-srcBase); return; }
    case byU16: { U16* hashTable = (U16*) tableBase; hashTable[h] = (U16)(p-srcBase); return; }
    }
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movq %rdx, -0x18(%rsp)
movl %ecx, -0x1c(%rsp)
movq %r8, -0x28(%rsp)
movl -0x1c(%rsp), %eax
movq %rax, -0x48(%rsp)
subq $0x3, %rax
ja 0x46cdd
movq -0x48(%rsp), %rax
leaq 0x67fa(%rip), %rcx      # 0x4d460
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0x46cdd
movq -0x18(%rsp), %rax
movq %rax, -0x30(%rsp)
movq -0x8(%rsp), %rdx
movq -0x30(%rsp), %rax
movl -0xc(%rsp), %ecx
movq %rdx, (%rax,%rcx,8)
jmp 0x46cdd
movq -0x18(%rsp), %rax
movq %rax, -0x38(%rsp)
movq -0x8(%rsp), %rax
movq -0x28(%rsp), %rcx
subq %rcx, %rax
movl %eax, %edx
movq -0x38(%rsp), %rax
movl -0xc(%rsp), %ecx
movl %edx, (%rax,%rcx,4)
jmp 0x46cdd
movq -0x18(%rsp), %rax
movq %rax, -0x40(%rsp)
movq -0x8(%rsp), %rax
movq -0x28(%rsp), %rcx
subq %rcx, %rax
movw %ax, %dx
movq -0x40(%rsp), %rax
movl -0xc(%rsp), %ecx
movw %dx, (%rax,%rcx,2)
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Aethlas[P]fflz4/./lib/lz4/lz4.c
// Function: LZ4_getIndexOnHash
static U32 LZ4_getIndexOnHash(U32 h, const void* tableBase, tableType_t tableType)
{
    LZ4_STATIC_ASSERT(LZ4_MEMORY_USAGE > 2);
    if (tableType == byU32) {
        const U32* const hashTable = (const U32*) tableBase;
        assert(h < (1U << (LZ4_MEMORY_USAGE-2)));
        return hashTable[h];
    }
    if (tableType == byU16) {
        const U16* const hashTable = (const U16*) tableBase;
        assert(h < (1U << (LZ4_MEMORY_USAGE-1)));
        return hashTable[h];
    }
    assert(0); return 0;  /* forbidden case */
}

// Assembly:
movl %edi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl %edx, -0x14(%rsp)
cmpl $0x2, -0x14(%rsp)
jne 0x46d20
movq -0x10(%rsp), %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rax
movl -0x8(%rsp), %ecx
movl (%rax,%rcx,4), %eax
movl %eax, -0x4(%rsp)
jmp 0x46d4c
cmpl $0x3, -0x14(%rsp)
jne 0x46d44
movq -0x10(%rsp), %rax
movq %rax, -0x28(%rsp)
movq -0x28(%rsp), %rax
movl -0x8(%rsp), %ecx
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rsp)
jmp 0x46d4c
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Aethlas[P]fflz4/./lib/lz4/lz4.c
// Function: LZ4_putIndexOnHash
static void LZ4_putIndexOnHash(U32 idx, U32 h, void* tableBase, tableType_t const tableType)
{
    switch (tableType)
    {
    default: /* fallthrough */
    case clearedTable: /* fallthrough */
    case byPtr: { /* illegal! */ assert(0); return; }
    case byU32: { U32* hashTable = (U32*) tableBase; hashTable[h] = idx; return; }
    case byU16: { U16* hashTable = (U16*) tableBase; assert(idx < 65536); hashTable[h] = (U16)idx; return; }
    }
}

// Assembly:
movl %edi, -0x4(%rsp)
movl %esi, -0x8(%rsp)
movq %rdx, -0x10(%rsp)
movl %ecx, -0x14(%rsp)
movl -0x14(%rsp), %eax
movl %eax, -0x2c(%rsp)
subl $0x2, %eax
jb 0x46d98
jmp 0x46d80
movl -0x2c(%rsp), %eax
subl $0x2, %eax
je 0x46d9a
jmp 0x46d8b
movl -0x2c(%rsp), %eax
subl $0x3, %eax
je 0x46db6
jmp 0x46d96
jmp 0x46d98
jmp 0x46dd4
movq -0x10(%rsp), %rax
movq %rax, -0x20(%rsp)
movl -0x4(%rsp), %edx
movq -0x20(%rsp), %rax
movl -0x8(%rsp), %ecx
movl %edx, (%rax,%rcx,4)
jmp 0x46dd4
movq -0x10(%rsp), %rax
movq %rax, -0x28(%rsp)
movl -0x4(%rsp), %eax
movw %ax, %dx
movq -0x28(%rsp), %rax
movl -0x8(%rsp), %ecx
movw %dx, (%rax,%rcx,2)
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Aethlas[P]fflz4/./lib/lz4/lz4.c
// Function: LZ4_wildCopy8
LZ4_FORCE_O2_INLINE_GCC_PPC64LE
void LZ4_wildCopy8(void* dstPtr, const void* srcPtr, void* dstEnd)
{
    BYTE* d = (BYTE*)dstPtr;
    const BYTE* s = (const BYTE*)srcPtr;
    BYTE* const e = (BYTE*)dstEnd;

    do { memcpy(d,s,8); d+=8; s+=8; } while (d<e);
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x20(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x28(%rsp)
movq -0x18(%rsp), %rax
movq %rax, -0x30(%rsp)
movq -0x20(%rsp), %rax
movq -0x28(%rsp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq -0x20(%rsp), %rax
addq $0x8, %rax
movq %rax, -0x20(%rsp)
movq -0x28(%rsp), %rax
addq $0x8, %rax
movq %rax, -0x28(%rsp)
movq -0x20(%rsp), %rax
cmpq -0x30(%rsp), %rax
jb 0x46e0d
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Aethlas[P]fflz4/./lib/lz4/lz4.c
// Function: LZ4_writeLE16
static void LZ4_writeLE16(void* memPtr, U16 value)
{
    if (LZ4_isLittleEndian()) {
        LZ4_write16(memPtr, value);
    } else {
        BYTE* p = (BYTE*)memPtr;
        p[0] = (BYTE) value;
        p[1] = (BYTE)(value>>8);
    }
}

// Assembly:
subq $0x18, %rsp
movw %si, %ax
movq %rdi, 0x10(%rsp)
movw %ax, 0xe(%rsp)
callq 0x47060
cmpl $0x0, %eax
je 0x46e7c
movq 0x10(%rsp), %rdi
movzwl 0xe(%rsp), %esi
callq 0x47070
jmp 0x46ea3
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movw 0xe(%rsp), %ax
movb %al, %cl
movq (%rsp), %rax
movb %cl, (%rax)
movzwl 0xe(%rsp), %eax
sarl $0x8, %eax
movb %al, %cl
movq (%rsp), %rax
movb %cl, 0x1(%rax)
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Aethlas[P]fflz4/./lib/lz4/lz4.c
// Function: LZ4_clearHash
static void LZ4_clearHash(U32 h, void* tableBase, tableType_t const tableType)
{
    switch (tableType)
    {
    default: /* fallthrough */
    case clearedTable: { /* illegal! */ assert(0); return; }
    case byPtr: { const BYTE** hashTable = (const BYTE**)tableBase; hashTable[h] = NULL; return; }
    case byU32: { U32* hashTable = (U32*) tableBase; hashTable[h] = 0; return; }
    case byU16: { U16* hashTable = (U16*) tableBase; hashTable[h] = 0; return; }
    }
}

// Assembly:
movl %edi, -0x4(%rsp)
movq %rsi, -0x10(%rsp)
movl %edx, -0x14(%rsp)
movl -0x14(%rsp), %eax
movq %rax, -0x38(%rsp)
subq $0x3, %rax
ja 0x46ee1
movq -0x38(%rsp), %rax
leaq 0x6598(%rip), %rcx      # 0x4d470
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0x46ee3
jmp 0x46f37
movq -0x10(%rsp), %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rax
movl -0x4(%rsp), %ecx
movq $0x0, (%rax,%rcx,8)
jmp 0x46f37
movq -0x10(%rsp), %rax
movq %rax, -0x28(%rsp)
movq -0x28(%rsp), %rax
movl -0x4(%rsp), %ecx
movl $0x0, (%rax,%rcx,4)
jmp 0x46f37
movq -0x10(%rsp), %rax
movq %rax, -0x30(%rsp)
movq -0x30(%rsp), %rax
movl -0x4(%rsp), %ecx
movw $0x0, (%rax,%rcx,2)
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Aethlas[P]fflz4/./lib/lz4/lz4.c
// Function: LZ4_hash5
static U32 LZ4_hash5(U64 sequence, tableType_t const tableType)
{
    const U32 hashLog = (tableType == byU16) ? LZ4_HASHLOG+1 : LZ4_HASHLOG;
    if (LZ4_isLittleEndian()) {
        const U64 prime5bytes = 889523592379ULL;
        return (U32)(((sequence << 24) * prime5bytes) >> (64 - hashLog));
    } else {
        const U64 prime8bytes = 11400714785074694791ULL;
        return (U32)(((sequence >> 24) * prime8bytes) >> (64 - hashLog));
    }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movl 0x14(%rsp), %edx
movl $0xc, %eax
movl $0xd, %ecx
cmpl $0x3, %edx
cmovel %ecx, %eax
movl %eax, 0x10(%rsp)
callq 0x47060
cmpl $0x0, %eax
je 0x46fc9
movabsq $0xcf1bbcdcbb, %rax     # imm = 0xCF1BBCDCBB
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
shlq $0x18, %rax
movabsq $0xcf1bbcdcbb, %rcx     # imm = 0xCF1BBCDCBB
imulq %rcx, %rax
movl $0x40, %ecx
subl 0x10(%rsp), %ecx
movl %ecx, %ecx
shrq %cl, %rax
movl %eax, 0x24(%rsp)
jmp 0x47000
movabsq $-0x61c8864e7a143579, %rax # imm = 0x9E3779B185EBCA87
movq %rax, (%rsp)
movq 0x18(%rsp), %rax
shrq $0x18, %rax
movabsq $-0x61c8864e7a143579, %rcx # imm = 0x9E3779B185EBCA87
imulq %rcx, %rax
movl $0x40, %ecx
subl 0x10(%rsp), %ecx
movl %ecx, %ecx
shrq %cl, %rax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Aethlas[P]fflz4/./lib/lz4/lz4.c
// Function: LZ4_wildCopy32
LZ4_FORCE_O2_INLINE_GCC_PPC64LE void
LZ4_wildCopy32(void* dstPtr, const void* srcPtr, void* dstEnd)
{
    BYTE* d = (BYTE*)dstPtr;
    const BYTE* s = (const BYTE*)srcPtr;
    BYTE* const e = (BYTE*)dstEnd;

    do { memcpy(d,s,16); memcpy(d+16,s+16,16); d+=32; s+=32; } while (d<e);
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x20(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x28(%rsp)
movq -0x18(%rsp), %rax
movq %rax, -0x30(%rsp)
movq -0x20(%rsp), %rax
movq -0x28(%rsp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq -0x20(%rsp), %rax
movq -0x28(%rsp), %rcx
movq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rax)
movq 0x18(%rcx), %rcx
movq %rcx, 0x18(%rax)
movq -0x20(%rsp), %rax
addq $0x20, %rax
movq %rax, -0x20(%rsp)
movq -0x28(%rsp), %rax
addq $0x20, %rax
movq %rax, -0x28(%rsp)
movq -0x20(%rsp), %rax
cmpq -0x30(%rsp), %rax
jb 0x4711d
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Aethlas[P]fflz4/./lib/lz4/lz4.c
// Function: LZ4_memcpy_using_offset
LZ4_FORCE_O2_INLINE_GCC_PPC64LE void
LZ4_memcpy_using_offset(BYTE* dstPtr, const BYTE* srcPtr, BYTE* dstEnd, const size_t offset)
{
    BYTE v[8];

    assert(dstEnd >= dstPtr + MINMATCH);
    LZ4_write32(dstPtr, 0);   /* silence an msan warning when offset==0 */

    switch(offset) {
    case 1:
        memset(v, *srcPtr, 8);
        break;
    case 2:
        memcpy(v, srcPtr, 2);
        memcpy(&v[2], srcPtr, 2);
        memcpy(&v[4], &v[0], 4);
        break;
    case 4:
        memcpy(v, srcPtr, 4);
        memcpy(&v[4], srcPtr, 4);
        break;
    default:
        LZ4_memcpy_using_offset_base(dstPtr, srcPtr, dstEnd, offset);
        return;
    }

    memcpy(dstPtr, v, 8);
    dstPtr += 8;
    while (dstPtr < dstEnd) {
        memcpy(dstPtr, v, 8);
        dstPtr += 8;
    }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x30(%rsp), %rdi
xorl %esi, %esi
callq 0x46f40
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
subq $0x1, %rax
je 0x47230
jmp 0x47216
movq 0x8(%rsp), %rax
subq $0x2, %rax
je 0x4724c
jmp 0x47223
movq 0x8(%rsp), %rax
subq $0x4, %rax
je 0x47270
jmp 0x47288
leaq 0x10(%rsp), %rdi
movq 0x28(%rsp), %rax
movzbl (%rax), %eax
movl $0x8, %edx
movzbl %al, %esi
callq 0x10c0
jmp 0x472a3
movq 0x28(%rsp), %rax
movw (%rax), %ax
movw %ax, 0x10(%rsp)
movq 0x28(%rsp), %rax
movw (%rax), %ax
movw %ax, 0x12(%rsp)
movl 0x10(%rsp), %eax
movl %eax, 0x14(%rsp)
jmp 0x472a3
movq 0x28(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x10(%rsp)
movq 0x28(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x14(%rsp)
jmp 0x472a3
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq 0x18(%rsp), %rcx
callq 0x472f0
jmp 0x472e7
movq 0x30(%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rcx, (%rax)
movq 0x30(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
cmpq 0x20(%rsp), %rax
jae 0x472e7
movq 0x30(%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rcx, (%rax)
movq 0x30(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x30(%rsp)
jmp 0x472be
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Aethlas[P]fflz4/./lib/lz4/lz4.c
// Function: LZ4_memcpy_using_offset_base
LZ4_FORCE_O2_INLINE_GCC_PPC64LE void
LZ4_memcpy_using_offset_base(BYTE* dstPtr, const BYTE* srcPtr, BYTE* dstEnd, const size_t offset)
{
    if (offset < 8) {
        dstPtr[0] = srcPtr[0];
        dstPtr[1] = srcPtr[1];
        dstPtr[2] = srcPtr[2];
        dstPtr[3] = srcPtr[3];
        srcPtr += inc32table[offset];
        memcpy(dstPtr+4, srcPtr, 4);
        srcPtr -= dec64table[offset];
        dstPtr += 8;
    } else {
        memcpy(dstPtr, srcPtr, 8);
        dstPtr += 8;
        srcPtr += 8;
    }

    LZ4_wildCopy8(dstPtr, srcPtr, dstEnd);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
cmpq $0x8, 0x8(%rsp)
jae 0x473b3
movq 0x18(%rsp), %rax
movb (%rax), %cl
movq 0x20(%rsp), %rax
movb %cl, (%rax)
movq 0x18(%rsp), %rax
movb 0x1(%rax), %cl
movq 0x20(%rsp), %rax
movb %cl, 0x1(%rax)
movq 0x18(%rsp), %rax
movb 0x2(%rax), %cl
movq 0x20(%rsp), %rax
movb %cl, 0x2(%rax)
movq 0x18(%rsp), %rax
movb 0x3(%rax), %cl
movq 0x20(%rsp), %rax
movb %cl, 0x3(%rax)
movq 0x8(%rsp), %rcx
leaq 0x6122(%rip), %rax      # 0x4d480
movl (%rax,%rcx,4), %ecx
movq 0x18(%rsp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq 0x18(%rsp), %rcx
movl (%rcx), %ecx
movl %ecx, 0x4(%rax)
movq 0x8(%rsp), %rcx
leaq 0x6115(%rip), %rax      # 0x4d4a0
movl (%rax,%rcx,4), %ecx
movq 0x18(%rsp), %rax
movslq %ecx, %rdx
xorl %ecx, %ecx
subq %rdx, %rcx
addq %rcx, %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x20(%rsp)
jmp 0x473df
movq 0x20(%rsp), %rax
movq 0x18(%rsp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq 0x20(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x20(%rsp)
movq 0x18(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x46de0
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ender672[P]liboil/oil_libjpeg.c
// Function: oil_libjpeg_init
int oil_libjpeg_init(struct oil_libjpeg *ol,
	struct jpeg_decompress_struct *dinfo, int out_width, int out_height)
{
	int ret;
	enum oil_colorspace cs;

	ol->dinfo = dinfo;

	cs = jpeg_cs_to_oil(dinfo->out_color_space);
	if (cs == OIL_CS_UNKNOWN) {
		return -1;
	}

	ol->inbuf = malloc(dinfo->output_width * dinfo->output_components);
	if (!ol->inbuf) {
		return -2;
	}

	ret = oil_scale_init(&ol->os, dinfo->output_height, out_height,
		dinfo->output_width, out_width, cs);
	if (ret!=0) {
		free(ol->inbuf);
		return ret;
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x58(%rax)
movq -0x18(%rbp), %rax
movl 0x40(%rax), %edi
callq 0x5440
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
jne 0x53a3
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x542d
movq -0x18(%rbp), %rax
movl 0x88(%rax), %eax
movq -0x18(%rbp), %rcx
imull 0x94(%rcx), %eax
movl %eax, %eax
movl %eax, %edi
callq 0x20d0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x60(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x60(%rax)
jne 0x53e0
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x542d
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x8c(%rax), %esi
movl -0x20(%rbp), %edx
movq -0x18(%rbp), %rax
movl 0x88(%rax), %ecx
movl -0x1c(%rbp), %r8d
movl -0x28(%rbp), %r9d
callq 0x2740
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x5426
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x21a0
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x542d
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/ender672[P]liboil/oil_libjpeg.c
// Function: jpeg_cs_to_oil
enum oil_colorspace jpeg_cs_to_oil(J_COLOR_SPACE cs)
{
	switch(cs) {
	case JCS_GRAYSCALE:
		return OIL_CS_G;
	case JCS_RGB:
		return OIL_CS_RGB;
	case JCS_CMYK:
		return OIL_CS_CMYK;
#ifdef JCS_EXTENSIONS
	case JCS_EXT_RGBX:
	case JCS_EXT_BGRX:
		return OIL_CS_RGBX;
#endif
	default:
		return OIL_CS_UNKNOWN;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x8, %eax
ja 0x548f
movq -0x10(%rbp), %rax
leaq 0x1c4e(%rip), %rcx      # 0x70b0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x1, -0x4(%rbp)
jmp 0x5496
movl $0x3, -0x4(%rbp)
jmp 0x5496
movl $0x204, -0x4(%rbp)      # imm = 0x204
jmp 0x5496
movl $0x4, -0x4(%rbp)
jmp 0x5496
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ender672[P]liboil/oil_libjpeg.c
// Function: oil_libjpeg_read_scanline
void oil_libjpeg_read_scanline(struct oil_libjpeg *ol, unsigned char *outbuf)
{
	while (oil_scale_slots(&ol->os)) {
		jpeg_read_scanlines(ol->dinfo, &ol->inbuf, 1);
		oil_scale_in(&ol->os, ol->inbuf);
	}
	oil_scale_out(&ol->os, outbuf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2c50
cmpl $0x0, %eax
je 0x552b
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rdi
movq -0x8(%rbp), %rsi
addq $0x60, %rsi
movl $0x1, %edx
callq 0x2280
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rsi
callq 0x2ce0
jmp 0x54f0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3110
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ender672[P]liboil/oil_libjpeg.c
// Function: oil_cs_to_jpeg
J_COLOR_SPACE oil_cs_to_jpeg(enum oil_colorspace cs)
{
	switch(cs) {
	case OIL_CS_G:
		return JCS_GRAYSCALE;
	case OIL_CS_RGB:
		return JCS_RGB;
	case OIL_CS_CMYK:
		return JCS_CMYK;
	default:
		return JCS_UNKNOWN;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0xc(%rbp)
subl $0x1, %eax
je 0x556a
jmp 0x5554
movl -0xc(%rbp), %eax
subl $0x3, %eax
je 0x5573
jmp 0x555e
movl -0xc(%rbp), %eax
subl $0x204, %eax            # imm = 0x204
je 0x557c
jmp 0x5585
movl $0x1, -0x4(%rbp)
jmp 0x558c
movl $0x2, -0x4(%rbp)
jmp 0x558c
movl $0x4, -0x4(%rbp)
jmp 0x558c
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ender672[P]liboil/oil_libpng.c
// Function: png_cs_to_oil
enum oil_colorspace png_cs_to_oil(png_byte cs)
{
	switch(cs) {
	case PNG_COLOR_TYPE_GRAY:
		return OIL_CS_G;
	case PNG_COLOR_TYPE_GA:
		return OIL_CS_GA;
	case PNG_COLOR_TYPE_RGB:
		return OIL_CS_RGB;
	case PNG_COLOR_TYPE_RGBA:
		return OIL_CS_RGBA;
	default:
		return OIL_CS_UNKNOWN;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x5(%rbp)
movzbl -0x5(%rbp), %eax
movq %rax, -0x10(%rbp)
subq $0x6, %rax
ja 0x5790
movq -0x10(%rbp), %rax
leaq 0x1971(%rip), %rcx      # 0x70d4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x1, -0x4(%rbp)
jmp 0x5797
movl $0x2, -0x4(%rbp)
jmp 0x5797
movl $0x3, -0x4(%rbp)
jmp 0x5797
movl $0x104, -0x4(%rbp)      # imm = 0x104
jmp 0x5797
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ender672[P]liboil/oil_libpng.c
// Function: alloc_full_image_buf
static unsigned char **alloc_full_image_buf(int height, int rowbytes)
{
	int i, j;
	unsigned char **imgbuf;

	imgbuf = malloc(height * sizeof(unsigned char *));
	if (!imgbuf) {
		return NULL;
	}
	for (i=0; i<height; i++) {
		imgbuf[i] = malloc(rowbytes);
		if (!imgbuf[i]) {
			for (j=0; j<i-1; j++) {
				free(imgbuf[j]);
			}
			free(imgbuf);
			return NULL;
		}
	}
	return imgbuf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
movl %esi, -0x10(%rbp)
movslq -0xc(%rbp), %rdi
shlq $0x3, %rdi
callq 0x20d0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x57d3
movq $0x0, -0x8(%rbp)
jmp 0x5861
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x5859
movslq -0x10(%rbp), %rdi
callq 0x20d0
movq %rax, %rdx
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x584c
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x5839
movq -0x20(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x21a0
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x5810
movq -0x20(%rbp), %rdi
callq 0x21a0
movq $0x0, -0x8(%rbp)
jmp 0x5861
jmp 0x584e
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x57da
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ender672[P]liboil/oil_libpng.c
// Function: oil_libpng_free
void oil_libpng_free(struct oil_libpng *ol)
{
	if (ol->inbuf) {
		free(ol->inbuf);
	}
	if (ol->inimage) {
		free_full_image_buf(ol->inimage, ol->os.in_height);
	}
	oil_scale_free(&ol->os);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x70(%rax)
je 0x5894
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rdi
callq 0x21a0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x78(%rax)
je 0x58b2
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rdi
movq -0x8(%rbp), %rax
movl (%rax), %esi
callq 0x58d0
movq -0x8(%rbp), %rdi
callq 0x2b00
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ender672[P]liboil/oil_libpng.c
// Function: free_full_image_buf
static void free_full_image_buf(unsigned char **imgbuf, int height)
{
	int i;
	for (i=0; i<height; i++) {
		free(imgbuf[i]);
	}
	free(imgbuf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x590a
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x21a0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x58e6
movq -0x8(%rbp), %rdi
callq 0x21a0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ender672[P]liboil/oil_libpng.c
// Function: oil_libpng_read_scanline
void oil_libpng_read_scanline(struct oil_libpng *ol, unsigned char *outbuf)
{
	switch (png_get_interlace_type(ol->rpng, ol->rinfo)) {
	case PNG_INTERLACE_NONE:
		read_scanline(ol);
		break;
	case PNG_INTERLACE_ADAM7:
		read_scanline_interlaced(ol);
		break;
	}
	oil_scale_out(&ol->os, outbuf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rdi
movq 0x60(%rax), %rsi
callq 0x21f0
movzbl %al, %ecx
movl %ecx, -0x14(%rbp)
testb %al, %al
je 0x5957
jmp 0x594d
movl -0x14(%rbp), %eax
subl $0x1, %eax
je 0x5962
jmp 0x596b
movq -0x8(%rbp), %rdi
callq 0x5980
jmp 0x596b
movq -0x8(%rbp), %rdi
callq 0x59d0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3110
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ender672[P]liboil/imgscale.c
// Function: prepare_jpeg_decompress
static void prepare_jpeg_decompress(FILE *input,
	struct jpeg_decompress_struct *dinfo, struct jpeg_error_mgr *jerr)
{
	long i;

	dinfo->err = jpeg_std_error(jerr);
	jpeg_create_decompress(dinfo);
	jpeg_stdio_src(dinfo, input);

	/* Save custom headers for the compressor, but ignore APP0 & APP14 so
	 * libjpeg can handle them.
	 */
	jpeg_save_markers(dinfo, JPEG_COM, 0xFFFF);
	for (i=1; i<14; i++) {
		jpeg_save_markers(dinfo, JPEG_APP0+i, 0xFFFF);
	}
	jpeg_save_markers(dinfo, JPEG_APP0+15, 0xFFFF);
	jpeg_read_header(dinfo, TRUE);

	/* For testing purposes, you can run with the environment variable
	 * OILRGBX in order to trigger libjpeg turbo's JCS_RGBX color space.
	 */
#ifdef JCS_EXTENSIONS
	if (getenv("OILRGBX") != NULL && dinfo->out_color_space == JCS_RGB) {
		dinfo->out_color_space = JCS_EXT_RGBX;
		jpeg_calc_output_dimensions(dinfo);
	}
#endif

	jpeg_start_decompress(dinfo);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2260
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
movl $0x50, %esi
movl $0x290, %edx            # imm = 0x290
callq 0x2150
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x2050
movq -0x10(%rbp), %rdi
movl $0xfe, %esi
movl $0xffff, %edx           # imm = 0xFFFF
callq 0x2030
movq $0x1, -0x20(%rbp)
cmpq $0xe, -0x20(%rbp)
jge 0x6221
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
addq $0xe0, %rax
movl %eax, %esi
movl $0xffff, %edx           # imm = 0xFFFF
callq 0x2030
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x61f2
movq -0x10(%rbp), %rdi
movl $0xef, %esi
movl $0xffff, %edx           # imm = 0xFFFF
callq 0x2030
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x2340
leaq 0xfb1(%rip), %rdi       # 0x71fa
callq 0x2270
cmpq $0x0, %rax
je 0x6272
movq -0x10(%rbp), %rax
cmpl $0x2, 0x40(%rax)
jne 0x6272
movq -0x10(%rbp), %rax
movl $0x7, 0x40(%rax)
movq -0x10(%rbp), %rdi
callq 0x2240
movq -0x10(%rbp), %rdi
callq 0x20f0
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/MersenneTwister-Lab[P]MTGP/mtgp64-ref.c
// Function: mtgp64_init
int mtgp64_init(mtgp64_ref_t *mtgp64,
		const mtgp64_params_ref_t *para, uint64_t seed) {
    int i;
    int size = para->mexp / 64 + 1;
    uint64_t hidden_seed;
    uint64_t tmp;
    mtgp64_status_ref_t *st;

    st = (mtgp64_status_ref_t *)malloc(sizeof(mtgp64_status_ref_t)
				     + sizeof(uint64_t) * size);
    if (st == NULL) {
	return -1;
    }
    hidden_seed = para->tbl[2] ^ (para->tbl[3] << 16);
    tmp = hidden_seed >> 32;
    tmp += tmp >> 16;
    tmp += tmp >> 8;
    memset(st->array, tmp & 0xff, sizeof(uint64_t) * size);
    mtgp64->params = *para;
    mtgp64->status = st;
    st->size = size;
    st->idx = size - 1;
    st->array[0] = seed;
    st->array[1] = hidden_seed;
    for (i = 1; i < size; i++) {
	st->array[i] ^= UINT64_C(6364136223846793005)
	    * (st->array[i - 1]
	       ^ (st->array[i - 1] >> 62)) + i;
    }
    return 0;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x30(%rsp), %rax
movl (%rax), %eax
movl $0x40, %ecx
cltd
idivl %ecx
addl $0x1, %eax
movl %eax, 0x20(%rsp)
movslq 0x20(%rsp), %rdi
shlq $0x3, %rdi
addq $0x8, %rdi
callq 0x10b0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x1215
movl $0xffffffff, 0x44(%rsp) # imm = 0xFFFFFFFF
jmp 0x1364
movq 0x30(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x30(%rsp), %rcx
movq 0x28(%rcx), %rcx
shlq $0x10, %rcx
xorq %rcx, %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
shrq $0x20, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
shrq $0x10, %rax
addq 0x10(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
shrq $0x8, %rax
addq 0x10(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
movq 0x10(%rsp), %rax
andq $0xff, %rax
movslq 0x20(%rsp), %rdx
shlq $0x3, %rdx
movzbl %al, %esi
callq 0x1070
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
movl $0x70, %edx
callq 0x10a0
movq 0x8(%rsp), %rcx
movq 0x38(%rsp), %rax
movq %rcx, 0x70(%rax)
movl 0x20(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, (%rax)
movl 0x20(%rsp), %ecx
subl $0x1, %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x4(%rax)
movq 0x28(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x18(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
cmpl 0x20(%rsp), %eax
jge 0x135c
movq 0x8(%rsp), %rax
movl 0x24(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq 0x8(%rax,%rcx,8), %rdx
movq 0x8(%rsp), %rax
movl 0x24(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq 0x8(%rax,%rcx,8), %rax
shrq $0x3e, %rax
xorq %rax, %rdx
movabsq $0x5851f42d4c957f2d, %rax # imm = 0x5851F42D4C957F2D
imulq %rax, %rdx
movslq 0x24(%rsp), %rax
addq %rax, %rdx
movq 0x8(%rsp), %rax
movslq 0x24(%rsp), %rcx
xorq 0x8(%rax,%rcx,8), %rdx
movq %rdx, 0x8(%rax,%rcx,8)
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x12ec
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MersenneTwister-Lab[P]MTGP/mtgp64-ref.c
// Function: mtgp64_print_idstring
void mtgp64_print_idstring(const mtgp64_ref_t *mtgp64, FILE *fp) {
    int i;
    fprintf(fp, "mtgp64:%d:", mtgp64->params.mexp);
    for (i = 0; i < 20; i++) {
	fprintf(fp, "%02x", (unsigned int)mtgp64->params.poly_sha1[i]);
    }
    fprintf(fp, "\n");
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
movl (%rax), %edx
leaq 0x1a77(%rip), %rsi      # 0x4018
movb $0x0, %al
callq 0x1080
movl $0x0, 0x4(%rsp)
cmpl $0x14, 0x4(%rsp)
jge 0x25e6
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
movslq 0x4(%rsp), %rcx
movzbl 0x58(%rax,%rcx), %edx
leaq 0x1a51(%rip), %rsi      # 0x4023
movb $0x0, %al
callq 0x1080
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x25b0
movq 0x8(%rsp), %rdi
leaq 0x1a56(%rip), %rsi      # 0x4048
movb $0x0, %al
callq 0x1080
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/MersenneTwister-Lab[P]MTGP/mtgp64-ref.c
// Function: mtgp64_genrand_uint64
uint64_t mtgp64_genrand_uint64(mtgp64_ref_t *mtgp64) {
    next_state(mtgp64);
    return temper(mtgp64->params.tmp_tbl,
		  mtgp64->status->array[mtgp64->status->idx],
		  mtgp64->status->array[(mtgp64->status->idx
				       + mtgp64->params.pos - 1)
				      % mtgp64->status->size]);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x2680
movq 0x10(%rsp), %rdi
addq $0x30, %rdi
movq 0x10(%rsp), %rax
movq 0x70(%rax), %rax
movq 0x10(%rsp), %rcx
movq 0x70(%rcx), %rcx
movslq 0x4(%rcx), %rcx
movq 0x8(%rax,%rcx,8), %rsi
movq 0x10(%rsp), %rax
movq 0x70(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq 0x70(%rax), %rax
movl 0x4(%rax), %eax
movq 0x10(%rsp), %rcx
addl 0x4(%rcx), %eax
subl $0x1, %eax
movq 0x10(%rsp), %rcx
movq 0x70(%rcx), %rcx
cltd
idivl (%rcx)
movq 0x8(%rsp), %rax
movslq %edx, %rcx
movq 0x8(%rax,%rcx,8), %rdx
callq 0x28a0
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/MersenneTwister-Lab[P]MTGP/mtgp64-ref.c
// Function: temper
static uint64_t temper(const uint64_t tmp_tbl[4], uint64_t r, uint64_t t) {
    t ^= t >> 16;
    t ^= t >> 8;
    if (t & 1) {
	r ^= tmp_tbl[0];
    }
    if (t & 2) {
	r ^= tmp_tbl[1];
    }
    if (t & 4) {
	r ^= tmp_tbl[2];
    }
    if (t & 8) {
	r ^= tmp_tbl[3];
    }
    return r;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq -0x18(%rsp), %rax
shrq $0x10, %rax
xorq -0x18(%rsp), %rax
movq %rax, -0x18(%rsp)
movq -0x18(%rsp), %rax
shrq $0x8, %rax
xorq -0x18(%rsp), %rax
movq %rax, -0x18(%rsp)
movq -0x18(%rsp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x28f6
movq -0x8(%rsp), %rax
movq (%rax), %rax
xorq -0x10(%rsp), %rax
movq %rax, -0x10(%rsp)
movq -0x18(%rsp), %rax
andq $0x2, %rax
cmpq $0x0, %rax
je 0x2918
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rax
xorq -0x10(%rsp), %rax
movq %rax, -0x10(%rsp)
movq -0x18(%rsp), %rax
andq $0x4, %rax
cmpq $0x0, %rax
je 0x293a
movq -0x8(%rsp), %rax
movq 0x10(%rax), %rax
xorq -0x10(%rsp), %rax
movq %rax, -0x10(%rsp)
movq -0x18(%rsp), %rax
andq $0x8, %rax
cmpq $0x0, %rax
je 0x295c
movq -0x8(%rsp), %rax
movq 0x18(%rax), %rax
xorq -0x10(%rsp), %rax
movq %rax, -0x10(%rsp)
movq -0x10(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MersenneTwister-Lab[P]MTGP/mtgp64-ref.c
// Function: mtgp64_genrand_close1_open2
double mtgp64_genrand_close1_open2(mtgp64_ref_t *mtgp64) {
    union {
	uint64_t u;
	double d;
    } x;
    x.u = mtgp64_genrand_uint64(mtgp64);
    x.u = (x.u >> 12) | UINT64_C(0x3ff0000000000000);
    return x.d;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x2600
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
shrq $0xc, %rax
movabsq $0x3ff0000000000000, %rcx # imm = 0x3FF0000000000000
orq %rcx, %rax
movq %rax, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/MersenneTwister-Lab[P]MTGP/mtgp64-ref.c
// Function: mtgp64_genrand_open_open
double mtgp64_genrand_open_open(mtgp64_ref_t *mtgp64) {
    union {
	uint64_t u;
	double d;
    } x;
    x.u = mtgp64_genrand_uint64(mtgp64);
    x.u = (x.u >> 12) | UINT64_C(0x3ff0000000000001);
    return x.d - 1.0;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x2600
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
shrq $0xc, %rax
movabsq $0x3ff0000000000001, %rcx # imm = 0x3FF0000000000001
orq %rcx, %rax
movq %rax, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
movsd 0x15d7(%rip), %xmm1     # 0x4008
subsd %xmm1, %xmm0
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MersenneTwister-Lab[P]MTGP/mtgp64-ref.c
// Function: print_uint64
void print_uint64(mtgp64_ref_t *mtgp64, int count) {
    int i;
    for (i = 0; i < count; i++) {
	printf("%016"PRIx64" ", mtgp64_genrand_uint64(mtgp64));
	if (i % 3 == 2) {
	    printf("\n");
	}
    }
    printf("\n");
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
cmpl 0xc(%rsp), %eax
jge 0x2aa8
movq 0x10(%rsp), %rdi
callq 0x2600
movq %rax, %rsi
leaq 0x15b5(%rip), %rdi      # 0x4028
movb $0x0, %al
callq 0x1060
movl 0x8(%rsp), %eax
movl $0x3, %ecx
cltd
idivl %ecx
cmpl $0x2, %edx
jne 0x2a99
leaq 0x15b6(%rip), %rdi      # 0x4048
movb $0x0, %al
callq 0x1060
jmp 0x2a9b
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x2a55
leaq 0x1599(%rip), %rdi      # 0x4048
movb $0x0, %al
callq 0x1060
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MersenneTwister-Lab[P]MTGP/mtgp64-ref.c
// Function: print_close1_open2
void print_close1_open2(mtgp64_ref_t *mtgp64, int count) {
    int i;
    for (i = 0; i < count; i++) {
	printf("%.18f ", mtgp64_genrand_close1_open2(mtgp64));
	if (i % 3 == 2) {
	    printf("\n");
	}
    }
    printf("\n");
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
cmpl 0xc(%rsp), %eax
jge 0x2b25
movq 0x10(%rsp), %rdi
callq 0x2970
leaq 0x1540(%rip), %rdi      # 0x4030
movb $0x1, %al
callq 0x1060
movl 0x8(%rsp), %eax
movl $0x3, %ecx
cltd
idivl %ecx
cmpl $0x2, %edx
jne 0x2b16
leaq 0x1539(%rip), %rdi      # 0x4048
movb $0x0, %al
callq 0x1060
jmp 0x2b18
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x2ad5
leaq 0x151c(%rip), %rdi      # 0x4048
movb $0x0, %al
callq 0x1060
addq $0x18, %rsp
retq
nopl (%rax,%rax)