LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/lukexi[P]eglstreams-mini/src/egl.c
// Function: EGLStreamAcquire
void EGLStreamAcquire(egl_display* Display) {
    // Ask the Display's EGLStream to acquire the new frame,
    // and pass a data pointer to pass along to drmHandleEvent
    EGLAttrib AcquireAttribs[] = {
        EGL_DRM_FLIP_EVENT_DATA_NV, (EGLAttrib)Display,
        EGL_NONE
    };

    EGLBoolean Result = pEglStreamConsumerAcquireAttribNV(
        Display->DisplayDevice,
        Display->Stream,
        AcquireAttribs);
    if (Result == EGL_FALSE) {
        EGLCheck("eglStreamConsumerAcquireAttribNV");
    }
    Display->PageFlipPending = true;
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq %rsp, %rdx
movq $0x333e, (%rdx)         # imm = 0x333E
movq %rdi, 0x8(%rdx)
movq $0x3038, 0x10(%rdx)     # imm = 0x3038
movq 0x30(%rdi), %rdi
movq 0x40(%rbx), %rsi
callq *0x521e(%rip)           # 0x8270
testl %eax, %eax
jne 0x3062
leaq 0x20d4(%rip), %rdi      # 0x5131
callq 0x306c
movb $0x1, 0x50(%rbx)
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/lukexi[P]eglstreams-mini/src/egl.c
// Function: EGLSwapDisplay
void EGLSwapDisplay(egl_display* Display) {

    NEWTIME(eglSwapBuffers);
    eglSwapBuffers(Display->DisplayDevice, Display->Surface);
    ENDTIME(eglSwapBuffers);

    NEWTIME(StreamAcquire);
    EGLStreamAcquire(Display);
    ENDTIME(StreamAcquire);


}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %eax, %eax
callq 0x41c3
movss %xmm0, 0x4(%rsp)
movq 0x20(%rbx), %rsi
movq 0x30(%rbx), %rdi
callq 0x2270
xorl %eax, %eax
callq 0x41c3
subss 0x4(%rsp), %xmm0
mulss 0x1f0c(%rip), %xmm0     # 0x5004
cvtss2sd %xmm0, %xmm0
leaq 0x1f25(%rip), %r14      # 0x5028
leaq 0x1f49(%rip), %rsi      # 0x5053
movq %r14, %rdi
movb $0x1, %al
callq 0x2050
xorl %eax, %eax
callq 0x41c3
movss %xmm0, 0x4(%rsp)
movq %rbx, %rdi
callq 0x3026
xorl %eax, %eax
callq 0x41c3
subss 0x4(%rsp), %xmm0
mulss 0x1ec6(%rip), %xmm0     # 0x5004
cvtss2sd %xmm0, %xmm0
leaq 0x1ef2(%rip), %rsi      # 0x503b
movq %r14, %rdi
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2050
// File: /workspace/github_c_makefile_star2_O2/lukexi[P]eglstreams-mini/src/egl.c
// Function: InitGLEW
void InitGLEW() {
    // Initialize GLEW
    glewExperimental = GL_TRUE;
    if(glewInit() != GLEW_OK) {
        Fatal("Could not init glew.\n");
    }
    GLenum GLEWError = glGetError();
    if (GLEWError) {
        printf("GLEW returned error: %i\n", GLEWError);
    }
}

// Assembly:
pushq %rax
movq 0x4c0a(%rip), %rax      # 0x7fc8
movb $0x1, (%rax)
callq 0x2290
testl %eax, %eax
je 0x33d8
leaq 0x22c6(%rip), %rdi      # 0x5697
xorl %eax, %eax
callq 0x40d8
callq 0x2110
testl %eax, %eax
je 0x33f2
leaq 0x22c5(%rip), %rdi      # 0x56ad
movl %eax, %esi
xorl %eax, %eax
popq %rcx
jmp 0x2050
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/lukexi[P]eglstreams-mini/src/egl.c
// Function: SetupEGL
egl_state* SetupEGL() {
    egl_state* EGL = calloc(1, sizeof(egl_state));

    // Setup global EGL state
    GetEglExtensionFunctionPointers();

    EGL->Device = GetEglDevice();

    int drmFd = GetDrmFd(EGL->Device);
    // Set up EGL state for each connected display
    kms_plane* Planes = SetDisplayModes(drmFd, &EGL->DisplaysCount);

    EGL->DRMFD         = drmFd;
    EGL->DisplayDevice = GetEglDisplay(EGL->Device, drmFd);
    EGL->Config        = GetEglConfig(EGL->DisplayDevice);
    EGL->RootContext   = GetEglContext(EGL->DisplayDevice, EGL->Config);


    EGL->Displays     = SetupEGLDisplays(EGL->DisplayDevice,
        EGL->Config, EGL->RootContext, Planes, EGL->DisplaysCount);

    EGLBoolean ret = eglMakeCurrent(EGL->DisplayDevice,
        EGL->Displays->Surface, EGL->Displays->Surface,
        EGL->RootContext);
    if (!ret) Fatal("Couldn't make main context current\n");

    InitGLEW();

    // Disable EGL VSync
    // (seems to have no effect)
    for (int DisplayIndex = 0; DisplayIndex < EGL->DisplaysCount; DisplayIndex++) {
        egl_display* Display = &EGL->Displays[DisplayIndex];
        eglMakeCurrent(Display->DisplayDevice,
            Display->Surface, Display->Surface,
            Display->Context);
        eglSwapInterval(Display->DisplayDevice, 0);
    }

    // Create a drmEventContext configured to
    // call our PageFlipEventHandler function
    // when a page flip occurs
    EGL->DRMEventContext.page_flip_handler = PageFlipEventHandler;
    // EGL->DRMEventContext.vblank_handler    = VBlankEventHandler;
    EGL->DRMEventContext.version           = 2;

    return EGL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
pushq $0x1
popq %rdi
pushq $0x60
popq %rsi
callq 0x2370
movq %rax, %rbx
callq 0x2a6b
callq 0x2b95
movq %rax, 0x20(%rbx)
movq %rax, %rdi
callq 0x2ce2
movl %eax, %ebp
leaq 0x8(%rbx), %r14
movl %eax, %edi
movq %r14, %rsi
callq 0x35b8
movq %rax, %r15
movl %ebp, 0x30(%rbx)
movq 0x20(%rbx), %rdi
movl %ebp, %esi
callq 0x2d70
movq %rax, 0x18(%rbx)
movq %rax, %rdi
callq 0x2e6b
movq %rax, 0x28(%rbx)
movq 0x18(%rbx), %rdi
movq %rax, %rsi
callq 0x2fa5
movq %rax, 0x10(%rbx)
movq 0x18(%rbx), %rdi
movq 0x28(%rbx), %rsi
movl 0x8(%rbx), %r8d
movq %rax, %rdx
movq %r15, %rcx
callq 0x315a
movq %rax, (%rbx)
movq 0x10(%rbx), %rcx
movq 0x18(%rbx), %rdi
movq 0x20(%rax), %rdx
movq %rdx, %rsi
callq 0x21b0
testl %eax, %eax
jne 0x34a4
leaq 0x2229(%rip), %rdi      # 0x56c6
xorl %eax, %eax
callq 0x40d8
callq 0x33b6
pushq $0x30
popq %r15
xorl %r12d, %r12d
movslq (%r14), %rax
cmpq %rax, %r12
jge 0x34e7
movq (%rbx), %r13
movq (%r13,%r15), %rdi
movq -0x10(%r13,%r15), %rdx
movq -0x8(%r13,%r15), %rcx
movq %rdx, %rsi
callq 0x21b0
movq (%r13,%r15), %rdi
xorl %esi, %esi
callq 0x22e0
incq %r12
addq $0x58, %r15
jmp 0x34b0
leaq 0x1d(%rip), %rax        # 0x350b
movq %rax, 0x48(%rbx)
movl $0x2, 0x38(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/lukexi[P]eglstreams-mini/src/egl.c
// Function: PageFlipEventHandler
static void PageFlipEventHandler(int fd, unsigned int frame,
                    unsigned int sec, unsigned int usec,
                    void *data)
{
    egl_display* Display = (egl_display*)data;
    (void)fd; (void)frame; (void)sec; (void)usec; (void)data;
    Display->PageFlipPending = false;

    float Now = GetTime();
    if (Display->LastPageFlip > 0) {
        printf("%20s page flip interval: %.2fms\n",
            Display->EDID->MonitorName,
            (Now - Display->LastPageFlip) * 1000);
    }

    Display->LastPageFlip = Now;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %r8, %rbx
movb $0x0, 0x50(%r8)
xorl %eax, %eax
callq 0x41c3
movaps %xmm0, %xmm2
movss 0x54(%rbx), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x3562
movq (%rbx), %rax
movq (%rax), %rsi
movaps %xmm2, %xmm1
subss %xmm0, %xmm1
mulss 0x1ac0(%rip), %xmm1     # 0x5004
cvtss2sd %xmm1, %xmm0
leaq 0x22b6(%rip), %rdi      # 0x5805
movb $0x1, %al
movss %xmm2, 0xc(%rsp)
callq 0x2050
movss 0xc(%rsp), %xmm2
movss %xmm2, 0x54(%rbx)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/lukexi[P]eglstreams-mini/src/egl.c
// Function: EGLQueryStreamState
EGLint EGLQueryStreamState(EGLDisplay eglDpy, EGLStreamKHR eglStream) {
     EGLint streamState;
     EGLBoolean r = pEglQueryStreamKHR(eglDpy, eglStream, EGL_STREAM_STATE_KHR, &streamState);
     if (r == EGL_FALSE) {
         EGLCheck("Query Stream");
     }

     return streamState;
 }

// Assembly:
pushq %rax
leaq 0x4(%rsp), %rcx
movl $0x3214, %edx           # imm = 0x3214
callq *0x4cea(%rip)           # 0x8268
testl %eax, %eax
jne 0x358e
leaq 0x2161(%rip), %rdi      # 0x56ea
callq 0x306c
movl 0x4(%rsp), %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/lukexi[P]eglstreams-mini/src/kms.c
// Function: AssignPropertyIDsOneType
static void AssignPropertyIDsOneType(int drmFd,
                                     uint32_t objectID,
                                     uint32_t objectType,
                                     struct PropertyIDAddresses *table,
                                     size_t tableLen)
{
    uint32_t i;
    drmModeObjectPropertiesPtr pModeObjectProperties =
        drmModeObjectGetProperties(drmFd, objectID, objectType);

    if (pModeObjectProperties == NULL) {
        Fatal("Unable to query mode object properties.\n");
    }

    for (i = 0; i < pModeObjectProperties->count_props; i++) {

        uint32_t j;
        drmModePropertyPtr pProperty =
            drmModeGetProperty(drmFd, pModeObjectProperties->props[i]);

        if (pProperty == NULL) {
            Fatal("Unable to query property.\n");
        }
        for (j = 0; j < tableLen; j++) {
            if (strcmp(table[j].name, pProperty->name) == 0) {
                *(table[j].ptr) = pProperty->prop_id;
                break;
            }
        }

        drmModeFreeProperty(pProperty);
    }

    drmModeFreeObjectProperties(pModeObjectProperties);

    for (i = 0; i < tableLen; i++) {
        if (*(table[i].ptr) == 0) {
            Fatal("Unable to find property ID for \'%s\'.\n", table[i].name);
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %rbx
movq %rcx, %r14
movl %edi, 0x4(%rsp)
callq 0x2190
movq %rax, %r15
testq %rax, %rax
jne 0x3ffd
leaq 0x20a4(%rip), %rdi      # 0x609a
xorl %eax, %eax
callq 0x40d8
xorl %ecx, %ecx
movq %r15, 0x8(%rsp)
movl (%r15), %eax
cmpq %rax, %rcx
jae 0x4089
movq 0x8(%r15), %rax
movq %rcx, 0x10(%rsp)
movl (%rax,%rcx,4), %esi
movl 0x4(%rsp), %edi
callq 0x2170
movq %rax, %r12
testq %rax, %rax
jne 0x4037
leaq 0x1ecf(%rip), %rdi      # 0x5eff
xorl %eax, %eax
callq 0x40d8
movq %r12, %r13
addq $0x8, %r13
xorl %ecx, %ecx
movl %ecx, %r15d
cmpq %rbx, %r15
jae 0x406f
movl %r15d, %ebp
shlq $0x4, %r15
movq (%r14,%r15), %rdi
movq %r13, %rsi
callq 0x2350
leal 0x1(%rbp), %ecx
testl %eax, %eax
jne 0x4040
addq %r14, %r15
movl (%r12), %eax
movq 0x8(%r15), %rcx
movl %eax, (%rcx)
movq %r12, %rdi
callq 0x2260
movq 0x10(%rsp), %rcx
incq %rcx
movq 0x8(%rsp), %r15
jmp 0x4004
movq %r15, %rdi
callq 0x2150
leaq 0x202b(%rip), %r15      # 0x60c3
xorl %r12d, %r12d
movl %r12d, %r12d
cmpq %rbx, %r12
jae 0x40c9
movq %r12, %rax
shlq $0x4, %rax
movq 0x8(%r14,%rax), %rcx
cmpl $0x0, (%rcx)
jne 0x40c4
addq %r14, %rax
movq (%rax), %rsi
movq %r15, %rdi
xorl %eax, %eax
callq 0x40d8
incl %r12d
jmp 0x409b
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/lukexi[P]eglstreams-mini/src/utils.c
// Function: Fatal
void Fatal(const char *format, ...)
{
    va_list ap;

    fprintf(stderr, "ERROR: ");

    va_start(ap, format);
    vfprintf(stderr, format, ap);
    va_end(ap);

    exit(1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %r14
movq %rsi, 0x8(%r14)
movq %rdx, 0x10(%r14)
movq %rcx, 0x18(%r14)
movq %r8, 0x20(%r14)
movq %r9, 0x28(%r14)
testb %al, %al
je 0x413b
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq 0x3eae(%rip), %r15      # 0x7ff0
movq (%r15), %rcx
leaq 0x1fac(%rip), %rdi      # 0x60f8
pushq $0x7
popq %rsi
pushq $0x1
popq %rdx
callq 0x23c0
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rsp, %rdx
movq %rax, (%rdx)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rdx)
movq %r14, 0x10(%rdx)
movq (%r15), %rdi
movq %rbx, %rsi
callq 0x21c0
pushq $0x1
popq %rdi
callq 0x20e0
// File: /workspace/github_c_makefile_star2_O2/lukexi[P]eglstreams-mini/src/utils.c
// Function: GetTime
float GetTime()
{
    static struct timeval InitialTime = {0, 0};
    if (InitialTime.tv_sec == 0)
    {
        gettimeofday(&InitialTime, NULL);
    }
    struct timeval Now;
    gettimeofday(&Now, NULL);

    struct timeval TimeSinceStart = { Now.tv_sec - InitialTime.tv_sec, Now.tv_usec - InitialTime.tv_usec };

    return (TimeSinceStart.tv_sec + (TimeSinceStart.tv_usec / 1000000.0));
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
cmpq $0x0, 0x40c8(%rip)      # 0x8298
jne 0x41e0
leaq 0x40bf(%rip), %rdi      # 0x8298
xorl %esi, %esi
callq 0x20f0
movq %rsp, %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x20f0
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq 0x409d(%rip), %rax      # 0x8298
subq 0x409e(%rip), %rcx      # 0x82a0
cvtsi2sd %rax, %xmm0
cvtsi2sd %rcx, %xmm1
divsd 0x1edc(%rip), %xmm1     # 0x60f0
addsd %xmm0, %xmm1
cvtsd2ss %xmm1, %xmm0
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/lukexi[P]eglstreams-mini/src/utils.c
// Function: TickFPS
void TickFPS(fps* FPS) {
    struct timeval Now;
    gettimeofday(&Now, NULL);

    FPS->Frames++;

    int NowSecond = Now.tv_sec;
    if (NowSecond > FPS->CurrentSecond) {
        printf("%40s: %i FPS\n", FPS->Name, FPS->Frames);
        FPS->Frames = 0;
        FPS->CurrentSecond = NowSecond;
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x20f0
movl (%rbx), %edx
movl 0x4(%rbx), %eax
incl %edx
movl %edx, (%rbx)
movl (%r14), %ebp
cmpl %ebp, %eax
jge 0x428d
movq 0x8(%rbx), %rsi
leaq 0x1e83(%rip), %rdi      # 0x6103
xorl %eax, %eax
callq 0x2050
andl $0x0, (%rbx)
movl %ebp, 0x4(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/lukexi[P]eglstreams-mini/src/utils.c
// Function: GLCheck
void GLCheck(const char* name) {
    GLenum err = glGetError();
    if (err != GL_NO_ERROR) {
        printf("%s: ", name);
        switch (err) {
            case GL_INVALID_ENUM: printf("Invalid enum\n");
                break;
            case GL_INVALID_VALUE: printf("Invalid value\n");
                break;
            case GL_INVALID_OPERATION: printf("Invalid operation\n");
                break;
            case GL_INVALID_FRAMEBUFFER_OPERATION: printf("Invalid framebuffer op\n");
                break;
            case GL_OUT_OF_MEMORY: printf("GL Out of memory\n");
                break;
        }
        exit(1);
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x2110
testl %eax, %eax
jne 0x42ae
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl %eax, %ebx
leaq 0x152a(%rip), %rdi      # 0x57e1
movq %r14, %rsi
xorl %eax, %eax
callq 0x2050
leal -0x500(%rbx), %eax
cmpl $0x6, %eax
ja 0x42e9
pushq $0x67
popq %rcx
btl %ebx, %ecx
jae 0x42e9
movl %eax, %eax
leaq 0x1ea3(%rip), %rcx      # 0x6180
movslq (%rcx,%rax,4), %rdi
addq %rcx, %rdi
callq 0x20b0
pushq $0x1
popq %rdi
callq 0x20e0
// File: /workspace/github_c_makefile_star2_O2/lukexi[P]eglstreams-mini/src/utils.c
// Function: EnableGLDebug
void EnableGLDebug() {
    glDebugMessageCallback(DebugCallback, NULL);
    glDebugMessageControl(GL_DONT_CARE,
        GL_DONT_CARE, GL_DONT_CARE, 0, 0, GL_TRUE);
    glEnable(GL_DEBUG_OUTPUT);
}

// Assembly:
pushq %rax
movq 0x3cdc(%rip), %rax      # 0x7fe8
leaq -0x22(%rip), %rdi       # 0x42f1
xorl %esi, %esi
callq *(%rax)
movq 0x3ca2(%rip), %rax      # 0x7fc0
pushq $0x1
popq %r9
movl $0x1100, %edi           # imm = 0x1100
movl $0x1100, %esi           # imm = 0x1100
movl $0x1100, %edx           # imm = 0x1100
xorl %ecx, %ecx
xorl %r8d, %r8d
callq *(%rax)
movl $0x92e0, %edi           # imm = 0x92E0
popq %rax
jmp 0x2040
// File: /workspace/github_c_makefile_star2_O2/endeav0r[P]hvm/src/hvm.c
// Function: core_dump
void core_dump (struct _vm * vm)
{
    FILE * fh;

    fh = fopen("core", "wb");
    if (fh == NULL)
        return;

    fwrite(vm->mem, 1, 65536, fh);

    fclose(fh);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x2c4a(%rip), %rdi      # 0x4004
leaq 0x2c48(%rip), %rsi      # 0x4009
callq 0x1270
testq %rax, %rax
je 0x13f0
movq %rax, %rbx
movq (%r14), %rdi
pushq $0x1
popq %rsi
movl $0x10000, %edx          # imm = 0x10000
movq %rax, %rcx
callq 0x1290
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x10f0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/endeav0r[P]hvm/src/hvm.c
// Function: main
int main (int argc, char * argv [])
{
    struct _vm * vm;
    int error;

    if (argc != 2) {
        fprintf(stderr, "Usage: %s <hvm program>\n", argv[0]);
        return 0;
    }

    signal(SIGINT, int_handler);

    vm = vm_load(argv[1]);
    main_loop = 1;

    while (main_loop) {
        //printf("%s\n", vm_ins_str(vm));
        error = vm_step(vm);
        if (error) {
            switch (error) {
            case VM_HALTED :
                break;
            case VM_BAD_INSTRUCTION :
                printf("VM Encountered Bad Instruction\n");
                printf("%s\n", vm_registers_str(vm));
                break;
            }
            break;
        }
    }

    core_dump(vm);
    vm_destroy(vm);

    return 0;
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
cmpl $0x2, %edi
jne 0x147e
leaq -0x18(%rip), %rsi       # 0x13f8
pushq $0x2
popq %rdi
callq 0x11b0
movq 0x8(%rbx), %rdi
callq 0x36ab
movq %rax, %rbx
movl $0x1, 0x5d46(%rip)      # 0x7174
pushq $0x1
popq %rax
testl %eax, %eax
je 0x146a
movq %rbx, %rdi
callq 0x390a
testl %eax, %eax
jne 0x1449
movl 0x5d2d(%rip), %eax      # 0x7174
jmp 0x1431
cmpl $0x2, %eax
jne 0x146a
leaq 0x2bd0(%rip), %rdi      # 0x4025
callq 0x10b0
movq %rbx, %rdi
callq 0x3814
movq %rax, %rdi
callq 0x10b0
movq %rbx, %rdi
callq 0x13ac
movq %rbx, %rdi
callq 0x374a
xorl %eax, %eax
popq %rbx
retq
movq 0x5b6b(%rip), %rax      # 0x6ff0
movq (%rax), %rdi
movq (%rbx), %rdx
leaq 0x2b7a(%rip), %rsi      # 0x400c
xorl %eax, %eax
callq 0x11c0
jmp 0x147a
nop
// File: /workspace/github_c_makefile_star2_O2/iciamyplant[P]Cub3d-Linux/src/parsing.c
// Function: ft_parsing_map
int		ft_parsing_map(char *fichier, t_recup *recup)
{
	int			fd;
	int			ret;
	char		*str;

	ret = 1;
	str = NULL;
	fd = open(fichier, O_RDONLY);
	if (!(recup->map = malloc(sizeof(char*) * recup->nblines)))
		return (0);
	while (ret != 0)
	{
		ret = get_next_line(fd, &str, recup);
		if (recup->insidemap == 1 && ft_lignevide(str) == 0 &&
				recup->count < recup->nblines)
			recup->lignevide = 1;
		if ((recup->insidemap = ft_is_map(str, recup)) == 1)
		{
			recup->count++;
			ft_copy_map(str, recup);
		}
		free(str);
	}
	close(fd);
	ft_init_sprite(recup);
	return (0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
andq $0x0, (%rsp)
xorl %esi, %esi
xorl %eax, %eax
callq 0x7400
movl %eax, %ebp
movslq 0x40(%rbx), %rdi
shlq $0x3, %rdi
callq 0x7100
movq %rax, 0x48(%rbx)
testq %rax, %rax
je 0x7617
pushq $0x1
popq %r15
movq %rsp, %r14
testl %r15d, %r15d
je 0x7608
movl %ebp, %edi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x9aac
movl %eax, %r15d
cmpl $0x1, 0x80(%rbx)
jne 0x75d4
movq (%rsp), %rdi
callq 0x9ea5
testl %eax, %eax
jne 0x75d4
movl 0x84(%rbx), %eax
cmpl 0x40(%rbx), %eax
jge 0x75d4
movl $0x1, 0x7c(%rbx)
movq (%rsp), %rdi
movq %rbx, %rsi
callq 0x7ced
movl %eax, 0x80(%rbx)
cmpl $0x1, %eax
jne 0x75fd
incl 0x84(%rbx)
movq (%rsp), %rdi
movq %rbx, %rsi
callq 0x7c17
movq (%rsp), %rdi
callq 0x7190
jmp 0x7597
movl %ebp, %edi
callq 0x7040
movq %rbx, %rdi
callq 0x834d
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/iciamyplant[P]Cub3d-Linux/src/parsing.c
// Function: ft_parsing
void	ft_parsing(char *fichier, t_recup *recup)
{
	int			fd;
	int			ret;
	char		*str;

	ret = 1;
	str = NULL;
	if ((fd = open(fichier, O_DIRECTORY)) != -1)
		ft_error(recup, "Invalide : is a directory\n");
	if ((fd = open(fichier, O_RDONLY)) == -1)
		ft_error(recup, "Fichier .cub invalide\n");
	recup->erreur = 0;
	while (ret != 0)
	{
		ret = get_next_line(fd, &str, recup);
		if (recup->erreur == 2)
			ft_error(recup, "La partie parsing detecte une erreur\n");
		ft_color_resolution(&str, recup);
		ft_texture(str, recup);
		ft_map(str, recup);
		free(str);
	}
	close(fd);
	if (recup->sizeline == 0 || recup->nblines == 0)
		ft_error(recup, "Map absente\n");
	ft_parsing_map(fichier, recup);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
andq $0x0, (%rsp)
movl $0x10000, %esi          # imm = 0x10000
xorl %eax, %eax
callq 0x7400
cmpl $-0x1, %eax
je 0x765a
leaq 0x59b2(%rip), %rsi      # 0xd004
movq %rbx, %rdi
callq 0x95a0
movq %r14, %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x7400
movl %eax, %ebp
cmpl $-0x1, %eax
jne 0x767c
leaq 0x59ab(%rip), %rsi      # 0xd01f
movq %rbx, %rdi
callq 0x95a0
andl $0x0, 0x74(%rbx)
pushq $0x1
popq %r13
movq %rsp, %r15
leaq 0x59a8(%rip), %r12      # 0xd036
testl %r13d, %r13d
je 0x76e2
movl %ebp, %edi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x9aac
movl %eax, %r13d
cmpl $0x2, 0x74(%rbx)
jne 0x76b4
movq %rbx, %rdi
movq %r12, %rsi
callq 0x95a0
movq %r15, %rdi
movq %rbx, %rsi
callq 0x7aa0
movq (%rsp), %rdi
movq %rbx, %rsi
callq 0x7a1b
movq (%rsp), %rdi
movq %rbx, %rsi
callq 0x7d74
movq (%rsp), %rdi
callq 0x7190
jmp 0x768e
movl %ebp, %edi
callq 0x7040
cmpl $0x0, 0x44(%rbx)
je 0x76f5
cmpl $0x0, 0x40(%rbx)
jne 0x7704
leaq 0x5960(%rip), %rsi      # 0xd05c
movq %rbx, %rdi
callq 0x95a0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x755c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/iciamyplant[P]Cub3d-Linux/src/parsing.c
// Function: ft_cub
int		ft_cub(char *str, t_recup *recup)
{
	int			i;

	i = 0;
	while (str[i] != '\0')
		i++;
	while (str[i] != '.')
	{
		i--;
		if (i == 0)
		{
			ft_error(recup, "Nom de la map invalide\n");
			return (0);
		}
	}
	if (str[i + 1] == 'c' && str[i + 2] == 'u' && str[i + 3] == 'b')
		ft_parsing(str, recup);
	else
		ft_error(recup, "Nom de la map invalide\n");
	return (0);
}

// Assembly:
xorl %eax, %eax
cmpb $0x0, (%rdi,%rax)
leaq 0x1(%rax), %rax
jne 0x7720
pushq %rax
cmpb $0x2e, -0x1(%rdi,%rax)
je 0x773d
decq %rax
cmpq $0x1, %rax
jne 0x772b
jmp 0x7758
cmpb $0x63, (%rdi,%rax)
jne 0x7758
cmpb $0x75, 0x1(%rdi,%rax)
jne 0x7758
cmpb $0x62, 0x2(%rdi,%rax)
jne 0x7758
callq 0x7624
jmp 0x776a
leaq 0x590a(%rip), %rax      # 0xd069
movq %rsi, %rdi
movq %rax, %rsi
callq 0x95a0
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/iciamyplant[P]Cub3d-Linux/src/parsing.c
// Function: main
int		main(int argc, char **argv)
{
	t_recup recup;

	recup.save = 0;
	ft_initialisation(&recup);
	if (argc == 2 || (argc == 3 && ft_check_save(argv[2]) == 1))
	{
		if (argc == 3)
			recup.save = 1;
		ft_cub(argv[1], &recup);
	}
	else
		write(1, "Error\nArguments invalides\n", 30);
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x428, %rsp            # imm = 0x428
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x8(%rsp), %rdi
andl $0x0, 0x68(%rdi)
callq 0x7e84
cmpl $0x2, %ebp
je 0x77aa
cmpl $0x3, %ebp
jne 0x77ba
movq 0x10(%rbx), %rdi
callq 0x9935
cmpl $0x1, %eax
jne 0x77ba
movl $0x1, 0x70(%rsp)
movq 0x8(%rbx), %rdi
leaq 0x8(%rsp), %rsi
callq 0x771e
jmp 0x77cc
leaq 0x58c0(%rip), %rsi      # 0xd081
pushq $0x1
popq %rdi
pushq $0x1e
popq %rdx
callq 0x73d0
xorl %eax, %eax
addq $0x428, %rsp            # imm = 0x428
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/iciamyplant[P]Cub3d-Linux/src/parsing_color_resolution_texture.c
// Function: ft_atoi2
int		ft_atoi2(const char *str, t_recup *recup)
{
	int		sum;

	sum = 0;
	if (str[1] != ' ' || ft_charinstr((char *)str, ',') == 1)
		recup->erreur = 2;
	while (str[recup->i] == ' ' || str[recup->i] == '\t'
			|| str[recup->i] == ',' || str[recup->i] == '\n'
			|| str[recup->i] == '\r' || str[recup->i] == '\v'
			|| str[recup->i] == '\f')
		recup->i++;
	if (str[recup->i] == '-' || str[recup->i] == '+')
		recup->erreur = 2;
	while (str[recup->i] >= '0' && str[recup->i] <= '9')
	{
		if (sum > 21474636)
			break ;
		sum = (sum * 10) + (str[recup->i] - 48);
		recup->i++;
	}
	while (str[recup->i] >= '0' && str[recup->i] <= '9')
		recup->i++;
	return (sum);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x20, 0x1(%rdi)
jne 0x77f8
pushq $0x2c
popq %rsi
movq %r14, %rdi
callq 0x7e1e
cmpl $0x1, %eax
jne 0x77ff
movl $0x2, 0x74(%rbx)
movslq 0x8(%rbx), %rcx
movq %rcx, %rax
addq %r14, %rax
movabsq $0x100100003e00, %rdx   # imm = 0x100100003E00
movzbl (%rax), %esi
cmpq $0x2d, %rsi
ja 0x7843
btq %rsi, %rdx
jae 0x782c
incl %ecx
movl %ecx, 0x8(%rbx)
incq %rax
jmp 0x7813
movabsq $0x280000000000, %rax   # imm = 0x280000000000
btq %rsi, %rax
jae 0x7843
movl $0x2, 0x74(%rbx)
movslq %ecx, %rdx
addq %r14, %rdx
xorl %eax, %eax
movb (%rdx), %sil
cmpb $0x30, %sil
jl 0x7878
cmpb $0x39, %sil
ja 0x7878
cmpl $0x147ad4c, %eax        # imm = 0x147AD4C
jg 0x7878
imull $0xa, %eax, %edi
addb $-0x30, %sil
movzbl %sil, %eax
addl %edi, %eax
incl %ecx
movl %ecx, 0x8(%rbx)
incq %rdx
jmp 0x784b
movslq %ecx, %rdx
addq %rdx, %r14
incl %ecx
movb (%r14), %dl
addb $-0x30, %dl
cmpb $0x9, %dl
ja 0x7893
movl %ecx, 0x8(%rbx)
incq %r14
jmp 0x787e
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/iciamyplant[P]Cub3d-Linux/src/parsing_color_resolution_texture.c
// Function: ft_atoi3
int		ft_atoi3(const char *str, t_recup *recup)
{
	int		verify;

	verify = 0;
	if (str[1] != ' ')
		recup->erreur = 2;
	ft_atoi3_check(str, recup);
	while (str[recup->i] == ' ' || str[recup->i] == '\t' || str[recup->i]
			== ',' || str[recup->i] == '\n' || str[recup->i] == '\r'
			|| str[recup->i] == '\v' || str[recup->i] == '\f')
	{
		recup->i++;
		verify = 0;
		if (str[recup->i] >= '0' && str[recup->i] <= '9')
			recup->indicateur2++;
		while (str[recup->i] >= '0' && str[recup->i] <= '9')
		{
			verify = (verify * 10) + str[recup->i] - 48;
			recup->sum = (recup->sum * 10) + (str[recup->i] - 48);
			recup->i++;
		}
		if (verify > 255 || verify < 0)
			recup->erreur = 2;
	}
	return (recup->sum);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x20, 0x1(%rdi)
je 0x78b2
movl $0x2, 0x74(%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x9e3a
movl 0x8(%rbx), %ecx
movabsq $0x100100003e00, %rax   # imm = 0x100100003E00
movslq %ecx, %rdx
movzbl (%r14,%rdx), %ecx
cmpq $0x2c, %rcx
ja 0x7941
btq %rcx, %rax
jae 0x7941
leaq 0x1(%rdx), %rcx
movl %ecx, 0x8(%rbx)
movb 0x1(%r14,%rdx), %dl
addb $-0x30, %dl
cmpb $0x9, %dl
ja 0x78f5
incl 0x60(%rbx)
movq %rcx, %rdx
addq %r14, %rdx
xorl %esi, %esi
movzbl (%rdx), %edi
leal -0x30(%rdi), %r8d
cmpb $0x9, %r8b
ja 0x7930
imull $0xa, %esi, %esi
addl %edi, %esi
addl $-0x30, %esi
imull $0xa, 0x8c(%rbx), %r8d
addl %r8d, %edi
addl $-0x30, %edi
movl %edi, 0x8c(%rbx)
incl %ecx
movl %ecx, 0x8(%rbx)
incq %rdx
jmp 0x78fd
cmpl $0x100, %esi            # imm = 0x100
jb 0x78ca
movl $0x2, 0x74(%rbx)
jmp 0x78ca
movl 0x8c(%rbx), %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/iciamyplant[P]Cub3d-Linux/src/parsing_color_resolution_texture.c
// Function: ft_path_texture
int		ft_path_texture(char *str, char **texture, t_recup *recup, int j)
{
	recup->count2 = 0;
	if (*texture != NULL)
	{
		recup->erreur = 2;
		return (0);
	}
	if (ft_charinstr(str, '.') == 0 || ft_charinstr(str, '/') == 0
			|| ft_strlen2(str) <= 2)
		recup->erreur = 2;
	while (str[j] != '.')
	{
		if (str[j] != ' ' && str[j] != '.')
			recup->erreur = 2;
		j++;
	}
	if (!(*texture = (char *)(malloc(sizeof(char) * (ft_strlen2(str) + 1)))))
		recup->erreur = 2;
	while (str[j] != '\0')
	{
		(*texture)[recup->count2] = str[j];
		recup->count2++;
		j++;
	}
	(*texture)[recup->count2] = '\0';
	return (0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
andl $0x0, 0x88(%rdx)
cmpq $0x0, (%rsi)
je 0x7973
movl $0x2, 0x74(%rbx)
jmp 0x7a10
movl %ecx, %ebp
movq %rsi, %r14
movq %rdi, %r15
pushq $0x2e
popq %rsi
callq 0x7e1e
testl %eax, %eax
je 0x79a3
pushq $0x2f
popq %rsi
movq %r15, %rdi
callq 0x7e1e
testl %eax, %eax
je 0x79a3
movq %r15, %rdi
callq 0x7e04
cmpl $0x2, %eax
jg 0x79aa
movl $0x2, 0x74(%rbx)
movslq %ebp, %r12
addq %r15, %r12
movzbl (%r12), %eax
cmpl $0x20, %eax
je 0x79c6
cmpl $0x2e, %eax
je 0x79cb
movl $0x2, 0x74(%rbx)
incq %r12
jmp 0x79b0
movq %r15, %rdi
callq 0x7e04
incl %eax
movslq %eax, %rdi
callq 0x7100
movq %rax, (%r14)
testq %rax, %rax
jne 0x79fa
movl $0x2, 0x74(%rbx)
jmp 0x79fa
movb %al, (%rcx,%rdx)
incl 0x88(%rbx)
incq %r12
movb (%r12), %al
movq (%r14), %rcx
movslq 0x88(%rbx), %rdx
testb %al, %al
jne 0x79ee
movb $0x0, (%rcx,%rdx)
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/iciamyplant[P]Cub3d-Linux/src/parsing_color_resolution_texture.c
// Function: ft_texture
void	ft_texture(char *str, t_recup *recup)
{
	int			i;
	static int	j = 0;

	i = 0;
	if (str[i] == 'S' && str[i + 1] == 'O')
		ft_path_texture(str, &recup->no, recup, 2);
	else if (str[i] == 'N' && str[i + 1] == 'O')
		ft_path_texture(str, &recup->so, recup, 2);
	else if (str[i] == 'E' && str[i + 1] == 'A')
		ft_path_texture(str, &recup->we, recup, 2);
	else if (str[i] == 'W' && str[i + 1] == 'E')
		ft_path_texture(str, &recup->ea, recup, 2);
	else if (str[i] == 'S' && str[i + 1] != 'O')
		ft_path_texture(str, &recup->sp, recup, 1);
	else if (str[0] != 'N' && str[0] != 'S' && str[0] != 'W' && str[0] != 'E'
			&& str[0] != 'R' && str[0] != 'F' && str[0] != 'C'
			&& str[0] > 65 && str[0] < 122)
		recup->erreur = 2;
	j++;
}

// Assembly:
pushq %rax
movq %rsi, %rdx
movb (%rdi), %al
movzbl %al, %ecx
leal -0x4e(%rcx), %esi
cmpl $0x9, %esi
ja 0x7a48
leaq 0x5669(%rip), %rcx      # 0xd09c
movslq (%rcx,%rsi,4), %rsi
addq %rcx, %rsi
jmpq *%rsi
cmpb $0x4f, 0x1(%rdi)
jne 0x7a98
leaq 0x20(%rdx), %rsi
jmp 0x7a88
cmpl $0x43, %ecx
je 0x7a98
cmpl $0x45, %ecx
je 0x7a7e
cmpl $0x46, %ecx
je 0x7a98
addb $-0x42, %al
cmpb $0x37, %al
ja 0x7a98
movl $0x2, 0x74(%rdx)
jmp 0x7a98
cmpb $0x45, 0x1(%rdi)
jne 0x7a98
leaq 0x30(%rdx), %rsi
jmp 0x7a88
cmpb $0x4f, 0x1(%rdi)
jne 0x7a8c
leaq 0x18(%rdx), %rsi
jmp 0x7a88
cmpb $0x41, 0x1(%rdi)
jne 0x7a98
leaq 0x28(%rdx), %rsi
pushq $0x2
jmp 0x7a92
leaq 0x38(%rdx), %rsi
pushq $0x1
popq %rcx
callq 0x794f
incl 0xd806(%rip)            # 0x152a4
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/iciamyplant[P]Cub3d-Linux/src/parsing_color_resolution_texture.c
// Function: ft_color_resolution
void	ft_color_resolution(char **str, t_recup *recup)
{
	int			i;

	i = 0;
	recup->i = 1;
	if (recup->sizeline > 0 && (recup->no == NULL || recup->so == NULL ||
				recup->we == NULL || recup->ea == NULL || recup->sp == NULL))
		recup->erreur = 2;
	if ((recup->no != NULL || recup->so != NULL || recup->we != NULL ||
				recup->ea != NULL || recup->sp != NULL) && (recup->rx == 0
				|| recup->ry == 0))
		recup->erreur = 2;
	if (*str[i] == 'R')
	{
		if (recup->rx != 0 && recup->ry != 0)
			recup->erreur = 2;
		recup->rx = ft_atoi2(*str, recup);
		recup->ry = ft_atoi2(*str, recup);
		if (ft_atoi2(*str, recup) > 0 || recup->rx == 0 || recup->ry == 0)
			recup->erreur = 2;
	}
	else if (*str[i] == 'F')
		recup->f = ft_atoi3(*str, recup);
	else if (*str[i] == 'C')
		recup->c = ft_atoi3(*str, recup);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x1, 0x8(%rsi)
cmpl $0x0, 0x44(%rsi)
movq 0x18(%rsi), %rax
jle 0x7ae3
testq %rax, %rax
je 0x7adc
cmpq $0x0, 0x20(%rbx)
je 0x7adc
cmpq $0x0, 0x28(%rbx)
je 0x7adc
cmpq $0x0, 0x30(%rbx)
je 0x7adc
cmpq $0x0, 0x38(%rbx)
jne 0x7b04
movl $0x2, 0x74(%rbx)
testq %rax, %rax
jne 0x7b04
cmpq $0x0, 0x20(%rbx)
jne 0x7b04
cmpq $0x0, 0x28(%rbx)
jne 0x7b04
cmpq $0x0, 0x30(%rbx)
jne 0x7b04
cmpq $0x0, 0x38(%rbx)
je 0x7b16
cmpl $0x0, (%rbx)
je 0x7b0f
cmpl $0x0, 0x4(%rbx)
jne 0x7b16
movl $0x2, 0x74(%rbx)
movq (%r14), %rdi
movzbl (%rdi), %eax
cmpl $0x43, %eax
je 0x7b7a
cmpl $0x46, %eax
je 0x7b6d
cmpl $0x52, %eax
jne 0x7b85
cmpl $0x0, (%rbx)
je 0x7b3d
cmpl $0x0, 0x4(%rbx)
je 0x7b3d
movl $0x2, 0x74(%rbx)
movq %rbx, %rsi
callq 0x77d8
movl %eax, (%rbx)
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x77d8
movl %eax, 0x4(%rbx)
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x77d8
testl %eax, %eax
jle 0x7b8d
movl $0x2, 0x74(%rbx)
jmp 0x7b85
movq %rbx, %rsi
callq 0x789b
movl %eax, 0xc(%rbx)
jmp 0x7b85
movq %rbx, %rsi
callq 0x789b
movl %eax, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
cmpl $0x0, (%rbx)
je 0x7b64
cmpl $0x0, 0x4(%rbx)
jne 0x7b85
jmp 0x7b64
nop
// File: /workspace/github_c_makefile_star2_O2/iciamyplant[P]Cub3d-Linux/src/parsing_map.c
// Function: ft_murs
int		ft_murs(t_recup *recup)
{
	int i;

	i = 0;
	while (i < recup->nblines)
	{
		if (recup->map[i][0] != '1')
			return (1);
		i++;
	}
	i = 0;
	while (i < recup->nblines)
	{
		if (recup->map[i][recup->sizeline - 1] != '1')
			return (1);
		i++;
	}
	if (ft_murs_util(recup->map[0]) == 1)
		return (1);
	if (ft_murs_util(recup->map[recup->nblines - 1]) == 1)
		return (1);
	return (0);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl 0x40(%rdi), %eax
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
pushq $0x1
popq %rbx
cmpq %rcx, %rax
je 0x7bc7
movq 0x48(%r14), %rdx
movq (%rdx,%rcx,8), %rdx
incq %rcx
cmpb $0x31, (%rdx)
je 0x7bb0
jmp 0x7c0d
movq 0x48(%r14), %rcx
xorl %edx, %edx
cmpq %rdx, %rax
je 0x7be6
movq (%rcx,%rdx,8), %rsi
movslq 0x44(%r14), %rdi
incq %rdx
cmpb $0x31, -0x1(%rsi,%rdi)
je 0x7bcd
jmp 0x7c0d
movq (%rcx), %rdi
callq 0x7e6c
cmpl $0x1, %eax
je 0x7c0d
movq 0x48(%r14), %rax
movslq 0x40(%r14), %rcx
movq -0x8(%rax,%rcx,8), %rdi
callq 0x7e6c
xorl %ebx, %ebx
cmpl $0x1, %eax
sete %bl
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/iciamyplant[P]Cub3d-Linux/src/parsing_map.c
// Function: ft_copy_map
int		ft_copy_map(char *str, t_recup *recup)
{
	static int	i = 0;
	int			j;

	j = 0;
	recup->map[i] = NULL;
	if (!(recup->map[i] = malloc(sizeof(char) * recup->sizeline + 1)))
		return (0);
	while (str[j] != '\0')
	{
		if (ft_depart(str[j], recup, i, j) == 1)
			recup->map[i][j] = '0';
		else if (str[j] == ' ')
			recup->map[i][j] = '1';
		else
			recup->map[i][j] = str[j];
		j++;
	}
	while (j <= (recup->sizeline - 1))
	{
		recup->map[i][j] = '1';
		j++;
	}
	recup->map[i][j] = '\0';
	i++;
	return (0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x48(%rsi), %rax
movslq 0xd67b(%rip), %r14      # 0x152a8
andq $0x0, (%rax,%r14,8)
movq %rdi, %r12
movslq 0x44(%rsi), %rdi
incq %rdi
callq 0x7100
movq 0x48(%rbx), %rcx
movq %rax, (%rcx,%r14,8)
testq %rax, %rax
je 0x7cdf
xorl %r15d, %r15d
movb (%r12,%r15), %al
testb %al, %al
je 0x7cb0
movsbl %al, %edi
movq %rbx, %rsi
movl %r14d, %edx
movl %r15d, %ecx
callq 0x7e39
cmpl $0x1, %eax
jne 0x7c89
movq 0x48(%rbx), %rax
movslq 0xd62a(%rip), %r14      # 0x152a8
movq (%rax,%r14,8), %rax
movb $0x30, (%rax,%r15)
jmp 0x7cab
movb (%r12,%r15), %al
movq 0x48(%rbx), %rcx
movslq 0xd610(%rip), %r14      # 0x152a8
movq (%rcx,%r14,8), %rcx
cmpb $0x20, %al
jne 0x7ca7
movb $0x31, (%rcx,%r15)
jmp 0x7cab
movb %al, (%rcx,%r15)
incq %r15
jmp 0x7c55
movslq %r14d, %rax
movslq 0x44(%rbx), %rdx
movq 0x48(%rbx), %rcx
movq (%rcx,%rax,8), %rcx
cmpq %rdx, %r15
jge 0x7cce
movb $0x31, (%rcx,%r15)
incq %r15
jmp 0x7cb3
movl %r15d, %eax
movb $0x0, (%rcx,%rax)
incl %r14d
movl %r14d, 0xd5c9(%rip)     # 0x152a8
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/iciamyplant[P]Cub3d-Linux/src/parsing_map.c
// Function: ft_is_map
int		ft_is_map(char *str, t_recup *recup)
{
	int i;

	i = 0;
	if (!str)
		return (0);
	if (ft_charinstr(str, '1') == 1 || ft_charinstr(str, '0') == 1)
	{
		while (str[i] != '\0')
		{
			if (str[i] != ' ' && str[i] != '0' && str[i] != '1' \
					&& str[i] != '2' && str[i] != 'N' && str[i] != 'S' \
					&& str[i] != 'E' && str[i] != 'W' && str[i] != '\n'
					&& str[i] != '\t')
			{
				if (recup->insidemap == 1)
					recup->wrongcharmap = 2;
				return (0);
			}
			i++;
		}
		return (1);
	}
	return (0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
xorl %ebx, %ebx
testq %rdi, %rdi
je 0x7d6c
movq %rsi, %r14
movq %rdi, %r15
pushq $0x31
popq %rsi
callq 0x7e1e
cmpl $0x1, %eax
je 0x7d1c
pushq $0x30
popq %rsi
movq %r15, %rdi
callq 0x7e1e
cmpl $0x1, %eax
jne 0x7d6c
movl $0x44201, %eax          # imm = 0x44201
movabsq $0x7000100000600, %rcx  # imm = 0x7000100000600
movzbl (%r15), %edx
cmpq $0x32, %rdx
ja 0x7d40
btq %rdx, %rcx
jb 0x7d4d
testq %rdx, %rdx
je 0x7d52
addl $-0x45, %edx
cmpl $0x12, %edx
ja 0x7d57
btl %edx, %eax
jae 0x7d57
incq %r15
jmp 0x7d2b
pushq $0x1
popq %rbx
jmp 0x7d6c
cmpl $0x1, 0x80(%r14)
jne 0x7d6c
movl $0x2, 0x90(%r14)
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/iciamyplant[P]Cub3d-Linux/src/parsing_map.c
// Function: ft_map
void	ft_map(char *str, t_recup *recup)
{
	int			i;
	static int	snblines = 0;
	static int	ssizeline = 0;

	i = 0;
	if (ft_is_map(str, recup) == 1)
	{
		if (recup->f == -1 || recup->c == -1 || recup->no == NULL ||
				recup->so == NULL || recup->we == NULL ||
				recup->ea == NULL || recup->sp == NULL)
			recup->erreur = 2;
		if ((i = ft_strlen(str)) > ssizeline)
			ssizeline = i;
		snblines = snblines + 1;
	}
	recup->nblines = snblines;
	recup->sizeline = ssizeline;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x7ced
testl %eax, %eax
je 0x7de7
cmpl $-0x1, 0xc(%rbx)
je 0x7db6
cmpl $-0x1, 0x10(%rbx)
je 0x7db6
cmpq $0x0, 0x18(%rbx)
je 0x7db6
cmpq $0x0, 0x20(%rbx)
je 0x7db6
cmpq $0x0, 0x28(%rbx)
je 0x7db6
cmpq $0x0, 0x30(%rbx)
je 0x7db6
cmpq $0x0, 0x38(%rbx)
jne 0x7dbd
movl $0x2, 0x74(%rbx)
movq %r14, %rdi
callq 0x9b98
movl 0xd4e5(%rip), %ecx      # 0x152b0
cmpl %ecx, %eax
jle 0x7dd7
movl %eax, 0xd4db(%rip)      # 0x152b0
movl %eax, %ecx
movl 0xd4cf(%rip), %eax      # 0x152ac
incl %eax
movl %eax, 0xd4c7(%rip)      # 0x152ac
jmp 0x7df3
movl 0xd4bf(%rip), %eax      # 0x152ac
movl 0xd4bd(%rip), %ecx      # 0x152b0
movl %eax, 0x40(%rbx)
movl %ecx, 0x44(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/iciamyplant[P]Cub3d-Linux/src/parsing_utils.c
// Function: ft_depart
int		ft_depart(char c, t_recup *recup, int i, int j)
{
	if (c == 'N' || c == 'S' || c == 'E' || c == 'W')
	{
		if (recup->depart != 'x')
			recup->multijoueurs = 1;
		recup->depart = c;
		recup->dx = i;
		recup->dy = j;
		return (1);
	}
	return (0);
}

// Assembly:
xorl %eax, %eax
leal -0x45(%rdi), %r8d
cmpl $0x12, %r8d
ja 0x7e6b
movl $0x44201, %r9d          # imm = 0x44201
btl %r8d, %r9d
jae 0x7e6b
cmpb $0x78, 0x50(%rsi)
je 0x7e5e
movl $0x1, 0x78(%rsi)
movb %dil, 0x50(%rsi)
movl %edx, 0x54(%rsi)
movl %ecx, 0x58(%rsi)
pushq $0x1
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/iciamyplant[P]Cub3d-Linux/src/keys_draw.c
// Function: ft_key_press
int		ft_key_press(int keycode, t_recup *recup)
{
	if (keycode == FORWARD_W_Z)
		recup->data.forward = 1;
	else if (keycode == BACK_S_S)
		recup->data.back = 1;
	else if (keycode == LEFT_A_Q)
		recup->data.left = 1;
	else if (keycode == RIGHT_D_D)
		recup->data.right = 1;
	else if (keycode == ROTATE_LEFT)
		recup->data.rotate_left = 1;
	else if (keycode == ROTATE_RIGHT)
		recup->data.rotate_right = 1;
	else if (keycode == 65307)
		ft_error(recup, "Non jrigole\n");
	return (1);
}

// Assembly:
cmpl $0x61, %edi
je 0x7f21
cmpl $0x64, %edi
je 0x7f39
cmpl $0x73, %edi
je 0x7f2d
cmpl $0xff53, %edi           # imm = 0xFF53
je 0x7ef0
cmpl $0xff1b, %edi           # imm = 0xFF1B
je 0x7f08
cmpl $0xff51, %edi           # imm = 0xFF51
je 0x7efc
cmpl $0x77, %edi
jne 0x7f43
movl $0x1, 0x2a4(%rsi)
jmp 0x7f43
movl $0x1, 0x2b8(%rsi)
jmp 0x7f43
movl $0x1, 0x2b4(%rsi)
jmp 0x7f43
pushq %rax
leaq 0x51b4(%rip), %rax      # 0xd0c4
movq %rsi, %rdi
movq %rax, %rsi
callq 0x95a0
addq $0x8, %rsp
jmp 0x7f43
movl $0x1, 0x2ac(%rsi)
jmp 0x7f43
movl $0x1, 0x2a8(%rsi)
jmp 0x7f43
movl $0x1, 0x2b0(%rsi)
pushq $0x1
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/iciamyplant[P]Cub3d-Linux/src/keys_draw.c
// Function: ft_key_release
int		ft_key_release(int keycode, t_recup *recup)
{
	if (keycode == FORWARD_W_Z)
		recup->data.forward = 0;
	else if (keycode == BACK_S_S)
		recup->data.back = 0;
	else if (keycode == LEFT_A_Q)
		recup->data.left = 0;
	else if (keycode == RIGHT_D_D)
		recup->data.right = 0;
	else if (keycode == ROTATE_LEFT)
		recup->data.rotate_left = 0;
	else if (keycode == ROTATE_RIGHT)
		recup->data.rotate_right = 0;
	return (1);
}

// Assembly:
cmpl $0x61, %edi
je 0x7f98
cmpl $0x64, %edi
je 0x7f8f
cmpl $0x73, %edi
je 0x7f74
cmpl $0xff53, %edi           # imm = 0xFF53
je 0x7f86
cmpl $0xff51, %edi           # imm = 0xFF51
je 0x7f7d
cmpl $0x77, %edi
jne 0x7f9f
andl $0x0, 0x2a4(%rsi)
jmp 0x7f9f
andl $0x0, 0x2a8(%rsi)
jmp 0x7f9f
andl $0x0, 0x2b4(%rsi)
jmp 0x7f9f
andl $0x0, 0x2b8(%rsi)
jmp 0x7f9f
andl $0x0, 0x2b0(%rsi)
jmp 0x7f9f
andl $0x0, 0x2ac(%rsi)
pushq $0x1
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/iciamyplant[P]Cub3d-Linux/src/keys_draw.c
// Function: ft_color_column
int		ft_color_column(t_recup *recup)
{
	int j;
	int i;

	j = -1;
	recup->ray.drawend = recup->ry - recup->ray.drawstart;
	i = recup->ray.drawend;
	while (++j < recup->ray.drawstart)
		recup->data.addr[j * recup->data.line_length / 4 +
			recup->ray.x] = recup->c;
	if (j <= recup->ray.drawend)
		ft_draw_texture(recup, recup->ray.x, j);
	j = i;
	while (++j < recup->ry)
		recup->data.addr[j * recup->data.line_length / 4 +
			recup->ray.x] = recup->f;
	return (0);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0x4(%rdi), %ebp
movl 0x364(%rdi), %eax
subl %eax, %ebp
movl %ebp, 0x368(%rdi)
pushq $-0x1
popq %rdx
pushq $0x4
popq %r14
leal 0x1(%rdx), %ecx
cmpl %eax, %ecx
jge 0x7ff9
movl 0x10(%rbx), %esi
movq 0x290(%rbx), %rdi
movl 0x29c(%rbx), %eax
imull %ecx, %eax
cltd
idivl %r14d
movslq 0x380(%rbx), %rdx
cltq
addq %rdx, %rax
movl %esi, (%rdi,%rax,4)
movl 0x364(%rbx), %eax
movl %ecx, %edx
jmp 0x7fc2
cmpl 0x368(%rbx), %edx
jge 0x8037
movl 0x380(%rbx), %esi
movq %rbx, %rdi
callq 0x8045
jmp 0x8037
movl 0xc(%rbx), %ecx
movq 0x290(%rbx), %rsi
movl 0x29c(%rbx), %eax
imull %ebp, %eax
cltd
idivl %r14d
movslq 0x380(%rbx), %rdx
cltq
addq %rdx, %rax
movl %ecx, (%rsi,%rax,4)
incl %ebp
cmpl 0x4(%rbx), %ebp
jl 0x8011
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/iciamyplant[P]Cub3d-Linux/src/keys_draw.c
// Function: ft_draw_texture
void	ft_draw_texture(t_recup *recup, int x, int y)
{
	y = recup->ray.drawstart - 1;
	ft_init_texture(recup);
	recup->t.step = 1.0 * recup->texture[0].height / recup->ray.lineheight;
	recup->t.texx = (int)(recup->t.wallx * (double)recup->texture
			[recup->t.texdir].width);
	if (recup->ray.side == 0 && recup->ray.raydirx > 0)
		recup->t.texx = recup->texture[recup->t.texdir].width -
			recup->t.texx - 1;
	if (recup->ray.side == 1 && recup->ray.raydiry < 0)
		recup->t.texx = recup->texture[recup->t.texdir].width -
			recup->t.texx - 1;
	recup->t.texpos = (recup->ray.drawstart - recup->ry / 2 +
			recup->ray.lineheight / 2) * recup->t.step;
	while (++y <= recup->ray.drawend)
	{
		recup->t.texy = (int)recup->t.texpos &
			(recup->texture[recup->t.texdir].height - 1);
		recup->t.texpos += recup->t.step;
		if (y < recup->ry && x < recup->rx)
			recup->data.addr[y * recup->data.line_length / 4 + x] =
				recup->texture[recup->t.texdir].addr[recup->t.texy *
					recup->texture[recup->t.texdir].line_length /
					4 + recup->t.texx];
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movl 0x364(%rdi), %r15d
callq 0x8293
cvtsi2sdl 0xe4(%r14), %xmm0
movl 0x354(%r14), %esi
movl 0x360(%r14), %ecx
cvtsi2sd %ecx, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x3a0(%r14)
movslq 0x388(%r14), %rax
imulq $0x60, %rax, %rax
movl 0xe0(%r14,%rax), %eax
cvtsi2sd %eax, %xmm1
mulsd 0x390(%r14), %xmm1
cvttsd2si %xmm1, %edx
movl %edx, 0x398(%r14)
cmpl $0x1, %esi
je 0x819b
testl %esi, %esi
jne 0x80d9
movsd 0x308(%r14), %xmm1
xorpd %xmm2, %xmm2
ucomisd %xmm2, %xmm1
jbe 0x80d9
notl %edx
addl %edx, %eax
movl %eax, 0x398(%r14)
movl 0x4(%r14), %eax
pushq $-0x2
popq %rsi
cltd
idivl %esi
movl %eax, %esi
pushq $0x2
popq %rdi
movl %ecx, %eax
cltd
idivl %edi
addl 0x364(%r14), %eax
addl %esi, %eax
cvtsi2sd %eax, %xmm1
leaq 0x98(%r14), %rcx
mulsd %xmm0, %xmm1
movsd %xmm1, 0x3a8(%r14)
pushq $0x4
popq %rsi
leal -0x1(%r15), %eax
cmpl 0x368(%r14), %eax
jge 0x8195
cvttsd2si %xmm1, %edi
movslq 0x388(%r14), %rax
imulq $0x60, %rax, %rdx
movl 0x4c(%rcx,%rdx), %eax
decl %eax
andl %edi, %eax
movl %eax, 0x39c(%r14)
addsd %xmm0, %xmm1
movsd %xmm1, 0x3a8(%r14)
cmpl 0x4(%r14), %r15d
jge 0x818d
cmpl %ebx, (%r14)
jle 0x818d
movq 0x18(%rcx,%rdx), %rdi
imull 0x24(%rcx,%rdx), %eax
cltd
idivl %esi
movslq 0x398(%r14), %rdx
cltq
addq %rdx, %rax
movl (%rdi,%rax,4), %edi
movq 0x290(%r14), %r8
movl 0x29c(%r14), %eax
imull %r15d, %eax
cltd
idivl %esi
addl %ebx, %eax
cltq
movl %edi, (%r8,%rax,4)
incl %r15d
jmp 0x8111
popq %rbx
popq %r14
popq %r15
retq
xorpd %xmm1, %xmm1
ucomisd 0x310(%r14), %xmm1
ja 0x80ce
jmp 0x80d9
nop
// File: /workspace/github_c_makefile_star2_O2/iciamyplant[P]Cub3d-Linux/src/raycasting_init.c
// Function: ft_initialisation2
void	ft_initialisation2(t_recup *recup)
{
	if (!(recup->s.zbuffer = (double *)malloc(sizeof(double) * recup->rx)))
		exit(0);
	recup->data.forward = 0;
	recup->data.back = 0;
	recup->data.left = 0;
	recup->data.right = 0;
	recup->data.rotate_right = 0;
	recup->data.rotate_left = 0;
	recup->ray.posx = (double)recup->dx + 0.5;
	recup->ray.posy = (double)recup->dy + 0.5;
	recup->ray.dirx = 0;
	recup->ray.diry = 0;
	recup->ray.planx = 0;
	recup->ray.plany = 0;
	ft_init_dir(recup);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movslq (%rdi), %rdi
shlq $0x3, %rdi
callq 0x7100
movq %rax, 0x410(%rbx)
testq %rax, %rax
je 0x820e
xorps %xmm0, %xmm0
andq $0x0, 0x2b4(%rbx)
movups %xmm0, 0x2a4(%rbx)
cvtdq2pd 0x54(%rbx), %xmm1
addpd 0x4ef1(%rip), %xmm1     # 0xd0e0
movupd %xmm1, 0x2d8(%rbx)
movups %xmm0, 0x2e8(%rbx)
movups %xmm0, 0x2f8(%rbx)
movq %rbx, %rdi
popq %rbx
jmp 0x9d1b
xorl %edi, %edi
callq 0x70a0
// File: /workspace/github_c_makefile_star2_O2/iciamyplant[P]Cub3d-Linux/src/raycasting_init.c
// Function: ft_initialisation3
void	ft_initialisation3(t_recup *recup)
{
	recup->ray.hit = 0;
	recup->ray.perpwalldist = 0;
	recup->ray.camerax = 2 * recup->ray.x / (double)recup->rx - 1;
	recup->ray.raydirx = recup->ray.dirx + recup->ray.planx * \
						recup->ray.camerax;
	recup->ray.raydiry = recup->ray.diry + recup->ray.plany * \
						recup->ray.camerax;
	recup->ray.mapx = (int)recup->ray.posx;
	recup->ray.mapy = (int)recup->ray.posy;
	recup->ray.movespeed = 0.1;
	recup->ray.rotspeed = 0.033 * 1.8;
	ft_init_more3(recup);
}

// Assembly:
andl $0x0, 0x350(%rdi)
andq $0x0, 0x358(%rdi)
movl 0x380(%rdi), %eax
addl %eax, %eax
cvtsi2sd %eax, %xmm0
cvtsi2sdl (%rdi), %xmm1
divsd %xmm1, %xmm0
addsd 0x4ec0(%rip), %xmm0     # 0xd100
movsd %xmm0, 0x318(%rdi)
movupd 0x2d8(%rdi), %xmm1
movupd 0x2e8(%rdi), %xmm2
movupd 0x2f8(%rdi), %xmm3
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
mulpd %xmm3, %xmm0
addpd %xmm2, %xmm0
movupd %xmm0, 0x308(%rdi)
cvttpd2dq %xmm1, %xmm0
movlpd %xmm0, 0x320(%rdi)
movaps 0x4e69(%rip), %xmm0     # 0xd0f0
movups %xmm0, 0x370(%rdi)
jmp 0x9d8b
// File: /workspace/github_c_makefile_star2_O2/iciamyplant[P]Cub3d-Linux/src/raycasting_init.c
// Function: ft_init_texture
void	ft_init_texture(t_recup *recup)
{
	if (recup->ray.side == 0 && recup->ray.raydirx < 0)
		recup->t.texdir = 0;
	if (recup->ray.side == 0 && recup->ray.raydirx >= 0)
		recup->t.texdir = 1;
	if (recup->ray.side == 1 && recup->ray.raydiry < 0)
		recup->t.texdir = 2;
	if (recup->ray.side == 1 && recup->ray.raydiry >= 0)
		recup->t.texdir = 3;
	if (recup->ray.side == 0)
		recup->t.wallx = recup->ray.posy + recup->ray.perpwalldist \
						* recup->ray.raydiry;
	else
		recup->t.wallx = recup->ray.posx + recup->ray.perpwalldist \
						* recup->ray.raydirx;
	recup->t.wallx -= floor((recup->t.wallx));
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x2d8(%rdi), %rax
movl 0x354(%rdi), %edx
movl $0x308, %ecx            # imm = 0x308
cmpl $0x1, %edx
je 0x82ed
testl %edx, %edx
jne 0x8319
movsd 0x308(%rbx), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
jbe 0x82cf
andl $0x0, 0x388(%rbx)
ucomisd %xmm1, %xmm0
jb 0x82df
movl $0x1, 0x388(%rbx)
leaq 0x2e0(%rbx), %rax
movl $0x310, %ecx            # imm = 0x310
jmp 0x8319
movsd 0x310(%rbx), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
jbe 0x8309
movl $0x2, 0x388(%rbx)
ucomisd %xmm1, %xmm0
jb 0x8319
movl $0x3, 0x388(%rbx)
movsd 0x358(%rbx), %xmm0
mulsd (%rbx,%rcx), %xmm0
addsd (%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
callq 0x7380
movsd 0x8(%rsp), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, 0x390(%rbx)
addq $0x10, %rsp
popq %rbx
retq