LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/eiskalteschatten[P]developersnotebook/src/views/DashboardView.cpp
// Function: projects_ending_soon_row_activated(_GtkTreeView*, _GtkTreePath*, _GtkTreeViewColumn*, DashboardView*)
void projects_ending_soon_row_activated(GtkTreeView *tree_view, GtkTreePath *path, GtkTreeViewColumn *col, DashboardView *dv) {
    GtkTreeModel *model = gtk_tree_view_get_model(tree_view);
    GtkTreeIter tree_iter;
    MainWindow *mw = static_cast<MainWindow*>(dv->main_window_obj);

    if (gtk_tree_model_get_iter(model, &tree_iter, path)) {
        GtkWidget *stack = mw->get_stack();
        gchar *id;
        gtk_tree_model_get(model, &tree_iter, ID_COLUMN, &id, -1);

        GtkWidget *stack_child_widget = gtk_stack_get_child_by_name(GTK_STACK(stack), "projects");
        gtk_stack_set_visible_child(GTK_STACK(stack), stack_child_widget);

        mw->get_projects_view()->select_row_in_list_view(id);

        g_free(id);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rcx, %rbx
movq %rsi, %r14
callq 0x84b0
movq %rax, %r15
movq 0x28(%rbx), %r13
leaq 0x10(%rsp), %rsi
movq %rax, %rdi
movq %r14, %rdx
callq 0x8d40
testl %eax, %eax
je 0x12499
movq 0x30(%r13), %r14
leaq 0x10(%rsp), %rsi
leaq 0x8(%rsp), %rbx
movq %r15, %rdi
xorl %edx, %edx
movq %rbx, %rcx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
xorl %eax, %eax
callq 0x8850
callq 0x89e0
movq %rax, %r15
movq %r14, %rdi
movq %rax, %rsi
callq 0x8150
leaq 0x16fa6(%rip), %rsi     # 0x2940a
movq %rax, %rdi
callq 0x8e50
movq %rax, %r12
movq %r14, %rdi
movq %r15, %rsi
callq 0x8150
movq %rax, %rdi
movq %r12, %rsi
callq 0x8930
movq 0x48(%r13), %rdi
movq (%rbx), %rsi
callq 0x1161c
movq (%rbx), %rdi
callq 0x90c8
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/eiskalteschatten[P]developersnotebook/src/db/SqliteConnectionManager.cpp
// Function: SqliteConnectionManager::SqliteConnectionManager()
SqliteConnectionManager::SqliteConnectionManager() {
    int connection = sqlite3_open(Constants::path_to_db.c_str(), &db);

    if (connection) {
        fprintf(stderr, "Can't open database: %s\n", sqlite3_errmsg(db));
        return;
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq $0x0, (%rdi)
movq 0x25662(%rip), %rdi     # 0x384a0
movq %rbx, %rsi
callq 0x8450
testl %eax, %eax
jne 0x12e4c
popq %rbx
retq
movq %rbx, %rdi
callq 0x90d0
jmp 0x12e4a
// File: /workspace/github_cpp_makefile_star2_O1/eiskalteschatten[P]developersnotebook/src/windows/MainWindow.cpp
// Function: MainWindow::setup_css()
void MainWindow::setup_css() {
    Css css("dark", path_to_exec);

    css_provider = gtk_css_provider_new();

    gtk_css_provider_load_from_path(css_provider, css.get_path().c_str(), NULL);
    gtk_style_context_add_provider_for_screen(gdk_screen_get_default(), GTK_STYLE_PROVIDER(css_provider), GTK_STYLE_PROVIDER_PRIORITY_USER);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x100, %rsp            # imm = 0x100
movq %rdi, %rbx
leaq 0x50(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x14ffa(%rip), %rsi     # 0x2964d
leaq 0x14ff7(%rip), %rdx     # 0x29651
leaq 0x40(%rsp), %rdi
callq 0xd5b4
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
leaq 0x20(%rsp), %rdi
callq 0xd524
leaq 0x60(%rsp), %rdi
leaq 0x40(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0xe4b4
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x146ac
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x8170
movq 0x40(%rsp), %rdi
cmpq %r14, %rdi
je 0x146c3
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x8170
callq 0x86a0
movq %rax, %r14
movq %rax, 0x38(%rbx)
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq 0xc0(%rsp), %rsi
movq 0xc8(%rsp), %rdx
addq %rsi, %rdx
movq %rsp, %rdi
callq 0xd524
movq (%rsp), %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x8af0
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x14717
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x8170
callq 0x8e20
movq %rax, %r14
movq 0x38(%rbx), %rbx
callq 0x85c0
movq %rbx, %rdi
movq %rax, %rsi
callq 0x8150
movq %r14, %rdi
movq %rax, %rsi
movl $0x320, %edx            # imm = 0x320
callq 0x8470
leaq 0x60(%rsp), %rdi
callq 0xe644
addq $0x100, %rsp            # imm = 0x100
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x147b2
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x8170
jmp 0x147b2
jmp 0x147af
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x14796
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x8170
jmp 0x14796
movq %rax, %rbx
movq 0x40(%rsp), %rdi
cmpq %r14, %rdi
je 0x147bc
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x8170
jmp 0x147bc
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0xe644
movq %rbx, %rdi
callq 0x87b0
// File: /workspace/github_cpp_makefile_star2_O1/eiskalteschatten[P]developersnotebook/src/windows/MainWindow.cpp
// Function: MainWindow::setup_grid()
void MainWindow::setup_grid() {
    grid = gtk_grid_new();

    gtk_grid_insert_row(GTK_GRID(grid), 0);
    gtk_grid_insert_row(GTK_GRID(grid), 1);
    gtk_grid_insert_column(GTK_GRID(grid), 0);
    gtk_grid_insert_column(GTK_GRID(grid), 1);

    gtk_widget_set_valign(grid, GTK_ALIGN_FILL);

    gtk_widget_set_name(grid, "main-grid");

    gtk_container_add(GTK_CONTAINER(window), grid);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x8c10
movq %rax, %r15
movq %rax, 0x28(%rbx)
callq 0x89d0
movq %rax, %r14
movq %r15, %rdi
movq %rax, %rsi
callq 0x8150
movq %rax, %rdi
xorl %esi, %esi
callq 0x82e0
movq 0x28(%rbx), %rdi
movq %r14, %rsi
callq 0x8150
movq %rax, %rdi
movl $0x1, %esi
callq 0x82e0
movq 0x28(%rbx), %rdi
movq %r14, %rsi
callq 0x8150
movq %rax, %rdi
xorl %esi, %esi
callq 0x8710
movq 0x28(%rbx), %rdi
movq %r14, %rsi
callq 0x8150
movq %rax, %rdi
movl $0x1, %esi
callq 0x8710
movq 0x28(%rbx), %rdi
xorl %esi, %esi
callq 0x8e90
movq 0x28(%rbx), %rdi
leaq 0x14dff(%rip), %rsi     # 0x29652
callq 0x8220
movq 0x20(%rbx), %r14
callq 0x89c0
movq %r14, %rdi
movq %rax, %rsi
callq 0x8150
movq 0x28(%rbx), %rsi
movq %rax, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x8ef0
nop
// File: /workspace/github_cpp_makefile_star2_O1/eiskalteschatten[P]developersnotebook/src/windows/MainWindow.cpp
// Function: MainWindow::save_and_close_window(_GtkWidget*)
void MainWindow::save_and_close_window(GtkWidget *window) {
    int width;
    int height;
    PreferencesModel *preferences_model = new PreferencesModel();

    if (gtk_window_is_maximized(GTK_WINDOW(window))) {
        preferences_model->set_window_maximized(true, false);
    }
    else {
        gtk_window_get_size(GTK_WINDOW(window), &width, &height);

        preferences_model->set_window_width(width, false);
        preferences_model->set_window_height(height, false);
        preferences_model->set_window_maximized(false, false);
    }

    preferences_model->save_all();

    gtk_widget_destroy(window);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl $0x68, %edi
callq 0x81a0
movq %rax, %r14
movq %rax, %rdi
callq 0x2810c
callq 0x8f40
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
callq 0x8150
movq %rax, %rdi
callq 0x8f50
movl %eax, %ebp
testl %eax, %eax
jne 0x14b06
movq %rbx, %rdi
movq %r15, %rsi
callq 0x8150
leaq 0xc(%rsp), %r15
leaq 0x8(%rsp), %r12
movq %rax, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x85a0
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x281f4
movq %r14, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x28288
xorl %esi, %esi
testl %ebp, %ebp
setne %sil
movq %r14, %rdi
xorl %edx, %edx
callq 0x2831c
movq (%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
movq %rbx, %rdi
callq 0x8180
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x68, %esi
movq %r14, %rdi
callq 0x8170
movq %rbx, %rdi
callq 0x87b0
// File: /workspace/github_cpp_makefile_star2_O1/eiskalteschatten[P]developersnotebook/src/windows/MenuBar.cpp
// Function: MenuBar::MenuBar(MainWindow*)
MenuBar::MenuBar(MainWindow *new_main_window_obj) {
    main_window_obj  = new_main_window_obj;
    main_window      = main_window_obj->get_window();
    primary_mask_key = GDK_CONTROL_MASK;

    // Override the primary modifier key for macOS
    #ifdef __APPLE__
        primary_mask_key = GDK_META_MASK;
    #endif

    menubar = gtk_menu_bar_new();

    // Accelerators
    accel_group = gtk_accel_group_new();
    gtk_window_add_accel_group(GTK_WINDOW(main_window), accel_group);

    setup_file_menu();
    #ifdef __APPLE__
        setup_edit_menu();
    #endif
    setup_view_menu();
    setup_help_menu();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsi, (%rdi)
movq 0x20(%rsi), %rax
movq %rax, 0x8(%rdi)
movl $0x4, 0x10(%rdi)
callq 0x8fd0
movq %rax, 0x20(%rbx)
callq 0x8b40
movq %rax, 0x18(%rbx)
movq 0x8(%rbx), %r14
callq 0x8f40
movq %r14, %rdi
movq %rax, %rsi
callq 0x8150
movq 0x18(%rbx), %rsi
movq %rax, %rdi
callq 0x8340
movq %rbx, %rdi
callq 0x153c0
movq %rbx, %rdi
callq 0x155fc
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x15748
// File: /workspace/github_cpp_makefile_star2_O1/eiskalteschatten[P]developersnotebook/src/windows/MenuBar.cpp
// Function: MenuBar::setup_view_menu()
void MenuBar::setup_view_menu() {
    GtkWidget *view_menu = gtk_menu_new();
    GtkWidget *view_mi   = gtk_menu_item_new_with_label("View");

    dashboard_mi = gtk_menu_item_new_with_label("Dashboard");
    projects_mi  = gtk_menu_item_new_with_label("Projects");

    // Setup submenu
    gtk_menu_item_set_submenu(GTK_MENU_ITEM(view_mi), view_menu);

    // Setup menu items

    // Dashboard
    {
        gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), dashboard_mi);
        gtk_widget_add_accelerator(dashboard_mi, "activate", accel_group, GDK_KEY_1, primary_mask_key, GTK_ACCEL_VISIBLE);
        g_signal_connect(G_OBJECT(dashboard_mi), "activate", G_CALLBACK(switch_stack_dashboard), this);
    }

    // Projects
    {
        gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), projects_mi);
        gtk_widget_add_accelerator(projects_mi, "activate", accel_group, GDK_KEY_2, primary_mask_key, GTK_ACCEL_VISIBLE);
        g_signal_connect(G_OBJECT(projects_mi), "activate", G_CALLBACK(switch_stack_projects), this);
    }

    #ifdef __APPLE__
        GtkWidget *separator_mi_1 = gtk_separator_menu_item_new();
        gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), separator_mi_1);
    #endif

    // Add the menu to the menu shell
    gtk_menu_shell_append(GTK_MENU_SHELL(menubar), view_mi);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0x87a0
movq %rax, %r12
leaq 0x140b5(%rip), %rdi     # 0x296cc
callq 0x8da0
movq %rax, %r14
leaq 0x14043(%rip), %rdi     # 0x29669
callq 0x8da0
movq %rax, 0x40(%rbx)
leaq 0x1403d(%rip), %rdi     # 0x29673
callq 0x8da0
movq %rax, 0x48(%rbx)
callq 0x8350
movq %r14, %rdi
movq %rax, %rsi
callq 0x8150
movq %rax, %rdi
movq %r12, %rsi
callq 0x8a80
callq 0x8270
movq %rax, %r15
movq %r12, %rdi
movq %rax, %rsi
callq 0x8150
movq 0x40(%rbx), %rsi
movq %rax, %rdi
callq 0x8830
movq 0x40(%rbx), %rdi
movq 0x18(%rbx), %rdx
movl 0x10(%rbx), %r8d
leaq 0x13a62(%rip), %r13     # 0x290ee
movq %r13, %rsi
movl $0x31, %ecx
movl $0x1, %r9d
callq 0x8980
movq 0x40(%rbx), %rdi
movl $0x50, %esi
callq 0x8150
leaq -0x37d(%rip), %rdx      # 0x15337
movq %rax, %rdi
movq %r13, %rsi
movq %rbx, %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x82a0
movq %r12, %rdi
movq %r15, %rsi
callq 0x8150
movq 0x48(%rbx), %rsi
movq %rax, %rdi
callq 0x8830
movq 0x48(%rbx), %rdi
movq 0x18(%rbx), %rdx
movl 0x10(%rbx), %r8d
movq %r13, %rsi
movl $0x32, %ecx
movl $0x1, %r9d
callq 0x8980
movq 0x48(%rbx), %rdi
movl $0x50, %esi
callq 0x8150
leaq -0x3cd(%rip), %rdx      # 0x15346
movq %rax, %rdi
movq %r13, %rsi
movq %rbx, %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x82a0
movq 0x20(%rbx), %rdi
movq %r15, %rsi
callq 0x8150
movq %rax, %rdi
movq %r14, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x8830
nop
// File: /workspace/github_cpp_makefile_star2_O1/eiskalteschatten[P]developersnotebook/src/windows/MenuBar.cpp
// Function: MenuBar::setup_help_menu()
void MenuBar::setup_help_menu() {
    GtkWidget *help_menu            = gtk_menu_new();
    about_mi                        = gtk_menu_item_new_with_label("About");
    GtkWidget *release_notes_mi     = gtk_menu_item_new_with_label("Release Notes");
    // GtkWidget *check_for_updates_mi = gtk_menu_item_new_with_label("Check for Updates");
    help_mi                         = gtk_menu_item_new_with_label("Help");

    // Setup submenu
    gtk_menu_item_set_submenu(GTK_MENU_ITEM(help_mi), help_menu);

    // Setup menu items

    // Check for updates
    // {
    //     gtk_menu_shell_append(GTK_MENU_SHELL(help_menu), check_for_updates_mi);
    // }

    // Release Notes
    {
        gtk_menu_shell_append(GTK_MENU_SHELL(help_menu), release_notes_mi);
        g_signal_connect(G_OBJECT(release_notes_mi), "activate", G_CALLBACK(ReleaseNotesWindow::activate), main_window_obj);
    }

    // About
    {
        gtk_menu_shell_append(GTK_MENU_SHELL(help_menu), about_mi);
        g_signal_connect(G_OBJECT(about_mi), "activate", G_CALLBACK(AboutDialog::activate), main_window_obj);
    }

    // Add the menu to the menu shell
    gtk_menu_shell_append(GTK_MENU_SHELL(menubar), help_mi);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x87a0
movq %rax, %r14
leaq 0x13f6f(%rip), %rdi     # 0x296d1
callq 0x8da0
movq %rax, 0x30(%rbx)
leaq 0x13f20(%rip), %rdi     # 0x29692
callq 0x8da0
movq %rax, %r12
leaq 0x13f56(%rip), %rdi     # 0x296d7
callq 0x8da0
movq %rax, %r15
movq %rax, 0x38(%rbx)
callq 0x8350
movq %r15, %rdi
movq %rax, %rsi
callq 0x8150
movq %rax, %rdi
movq %r14, %rsi
callq 0x8a80
callq 0x8270
movq %rax, %r15
movq %r14, %rdi
movq %rax, %rsi
callq 0x8150
movq %rax, %rdi
movq %r12, %rsi
callq 0x8830
movl $0x50, %esi
movq %r12, %rdi
callq 0x8150
movq (%rbx), %rcx
leaq 0x13911(%rip), %r12     # 0x290ee
leaq -0xc10(%rip), %rdx      # 0x14bd4
movq %rax, %rdi
movq %r12, %rsi
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x82a0
movq %r14, %rdi
movq %r15, %rsi
callq 0x8150
movq 0x30(%rbx), %rsi
movq %rax, %rdi
callq 0x8830
movq 0x30(%rbx), %rdi
movl $0x50, %esi
callq 0x8150
movq (%rbx), %rcx
leaq -0x18a8(%rip), %rdx     # 0x13f7c
movq %rax, %rdi
movq %r12, %rsi
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x82a0
movq 0x20(%rbx), %rdi
movq %r15, %rsi
callq 0x8150
movq 0x38(%rbx), %rsi
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x8830
// File: /workspace/github_cpp_makefile_star2_O1/eiskalteschatten[P]developersnotebook/src/windows/MenuBar.cpp
// Function: MenuBar::setup_edit_menu()
void MenuBar::setup_edit_menu() {
    GtkWidget *edit_menu = gtk_menu_new();
    // preferences_mi       = gtk_menu_item_new_with_label("Preferences");
    GtkWidget *edit_mi   = gtk_menu_item_new_with_label("Edit");

    // Setup submenu
    gtk_menu_item_set_submenu(GTK_MENU_ITEM(edit_mi), edit_menu);

    // Setup menu items
    // gtk_menu_shell_append(GTK_MENU_SHELL(edit_menu), preferences_mi);
    // gtk_widget_add_accelerator(preferences_mi, "activate", accel_group, GDK_KEY_comma, primary_mask_key, GTK_ACCEL_VISIBLE);

    // Add the menu to the menu shell
    gtk_menu_shell_append(GTK_MENU_SHELL(menubar), edit_mi);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x87a0
movq %rax, %r14
leaq 0x13e56(%rip), %rdi     # 0x296c7
callq 0x8da0
movq %rax, %r15
callq 0x8350
movq %r15, %rdi
movq %rax, %rsi
callq 0x8150
movq %rax, %rdi
movq %r14, %rsi
callq 0x8a80
movq 0x20(%rbx), %rbx
callq 0x8270
movq %rbx, %rdi
movq %rax, %rsi
callq 0x8150
movq %rax, %rdi
movq %r15, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x8830
// File: /workspace/github_cpp_makefile_star2_O1/eiskalteschatten[P]developersnotebook/src/models/ProjectsModel.cpp
// Function: ProjectsModel::set_is_complete(bool, bool)
void ProjectsModel::set_is_complete(const bool new_is_complete, bool update_db) {
    int int_value = new_is_complete ? 1 : 0;
    is_complete   = new_is_complete;

    if (update_db) {
        update_single_int("is_complete", int_value);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movl %esi, 0xc(%rsp)
movb %sil, 0x100(%rdi)
testl %edx, %edx
je 0x2721a
movq %rdi, %rbx
leaq 0x20(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x211a(%rip), %rsi      # 0x292f9
leaq 0x211e(%rip), %rdx      # 0x29304
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0xd5b4
leaq 0xc(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x16c50
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x2721a
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x8170
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x2723e
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x8170
movq %rbx, %rdi
callq 0x87b0
// File: /workspace/github_cpp_makefile_star2_O1/eiskalteschatten[P]developersnotebook/src/models/ProjectsModel.cpp
// Function: ProjectsModel::truncate_notes()
void ProjectsModel::truncate_notes() {
    notes = std::regex_replace(notes, std::regex("\\n"), " ");
    notes = std::regex_replace(notes, std::regex("\\r"), "");

    if (notes != "" && notes.length() >= 50) {
        notes = notes.substr(0, 47) + "...";
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r14
leaq 0x2d99(%rip), %rsi      # 0x2a6da
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
movl $0x10, %edx
callq 0x182de
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
movq 0xe0(%r14), %rsi
movq 0xe8(%r14), %rdx
addq %rsi, %rdx
movl $0x0, (%rsp)
leaq 0x1bed(%rip), %r8       # 0x29577
leaq 0x8(%rsp), %rdi
movl $0x1, %r9d
movq %rbx, %rcx
callq 0x23c61
leaq 0xe0(%r14), %rbx
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x8630
movq (%r15), %rdi
cmpq %r12, %rdi
je 0x279c9
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x8170
leaq 0x28(%rsp), %rdi
callq 0x18346
leaq 0x2d03(%rip), %rsi      # 0x2a6dd
leaq 0x28(%rsp), %r15
movq %r15, %rdi
movl $0x10, %edx
callq 0x182de
leaq 0x8(%rsp), %rdi
movq %r12, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0xe0(%r14), %rsi
movq 0xe8(%r14), %rdx
addq %rsi, %rdx
movl $0x0, (%rsp)
leaq 0x1f36(%rip), %r8       # 0x29955
movq %r15, %rcx
xorl %r9d, %r9d
callq 0x23c61
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x8630
movq (%r15), %rdi
cmpq %r12, %rdi
je 0x27a4f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x8170
leaq 0x28(%rsp), %rdi
callq 0x18346
leaq 0x1ef5(%rip), %rsi      # 0x29955
movq %rbx, %rdi
callq 0x8c00
testl %eax, %eax
je 0x27b26
cmpq $0x32, 0xe8(%r14)
jb 0x27b26
leaq 0x28(%rsp), %r14
movl $0x2f, %ecx
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x8ce0
leaq 0x2c44(%rip), %rsi      # 0x2a6e0
movq %r14, %rdi
callq 0x87f0
movq %r12, 0x8(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x27ac7
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
jmp 0x27acf
movups (%rcx), %xmm0
movups %xmm0, (%r12)
movq 0x8(%rax), %rdx
leaq 0x8(%rsp), %r14
movq %rdx, 0x8(%r14)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8630
movq (%r14), %rdi
cmpq %r12, %rdi
je 0x27b0b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x8170
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x27b26
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x8170
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x27b78
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x8170
jmp 0x27b78
jmp 0x27b54
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x27b6e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x8170
leaq 0x28(%rsp), %rdi
callq 0x18346
movq %rbx, %rdi
callq 0x87b0
// File: /workspace/github_cpp_makefile_star2_O1/eiskalteschatten[P]developersnotebook/src/models/PreferencesModel.cpp
// Function: PreferencesModel::setup()
void PreferencesModel::setup() {
	table_schema = &SqliteSchema::preferences_table;

    select_one();

	if (get_window_width() == -1) {
		set_window_width(default_window_width, true);
	}

	if (get_window_height() == -1) {
		set_window_height(default_window_height, true);
	}
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x10445(%rip), %rax     # 0x385a0
movq %rax, 0x8(%rdi)
callq 0x173ee
cmpl $-0x1, 0x5c(%rbx)
jne 0x2817e
leaq 0x25cb(%rip), %rsi      # 0x2a73c
movq %rbx, %rdi
movl $0x1, %edx
callq 0x281f4
cmpl $-0x1, 0x60(%rbx)
je 0x28186
popq %rbx
retq
leaq 0x25b3(%rip), %rsi      # 0x2a740
movq %rbx, %rdi
movl $0x1, %edx
popq %rbx
jmp 0x28288
nop
// File: /workspace/github_cpp_makefile_star2_O1/eiskalteschatten[P]developersnotebook/src/models/PreferencesModel.cpp
// Function: PreferencesModel::set_window_maximized(bool, bool)
void PreferencesModel::set_window_maximized(const bool new_maximized, bool update_db) {
    int int_value    = new_maximized ? 1 : 0;
    window_maximized = new_maximized;

    if (update_db) {
        update_single_int("window_maximized", int_value);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movl %esi, 0xc(%rsp)
movb %sil, 0x64(%rdi)
testl %edx, %edx
je 0x2837f
movq %rdi, %rbx
leaq 0x20(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x11d8(%rip), %rsi      # 0x2951c
leaq 0x11e1(%rip), %rdx      # 0x2952c
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0xd5b4
leaq 0xc(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x16c50
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x2837f
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x8170
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x283a3
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x8170
movq %rbx, %rdi
callq 0x87b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/eiskalteschatten[P]developersnotebook/src/components/Modal.cpp
// Function: Modal::show_error_modal()
void Modal::show_error_modal() {
    #ifdef __APPLE__
        mac_show_error_modal(message, sub_message);
    #else
        GtkWidget *image = gtk_image_new_from_icon_name("dialog-error", GTK_ICON_SIZE_DIALOG);
        gtk_grid_attach(GTK_GRID(main_grid), image, 0, 0, 1, 2);

        GtkDialogFlags flags = GTK_DIALOG_DESTROY_WITH_PARENT;
        GtkWidget *dialog    = gtk_dialog_new_with_buttons("",
                                                           GTK_WINDOW(parent_window),
                                                           flags,
                                                           "OK",
                                                           GTK_RESPONSE_OK,
                                                           NULL);

        gtk_container_set_border_width(GTK_CONTAINER(dialog), 10);

        GtkWidget *content_area = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
        gtk_box_pack_start(GTK_BOX(content_area), main_grid, TRUE, FALSE, 0);
        gtk_widget_show_all(dialog);

        gtk_dialog_run(GTK_DIALOG(dialog));
        gtk_widget_destroy(dialog);
    #endif
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x1bfd(%rip), %rdi      # 0x2a77b
movl $0x6, %esi
callq 0x8a20
movq %rax, %r14
movq 0x8(%rbx), %r15
callq 0x89d0
movq %r15, %rdi
movq %rax, %rsi
callq 0x8150
movq %rax, %rdi
movq %r14, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
movl $0x1, %r8d
movl $0x2, %r9d
callq 0x8ac0
movq (%rbx), %r14
callq 0x8f40
movq %r14, %rdi
movq %rax, %rsi
callq 0x8150
leaq 0xd81(%rip), %rdi       # 0x29955
leaq 0x1bad(%rip), %rcx      # 0x2a788
movq %rax, %rsi
movl $0x2, %edx
movl $0xfffffffb, %r8d       # imm = 0xFFFFFFFB
xorl %r9d, %r9d
xorl %eax, %eax
callq 0x87c0
movq %rax, %r14
callq 0x89c0
movq %r14, %rdi
movq %rax, %rsi
callq 0x8150
movq %rax, %rdi
movl $0xa, %esi
callq 0x9000
callq 0x8860
movq %rax, %r15
movq %r14, %rdi
movq %rax, %rsi
callq 0x8150
movq %rax, %rdi
callq 0x8040
movq %rax, %r12
callq 0x88f0
movq %r12, %rdi
movq %rax, %rsi
callq 0x8150
movq 0x8(%rbx), %rsi
movq %rax, %rdi
movl $0x1, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x8260
movq %r14, %rdi
callq 0x8c70
movq %r14, %rdi
movq %r15, %rsi
callq 0x8150
movq %rax, %rdi
callq 0x8330
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x8180
nop
// File: /workspace/github_cpp_makefile_star2_O1/martinda3[P]Compiler/src/ASifState.cpp
// Function: toyc::ASifState::ASifState(toyc::ASexpression*, toyc::ASstatement*, toyc::ASstatement*)
ASifState::ASifState(ASexpression* oper1, ASstatement* oper2, ASstatement* oper3)
	{
		op1 = oper1;
		op2 = oper2;
		op3 = oper3;
		hasop = true;
		setType(IFstate);
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
callq 0x1a7e4
leaq 0x2ce3f(%rip), %rax     # 0x37ae8
movq %rax, (%rbx)
leaq 0x38(%rbx), %r13
movq %r13, 0x28(%rbx)
movq $0x0, 0x30(%rbx)
movb $0x0, 0x38(%rbx)
movq %r12, 0x10(%rbx)
movq %r15, 0x18(%rbx)
movq %r14, 0x20(%rbx)
movb $0x1, 0x48(%rbx)
movq %rbx, %rdi
movl $0x3, %esi
callq 0x1a7f6
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq 0x28(%rbx), %rdi
cmpq %r13, %rdi
je 0xacff
movq (%r13), %rsi
incq %rsi
callq 0x8260
movq %r14, %rdi
callq 0x8420
nop
// File: /workspace/github_cpp_makefile_star2_O1/martinda3[P]Compiler/src/ASifState.cpp
// Function: toyc::ASifState::ASifState(toyc::ASexpression*, toyc::ASstatement*)
ASifState::ASifState(ASexpression* oper1, ASstatement* oper2)
	{
		op1 = oper1;
		op2 = oper2;
		hasop = false;
		setType(IFstate);
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0x1a7e4
leaq 0x2cdc3(%rip), %rax     # 0x37ae8
movq %rax, (%rbx)
leaq 0x38(%rbx), %r12
movq %r12, 0x28(%rbx)
movq $0x0, 0x30(%rbx)
xorl %eax, %eax
movb %al, 0x38(%rbx)
movq %r15, 0x10(%rbx)
movq %r14, 0x18(%rbx)
movb %al, 0x48(%rbx)
movq %rbx, %rdi
movl $0x3, %esi
callq 0x1a7f6
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq 0x28(%rbx), %rdi
cmpq %r12, %rdi
je 0xad79
movq (%r12), %rsi
incq %rsi
callq 0x8260
movq %r14, %rdi
callq 0x8420
nop
// File: /workspace/github_cpp_makefile_star2_O1/martinda3[P]Compiler/src/TCparser.cpp
// Function: toyc::TCparser::program()
ASprogram* TCparser::program()
	{
		enteringDEBUG("Program");   //  Need to call DefinitionList to recirsivly repeat
		ASdefinition* definitionList[MAX_STATEMENTS];
		symTable = new TCsymTable();
		int num = DefinitionList(definitionList, 0);
		exitingDEBUG("Program");
		return new ASprog(inputFileName, definitionList, num);
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x1000, %rsp           # imm = 0x1000
movq %rdi, %rbx
leaq 0x50(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1e7e3(%rip), %rsi     # 0x2a130
leaq 0x1e7e3(%rip), %rdx     # 0x2a137
leaq 0x40(%rsp), %r14
movq %r14, %rdi
callq 0xfc42
movq %r14, %rdi
callq 0xbac6
movq 0x40(%rsp), %rdi
cmpq %r15, %rdi
je 0xb980
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x8260
movl $0x328, %edi            # imm = 0x328
callq 0x8250
movq %rax, %r14
movq %rax, %rdi
callq 0x28814
leaq 0x2ebd4(%rip), %rax     # 0x3a570
movq %r14, (%rax)
leaq 0x60(%rsp), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0xbe5a
movl %eax, %ebx
leaq 0x30(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x1e770(%rip), %rsi     # 0x2a130
leaq 0x1e770(%rip), %rdx     # 0x2a137
leaq 0x20(%rsp), %rdi
callq 0xfc42
leaq 0x20(%rsp), %rdi
callq 0xbd28
movq 0x20(%rsp), %rdi
cmpq %r14, %rdi
je 0xb9f2
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x8260
movl $0xfd8, %edi            # imm = 0xFD8
callq 0x8250
movq %rax, %r14
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x2eae1(%rip), %rax     # 0x3a4f0
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
movq %rsp, %rdi
callq 0xabf6
movq %rsp, %rsi
leaq 0x60(%rsp), %rdx
movq %r14, %rdi
movl %ebx, %ecx
callq 0x25ce0
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0xba49
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x8260
movq %r14, %rax
addq $0x1000, %rsp           # imm = 0x1000
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0xba77
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x8260
jmp 0xba77
movq %rax, %rbx
movl $0xfd8, %esi            # imm = 0xFD8
jmp 0xba9f
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r14, %rdi
je 0xbabe
movq 0x30(%rsp), %rsi
jmp 0xbab6
movq %rax, %rbx
jmp 0xbabe
movq %rax, %rbx
movl $0x328, %esi            # imm = 0x328
movq %r14, %rdi
jmp 0xbab9
movq %rax, %rbx
movq 0x40(%rsp), %rdi
cmpq %r15, %rdi
je 0xbabe
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x8260
movq %rbx, %rdi
callq 0x8420
// File: /workspace/github_cpp_makefile_star2_O1/martinda3[P]Compiler/src/TCparser.cpp
// Function: toyc::TCparser::DefinitionList(toyc::ASdefinition**, int)
int TCparser::DefinitionList(ASdefinition* l[], int n)
	{
		int num = 0;

		enteringDEBUG("Definition List");
		if (!(buff->getTokenType() == EOFILE))
		{
			l[n] = Definition();
			num = DefinitionList(l, n + 1);
		}
		else
		{
			num = n;
		}
		exitingDEBUG("Definition List");
		return num;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x30(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x1e2b9(%rip), %rsi     # 0x2a138
leaq 0x1e2c1(%rip), %rdx     # 0x2a147
leaq 0x20(%rsp), %r12
movq %r12, %rdi
callq 0xfc42
movq %r12, %rdi
callq 0xbac6
movq 0x20(%rsp), %rdi
cmpq %r13, %rdi
je 0xbeb2
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x8260
movq 0x8(%r15), %rdi
callq 0x179ac
cmpl $0x2d, %eax
je 0xbede
movq %r15, %rdi
callq 0xbf58
movslq %ebx, %rdx
movq %rax, (%r14,%rdx,8)
incl %edx
movq %r15, %rdi
movq %r14, %rsi
callq 0xbe5a
movl %eax, %ebx
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x1e24a(%rip), %rsi     # 0x2a138
leaq 0x1e252(%rip), %rdx     # 0x2a147
movq %rsp, %r14
movq %r14, %rdi
callq 0xfc42
movq %r14, %rdi
callq 0xbd28
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0xbf1e
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x8260
movl %ebx, %eax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
jmp 0xbf3f
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r13, %rdi
je 0xbf50
movq (%r13), %rsi
incq %rsi
callq 0x8260
movq %rbx, %rdi
callq 0x8420
// File: /workspace/github_cpp_makefile_star2_O1/martinda3[P]Compiler/src/TCparser.cpp
// Function: toyc::TCparser::accept(int)
TCtoken* TCparser::accept(int t)
	{
		TCtoken *token; 
		std::string name;
		if (t == buff->getTokenType())
		{
			token = buff;
			name = token->getLexeme();
//			if (v_parser) {tokenDEBUG(name);}
			buff = scanner->getToken();
			return token;
		}
		else { throw t; }
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
movq 0x8(%rdi), %rdi
callq 0x179ac
cmpl %ebp, %eax
jne 0xc5fb
movq 0x8(%rbx), %r14
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
callq 0x179b0
movq %rsp, %rdi
leaq 0x20(%rsp), %r15
movq %r15, %rsi
callq 0x82f0
movq (%r15), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0xc5c9
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x8260
movq (%rbx), %rdi
callq 0x10f24
movq %rax, 0x8(%rbx)
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0xc5eb
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x8260
movq %r14, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x4, %edi
callq 0x8130
movl %ebp, (%rax)
movq 0x2d98a(%rip), %rsi     # 0x39f98
movq %rax, %rdi
xorl %edx, %edx
callq 0x83f0
jmp 0xc61a
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0xc633
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x8260
movq %rbx, %rdi
callq 0x8420
nop
// File: /workspace/github_cpp_makefile_star2_O1/martinda3[P]Compiler/src/TCparser.cpp
// Function: toyc::TCparser::FunctionDefinition(toyc::ASdefinition**, int*)
ASstatement* TCparser::FunctionDefinition(ASdefinition* list[], int* i) // DONE NEED TO TEST MORE
	{
		// FunctionDefinition  --> FunctionHeader FunctionBody
		enteringDEBUG("Function Definition");
		ASstatement* operand = NULL;
		*i = FunctionHeader(list);
		operand = FunctionBody();
		exitingDEBUG("Function Definition");
		return operand;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x30(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x1db15(%rip), %rsi     # 0x2a177
leaq 0x1db21(%rip), %rdx     # 0x2a18a
leaq 0x20(%rsp), %r12
movq %r12, %rdi
callq 0xfc42
movq %r12, %rdi
callq 0xbac6
movq 0x20(%rsp), %rdi
cmpq %r13, %rdi
je 0xc695
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x8260
movq %rbx, %rdi
movq %r15, %rsi
callq 0xc72a
movl %eax, (%r14)
movq %rbx, %rdi
callq 0xc8f4
movq %rax, %rbx
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x1dab9(%rip), %rsi     # 0x2a177
leaq 0x1dac5(%rip), %rdx     # 0x2a18a
movq %rsp, %r14
movq %r14, %rdi
callq 0xfc42
movq %r14, %rdi
callq 0xbd28
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0xc6ee
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x8260
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
jmp 0xc710
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r13, %rdi
je 0xc721
movq (%r13), %rsi
incq %rsi
callq 0x8260
movq %rbx, %rdi
callq 0x8420
nop
// File: /workspace/github_cpp_makefile_star2_O1/martinda3[P]Compiler/src/TCparser.cpp
// Function: toyc::TCparser::FunctionHeader(toyc::ASdefinition**)
int TCparser::FunctionHeader(ASdefinition* list[]) // DONE
	{
		// FunctionHeader --> LPAREN [ FormalParamList ] RPAREN
		enteringDEBUG("Function Header");
		accept(LPAREN);
		int i;
		if (buff->getTokenType() == INT || buff->getTokenType() == CHAR)
		{
			i = FormalParamList(list);
			accept(RPAREN);
			exitingDEBUG("Function Header");
		}
		else if (buff->getTokenType() == RPAREN)
		{
			i = 0;
			accept(RPAREN);
			exitingDEBUG("Function Header");
		}
		else      // Error Handlding
		{
			reportSEMANTIC_ERROR(scanner, "type or ')' expected");
			exit(EXIT_FAILURE);
		}
		return i;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x1da3c(%rip), %rsi     # 0x2a18b
leaq 0x1da44(%rip), %rdx     # 0x2a19a
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0xfc42
movq %r15, %rdi
callq 0xbac6
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0xc782
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x8260
movq %rbx, %rdi
movl $0x1e, %esi
callq 0xc558
movq 0x8(%rbx), %rdi
callq 0x179ac
cmpl $0x3, %eax
je 0xc7ab
movq 0x8(%rbx), %rdi
callq 0x179ac
cmpl $0x5, %eax
jne 0xc7fc
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc9c4
movq %rbx, %rdi
movl $0x1f, %esi
callq 0xc558
leaq 0x78(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x1d9b7(%rip), %rsi     # 0x2a18b
leaq 0x1d9bf(%rip), %rdx     # 0x2a19a
leaq 0x68(%rsp), %rbx
movq %rbx, %rdi
callq 0xfc42
movq %rbx, %rdi
callq 0xbd28
movq 0x68(%rsp), %rdi
movl $0x1, %ebx
jmp 0xc84b
movq 0x8(%rbx), %rdi
callq 0x179ac
cmpl $0x1f, %eax
jne 0xc86d
movq %rbx, %rdi
movl $0x1f, %esi
callq 0xc558
leaq 0x58(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x1d963(%rip), %rsi     # 0x2a18b
leaq 0x1d96b(%rip), %rdx     # 0x2a19a
leaq 0x48(%rsp), %rbx
movq %rbx, %rdi
callq 0xfc42
movq %rbx, %rdi
callq 0xbd28
movq 0x48(%rsp), %rdi
xorl %ebx, %ebx
cmpq %r12, %rdi
je 0xc85c
movq (%r12), %rsi
incq %rsi
callq 0x8260
movl %ebx, %eax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq (%rbx), %rbx
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x1d91a(%rip), %rsi     # 0x2a19b
leaq 0x1d927(%rip), %rdx     # 0x2a1af
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0xfc42
movq %rbx, %rdi
movq %r14, %rsi
callq 0x16ebd
leaq 0x28(%rsp), %rdi
callq 0x8488
movl $0x1, %edi
callq 0x82e0
movq %rax, %rbx
movq 0x28(%rsp), %rdi
jmp 0xc8da
movq %rax, %rbx
movq 0x48(%rsp), %rdi
jmp 0xc8da
movq %rax, %rbx
movq 0x68(%rsp), %rdi
jmp 0xc8da
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0xc8eb
movq (%r12), %rsi
incq %rsi
callq 0x8260
movq %rbx, %rdi
callq 0x8420
nop
// File: /workspace/github_cpp_makefile_star2_O1/martinda3[P]Compiler/src/TCparser.cpp
// Function: toyc::TCparser::FunctionBody()
ASstatement* TCparser::FunctionBody()  // DONE NEED TO TEST MORE
	{
		// FunctionBody --> CompoundStatement
		enteringDEBUG("Function Body");
		ASstatement* operand = NULL;
		operand = CompoundStatement();
		//CompoundStatement();
		exitingDEBUG("Function Body");
		return operand;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1d8a0(%rip), %rsi     # 0x2a1b0
leaq 0x1d8a6(%rip), %rdx     # 0x2a1bd
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0xfc42
movq %r14, %rdi
callq 0xbac6
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0xc943
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x8260
movq %rbx, %rdi
callq 0xd05a
movq %rax, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1d852(%rip), %rsi     # 0x2a1b0
leaq 0x1d858(%rip), %rdx     # 0x2a1bd
movq %rsp, %r14
movq %r14, %rdi
callq 0xfc42
movq %r14, %rdi
callq 0xbd28
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0xc98e
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x8260
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
jmp 0xc9ac
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0xc9bc
movq (%r15), %rsi
incq %rsi
callq 0x8260
movq %rbx, %rdi
callq 0x8420
// File: /workspace/github_cpp_makefile_star2_O1/martinda3[P]Compiler/src/TCparser.cpp
// Function: toyc::TCparser::ExpressionStatement()
ASstatement* TCparser::ExpressionStatement() // WIP
	{
		// ExpressionStatement --> Expression
		enteringDEBUG("Expression Statement");
		ASexpression* operand = NULL;
		operand = Expression();
		exitingDEBUG("Expression Statement");
		accept(SEMICOLON);
		return new ASexprState(operand);
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x38(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1ccb6(%rip), %rsi     # 0x2a23e
leaq 0x1ccc3(%rip), %rdx     # 0x2a252
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0xfc42
movq %r14, %rdi
callq 0xbac6
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0xd5bb
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x8260
movq %rbx, %rdi
callq 0xd682
movq %rax, %r14
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x1cc67(%rip), %rsi     # 0x2a23e
leaq 0x1cc74(%rip), %rdx     # 0x2a252
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0xfc42
movq %r15, %rdi
callq 0xbd28
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0xd60a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x8260
movq %rbx, %rdi
movl $0x27, %esi
callq 0xc558
movl $0x38, %edi
callq 0x8250
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x1b36c
movq %r15, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movl $0x38, %esi
movq %r15, %rdi
jmp 0xd674
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0xd679
movq 0x18(%rsp), %rsi
jmp 0xd671
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0xd679
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x8260
movq %rbx, %rdi
callq 0x8420
nop
// File: /workspace/github_cpp_makefile_star2_O1/martinda3[P]Compiler/src/TCparser.cpp
// Function: toyc::TCparser::BreakStatement()
ASstatement* TCparser::BreakStatement() // DONE NEED TO TEST
	{
		// BreakStatement --> BREAK SEMICOLON
		enteringDEBUG("Break Statement");
		accept(BREAK);
		accept(SEMICOLON);
		exitingDEBUG("Break Statement");
		return new ASbreakState();
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1c61c(%rip), %rsi     # 0x2a2b0
leaq 0x1c624(%rip), %rdx     # 0x2a2bf
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0xfc42
movq %r14, %rdi
callq 0xbac6
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0xdcc7
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x8260
movq %rbx, %rdi
movl $0xb, %esi
callq 0xc558
movq %rbx, %rdi
movl $0x27, %esi
callq 0xc558
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x1c5bf(%rip), %rsi     # 0x2a2b0
leaq 0x1c5c7(%rip), %rdx     # 0x2a2bf
movq %rsp, %rbx
movq %rbx, %rdi
callq 0xfc42
movq %rbx, %rdi
callq 0xbd28
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0xdd21
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x8260
movl $0x10, %edi
callq 0x8250
movq %rax, %r14
movq %rax, %rdi
callq 0x182e4
movq %r14, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movl $0x10, %esi
movq %r14, %rdi
jmp 0xdd78
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0xdd7d
movq 0x10(%rsp), %rsi
jmp 0xdd75
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0xdd7d
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x8260
movq %rbx, %rdi
callq 0x8420
nop
// File: /workspace/github_cpp_makefile_star2_O1/martinda3[P]Compiler/src/TCparser.cpp
// Function: toyc::TCparser::NullStatement()
ASstatement* TCparser::NullStatement() // DONE NEED TO TEST
	{
		// SEMICOLON
		enteringDEBUG("Null Statement");
		exitingDEBUG("Null Statement");
		accept(SEMICOLON);
		return new ASnullState();
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1c51e(%rip), %rsi     # 0x2a2c0
leaq 0x1c525(%rip), %rdx     # 0x2a2ce
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0xfc42
movq %r14, %rdi
callq 0xbac6
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0xddd5
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x8260
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1c4db(%rip), %rsi     # 0x2a2c0
leaq 0x1c4e2(%rip), %rdx     # 0x2a2ce
movq %rsp, %r14
movq %r14, %rdi
callq 0xfc42
movq %r14, %rdi
callq 0xbd28
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0xde15
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x8260
movq %rbx, %rdi
movl $0x27, %esi
callq 0xc558
movl $0x10, %edi
callq 0x8250
movq %rax, %r14
movq %rax, %rdi
callq 0x183b8
movq %r14, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movl $0x10, %esi
movq %r14, %rdi
jmp 0xde79
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0xde7e
movq 0x10(%rsp), %rsi
jmp 0xde76
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0xde7e
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x8260
movq %rbx, %rdi
callq 0x8420
// File: /workspace/github_cpp_makefile_star2_O1/martinda3[P]Compiler/src/TCparser.cpp
// Function: toyc::TCparser::ReturnStatement()
ASstatement* TCparser::ReturnStatement() // WIP
	{
		// RETURN [ Expression ] SEMICOLON
		enteringDEBUG("Return Statement");
		ASexpression* operand = NULL;
		accept(RETURN);
		try
		{
			operand = Expression();
			accept(SEMICOLON);
			exitingDEBUG("Return Statement");
			return new ASreturnState(operand);
		}
		catch (int t)
		{
			accept(SEMICOLON);
			exitingDEBUG("Return Statement");
			return new ASreturnState();
		}
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
leaq 0x58(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1c42b(%rip), %rsi     # 0x2a2cf
leaq 0x1c434(%rip), %rdx     # 0x2a2df
leaq 0x48(%rsp), %r14
movq %r14, %rdi
callq 0xfc42
movq %r14, %rdi
callq 0xbac6
movq 0x48(%rsp), %rdi
cmpq %r15, %rdi
je 0xded7
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x8260
movq %rbx, %rdi
movl $0xa, %esi
callq 0xc558
movq %rbx, %rdi
callq 0xd682
movq %rax, %r14
movq %rbx, %rdi
movl $0x27, %esi
callq 0xc558
leaq 0x38(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1c3c3(%rip), %rsi     # 0x2a2cf
leaq 0x1c3cc(%rip), %rdx     # 0x2a2df
leaq 0x28(%rsp), %rdi
callq 0xfc42
leaq 0x28(%rsp), %rdi
callq 0xbd28
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0xdf3e
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x8260
movl $0x40, %edi
callq 0x8250
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0xa82c
movq %r15, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rdx, %r12
movq %rax, %r14
movl $0x40, %esi
movq %r15, %rdi
jmp 0xdf8d
movq %rdx, %r12
movq %rax, %r14
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0xdfbe
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x8260
jmp 0xdfbe
jmp 0xdfb8
movq %rax, %r14
movq 0x48(%rsp), %rdi
cmpq %r15, %rdi
je 0xdfb0
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x8260
movq %r14, %rdi
callq 0x8420
movq %rdx, %r12
movq %rax, %r14
cmpl $0x1, %r12d
jne 0xdfb0
movq %r14, %rdi
callq 0x80e0
movq %rbx, %rdi
movl $0x27, %esi
callq 0xc558
leaq 0x18(%rsp), %rbx
movq %rbx, -0x10(%rbx)
leaq 0x1c2e6(%rip), %rsi     # 0x2a2cf
leaq 0x1c2ef(%rip), %rdx     # 0x2a2df
leaq 0x8(%rsp), %rdi
callq 0xfc42
leaq 0x8(%rsp), %rdi
callq 0xbd28
movq 0x8(%rsp), %rdi
cmpq %rbx, %rdi
je 0xe01b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x8260
movl $0x40, %edi
callq 0x8250
movq %rax, %r15
movq %rax, %rdi
callq 0xa894
callq 0x83d0
jmp 0xdf56
movq %rax, %r14
movl $0x40, %esi
movq %r15, %rdi
jmp 0xe05c
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %rbx, %rdi
je 0xe068
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x8260
jmp 0xe068
jmp 0xe065
movq %rax, %r14
callq 0x83d0
jmp 0xdfb0
// File: /workspace/github_cpp_makefile_star2_O1/martinda3[P]Compiler/src/TCparser.cpp
// Function: toyc::TCparser::WhileStatement()
ASstatement* TCparser::WhileStatement() // Testing
	{
		// WHILE LPAREN Expression RPAREN Statement
		enteringDEBUG("While Statement");
		ASexpression* operand = NULL;
		ASstatement* operand2 = NULL;
		accept(WHILE);
		accept(LPAREN);
		operand = Expression();
		accept(RPAREN);
		operand2 = Statement();
		exitingDEBUG("While Statement");
		return new ASwhileState(operand, operand2);
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r14
leaq 0x38(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1c250(%rip), %rsi     # 0x2a2e0
leaq 0x1c258(%rip), %rdx     # 0x2a2ef
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0xfc42
movq %rbx, %rdi
callq 0xbac6
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0xe0c3
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x8260
movq %r14, %rdi
movl $0x8, %esi
callq 0xc558
movq %r14, %rdi
movl $0x1e, %esi
callq 0xc558
movq %r14, %rdi
callq 0xd682
movq %rax, %rbx
movq %r14, %rdi
movl $0x1f, %esi
callq 0xc558
movq %r14, %rdi
callq 0xd946
movq %rax, %r14
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x1c1cf(%rip), %rsi     # 0x2a2e0
leaq 0x1c1d7(%rip), %rdx     # 0x2a2ef
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0xfc42
movq %r15, %rdi
callq 0xbd28
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0xe144
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x8260
movl $0x20, %edi
callq 0x8250
movq %rax, %r15
movq %rax, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x191fc
movq %r15, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movl $0x20, %esi
movq %r15, %rdi
jmp 0xe1a4
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0xe1a9
movq 0x18(%rsp), %rsi
jmp 0xe1a1
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0xe1a9
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x8260
movq %rbx, %rdi
callq 0x8420
nop
// File: /workspace/github_cpp_makefile_star2_O1/martinda3[P]Compiler/src/TCparser.cpp
// Function: toyc::TCparser::WriteStatement()
ASstatement* TCparser::WriteStatement() // WIP
	{
		// WriteStatement -> WRITE LPAREN ActualParameters RPAREN SEMICOLON
		enteringDEBUG("Write Statement");
		ASexpression* operand = NULL;
		ASexpression* operand2[MAX_STATEMENTS];
		accept(WRITE);
        enter_special_id(symTable,WRITE);
		accept(LPAREN);
		operand = ActualParameters();
		operand2[0] = operand;
		accept(RPAREN);
		exitingDEBUG("Write Statement");
		accept(SEMICOLON);
		return new ASwriteState(operand2, 1);
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xfe0, %rsp            # imm = 0xFE0
movq %rdi, %rbx
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1bcba(%rip), %rsi     # 0x2a353
leaq 0x1bcc2(%rip), %rdx     # 0x2a362
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0xfc42
movq %r14, %rdi
callq 0xbac6
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0xe6cc
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x8260
movq %rbx, %rdi
movl $0xc, %esi
callq 0xc558
leaq 0x2be90(%rip), %rax     # 0x3a570
movq (%rax), %rdi
movl $0xc, %esi
callq 0xe8e1
movq %rbx, %rdi
movl $0x1e, %esi
callq 0xc558
movq %rbx, %rdi
callq 0xe9ce
movq %rax, 0x40(%rsp)
movq %rbx, %rdi
movl $0x1f, %esi
callq 0xc558
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x1bc2f(%rip), %rsi     # 0x2a353
leaq 0x1bc37(%rip), %rdx     # 0x2a362
movq %rsp, %rdi
callq 0xfc42
movq %rsp, %rdi
callq 0xbd28
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0xe751
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x8260
movq %rbx, %rdi
movl $0x27, %esi
callq 0xc558
movl $0xfb8, %edi            # imm = 0xFB8
callq 0x8250
movq %rax, %r14
leaq 0x40(%rsp), %rsi
movq %rax, %rdi
movl $0x1, %edx
callq 0x1a08c
movq %r14, %rax
addq $0xfe0, %rsp            # imm = 0xFE0
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movl $0xfb8, %esi            # imm = 0xFB8
movq %r14, %rdi
jmp 0xe7c7
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0xe7cc
movq 0x10(%rsp), %rsi
jmp 0xe7c4
movq %rax, %rbx
jmp 0xe7cc
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0xe7cc
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x8260
movq %rbx, %rdi
callq 0x8420