LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/Gaurang18[P]Compiler-Project-BITS-Pilani/./parser.c
// Function: pullup
parsetree pullup(parsetree head){
    if(head->left==NULL){
        head->child->right = head->right;
        if(head->right!=NULL)
            head->right->left = head->child;
        head->parent->child = head->child;
        head->child->parent = head->parent;
        parsetree temp = head->child;
        free(head);
        return temp;

    }
    else
    {
        head->left->right = head->child;
        head->child->left = head->left;
        head->child->right = head->right;
        if(head->right!=NULL)
            head->right->left = head->child;
        head->child->parent = head->parent;
        parsetree temp = head->child;
        free(head);
        return temp;
    }
    
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x5144
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x50fa
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2030
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x51d0
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x519f
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2030
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Gaurang18[P]Compiler-Project-BITS-Pilani/./parser.c
// Function: countNodes
void countNodes(parsetree head, int *count){

    if(head==NULL)
        return;
    countNodes(head->child, count);

    count[0]++;
    // printf("%d\n", count[0]);


    countNodes(head->right, count); 



}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x5509
jmp 0x5536
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x54f0
movq -0x10(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x54f0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Gaurang18[P]Compiler-Project-BITS-Pilani/./parser.c
// Function: ComputeFirstAndFollowSets
void ComputeFirstAndFollowSets(int G[][14], int first[][11], int follow [][15]){ //Compute the first and follow Sets, given Grammar
    int i, j;
    for(i = 1; i < 52; i++){
        //printf("%d - ", i);
        int result[1024] = {0};
        findfirst(result, i, G);
        for(j = 0; result[j]!=0; j++){
             first[i][j] = result[j];

        }

        first[i][j] = -1;

    }

    for(i = 1; i < 52; i++){
        //printf("%d - ", i);
        int result[1024] = {0};
        findfollow(result, i, G);
        for(j = 0; result[j]!=0; j++){
             
             if(result[j]==-1)
                follow[i][j] = 0;
             else{
                follow[i][j] = result[j];
             }
    }

        follow[i][j] = -1;

    }



}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2020, %rsp           # imm = 0x2020
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x1, -0x1c(%rbp)
cmpl $0x34, -0x1c(%rbp)
jge 0x5857
leaq -0x1020(%rbp), %rdi
xorl %esi, %esi
movl $0x1000, %edx           # imm = 0x1000
callq 0x20c0
leaq -0x1020(%rbp), %rdi
movl -0x1c(%rbp), %esi
movq -0x8(%rbp), %rdx
callq 0x4450
movl $0x0, -0x20(%rbp)
movslq -0x20(%rbp), %rax
cmpl $0x0, -0x1020(%rbp,%rax,4)
je 0x582f
movslq -0x20(%rbp), %rax
movl -0x1020(%rbp,%rax,4), %edx
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x2c, %rcx, %rcx
addq %rcx, %rax
movslq -0x20(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x57f5
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x2c, %rcx, %rcx
addq %rcx, %rax
movslq -0x20(%rbp), %rcx
movl $0xffffffff, (%rax,%rcx,4) # imm = 0xFFFFFFFF
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x57be
movl $0x1, -0x1c(%rbp)
cmpl $0x34, -0x1c(%rbp)
jge 0x5923
leaq -0x2020(%rbp), %rdi
xorl %esi, %esi
movl $0x1000, %edx           # imm = 0x1000
callq 0x20c0
leaq -0x2020(%rbp), %rdi
movl -0x1c(%rbp), %esi
movq -0x8(%rbp), %rdx
callq 0x4630
movl $0x0, -0x20(%rbp)
movslq -0x20(%rbp), %rax
cmpl $0x0, -0x2020(%rbp,%rax,4)
je 0x58fb
movslq -0x20(%rbp), %rax
cmpl $-0x1, -0x2020(%rbp,%rax,4)
jne 0x58cd
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x3c, %rcx, %rcx
addq %rcx, %rax
movslq -0x20(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
jmp 0x58ee
movslq -0x20(%rbp), %rax
movl -0x2020(%rbp,%rax,4), %edx
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x3c, %rcx, %rcx
addq %rcx, %rax
movslq -0x20(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
jmp 0x58f0
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x5895
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x3c, %rcx, %rcx
addq %rcx, %rax
movslq -0x20(%rbp), %rcx
movl $0xffffffff, (%rax,%rcx,4) # imm = 0xFFFFFFFF
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x585e
addq $0x2020, %rsp           # imm = 0x2020
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Gaurang18[P]Compiler-Project-BITS-Pilani/./parser.c
// Function: addLexeme
void addLexeme(parsetree head, node* Lex){

    if(head==NULL){
        return;
    }
    else{
    addLexeme(head->child, Lex);

    /*if(head->value > NON_TERMINALS && head->value!=109){
        if(strcmp(Lex->tk->token,"COMMENTMARK")==0){
            Lex = getNextToken();
        }
        if(strcmp(Lex->tk->value,"declare")==0 && head->value!=59){
            Lex = getNextToken();
        }
        head->Lex = Lex;
        printf("%s\n", terms[head->value]);
        Lex = getNextToken();
    }*/
    if(head->isleaf == 1 && head->value!=109 ){
        
        // head->Lex->tk->line = lineno[pop1];
        strcpy(head->Lex->tk->value,arra[popl++]);
         
        //printf("%s     -     %s\n",terms[head->value],head->Lex->tk->value);
    }
    addLexeme(head->right, Lex);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x5be9
jmp 0x5c53
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x5bd0
movq -0x8(%rbp), %rax
cmpl $0x1, 0x38(%rax)
jne 0x5c42
movq -0x8(%rbp), %rax
cmpl $0x6d, 0x8(%rax)
je 0x5c42
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdi
addq $0x1e, %rdi
movl 0x18086(%rip), %eax     # 0x1dca8
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0x1807b(%rip)     # 0x1dca8
cltq
leaq 0xd38a(%rip), %rsi      # 0x12fc0
imulq $0x28, %rax, %rax
addq %rax, %rsi
callq 0x2050
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x5bd0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Gaurang18[P]Compiler-Project-BITS-Pilani/./parser.c
// Function: populateLexemes
void populateLexemes(parsetree head, char *filename){



    /*FILE* fp = fopen("testcase5.txt","r");
    rewind(fp);
    fseek( fp, 0, SEEK_SET);
    fp = getstream(fp);*/
 
           node* Lex = getNextToken();                  //Call method in lexer
                    int i = 1;
                    int j = 0;
                    while(strcmp(Lex->tk->value,"$")!=0){

                         //if(strcmp(Lex->tk->value, "**")!=0)
                         // lineno[j] = Lex->tk->value;
                         strcpy(arra[j++],Lex->tk->value);

                         //printf("%s \n", arra[j-1]);
                //printf("%d. token = %s, value = %s, line = %d\n", i++,Lex->tk->token, Lex->tk->value, Lex->tk->line);   //print tokens to console
                        free(Lex);
                        node* Lex = getNextToken();
                    }               //Call method in lexer
    addLexeme(head, Lex);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x2750
movq %rax, -0x18(%rbp)
movl $0x1, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
addq $0x1e, %rdi
leaq 0x7c1c(%rip), %rsi      # 0xd8b5
callq 0x20f0
cmpl $0x0, %eax
je 0x5ce2
movl -0x20(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x20(%rbp)
cltq
leaq 0xd309(%rip), %rdi      # 0x12fc0
imulq $0x28, %rax, %rax
addq %rax, %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
addq $0x1e, %rsi
callq 0x2050
movq -0x18(%rbp), %rdi
callq 0x2030
callq 0x2750
movq %rax, -0x28(%rbp)
jmp 0x5c87
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x5bd0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Gaurang18[P]Compiler-Project-BITS-Pilani/./symboltable.h
// Function: create_node
struct tokNode* create_node(char* key,char* type,char* functionname,char* ifnumvalue){
   struct tokNode *node = (struct tokNode *)malloc(sizeof(struct tokNode));
   strcpy(node->name,key);
   strcpy(node->ifnumvalue,ifnumvalue);
   strcpy(node->scope,functionname);
   strcpy(node->type,type);
   node->offset = 0;
   node->width = 0;
   node->next = NULL;
   return node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x58, %edi
callq 0x2130
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x2050
movq -0x28(%rbp), %rdi
addq $0x1e, %rdi
movq -0x20(%rbp), %rsi
callq 0x2050
movq -0x28(%rbp), %rdi
addq $0x28, %rdi
movq -0x18(%rbp), %rsi
callq 0x2050
movq -0x28(%rbp), %rdi
addq $0x37, %rdi
movq -0x10(%rbp), %rsi
callq 0x2050
movq -0x28(%rbp), %rax
movl $0x0, 0x48(%rax)
movq -0x28(%rbp), %rax
movl $0x0, 0x4c(%rax)
movq -0x28(%rbp), %rax
movq $0x0, 0x50(%rax)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Gaurang18[P]Compiler-Project-BITS-Pilani/./symboltable.h
// Function: create_func_node
struct funcNode* create_func_node(char *lexeme,char *input_parameters,char *output_parameters){
   struct funcNode *node = (struct funcNode *)malloc(sizeof(struct funcNode));
   strcpy(node->name,lexeme);
   strcpy(node->input,input_parameters);
   strcpy(node->output,output_parameters);
   return node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0xf0, %edi
callq 0x2130
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x2050
movq -0x20(%rbp), %rdi
addq $0x1e, %rdi
movq -0x10(%rbp), %rsi
callq 0x2050
movq -0x20(%rbp), %rdi
addq $0x82, %rdi
movq -0x18(%rbp), %rsi
callq 0x2050
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Gaurang18[P]Compiler-Project-BITS-Pilani/./symboltable.h
// Function: hash
int hash(char *key)
{
    int value = 0;
    int i;
    for (i = 0; i < strlen(key); i++)
         value += (int)key[i];
    return (value % SIZE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movslq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2080
movq %rax, %rcx
movq -0x18(%rbp), %rax
cmpq %rcx, %rax
jae 0x63c4
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x638a
movl -0xc(%rbp), %eax
movl $0x14, %ecx
cltd
idivl %ecx
movl %edx, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Gaurang18[P]Compiler-Project-BITS-Pilani/./functionsymboltable.h
// Function: hash_insert_func
int hash_insert_func(char *key,char* input_parameters,char* output_parameters)
{
    int h = hash(key);
    struct funcNode* it = create_func_node(key,input_parameters,output_parameters);
    if (it == NULL){
        return 0;
    }
    while(functable->table[h]->next != NULL){
        h++;
    }
    functable->table[h]->next = it;
    strcpy(arr[funcnum++], key);
    return h;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6370
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x6310
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x6425
movl $0x0, -0x4(%rbp)
jmp 0x6495
jmp 0x6427
movq 0x1a6c2(%rip), %rax     # 0x20af0
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpq $0x0, 0xe8(%rax)
je 0x644b
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x6427
movq -0x30(%rbp), %rcx
movq 0x1a69a(%rip), %rax     # 0x20af0
movslq -0x24(%rbp), %rdx
movq (%rax,%rdx,8), %rax
movq %rcx, 0xe8(%rax)
movl 0x1a67d(%rip), %eax     # 0x20ae8
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0x1a672(%rip)     # 0x20ae8
cltq
leaq 0x1a681(%rip), %rdi     # 0x20b00
imulq $0x64, %rax, %rax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x2050
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Gaurang18[P]Compiler-Project-BITS-Pilani/./functionsymboltable.h
// Function: get_func_hash_value
int get_func_hash_value(char* functionname){
    int h = hash(functionname);
    while(functable->table[h]->next != NULL){
        if(strcmp(functable->table[h]->next->name,functionname) == 0){
            return h;
        }
        h++;
    }
    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6370
movl %eax, -0x14(%rbp)
movq 0x1a631(%rip), %rax     # 0x20af0
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpq $0x0, 0xe8(%rax)
je 0x6508
movq 0x1a618(%rip), %rax     # 0x20af0
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0xe8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x20f0
cmpl $0x0, %eax
jne 0x64fd
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x650f
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x64b8
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Gaurang18[P]Compiler-Project-BITS-Pilani/./functionsymboltable.h
// Function: func_display
void func_display(){
    int i;
    fnode* it;
    int j=1;
    for(i=0;i<SIZE;i++){
        if(functable->table[i]->next != NULL && ((int)(functable->table[i]->next->name) < 100000000)){
            it = functable->table[i]->next;
            //printf("%d. I am    %s    module\n",j++,functable->table[i]->next->name);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x1, -0x14(%rbp)
movl $0x0, -0x4(%rbp)
cmpl $0x14, -0x4(%rbp)
jge 0x6595
movq 0x1a5b1(%rip), %rax     # 0x20af0
movslq -0x4(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpq $0x0, 0xe8(%rax)
je 0x6588
movq 0x1a598(%rip), %rax     # 0x20af0
movslq -0x4(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0xe8(%rax), %rax
cmpl $0x5f5e100, %eax        # imm = 0x5F5E100
jge 0x6588
movq 0x1a57b(%rip), %rax     # 0x20af0
movslq -0x4(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0xe8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x658a
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x6532
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Gaurang18[P]Compiler-Project-BITS-Pilani/./functionsymboltable.h
// Function: get_Func_input_type
void get_Func_input_type(char* functionname){
    int i;
    fnode* it;
    char inputtype[1000] = {'\0'};
    int j=1;
    for(i=0;i<SIZE;i++){
        if(functable->table[i]->next != NULL && ((int)(functable->table[i]->next->name) < 100000000)){
            if(strcmp(functable->table[i]->next->name,functionname) == 0){
                strcpy(inputtype, functable->table[i]->next->input);
                printf("I am    %s    module and input parameters are..\n",functable->table[i]->next->name);
                    char *token;
                    token = strtok(functable->table[i]->next->input, ";");
                    while( token != NULL ) {
                       printf( "%d. %s\n", j++,token );
                       token = strtok(NULL, ";");
                    }
                // return functable->table[i]->next->input;
            }
        }
        // return "";
    }
    // return inputtype;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x410, %rsp            # imm = 0x410
movq %rdi, -0x8(%rbp)
leaq -0x400(%rbp), %rdi
xorl %esi, %esi
movl $0x3e8, %edx            # imm = 0x3E8
callq 0x20c0
movl $0x1, -0x404(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x14, -0xc(%rbp)
jge 0x6717
movq 0x1a50c(%rip), %rax     # 0x20af0
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpq $0x0, 0xe8(%rax)
je 0x6707
movq 0x1a4ef(%rip), %rax     # 0x20af0
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0xe8(%rax), %rax
cmpl $0x5f5e100, %eax        # imm = 0x5F5E100
jge 0x6707
movq 0x1a4ce(%rip), %rax     # 0x20af0
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0xe8(%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x20f0
cmpl $0x0, %eax
jne 0x6705
leaq -0x400(%rbp), %rdi
movq 0x1a49f(%rip), %rax     # 0x20af0
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0xe8(%rax), %rsi
addq $0x1e, %rsi
callq 0x2050
movq 0x1a480(%rip), %rax     # 0x20af0
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0xe8(%rax), %rsi
leaq 0x6145(%rip), %rdi      # 0xc7cb
movb $0x0, %al
callq 0x2090
movq 0x1a45c(%rip), %rax     # 0x20af0
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0xe8(%rax), %rdi
addq $0x1e, %rdi
leaq 0x5e14(%rip), %rsi      # 0xc4c2
callq 0x2160
movq %rax, -0x410(%rbp)
cmpq $0x0, -0x410(%rbp)
je 0x6703
movl -0x404(%rbp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, -0x404(%rbp)
movq -0x410(%rbp), %rdx
leaq 0x6119(%rip), %rdi      # 0xc7fc
movb $0x0, %al
callq 0x2090
xorl %eax, %eax
movl %eax, %edi
leaq 0x5dcd(%rip), %rsi      # 0xc4c2
callq 0x2160
movq %rax, -0x410(%rbp)
jmp 0x66ba
jmp 0x6705
jmp 0x6707
jmp 0x6709
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x65d3
addq $0x410, %rsp            # imm = 0x410
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Gaurang18[P]Compiler-Project-BITS-Pilani/./functionsymboltable.h
// Function: get_Func_output_type
void get_Func_output_type(char* functionname){
    int i;
    fnode* it;
    int j=1;
    char outputtype[1000] = {'\0'};
    for(i=0;i<SIZE;i++){
        if(functable->table[i]->next != NULL && ((int)(functable->table[i]->next->name) < 100000000)){
            if(strcmp(functable->table[i]->next->name,functionname) == 0){
                strcpy(outputtype, functable->table[i]->next->output);
                printf("I am    %s    module and output parameters are..\n",functable->table[i]->next->name);
                    char *token;
                    token = strtok(functable->table[i]->next->output, ";");
                    while( token != NULL ) {
                       printf( "%d. %s\n", j++,token );
                       token = strtok(NULL, ";");
                    }
                    // return functable->table[i]->next->output;
            }
        }
    }

    // return "";
    // return outputtype;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x420, %rsp            # imm = 0x420
movq %rdi, -0x8(%rbp)
movl $0x1, -0x1c(%rbp)
leaq -0x410(%rbp), %rdi
xorl %esi, %esi
movl $0x3e8, %edx            # imm = 0x3E8
callq 0x20c0
movl $0x0, -0xc(%rbp)
cmpl $0x14, -0xc(%rbp)
jge 0x6894
movq 0x1a38f(%rip), %rax     # 0x20af0
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpq $0x0, 0xe8(%rax)
je 0x6884
movq 0x1a372(%rip), %rax     # 0x20af0
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0xe8(%rax), %rax
cmpl $0x5f5e100, %eax        # imm = 0x5F5E100
jge 0x6884
movq 0x1a351(%rip), %rax     # 0x20af0
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0xe8(%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x20f0
cmpl $0x0, %eax
jne 0x6882
leaq -0x410(%rbp), %rdi
movq 0x1a322(%rip), %rax     # 0x20af0
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0xe8(%rax), %rsi
addq $0x82, %rsi
callq 0x2050
movq 0x1a300(%rip), %rax     # 0x20af0
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0xe8(%rax), %rsi
leaq 0x5ffe(%rip), %rdi      # 0xc804
movb $0x0, %al
callq 0x2090
movq 0x1a2dc(%rip), %rax     # 0x20af0
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0xe8(%rax), %rdi
addq $0x82, %rdi
leaq 0x5c91(%rip), %rsi      # 0xc4c2
callq 0x2160
movq %rax, -0x418(%rbp)
cmpq $0x0, -0x418(%rbp)
je 0x6880
movl -0x1c(%rbp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x418(%rbp), %rdx
leaq 0x5f9c(%rip), %rdi      # 0xc7fc
movb $0x0, %al
callq 0x2090
xorl %eax, %eax
movl %eax, %edi
leaq 0x5c50(%rip), %rsi      # 0xc4c2
callq 0x2160
movq %rax, -0x418(%rbp)
jmp 0x683d
jmp 0x6882
jmp 0x6884
jmp 0x6886
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x6750
addq $0x420, %rsp            # imm = 0x420
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Gaurang18[P]Compiler-Project-BITS-Pilani/./functionsymboltable.h
// Function: get_Function_input_type
char* get_Function_input_type(char* functionname){
    int i;
    fnode* it;
    char inputtype[1000] = {'\0'};
    int j=1;
    for(i=0;i<SIZE;i++){
        if(functable->table[i]->next != NULL && ((int)(functable->table[i]->next->name) < 100000000)){
            if(strcmp(functable->table[i]->next->name,functionname) == 0){
                strcpy(inputtype, functable->table[i]->next->input);
                
                // return functable->table[i]->next->input;
            }
        }
        // return "";
    }
    return inputtype;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x410, %rsp            # imm = 0x410
movq %rdi, -0x8(%rbp)
leaq -0x400(%rbp), %rdi
xorl %esi, %esi
movl $0x3e8, %edx            # imm = 0x3E8
callq 0x20c0
movl $0x1, -0x404(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x14, -0xc(%rbp)
jge 0x696f
movq 0x1a20c(%rip), %rax     # 0x20af0
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpq $0x0, 0xe8(%rax)
je 0x695f
movq 0x1a1f3(%rip), %rax     # 0x20af0
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0xe8(%rax), %rax
cmpl $0x5f5e100, %eax        # imm = 0x5F5E100
jge 0x695f
movq 0x1a1d6(%rip), %rax     # 0x20af0
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0xe8(%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x20f0
cmpl $0x0, %eax
jne 0x695d
leaq -0x400(%rbp), %rdi
movq 0x1a1ab(%rip), %rax     # 0x20af0
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0xe8(%rax), %rsi
addq $0x1e, %rsi
callq 0x2050
jmp 0x695f
jmp 0x6961
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x68d3
leaq -0x400(%rbp), %rax
addq $0x410, %rsp            # imm = 0x410
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Gaurang18[P]Compiler-Project-BITS-Pilani/./functionsymboltable.h
// Function: get_Function_output_type
char* get_Function_output_type(char* functionname){
    int i;
    fnode* it;
    int j=1;
    char outputtype[1000] = {'\0'};
    for(i=0;i<SIZE;i++){
        if(functable->table[i]->next != NULL && ((int)(functable->table[i]->next->name) < 100000000)){
            if(strcmp(functable->table[i]->next->name,functionname) == 0){
                strcpy(outputtype, functable->table[i]->next->output);
                
                    // return functable->table[i]->next->output;
            }
        }
    }

    // return "";
    return outputtype;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x410, %rsp            # imm = 0x410
movq %rdi, -0x8(%rbp)
movl $0x1, -0x1c(%rbp)
leaq -0x410(%rbp), %rdi
xorl %esi, %esi
movl $0x3e8, %edx            # imm = 0x3E8
callq 0x20c0
movl $0x0, -0xc(%rbp)
cmpl $0x14, -0xc(%rbp)
jge 0x6a4f
movq 0x1a12f(%rip), %rax     # 0x20af0
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpq $0x0, 0xe8(%rax)
je 0x6a3f
movq 0x1a116(%rip), %rax     # 0x20af0
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0xe8(%rax), %rax
cmpl $0x5f5e100, %eax        # imm = 0x5F5E100
jge 0x6a3f
movq 0x1a0f9(%rip), %rax     # 0x20af0
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0xe8(%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x20f0
cmpl $0x0, %eax
jne 0x6a3d
leaq -0x410(%rbp), %rdi
movq 0x1a0ce(%rip), %rax     # 0x20af0
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0xe8(%rax), %rsi
addq $0x82, %rsi
callq 0x2050
jmp 0x6a3f
jmp 0x6a41
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x69b0
leaq -0x410(%rbp), %rax
addq $0x410, %rsp            # imm = 0x410
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Gaurang18[P]Compiler-Project-BITS-Pilani/./functionsymboltable.h
// Function: check_func_present
int check_func_present(char* functionname){
    int i;
    fnode* it;
    int j=1;
    for(i=0;i<SIZE;i++){
        if(functable->table[i]->next != NULL && ((int)(functable->table[i]->next->name) < 100000000)){
            if(strcmp(functable->table[i]->next->name,functionname) == 0){
               return 1;
            }
        }
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl $0x1, -0x24(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x14, -0x14(%rbp)
jge 0x6af2
movq 0x1a069(%rip), %rax     # 0x20af0
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpq $0x0, 0xe8(%rax)
je 0x6ae5
movq 0x1a050(%rip), %rax     # 0x20af0
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0xe8(%rax), %rax
cmpl $0x5f5e100, %eax        # imm = 0x5F5E100
jge 0x6ae5
movq 0x1a033(%rip), %rax     # 0x20af0
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0xe8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x20f0
cmpl $0x0, %eax
jne 0x6ae3
movl $0x1, -0x4(%rbp)
jmp 0x6af9
jmp 0x6ae5
jmp 0x6ae7
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x6a7a
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Gaurang18[P]Compiler-Project-BITS-Pilani/./functionsymboltable.h
// Function: directfunctionpointer
fnode* directfunctionpointer(char* functionname){
    int i;
    fnode* it;
    int j=1;
    for(i=0;i<SIZE;i++){
        if(functable->table[i]->next != NULL && ((int)(functable->table[i]->next->name) < 100000000)){
            if(strcmp(functable->table[i]->next->name,functionname) == 0){
               return functable->table[i]->next;
            }
        }
    }
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl $0x1, -0x24(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x14, -0x14(%rbp)
jge 0x6bbc
movq 0x19fb5(%rip), %rax     # 0x20af0
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpq $0x0, 0xe8(%rax)
je 0x6bac
movq 0x19f9c(%rip), %rax     # 0x20af0
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0xe8(%rax), %rax
cmpl $0x5f5e100, %eax        # imm = 0x5F5E100
jge 0x6bac
movq 0x19f7f(%rip), %rax     # 0x20af0
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0xe8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x20f0
cmpl $0x0, %eax
jne 0x6baa
movq 0x19f5b(%rip), %rax     # 0x20af0
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0xe8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x6bc4
jmp 0x6bac
jmp 0x6bae
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x6b2a
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Gaurang18[P]Compiler-Project-BITS-Pilani/./tokensymboltable.h
// Function: displaySymbolTable
void displaySymbolTable(){
    int i;
    printf("\t\t\t\t Symbol Table\n");
    printf("%-3s %-20s %-22s %-20s %5s %6s\n","No.","Identifier name","Type", "Module Scope","Width","Offset");
      
    for(i=0; i<funcnum; i++)
        display(arr[i]);

    //assert(0);


}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x5710(%rip), %rdi      # 0xc85f
movb $0x0, %al
callq 0x2090
leaq 0x5715(%rip), %rdi      # 0xc872
leaq 0x572e(%rip), %rsi      # 0xc892
leaq 0x572b(%rip), %rdx      # 0xc896
leaq 0x69c1(%rip), %rcx      # 0xdb33
leaq 0x572d(%rip), %r8       # 0xc8a6
leaq 0x5733(%rip), %r9       # 0xc8b3
leaq 0x5732(%rip), %rax      # 0xc8b9
movq %rax, (%rsp)
movb $0x0, %al
callq 0x2090
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
cmpl 0x19946(%rip), %eax     # 0x20ae8
jge 0x71c6
movslq -0x4(%rbp), %rax
leaq 0x19951(%rip), %rdi     # 0x20b00
imulq $0x64, %rax, %rax
addq %rax, %rdi
callq 0x6f20
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x7199
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Gaurang18[P]Compiler-Project-BITS-Pilani/./tokensymboltable.h
// Function: checksymbolpresent
int checksymbolpresent(char* key,char* functionname){
    int j = get_func_hash_value(functionname);
    int h = hash(key);
    if(ht->functable[j]->table[h]==NULL){
        return 0;
    }
    while(ht->functable[j]->table[h]->next != NULL){
        if(strcmp(key,ht->functable[j]->table[h]->next->name) == 0){
            return 1;
        }
        h++;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x64a0
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6370
movl %eax, -0x20(%rbp)
movq 0x1c019(%rip), %rax     # 0x23218
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x20(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x721b
movl $0x0, -0x4(%rbp)
jmp 0x727f
jmp 0x721d
movq 0x1bff4(%rip), %rax     # 0x23218
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpq $0x0, 0x50(%rax)
je 0x7278
movq -0x10(%rbp), %rdi
movq 0x1bfd2(%rip), %rax     # 0x23218
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x50(%rax), %rsi
callq 0x20f0
cmpl $0x0, %eax
jne 0x726d
movl $0x1, -0x4(%rbp)
jmp 0x727f
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x721d
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Gaurang18[P]Compiler-Project-BITS-Pilani/./tokensymboltable.h
// Function: getoffset
int getoffset(char* key,char* functionname){
    int j = get_func_hash_value(functionname);
    int h = hash(key);
    while(ht->functable[j]->table[h]->next != NULL){
        if(strcmp(key,ht->functable[j]->table[h]->next->name) == 0){
            return ht->functable[j]->table[h]->next->offset;
        }
        h++;
    }
    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x64a0
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6370
movl %eax, -0x20(%rbp)
movq 0x1bf59(%rip), %rax     # 0x23218
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpq $0x0, 0x50(%rax)
je 0x732d
movq -0x10(%rbp), %rdi
movq 0x1bf37(%rip), %rax     # 0x23218
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x50(%rax), %rsi
callq 0x20f0
cmpl $0x0, %eax
jne 0x7322
movq 0x1bf12(%rip), %rax     # 0x23218
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x50(%rax), %rax
movl 0x48(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x7334
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x72b8
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Gaurang18[P]Compiler-Project-BITS-Pilani/./tokensymboltable.h
// Function: gettype
char* gettype(char* key,char* functionname){
    int j = get_func_hash_value(functionname);
    int h = hash(key);
    while(ht->functable[j]->table[h]->next != NULL){
        if(strcmp(key,ht->functable[j]->table[h]->next->name) == 0){
            return ht->functable[j]->table[h]->next->type;
        }
        h++;
    }
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x64a0
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6370
movl %eax, -0x20(%rbp)
movq 0x1bea9(%rip), %rax     # 0x23218
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpq $0x0, 0x50(%rax)
je 0x73df
movq -0x10(%rbp), %rdi
movq 0x1be87(%rip), %rax     # 0x23218
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x50(%rax), %rsi
callq 0x20f0
cmpl $0x0, %eax
jne 0x73d4
movq 0x1be62(%rip), %rax     # 0x23218
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x50(%rax), %rax
addq $0x37, %rax
movq %rax, -0x8(%rbp)
jmp 0x73e7
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x7368
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Gaurang18[P]Compiler-Project-BITS-Pilani/./tokensymboltable.h
// Function: getdirectpointer
pNode* getdirectpointer(char* key,char* functionname){
	int j = get_func_hash_value(functionname);
    int h = hash(key);
    while(ht->functable[j]->table[h]->next != NULL){
        if(strcmp(key,ht->functable[j]->table[h]->next->name) == 0){
            return ht->functable[j]->table[h]->next;
        }
        h++;
    }
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x64a0
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6370
movl %eax, -0x20(%rbp)
movq 0x1bc29(%rip), %rax     # 0x23218
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpq $0x0, 0x50(%rax)
je 0x765b
movq -0x10(%rbp), %rdi
movq 0x1bc07(%rip), %rax     # 0x23218
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x50(%rax), %rsi
callq 0x20f0
cmpl $0x0, %eax
jne 0x7650
movq 0x1bbe2(%rip), %rax     # 0x23218
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x50(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x7663
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x75e8
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Gaurang18[P]Compiler-Project-BITS-Pilani/./symboltable.c
// Function: createsymboltable
void createsymboltable(){
        functable = (struct func_hash_table*)malloc(sizeof(struct func_hash_table*));
        int i;
        char *t = "";
        char *inp = "";
        char *output = "";
        for (i = 0;i < SIZE;i++) {
            functable->table[i] = create_func_node(t,inp,output);
        }
        ht = (struct hash_of_hash_tables*)malloc(sizeof(struct hash_of_hash_tables));
        int j;
        for (j = 0 ; j < HASHSIZE ; j++) {
                ht->functable[j] = create_table();
                for ( i = 0 ; i < SIZE ; ++i ) {
                    char *key = "";
                    char* functionname = "";
                    char* type = "";
                    char* ifnumvalue = "";
                    ht->functable[j]->table[i] = create_node(key,type,functionname,ifnumvalue);
                }
        }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl $0x8, %edi
callq 0x2130
movq %rax, 0x18b57(%rip)     # 0x20af0
leaq 0x572b(%rip), %rax      # 0xd6cb
movq %rax, -0x10(%rbp)
leaq 0x5720(%rip), %rax      # 0xd6cb
movq %rax, -0x18(%rbp)
leaq 0x5715(%rip), %rax      # 0xd6cb
movq %rax, -0x20(%rbp)
movl $0x0, -0x4(%rbp)
cmpl $0x14, -0x4(%rbp)
jge 0x7ff5
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x6310
movq %rax, %rdx
movq 0x18b0e(%rip), %rax     # 0x20af0
movslq -0x4(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x7fc1
movl $0xa0, %edi
callq 0x2130
movq %rax, 0x1b212(%rip)     # 0x23218
movl $0x0, -0x24(%rbp)
cmpl $0x14, -0x24(%rbp)
jge 0x80b1
callq 0x6250
movq %rax, %rdx
movq 0x1b1f2(%rip), %rax     # 0x23218
movslq -0x24(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl $0x0, -0x4(%rbp)
cmpl $0x14, -0x4(%rbp)
jge 0x80a1
leaq 0x5689(%rip), %rax      # 0xd6cb
movq %rax, -0x30(%rbp)
leaq 0x567e(%rip), %rax      # 0xd6cb
movq %rax, -0x38(%rbp)
leaq 0x5673(%rip), %rax      # 0xd6cb
movq %rax, -0x40(%rbp)
leaq 0x5668(%rip), %rax      # 0xd6cb
movq %rax, -0x48(%rbp)
movq -0x30(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq -0x48(%rbp), %rcx
callq 0x6270
movq %rax, %rdx
movq 0x1b192(%rip), %rax     # 0x23218
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x4(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x8035
jmp 0x80a3
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x800d
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Gaurang18[P]Compiler-Project-BITS-Pilani/./codegen.c
// Function: codegen
void codegen(parsetree head, FILE* fp){
    /*parseTree mf = ast->child->right;
    parseTree typedefinitions = mf->child->child;
    parseTree decl = typedefinitions->right;*/
    //print("\nsection .data\n");
    declarevariables(head, fp);
    fprintf(fp,"\nsection .text\n");
    fprintf(fp,"global main\n");
    fprintf(fp,"extern scanf\n");
    fprintf(fp,"extern printf\n");
    fprintf(fp,"\nmain :\n");
    //handle_stmt(decl->right->child, output, ht);
    //fclose(fp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x9bc0
movq -0x10(%rbp), %rdi
leaq 0x33f3(%rip), %rsi      # 0xd1bb
movb $0x0, %al
callq 0x2100
movq -0x10(%rbp), %rdi
leaq 0x33f1(%rip), %rsi      # 0xd1cb
movb $0x0, %al
callq 0x2100
movq -0x10(%rbp), %rdi
leaq 0x33ec(%rip), %rsi      # 0xd1d8
movb $0x0, %al
callq 0x2100
movq -0x10(%rbp), %rdi
leaq 0x33e8(%rip), %rsi      # 0xd1e6
movb $0x0, %al
callq 0x2100
movq -0x10(%rbp), %rdi
leaq 0x33e5(%rip), %rsi      # 0xd1f5
movb $0x0, %al
callq 0x2100
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/videolan[P]bitstream/examples/mpeg_print_pcr.c
// Function: handle_section
static void handle_section(uint16_t i_pid, uint8_t *p_section)
{
    uint8_t i_table_id = psi_get_tableid(p_section);

    if (!psi_validate(p_section)) {
        free(p_section);
        return;
    }

    switch (i_table_id) {
    case PAT_TABLE_ID:
        handle_pat_section(i_pid, p_section);
        break;

    case PMT_TABLE_ID:
        handle_pmt(i_pid, p_section);
        break;

    default:
        free( p_section );
        break;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %di, %ax
movw %ax, -0x2(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1ba0
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1bb0
testb $0x1, %al
jne 0x1987
movq -0x10(%rbp), %rdi
callq 0x1030
jmp 0x19cb
movzbl -0x11(%rbp), %eax
movl %eax, -0x18(%rbp)
testl %eax, %eax
je 0x199e
jmp 0x1994
movl -0x18(%rbp), %eax
subl $0x2, %eax
je 0x19b0
jmp 0x19c2
movw -0x2(%rbp), %ax
movq -0x10(%rbp), %rsi
movzwl %ax, %edi
callq 0x1c00
jmp 0x19cb
movw -0x2(%rbp), %ax
movq -0x10(%rbp), %rsi
movzwl %ax, %edi
callq 0x1c60
jmp 0x19cb
movq -0x10(%rbp), %rdi
callq 0x1030
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/videolan[P]bitstream/examples/./bitstream/mpeg/ts.h
// Function: ts_next_section
static inline uint8_t *ts_next_section(uint8_t *p_ts)
{
    uint8_t *p_payload;

    if (!ts_get_unitstart(p_ts))
        return p_ts + TS_SIZE;
    p_payload = ts_payload(p_ts);
    if (p_payload >= p_ts + TS_SIZE)
        return p_ts + TS_SIZE;

    return p_payload + *p_payload + 1; /* pointer_field */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1a60
testb $0x1, %al
jne 0x1a09
movq -0x10(%rbp), %rax
addq $0xbc, %rax
movq %rax, -0x8(%rbp)
jmp 0x1a53
movq -0x10(%rbp), %rdi
callq 0x1a90
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
addq $0xbc, %rcx
cmpq %rcx, %rax
jb 0x1a3a
movq -0x10(%rbp), %rax
addq $0xbc, %rax
movq %rax, -0x8(%rbp)
jmp 0x1a53
movq -0x18(%rbp), %rax
movq -0x18(%rbp), %rcx
movzbl (%rcx), %ecx
movslq %ecx, %rcx
addq %rcx, %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/videolan[P]bitstream/examples/mpeg_print_pcr.c
// Function: handle_pat_section
static void handle_pat_section(uint16_t i_pid, uint8_t *p_section)
{
    if (i_pid != PAT_PID || !pat_validate(p_section)) {
        free(p_section);
        return;
    }

    if (!psi_table_section(pp_next_pat_sections, p_section))
        return;

    handle_pat();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movw %di, %ax
movw %ax, -0x2(%rbp)
movq %rsi, -0x10(%rbp)
movzwl -0x2(%rbp), %eax
cmpl $0x0, %eax
jne 0x1c29
movq -0x10(%rbp), %rdi
callq 0x1d80
testb $0x1, %al
jne 0x1c34
movq -0x10(%rbp), %rdi
callq 0x1030
jmp 0x1c4f
movq -0x10(%rbp), %rsi
leaq 0x33471(%rip), %rdi     # 0x350b0
callq 0x1df0
testb $0x1, %al
jne 0x1c4a
jmp 0x1c4f
callq 0x1f20
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/videolan[P]bitstream/examples/mpeg_print_pcr.c
// Function: handle_pmt
static void handle_pmt(uint16_t i_pid, uint8_t *p_pmt)
{
    uint16_t i_sid = pmt_get_program(p_pmt);
    sid_t *p_sid;
    int i;

    /* we do this before checking the service ID */
    if (!pmt_validate(p_pmt)) {
        free(p_pmt);
        return;
    }

    for (i = 0; i < i_nb_sids; i++)
        if (pp_sids[i]->i_sid && pp_sids[i]->i_sid == i_sid)
            break;

    if (i != i_nb_sids) {
        p_sid = pp_sids[i];
        if (i_pid == p_sid->i_pmt_pid) {
            printf("%"PRIu16"\n", pmt_get_pcrpid(p_pmt));
            exit(EXIT_SUCCESS);
        }
    }

    free(p_pmt);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movw %di, %ax
movw %ax, -0x2(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2480
movw %ax, -0x12(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2a70
testb $0x1, %al
jne 0x1c9b
movq -0x10(%rbp), %rdi
callq 0x1030
jmp 0x1d47
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl 0x34405(%rip), %eax     # 0x360b0
jge 0x1ced
movq 0x34404(%rip), %rax     # 0x360b8
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movzwl (%rax), %eax
cmpl $0x0, %eax
je 0x1ce0
movq 0x343ed(%rip), %rax     # 0x360b8
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movzwl (%rax), %eax
movzwl -0x12(%rbp), %ecx
cmpl %ecx, %eax
jne 0x1ce0
jmp 0x1ced
jmp 0x1ce2
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x1ca2
movl -0x24(%rbp), %eax
cmpl 0x343ba(%rip), %eax     # 0x360b0
je 0x1d3e
movq 0x343b9(%rip), %rax     # 0x360b8
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movzwl -0x2(%rbp), %eax
movq -0x20(%rbp), %rcx
movzwl 0x2(%rcx), %ecx
cmpl %ecx, %eax
jne 0x1d3c
movq -0x10(%rbp), %rdi
callq 0x2c30
movzwl %ax, %esi
leaq 0x1307(%rip), %rdi      # 0x3035
movb $0x0, %al
callq 0x1060
xorl %edi, %edi
callq 0x1100
jmp 0x1d3e
movq -0x10(%rbp), %rdi
callq 0x1030
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/videolan[P]bitstream/examples/./bitstream/mpeg/psi/pat.h
// Function: pat_validate
static inline bool pat_validate(const uint8_t *p_pat)
{
    if (!psi_get_syntax(p_pat) || psi_get_tableid(p_pat) != PAT_TABLE_ID)
        return false;
    if ((psi_get_length(p_pat) - PAT_HEADER_SIZE + PSI_HEADER_SIZE
         - PSI_CRC_SIZE) % PAT_PROGRAM_SIZE)
        return false;

    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1d50
testb $0x1, %al
jne 0x1d9b
jmp 0x1dac
movq -0x10(%rbp), %rdi
callq 0x1ba0
movzbl %al, %eax
cmpl $0x0, %eax
je 0x1db2
movb $0x0, -0x1(%rbp)
jmp 0x1dde
movq -0x10(%rbp), %rdi
callq 0x1b70
movzwl %ax, %eax
subl $0x8, %eax
addl $0x3, %eax
subl $0x4, %eax
movl $0x4, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
je 0x1dda
movb $0x0, -0x1(%rbp)
jmp 0x1dde
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/videolan[P]bitstream/examples/./bitstream/mpeg/psi/psi.h
// Function: psi_table_section
static inline bool psi_table_section(uint8_t **pp_sections, uint8_t *p_section)
{
    uint8_t i_section = psi_get_section( p_section );
    uint8_t i_last_section = psi_get_lastsection( p_section );
    uint8_t i_version = psi_get_version( p_section );
    uint16_t i_tableidext = psi_get_tableidext( p_section );
    int i;

    free(pp_sections[i_section]);
    pp_sections[i_section] = p_section;

    for (i = 0; i <= i_last_section; i++) {
        uint8_t *p = pp_sections[i];
        if (p == NULL)
            return false;
        if (psi_get_lastsection(p) != i_last_section
             || psi_get_version(p) != i_version
             || psi_get_tableidext(p) != i_tableidext)
            return false;
    }

    /* free spurious, invalid sections */
    for (; i < PSI_TABLE_MAX_SECTIONS; i++) {
        free(pp_sections[i]);
        pp_sections[i] = NULL;
    }

    /* a new, full table is available */
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2420
movb %al, -0x19(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2440
movb %al, -0x1a(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2460
movb %al, -0x1b(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2480
movw %ax, -0x1e(%rbp)
movq -0x10(%rbp), %rax
movzbl -0x19(%rbp), %ecx
movq (%rax,%rcx,8), %rdi
callq 0x1030
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rax
movzbl -0x19(%rbp), %ecx
movq %rdx, (%rax,%rcx,8)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movzbl -0x1a(%rbp), %ecx
cmpl %ecx, %eax
jg 0x1ed3
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x1e84
movb $0x0, -0x1(%rbp)
jmp 0x1f0e
movq -0x30(%rbp), %rdi
callq 0x2440
movzbl %al, %eax
movzbl -0x1a(%rbp), %ecx
cmpl %ecx, %eax
jne 0x1ec0
movq -0x30(%rbp), %rdi
callq 0x2460
movzbl %al, %eax
movzbl -0x1b(%rbp), %ecx
cmpl %ecx, %eax
jne 0x1ec0
movq -0x30(%rbp), %rdi
callq 0x2480
movzwl %ax, %eax
movzwl -0x1e(%rbp), %ecx
cmpl %ecx, %eax
je 0x1ec6
movb $0x0, -0x1(%rbp)
jmp 0x1f0e
jmp 0x1ec8
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x1e59
jmp 0x1ed5
cmpl $0x100, -0x24(%rbp)     # imm = 0x100
jge 0x1f0a
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1030
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x1ed5
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)