LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/back1127[P]linkedge-thing-access-websocket_client_sdk/sdk/test/linux/simulated_device.c
// Function: set_dev_bool_rw
int set_dev_bool_rw(const char *pk, const char *dn, int value)
{
    int index;
    
    if (value != 0 && value != 1) {
        return LE_ERROR_PARAM_RANGE_OVERFLOW;
    }

    index = get_device_index(pk, dn);
    g_devices[index].bool_rw = value;
    return LE_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x1838
cmpl $0x1, -0x1c(%rbp)
je 0x1838
movl $0x186a7, -0x4(%rbp)    # imm = 0x186A7
jmp 0x1871
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1380
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x1c(%rbp)
setne %cl
movq 0x4a3a(%rip), %rax      # 0x6290
movslq -0x20(%rbp), %rdx
imulq $0x10a8, %rdx, %rdx     # imm = 0x10A8
addq %rdx, %rax
andb $0x1, %cl
movb %cl, 0x60(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/back1127[P]linkedge-thing-access-websocket_client_sdk/sdk/test/linux/simulated_device.c
// Function: set_dev_string_rw
int set_dev_string_rw(const char *pk, const char *dn, const char *value)
{
    int index;
    
    if (strlen(value) > 2048) {
        return LE_ERROR_PARAM_RANGE_OVERFLOW;
    }

    index = get_device_index(pk, dn);
    snprintf(g_devices[index].string_rw, sizeof(g_devices[index].string_rw), "%s", value);
    return LE_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1130
cmpq $0x800, %rax            # imm = 0x800
jbe 0x192e
movl $0x186a7, -0x4(%rbp)    # imm = 0x186A7
jmp 0x1975
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1380
movl %eax, -0x24(%rbp)
movq 0x494b(%rip), %rdi      # 0x6290
movslq -0x24(%rbp), %rax
imulq $0x10a8, %rax, %rax     # imm = 0x10A8
addq %rax, %rdi
addq $0x62, %rdi
movq -0x20(%rbp), %rcx
movl $0x800, %esi            # imm = 0x800
leaq 0x26b9(%rip), %rdx      # 0x4020
movb $0x0, %al
callq 0x1050
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/back1127[P]linkedge-thing-access-websocket_client_sdk/sdk/test/linux/simulated_device.c
// Function: set_dev_date_rw
int set_dev_date_rw(const char *pk, const char *dn, const char *value)
{
    int index;
    
    if (strlen(value) > 32) {
        return LE_ERROR_PARAM_RANGE_OVERFLOW;
    }

    index = get_device_index(pk, dn);
    snprintf(g_devices[index].date_rw, sizeof(g_devices[index].date_rw), "%s", value);
    return LE_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1130
cmpq $0x20, %rax
jbe 0x1a7c
movl $0x186a7, -0x4(%rbp)    # imm = 0x186A7
jmp 0x1ac6
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1380
movl %eax, -0x24(%rbp)
movq 0x47fd(%rip), %rdi      # 0x6290
movslq -0x24(%rbp), %rax
imulq $0x10a8, %rax, %rax     # imm = 0x10A8
addq %rax, %rdi
addq $0x1062, %rdi           # imm = 0x1062
movq -0x20(%rbp), %rcx
movl $0x20, %esi
leaq 0x2568(%rip), %rdx      # 0x4020
movb $0x0, %al
callq 0x1050
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/back1127[P]linkedge-thing-access-websocket_client_sdk/sdk/test/linux/simulated_device.c
// Function: get_property_enum
int get_property_enum(const char *name)
{
   int i = E_PROPERTY_INVALID, count;

   count = sizeof(g_property_string_enum_map) / sizeof(property_string_enum_map_t);

   for(i = 0; i < count; i++) {
       if (0 == strcmp(g_property_string_enum_map[i].property_string, name)) {
           break;
       }
   }
   return i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0xe, -0xc(%rbp)
movl $0xf, -0x10(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x1bcf
movslq -0xc(%rbp), %rax
leaq 0x45ac(%rip), %rdi      # 0x6150
imulq $0x14, %rax, %rax
addq %rax, %rdi
addq $0x4, %rdi
movq -0x8(%rbp), %rsi
callq 0x11e0
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x1bc2
jmp 0x1bcf
jmp 0x1bc4
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1b91
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/back1127[P]linkedge-thing-access-websocket_client_sdk/sdk/test/linux/simulated_device.c
// Function: send_signal_property_changed
void send_signal_property_changed(const char *pk, const char *dn)
{
   int i;
   
   snprintf(g_property_changed_pk, sizeof(g_property_changed_pk), "%s", pk);
   snprintf(g_property_changed_dn, sizeof(g_property_changed_dn), "%s", dn);
   pthread_mutex_lock(&g_property_monitor_locker);
   pthread_cond_signal(&g_cond_property_changed);
   pthread_mutex_unlock(&g_property_monitor_locker);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rcx
leaq 0x4755(%rip), %rdi      # 0x6350
movl $0x10, %esi
leaq 0x2419(%rip), %rdx      # 0x4020
movb $0x0, %al
callq 0x1050
movq -0x10(%rbp), %rcx
leaq 0x4747(%rip), %rdi      # 0x6360
movl $0x20, %esi
leaq 0x23fb(%rip), %rdx      # 0x4020
movb $0x0, %al
callq 0x1050
leaq 0x466d(%rip), %rdi      # 0x62a0
callq 0x1260
leaq 0x46b1(%rip), %rdi      # 0x62f0
callq 0x1090
leaq 0x4655(%rip), %rdi      # 0x62a0
callq 0x1270
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/back1127[P]linkedge-thing-access-websocket_client_sdk/sdk/test/linux/simulated_device.c
// Function: report_all_event
void report_all_event(const char *pk, const char *dn)
{
    leda_device_data_t event_output[1] = {0};

    snprintf(event_output[0].key, MAX_PARAM_NAME_LENGTH, PROPERTY_INT32_RW);
    event_output[0].type = LEDA_TYPE_INT;
    snprintf(event_output[0].value, MAX_PARAM_VALUE_LENGTH, "%d", get_dev_int32_rw(pk, dn));
    leda_report_event(pk, dn, EVENT_INT32, event_output, 1);
    
    snprintf(event_output[0].key, MAX_PARAM_NAME_LENGTH, PROPERTY_FLOAT_RW);
    event_output[0].type = LEDA_TYPE_FLOAT;
    snprintf(event_output[0].value, MAX_PARAM_VALUE_LENGTH, "%f", get_dev_float_rw(pk, dn));
    leda_report_event(pk, dn, EVENT_FLOAT, event_output, 1);
    
    snprintf(event_output[0].key, MAX_PARAM_NAME_LENGTH, PROPERTY_STRING_RW);
    event_output[0].type = LEDA_TYPE_TEXT;
    snprintf(event_output[0].value, MAX_PARAM_VALUE_LENGTH, "%s", get_dev_string_rw(pk, dn));
    leda_report_event(pk, dn, EVENT_STRING, event_output, 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x880, %rsp            # imm = 0x880
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x860(%rbp), %rdi
xorl %esi, %esi
movl $0x844, %edx            # imm = 0x844
callq 0x1040
leaq -0x860(%rbp), %rdi
addq $0x4, %rdi
movl $0x40, %esi
leaq 0x2396(%rip), %rdx      # 0x4033
movb $0x0, %al
callq 0x1050
movl $0x0, -0x860(%rbp)
leaq -0x860(%rbp), %rax
addq $0x44, %rax
movq %rax, -0x878(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x13f0
movq -0x878(%rbp), %rdi
movl %eax, %ecx
movl $0x800, %esi            # imm = 0x800
leaq 0x235a(%rip), %rdx      # 0x403c
movb $0x0, %al
callq 0x1050
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x860(%rbp), %rcx
leaq 0x2340(%rip), %rdx      # 0x403f
movl $0x1, %r8d
callq 0x1140
leaq -0x860(%rbp), %rdi
addq $0x4, %rdi
movl $0x40, %esi
leaq 0x232a(%rip), %rdx      # 0x404b
movb $0x0, %al
callq 0x1050
movl $0x2, -0x860(%rbp)
leaq -0x860(%rbp), %rax
addq $0x44, %rax
movq %rax, -0x870(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x14e0
movq -0x870(%rbp), %rdi
cvtss2sd %xmm0, %xmm0
movl $0x800, %esi            # imm = 0x800
leaq 0x22ec(%rip), %rdx      # 0x4054
movb $0x1, %al
callq 0x1050
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x860(%rbp), %rcx
leaq 0x22d2(%rip), %rdx      # 0x4057
movl $0x1, %r8d
callq 0x1140
leaq -0x860(%rbp), %rdi
addq $0x4, %rdi
movl $0x40, %esi
leaq 0x22bc(%rip), %rdx      # 0x4063
movb $0x0, %al
callq 0x1050
movl $0x3, -0x860(%rbp)
leaq -0x860(%rbp), %rax
addq $0x44, %rax
movq %rax, -0x868(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x18c0
movq -0x868(%rbp), %rdi
movq %rax, %rcx
movl $0x800, %esi            # imm = 0x800
leaq 0x2233(%rip), %rdx      # 0x4020
movb $0x0, %al
callq 0x1050
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x860(%rbp), %rcx
leaq 0x2263(%rip), %rdx      # 0x406d
movl $0x1, %r8d
callq 0x1140
addq $0x880, %rsp            # imm = 0x880
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/back1127[P]linkedge-thing-access-websocket_client_sdk/sdk/test/linux/simulated_device.c
// Function: property_monitor
void *property_monitor(void *arg)
{
    leda_device_data_t property[1] = {0};

    pthread_detach(pthread_self());
    
    while (g_running) {
        pthread_mutex_lock(&g_property_monitor_locker);
        pthread_cond_wait(&g_cond_property_changed, &g_property_monitor_locker);
        report_all_property(g_property_changed_pk, g_property_changed_dn);
        memset(g_property_changed_pk, 0, sizeof(g_property_changed_pk));
        memset(g_property_changed_dn, 0, sizeof(g_property_changed_dn));
        pthread_mutex_unlock(&g_property_monitor_locker);
    }

    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x850, %rsp            # imm = 0x850
movq %rdi, -0x8(%rbp)
leaq -0x850(%rbp), %rdi
xorl %esi, %esi
movl $0x844, %edx            # imm = 0x844
callq 0x1040
callq 0x1170
movq %rax, %rdi
callq 0x11d0
cmpl $0x0, 0x3dc6(%rip)      # 0x627c
je 0x251e
leaq 0x3de1(%rip), %rdi      # 0x62a0
callq 0x1260
leaq 0x3e25(%rip), %rdi      # 0x62f0
leaq 0x3dce(%rip), %rsi      # 0x62a0
callq 0x1220
leaq 0x3e72(%rip), %rdi      # 0x6350
leaq 0x3e7b(%rip), %rsi      # 0x6360
callq 0x1e20
leaq 0x3e5f(%rip), %rdi      # 0x6350
xorl %esi, %esi
movl $0x10, %edx
callq 0x1040
leaq 0x3e5c(%rip), %rdi      # 0x6360
xorl %esi, %esi
movl $0x20, %edx
callq 0x1040
leaq 0x3d89(%rip), %rdi      # 0x62a0
callq 0x1270
jmp 0x24af
xorl %eax, %eax
addq $0x850, %rsp            # imm = 0x850
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/back1127[P]linkedge-thing-access-websocket_client_sdk/sdk/test/linux/simulated_device.c
// Function: thread_online
void* thread_online(void *arg)
{
    int count, i, ret;
    char *pk, *dn;
    
    pthread_detach(pthread_self());
    prctl(PR_SET_NAME, "online", NULL, NULL, NULL);

    count = g_devices_count;
    
    while (g_running) {
        pthread_mutex_lock(&g_mtx_online);
        pthread_cond_wait(&g_cond_conn_state_changed, &g_mtx_online);
        for (i = 0; i < count; i++) {
            if (g_is_connected) {
                ret = leda_online(g_devices[i].pk, g_devices[i].dn);
                if (LE_SUCCESS == ret) {
                    g_devices[i].online = 1;
                }
            } else {
                g_devices[i].online = 0; 
            }
        }
        pthread_mutex_unlock(&g_mtx_online);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
callq 0x1170
movq %rax, %rdi
callq 0x11d0
movl $0xf, %edi
leaq 0x1b5f(%rip), %rsi      # 0x4114
xorl %eax, %eax
movl %eax, %r8d
movq %r8, %rdx
movq %r8, %rcx
movb $0x0, %al
callq 0x10b0
movl 0x3ccb(%rip), %eax      # 0x6298
movl %eax, -0x14(%rbp)
cmpl $0x0, 0x3ca5(%rip)      # 0x627c
je 0x26b0
leaq 0x3ce4(%rip), %rdi      # 0x62c8
callq 0x1260
leaq 0x3d30(%rip), %rdi      # 0x6320
leaq 0x3cd1(%rip), %rsi      # 0x62c8
callq 0x1220
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x269f
cmpl $0x0, 0x3d6a(%rip)      # 0x6380
je 0x2673
movq 0x3c71(%rip), %rdi      # 0x6290
movslq -0x18(%rbp), %rax
imulq $0x10a8, %rax, %rax     # imm = 0x10A8
addq %rax, %rdi
movq 0x3c5c(%rip), %rsi      # 0x6290
movslq -0x18(%rbp), %rax
imulq $0x10a8, %rax, %rax     # imm = 0x10A8
addq %rax, %rsi
addq $0x10, %rsi
callq 0x11c0
movl %eax, -0x1c(%rbp)
xorl %eax, %eax
cmpl -0x1c(%rbp), %eax
jne 0x2671
movq 0x3c34(%rip), %rax      # 0x6290
movslq -0x18(%rbp), %rcx
imulq $0x10a8, %rcx, %rcx     # imm = 0x10A8
addq %rcx, %rax
movl $0x1, 0x30(%rax)
jmp 0x268f
movq 0x3c16(%rip), %rax      # 0x6290
movslq -0x18(%rbp), %rcx
imulq $0x10a8, %rcx, %rcx     # imm = 0x10A8
addq %rcx, %rax
movl $0x0, 0x30(%rax)
jmp 0x2691
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x2603
leaq 0x3c22(%rip), %rdi      # 0x62c8
callq 0x1270
jmp 0x25d0
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/back1127[P]linkedge-thing-access-websocket_client_sdk/sdk/test/linux/simulated_device.c
// Function: thread_report
void *thread_report(void *arg) {
    int count, i;
    char *pk, *dn;

    pthread_detach(pthread_self());
    prctl(PR_SET_NAME, "report", NULL, NULL, NULL);
    
    count = g_devices_count;
    
    while (g_running) {
        for (i = 0; i < count; i++) {
            pk = g_devices[i].pk;
            dn = g_devices[i].dn;
            if (g_devices[i].online == 1) {
                report_all_event(pk, dn);
                report_all_property(pk, dn);
            }
            usleep(5*1000000/count);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
callq 0x1170
movq %rax, %rdi
callq 0x11d0
movl $0xf, %edi
leaq 0x1a36(%rip), %rsi      # 0x411b
xorl %eax, %eax
movl %eax, %r8d
movq %r8, %rdx
movq %r8, %rcx
movb $0x0, %al
callq 0x10b0
movl 0x3b9b(%rip), %eax      # 0x6298
movl %eax, -0x14(%rbp)
cmpl $0x0, 0x3b75(%rip)      # 0x627c
je 0x27ae
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x27a9
movq 0x3b69(%rip), %rax      # 0x6290
movslq -0x18(%rbp), %rcx
imulq $0x10a8, %rcx, %rcx     # imm = 0x10A8
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq 0x3b50(%rip), %rax      # 0x6290
movslq -0x18(%rbp), %rcx
imulq $0x10a8, %rcx, %rcx     # imm = 0x10A8
addq %rcx, %rax
addq $0x10, %rax
movq %rax, -0x28(%rbp)
movq 0x3b33(%rip), %rax      # 0x6290
movslq -0x18(%rbp), %rcx
imulq $0x10a8, %rcx, %rcx     # imm = 0x10A8
addq %rcx, %rax
cmpl $0x1, 0x30(%rax)
jne 0x278b
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x1c60
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x1e20
movl $0x4c4b40, %eax         # imm = 0x4C4B40
cltd
idivl -0x14(%rbp)
movl %eax, %edi
callq 0x1180
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x2714
jmp 0x2700
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/back1127[P]linkedge-thing-access-websocket_client_sdk/sdk/test/linux/simulated_device.c
// Function: cb_call_service
static int cb_call_service(const char *pk, const char *dn, const char *method_name, const leda_device_data_t *input, int count, 
                            leda_device_data_t *output, void *usr)
{
    int i, ret = LE_ERROR_UNKNOWN;
    
    if (!method_name || !output) {
        return LE_ERROR_INVAILD_PARAM;
    }
    if (0 == strcmp(SERVICE_WRITE, method_name)) {
        ret = cb_set_property(pk, dn, input, count, NULL);
    } else {
        ret = LEDA_ERROR_SERVICE_NOT_EXIST;
    }

    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movq %r9, -0x38(%rbp)
movl $0x186a0, -0x40(%rbp)   # imm = 0x186A0
cmpq $0x0, -0x20(%rbp)
je 0x3939
cmpq $0x0, -0x38(%rbp)
jne 0x3942
movl $0x186a1, -0x4(%rbp)    # imm = 0x186A1
jmp 0x3985
movq -0x20(%rbp), %rsi
leaq 0x97b(%rip), %rdi       # 0x42c8
callq 0x11e0
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x3978
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
movl -0x2c(%rbp), %ecx
xorl %eax, %eax
movl %eax, %r8d
callq 0x35a0
movl %eax, -0x40(%rbp)
jmp 0x397f
movl $0x1a9cd, -0x40(%rbp)   # imm = 0x1A9CD
movl -0x40(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/MartinNovotny25[P]VUT-FIT-IFJ2020/tokenList.c
// Function: TDLLPrintAllTokens
void TDLLPrintAllTokens(TDLList *L) {
    printf("tokenList: Printing all tokens from DL list...\n\n");
    TDLLFirst(L);
    
    while (L->Act != NULL) {                          //while prechadza listom
        printf("typ   %d\n", L->Act->tdata.type);
        if (L->Act->tdata.type == t_EOF) {
            printf("lexem EOF\n\n");
        } else {
            if (L->Act->tdata.type == t_EOL) {
                printf("lexem EOL\n\n");
            } else {
                printf("lexem %s\n\n", L->Act->tdata.lex);
            }
        }
        
        TDLLSucc(L);                                //presun aktivity na nasledujuci token
    }
    printf("tokenList: Printing Ended Succesfully...\n");
    TDLLFirst(L);                                      //aktivita sa vrati na zaciatok
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0xbe01(%rip), %rdi      # 0xd004
movb $0x0, %al
callq 0x1060
movq -0x8(%rbp), %rdi
callq 0x12c0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x129c
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x8(%rax), %esi
leaq 0xbe05(%rip), %rdi      # 0xd035
movb $0x0, %al
callq 0x1060
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0x1d, 0x8(%rax)
jne 0x1255
leaq 0xbdf3(%rip), %rdi      # 0xd03f
movb $0x0, %al
callq 0x1060
jmp 0x128e
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0x2f, 0x8(%rax)
jne 0x1273
leaq 0xbde1(%rip), %rdi      # 0xd04b
movb $0x0, %al
callq 0x1060
jmp 0x128c
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rsi
leaq 0xbdd2(%rip), %rdi      # 0xd057
movb $0x0, %al
callq 0x1060
jmp 0x128e
movq -0x8(%rbp), %rdi
callq 0x12e0
jmp 0x1213
leaq 0xbdbf(%rip), %rdi      # 0xd062
movb $0x0, %al
callq 0x1060
movq -0x8(%rbp), %rdi
callq 0x12c0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MartinNovotny25[P]VUT-FIT-IFJ2020/tokenList.c
// Function: TDLLDisposeList
void TDLLDisposeList (TDLList *L) {

    TDLLElemPtr tmp = L->First;             //tmp ukazuje na prvy prvok
    while (L->First != NULL) {              //zoznam nie je prazdny
        L->First = L->First->rptr;          //cyklus posuva ukazatel First do prava a uvolnuje pamat prvku pred nim
        free(tmp);
        tmp = L->First;
    }
    L->First = NULL;                        //ukazatele zoznamu nastavi na NULL
    L->Last = NULL;
    L->Act = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x1389
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x1357
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MartinNovotny25[P]VUT-FIT-IFJ2020/tokenList.c
// Function: TDLLInsertFirst
void TDLLInsertFirst (TDLList *L, TOKEN token) {

    TDLLElemPtr tmp = (TDLLElemPtr) malloc(sizeof(struct TDLLElem));       //alokacia pamate
    if (tmp == NULL) {                                 //overenie uspesnosti alokacie
        return;
    }
    tmp->tdata = token;                                    //nakopirovanie dat
    tmp->rptr = L->First;                               //prepojenie ukazatelov
    tmp->lptr = NULL;
    if (L->First == NULL) {                             //zoznam je prazdny
        L->Last = tmp;                                  //posledny prvok bude tmp
    }
    else {                                              //zoznam nie je prazdny
        L->First->lptr = tmp;                           //lavy ukazate prveho bude ukazovat na novy prvok
    }
    L->First = tmp;                                     //prvy prvok bude tmp
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rsi, -0x10(%rbp)
movl %edx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movl $0x20, %edi
callq 0x10a0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x13ea
jmp 0x144a
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x1430
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x143f
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/MartinNovotny25[P]VUT-FIT-IFJ2020/tokenList.c
// Function: TDLLInsertLast
void TDLLInsertLast(TDLList *L, TOKEN token) {

    TDLLElemPtr tmp = (TDLLElemPtr) malloc(sizeof(struct TDLLElem));       //alokacia pamate
    if (tmp == NULL) {
        return;
    }
    tmp->tdata = token;                                    //nakopirovanie dat
    tmp->rptr = NULL;                                   //pravy ukazatel noveho prvku musi byt NULL
    tmp->lptr = L->Last;                                //lavy ukazatl noveho ukazuje na Last
    if (L->Last == NULL) {                              //zoznam je prazdny
        L->First = tmp;
    }
    else {                                              //zoznam nieje prazdny
        L->Last->rptr = tmp;
    }
    L->Last = tmp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rsi, -0x10(%rbp)
movl %edx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movl $0x20, %edi
callq 0x10a0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x147a
jmp 0x14dd
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x14c1
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
jmp 0x14d1
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MartinNovotny25[P]VUT-FIT-IFJ2020/tokenList.c
// Function: TDLLDeleteFirst
void TDLLDeleteFirst (TDLList *L) {

    if (L->First != NULL) {                         //zoznam nie je prazdny
        TDLLElemPtr tmp = L->First;
        if (L->First == L->Act) {
            L->Act = NULL;
        }
        if (L->First == L->Last) {                  //zoznam ma jediny prvok
            tmp = L->First;
            L->First = NULL;
            L->Last = NULL;
        }
        else {                                      //zoznam ma viac prvkov
            tmp = L->First;
            L->First = L->First->rptr;
            L->First->lptr = NULL;
        }
        free(tmp);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x163c
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jne 0x15d2
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jne 0x1607
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
jmp 0x1633
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rdi
callq 0x1030
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MartinNovotny25[P]VUT-FIT-IFJ2020/tokenList.c
// Function: TDLLDeleteLast
void TDLLDeleteLast (TDLList *L) {

    if (L->First != NULL) {                      //zoznam nie je prazdny
        TDLLElemPtr tmp = L->First;
        if (L->First == L->Act) {
            L->Act = NULL;
        }
        if (L->First == L->Last) {               //zoznam ma jediny prvok
            tmp = L->Last;
            L->First = NULL;
            L->Last = NULL;
        }
        else {                                   //zoznam ma viac prvkov
            tmp = L->Last;
            L->Last = L->Last->lptr;
            L->Last->rptr = NULL;
        }
        free(tmp);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x1701
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jne 0x1692
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jne 0x16c8
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
jmp 0x16f8
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq $0x0, 0x18(%rax)
movq -0x10(%rbp), %rdi
callq 0x1030
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MartinNovotny25[P]VUT-FIT-IFJ2020/tokenList.c
// Function: TDLLPostDelete
void TDLLPostDelete (TDLList *L) {

    if (L->Act && L->Act != L->Last) {              //zoznam musi byt aktivny inde ako na posledom prvku
        TDLLElemPtr tmp = L->Act->rptr;              //tmp bude ukazovat na odstranovany prvok
        if (tmp == L->Last) {                       //mazany prvok je posledny
            L->Act->rptr = NULL;                    //pravy ukazatel aktivneho prvku bude NULL
            L->Last = L->Act;                       //aktivny prvok sa stava poslednym
        }
        else {                                      //mazany prvok nieje posledny
            L->Act->rptr = tmp->rptr;               //pravy ukazatel aktivneho ukazuje vpravo od mazaneho
            tmp->rptr->lptr = L->Act;               //lavy ukazetel vpravo od mazaneho bude ukazovat na aktivny
        }
        free(tmp);                                  //uvolnenie pamati mazaneho prvku
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x17ae
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
je 0x17ae
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jne 0x177d
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x17a5
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rdi
callq 0x1030
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MartinNovotny25[P]VUT-FIT-IFJ2020/tokenList.c
// Function: TDLLPreDelete
void TDLLPreDelete (TDLList *L) {

    if (L->Act && L->Act != L->First) {             //zoznam musi byt aktivny inde ako na prvom prvku
        TDLLElemPtr tmp = L->Act->lptr;              //tmp bude ukazovat na odstranovany prvok
        if (tmp == L->First) {                      //odstranovan prvok je prvy
            L->Act->lptr = NULL;                    //lavy ukazatel aktivneho prvku bude NULL
            L->First = L->Act;                      //aktivny prvok sa stava prvym
        }
        else {                                      //odstranovany prvok nie je prvy
            L->Act->lptr = tmp->lptr;               //lavy ukazatel aktivneho musi ukazovat vlavo od mazaneho
            tmp->lptr->rptr = L->Act;               //pravy ukazatel vpravo od mazaneho musi ukazovat na aktivny
        }
        free(tmp);                                  //uvolnenie pamati mazaneho prvku
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x185b
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
je 0x185b
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x182a
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0x1852
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rdi
callq 0x1030
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MartinNovotny25[P]VUT-FIT-IFJ2020/tokenList.c
// Function: TDLLPostInsert
void TDLLPostInsert (TDLList *L, TOKEN token) {

    if (L->Act) {                                   //zoznam je aktivny
        TDLLElemPtr tmp = (TDLLElemPtr) malloc(sizeof(struct TDLLElem));   //alokacia pamati
        tmp->tdata = token;                            //kopirovanie dat
        if (L->Act == L->Last) {                    //aktivny prvok je posledny
            L->Act->rptr = tmp;
            tmp->lptr = L->Act;
            tmp->rptr = NULL;
            L->Last = tmp;
        }
        else {                                      //aktivny prvok nie je posledny
            tmp->rptr = L->Act->rptr;               //pravy ukazatel tmp ukazuje vpravo od Act
            tmp->rptr->lptr = tmp;                  //lavy ukazatel prvku vpravo od tmp ukazuje na tmp
            tmp->lptr = L->Act;                     //lavy ukazatel tmp ukazuje na Act
            L->Act->rptr = tmp;                     //pravy ukazatel act ukazuje na tmp
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rsi, -0x10(%rbp)
movl %edx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x1945
movl $0x20, %edi
callq 0x10a0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jne 0x18ff
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x1943
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rcx
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x18(%rax)
jmp 0x1945
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MartinNovotny25[P]VUT-FIT-IFJ2020/tokenList.c
// Function: TDLLPreInsert
void TDLLPreInsert (TDLList *L, TOKEN token) {

    if (L->Act) {                                   //zoznam je aktivny
        TDLLElemPtr tmp = (TDLLElemPtr) malloc(sizeof(struct TDLLElem));   //alokacia pamati
        tmp->tdata = token;                            //kopirovanie dat
        if (L->Act == L->First) {                    //aktivny prvok je prvy
            tmp->rptr = L->Act;                      //pravy ukazatel tmp ukazuje na act
            tmp->lptr = NULL;                        //lavy ukazatel tmp je NULL
            L->Act->lptr = tmp;                      //lavy ukazatel act ukazuje na tmp
            L->First = tmp;                          //tmp je prvy prvok v zozname
        }
        else {                                      //aktivny prvok nie je prvy
            tmp->rptr = L->Act;                      //pravy ukazatel tmp ukazuje na act
            tmp->lptr = L->Act->lptr;                //lavy ukazatel tmp ukazuje na prvok pred act
            tmp->lptr->rptr = tmp;                   //pravy ukazatel prvku pred act ukazuje na tmp
            L->Act->lptr = tmp;                      //lavy ukazatel act ukazuje na tmp
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rsi, -0x10(%rbp)
movl %edx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x1a23
movl $0x20, %edi
callq 0x10a0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x19dd
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
jmp 0x1a21
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x10(%rax)
jmp 0x1a23
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MartinNovotny25[P]VUT-FIT-IFJ2020/parser.c
// Function: main
int main() {

    //inicilizacia zoznamu tokenov
    TDLLInitList(&tokens);

    //načitanie prvého tokenu
    token = get_next_token(stdin);
    //nacitanie tokenu do zoznamu tokenov, bude sa volast s kazdym get_next_token
    TDLLInsertLast(&tokens, token);
    // eol(y) na zaciatku -- nepovinne
    if (token.type == t_EOL) {
        rule_eol();
    }

    // Test package main
    if (token.type != t_PACKAGE_MAIN) { error_call(ERR_SYN, &tokens); }
    else { token = get_next_token(stdin); TDLLInsertLast(&tokens, token); }

    // Neterminal <eol> -- nepovinny eol
    if (token.type == t_EOL) {
        rule_eol();
    }

    // Neterminal <def_func> -- Zacne definicia funkcie
    if (token.type != t_FUNC) { error_call(ERR_SYN, &tokens); }
    else {
        token = get_next_token(stdin);
        TDLLInsertLast(&tokens, token);
        def_func();
    }
    goThroughList(&tokens);

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl $0x0, -0x4(%rbp)
leaq 0xe89a(%rip), %rdi      # 0x103b0
callq 0x1310
movq 0xe4b6(%rip), %rax      # 0xffd8
movq (%rax), %rdi
callq 0x4840
movq %rax, -0x18(%rbp)
movl %edx, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq %rax, 0xe88c(%rip)      # 0x103c8
movq -0x10(%rbp), %rax
movq %rax, 0xe889(%rip)      # 0x103d0
movq 0xe87a(%rip), %rsi      # 0x103c8
movl 0xe87c(%rip), %edx      # 0x103d0
leaq 0xe855(%rip), %rdi      # 0x103b0
callq 0x1450
cmpl $0x2f, 0xe869(%rip)     # 0x103d0
jne 0x1b6e
callq 0x43d0
cmpl $0x1b, 0xe85b(%rip)     # 0x103d0
je 0x1b8a
movl $0x2, %edi
leaq 0xe82d(%rip), %rsi      # 0x103b0
callq 0x64e0
jmp 0x1bcf
movq 0xe447(%rip), %rax      # 0xffd8
movq (%rax), %rdi
callq 0x4840
movq %rax, -0x28(%rbp)
movl %edx, -0x20(%rbp)
movq -0x28(%rbp), %rax
movq %rax, 0xe81d(%rip)      # 0x103c8
movq -0x20(%rbp), %rax
movq %rax, 0xe81a(%rip)      # 0x103d0
movq 0xe80b(%rip), %rsi      # 0x103c8
movl 0xe80d(%rip), %edx      # 0x103d0
leaq 0xe7e6(%rip), %rdi      # 0x103b0
callq 0x1450
cmpl $0x2f, 0xe7fa(%rip)     # 0x103d0
jne 0x1bdd
callq 0x43d0
cmpl $0x1c, 0xe7ec(%rip)     # 0x103d0
je 0x1bf9
movl $0x2, %edi
leaq 0xe7be(%rip), %rsi      # 0x103b0
callq 0x64e0
jmp 0x1c43
movq 0xe3d8(%rip), %rax      # 0xffd8
movq (%rax), %rdi
callq 0x4840
movq %rax, -0x38(%rbp)
movl %edx, -0x30(%rbp)
movq -0x38(%rbp), %rax
movq %rax, 0xe7ae(%rip)      # 0x103c8
movq -0x30(%rbp), %rax
movq %rax, 0xe7ab(%rip)      # 0x103d0
movq 0xe79c(%rip), %rsi      # 0x103c8
movl 0xe79e(%rip), %edx      # 0x103d0
leaq 0xe777(%rip), %rdi      # 0x103b0
callq 0x1450
callq 0x1c60
leaq 0xe766(%rip), %rdi      # 0x103b0
callq 0xc160
xorl %eax, %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MartinNovotny25[P]VUT-FIT-IFJ2020/parser.c
// Function: rule_func_retlist_body
void rule_func_retlist_body() {
    switch (token.type) {
        //REQUIRED_RETURN
        case t_LEFT_BRACKET:
            token = get_next_token(stdin);
            TDLLInsertLast(&tokens, token);

            rule_func_body();

            break;

            //OPTIONAL_RETURN
        case t_BRACES_L:
            global_brace_count++;
            token = get_next_token(stdin);
            TDLLInsertLast(&tokens, token);
            if (token.type != t_EOL) { error_call(ERR_SYN, &tokens); }
            else { token = get_next_token(stdin); TDLLInsertLast(&tokens, token); }

            // Neterminál stat (STATEMENT) -- Vyjadruje možné príkazy v tele funkcie
            rule_stat();

    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl 0xe512(%rip), %eax      # 0x103d0
movl %eax, -0x34(%rbp)
subl $0x6, %eax
je 0x1ed5
jmp 0x1ec8
movl -0x34(%rbp), %eax
subl $0x34, %eax
je 0x1f24
jmp 0x1fde
movq 0xe0fc(%rip), %rax      # 0xffd8
movq (%rax), %rdi
callq 0x4840
movq %rax, -0x10(%rbp)
movl %edx, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq %rax, 0xe4d2(%rip)      # 0x103c8
movq -0x8(%rbp), %rax
movq %rax, 0xe4cf(%rip)      # 0x103d0
movq 0xe4c0(%rip), %rsi      # 0x103c8
movl 0xe4c2(%rip), %edx      # 0x103d0
leaq 0xe49b(%rip), %rdi      # 0x103b0
callq 0x1450
callq 0x2130
jmp 0x1fde
movl 0xe482(%rip), %eax      # 0x103ac
addl $0x1, %eax
movl %eax, 0xe479(%rip)      # 0x103ac
movq 0xe09e(%rip), %rax      # 0xffd8
movq (%rax), %rdi
callq 0x4840
movq %rax, -0x20(%rbp)
movl %edx, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq %rax, 0xe474(%rip)      # 0x103c8
movq -0x18(%rbp), %rax
movq %rax, 0xe471(%rip)      # 0x103d0
movq 0xe462(%rip), %rsi      # 0x103c8
movl 0xe464(%rip), %edx      # 0x103d0
leaq 0xe43d(%rip), %rdi      # 0x103b0
callq 0x1450
cmpl $0x2f, 0xe451(%rip)     # 0x103d0
je 0x1f94
movl $0x2, %edi
leaq 0xe423(%rip), %rsi      # 0x103b0
callq 0x64e0
jmp 0x1fd9
movq 0xe03d(%rip), %rax      # 0xffd8
movq (%rax), %rdi
callq 0x4840
movq %rax, -0x30(%rbp)
movl %edx, -0x28(%rbp)
movq -0x30(%rbp), %rax
movq %rax, 0xe413(%rip)      # 0x103c8
movq -0x28(%rbp), %rax
movq %rax, 0xe410(%rip)      # 0x103d0
movq 0xe401(%rip), %rsi      # 0x103c8
movl 0xe403(%rip), %edx      # 0x103d0
leaq 0xe3dc(%rip), %rdi      # 0x103b0
callq 0x1450
callq 0x2280
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MartinNovotny25[P]VUT-FIT-IFJ2020/parser.c
// Function: rule_return_type
void rule_return_type() {
    switch (token.type) {
        case t_RIGHT_BRACKET:
            //token = get_next_token(stdin);
            //TDLLInsertLast(&tokens, token);
            break;

        case t_INT_ID:
            is_return = true;
            token = get_next_token(stdin);
            TDLLInsertLast(&tokens, token);
            rule_return_type_n();
            break;
        case t_FLOAT64:
            is_return = true;
            token = get_next_token(stdin);
            TDLLInsertLast(&tokens, token);
            rule_return_type_n();
            break;
        case t_STRING_ID:
            is_return = true;
            token = get_next_token(stdin);
            TDLLInsertLast(&tokens, token);
            rule_return_type_n();
            break;
    }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl 0xe3d2(%rip), %eax      # 0x103d0
addl $-0x7, %eax
movl %eax, %ecx
movq %rcx, -0x38(%rbp)
subl $0x11, %eax
ja 0x2123
movq -0x38(%rbp), %rax
leaq 0xb071(%rip), %rcx      # 0xd08c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0x2123
movb $0x1, 0xe379(%rip)      # 0x103a9
movq 0xdfa1(%rip), %rax      # 0xffd8
movq (%rax), %rdi
callq 0x4840
movq %rax, -0x10(%rbp)
movl %edx, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq %rax, 0xe377(%rip)      # 0x103c8
movq -0x8(%rbp), %rax
movq %rax, 0xe374(%rip)      # 0x103d0
movq 0xe365(%rip), %rsi      # 0x103c8
movl 0xe367(%rip), %edx      # 0x103d0
leaq 0xe340(%rip), %rdi      # 0x103b0
callq 0x1450
callq 0x40f0
jmp 0x2123
movb $0x1, 0xe323(%rip)      # 0x103a9
movq 0xdf4b(%rip), %rax      # 0xffd8
movq (%rax), %rdi
callq 0x4840
movq %rax, -0x20(%rbp)
movl %edx, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq %rax, 0xe321(%rip)      # 0x103c8
movq -0x18(%rbp), %rax
movq %rax, 0xe31e(%rip)      # 0x103d0
movq 0xe30f(%rip), %rsi      # 0x103c8
movl 0xe311(%rip), %edx      # 0x103d0
leaq 0xe2ea(%rip), %rdi      # 0x103b0
callq 0x1450
callq 0x40f0
jmp 0x2123
movb $0x1, 0xe2d0(%rip)      # 0x103a9
movq 0xdef8(%rip), %rax      # 0xffd8
movq (%rax), %rdi
callq 0x4840
movq %rax, -0x30(%rbp)
movl %edx, -0x28(%rbp)
movq -0x30(%rbp), %rax
movq %rax, 0xe2ce(%rip)      # 0x103c8
movq -0x28(%rbp), %rax
movq %rax, 0xe2cb(%rip)      # 0x103d0
movq 0xe2bc(%rip), %rsi      # 0x103c8
movl 0xe2be(%rip), %edx      # 0x103d0
leaq 0xe297(%rip), %rdi      # 0x103b0
callq 0x1450
callq 0x40f0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MartinNovotny25[P]VUT-FIT-IFJ2020/parser.c
// Function: rule_func_body
void rule_func_body() {
    //pravidlo return_type
    rule_return_type();

    //V prípade, že nám nepríde ukončovacia zátvorka zoznamu návratových typov, ERROR.

    if (token.type != t_RIGHT_BRACKET) { error_call(ERR_SYN, &tokens); }
    else { token = get_next_token(stdin); TDLLInsertLast(&tokens, token); }

    // Token otváracej množinovej zátvorky pre začiatok tela funckie

    if (token.type != t_BRACES_L) { error_call(ERR_SYN, &tokens); }
    else {
        global_brace_count++;
        token = get_next_token(stdin);
        TDLLInsertLast(&tokens, token);
    }

    // Nutný EOL po otváracej množinovej zátvorke
    if (token.type != t_EOL) { error_call(ERR_SYN, &tokens); }
    else { token = get_next_token(stdin); TDLLInsertLast(&tokens, token); }


    // Neterminál EOL pre možné príkazy v tele funckie
    rule_stat();

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
callq 0x1ff0
cmpl $0x7, 0xe28c(%rip)      # 0x103d0
je 0x2159
movl $0x2, %edi
leaq 0xe25e(%rip), %rsi      # 0x103b0
callq 0x64e0
jmp 0x219e
movq 0xde78(%rip), %rax      # 0xffd8
movq (%rax), %rdi
callq 0x4840
movq %rax, -0x10(%rbp)
movl %edx, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq %rax, 0xe24e(%rip)      # 0x103c8
movq -0x8(%rbp), %rax
movq %rax, 0xe24b(%rip)      # 0x103d0
movq 0xe23c(%rip), %rsi      # 0x103c8
movl 0xe23e(%rip), %edx      # 0x103d0
leaq 0xe217(%rip), %rdi      # 0x103b0
callq 0x1450
cmpl $0x34, 0xe22b(%rip)     # 0x103d0
je 0x21ba
movl $0x2, %edi
leaq 0xe1fd(%rip), %rsi      # 0x103b0
callq 0x64e0
jmp 0x220e
movl 0xe1ec(%rip), %eax      # 0x103ac
addl $0x1, %eax
movl %eax, 0xe1e3(%rip)      # 0x103ac
movq 0xde08(%rip), %rax      # 0xffd8
movq (%rax), %rdi
callq 0x4840
movq %rax, -0x20(%rbp)
movl %edx, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq %rax, 0xe1de(%rip)      # 0x103c8
movq -0x18(%rbp), %rax
movq %rax, 0xe1db(%rip)      # 0x103d0
movq 0xe1cc(%rip), %rsi      # 0x103c8
movl 0xe1ce(%rip), %edx      # 0x103d0
leaq 0xe1a7(%rip), %rdi      # 0x103b0
callq 0x1450
cmpl $0x2f, 0xe1bb(%rip)     # 0x103d0
je 0x222a
movl $0x2, %edi
leaq 0xe18d(%rip), %rsi      # 0x103b0
callq 0x64e0
jmp 0x226f
movq 0xdda7(%rip), %rax      # 0xffd8
movq (%rax), %rdi
callq 0x4840
movq %rax, -0x30(%rbp)
movl %edx, -0x28(%rbp)
movq -0x30(%rbp), %rax
movq %rax, 0xe17d(%rip)      # 0x103c8
movq -0x28(%rbp), %rax
movq %rax, 0xe17a(%rip)      # 0x103d0
movq 0xe16b(%rip), %rsi      # 0x103c8
movl 0xe16d(%rip), %edx      # 0x103d0
leaq 0xe146(%rip), %rdi      # 0x103b0
callq 0x1450
callq 0x2280
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MartinNovotny25[P]VUT-FIT-IFJ2020/parser.c
// Function: rule_id_n_or_call_func
void rule_id_n_or_call_func()
{
    switch (token.type)
    {
        case t_COMMA:
            //Kontrola dalších
            rule_id_n();
            //Či príde := alebo =
            rule_init_def();
            // či s bude priradzovan pomocou výrazu alebo volaním funckie
            rule_func_assign();
            rule_stat();
            break;
        case t_DEFINITION_2:
            //Kontrola dalších ID, vieme že neprídu, ale musí to tam byť, nič to nemení
            rule_id_n();
            //Či príde := alebo =, netreba, ale treba to tam pre správne fungovanie
            rule_init_def();
            // či s bude priradzovan pomocou výrazu alebo volaním funckie
            rule_func_assign();
            rule_stat();
            break;

        case t_ASSIGN:
            //Kontrola dalších ID, vieme že neprídu, ale musí to tam byť, nič to nemení
            rule_id_n();
            //Či príde := alebo =, netreba, ale treba to tam pre správne fungovanie
            rule_init_def();
            // či s bude priradzovan pomocou výrazu alebo volaním funckie
            rule_func_assign();
            rule_stat();
            break;

        case t_LEFT_BRACKET:
            token = get_next_token(stdin);
            TDLLInsertLast(&tokens, token);
            // Testovanie parametrov funkcie
            rule_func_params();
            // Nepovinné eoly
            rule_eol();
            // Další statement
            rule_stat();
            break;
        default:
            error_call(ERR_SYN, &tokens);
    }


}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl 0xd6b2(%rip), %eax      # 0x103d0
movl %eax, -0x14(%rbp)
subl $0x3, %eax
je 0x2d78
jmp 0x2d28
movl -0x14(%rbp), %eax
subl $0x5, %eax
je 0x2d49
jmp 0x2d32
movl -0x14(%rbp), %eax
subl $0x6, %eax
je 0x2d8e
jmp 0x2d3c
movl -0x14(%rbp), %eax
subl $0x32, %eax
je 0x2d62
jmp 0x2de4
callq 0x3740
callq 0x3d90
callq 0x2e00
callq 0x2280
jmp 0x2df5
callq 0x3740
callq 0x3d90
callq 0x2e00
callq 0x2280
jmp 0x2df5
callq 0x3740
callq 0x3d90
callq 0x2e00
callq 0x2280
jmp 0x2df5
movq 0xd243(%rip), %rax      # 0xffd8
movq (%rax), %rdi
callq 0x4840
movq %rax, -0x10(%rbp)
movl %edx, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq %rax, 0xd619(%rip)      # 0x103c8
movq -0x8(%rbp), %rax
movq %rax, 0xd616(%rip)      # 0x103d0
movq 0xd607(%rip), %rsi      # 0x103c8
movl 0xd609(%rip), %edx      # 0x103d0
leaq 0xd5e2(%rip), %rdi      # 0x103b0
callq 0x1450
callq 0x3540
callq 0x43d0
callq 0x2280
jmp 0x2df5
movl $0x2, %edi
leaq 0xd5c0(%rip), %rsi      # 0x103b0
callq 0x64e0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)