/**************************************************************************************
 * Chaga compiler                                                                     *
 * Copyright (C) 2026 Robert James Bruce                                              *
 *                                                                                    *
 * This file is part of the Chaga compiler.                                           *
 *                                                                                    *
 * The Chaga compiler is free software: you can redistribute it and/or modify it      *
 * under the terms of the GNU General Public License as published by the              *
 * Free Software Foundation, either version 3 of the License, or (at your option) any *
 * later version.                                                                     *
 *                                                                                    *
 * The Chaga compiler is distributed in the hope that it will be useful, but WITHOUT  *
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or              *
 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License               *
 * for more details.                                                                  *
 *                                                                                    *
 * You should have received a copy of the GNU General Public License                  *
 * along with the Chaga compiler. If not, see <https://www.gnu.org/licenses/>.        *
 **************************************************************************************/
#include "include/chaga_compiler-x86_assembler.h"




// *****************************************************************************************************************************
// * create_stackframe_cross_reference_table_for_main_only                                                                     *
// *                                                                                                                           *
// * This table provides the negative offset relative to the stack pointer's current location for each variable stored in the  *
// * stackframe. Each offset is cross-referenced with the variables stored in each function or procecedure. This functionality *
// * is necessary when creating the assembler output code.                                                                     *
// *                                                                                                                           *
// * TODO: I need to allocate one more stackframe value for the return value for the main function back to the system.         *
// *****************************************************************************************************************************
stackframe_node * create_stackframe_cross_reference_table_for_main_function (stackframe_node *stackframe_cross_reference_table, symtab_node *symbol_table, unsigned long long int scope_level_for_main_function)
{
  stackframe_node *new_stackframe_element, *temp_stackframe_element;
  symtab_node *symbol_table_element;
  token_node *current_token;
  size_t stackframe_offset;

  stackframe_offset = 16; // initialize offset to 16 bytes to give some extra memory padding on the stack frame. I also allocate 16 additional bytes total storage required in other subroutines to compensate for this as well.
  symbol_table_element = symbol_table;
  while (symbol_table_element != NULL)
  {
    if (symbol_table_element->scope_level == scope_level_for_main_function)
    {
      if (symbol_table_element->attribute_type == _datatype)
      {
        if ((symbol_table_element->datatype == _int)      || 
            (symbol_table_element->datatype == _real)     || 
            (symbol_table_element->datatype == _bool)     ||
            (symbol_table_element->datatype == _pointer))  
        {
          if (symbol_table_element->identifier != NULL)
          {
            if ((strncmp(symbol_table_element->identifier, "argc", 4) != 0) && (strncmp(symbol_table_element->identifier, "argv", 4) != 0))
            {
              new_stackframe_element = (stackframe_node *) malloc(sizeof(stackframe_node));
              if (new_stackframe_element != NULL)
              {
                new_stackframe_element->symbol_table_entry    = symbol_table_element;
                new_stackframe_element->stackframe_offset     = stackframe_offset;
                new_stackframe_element->storage_size_in_bytes = 8; // This datatype takes 8 bytes of storage space on a stack frame since it is a 64-bit pointer.
                new_stackframe_element->next                  = NULL;
                stackframe_offset = stackframe_offset + 8;
                if (stackframe_cross_reference_table != NULL)
                {
                  temp_stackframe_element = stackframe_cross_reference_table;
                  while (temp_stackframe_element->next != NULL)
                  {
                    temp_stackframe_element = temp_stackframe_element->next;
                  }
                  temp_stackframe_element->next = new_stackframe_element;
                }
                else
                {
                  stackframe_cross_reference_table = new_stackframe_element;
                }
              }
            }
          }
        }
      }
    }
    symbol_table_element = symbol_table_element->next;
  }
  return stackframe_cross_reference_table;
}




// *********************************************************************************************************************
// * Create stackframe cross reference table for function.                                                             *
// *                                                                                                                   *
// * This table provides the negative offset relative to the stack pointer's current location for each variable stored *
// * in the stackframe for a given input named procedure (i.e. identifier). Each offset is cross-referenced with the   *
// * variables stored in each procecedure. This functionality is necessary when creating the assembler output code.    *
// *                                                                                                                   *
// * TODO: I need to allocate one more stackframe 8-byte pointer for the return value for a function.                  *
// *********************************************************************************************************************
stackframe_node * create_stackframe_cross_reference_table_for_function (stackframe_node *stackframe_cross_reference_table, symtab_node *symbol_table, unsigned long long int scope_level_for_function)
{
  stackframe_node *new_stackframe_element, *temp_stackframe_element;
  symtab_node *symbol_table_element;
  size_t stackframe_offset;

  stackframe_offset = 16; // initialize offset to 16 bytes to give some extra memory padding on the stack frame. I also allocate 16 additional bytes total storage required in other subroutines to compensate for this as well.
  symbol_table_element = symbol_table;
  while (symbol_table_element != NULL) 
  {
    if (symbol_table_element->scope_level == scope_level_for_function)
    {
      if (symbol_table_element->attribute_type == _datatype)
      {
        if ((symbol_table_element->datatype == _int)      || 
            (symbol_table_element->datatype == _real)     || 
            (symbol_table_element->datatype == _bool)     ||
            (symbol_table_element->datatype == _pointer))  
        {
          new_stackframe_element = (stackframe_node *) malloc(sizeof(stackframe_node));
          if (new_stackframe_element != NULL)
          {
            new_stackframe_element->symbol_table_entry    = symbol_table_element;
            new_stackframe_element->stackframe_offset     = stackframe_offset;
            new_stackframe_element->storage_size_in_bytes = 8; // This datatype takes 8 bytes of storage space on a stack frame since it is a 64-bit pointer.
            new_stackframe_element->next                  = NULL;
            stackframe_offset = stackframe_offset + 8;
            if (stackframe_cross_reference_table != NULL)
            {
              temp_stackframe_element = stackframe_cross_reference_table;
              while (temp_stackframe_element->next != NULL)
              {
                temp_stackframe_element = temp_stackframe_element->next;
              }
              temp_stackframe_element->next = new_stackframe_element;
            }
            else
            {
              stackframe_cross_reference_table = new_stackframe_element;
            }
          }
        }
      }
    }
    symbol_table_element = symbol_table_element->next;
  }
}




// *********************************************************************************************************************
// * Create stackframe cross reference table for procedure.                                                            *
// *                                                                                                                   *
// * This table provides the negative offset relative to the stack pointer's current location for each variable stored *
// * in the stackframe for a given input named procedure (i.e. identifier). Each offset is cross-referenced with the   *
// * variables stored in each procecedure. This functionality is necessary when creating the assembler output code.    *
// *********************************************************************************************************************
stackframe_node * create_stackframe_cross_reference_table_for_procedure (stackframe_node *stackframe_cross_reference_table, symtab_node *symbol_table, unsigned long long int scope_level_for_procedure)
{
  stackframe_node *new_stackframe_element, *temp_stackframe_element;
  symtab_node *symbol_table_element;
  size_t stackframe_offset;

  stackframe_offset = 16; // initialize offset to 16 bytes to give some extra memory padding on the stack frame. I also allocate 16 additional bytes total storage required in other subroutines to compensate for this as well.
  symbol_table_element = symbol_table;
  while (symbol_table_element != NULL) 
  {
    if (symbol_table_element->scope_level == scope_level_for_procedure)
    {
      if (symbol_table_element->attribute_type == _datatype)
      {
        if ((symbol_table_element->datatype == _int)      || 
            (symbol_table_element->datatype == _real)     || 
            (symbol_table_element->datatype == _bool)     ||
            (symbol_table_element->datatype == _pointer))  
        {
          new_stackframe_element = (stackframe_node *) malloc(sizeof(stackframe_node));
          if (new_stackframe_element != NULL)
          {
            new_stackframe_element->symbol_table_entry    = symbol_table_element;
            new_stackframe_element->stackframe_offset     = stackframe_offset;
            new_stackframe_element->storage_size_in_bytes = 8; // This datatype takes 8 bytes of storage space on a stack frame since it is a 64-bit pointer.
            new_stackframe_element->next                  = NULL;
            stackframe_offset = stackframe_offset + 8;
            if (stackframe_cross_reference_table != NULL)
            {
              temp_stackframe_element = stackframe_cross_reference_table;
              while (temp_stackframe_element->next != NULL)
              {
                temp_stackframe_element = temp_stackframe_element->next;
              }
              temp_stackframe_element->next = new_stackframe_element;
            }
            else
            {
              stackframe_cross_reference_table = new_stackframe_element;
            }
          }
        }
      }
    }
    symbol_table_element = symbol_table_element->next;
  }
  return stackframe_cross_reference_table;
}




stackframe_node * create_stackframe_cross_reference_table (symtab_node *symbol_table)
{
  stackframe_node *stackframe_cross_reference_table;
  symtab_node *symbol_table_element;
  unsigned long long int scope_level;

  stackframe_cross_reference_table = NULL;
  symbol_table_element = symbol_table;
  while (symbol_table_element != NULL)
  {
    if (symbol_table_element->attribute_type == _function)
    {
      scope_level = symbol_table_element->scope_level;
      if (symbol_table_element->identifier != NULL)
      {
        if (strncmp(symbol_table_element->identifier, "main", 4) == 0)
        {
          stackframe_cross_reference_table = create_stackframe_cross_reference_table_for_main_function (stackframe_cross_reference_table, symbol_table, scope_level);
        }
        else
        {
          stackframe_cross_reference_table = create_stackframe_cross_reference_table_for_function (stackframe_cross_reference_table, symbol_table, scope_level);
        }
      }
    }
    else
    {
      if (symbol_table_element->attribute_type == _procedure)
      {
        scope_level = symbol_table_element->scope_level;
        stackframe_cross_reference_table = create_stackframe_cross_reference_table_for_procedure (stackframe_cross_reference_table, symbol_table, scope_level);
      }
    }
    symbol_table_element = symbol_table_element->next;
  }
  return stackframe_cross_reference_table;
}




// *********************************************************************************************************************
// * add_new_symbol_table_entry_to_stackframe_cross_reference_table                                                    *
// *                                                                                                                   *
// * This table provides the negative offset relative to the stack pointer's current location for each variable stored *
// * in the stackframe for a given input named procedure (i.e. identifier). Each offset is cross-referenced with the   *
// * variables stored in each procecedure. This functionality is necessary when creating the assembler output code.    *
// *********************************************************************************************************************
stackframe_node * add_new_symbol_table_entry_to_stackframe_cross_reference_table (stackframe_node *stackframe_cross_reference_table, symtab_node *symbol_table, symtab_node *new_symbol_table_element)
{
  stackframe_node          *stackframe_element, *new_stackframe_element, *previous_stackframe_element;
  symtab_node              *symbol_table_element;
  token_node               *current_token;
  int                      comparison_result;
  unsigned long long int   scope_level;  
  size_t                   stackframe_offset, highest_stackframe_offset_for_current_scope;

  previous_stackframe_element = NULL;
  if ((stackframe_cross_reference_table != NULL) && (symbol_table != NULL) && (new_symbol_table_element != NULL))
  {
    highest_stackframe_offset_for_current_scope = 0;
    scope_level = new_symbol_table_element->scope_level;
// ********************************************************************************************************************************************
// * Now determine highest stackframe offset for given scope level to determine next stackframe offset to assign to new_symbol_table_element. *
// ********************************************************************************************************************************************
    stackframe_element = stackframe_cross_reference_table;
    while (stackframe_element != NULL)
    { 
      symbol_table_element = stackframe_element->symbol_table_entry;
      if (symbol_table_element != NULL)
      {
        if (symbol_table_element->scope_level == scope_level)
        {
          if (stackframe_element->stackframe_offset > highest_stackframe_offset_for_current_scope)
          {
            highest_stackframe_offset_for_current_scope = stackframe_element->stackframe_offset;
            previous_stackframe_element = stackframe_element;
          }
        }
      }
      stackframe_element = stackframe_element->next;
    }
    new_stackframe_element = (stackframe_node *) malloc(sizeof(stackframe_node));
    if (new_stackframe_element != NULL)
    {
      new_stackframe_element->symbol_table_entry    = new_symbol_table_element;
      new_stackframe_element->stackframe_offset     = highest_stackframe_offset_for_current_scope + 8;
      new_stackframe_element->storage_size_in_bytes = 8; // This datatype takes 8 bytes of storage space on a stack frame since it is a 64-bit pointer.
      new_stackframe_element->next                  = NULL;
      if (previous_stackframe_element != NULL)
      {   
        new_stackframe_element->next = previous_stackframe_element->next;
        previous_stackframe_element->next = new_stackframe_element;
      }
      else
      {
        stackframe_element = stackframe_cross_reference_table;
        while (stackframe_element->next != NULL)
        {
          stackframe_element = stackframe_element->next;
        }
        stackframe_element->next = new_stackframe_element; 
      }
    }
  }
  return stackframe_cross_reference_table;
}




symtab_node * allocate_additional_temporary_stack_storage_variables_for_calls_to_functions_and_procedures (symtab_node *symbol_table, ast_node *abstract_syntax_tree)
{
  ast_node *ast_element, *temp_ast_element;
  symtab_node *symbol_table_element, *temp_symbol_table_element, *symbol_table_element_for_function, *symbol_table_element_for_procedure;
  symtab_node *name_of_function_or_procedure_being_called_symbol_table_element, *temporary_storage_variable;
  param_node *parameter_list_element;
  int state, current_token_type;
  unsigned long long int scope_level, parameter_list_entry_counter, counter_for_new_variables;
  char *current_token;
  unsigned char new_variable[1024];

  //printf ("ENTERING allocate_additional_temporary_stack_storage_variables_for_calls_to_functions_and_procedures\n");
  symbol_table_element_for_function = NULL;
  symbol_table_element_for_procedure = NULL;
  parameter_list_element = NULL;
  scope_level = 0;
  parameter_list_entry_counter = 0;
  counter_for_new_variables = 0;
  if (symbol_table != NULL)
  {
    state = 0;
    ast_element = abstract_syntax_tree;
    while ((ast_element != NULL) && (state < 99999))
    {
      current_token = ast_element->token;
      current_token_type = ast_element->token_type;
      //printf ("state = %d, current_token = %s\n", state, current_token);
      switch (state)
      {
        case 0:
          if (ast_element->statement_type == _define)
          {
            state = 10;
          }
        break;
        case 10:
          if (current_token != NULL)
          {
            if (current_token_type == TOKEN_IDENTIFIER)
            {
              symbol_table_element_for_function = retrieve_symbol_table_element_for_function_or_procedure_name (symbol_table, current_token, _function);
              if (symbol_table_element_for_function != NULL)
              {
                scope_level = symbol_table_element_for_function->scope_level;
                state = 2000;
              }
              else
              {
                symbol_table_element_for_procedure = retrieve_symbol_table_element_for_function_or_procedure_name (symbol_table, current_token, _procedure);
                if (symbol_table_element_for_procedure != NULL)
                {
                  scope_level = symbol_table_element_for_procedure->scope_level;
                  state = 2000;
                }
                else
                {
                  state = 99999;
                }
              }
            }
            else
            {
              state = 99999;
            }
          }
        break;
        case 2000:
          if (ast_element->statement_type == _left_curly_brace)
          {
            state = 4000;
          }
          else
          {
            state = 99999;
          }
        break;
        case 4000:
          if ((ast_element->statement_type == _print)  || 
              (ast_element->statement_type == _set)    ||
              (ast_element->statement_type == _if)     ||
              (ast_element->statement_type == _else)   ||
              (ast_element->statement_type == _while)  ||
              (ast_element->statement_type == _left_curly_brace))
          {
            while (ast_element->sibling != NULL)
            {
              ast_element = ast_element->sibling;
            }
            state = 4000;
          }
          else
          {
            if (ast_element->statement_type == _call)
            {
              name_of_function_or_procedure_being_called_symbol_table_element = NULL;
              if (ast_element->sibling != NULL)
              {
                ast_element = ast_element->sibling;
                name_of_function_or_procedure_being_called_symbol_table_element = ast_element->symbol_table_entry;
              }
              if (name_of_function_or_procedure_being_called_symbol_table_element != NULL)
              {
                if (name_of_function_or_procedure_being_called_symbol_table_element->identifier != NULL)
                {
                  //printf ("name of function or procedure being called:    %s\n", name_of_function_or_procedure_being_called_symbol_table_element->identifier);
                  //printf ("scope_level (where call statement is located): %llu\n", scope_level);
                  parameter_list_entry_counter = 0;
                  parameter_list_element = name_of_function_or_procedure_being_called_symbol_table_element->parameter_list;
                  if (parameter_list_element != NULL)
                  {
                    symbol_table_set_status_to_available_unused_temporary_variables_for_numerical_expression_processing (symbol_table, scope_level);
                    counter_for_new_variables = 0;
                    parameter_list_entry_counter = 1;
                    while (parameter_list_element != NULL)
                    {
                      temporary_storage_variable = retrieve_unused_temporary_variable_for_numerical_expression_processing (symbol_table, _datatype, _pointer, scope_level);
                      if (temporary_storage_variable == NULL)
                      {
                        counter_for_new_variables++;
                        snprintf (&new_variable[0], sizeof(new_variable), "___temp%lld___", counter_for_new_variables);
                        while (identifier_already_exists_in_symbol_table(symbol_table, &new_variable[0], scope_level))
                        {
                          counter_for_new_variables++;
                          snprintf (&new_variable[0], sizeof(new_variable), "___temp%lld___", counter_for_new_variables);
                        }
                        symbol_table = add_symbol_table_element (symbol_table, &new_variable[0], _datatype, _pointer, 0, 0, 0, 0, scope_level, TRUE, FALSE);
                        temporary_storage_variable = retrieve_unused_temporary_variable_for_numerical_expression_processing (symbol_table, _datatype, _pointer, scope_level);
                      }
                      if (temporary_storage_variable != NULL)
                      {
                        temporary_storage_variable->internal_use_only_variable_is_available = FALSE;
                        parameter_list_element = parameter_list_element->next;
                        if (parameter_list_element != NULL)
                        {
                          parameter_list_entry_counter++;
                        }
                      }
                    }
                  }
                  while (ast_element->sibling != NULL)
                  {
                    ast_element = ast_element->sibling;
                  }
                  state = 4000;
                }
              }
            }
            else
            {
              if (ast_element->statement_type == _right_curly_brace)
              {
                if (ast_element->num_right_curly_braces < ast_element->num_left_curly_braces)
                {
                  state = 4000;
                }
                else
                {
                  if (ast_element->num_left_curly_braces == ast_element->num_right_curly_braces)
                  {
                    state = 0;
                  }
                  else
                  {
                    printf ("num_right_curly_braces IS GREATER THAN num_left_curly_braces!!! EXITING NOW.\n");
                    exit (EXIT_FAILURE);
                    state = 99999;
                  }
                }
              }
              else
              {
                printf ("UNKNOWN STATEMENT TYPE. EXITING NOW.\n");
                exit (EXIT_FAILURE);
                state = 99999;
              }
            }
          }
        break;
        default:
        break;
      }
      if (state < 99999)
      {
        if (ast_element->sibling != NULL)
        {
          ast_element = ast_element->sibling;
        }
        else
        {
          ast_element = ast_element->child;
        }
      }
    }
  }
  if (state == 99999)
  {
    // TODO: free all memory allocate to assembler_program
  }
  return symbol_table;
}




// *****************************************************************************************************
// * create_assembler_program_first_pass                                                               *
// *                                                                                                   *
// * In the first pass, generate labels for the following statements:                                  *
// *                                                                                                   *
// * IF-THEN-ELSE: IF, ELSE, and RIGHT CURLY BRACES that terminate an IF-THEN or ELSE statement block. *
// * WHILE:        RIGHT CURLY BRACE that terminates a WHILE statement.                                *
// *                                                                                                   * 
// * The labels are necessary for x86 assembler branch statements.                                     *
// *****************************************************************************************************
ast_node * create_assembler_program_first_pass (ast_node *abstract_syntax_tree)
{
  ast_node *ast_element, *temp_ast_element, *temp2_ast_element, *next_ast_element_after_if_then_statement_block, *next_ast_element_after_if_then_else_statement_blocks;
  asmblr_node *assembler_statement;
  int state;
  size_t token_string_length; 
  char *current_token;
  chaga_statement_type current_token_type;
  unsigned long long int *label, curly_brace_difference;

  state = 0;
  ast_element = abstract_syntax_tree;
  while ((ast_element != NULL) && (state < 99999))
  {
    current_token = ast_element->token;
    current_token_type = ast_element->token_type;
    //printf ("Inside create_assembler_program_first_pass: state = %d, current_token = %s\n", state, current_token);
    //printf ("number_of_left_curly_braces:  %lld\n", ast_element->num_left_curly_braces);
    //printf ("number_of_right_curly_braces: %lld\n", ast_element->num_right_curly_braces);
    switch (state)
    {
      case 0:
        if (ast_element->statement_type == _define)
        {
          state = 10;
        }
      break;
      case 10:
        current_token = ast_element->token;
        if (current_token != NULL)
        {
          if (current_token != NULL)
          {
            if (current_token_type == TOKEN_IDENTIFIER)
            {
              state = 2000;
            }
            else
            {
              state = 99999;
            }
          }
          else
          {
            state = 99999;
          }
        }
        else
        {
          state = 99999;
        }
      break;
      case 2000:
        if (ast_element->statement_type == _left_curly_brace)
        {
          state = 2100;
        }
        else
        {
          state = 99999;
        }
      break;
      case 2100:
        if ((ast_element->statement_type == _print) ||
            (ast_element->statement_type == _set))
        {
// **********************************************************
// * Advance to next statement in the Abstract syntax tree. *
// **********************************************************
          while (ast_element->sibling != NULL)
          {
            ast_element = ast_element->sibling;
          }
          state = 2100;
        }
        else
        {
          if (ast_element->statement_type == _if)
          {
            temp_ast_element = find_else_statement_associated_with_if_statement (ast_element);
            if (temp_ast_element != NULL)
            {
              temp_ast_element->label = (unsigned long long int *) malloc(sizeof(unsigned long long int));
              if (temp_ast_element->label != NULL)
              {
                label = retrieve_highest_label_number_from_abstract_syntax_tree (abstract_syntax_tree);
                if (label != NULL)
                {
                  *temp_ast_element->label = (*label) + 1;
                }
                else
                {
                  *temp_ast_element->label = 1;
                }
                ast_element->label_associated_with_else_statement = (unsigned long long int *) malloc(sizeof(unsigned long long int));
                if (ast_element->label_associated_with_else_statement != NULL)
                {
                  *ast_element->label_associated_with_else_statement = *temp_ast_element->label;
                }
                else
                {
                  state = 99999;
                }
                if (state != 99999)
                {
// ****************************************************************
// * Now find the next statement after the IF-THEN-ELSE statement *
// ****************************************************************
                  temp_ast_element = find_next_statement_after_if_then_else_statement (ast_element);
                  if (temp_ast_element != NULL)
                  {
                    temp_ast_element->label = (unsigned long long int *) malloc(sizeof(unsigned long long int));
                    if (temp_ast_element->label != NULL)
                    {
                      label = retrieve_highest_label_number_from_abstract_syntax_tree (abstract_syntax_tree);
                      if (label != NULL)
                      {
                        *temp_ast_element->label = (*label) + 1;
                      }
                      else
                      {
                        *temp_ast_element->label = 1;
                      }
                      ast_element->label_after_if_then_else_statement = (unsigned long long int *) malloc(sizeof(unsigned long long int));
                      if (ast_element->label_after_if_then_else_statement != NULL)
                      {
                        label = retrieve_highest_label_number_from_abstract_syntax_tree (abstract_syntax_tree);
                        if (label != NULL)
                        {
                          *temp_ast_element->label = (*label) + 1;
                        }
                        else
                        {
                          *temp_ast_element->label = 1;
                        }
                        *ast_element->label_after_if_then_else_statement = *temp_ast_element->label;
                      }
                      else
                      {
                        state = 99999;
                      }
                    }
                    else
                    {
                      state = 99999;
                    }
                    if (state != 99999)
                    {
// ***********************************************************************************************************
// * Now find the closing curly brace for the IF-THEN statement block for the current IF-THEN-ELSE statement *
// * This is important because I must insert an x86 assembler JUMP statement at the closing curly brace for  *
// * the IF-THEN statement block for the assembler code to JUMP over (avoid) the ELSE statement block which  *
// * follows. The jump will be to the first instruction after the IF-THEN-ELSE statement blocks.             *
// ***********************************************************************************************************
                      temp2_ast_element = find_closing_curly_brace_of_if_then_statement_block_for_if_then_else_statement (ast_element);
                      if (temp2_ast_element != NULL)
                      {
                        temp2_ast_element->insert_jump_statement = (unsigned long long int *) malloc(sizeof(unsigned long long int));
                        if (temp2_ast_element->insert_jump_statement != NULL)
                        {
                          *temp2_ast_element->insert_jump_statement = *temp_ast_element->label;
                        }
                        else
                        {
                          state = 99999;
                        }
                      }
                      else
                      {
                        state = 99999;
                      }
                    }
                  } 
                  else
                  {
                    state = 99999;
                  }
                }
              }
              else
              {
                state = 99999;
              }
            }
            else
            {
// ********************************************************************************************************************
// * There is no ELSE statement after the IF-THEN statement. Now find the next statement after the IF-THEN statement. *
// * The next statement will be one of the following:                                                                 *
// *                                                                                                                  *
// * RIGHT CURLY BRACE (closing an IF-THEN statement block)                                                           *
// * IF                                                                                                               *
// * PRINT                                                                                                            *
// * SET                                                                                                              *
// ********************************************************************************************************************
              temp_ast_element = find_next_statement_after_if_then_statement (ast_element);
              if (temp_ast_element != NULL)
              {
                temp_ast_element->label = (unsigned long long int *) malloc(sizeof(unsigned long long int));
                if (temp_ast_element->label != NULL)
                {
                  label = retrieve_highest_label_number_from_abstract_syntax_tree (abstract_syntax_tree);
                  if (label != NULL)
                  {
                    *temp_ast_element->label = (*label) + 1;
                  }
                  else
                  {
                    *temp_ast_element->label = 1;
                  }
                  ast_element->label_after_if_then_statement = (unsigned long long int *) malloc(sizeof(unsigned long long int));
                  if (ast_element->label_after_if_then_statement != NULL)
                  {
                    *ast_element->label_after_if_then_statement = *temp_ast_element->label;
                  }
                  else
                  {
                    state = 99999;
                  }
                }
                else
                {
                  state = 99999;
                }
              }
              else
              {
                state = 99999;
              }
            }
          }
          else
          {
            if (ast_element->statement_type == _while)
            {
              if (ast_element->label == NULL)
              {
                ast_element->label = (unsigned long long int *) malloc(sizeof(unsigned long long int));
                if (ast_element->label != NULL)
                {
                  label = retrieve_highest_label_number_from_abstract_syntax_tree (abstract_syntax_tree);
                  if (label != NULL)
                  {
                    *ast_element->label = (*label) + 1;
                  }
                  else
                  {
                    *ast_element->label = 1;
                  }
                }
              }
              temp_ast_element = find_next_statement_after_while_statement (ast_element);
              if (temp_ast_element != NULL)
              {
                if (temp_ast_element->label == NULL)
                {
                  temp_ast_element->label = (unsigned long long int *) malloc(sizeof(unsigned long long int));
                  if (temp_ast_element->label != NULL)
                  {
                    label = retrieve_highest_label_number_from_abstract_syntax_tree (abstract_syntax_tree);
                    if (label != NULL)
                    {
                      *temp_ast_element->label = (*label) + 1;
                    }
                    else
                    {
                      *temp_ast_element->label = 1;
                    }
                    ast_element->label_after_while_statement = (unsigned long long int *) malloc(sizeof(unsigned long long int));
                    if (ast_element->label_after_while_statement != NULL)
                    {
                      *ast_element->label_after_while_statement = *temp_ast_element->label;
                    }
                    else
                    {
                      state = 99999;
                    }
                  }
                  else
                  {
                    state = 99999;
                  }
                }
                else
                {
                  ast_element->label_after_while_statement = (unsigned long long int *) malloc(sizeof(unsigned long long int));
                  if (ast_element->label_after_while_statement != NULL)
                  {
                    *ast_element->label_after_while_statement = *temp_ast_element->label;
                  }
                  else
                  {
                    state = 99999;
                  }
                }
              }
              else
              {
                state = 99999;
              }
              if (state != 99999)
              {
// ********************************************************************************************************
// * Now find the closing curly brace for the current WHILE statement block. This is important because I  *
// * must insert an x86 assembler JUMP statement at the closing curly brace for the WHILE statement block *
// * for the assembler code to JUMP back to the beginning of the WHILE statement for a possible iteration *
// * again.                                                                                               *
// ********************************************************************************************************
                if (ast_element->label != NULL)
                {
                  temp2_ast_element = find_closing_curly_brace_of_while_statement_block (ast_element);
                  if (temp2_ast_element != NULL)
                  {
                    temp2_ast_element->insert_jump_statement = (unsigned long long int *) malloc(sizeof(unsigned long long int));
                    if (temp2_ast_element->insert_jump_statement != NULL)
                    {
                      *temp2_ast_element->insert_jump_statement = *ast_element->label;
                    }
                    else
                    {
                      state = 99999;
                    }
                  }
                  else
                  {
                    state = 99999;
                  }
                }
              }
            }
            else
            {
              if (ast_element->statement_type == _right_curly_brace)
              {
                curly_brace_difference = ast_element->num_left_curly_braces - ast_element->num_right_curly_braces;
                if (curly_brace_difference == 0)
                {
                  state = 0;
                }
              }
            }
          }
        }
        if (state < 99999)
        {
// **********************************************************
// * Advance to next statement in the Abstract syntax tree. *
// **********************************************************
          while (ast_element->sibling != NULL)
          {
            ast_element = ast_element->sibling;
          }
        }
      break;
      default:
        state = 99999;
      break;
    }
    if (state < 99999)
    {
      if (ast_element->sibling != NULL)
      {
        ast_element = ast_element->sibling;
      }
      else
      {
        ast_element = ast_element->child;
      }
    }
  }
  //printf ("\nAST AFTER FIRST PASS:\n\n");
  //ast_element = abstract_syntax_tree;
  //while (ast_element != NULL)
  //{
  //  if (ast_element->token != NULL)
  //  {
  //    printf ("%s ", ast_element->token);
  //    if (ast_element->label != NULL)
  //    {
  //      printf (" : LABEL = %lld", *ast_element->label);
  //    }
  //    if (ast_element->label_after_if_then_statement != NULL)
  //    {
  //      printf (" : LABEL AFTER IF THEN STATEMENT = %lld", *ast_element->label_after_if_then_statement);
  //    }
  //    if (ast_element->label_associated_with_else_statement != NULL)
  //    {
  //      printf (" : LABEL FOR ELSE STATEMENT ASSOCIATED WITH THIS IF STATEMENT = %lld", *ast_element->label_associated_with_else_statement);
  //    }
  //    if (ast_element->label_after_if_then_else_statement != NULL)
  //    {
  //      printf (" : LABEL AFTER IF THEN ELSE STATEMENT = %lld", *ast_element->label_after_if_then_else_statement);
  //    }
  //    if (ast_element->label_after_while_statement != NULL)
  //    {
  //      printf (" : LABEL AFTER WHILE STATEMENT BLOCK = %lld", *ast_element->label_after_while_statement);
  //    }
  //    if (ast_element->insert_jump_statement != NULL)
  //    {
  //      printf (" : INSERT jmp %lld", *ast_element->insert_jump_statement);
  //    }
  //    printf ("\n");
  //  }
  //  if (ast_element->sibling != NULL)
  //  {
  //    ast_element = ast_element->sibling;
  //  }
  //  else
  //  {
  //    ast_element = ast_element->child;
  //  }
  //}
  return abstract_syntax_tree;
}



asmblr_node * create_assembler_program (ast_node *abstract_syntax_tree, symtab_node *symbol_table, stackframe_node *stackframe_cross_reference_table)
{
  ast_node *ast_element, *temp_ast_element;
  symtab_node *symbol_table_element, *temp_symbol_table_element, *symbol_table_element_for_function, *symbol_table_element_for_procedure;
  asmblr_node *assembler_program, *assembler_output_for_function_or_procedure;
  expression_stack_node *expression_stack;
  stackframe_node *stackframe_element;
  int state, inside_main_function, inside_procedure, current_token_type;
  size_t token_string_length; 
  unsigned long long int scope_level;
  char *current_token;

  assembler_program = NULL;
  expression_stack = NULL;
  stackframe_element = NULL;
  symbol_table_element_for_function = NULL;
  symbol_table_element_for_procedure = NULL;
  scope_level = 0;
  if (symbol_table != NULL)
  {
    inside_main_function = FALSE;
    inside_procedure = FALSE;
    state = 0;
    ast_element = abstract_syntax_tree;
    while ((ast_element != NULL) && (state < 99999))
    {
      current_token = ast_element->token;
      current_token_type = ast_element->token_type;
      //printf ("Inside create_assembler_program: state = %d, current_token = %s\n", state, current_token);
      switch (state)
      {
        case 0:
          if (ast_element->statement_type == _define)
          {
            assembler_output_for_function_or_procedure = NULL;
            inside_main_function = FALSE;
            inside_procedure = FALSE;
            state = 10;
          }
        break;
        case 10:
          if (current_token != NULL)
          {
            if (current_token_type == TOKEN_IDENTIFIER)
            {
              symbol_table_element_for_function = retrieve_symbol_table_element_for_function_or_procedure_name (symbol_table, current_token, _function);
              if (symbol_table_element_for_function != NULL)
              {
                token_string_length = strlen (current_token);
                switch (token_string_length)
                {
                  case 4:
                    if (strncmp(current_token, "main", 4) == 0)
                    {
                      symbol_table_element = ast_element->symbol_table_entry;
                      if (symbol_table_element != NULL)
                      {
                        scope_level = symbol_table_element->scope_level;
                        assembler_program = create_assembler_output_for_main_function_definition (assembler_program, symbol_table, stackframe_cross_reference_table, scope_level);
                        inside_main_function = TRUE;
                        inside_procedure = FALSE;
                        state = 2000;
                      }
                    }
                    else
                    {
                      state = 99999;
                    }
                  break;
                  default:
                    state = 99999;
                  break;
                }
              }
              else
              {
                symbol_table_element_for_procedure = retrieve_symbol_table_element_for_function_or_procedure_name (symbol_table, current_token, _procedure);
                if (symbol_table_element_for_procedure != NULL)
                {
                  scope_level = symbol_table_element_for_procedure->scope_level;
                  assembler_program = create_assembler_output_for_procedure_definition (assembler_program, symbol_table, stackframe_cross_reference_table, symbol_table_element_for_procedure, scope_level);
                  inside_main_function = FALSE;
                  inside_procedure = TRUE;
                  state = 2000;
                }
                else
                {
                  state = 99999;
                }
              }
            }       
          }
        break;
        case 2000:
          if (ast_element->statement_type == _left_curly_brace)
          {
            state = 4000;
          }
          else
          {
            state = 99999;
          }
        break;
        case 4000:
          if (ast_element->statement_type == _print)
          {
            if (ast_element->label != NULL)
            {
              assembler_program = create_assembler_output_code_section_label (assembler_program, ast_element, scope_level);
            }
// ******************************
// * PRINT statement processing *
// ******************************
            assembler_program = create_assembler_output_print_statement (assembler_program, ast_element, stackframe_cross_reference_table, scope_level);
// ***************************************************************************************************
// * Now advance to the next statement since we've procssed all the tokens for the printf statement. *
// ***************************************************************************************************
            while (ast_element->sibling != NULL)
            {
              ast_element = ast_element->sibling;
            }
            state = 4000;
          }
          else
          {
            if (ast_element->statement_type == _set)
            {
              if (ast_element->label != NULL)
              {
                assembler_program = create_assembler_output_code_section_label (assembler_program, ast_element, scope_level);
              }
              state = 5000;
            }
            else
            {
              if (ast_element->statement_type == _if)
              {
                if (ast_element->label != NULL)
                {
                  assembler_program = create_assembler_output_code_section_label (assembler_program, ast_element, scope_level);
                }
                assembler_program = create_assembler_output_if_statement (assembler_program, ast_element, symbol_table, stackframe_cross_reference_table, scope_level);
                while (ast_element->sibling != NULL)
                {
                  ast_element = ast_element->sibling;
                }
                state = 4000;
              }
              else
              {
                if (ast_element->statement_type == _else)
                {
                  if (ast_element->label != NULL)
                  {
                    assembler_program = create_assembler_output_code_section_label (assembler_program, ast_element, scope_level);
                  }
                  state = 4000;
                }
                else
                {
                  if (ast_element->statement_type == _while)
                  {
                    if (ast_element->label != NULL)
                    {
                      assembler_program = create_assembler_output_code_section_label (assembler_program, ast_element, scope_level);
                    }
                    assembler_program = create_assembler_output_while_statement (assembler_program, ast_element, symbol_table, stackframe_cross_reference_table, scope_level);
                    while (ast_element->sibling != NULL)
                    {
                      ast_element = ast_element->sibling;
                    }
                    state = 4000;
                  }
                  else
                  {
                    if (ast_element->statement_type == _call)
                    {
                      if (ast_element->label != NULL)
                      {
                        assembler_program = create_assembler_output_code_section_label (assembler_program, ast_element, scope_level);
                      }
                      assembler_program = create_assembler_output_call_statement (assembler_program, ast_element, symbol_table, stackframe_cross_reference_table, scope_level);
                      while (ast_element->sibling != NULL)
                      {
                        ast_element = ast_element->sibling;
                      }
                      state = 4000;
                    }
                    else
                    {
                      if (ast_element->statement_type == _left_curly_brace)
                      {
                        state = 4000;
                      }
                      else
                      {
                        if (ast_element->statement_type == _right_curly_brace)
                        {
                          if (ast_element->label != NULL)
                          {
                            assembler_program = create_assembler_output_code_section_label (assembler_program, ast_element, scope_level);
                          }
                          if (ast_element->insert_jump_statement != NULL)
                          {
                            assembler_program = create_assembler_output_code_section_jump_statement (assembler_program, ast_element, scope_level);
                          }
                          if (ast_element->num_right_curly_braces < ast_element->num_left_curly_braces)
                          {
                            state = 4000;
                          }
                          else
                          {
                            if (ast_element->num_left_curly_braces == ast_element->num_right_curly_braces)
                            {
                              if (inside_main_function)
                              {
                                assembler_program = create_assembler_output_exit_main_function (assembler_program, stackframe_cross_reference_table, scope_level);
                                state = 0;
                              }
                              else
                              {
                                if (inside_procedure)
                                {
                                  assembler_program = create_assembler_output_return_from_procedure (assembler_program, stackframe_cross_reference_table, scope_level);
                                  state = 0;
                                }
                                else
                                {
                                  state = 99999;
                                }
                              }
                            }
                            else
                            {
                              printf ("num_right_curly_braces IS GREATER THAN num_left_curly_braces!!! EXITING NOW.\n");
                              exit (EXIT_FAILURE);
                              state = 99999;
                            }
                          }
                        }
                        else
                        {
                          printf ("UNKNOWN STATEMENT TYPE. EXITING NOW.\n");
                          exit (EXIT_FAILURE);
                          state = 99999;
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        break;
// ****************************
// * SET statement processing *
// ****************************
        case 5000:
          assembler_program = create_assembler_output_set_statement (assembler_program, ast_element, symbol_table, stackframe_cross_reference_table, scope_level);
          while (ast_element->sibling != NULL)
          {
            ast_element = ast_element->sibling;
          }
          state = 4000;
        break;
        default:
        break;
      }
      if (state < 99999)
      {
        if (ast_element->sibling != NULL)
        {
          ast_element = ast_element->sibling;
        }
        else
        {
          ast_element = ast_element->child;
        }
      }
    }
  }
  if (state == 99999)
  {
    // TODO: free all memory allocate to assembler_program
  }
  return assembler_program;
}




// ********************************************************************************
// * This subroutine creates assembly language code for main function definition. *
// ********************************************************************************
asmblr_node * create_assembler_output_for_main_function_definition (asmblr_node *assembler_program, symtab_node *symbol_table, stackframe_node *stackframe_cross_reference_table, unsigned long long int scope_level)
{
  asmblr_node *assembler_statement, *assembler_element, *temp_assembler_element;
  symtab_node *symbol_table_element;
  size_t token_string_length, buffer_size, num_datatype_declarations, i, j, stackframe_storage_allocation_in_bytes;
  unsigned char temp_buffer[1024];

  assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
  if (assembler_statement != NULL)
  {
    assembler_statement->scope_level = scope_level;  // Program sections are organized by scope level
    assembler_statement->label = NULL;
    assembler_statement->label_associated_with_else_statement = NULL;
    assembler_statement->label_after_if_then_else_statement = NULL;
    assembler_statement->code_section_contents = NULL;       
    assembler_statement->data_section_contents = NULL;       
    assembler_statement->next = NULL;
    num_datatype_declarations = symbol_table_count_number_of_datatype_declarations_for_given_scope_level_excluding_argv_argc_in_main (symbol_table, scope_level);
    if (num_datatype_declarations == 0)
    {
      buffer_size = 256;
      assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * buffer_size);
      if (assembler_statement->code_section_contents != NULL)
      {
        strncpy (assembler_statement->code_section_contents, "        .text\n        .globl main\n        .type main, @function\nmain:\n        endbr64\n        push rbp\n        mov rbp, rsp\n", buffer_size);
      }
    }
    else
    {
// ****************************************************************************************************************************************
// * I need to output the following x86 assembler code to initialize each variable declared in the main procedure (except argc and argc). *
// * This code intializes each pointer to NULL.                                                                                           *
// *                                                                                                                                      *
// * An unsigned long long int may contain a MINIMUM 1 digit and a MAXIMUM 20 digits. Worst case scenario:                                *
// * "    mov QWORD PTR -12345678901234567890[rbp], 0\n"                                                                                  *
// *  123456789012345678901234567890123456789012345678                                                                                    *
// * Therefore (in a worst-case scenario) I need 50 bytes (for each variable declared) + 1 (for NULL terminating byte at end of buffer).  *
// ****************************************************************************************************************************************
      buffer_size = 256 + 64 * num_datatype_declarations; // this includes the one extra byte for NULL terminator at end of buffer.
      assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * buffer_size);
      if (assembler_statement->code_section_contents != NULL)
      {
        strncpy (assembler_statement->code_section_contents, "        .text\n        .globl main\n        .type main, @function\nmain:\n        endbr64\n        push rbp\n        mov rbp, rsp\n", buffer_size);
// **************************************************************************************************************************************
// * Now subtract an offset to the stack to allocate storage space for each variable defined in main. In GNU/Linux, stackframe storage  *
// * space must be on increments of 16 bytes. This is outlined in what is called the Application Binary Interface (ABI).                *
// *                                                                                                                                    *
// *                                                                                                                                    *
// * Example 1: One variable is declared in main. That variable is a 64-bit pointer. It requires 8 bytes of storage space on the stack. *
// *    Result: 16 bytes of storage space is allocated on the stack.                                                                    * 
// *                                                                                                                                    *
// *                                                                                                                                    *
// * Example 2: Three variables are declared in main. Each variable is a 64-bit pointer. Each pointer requires 8 bytes of storage on    *
// *            the stack. Thus the three pointers need 24 bytes of storage.                                                            *
// *    Result: 32 bytes of storage space is allocated on the stack since 32 bytes is the next increment of 16 bytes that can safely    *
// *            store 24 bytes.                                                                                                         *
// **************************************************************************************************************************************
        stackframe_storage_allocation_in_bytes = determine_stackframe_storage_size_for_all_locally_defined_variables_in_main (stackframe_cross_reference_table, symbol_table);
        snprintf (&temp_buffer[0], sizeof(temp_buffer), "        sub rsp, %ld\n", stackframe_storage_allocation_in_bytes); 
        strncat (assembler_statement->code_section_contents, &temp_buffer[0], buffer_size);
// ***************************************************************
// * Now initialize all local variables in main to zero or NULL. *
// ***************************************************************
        j = 1;
        i = stackframe_storage_allocation_in_bytes;
        while (i > 0)
        {
          snprintf (&temp_buffer[0], sizeof(temp_buffer), "        mov QWORD PTR -%ld[rbp], 0\n", j*8);
          strncat (assembler_statement->code_section_contents, &temp_buffer[0], buffer_size);
          j++;
          i = i - 8;
        }
      }
    }
    if (assembler_program != NULL)
    {
      temp_assembler_element = assembler_program;
      while (temp_assembler_element->next != NULL)
      {
        temp_assembler_element = temp_assembler_element->next;
      }
      temp_assembler_element->next = assembler_statement;
    }
    else
    {
      assembler_program = assembler_statement;
    }
  }
  return assembler_program;
}




// **************************************************************************************
// * This subroutine creates assembly language code for a general procedure definition. *
// **************************************************************************************
asmblr_node * create_assembler_output_for_procedure_definition (asmblr_node *assembler_program, symtab_node *symbol_table, stackframe_node *stackframe_cross_reference_table, symtab_node *symbol_table_element_for_procedure, unsigned long long int scope_level)
{
  asmblr_node *assembler_statement, *assembler_element, *temp_assembler_element;
  symtab_node *symbol_table_element;
  param_node *parameter_list_element;
  stackframe_node *stackframe_element;
  param_mapping_node *parameter_mapping_list, *parameter_mapping_element1, *parameter_mapping_element2, *parameter_mapping_element3, *parameter_mapping_element4;
  param_mapping_node *parameter_mapping_element5, *parameter_mapping_element6, *parameter_mapping_element7, *parameter_mapping_element8, *parameter_mapping_element9;
  size_t token_string_length, length_of_procedure_name, buffer_size, num_datatype_declarations, i, j, stackframe_storage_allocation_in_bytes;
  unsigned char temp_buffer[1024];
  unsigned long long int parameter_list_entry_counter;

  parameter_mapping_list = NULL;
  if (symbol_table_element_for_procedure != NULL)
  {
    if (symbol_table_element_for_procedure->identifier != NULL)
    {
      if (symbol_table_element_for_procedure->attribute_type == _procedure)
      {
        length_of_procedure_name = strlen (symbol_table_element_for_procedure->identifier);
        if (length_of_procedure_name > 0)
        {
          assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
          if (assembler_statement != NULL)
          {
            assembler_statement->scope_level = scope_level;  // Program sections are organized by scope level
            assembler_statement->label = NULL;
            assembler_statement->label_associated_with_else_statement = NULL;
            assembler_statement->label_after_if_then_else_statement = NULL;
            assembler_statement->code_section_contents = NULL;       
            assembler_statement->data_section_contents = NULL;       
            assembler_statement->next = NULL;
            buffer_size = 256 + length_of_procedure_name * 3;
            assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * buffer_size);
            if (assembler_statement->code_section_contents != NULL)
            {
              snprintf (assembler_statement->code_section_contents, buffer_size, "        .text\n        .globl %s\n        .type %s, @function\n%s:\n        endbr64\n        push rbp\n        mov rbp, rsp\n", symbol_table_element_for_procedure->identifier, symbol_table_element_for_procedure->identifier, symbol_table_element_for_procedure->identifier);
            }
            if (assembler_program != NULL)
            {
              temp_assembler_element = assembler_program;
              while (temp_assembler_element->next != NULL)
              {
                temp_assembler_element = temp_assembler_element->next;
              }
              temp_assembler_element->next = assembler_statement;
            }
            else
            {
              assembler_program = assembler_statement;
            }
          }   
// ***********************************************************************************************************************************************
// * Now subtract an offset to the stack to allocate storage space for each variable defined in the procedure. In GNU/Linux, stackframe storage  *
// * space must be on increments of 16 bytes. This is outlined in what is called the Application Binary Interface (ABI).                         *
// *                                                                                                                                             *
// *                                                                                                                                             *
// * Example 1: One variable is declared. That variable is a 64-bit pointer. It requires 8 bytes of storage space on the stack.                  *
// *    Result: 16 bytes of storage space is allocated on the stack.                                                                             * 
// *                                                                                                                                             *
// *                                                                                                                                             *
// * Example 2: Three variables are declared. Each variable is a 64-bit pointer. Each pointer requires 8 bytes of storage on                     *
// *            the stack. Thus the three pointers need 24 bytes of storage.                                                                     *
// *    Result: 32 bytes of storage space is allocated on the stack since 32 bytes is the next increment of 16 bytes that can safely             *
// *            store 24 bytes.                                                                                                                  *
// ***********************************************************************************************************************************************
          stackframe_storage_allocation_in_bytes = determine_stackframe_storage_size_for_all_locally_defined_variables_based_on_scope_level (stackframe_cross_reference_table, symbol_table, scope_level);
          if (stackframe_storage_allocation_in_bytes > 0)
          {
            assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
            if (assembler_statement != NULL)
            {
              assembler_statement->scope_level = scope_level;  // Program sections are organized by scope level
              assembler_statement->label = NULL;
              assembler_statement->label_associated_with_else_statement = NULL;
              assembler_statement->label_after_if_then_else_statement = NULL;
              assembler_statement->code_section_contents = NULL;       
              assembler_statement->data_section_contents = NULL;       
              assembler_statement->next = NULL;
              buffer_size = 128;
              assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * buffer_size);
              if (assembler_statement->code_section_contents != NULL)
              {
                snprintf (assembler_statement->code_section_contents, buffer_size, "        sub rsp, %ld\n", stackframe_storage_allocation_in_bytes);  
              }
              if (assembler_program != NULL)
              {
                temp_assembler_element = assembler_program;
                while (temp_assembler_element->next != NULL)
                {
                  temp_assembler_element = temp_assembler_element->next;
                }
                temp_assembler_element->next = assembler_statement;
              }
              else
              {
                assembler_program = assembler_statement;
              }
            }
// *******************************************************************************************
// * Initialize all temporary and local variables on the stackframe for the local procedure. *
// *******************************************************************************************
            j = 1;
            i = stackframe_storage_allocation_in_bytes;
            while (i > 0)
            {
              assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
              if (assembler_statement != NULL)
              {
                assembler_statement->scope_level = scope_level;  // Program sections are organized by scope level
                assembler_statement->label = NULL;
                assembler_statement->label_associated_with_else_statement = NULL;
                assembler_statement->label_after_if_then_else_statement = NULL;
                assembler_statement->code_section_contents = NULL;       
                assembler_statement->data_section_contents = NULL;       
                assembler_statement->next = NULL;
                buffer_size = 256;
                assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * buffer_size);
                if (assembler_statement->code_section_contents != NULL)
                {
                  snprintf (assembler_statement->code_section_contents, buffer_size, "        mov QWORD PTR -%ld[rbp], 0\n", j*8);
                  if (assembler_program != NULL)
                  {
                    temp_assembler_element = assembler_program;
                    while (temp_assembler_element->next != NULL)
                    {
                      temp_assembler_element = temp_assembler_element->next;
                    }
                    temp_assembler_element->next = assembler_statement;
                  }
                  else
                  {
                    assembler_program = assembler_statement;
                  }
                }
                else
                {
                  printf ("ERROR: malloc() failed to allocate memory. Exiting now.\n");
                  exit (EXIT_FAILURE);
                }
                j++;
                i = i - 8;
              }
            }
          }
// **************************************************************************************************************************
// * Any local parameters declared by the function or procedure must receive and store those values on the local stackframe *
// * allocated for the function or procedure or function.                                                                   *
// *                                                                                                                        *
// * The next step is count the number of local parameters input to this declared function or procedure.                    *
// **************************************************************************************************************************
          //printf ("\n\n\n");
          //printf ("symbol_table_element_for_procedure->identifier = %s\n", symbol_table_element_for_procedure->identifier);
          //printf ("scope_level                                    = %llu\n", scope_level);
          parameter_list_entry_counter = 0;
          parameter_list_element = symbol_table_element_for_procedure->parameter_list;
          if (parameter_list_element != NULL)
          {
// ********************************************************************************************************
// * The function or procedure has one or more parameters that must be received from the calling program. *
// *                                                                                                      *
// * The next step is count the number of parameters to be received.                                      *
// ********************************************************************************************************
            parameter_list_entry_counter = 1;
            while (parameter_list_element != NULL)
            {
              if (parameter_list_element->identifier != NULL)
              {
                //printf ("Parameter list identifier                      = %s\n", parameter_list_element->identifier);
                stackframe_element = retrieve_stackframe_offset_for_input_datatype_identifier_name_and_scope (stackframe_cross_reference_table, parameter_list_element->identifier, scope_level);
                if (stackframe_element != NULL)
                {
                  parameter_mapping_list = add_parameter_mapping_element (parameter_mapping_list, parameter_list_entry_counter, stackframe_element->stackframe_offset, parameter_list_element->datatype);
                  //printf ("Stack frame offset                             = %ld\n", stackframe_element->stackframe_offset);
                }
              }  
              parameter_list_element = parameter_list_element->next;
              if (parameter_list_element != NULL)
              {
                parameter_list_entry_counter++;
              }
            }
            //printf ("parameter_list_entry_counter                   = %llu\n", parameter_list_entry_counter);
            switch (parameter_list_entry_counter)
            {
              case 1:
// **************************************************************************************************************
// * One parameter is defined in the procedure or function. I will retrieve the parameter being passed in from  *
// * the calling program via a register. Then I will generate the x86 assembler instructions to receive the one *
// * parameter and store it on the local stack frame.                                                           *
// **************************************************************************************************************
                if (parameter_mapping_list != NULL)
                {
                  assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
                  if (assembler_statement != NULL)
                  {
                    assembler_statement->scope_level = scope_level;  // Program sections are organized by scope level
                    assembler_statement->label = NULL;
                    assembler_statement->label_associated_with_else_statement = NULL;
                    assembler_statement->label_after_if_then_else_statement = NULL;
                    assembler_statement->code_section_contents = NULL;       
                    assembler_statement->data_section_contents = NULL;       
                    assembler_statement->next = NULL;
                    buffer_size = 256;
                    assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * buffer_size);
                    if (assembler_statement->code_section_contents != NULL)
                    {
                      snprintf (assembler_statement->code_section_contents, buffer_size, "        mov QWORD PTR -%ld[rbp], rdi\n", parameter_mapping_list->stackframe_offset);
                    }
                    if (assembler_program != NULL)
                    {
                      temp_assembler_element = assembler_program;
                      while (temp_assembler_element->next != NULL)
                      {
                        temp_assembler_element = temp_assembler_element->next;
                      }
                      temp_assembler_element->next = assembler_statement;
                    }
                    else
                    {
                      assembler_program = assembler_statement;
                    }
                  }
                }
              break;
              case 2:
// **************************************************************************************************************
// * Two parameters are defined in the procedure or function. I will retrieve the two parameters being passed   *
// * in from the calling program via registers. Then I will generate the x86 assembler instructions to receive  *
// * the two parameters and store those parameters on the local stack frame.                                    *
// **************************************************************************************************************
                parameter_mapping_element1 = NULL;
                parameter_mapping_element2 = NULL;
                if (parameter_mapping_list != NULL)
                {
                  parameter_mapping_element2 = parameter_mapping_list;
                }
                if (parameter_mapping_element2 != NULL)
                {
                  parameter_mapping_element1 = parameter_mapping_element2->next;
                }
                if ((parameter_mapping_element1 != NULL) && (parameter_mapping_element2 != NULL))
                {
                  assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
                  if (assembler_statement != NULL)
                  {
                    assembler_statement->scope_level = scope_level;  // Program sections are organized by scope level
                    assembler_statement->label = NULL;
                    assembler_statement->label_associated_with_else_statement = NULL;
                    assembler_statement->label_after_if_then_else_statement = NULL;
                    assembler_statement->code_section_contents = NULL;       
                    assembler_statement->data_section_contents = NULL;       
                    assembler_statement->next = NULL;
                    buffer_size = 256;
                    assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * buffer_size);
                    if (assembler_statement->code_section_contents != NULL)
                    {
                      snprintf (assembler_statement->code_section_contents, buffer_size, "        mov QWORD PTR -%ld[rbp], rdi\n        mov QWORD PTR -%ld[rbp], rsi\n", parameter_mapping_element1->stackframe_offset, parameter_mapping_element2->stackframe_offset);
                    }
                    if (assembler_program != NULL)
                    {
                      temp_assembler_element = assembler_program;
                      while (temp_assembler_element->next != NULL)
                      {
                        temp_assembler_element = temp_assembler_element->next;
                      }
                      temp_assembler_element->next = assembler_statement;
                    }
                    else
                    {
                      assembler_program = assembler_statement;
                    }
                  }
                }
// ************************************************************************************************************************
// * The last step: initialize all temporary and local variables on the stackframe for the local procedure EXCEPT for the *
// * two parameters passed in to the procedure.                                                                           *
// ************************************************************************************************************************
              break;
              case 3:
// ****************************************************************************************************************
// * Three parameters are defined in the procedure or function. I will retrieve the three parameters being passed *
// * in from the calling program via registers. Then I will generate the x86 assembler instructions to receive    *
// * the three parameters and store those parameters on the local stack frame.                                    *
// ****************************************************************************************************************
                parameter_mapping_element1 = NULL;
                parameter_mapping_element2 = NULL;
                parameter_mapping_element3 = NULL;
                if (parameter_mapping_list != NULL)
                {
                  parameter_mapping_element3 = parameter_mapping_list;
                }
                if (parameter_mapping_element3 != NULL)
                {
                  parameter_mapping_element2 = parameter_mapping_element3->next;
                }
                if (parameter_mapping_element2 != NULL)
                {
                  parameter_mapping_element1 = parameter_mapping_element2->next;
                }
                if ((parameter_mapping_element1 != NULL) && (parameter_mapping_element2 != NULL) && (parameter_mapping_element3 != NULL))
                {
                  assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
                  if (assembler_statement != NULL)
                  {
                    assembler_statement->scope_level = scope_level;  // Program sections are organized by scope level
                    assembler_statement->label = NULL;
                    assembler_statement->label_associated_with_else_statement = NULL;
                    assembler_statement->label_after_if_then_else_statement = NULL;
                    assembler_statement->code_section_contents = NULL;       
                    assembler_statement->data_section_contents = NULL;       
                    assembler_statement->next = NULL;
                    buffer_size = 256;
                    assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * buffer_size);
                    if (assembler_statement->code_section_contents != NULL)
                    {
                      snprintf (assembler_statement->code_section_contents, buffer_size, "        mov QWORD PTR -%ld[rbp], rdi\n        mov QWORD PTR -%ld[rbp], rsi\n        mov QWORD PTR -%ld[rbp], rdx\n", parameter_mapping_element1->stackframe_offset, parameter_mapping_element2->stackframe_offset, parameter_mapping_element3->stackframe_offset);
                    }
                    if (assembler_program != NULL)
                    {
                      temp_assembler_element = assembler_program;
                      while (temp_assembler_element->next != NULL)
                      {
                        temp_assembler_element = temp_assembler_element->next;
                      }
                      temp_assembler_element->next = assembler_statement;
                    }
                    else
                    {
                      assembler_program = assembler_statement;
                    }
                  }
                }
              break;
              case 4:
// **************************************************************************************************************
// * Four parameters are defined in the procedure or function. I will retrieve the four parameters being passed *
// * in from the calling program via registers. Then I will generate the x86 assembler instructions to receive  *
// * the four parameters and store those parameters on the local stack frame.                                   *
// **************************************************************************************************************
                parameter_mapping_element1 = NULL;
                parameter_mapping_element2 = NULL;
                parameter_mapping_element3 = NULL;
                parameter_mapping_element4 = NULL;
                if (parameter_mapping_list != NULL)
                {
                  parameter_mapping_element4 = parameter_mapping_list;
                }
                if (parameter_mapping_element4 != NULL)
                {
                  parameter_mapping_element3 = parameter_mapping_element4->next;
                }
                if (parameter_mapping_element3 != NULL)
                {
                  parameter_mapping_element2 = parameter_mapping_element3->next;
                }
                if (parameter_mapping_element2 != NULL)
                {
                  parameter_mapping_element1 = parameter_mapping_element2->next;
                }
                if ((parameter_mapping_element1 != NULL) && 
                    (parameter_mapping_element2 != NULL) && 
                    (parameter_mapping_element3 != NULL) &&
                    (parameter_mapping_element4 != NULL))
                {
                  assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
                  if (assembler_statement != NULL)
                  {
                    assembler_statement->scope_level = scope_level;  // Program sections are organized by scope level
                    assembler_statement->label = NULL;
                    assembler_statement->label_associated_with_else_statement = NULL;
                    assembler_statement->label_after_if_then_else_statement = NULL;
                    assembler_statement->code_section_contents = NULL;       
                    assembler_statement->data_section_contents = NULL;       
                    assembler_statement->next = NULL;
                    buffer_size = 512;
                    assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * buffer_size);
                    if (assembler_statement->code_section_contents != NULL)
                    {
                      snprintf (assembler_statement->code_section_contents, buffer_size, "        mov QWORD PTR -%ld[rbp], rdi\n        mov QWORD PTR -%ld[rbp], rsi\n        mov QWORD PTR -%ld[rbp], rdx\n        mov QWORD PTR -%ld[rbp], rcx\n", parameter_mapping_element1->stackframe_offset, parameter_mapping_element2->stackframe_offset, parameter_mapping_element3->stackframe_offset, parameter_mapping_element4->stackframe_offset);
                    }
                    if (assembler_program != NULL)
                    {
                      temp_assembler_element = assembler_program;
                      while (temp_assembler_element->next != NULL)
                      {
                        temp_assembler_element = temp_assembler_element->next;
                      }
                      temp_assembler_element->next = assembler_statement;
                    }
                    else
                    {
                      assembler_program = assembler_statement;
                    }
                  }
                }
              break;
              case 5:
// **************************************************************************************************************
// * Five parameters are defined in the procedure or function. I will retrieve the five parameters being passed *
// * in from the calling program via registers. Then I will generate the x86 assembler instructions to receive  *
// * the five parameters and store those parameters on the local stack frame.                                   *
// **************************************************************************************************************
                parameter_mapping_element1 = NULL;
                parameter_mapping_element2 = NULL;
                parameter_mapping_element3 = NULL;
                parameter_mapping_element4 = NULL;
                parameter_mapping_element5 = NULL;
                if (parameter_mapping_list != NULL)
                {
                  parameter_mapping_element5 = parameter_mapping_list;
                }
                if (parameter_mapping_element5 != NULL)
                {
                  parameter_mapping_element4 = parameter_mapping_element5->next;
                }
                if (parameter_mapping_element4 != NULL)
                {
                  parameter_mapping_element3 = parameter_mapping_element4->next;
                }
                if (parameter_mapping_element3 != NULL)
                {
                  parameter_mapping_element2 = parameter_mapping_element3->next;
                }
                if (parameter_mapping_element2 != NULL)
                {
                  parameter_mapping_element1 = parameter_mapping_element2->next;
                }
                if ((parameter_mapping_element1 != NULL) && 
                    (parameter_mapping_element2 != NULL) && 
                    (parameter_mapping_element3 != NULL) &&
                    (parameter_mapping_element4 != NULL) &&
                    (parameter_mapping_element5 != NULL))
                {
                  assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
                  if (assembler_statement != NULL)
                  {
                    assembler_statement->scope_level = scope_level;  // Program sections are organized by scope level
                    assembler_statement->label = NULL;
                    assembler_statement->label_associated_with_else_statement = NULL;
                    assembler_statement->label_after_if_then_else_statement = NULL;
                    assembler_statement->code_section_contents = NULL;       
                    assembler_statement->data_section_contents = NULL;       
                    assembler_statement->next = NULL;
                    buffer_size = 512;
                    assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * buffer_size);
                    if (assembler_statement->code_section_contents != NULL)
                    {
                      snprintf (assembler_statement->code_section_contents, buffer_size, "        mov QWORD PTR -%ld[rbp], rdi\n        mov QWORD PTR -%ld[rbp], rsi\n        mov QWORD PTR -%ld[rbp], rdx\n        mov QWORD PTR -%ld[rbp], rcx\n        mov QWORD PTR -%ld[rbp], r8\n", parameter_mapping_element1->stackframe_offset, parameter_mapping_element2->stackframe_offset, parameter_mapping_element3->stackframe_offset, parameter_mapping_element4->stackframe_offset, parameter_mapping_element5->stackframe_offset);
                    }
                    if (assembler_program != NULL)
                    {
                      temp_assembler_element = assembler_program;
                      while (temp_assembler_element->next != NULL)
                      {
                        temp_assembler_element = temp_assembler_element->next;
                      }
                      temp_assembler_element->next = assembler_statement;
                    }
                    else
                    {
                      assembler_program = assembler_statement;
                    }
                  }
                }
              break;
              case 6:
// *************************************************************************************************************
// * Six parameters are defined in the procedure or function. I will retrieve the six parameters being passed  *
// * in from the calling program via registers. Then I will generate the x86 assembler instructions to receive *
// * the six parameters and store those parameters on the local stack frame.                                   *
// *************************************************************************************************************
                parameter_mapping_element1 = NULL;
                parameter_mapping_element2 = NULL;
                parameter_mapping_element3 = NULL;
                parameter_mapping_element4 = NULL;
                parameter_mapping_element5 = NULL;
                parameter_mapping_element6 = NULL;
                if (parameter_mapping_list != NULL)
                {
                  parameter_mapping_element6 = parameter_mapping_list;
                }
                if (parameter_mapping_element6 != NULL)
                {
                  parameter_mapping_element5 = parameter_mapping_element6->next;
                }
                if (parameter_mapping_element5 != NULL)
                {
                  parameter_mapping_element4 = parameter_mapping_element5->next;
                }
                if (parameter_mapping_element4 != NULL)
                {
                  parameter_mapping_element3 = parameter_mapping_element4->next;
                }
                if (parameter_mapping_element3 != NULL)
                {
                  parameter_mapping_element2 = parameter_mapping_element3->next;
                }
                if (parameter_mapping_element2 != NULL)
                {
                  parameter_mapping_element1 = parameter_mapping_element2->next;
                }
                if ((parameter_mapping_element1 != NULL) && 
                    (parameter_mapping_element2 != NULL) && 
                    (parameter_mapping_element3 != NULL) &&
                    (parameter_mapping_element4 != NULL) &&
                    (parameter_mapping_element5 != NULL) &&
                    (parameter_mapping_element6 != NULL))
                {
                  assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
                  if (assembler_statement != NULL)
                  {
                    assembler_statement->scope_level = scope_level;  // Program sections are organized by scope level
                    assembler_statement->label = NULL;
                    assembler_statement->label_associated_with_else_statement = NULL;
                    assembler_statement->label_after_if_then_else_statement = NULL;
                    assembler_statement->code_section_contents = NULL;       
                    assembler_statement->data_section_contents = NULL;       
                    assembler_statement->next = NULL;
                    buffer_size = 512;
                    assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * buffer_size);
                    if (assembler_statement->code_section_contents != NULL)
                    {
                      snprintf (assembler_statement->code_section_contents, buffer_size, "        mov QWORD PTR -%ld[rbp], rdi\n        mov QWORD PTR -%ld[rbp], rsi\n        mov QWORD PTR -%ld[rbp], rdx\n        mov QWORD PTR -%ld[rbp], rcx\n        mov QWORD PTR -%ld[rbp], r8\n        mov QWORD PTR -%ld[rbp], r9\n", parameter_mapping_element1->stackframe_offset, parameter_mapping_element2->stackframe_offset, parameter_mapping_element3->stackframe_offset, parameter_mapping_element4->stackframe_offset, parameter_mapping_element5->stackframe_offset, parameter_mapping_element6->stackframe_offset);
                    }
                    if (assembler_program != NULL)
                    {
                      temp_assembler_element = assembler_program;
                      while (temp_assembler_element->next != NULL)
                      {
                        temp_assembler_element = temp_assembler_element->next;
                      }
                      temp_assembler_element->next = assembler_statement;
                    }
                    else
                    {
                      assembler_program = assembler_statement;
                    }
                  }
                }
              break;
              default:
                printf ("ERROR: Parameter passing to functions or procedures with seven or more parameters is not supported at this time.\n");
                exit (EXIT_FAILURE);
              break;
            }
          }
        }
      }
    }
  }
  return assembler_program;
}




// ********************************************************************************************************************************
// * create_assembler_output_print_statement                                                                                      *
// *                                                                                                                              *
// * This subroutine creates the assembler output for a printf() statement.                                                       *
// *                                                                                                                              *
// * NOTE: This subroutine is limited to generating assembler output for STATIC (non-changing) string data in a printf statement. *
// *       formatting options inside printf are not supported yet.                                                                *
// ********************************************************************************************************************************
asmblr_node * create_assembler_output_print_statement (asmblr_node *assembler_program, ast_node *abstract_syntax_tree, stackframe_node *stackframe_cross_reference_table, unsigned long long int scope_level)
{
  asmblr_node     *assembler_statement, *assembler_element, *temp_assembler_element;
  ast_node        *ast_element;
  binstr_node     *binary_output_string;
  stackframe_node *stackframe_element;
  symtab_node     *symbol_table_entry;
  unsigned char byte, *hex_string, *data_section_string_buffer;
  int state, token_type;
  size_t i, j, token_string_length, code_section_string_buffer_max_length, data_section_string_buffer_length; 
  unsigned long long int *label;
  char *token, *escaped_double_quotes_token;

  state = 0;
  ast_element = abstract_syntax_tree;
  while ((ast_element != NULL) && (state != 99999))
  {
    token = ast_element->token;
    if (token != NULL)
    {
      //printf ("In create_assembler_output_print_statement: state = %d, token = %s\n", state, token);
    }
    switch (state)
    {
      case 0:
        assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
        if (assembler_statement != NULL)
        {
          assembler_statement->scope_level = scope_level;
          assembler_statement->label = NULL;
          assembler_statement->label_associated_with_else_statement = NULL;
          assembler_statement->label_after_if_then_else_statement = NULL;
          assembler_statement->code_section_contents = NULL;       
          assembler_statement->data_section_contents = NULL;       
          assembler_statement->next = NULL;
          state = 10;
          ast_element = ast_element->sibling;
        }
        else
        {
          state = 99999;
        }
      break;
      case 10:
        if (assembler_statement != NULL)
        {
          token = ast_element->token;
          token_type = ast_element->token_type;
          if (token != NULL)
          {
            if (token_type == TOKEN_STRING)
            {
              assembler_statement->label = (unsigned long long int *) malloc(sizeof(unsigned long long int));
              if (assembler_statement->label != NULL)
              {
                label = retrieve_highest_label_number_from_assembly_output (assembler_program);
                if (label != NULL)
                {
                  *assembler_statement->label = (*label) + 1;
                }
                else
                {
                  *assembler_statement->label = 1;
                }
// ********************************************************************************************************
// * All double quotes found within a token must be escaped! If not, it will cause the assembler to fail. *
// ********************************************************************************************************
                escaped_double_quotes_token = escape_double_quotes_inside_text (token);
                if (escaped_double_quotes_token != NULL)
                {
                  token_string_length = strlen(escaped_double_quotes_token);
                  data_section_string_buffer_length = token_string_length + 37;
                  data_section_string_buffer = (unsigned char *) malloc(sizeof(char)*data_section_string_buffer_length); 
                  if (data_section_string_buffer != NULL)
                  {
                    data_section_string_buffer[0]  = ' ';
                    data_section_string_buffer[1]  = ' ';
                    data_section_string_buffer[2]  = ' ';
                    data_section_string_buffer[3]  = ' ';
                    data_section_string_buffer[4]  = ' ';
                    data_section_string_buffer[5]  = ' ';
                    data_section_string_buffer[6]  = ' ';
                    data_section_string_buffer[7]  = ' ';
                    data_section_string_buffer[8]  = '.';
                    data_section_string_buffer[9]  = 's';
                    data_section_string_buffer[10] = 't';
                    data_section_string_buffer[11] = 'r';
                    data_section_string_buffer[12] = 'i';
                    data_section_string_buffer[13] = 'n';
                    data_section_string_buffer[14] = 'g';
                    data_section_string_buffer[15] = ' ';
                    data_section_string_buffer[16] = '"';
                    for (i = 0; i < token_string_length; i++)
                    {
                      data_section_string_buffer[17+i] = escaped_double_quotes_token[i];
                    }
                    data_section_string_buffer[17+token_string_length] = '"';
                    data_section_string_buffer[18+token_string_length] = '\n';
                    data_section_string_buffer[19+token_string_length] = ' ';
                    data_section_string_buffer[20+token_string_length] = ' ';
                    data_section_string_buffer[21+token_string_length] = ' ';
                    data_section_string_buffer[22+token_string_length] = ' ';
                    data_section_string_buffer[23+token_string_length] = ' ';
                    data_section_string_buffer[24+token_string_length] = ' ';
                    data_section_string_buffer[25+token_string_length] = ' ';
                    data_section_string_buffer[26+token_string_length] = ' ';
                    data_section_string_buffer[27+token_string_length] = '.';
                    data_section_string_buffer[28+token_string_length] = 'a';
                    data_section_string_buffer[29+token_string_length] = 'l';
                    data_section_string_buffer[30+token_string_length] = 'i';
                    data_section_string_buffer[31+token_string_length] = 'g';
                    data_section_string_buffer[32+token_string_length] = 'n';
                    data_section_string_buffer[33+token_string_length] = ' ';
                    data_section_string_buffer[34+token_string_length] = '8';
                    data_section_string_buffer[35+token_string_length] = '\n';
                    data_section_string_buffer[36+token_string_length] = '\0';
                  }
                  free (escaped_double_quotes_token);
                  escaped_double_quotes_token = NULL;
                }
                assembler_statement->data_section_contents = data_section_string_buffer;
// ********************************************************
// * Now enter assembly code for the print functionality. *
// ********************************************************
                code_section_string_buffer_max_length = 4096;
                assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
                if (assembler_statement->code_section_contents != NULL)
                {
                  snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        lea rax, .M%llu[rip]\n        mov rdi, rax\n        mov eax, 0\n        call printf@PLT\n", *assembler_statement->label);
                }
                if (assembler_program != NULL)
                {
                  temp_assembler_element = assembler_program;
                  while (temp_assembler_element->next != NULL)
                  {
                    temp_assembler_element = temp_assembler_element->next;
                  }
                  temp_assembler_element->next = assembler_statement;
                }
                else
                {
                  assembler_program = assembler_statement;
                }
                state = 20;
                ast_element = ast_element->sibling;
              }
              else
              {
                state = 99999;
              }
            }
            else
            {
              if (token_type == TOKEN_IDENTIFIER)
              {
                symbol_table_entry = ast_element->symbol_table_entry;
                if (symbol_table_entry != NULL)
                {
                  if ((symbol_table_entry->attribute_type == _datatype) && (symbol_table_entry->datatype == _int)) 
                  {
                    stackframe_element = retrieve_stackframe_offset (stackframe_cross_reference_table, symbol_table_entry);
                    if (stackframe_element != NULL)
                    {
// *******************************************************************************************
// * Now I will call stringint_display (internal library) to display the value of a variable *
// *******************************************************************************************
                      code_section_string_buffer_max_length = 4096;
                      assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
                      if (assembler_statement->code_section_contents != NULL)
                      {
                        snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov rax, QWORD PTR -%ld[rbp]\n        mov esi, 0\n        mov rdi, rax\n        call packed_string_integer_display@PLT\n", stackframe_element->stackframe_offset);
                        state = 20;
                        ast_element = ast_element->sibling;
                        if (assembler_program != NULL)
                        {
                          temp_assembler_element = assembler_program;
                          while (temp_assembler_element->next != NULL)
                          {
                            temp_assembler_element = temp_assembler_element->next;
                          }
                          temp_assembler_element->next = assembler_statement;
                        }
                        else
                        {
                          assembler_program = assembler_statement;
                        }
                      }
                      else
                      {
                        state = 99999;
                      }
                    }
                    else
                    {
                      state = 99999;
                    }
                  }
                  else
                  {
                    if ((symbol_table_entry->attribute_type == _datatype) && (symbol_table_entry->datatype == _real)) 
                    {
                      stackframe_element = retrieve_stackframe_offset (stackframe_cross_reference_table, symbol_table_entry);
                      if (stackframe_element != NULL)
                      {
// *******************************************************************************************
// * Now I will call stringint_display (internal library) to display the value of a variable *
// *******************************************************************************************
                        code_section_string_buffer_max_length = 4096;
                        assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
                        if (assembler_statement->code_section_contents != NULL)
                        {
                          snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov rax, QWORD PTR -%ld[rbp]\n        mov esi, 0\n        mov rdi, rax\n        call packed_string_real_display@PLT\n", stackframe_element->stackframe_offset);
                          state = 20;
                          ast_element = ast_element->sibling;
                          if (assembler_program != NULL)
                          {
                            temp_assembler_element = assembler_program;
                            while (temp_assembler_element->next != NULL)
                            {
                              temp_assembler_element = temp_assembler_element->next;
                            }
                            temp_assembler_element->next = assembler_statement;
                          }
                          else
                          {
                            assembler_program = assembler_statement;
                          }
                        }
                        else
                        {
                          state = 99999;
                        }
                      }
                      else
                      {
                        state = 99999;
                      }
                    }
                    else
                    {
                      if ((symbol_table_entry->attribute_type == _datatype) && (symbol_table_entry->datatype == _bool)) 
                      {
                        stackframe_element = retrieve_stackframe_offset (stackframe_cross_reference_table, symbol_table_entry);
                        if (stackframe_element != NULL)
                        {
// **************************************************************************************
// * Now I will call bool_display (internal library) to display the value of a variable *
// **************************************************************************************
                          code_section_string_buffer_max_length = 4096;
                          assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
                          if (assembler_statement->code_section_contents != NULL)
                          {
                            snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov rax, QWORD PTR -%ld[rbp]\n        mov rdi, rax\n        call boolean_display@PLT\n", stackframe_element->stackframe_offset);
                            state = 20;
                            ast_element = ast_element->sibling;
                            if (assembler_program != NULL)
                            {
                              temp_assembler_element = assembler_program;
                              while (temp_assembler_element->next != NULL)
                              {
                                temp_assembler_element = temp_assembler_element->next;
                              }
                              temp_assembler_element->next = assembler_statement;
                            }
                            else
                            {
                              assembler_program = assembler_statement;
                            }
                          }
                          else
                          {
                            state = 99999;
                          }
                        }
                        else
                        {
                          state = 99999;
                        }
                      }
                      else
                      {
                        state = 99999;
                      }
                    } 
                  }
                }
                else
                {
                  state = 99999;
                }
              }
              else
              {
                state = 99999;
              }
            }
          }
          else
          {
            state = 99999;
          }
        }
        else
        {
          state = 99999;
        }
      break;  
      case 20:
        assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
        if (assembler_statement != NULL)
        {
          assembler_statement->scope_level = scope_level;
          assembler_statement->label = NULL;
          assembler_statement->label_associated_with_else_statement = NULL;
          assembler_statement->label_after_if_then_else_statement = NULL;
          assembler_statement->code_section_contents = NULL;       
          assembler_statement->data_section_contents = NULL;       
          assembler_statement->next = NULL;
          state = 10;
        }
        else
        {
          state = 99999;
        }
      break;
      default:
      break;
    } 
  }
  if (state == 99999)
  {
    // TODO: free up the memory allocated for assmelber_statement linked list and return a NULL to indicate failure.
  }
  return assembler_program;
}




asmblr_node * create_assembler_output_set_statement (asmblr_node *assembler_program, ast_node *abstract_syntax_tree, symtab_node *symbol_table, stackframe_node *stackframe_cross_reference_table, unsigned long long int scope_level)
{
  asmblr_node *assembler_statement, *assembler_element, *temp_assembler_element;
  ast_node *ast_element;
  symtab_node *symbol_table_element, *temporary_storage_variable;
  stackframe_node *target_variable_stackframe_element, *temporary_storage_variable_stackframe_element, *chaga_variable_stackframe_element;
  chaga_attribute_type target_variable_attribute_type;
  chaga_attribute_datatype target_variable_datatype;
  unsigned long long int target_variable_scope_level, counter_for_new_variables;
  int state, token_type;
  char *token, *constant_integer_token, *constant_real_token, *constant_boolean_token;
  unsigned char new_variable[1024], *data_section_string_buffer;
  unsigned long long int *label;
  size_t i, j, token_string_length, code_section_string_buffer_max_length, data_section_string_buffer_length; 

  assembler_statement = NULL;
  data_section_string_buffer = NULL;
  ast_element = NULL;
  target_variable_stackframe_element = NULL;
  temporary_storage_variable = NULL;
  temporary_storage_variable_stackframe_element = NULL;
  constant_integer_token = NULL;
  constant_real_token = NULL;
  constant_boolean_token = NULL;
  token = NULL;
  counter_for_new_variables = 0;
  if (abstract_syntax_tree != NULL)
  {
    state = 0;
    ast_element = abstract_syntax_tree;
    while ((ast_element != NULL) && (state != 99999))
    {
      token = ast_element->token;
      token_type = ast_element->token_type;
      if (token != NULL)
      {
        switch (state)
        {
          case 0:
            if (token_type == TOKEN_IDENTIFIER)
            {
// *******************************************************************************************************************************
// * STEP 1:  Determine what the target IDENTIFIER's datatype is (i.e. BOOLEAN, FLOAT, or INT). This is important because I must *
// *          call one of the following subroutines to process the expression at run-time via LibChaga:                          *
// *                                                                                                                             *
// *          evaluate_runtime_expression_return_boolean_result_for_set_statement()                                              *
// *          evaluate_runtime_expression_return_real_result_for_set_statement()                                                 *
// *          evaluate_runtime_expression_return_integer_result_for_set_statement()                                              *
// *                                                                                                                             *
// * Note: I also need to know the target IDENTIFIER's scope level.                                                              *
// *******************************************************************************************************************************
              symbol_table_element = ast_element->symbol_table_entry;
              if (symbol_table_element != NULL)
              {
                target_variable_stackframe_element = retrieve_stackframe_offset (stackframe_cross_reference_table, symbol_table_element);
                if (target_variable_stackframe_element != NULL)
                {
                  target_variable_scope_level = symbol_table_element->scope_level;
                  target_variable_attribute_type = symbol_table_element->attribute_type;
                  target_variable_datatype = symbol_table_element->datatype;              
                  if (target_variable_attribute_type == _datatype)
                  {
                    switch (target_variable_datatype)
                    {
                      case _int:
                        state = 10;
                      break;
                      case _real:
                        state = 10;
                      break;
                      case _bool:
                        state = 10;
                      break;
                      default:
                        state = 99999;
                      break;
                    }                    
                  }
                  else
                  {
                    state = 99999;
                  }
                }
                else
                {
                  state = 99999;
                }
              }
              else
              {
                state = 99999;
              }
// *******************************************************************************************************************************
// * STEP 2:  Check if there is at least one temporary variable already allocated on the stack frame in the current scope level  * 
// *          which is a 64-bit pointer datatype (_pointer). This temporary variable will hold a 64-bit pointer to a linked list *
// *          containing the expression to be evaluated at run-time.                                                             *
// *******************************************************************************************************************************
              if (state != 99999)
              {
                symbol_table_set_status_to_available_unused_temporary_variables_for_numerical_expression_processing (symbol_table, target_variable_scope_level);
                temporary_storage_variable = retrieve_unused_temporary_variable_for_numerical_expression_processing (symbol_table, _datatype, _pointer, target_variable_scope_level);
                if (temporary_storage_variable != NULL)
                {
                  if (temporary_storage_variable->identifier != NULL)
                  {
                    temporary_storage_variable_stackframe_element = retrieve_stackframe_offset (stackframe_cross_reference_table, temporary_storage_variable);
                    if (temporary_storage_variable_stackframe_element == NULL)
                    {
                      state = 99999;
                    }
                  }
                  else
                  {
                    state = 99999;
                  }
                }
                else
                {
                  state = 99999;
                }
              }
            }
            else
            {
              state = 99999;
            }
          break;
          case 10:
            if (token_type == TOKEN_ASSIGNMENT)
            {
              state = 20;
            }
            else
            {
              state = 99999;
            }
          break;
          case 20:
            if (token_type == TOKEN_IDENTIFIER)
            {
              assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
              if (assembler_statement != NULL)
              {
                assembler_statement->scope_level = scope_level;
                assembler_statement->label = NULL;
                assembler_statement->label_associated_with_else_statement = NULL;
                assembler_statement->label_after_if_then_else_statement = NULL;
                assembler_statement->code_section_contents = NULL;       
                assembler_statement->data_section_contents = NULL;       
                assembler_statement->next = NULL;
                if (temporary_storage_variable_stackframe_element != NULL)
                {
                  symbol_table_element = ast_element->symbol_table_entry;
                  if (symbol_table_element != NULL)
                  {
                    chaga_variable_stackframe_element = retrieve_stackframe_offset (stackframe_cross_reference_table, symbol_table_element);
                    if (chaga_variable_stackframe_element != NULL)
                    {
                      if (symbol_table_element->attribute_type == _datatype)
                      {
                        switch (symbol_table_element->datatype)
                        {
                          case _int:
                            code_section_string_buffer_max_length = 4096;
                            assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
                            if (assembler_statement->code_section_contents != NULL)
                            {
                              snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov rdx, QWORD PTR -%ld[rbp]\n        mov rax, QWORD PTR -%ld[rbp]\n        mov ecx, 0\n        mov esi, 1\n        mov rdi, rax\n        call add_operand_element_runtime_expression@PLT\n        mov QWORD PTR -%ld[rbp], rax\n", chaga_variable_stackframe_element->stackframe_offset, temporary_storage_variable_stackframe_element->stackframe_offset, temporary_storage_variable_stackframe_element->stackframe_offset);
                              if (assembler_program != NULL)
                              {
                                temp_assembler_element = assembler_program;
                                while (temp_assembler_element->next != NULL)
                                {
                                  temp_assembler_element = temp_assembler_element->next;
                                }
                                temp_assembler_element->next = assembler_statement;
                              }
                              else
                              {
                                assembler_program = assembler_statement;
                              }
                              state = 20;
                            }
                            else
                            {
                              state = 99999;
                            }
                          break;
                          case _real:
                            code_section_string_buffer_max_length = 4096;
                            assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
                            if (assembler_statement->code_section_contents != NULL)
                            {
                              snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov rdx, QWORD PTR -%ld[rbp]\n        mov rax, QWORD PTR -%ld[rbp]\n        mov ecx, 0\n        mov esi, 3\n        mov rdi, rax\n        call add_operand_element_runtime_expression@PLT\n        mov QWORD PTR -%ld[rbp], rax\n", chaga_variable_stackframe_element->stackframe_offset, temporary_storage_variable_stackframe_element->stackframe_offset, temporary_storage_variable_stackframe_element->stackframe_offset);
                              if (assembler_program != NULL)
                              {
                                temp_assembler_element = assembler_program;
                                while (temp_assembler_element->next != NULL)
                                {
                                  temp_assembler_element = temp_assembler_element->next;
                                }
                                temp_assembler_element->next = assembler_statement;
                              }
                              else
                              {
                                assembler_program = assembler_statement;
                              }
                              state = 20;
                            }
                            else
                            {
                              state = 99999;
                            }
                          break;
                          case _bool:
                            code_section_string_buffer_max_length = 4096;
                            assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
                            if (assembler_statement->code_section_contents != NULL)
                            {
                              snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov rdx, QWORD PTR -%ld[rbp]\n        mov rax, QWORD PTR -%ld[rbp]\n        mov ecx, 0\n        mov esi, 2\n        mov rdi, rax\n        call add_operand_element_runtime_expression@PLT\n        mov QWORD PTR -%ld[rbp], rax\n", chaga_variable_stackframe_element->stackframe_offset, temporary_storage_variable_stackframe_element->stackframe_offset, temporary_storage_variable_stackframe_element->stackframe_offset);
                              if (assembler_program != NULL)
                              {
                                temp_assembler_element = assembler_program;
                                while (temp_assembler_element->next != NULL)
                                {
                                  temp_assembler_element = temp_assembler_element->next;
                                }
                                temp_assembler_element->next = assembler_statement;
                              }
                              else
                              {
                                assembler_program = assembler_statement;
                              }
                              state = 20;
                            }
                            else
                            {
                              state = 99999;
                            }
                          break;
                          default:
                            state = 99999;
                          break;
                        }
                      }
                      else
                      {
                        state = 99999;
                      }
                    }
                    else
                    {
                      state = 99999;
                    }
                  }
                  else
                  {
                    state = 99999;
                  }
                }
                else
                {
                  state = 99999;
                }
              }
              else
              {
                state = 99999;
              }
            }
            else
            {
              if (token_type == TOKEN_IDENTIFIER_INTEGER_CONSTANT)
              {
                if (temporary_storage_variable_stackframe_element != NULL)
                {
                  assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
                  if (assembler_statement != NULL)
                  {
                    assembler_statement->label = (unsigned long long int *) malloc(sizeof(unsigned long long int));
                    if (assembler_statement->label != NULL)
                    {
                      assembler_statement->scope_level = scope_level;
                      assembler_statement->label_associated_with_else_statement = NULL;
                      assembler_statement->label_after_if_then_else_statement = NULL;
                      assembler_statement->code_section_contents = NULL;       
                      assembler_statement->data_section_contents = NULL;       
                      assembler_statement->next = NULL;
                      label = retrieve_highest_label_number_from_assembly_output (assembler_program);
                      if (label != NULL)
                      {
                        *assembler_statement->label = (*label) + 1;
                      }
                      else
                      {
                        *assembler_statement->label = 1;
                      }
                      constant_integer_token = token;
                      if (constant_integer_token != NULL)
                      {
                        token_string_length = strlen(constant_integer_token);
                        data_section_string_buffer_length = token_string_length + 37;
                        data_section_string_buffer = (unsigned char *) malloc(sizeof(char)*data_section_string_buffer_length); 
                        if (data_section_string_buffer != NULL)
                        {
                          data_section_string_buffer[0]  = ' ';
                          data_section_string_buffer[1]  = ' ';
                          data_section_string_buffer[2]  = ' ';
                          data_section_string_buffer[3]  = ' ';
                          data_section_string_buffer[4]  = ' ';
                          data_section_string_buffer[5]  = ' ';
                          data_section_string_buffer[6]  = ' ';
                          data_section_string_buffer[7]  = ' ';
                          data_section_string_buffer[8]  = '.';
                          data_section_string_buffer[9]  = 's';
                          data_section_string_buffer[10] = 't';
                          data_section_string_buffer[11] = 'r';
                          data_section_string_buffer[12] = 'i';
                          data_section_string_buffer[13] = 'n';
                          data_section_string_buffer[14] = 'g';
                          data_section_string_buffer[15] = ' ';
                          data_section_string_buffer[16] = '"';
                          for (i = 0; i < token_string_length; i++)
                          {
                            data_section_string_buffer[17+i] = constant_integer_token[i];
                          }
                          data_section_string_buffer[17+token_string_length] = '"';
                          data_section_string_buffer[18+token_string_length] = '\n';
                          data_section_string_buffer[19+token_string_length] = ' ';
                          data_section_string_buffer[20+token_string_length] = ' ';
                          data_section_string_buffer[21+token_string_length] = ' ';
                          data_section_string_buffer[22+token_string_length] = ' ';
                          data_section_string_buffer[23+token_string_length] = ' ';
                          data_section_string_buffer[24+token_string_length] = ' ';
                          data_section_string_buffer[25+token_string_length] = ' ';
                          data_section_string_buffer[26+token_string_length] = ' ';
                          data_section_string_buffer[27+token_string_length] = '.';
                          data_section_string_buffer[28+token_string_length] = 'a';
                          data_section_string_buffer[29+token_string_length] = 'l';
                          data_section_string_buffer[30+token_string_length] = 'i';
                          data_section_string_buffer[31+token_string_length] = 'g';
                          data_section_string_buffer[32+token_string_length] = 'n';
                          data_section_string_buffer[33+token_string_length] = ' ';
                          data_section_string_buffer[34+token_string_length] = '8';
                          data_section_string_buffer[35+token_string_length] = '\n';
                          data_section_string_buffer[36+token_string_length] = '\0';
                        }
                        assembler_statement->data_section_contents = data_section_string_buffer;
                        code_section_string_buffer_max_length = 4096;
                        assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
                        if (assembler_statement->code_section_contents != NULL)
                        {
                          snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov rax, QWORD PTR -%ld[rbp]\n        mov ecx, 0\n        lea rdx, .M%llu[rip]\n        mov esi, 4\n        mov rdi, rax\n        call add_operand_element_runtime_expression@PLT\n        mov QWORD PTR -%ld[rbp], rax\n", temporary_storage_variable_stackframe_element->stackframe_offset, *assembler_statement->label, temporary_storage_variable_stackframe_element->stackframe_offset);
                          state = 20;
                        }
                        if (assembler_program != NULL)
                        {
                          temp_assembler_element = assembler_program;
                          while (temp_assembler_element->next != NULL)
                          {
                            temp_assembler_element = temp_assembler_element->next;
                          }
                          temp_assembler_element->next = assembler_statement;
                        }
                        else
                        {
                          assembler_program = assembler_statement;
                        }
                      }
                      else
                      {
                        state = 99999;
                      }
                    }
                    else
                    {
                      state = 99999;
                    }
                  }
                  else
                  {
                    state = 99999;
                  }
                }
                else
                {
                  state = 99999;
                }
              }
              else
              {
                if (token_type == TOKEN_IDENTIFIER_FLOATING_POINT_CONSTANT)
                {
                  if (temporary_storage_variable_stackframe_element != NULL)
                  {
                    assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
                    if (assembler_statement != NULL)
                    {
                      assembler_statement->label = (unsigned long long int *) malloc(sizeof(unsigned long long int));
                      if (assembler_statement->label != NULL)
                      {
                        assembler_statement->scope_level = scope_level;
                        assembler_statement->label_associated_with_else_statement = NULL;
                        assembler_statement->label_after_if_then_else_statement = NULL;
                        assembler_statement->code_section_contents = NULL;       
                        assembler_statement->data_section_contents = NULL;       
                        assembler_statement->next = NULL;
                        label = retrieve_highest_label_number_from_assembly_output (assembler_program);
                        if (label != NULL)
                        {
                          *assembler_statement->label = (*label) + 1;
                        }
                        else
                        {
                          *assembler_statement->label = 1;
                        }
                        constant_real_token = token;
                        if (constant_real_token != NULL)
                        {
                          token_string_length = strlen(constant_real_token);
                          data_section_string_buffer_length = token_string_length + 37;
                          data_section_string_buffer = (unsigned char *) malloc(sizeof(char)*data_section_string_buffer_length); 
                          if (data_section_string_buffer != NULL)
                          {
                            data_section_string_buffer[0]  = ' ';
                            data_section_string_buffer[1]  = ' ';
                            data_section_string_buffer[2]  = ' ';
                            data_section_string_buffer[3]  = ' ';
                            data_section_string_buffer[4]  = ' ';
                            data_section_string_buffer[5]  = ' ';
                            data_section_string_buffer[6]  = ' ';
                            data_section_string_buffer[7]  = ' ';
                            data_section_string_buffer[8]  = '.';
                            data_section_string_buffer[9]  = 's';
                            data_section_string_buffer[10] = 't';
                            data_section_string_buffer[11] = 'r';
                            data_section_string_buffer[12] = 'i';
                            data_section_string_buffer[13] = 'n';
                            data_section_string_buffer[14] = 'g';
                            data_section_string_buffer[15] = ' ';
                            data_section_string_buffer[16] = '"';
                            for (i = 0; i < token_string_length; i++)
                            {
                              data_section_string_buffer[17+i] = constant_real_token[i];
                            }
                            data_section_string_buffer[17+token_string_length] = '"';
                            data_section_string_buffer[18+token_string_length] = '\n';
                            data_section_string_buffer[19+token_string_length] = ' ';
                            data_section_string_buffer[20+token_string_length] = ' ';
                            data_section_string_buffer[21+token_string_length] = ' ';
                            data_section_string_buffer[22+token_string_length] = ' ';
                            data_section_string_buffer[23+token_string_length] = ' ';
                            data_section_string_buffer[24+token_string_length] = ' ';
                            data_section_string_buffer[25+token_string_length] = ' ';
                            data_section_string_buffer[26+token_string_length] = ' ';
                            data_section_string_buffer[27+token_string_length] = '.';
                            data_section_string_buffer[28+token_string_length] = 'a';
                            data_section_string_buffer[29+token_string_length] = 'l';
                            data_section_string_buffer[30+token_string_length] = 'i';
                            data_section_string_buffer[31+token_string_length] = 'g';
                            data_section_string_buffer[32+token_string_length] = 'n';
                            data_section_string_buffer[33+token_string_length] = ' ';
                            data_section_string_buffer[34+token_string_length] = '8';
                            data_section_string_buffer[35+token_string_length] = '\n';
                            data_section_string_buffer[36+token_string_length] = '\0';
                          }
                          assembler_statement->data_section_contents = data_section_string_buffer;
                          code_section_string_buffer_max_length = 4096;
                          assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
                          if (assembler_statement->code_section_contents != NULL)
                          {
                            snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov rax, QWORD PTR -%ld[rbp]\n        mov ecx, 0\n        lea rdx, .M%llu[rip]\n        mov esi, 5\n        mov rdi, rax\n        call add_operand_element_runtime_expression@PLT\n        mov QWORD PTR -%ld[rbp], rax\n", temporary_storage_variable_stackframe_element->stackframe_offset, *assembler_statement->label, temporary_storage_variable_stackframe_element->stackframe_offset);
                            state = 20;
                          }
                          if (assembler_program != NULL)
                          {
                            temp_assembler_element = assembler_program;
                            while (temp_assembler_element->next != NULL)
                            {
                              temp_assembler_element = temp_assembler_element->next;
                            }
                            temp_assembler_element->next = assembler_statement;
                          }
                          else
                          {
                            assembler_program = assembler_statement;
                          }
                        }
                        else
                        {
                          state = 99999;
                        }
                      }
                      else
                      {
                        state = 99999;
                      }
                    }
                    else
                    {
                      state = 99999;
                    }
                  }
                  else
                  {
                    state = 99999;
                  }
                }
                else
                {
                  if ((token_type == TOKEN_TRUE) || (token_type == TOKEN_FALSE))
                  {
                    if (temporary_storage_variable_stackframe_element != NULL)
                    {
                      assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
                      if (assembler_statement != NULL)
                      {
                        assembler_statement->label = (unsigned long long int *) malloc(sizeof(unsigned long long int));
                        if (assembler_statement->label != NULL)
                        {
                          assembler_statement->scope_level = scope_level;
                          assembler_statement->label_associated_with_else_statement = NULL;
                          assembler_statement->label_after_if_then_else_statement = NULL;
                          assembler_statement->code_section_contents = NULL;       
                          assembler_statement->data_section_contents = NULL;       
                          assembler_statement->next = NULL;
                          label = retrieve_highest_label_number_from_assembly_output (assembler_program);
                          if (label != NULL)
                          {
                            *assembler_statement->label = (*label) + 1;
                          }
                          else
                          {
                            *assembler_statement->label = 1;
                          }
                          constant_boolean_token = token;
                          if (constant_boolean_token != NULL)
                          {
                            token_string_length = strlen(constant_boolean_token);
                            data_section_string_buffer_length = token_string_length + 37;
                            data_section_string_buffer = (unsigned char *) malloc(sizeof(char)*data_section_string_buffer_length); 
                            if (data_section_string_buffer != NULL)
                            {
                              data_section_string_buffer[0]  = ' ';
                              data_section_string_buffer[1]  = ' ';
                              data_section_string_buffer[2]  = ' ';
                              data_section_string_buffer[3]  = ' ';
                              data_section_string_buffer[4]  = ' ';
                              data_section_string_buffer[5]  = ' ';
                              data_section_string_buffer[6]  = ' ';
                              data_section_string_buffer[7]  = ' ';
                              data_section_string_buffer[8]  = '.';
                              data_section_string_buffer[9]  = 's';
                              data_section_string_buffer[10] = 't';
                              data_section_string_buffer[11] = 'r';
                              data_section_string_buffer[12] = 'i';
                              data_section_string_buffer[13] = 'n';
                              data_section_string_buffer[14] = 'g';
                              data_section_string_buffer[15] = ' ';
                              data_section_string_buffer[16] = '"';
                              for (i = 0; i < token_string_length; i++)
                              {
                                data_section_string_buffer[17+i] = constant_boolean_token[i];
                              }
                              data_section_string_buffer[17+token_string_length] = '"';
                              data_section_string_buffer[18+token_string_length] = '\n';
                              data_section_string_buffer[19+token_string_length] = ' ';
                              data_section_string_buffer[20+token_string_length] = ' ';
                              data_section_string_buffer[21+token_string_length] = ' ';
                              data_section_string_buffer[22+token_string_length] = ' ';
                              data_section_string_buffer[23+token_string_length] = ' ';
                              data_section_string_buffer[24+token_string_length] = ' ';
                              data_section_string_buffer[25+token_string_length] = ' ';
                              data_section_string_buffer[26+token_string_length] = ' ';
                              data_section_string_buffer[27+token_string_length] = '.';
                              data_section_string_buffer[28+token_string_length] = 'a';
                              data_section_string_buffer[29+token_string_length] = 'l';
                              data_section_string_buffer[30+token_string_length] = 'i';
                              data_section_string_buffer[31+token_string_length] = 'g';
                              data_section_string_buffer[32+token_string_length] = 'n';
                              data_section_string_buffer[33+token_string_length] = ' ';
                              data_section_string_buffer[34+token_string_length] = '8';
                              data_section_string_buffer[35+token_string_length] = '\n';
                              data_section_string_buffer[36+token_string_length] = '\0';
                            }
                            assembler_statement->data_section_contents = data_section_string_buffer;
                            code_section_string_buffer_max_length = 4096;
                            assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
                            if (assembler_statement->code_section_contents != NULL)
                            {
                              snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov rax, QWORD PTR -%ld[rbp]\n        mov ecx, 0\n        lea rdx, .M%llu[rip]\n        mov esi, 6\n        mov rdi, rax\n        call add_operand_element_runtime_expression@PLT\n        mov QWORD PTR -%ld[rbp], rax\n", temporary_storage_variable_stackframe_element->stackframe_offset, *assembler_statement->label, temporary_storage_variable_stackframe_element->stackframe_offset);
                              state = 20;
                            }
                            if (assembler_program != NULL)
                            {
                              temp_assembler_element = assembler_program;
                              while (temp_assembler_element->next != NULL)
                              {
                                temp_assembler_element = temp_assembler_element->next;
                              }
                              temp_assembler_element->next = assembler_statement;
                            }
                            else
                            {
                              assembler_program = assembler_statement;
                            }
                          }
                          else
                          {
                            state = 99999;
                          }
                        }
                        else
                        {
                          state = 99999;
                        }
                      }
                      else
                      {
                        state = 99999;
                      }
                    }
                    else
                    {
                      state = 99999;
                    }
                  }
                  else
                  {
                    if (token_type == TOKEN_PLUS)
                    {
                      if (temporary_storage_variable_stackframe_element != NULL)
                      {
                        assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
                        if (assembler_statement != NULL)
                        {
                          assembler_statement->scope_level = scope_level;
                          assembler_statement->label = NULL;
                          assembler_statement->label_associated_with_else_statement = NULL;
                          assembler_statement->label_after_if_then_else_statement = NULL;
                          assembler_statement->code_section_contents = NULL;       
                          assembler_statement->data_section_contents = NULL;       
                          assembler_statement->next = NULL;
                          code_section_string_buffer_max_length = 4096;
                          assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
                          if (assembler_statement->code_section_contents != NULL)
                          {
                            snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov rax, QWORD PTR -%ld[rbp]\n        mov esi, 11\n        mov rdi, rax\n        call add_operator_element_runtime_expression@PLT\n        mov QWORD PTR -%ld[rbp], rax\n", temporary_storage_variable_stackframe_element->stackframe_offset, temporary_storage_variable_stackframe_element->stackframe_offset);
                            if (assembler_program != NULL)
                            {
                              temp_assembler_element = assembler_program;
                              while (temp_assembler_element->next != NULL)
                              {
                                temp_assembler_element = temp_assembler_element->next;
                              }
                              temp_assembler_element->next = assembler_statement;
                            }
                            else
                            {
                              assembler_program = assembler_statement;
                            }
                            state = 20;
                          }
                          else
                          {
                            state = 99999;
                          }
                        }
                        else
                        {
                          state = 99999;
                        }
                      }
                      else
                      {
                        state = 99999;
                      }
                    }
                    else
                    {
                      if (token_type == TOKEN_MINUS)
                      {
                        if (temporary_storage_variable_stackframe_element != NULL)
                        {
                          assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
                          if (assembler_statement != NULL)
                          {
                            assembler_statement->scope_level = scope_level;
                            assembler_statement->label = NULL;
                            assembler_statement->label_associated_with_else_statement = NULL;
                            assembler_statement->label_after_if_then_else_statement = NULL;
                            assembler_statement->code_section_contents = NULL;       
                            assembler_statement->data_section_contents = NULL;       
                            assembler_statement->next = NULL;
                            code_section_string_buffer_max_length = 4096;
                            assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
                            if (assembler_statement->code_section_contents != NULL)
                            {
                              snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov rax, QWORD PTR -%ld[rbp]\n        mov esi, 12\n        mov rdi, rax\n        call add_operator_element_runtime_expression@PLT\n        mov QWORD PTR -%ld[rbp], rax\n", temporary_storage_variable_stackframe_element->stackframe_offset, temporary_storage_variable_stackframe_element->stackframe_offset);
                              if (assembler_program != NULL)
                              {
                                temp_assembler_element = assembler_program;
                                while (temp_assembler_element->next != NULL)
                                {
                                  temp_assembler_element = temp_assembler_element->next;
                                }
                                temp_assembler_element->next = assembler_statement;
                              }
                              else
                              {
                                assembler_program = assembler_statement;
                              }
                              state = 20;
                            }
                            else
                            {
                              state = 99999;
                            }
                          }
                          else
                          {
                            state = 99999;
                          }
                        }
                        else
                        {
                          state = 99999;
                        }
                      }
                      else
                      {
                        if (token_type == TOKEN_ASTERISK)
                        {
                          if (temporary_storage_variable_stackframe_element != NULL)
                          {
                            assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
                            if (assembler_statement != NULL)
                            {
                              assembler_statement->scope_level = scope_level;
                              assembler_statement->label = NULL;
                              assembler_statement->label_associated_with_else_statement = NULL;
                              assembler_statement->label_after_if_then_else_statement = NULL;
                              assembler_statement->code_section_contents = NULL;       
                              assembler_statement->data_section_contents = NULL;       
                              assembler_statement->next = NULL;
                              code_section_string_buffer_max_length = 4096;
                              assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
                              if (assembler_statement->code_section_contents != NULL)
                              {
                                snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov rax, QWORD PTR -%ld[rbp]\n        mov esi, 13\n        mov rdi, rax\n        call add_operator_element_runtime_expression@PLT\n        mov QWORD PTR -%ld[rbp], rax\n", temporary_storage_variable_stackframe_element->stackframe_offset, temporary_storage_variable_stackframe_element->stackframe_offset);
                                if (assembler_program != NULL)
                                {
                                  temp_assembler_element = assembler_program;
                                  while (temp_assembler_element->next != NULL)
                                  {
                                    temp_assembler_element = temp_assembler_element->next;
                                  }
                                  temp_assembler_element->next = assembler_statement;
                                }
                                else
                                {
                                  assembler_program = assembler_statement;
                                }
                                state = 20;
                              }
                              else
                              {
                                state = 99999;
                              }
                            }
                            else
                            {
                              state = 99999;
                            }
                          }
                          else
                          {
                            state = 99999;
                          }
                        }
                        else
                        {
                          if (token_type == TOKEN_DIVIDE)
                          {
                            if (temporary_storage_variable_stackframe_element != NULL)
                            {
                              assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
                              if (assembler_statement != NULL)
                              {
                                assembler_statement->scope_level = scope_level;
                                assembler_statement->label = NULL;
                                assembler_statement->label_associated_with_else_statement = NULL;
                                assembler_statement->label_after_if_then_else_statement = NULL;
                                assembler_statement->code_section_contents = NULL;       
                                assembler_statement->data_section_contents = NULL;       
                                assembler_statement->next = NULL;
                                code_section_string_buffer_max_length = 4096;
                                assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
                                if (assembler_statement->code_section_contents != NULL)
                                {
                                  snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov rax, QWORD PTR -%ld[rbp]\n        mov esi, 14\n        mov rdi, rax\n        call add_operator_element_runtime_expression@PLT\n        mov QWORD PTR -%ld[rbp], rax\n", temporary_storage_variable_stackframe_element->stackframe_offset, temporary_storage_variable_stackframe_element->stackframe_offset);
                                  if (assembler_program != NULL)
                                  {
                                    temp_assembler_element = assembler_program;
                                    while (temp_assembler_element->next != NULL)
                                    {
                                      temp_assembler_element = temp_assembler_element->next;
                                    }
                                    temp_assembler_element->next = assembler_statement;
                                  }
                                  else
                                  {
                                    assembler_program = assembler_statement;
                                  }
                                  state = 20;
                                }
                                else
                                {
                                  state = 99999;
                                }
                              }
                              else
                              {
                                state = 99999;
                              }
                            }
                            else
                            {
                              state = 99999;
                            }
                          }
                          else
                          {
                            if (token_type == TOKEN_MODULO)
                            {
                              if (temporary_storage_variable_stackframe_element != NULL)
                              {
                                assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
                                if (assembler_statement != NULL)
                                {
                                  assembler_statement->scope_level = scope_level;
                                  assembler_statement->label = NULL;
                                  assembler_statement->label_associated_with_else_statement = NULL;
                                  assembler_statement->label_after_if_then_else_statement = NULL;
                                  assembler_statement->code_section_contents = NULL;
                                  assembler_statement->data_section_contents = NULL;
                                  assembler_statement->next = NULL;
                                  code_section_string_buffer_max_length = 4096;
                                  assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
                                  if (assembler_statement->code_section_contents != NULL)
                                  {
                                    snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov rax, QWORD PTR -%ld[rbp]\n        mov esi, 15\n        mov rdi, rax\n        call add_operator_element_runtime_expression@PLT\n        mov QWORD PTR -%ld[rbp], rax\n", temporary_storage_variable_stackframe_element->stackframe_offset, temporary_storage_variable_stackframe_element->stackframe_offset);
                                    if (assembler_program != NULL)
                                    {
                                      temp_assembler_element = assembler_program;
                                      while (temp_assembler_element->next != NULL)
                                      {
                                        temp_assembler_element = temp_assembler_element->next;
                                      }
                                      temp_assembler_element->next = assembler_statement;
                                    }
                                    else
                                    {
                                      assembler_program = assembler_statement;
                                    }
                                    state = 20;
                                  }
                                  else
                                  {
                                    state = 99999;
                                  }
                                }
                                else
                                {
                                  state = 99999;
                                }
                              }
                              else
                              {
                                state = 99999;
                              }
                            }
                            else
                            {
                              if (token_type == TOKEN_AND)
                              {
                                if (temporary_storage_variable_stackframe_element != NULL)
                                {
                                  assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
                                  if (assembler_statement != NULL)
                                  {
                                    assembler_statement->scope_level = scope_level;
                                    assembler_statement->label = NULL;
                                    assembler_statement->label_associated_with_else_statement = NULL;
                                    assembler_statement->label_after_if_then_else_statement = NULL;
                                    assembler_statement->code_section_contents = NULL;
                                    assembler_statement->data_section_contents = NULL;
                                    assembler_statement->next = NULL;
                                    code_section_string_buffer_max_length = 4096;
                                    assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
                                    if (assembler_statement->code_section_contents != NULL)
                                    {
                                      snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov rax, QWORD PTR -%ld[rbp]\n        mov esi, 7\n        mov rdi, rax\n        call add_operator_element_runtime_expression@PLT\n        mov QWORD PTR -%ld[rbp], rax\n", temporary_storage_variable_stackframe_element->stackframe_offset, temporary_storage_variable_stackframe_element->stackframe_offset);
                                      if (assembler_program != NULL)
                                      {
                                        temp_assembler_element = assembler_program;
                                        while (temp_assembler_element->next != NULL)
                                        {
                                          temp_assembler_element = temp_assembler_element->next;
                                        }
                                        temp_assembler_element->next = assembler_statement;
                                      }
                                      else
                                      {
                                        assembler_program = assembler_statement;
                                      }
                                      state = 20;
                                    }
                                    else
                                    {
                                      state = 99999;
                                    }
                                  }
                                  else
                                  {
                                    state = 99999;
                                  }
                                }
                                else
                                {
                                  state = 99999;
                                }
                              }
                              else
                              {
                                if (token_type == TOKEN_OR)
                                {
                                  if (temporary_storage_variable_stackframe_element != NULL)
                                  {
                                    assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
                                    if (assembler_statement != NULL)
                                    {
                                      assembler_statement->scope_level = scope_level;
                                      assembler_statement->label = NULL;
                                      assembler_statement->label_associated_with_else_statement = NULL;
                                      assembler_statement->label_after_if_then_else_statement = NULL;
                                      assembler_statement->code_section_contents = NULL;
                                      assembler_statement->data_section_contents = NULL;
                                      assembler_statement->next = NULL;
                                      code_section_string_buffer_max_length = 4096;
                                      assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
                                      if (assembler_statement->code_section_contents != NULL)
                                      {
                                        snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov rax, QWORD PTR -%ld[rbp]\n        mov esi, 8\n        mov rdi, rax\n        call add_operator_element_runtime_expression@PLT\n        mov QWORD PTR -%ld[rbp], rax\n", temporary_storage_variable_stackframe_element->stackframe_offset, temporary_storage_variable_stackframe_element->stackframe_offset);
                                        if (assembler_program != NULL)
                                        {
                                          temp_assembler_element = assembler_program;
                                          while (temp_assembler_element->next != NULL)
                                          {
                                            temp_assembler_element = temp_assembler_element->next;
                                          }
                                          temp_assembler_element->next = assembler_statement;
                                        }
                                        else
                                        {
                                          assembler_program = assembler_statement;
                                        }
                                        state = 20;
                                      }
                                      else
                                      {
                                        state = 99999;
                                      }
                                    }
                                    else
                                    {
                                      state = 99999;
                                    }
                                  }
                                  else
                                  {
                                    state = 99999;
                                  }
                                }
                                else
                                {
                                  if (token_type == TOKEN_XOR)
                                  {
                                    if (temporary_storage_variable_stackframe_element != NULL)
                                    {
                                      assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
                                      if (assembler_statement != NULL)
                                      {
                                        assembler_statement->scope_level = scope_level;
                                        assembler_statement->label = NULL;
                                        assembler_statement->label_associated_with_else_statement = NULL;
                                        assembler_statement->label_after_if_then_else_statement = NULL;
                                        assembler_statement->code_section_contents = NULL;
                                        assembler_statement->data_section_contents = NULL;
                                        assembler_statement->next = NULL;
                                        code_section_string_buffer_max_length = 4096;
                                        assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
                                        if (assembler_statement->code_section_contents != NULL)
                                        {
                                          snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov rax, QWORD PTR -%ld[rbp]\n        mov esi, 9\n        mov rdi, rax\n        call add_operator_element_runtime_expression@PLT\n        mov QWORD PTR -%ld[rbp], rax\n", temporary_storage_variable_stackframe_element->stackframe_offset, temporary_storage_variable_stackframe_element->stackframe_offset);
                                          if (assembler_program != NULL)
                                          {
                                            temp_assembler_element = assembler_program;
                                            while (temp_assembler_element->next != NULL)
                                            {
                                              temp_assembler_element = temp_assembler_element->next;
                                            }
                                            temp_assembler_element->next = assembler_statement;
                                          }
                                          else
                                          {
                                            assembler_program = assembler_statement;
                                          }
                                          state = 20;
                                        }
                                        else
                                        {
                                          state = 99999;
                                        }
                                      }
                                      else
                                      {
                                        state = 99999;
                                      }
                                    }
                                    else
                                    {
                                      state = 99999;
                                    }
                                  }
                                  else
                                  {
                                    if (token_type == TOKEN_NOT)
                                    {
                                      if (temporary_storage_variable_stackframe_element != NULL)
                                      {
                                        assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
                                        if (assembler_statement != NULL)
                                        {
                                          assembler_statement->scope_level = scope_level;
                                          assembler_statement->label = NULL;
                                          assembler_statement->label_associated_with_else_statement = NULL;
                                          assembler_statement->label_after_if_then_else_statement = NULL;
                                          assembler_statement->code_section_contents = NULL;
                                          assembler_statement->data_section_contents = NULL;
                                          assembler_statement->next = NULL;
                                          code_section_string_buffer_max_length = 4096;
                                          assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
                                          if (assembler_statement->code_section_contents != NULL)
                                          {
                                            snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov rax, QWORD PTR -%ld[rbp]\n        mov esi, 10\n        mov rdi, rax\n        call add_operator_element_runtime_expression@PLT\n        mov QWORD PTR -%ld[rbp], rax\n", temporary_storage_variable_stackframe_element->stackframe_offset, temporary_storage_variable_stackframe_element->stackframe_offset);
                                            if (assembler_program != NULL)
                                            {
                                              temp_assembler_element = assembler_program;
                                              while (temp_assembler_element->next != NULL)
                                              {
                                                temp_assembler_element = temp_assembler_element->next;
                                              }
                                              temp_assembler_element->next = assembler_statement;
                                            }
                                            else
                                            {
                                              assembler_program = assembler_statement;
                                            }
                                            state = 20;
                                          }
                                          else
                                          {
                                            state = 99999;
                                          }
                                        }
                                        else
                                        {
                                          state = 99999;
                                        }
                                      }
                                      else
                                      {
                                        state = 99999;
                                      }
                                    }
                                    else
                                    {
                                      if (token_type == TOKEN_EQUAL)
                                      {
                                        if (temporary_storage_variable_stackframe_element != NULL)
                                        {
                                          assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
                                          if (assembler_statement != NULL)
                                          {
                                            assembler_statement->scope_level = scope_level;
                                            assembler_statement->label = NULL;
                                            assembler_statement->label_associated_with_else_statement = NULL;
                                            assembler_statement->label_after_if_then_else_statement = NULL;
                                            assembler_statement->code_section_contents = NULL;
                                            assembler_statement->data_section_contents = NULL;
                                            assembler_statement->next = NULL;
                                            code_section_string_buffer_max_length = 4096;
                                            assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
                                            if (assembler_statement->code_section_contents != NULL)
                                            {
                                              snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov rax, QWORD PTR -%ld[rbp]\n        mov esi, 5\n        mov rdi, rax\n        call add_operator_element_runtime_expression@PLT\n        mov QWORD PTR -%ld[rbp], rax\n", temporary_storage_variable_stackframe_element->stackframe_offset, temporary_storage_variable_stackframe_element->stackframe_offset);
                                              if (assembler_program != NULL)
                                              {
                                                temp_assembler_element = assembler_program;
                                                while (temp_assembler_element->next != NULL)
                                                {
                                                  temp_assembler_element = temp_assembler_element->next;
                                                }
                                                temp_assembler_element->next = assembler_statement;
                                              }
                                              else
                                              {
                                                assembler_program = assembler_statement;
                                              }
                                              state = 20;
                                            }
                                            else
                                            {
                                              state = 99999;
                                            }
                                          }
                                          else
                                          {
                                            state = 99999;
                                          }
                                        }
                                        else
                                        {
                                          state = 99999;
                                        }
                                      }
                                      else
                                      {
                                        if (token_type == TOKEN_NOT_EQUAL)
                                        {
                                          if (temporary_storage_variable_stackframe_element != NULL)
                                          {
                                            assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
                                            if (assembler_statement != NULL)
                                            {
                                              assembler_statement->scope_level = scope_level;
                                              assembler_statement->label = NULL;
                                              assembler_statement->label_associated_with_else_statement = NULL;
                                              assembler_statement->label_after_if_then_else_statement = NULL;
                                              assembler_statement->code_section_contents = NULL;
                                              assembler_statement->data_section_contents = NULL;
                                              assembler_statement->next = NULL;
                                              code_section_string_buffer_max_length = 4096;
                                              assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
                                              if (assembler_statement->code_section_contents != NULL)
                                              {
                                                snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov rax, QWORD PTR -%ld[rbp]\n        mov esi, 6\n        mov rdi, rax\n        call add_operator_element_runtime_expression@PLT\n        mov QWORD PTR -%ld[rbp], rax\n", temporary_storage_variable_stackframe_element->stackframe_offset, temporary_storage_variable_stackframe_element->stackframe_offset);
                                                if (assembler_program != NULL)
                                                {
                                                  temp_assembler_element = assembler_program;
                                                  while (temp_assembler_element->next != NULL)
                                                  {
                                                    temp_assembler_element = temp_assembler_element->next;
                                                  }
                                                  temp_assembler_element->next = assembler_statement;
                                                }
                                                else
                                                {
                                                  assembler_program = assembler_statement;
                                                }
                                                state = 20;
                                              }
                                              else
                                              {
                                                state = 99999;
                                              }
                                            }
                                            else
                                            {
                                              state = 99999;
                                            }
                                          }
                                          else
                                          {
                                            state = 99999;
                                          }
                                        }
                                        else
                                        {
                                          if (token_type == TOKEN_GREATER_THAN)
                                          {
                                            if (temporary_storage_variable_stackframe_element != NULL)
                                            {
                                              assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
                                              if (assembler_statement != NULL)
                                              {
                                                assembler_statement->scope_level = scope_level;
                                                assembler_statement->label = NULL;
                                                assembler_statement->label_associated_with_else_statement = NULL;
                                                assembler_statement->label_after_if_then_else_statement = NULL;
                                                assembler_statement->code_section_contents = NULL;
                                                assembler_statement->data_section_contents = NULL;
                                                assembler_statement->next = NULL;
                                                code_section_string_buffer_max_length = 4096;
                                                assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
                                                if (assembler_statement->code_section_contents != NULL)
                                                {
                                                  snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov rax, QWORD PTR -%ld[rbp]\n        mov esi, 2\n        mov rdi, rax\n        call add_operator_element_runtime_expression@PLT\n        mov QWORD PTR -%ld[rbp], rax\n", temporary_storage_variable_stackframe_element->stackframe_offset, temporary_storage_variable_stackframe_element->stackframe_offset);
                                                  if (assembler_program != NULL)
                                                  {
                                                    temp_assembler_element = assembler_program;
                                                    while (temp_assembler_element->next != NULL)
                                                    {
                                                      temp_assembler_element = temp_assembler_element->next;
                                                    }
                                                    temp_assembler_element->next = assembler_statement;
                                                  }
                                                  else
                                                  {
                                                    assembler_program = assembler_statement;
                                                  }
                                                  state = 20;
                                                }
                                                else
                                                {
                                                  state = 99999;
                                                }
                                              }
                                              else
                                              {
                                                state = 99999;
                                              }
                                            }
                                            else
                                            {
                                              state = 99999;
                                            }
                                          }
                                          else
                                          {
                                            if (token_type == TOKEN_LESS_THAN)
                                            {
                                              if (temporary_storage_variable_stackframe_element != NULL)
                                              {
                                                assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
                                                if (assembler_statement != NULL)
                                                {
                                                  assembler_statement->scope_level = scope_level;
                                                  assembler_statement->label = NULL;
                                                  assembler_statement->label_associated_with_else_statement = NULL;
                                                  assembler_statement->label_after_if_then_else_statement = NULL;
                                                  assembler_statement->code_section_contents = NULL;
                                                  assembler_statement->data_section_contents = NULL;
                                                  assembler_statement->next = NULL;
                                                  code_section_string_buffer_max_length = 4096;
                                                  assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
                                                  if (assembler_statement->code_section_contents != NULL)
                                                  {
                                                    snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov rax, QWORD PTR -%ld[rbp]\n        mov esi, 4\n        mov rdi, rax\n        call add_operator_element_runtime_expression@PLT\n        mov QWORD PTR -%ld[rbp], rax\n", temporary_storage_variable_stackframe_element->stackframe_offset, temporary_storage_variable_stackframe_element->stackframe_offset);
                                                    if (assembler_program != NULL)
                                                    {
                                                      temp_assembler_element = assembler_program;
                                                      while (temp_assembler_element->next != NULL)
                                                      {
                                                        temp_assembler_element = temp_assembler_element->next;
                                                      }
                                                      temp_assembler_element->next = assembler_statement;
                                                    }
                                                    else
                                                    {
                                                      assembler_program = assembler_statement;
                                                    }
                                                    state = 20;
                                                  }
                                                  else
                                                  {
                                                    state = 99999;
                                                  }
                                                }
                                                else
                                                {
                                                  state = 99999;
                                                }
                                              }
                                              else
                                              {
                                                state = 99999;
                                              }
                                            }
                                            else
                                            {
                                              if (token_type == TOKEN_GREATER_THAN_OR_EQUAL)
                                              {
                                                if (temporary_storage_variable_stackframe_element != NULL)
                                                {
                                                  assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
                                                  if (assembler_statement != NULL)
                                                  {
                                                    assembler_statement->scope_level = scope_level;
                                                    assembler_statement->label = NULL;
                                                    assembler_statement->label_associated_with_else_statement = NULL;
                                                    assembler_statement->label_after_if_then_else_statement = NULL;
                                                    assembler_statement->code_section_contents = NULL;
                                                    assembler_statement->data_section_contents = NULL;
                                                    assembler_statement->next = NULL;
                                                    code_section_string_buffer_max_length = 4096;
                                                    assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
                                                    if (assembler_statement->code_section_contents != NULL)
                                                    {
                                                      snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov rax, QWORD PTR -%ld[rbp]\n        mov esi, 1\n        mov rdi, rax\n        call add_operator_element_runtime_expression@PLT\n        mov QWORD PTR -%ld[rbp], rax\n", temporary_storage_variable_stackframe_element->stackframe_offset, temporary_storage_variable_stackframe_element->stackframe_offset);
                                                      if (assembler_program != NULL)
                                                      {
                                                        temp_assembler_element = assembler_program;
                                                        while (temp_assembler_element->next != NULL)
                                                        {
                                                          temp_assembler_element = temp_assembler_element->next;
                                                        }
                                                        temp_assembler_element->next = assembler_statement;
                                                      }
                                                      else
                                                      {
                                                        assembler_program = assembler_statement;
                                                      }
                                                      state = 20;
                                                    }
                                                    else
                                                    {
                                                      state = 99999;
                                                    }
                                                  }
                                                  else
                                                  {
                                                    state = 99999;
                                                  }
                                                }
                                                else
                                                {
                                                  state = 99999;
                                                }
                                              }
                                              else
                                              {
                                                if (token_type == TOKEN_LESS_THAN_OR_EQUAL)
                                                {
                                                  if (temporary_storage_variable_stackframe_element != NULL)
                                                  {
                                                    assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
                                                    if (assembler_statement != NULL)
                                                    {
                                                      assembler_statement->scope_level = scope_level;
                                                      assembler_statement->label = NULL;
                                                      assembler_statement->label_associated_with_else_statement = NULL;
                                                      assembler_statement->label_after_if_then_else_statement = NULL;
                                                      assembler_statement->code_section_contents = NULL;
                                                      assembler_statement->data_section_contents = NULL;
                                                      assembler_statement->next = NULL;
                                                    }
                                                    else
                                                    {
                                                      state = 99999;
                                                    }
                                                    if (assembler_statement != NULL)
                                                    {
                                                      code_section_string_buffer_max_length = 4096;
                                                      assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
                                                      if (assembler_statement->code_section_contents != NULL)
                                                      {
                                                        snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov rax, QWORD PTR -%ld[rbp]\n        mov esi, 3\n        mov rdi, rax\n        call add_operator_element_runtime_expression@PLT\n        mov QWORD PTR -%ld[rbp], rax\n", temporary_storage_variable_stackframe_element->stackframe_offset, temporary_storage_variable_stackframe_element->stackframe_offset);
                                                        if (assembler_program != NULL)
                                                        {
                                                          temp_assembler_element = assembler_program;
                                                          while (temp_assembler_element->next != NULL)
                                                          {
                                                            temp_assembler_element = temp_assembler_element->next;
                                                          }
                                                          temp_assembler_element->next = assembler_statement;
                                                        }
                                                        else
                                                        {
                                                          assembler_program = assembler_statement;
                                                        }
                                                        state = 20;
                                                      }
                                                      else
                                                      {
                                                        state = 99999;
                                                      }
                                                    }
                                                    else
                                                    {
                                                      state = 99999;
                                                    }
                                                  }
                                                  else
                                                  {
                                                    state = 99999;
                                                  }
                                                }
                                                else
                                                {
                                                  state = 99999;
                                                }
                                              }
                                            }
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          break;
          default:
          break;
        } 
      }
      else
      {
        state = 99999;
      }
      if (state != 99999)
      {
        if (ast_element != NULL)
        {
          ast_element = ast_element->sibling;
        }
      }
    }
    if (state != 99999)
    {
// ***************************************************************************************************
// * Second pass:                                                                                    *
// *                                                                                                 *
// * STEP 1. Generate the x86 assembler instructions to evaluate the run-time expression built.      *
// *                                                                                                 *
// * STEP 2: Temporarily store the result of the evaluation on the stack in the expression evaluator *
// *         temporary variable allocated for this task.                                             *
// *                                                                                                 *
// * STEP 3: Release memory allocated for any previous value in the target variable.                 *
// *                                                                                                 *
// * STEP 4: Move the result from step 2 (stored in the temporary expression evaluator) into the     *
// *         target variable.                                                                        *        
// *                                                                                                 *
// * STEP 5: Set the temporary expression evaluator variable to NULL (don't release memory since the *
// *         target variable points to the value now.                                                *
// ***************************************************************************************************
      if ((target_variable_stackframe_element != NULL) && (temporary_storage_variable_stackframe_element != NULL))
      {
        if (target_variable_attribute_type == _datatype)
        {

          switch (target_variable_datatype)
          {
            case _int:
// ***************************************************************************************************
// * STEP 1. Generate the x86 assembler instructions to evaluate the run-time expression built.      *
// *                                                                                                 *
// * STEP 2: Temporarily store the result of the evaluation on the stack in the expression evaluator *
// *         temporary variable allocated for this task.                                             *
// ***************************************************************************************************
              assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
              if (assembler_statement != NULL)
              {
                assembler_statement->scope_level = scope_level;
                assembler_statement->label = NULL;
                assembler_statement->label_associated_with_else_statement = NULL;
                assembler_statement->label_after_if_then_else_statement = NULL;
                assembler_statement->code_section_contents = NULL;
                assembler_statement->data_section_contents = NULL;
                assembler_statement->next = NULL;
                code_section_string_buffer_max_length = 4096;
                assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
                if (assembler_statement->code_section_contents != NULL)
                {
                  snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov rax, QWORD PTR -%ld[rbp]\n        mov rdi, rax\n        call evaluate_runtime_expression_return_integer_result_for_set_statement@PLT\n        mov QWORD PTR -%ld[rbp], rax\n", temporary_storage_variable_stackframe_element->stackframe_offset, temporary_storage_variable_stackframe_element->stackframe_offset);
                }
                if (assembler_program != NULL)
                {
                  temp_assembler_element = assembler_program;
                  while (temp_assembler_element->next != NULL)
                  {
                    temp_assembler_element = temp_assembler_element->next;
                  }
                  temp_assembler_element->next = assembler_statement;
                }
                else
                {
                  assembler_program = assembler_statement;
                }
              }
              else
              {
                state = 99999;
              }
// ***********************************************************************************
// * STEP 3: Release memory allocated for any previous value in the target variable. *
// ***********************************************************************************
              assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
              if (assembler_statement != NULL)
              {
                assembler_statement->scope_level = scope_level;
                assembler_statement->label = NULL;
                assembler_statement->label_associated_with_else_statement = NULL;
                assembler_statement->label_after_if_then_else_statement = NULL;
                assembler_statement->code_section_contents = NULL;
                assembler_statement->data_section_contents = NULL;
                assembler_statement->next = NULL;
                code_section_string_buffer_max_length = 4096;
                assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
                if (assembler_statement->code_section_contents != NULL)
                {
                  snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov rax, QWORD PTR -%ld[rbp]\n        mov rdi, rax\n        call packed_string_integer_release_memory@PLT\n        mov QWORD PTR -%ld[rbp], rax\n", target_variable_stackframe_element->stackframe_offset, target_variable_stackframe_element->stackframe_offset);
                }
                if (assembler_program != NULL)
                {
                  temp_assembler_element = assembler_program;
                  while (temp_assembler_element->next != NULL)
                  {
                    temp_assembler_element = temp_assembler_element->next;
                  }
                  temp_assembler_element->next = assembler_statement;
                }
                else
                {
                  assembler_program = assembler_statement;
                }
              }
              else
              {
                state = 99999;
              }
// ****************************************************************************************************************
// * STEP 4: Move the result from step 2 (stored in the temporary expression evaluator) into the target variable. *
// ****************************************************************************************************************
              assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
              if (assembler_statement != NULL)
              {
                assembler_statement->scope_level = scope_level;
                assembler_statement->label = NULL;
                assembler_statement->label_associated_with_else_statement = NULL;
                assembler_statement->label_after_if_then_else_statement = NULL;
                assembler_statement->code_section_contents = NULL;
                assembler_statement->data_section_contents = NULL;
                assembler_statement->next = NULL;
                code_section_string_buffer_max_length = 4096;
                assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
                if (assembler_statement->code_section_contents != NULL)
                {
                  snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov rax, QWORD PTR -%ld[rbp]\n        mov QWORD PTR -%ld[rbp], rax\n", temporary_storage_variable_stackframe_element->stackframe_offset, target_variable_stackframe_element->stackframe_offset);
                }
                if (assembler_program != NULL)
                {
                  temp_assembler_element = assembler_program;
                  while (temp_assembler_element->next != NULL)
                  {
                    temp_assembler_element = temp_assembler_element->next;
                  }
                  temp_assembler_element->next = assembler_statement;
                }
                else
                {
                  assembler_program = assembler_statement;
                }
              }
              else
              {
                state = 99999;
              }
// *************************************************************************************************
// * STEP 5: Set the temporary expression evaluator variable to NULL. NOTE: I don't release memory *
// *         from the temporary variable since the target variable points to the value now.        *
// *************************************************************************************************
              assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
              if (assembler_statement != NULL)
              {
                assembler_statement->scope_level = scope_level;
                assembler_statement->label = NULL;
                assembler_statement->label_associated_with_else_statement = NULL;
                assembler_statement->label_after_if_then_else_statement = NULL;
                assembler_statement->code_section_contents = NULL;
                assembler_statement->data_section_contents = NULL;
                assembler_statement->next = NULL;
                code_section_string_buffer_max_length = 4096;
                assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
                if (assembler_statement->code_section_contents != NULL)
                {
                  snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov QWORD PTR -%ld[rbp], 0\n", temporary_storage_variable_stackframe_element->stackframe_offset);
                }
                else
                {
                  state = 99999;
                }
                if (assembler_program != NULL)
                {
                  temp_assembler_element = assembler_program;
                  while (temp_assembler_element->next != NULL)
                  {
                    temp_assembler_element = temp_assembler_element->next;
                  }
                  temp_assembler_element->next = assembler_statement;
                }
                else
                {
                  assembler_program = assembler_statement;
                }
              }
	    break;
	    case _real:
// ***************************************************************************************************
// * STEP 1. Generate the x86 assembler instructions to evaluate the run-time expression built.      *
// *                                                                                                 *
// * STEP 2: Temporarily store the result of the evaluation on the stack in the expression evaluator *
// *         temporary variable allocated for this task.                                             *
// ***************************************************************************************************
              assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
              if (assembler_statement != NULL)
              {
                assembler_statement->scope_level = scope_level;
                assembler_statement->label = NULL;
                assembler_statement->label_associated_with_else_statement = NULL;
                assembler_statement->label_after_if_then_else_statement = NULL;
                assembler_statement->code_section_contents = NULL;
                assembler_statement->data_section_contents = NULL;
                assembler_statement->next = NULL;
                code_section_string_buffer_max_length = 4096;
                assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
                if (assembler_statement->code_section_contents != NULL)
                {
                  snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov rax, QWORD PTR -%ld[rbp]\n        mov rdi, rax\n        call evaluate_runtime_expression_return_real_result_for_set_statement@PLT\n        mov QWORD PTR -%ld[rbp], rax\n", temporary_storage_variable_stackframe_element->stackframe_offset, temporary_storage_variable_stackframe_element->stackframe_offset);
                }
                if (assembler_program != NULL)
                {
                  temp_assembler_element = assembler_program;
                  while (temp_assembler_element->next != NULL)
                  {
                    temp_assembler_element = temp_assembler_element->next;
                  }
                  temp_assembler_element->next = assembler_statement;
                }
                else
                {
                  assembler_program = assembler_statement;
                }
              }
              else
              {
                state = 99999;
              }
// ***********************************************************************************
// * STEP 3: Release memory allocated for any previous value in the target variable. *
// ***********************************************************************************
              assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
              if (assembler_statement != NULL)
              {
                assembler_statement->scope_level = scope_level;
                assembler_statement->label = NULL;
                assembler_statement->label_associated_with_else_statement = NULL;
                assembler_statement->label_after_if_then_else_statement = NULL;
                assembler_statement->code_section_contents = NULL;
                assembler_statement->data_section_contents = NULL;
                assembler_statement->next = NULL;
                code_section_string_buffer_max_length = 4096;
                assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
                if (assembler_statement->code_section_contents != NULL)
                {
                  snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov rax, QWORD PTR -%ld[rbp]\n        mov rdi, rax\n        call packed_string_real_release_memory@PLT\n        mov QWORD PTR -%ld[rbp], rax\n", target_variable_stackframe_element->stackframe_offset, target_variable_stackframe_element->stackframe_offset);
                }
                if (assembler_program != NULL)
                {
                  temp_assembler_element = assembler_program;
                  while (temp_assembler_element->next != NULL)
                  {
                    temp_assembler_element = temp_assembler_element->next;
                  }
                  temp_assembler_element->next = assembler_statement;
                }
                else
                {
                  assembler_program = assembler_statement;
                }
              }
              else
              {
                state = 99999;
              }
// ****************************************************************************************************************
// * STEP 4: Move the result from step 2 (stored in the temporary expression evaluator) into the target variable. *
// ****************************************************************************************************************
              assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
              if (assembler_statement != NULL)
              {
                assembler_statement->scope_level = scope_level;
                assembler_statement->label = NULL;
                assembler_statement->label_associated_with_else_statement = NULL;
                assembler_statement->label_after_if_then_else_statement = NULL;
                assembler_statement->code_section_contents = NULL;
                assembler_statement->data_section_contents = NULL;
                assembler_statement->next = NULL;
                code_section_string_buffer_max_length = 4096;
                assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
                if (assembler_statement->code_section_contents != NULL)
                {
                  snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov rax, QWORD PTR -%ld[rbp]\n        mov QWORD PTR -%ld[rbp], rax\n", temporary_storage_variable_stackframe_element->stackframe_offset, target_variable_stackframe_element->stackframe_offset);
                }
                if (assembler_program != NULL)
                {
                  temp_assembler_element = assembler_program;
                  while (temp_assembler_element->next != NULL)
                  {
                    temp_assembler_element = temp_assembler_element->next;
                  }
                  temp_assembler_element->next = assembler_statement;
                }
                else
                {
                  assembler_program = assembler_statement;
                }
              }
              else
              {
                state = 99999;
              }
// *************************************************************************************************
// * STEP 5: Set the temporary expression evaluator variable to NULL. NOTE: I don't release memory *
// *         from the temporary variable since the target variable points to the value now.        *
// *************************************************************************************************
              assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
              if (assembler_statement != NULL)
              {
                assembler_statement->scope_level = scope_level;
                assembler_statement->label = NULL;
                assembler_statement->label_associated_with_else_statement = NULL;
                assembler_statement->label_after_if_then_else_statement = NULL;
                assembler_statement->code_section_contents = NULL;
                assembler_statement->data_section_contents = NULL;
                assembler_statement->next = NULL;
                code_section_string_buffer_max_length = 4096;
                assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
                if (assembler_statement->code_section_contents != NULL)
                {
                  snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov QWORD PTR -%ld[rbp], 0\n", temporary_storage_variable_stackframe_element->stackframe_offset);
                }
                else
                {
                  state = 99999;
                }
                if (assembler_program != NULL)
                {
                  temp_assembler_element = assembler_program;
                  while (temp_assembler_element->next != NULL)
                  {
                    temp_assembler_element = temp_assembler_element->next;
                  }
                  temp_assembler_element->next = assembler_statement;
                }
                else
                {
                  assembler_program = assembler_statement;
                }
              }
	    break;
            case _bool:
// ***************************************************************************************************
// * STEP 1. Generate the x86 assembler instructions to evaluate the run-time expression built.      *
// *                                                                                                 *
// * STEP 2: Temporarily store the result of the evaluation on the stack in the expression evaluator *
// *         temporary variable allocated for this task.                                             *
// ***************************************************************************************************
              assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
              if (assembler_statement != NULL)
              {
                assembler_statement->scope_level = scope_level;
                assembler_statement->label = NULL;
                assembler_statement->label_associated_with_else_statement = NULL;
                assembler_statement->label_after_if_then_else_statement = NULL;
                assembler_statement->code_section_contents = NULL;
                assembler_statement->data_section_contents = NULL;
                assembler_statement->next = NULL;
                code_section_string_buffer_max_length = 4096;
                assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
                if (assembler_statement->code_section_contents != NULL)
                {
                  snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov rax, QWORD PTR -%ld[rbp]\n        mov rdi, rax\n        call evaluate_runtime_expression_return_boolean_result_for_set_statement@PLT\n        mov QWORD PTR -%ld[rbp], rax\n", temporary_storage_variable_stackframe_element->stackframe_offset, temporary_storage_variable_stackframe_element->stackframe_offset);
                }
                if (assembler_program != NULL)
                {
                  temp_assembler_element = assembler_program;
                  while (temp_assembler_element->next != NULL)
                  {
                    temp_assembler_element = temp_assembler_element->next;
                  }
                  temp_assembler_element->next = assembler_statement;
                }
                else
                {
                  assembler_program = assembler_statement;
                }
              }
              else
              {
                state = 99999;
              }
// ***********************************************************************************
// * STEP 3: Release memory allocated for any previous value in the target variable. *
// ***********************************************************************************
              assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
              if (assembler_statement != NULL)
              {
                assembler_statement->scope_level = scope_level;
                assembler_statement->label = NULL;
                assembler_statement->label_associated_with_else_statement = NULL;
                assembler_statement->label_after_if_then_else_statement = NULL;
                assembler_statement->code_section_contents = NULL;
                assembler_statement->data_section_contents = NULL;
                assembler_statement->next = NULL;
                code_section_string_buffer_max_length = 4096;
                assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
                if (assembler_statement->code_section_contents != NULL)
                {
                  snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov rax, QWORD PTR -%ld[rbp]\n        mov rdi, rax\n        call boolean_release_memory@PLT\n        mov QWORD PTR -%ld[rbp], rax\n", target_variable_stackframe_element->stackframe_offset, target_variable_stackframe_element->stackframe_offset);
                }
                if (assembler_program != NULL)
                {
                  temp_assembler_element = assembler_program;
                  while (temp_assembler_element->next != NULL)
                  {
                    temp_assembler_element = temp_assembler_element->next;
                  }
                  temp_assembler_element->next = assembler_statement;
                }
                else
                {
                  assembler_program = assembler_statement;
                }
              }
              else
              {
                state = 99999;
              }
// ****************************************************************************************************************
// * STEP 4: Move the result from step 2 (stored in the temporary expression evaluator) into the target variable. *
// ****************************************************************************************************************
              assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
              if (assembler_statement != NULL)
              {
                assembler_statement->scope_level = scope_level;
                assembler_statement->label = NULL;
                assembler_statement->label_associated_with_else_statement = NULL;
                assembler_statement->label_after_if_then_else_statement = NULL;
                assembler_statement->code_section_contents = NULL;
                assembler_statement->data_section_contents = NULL;
                assembler_statement->next = NULL;
                code_section_string_buffer_max_length = 4096;
                assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
                if (assembler_statement->code_section_contents != NULL)
                {
                  snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov rax, QWORD PTR -%ld[rbp]\n        mov QWORD PTR -%ld[rbp], rax\n", temporary_storage_variable_stackframe_element->stackframe_offset, target_variable_stackframe_element->stackframe_offset);
                }
                if (assembler_program != NULL)
                {
                  temp_assembler_element = assembler_program;
                  while (temp_assembler_element->next != NULL)
                  {
                    temp_assembler_element = temp_assembler_element->next;
                  }
                  temp_assembler_element->next = assembler_statement;
                }
                else
                {
                  assembler_program = assembler_statement;
                }
              }
              else
              {
                state = 99999;
              }
// *************************************************************************************************
// * STEP 5: Set the temporary expression evaluator variable to NULL. NOTE: I don't release memory *
// *         from the temporary variable since the target variable points to the value now.        *
// *************************************************************************************************
              assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
              if (assembler_statement != NULL)
              {
                assembler_statement->scope_level = scope_level;
                assembler_statement->label = NULL;
                assembler_statement->label_associated_with_else_statement = NULL;
                assembler_statement->label_after_if_then_else_statement = NULL;
                assembler_statement->code_section_contents = NULL;
                assembler_statement->data_section_contents = NULL;
                assembler_statement->next = NULL;
                code_section_string_buffer_max_length = 4096;
                assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
                if (assembler_statement->code_section_contents != NULL)
                {
                  snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov QWORD PTR -%ld[rbp], 0\n", temporary_storage_variable_stackframe_element->stackframe_offset);
                }
                else
                {
                  state = 99999;
                }
                if (assembler_program != NULL)
                {
                  temp_assembler_element = assembler_program;
                  while (temp_assembler_element->next != NULL)
                  {
                    temp_assembler_element = temp_assembler_element->next;
                  }
                  temp_assembler_element->next = assembler_statement;
                }
                else
                {
                  assembler_program = assembler_statement;
                }
              }
	    break;
	    default:
	    break;
	  }
        }
      }
    }
  }
  return assembler_program;
}




asmblr_node * create_assembler_output_if_statement (asmblr_node *assembler_program, ast_node *abstract_syntax_tree, symtab_node *symbol_table, stackframe_node *stackframe_cross_reference_table, unsigned long long int scope_level)
{
  asmblr_node *assembler_statement, *assembler_element, *temp_assembler_element;
  ast_node *ast_element, *temp_ast_element;
  symtab_node *symbol_table_element, *temporary_storage_variable;
  stackframe_node *temporary_storage_variable_stackframe_element, *chaga_variable_stackframe_element;
  chaga_attribute_type target_variable_attribute_type;
  chaga_attribute_datatype target_variable_datatype;
  int state, token_type;
  char *token, *constant_integer_token, *constant_real_token, *constant_boolean_token;
  unsigned char new_variable[1024], *data_section_string_buffer;
  unsigned long long int *label;
  size_t i, j, token_string_length, code_section_string_buffer_max_length, data_section_string_buffer_length; 

  assembler_statement = NULL;
  data_section_string_buffer = NULL;
  ast_element = NULL;
  temporary_storage_variable = NULL;
  temporary_storage_variable_stackframe_element = NULL;
  constant_integer_token = NULL;
  constant_real_token = NULL;
  constant_boolean_token = NULL;
  token = NULL;
  if (abstract_syntax_tree != NULL)
  {
    state = 0;
    ast_element = abstract_syntax_tree;
    while ((ast_element != NULL) && (state != 99999))
    {
      token = ast_element->token;
      token_type = ast_element->token_type;
      if (token != NULL)
      {
        //printf ("In create_assembler_output_if_statement: state = %d, token = %s\n", state, token);
        switch (state)
        {
          case 0:
            temporary_storage_variable = retrieve_unused_temporary_variable_for_numerical_expression_processing (symbol_table, _datatype, _pointer, scope_level);
            if (temporary_storage_variable != NULL)
            {
              if (temporary_storage_variable->identifier != NULL)
              {
                temporary_storage_variable_stackframe_element = retrieve_stackframe_offset (stackframe_cross_reference_table, temporary_storage_variable);
                if (temporary_storage_variable_stackframe_element != NULL)
                {
                  state = 10; 
                }
                else
                {
                  state = 99999;
                }
              }
              else
              {
                state = 99999;
              }
            }
            else
            {
              state = 99999;
            }
          break;
          case 10:
            if (token_type == TOKEN_IDENTIFIER)
            {
              assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
              if (assembler_statement != NULL)
              {
                assembler_statement->scope_level = scope_level;
                assembler_statement->label = NULL;
                assembler_statement->label_associated_with_else_statement = NULL;
                assembler_statement->label_after_if_then_else_statement = NULL;
                assembler_statement->code_section_contents = NULL;
                assembler_statement->data_section_contents = NULL;
                assembler_statement->next = NULL;
                if (temporary_storage_variable_stackframe_element != NULL)
                {
                  symbol_table_element = ast_element->symbol_table_entry;
                  if (symbol_table_element != NULL)
                  {
                    chaga_variable_stackframe_element = retrieve_stackframe_offset (stackframe_cross_reference_table, symbol_table_element);
                    if (chaga_variable_stackframe_element != NULL)
                    {
                      if (symbol_table_element->attribute_type == _datatype)
                      {
                        switch (symbol_table_element->datatype)
                        {
                          case _int:
                            code_section_string_buffer_max_length = 4096;
                            assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
                            if (assembler_statement->code_section_contents != NULL)
                            {
                              snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov rdx, QWORD PTR -%ld[rbp]\n        mov rax, QWORD PTR -%ld[rbp]\n        mov ecx, 0\n        mov esi, 1\n        mov rdi, rax\n        call add_operand_element_runtime_expression@PLT\n        mov QWORD PTR -%ld[rbp], rax\n", chaga_variable_stackframe_element->stackframe_offset, temporary_storage_variable_stackframe_element->stackframe_offset, temporary_storage_variable_stackframe_element->stackframe_offset);
                              if (assembler_program != NULL)
                              {
                                temp_assembler_element = assembler_program;
                                while (temp_assembler_element->next != NULL)
                                {
                                  temp_assembler_element = temp_assembler_element->next;
                                }
                                temp_assembler_element->next = assembler_statement;
                              }
                              else
                              {
                                assembler_program = assembler_statement;
                              }
                              state = 10;
                            }
                            else
                            {
                              state = 99999;
                            }
                          break;
                          case _real:
                            code_section_string_buffer_max_length = 4096;
                            assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
                            if (assembler_statement->code_section_contents != NULL)
                            {
                              snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov rdx, QWORD PTR -%ld[rbp]\n        mov rax, QWORD PTR -%ld[rbp]\n        mov ecx, 0\n        mov esi, 3\n        mov rdi, rax\n        call add_operand_element_runtime_expression@PLT\n        mov QWORD PTR -%ld[rbp], rax\n", chaga_variable_stackframe_element->stackframe_offset, temporary_storage_variable_stackframe_element->stackframe_offset, temporary_storage_variable_stackframe_element->stackframe_offset);
                              if (assembler_program != NULL)
                              {
                                temp_assembler_element = assembler_program;
                                while (temp_assembler_element->next != NULL)
                                {
                                  temp_assembler_element = temp_assembler_element->next;
                                }
                                temp_assembler_element->next = assembler_statement;
                              }
                              else
                              {
                                assembler_program = assembler_statement;
                              }
                              state = 10;
                            }
                            else
                            {
                              state = 99999;
                            }
                          break;
                          case _bool:
                            code_section_string_buffer_max_length = 4096;
                            assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
                            if (assembler_statement->code_section_contents != NULL)
                            {
                              snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov rdx, QWORD PTR -%ld[rbp]\n        mov rax, QWORD PTR -%ld[rbp]\n        mov ecx, 0\n        mov esi, 2\n        mov rdi, rax\n        call add_operand_element_runtime_expression@PLT\n        mov QWORD PTR -%ld[rbp], rax\n", chaga_variable_stackframe_element->stackframe_offset, temporary_storage_variable_stackframe_element->stackframe_offset, temporary_storage_variable_stackframe_element->stackframe_offset);
                              if (assembler_program != NULL)
                              {
                                temp_assembler_element = assembler_program;
                                while (temp_assembler_element->next != NULL)
                                {
                                  temp_assembler_element = temp_assembler_element->next;
                                }
                                temp_assembler_element->next = assembler_statement;
                              }
                              else
                              {
                                assembler_program = assembler_statement;
                              }
                              state = 10;
                            }
                            else
                            {
                              state = 99999;
                            }
                          break;
                          default:
                            state = 99999;
                          break;
                        }
                      }
                      else
                      {
                        state = 99999;
                      }
                    }
                    else
                    {
                      state = 99999;
                    }
                  }
                  else
                  {
                    state = 99999;
                  }
                }
                else
                {
                  state = 99999;
                }
              }
              else
              {
                state = 99999;
              }
            }
            else
            {
              if (token_type == TOKEN_IDENTIFIER_INTEGER_CONSTANT)
              {
                if (temporary_storage_variable_stackframe_element != NULL)
                {
                  assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
                  if (assembler_statement != NULL)
                  {
                    assembler_statement->label = (unsigned long long int *) malloc(sizeof(unsigned long long int));
                    if (assembler_statement->label != NULL)
                    {
                      assembler_statement->scope_level = scope_level;
                      assembler_statement->label_associated_with_else_statement = NULL;
                      assembler_statement->label_after_if_then_else_statement = NULL;
                      assembler_statement->code_section_contents = NULL;
                      assembler_statement->data_section_contents = NULL;
                      assembler_statement->next = NULL;
                      label = retrieve_highest_label_number_from_assembly_output (assembler_program);
                      if (label != NULL)
                      {
                        *assembler_statement->label = (*label) + 1;
                      }
                      else
                      {
                        *assembler_statement->label = 1;
                      }
                      constant_integer_token = token;
                      if (constant_integer_token != NULL)
                      {
                        token_string_length = strlen(constant_integer_token);
                        data_section_string_buffer_length = token_string_length + 37;
                        data_section_string_buffer = (unsigned char *) malloc(sizeof(char)*data_section_string_buffer_length); 
                        if (data_section_string_buffer != NULL)
                        {
                          data_section_string_buffer[0]  = ' ';
                          data_section_string_buffer[1]  = ' ';
                          data_section_string_buffer[2]  = ' ';
                          data_section_string_buffer[3]  = ' ';
                          data_section_string_buffer[4]  = ' ';
                          data_section_string_buffer[5]  = ' ';
                          data_section_string_buffer[6]  = ' ';
                          data_section_string_buffer[7]  = ' ';
                          data_section_string_buffer[8]  = '.';
                          data_section_string_buffer[9]  = 's';
                          data_section_string_buffer[10] = 't';
                          data_section_string_buffer[11] = 'r';
                          data_section_string_buffer[12] = 'i';
                          data_section_string_buffer[13] = 'n';
                          data_section_string_buffer[14] = 'g';
                          data_section_string_buffer[15] = ' ';
                          data_section_string_buffer[16] = '"';
                          for (i = 0; i < token_string_length; i++)
                          {
                            data_section_string_buffer[17+i] = constant_integer_token[i];
                          }
                          data_section_string_buffer[17+token_string_length] = '"';
                          data_section_string_buffer[18+token_string_length] = '\n';
                          data_section_string_buffer[19+token_string_length] = ' ';
                          data_section_string_buffer[20+token_string_length] = ' ';
                          data_section_string_buffer[21+token_string_length] = ' ';
                          data_section_string_buffer[22+token_string_length] = ' ';
                          data_section_string_buffer[23+token_string_length] = ' ';
                          data_section_string_buffer[24+token_string_length] = ' ';
                          data_section_string_buffer[25+token_string_length] = ' ';
                          data_section_string_buffer[26+token_string_length] = ' ';
                          data_section_string_buffer[27+token_string_length] = '.';
                          data_section_string_buffer[28+token_string_length] = 'a';
                          data_section_string_buffer[29+token_string_length] = 'l';
                          data_section_string_buffer[30+token_string_length] = 'i';
                          data_section_string_buffer[31+token_string_length] = 'g';
                          data_section_string_buffer[32+token_string_length] = 'n';
                          data_section_string_buffer[33+token_string_length] = ' ';
                          data_section_string_buffer[34+token_string_length] = '8';
                          data_section_string_buffer[35+token_string_length] = '\n';
                          data_section_string_buffer[36+token_string_length] = '\0';
                        }
                        assembler_statement->data_section_contents = data_section_string_buffer;
                        code_section_string_buffer_max_length = 4096;
                        assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
                        if (assembler_statement->code_section_contents != NULL)
                        {
                          snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov rax, QWORD PTR -%ld[rbp]\n        mov ecx, 0\n        lea rdx, .M%llu[rip]\n        mov esi, 4\n        mov rdi, rax\n        call add_operand_element_runtime_expression@PLT\n        mov QWORD PTR -%ld[rbp], rax\n", temporary_storage_variable_stackframe_element->stackframe_offset, *assembler_statement->label, temporary_storage_variable_stackframe_element->stackframe_offset);
                          state = 10;
                        }
                        if (assembler_program != NULL)
                        {
                          temp_assembler_element = assembler_program;
                          while (temp_assembler_element->next != NULL)
                          {
                            temp_assembler_element = temp_assembler_element->next;
                          }
                          temp_assembler_element->next = assembler_statement;
                        }
                        else
                        {
                          assembler_program = assembler_statement;
                        }
                      }
                      else
                      {
                        state = 99999;
                      }
                    }
                    else
                    {
                      state = 99999;
                    }
                  }
                  else
                  {
                    state = 99999;
                  }
                }
                else
                {
                  state = 99999;
                }
              }
              else
              {
                if (token_type == TOKEN_IDENTIFIER_FLOATING_POINT_CONSTANT)
                {
                  if (temporary_storage_variable_stackframe_element != NULL)
                  {
                    assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
                    if (assembler_statement != NULL)
                    {
                      assembler_statement->label = (unsigned long long int *) malloc(sizeof(unsigned long long int));
                      if (assembler_statement->label != NULL)
                      {
                        assembler_statement->scope_level = scope_level;
                        assembler_statement->label_associated_with_else_statement = NULL;
                        assembler_statement->label_after_if_then_else_statement = NULL;
                        assembler_statement->code_section_contents = NULL;
                        assembler_statement->data_section_contents = NULL;
                        assembler_statement->next = NULL;
                        label = retrieve_highest_label_number_from_assembly_output (assembler_program);
                        if (label != NULL)
                        {
                          *assembler_statement->label = (*label) + 1;
                        } 
                        else
                        {
                          *assembler_statement->label = 1;
                        }
                        constant_real_token = token;
                        if (constant_real_token != NULL)
                        {
                          token_string_length = strlen(constant_real_token);
                          data_section_string_buffer_length = token_string_length + 37;
                          data_section_string_buffer = (unsigned char *) malloc(sizeof(char)*data_section_string_buffer_length); 
                          if (data_section_string_buffer != NULL)
                          {
                            data_section_string_buffer[0]  = ' ';
                            data_section_string_buffer[1]  = ' ';
                            data_section_string_buffer[2]  = ' ';
                            data_section_string_buffer[3]  = ' ';
                            data_section_string_buffer[4]  = ' ';
                            data_section_string_buffer[5]  = ' ';
                            data_section_string_buffer[6]  = ' ';
                            data_section_string_buffer[7]  = ' ';
                            data_section_string_buffer[8]  = '.';
                            data_section_string_buffer[9]  = 's';
                            data_section_string_buffer[10] = 't';
                            data_section_string_buffer[11] = 'r';
                            data_section_string_buffer[12] = 'i';
                            data_section_string_buffer[13] = 'n';
                            data_section_string_buffer[14] = 'g';
                            data_section_string_buffer[15] = ' ';
                            data_section_string_buffer[16] = '"';
                            for (i = 0; i < token_string_length; i++)
                            {
                              data_section_string_buffer[17+i] = constant_real_token[i];
                            }
                            data_section_string_buffer[17+token_string_length] = '"';
                            data_section_string_buffer[18+token_string_length] = '\n';
                            data_section_string_buffer[19+token_string_length] = ' ';
                            data_section_string_buffer[20+token_string_length] = ' ';
                            data_section_string_buffer[21+token_string_length] = ' ';
                            data_section_string_buffer[22+token_string_length] = ' ';
                            data_section_string_buffer[23+token_string_length] = ' ';
                            data_section_string_buffer[24+token_string_length] = ' ';
                            data_section_string_buffer[25+token_string_length] = ' ';
                            data_section_string_buffer[26+token_string_length] = ' ';
                            data_section_string_buffer[27+token_string_length] = '.';
                            data_section_string_buffer[28+token_string_length] = 'a';
                            data_section_string_buffer[29+token_string_length] = 'l';
                            data_section_string_buffer[30+token_string_length] = 'i';
                            data_section_string_buffer[31+token_string_length] = 'g';
                            data_section_string_buffer[32+token_string_length] = 'n';
                            data_section_string_buffer[33+token_string_length] = ' ';
                            data_section_string_buffer[34+token_string_length] = '8';
                            data_section_string_buffer[35+token_string_length] = '\n';
                            data_section_string_buffer[36+token_string_length] = '\0';
                          }
                          assembler_statement->data_section_contents = data_section_string_buffer;
                          code_section_string_buffer_max_length = 4096;
                          assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
                          if (assembler_statement->code_section_contents != NULL)
                          {
                            snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov rax, QWORD PTR -%ld[rbp]\n        mov ecx, 0\n        lea rdx, .M%llu[rip]\n        mov esi, 5\n        mov rdi, rax\n        call add_operand_element_runtime_expression@PLT\n        mov QWORD PTR -%ld[rbp], rax\n", temporary_storage_variable_stackframe_element->stackframe_offset, *assembler_statement->label, temporary_storage_variable_stackframe_element->stackframe_offset);
                            state = 10;
                          }
                          if (assembler_program != NULL)
                          {
                            temp_assembler_element = assembler_program;
                            while (temp_assembler_element->next != NULL)
                            {
                              temp_assembler_element = temp_assembler_element->next;
                            }
                            temp_assembler_element->next = assembler_statement;
                          }
                          else
                          {
                            assembler_program = assembler_statement;
                          }
                        }
                        else
                        {
                          state = 99999;
                        }
                      }
                      else
                      {
                        state = 99999;
                      }
                    }
                    else
                    {
                      state = 99999;
                    }
                  }
                  else
                  {
                    state = 99999;
                  }
                }
                else
                {
                  if ((token_type == TOKEN_TRUE) || (token_type == TOKEN_FALSE))
                  {
                    if (temporary_storage_variable_stackframe_element != NULL)
                    {
                      assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
                      if (assembler_statement != NULL)
                      {
                        assembler_statement->label = (unsigned long long int *) malloc(sizeof(unsigned long long int));
                        if (assembler_statement->label != NULL)
                        {
                          assembler_statement->scope_level = scope_level;
                          assembler_statement->label_associated_with_else_statement = NULL;
                          assembler_statement->label_after_if_then_else_statement = NULL;
                          assembler_statement->code_section_contents = NULL;
                          assembler_statement->data_section_contents = NULL;
                          assembler_statement->next = NULL;
                          label = retrieve_highest_label_number_from_assembly_output (assembler_program);
                          if (label != NULL)
                          {
                            *assembler_statement->label = (*label) + 1; // This label will be used to access the string "TRUE" or "FALSE" in assembler. It is different from label above used to identify ELSE statement blocks.
                          }
                          else
                          {
                            *assembler_statement->label = 1;
                          }
                          constant_boolean_token = token;
                          if (constant_boolean_token != NULL)
                          {
                            token_string_length = strlen(constant_boolean_token);
                            data_section_string_buffer_length = token_string_length + 37;
                            data_section_string_buffer = (unsigned char *) malloc(sizeof(char)*data_section_string_buffer_length); 
                            if (data_section_string_buffer != NULL)
                            {
                              data_section_string_buffer[0]  = ' ';
                              data_section_string_buffer[1]  = ' ';
                              data_section_string_buffer[2]  = ' ';
                              data_section_string_buffer[3]  = ' ';
                              data_section_string_buffer[4]  = ' ';
                              data_section_string_buffer[5]  = ' ';
                              data_section_string_buffer[6]  = ' ';
                              data_section_string_buffer[7]  = ' ';
                              data_section_string_buffer[8]  = '.';
                              data_section_string_buffer[9]  = 's';
                              data_section_string_buffer[10] = 't';
                              data_section_string_buffer[11] = 'r';
                              data_section_string_buffer[12] = 'i';
                              data_section_string_buffer[13] = 'n';
                              data_section_string_buffer[14] = 'g';
                              data_section_string_buffer[15] = ' ';
                              data_section_string_buffer[16] = '"';
                              for (i = 0; i < token_string_length; i++)
                              {
                                data_section_string_buffer[17+i] = constant_boolean_token[i];
                              }
                              data_section_string_buffer[17+token_string_length] = '"';
                              data_section_string_buffer[18+token_string_length] = '\n';
                              data_section_string_buffer[19+token_string_length] = ' ';
                              data_section_string_buffer[20+token_string_length] = ' ';
                              data_section_string_buffer[21+token_string_length] = ' ';
                              data_section_string_buffer[22+token_string_length] = ' ';
                              data_section_string_buffer[23+token_string_length] = ' ';
                              data_section_string_buffer[24+token_string_length] = ' ';
                              data_section_string_buffer[25+token_string_length] = ' ';
                              data_section_string_buffer[26+token_string_length] = ' ';
                              data_section_string_buffer[27+token_string_length] = '.';
                              data_section_string_buffer[28+token_string_length] = 'a';
                              data_section_string_buffer[29+token_string_length] = 'l';
                              data_section_string_buffer[30+token_string_length] = 'i';
                              data_section_string_buffer[31+token_string_length] = 'g';
                              data_section_string_buffer[32+token_string_length] = 'n';
                              data_section_string_buffer[33+token_string_length] = ' ';
                              data_section_string_buffer[34+token_string_length] = '8';
                              data_section_string_buffer[35+token_string_length] = '\n';
                              data_section_string_buffer[36+token_string_length] = '\0';
                            }
                            assembler_statement->data_section_contents = data_section_string_buffer;
                            code_section_string_buffer_max_length = 4096;
                            assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
                            if (assembler_statement->code_section_contents != NULL)
                            {
                              snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov rax, QWORD PTR -%ld[rbp]\n        mov ecx, 0\n        lea rdx, .M%llu[rip]\n        mov esi, 6\n        mov rdi, rax\n        call add_operand_element_runtime_expression@PLT\n        mov QWORD PTR -%ld[rbp], rax\n", temporary_storage_variable_stackframe_element->stackframe_offset, *assembler_statement->label, temporary_storage_variable_stackframe_element->stackframe_offset);
                              state = 10;
                            }
                            if (assembler_program != NULL)
                            {
                              temp_assembler_element = assembler_program;
                              while (temp_assembler_element->next != NULL)
                              {
                                temp_assembler_element = temp_assembler_element->next;
                              }
                              temp_assembler_element->next = assembler_statement;
                            }
                            else
                            {
                              assembler_program = assembler_statement;
                            }
                          }
                          else
                          {
                            state = 99999;
                          }
                        }
                        else
                        {
                          state = 99999;
                        }
                      }
                      else
                      {
                        state = 99999;
                      }
                    }
                    else
                    {
                      state = 99999;
                    }
                  }
                  else
                  {
                    if (token_type == TOKEN_PLUS)
                    {
                      if (temporary_storage_variable_stackframe_element != NULL)
                      {
                        assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
                        if (assembler_statement != NULL)
                        {
                          assembler_statement->scope_level = scope_level;
                          assembler_statement->label = NULL;
                          assembler_statement->label_associated_with_else_statement = NULL;
                          assembler_statement->label_after_if_then_else_statement = NULL;
                          assembler_statement->code_section_contents = NULL;
                          assembler_statement->data_section_contents = NULL;
                          assembler_statement->next = NULL;
                          code_section_string_buffer_max_length = 4096;
                          assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
                          if (assembler_statement->code_section_contents != NULL)
                          {
                            snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov rax, QWORD PTR -%ld[rbp]\n        mov esi, 11\n        mov rdi, rax\n        call add_operator_element_runtime_expression@PLT\n        mov QWORD PTR -%ld[rbp], rax\n", temporary_storage_variable_stackframe_element->stackframe_offset, temporary_storage_variable_stackframe_element->stackframe_offset);
                            if (assembler_program != NULL)
                            {
                              temp_assembler_element = assembler_program;
                              while (temp_assembler_element->next != NULL)
                              {
                                temp_assembler_element = temp_assembler_element->next;
                              }
                              temp_assembler_element->next = assembler_statement;
                            }
                            else
                            {
                              assembler_program = assembler_statement;
                            }
                            state = 10;
                          }
                          else
                          {
                            state = 99999;
                          }
                        }
                        else
                        {
                          state = 99999;
                        }
                      }
                      else
                      {
                        state = 99999;
                      }
                    }
                    else
                    {
                      if (token_type == TOKEN_MINUS)
                      {
                        if (temporary_storage_variable_stackframe_element != NULL)
                        {
                          assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
                          if (assembler_statement != NULL)
                          {
                            assembler_statement->scope_level = scope_level;
                            assembler_statement->label = NULL;
                            assembler_statement->label_associated_with_else_statement = NULL;
                            assembler_statement->label_after_if_then_else_statement = NULL;
                            assembler_statement->code_section_contents = NULL;
                            assembler_statement->data_section_contents = NULL;
                            assembler_statement->next = NULL;
                            code_section_string_buffer_max_length = 4096;
                            assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
                            if (assembler_statement->code_section_contents != NULL)
                            {
                              snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov rax, QWORD PTR -%ld[rbp]\n        mov esi, 12\n        mov rdi, rax\n        call add_operator_element_runtime_expression@PLT\n        mov QWORD PTR -%ld[rbp], rax\n", temporary_storage_variable_stackframe_element->stackframe_offset, temporary_storage_variable_stackframe_element->stackframe_offset);
                              if (assembler_program != NULL)
                              {
                                temp_assembler_element = assembler_program;
                                while (temp_assembler_element->next != NULL)
                                {
                                  temp_assembler_element = temp_assembler_element->next;
                                }
                                temp_assembler_element->next = assembler_statement;
                              }
                              else
                              {
                                assembler_program = assembler_statement;
                              }
                              state = 10;
                            }
                            else
                            {
                              state = 99999;
                            }
                          }
                          else
                          {
                            state = 99999;
                          }
                        }
                        else
                        {
                          state = 99999;
                        }
                      }
                      else
                      {
                        if (token_type == TOKEN_ASTERISK)
                        {
                          if (temporary_storage_variable_stackframe_element != NULL)
                          {
                            assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
                            if (assembler_statement != NULL)
                            {
                              assembler_statement->scope_level = scope_level;
                              assembler_statement->label = NULL;
                              assembler_statement->label_associated_with_else_statement = NULL;
                              assembler_statement->label_after_if_then_else_statement = NULL;
                              assembler_statement->code_section_contents = NULL;
                              assembler_statement->data_section_contents = NULL;
                              assembler_statement->next = NULL;
                              code_section_string_buffer_max_length = 4096;
                              assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
                              if (assembler_statement->code_section_contents != NULL)
                              {
                                snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov rax, QWORD PTR -%ld[rbp]\n        mov esi, 13\n        mov rdi, rax\n        call add_operator_element_runtime_expression@PLT\n        mov QWORD PTR -%ld[rbp], rax\n", temporary_storage_variable_stackframe_element->stackframe_offset, temporary_storage_variable_stackframe_element->stackframe_offset);
                                if (assembler_program != NULL)
                                {
                                  temp_assembler_element = assembler_program;
                                  while (temp_assembler_element->next != NULL)
                                  {
                                    temp_assembler_element = temp_assembler_element->next;
                                  }
                                  temp_assembler_element->next = assembler_statement;
                                }
                                else
                                {
                                  assembler_program = assembler_statement;
                                }
                                state = 10;
                              }
                              else
                              {
                                state = 99999;
                              }
                            }
                            else
                            {
                              state = 99999;
                            }
                          }
                          else
                          {
                            state = 99999;
                          }
                        }
                        else
                        {
                          if (token_type == TOKEN_DIVIDE)
                          {
                            if (temporary_storage_variable_stackframe_element != NULL)
                            {
                              assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
                              if (assembler_statement != NULL)
                              {
                                assembler_statement->scope_level = scope_level;
                                assembler_statement->label = NULL;
                                assembler_statement->label_associated_with_else_statement = NULL;
                                assembler_statement->label_after_if_then_else_statement = NULL;
                                assembler_statement->code_section_contents = NULL;
                                assembler_statement->data_section_contents = NULL;
                                assembler_statement->next = NULL;
                                code_section_string_buffer_max_length = 4096;
                                assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
                                if (assembler_statement->code_section_contents != NULL)
                                {
                                  snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov rax, QWORD PTR -%ld[rbp]\n        mov esi, 14\n        mov rdi, rax\n        call add_operator_element_runtime_expression@PLT\n        mov QWORD PTR -%ld[rbp], rax\n", temporary_storage_variable_stackframe_element->stackframe_offset, temporary_storage_variable_stackframe_element->stackframe_offset);
                                  if (assembler_program != NULL)
                                  {
                                    temp_assembler_element = assembler_program;
                                    while (temp_assembler_element->next != NULL)
                                    {
                                      temp_assembler_element = temp_assembler_element->next;
                                    }
                                    temp_assembler_element->next = assembler_statement;
                                  }
                                  else
                                  {
                                    assembler_program = assembler_statement;
                                  }
                                  state = 10;
                                }
                                else
                                {
                                  state = 99999;
                                }
                              }
                              else
                              {
                                state = 99999;
                              }
                            }
                            else
                            {
                              state = 99999;
                            }
                          }
                          else
                          {
                            if (token_type == TOKEN_MODULO)
                            {
                              if (temporary_storage_variable_stackframe_element != NULL)
                              {
                                assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
                                if (assembler_statement != NULL)
                                {
                                  assembler_statement->scope_level = scope_level;
                                  assembler_statement->label = NULL;
                                  assembler_statement->label_associated_with_else_statement = NULL;
                                  assembler_statement->label_after_if_then_else_statement = NULL;
                                  assembler_statement->code_section_contents = NULL;
                                  assembler_statement->data_section_contents = NULL;
                                  assembler_statement->next = NULL;
                                  code_section_string_buffer_max_length = 4096;
                                  assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
                                  if (assembler_statement->code_section_contents != NULL)
                                  {
                                    snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov rax, QWORD PTR -%ld[rbp]\n        mov esi, 15\n        mov rdi, rax\n        call add_operator_element_runtime_expression@PLT\n        mov QWORD PTR -%ld[rbp], rax\n", temporary_storage_variable_stackframe_element->stackframe_offset, temporary_storage_variable_stackframe_element->stackframe_offset);
                                    if (assembler_program != NULL)
                                    {
                                      temp_assembler_element = assembler_program;
                                      while (temp_assembler_element->next != NULL)
                                      {
                                        temp_assembler_element = temp_assembler_element->next;
                                      }
                                      temp_assembler_element->next = assembler_statement;
                                    }
                                    else
                                    {
                                      assembler_program = assembler_statement;
                                    }
                                    state = 10;
                                  }
                                  else
                                  {
                                    state = 99999;
                                  }
                                }
                                else
                                {
                                  state = 99999;
                                }
                              }
                              else
                              {
                                state = 99999;
                              }
                            }
                            else
                            {
                              if (token_type == TOKEN_AND)
                              {
                                if (temporary_storage_variable_stackframe_element != NULL)
                                {
                                  assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
                                  if (assembler_statement != NULL)
                                  {
                                    assembler_statement->scope_level = scope_level;
                                    assembler_statement->label = NULL;
                                    assembler_statement->label_associated_with_else_statement = NULL;
                                    assembler_statement->label_after_if_then_else_statement = NULL;
                                    assembler_statement->code_section_contents = NULL;
                                    assembler_statement->data_section_contents = NULL;
                                    assembler_statement->next = NULL;
                                    code_section_string_buffer_max_length = 4096;
                                    assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
                                    if (assembler_statement->code_section_contents != NULL)
                                    {
                                      snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov rax, QWORD PTR -%ld[rbp]\n        mov esi, 7\n        mov rdi, rax\n        call add_operator_element_runtime_expression@PLT\n        mov QWORD PTR -%ld[rbp], rax\n", temporary_storage_variable_stackframe_element->stackframe_offset, temporary_storage_variable_stackframe_element->stackframe_offset);
                                      if (assembler_program != NULL)
                                      {
                                        temp_assembler_element = assembler_program;
                                        while (temp_assembler_element->next != NULL)
                                        {
                                          temp_assembler_element = temp_assembler_element->next;
                                        }
                                        temp_assembler_element->next = assembler_statement;
                                      }
                                      else
                                      {
                                        assembler_program = assembler_statement;
                                      }
                                      state = 10;
                                    }
                                    else
                                    {
                                      state = 99999;
                                    }
                                  }
                                  else
                                  {
                                    state = 99999;
                                  }
                                }
                                else
                                {
                                  state = 99999;
                                }
                              }
                              else
                              {
                                if (token_type == TOKEN_OR)
                                {
                                  if (temporary_storage_variable_stackframe_element != NULL)
                                  {
                                    assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
                                    if (assembler_statement != NULL)
                                    {
                                      assembler_statement->scope_level = scope_level;
                                      assembler_statement->label = NULL;
                                      assembler_statement->label_associated_with_else_statement = NULL;
                                      assembler_statement->label_after_if_then_else_statement = NULL;
                                      assembler_statement->code_section_contents = NULL;
                                      assembler_statement->data_section_contents = NULL;
                                      assembler_statement->next = NULL;
                                      code_section_string_buffer_max_length = 4096;
                                      assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
                                      if (assembler_statement->code_section_contents != NULL)
                                      {
                                        snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov rax, QWORD PTR -%ld[rbp]\n        mov esi, 8\n        mov rdi, rax\n        call add_operator_element_runtime_expression@PLT\n        mov QWORD PTR -%ld[rbp], rax\n", temporary_storage_variable_stackframe_element->stackframe_offset, temporary_storage_variable_stackframe_element->stackframe_offset);
                                        if (assembler_program != NULL)
                                        {
                                          temp_assembler_element = assembler_program;
                                          while (temp_assembler_element->next != NULL)
                                          {
                                            temp_assembler_element = temp_assembler_element->next;
                                          }
                                          temp_assembler_element->next = assembler_statement;
                                        }
                                        else
                                        {
                                          assembler_program = assembler_statement;
                                        }
                                        state = 10;
                                      }
                                      else
                                      {
                                        state = 99999;
                                      }
                                    }
                                    else
                                    {
                                      state = 99999;
                                    }
                                  }
                                  else
                                  {
                                    state = 99999;
                                  }
                                }
                                else
                                {
                                  if (token_type == TOKEN_XOR)
                                  {
                                    if (temporary_storage_variable_stackframe_element != NULL)
                                    {
                                      assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
                                      if (assembler_statement != NULL)
                                      {
                                        assembler_statement->scope_level = scope_level;
                                        assembler_statement->label = NULL;
                                        assembler_statement->label_associated_with_else_statement = NULL;
                                        assembler_statement->label_after_if_then_else_statement = NULL;
                                        assembler_statement->code_section_contents = NULL;
                                        assembler_statement->data_section_contents = NULL;
                                        assembler_statement->next = NULL;
                                        code_section_string_buffer_max_length = 4096;
                                        assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
                                        if (assembler_statement->code_section_contents != NULL)
                                        {
                                          snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov rax, QWORD PTR -%ld[rbp]\n        mov esi, 9\n        mov rdi, rax\n        call add_operator_element_runtime_expression@PLT\n        mov QWORD PTR -%ld[rbp], rax\n", temporary_storage_variable_stackframe_element->stackframe_offset, temporary_storage_variable_stackframe_element->stackframe_offset);
                                          if (assembler_program != NULL)
                                          {
                                            temp_assembler_element = assembler_program;
                                            while (temp_assembler_element->next != NULL)
                                            {
                                              temp_assembler_element = temp_assembler_element->next;
                                            }
                                            temp_assembler_element->next = assembler_statement;
                                          }
                                          else
                                          {
                                            assembler_program = assembler_statement;
                                          }
                                          state = 10;
                                        }
                                        else
                                        {
                                          state = 99999;
                                        }
                                      }
                                      else
                                      {
                                        state = 99999;
                                      }
                                    }
                                    else
                                    {
                                      state = 99999;
                                    }
                                  }
                                  else
                                  {
                                    if (token_type == TOKEN_NOT)
                                    {
                                      if (temporary_storage_variable_stackframe_element != NULL)
                                      {
                                        assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
                                        if (assembler_statement != NULL)
                                        {
                                          assembler_statement->scope_level = scope_level;
                                          assembler_statement->label = NULL;
                                          assembler_statement->label_associated_with_else_statement = NULL;
                                          assembler_statement->label_after_if_then_else_statement = NULL;
                                          assembler_statement->code_section_contents = NULL;
                                          assembler_statement->data_section_contents = NULL;
                                          assembler_statement->next = NULL;
                                          code_section_string_buffer_max_length = 4096;
                                          assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
                                          if (assembler_statement->code_section_contents != NULL)
                                          {
                                            snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov rax, QWORD PTR -%ld[rbp]\n        mov esi, 10\n        mov rdi, rax\n        call add_operator_element_runtime_expression@PLT\n        mov QWORD PTR -%ld[rbp], rax\n", temporary_storage_variable_stackframe_element->stackframe_offset, temporary_storage_variable_stackframe_element->stackframe_offset);
                                            if (assembler_program != NULL)
                                            {
                                              temp_assembler_element = assembler_program;
                                              while (temp_assembler_element->next != NULL)
                                              {
                                                temp_assembler_element = temp_assembler_element->next;
                                              }
                                              temp_assembler_element->next = assembler_statement;
                                            }
                                            else
                                            {
                                              assembler_program = assembler_statement;
                                            }
                                            state = 10;
                                          }
                                          else
                                          {
                                            state = 99999;
                                          }
                                        }
                                        else
                                        {
                                          state = 99999;
                                        }
                                      }
                                      else
                                      {
                                        state = 99999;
                                      }
                                    }
                                    else
                                    {
                                      if (token_type == TOKEN_EQUAL)
                                      {
                                        if (temporary_storage_variable_stackframe_element != NULL)
                                        {
                                          assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
                                          if (assembler_statement != NULL)
                                          {
                                            assembler_statement->scope_level = scope_level;
                                            assembler_statement->label = NULL;
                                            assembler_statement->label_associated_with_else_statement = NULL;
                                            assembler_statement->label_after_if_then_else_statement = NULL;
                                            assembler_statement->code_section_contents = NULL;
                                            assembler_statement->data_section_contents = NULL;
                                            assembler_statement->next = NULL;
                                            code_section_string_buffer_max_length = 4096;
                                            assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
                                            if (assembler_statement->code_section_contents != NULL)
                                            {
                                              snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov rax, QWORD PTR -%ld[rbp]\n        mov esi, 5\n        mov rdi, rax\n        call add_operator_element_runtime_expression@PLT\n        mov QWORD PTR -%ld[rbp], rax\n", temporary_storage_variable_stackframe_element->stackframe_offset, temporary_storage_variable_stackframe_element->stackframe_offset);
                                              if (assembler_program != NULL)
                                              {
                                                temp_assembler_element = assembler_program;
                                                while (temp_assembler_element->next != NULL)
                                                {
                                                  temp_assembler_element = temp_assembler_element->next;
                                                }
                                                temp_assembler_element->next = assembler_statement;
                                              }
                                              else
                                              {
                                                assembler_program = assembler_statement;
                                              }
                                              state = 10;
                                            }
                                            else
                                            {
                                              state = 99999;
                                            }
                                          }
                                          else
                                          {
                                            state = 99999;
                                          }
                                        }
                                        else
                                        {
                                          state = 99999;
                                        }
                                      }
                                      else
                                      {
                                        if (token_type == TOKEN_NOT_EQUAL)
                                        {
                                          if (temporary_storage_variable_stackframe_element != NULL)
                                          {
                                            assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
                                            if (assembler_statement != NULL)
                                            {
                                              assembler_statement->scope_level = scope_level;
                                              assembler_statement->label = NULL;
                                              assembler_statement->label_associated_with_else_statement = NULL;
                                              assembler_statement->label_after_if_then_else_statement = NULL;
                                              assembler_statement->code_section_contents = NULL;
                                              assembler_statement->data_section_contents = NULL;
                                              assembler_statement->next = NULL;
                                              code_section_string_buffer_max_length = 4096;
                                              assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
                                              if (assembler_statement->code_section_contents != NULL)
                                              {
                                                snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov rax, QWORD PTR -%ld[rbp]\n        mov esi, 6\n        mov rdi, rax\n        call add_operator_element_runtime_expression@PLT\n        mov QWORD PTR -%ld[rbp], rax\n", temporary_storage_variable_stackframe_element->stackframe_offset, temporary_storage_variable_stackframe_element->stackframe_offset);
                                                if (assembler_program != NULL)
                                                {
                                                  temp_assembler_element = assembler_program;
                                                  while (temp_assembler_element->next != NULL)
                                                  {
                                                    temp_assembler_element = temp_assembler_element->next;
                                                  }
                                                  temp_assembler_element->next = assembler_statement;
                                                }
                                                else
                                                {
                                                  assembler_program = assembler_statement;
                                                }
                                                state = 10;
                                              }
                                              else
                                              {
                                                state = 99999;
                                              }
                                            }
                                            else
                                            {
                                              state = 99999;
                                            }
                                          }
                                          else
                                          {
                                            state = 99999;
                                          }
                                        }
                                        else
                                        {
                                          if (token_type == TOKEN_GREATER_THAN)
                                          {
                                            if (temporary_storage_variable_stackframe_element != NULL)
                                            {
                                              assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
                                              if (assembler_statement != NULL)
                                              {
                                                assembler_statement->scope_level = scope_level;
                                                assembler_statement->label = NULL;
                                                assembler_statement->label_associated_with_else_statement = NULL;
                                                assembler_statement->label_after_if_then_else_statement = NULL;
                                                assembler_statement->code_section_contents = NULL;
                                                assembler_statement->data_section_contents = NULL;
                                                assembler_statement->next = NULL;
                                                code_section_string_buffer_max_length = 4096;
                                                assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
                                                if (assembler_statement->code_section_contents != NULL)
                                                {
                                                  snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov rax, QWORD PTR -%ld[rbp]\n        mov esi, 2\n        mov rdi, rax\n        call add_operator_element_runtime_expression@PLT\n        mov QWORD PTR -%ld[rbp], rax\n", temporary_storage_variable_stackframe_element->stackframe_offset, temporary_storage_variable_stackframe_element->stackframe_offset);
                                                  if (assembler_program != NULL)
                                                  {
                                                    temp_assembler_element = assembler_program;
                                                    while (temp_assembler_element->next != NULL)
                                                    {
                                                      temp_assembler_element = temp_assembler_element->next;
                                                    }
                                                    temp_assembler_element->next = assembler_statement;
                                                  }
                                                  else
                                                  {
                                                    assembler_program = assembler_statement;
                                                  }
                                                  state = 10;
                                                }
                                                else
                                                {
                                                  state = 99999;
                                                }
                                              }
                                              else
                                              {
                                                state = 99999;
                                              }
                                            }
                                            else
                                            {
                                              state = 99999;
                                            }
                                          }
                                          else
                                          {
                                            if (token_type == TOKEN_LESS_THAN)
                                            {
                                              if (temporary_storage_variable_stackframe_element != NULL)
                                              {
                                                assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
                                                if (assembler_statement != NULL)
                                                {
                                                  assembler_statement->scope_level = scope_level;
                                                  assembler_statement->label = NULL;
                                                  assembler_statement->label_associated_with_else_statement = NULL;
                                                  assembler_statement->label_after_if_then_else_statement = NULL;
                                                  assembler_statement->code_section_contents = NULL;
                                                  assembler_statement->data_section_contents = NULL;
                                                  assembler_statement->next = NULL;
                                                  code_section_string_buffer_max_length = 4096;
                                                  assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
                                                  if (assembler_statement->code_section_contents != NULL)
                                                  {
                                                    snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov rax, QWORD PTR -%ld[rbp]\n        mov esi, 4\n        mov rdi, rax\n        call add_operator_element_runtime_expression@PLT\n        mov QWORD PTR -%ld[rbp], rax\n", temporary_storage_variable_stackframe_element->stackframe_offset, temporary_storage_variable_stackframe_element->stackframe_offset);
                                                    if (assembler_program != NULL)
                                                    {
                                                      temp_assembler_element = assembler_program;
                                                      while (temp_assembler_element->next != NULL)
                                                      {
                                                        temp_assembler_element = temp_assembler_element->next;
                                                      }
                                                      temp_assembler_element->next = assembler_statement;
                                                    }
                                                    else
                                                    {
                                                      assembler_program = assembler_statement;
                                                    }
                                                    state = 10;
                                                  }
                                                  else
                                                  {
                                                    state = 99999;
                                                  }
                                                }
                                                else
                                                {
                                                  state = 99999;
                                                }
                                              }
                                              else
                                              {
                                                state = 99999;
                                              }
                                            }
                                            else
                                            {
                                              if (token_type == TOKEN_GREATER_THAN_OR_EQUAL)
                                              {
                                                if (temporary_storage_variable_stackframe_element != NULL)
                                                {
                                                  assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
                                                  if (assembler_statement != NULL)
                                                  {
                                                    assembler_statement->scope_level = scope_level;
                                                    assembler_statement->label = NULL;
                                                    assembler_statement->label_associated_with_else_statement = NULL;
                                                    assembler_statement->label_after_if_then_else_statement = NULL;
                                                    assembler_statement->code_section_contents = NULL;
                                                    assembler_statement->data_section_contents = NULL;
                                                    assembler_statement->next = NULL;
                                                    code_section_string_buffer_max_length = 4096;
                                                    assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
                                                    if (assembler_statement->code_section_contents != NULL)
                                                    {
                                                      snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov rax, QWORD PTR -%ld[rbp]\n        mov esi, 1\n        mov rdi, rax\n        call add_operator_element_runtime_expression@PLT\n        mov QWORD PTR -%ld[rbp], rax\n", temporary_storage_variable_stackframe_element->stackframe_offset, temporary_storage_variable_stackframe_element->stackframe_offset);
                                                      if (assembler_program != NULL)
                                                      {
                                                        temp_assembler_element = assembler_program;
                                                        while (temp_assembler_element->next != NULL)
                                                        {
                                                          temp_assembler_element = temp_assembler_element->next;
                                                        }
                                                        temp_assembler_element->next = assembler_statement;
                                                      }
                                                      else
                                                      {
                                                        assembler_program = assembler_statement;
                                                      }
                                                      state = 10;
                                                    }
                                                    else
                                                    {
                                                      state = 99999;
                                                    }
                                                  }
                                                  else
                                                  {
                                                    state = 99999;
                                                  }
                                                }
                                                else
                                                {
                                                  state = 99999;
                                                }
                                              }
                                              else
                                              {
                                                if (token_type == TOKEN_LESS_THAN_OR_EQUAL)
                                                {
                                                  if (temporary_storage_variable_stackframe_element != NULL)
                                                  {
                                                    assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
                                                    if (assembler_statement != NULL)
                                                    {
                                                      assembler_statement->scope_level = scope_level;
                                                      assembler_statement->label = NULL;
                                                      assembler_statement->label_associated_with_else_statement = NULL;
                                                      assembler_statement->label_after_if_then_else_statement = NULL;
                                                      assembler_statement->code_section_contents = NULL;
                                                      assembler_statement->data_section_contents = NULL;
                                                      assembler_statement->next = NULL;
                                                    }
                                                    else
                                                    {
                                                      state = 99999;
                                                    }
                                                    if (assembler_statement != NULL)
                                                    {
                                                      code_section_string_buffer_max_length = 4096;
                                                      assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
                                                      if (assembler_statement->code_section_contents != NULL)
                                                      {
                                                        snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov rax, QWORD PTR -%ld[rbp]\n        mov esi, 3\n        mov rdi, rax\n        call add_operator_element_runtime_expression@PLT\n        mov QWORD PTR -%ld[rbp], rax\n", temporary_storage_variable_stackframe_element->stackframe_offset, temporary_storage_variable_stackframe_element->stackframe_offset);
                                                        if (assembler_program != NULL)
                                                        {
                                                          temp_assembler_element = assembler_program;
                                                          while (temp_assembler_element->next != NULL)
                                                          {
                                                            temp_assembler_element = temp_assembler_element->next;
                                                          }
                                                          temp_assembler_element->next = assembler_statement;
                                                        }
                                                        else
                                                        {
                                                          assembler_program = assembler_statement;
                                                        }
                                                        state = 10;
                                                      }
                                                      else
                                                      {
                                                        state = 99999;
                                                      }
                                                    }
                                                    else
                                                    {
                                                      state = 99999;
                                                    }
                                                  }
                                                  else
                                                  {
                                                    state = 99999;
                                                  }
                                                }
                                                else
                                                {
                                                  state = 99999;
                                                }
                                              }
                                            }
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          break;
          default:
          break;
        } 
      }
      else
      {
        state = 99999;
      }
      if (state != 99999)
      {
        if (ast_element != NULL)
        {
          ast_element = ast_element->sibling;
        }
      }
    }
    if (state != 99999)
    {
// **********************************************************************************************
// * Second pass:                                                                               *
// *                                                                                            *
// * STEP 1. Generate the x86 assembler instructions to evaluate the run-time expression built. *
// *                                                                                            *
// * STEP 2: Retrieve the return value from register AL. It will be either TRUE or FALSE.       *
// *         temporary variable allocated for this task. Set the temporary expression           *
// *         evaluator variable to NULL.                                                        *
// **********************************************************************************************
    }
    if (state != 99999)
    {
      if (temporary_storage_variable_stackframe_element != NULL)
      {
        assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
        if (assembler_statement != NULL)
        {
          assembler_statement->scope_level = scope_level;
          assembler_statement->label = NULL;
          assembler_statement->label_associated_with_else_statement = NULL;
          assembler_statement->label_after_if_then_else_statement = NULL;
          assembler_statement->code_section_contents = NULL;
          assembler_statement->data_section_contents = NULL;
          assembler_statement->next = NULL;
          code_section_string_buffer_max_length = 4096;
          assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
          if (assembler_statement->code_section_contents != NULL)
          {
// ******************************************************************************************************************************
// * Now go back to the first IF statement (the first sibling in the current location of the Abstract Syntax Tree. Does this IF *
// * statement have an ELSE statement block? IF so, I need to issue a branch to the ELSE statement block. Otherwise, I need     *
// * to issue a branch to first statement after the IF statement block.                                                         *
// ******************************************************************************************************************************
            ast_element = abstract_syntax_tree;
            if (ast_element != NULL)
            {
              if (ast_element->label_associated_with_else_statement != NULL)
              {
                snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov rax, QWORD PTR -%ld[rbp]\n        mov rdi, rax\n        call evaluate_runtime_expression_return_boolean_result@PLT\n        mov QWORD PTR -%ld[rbp], 0\n        cmp al, 1\n        jne .L%llu\n", temporary_storage_variable_stackframe_element->stackframe_offset, temporary_storage_variable_stackframe_element->stackframe_offset, *ast_element->label_associated_with_else_statement);
              }
              else
              {
// ******************************************************
// * Ok, this IF statement has no ELSE statement block. *
// ******************************************************
                if (ast_element->label_after_if_then_statement != NULL)
                {
                  snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov rax, QWORD PTR -%ld[rbp]\n        mov rdi, rax\n        call evaluate_runtime_expression_return_boolean_result@PLT\n        mov QWORD PTR -%ld[rbp], 0\n        cmp al, 1\n        jne .L%llu\n", temporary_storage_variable_stackframe_element->stackframe_offset, temporary_storage_variable_stackframe_element->stackframe_offset, *ast_element->label_after_if_then_statement);
                }
              }
            }
          }
          if (assembler_program != NULL)
          {
            temp_assembler_element = assembler_program;
            while (temp_assembler_element->next != NULL)
            {
              temp_assembler_element = temp_assembler_element->next;
            }
            temp_assembler_element->next = assembler_statement;
          }
          else
          {
            assembler_program = assembler_statement;
          }
        }
        else
        {
          state = 99999;
        }
      }
    }
  }
  return assembler_program;
}




asmblr_node * create_assembler_output_while_statement (asmblr_node *assembler_program, ast_node *abstract_syntax_tree, symtab_node *symbol_table, stackframe_node *stackframe_cross_reference_table, unsigned long long int scope_level)
{
  asmblr_node *assembler_statement, *assembler_element, *temp_assembler_element;
  ast_node *ast_element, *temp_ast_element;
  symtab_node *symbol_table_element, *temporary_storage_variable;
  stackframe_node *temporary_storage_variable_stackframe_element, *chaga_variable_stackframe_element;
  chaga_attribute_type target_variable_attribute_type;
  chaga_attribute_datatype target_variable_datatype;
  int state, token_type;
  char *token, *constant_integer_token, *constant_real_token, *constant_boolean_token;
  unsigned char new_variable[1024], *data_section_string_buffer;
  unsigned long long int *label;
  size_t i, j, token_string_length, code_section_string_buffer_max_length, data_section_string_buffer_length; 

  assembler_statement = NULL;
  data_section_string_buffer = NULL;
  ast_element = NULL;
  temporary_storage_variable = NULL;
  temporary_storage_variable_stackframe_element = NULL;
  constant_integer_token = NULL;
  constant_real_token = NULL;
  constant_boolean_token = NULL;
  token = NULL;
  if (abstract_syntax_tree != NULL)
  {
    state = 0;
    ast_element = abstract_syntax_tree;
    while ((ast_element != NULL) && (state != 99999))
    {
      token = ast_element->token;
      token_type = ast_element->token_type;
      if (token != NULL)
      {
        //printf ("In create_assembler_output_while_statement: state = %d, token = %s\n", state, token);
        switch (state)
        {
          case 0:
            temporary_storage_variable = retrieve_unused_temporary_variable_for_numerical_expression_processing (symbol_table, _datatype, _pointer, scope_level);
            if (temporary_storage_variable != NULL)
            {
              if (temporary_storage_variable->identifier != NULL)
              {
                temporary_storage_variable_stackframe_element = retrieve_stackframe_offset (stackframe_cross_reference_table, temporary_storage_variable);
                if (temporary_storage_variable_stackframe_element != NULL)
                {
                  state = 10; 
                }
                else
                {
                  state = 99999;
                }
              }
              else
              {
                state = 99999;
              }
            }
            else
            {
              state = 99999;
            }
          break;
          case 10:
            if (token_type == TOKEN_IDENTIFIER)
            {
              assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
              if (assembler_statement != NULL)
              {
                assembler_statement->scope_level = scope_level;
                assembler_statement->label = NULL;
                assembler_statement->label_associated_with_else_statement = NULL;
                assembler_statement->label_after_if_then_else_statement = NULL;
                assembler_statement->code_section_contents = NULL;
                assembler_statement->data_section_contents = NULL;
                assembler_statement->next = NULL;
                if (temporary_storage_variable_stackframe_element != NULL)
                {
                  symbol_table_element = ast_element->symbol_table_entry;
                  if (symbol_table_element != NULL)
                  {
                    chaga_variable_stackframe_element = retrieve_stackframe_offset (stackframe_cross_reference_table, symbol_table_element);
                    if (chaga_variable_stackframe_element != NULL)
                    {
                      if (symbol_table_element->attribute_type == _datatype)
                      {
                        switch (symbol_table_element->datatype)
                        {
                          case _int:
                            code_section_string_buffer_max_length = 4096;
                            assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
                            if (assembler_statement->code_section_contents != NULL)
                            {
                              snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov rdx, QWORD PTR -%ld[rbp]\n        mov rax, QWORD PTR -%ld[rbp]\n        mov ecx, 0\n        mov esi, 1\n        mov rdi, rax\n        call add_operand_element_runtime_expression@PLT\n        mov QWORD PTR -%ld[rbp], rax\n", chaga_variable_stackframe_element->stackframe_offset, temporary_storage_variable_stackframe_element->stackframe_offset, temporary_storage_variable_stackframe_element->stackframe_offset);
                              if (assembler_program != NULL)
                              {
                                temp_assembler_element = assembler_program;
                                while (temp_assembler_element->next != NULL)
                                {
                                  temp_assembler_element = temp_assembler_element->next;
                                }
                                temp_assembler_element->next = assembler_statement;
                              }
                              else
                              {
                                assembler_program = assembler_statement;
                              }
                              state = 10;
                            }
                            else
                            {
                              state = 99999;
                            }
                          break;
                          case _real:
                            code_section_string_buffer_max_length = 4096;
                            assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
                            if (assembler_statement->code_section_contents != NULL)
                            {
                              snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov rdx, QWORD PTR -%ld[rbp]\n        mov rax, QWORD PTR -%ld[rbp]\n        mov ecx, 0\n        mov esi, 3\n        mov rdi, rax\n        call add_operand_element_runtime_expression@PLT\n        mov QWORD PTR -%ld[rbp], rax\n", chaga_variable_stackframe_element->stackframe_offset, temporary_storage_variable_stackframe_element->stackframe_offset, temporary_storage_variable_stackframe_element->stackframe_offset);
                              if (assembler_program != NULL)
                              {
                                temp_assembler_element = assembler_program;
                                while (temp_assembler_element->next != NULL)
                                {
                                  temp_assembler_element = temp_assembler_element->next;
                                }
                                temp_assembler_element->next = assembler_statement;
                              }
                              else
                              {
                                assembler_program = assembler_statement;
                              }
                              state = 10;
                            }
                            else
                            {
                              state = 99999;
                            }
                          break;
                          case _bool:
                            code_section_string_buffer_max_length = 4096;
                            assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
                            if (assembler_statement->code_section_contents != NULL)
                            {
                              snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov rdx, QWORD PTR -%ld[rbp]\n        mov rax, QWORD PTR -%ld[rbp]\n        mov ecx, 0\n        mov esi, 2\n        mov rdi, rax\n        call add_operand_element_runtime_expression@PLT\n        mov QWORD PTR -%ld[rbp], rax\n", chaga_variable_stackframe_element->stackframe_offset, temporary_storage_variable_stackframe_element->stackframe_offset, temporary_storage_variable_stackframe_element->stackframe_offset);
                              if (assembler_program != NULL)
                              {
                                temp_assembler_element = assembler_program;
                                while (temp_assembler_element->next != NULL)
                                {
                                  temp_assembler_element = temp_assembler_element->next;
                                }
                                temp_assembler_element->next = assembler_statement;
                              }
                              else
                              {
                                assembler_program = assembler_statement;
                              }
                              state = 10;
                            }
                            else
                            {
                              state = 99999;
                            }
                          break;
                          default:
                            state = 99999;
                          break;
                        }
                      }
                      else
                      {
                        state = 99999;
                      }
                    }
                    else
                    {
                      state = 99999;
                    }
                  }
                  else
                  {
                    state = 99999;
                  }
                }
                else
                {
                  state = 99999;
                }
              }
              else
              {
                state = 99999;
              }
            }
            else
            {
              if (token_type == TOKEN_IDENTIFIER_INTEGER_CONSTANT)
              {
                if (temporary_storage_variable_stackframe_element != NULL)
                {
                  assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
                  if (assembler_statement != NULL)
                  {
                    assembler_statement->label = (unsigned long long int *) malloc(sizeof(unsigned long long int));
                    if (assembler_statement->label != NULL)
                    {
                      assembler_statement->scope_level = scope_level;
                      assembler_statement->label_associated_with_else_statement = NULL;
                      assembler_statement->label_after_if_then_else_statement = NULL;
                      assembler_statement->code_section_contents = NULL;
                      assembler_statement->data_section_contents = NULL;
                      assembler_statement->next = NULL;
                      label = retrieve_highest_label_number_from_assembly_output (assembler_program);
                      if (label != NULL)
                      {
                        *assembler_statement->label = (*label) + 1;
                      }
                      else
                      {
                        *assembler_statement->label = 1;
                      }
                      constant_integer_token = token;
                      if (constant_integer_token != NULL)
                      {
                        token_string_length = strlen(constant_integer_token);
                        data_section_string_buffer_length = token_string_length + 37;
                        data_section_string_buffer = (unsigned char *) malloc(sizeof(char)*data_section_string_buffer_length); 
                        if (data_section_string_buffer != NULL)
                        {
                          data_section_string_buffer[0]  = ' ';
                          data_section_string_buffer[1]  = ' ';
                          data_section_string_buffer[2]  = ' ';
                          data_section_string_buffer[3]  = ' ';
                          data_section_string_buffer[4]  = ' ';
                          data_section_string_buffer[5]  = ' ';
                          data_section_string_buffer[6]  = ' ';
                          data_section_string_buffer[7]  = ' ';
                          data_section_string_buffer[8]  = '.';
                          data_section_string_buffer[9]  = 's';
                          data_section_string_buffer[10] = 't';
                          data_section_string_buffer[11] = 'r';
                          data_section_string_buffer[12] = 'i';
                          data_section_string_buffer[13] = 'n';
                          data_section_string_buffer[14] = 'g';
                          data_section_string_buffer[15] = ' ';
                          data_section_string_buffer[16] = '"';
                          for (i = 0; i < token_string_length; i++)
                          {
                            data_section_string_buffer[17+i] = constant_integer_token[i];
                          }
                          data_section_string_buffer[17+token_string_length] = '"';
                          data_section_string_buffer[18+token_string_length] = '\n';
                          data_section_string_buffer[19+token_string_length] = ' ';
                          data_section_string_buffer[20+token_string_length] = ' ';
                          data_section_string_buffer[21+token_string_length] = ' ';
                          data_section_string_buffer[22+token_string_length] = ' ';
                          data_section_string_buffer[23+token_string_length] = ' ';
                          data_section_string_buffer[24+token_string_length] = ' ';
                          data_section_string_buffer[25+token_string_length] = ' ';
                          data_section_string_buffer[26+token_string_length] = ' ';
                          data_section_string_buffer[27+token_string_length] = '.';
                          data_section_string_buffer[28+token_string_length] = 'a';
                          data_section_string_buffer[29+token_string_length] = 'l';
                          data_section_string_buffer[30+token_string_length] = 'i';
                          data_section_string_buffer[31+token_string_length] = 'g';
                          data_section_string_buffer[32+token_string_length] = 'n';
                          data_section_string_buffer[33+token_string_length] = ' ';
                          data_section_string_buffer[34+token_string_length] = '8';
                          data_section_string_buffer[35+token_string_length] = '\n';
                          data_section_string_buffer[36+token_string_length] = '\0';
                        }
                        assembler_statement->data_section_contents = data_section_string_buffer;
                        code_section_string_buffer_max_length = 4096;
                        assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
                        if (assembler_statement->code_section_contents != NULL)
                        {
                          snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov rax, QWORD PTR -%ld[rbp]\n        mov ecx, 0\n        lea rdx, .M%llu[rip]\n        mov esi, 4\n        mov rdi, rax\n        call add_operand_element_runtime_expression@PLT\n        mov QWORD PTR -%ld[rbp], rax\n", temporary_storage_variable_stackframe_element->stackframe_offset, *assembler_statement->label, temporary_storage_variable_stackframe_element->stackframe_offset);
                          state = 10;
                        }
                        if (assembler_program != NULL)
                        {
                          temp_assembler_element = assembler_program;
                          while (temp_assembler_element->next != NULL)
                          {
                            temp_assembler_element = temp_assembler_element->next;
                          }
                          temp_assembler_element->next = assembler_statement;
                        }
                        else
                        {
                          assembler_program = assembler_statement;
                        }
                      }
                      else
                      {
                        state = 99999;
                      }
                    }
                    else
                    {
                      state = 99999;
                    }
                  }
                  else
                  {
                    state = 99999;
                  }
                }
                else
                {
                  state = 99999;
                }
              }
              else
              {
                if (token_type == TOKEN_IDENTIFIER_FLOATING_POINT_CONSTANT)
                {
                  if (temporary_storage_variable_stackframe_element != NULL)
                  {
                    assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
                    if (assembler_statement != NULL)
                    {
                      assembler_statement->label = (unsigned long long int *) malloc(sizeof(unsigned long long int));
                      if (assembler_statement->label != NULL)
                      {
                        assembler_statement->scope_level = scope_level;
                        assembler_statement->label_associated_with_else_statement = NULL;
                        assembler_statement->label_after_if_then_else_statement = NULL;
                        assembler_statement->code_section_contents = NULL;
                        assembler_statement->data_section_contents = NULL;
                        assembler_statement->next = NULL;
                        label = retrieve_highest_label_number_from_assembly_output (assembler_program);
                        if (label != NULL)
                        {
                          *assembler_statement->label = (*label) + 1;
                        } 
                        else
                        {
                          *assembler_statement->label = 1;
                        }
                        constant_real_token = token;
                        if (constant_real_token != NULL)
                        {
                          token_string_length = strlen(constant_real_token);
                          data_section_string_buffer_length = token_string_length + 37;
                          data_section_string_buffer = (unsigned char *) malloc(sizeof(char)*data_section_string_buffer_length); 
                          if (data_section_string_buffer != NULL)
                          {
                            data_section_string_buffer[0]  = ' ';
                            data_section_string_buffer[1]  = ' ';
                            data_section_string_buffer[2]  = ' ';
                            data_section_string_buffer[3]  = ' ';
                            data_section_string_buffer[4]  = ' ';
                            data_section_string_buffer[5]  = ' ';
                            data_section_string_buffer[6]  = ' ';
                            data_section_string_buffer[7]  = ' ';
                            data_section_string_buffer[8]  = '.';
                            data_section_string_buffer[9]  = 's';
                            data_section_string_buffer[10] = 't';
                            data_section_string_buffer[11] = 'r';
                            data_section_string_buffer[12] = 'i';
                            data_section_string_buffer[13] = 'n';
                            data_section_string_buffer[14] = 'g';
                            data_section_string_buffer[15] = ' ';
                            data_section_string_buffer[16] = '"';
                            for (i = 0; i < token_string_length; i++)
                            {
                              data_section_string_buffer[17+i] = constant_real_token[i];
                            }
                            data_section_string_buffer[17+token_string_length] = '"';
                            data_section_string_buffer[18+token_string_length] = '\n';
                            data_section_string_buffer[19+token_string_length] = ' ';
                            data_section_string_buffer[20+token_string_length] = ' ';
                            data_section_string_buffer[21+token_string_length] = ' ';
                            data_section_string_buffer[22+token_string_length] = ' ';
                            data_section_string_buffer[23+token_string_length] = ' ';
                            data_section_string_buffer[24+token_string_length] = ' ';
                            data_section_string_buffer[25+token_string_length] = ' ';
                            data_section_string_buffer[26+token_string_length] = ' ';
                            data_section_string_buffer[27+token_string_length] = '.';
                            data_section_string_buffer[28+token_string_length] = 'a';
                            data_section_string_buffer[29+token_string_length] = 'l';
                            data_section_string_buffer[30+token_string_length] = 'i';
                            data_section_string_buffer[31+token_string_length] = 'g';
                            data_section_string_buffer[32+token_string_length] = 'n';
                            data_section_string_buffer[33+token_string_length] = ' ';
                            data_section_string_buffer[34+token_string_length] = '8';
                            data_section_string_buffer[35+token_string_length] = '\n';
                            data_section_string_buffer[36+token_string_length] = '\0';
                          }
                          assembler_statement->data_section_contents = data_section_string_buffer;
                          code_section_string_buffer_max_length = 4096;
                          assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
                          if (assembler_statement->code_section_contents != NULL)
                          {
                            snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov rax, QWORD PTR -%ld[rbp]\n        mov ecx, 0\n        lea rdx, .M%llu[rip]\n        mov esi, 5\n        mov rdi, rax\n        call add_operand_element_runtime_expression@PLT\n        mov QWORD PTR -%ld[rbp], rax\n", temporary_storage_variable_stackframe_element->stackframe_offset, *assembler_statement->label, temporary_storage_variable_stackframe_element->stackframe_offset);
                            state = 10;
                          }
                          if (assembler_program != NULL)
                          {
                            temp_assembler_element = assembler_program;
                            while (temp_assembler_element->next != NULL)
                            {
                              temp_assembler_element = temp_assembler_element->next;
                            }
                            temp_assembler_element->next = assembler_statement;
                          }
                          else
                          {
                            assembler_program = assembler_statement;
                          }
                        }
                        else
                        {
                          state = 99999;
                        }
                      }
                      else
                      {
                        state = 99999;
                      }
                    }
                    else
                    {
                      state = 99999;
                    }
                  }
                  else
                  {
                    state = 99999;
                  }
                }
                else
                {
                  if ((token_type == TOKEN_TRUE) || (token_type == TOKEN_FALSE))
                  {
                    if (temporary_storage_variable_stackframe_element != NULL)
                    {
                      assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
                      if (assembler_statement != NULL)
                      {
                        assembler_statement->label = (unsigned long long int *) malloc(sizeof(unsigned long long int));
                        if (assembler_statement->label != NULL)
                        {
                          assembler_statement->scope_level = scope_level;
                          assembler_statement->label_associated_with_else_statement = NULL;
                          assembler_statement->label_after_if_then_else_statement = NULL;
                          assembler_statement->code_section_contents = NULL;
                          assembler_statement->data_section_contents = NULL;
                          assembler_statement->next = NULL;
                          label = retrieve_highest_label_number_from_assembly_output (assembler_program);
                          if (label != NULL)
                          {
                            *assembler_statement->label = (*label) + 1; // This label will be used to access the string "TRUE" or "FALSE" in assembler. It is different from label above used to identify ELSE statement blocks.
                          }
                          else
                          {
                            *assembler_statement->label = 1;
                          }
                          constant_boolean_token = token;
                          if (constant_boolean_token != NULL)
                          {
                            token_string_length = strlen(constant_boolean_token);
                            data_section_string_buffer_length = token_string_length + 37;
                            data_section_string_buffer = (unsigned char *) malloc(sizeof(char)*data_section_string_buffer_length); 
                            if (data_section_string_buffer != NULL)
                            {
                              data_section_string_buffer[0]  = ' ';
                              data_section_string_buffer[1]  = ' ';
                              data_section_string_buffer[2]  = ' ';
                              data_section_string_buffer[3]  = ' ';
                              data_section_string_buffer[4]  = ' ';
                              data_section_string_buffer[5]  = ' ';
                              data_section_string_buffer[6]  = ' ';
                              data_section_string_buffer[7]  = ' ';
                              data_section_string_buffer[8]  = '.';
                              data_section_string_buffer[9]  = 's';
                              data_section_string_buffer[10] = 't';
                              data_section_string_buffer[11] = 'r';
                              data_section_string_buffer[12] = 'i';
                              data_section_string_buffer[13] = 'n';
                              data_section_string_buffer[14] = 'g';
                              data_section_string_buffer[15] = ' ';
                              data_section_string_buffer[16] = '"';
                              for (i = 0; i < token_string_length; i++)
                              {
                                data_section_string_buffer[17+i] = constant_boolean_token[i];
                              }
                              data_section_string_buffer[17+token_string_length] = '"';
                              data_section_string_buffer[18+token_string_length] = '\n';
                              data_section_string_buffer[19+token_string_length] = ' ';
                              data_section_string_buffer[20+token_string_length] = ' ';
                              data_section_string_buffer[21+token_string_length] = ' ';
                              data_section_string_buffer[22+token_string_length] = ' ';
                              data_section_string_buffer[23+token_string_length] = ' ';
                              data_section_string_buffer[24+token_string_length] = ' ';
                              data_section_string_buffer[25+token_string_length] = ' ';
                              data_section_string_buffer[26+token_string_length] = ' ';
                              data_section_string_buffer[27+token_string_length] = '.';
                              data_section_string_buffer[28+token_string_length] = 'a';
                              data_section_string_buffer[29+token_string_length] = 'l';
                              data_section_string_buffer[30+token_string_length] = 'i';
                              data_section_string_buffer[31+token_string_length] = 'g';
                              data_section_string_buffer[32+token_string_length] = 'n';
                              data_section_string_buffer[33+token_string_length] = ' ';
                              data_section_string_buffer[34+token_string_length] = '8';
                              data_section_string_buffer[35+token_string_length] = '\n';
                              data_section_string_buffer[36+token_string_length] = '\0';
                            }
                            assembler_statement->data_section_contents = data_section_string_buffer;
                            code_section_string_buffer_max_length = 4096;
                            assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
                            if (assembler_statement->code_section_contents != NULL)
                            {
                              snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov rax, QWORD PTR -%ld[rbp]\n        mov ecx, 0\n        lea rdx, .M%llu[rip]\n        mov esi, 6\n        mov rdi, rax\n        call add_operand_element_runtime_expression@PLT\n        mov QWORD PTR -%ld[rbp], rax\n", temporary_storage_variable_stackframe_element->stackframe_offset, *assembler_statement->label, temporary_storage_variable_stackframe_element->stackframe_offset);
                              state = 10;
                            }
                            if (assembler_program != NULL)
                            {
                              temp_assembler_element = assembler_program;
                              while (temp_assembler_element->next != NULL)
                              {
                                temp_assembler_element = temp_assembler_element->next;
                              }
                              temp_assembler_element->next = assembler_statement;
                            }
                            else
                            {
                              assembler_program = assembler_statement;
                            }
                          }
                          else
                          {
                            state = 99999;
                          }
                        }
                        else
                        {
                          state = 99999;
                        }
                      }
                      else
                      {
                        state = 99999;
                      }
                    }
                    else
                    {
                      state = 99999;
                    }
                  }
                  else
                  {
                    if (token_type == TOKEN_PLUS)
                    {
                      if (temporary_storage_variable_stackframe_element != NULL)
                      {
                        assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
                        if (assembler_statement != NULL)
                        {
                          assembler_statement->scope_level = scope_level;
                          assembler_statement->label = NULL;
                          assembler_statement->label_associated_with_else_statement = NULL;
                          assembler_statement->label_after_if_then_else_statement = NULL;
                          assembler_statement->code_section_contents = NULL;
                          assembler_statement->data_section_contents = NULL;
                          assembler_statement->next = NULL;
                          code_section_string_buffer_max_length = 4096;
                          assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
                          if (assembler_statement->code_section_contents != NULL)
                          {
                            snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov rax, QWORD PTR -%ld[rbp]\n        mov esi, 11\n        mov rdi, rax\n        call add_operator_element_runtime_expression@PLT\n        mov QWORD PTR -%ld[rbp], rax\n", temporary_storage_variable_stackframe_element->stackframe_offset, temporary_storage_variable_stackframe_element->stackframe_offset);
                            if (assembler_program != NULL)
                            {
                              temp_assembler_element = assembler_program;
                              while (temp_assembler_element->next != NULL)
                              {
                                temp_assembler_element = temp_assembler_element->next;
                              }
                              temp_assembler_element->next = assembler_statement;
                            }
                            else
                            {
                              assembler_program = assembler_statement;
                            }
                            state = 10;
                          }
                          else
                          {
                            state = 99999;
                          }
                        }
                        else
                        {
                          state = 99999;
                        }
                      }
                      else
                      {
                        state = 99999;
                      }
                    }
                    else
                    {
                      if (token_type == TOKEN_MINUS)
                      {
                        if (temporary_storage_variable_stackframe_element != NULL)
                        {
                          assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
                          if (assembler_statement != NULL)
                          {
                            assembler_statement->scope_level = scope_level;
                            assembler_statement->label = NULL;
                            assembler_statement->label_associated_with_else_statement = NULL;
                            assembler_statement->label_after_if_then_else_statement = NULL;
                            assembler_statement->code_section_contents = NULL;
                            assembler_statement->data_section_contents = NULL;
                            assembler_statement->next = NULL;
                            code_section_string_buffer_max_length = 4096;
                            assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
                            if (assembler_statement->code_section_contents != NULL)
                            {
                              snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov rax, QWORD PTR -%ld[rbp]\n        mov esi, 12\n        mov rdi, rax\n        call add_operator_element_runtime_expression@PLT\n        mov QWORD PTR -%ld[rbp], rax\n", temporary_storage_variable_stackframe_element->stackframe_offset, temporary_storage_variable_stackframe_element->stackframe_offset);
                              if (assembler_program != NULL)
                              {
                                temp_assembler_element = assembler_program;
                                while (temp_assembler_element->next != NULL)
                                {
                                  temp_assembler_element = temp_assembler_element->next;
                                }
                                temp_assembler_element->next = assembler_statement;
                              }
                              else
                              {
                                assembler_program = assembler_statement;
                              }
                              state = 10;
                            }
                            else
                            {
                              state = 99999;
                            }
                          }
                          else
                          {
                            state = 99999;
                          }
                        }
                        else
                        {
                          state = 99999;
                        }
                      }
                      else
                      {
                        if (token_type == TOKEN_ASTERISK)
                        {
                          if (temporary_storage_variable_stackframe_element != NULL)
                          {
                            assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
                            if (assembler_statement != NULL)
                            {
                              assembler_statement->scope_level = scope_level;
                              assembler_statement->label = NULL;
                              assembler_statement->label_associated_with_else_statement = NULL;
                              assembler_statement->label_after_if_then_else_statement = NULL;
                              assembler_statement->code_section_contents = NULL;
                              assembler_statement->data_section_contents = NULL;
                              assembler_statement->next = NULL;
                              code_section_string_buffer_max_length = 4096;
                              assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
                              if (assembler_statement->code_section_contents != NULL)
                              {
                                snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov rax, QWORD PTR -%ld[rbp]\n        mov esi, 13\n        mov rdi, rax\n        call add_operator_element_runtime_expression@PLT\n        mov QWORD PTR -%ld[rbp], rax\n", temporary_storage_variable_stackframe_element->stackframe_offset, temporary_storage_variable_stackframe_element->stackframe_offset);
                                if (assembler_program != NULL)
                                {
                                  temp_assembler_element = assembler_program;
                                  while (temp_assembler_element->next != NULL)
                                  {
                                    temp_assembler_element = temp_assembler_element->next;
                                  }
                                  temp_assembler_element->next = assembler_statement;
                                }
                                else
                                {
                                  assembler_program = assembler_statement;
                                }
                                state = 10;
                              }
                              else
                              {
                                state = 99999;
                              }
                            }
                            else
                            {
                              state = 99999;
                            }
                          }
                          else
                          {
                            state = 99999;
                          }
                        }
                        else
                        {
                          if (token_type == TOKEN_DIVIDE)
                          {
                            if (temporary_storage_variable_stackframe_element != NULL)
                            {
                              assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
                              if (assembler_statement != NULL)
                              {
                                assembler_statement->scope_level = scope_level;
                                assembler_statement->label = NULL;
                                assembler_statement->label_associated_with_else_statement = NULL;
                                assembler_statement->label_after_if_then_else_statement = NULL;
                                assembler_statement->code_section_contents = NULL;
                                assembler_statement->data_section_contents = NULL;
                                assembler_statement->next = NULL;
                                code_section_string_buffer_max_length = 4096;
                                assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
                                if (assembler_statement->code_section_contents != NULL)
                                {
                                  snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov rax, QWORD PTR -%ld[rbp]\n        mov esi, 14\n        mov rdi, rax\n        call add_operator_element_runtime_expression@PLT\n        mov QWORD PTR -%ld[rbp], rax\n", temporary_storage_variable_stackframe_element->stackframe_offset, temporary_storage_variable_stackframe_element->stackframe_offset);
                                  if (assembler_program != NULL)
                                  {
                                    temp_assembler_element = assembler_program;
                                    while (temp_assembler_element->next != NULL)
                                    {
                                      temp_assembler_element = temp_assembler_element->next;
                                    }
                                    temp_assembler_element->next = assembler_statement;
                                  }
                                  else
                                  {
                                    assembler_program = assembler_statement;
                                  }
                                  state = 10;
                                }
                                else
                                {
                                  state = 99999;
                                }
                              }
                              else
                              {
                                state = 99999;
                              }
                            }
                            else
                            {
                              state = 99999;
                            }
                          }
                          else
                          {
                            if (token_type == TOKEN_MODULO)
                            {
                              if (temporary_storage_variable_stackframe_element != NULL)
                              {
                                assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
                                if (assembler_statement != NULL)
                                {
                                  assembler_statement->scope_level = scope_level;
                                  assembler_statement->label = NULL;
                                  assembler_statement->label_associated_with_else_statement = NULL;
                                  assembler_statement->label_after_if_then_else_statement = NULL;
                                  assembler_statement->code_section_contents = NULL;
                                  assembler_statement->data_section_contents = NULL;
                                  assembler_statement->next = NULL;
                                  code_section_string_buffer_max_length = 4096;
                                  assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
                                  if (assembler_statement->code_section_contents != NULL)
                                  {
                                    snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov rax, QWORD PTR -%ld[rbp]\n        mov esi, 15\n        mov rdi, rax\n        call add_operator_element_runtime_expression@PLT\n        mov QWORD PTR -%ld[rbp], rax\n", temporary_storage_variable_stackframe_element->stackframe_offset, temporary_storage_variable_stackframe_element->stackframe_offset);
                                    if (assembler_program != NULL)
                                    {
                                      temp_assembler_element = assembler_program;
                                      while (temp_assembler_element->next != NULL)
                                      {
                                        temp_assembler_element = temp_assembler_element->next;
                                      }
                                      temp_assembler_element->next = assembler_statement;
                                    }
                                    else
                                    {
                                      assembler_program = assembler_statement;
                                    }
                                    state = 10;
                                  }
                                  else
                                  {
                                    state = 99999;
                                  }
                                }
                                else
                                {
                                  state = 99999;
                                }
                              }
                              else
                              {
                                state = 99999;
                              }
                            }
                            else
                            {
                              if (token_type == TOKEN_AND)
                              {
                                if (temporary_storage_variable_stackframe_element != NULL)
                                {
                                  assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
                                  if (assembler_statement != NULL)
                                  {
                                    assembler_statement->scope_level = scope_level;
                                    assembler_statement->label = NULL;
                                    assembler_statement->label_associated_with_else_statement = NULL;
                                    assembler_statement->label_after_if_then_else_statement = NULL;
                                    assembler_statement->code_section_contents = NULL;
                                    assembler_statement->data_section_contents = NULL;
                                    assembler_statement->next = NULL;
                                    code_section_string_buffer_max_length = 4096;
                                    assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
                                    if (assembler_statement->code_section_contents != NULL)
                                    {
                                      snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov rax, QWORD PTR -%ld[rbp]\n        mov esi, 7\n        mov rdi, rax\n        call add_operator_element_runtime_expression@PLT\n        mov QWORD PTR -%ld[rbp], rax\n", temporary_storage_variable_stackframe_element->stackframe_offset, temporary_storage_variable_stackframe_element->stackframe_offset);
                                      if (assembler_program != NULL)
                                      {
                                        temp_assembler_element = assembler_program;
                                        while (temp_assembler_element->next != NULL)
                                        {
                                          temp_assembler_element = temp_assembler_element->next;
                                        }
                                        temp_assembler_element->next = assembler_statement;
                                      }
                                      else
                                      {
                                        assembler_program = assembler_statement;
                                      }
                                      state = 10;
                                    }
                                    else
                                    {
                                      state = 99999;
                                    }
                                  }
                                  else
                                  {
                                    state = 99999;
                                  }
                                }
                                else
                                {
                                  state = 99999;
                                }
                              }
                              else
                              {
                                if (token_type == TOKEN_OR)
                                {
                                  if (temporary_storage_variable_stackframe_element != NULL)
                                  {
                                    assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
                                    if (assembler_statement != NULL)
                                    {
                                      assembler_statement->scope_level = scope_level;
                                      assembler_statement->label = NULL;
                                      assembler_statement->label_associated_with_else_statement = NULL;
                                      assembler_statement->label_after_if_then_else_statement = NULL;
                                      assembler_statement->code_section_contents = NULL;
                                      assembler_statement->data_section_contents = NULL;
                                      assembler_statement->next = NULL;
                                      code_section_string_buffer_max_length = 4096;
                                      assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
                                      if (assembler_statement->code_section_contents != NULL)
                                      {
                                        snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov rax, QWORD PTR -%ld[rbp]\n        mov esi, 8\n        mov rdi, rax\n        call add_operator_element_runtime_expression@PLT\n        mov QWORD PTR -%ld[rbp], rax\n", temporary_storage_variable_stackframe_element->stackframe_offset, temporary_storage_variable_stackframe_element->stackframe_offset);
                                        if (assembler_program != NULL)
                                        {
                                          temp_assembler_element = assembler_program;
                                          while (temp_assembler_element->next != NULL)
                                          {
                                            temp_assembler_element = temp_assembler_element->next;
                                          }
                                          temp_assembler_element->next = assembler_statement;
                                        }
                                        else
                                        {
                                          assembler_program = assembler_statement;
                                        }
                                        state = 10;
                                      }
                                      else
                                      {
                                        state = 99999;
                                      }
                                    }
                                    else
                                    {
                                      state = 99999;
                                    }
                                  }
                                  else
                                  {
                                    state = 99999;
                                  }
                                }
                                else
                                {
                                  if (token_type == TOKEN_XOR)
                                  {
                                    if (temporary_storage_variable_stackframe_element != NULL)
                                    {
                                      assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
                                      if (assembler_statement != NULL)
                                      {
                                        assembler_statement->scope_level = scope_level;
                                        assembler_statement->label = NULL;
                                        assembler_statement->label_associated_with_else_statement = NULL;
                                        assembler_statement->label_after_if_then_else_statement = NULL;
                                        assembler_statement->code_section_contents = NULL;
                                        assembler_statement->data_section_contents = NULL;
                                        assembler_statement->next = NULL;
                                        code_section_string_buffer_max_length = 4096;
                                        assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
                                        if (assembler_statement->code_section_contents != NULL)
                                        {
                                          snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov rax, QWORD PTR -%ld[rbp]\n        mov esi, 9\n        mov rdi, rax\n        call add_operator_element_runtime_expression@PLT\n        mov QWORD PTR -%ld[rbp], rax\n", temporary_storage_variable_stackframe_element->stackframe_offset, temporary_storage_variable_stackframe_element->stackframe_offset);
                                          if (assembler_program != NULL)
                                          {
                                            temp_assembler_element = assembler_program;
                                            while (temp_assembler_element->next != NULL)
                                            {
                                              temp_assembler_element = temp_assembler_element->next;
                                            }
                                            temp_assembler_element->next = assembler_statement;
                                          }
                                          else
                                          {
                                            assembler_program = assembler_statement;
                                          }
                                          state = 10;
                                        }
                                        else
                                        {
                                          state = 99999;
                                        }
                                      }
                                      else
                                      {
                                        state = 99999;
                                      }
                                    }
                                    else
                                    {
                                      state = 99999;
                                    }
                                  }
                                  else
                                  {
                                    if (token_type == TOKEN_NOT)
                                    {
                                      if (temporary_storage_variable_stackframe_element != NULL)
                                      {
                                        assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
                                        if (assembler_statement != NULL)
                                        {
                                          assembler_statement->scope_level = scope_level;
                                          assembler_statement->label = NULL;
                                          assembler_statement->label_associated_with_else_statement = NULL;
                                          assembler_statement->label_after_if_then_else_statement = NULL;
                                          assembler_statement->code_section_contents = NULL;
                                          assembler_statement->data_section_contents = NULL;
                                          assembler_statement->next = NULL;
                                          code_section_string_buffer_max_length = 4096;
                                          assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
                                          if (assembler_statement->code_section_contents != NULL)
                                          {
                                            snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov rax, QWORD PTR -%ld[rbp]\n        mov esi, 10\n        mov rdi, rax\n        call add_operator_element_runtime_expression@PLT\n        mov QWORD PTR -%ld[rbp], rax\n", temporary_storage_variable_stackframe_element->stackframe_offset, temporary_storage_variable_stackframe_element->stackframe_offset);
                                            if (assembler_program != NULL)
                                            {
                                              temp_assembler_element = assembler_program;
                                              while (temp_assembler_element->next != NULL)
                                              {
                                                temp_assembler_element = temp_assembler_element->next;
                                              }
                                              temp_assembler_element->next = assembler_statement;
                                            }
                                            else
                                            {
                                              assembler_program = assembler_statement;
                                            }
                                            state = 10;
                                          }
                                          else
                                          {
                                            state = 99999;
                                          }
                                        }
                                        else
                                        {
                                          state = 99999;
                                        }
                                      }
                                      else
                                      {
                                        state = 99999;
                                      }
                                    }
                                    else
                                    {
                                      if (token_type == TOKEN_EQUAL)
                                      {
                                        if (temporary_storage_variable_stackframe_element != NULL)
                                        {
                                          assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
                                          if (assembler_statement != NULL)
                                          {
                                            assembler_statement->scope_level = scope_level;
                                            assembler_statement->label = NULL;
                                            assembler_statement->label_associated_with_else_statement = NULL;
                                            assembler_statement->label_after_if_then_else_statement = NULL;
                                            assembler_statement->code_section_contents = NULL;
                                            assembler_statement->data_section_contents = NULL;
                                            assembler_statement->next = NULL;
                                            code_section_string_buffer_max_length = 4096;
                                            assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
                                            if (assembler_statement->code_section_contents != NULL)
                                            {
                                              snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov rax, QWORD PTR -%ld[rbp]\n        mov esi, 5\n        mov rdi, rax\n        call add_operator_element_runtime_expression@PLT\n        mov QWORD PTR -%ld[rbp], rax\n", temporary_storage_variable_stackframe_element->stackframe_offset, temporary_storage_variable_stackframe_element->stackframe_offset);
                                              if (assembler_program != NULL)
                                              {
                                                temp_assembler_element = assembler_program;
                                                while (temp_assembler_element->next != NULL)
                                                {
                                                  temp_assembler_element = temp_assembler_element->next;
                                                }
                                                temp_assembler_element->next = assembler_statement;
                                              }
                                              else
                                              {
                                                assembler_program = assembler_statement;
                                              }
                                              state = 10;
                                            }
                                            else
                                            {
                                              state = 99999;
                                            }
                                          }
                                          else
                                          {
                                            state = 99999;
                                          }
                                        }
                                        else
                                        {
                                          state = 99999;
                                        }
                                      }
                                      else
                                      {
                                        if (token_type == TOKEN_NOT_EQUAL)
                                        {
                                          if (temporary_storage_variable_stackframe_element != NULL)
                                          {
                                            assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
                                            if (assembler_statement != NULL)
                                            {
                                              assembler_statement->scope_level = scope_level;
                                              assembler_statement->label = NULL;
                                              assembler_statement->label_associated_with_else_statement = NULL;
                                              assembler_statement->label_after_if_then_else_statement = NULL;
                                              assembler_statement->code_section_contents = NULL;
                                              assembler_statement->data_section_contents = NULL;
                                              assembler_statement->next = NULL;
                                              code_section_string_buffer_max_length = 4096;
                                              assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
                                              if (assembler_statement->code_section_contents != NULL)
                                              {
                                                snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov rax, QWORD PTR -%ld[rbp]\n        mov esi, 6\n        mov rdi, rax\n        call add_operator_element_runtime_expression@PLT\n        mov QWORD PTR -%ld[rbp], rax\n", temporary_storage_variable_stackframe_element->stackframe_offset, temporary_storage_variable_stackframe_element->stackframe_offset);
                                                if (assembler_program != NULL)
                                                {
                                                  temp_assembler_element = assembler_program;
                                                  while (temp_assembler_element->next != NULL)
                                                  {
                                                    temp_assembler_element = temp_assembler_element->next;
                                                  }
                                                  temp_assembler_element->next = assembler_statement;
                                                }
                                                else
                                                {
                                                  assembler_program = assembler_statement;
                                                }
                                                state = 10;
                                              }
                                              else
                                              {
                                                state = 99999;
                                              }
                                            }
                                            else
                                            {
                                              state = 99999;
                                            }
                                          }
                                          else
                                          {
                                            state = 99999;
                                          }
                                        }
                                        else
                                        {
                                          if (token_type == TOKEN_GREATER_THAN)
                                          {
                                            if (temporary_storage_variable_stackframe_element != NULL)
                                            {
                                              assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
                                              if (assembler_statement != NULL)
                                              {
                                                assembler_statement->scope_level = scope_level;
                                                assembler_statement->label = NULL;
                                                assembler_statement->label_associated_with_else_statement = NULL;
                                                assembler_statement->label_after_if_then_else_statement = NULL;
                                                assembler_statement->code_section_contents = NULL;
                                                assembler_statement->data_section_contents = NULL;
                                                assembler_statement->next = NULL;
                                                code_section_string_buffer_max_length = 4096;
                                                assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
                                                if (assembler_statement->code_section_contents != NULL)
                                                {
                                                  snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov rax, QWORD PTR -%ld[rbp]\n        mov esi, 2\n        mov rdi, rax\n        call add_operator_element_runtime_expression@PLT\n        mov QWORD PTR -%ld[rbp], rax\n", temporary_storage_variable_stackframe_element->stackframe_offset, temporary_storage_variable_stackframe_element->stackframe_offset);
                                                  if (assembler_program != NULL)
                                                  {
                                                    temp_assembler_element = assembler_program;
                                                    while (temp_assembler_element->next != NULL)
                                                    {
                                                      temp_assembler_element = temp_assembler_element->next;
                                                    }
                                                    temp_assembler_element->next = assembler_statement;
                                                  }
                                                  else
                                                  {
                                                    assembler_program = assembler_statement;
                                                  }
                                                  state = 10;
                                                }
                                                else
                                                {
                                                  state = 99999;
                                                }
                                              }
                                              else
                                              {
                                                state = 99999;
                                              }
                                            }
                                            else
                                            {
                                              state = 99999;
                                            }
                                          }
                                          else
                                          {
                                            if (token_type == TOKEN_LESS_THAN)
                                            {
                                              if (temporary_storage_variable_stackframe_element != NULL)
                                              {
                                                assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
                                                if (assembler_statement != NULL)
                                                {
                                                  assembler_statement->scope_level = scope_level;
                                                  assembler_statement->label = NULL;
                                                  assembler_statement->label_associated_with_else_statement = NULL;
                                                  assembler_statement->label_after_if_then_else_statement = NULL;
                                                  assembler_statement->code_section_contents = NULL;
                                                  assembler_statement->data_section_contents = NULL;
                                                  assembler_statement->next = NULL;
                                                  code_section_string_buffer_max_length = 4096;
                                                  assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
                                                  if (assembler_statement->code_section_contents != NULL)
                                                  {
                                                    snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov rax, QWORD PTR -%ld[rbp]\n        mov esi, 4\n        mov rdi, rax\n        call add_operator_element_runtime_expression@PLT\n        mov QWORD PTR -%ld[rbp], rax\n", temporary_storage_variable_stackframe_element->stackframe_offset, temporary_storage_variable_stackframe_element->stackframe_offset);
                                                    if (assembler_program != NULL)
                                                    {
                                                      temp_assembler_element = assembler_program;
                                                      while (temp_assembler_element->next != NULL)
                                                      {
                                                        temp_assembler_element = temp_assembler_element->next;
                                                      }
                                                      temp_assembler_element->next = assembler_statement;
                                                    }
                                                    else
                                                    {
                                                      assembler_program = assembler_statement;
                                                    }
                                                    state = 10;
                                                  }
                                                  else
                                                  {
                                                    state = 99999;
                                                  }
                                                }
                                                else
                                                {
                                                  state = 99999;
                                                }
                                              }
                                              else
                                              {
                                                state = 99999;
                                              }
                                            }
                                            else
                                            {
                                              if (token_type == TOKEN_GREATER_THAN_OR_EQUAL)
                                              {
                                                if (temporary_storage_variable_stackframe_element != NULL)
                                                {
                                                  assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
                                                  if (assembler_statement != NULL)
                                                  {
                                                    assembler_statement->scope_level = scope_level;
                                                    assembler_statement->label = NULL;
                                                    assembler_statement->label_associated_with_else_statement = NULL;
                                                    assembler_statement->label_after_if_then_else_statement = NULL;
                                                    assembler_statement->code_section_contents = NULL;
                                                    assembler_statement->data_section_contents = NULL;
                                                    assembler_statement->next = NULL;
                                                    code_section_string_buffer_max_length = 4096;
                                                    assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
                                                    if (assembler_statement->code_section_contents != NULL)
                                                    {
                                                      snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov rax, QWORD PTR -%ld[rbp]\n        mov esi, 1\n        mov rdi, rax\n        call add_operator_element_runtime_expression@PLT\n        mov QWORD PTR -%ld[rbp], rax\n", temporary_storage_variable_stackframe_element->stackframe_offset, temporary_storage_variable_stackframe_element->stackframe_offset);
                                                      if (assembler_program != NULL)
                                                      {
                                                        temp_assembler_element = assembler_program;
                                                        while (temp_assembler_element->next != NULL)
                                                        {
                                                          temp_assembler_element = temp_assembler_element->next;
                                                        }
                                                        temp_assembler_element->next = assembler_statement;
                                                      }
                                                      else
                                                      {
                                                        assembler_program = assembler_statement;
                                                      }
                                                      state = 10;
                                                    }
                                                    else
                                                    {
                                                      state = 99999;
                                                    }
                                                  }
                                                  else
                                                  {
                                                    state = 99999;
                                                  }
                                                }
                                                else
                                                {
                                                  state = 99999;
                                                }
                                              }
                                              else
                                              {
                                                if (token_type == TOKEN_LESS_THAN_OR_EQUAL)
                                                {
                                                  if (temporary_storage_variable_stackframe_element != NULL)
                                                  {
                                                    assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
                                                    if (assembler_statement != NULL)
                                                    {
                                                      assembler_statement->scope_level = scope_level;
                                                      assembler_statement->label = NULL;
                                                      assembler_statement->label_associated_with_else_statement = NULL;
                                                      assembler_statement->label_after_if_then_else_statement = NULL;
                                                      assembler_statement->code_section_contents = NULL;
                                                      assembler_statement->data_section_contents = NULL;
                                                      assembler_statement->next = NULL;
                                                    }
                                                    else
                                                    {
                                                      state = 99999;
                                                    }
                                                    if (assembler_statement != NULL)
                                                    {
                                                      code_section_string_buffer_max_length = 4096;
                                                      assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
                                                      if (assembler_statement->code_section_contents != NULL)
                                                      {
                                                        snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov rax, QWORD PTR -%ld[rbp]\n        mov esi, 3\n        mov rdi, rax\n        call add_operator_element_runtime_expression@PLT\n        mov QWORD PTR -%ld[rbp], rax\n", temporary_storage_variable_stackframe_element->stackframe_offset, temporary_storage_variable_stackframe_element->stackframe_offset);
                                                        if (assembler_program != NULL)
                                                        {
                                                          temp_assembler_element = assembler_program;
                                                          while (temp_assembler_element->next != NULL)
                                                          {
                                                            temp_assembler_element = temp_assembler_element->next;
                                                          }
                                                          temp_assembler_element->next = assembler_statement;
                                                        }
                                                        else
                                                        {
                                                          assembler_program = assembler_statement;
                                                        }
                                                        state = 10;
                                                      }
                                                      else
                                                      {
                                                        state = 99999;
                                                      }
                                                    }
                                                    else
                                                    {
                                                      state = 99999;
                                                    }
                                                  }
                                                  else
                                                  {
                                                    state = 99999;
                                                  }
                                                }
                                                else
                                                {
                                                  state = 99999;
                                                }
                                              }
                                            }
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          break;
          default:
          break;
        } 
      }
      else
      {
        state = 99999;
      }
      if (state != 99999)
      {
        if (ast_element != NULL)
        {
          ast_element = ast_element->sibling;
        }
      }
    }
    if (state != 99999)
    {
// **********************************************************************************************
// * Second pass:                                                                               *
// *                                                                                            *
// * STEP 1. Generate the x86 assembler instructions to evaluate the run-time expression built. *
// *                                                                                            *
// * STEP 2: Retrieve the return value from register AL. It will be either TRUE or FALSE.       *
// *         temporary variable allocated for this task. Set the temporary expression           *
// *         evaluator variable to NULL.                                                        *
// **********************************************************************************************
    }
    if (state != 99999)
    {

      if (temporary_storage_variable_stackframe_element != NULL)
      {
        assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
        if (assembler_statement != NULL)
        {
          assembler_statement->scope_level = scope_level;
          assembler_statement->label = NULL;
          assembler_statement->label_associated_with_else_statement = NULL;
          assembler_statement->label_after_if_then_else_statement = NULL;
          assembler_statement->code_section_contents = NULL;
          assembler_statement->data_section_contents = NULL;
          assembler_statement->next = NULL;
          code_section_string_buffer_max_length = 4096;
          assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
          if (assembler_statement->code_section_contents != NULL)
          {
// ***************************************************************************************************************************
// * Now jump back and rebuild the run-time expression for the WHILE statement. This must be done at every iteration because *
// * variable values (if applicable) could change during the iteration through the while loop. Then evaluate the WHILE       *
// * expression to determine if it is TRUE or FALSE. A TRUE result means the WHILE statement block will be executed. A FALSE *
// * value will jump over the WHILE statement block to the next statement after WHILE statement.                             *
// ***************************************************************************************************************************
            ast_element = abstract_syntax_tree;
            if (ast_element != NULL)
            {
              if (ast_element->label_after_while_statement != NULL)
              {
                snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov rax, QWORD PTR -%ld[rbp]\n        mov rdi, rax\n        call evaluate_runtime_expression_return_boolean_result@PLT\n        mov QWORD PTR -%ld[rbp], 0\n        cmp al, 1\n        jne .L%llu\n", temporary_storage_variable_stackframe_element->stackframe_offset, temporary_storage_variable_stackframe_element->stackframe_offset, *ast_element->label_after_while_statement);
              }
            }
            if (assembler_program != NULL)
            {
              temp_assembler_element = assembler_program;
              while (temp_assembler_element->next != NULL)
              {
                temp_assembler_element = temp_assembler_element->next;
              }
              temp_assembler_element->next = assembler_statement;
            }
            else
            {
              assembler_program = assembler_statement;
            }
          }
          else
          {
            state = 99999;
          }
        }
        else
        {
          state = 99999;
        }
      }
    }
  }
  return assembler_program;
}




asmblr_node * create_assembler_output_code_section_label (asmblr_node *assembler_program, ast_node *abstract_syntax_tree, unsigned long long int scope_level)
{
  asmblr_node *assembler_statement, *temp_assembler_element;
  ast_node *ast_element;
  size_t code_section_string_buffer_max_length;

  if (abstract_syntax_tree != NULL)
  {
    ast_element = abstract_syntax_tree;
    if (ast_element->label != NULL)
    {
      assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
      if (assembler_statement != NULL)
      {
        assembler_statement->scope_level = scope_level;
        assembler_statement->label = NULL;
        assembler_statement->label_associated_with_else_statement = NULL;
        assembler_statement->label_after_if_then_else_statement = NULL;
        assembler_statement->code_section_contents = NULL;
        assembler_statement->data_section_contents = NULL;
        assembler_statement->next = NULL;
        code_section_string_buffer_max_length = 4096;
        assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
        if (assembler_statement->code_section_contents != NULL)
        {
          snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, ".L%llu:\n", *ast_element->label);
          if (assembler_program != NULL)
          {
            temp_assembler_element = assembler_program;
            while (temp_assembler_element->next != NULL)
            {
              temp_assembler_element = temp_assembler_element->next;
            }
            temp_assembler_element->next = assembler_statement;
          }
          else
          {
            assembler_program = assembler_statement;
          }
        }
        else
        {
          printf ("ERROR: malloc() returned NULL. Exiting now.\n");
          exit (EXIT_FAILURE);
        }
      }
      else
      {
        printf ("ERROR: malloc() returned NULL. Exiting now.\n");
        exit (EXIT_FAILURE);
      }
    }
  }
  return assembler_program;
}




asmblr_node * create_assembler_output_code_section_jump_statement (asmblr_node *assembler_program, ast_node *abstract_syntax_tree, unsigned long long int scope_level)
{
  asmblr_node *assembler_statement, *assembler_element, *temp_assembler_element;
  size_t code_section_buffer_size;

  //printf ("Entering create_assembler_output_code_section_jump_statement\n");
  if (abstract_syntax_tree != NULL)
  {
    if (abstract_syntax_tree->insert_jump_statement != NULL)
    {
      assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
      if (assembler_statement != NULL)
      {
        assembler_statement->scope_level = scope_level;
        assembler_statement->label = NULL;
        assembler_statement->label_associated_with_else_statement = NULL;
        assembler_statement->label_after_if_then_else_statement = NULL;
        assembler_statement->code_section_contents = NULL;
        assembler_statement->data_section_contents = NULL;
        assembler_statement->next = NULL;
        code_section_buffer_size = 4096;
        assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_buffer_size);
        if (assembler_statement->code_section_contents != NULL)
        {
          snprintf (assembler_statement->code_section_contents, code_section_buffer_size, "        jmp .L%llu\n", *abstract_syntax_tree->insert_jump_statement);
        }
        if (assembler_program != NULL)
        {
          temp_assembler_element = assembler_program;
          while (temp_assembler_element->next != NULL)
          {
            temp_assembler_element = temp_assembler_element->next;
          }
          temp_assembler_element->next = assembler_statement;
        }
        else
        {
          assembler_program = assembler_statement;
        }
      }
    }
  }
  return assembler_program;
}



// ********************************************************************************************************************
// * create_assembler_output_exit_main_function                                                                       *
// *                                                                                                                  *
// * In create_assembler_output_exit_main_function, I must release any memory allocated from the heap to store        *
// * string-based integers, string-based floats, and string-based booleans. Once that's done, I can then exit.        *
// *                                                                                                                  *
// * IMPORTANT NOTE: create_assembler_output_exit_main_function() and create_assembler_output_return_from_procedure() *
// * are identical at the moment; however, in future revisions, I'll be returning an EXIT code for MAIN and dealing   *
// * with return values on the stack for functions. The procedure return is simple - it never returns a value.        *
// * Functions do return a value on the stack.                                                                        * 
// ********************************************************************************************************************
asmblr_node * create_assembler_output_exit_main_function (asmblr_node *assembler_program, stackframe_node *stackframe_cross_reference_table, unsigned long long int scope_level)
{
  asmblr_node *assembler_statement, *assembler_element, *temp_assembler_element;
  symtab_node *symbol_table_element;
  stackframe_node *stackframe_element;
  size_t code_section_buffer_size;
// ***********************************************************************************************************************
// * Determine all the variables and their stack offsets for the MAIN function. I must know this stuff because I need to *
// * release all HEAP memory for these variables (if the variables on the stack point to allocated HEAP memory). I'm     *
// * referring to string-based integers, string-based floats, string-based boolean data structures used in LibChaga, and *
// * constants (which are string-based and can be released with the free function. Examples of constants include "TRUE", *
// * "FALSE", "1.0", "3.14", etc.                                                                                        *
// ***********************************************************************************************************************
  assembler_statement = NULL;
  stackframe_element = stackframe_cross_reference_table;
  while (stackframe_element != NULL)
  {
    symbol_table_element = stackframe_element->symbol_table_entry;
    if (symbol_table_element != NULL)
    {
      if (symbol_table_element->scope_level == scope_level)
      {
        if (symbol_table_element->attribute_type == _datatype)
        {
          switch (symbol_table_element->datatype)
          {
            case _int:
            case _real:
            case _bool:
              assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
              if (assembler_statement != NULL)
              {
                assembler_statement->scope_level = scope_level;
                assembler_statement->label = NULL;
                assembler_statement->label_associated_with_else_statement = NULL;
                assembler_statement->label_after_if_then_else_statement = NULL;
                assembler_statement->code_section_contents = NULL;
                assembler_statement->data_section_contents = NULL;
                assembler_statement->next = NULL;
              }
            break;
            default:
            break;
          }
          switch (symbol_table_element->datatype)
          {
            case _int:
              if (assembler_statement != NULL)
              {
                code_section_buffer_size = 4096;
                assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_buffer_size);
                if (assembler_statement->code_section_contents != NULL)
                {
                  snprintf (assembler_statement->code_section_contents, code_section_buffer_size, "        mov rax, QWORD PTR -%ld[rbp]\n        mov rdi, rax\n        call packed_string_integer_release_memory@PLT\n        mov QWORD PTR -%ld[rbp], rax\n", stackframe_element->stackframe_offset, stackframe_element->stackframe_offset);
                }
              }
             break;
             case _real:
              if (assembler_statement != NULL)
              {
                code_section_buffer_size = 4096;
                assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_buffer_size);
                if (assembler_statement->code_section_contents != NULL)
                {
                  snprintf (assembler_statement->code_section_contents, code_section_buffer_size, "        mov rax, QWORD PTR -%ld[rbp]\n        mov rdi, rax\n        call packed_string_real_release_memory@PLT\n        mov QWORD PTR -%ld[rbp], rax\n", stackframe_element->stackframe_offset, stackframe_element->stackframe_offset);
                }
              }
             break;
             case _bool:
              if (assembler_statement != NULL)
              {
                code_section_buffer_size = 4096;
                assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_buffer_size);
                if (assembler_statement->code_section_contents != NULL)
                {
                  snprintf (assembler_statement->code_section_contents, code_section_buffer_size, "        mov rax, QWORD PTR -%ld[rbp]\n        mov rdi, rax\n        call boolean_release_memory@PLT\n        mov QWORD PTR -%ld[rbp], rax\n", stackframe_element->stackframe_offset, stackframe_element->stackframe_offset);
                }
              }
             break;
             default:
             break;
          }
          switch (symbol_table_element->datatype)
          {
            case _int:
            case _real:
            case _bool:
              if (assembler_program != NULL)
              {
                temp_assembler_element = assembler_program;
                while (temp_assembler_element->next != NULL)
                {
                  temp_assembler_element = temp_assembler_element->next;
                }
                temp_assembler_element->next = assembler_statement;
              }
              else
              {
                assembler_program = assembler_statement;
              }
            break;
            default:
            break;
          }
        }
      }
    }
    stackframe_element = stackframe_element->next;
  }
// ***************************************************************************************
// * Next, now that memory from the heap has been deallocated, the last step is to exit. *
// ***************************************************************************************
  assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
  if (assembler_statement != NULL)
  {
    assembler_statement->scope_level = scope_level;
    assembler_statement->label = NULL;
    assembler_statement->label_associated_with_else_statement = NULL;
    assembler_statement->label_after_if_then_else_statement = NULL;
    assembler_statement->code_section_contents = NULL;
    assembler_statement->data_section_contents = NULL;
    assembler_statement->next = NULL;
    code_section_buffer_size = 4096;
    assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_buffer_size);
    if (assembler_statement->code_section_contents != NULL)
    {
      snprintf (assembler_statement->code_section_contents, code_section_buffer_size, "        leave\n        ret\n\n");
    }
    if (assembler_program != NULL)
    {
      temp_assembler_element = assembler_program;
      while (temp_assembler_element->next != NULL)
      {
        temp_assembler_element = temp_assembler_element->next;
      }
      temp_assembler_element->next = assembler_statement;
    }
    else
    {
      assembler_program = assembler_statement;
    }
  }
  return assembler_program;
}




// ***********************************************************************************************************
// * create_assembler_output_return_from_procedure                                                           *
// *                                                                                                         *
// * In this function, I must release any memory allocated from the heap to store string-based integers,     *
// * string-based reals, and string-based booleans. Once that's done, I can then return to calling function. *
// ***********************************************************************************************************
asmblr_node * create_assembler_output_return_from_procedure (asmblr_node *assembler_program, stackframe_node *stackframe_cross_reference_table, unsigned long long int scope_level)
{
  asmblr_node *assembler_statement, *assembler_element, *temp_assembler_element;
  symtab_node *symbol_table_element;
  stackframe_node *stackframe_element;
  size_t code_section_buffer_size;

// ***********************************************************************************************************************
// * Determine all the variables and their stack offsets for local variables defined in the procedure. I must know this  *
// * information because I need to release all HEAP memory for these variables (if the variables on the stack point to   *
// * allocated HEAP memory). I'm referring to string-based integers, string-based reals, and string-based boolean data   *
// * structures used in LibChaga.                                                                                        *
// ***********************************************************************************************************************
  assembler_statement = NULL;
  stackframe_element = stackframe_cross_reference_table;
  while (stackframe_element != NULL)
  {
    symbol_table_element = stackframe_element->symbol_table_entry;
    if (symbol_table_element != NULL)
    {
      if (symbol_table_element->scope_level == scope_level)
      {
        if (symbol_table_element->attribute_type == _datatype)
        {
          switch (symbol_table_element->datatype)
          {
            case _int:
            case _real:
            case _bool:
              assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
              if (assembler_statement != NULL)
              {
                assembler_statement->scope_level = scope_level;
                assembler_statement->label = NULL;
                assembler_statement->label_associated_with_else_statement = NULL;
                assembler_statement->label_after_if_then_else_statement = NULL;
                assembler_statement->code_section_contents = NULL;
                assembler_statement->data_section_contents = NULL;
                assembler_statement->next = NULL;
              }
            break;
            default:
            break;
          }
          switch (symbol_table_element->datatype)
          {
            case _int:
              if (assembler_statement != NULL)
              {
                code_section_buffer_size = 4096;
                assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_buffer_size);
                if (assembler_statement->code_section_contents != NULL)
                {
                  snprintf (assembler_statement->code_section_contents, code_section_buffer_size, "        mov rax, QWORD PTR -%ld[rbp]\n        mov rdi, rax\n        call packed_string_integer_release_memory@PLT\n        mov QWORD PTR -%ld[rbp], rax\n", stackframe_element->stackframe_offset, stackframe_element->stackframe_offset);
                }
              }
             break;
             case _real:
              if (assembler_statement != NULL)
              {
                code_section_buffer_size = 4096;
                assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_buffer_size);
                if (assembler_statement->code_section_contents != NULL)
                {
                  snprintf (assembler_statement->code_section_contents, code_section_buffer_size, "        mov rax, QWORD PTR -%ld[rbp]\n        mov rdi, rax\n        call packed_string_real_release_memory@PLT\n        mov QWORD PTR -%ld[rbp], rax\n", stackframe_element->stackframe_offset, stackframe_element->stackframe_offset);
                }
              }
             break;
             case _bool:
              if (assembler_statement != NULL)
              {
                code_section_buffer_size = 4096;
                assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_buffer_size);
                if (assembler_statement->code_section_contents != NULL)
                {
                  snprintf (assembler_statement->code_section_contents, code_section_buffer_size, "        mov rax, QWORD PTR -%ld[rbp]\n        mov rdi, rax\n        call boolean_release_memory@PLT\n        mov QWORD PTR -%ld[rbp], rax\n", stackframe_element->stackframe_offset, stackframe_element->stackframe_offset);
                }
              }
             break;
             default:
             break;
          }
          switch (symbol_table_element->datatype)
          {
            case _int:
            case _real:
            case _bool:
              if (assembler_program != NULL)
              {
                temp_assembler_element = assembler_program;
                while (temp_assembler_element->next != NULL)
                {
                  temp_assembler_element = temp_assembler_element->next;
                }
                temp_assembler_element->next = assembler_statement;
              }
              else
              {
                assembler_program = assembler_statement;
              }
            break;
            default:
            break;
          }
        }
      }
    }
    stackframe_element = stackframe_element->next;
  }
// ***************************************************************************************
// * Next, now that memory from the heap has been deallocated, the last step is to exit. *
// ***************************************************************************************
  assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
  if (assembler_statement != NULL)
  {
    assembler_statement->scope_level = scope_level;
    assembler_statement->label = NULL;
    assembler_statement->label_associated_with_else_statement = NULL;
    assembler_statement->label_after_if_then_else_statement = NULL;
    assembler_statement->code_section_contents = NULL;
    assembler_statement->data_section_contents = NULL;
    assembler_statement->next = NULL;
    code_section_buffer_size = 4096;
    assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_buffer_size);
    if (assembler_statement->code_section_contents != NULL)
    {
      snprintf (assembler_statement->code_section_contents, code_section_buffer_size, "        leave\n        ret\n\n");
    }
    if (assembler_program != NULL)
    {
      temp_assembler_element = assembler_program;
      while (temp_assembler_element->next != NULL)
      {
        temp_assembler_element = temp_assembler_element->next;
      }
      temp_assembler_element->next = assembler_statement;
    }
    else
    {
      assembler_program = assembler_statement;
    }
  }
  return assembler_program;
}




asmblr_node * create_assembler_output_call_statement (asmblr_node *assembler_program, ast_node *abstract_syntax_tree, symtab_node *symbol_table, stackframe_node *stackframe_cross_reference_table, unsigned long long int scope_level)
{
  asmblr_node *assembler_statement, *assembler_element, *temp_assembler_element;
  ast_node *ast_element;
  symtab_node *symbol_table_element, *temporary_storage_variable, *procedure_or_function_name_symbol_table_element;
  param_node *parameter_list_element;
  stackframe_node *target_variable_stackframe_element, *temporary_storage_variable_stackframe_element, *chaga_variable_stackframe_element;
  param_mapping_node *parameter_mapping_list, *parameter_mapping_element, *parameter_mapping_element1, *parameter_mapping_element2, *parameter_mapping_element3, *parameter_mapping_element4;
  param_mapping_node *parameter_mapping_element5, *parameter_mapping_element6, *parameter_mapping_element7, *parameter_mapping_element8, *parameter_mapping_element9;
  chaga_attribute_type target_variable_attribute_type;
  chaga_attribute_datatype target_variable_datatype;
  unsigned long long int procedure_or_function_name_scope_level, counter_for_new_variables;
  unsigned long long int *label, parameter_list_entry_counter;
  int state, token_type;
  char *token, *constant_integer_token, *constant_real_token, *constant_boolean_token, found_comma_token;
  unsigned char new_variable[1024], *data_section_string_buffer;
  size_t i, j, token_string_length, code_section_string_buffer_max_length, data_section_string_buffer_length; 

  assembler_statement = NULL;
  data_section_string_buffer = NULL;
  ast_element = NULL;
  target_variable_stackframe_element = NULL;
  temporary_storage_variable = NULL;
  temporary_storage_variable_stackframe_element = NULL;
  constant_integer_token = NULL;
  constant_real_token = NULL;
  constant_boolean_token = NULL;
  token = NULL;
  procedure_or_function_name_symbol_table_element = NULL;
  parameter_list_element = NULL;
  parameter_mapping_list = NULL;
  counter_for_new_variables = 0;
  if (abstract_syntax_tree != NULL)
  {
// ***************************************************************************************************************************
// * STEP 1:  Determine the datatype(s) of the target variable(s) I'll be sending the expression(s) too via the stackframe.  *
// *          This is important because I must call one of the following subroutines to process each expression at run-time  *
// *          via LibChaga:                                                                                                  *
// *                                                                                                                         *
// *          evaluate_runtime_expression_return_boolean_result_for_set_statement()                                          *
// *          evaluate_runtime_expression_return_real_result_for_set_statement()                                             *
// *          evaluate_runtime_expression_return_integer_result_for_set_statement()                                          *
// *                                                                                                                         *
// * Example:                                                                                                                *
// * define procedure display_results (int bar, bool baz)                                                                    *
// * {                                                                                                                       *
// *   [...]                                                                                                                 *
// * }                                                                                                                       *
// *                                                                                                                         *
// * define function main (int argc, pointer argv) return (int)                                                              *
// * {                                                                                                                       *
// *   declare int i1;                                                                                                       *
// *   declare bool b2;                                                                                                      *
// *   call display_results (3 * i1 - 2, i1 > 5);                                                                            *
// * }                                                                                                                       *
// *                                                                                                                         *
// * The first argument in procedure display_results is an integer datatype. Therefore when I run-time evaluate: 3 * i1 - 2, *
// * I must evaluate the expression as an integer result before pushing the result onto the stack frame for the first        *
// * argument (i.e. to the 'bar' variable in procedure display_results).                                                     *
// *                                                                                                                         *
// * The second argument in procedure display_results is a Boolean datatype. Therefore when I run-time evaluate: i1 > 5,     *
// * I must evaluate the expression as a Boolean result before pushing the result onto the stack frame ias the second        *
// * argument (i.e. to the 'baz' varaiable in procedure display_results).                                                    *
// ***************************************************************************************************************************
    if (abstract_syntax_tree->sibling != NULL)
    {
      if (abstract_syntax_tree->sibling->symbol_table_entry != NULL)
      {
        procedure_or_function_name_symbol_table_element = abstract_syntax_tree->sibling->symbol_table_entry;
      }
    }
    if (procedure_or_function_name_symbol_table_element != NULL)
    {
      //printf ("\n\n\n");
      if (procedure_or_function_name_symbol_table_element->identifier != NULL)
      {
        //printf ("procedure_or_function_name_symbol_table_element->identifier  = %s\n", procedure_or_function_name_symbol_table_element->identifier);
        //printf ("procedure_or_function_name_symbol_table_element->scope_level = %llu\n", procedure_or_function_name_symbol_table_element->scope_level);
        parameter_list_entry_counter = 0;
// *******************************************************************************************************************************************
// * Step 2: Check that the calling program is not sending any parameters to the function since the function does not accept any parameters. *
// *******************************************************************************************************************************************
        parameter_list_element = procedure_or_function_name_symbol_table_element->parameter_list;
        if (parameter_list_element == NULL)
        {
// ********************************************************************************************************************************************
// * Final step: Since the parameter list is NULL, the function or procedure being called does not need to receive any variable datatypes or  *
// * expressions. Consequently, I can issue a simple x86 call statement in assmebly with no parameters to be pushed on the stack.             *
// *                                                                                                                                          *
// * Note: I've already verified that no parameters were present on the calling end of the function when creating the Abstract Syntax Tree.   *
// * The abstract syntax tree subroutine would generate a syntax error stating something like too many parameters being sent to function or   *
// * if the function or procedure were defined with no parameter list yet the calling program was sending a bunch of parameters.              *
// ********************************************************************************************************************************************
          assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
          if (assembler_statement != NULL)
          {
            assembler_statement->scope_level = scope_level;
            assembler_statement->label = NULL;
            assembler_statement->label_associated_with_else_statement = NULL;
            assembler_statement->label_after_if_then_else_statement = NULL;
            assembler_statement->code_section_contents = NULL;       
            assembler_statement->data_section_contents = NULL;       
            assembler_statement->next = NULL;
            code_section_string_buffer_max_length = 16 + strlen(procedure_or_function_name_symbol_table_element->identifier);
            assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
            if (assembler_statement->code_section_contents != NULL)
            {
              snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        call %s\n", procedure_or_function_name_symbol_table_element->identifier);
              if (assembler_program != NULL)
              {
                temp_assembler_element = assembler_program;
                while (temp_assembler_element->next != NULL)
                {
                  temp_assembler_element = temp_assembler_element->next;
                }
                temp_assembler_element->next = assembler_statement;
              }
              else
              {
                assembler_program = assembler_statement;
              }
            }
          }
        }
        else
        {
// *************************************************************************************************************
// * Since I'm in the else portion of the statement block, I have one or more parameters that must be sent to  *
// * the called procedure or function. Each of these parameters could be an expression that must be computed   *
// * at run-time before that parameter result can be sent to the function or procedure being called. Thefore,  *
// * in the next steps I load each parameter in as an expression for run-time evaluation. It's a big step and  *
// * complex. Then I store the result from that evaluation in temporary stackframe storage space. If there are *
// * more parameters being sent to a called procedure or function then I must evaluate each of the subsequent  *
// * expressions for each of those parameters as well. Each parameter will be stored in a dedicated temporary  *
// * storage space on the stack frame. In other words, parameter one is stored in dedicated in its own temp    *
// * space; Parameter two is stored in its own dedicated stack space; Parameter three is stored in its own     *
// * dedicated temporary stack space, etc.                                                                     *
// *************************************************************************************************************


// **********************************************************************************************************
// * Advance to the first expression in the Abstract syntax tree (which will be sent as the first parameter *
// * in the call to a procedure or function). Each expression or parameter is separated by a comma which    *
// * you may see below in a while loop.                                                                     * 
// **********************************************************************************************************
          ast_element = abstract_syntax_tree;
          if (ast_element != NULL)
          {
            ast_element = ast_element->sibling;
          }
          if (ast_element != NULL)
          {
            ast_element = ast_element->sibling;
          }
// ******************************************************************************************************************
// * If any temporary variable already exist in the stackframe for the current scope, set them to AVAILABLE status. *
// ******************************************************************************************************************
          symbol_table_set_status_to_available_unused_temporary_variables_for_numerical_expression_processing (symbol_table, scope_level);
// **************************************************************************************************************************************
// * The parameter list contains one or more expected datatypes. Examine the first target datatype (first paramter) in the procedure    *
// * or function being called. Knowing the datatype for the first parameter will determine how the expression will uptimately be        *
// * converted to match.                                                                                                                *
// *                                                                                                                                    *
// * Example: A procedure foo is declared as follows:                                                                                   *
// * PROCEDURE FOO (int bar)                                                                                                            *
// *                                                                                                                                    *
// * Some example ways procedure FOO could be called:                                                                                   *
// * call FOO (TRUE);                                                                                                                   *
// * call FOO (1);                                                                                                                      *
// * call FOO (3.14159 / 5 * 12);                                                                                                       *
// * call FOO (1+2*baz);                                                                                                                *
// * call FOO (i1);                                                                                                                     *
// * call FOO (i1*i2*i3-i4);                                                                                                            *
// *                                                                                                                                    *
// * In each of the situations above, the expression being sent to the first parameter in FOO must be converted to an INTeger datatype. *
// **************************************************************************************************************************************
          parameter_list_entry_counter = 1;
          while (parameter_list_element != NULL)
          {
// *******************************************************************************************************************************************
// * Initialize any existing temporary storage variables on the stackframe under current scope to zero. I use temporary storage variables on *
// * the stackframe to store a pointer to each postfix expression as a linked list. One the postfix expression is evaluated at run-time, I   *
// * then send the result of that postfix expression as a parameter to the calling procedure or function.                                    *
// *                                                                                                                                         *
// * Example: call FOO ((1+2)*3, (4-5)*6);                                                                                                   *
// * In this example, I would create (if none exist) two temporary variables on the stackframe. I will call temp ___temp1___ and ___temp2___ *
// * ___temp1___ = 1 2 + 3 * = 9                                                                                                             *
// * ___temp2___ = 4 5 - 6 * = -6                                                                                                            *
// *                                                                                                                                         *
// * Lastly, I then call FOO with parameters: 9, -6 : but these parameters are evaluated at run-time, not compile time. I'm only setting     *
// * up the infrastructure to load each expression (e.g. 1 2 + 3 *) into a temporary variable (e.g. ___temp1___) then calling the run-time   *
// * expression engine to evaluate that linked-list postfix expression (which of course is done at run-time). Then I pass the result of      *
// * that expression in as parameters via the stackframe to the function.                                                                    *
// *******************************************************************************************************************************************
            temporary_storage_variable = retrieve_unused_temporary_variable_for_numerical_expression_processing (symbol_table, _datatype, _pointer, scope_level);
            if (temporary_storage_variable == NULL)
            {
              counter_for_new_variables++;
              snprintf (&new_variable[0], sizeof(new_variable), "___temp%lld___", counter_for_new_variables);
              while (identifier_already_exists_in_symbol_table(symbol_table, &new_variable[0], scope_level))
              {
                counter_for_new_variables++;
                snprintf (&new_variable[0], sizeof(new_variable), "___temp%lld___", counter_for_new_variables);
              }
              symbol_table = add_symbol_table_element (symbol_table, &new_variable[0], _datatype, _pointer, 0, 0, 0, 0, scope_level, TRUE, FALSE);
              temporary_storage_variable = retrieve_unused_temporary_variable_for_numerical_expression_processing (symbol_table, _datatype, _pointer, scope_level);
              if (temporary_storage_variable != NULL)
              {
                stackframe_cross_reference_table = add_new_symbol_table_entry_to_stackframe_cross_reference_table (stackframe_cross_reference_table, symbol_table, temporary_storage_variable);
              }
            }
            if (temporary_storage_variable != NULL)
            {
              if (temporary_storage_variable->identifier != NULL)
              {
                temporary_storage_variable_stackframe_element = retrieve_stackframe_offset (stackframe_cross_reference_table, temporary_storage_variable);
                if (temporary_storage_variable_stackframe_element != NULL)
                {
                  temporary_storage_variable->internal_use_only_variable_is_available = FALSE;
                  switch (parameter_list_element->datatype)
                  {
                    case _int:
                      parameter_mapping_list = add_parameter_mapping_element (parameter_mapping_list, parameter_list_entry_counter, temporary_storage_variable_stackframe_element->stackframe_offset, _int);
                      found_comma_token = FALSE;
                      while ((ast_element != NULL) && (!found_comma_token))
                      {
                        assembler_program = create_assembler_output_for_operator_or_operand_to_build_runtime_expression (assembler_program, ast_element, symbol_table, stackframe_cross_reference_table, temporary_storage_variable_stackframe_element, scope_level);
                        ast_element = ast_element->sibling;
                        if (ast_element != NULL)
                        {
                          if (ast_element->token_type == TOKEN_COMMA)
                          {
                            found_comma_token = TRUE;
                            ast_element = ast_element->sibling; // advance past the comma token to point at next expression (and next parameter to be passed to calling procedure)
                          }
                        }
                      }
// **************************************************************************************
// * Generate the x86 assembler instructions to evaluate the run-time expression built. *
// **************************************************************************************
                      assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
                      if (assembler_statement != NULL)
                      {
                        assembler_statement->scope_level = scope_level;
                        assembler_statement->label = NULL;
                        assembler_statement->label_associated_with_else_statement = NULL;
                        assembler_statement->label_after_if_then_else_statement = NULL;
                        assembler_statement->code_section_contents = NULL;
                        assembler_statement->data_section_contents = NULL;
                        assembler_statement->next = NULL;
                        code_section_string_buffer_max_length = 4096;
                        assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
                        if (assembler_statement->code_section_contents != NULL)
                        {
                          snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov rax, QWORD PTR -%ld[rbp]\n        mov rdi, rax\n        call evaluate_runtime_expression_return_integer_result_for_set_statement@PLT\n        mov QWORD PTR -%ld[rbp], rax\n", temporary_storage_variable_stackframe_element->stackframe_offset, temporary_storage_variable_stackframe_element->stackframe_offset);
                        }
                        if (assembler_program != NULL)
                        {
                          temp_assembler_element = assembler_program;
                          while (temp_assembler_element->next != NULL)
                          {
                            temp_assembler_element = temp_assembler_element->next;
                          }
                          temp_assembler_element->next = assembler_statement;
                        }
                        else
                        {
                          assembler_program = assembler_statement;
                        }
                      }
                    break;
                    case _real:
                      printf ("Entry %lld in parameter list is a REAL datatype.\n", parameter_list_entry_counter);
                    break;
                    case _bool:
                      printf ("Entry %lld in parameter list is a BOOLEAN datatype.\n", parameter_list_entry_counter);
                    break;
                    default:
                      printf ("Unknown parameter_list datatype.\n");
                    break;
                  }
                  parameter_list_element = parameter_list_element->next;
                  if (parameter_list_element != NULL)
                  {
                    parameter_list_entry_counter++;
                  }
                }
                else
                {
                  printf ("temporary_storage_variable_stackframe_element is NULL\n");
                  exit (EXIT_FAILURE);
                }
              }
            }
          }
// ************************************************************************************************************************
// * Now that all temporary expressions have been evaluated then stored in localized temp storage on the stack frame, the *
// * next step is to determine if I can pass all of these localized temporarily stored parameter results into the calling *
// * subroutine via  Intel x86 registers or if I must formally pass some stored parameters in via the stack.              * 
// *                                                                                                                      *
// * Parameters to procedures or functions are passed in via the following Intel x86 registers:                           *
// * rdi, rsi, rdx, rcx, r8, and r9.                                                                                      *
// *                                                                                                                      *
// * Using these registers (above) to pass parameters is signifcantly faster than accessing conventional memory on the    *
// * stack. However, if I have seven or more parameters to pass in to a procedure or function, then I must pass in the    *
// * remaining parameters via the stack and convenional memory access (i.e. the stack frame). It is a slower method than  *
// * passing in by register but there's no way around it.                                                                 *
// ************************************************************************************************************************
          //printf ("\nParameter mapping list:\n");
          //parameter_mapping_element = parameter_mapping_list;
          //while (parameter_mapping_element != NULL)
          //{
          //  printf ("Parameter_index: %llu\n", parameter_mapping_element->parameter_index);
          //  printf ("Calling parameter stackframe offset: %ld\n", parameter_mapping_element->stackframe_offset);
          //  printf ("Receiving parameter datatype: ");
          //  switch (parameter_mapping_element->receiving_parameter_datatype)
          //  {
          //    case _int:
          //      printf ("int");
          //    break;
          //    case _bool:
          //      printf ("bool");
          //    break;
          //    case _real:
          //      printf ("real");
          //    break;
          //    default:
          //      printf ("unknown datatype");
          //    break;
          //  }
          //  putchar ('\n');
          //  parameter_mapping_element = parameter_mapping_element->next;
          //}
          switch (parameter_list_entry_counter)
          {
// ******************************************************************************************************************************
// * One parameter is being sent to the called procedure or function. I'll pass the parameters into the function via registers. *
// ******************************************************************************************************************************
            case 1:
              if (parameter_mapping_list != NULL)
              {
// ******************************************************************************************************
// * Generate the x86 assembler instructions to load parameters in then call the function or procedure. *
// ******************************************************************************************************
                assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
                if (assembler_statement != NULL)
                {
                  assembler_statement->scope_level = scope_level;
                  assembler_statement->label = NULL;
                  assembler_statement->label_associated_with_else_statement = NULL;
                  assembler_statement->label_after_if_then_else_statement = NULL;
                  assembler_statement->code_section_contents = NULL;
                  assembler_statement->data_section_contents = NULL;
                  assembler_statement->next = NULL;
                  code_section_string_buffer_max_length = 2048 + strlen(procedure_or_function_name_symbol_table_element->identifier);
                  assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
                  if (assembler_statement->code_section_contents != NULL)
                  {
                    snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov rax, QWORD PTR -%ld[rbp]\n        mov rdi, rax\n        call %s\n", parameter_mapping_list->stackframe_offset, procedure_or_function_name_symbol_table_element->identifier);
                    snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov rax, QWORD PTR -%ld[rbp]\n        mov rdi, rax\n        call %s\n        mov QWORD PTR -%ld[rbp], 0\n", parameter_mapping_list->stackframe_offset, procedure_or_function_name_symbol_table_element->identifier, parameter_mapping_list->stackframe_offset);
                  }
                  if (assembler_program != NULL)
                  {
                    temp_assembler_element = assembler_program;
                    while (temp_assembler_element->next != NULL)
                    {
                      temp_assembler_element = temp_assembler_element->next;
                    }
                    temp_assembler_element->next = assembler_statement;
                  }
                  else
                  {
                    assembler_program = assembler_statement;
                  }
                }
              }
            break;
// ********************************************************************************************************************************
// * Two parameters are being sent to the called procedure or function. I'll pass the parameters into the function via registers. *
// ********************************************************************************************************************************
            case 2:
              parameter_mapping_element1 = NULL;
              parameter_mapping_element2 = NULL;
              if (parameter_mapping_list != NULL)
              {
                parameter_mapping_element1 = parameter_mapping_list;
              }
              if (parameter_mapping_element1 != NULL)
              {
                parameter_mapping_element2 = parameter_mapping_element1->next;
              }  
              if ((parameter_mapping_element1 != NULL) && (parameter_mapping_element2 != NULL))
              {
// ******************************************************************************************************
// * Generate the x86 assembler instructions to load parameters in then call the function or procedure. *
// ******************************************************************************************************
                assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
                if (assembler_statement != NULL)
                {
                  assembler_statement->scope_level = scope_level;
                  assembler_statement->label = NULL;
                  assembler_statement->label_associated_with_else_statement = NULL;
                  assembler_statement->label_after_if_then_else_statement = NULL;
                  assembler_statement->code_section_contents = NULL;
                  assembler_statement->data_section_contents = NULL;
                  assembler_statement->next = NULL;
                  code_section_string_buffer_max_length = 2048 + strlen(procedure_or_function_name_symbol_table_element->identifier);
                  assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
                  if (assembler_statement->code_section_contents != NULL)
                  {
                    snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov rdx, QWORD PTR -%ld[rbp]\n        mov rax, QWORD PTR -%ld[rbp]\n        mov rsi, rdx\n        mov rdi, rax\n        call %s\n        mov QWORD PTR -%ld[rbp], 0\n        mov QWORD PTR -%ld[rbp], 0\n", parameter_mapping_element1->stackframe_offset, parameter_mapping_element2->stackframe_offset, procedure_or_function_name_symbol_table_element->identifier, parameter_mapping_element1->stackframe_offset, parameter_mapping_element2->stackframe_offset);
                  }
                  if (assembler_program != NULL)
                  {
                    temp_assembler_element = assembler_program;
                    while (temp_assembler_element->next != NULL)
                    {
                      temp_assembler_element = temp_assembler_element->next;
                    }
                    temp_assembler_element->next = assembler_statement;
                  }
                  else
                  {
                    assembler_program = assembler_statement;
                  }
                }
              }
            break;
            case 3:
// **********************************************************************************************************************************
// * Three parameters are being sent to the called procedure or function. I'll pass the parameters into the function via registers. *
// **********************************************************************************************************************************
              parameter_mapping_element1 = NULL;
              parameter_mapping_element2 = NULL;
              parameter_mapping_element3 = NULL;
              if (parameter_mapping_list != NULL)
              {
                parameter_mapping_element1 = parameter_mapping_list;
              }
              if (parameter_mapping_element1 != NULL)
              {
                parameter_mapping_element2 = parameter_mapping_element1->next;
              }
              if (parameter_mapping_element2 != NULL)
              {
                parameter_mapping_element3 = parameter_mapping_element2->next;
              }
              if ((parameter_mapping_element1 != NULL) && (parameter_mapping_element2 != NULL) && (parameter_mapping_element3 != NULL))
              {
// ******************************************************************************************************
// * Generate the x86 assembler instructions to load parameters in then call the function or procedure. *
// ******************************************************************************************************
                assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
                if (assembler_statement != NULL)
                {
                  assembler_statement->scope_level = scope_level;
                  assembler_statement->label = NULL;
                  assembler_statement->label_associated_with_else_statement = NULL;
                  assembler_statement->label_after_if_then_else_statement = NULL;
                  assembler_statement->code_section_contents = NULL;
                  assembler_statement->data_section_contents = NULL;
                  assembler_statement->next = NULL;
                  code_section_string_buffer_max_length = 2048 + strlen(procedure_or_function_name_symbol_table_element->identifier);
                  assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
                  if (assembler_statement->code_section_contents != NULL)
                  {
                    snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov rdx, QWORD PTR -%ld[rbp]\n        mov rcx, QWORD PTR -%ld[rbp]\n        mov rax, QWORD PTR -%ld[rbp]\n        mov rsi, rcx\n        mov rdi, rax\n        call %s\n        mov QWORD PTR -%ld[rbp], 0\n        mov QWORD PTR -%ld[rbp], 0\n        mov QWORD PTR -%ld[rbp], 0\n", parameter_mapping_element1->stackframe_offset, parameter_mapping_element2->stackframe_offset, parameter_mapping_element3->stackframe_offset, procedure_or_function_name_symbol_table_element->identifier, parameter_mapping_element1->stackframe_offset, parameter_mapping_element2->stackframe_offset, parameter_mapping_element3->stackframe_offset);
                  }
                  if (assembler_program != NULL)
                  {
                    temp_assembler_element = assembler_program;
                    while (temp_assembler_element->next != NULL)
                    {
                      temp_assembler_element = temp_assembler_element->next;
                    }
                    temp_assembler_element->next = assembler_statement;
                  }
                  else
                  {
                    assembler_program = assembler_statement;
                  }
                }
              }
            break;
            case 4:
// *********************************************************************************************************************************
// * Four parameters are being sent to the called procedure or function. I'll pass the parameters into the function via registers. *
// *********************************************************************************************************************************
              parameter_mapping_element1 = NULL;
              parameter_mapping_element2 = NULL;
              parameter_mapping_element3 = NULL;
              parameter_mapping_element4 = NULL;
              if (parameter_mapping_list != NULL)
              {
                parameter_mapping_element1 = parameter_mapping_list;
              }
              if (parameter_mapping_element1 != NULL)
              {
                parameter_mapping_element2 = parameter_mapping_element1->next;
              }
              if (parameter_mapping_element2 != NULL)
              {
                parameter_mapping_element3 = parameter_mapping_element2->next;
              }
              if (parameter_mapping_element3 != NULL)
              {
                parameter_mapping_element4 = parameter_mapping_element3->next;
              }
              if ((parameter_mapping_element1 != NULL) && 
                  (parameter_mapping_element2 != NULL) && 
                  (parameter_mapping_element3 != NULL) &&
                  (parameter_mapping_element4 != NULL))
              {
// ******************************************************************************************************
// * Generate the x86 assembler instructions to load parameters in then call the function or procedure. *
// ******************************************************************************************************
                assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
                if (assembler_statement != NULL)
                {
                  assembler_statement->scope_level = scope_level;
                  assembler_statement->label = NULL;
                  assembler_statement->label_associated_with_else_statement = NULL;
                  assembler_statement->label_after_if_then_else_statement = NULL;
                  assembler_statement->code_section_contents = NULL;
                  assembler_statement->data_section_contents = NULL;
                  assembler_statement->next = NULL;
                  code_section_string_buffer_max_length = 2048 + strlen(procedure_or_function_name_symbol_table_element->identifier);
                  assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
                  if (assembler_statement->code_section_contents != NULL)
                  {
                    snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov rcx, QWORD PTR -%ld[rbp]\n        mov rdx, QWORD PTR -%ld[rbp]\n        mov rsi, QWORD PTR -%ld[rbp]\n        mov rax, QWORD PTR -%ld[rbp]\n        mov rdi, rax\n        call %s\n        mov QWORD PTR -%ld[rbp], 0\n        mov QWORD PTR -%ld[rbp], 0\n        mov QWORD PTR -%ld[rbp], 0\n        mov QWORD PTR -%ld[rbp], 0\n", parameter_mapping_element1->stackframe_offset, parameter_mapping_element2->stackframe_offset, parameter_mapping_element3->stackframe_offset, parameter_mapping_element4->stackframe_offset, procedure_or_function_name_symbol_table_element->identifier, parameter_mapping_element1->stackframe_offset, parameter_mapping_element2->stackframe_offset, parameter_mapping_element3->stackframe_offset, parameter_mapping_element4->stackframe_offset);
                  }
                  if (assembler_program != NULL)
                  {
                    temp_assembler_element = assembler_program;
                    while (temp_assembler_element->next != NULL)
                    {
                      temp_assembler_element = temp_assembler_element->next;
                    }
                    temp_assembler_element->next = assembler_statement;
                  }
                  else
                  {
                    assembler_program = assembler_statement;
                  }
                }
              }
            break;
            case 5:
// *********************************************************************************************************************************
// * Five parameters are being sent to the called procedure or function. I'll pass the parameters into the function via registers. *
// *********************************************************************************************************************************
              parameter_mapping_element1 = NULL;
              parameter_mapping_element2 = NULL;
              parameter_mapping_element3 = NULL;
              parameter_mapping_element4 = NULL;
              parameter_mapping_element5 = NULL;
              if (parameter_mapping_list != NULL)
              {
                parameter_mapping_element1 = parameter_mapping_list;
              }
              if (parameter_mapping_element1 != NULL)
              {
                parameter_mapping_element2 = parameter_mapping_element1->next;
              }
              if (parameter_mapping_element2 != NULL)
              {
                parameter_mapping_element3 = parameter_mapping_element2->next;
              }
              if (parameter_mapping_element3 != NULL)
              {
                parameter_mapping_element4 = parameter_mapping_element3->next;
              }
              if (parameter_mapping_element4 != NULL)
              {
                parameter_mapping_element5 = parameter_mapping_element4->next;
              }
              if ((parameter_mapping_element1 != NULL) && 
                  (parameter_mapping_element2 != NULL) && 
                  (parameter_mapping_element3 != NULL) &&
                  (parameter_mapping_element4 != NULL) &&
                  (parameter_mapping_element5 != NULL))
              {
// ******************************************************************************************************
// * Generate the x86 assembler instructions to load parameters in then call the function or procedure. *
// ******************************************************************************************************
                assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
                if (assembler_statement != NULL)
                {
                  assembler_statement->scope_level = scope_level;
                  assembler_statement->label = NULL;
                  assembler_statement->label_associated_with_else_statement = NULL;
                  assembler_statement->label_after_if_then_else_statement = NULL;
                  assembler_statement->code_section_contents = NULL;
                  assembler_statement->data_section_contents = NULL;
                  assembler_statement->next = NULL;
                  code_section_string_buffer_max_length = 2048 + strlen(procedure_or_function_name_symbol_table_element->identifier);
                  assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
                  if (assembler_statement->code_section_contents != NULL)
                  {
                    snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov rdi, QWORD PTR -%ld[rbp]\n        mov rcx, QWORD PTR -%ld[rbp]\n        mov rdx, QWORD PTR -%ld[rbp]\n        mov rsi, QWORD PTR -%ld[rbp]\n        mov rax, QWORD PTR -%ld[rbp]\n        mov r8, rdi\n        mov rdi, rax\n        call %s\n        mov QWORD PTR -%ld[rbp], 0\n        mov QWORD PTR -%ld[rbp], 0\n        mov QWORD PTR -%ld[rbp], 0\n        mov QWORD PTR -%ld[rbp], 0\n        mov QWORD PTR -%ld[rbp], 0\n", parameter_mapping_element1->stackframe_offset, parameter_mapping_element2->stackframe_offset, parameter_mapping_element3->stackframe_offset, parameter_mapping_element4->stackframe_offset, parameter_mapping_element5->stackframe_offset, procedure_or_function_name_symbol_table_element->identifier, parameter_mapping_element1->stackframe_offset, parameter_mapping_element2->stackframe_offset, parameter_mapping_element3->stackframe_offset, parameter_mapping_element4->stackframe_offset, parameter_mapping_element5->stackframe_offset);
                  }
                  if (assembler_program != NULL)
                  {
                    temp_assembler_element = assembler_program;
                    while (temp_assembler_element->next != NULL)
                    {
                      temp_assembler_element = temp_assembler_element->next;
                    }
                    temp_assembler_element->next = assembler_statement;
                  }
                  else
                  {
                    assembler_program = assembler_statement;
                  }
                }
              }
            break;
            case 6: // Six parameters are being sent to the called procedure or function. I'll pass the parameters in to the function via registers.
// ********************************************************************************************************************************
// * Six parameters are being sent to the called procedure or function. I'll pass the parameters into the function via registers. *
// ********************************************************************************************************************************
              parameter_mapping_element1 = NULL;
              parameter_mapping_element2 = NULL;
              parameter_mapping_element3 = NULL;
              parameter_mapping_element4 = NULL;
              parameter_mapping_element5 = NULL;
              parameter_mapping_element6 = NULL;
              if (parameter_mapping_list != NULL)
              {
                parameter_mapping_element1 = parameter_mapping_list;
              }
              if (parameter_mapping_element1 != NULL)
              {
                parameter_mapping_element2 = parameter_mapping_element1->next;
              }
              if (parameter_mapping_element2 != NULL)
              {
                parameter_mapping_element3 = parameter_mapping_element2->next;
              }
              if (parameter_mapping_element3 != NULL)
              {
                parameter_mapping_element4 = parameter_mapping_element3->next;
              }
              if (parameter_mapping_element4 != NULL)
              {
                parameter_mapping_element5 = parameter_mapping_element4->next;
              }
              if (parameter_mapping_element5 != NULL)
              {
                parameter_mapping_element6 = parameter_mapping_element5->next;
              }
              if ((parameter_mapping_element1 != NULL) && 
                  (parameter_mapping_element2 != NULL) && 
                  (parameter_mapping_element3 != NULL) &&
                  (parameter_mapping_element4 != NULL) &&
                  (parameter_mapping_element5 != NULL) &&
                  (parameter_mapping_element6 != NULL))
              {
// ******************************************************************************************************
// * Generate the x86 assembler instructions to load parameters in then call the function or procedure. *
// ******************************************************************************************************
                assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
                if (assembler_statement != NULL)
                {
                  assembler_statement->scope_level = scope_level;
                  assembler_statement->label = NULL;
                  assembler_statement->label_associated_with_else_statement = NULL;
                  assembler_statement->label_after_if_then_else_statement = NULL;
                  assembler_statement->code_section_contents = NULL;
                  assembler_statement->data_section_contents = NULL;
                  assembler_statement->next = NULL;
                  code_section_string_buffer_max_length = 2048 + strlen(procedure_or_function_name_symbol_table_element->identifier);
                  assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
                  if (assembler_statement->code_section_contents != NULL)
                  {
                    snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov r8, QWORD PTR -%ld[rbp]\n        mov rdi, QWORD PTR -%ld[rbp]\n        mov rcx, QWORD PTR -%ld[rbp]\n        mov rdx, QWORD PTR -%ld[rbp]\n        mov rsi, QWORD PTR -%ld[rbp]\n        mov rax, QWORD PTR -%ld[rbp]\n        mov r9, r8\n        mov r8, rdi\n        mov rdi, rax\n        call %s\n        mov QWORD PTR -%ld[rbp], 0\n        mov QWORD PTR -%ld[rbp], 0\n        mov QWORD PTR -%ld[rbp], 0\n        mov QWORD PTR -%ld[rbp], 0\n        mov QWORD PTR -%ld[rbp], 0\n        mov QWORD PTR -%ld[rbp], 0\n", parameter_mapping_element1->stackframe_offset, parameter_mapping_element2->stackframe_offset, parameter_mapping_element3->stackframe_offset, parameter_mapping_element4->stackframe_offset, parameter_mapping_element5->stackframe_offset, parameter_mapping_element6->stackframe_offset, procedure_or_function_name_symbol_table_element->identifier, parameter_mapping_element1->stackframe_offset, parameter_mapping_element2->stackframe_offset, parameter_mapping_element3->stackframe_offset, parameter_mapping_element4->stackframe_offset, parameter_mapping_element5->stackframe_offset, parameter_mapping_element6->stackframe_offset);
                  }
                  if (assembler_program != NULL)
                  {
                    temp_assembler_element = assembler_program;
                    while (temp_assembler_element->next != NULL)
                    {
                      temp_assembler_element = temp_assembler_element->next;
                    }
                    temp_assembler_element->next = assembler_statement;
                  }
                  else
                  {
                    assembler_program = assembler_statement;
                  }
                }
              }






            break;
            default: // Seven or more parameters are being sent to the called procedure or function. I will use a combination of registers and the stack frame to pass parameters into the precedure or function.
              printf ("NOT YET IMPLEMENTED: 7 or more parameters in a subroutine\n");
            break;
          }
        }
      }
    }
  }
  return assembler_program;
}




asmblr_node * create_assembler_output_for_operator_or_operand_to_build_runtime_expression (asmblr_node *assembler_program, ast_node *ast_element, symtab_node *symbol_table, stackframe_node *stackframe_cross_reference_table, stackframe_node *temporary_storage_variable_stackframe_element, unsigned long long int scope_level)
{
  asmblr_node *assembler_statement, *assembler_element, *temp_assembler_element;
  symtab_node *symbol_table_element, *temporary_storage_variable;
  stackframe_node *chaga_variable_stackframe_element;
  chaga_attribute_type target_variable_attribute_type;
  chaga_attribute_datatype target_variable_datatype;
  unsigned long long int target_variable_scope_level, counter_for_new_variables;
  int state, token_type;
  char *token, *constant_integer_token, *constant_real_token, *constant_boolean_token;
  unsigned char new_variable[1024], *data_section_string_buffer;
  unsigned long long int *label;
  size_t i, j, token_string_length, code_section_string_buffer_max_length, data_section_string_buffer_length; 

  //printf ("Entering create_assembler_output_for_operator_or_operand_to_build_runtime_expression.\n");
  assembler_statement = NULL;
  data_section_string_buffer = NULL;
  temporary_storage_variable = NULL;
  constant_integer_token = NULL;
  constant_real_token = NULL;
  constant_boolean_token = NULL;
  token = NULL;
  counter_for_new_variables = 0;
  if (ast_element != NULL)
  {
    if (temporary_storage_variable_stackframe_element != NULL)
    {
      token = ast_element->token;
      token_type = ast_element->token_type;
      if (token != NULL)
      {
        switch (token_type)
        {
          case TOKEN_IDENTIFIER:
            assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
            if (assembler_statement != NULL)
            {
              assembler_statement->scope_level = scope_level;
              assembler_statement->label = NULL;
              assembler_statement->label_associated_with_else_statement = NULL;
              assembler_statement->label_after_if_then_else_statement = NULL;
              assembler_statement->code_section_contents = NULL;       
              assembler_statement->data_section_contents = NULL;       
              assembler_statement->next = NULL;
              symbol_table_element = ast_element->symbol_table_entry;
              if (symbol_table_element != NULL)
              {
                chaga_variable_stackframe_element = retrieve_stackframe_offset (stackframe_cross_reference_table, symbol_table_element);
                if (chaga_variable_stackframe_element != NULL)
                {
                  if (symbol_table_element->attribute_type == _datatype)
                  {
                    switch (symbol_table_element->datatype)
                    {
                      case _int:
                        code_section_string_buffer_max_length = 4096;
                        assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
                        if (assembler_statement->code_section_contents != NULL)
                        {
                          snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov rdx, QWORD PTR -%ld[rbp]\n        mov rax, QWORD PTR -%ld[rbp]\n        mov ecx, 0\n        mov esi, 1\n        mov rdi, rax\n        call add_operand_element_runtime_expression@PLT\n        mov QWORD PTR -%ld[rbp], rax\n", chaga_variable_stackframe_element->stackframe_offset, temporary_storage_variable_stackframe_element->stackframe_offset, temporary_storage_variable_stackframe_element->stackframe_offset);
                          if (assembler_program != NULL)
                          {
                            temp_assembler_element = assembler_program;
                            while (temp_assembler_element->next != NULL)
                            {
                              temp_assembler_element = temp_assembler_element->next;
                            }
                            temp_assembler_element->next = assembler_statement;
                          }
                          else
                          {
                            assembler_program = assembler_statement;
                          }
                        }
                      break;
                      case _real:
                        code_section_string_buffer_max_length = 4096;
                        assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
                        if (assembler_statement->code_section_contents != NULL)
                        {
                          snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov rdx, QWORD PTR -%ld[rbp]\n        mov rax, QWORD PTR -%ld[rbp]\n        mov ecx, 0\n        mov esi, 3\n        mov rdi, rax\n        call add_operand_element_runtime_expression@PLT\n        mov QWORD PTR -%ld[rbp], rax\n", chaga_variable_stackframe_element->stackframe_offset, temporary_storage_variable_stackframe_element->stackframe_offset, temporary_storage_variable_stackframe_element->stackframe_offset);
                          if (assembler_program != NULL)
                          {
                            temp_assembler_element = assembler_program;
                            while (temp_assembler_element->next != NULL)
                            {
                              temp_assembler_element = temp_assembler_element->next;
                            }
                            temp_assembler_element->next = assembler_statement;
                          }
                          else
                          {
                            assembler_program = assembler_statement;
                          }
                        }
                      break;
                      case _bool:
                        code_section_string_buffer_max_length = 4096;
                        assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
                        if (assembler_statement->code_section_contents != NULL)
                        {
                          snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov rdx, QWORD PTR -%ld[rbp]\n        mov rax, QWORD PTR -%ld[rbp]\n        mov ecx, 0\n        mov esi, 2\n        mov rdi, rax\n        call add_operand_element_runtime_expression@PLT\n        mov QWORD PTR -%ld[rbp], rax\n", chaga_variable_stackframe_element->stackframe_offset, temporary_storage_variable_stackframe_element->stackframe_offset, temporary_storage_variable_stackframe_element->stackframe_offset);
                          if (assembler_program != NULL)
                          {
                            temp_assembler_element = assembler_program;
                            while (temp_assembler_element->next != NULL)
                            {
                              temp_assembler_element = temp_assembler_element->next;
                            }
                            temp_assembler_element->next = assembler_statement;
                          }
                          else
                          {
                            assembler_program = assembler_statement;
                          }
                        }
                      break;
                      default:
                      break;
                    }
                  }
                }
              }
            }
          break;
          case TOKEN_IDENTIFIER_INTEGER_CONSTANT:
            assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
            if (assembler_statement != NULL)
            {
              assembler_statement->label = (unsigned long long int *) malloc(sizeof(unsigned long long int));
              if (assembler_statement->label != NULL)
              {
                assembler_statement->scope_level = scope_level;
                assembler_statement->label_associated_with_else_statement = NULL;
                assembler_statement->label_after_if_then_else_statement = NULL;
                assembler_statement->code_section_contents = NULL;       
                assembler_statement->data_section_contents = NULL;       
                assembler_statement->next = NULL;
                label = retrieve_highest_label_number_from_assembly_output (assembler_program);
                if (label != NULL)
                {
                  *assembler_statement->label = (*label) + 1;
                }
                else
                {
                  *assembler_statement->label = 1;
                }
                constant_integer_token = token;
                if (constant_integer_token != NULL)
                {
                  token_string_length = strlen(constant_integer_token);
                  data_section_string_buffer_length = token_string_length + 37;
                  data_section_string_buffer = (unsigned char *) malloc(sizeof(char)*data_section_string_buffer_length); 
                  if (data_section_string_buffer != NULL)
                  {
                    data_section_string_buffer[0]  = ' ';
                    data_section_string_buffer[1]  = ' ';
                    data_section_string_buffer[2]  = ' ';
                    data_section_string_buffer[3]  = ' ';
                    data_section_string_buffer[4]  = ' ';
                    data_section_string_buffer[5]  = ' ';
                    data_section_string_buffer[6]  = ' ';
                    data_section_string_buffer[7]  = ' ';
                    data_section_string_buffer[8]  = '.';
                    data_section_string_buffer[9]  = 's';
                    data_section_string_buffer[10] = 't';
                    data_section_string_buffer[11] = 'r';
                    data_section_string_buffer[12] = 'i';
                    data_section_string_buffer[13] = 'n';
                    data_section_string_buffer[14] = 'g';
                    data_section_string_buffer[15] = ' ';
                    data_section_string_buffer[16] = '"';
                    for (i = 0; i < token_string_length; i++)
                    {
                      data_section_string_buffer[17+i] = constant_integer_token[i];
                    }
                    data_section_string_buffer[17+token_string_length] = '"';
                    data_section_string_buffer[18+token_string_length] = '\n';
                    data_section_string_buffer[19+token_string_length] = ' ';
                    data_section_string_buffer[20+token_string_length] = ' ';
                    data_section_string_buffer[21+token_string_length] = ' ';
                    data_section_string_buffer[22+token_string_length] = ' ';
                    data_section_string_buffer[23+token_string_length] = ' ';
                    data_section_string_buffer[24+token_string_length] = ' ';
                    data_section_string_buffer[25+token_string_length] = ' ';
                    data_section_string_buffer[26+token_string_length] = ' ';
                    data_section_string_buffer[27+token_string_length] = '.';
                    data_section_string_buffer[28+token_string_length] = 'a';
                    data_section_string_buffer[29+token_string_length] = 'l';
                    data_section_string_buffer[30+token_string_length] = 'i';
                    data_section_string_buffer[31+token_string_length] = 'g';
                    data_section_string_buffer[32+token_string_length] = 'n';
                    data_section_string_buffer[33+token_string_length] = ' ';
                    data_section_string_buffer[34+token_string_length] = '8';
                    data_section_string_buffer[35+token_string_length] = '\n';
                    data_section_string_buffer[36+token_string_length] = '\0';
                  }
                  assembler_statement->data_section_contents = data_section_string_buffer;
                  code_section_string_buffer_max_length = 4096;
                  assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
                  if (assembler_statement->code_section_contents != NULL)
                  {
                    snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov rax, QWORD PTR -%ld[rbp]\n        mov ecx, 0\n        lea rdx, .M%llu[rip]\n        mov esi, 4\n        mov rdi, rax\n        call add_operand_element_runtime_expression@PLT\n        mov QWORD PTR -%ld[rbp], rax\n", temporary_storage_variable_stackframe_element->stackframe_offset, *assembler_statement->label, temporary_storage_variable_stackframe_element->stackframe_offset);
                  }
                  if (assembler_program != NULL)
                  {
                    temp_assembler_element = assembler_program;
                    while (temp_assembler_element->next != NULL)
                    {
                      temp_assembler_element = temp_assembler_element->next;
                    }
                    temp_assembler_element->next = assembler_statement;
                  }
                  else
                  {
                    assembler_program = assembler_statement;
                  }
                }
              }
            }
          break;
          case TOKEN_IDENTIFIER_FLOATING_POINT_CONSTANT:
            assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
            if (assembler_statement != NULL)
            {
              assembler_statement->label = (unsigned long long int *) malloc(sizeof(unsigned long long int));
              if (assembler_statement->label != NULL)
              {
                assembler_statement->scope_level = scope_level;
                assembler_statement->label_associated_with_else_statement = NULL;
                assembler_statement->label_after_if_then_else_statement = NULL;
                assembler_statement->code_section_contents = NULL;       
                assembler_statement->data_section_contents = NULL;       
                assembler_statement->next = NULL;
                label = retrieve_highest_label_number_from_assembly_output (assembler_program);
                if (label != NULL)
                {
                  *assembler_statement->label = (*label) + 1;
                }
                else
                {
                  *assembler_statement->label = 1;
                }
                constant_real_token = token;
                if (constant_real_token != NULL)
                {
                  token_string_length = strlen(constant_real_token);
                  data_section_string_buffer_length = token_string_length + 37;
                  data_section_string_buffer = (unsigned char *) malloc(sizeof(char)*data_section_string_buffer_length); 
                  if (data_section_string_buffer != NULL)
                  {
                    data_section_string_buffer[0]  = ' ';
                    data_section_string_buffer[1]  = ' ';
                    data_section_string_buffer[2]  = ' ';
                    data_section_string_buffer[3]  = ' ';
                    data_section_string_buffer[4]  = ' ';
                    data_section_string_buffer[5]  = ' ';
                    data_section_string_buffer[6]  = ' ';
                    data_section_string_buffer[7]  = ' ';
                    data_section_string_buffer[8]  = '.';
                    data_section_string_buffer[9]  = 's';
                    data_section_string_buffer[10] = 't';
                    data_section_string_buffer[11] = 'r';
                    data_section_string_buffer[12] = 'i';
                    data_section_string_buffer[13] = 'n';
                    data_section_string_buffer[14] = 'g';
                    data_section_string_buffer[15] = ' ';
                    data_section_string_buffer[16] = '"';
                    for (i = 0; i < token_string_length; i++)
                    {
                      data_section_string_buffer[17+i] = constant_real_token[i];
                    }
                    data_section_string_buffer[17+token_string_length] = '"';
                    data_section_string_buffer[18+token_string_length] = '\n';
                    data_section_string_buffer[19+token_string_length] = ' ';
                    data_section_string_buffer[20+token_string_length] = ' ';
                    data_section_string_buffer[21+token_string_length] = ' ';
                    data_section_string_buffer[22+token_string_length] = ' ';
                    data_section_string_buffer[23+token_string_length] = ' ';
                    data_section_string_buffer[24+token_string_length] = ' ';
                    data_section_string_buffer[25+token_string_length] = ' ';
                    data_section_string_buffer[26+token_string_length] = ' ';
                    data_section_string_buffer[27+token_string_length] = '.';
                    data_section_string_buffer[28+token_string_length] = 'a';
                    data_section_string_buffer[29+token_string_length] = 'l';
                    data_section_string_buffer[30+token_string_length] = 'i';
                    data_section_string_buffer[31+token_string_length] = 'g';
                    data_section_string_buffer[32+token_string_length] = 'n';
                    data_section_string_buffer[33+token_string_length] = ' ';
                    data_section_string_buffer[34+token_string_length] = '8';
                    data_section_string_buffer[35+token_string_length] = '\n';
                    data_section_string_buffer[36+token_string_length] = '\0';
                  }
                  assembler_statement->data_section_contents = data_section_string_buffer;
                  code_section_string_buffer_max_length = 4096;
                  assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
                  if (assembler_statement->code_section_contents != NULL)
                  {
                    snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov rax, QWORD PTR -%ld[rbp]\n        mov ecx, 0\n        lea rdx, .M%llu[rip]\n        mov esi, 5\n        mov rdi, rax\n        call add_operand_element_runtime_expression@PLT\n        mov QWORD PTR -%ld[rbp], rax\n", temporary_storage_variable_stackframe_element->stackframe_offset, *assembler_statement->label, temporary_storage_variable_stackframe_element->stackframe_offset);
                  }
                  if (assembler_program != NULL)
                  {
                    temp_assembler_element = assembler_program;
                    while (temp_assembler_element->next != NULL)
                    {
                      temp_assembler_element = temp_assembler_element->next;
                    }
                    temp_assembler_element->next = assembler_statement;
                  }
                  else
                  {
                    assembler_program = assembler_statement;
                  }
                }
              }
            }
          break;
          case TOKEN_TRUE:
          case TOKEN_FALSE:
            assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
            if (assembler_statement != NULL)
            {
              assembler_statement->label = (unsigned long long int *) malloc(sizeof(unsigned long long int));
              if (assembler_statement->label != NULL)
              {
                assembler_statement->scope_level = scope_level;
                assembler_statement->label_associated_with_else_statement = NULL;
                assembler_statement->label_after_if_then_else_statement = NULL;
                assembler_statement->code_section_contents = NULL;       
                assembler_statement->data_section_contents = NULL;       
                assembler_statement->next = NULL;
                label = retrieve_highest_label_number_from_assembly_output (assembler_program);
                if (label != NULL)
                {
                  *assembler_statement->label = (*label) + 1;
                }
                else
                {
                  *assembler_statement->label = 1;
                }
                constant_boolean_token = token;
                if (constant_boolean_token != NULL)
                {
                  token_string_length = strlen(constant_boolean_token);
                  data_section_string_buffer_length = token_string_length + 37;
                  data_section_string_buffer = (unsigned char *) malloc(sizeof(char)*data_section_string_buffer_length); 
                  if (data_section_string_buffer != NULL)
                  {
                    data_section_string_buffer[0]  = ' ';
                    data_section_string_buffer[1]  = ' ';
                    data_section_string_buffer[2]  = ' ';
                    data_section_string_buffer[3]  = ' ';
                    data_section_string_buffer[4]  = ' ';
                    data_section_string_buffer[5]  = ' ';
                    data_section_string_buffer[6]  = ' ';
                    data_section_string_buffer[7]  = ' ';
                    data_section_string_buffer[8]  = '.';
                    data_section_string_buffer[9]  = 's';
                    data_section_string_buffer[10] = 't';
                    data_section_string_buffer[11] = 'r';
                    data_section_string_buffer[12] = 'i';
                    data_section_string_buffer[13] = 'n';
                    data_section_string_buffer[14] = 'g';
                    data_section_string_buffer[15] = ' ';
                    data_section_string_buffer[16] = '"';
                    for (i = 0; i < token_string_length; i++)
                    {
                      data_section_string_buffer[17+i] = constant_boolean_token[i];
                    }
                    data_section_string_buffer[17+token_string_length] = '"';
                    data_section_string_buffer[18+token_string_length] = '\n';
                    data_section_string_buffer[19+token_string_length] = ' ';
                    data_section_string_buffer[20+token_string_length] = ' ';
                    data_section_string_buffer[21+token_string_length] = ' ';
                    data_section_string_buffer[22+token_string_length] = ' ';
                    data_section_string_buffer[23+token_string_length] = ' ';
                    data_section_string_buffer[24+token_string_length] = ' ';
                    data_section_string_buffer[25+token_string_length] = ' ';
                    data_section_string_buffer[26+token_string_length] = ' ';
                    data_section_string_buffer[27+token_string_length] = '.';
                    data_section_string_buffer[28+token_string_length] = 'a';
                    data_section_string_buffer[29+token_string_length] = 'l';
                    data_section_string_buffer[30+token_string_length] = 'i';
                    data_section_string_buffer[31+token_string_length] = 'g';
                    data_section_string_buffer[32+token_string_length] = 'n';
                    data_section_string_buffer[33+token_string_length] = ' ';
                    data_section_string_buffer[34+token_string_length] = '8';
                    data_section_string_buffer[35+token_string_length] = '\n';
                    data_section_string_buffer[36+token_string_length] = '\0';
                  }
                  assembler_statement->data_section_contents = data_section_string_buffer;
                  code_section_string_buffer_max_length = 4096;
                  assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
                  if (assembler_statement->code_section_contents != NULL)
                  {
                    snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov rax, QWORD PTR -%ld[rbp]\n        mov ecx, 0\n        lea rdx, .M%llu[rip]\n        mov esi, 6\n        mov rdi, rax\n        call add_operand_element_runtime_expression@PLT\n        mov QWORD PTR -%ld[rbp], rax\n", temporary_storage_variable_stackframe_element->stackframe_offset, *assembler_statement->label, temporary_storage_variable_stackframe_element->stackframe_offset);
                  }
                  if (assembler_program != NULL)
                  {
                    temp_assembler_element = assembler_program;
                    while (temp_assembler_element->next != NULL)
                    {
                      temp_assembler_element = temp_assembler_element->next;
                    }
                    temp_assembler_element->next = assembler_statement;
                  }
                  else
                  {
                    assembler_program = assembler_statement;
                  }
                }
              }
            }
          break;
          case TOKEN_PLUS:
            assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
            if (assembler_statement != NULL)
            {
              assembler_statement->scope_level = scope_level;
              assembler_statement->label = NULL;
              assembler_statement->label_associated_with_else_statement = NULL;
              assembler_statement->label_after_if_then_else_statement = NULL;
              assembler_statement->code_section_contents = NULL;       
              assembler_statement->data_section_contents = NULL;       
              assembler_statement->next = NULL;
              code_section_string_buffer_max_length = 4096;
              assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
              if (assembler_statement->code_section_contents != NULL)
              {
                snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov rax, QWORD PTR -%ld[rbp]\n        mov esi, 11\n        mov rdi, rax\n        call add_operator_element_runtime_expression@PLT\n        mov QWORD PTR -%ld[rbp], rax\n", temporary_storage_variable_stackframe_element->stackframe_offset, temporary_storage_variable_stackframe_element->stackframe_offset);
                if (assembler_program != NULL)
                {
                  temp_assembler_element = assembler_program;
                  while (temp_assembler_element->next != NULL)
                  {
                    temp_assembler_element = temp_assembler_element->next;
                  }
                  temp_assembler_element->next = assembler_statement;
                }
                else
                {
                  assembler_program = assembler_statement;
                }
              }
            }
          break;
          case TOKEN_MINUS:
            assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
            if (assembler_statement != NULL)
            {
              assembler_statement->scope_level = scope_level;
              assembler_statement->label = NULL;
              assembler_statement->label_associated_with_else_statement = NULL;
              assembler_statement->label_after_if_then_else_statement = NULL;
              assembler_statement->code_section_contents = NULL;       
              assembler_statement->data_section_contents = NULL;       
              assembler_statement->next = NULL;
              code_section_string_buffer_max_length = 4096;
              assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
              if (assembler_statement->code_section_contents != NULL)
              {
                snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov rax, QWORD PTR -%ld[rbp]\n        mov esi, 12\n        mov rdi, rax\n        call add_operator_element_runtime_expression@PLT\n        mov QWORD PTR -%ld[rbp], rax\n", temporary_storage_variable_stackframe_element->stackframe_offset, temporary_storage_variable_stackframe_element->stackframe_offset);
                if (assembler_program != NULL)
                {
                  temp_assembler_element = assembler_program;
                  while (temp_assembler_element->next != NULL)
                  {
                    temp_assembler_element = temp_assembler_element->next;
                  }
                  temp_assembler_element->next = assembler_statement;
                }
                else
                {
                  assembler_program = assembler_statement;
                }
              }
            }
          break;
          case TOKEN_ASTERISK:
            assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
            if (assembler_statement != NULL)
            {
              assembler_statement->scope_level = scope_level;
              assembler_statement->label = NULL;
              assembler_statement->label_associated_with_else_statement = NULL;
              assembler_statement->label_after_if_then_else_statement = NULL;
              assembler_statement->code_section_contents = NULL;       
              assembler_statement->data_section_contents = NULL;       
              assembler_statement->next = NULL;
              code_section_string_buffer_max_length = 4096;
              assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
              if (assembler_statement->code_section_contents != NULL)
              {
                snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov rax, QWORD PTR -%ld[rbp]\n        mov esi, 13\n        mov rdi, rax\n        call add_operator_element_runtime_expression@PLT\n        mov QWORD PTR -%ld[rbp], rax\n", temporary_storage_variable_stackframe_element->stackframe_offset, temporary_storage_variable_stackframe_element->stackframe_offset);
                if (assembler_program != NULL)
                {
                  temp_assembler_element = assembler_program;
                  while (temp_assembler_element->next != NULL)
                  {
                    temp_assembler_element = temp_assembler_element->next;
                  }
                  temp_assembler_element->next = assembler_statement;
                }
                else
                {
                  assembler_program = assembler_statement;
                }
              }
            }
          break;
          case TOKEN_DIVIDE:
            assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
            if (assembler_statement != NULL)
            {
              assembler_statement->scope_level = scope_level;
              assembler_statement->label = NULL;
              assembler_statement->label_associated_with_else_statement = NULL;
              assembler_statement->label_after_if_then_else_statement = NULL;
              assembler_statement->code_section_contents = NULL;       
              assembler_statement->data_section_contents = NULL;       
              assembler_statement->next = NULL;
              code_section_string_buffer_max_length = 4096;
              assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
              if (assembler_statement->code_section_contents != NULL)
              {
                snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov rax, QWORD PTR -%ld[rbp]\n        mov esi, 14\n        mov rdi, rax\n        call add_operator_element_runtime_expression@PLT\n        mov QWORD PTR -%ld[rbp], rax\n", temporary_storage_variable_stackframe_element->stackframe_offset, temporary_storage_variable_stackframe_element->stackframe_offset);
                if (assembler_program != NULL)
                {
                  temp_assembler_element = assembler_program;
                  while (temp_assembler_element->next != NULL)
                  {
                    temp_assembler_element = temp_assembler_element->next;
                  }
                  temp_assembler_element->next = assembler_statement;
                }
                else
                {
                  assembler_program = assembler_statement;
                }
              }
            }
          break;
          case TOKEN_MODULO:
            assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
            if (assembler_statement != NULL)
            {
              assembler_statement->scope_level = scope_level;
              assembler_statement->label = NULL;
              assembler_statement->label_associated_with_else_statement = NULL;
              assembler_statement->label_after_if_then_else_statement = NULL;
              assembler_statement->code_section_contents = NULL;
              assembler_statement->data_section_contents = NULL;
              assembler_statement->next = NULL;
              code_section_string_buffer_max_length = 4096;
              assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
              if (assembler_statement->code_section_contents != NULL)
              {
                snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov rax, QWORD PTR -%ld[rbp]\n        mov esi, 15\n        mov rdi, rax\n        call add_operator_element_runtime_expression@PLT\n        mov QWORD PTR -%ld[rbp], rax\n", temporary_storage_variable_stackframe_element->stackframe_offset, temporary_storage_variable_stackframe_element->stackframe_offset);
                if (assembler_program != NULL)
                {
                  temp_assembler_element = assembler_program;
                  while (temp_assembler_element->next != NULL)
                  {
                    temp_assembler_element = temp_assembler_element->next;
                  }
                  temp_assembler_element->next = assembler_statement;
                }
                else
                {
                  assembler_program = assembler_statement;
                }
              }
            }
          break;
          case TOKEN_AND:
            assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
            if (assembler_statement != NULL)
            {
              assembler_statement->scope_level = scope_level;
              assembler_statement->label = NULL;
              assembler_statement->label_associated_with_else_statement = NULL;
              assembler_statement->label_after_if_then_else_statement = NULL;
              assembler_statement->code_section_contents = NULL;
              assembler_statement->data_section_contents = NULL;
              assembler_statement->next = NULL;
              code_section_string_buffer_max_length = 4096;
              assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
              if (assembler_statement->code_section_contents != NULL)
              {
                snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov rax, QWORD PTR -%ld[rbp]\n        mov esi, 7\n        mov rdi, rax\n        call add_operator_element_runtime_expression@PLT\n        mov QWORD PTR -%ld[rbp], rax\n", temporary_storage_variable_stackframe_element->stackframe_offset, temporary_storage_variable_stackframe_element->stackframe_offset);
                if (assembler_program != NULL)
                {
                  temp_assembler_element = assembler_program;
                  while (temp_assembler_element->next != NULL)
                  {
                    temp_assembler_element = temp_assembler_element->next;
                  }
                  temp_assembler_element->next = assembler_statement;
                }
                else
                {
                  assembler_program = assembler_statement;
                }
              }
            }
          break;
          case TOKEN_OR:
            assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
            if (assembler_statement != NULL)
            {
              assembler_statement->scope_level = scope_level;
              assembler_statement->label = NULL;
              assembler_statement->label_associated_with_else_statement = NULL;
              assembler_statement->label_after_if_then_else_statement = NULL;
              assembler_statement->code_section_contents = NULL;
              assembler_statement->data_section_contents = NULL;
              assembler_statement->next = NULL;
              code_section_string_buffer_max_length = 4096;
              assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
              if (assembler_statement->code_section_contents != NULL)
              {
                snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov rax, QWORD PTR -%ld[rbp]\n        mov esi, 8\n        mov rdi, rax\n        call add_operator_element_runtime_expression@PLT\n        mov QWORD PTR -%ld[rbp], rax\n", temporary_storage_variable_stackframe_element->stackframe_offset, temporary_storage_variable_stackframe_element->stackframe_offset);
                if (assembler_program != NULL)
                {
                  temp_assembler_element = assembler_program;
                  while (temp_assembler_element->next != NULL)
                  {
                    temp_assembler_element = temp_assembler_element->next;
                  }
                  temp_assembler_element->next = assembler_statement;
                }
                else
                {
                  assembler_program = assembler_statement;
                }
              }
            }
          break;
          case TOKEN_XOR:
            assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
            if (assembler_statement != NULL)
            {
              assembler_statement->scope_level = scope_level;
              assembler_statement->label = NULL;
              assembler_statement->label_associated_with_else_statement = NULL;
              assembler_statement->label_after_if_then_else_statement = NULL;
              assembler_statement->code_section_contents = NULL;
              assembler_statement->data_section_contents = NULL;
              assembler_statement->next = NULL;
              code_section_string_buffer_max_length = 4096;
              assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
              if (assembler_statement->code_section_contents != NULL)
              {
                snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov rax, QWORD PTR -%ld[rbp]\n        mov esi, 9\n        mov rdi, rax\n        call add_operator_element_runtime_expression@PLT\n        mov QWORD PTR -%ld[rbp], rax\n", temporary_storage_variable_stackframe_element->stackframe_offset, temporary_storage_variable_stackframe_element->stackframe_offset);
                if (assembler_program != NULL)
                {
                  temp_assembler_element = assembler_program;
                  while (temp_assembler_element->next != NULL)
                  {
                    temp_assembler_element = temp_assembler_element->next;
                  }
                  temp_assembler_element->next = assembler_statement;
                }
                else
                {
                  assembler_program = assembler_statement;
                }
              }
            }
          break;
          case TOKEN_NOT:
            assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
            if (assembler_statement != NULL)
            {
              assembler_statement->scope_level = scope_level;
              assembler_statement->label = NULL;
              assembler_statement->label_associated_with_else_statement = NULL;
              assembler_statement->label_after_if_then_else_statement = NULL;
              assembler_statement->code_section_contents = NULL;
              assembler_statement->data_section_contents = NULL;
              assembler_statement->next = NULL;
              code_section_string_buffer_max_length = 4096;
              assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
              if (assembler_statement->code_section_contents != NULL)
              {
                snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov rax, QWORD PTR -%ld[rbp]\n        mov esi, 10\n        mov rdi, rax\n        call add_operator_element_runtime_expression@PLT\n        mov QWORD PTR -%ld[rbp], rax\n", temporary_storage_variable_stackframe_element->stackframe_offset, temporary_storage_variable_stackframe_element->stackframe_offset);
                if (assembler_program != NULL)
                {
                  temp_assembler_element = assembler_program;
                  while (temp_assembler_element->next != NULL)
                  {
                    temp_assembler_element = temp_assembler_element->next;
                  }
                  temp_assembler_element->next = assembler_statement;
                }
                else
                {
                  assembler_program = assembler_statement;
                }
              }
            }
          break;
          case TOKEN_EQUAL:
            assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
            if (assembler_statement != NULL)
            {
              assembler_statement->scope_level = scope_level;
              assembler_statement->label = NULL;
              assembler_statement->label_associated_with_else_statement = NULL;
              assembler_statement->label_after_if_then_else_statement = NULL;
              assembler_statement->code_section_contents = NULL;
              assembler_statement->data_section_contents = NULL;
              assembler_statement->next = NULL;
              code_section_string_buffer_max_length = 4096;
              assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
              if (assembler_statement->code_section_contents != NULL)
              {
                snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov rax, QWORD PTR -%ld[rbp]\n        mov esi, 5\n        mov rdi, rax\n        call add_operator_element_runtime_expression@PLT\n        mov QWORD PTR -%ld[rbp], rax\n", temporary_storage_variable_stackframe_element->stackframe_offset, temporary_storage_variable_stackframe_element->stackframe_offset);
                if (assembler_program != NULL)
                {
                  temp_assembler_element = assembler_program;
                  while (temp_assembler_element->next != NULL)
                  {
                    temp_assembler_element = temp_assembler_element->next;
                  }
                  temp_assembler_element->next = assembler_statement;
                }
                else
                {
                  assembler_program = assembler_statement;
                }
              }
            }
          break;
          case TOKEN_NOT_EQUAL:
            assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
            if (assembler_statement != NULL)
            {
              assembler_statement->scope_level = scope_level;
              assembler_statement->label = NULL;
              assembler_statement->label_associated_with_else_statement = NULL;
              assembler_statement->label_after_if_then_else_statement = NULL;
              assembler_statement->code_section_contents = NULL;
              assembler_statement->data_section_contents = NULL;
              assembler_statement->next = NULL;
              code_section_string_buffer_max_length = 4096;
              assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
              if (assembler_statement->code_section_contents != NULL)
              {
                snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov rax, QWORD PTR -%ld[rbp]\n        mov esi, 6\n        mov rdi, rax\n        call add_operator_element_runtime_expression@PLT\n        mov QWORD PTR -%ld[rbp], rax\n", temporary_storage_variable_stackframe_element->stackframe_offset, temporary_storage_variable_stackframe_element->stackframe_offset);
                if (assembler_program != NULL)
                {
                  temp_assembler_element = assembler_program;
                  while (temp_assembler_element->next != NULL)
                  {
                    temp_assembler_element = temp_assembler_element->next;
                  }
                  temp_assembler_element->next = assembler_statement;
                }
                else
                {
                  assembler_program = assembler_statement;
                }
              }
            }
          break;
          case TOKEN_GREATER_THAN: 
            assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
            if (assembler_statement != NULL)
            {
              assembler_statement->scope_level = scope_level;
              assembler_statement->label = NULL;
              assembler_statement->label_associated_with_else_statement = NULL;
              assembler_statement->label_after_if_then_else_statement = NULL;
              assembler_statement->code_section_contents = NULL;
              assembler_statement->data_section_contents = NULL;
              assembler_statement->next = NULL;
              code_section_string_buffer_max_length = 4096;
              assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
              if (assembler_statement->code_section_contents != NULL)
              {
                snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov rax, QWORD PTR -%ld[rbp]\n        mov esi, 2\n        mov rdi, rax\n        call add_operator_element_runtime_expression@PLT\n        mov QWORD PTR -%ld[rbp], rax\n", temporary_storage_variable_stackframe_element->stackframe_offset, temporary_storage_variable_stackframe_element->stackframe_offset);
                if (assembler_program != NULL)
                {
                  temp_assembler_element = assembler_program;
                  while (temp_assembler_element->next != NULL)
                  {
                    temp_assembler_element = temp_assembler_element->next;
                  }
                  temp_assembler_element->next = assembler_statement;
                }
                else
                {
                  assembler_program = assembler_statement;
                }
              }
            }
          break;
          case TOKEN_LESS_THAN:
            assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
            if (assembler_statement != NULL)
            {
              assembler_statement->scope_level = scope_level;
              assembler_statement->label = NULL;
              assembler_statement->label_associated_with_else_statement = NULL;
              assembler_statement->label_after_if_then_else_statement = NULL;
              assembler_statement->code_section_contents = NULL;
              assembler_statement->data_section_contents = NULL;
              assembler_statement->next = NULL;
              code_section_string_buffer_max_length = 4096;
              assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
              if (assembler_statement->code_section_contents != NULL)
              {
                snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov rax, QWORD PTR -%ld[rbp]\n        mov esi, 4\n        mov rdi, rax\n        call add_operator_element_runtime_expression@PLT\n        mov QWORD PTR -%ld[rbp], rax\n", temporary_storage_variable_stackframe_element->stackframe_offset, temporary_storage_variable_stackframe_element->stackframe_offset);
                if (assembler_program != NULL)
                {
                  temp_assembler_element = assembler_program;
                  while (temp_assembler_element->next != NULL)
                  {
                    temp_assembler_element = temp_assembler_element->next;
                  }
                  temp_assembler_element->next = assembler_statement;
                }
                else
                {
                  assembler_program = assembler_statement;
                }
              }
            }
          break;
          case TOKEN_GREATER_THAN_OR_EQUAL:
            assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
            if (assembler_statement != NULL)
            {
              assembler_statement->scope_level = scope_level;
              assembler_statement->label = NULL;
              assembler_statement->label_associated_with_else_statement = NULL;
              assembler_statement->label_after_if_then_else_statement = NULL;
              assembler_statement->code_section_contents = NULL;
              assembler_statement->data_section_contents = NULL;
              assembler_statement->next = NULL;
              code_section_string_buffer_max_length = 4096;
              assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
              if (assembler_statement->code_section_contents != NULL)
              {
                snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov rax, QWORD PTR -%ld[rbp]\n        mov esi, 1\n        mov rdi, rax\n        call add_operator_element_runtime_expression@PLT\n        mov QWORD PTR -%ld[rbp], rax\n", temporary_storage_variable_stackframe_element->stackframe_offset, temporary_storage_variable_stackframe_element->stackframe_offset);
                if (assembler_program != NULL)
                {
                  temp_assembler_element = assembler_program;
                  while (temp_assembler_element->next != NULL)
                  {
                    temp_assembler_element = temp_assembler_element->next;
                  }
                  temp_assembler_element->next = assembler_statement;
                }
                else
                {
                  assembler_program = assembler_statement;
                }
              }
            }
          break;
          case TOKEN_LESS_THAN_OR_EQUAL:
            assembler_statement = (asmblr_node *) malloc(sizeof(asmblr_node));
            if (assembler_statement != NULL)
            {
              assembler_statement->scope_level = scope_level;
              assembler_statement->label = NULL;
              assembler_statement->label_associated_with_else_statement = NULL;
              assembler_statement->label_after_if_then_else_statement = NULL;
              assembler_statement->code_section_contents = NULL;
              assembler_statement->data_section_contents = NULL;
              assembler_statement->next = NULL;
              code_section_string_buffer_max_length = 4096;
              assembler_statement->code_section_contents = (unsigned char *) malloc(sizeof(char) * code_section_string_buffer_max_length);
              if (assembler_statement->code_section_contents != NULL)
              {
                snprintf (assembler_statement->code_section_contents, code_section_string_buffer_max_length, "        mov rax, QWORD PTR -%ld[rbp]\n        mov esi, 3\n        mov rdi, rax\n        call add_operator_element_runtime_expression@PLT\n        mov QWORD PTR -%ld[rbp], rax\n", temporary_storage_variable_stackframe_element->stackframe_offset, temporary_storage_variable_stackframe_element->stackframe_offset);
                if (assembler_program != NULL)
                {
                  temp_assembler_element = assembler_program;
                  while (temp_assembler_element->next != NULL)
                  {
                    temp_assembler_element = temp_assembler_element->next;
                  }
                  temp_assembler_element->next = assembler_statement;
                }
                else
                {
                  assembler_program = assembler_statement;
                }
              }
            }
          break;
          default:
          break;
        } 
      }
    }
  }
  //printf ("Leaving create_assembler_output_for_operator_or_operand_to_build_runtime_expression.\n");
  return assembler_program;
}




void write_assembler_output_to_file (FILE *fp, asmblr_node *assembler_program)
{
  asmblr_node *assembler_program_element;
  int output_data_section;
  unsigned long long int highest_scope_level, current_scope_level;

  if (assembler_program != NULL)
  {
    fprintf (fp, "        .intel_syntax noprefix\n\n");
  }
  highest_scope_level = 0;
  assembler_program_element = assembler_program;
  while (assembler_program_element != NULL)
  {
    if (assembler_program_element->scope_level > highest_scope_level)
    {
      highest_scope_level = assembler_program_element->scope_level;
    }
    assembler_program_element = assembler_program_element->next;
  }
  current_scope_level = 0;
  while (current_scope_level <= highest_scope_level)
  {
    output_data_section = FALSE;
    assembler_program_element = assembler_program;
    while ((assembler_program_element != NULL) && (!output_data_section))
    {
      if (assembler_program_element->scope_level == current_scope_level)
      {
        if (assembler_program_element->data_section_contents != NULL)
        {
          output_data_section = TRUE;
        }
      }
      assembler_program_element = assembler_program_element->next;
    }
    if (output_data_section)
    {
      fprintf (fp, "        .section .rodata\n");
      assembler_program_element = assembler_program;
      while (assembler_program_element != NULL)
      {
        if (assembler_program_element->scope_level == current_scope_level)
        {
          if (assembler_program_element->data_section_contents != NULL)
          {
            if (assembler_program_element->label != NULL)
            {
              fprintf (fp, ".M%llu:\n%s\n", *assembler_program_element->label, assembler_program_element->data_section_contents);
            }
          }
        }
        assembler_program_element = assembler_program_element->next;
      }
    }
    assembler_program_element = assembler_program;
    while (assembler_program_element != NULL) 
    {
      if (assembler_program_element->scope_level == current_scope_level)
      {
        if (assembler_program_element->code_section_contents != NULL)
        {
          fprintf (fp, "%s", assembler_program_element->code_section_contents);
        }
      }
      assembler_program_element = assembler_program_element->next;
    }
    current_scope_level++;
  } 
}




void create_executable_output_file_from_x86_assembler_file (char *assembler_input_filename, char *assembler_object_filename, char *executable_filename)
{
  int executable_file_creation_status, object_file_creation_status, delete_files_status;
  char shell_command[65536];

  snprintf (&shell_command[0], sizeof(shell_command), "/usr/bin/as %s -o %s", assembler_input_filename, assembler_object_filename);
  object_file_creation_status = system (&shell_command[0]);
  if (object_file_creation_status != -1)
  {
    snprintf (&shell_command[0], sizeof(shell_command), "/usr/bin/gcc %s -lchaga -o %s", assembler_object_filename, executable_filename);
    executable_file_creation_status = system (&shell_command[0]);
    if (executable_file_creation_status != -1)
    {
// ******************************************************************
// * Now clean up by deleting temporary assembler and object files. *
// ******************************************************************
      snprintf (&shell_command[0], sizeof(shell_command), "/usr/bin/rm %s", assembler_input_filename);
      delete_files_status = system (&shell_command[0]);
      snprintf (&shell_command[0], sizeof(shell_command), "/usr/bin/rm %s", assembler_object_filename);
      delete_files_status = system (&shell_command[0]);
    }
    else
    {
      printf ("/usr/bin/ld failed to create executable file for object file: %s", assembler_object_filename);
    }
  }
  else
  {
    printf ("/usr/bin/as failed to create object file for assembler file: %s", assembler_input_filename);
  }
}




size_t symbol_table_count_number_of_datatype_declarations_for_given_scope_level_excluding_argv_argc_in_main (symtab_node *symbol_table, unsigned long long int scope_level)
{
  symtab_node *symbol_table_element;
  size_t num_datatype_declarations;

  num_datatype_declarations = 0;
  symbol_table_element = symbol_table;
  while (symbol_table_element != NULL)
  {
    if (symbol_table_element->identifier != NULL)
    {
      if (strncmp(symbol_table_element->identifier, "argc", 4) != 0)
      {
        if (strncmp(symbol_table_element->identifier, "argv", 4) != 0)
        {
          if (symbol_table_element->attribute_type == _datatype)
          {
            if (symbol_table_element->scope_level == scope_level)
            {
              num_datatype_declarations++;
            }
          }
        }
      }
      symbol_table_element = symbol_table_element->next;
    }
  }
  return num_datatype_declarations;
}





size_t symbol_table_count_number_of_datatype_declarations_for_given_scope_level (symtab_node *symbol_table, unsigned long long int scope_level)
{
  symtab_node *symbol_table_element;
  size_t num_datatype_declarations;

  num_datatype_declarations = 0;
  symbol_table_element = symbol_table;
  while (symbol_table_element != NULL)
  {
    if (symbol_table_element->identifier != NULL)
    {
      if (symbol_table_element->attribute_type == _datatype)
      {
        if (symbol_table_element->scope_level == scope_level)
        {
          num_datatype_declarations++;
        }
      }
      symbol_table_element = symbol_table_element->next;
    }
  }
  return num_datatype_declarations;
}






// *********************************************************************************************************************
// * retrieve_highest_label_number_from_assembly_output                                                                *
// *                                                                                                                   *
// * Assembler output contains labels to reference data such as strings from a printf statement. The label pointing to *
// * each string in the data section MUST be unique. The easiest way to do that is to report the highest number label  *
// * currently used. Then in calling program, increment that value by one to get a new unused label.                   * 
// *********************************************************************************************************************
unsigned long long int * retrieve_highest_label_number_from_assembly_output (asmblr_node *assembler_program)
{
  unsigned long long int *highest_label_number;
  asmblr_node *assembler_element;

  highest_label_number = NULL;
  assembler_element = assembler_program;
  while (assembler_element != NULL)
  {
    if (assembler_element->label != NULL)
    {
      if (highest_label_number != NULL)
      {
        if (*assembler_element->label > *highest_label_number)
        {
          highest_label_number = assembler_element->label;
        }
      }
      else
      {
        highest_label_number = assembler_element->label;
      }
    }
    assembler_element = assembler_element->next;
  }
  return highest_label_number;
}




unsigned long long int * retrieve_highest_label_number_from_abstract_syntax_tree (ast_node *abstract_syntax_tree)
{
  unsigned long long int *highest_label_number;
  ast_node *ast_element;

  highest_label_number = NULL;
  ast_element = abstract_syntax_tree;
  while (ast_element != NULL)
  {
    if (ast_element->label != NULL)
    { 
      if (highest_label_number != NULL)
      {
        if (*ast_element->label > *highest_label_number)
        {
          highest_label_number = ast_element->label;
        }
      }
      else
      {
        highest_label_number = ast_element->label;
      }
    }
    if (ast_element->sibling != NULL)
    {
      ast_element = ast_element->sibling;
    }
    else
    {
      ast_element = ast_element->child;
    }
  }
  return highest_label_number;
}




ast_node * find_else_statement_associated_with_if_statement (ast_node *abstract_syntax_tree)
{
  unsigned long long int if_statement_curly_brace_difference, else_statement_curly_brace_difference, curly_brace_difference;
  asmblr_node *assembler_element;
  ast_node *ast_element;
  char found;
  int state;

  //printf ("Entering find_else_statement_associated_with_if_statement\n");
  found = FALSE;
  if_statement_curly_brace_difference = 0;
  if (abstract_syntax_tree != NULL)
  {
    if (abstract_syntax_tree->statement_type == _if)
    {
      if_statement_curly_brace_difference = abstract_syntax_tree->num_left_curly_braces - abstract_syntax_tree->num_right_curly_braces;
    }
  }
  state = 0;
  ast_element = abstract_syntax_tree;
  while ((ast_element != NULL) && (!found) && (state != 999))
  {
    //printf ("state = %d, token: %s\n", state, ast_element->token);
    switch (state)
    {
      case 0:
        if (ast_element->statement_type == _right_curly_brace)
        {
          curly_brace_difference = ast_element->num_left_curly_braces - ast_element->num_right_curly_braces;
          if (if_statement_curly_brace_difference == curly_brace_difference)
          {
            state = 10;
          }
        }
      break;
      case 10:
        if (ast_element->statement_type == _else)
        {
          else_statement_curly_brace_difference = ast_element->num_left_curly_braces - ast_element->num_right_curly_braces;
          //printf ("if_statement_curly_brace_difference = %llu\n", if_statement_curly_brace_difference);
          //printf ("else_statement_curly_brace_difference = %llu\n", else_statement_curly_brace_difference);
          if (if_statement_curly_brace_difference == else_statement_curly_brace_difference)
          {
            found = TRUE;
          }
        }
        else
        {
          state = 999;
        }
      break;
      default:
      break;  
    }
    if (state != 999)
    {
      if (!found)
      {
        if (ast_element->sibling != NULL)
        {
          ast_element = ast_element->sibling;
        }
        else
        {
          ast_element = ast_element->child;
        }
      }
    }
  }
  if (state == 999)
  {
    ast_element = NULL;
    //printf ("NO ELSE STATEMENT FOUND.\n");
  }
  //printf ("Leaving find_else_statement_associated_with_if_statement\n");
  return ast_element;
}




// ******************************************************************************************************************
// * find_next_statement_after_if_then_statement                                                                    *
// *                                                                                                                *
// * This subroutine finds the next statement following an IF-THEN statement (i.e. no ELSE statement is present) to *
// * determine the jump point when the statement block for the IF statement must be skipped (i.e. when the Boolean  *
// * expression is FALSE. In such cases, I must proceed after the IF-THEN statement.                                *
// ******************************************************************************************************************
ast_node * find_next_statement_after_if_then_statement (ast_node *abstract_syntax_tree)
{
  unsigned long long int if_statement_curly_brace_difference, else_statement_curly_brace_difference, curly_brace_difference;
  asmblr_node *assembler_element;
  ast_node *ast_element;
  int state;
  char found;

  //printf ("Entering find_next_statement_after_if_then_statement.\n");
  ast_element = NULL;
  state = 0;
  found = FALSE;
  if_statement_curly_brace_difference = 0;
  else_statement_curly_brace_difference = 0;
  curly_brace_difference = 0;
  ast_element = abstract_syntax_tree;
  while ((ast_element != NULL) && (!found) && (state != 999))
  {
    //printf ("state = %d, token = %s\n", state, ast_element->token);
    switch (state)
    {
      case 0:
        if (ast_element->statement_type == _if)
        {
          if_statement_curly_brace_difference = ast_element->num_left_curly_braces - ast_element->num_right_curly_braces;
// *****************************************************
// * Now advance to next statement after IF statement. *
// *****************************************************
          while (ast_element->sibling != NULL)
          {
            ast_element = ast_element->sibling;
          }
          state = 10;
        }
        else
        {
          state = 999;
        }
      break;
      case 10:
        if (ast_element->statement_type == _left_curly_brace)
        {
          state = 20;
        }
        else
        {
          if ((ast_element->statement_type == _declare)  ||
              (ast_element->statement_type == _if)       ||
              (ast_element->statement_type == _print)    ||
              (ast_element->statement_type == _set))
          {
            curly_brace_difference = ast_element->num_left_curly_braces - ast_element->num_right_curly_braces; 
            if (if_statement_curly_brace_difference == curly_brace_difference)
            {
              found = TRUE;
            }
          }
        }
      break;
      case 20:
        if (ast_element->statement_type == _right_curly_brace)
        {
          curly_brace_difference = ast_element->num_left_curly_braces - ast_element->num_right_curly_braces;
          if (if_statement_curly_brace_difference == curly_brace_difference)
          {
            state = 30;
          }
        }
      break;
      case 30:
// ****************************************************************************************************************
// * This is a sanity check to ensure the next statement after the RIGHT CURLY BRACE is not an ELSE statement.    *
// * Minimally, it must be either another statement or a RIGHT CURLY BRACE for the end of a function declaration. *
// ****************************************************************************************************************
        if (ast_element->statement_type != _else)
        {
          found = TRUE;
        }
        else
        {
          //printf ("Unexpected ELSE statement found. Setting state to 99999\n");
          state = 999;
        }
      break;
      default:
      break;
    }
    if (state != 999)
    {
      if (!found)
      {
        if (ast_element->sibling != NULL)
        {
          ast_element = ast_element->sibling;
        }
        else
        {
          ast_element = ast_element->child;
        }
      }
    }
  }
  //printf ("Leaving find_next_statement_after_if_then_statement.\n");
  return ast_element;
}




ast_node * find_next_statement_after_if_then_else_statement (ast_node *abstract_syntax_tree)
{
  unsigned long long int if_statement_curly_brace_difference, else_statement_curly_brace_difference, curly_brace_difference;
  asmblr_node *assembler_element;
  ast_node *ast_element;
  int state;
  char found;

  state = 0;
  found = FALSE;
  if_statement_curly_brace_difference = 0;
  else_statement_curly_brace_difference = 0;
  curly_brace_difference = 0;
  ast_element = abstract_syntax_tree;
  while ((ast_element != NULL) && (!found))
  {
    switch (state)
    {
      case 0:
        if (ast_element->statement_type == _if)
        {
          if_statement_curly_brace_difference = ast_element->num_left_curly_braces - ast_element->num_right_curly_braces;
// *****************************************************
// * Now advance to next statement after IF statement. *
// *****************************************************
          while (ast_element->sibling != NULL)
          {
            ast_element = ast_element->sibling;
          }
          state = 10;
        }
        else
        {
          state = 99999;
        }
      break;
      case 10:
        if (ast_element->statement_type == _else)
        {
          else_statement_curly_brace_difference = ast_element->num_left_curly_braces - ast_element->num_right_curly_braces;
          if (if_statement_curly_brace_difference == else_statement_curly_brace_difference)
          {
            state = 20;
          }
        }
      break;
      case 20:
        if (ast_element->statement_type == _left_curly_brace)
        {
          state = 30;
        }
        else
        {
          if ((ast_element->statement_type == _declare) ||
              (ast_element->statement_type == _if)      ||
              (ast_element->statement_type == _print)   ||
              (ast_element->statement_type == _set))
          {
            curly_brace_difference = ast_element->num_left_curly_braces - ast_element->num_right_curly_braces;
            if (if_statement_curly_brace_difference == curly_brace_difference)
            {
              state = 40;
            }
          }
          else
          {
            state = 99999;
          }
        }
      break;
      case 30:
        if (ast_element->statement_type == _right_curly_brace)
        {
          curly_brace_difference = ast_element->num_left_curly_braces - ast_element->num_right_curly_braces;
          if (if_statement_curly_brace_difference == curly_brace_difference)
          {
            state = 40;
          }
        }
      break;
      case 40:
        if ((ast_element->statement_type == _declare)           ||
            (ast_element->statement_type == _if)                ||
            (ast_element->statement_type == _print)             ||
            (ast_element->statement_type == _right_curly_brace) ||
            (ast_element->statement_type == _set))
        { 
          found = TRUE;
        }
        else
        {
          state = 99999;
        }
      break;
      default:
      break;
    }
    if (!found)
    {
      if (ast_element->sibling != NULL)
      {
        ast_element = ast_element->sibling;
      }
      else
      {
        ast_element = ast_element->child;
      }
    }
  }
  return ast_element;
}




// ********************************************************************************************************************
// * find_closing_curly_brace_of_if_then_statement_block_for_if_then_else_statement                                   *
// *                                                                                                                  *
// * This subroutine finds the end (closing curly brace) of an IF-THEN statement block for an IF-THEN-ELSE statement. *
// * This functionality is necessary to create an assembler x86 JUMP command once the IF-THEN portion of a statement  *
// * block is executed (which skips over the ELSE statement block in x86 assembler).                                  *
// ********************************************************************************************************************
ast_node * find_closing_curly_brace_of_if_then_statement_block_for_if_then_else_statement (ast_node *abstract_syntax_tree)
{
  unsigned long long int if_statement_curly_brace_difference, else_statement_curly_brace_difference, curly_brace_difference;
  ast_node *ast_element, *end_of_if_then_statement_block_ast_element;
  int state;
  char found;

  //printf ("Entering find_closing_curly_brace_of_if_then_statement_block_for_if_then_else_statement\n");
  ast_element = NULL;
  state = 0;
  found = FALSE;
  if_statement_curly_brace_difference = 0;
  else_statement_curly_brace_difference = 0;
  curly_brace_difference = 0;
  ast_element = abstract_syntax_tree;
  end_of_if_then_statement_block_ast_element = NULL;
  while ((ast_element != NULL) && (!found))
  {
    //printf ("state = %d: token = %s\n", state, ast_element->token);
    switch (state)
    {
      case 0:
        if (abstract_syntax_tree->statement_type == _if)
        {
          if_statement_curly_brace_difference = abstract_syntax_tree->num_left_curly_braces - abstract_syntax_tree->num_right_curly_braces;
// *****************************************************
// * Now advance to next statement after IF statement. *
// *****************************************************
          while (ast_element->sibling != NULL)
          {
            ast_element = ast_element->sibling;
          }
          state = 10;
        }
        else
        {
          state = 99999;
        }
      break;
      case 10:
        if (ast_element->statement_type == _left_curly_brace)
        {
          state = 20;
        }
        else
        {
          state = 99999;
        }
      break;
      case 20:
        if (ast_element->statement_type == _right_curly_brace)
        {
          curly_brace_difference = ast_element->num_left_curly_braces - ast_element->num_right_curly_braces;
          if (if_statement_curly_brace_difference == curly_brace_difference)
          {
            end_of_if_then_statement_block_ast_element = ast_element;
            state = 30;
          }
        }
      break;
      case 30:
// ***********************************************************************************
// * This is a sanity check to ensure the next statement after the RIGHT CURLY BRACE *
// * of the IF-THEN statement block is an ELSE statement.                            *
// ***********************************************************************************
        if (ast_element->statement_type == _else)
        {
          found = TRUE;
        }
        else
        {
          end_of_if_then_statement_block_ast_element = NULL;
          state = 99999;
        }
      break;
      default:
        end_of_if_then_statement_block_ast_element = NULL;
      break;
    }
    if (!found)
    {
      if (ast_element->sibling != NULL)
      {
        ast_element = ast_element->sibling;
      }
      else
      {
        ast_element = ast_element->child;
      }
    }
  }
  //printf ("Leaving find_closing_curly_brace_of_if_then_statement_block_for_if_then_else_statement\n");
  return end_of_if_then_statement_block_ast_element;
}




ast_node * find_next_statement_after_while_statement (ast_node *abstract_syntax_tree)
{
  unsigned long long int while_statement_curly_brace_difference, curly_brace_difference;
  asmblr_node *assembler_element;
  ast_node *ast_element;
  int state;
  char found;

  state = 0;
  found = FALSE;
  while_statement_curly_brace_difference = 0;
  curly_brace_difference = 0;
  ast_element = abstract_syntax_tree;
  while ((ast_element != NULL) && (!found))
  {
    switch (state)
    {
      case 0:
        if (ast_element->statement_type == _while)
        {
          while_statement_curly_brace_difference = ast_element->num_left_curly_braces - ast_element->num_right_curly_braces;
// *******************************************U************
// * Now advance to next statement after WHILE statement. *
// ********************************************************
          while (ast_element->sibling != NULL)
          {
            ast_element = ast_element->sibling;
          }
          state = 10;
        }
        else
        {
          state = 99999;
        }
      break;
      case 10:
        if (ast_element->statement_type == _left_curly_brace)
        {
          state = 20;
        }
      break;
      case 20:
        if (ast_element->statement_type == _right_curly_brace)
        {
          curly_brace_difference = ast_element->num_left_curly_braces - ast_element->num_right_curly_braces;
          if (while_statement_curly_brace_difference == curly_brace_difference)
          {
            state = 40;
          }
        }
      break;
      case 40:
        if ((ast_element->statement_type == _declare)           ||
            (ast_element->statement_type == _if)                ||
            (ast_element->statement_type == _print)             ||
            (ast_element->statement_type == _right_curly_brace) ||
            (ast_element->statement_type == _set)               ||
            (ast_element->statement_type == _while))
        { 
          found = TRUE;
        }
        else
        {
          state = 99999;
        }
      break;
      default:
      break;
    }
    if (!found)
    {
      if (ast_element->sibling != NULL)
      {
        ast_element = ast_element->sibling;
      }
      else
      {
        ast_element = ast_element->child;
      }
    }
  }
  return ast_element;
}




ast_node * find_closing_curly_brace_of_while_statement_block (ast_node *abstract_syntax_tree)
{
  unsigned long long int while_statement_curly_brace_difference, curly_brace_difference;
  asmblr_node *assembler_element;
  ast_node *ast_element;
  int state;
  char found;

  state = 0;
  found = FALSE;
  while_statement_curly_brace_difference = 0;
  curly_brace_difference = 0;
  ast_element = abstract_syntax_tree;
  while ((ast_element != NULL) && (!found))
  {
    switch (state)
    {
      case 0:
        if (ast_element->statement_type == _while)
        {
          while_statement_curly_brace_difference = ast_element->num_left_curly_braces - ast_element->num_right_curly_braces;
// *******************************************U************
// * Now advance to next statement after WHILE statement. *
// ********************************************************
          while (ast_element->sibling != NULL)
          {
            ast_element = ast_element->sibling;
          }
          state = 10;
        }
        else
        {
          state = 99999;
        }
      break;
      case 10:
        if (ast_element->statement_type == _left_curly_brace)
        {
          state = 20;
        }
      break;
      case 20:
        if (ast_element->statement_type == _right_curly_brace)
        {
          curly_brace_difference = ast_element->num_left_curly_braces - ast_element->num_right_curly_braces;
          if (while_statement_curly_brace_difference == curly_brace_difference)
          {
            found = TRUE;
          }
        }
      break;
      default:
      break;
    }
    if (!found)
    {
      if (ast_element->sibling != NULL)
      {
        ast_element = ast_element->sibling;
      }
      else
      {
        ast_element = ast_element->child;
      }
    }
  }
  return ast_element;
}




// ************************************************************************************************************************************
// * determine_stackframe_storage_size_for_all_locally_defined_variables_in_main                                                      *
// *                                                                                                                                  *
// * This function counts the storage size requirements (in bytes) for all the locally-defined variables (except argc/arc) in main.   *
// * We must perform this task to determine how much storage space on the stack frame is required to store main variables. The amount *
// * of storage space is first computed. Next, I determine how much stack space is required on increments of 16 bytes storage space.  *
// *                                                                                                                                  *
// * If the computed storage space is 24 bytes, I would then return 32 bytes for the stack since the stack must be on 16-byte         *
// * increments. 32 bytes of storage will obviously hold 24 bytes that are required.                                                  *
// ************************************************************************************************************************************
size_t determine_stackframe_storage_size_for_all_locally_defined_variables_in_main (stackframe_node *stackframe_cross_reference_table, symtab_node *symbol_table)
{
  stackframe_node *stackframe_element;
  symtab_node *symbol_table_element;
  size_t total_stackframe_storage_size_required_for_locally_defined_variables, storage_space_for_all_locally_defined_variables_in_bytes;
  unsigned long long int scope_level_for_main;
  int found;

  storage_space_for_all_locally_defined_variables_in_bytes = 0; 
  total_stackframe_storage_size_required_for_locally_defined_variables = 0;
// *********************************************************************************************
// * Retrieve the scope_level for the main function declaration. This is necessary so that we  *
// * can determine what variables are declared under main. We don't know what scope_level main *
// * is associated with.                                                                       *
// *********************************************************************************************
  found = FALSE;
  symbol_table_element = symbol_table;
  while ((symbol_table_element != NULL) && (!found))
  {
    if (symbol_table_element->identifier != NULL)
    {
      if (strncmp(symbol_table_element->identifier, "main", 4) == 0)
      {
        if ((symbol_table_element->attribute_type == _function) || (symbol_table_element->attribute_type == _procedure))
        {
          scope_level_for_main = symbol_table_element->scope_level;
          found = TRUE;
        }
      }
      if (!found)
      {
        symbol_table_element = symbol_table_element->next;
      }
    }
  }
  if (found)
  {
    stackframe_element = stackframe_cross_reference_table;
    while (stackframe_element != NULL)
    {
      symbol_table_element = stackframe_element->symbol_table_entry;
      if (symbol_table_element != NULL)
      {
        if (symbol_table_element->scope_level == scope_level_for_main)
        {
          if (symbol_table_element->attribute_type == _datatype)
          {
            if (symbol_table_element->identifier != NULL)
            {
              if (strncmp(symbol_table_element->identifier, "argc", 4) != 0) // avoid the argc element since it does not require stack frame storage ever.
              {
                storage_space_for_all_locally_defined_variables_in_bytes = storage_space_for_all_locally_defined_variables_in_bytes + stackframe_element->storage_size_in_bytes;
              }
            }
          }
        }
      }
      stackframe_element = stackframe_element->next;
    }
  }
  if (storage_space_for_all_locally_defined_variables_in_bytes > 0)
  {
    if ((storage_space_for_all_locally_defined_variables_in_bytes % 16) == 0)
    {
      total_stackframe_storage_size_required_for_locally_defined_variables = storage_space_for_all_locally_defined_variables_in_bytes;
    }
    else
    {
      total_stackframe_storage_size_required_for_locally_defined_variables = (storage_space_for_all_locally_defined_variables_in_bytes / 16) * 16 + 16;
    }
  }
// *************************************************************
// * Add an addition protective layer beyond what is required. *
// *************************************************************
  total_stackframe_storage_size_required_for_locally_defined_variables = total_stackframe_storage_size_required_for_locally_defined_variables + 16;
  return total_stackframe_storage_size_required_for_locally_defined_variables;
}




// **************************************************************************************************************************************
// * determine_stackframe_storage_size_for_all_locally_defined_variables_based_on_scope_level                                           *
// *                                                                                                                                    *
// * This function counts the storage size requirements (in bytes) for all the locally-defined variables in a procedure or function. We *
// * must perform this task to determine how much storage space on the stack frame is required to store main variables. The amount of   *
// * storage space is first computed. Next, I determine how much stack space is required on increments of 16 bytes storage space.       *
// *                                                                                                                                    *
// * If the computed storage space is 24 bytes, I would then return 32 bytes for the stack since the stack must be on 16-byte           *
// * increments. 32 bytes of storage will obviously hold 24 bytes that are required.                                                    *
// *                                                                                                                                    *
// * NOTE: A special version of this function is called:                                                                                *
// *                                                                                                                                    *
// *       determine_stackframe_storage_size_for_all_locally_defined_variables_in_main()                                                *
// *                                                                                                                                    *
// *       That function has nearly identical functionality with one key exception: for main function I do not allocate stack space for *
//         argv and argc since those are passed in from the operating system and do not need local stack space.                         *
// **************************************************************************************************************************************
size_t determine_stackframe_storage_size_for_all_locally_defined_variables_based_on_scope_level (stackframe_node *stackframe_cross_reference_table, symtab_node *symbol_table, unsigned long long int scope_level)
{
  stackframe_node *stackframe_element;
  symtab_node *symbol_table_element;
  size_t total_stackframe_storage_size_required_for_locally_defined_variables, storage_space_for_all_locally_defined_variables_in_bytes;
  int found;

  storage_space_for_all_locally_defined_variables_in_bytes = 0; 
  total_stackframe_storage_size_required_for_locally_defined_variables = 0;
  stackframe_element = stackframe_cross_reference_table;
  while (stackframe_element != NULL)
  {
    symbol_table_element = stackframe_element->symbol_table_entry;
    if (symbol_table_element != NULL)
    {
      if (symbol_table_element->scope_level == scope_level)
      {
        if (symbol_table_element->attribute_type == _datatype)
        {
          storage_space_for_all_locally_defined_variables_in_bytes = storage_space_for_all_locally_defined_variables_in_bytes + stackframe_element->storage_size_in_bytes;
        }
      }
    }
    stackframe_element = stackframe_element->next;
  }
  if (storage_space_for_all_locally_defined_variables_in_bytes > 0)
  {
    if ((storage_space_for_all_locally_defined_variables_in_bytes % 16) == 0)
    {
      total_stackframe_storage_size_required_for_locally_defined_variables = storage_space_for_all_locally_defined_variables_in_bytes;
    }
    else
    {
      total_stackframe_storage_size_required_for_locally_defined_variables = (storage_space_for_all_locally_defined_variables_in_bytes / 16) * 16 + 16;
    }
  }
// *************************************************************
// * Add an addition protective layer beyond what is required. *
// *************************************************************
  total_stackframe_storage_size_required_for_locally_defined_variables = total_stackframe_storage_size_required_for_locally_defined_variables + 16;
  return total_stackframe_storage_size_required_for_locally_defined_variables;
}




// ********************************************************************************************************************************
// * escape_quotes_inside_text                                                                                                    *
// *                                                                                                                              *
// * This subroutine replaces all double quotes for input text. Failing to escape double quotes will cause the assembler to fail. *
// *                                                                                                                              *
// * EXAMPLES:                                                                                                                    *
// *                                                                                                                              *
// * INPUT:   This is some "quoted text"                                                                                          *
// * OUTPUT:  This is some \"quoted text\"                                                                                        *
// *                                                                                                                              *
// * INPUT:   This is some \"escaped \" quoted text while this "quoted text" is not escaped.                                      *
// * OUTPUT:  This is some \"escaped \" quoted text while this \"quoted text\" is not escaped.                                    *
// ********************************************************************************************************************************
char * escape_double_quotes_inside_text (char *input_text)
{
  char byte, *escaped_text;
  size_t input_text_length, escaped_text_length, i, j;
  int state;

  escaped_text = NULL;
  if (input_text != NULL)
  {
    input_text_length = strlen (input_text); 
    escaped_text_length = 0;
    i = 0;
    state = 0;
    while (i < input_text_length)
    {
      switch (state)
      {
        case 0:
          if (input_text[i] == '\\')
          {
            escaped_text_length++;
            state = 1;
          }
          else
          {
            if (input_text[i] == '"')
            {
              escaped_text_length = escaped_text_length + 2; // each non-escaped quote requiries the following two bytes: \"
            }
            else
            {
              escaped_text_length++;
            }
          }
        break;
        case 1:
          escaped_text_length++;
          state = 0; // skip over this byte because it was escaped by previous byte.
        break; 
      }
      i++;
    }
    if (escaped_text_length > 0)
    {
      escaped_text = (char *) malloc(sizeof(char)*(escaped_text_length + 1)); // add one for NULL terminator.
      if (escaped_text != NULL)
      {
        memset (escaped_text, 0, escaped_text_length + 1); // Clear the buffer and NULL-terminate it.
        i = 0;
        j = 0;
        state = 0;
        while (i < input_text_length)
        {
          switch (state)
          {
            case 0:
              if (input_text[i] == '\\')
              {
                if (j < escaped_text_length)
                {
                  escaped_text[j] = '\\';
                  j++;
                }
                state = 1;
              }
              else
              {
                if (input_text[i] == '"')
                {
                  if (j < escaped_text_length)
                  {
                    escaped_text[j] = '\\';
                    j++;
                  }
                  if (j < escaped_text_length)
                  {
                    escaped_text[j] = '"';
                    j++;
                  }
                }
                else
                {
                  if (j < escaped_text_length)
                  {
                    escaped_text[j] = input_text[i];
                    j++;
                  }
                }
              }
            break;
            case 1:
              if (j < escaped_text_length)
              {
                escaped_text[j] = input_text[i]; // copy over this byte because it was escaped by previous byte.
                j++;
              }
              state = 0;
            break; 
          }
          i++;
        }
      }
    }
  }
  return escaped_text;
}

