compiler

parse.y (78945B)

---

 %define parse.error verbose
 
 %{
 #include "lex.h"
 int line = 1;
 char *fname;
 int yywrap(void){ return 1; }
 int yylex(void);
 void yyerror(const char *s)
 {
   fprintf(stderr, "%s:%i:%s\n", fname, line, s);
   exit(1);
 }
 
 #define IDENTIFIER_TYPES( f ) \
   f(undefined) \
   f(variable) \
   f(func) \
   f(parameter)
 
 enum id_type {
   #define f(n) n,
   IDENTIFIER_TYPES(f)
   #undef f
 };
 
 #define EXPRESSION_TYPES( f ) \
   f(nop) f(string) f(number) f(idnt) \
   f(neg) f(add) f(mul) f(divide) f(mod)\
   f(comma) \
   f(ref) f(deref) \
   f(l_eq) f(l_lt) \
   f(l_and) f(l_or) f(l_not) \
   f(b_and) f(b_or) f(b_not) f(b_xor) \
   f(shift_l) f(shift_r) \
   f(set) f(decl) \
   f(ifnz) f(loop) \
   f(printchar) f(writestring) f(readstring)\
   f(brk_sys) f(_syscall) \
   f(function) f(fcall) f(ret) f(exit_p)
 
 enum e_type {
   #define f(n) n,
   EXPRESSION_TYPES(f)
   #undef f
 };
 
 struct expression {
   enum e_type type;
   enum id_type id_type;
   int constant;
   int declares;
   char *str;
   char flags;
   int64_t i;
   size_t args_count;
   struct expression *args;
 };
 
 struct identifiers{
   size_t count;
   struct expression *identifiers;
 };
 struct identifiers *ids = NULL;
 struct expression *defid(char *name)
 {
   int i;
   if (!ids)
     ids = calloc(sizeof(struct identifiers), 1);
   for (i = 0; i < ids->count; i++) {
     if (!strcmp(ids->identifiers[i].str, name)) return &ids->identifiers[i];
   }
   ids->count++;
   ids->identifiers = realloc(ids->identifiers, sizeof(struct expression) * ids->count);
 
   ids->identifiers[ids->count-1].type = idnt;
   ids->identifiers[ids->count-1].id_type = undefined;
   ids->identifiers[ids->count-1].constant = 1;
   ids->identifiers[ids->count-1].str = malloc(strlen(name) + 1);
 
   strcpy(ids->identifiers[ids->count-1].str, name);
   free(name);
 
   return &ids->identifiers[ids->count-1];
 }
 
 struct expression *find_idnt(char *name)
 {
   struct expression *r = NULL;
   size_t i;
   for (i = 0; i < ids->count; i++) {
     if (!strcmp(ids->identifiers[i].str, name)) {
       r = &ids->identifiers[i];
       break;
     }
   }
   if (!r) yyerror("undefined symbol");
   return r;
 }
 
 struct expression *ZERO = &(struct expression){ .type = number, .constant = 1 };
 struct expression *ONE = &(struct expression){ .type = number, .constant = 1, .i = 1 };
 struct expression *final;
 
 struct expression *e(enum e_type type, struct expression *arg1, struct expression *arg2, int nofree)
 {
   struct expression *r = calloc(sizeof(struct expression), 1);
   r->type = type;
   if (r->type == comma && (arg1 && arg1->type == comma || arg2 && arg2->type == comma)) {
     if (arg1 && arg1->type == comma && arg2 && arg2->type == comma) {
       r->args_count = arg1->args_count + arg2->args_count;
       r->args = calloc(sizeof(struct expression), r->args_count);
       memmove(r->args, arg1->args, sizeof(struct expression) * arg1->args_count);
       memmove(&r->args[arg1->args_count], arg2->args, sizeof(struct expression) * arg2->args_count);
     } else if (arg1 && arg1->type == comma) {
       r->args_count = arg1->args_count + 1;
       r->args = calloc(sizeof(struct expression), r->args_count);
       memmove(r->args, arg1->args, sizeof(struct expression) * arg1->args_count);
       if (arg2) memmove(&r->args[arg1->args_count], arg2, sizeof(struct expression));
     } else if (arg2 && arg2->type == comma) {
       r->args_count = arg2->args_count + 1;
       r->args = calloc(sizeof(struct expression), r->args_count);
       if (arg1) memmove(r->args, arg1, sizeof(struct expression));
       memmove(&r->args[arg1 ? 1 : 0], arg2->args, sizeof(struct expression) * arg2->args_count);
     }
   } else if (r->type == number) {
     r->i = (int64_t) arg1;
   } else if (r->type == string && arg1) {
     r->str = calloc(strlen((char *)arg1) + 1, 1);
     strcpy(r->str, (char *)arg1);
   } else {
     r->args_count = (arg1 ? 1 : 0) + (arg2 ? 1 : 0);
     r->args = calloc(sizeof(struct expression), r->args_count);
     if (arg1) memmove(r->args, arg1, sizeof(struct expression));
     if (arg2) memmove(&r->args[arg1 ? 1 : 0], arg2, sizeof(struct expression));
   }
   //if (!nofree && arg1 && !arg1->constant) free(arg1);
   if (!nofree && arg2 && !arg2->constant) free(arg2);
   return r;
 }
 int curr_decl = 0;
 struct expression *defun(struct expression *identifier, struct expression *params, struct expression *body)
 {
   struct expression *r = calloc(sizeof(struct expression), 1);
   r->type = function;
   r->declares = curr_decl;
   curr_decl = 0;
   r->args_count = params ? 3 : 2;
   r->args = calloc(sizeof(struct expression), r->args_count);
   memmove(r->args, identifier, sizeof(struct expression));
   if (params) memmove(&r->args[1], params, sizeof(struct expression));
   memmove(&r->args[r->args_count-1], body, sizeof(struct expression));
   if (params) free(params);
   if (body) free(body);
   return r;
 }
 
 void append(struct expression *base, struct expression *arg)
 {
   base->args = realloc(base->args, sizeof(struct expression) * (++base->args_count));
   memmove(&base->args[base->args_count-1], arg, sizeof(struct expression));
   free(arg);
 }
 
 struct expression *move(struct expression *e)
 {
   struct expression *r = calloc(sizeof(struct expression), 1);
   memmove(r, e, sizeof(struct expression));
   free(e);
   return r;
 }
 struct expression *copy(struct expression *e)
 {
   struct expression *r = calloc(sizeof(struct expression), 1);
   memcpy(r, e, sizeof(struct expression));
   return r;
 }
 
 char *expand_str(char *str) {
   int i, j = 0, l = strlen(str);
   for (i = 0; i < l; i++) {
     if (str[i] == '\\') {
       switch (str[i+1]) {
       case 'n':
         j = 1;
         str[i+j] = '\n';
         break;
       case 'r':
         j = 1;
         str[i+j] = '\r';
         break;
       case 't':
         j = 1;
         str[i+j] = '\t';
         break;
       case '\\':
         i++;
       default:
         j = 0;
         break;
       }
       l -= j;
       if (j) memmove(&str[i], &str[i+j], l - i + 1);
     }
   }
   return str;
 }
 
 char *escape_str(char *str) {
   int i, j, l = strlen(str);
   char *r;
   for (i = 0, j = 1; i < l; i++)
     if (str[i] == '\\' || str[i] == '\n' || str[i] == '\r' || str[i] == '\t')
       j++;
   r = calloc(l + j, 1);
   for (i = 0, j = 0; i < l; i++, j++) {
     switch (str[i]) {
     case '\n':
       r[j++] = '\\';
       r[j] = 'n';
       break;
     case '\r':
       r[j++] = '\\';
       r[j] = 'r';
       break;
     case '\t':
       r[j++] = '\\';
       r[j] = 't';
       break;
     case '\\':
       r[j++] = '\\';
       r[j] = '\\';
       break;
     default:
       r[j] = str[i];
       break;
     }
   }
   return r;
 }
 %}
 
 %union {struct expression *expr; char *str; int64_t i;}
 
 %token END 0
 %token <str> IDENTIFIER STRING
 %token <i> NUMBER
 %token INC "++" DEC "--"
 %token EQ "==" LTEQ "<=" GTEQ ">=" AND "&&" OR "||" NOT_EQ "!="
 %token SHIFT_L "<<" SHIFT_R ">>"
 %token ADD_EQ "+=" SUB_EQ "-=" MUL_EQ "*=" DIV_EQ "/=" MOD_EQ "%="
 %token OR_EQ "|=" AND_EQ "&=" XOR_EQ "^=" SHL_EQ "<<=" SHR_EQ ">>="
 %token RETURN "return" IF "if" ELSE "else" WHILE "while" DECL "decl"
 %token EXIT "exit" PUTC "putc" WRITE "write" READ "read" BRK "brk"
 %token SYSCALL1 "_syscall1" SYSCALL2 "_syscall2" SYSCALL3 "_syscall3"
 %token SYSCALL4 "_syscall4" SYSCALL5 "_syscall5" SYSCALL6 "_syscall6"
 
 %nonassoc "if"
 %nonassoc "else"
 
 %left  ','
 %right '?' ':' '=' "+=" "-=" "*=" "/=" "%=" "&=" "|=" "^=" "<<=" ">>="
 %left  "||"
 %left  "&&"
 %left  '|'
 %left  '^'
 %left  '&'
 %left  "==" "!="
 %left  '<' '>' "<=" ">="
 %left  "<<" ">>"
 %left  '+' '-'
 %left  '*' '/' '%'
 %right REF NEG "++" "--" '!' '~'
 %left  '(' '['
 
 %type <expr> expression exprs c_expr var_def var_defs statement comp_stmt if_stmt
 %type <expr> parameters parameter identifier program function ifelse
 %type <str> str
 
 %%
 
 program:    program function                      {$$ = move($1); append($$, $2); final = $$;}
 |           function                              {$$ = e(comma, $1, NULL, 0); final = $$;}
 ;
 
 function:   identifier '(' parameters ')' statement {$1->id_type = function; $$ = defun(copy($1), $3, $5);}
 ;
 
 parameters: parameter                             {$$ = move($1);}
 |           %empty                                {$$ = NULL;}
 ;
 
 parameter:  parameter ',' parameter               {$$ = e(comma, $1, $3, 0);}
 |           identifier                            {$1->id_type = parameter; $$ = copy($1);}
 ;
 
 statement:  "return" exprs ';'                    {$$ = e(ret, $2, NULL, 0);}
 |           "while" '(' expression ')' statement  {$$ = e(loop, $3, $5, 0);}
 |           ifelse                                {$$ = move($1);}
 |           exprs ';'                             {$$ = move($1);}
 |           "exit" ';'                            {$$ = e(exit_p, ZERO, NULL, 0);}
 |           "exit" expression ';'                 {$$ = e(exit_p, $2, NULL, 0);}
 |           comp_stmt '}'                         {$$ = move($1);}
 |           ';'                                   {$$ = e(nop, NULL, NULL, 1);}
 ;
 
 ;
 
 ifelse:     if_stmt "else" statement %prec "else" {$$ = move($1); append($$, $3);}
 |           if_stmt %prec "if"                    {$$ = move($1);}
 ;
 
 if_stmt:    "if" '(' expression ')' statement     {$$ = e(ifnz, $3, $5, 0);}
 ;
 
 comp_stmt:  '{'                                   {$$ = e(comma, NULL, NULL, 1);}
 |           comp_stmt statement                   {$$ = move($1); append($$, $2);}
 ;
 
 var_defs:   "decl" var_def                        {$$ = move($2);}
 |           var_defs ',' var_def                  {$$ = e(comma, $1, $3, 0);}
 ;
 
 var_def:    identifier                            {curr_decl++; $1->id_type = variable; $$ = e(decl, $1, NULL, 0);}
 |           identifier '=' expression             {curr_decl++; $1->id_type = variable; $$ = e(comma, e(decl, $1, NULL, 0), e(set, $1, $3, 0), 0);}
 ;
 
 identifier: IDENTIFIER                            {$$ = copy(defid($1));}
 ;
 
 exprs:      c_expr                                {$$ = move($1);}
 |           var_defs                              {$$ = move($1);}
 ;
 
 c_expr:     expression                            {$$ = move($1);}
 |           c_expr ',' expression                 {$$ = e(comma, $1, $3, 0);}
 ;
 
 expression: IDENTIFIER                            {$$ = copy(defid($1)); /*$$ = copy(find_idnt($1));*/}
 |           NUMBER                                {$$ = e(number, (void *)$1, NULL, 1);}
 |           str                                   {$$ = e(string, (void *)expand_str($1), NULL, 0);}
 |           expression '[' expression ']'         {$$ = e(deref, e(add, $1, $3, 0), NULL, 0);}
 |           '(' exprs ')'                         {$$ = move($2);}
 |           expression '(' ')'                    {$$ = e(fcall, $1, NULL, 0);}
 |           expression '(' c_expr ')'             {$$ = e(fcall, $1, $3, 0);}
 |           "putc" '(' expression ')'             {$$ = e(printchar, $3, NULL, 0);}
 |           "write" '(' expression ',' expression ',' expression ')' {$$ = e(writestring, e(comma, e(comma, $3, $5, 0), $7, 0), NULL, 0);}
 |           "read" '(' expression ',' expression ',' expression ')' {$$ = e(readstring, e(comma, e(comma, $3, $5, 0), $7, 0), NULL, 0);}
 |           "brk" '(' expression ')'              {$$ = e(brk_sys, $3, NULL, 0);}
 |           "_syscall1" '(' expression ','
                             expression ')'        {$$ = e(_syscall, $3, $5, 0);}
 
 |           "_syscall2" '(' expression ','
                             expression ','
                             expression ')'        {$$ = e(_syscall, $3, e(comma, $5, $7, 0), 0);}
 
 |           "_syscall3" '(' expression ','
                             expression ','
                             expression ','
                             expression ')'        {$$ = e(_syscall, $3, e(comma, e(comma, $5, $7, 0), $9, 0), 0);}
 
 |           "_syscall4" '(' expression ','
                             expression ','
                             expression ','
                             expression ','
                             expression ')'        {$$ = e(_syscall, $3, e(comma, e(comma, e(comma, $5, $7, 0), $9, 0), $11, 0), 0);}
 
 |           "_syscall5" '(' expression ','
                             expression ','
                             expression ','
                             expression ','
                             expression ','
                             expression ')'        {$$ = e(_syscall, $3, e(comma, e(comma, e(comma, e(comma, $5, $7, 0), $9, 0), $11, 0), $13, 0), 0);}
 
 |           "_syscall6" '(' expression ','
                             expression ','
                             expression ','
                             expression ','
                             expression ','
                             expression ','
                             expression ')'        {$$ = e(_syscall, $3, e(comma, e(comma, e(comma, e(comma, e(comma, $5, $7, 0), $9, 0), $11, 0), $13, 0), $15, 0), 0);}
 
 |           expression '+' expression             {$$ = e(add, $1, $3, 0);}
 |           expression '-' expression             {if ($3->type == number) {
                                                      $$ = e(add, $1, $3, 0);
                                                      $$->args[1].i = -$$->args[1].i;
                                                    } else {
                                                      $$ = e(add, $1, e(neg, $3, NULL, 0), 0);
                                                    }}
 |           expression '*' expression             {$$ = e(mul, $1, $3, 0);}
 |           expression '/' expression             {$$ = e(divide, $1, $3, 0);}
 |           expression '%' expression             {$$ = e(mod, $1, $3, 0);}
 |           expression '&' expression             {$$ = e(b_and, $1, $3, 0);}
 |           expression '|' expression             {$$ = e(b_or, $1, $3, 0);}
 |           expression '^' expression             {$$ = e(b_xor, $1, $3, 0);}
 |           expression "<<" expression            {$$ = e(shift_l, $1, $3, 0);}
 |           expression ">>" expression            {$$ = e(shift_r, $1, $3, 0);}
 |           expression '=' expression             {$$ = e(set, $1, $3, 0);}
 |           expression "+=" expression            {$$ = e(set, $1, e(add, $1, $3, 0), 0);}
 |           expression "-=" expression            {if ($3->type == number) {
                                                      $$ = e(add, $1, $3, 0);
                                                      $$->args[1].i = -$$->args[1].i;
                                                      $$ = e(set, $1, $$, 0);
                                                    } else {
                                                      $$ = e(set, $1, e(add, $1, e(neg, $3, NULL, 0), 0), 0);
                                                    }}
 |           expression "*=" expression            {$$ = e(set, $1, e(mul, $1, $3, 0), 0);}
 |           expression "/=" expression            {$$ = e(set, $1, e(divide, $1, $3, 0), 0);}
 |           expression "%=" expression            {$$ = e(set, $1, e(mod, $1, $3, 0), 0);}
 |           expression "&=" expression            {$$ = e(set, $1, e(b_and, $1, $3, 0), 0);}
 |           expression "|=" expression            {$$ = e(set, $1, e(b_or, $1, $3, 0), 0);}
 |           expression "^=" expression            {$$ = e(set, $1, e(b_xor, $1, $3, 0), 0);}
 |           expression "<<=" expression           {$$ = e(set, $1, e(shift_l, $1, $3, 0), 0);}
 |           expression ">>=" expression           {$$ = e(set, $1, e(shift_r, $1, $3, 0), 0);}
 |           expression "==" expression            {$$ = e(l_eq, $1, $3, 0);}
 |           expression "!=" expression            {$$ = e(l_not, e(l_eq, $1, $3, 0), NULL, 0);}
 |           expression '<' expression             {$$ = e(l_lt, $1, $3, 0);}
 |           expression '>' expression             {$$ = e(l_lt, $3, $1, 0);}
 |           expression "<=" expression            {$$ = e(l_not, e(l_lt, $1, $3, 0), NULL, 0);}
 |           expression ">=" expression            {$$ = e(l_not, e(l_lt, $3, $1, 0), NULL, 0);}
 |           expression "&&" expression            {$$ = e(l_and, $1, $3, 0);}
 |           expression "||" expression            {$$ = e(l_or, $1, $3, 0);}
 |           '!' expression                        {$$ = e(l_not, $2, NULL, 0);}
 |           '~' expression                        {printf("uh-oh\n");$$ = NULL;}
 |           '*' expression %prec REF              {$$ = e(deref, $2, NULL, 0);}
 |           '&' expression %prec REF              {$$ = e(ref, $2, NULL, 0);}
 |           '-' expression %prec NEG              {if ($2->type == number) {
                                                      $$ = $2;
                                                      $$->i = -$$->i;
                                                    } else {
                                                      $$ = e(neg, $2, NULL, 0);
                                                    }}
 |           '+' expression %prec NEG              {printf("uh-oh\n");$$ = NULL;}
 |           "++" expression                       {$$ = e(set, $2, e(add, $2, ONE, 0), 0);}
 |           "--" expression                       {$$ = e(set, $2, e(add, $2, e(neg, ONE, NULL, 0), 0), 0);}
 |           expression "++"                       {printf("uh-oh ++\n");$$ = NULL;}
 |           expression "--"                       {printf("uh-oh --\n");$$ = NULL;}
 ;          
 
 str:        str STRING                            {$$ = calloc(strlen($1) + strlen($2) + 1, 1); strcpy($$, $1); strcpy(&$$[strlen($$)], $2); free($1); free($2);}
 |           STRING                                {$$ = $1;}
 ;
 
 %%
 #include <stdio.h>
 #include <fcntl.h>
 
 char *exp_str[] = {
 #define f(e) #e,
 EXPRESSION_TYPES(f)
 #undef f
 };
 
 int has_sideeffect(struct expression *n)
 {
   int i, r = 0;
   switch (n->type) {
   case nop: case number: case idnt: case string:
     return 0;
   case set: case decl: case ret: 
     return 1;
   case brk_sys: case printchar: case writestring:
   case readstring: case _syscall: case exit_p:
     return 2;
   case neg: case l_not: case b_not: case ref: case deref:
     return has_sideeffect(n->args);
   case add: case mul: case divide: case mod: case b_and: case b_or: case b_xor:
   case l_and: case l_or: case l_lt: case l_eq: case shift_l: case shift_r:
   case loop: case comma: case ifnz:
     for (i = 0; i < n->args_count; i++)
       r |= has_sideeffect(&n->args[i]);
     return r;
   default:
     return 1;
   }
 }
 
 void stringify(struct expression *e, int p_indent, int last, char *name, uint64_t idmap)
 {
   int i, indent = p_indent + 3;
   char *str;
   if (last) idmap |= (1 << p_indent/3);
   for (i = 0; i < p_indent; i+=3) fprintf(stderr, "%s  ", (idmap & (1 << (i/3))) ? " " : "│");
   if (p_indent >= 0) fprintf(stderr, "%s- ", last ? "-": "+");
   switch(e->type) {
   case function:
     fprintf(stderr, "%s (", e->args->str);
     if (e->args_count == 3) {
       if (e->args[1].type == comma) {
         for (i = 0; i < e->args[1].args_count; i++)
           fprintf(stderr, "%s%s", e->args[1].args[i].str, i+1 == e->args[1].args_count ? "" : ", ");
       } else {
         fprintf(stderr, "%s", e->args[1].str);
       }
     }
     fprintf(stderr, "):\n");
     stringify(&e->args[e->args_count-1], indent, 1, NULL, idmap);
     break;
   case string:
     str = escape_str(e->str);
     fprintf(stderr, "%s: \"%s\"\n", name ? name : "string", str);
     free(str);
     break;
   case idnt:
     fprintf(stderr, "%s: %s\n", name ? name : "ident", e->str);
     break;
   case number:
     fprintf(stderr, "%s: %li\n", name ? name : "number", e->i);
     break;
   default:
     fprintf(stderr, "%s: (pure: %i)\n", exp_str[e->type], !has_sideeffect(e));
     for (i = 0; i < e->args_count;) {
       stringify(&e->args[i++], indent, i+1 == e->args_count, NULL, idmap);
     }
     break;
   }
 }
 
 void breakpoint(void) {}
 
 struct storage {
   int type;
   char *var;
   char rbp;
   int rev;
 };
 struct reg_history {
   /* 0 - undefined
    * 1 - variable
    * 2 - constant */
   int type;
   int reg;
   int val;
   int rev;
 };
 
 struct storage regs[1024];
 struct reg_history reg_hist[16];
 const int registers = 16;
 int next_reg;
 uint16_t used_regs;
 int next_rbp;
 
 char machine_code[16384] = { 0 };
 int mc_ptr = 0;
 char rodata[8192] = { 0 };
 int rd_ptr = 0;
 int entry_addr = -1;
 long start_addr, rodata_addr;
 int func_declares;
 
 int arg_order[16] = {7, 6, 2, 1, 8, 9, 1, 0, 11, 12, 13, 14, 15, 3, 5};
 int syscall_arg[16] = {7, 6, 2, 10, 8, 9, -1, -1, -1, -1, -1, -1, -1, -1, -1};
 //int caller_save = 0b0000111111001111;
 int caller_save = 0b1111111111001111;
 
 int get_free_reg(int mark_used)
 {
   int i;
   for (i = 0; i < registers; i++) {
     if (!(used_regs & (1 << i))) {
       if (mark_used) used_regs |= (1 << i);
       return i;
       break;
     }
   }
   fprintf(stderr, "Out of registers?!? fix me\n");
   exit(1);
 }
 
 void push(int reg, int *pushed, char *order, char *from) {
   int i;
   if (used_regs & (1 << reg)) {
     machine_code[mc_ptr++] = 0x48 | (reg > 7 ? 1 : 0);
     machine_code[mc_ptr++] = 0x50 + (reg % 8);
     for (i = 0; i < registers; i++) {
       if (order[i] == -1) {
         order[i] = reg;
         used_regs &= ~(1 << reg);
         *pushed |= (1 << reg);
         next_rbp += 8;
         return;
       }
     }
     fprintf(stderr, "Unable to push any more registers\n");
     exit(1);
   }
 }
 
 void pop(int reg, int *pushed) {
   if (!(*pushed & (1 << reg))) {
     fprintf(stderr, "Trying to pop a register which hasn't been pushed\n");
     exit(1);
   }
   machine_code[mc_ptr++] = 0x48 | (reg > 7 ? 1 : 0);
   machine_code[mc_ptr++] = 0x58 + (reg % 8);
   *pushed &= ~(1 << reg);
   used_regs |= (1 << reg);
   next_rbp -= 8;
   reg_hist[reg].type = 0;
 }
 
 struct func_template {
   char *fname;
   int fptr;
 };
 
 struct func_template *ftemp;
 int ftemp_len = 0;
 
 void func_append(char *fname, int ptr)
 {
   int i, j;
   for (i = 0; i < ftemp_len; i++)
     if (!strcmp(ftemp[i].fname, fname)) break;
   if (i == ftemp_len) {
     ftemp = realloc(ftemp, sizeof(struct func_template) * ++ftemp_len);
     ftemp[i].fname = malloc(strlen(fname) + 1);
     strcpy(ftemp[i].fname, fname);
     ftemp[i].fptr = 0;
   }
   if (!ftemp[i].fptr) {
     ftemp[i].fptr = ptr;
   } else {
     for (j = ftemp[i].fptr; *((int *) &machine_code[j]); j = *((int *) &machine_code[j]));
     *((int *) &machine_code[j]) = ptr;
   }
 }
 
 void func_retrofit(char *fname, int ptr)
 {
   int i, j, k;
   for (i = 0; i < ftemp_len; i++)
     if (!strcmp(ftemp[i].fname, fname)) break;
   if (i == ftemp_len) return;
 
   for (j = ftemp[i].fptr, k = 1; k; j = k) {
     k = *((int *) &machine_code[j]);
     *((int *) &machine_code[j]) = ptr - j - 4;
   }
   ftemp[i].fptr = 0;
 }
 
 int compile_tree(FILE *output, struct expression *tree, int discard_result, int out_reg)
 {
   int i, j, k, l, reg = -1;
   char push_order[16] = { -1, -1, -1, -1,
                           -1, -1, -1, -1,
                           -1, -1, -1, -1,
                           -1, -1, -1, -1 };
   int pushed = 0;
   struct expression *tmp;
   switch (tree->type) {
   case function:
     next_reg = registers;
     used_regs = (1 << 5) | (1 << 4);
     next_rbp = 8;
     tree->i = mc_ptr;
     find_idnt(tree->args->str)->i = mc_ptr + start_addr;
     find_idnt(tree->args->str)->flags |= 1;
     func_retrofit(tree->args->str, mc_ptr);
     memset(reg_hist, 0, sizeof(reg_hist));
     if (!strcmp(tree->args->str, "_start")) {
       entry_addr = mc_ptr;
       machine_code[mc_ptr++] = 0x55;
       machine_code[mc_ptr++] = 0x48;
       machine_code[mc_ptr++] = 0x89;
       machine_code[mc_ptr++] = 0xE5;
 
       if (tree->declares) {
         machine_code[mc_ptr++] = 0x48;
         machine_code[mc_ptr++] = 0x81;
         machine_code[mc_ptr++] = 0xEC;
         *(int *) &machine_code[mc_ptr] = tree->declares*8;
         mc_ptr += 4;
       }
     } else {
       if (tree->args[1].type == idnt && tree->args[1].id_type == parameter) {
         tree->declares++;
         regs[next_reg].type = 1;
         regs[next_reg].var = tree->args[1].str;
         regs[next_reg].rbp = next_rbp;
         next_rbp += 8;
         next_reg++;
       } else if (tree->args[1].type == comma && tree->args[1].args->type == idnt && tree->args[1].args->id_type == parameter) {
         for (i = 0; i < tree->args[1].args_count; i++) {
           tree->declares++;
           regs[next_reg].type = 1;
           regs[next_reg].var = tree->args[1].args[i].str;
           regs[next_reg].rbp = next_rbp;
           next_rbp += 8;
           next_reg++;
         }
       }
       func_declares = tree->declares;
       machine_code[mc_ptr++] = 0x55;
       machine_code[mc_ptr++] = 0x48;
       machine_code[mc_ptr++] = 0x89;
       machine_code[mc_ptr++] = 0xE5;
 
       if (tree->declares) {
         machine_code[mc_ptr++] = 0x48;
         machine_code[mc_ptr++] = 0x81;
         machine_code[mc_ptr++] = 0xEC;
         *(int *) &machine_code[mc_ptr] = tree->declares*8;
         mc_ptr += 4;
       }
 
       if (tree->args[1].type == idnt && tree->args[1].id_type == parameter) {
         machine_code[mc_ptr++] = 0x48 | (arg_order[0] > 7 ? 4 : 0);
         machine_code[mc_ptr++] = 0x89;
         machine_code[mc_ptr++] = 0x45 + (arg_order[0] % 8) * 8;
         machine_code[mc_ptr++] = -regs[registers].rbp;
         reg_hist[arg_order[0]].type = 1;
         reg_hist[arg_order[0]].reg = registers;
         reg_hist[arg_order[0]].rev = ++regs[registers].rev;
       } else if (tree->args[1].type == comma && tree->args[1].args->type == idnt && tree->args[1].args->id_type == parameter) {
         for (i = 0; i < tree->args[1].args_count; i++) {
           machine_code[mc_ptr++] = 0x48 | (arg_order[i] > 7 ? 4 : 0);
           machine_code[mc_ptr++] = 0x89;
           machine_code[mc_ptr++] = 0x45 + (arg_order[i] % 8) * 8;
           machine_code[mc_ptr++] = -regs[registers + i].rbp;
           reg_hist[arg_order[i]].type = 1;
           reg_hist[arg_order[i]].reg = registers + i;
           reg_hist[arg_order[i]].rev = ++regs[registers + i].rev;
         }
       }
     }
     j = compile_tree(output, &tree->args[tree->args_count-1], 1, 0);
     if (strcmp(tree->args->str, "_start") && j != -3 && j != -2) {
       machine_code[mc_ptr++] = 0xc9;
       machine_code[mc_ptr++] = 0xc3;
     }
     break;
   case comma:
     for (i = 0; i < tree->args_count; i++) {
       j = compile_tree(output, &tree->args[i], (i+1 == tree->args_count ? discard_result : 1), (i+1 == tree->args_count ? out_reg : -1));
       if (j == -2 || j == -3) return j;
     }
     if (!discard_result) reg = j;
     break;
   case fcall:
     for (i = 0; i < registers; i++) {
       if (caller_save & (1 << i)) {
         push(i, &pushed, push_order, "fcall (caller_save)");
       }
     }
     if (tree->args_count == 2) {
       if (tree->args[1].type == comma) {
         for (i = 0; i < tree->args[1].args_count; i++) {
           j = compile_tree(output, &tree->args[1].args[i], 0, arg_order[i]);
         }
       } else {
         j = compile_tree(output, &tree->args[1], 0, arg_order[0]);
       }
     }
     machine_code[mc_ptr++] = 0xe8;
     if (find_idnt(tree->args->str)->flags & 1) {
       j = find_idnt(tree->args->str)->i - start_addr - mc_ptr - 4;
     } else {
       func_append(tree->args->str, mc_ptr);
       j = 0;
     }
     *(int32_t *) &machine_code[mc_ptr] = j;
     mc_ptr += 4;
 
     if (tree->args[1].type == comma)
       for (i = 0; i < tree->args[1].args_count; i++)
         used_regs &= ~(1 << arg_order[i]);
     else
       used_regs &= ~(1 << arg_order[0]);
 
     memset(reg_hist, 0, sizeof(reg_hist));
     if (!discard_result) {
       reg = 0;
       used_regs |= !(pushed & 1);
     }
     break;
   case add:
     if (!discard_result &&
         (tree->args->type == idnt || tree->args[1].type == idnt)) {
       if (tree->args->type == idnt) {
         j = compile_tree(output, tree->args, discard_result, -1);
         tmp = &tree->args[1];
       } else {
         j = compile_tree(output, &tree->args[1], discard_result, -1);
         tmp = tree->args;
       }
       if (j == out_reg && tmp->type == number &&
           tmp->i < (long) 0x80000000 && tmp->i >= (long) -0x80000000) {
         reg = j;
         k = (int) tmp->i;
         machine_code[mc_ptr++] = 0x48;
         machine_code[mc_ptr++] = 0x81;
         machine_code[mc_ptr++] = 0x45;
         *(int32_t *) &machine_code[mc_ptr] = k;
         mc_ptr += 4;
         break;
       }
     } else {
       j = compile_tree(output, tree->args, discard_result, -1);
     }
     k = compile_tree(output, &tree->args[1], discard_result, -1);
     if (discard_result) {
       if (j >= 0 && j < registers) used_regs &= ~(1 << j);
       if (k >= 0 && k < registers) used_regs &= ~(1 << k);
       break;
     }
     if (out_reg < 0 || out_reg != j && out_reg != k) {
       if (k >= registers) {
         if (j >= registers) {
             reg = out_reg;
           if (out_reg < 0 || out_reg >= registers)
             reg = get_free_reg(1);
           machine_code[mc_ptr++] = 0x48 | (reg > 7 ? 4 : 0);
           machine_code[mc_ptr++] = 0x8b;
           machine_code[mc_ptr++] = 0x45 + (reg % 8) * 8;
           machine_code[mc_ptr++] = -regs[j].rbp;
           j = reg;
         }
         machine_code[mc_ptr++] = 0x48 | (j > 7 ? 4 : 0);
         machine_code[mc_ptr++] = 0x03;
         machine_code[mc_ptr++] = 0x45 + (j % 8) * 8;
         machine_code[mc_ptr++] = -regs[k].rbp;
         reg = j, l = k;
       } else if (j >= registers) {
         machine_code[mc_ptr++] = 0x48 | (k > 7 ? 4 : 0);
         machine_code[mc_ptr++] = 0x03;
         machine_code[mc_ptr++] = 0x45 + (k % 8) * 8;
         machine_code[mc_ptr++] = -regs[j].rbp;
         reg = k, l = j;
       } else {
         machine_code[mc_ptr++] = 0x48 | (j > 7 ? 4 : 0) | (k > 7 ? 1 : 0);
         machine_code[mc_ptr++] = 0x03;
         machine_code[mc_ptr++] = 0xC0 + (j % 8) * 8 + (k % 8);
         reg = j, l = k;
       }
     } else {
       if (out_reg == k) {
         l = j;
         j = k;
         k = l;
       }
       if (j >= registers) {
         if (k >= registers) {
           reg = get_free_reg(1);
           machine_code[mc_ptr++] = 0x48 | (reg > 7 ? 4 : 0);
           machine_code[mc_ptr++] = 0x8b;
           machine_code[mc_ptr++] = 0x45 + (reg % 8) * 8;
           machine_code[mc_ptr++] = -regs[k].rbp;
           k = reg;
         }
         machine_code[mc_ptr++] = 0x48 | (k > 7 ? 4 : 0);
         machine_code[mc_ptr++] = 0x01;
         machine_code[mc_ptr++] = 0x45 + (k % 8) * 8;
         machine_code[mc_ptr++] = -regs[j].rbp;
       } else if (k >= registers) {
         machine_code[mc_ptr++] = 0x48 | (j > 7 ? 4 : 0);
         machine_code[mc_ptr++] = 0x03;
         machine_code[mc_ptr++] = 0x45 + (j % 8) * 8;
         machine_code[mc_ptr++] = -regs[k].rbp;
       } else {
         machine_code[mc_ptr++] = 0x48 | (j > 7 ? 4 : 0) | (k > 7 ? 1 : 0);
         machine_code[mc_ptr++] = 0x03;
         machine_code[mc_ptr++] = 0xC0 + (j % 8) * 8 + (k % 8);
         if (reg_hist[j].type & 2 && reg_hist[k].type & 2) {
           reg_hist[j].type = 2;
           reg_hist[j].val += reg_hist[k].val;
         } else if (reg_hist[j].type & 2) {
           reg_hist[j].type = 0;
         }
       }
       reg = j, l = k;
     }
     if (l < registers) used_regs &= ~(1 << l);
     break;
   case neg:
     j = compile_tree(output, tree->args, discard_result, (out_reg >= 0 ? out_reg : get_free_reg(1)));
     if (discard_result) {
       if (j < registers) used_regs &= ~(1 << j);
       break;
     }
     reg = j;
     if (reg >= registers) {
       machine_code[mc_ptr++] = 0x48;
       machine_code[mc_ptr++] = 0xf7;
       machine_code[mc_ptr++] = 0x5d;
       machine_code[mc_ptr++] = -regs[reg].rbp;
     } else {
       machine_code[mc_ptr++] = 0x48 | (reg > 7 ? 1 : 0);
       machine_code[mc_ptr++] = 0xf7;
       machine_code[mc_ptr++] = 0xd8 + (reg % 8);
     }
     break;
   case mul:
     j = compile_tree(output, tree->args, discard_result, -1);
     k = compile_tree(output, &tree->args[1], discard_result, -1);
     if (discard_result) {
       if (j < registers) used_regs &= ~(1 << j);
       if (k < registers) used_regs &= ~(1 << k);
       break;
     }
     if (out_reg < 0 || out_reg != j && out_reg != k) {
       if (k >= registers) {
         if (j >= registers) {
             reg = out_reg;
           if (out_reg < 0 || out_reg >= registers)
             reg = get_free_reg(1);
           machine_code[mc_ptr++] = 0x48 | (reg > 7 ? 4 : 0);
           machine_code[mc_ptr++] = 0x8b;
           machine_code[mc_ptr++] = 0x45 + (reg % 8) * 8;
           machine_code[mc_ptr++] = -regs[j].rbp;
           j = reg;
         }
         machine_code[mc_ptr++] = 0x48 | (j > 7 ? 4 : 0);
         machine_code[mc_ptr++] = 0x0F;
         machine_code[mc_ptr++] = 0xAF;
         machine_code[mc_ptr++] = 0x45 + (j % 8) * 8;
         machine_code[mc_ptr++] = -regs[k].rbp;
         reg = j, l = k;
       } else if (j >= registers) {
         machine_code[mc_ptr++] = 0x48 | (k > 7 ? 4 : 0);
         machine_code[mc_ptr++] = 0x0F;
         machine_code[mc_ptr++] = 0xAF;
         machine_code[mc_ptr++] = 0x45 + (k % 8) * 8;
         machine_code[mc_ptr++] = -regs[j].rbp;
         reg = k, l = j;
       } else {
         machine_code[mc_ptr++] = 0x48 | (j > 7 ? 4 : 0) | (k > 7 ? 1 : 0);
         machine_code[mc_ptr++] = 0x0F;
         machine_code[mc_ptr++] = 0xAF;
         machine_code[mc_ptr++] = 0xC0 + (j % 8) * 8 + (k % 8);
         reg = j, l = k;
       }
     } else {
       if (out_reg == k) {
         l = j;
         j = k;
         k = l;
       }
       if (j >= registers) {
         reg = get_free_reg(1);
         machine_code[mc_ptr++] = 0x48 | (reg > 7 ? 4 : 0);
         machine_code[mc_ptr++] = 0x8b;
         machine_code[mc_ptr++] = 0x45 + (reg % 8) * 8;
         machine_code[mc_ptr++] = -regs[j].rbp;
         j = reg;
         if (k >= registers) {
           machine_code[mc_ptr++] = 0x48 | (j > 7 ? 4 : 0);
           machine_code[mc_ptr++] = 0x0F;
           machine_code[mc_ptr++] = 0xAF;
           machine_code[mc_ptr++] = 0x45 + (j % 8) * 8;
           machine_code[mc_ptr++] = -regs[k].rbp;
         } else {
           machine_code[mc_ptr++] = 0x48 | (j > 7 ? 4 : 0) | (k > 7 ? 1 : 0);
           machine_code[mc_ptr++] = 0x0F;
           machine_code[mc_ptr++] = 0xAF;
           machine_code[mc_ptr++] = 0xC0 + (j % 8) * 8 + (k % 8);
           //machine_code[mc_ptr++] = -regs[j].rbp;
         }
       } else if (k >= registers) {
         machine_code[mc_ptr++] = 0x48 | (j > 7 ? 4 : 0);
         machine_code[mc_ptr++] = 0x0F;
         machine_code[mc_ptr++] = 0xAF;
         machine_code[mc_ptr++] = 0x45 + (j % 8) * 8;
         machine_code[mc_ptr++] = -regs[k].rbp;
       } else {
         machine_code[mc_ptr++] = 0x48 | (j > 7 ? 4 : 0) | (k > 7 ? 1 : 0);
         machine_code[mc_ptr++] = 0x0F;
         machine_code[mc_ptr++] = 0xAF;
         machine_code[mc_ptr++] = 0xC0 + (j % 8) * 8 + (k % 8);
         if (reg_hist[j].type & 2 && reg_hist[k].type & 2) {
           reg_hist[j].type = 2;
           reg_hist[j].val += reg_hist[k].val;
         } else if (reg_hist[j].type & 2) {
           reg_hist[j].type = 0;
         }
       }
       reg = j, l = k;
     }
     if (l < registers) used_regs &= ~(1 << l);
     break;
     /*
     j = compile_tree(output, tree->args, discard_result, -1);
     k = compile_tree(output, &tree->args[1], discard_result, -1);
     if (discard_result) {
       if (j < registers) used_regs &= ~(1 << j);
       if (k < registers) used_regs &= ~(1 << k);
       break;
     }
     reg = j;
     if ((out_reg == -1 || out_reg >= registers) && j >= registers) {
       reg = get_free_reg(1);
       if (j >= registers) {
         machine_code[mc_ptr++] = 0x48 | (reg > 7 ? 4 : 0);
         machine_code[mc_ptr++] = 0x8b;
         machine_code[mc_ptr++] = 0x45 + reg*8;
         machine_code[mc_ptr++] = -regs[j].rbp;
       } else {
         machine_code[mc_ptr++] = 0x48 | (reg > 7 ? 4 : 0);
         machine_code[mc_ptr++] = 0x8b;
         machine_code[mc_ptr++] = 0x45 + reg*8;
       }
     }
 
     machine_code[mc_ptr++] = 0x48 | (reg > 7 ? 4 : 0);
     machine_code[mc_ptr++] = 0x0F;
     machine_code[mc_ptr++] = 0xAF;
     if (k >= registers) {
       machine_code[mc_ptr++] = 0x45 + (reg % 8) * 8;
       machine_code[mc_ptr++] = -regs[k].rbp;
     } else {
       machine_code[mc_ptr-3] |= (k > 7 ? 1 : 0);
       machine_code[mc_ptr++] = 0xC0 + (reg % 8) * 8 + (k % 8);
       used_regs &= ~(1 << k);
     }
     break;
     */
   case divide:
     if (discard_result) {
       j = compile_tree(output, tree->args, 1, -1);
       k = compile_tree(output, &tree->args[1], 1, -1);
       if (j < registers) used_regs &= ~(1 << j);
       break;
     }
     push(0, &pushed, push_order, "divide (rax)");
     push(2, &pushed, push_order, "divide (rdx)");
     j = compile_tree(output, tree->args, 0, 0);
     machine_code[mc_ptr++] = 0x48;
     machine_code[mc_ptr++] = 0x99;
     used_regs |= (1 << 0) | (1 << 2);
 
     k = compile_tree(output, &tree->args[1], 0, -1);
     machine_code[mc_ptr++] = 0x48;
     machine_code[mc_ptr++] = 0xF7;
     if (k >= registers) {
       machine_code[mc_ptr++] = 0x7d;
       machine_code[mc_ptr++] = -regs[k].rbp;
     } else {
       machine_code[mc_ptr-2] |= (k > 7 ? 1 : 0);
       machine_code[mc_ptr++] = 0xf8 + (k % 8);
       used_regs &= ~(1 << k);
     }
     reg = 0;
     break;
   case mod:
     if (discard_result) {
       j = compile_tree(output, tree->args, 1, -1);
       k = compile_tree(output, &tree->args[1], 1, -1);
       if (j < registers) used_regs &= ~(1 << j);
       break;
     }
     push(0, &pushed, push_order, "mod (rax)");
     push(2, &pushed, push_order, "mod (rdx)");
     j = compile_tree(output, tree->args, 0, 0);
     machine_code[mc_ptr++] = 0x48;
     machine_code[mc_ptr++] = 0x99;
     used_regs |= (1 << 0) | (1 << 2);
 
     k = compile_tree(output, &tree->args[1], 0, -1);
     machine_code[mc_ptr++] = 0x48;
     machine_code[mc_ptr++] = 0xF7;
     if (k >= registers) {
       machine_code[mc_ptr++] = 0x7d;
       machine_code[mc_ptr++] = -regs[k].rbp;
     } else {
       machine_code[mc_ptr-2] |= (k > 7 ? 1 : 0);
       machine_code[mc_ptr++] = 0xf8 + (k % 8);
       used_regs &= ~(1 << k);
     }
     reg = 2;
     break;
   case shift_l:
     j = compile_tree(output, tree->args, discard_result, out_reg);
     k = compile_tree(output, &tree->args[1], discard_result, 1);
     if (discard_result) {
       if (j < registers) used_regs &= ~(1 << j);
       if (k < registers) used_regs &= ~(1 << k);
       break;
     }
     if (k != 1) {
       if (used_regs & (1 << 1)) {
         fprintf(stderr, "Not implemented yet! (rcx)\n");
         exit(1);
       }
       used_regs |= (1 << 1);
       if (k >= registers) {
         machine_code[mc_ptr++] = 0x48;
         machine_code[mc_ptr++] = 0x8b;
         machine_code[mc_ptr++] = 0x4d;
         machine_code[mc_ptr++] = -regs[k].rbp;
       } else {
         machine_code[mc_ptr++] = 0x48 | (k > 7 ? 1 : 0);
         machine_code[mc_ptr++] = 0x8b;
         machine_code[mc_ptr++] = 0xc8 + (k % 8);
         used_regs &= ~(1 << k);
       }
       k = 1;
     }
     reg = j;
     if (reg >= registers) {
       reg = get_free_reg(1);
       machine_code[mc_ptr++] = 0x48;
       machine_code[mc_ptr++] = 0x8b;
       machine_code[mc_ptr++] = 0x45 + reg*8;
       machine_code[mc_ptr++] = -regs[j].rbp;
     }
     machine_code[mc_ptr++] = 0x48;
     machine_code[mc_ptr++] = 0xd3;
     machine_code[mc_ptr++] = 0xe0 + reg;
 
     if (k < registers) used_regs &= ~(1 << k);
     break;
   case shift_r:
     j = compile_tree(output, tree->args, discard_result, out_reg);
     k = compile_tree(output, &tree->args[1], discard_result, 1);
     if (discard_result) {
       if (j < registers) used_regs &= ~(1 << j);
       if (k < registers) used_regs &= ~(1 << k);
       break;
     }
     if (k != 1) {
       if (used_regs & (1 << 1)) {
         fprintf(stderr, "Not implemented yet! (rcx)\n");
         exit(1);
       }
       used_regs |= (1 << 1);
       if (k >= registers) {
         machine_code[mc_ptr++] = 0x48;
         machine_code[mc_ptr++] = 0x8b;
         machine_code[mc_ptr++] = 0x4d;
         machine_code[mc_ptr++] = -regs[k].rbp;
       } else {
         machine_code[mc_ptr++] = 0x48 | (k > 7 ? 1 : 0);
         machine_code[mc_ptr++] = 0x8b;
         machine_code[mc_ptr++] = 0xc8 + (k % 8);
         used_regs &= ~(1 << k);
       }
       k = 1;
     }
     reg = j;
     if (reg >= registers) {
       reg = get_free_reg(1);
       machine_code[mc_ptr++] = 0x48;
       machine_code[mc_ptr++] = 0x8b;
       machine_code[mc_ptr++] = 0x45 + reg*8;
       machine_code[mc_ptr++] = -regs[j].rbp;
     }
     machine_code[mc_ptr++] = 0x48;
     machine_code[mc_ptr++] = 0xd3;
     machine_code[mc_ptr++] = 0xe8 + reg;
 
     if (k < registers) used_regs &= ~(1 << k);
     break;
   case b_and:
     j = compile_tree(output, tree->args, discard_result, out_reg);
     k = compile_tree(output, &tree->args[1], discard_result, -1);
     if (discard_result) {
       if (j < registers) used_regs &= ~(1 << j);
       if (k < registers) used_regs &= ~(1 << k);
       break;
     }
     reg = j;
     if (reg >= registers) {
       reg = get_free_reg(1);
       machine_code[mc_ptr++] = 0x48 | (reg > 7 ? 4 : 0);
       machine_code[mc_ptr++] = 0x8b;
       machine_code[mc_ptr++] = 0x45 + (reg % 8) * 8;
       machine_code[mc_ptr++] = -regs[j].rbp;
     }
     machine_code[mc_ptr++] = 0x48 | (reg > 7 ? 4 : 0);
     machine_code[mc_ptr++] = 0x23;
     if (tree->args[1].type == idnt) {
       machine_code[mc_ptr++] = 0x45 + (reg % 8) * 8;
       machine_code[mc_ptr++] = -regs[k].rbp;
     } else {
       machine_code[mc_ptr-2] |= k > 7 ? 1 : 0;
       machine_code[mc_ptr++] = 0xC0 + (reg % 8) * 8 + (k % 8);
     }
     if (k < registers) used_regs &= ~(1 << k);
     break;
   case b_or:
     j = compile_tree(output, tree->args, discard_result, out_reg);
     k = compile_tree(output, &tree->args[1], discard_result, -1);
     if (discard_result) {
       if (j < registers) used_regs &= ~(1 << j);
       if (k < registers) used_regs &= ~(1 << k);
       break;
     }
     reg = j;
     if (reg >= registers) {
       reg = get_free_reg(1);
       machine_code[mc_ptr++] = 0x48 | (reg > 7 ? 4 : 0);
       machine_code[mc_ptr++] = 0x8b;
       machine_code[mc_ptr++] = 0x45 + (reg % 8) * 8;
       machine_code[mc_ptr++] = -regs[j].rbp;
     }
     machine_code[mc_ptr++] = 0x48 | (reg > 7 ? 4 : 0);
     machine_code[mc_ptr++] = 0x0b;
     if (tree->args[1].type == idnt) {
       machine_code[mc_ptr++] = 0x45 + (reg % 8) * 8;
       machine_code[mc_ptr++] = -regs[k].rbp;
     } else {
       machine_code[mc_ptr-2] |= k > 7 ? 1 : 0;
       machine_code[mc_ptr++] = 0xC0 + (reg % 8) * 8 + (k % 8);
     }
     if (k < registers) used_regs &= ~(1 << k);
     break;
   case b_xor:
     j = compile_tree(output, tree->args, discard_result, out_reg);
     k = compile_tree(output, &tree->args[1], discard_result, -1);
     if (discard_result) {
       if (j < registers) used_regs &= ~(1 << j);
       if (k < registers) used_regs &= ~(1 << k);
       break;
     }
     reg = j;
     if (reg >= registers) {
       reg = get_free_reg(1);
       machine_code[mc_ptr++] = 0x48 | (reg > 7 ? 4 : 0);
       machine_code[mc_ptr++] = 0x8b;
       machine_code[mc_ptr++] = 0x45 + (reg % 8) * 8;
       machine_code[mc_ptr++] = -regs[j].rbp;
     }
     machine_code[mc_ptr++] = 0x48 | (reg > 7 ? 4 : 0);
     machine_code[mc_ptr++] = 0x33;
     if (tree->args[1].type == idnt) {
       machine_code[mc_ptr++] = 0x45 + (reg % 8) * 8;
       machine_code[mc_ptr++] = -regs[k].rbp;
     } else {
       machine_code[mc_ptr-2] |= k > 7 ? 1 : 0;
       machine_code[mc_ptr++] = 0xC0 + (reg % 8) * 8 + (k % 8);
     }
     if (k < registers) used_regs &= ~(1 << k);
     break;
   case decl:
     reg = next_reg++;
     regs[reg].type = 1;
     regs[reg].rbp = next_rbp;
     next_rbp += 8;
     regs[reg].var = tree->args->str;
     break;
   case set:
     /*
     reg = compile_tree(output, tree->args, 0, -1);
     j = compile_tree(output, &tree->args[1], 0, reg);
     break;
   case set:
   */
     if (tree->args->type == deref)
       reg = compile_tree(output, tree->args->args, 0, -1);
     else
       reg = compile_tree(output, tree->args, 0, -1);
     if (reg >= registers && tree->args->type != deref) {
       j = compile_tree(output, &tree->args[1], 0, reg);
       break;
     }
     j = compile_tree(output, &tree->args[1], 0, -1);
     if (j < 0) {
       fprintf(stderr, "No rvalue for assignment\n");
       exit(1);
     }
     if (j >= registers) {
       k = get_free_reg(1);
       machine_code[mc_ptr++] = 0x48 | (k > 7 ? 4 : 0);
       machine_code[mc_ptr++] = 0x8b;
       machine_code[mc_ptr++] = 0x45 + (k % 8) * 8;
       machine_code[mc_ptr++] = -regs[j].rbp;
     } else {
       k = j;
     }
     if (tree->args->type == deref) {
       if (reg >= registers) {
         j = get_free_reg(1);
         machine_code[mc_ptr++] = 0x48 | (j > 7 ? 4 : 0);
         machine_code[mc_ptr++] = 0x8b;
         machine_code[mc_ptr++] = 0x45 + (j % 8) * 8;
         machine_code[mc_ptr++] = -regs[reg].rbp;
         reg = j;
       }
       machine_code[mc_ptr++] = 0x48 | (reg > 7 ? 1 : 0) | (k > 7 ? 4 : 0);
       machine_code[mc_ptr++] = 0x89;
       machine_code[mc_ptr++] = 0x00 + (reg % 8) + (k % 8) * 8;
     } else if (reg >= registers) {
       machine_code[mc_ptr++] = 0x48 | (k > 7 ? 4 : 0);
       machine_code[mc_ptr++] = 0x89;
       machine_code[mc_ptr++] = 0x45 + (k % 8) * 8;
       machine_code[mc_ptr++] = -regs[reg].rbp;
     }
     if (discard_result) {
       used_regs &= ~(1 << k);
       used_regs &= ~(1 << reg);
       reg = -1;
       break;
     }
     reg = k;
     break;
   case ref:
     if (tree->args->type != idnt) {
       fprintf(stderr, "Unable to reference non-identifier\n");
       exit(1);
     }
     if (discard_result) break;
     j = compile_tree(output, tree->args, 0, -1);
     reg = out_reg;
     if (out_reg < 0 || out_reg >= registers)
       reg = get_free_reg(1);
     used_regs |= (1 << reg);
     machine_code[mc_ptr++] = 0x48 | (reg > 7 ? 4 : 0);
     machine_code[mc_ptr++] = 0x8d;
     machine_code[mc_ptr++] = 0x45 + (reg % 8) * 8;
     machine_code[mc_ptr++] = -regs[j].rbp;
     break;
   case deref:
     j = compile_tree(output, tree->args, discard_result, out_reg);
     if (discard_result) {
       if (used_regs & (1 << j)) used_regs &= ~(1 << j);
       break;
     }
     reg = j;
     if (j >= registers) {
       reg = get_free_reg(1);
       machine_code[mc_ptr++] = 0x48 | (reg > 7 ? 4 : 0);
       machine_code[mc_ptr++] = 0x8b;
       machine_code[mc_ptr++] = 0x45 + (reg % 8) * 8;
       machine_code[mc_ptr++] = -regs[j].rbp;
     }
     machine_code[mc_ptr++] = 0x48 | (reg > 7 ? 5 : 0);
     machine_code[mc_ptr++] = 0x8b;
     machine_code[mc_ptr++] = 0x00 + (reg % 8) + (reg % 8) * 8;
     break;
   case idnt:
     if (discard_result) break;
     for (reg = registers; reg < 1024; reg++) {
       if (regs[reg].type != 1) continue;
       if (!strcmp(regs[reg].var, tree->str)) break;
     }
     if (reg == 1024) {
       fprintf(stderr, "Unable to locate identifier <%s>\n", tree->str);
       exit(1);
     }
     /*
     for (i = 0; i < registers; i++) {
       if (reg_hist[i].type & 1 && reg_hist[i].reg == reg && reg_hist[i].rev == regs[reg].rev) {
         reg = i;
         used_regs |= (1 << reg);
         break;
       }
     }
     */
     break;
   case number:
     if (discard_result) break;
     /*
     for (i = 0; i < registers; i++) {
       if (reg_hist[i].type & 2 && reg_hist[i].val == tree->i) {
         reg = i;
         break;
       }
     }
     */
     if (out_reg < 0 || out_reg >= registers)
       reg = get_free_reg(1);
     else
       reg = out_reg;
     if (tree->i) {
       if (tree->i == 1) {
         if (reg > 7)
           machine_code[mc_ptr++] = 0x41;
         machine_code[mc_ptr++] = 0x33;
         machine_code[mc_ptr++] = 0xc0 + (reg % 8) + (reg % 8) * 8;
         if (reg > 7)
           machine_code[mc_ptr++] = 0x41;
         machine_code[mc_ptr++] = 0xff;
         machine_code[mc_ptr++] = 0xc0 + (reg % 8);
       } else if (tree->i == -1) {
         if (reg > 7)
           machine_code[mc_ptr++] = 0x41;
         machine_code[mc_ptr++] = 0x33;
         machine_code[mc_ptr++] = 0xc0 + (reg % 8) + (reg % 8) * 8;
 
         machine_code[mc_ptr++] = 0x48 | (reg > 7 ? 1 : 0);
         machine_code[mc_ptr++] = 0xff;
         machine_code[mc_ptr++] = 0xc8 + (reg % 8);
       } else if (tree->i <= 0x7FFFFFFF && tree->i > 0) {
         if (reg > 7)
           machine_code[mc_ptr++] = 0x41;
         machine_code[mc_ptr++] = 0xb8 + (reg % 8);
         *(int32_t *) &machine_code[mc_ptr] = (int) tree->i;
         mc_ptr += 4;
       } else if (tree->i < 0 && -tree->i <= 0x7FFFFFFF) {
         machine_code[mc_ptr++] = 0x48 | (reg > 7 ? 1 : 0);
         machine_code[mc_ptr++] = 0xc7;
         machine_code[mc_ptr++] = 0xc0 + (reg % 8);
         *(int32_t *) &machine_code[mc_ptr] = (int) tree->i;
         mc_ptr += 4;
       } else {
         machine_code[mc_ptr++] = 0x48 | (reg > 7 ? 1 : 0);
         machine_code[mc_ptr++] = 0xb8 + (reg % 8);
         *(int64_t *) &machine_code[mc_ptr] = tree->i;
         mc_ptr += 8;
       }
     } else {
       if (reg > 7)
         machine_code[mc_ptr++] = 0x45;
       machine_code[mc_ptr++] = 0x33;
       machine_code[mc_ptr++] = 0xc0 + (reg % 8) + (reg % 8) * 8;
     }
     reg_hist[reg].type = 2;
     reg_hist[reg].val = tree->i;
     break;
   case string:
     if (discard_result) break;
     reg = out_reg;
     if (reg == -1 || reg >= registers)
       reg = get_free_reg(1);
     if (!tree->i) {
       strcpy(&rodata[rd_ptr], tree->str);
       tree->i = rodata_addr + rd_ptr;
       rd_ptr += strlen(tree->str) + 1;
     }
     machine_code[mc_ptr++] = 0x48 | (reg > 7 ? 1 : 0);
     machine_code[mc_ptr++] = 0xb8 + (reg % 8);
     *(int64_t *) &machine_code[mc_ptr] = tree->i;
     mc_ptr += 8;
     break;
   case loop:
     memset(reg_hist, 0, sizeof(reg_hist));
     machine_code[mc_ptr++] = 0xe9;
     l = mc_ptr;
     mc_ptr += 4;
     compile_tree(output, &tree->args[1], 1, -1);
     *(int32_t *) &machine_code[l] = mc_ptr - l - 4;
     switch (tree->args->type) {
     case l_not:
       j = compile_tree(output, tree->args->args, 0, -1);
       if (j >= registers) {
         machine_code[mc_ptr++] = 0x48;
         machine_code[mc_ptr++] = 0x83;
         machine_code[mc_ptr++] = 0x7d;
         machine_code[mc_ptr++] = -regs[j].rbp;
       } else {
         machine_code[mc_ptr++] = 0x48 | (j > 7 ? 1 : 0);
         machine_code[mc_ptr++] = 0x83;
         machine_code[mc_ptr++] = 0xf8 + (j % 8);
       }
       machine_code[mc_ptr++] = 0x00;
       machine_code[mc_ptr++] = 0x0f;
       machine_code[mc_ptr++] = 0x84;
       *(int32_t *) &machine_code[mc_ptr] = -(mc_ptr - l);
       mc_ptr += 4;
       break;
     case l_eq:
       j = compile_tree(output, tree->args->args, 0, -1);
       k = compile_tree(output, &tree->args->args[1], 0, -1);
       if (j >= registers) {
         if (k >= registers) {
           k = compile_tree(output, &tree->args->args[1], 0, get_free_reg(0));
         }
         machine_code[mc_ptr++] = 0x48 | (k > 7 ? 4 : 0);
         machine_code[mc_ptr++] = 0x39;
         machine_code[mc_ptr++] = 0x45 + (k % 8) * 8;
         machine_code[mc_ptr++] = -regs[j].rbp;
       } else {
         machine_code[mc_ptr++] = 0x48 | (j > 7 ? 4 : 0);
         machine_code[mc_ptr++] = 0x3b;
         if (k >= registers) {
           machine_code[mc_ptr++] = 0x45 + (j % 8) * 8;
           machine_code[mc_ptr++] = -regs[k].rbp;
         } else {
           machine_code[mc_ptr-2] |= (k > 7 ? 1 : 0);
           machine_code[mc_ptr++] = 0xc0 + (k % 8) + (j % 8) * 8;
         }
       }
       machine_code[mc_ptr++] = 0x0f;
       machine_code[mc_ptr++] = 0x84;
       *(int32_t *) &machine_code[mc_ptr] = -(mc_ptr - l);
       mc_ptr += 4;
       break;
     case l_lt:
       j = compile_tree(output, tree->args->args, 0, -1);
       k = compile_tree(output, &tree->args->args[1], 0, -1);
       if (j >= registers) {
         if (k >= registers) {
           k = compile_tree(output, &tree->args->args[1], 0, get_free_reg(0));
         }
         machine_code[mc_ptr++] = 0x48 | (k > 7 ? 4 : 0);
         machine_code[mc_ptr++] = 0x39;
         machine_code[mc_ptr++] = 0x45 + (k % 8) * 8;
         machine_code[mc_ptr++] = -regs[j].rbp;
       } else {
         machine_code[mc_ptr++] = 0x48 | (j > 7 ? 4 : 0);
         machine_code[mc_ptr++] = 0x3b;
         if (k >= registers) {
           machine_code[mc_ptr++] = 0x45 + (j % 8) * 8;
           machine_code[mc_ptr++] = -regs[k].rbp;
         } else {
           machine_code[mc_ptr-2] |= (k > 7 ? 1 : 0);
           machine_code[mc_ptr++] = 0xc0 + (k % 8) + (j % 8) * 8;
         }
       }
       machine_code[mc_ptr++] = 0x0f;
       machine_code[mc_ptr++] = 0x8c;
       *(int32_t *) &machine_code[mc_ptr] = -(mc_ptr - l);
       mc_ptr += 4;
       break;
     default:
       j = compile_tree(output, tree->args, 0, -1);
       if (j >= registers) {
         machine_code[mc_ptr++] = 0x48;
         machine_code[mc_ptr++] = 0x83;
         machine_code[mc_ptr++] = 0x7d;
         machine_code[mc_ptr++] = -regs[j].rbp;
       } else {
         machine_code[mc_ptr++] = 0x48 | (j > 7 ? 1 : 0);
         machine_code[mc_ptr++] = 0x83;
         machine_code[mc_ptr++] = 0xf8 + (j % 8);
       }
       machine_code[mc_ptr++] = 0x00;
       machine_code[mc_ptr++] = 0x0f;
       machine_code[mc_ptr++] = 0x85;
       *(int32_t *) &machine_code[mc_ptr] = -(mc_ptr - l);
       mc_ptr += 4;
       break;
     }
     used_regs = (1 << 5) | (1 << 4);
     for (i = 0; i < registers; i++)
       reg_hist[i].type = 0;
     break;
   case ifnz:
     /*
     j = compile_tree(output, tree->args, 0, -1);
     if (j >= registers) {
       machine_code[mc_ptr++] = 0x48;
       machine_code[mc_ptr++] = 0x83;
       machine_code[mc_ptr++] = 0x7d;
       machine_code[mc_ptr++] = -regs[j].rbp;
       machine_code[mc_ptr++] = 0x00;
     } else {
       machine_code[mc_ptr++] = 0x48 | (j > 7 ? 1 : 0);
       machine_code[mc_ptr++] = 0x83;
       machine_code[mc_ptr++] = 0xf8 + (j % 8);
       machine_code[mc_ptr++] = 0x00;
     }
     //machine_code[mc_ptr++] = 0x00;
     machine_code[mc_ptr++] = 0x0f;
     machine_code[mc_ptr++] = 0x84;
     k = mc_ptr;
     mc_ptr += 4;
     */
     switch (tree->args->type) {
     case l_not:
       j = compile_tree(output, tree->args->args, 0, -1);
       if (j >= registers) {
         machine_code[mc_ptr++] = 0x48;
         machine_code[mc_ptr++] = 0x83;
         machine_code[mc_ptr++] = 0x7d;
         machine_code[mc_ptr++] = -regs[j].rbp;
       } else {
         machine_code[mc_ptr++] = 0x48 | (j > 7 ? 1 : 0);
         machine_code[mc_ptr++] = 0x83;
         machine_code[mc_ptr++] = 0xf8 + (j % 8);
       }
       machine_code[mc_ptr++] = 0x00;
       machine_code[mc_ptr++] = 0x0f;
       machine_code[mc_ptr++] = 0x85;
       //*(int32_t *) &machine_code[mc_ptr] = -(mc_ptr - l);
       k = mc_ptr;
       mc_ptr += 4;
       break;
     case l_eq:
       j = compile_tree(output, tree->args->args, 0, -1);
       k = compile_tree(output, &tree->args->args[1], 0, -1);
       if (j >= registers) {
         if (k >= registers) {
           k = compile_tree(output, &tree->args->args[1], 0, get_free_reg(0));
         }
         machine_code[mc_ptr++] = 0x48 | (k > 7 ? 4 : 0);
         machine_code[mc_ptr++] = 0x39;
         machine_code[mc_ptr++] = 0x45 + (k % 8) * 8;
         machine_code[mc_ptr++] = -regs[j].rbp;
       } else {
         machine_code[mc_ptr++] = 0x48 | (j > 7 ? 4 : 0);
         machine_code[mc_ptr++] = 0x3b;
         if (k >= registers) {
           machine_code[mc_ptr++] = 0x45 + (j % 8) * 8;
           machine_code[mc_ptr++] = -regs[k].rbp;
         } else {
           machine_code[mc_ptr-2] |= (k > 7 ? 1 : 0);
           machine_code[mc_ptr++] = 0xc0 + (k % 8) + (j % 8) * 8;
         }
       }
       machine_code[mc_ptr++] = 0x0f;
       machine_code[mc_ptr++] = 0x85;
       //*(int32_t *) &machine_code[mc_ptr] = -(mc_ptr - l);
       k = mc_ptr;
       mc_ptr += 4;
       break;
     case l_lt:
       j = compile_tree(output, tree->args->args, 0, -1);
       k = compile_tree(output, &tree->args->args[1], 0, -1);
       if (j >= registers) {
         if (k >= registers) {
           k = compile_tree(output, &tree->args->args[1], 0, get_free_reg(0));
         }
         machine_code[mc_ptr++] = 0x48 | (k > 7 ? 4 : 0);
         machine_code[mc_ptr++] = 0x39;
         machine_code[mc_ptr++] = 0x45 + (k % 8) * 8;
         machine_code[mc_ptr++] = -regs[j].rbp;
       } else {
         machine_code[mc_ptr++] = 0x48 | (j > 7 ? 4 : 0);
         machine_code[mc_ptr++] = 0x3b;
         if (k >= registers) {
           machine_code[mc_ptr++] = 0x45 + (j % 8) * 8;
           machine_code[mc_ptr++] = -regs[k].rbp;
         } else {
           machine_code[mc_ptr-2] |= (k > 7 ? 1 : 0);
           machine_code[mc_ptr++] = 0xc0 + (k % 8) + (j % 8) * 8;
         }
       }
       machine_code[mc_ptr++] = 0x0f;
       machine_code[mc_ptr++] = 0x8d;
       //*(int32_t *) &machine_code[mc_ptr] = -(mc_ptr - l);
       k = mc_ptr;
       mc_ptr += 4;
       break;
     case b_and:
       j = compile_tree(output, tree->args->args, 0, -1);
       k = compile_tree(output, &tree->args->args[1], 0, -1);
       if (j >= registers) {
         if (k >= registers) {
           k = compile_tree(output, &tree->args->args[1], 0, get_free_reg(0));
         }
         machine_code[mc_ptr++] = 0x48 | (k > 7 ? 4 : 0);
         machine_code[mc_ptr++] = 0x85;
         machine_code[mc_ptr++] = 0x45 + (k % 8) * 8;
         machine_code[mc_ptr++] = -regs[j].rbp;
       } else {
         machine_code[mc_ptr++] = 0x48 | (j > 7 ? 4 : 0);
         machine_code[mc_ptr++] = 0x85;
         if (k >= registers) {
           machine_code[mc_ptr++] = 0x45 + (j % 8) * 8;
           machine_code[mc_ptr++] = -regs[k].rbp;
         } else {
           machine_code[mc_ptr-2] |= (k > 7 ? 1 : 0);
           machine_code[mc_ptr++] = 0xc0 + (k % 8) + (j % 8) * 8;
         }
       }
       machine_code[mc_ptr++] = 0x0f;
       machine_code[mc_ptr++] = 0x84;
       //*(int32_t *) &machine_code[mc_ptr] = -(mc_ptr - l);
       k = mc_ptr;
       mc_ptr += 4;
       break;
     default:
       j = compile_tree(output, tree->args, 0, -1);
       if (j >= registers) {
         machine_code[mc_ptr++] = 0x48;
         machine_code[mc_ptr++] = 0x83;
         machine_code[mc_ptr++] = 0x7d;
         machine_code[mc_ptr++] = -regs[j].rbp;
       } else {
         machine_code[mc_ptr++] = 0x48 | (j > 7 ? 1 : 0);
         machine_code[mc_ptr++] = 0x83;
         machine_code[mc_ptr++] = 0xf8 + (j % 8);
       }
       machine_code[mc_ptr++] = 0x00;
       machine_code[mc_ptr++] = 0x0f;
       machine_code[mc_ptr++] = 0x84;
       //*(int32_t *) &machine_code[mc_ptr] = -(mc_ptr - l);
       k = mc_ptr;
       mc_ptr += 4;
       break;
     }
     // True
     used_regs = (1 << 5) | (1 << 4);
     compile_tree(output, &tree->args[1], 1, -1);
     if (tree->args_count == 3) {
       machine_code[mc_ptr++] = 0xe9;
       l = mc_ptr;
       *(int32_t *) &machine_code[mc_ptr] = 0x00;
       mc_ptr += 4;
       // Else
       *(int32_t *) &machine_code[k] = mc_ptr - k - 4;
       compile_tree(output, &tree->args[2], 1, -1);
       *(int32_t *) &machine_code[l] = mc_ptr - l - 4;
     } else {
       *(int32_t *) &machine_code[k] = mc_ptr - k - 4;
     }
     used_regs = (1 << 5) | (1 << 4);
     for (i = 0; i < registers; i++)
       reg_hist[i].type = 0;
     break;
   case l_not:
     j = compile_tree(output, tree->args, discard_result, out_reg);
     if (discard_result) {
       if (j < registers) used_regs &= ~(1 << j);
       break;
     }
     reg = j;
     if (j >= registers) {
       reg = get_free_reg(1);
       machine_code[mc_ptr++] = 0x48;
       machine_code[mc_ptr++] = 0x83;
       machine_code[mc_ptr++] = 0x7d;
       machine_code[mc_ptr++] = -regs[j].rbp;
     } else {
       machine_code[mc_ptr++] = 0x48 | (reg > 7 ? 1 : 0);
       machine_code[mc_ptr++] = 0x83;
       machine_code[mc_ptr++] = 0xf8 + (reg % 8);
     }
     machine_code[mc_ptr++] = 0x00;
     machine_code[mc_ptr++] = 0x74;
     machine_code[mc_ptr++] = 0x05;
     // Not zero
     machine_code[mc_ptr++] = 0x48 | (reg > 7 ? 5 : 0);
     machine_code[mc_ptr++] = 0x33;
     machine_code[mc_ptr++] = 0xc0 + (reg % 8) + (reg % 8) * 8;
     machine_code[mc_ptr++] = 0xeb;
     machine_code[mc_ptr++] = 0x0a;
     // Zero
     machine_code[mc_ptr++] = 0x48 + (reg > 7 ? 1 : 0);
     machine_code[mc_ptr++] = 0xb8 + (reg % 8);
     *(int64_t *) &machine_code[mc_ptr] = 1;
     mc_ptr += 8;
     break;
   case l_and:
     if (tree->args->type == number)
       k = tree->args->i, l = 1;
     else
       l = 0;
     if (l) {
       if (k)
         reg = compile_tree(output, &tree->args[1], discard_result, out_reg);
       else
         reg = compile_tree(output, tree->args, discard_result, out_reg);
       break;
     }
     j = compile_tree(output, tree->args, discard_result, out_reg);
     reg = j;
     if (j >= registers) {
       reg = get_free_reg(1);
       machine_code[mc_ptr++] = 0x48;
       machine_code[mc_ptr++] = 0x83;
       machine_code[mc_ptr++] = 0x7d;
       machine_code[mc_ptr++] = -regs[j].rbp;
     } else {
       machine_code[mc_ptr++] = 0x48 | (reg > 7 ? 1 : 0);
       machine_code[mc_ptr++] = 0x83;
       machine_code[mc_ptr++] = 0xf8 + (reg % 8);
     }
     machine_code[mc_ptr++] = 0x00;
 
     machine_code[mc_ptr++] = 0x0f;
     machine_code[mc_ptr++] = 0x84;
     //machine_code[mc_ptr++] = 0x05;
     l = mc_ptr;
     mc_ptr += 4;
     // Not zero
     compile_tree(output, &tree->args[1], discard_result, reg);
     if (discard_result) {
       *(int32_t *) &machine_code[l] = mc_ptr - l;
       if (reg < registers) used_regs &= ~(1 << reg);
       break;
     }
     machine_code[mc_ptr++] = 0xeb;
     machine_code[mc_ptr++] = 0x03;
     *(int32_t *) &machine_code[l] = mc_ptr - l - 4;
     // Zero
     machine_code[mc_ptr++] = 0x48 + (reg > 7 ? 5 : 0);
     machine_code[mc_ptr++] = 0x33;
     machine_code[mc_ptr++] = 0xc0 + (reg % 8) * 8 + (reg % 8);
     break;
   case l_or:
     if (has_sideeffect(tree->args) || has_sideeffect(&tree->args[1]) ||
         !discard_result) {
       if (tree->args->type == number)
         k = tree->args->i, l = 1;
       else
         l = 0;
       if (l) {
         if (k)
           reg = compile_tree(output, tree->args, discard_result, out_reg);
         else
           reg = compile_tree(output, &tree->args[1], discard_result, out_reg);
         break;
       }
       j = compile_tree(output, tree->args, 0, out_reg);
       reg = j;
       if (j >= registers) {
         reg = get_free_reg(1);
         machine_code[mc_ptr++] = 0x48;
         machine_code[mc_ptr++] = 0x83;
         machine_code[mc_ptr++] = 0x7d;
         machine_code[mc_ptr++] = -regs[j].rbp;
       } else {
         machine_code[mc_ptr++] = 0x48 | (reg > 7 ? 1 : 0);
         machine_code[mc_ptr++] = 0x83;
         machine_code[mc_ptr++] = 0xf8 + (reg % 8);
       }
       machine_code[mc_ptr++] = 0x00;
     }
 
     if (has_sideeffect(&tree->args[1]) || !discard_result) {
       machine_code[mc_ptr++] = 0x0f;
       machine_code[mc_ptr++] = 0x85;
       l = mc_ptr;
       mc_ptr += 4;
       compile_tree(output, &tree->args[1], discard_result, reg);
       *(int32_t *) &machine_code[l] = mc_ptr - l - 4;
     }
     if (discard_result) {
       if (reg >= 0 && reg < registers) used_regs &= ~(1 << reg);
       break;
     }
     break;
   case l_eq:
     j = compile_tree(output, tree->args, discard_result, -1);
     k = compile_tree(output, &tree->args[1], discard_result, -1);
     if (discard_result) {
       if (j < registers) used_regs &= ~(1 << j);
       if (k < registers) used_regs &= ~(1 << k);
       break;
     }
     reg = k;
 
     if (j >= registers) {
       if (k >= registers) {
         reg = get_free_reg(1);
         machine_code[mc_ptr++] = 0x48 | (reg > 7 ? 4 : 0);
         machine_code[mc_ptr++] = 0x8b;
         machine_code[mc_ptr++] = 0x45 + (reg % 8) * 8;
         machine_code[mc_ptr++] = -regs[k].rbp;
         k = reg;
       }
       machine_code[mc_ptr++] = 0x48 | (k > 7 ? 4 : 0);
       machine_code[mc_ptr++] = 0x39;
       machine_code[mc_ptr++] = 0x45 + (k % 8) * 8;
       machine_code[mc_ptr++] = -regs[j].rbp;
     } else if (k >= registers) {
       machine_code[mc_ptr++] = 0x48 | (j > 7 ? 4 : 0);
       machine_code[mc_ptr++] = 0x3b;
       machine_code[mc_ptr++] = 0x45 + (j % 8) * 8;
       machine_code[mc_ptr++] = -regs[k].rbp;
     } else {
       machine_code[mc_ptr++] = 0x48 | (j > 7 ? 1 : 0) | (k > 7 ? 4 : 0);
       machine_code[mc_ptr++] = 0x39;
       machine_code[mc_ptr++] = 0xc0 + (j % 8) + (k % 8) * 8;
       used_regs &= ~(1 << k);
     }
     if (j < registers && k >= registers) used_regs &= ~(1 << reg), reg = j;
     machine_code[mc_ptr++] = 0x74;
     machine_code[mc_ptr++] = 0x05; //Offset
     // Not less than:
     machine_code[mc_ptr++] = 0x48 | (reg > 7 ? 5 : 0);
     machine_code[mc_ptr++] = 0x33;
     machine_code[mc_ptr++] = 0xc0 + (reg % 8) + (reg % 8) * 8;
     machine_code[mc_ptr++] = 0xeb;
     machine_code[mc_ptr++] = 0x0a;
     // Less than:
     machine_code[mc_ptr++] = 0x48 + (reg > 7 ? 1 : 0);
     machine_code[mc_ptr++] = 0xb8 + (reg % 8);
     *(int64_t *) &machine_code[mc_ptr] = 1;
     mc_ptr += 8;
     break;
   case l_lt:
     j = compile_tree(output, tree->args, discard_result, -1);
     k = compile_tree(output, &tree->args[1], discard_result, -1);
     if (discard_result) {
       if (j < registers) used_regs &= ~(1 << j);
       if (k < registers) used_regs &= ~(1 << k);
       break;
     }
 
     reg = j;
     if (j >= registers) {
       reg = k;
       if (k >= registers) {
         reg = get_free_reg(1);
         machine_code[mc_ptr++] = 0x48 | (reg > 7 ? 4 : 0);
         machine_code[mc_ptr++] = 0x8b;
         machine_code[mc_ptr++] = 0x45 + (reg % 8) * 8;
         machine_code[mc_ptr++] = -regs[k].rbp;
         k = reg;
       }
       machine_code[mc_ptr++] = 0x48 | (k > 7 ? 4 : 0);
       machine_code[mc_ptr++] = 0x39;
       machine_code[mc_ptr++] = 0x45 + (k % 8) * 8;
       machine_code[mc_ptr++] = -regs[j].rbp;
     } else if (k >= registers) {
       machine_code[mc_ptr++] = 0x48 | (j > 7 ? 4 : 0);
       machine_code[mc_ptr++] = 0x3b;
       machine_code[mc_ptr++] = 0x45 + (j % 8) * 8;
       machine_code[mc_ptr++] = -regs[k].rbp;
     } else {
       machine_code[mc_ptr++] = 0x48 | (j > 7 ? 1 : 0) | (k > 7 ? 4 : 0);
       machine_code[mc_ptr++] = 0x39;
       machine_code[mc_ptr++] = 0xc0 + (j % 8) + (k % 8) * 8;
       used_regs &= ~(1 << k);
     }
     if (reg != out_reg && out_reg >= 0) {
       used_regs &= ~(1 << reg);
       reg = out_reg;
     }
     machine_code[mc_ptr++] = 0x7c;
     machine_code[mc_ptr++] = 0x05; //Offset
     // Not less than:
     machine_code[mc_ptr++] = 0x48 | (reg > 7 ? 5 : 0);
     machine_code[mc_ptr++] = 0x33;
     machine_code[mc_ptr++] = 0xc0 + (reg % 8) + (reg % 8) * 8;
     machine_code[mc_ptr++] = 0xeb;
     machine_code[mc_ptr++] = 0x0a;
     // Less than:
     machine_code[mc_ptr++] = 0x48 + (reg > 7 ? 1 : 0);
     machine_code[mc_ptr++] = 0xb8 + (reg % 8);
     *(int64_t *) &machine_code[mc_ptr] = 1;
     mc_ptr += 8;
     break;
   case ret:
     compile_tree(output, tree->args, 0, 0);
     machine_code[mc_ptr++] = 0xc9;
     machine_code[mc_ptr++] = 0xc3;
     return -3;
   case _syscall:
     push(0, &pushed, push_order, "readstring (rax)");
     if (tree->args[1].type != comma) {
       push(syscall_arg[0], &pushed, push_order, "readstring (syscall_arg 0)");
       compile_tree(output, &tree->args->args[0], 0, syscall_arg[0]);
       i = 1;
     } else {
       for (i = 0; i < tree->args[1].args_count; i++) {
         push(syscall_arg[i], &pushed, push_order, "readstring (syscall_arg loop)");
         compile_tree(output, &tree->args[1].args[i], 0, syscall_arg[i]);
       }
     }
 
     compile_tree(output, tree->args, 0, 0);
 
     machine_code[mc_ptr++] = 0x0f;
     machine_code[mc_ptr++] = 0x05;
     for (j = 0; j < i; j++)
       used_regs &= ~(1 << syscall_arg[j]);
     reg = 0;
     break;
   case readstring:
     push(0, &pushed, push_order, "readstring (rax)");
     push(syscall_arg[0], &pushed, push_order, "readstring (syscall_arg 0)");
     push(syscall_arg[1], &pushed, push_order, "readstring (syscall_arg 1)");
     push(syscall_arg[2], &pushed, push_order, "readstring (syscall_arg 2)");
     compile_tree(output, &tree->args->args[0], 0, syscall_arg[0]);
     compile_tree(output, &tree->args->args[1], 0, syscall_arg[1]);
     compile_tree(output, &tree->args->args[2], 0, syscall_arg[2]);
 
     compile_tree(output, ZERO, 0, 0);
     /*
     machine_code[mc_ptr++] = 0x48;
     machine_code[mc_ptr++] = 0xb8;
     *(int64_t *) &machine_code[mc_ptr] = 0x00;
     mc_ptr += 8;
     */
 
     machine_code[mc_ptr++] = 0x0f;
     machine_code[mc_ptr++] = 0x05;
     used_regs &= ~(1 << syscall_arg[0]);
     used_regs &= ~(1 << syscall_arg[1]);
     used_regs &= ~(1 << syscall_arg[2]);
     reg = 0;
     break;
   case writestring:
     push(0, &pushed, push_order, "writestring (rax)");
     push(syscall_arg[0], &pushed, push_order, "writestring (syscall_arg 0)");
     push(syscall_arg[1], &pushed, push_order, "writestring (syscall_arg 1)");
     push(syscall_arg[2], &pushed, push_order, "writestring (syscall_arg 2)");
     compile_tree(output, &tree->args->args[0], 0, syscall_arg[0]);
     used_regs |= (1 << syscall_arg[0]);
     compile_tree(output, &tree->args->args[1], 0, syscall_arg[1]);
     used_regs |= (1 << syscall_arg[1]);
     compile_tree(output, &tree->args->args[2], 0, syscall_arg[2]);
     used_regs |= (1 << syscall_arg[2]);
 
     compile_tree(output, ONE, 0, 0);
     /*
     machine_code[mc_ptr++] = 0x48;
     machine_code[mc_ptr++] = 0xb8;
     *(int64_t *) &machine_code[mc_ptr] = 0x01;
     mc_ptr += 8;
     */
 
     machine_code[mc_ptr++] = 0x0f;
     machine_code[mc_ptr++] = 0x05;
     used_regs &= ~(1 << syscall_arg[0]);
     used_regs &= ~(1 << syscall_arg[1]);
     used_regs &= ~(1 << syscall_arg[2]);
     reg = 0;
     break;
   case printchar:
     push(0, &pushed, push_order, "printchar (rax)");
     push(syscall_arg[0], &pushed, push_order, "printchar (syscall_arg 0)");
     push(syscall_arg[1], &pushed, push_order, "printchar (syscall_arg 1)");
     push(syscall_arg[2], &pushed, push_order, "printchar (syscall_arg 2)");
 
     j = compile_tree(output, tree->args, 0, syscall_arg[1]);
 
     // Allocate extra space on the stack for the character
     // Because of scratch space, this might be unnecessary
     machine_code[mc_ptr++] = 0x48;
     machine_code[mc_ptr++] = 0x83;
     machine_code[mc_ptr++] = 0xec;
     machine_code[mc_ptr++] = 0x08;
 
     machine_code[mc_ptr++] = 0x48 | (j > 7 ? 4 : 0);
     machine_code[mc_ptr++] = 0x89;
     machine_code[mc_ptr++] = 0x45 + (j % 8) * 8;
     machine_code[mc_ptr++] = -next_rbp;
 
     machine_code[mc_ptr++] = 0x48 | (j > 7 ? 4 : 0);
     machine_code[mc_ptr++] = 0x8d;
     machine_code[mc_ptr++] = 0x45 + (j % 8) * 8;
     machine_code[mc_ptr++] = -next_rbp;
 
 
     compile_tree(output, ONE, 0, 0);
     /*
     machine_code[mc_ptr++] = 0x48;
     machine_code[mc_ptr++] = 0xb8;
     *(int64_t *) &machine_code[mc_ptr] = 0x01;
     mc_ptr += 8;
     */
     machine_code[mc_ptr++] = 0x48 | (arg_order[0] > 7 ? 1 : 0);
     machine_code[mc_ptr++] = 0x89;
     machine_code[mc_ptr++] = 0xc0 + (arg_order[0] % 8);
     machine_code[mc_ptr++] = 0x48 | (arg_order[2] > 7 ? 1 : 0);
     machine_code[mc_ptr++] = 0x89;
     machine_code[mc_ptr++] = 0xc0 + (arg_order[2] % 8);
 
     machine_code[mc_ptr++] = 0x0f;
     machine_code[mc_ptr++] = 0x05;
 
     machine_code[mc_ptr++] = 0x48;
     machine_code[mc_ptr++] = 0x83;
     machine_code[mc_ptr++] = 0xc4;
     machine_code[mc_ptr++] = 0x08;
 
     used_regs &= ~(1 << syscall_arg[0]);
     used_regs &= ~(1 << syscall_arg[1]);
     used_regs &= ~(1 << syscall_arg[2]);
     reg = 0;
     break;
   case brk_sys:
     push(0, &pushed, push_order, "brk_sys (rax)");
     push(syscall_arg[0], &pushed, push_order, "brk_sys (syscall_arg 0)");
     j = compile_tree(output, tree->args, 0, syscall_arg[0]);
     machine_code[mc_ptr++] = 0xb8;
     *(int32_t *) &machine_code[mc_ptr] = 0x0c;
     mc_ptr += 4;
     machine_code[mc_ptr++] = 0x0f;
     machine_code[mc_ptr++] = 0x05;
     reg = 0;
     break;
   case exit_p:
     j = compile_tree(output, tree->args, 0, syscall_arg[0]);
     machine_code[mc_ptr++] = 0xb8;
     *(int32_t *) &machine_code[mc_ptr] = 0x3c;
     mc_ptr += 4;
     machine_code[mc_ptr++] = 0x0f;
     machine_code[mc_ptr++] = 0x05;
     return -2;
   }
   if (!discard_result) {
     if (reg < 0) {
       fprintf(stderr, "No value in <reg>\n");
       fprintf(stderr, "type: %s\n", exp_str[tree->type]);
       exit(1);
     }
     if (out_reg == reg || out_reg < 0 && !(pushed & (1 << reg))) {
       out_reg = reg;
       used_regs |= (1 << out_reg);
       goto pop_used;
     } else if (out_reg < 0) {
       k = used_regs;
       used_regs |= pushed;
       out_reg = get_free_reg(1);
       used_regs = k;
       used_regs |= (1 << out_reg);
     }
     if (reg >= registers && out_reg >= registers) {
       j = get_free_reg(0);
       machine_code[mc_ptr++] = 0x48 | (j > 7 ? 4 : 0);
       machine_code[mc_ptr++] = 0x8b;
       machine_code[mc_ptr++] = 0x45 + (j % 8) * 8;
       machine_code[mc_ptr++] = -regs[reg].rbp;
       
       machine_code[mc_ptr++] = 0x48 | (j > 7 ? 4 : 0);
       machine_code[mc_ptr++] = 0x89;
       machine_code[mc_ptr++] = 0x45 + (j % 8) * 8;
       machine_code[mc_ptr++] = -regs[out_reg].rbp;
       regs[out_reg].rev++;
     } else if (reg >= registers && out_reg < registers) {
       machine_code[mc_ptr++] = 0x48 | (out_reg > 7 ? 4 : 0);
       machine_code[mc_ptr++] = 0x8b;
       machine_code[mc_ptr++] = 0x45 + (out_reg % 8) * 8;
       machine_code[mc_ptr++] = -regs[reg].rbp;
       reg_hist[out_reg].type = 1;
       reg_hist[out_reg].reg = reg;
       reg_hist[out_reg].rev = ++regs[reg].rev;
     } else {
       machine_code[mc_ptr++] = 0x48 | (reg > 7 ? 4 : 0);
       machine_code[mc_ptr++] = 0x89;
       if (out_reg >= registers) {
         machine_code[mc_ptr++] = 0x45 + (reg % 8) * 8;
         machine_code[mc_ptr++] = -regs[out_reg].rbp;
         reg_hist[reg].type |= 1;
         reg_hist[reg].reg = reg;
         reg_hist[reg].rev = ++regs[out_reg].rev;
       } else {
         machine_code[mc_ptr-2] |= (out_reg > 7 ? 1 : 0);
         machine_code[mc_ptr++] = 0xc0 + (out_reg % 8) + (reg % 8) * 8;
         memcpy(&reg_hist[out_reg], &reg_hist[reg], sizeof(struct reg_history));
         used_regs |= (1 << out_reg);
       }
       used_regs &= ~(1 << reg);
     }
   }
 pop_used:
   if (pushed)
     for (i = registers-1; i >= 0; i--) {
       if (push_order[i] >= 0) pop(push_order[i], &pushed);
     }
 end:
   return out_reg;
 }
 
 struct elf_hdr {
   unsigned int magic;
   unsigned char class;
   unsigned char endianness;
   unsigned char version;
   unsigned char abi;
   unsigned char abi_version;
   unsigned char pad[7];
   unsigned short type;
   unsigned short arch;
   unsigned int version2;
   unsigned long entry;
   unsigned long phoff;
   unsigned long shoff;
   unsigned int flags;
   unsigned short ehsize;
   unsigned short phsize;
   unsigned short phcount;
   unsigned short shsize;
   unsigned short shcount;
   unsigned short shstrindx;
 } __attribute((packed));
 
 struct prg_hdr {
   unsigned int type;
   unsigned int flags;
   unsigned long offset;
   unsigned long vaddr;
   unsigned long paddr;
   unsigned long fsize;
   unsigned long msize;
   unsigned long align;
 } __attribute((packed));
 
 struct sec_hdr {
   unsigned int name;
   unsigned int type;
   unsigned long flags;
   unsigned long addr;
   unsigned long offset;
   unsigned long size;
   unsigned int link;
   unsigned int info;
   unsigned long align;
   unsigned long esize;
 } __attribute((packed));
 
 struct elf_hdr elf_hdr = { 0x464c457f, 2, 1, 1, 0, 0, { 0 }, 2, 0x3e, 1, 0, 0x40, 0, 0, 0x40, 0x38, 0, 0x40, 0, 0 };
 struct prg_hdr load_text =   { 1, 5, 0, 0, 0, 0, 0, 1 };
 struct prg_hdr load_rodata = { 1, 4, 0, 0, 0, 0, 0, 1 };
 struct sec_hdr null_section = { 0 };
 struct sec_hdr text_section = { 1, 1, 6, 0, 0, 0, 0, 0, 1, 0 };
 struct sec_hdr rodata_section = { 7, 1, 2, 0, 0, 0, 0, 0, 1, 0 };
 struct sec_hdr strtab_section = { 15, 3, 0, 0, 0, 0, 0, 0, 1, 0 };
 char strtab[] = "\0.text\0.rodata\0.strtab";
 
 char padding[4096] = { 0 };
 
 int main(int argc, char **argv)
 {
   int failed = 0, i, outfd, use_rodata = 1, flag_s = 0, first_arg = 1;
 
   if (argc > 1 && argv[1][0] == '-' && argv[1][1]) {
     switch (argv[1][1]) {
     case 's':
       flag_s = 1;
       break;
     }
     argc--;
     first_arg = 2;
   }
   if (argc == 1) {
     fname = "stdin";
     outfd = 1;
   } else if (argc < 3) {
     fprintf(stderr, "Too few arguments\nUsage: %s <in-file> <out-file>\n", *argv);
     exit(1);
   } else {
     if (argv[first_arg][0] == '-' && !argv[first_arg][1]) {
       fname = "stdin";
       yyin = stdin;
     } else {
       fname = argv[first_arg];
       yyin = fopen(fname, "r");
     }
     outfd = open(argv[first_arg + 1], O_TRUNC  | O_WRONLY | O_CREAT,
                  (S_IRUSR | S_IWUSR | S_IXUSR  | S_IRGRP  |
                   S_IXGRP | S_IROTH | S_IXOTH) & 0x1ff);
     if (outfd == -1) {
       fprintf(stderr, "Unable to open out-file\n");
       exit(1);
     }
   }
 
   yyparse();
 
   if (flag_s) stringify(final, -3, 0, NULL, 0);
 
   if (use_rodata) elf_hdr.phcount = 2;
   else elf_hdr.phcount = 1;
   if (use_rodata) elf_hdr.shcount = 4;
   else elf_hdr.shcount = 3;
   elf_hdr.shstrindx = elf_hdr.shcount - 1;
 
   int hdr1_size = sizeof(elf_hdr) + sizeof(struct prg_hdr) * elf_hdr.phcount;
   start_addr = 0x400000 + hdr1_size;
   rodata_addr = 0x600000;
 
   for (i = 0; i < final->args_count; i++) {
     compile_tree(stdout, &final->args[i], 1, -1);
   }
   for (i = 0; i < ftemp_len; i++) {
     if (ftemp[i].fptr) {
       fprintf(stderr, "No definition for function <%s> found\n", ftemp[i].fname);
 
     }
   }
   if (failed) exit(1);
   if (entry_addr < 0) {
     fprintf(stderr, "No _start symbol found!\n");
     exit(1);
   }
 
   int section_pad = 16 - ((hdr1_size + mc_ptr) % 16);
   int rodata_offset = sizeof(elf_hdr) + sizeof(load_text) + sizeof(load_rodata)
                     + mc_ptr + section_pad + sizeof(null_section) + sizeof(text_section)
                     + sizeof(rodata_section) + sizeof(strtab_section) 
                     + sizeof(strtab);
   int rodata_pad_len = 4096 - (rodata_offset % 4096);
   rodata_offset += rodata_pad_len;
 
   elf_hdr.entry = start_addr + entry_addr;
   elf_hdr.shoff = hdr1_size + mc_ptr + section_pad;
 
   load_text.offset = 0;
   load_text.vaddr = 0x400000;
   load_text.paddr = 0x400000;
   load_text.fsize = hdr1_size + mc_ptr;
   load_text.msize = hdr1_size + mc_ptr;
 
   load_rodata.offset = rodata_offset;
   load_rodata.vaddr = 0x600000;
   load_rodata.paddr = 0x600000;
   load_rodata.fsize = rd_ptr;
   load_rodata.msize = rd_ptr;
 
   text_section.addr = start_addr;
   text_section.offset = hdr1_size;
   text_section.size = mc_ptr;
 
   rodata_section.addr = load_rodata.vaddr;
   rodata_section.offset = load_rodata.offset;
   rodata_section.size = load_rodata.fsize;
 
   strtab_section.offset = hdr1_size + mc_ptr + section_pad + sizeof(struct sec_hdr) * elf_hdr.shcount;
   strtab_section.size = sizeof(strtab);
 
   write(outfd, &elf_hdr, sizeof(elf_hdr));
   write(outfd, &load_text, sizeof(load_text));
   if (use_rodata) write(outfd, &load_rodata, sizeof(load_rodata));
   write(outfd, machine_code, mc_ptr);
   write(outfd, padding, section_pad);
   write(outfd, &null_section, sizeof(null_section));
   write(outfd, &text_section, sizeof(text_section));
   if (use_rodata) write(outfd, &rodata_section, sizeof(rodata_section));
   write(outfd, &strtab_section, sizeof(strtab_section));
   write(outfd, strtab, sizeof(strtab));
   if (use_rodata) write(outfd, padding, rodata_pad_len);
   if (use_rodata) write(outfd, rodata, rd_ptr);
 }