#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include "d_ir.h"


#line 1184 "/usr/src/ports/cocom/cocom-0.996-2.i686/src/cocom-0.996/DINO/d_ir.sprut"

#include "d_common.h"
#include "d_built.h"

/* All internal representation storage is implemented by object stack.  See
   package `object-stack'. */

os_t irp;

IR_node_t temp_unique_ident;
IR_node_t temp_unique_int;
IR_node_t temp_unique_float;
IR_node_t temp_unique_char;
IR_node_t temp_unique_string;
IR_node_t temp_ident;
IR_node_t temp_decl;
IR_node_t temp_var_occurrence;
IR_node_t destroy_unique_ident;



#line 30 "d_ir.c"
#ifndef IR_START_ALLOC
#define IR_START_ALLOC()
#endif

#ifndef IR_STOP_ALLOC
#define IR_STOP_ALLOC()
#endif

#ifndef IR_ALLOC
#define IR_ALLOC(ptr, size, ptr_type) ((ptr) = (ptr_type) malloc (size))
#endif

#ifndef IR_FREE
#define IR_FREE(ptr, size) free (ptr)
#endif

#ifndef IR_BEGIN_IR_node_t
#define IR_BEGIN_IR_node_t(a) memset (&(a), 0, sizeof (a))
#endif

#ifndef IR_END_IR_node_t
#define IR_END_IR_node_t(a)
#endif

#ifndef IR_COPY_IR_node_t
#define IR_COPY_IR_node_t(a, b) ((a) = (b))
#endif

#ifndef IR_EQUAL_IR_node_t
#define IR_EQUAL_IR_node_t(a, b) ((a) == (b))
#endif

#ifndef IR_PRINT_IR_node_t
#define IR_PRINT_IR_node_t(a) printf ("%lx", (unsigned long) (a))
#endif

#ifndef IR_INPUT_IR_node_t
#define IR_INPUT_IR_node_t(file, field) (fread (&(field), sizeof (field), 1, (file)) != sizeof (field))
#endif

#ifndef IR_OUTPUT_IR_node_t
#define IR_OUTPUT_IR_node_t(file, field) (fwrite (&(field), sizeof (field), 1, (file)) != sizeof (field))
#endif

#ifndef IR_BEGIN_char_t
#define IR_BEGIN_char_t(a) memset (&(a), 0, sizeof (a))
#endif

#ifndef IR_END_char_t
#define IR_END_char_t(a)
#endif

#ifndef IR_COPY_char_t
#define IR_COPY_char_t(a, b) ((a) = (b))
#endif

#ifndef IR_EQUAL_char_t
#define IR_EQUAL_char_t(a, b) ((a) == (b))
#endif

#ifndef IR_PRINT_char_t
#define IR_PRINT_char_t(a)
#endif

#ifndef IR_INPUT_char_t
#define IR_INPUT_char_t(file, field) (fread (&(field), sizeof (field), 1, (file)) != sizeof (field))
#endif

#ifndef IR_OUTPUT_char_t
#define IR_OUTPUT_char_t(file, field) (fwrite (&(field), sizeof (field), 1, (file)) != sizeof (field))
#endif

#ifndef IR_BEGIN_int_t
#define IR_BEGIN_int_t(a) memset (&(a), 0, sizeof (a))
#endif

#ifndef IR_END_int_t
#define IR_END_int_t(a)
#endif

#ifndef IR_COPY_int_t
#define IR_COPY_int_t(a, b) ((a) = (b))
#endif

#ifndef IR_EQUAL_int_t
#define IR_EQUAL_int_t(a, b) ((a) == (b))
#endif

#ifndef IR_PRINT_int_t
#define IR_PRINT_int_t(a)
#endif

#ifndef IR_INPUT_int_t
#define IR_INPUT_int_t(file, field) (fread (&(field), sizeof (field), 1, (file)) != sizeof (field))
#endif

#ifndef IR_OUTPUT_int_t
#define IR_OUTPUT_int_t(file, field) (fwrite (&(field), sizeof (field), 1, (file)) != sizeof (field))
#endif

#ifndef IR_BEGIN_floating_t
#define IR_BEGIN_floating_t(a) memset (&(a), 0, sizeof (a))
#endif

#ifndef IR_END_floating_t
#define IR_END_floating_t(a)
#endif

#ifndef IR_COPY_floating_t
#define IR_COPY_floating_t(a, b) ((a) = (b))
#endif

#ifndef IR_EQUAL_floating_t
#define IR_EQUAL_floating_t(a, b) ((a) == (b))
#endif

#ifndef IR_PRINT_floating_t
#define IR_PRINT_floating_t(a)
#endif

#ifndef IR_INPUT_floating_t
#define IR_INPUT_floating_t(file, field) (fread (&(field), sizeof (field), 1, (file)) != sizeof (field))
#endif

#ifndef IR_OUTPUT_floating_t
#define IR_OUTPUT_floating_t(file, field) (fwrite (&(field), sizeof (field), 1, (file)) != sizeof (field))
#endif

#ifndef IR_BEGIN_string_t
#define IR_BEGIN_string_t(a) memset (&(a), 0, sizeof (a))
#endif

#ifndef IR_END_string_t
#define IR_END_string_t(a)
#endif

#ifndef IR_COPY_string_t
#define IR_COPY_string_t(a, b) ((a) = (b))
#endif

#ifndef IR_EQUAL_string_t
#define IR_EQUAL_string_t(a, b) ((a) == (b))
#endif

#ifndef IR_PRINT_string_t
#define IR_PRINT_string_t(a)
#endif

#ifndef IR_INPUT_string_t
#define IR_INPUT_string_t(file, field) (fread (&(field), sizeof (field), 1, (file)) != sizeof (field))
#endif

#ifndef IR_OUTPUT_string_t
#define IR_OUTPUT_string_t(file, field) (fwrite (&(field), sizeof (field), 1, (file)) != sizeof (field))
#endif

#ifndef IR_BEGIN_integer_t
#define IR_BEGIN_integer_t(a) memset (&(a), 0, sizeof (a))
#endif

#ifndef IR_END_integer_t
#define IR_END_integer_t(a)
#endif

#ifndef IR_COPY_integer_t
#define IR_COPY_integer_t(a, b) ((a) = (b))
#endif

#ifndef IR_EQUAL_integer_t
#define IR_EQUAL_integer_t(a, b) ((a) == (b))
#endif

#ifndef IR_PRINT_integer_t
#define IR_PRINT_integer_t(a)
#endif

#ifndef IR_INPUT_integer_t
#define IR_INPUT_integer_t(file, field) (fread (&(field), sizeof (field), 1, (file)) != sizeof (field))
#endif

#ifndef IR_OUTPUT_integer_t
#define IR_OUTPUT_integer_t(file, field) (fwrite (&(field), sizeof (field), 1, (file)) != sizeof (field))
#endif

#ifndef IR_BEGIN_bool_t
#define IR_BEGIN_bool_t(a) memset (&(a), 0, sizeof (a))
#endif

#ifndef IR_END_bool_t
#define IR_END_bool_t(a)
#endif

#ifndef IR_COPY_bool_t
#define IR_COPY_bool_t(a, b) ((a) = (b))
#endif

#ifndef IR_EQUAL_bool_t
#define IR_EQUAL_bool_t(a, b) ((a) == (b))
#endif

#ifndef IR_PRINT_bool_t
#define IR_PRINT_bool_t(a)
#endif

#ifndef IR_INPUT_bool_t
#define IR_INPUT_bool_t(file, field) (fread (&(field), sizeof (field), 1, (file)) != sizeof (field))
#endif

#ifndef IR_OUTPUT_bool_t
#define IR_OUTPUT_bool_t(file, field) (fwrite (&(field), sizeof (field), 1, (file)) != sizeof (field))
#endif

#ifndef IR_BEGIN_position_t
#define IR_BEGIN_position_t(a) memset (&(a), 0, sizeof (a))
#endif

#ifndef IR_END_position_t
#define IR_END_position_t(a)
#endif

#ifndef IR_COPY_position_t
#define IR_COPY_position_t(a, b) ((a) = (b))
#endif

#ifndef IR_EQUAL_position_t
#define IR_EQUAL_position_t(a, b) ((a) == (b))
#endif

#ifndef IR_PRINT_position_t
#define IR_PRINT_position_t(a)
#endif

#ifndef IR_INPUT_position_t
#define IR_INPUT_position_t(file, field) (fread (&(field), sizeof (field), 1, (file)) != sizeof (field))
#endif

#ifndef IR_OUTPUT_position_t
#define IR_OUTPUT_position_t(file, field) (fwrite (&(field), sizeof (field), 1, (file)) != sizeof (field))
#endif

#ifndef IR_BEGIN_type_mask_t
#define IR_BEGIN_type_mask_t(a) memset (&(a), 0, sizeof (a))
#endif

#ifndef IR_END_type_mask_t
#define IR_END_type_mask_t(a)
#endif

#ifndef IR_COPY_type_mask_t
#define IR_COPY_type_mask_t(a, b) ((a) = (b))
#endif

#ifndef IR_EQUAL_type_mask_t
#define IR_EQUAL_type_mask_t(a, b) ((a) == (b))
#endif

#ifndef IR_PRINT_type_mask_t
#define IR_PRINT_type_mask_t(a)
#endif

#ifndef IR_INPUT_type_mask_t
#define IR_INPUT_type_mask_t(file, field) (fread (&(field), sizeof (field), 1, (file)) != sizeof (field))
#endif

#ifndef IR_OUTPUT_type_mask_t
#define IR_OUTPUT_type_mask_t(file, field) (fwrite (&(field), sizeof (field), 1, (file)) != sizeof (field))
#endif

#ifndef IR_BEGIN_implementation_func_t
#define IR_BEGIN_implementation_func_t(a) memset (&(a), 0, sizeof (a))
#endif

#ifndef IR_END_implementation_func_t
#define IR_END_implementation_func_t(a)
#endif

#ifndef IR_COPY_implementation_func_t
#define IR_COPY_implementation_func_t(a, b) ((a) = (b))
#endif

#ifndef IR_EQUAL_implementation_func_t
#define IR_EQUAL_implementation_func_t(a, b) ((a) == (b))
#endif

#ifndef IR_PRINT_implementation_func_t
#define IR_PRINT_implementation_func_t(a)
#endif

#ifndef IR_INPUT_implementation_func_t
#define IR_INPUT_implementation_func_t(file, field) (fread (&(field), sizeof (field), 1, (file)) != sizeof (field))
#endif

#ifndef IR_OUTPUT_implementation_func_t
#define IR_OUTPUT_implementation_func_t(file, field) (fwrite (&(field), sizeof (field), 1, (file)) != sizeof (field))
#endif

#ifndef IR_BEGIN_ticker_t
#define IR_BEGIN_ticker_t(a) memset (&(a), 0, sizeof (a))
#endif

#ifndef IR_END_ticker_t
#define IR_END_ticker_t(a)
#endif

#ifndef IR_COPY_ticker_t
#define IR_COPY_ticker_t(a, b) ((a) = (b))
#endif

#ifndef IR_EQUAL_ticker_t
#define IR_EQUAL_ticker_t(a, b) ((a) == (b))
#endif

#ifndef IR_PRINT_ticker_t
#define IR_PRINT_ticker_t(a)
#endif

#ifndef IR_INPUT_ticker_t
#define IR_INPUT_ticker_t(file, field) (fread (&(field), sizeof (field), 1, (file)) != sizeof (field))
#endif

#ifndef IR_OUTPUT_ticker_t
#define IR_OUTPUT_ticker_t(file, field) (fwrite (&(field), sizeof (field), 1, (file)) != sizeof (field))
#endif

short _IR_node_level [] =
{
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0
};

unsigned char _IR_SF_ir_node [] =
{255, 239, 255, 255, 255, 255, 255, 191, 255, 255, 255, 255, 255, 255, 255, 255, 255, 127, 255, 255, 
  31
};

unsigned char _IR_SF_unique_char [] =
{2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_generic_pos [] =
{172, 234, 255, 255, 255, 255, 255, 191, 255, 255, 239, 255, 255, 255, 255, 255, 255, 63, 255, 255, 
  31
};

unsigned char _IR_SF_char [] =
{8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_unique_int [] =
{16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_int [] =
{32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_unique_float [] =
{64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_float [] =
{128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_unique_string [] =
{0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_string [] =
{0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_unique_ident [] =
{0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_ident [] =
{0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_expr [] =
{168, 250, 255, 255, 255, 255, 255, 191, 255, 255, 11, 0, 0, 0, 0, 128, 255, 32, 14, 28, 
  0
};

unsigned char _IR_SF_operation [] =
{0, 224, 255, 255, 255, 255, 255, 63, 0, 0, 0, 0, 0, 0, 0, 128, 255, 0, 0, 0, 
  0
};

unsigned char _IR_SF_binary_operation [] =
{0, 64, 255, 255, 255, 31, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 255, 0, 0, 0, 
  0
};

unsigned char _IR_SF_unary_operation [] =
{0, 128, 0, 0, 0, 224, 255, 63, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_in [] =
{0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_or [] =
{0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_xor [] =
{0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_and [] =
{0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_eq [] =
{0, 0, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_ne [] =
{0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_identity [] =
{0, 0, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_unidentity [] =
{0, 0, 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_lt [] =
{0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_gt [] =
{0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_le [] =
{0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_ge [] =
{0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_lshift [] =
{0, 0, 0, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_rshift [] =
{0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_ashift [] =
{0, 0, 0, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_concat [] =
{0, 0, 0, 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_plus [] =
{0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_minus [] =
{0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_mult [] =
{0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_div [] =
{0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_mod [] =
{0, 0, 0, 0, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_index [] =
{0, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_key_index [] =
{0, 0, 0, 0, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_member_access [] =
{0, 0, 0, 0, 128, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_period [] =
{0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_logical_binary_operation [] =
{0, 0, 0, 0, 0, 14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_logical_or [] =
{0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_logical_and [] =
{0, 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_cond [] =
{0, 0, 0, 0, 0, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_const [] =
{0, 0, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_new [] =
{0, 0, 0, 0, 0, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_not [] =
{0, 0, 0, 0, 0, 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_unary_plus [] =
{0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_unary_minus [] =
{0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_bitwise_not [] =
{0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_length [] =
{0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_typeof [] =
{0, 0, 0, 0, 0, 0, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_charof [] =
{0, 0, 0, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_intof [] =
{0, 0, 0, 0, 0, 0, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_floatof [] =
{0, 0, 0, 0, 0, 0, 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_vectorof [] =
{0, 0, 0, 0, 0, 0, 0, 33, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_tableof [] =
{0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_funcof [] =
{0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_threadof [] =
{0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_classof [] =
{0, 0, 0, 0, 0, 0, 0, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_format_vectorof [] =
{0, 0, 0, 0, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_designator [] =
{0, 8, 255, 255, 127, 1, 0, 64, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 240, 3, 
  0
};

unsigned char _IR_SF_type [] =
{0, 0, 0, 0, 0, 0, 0, 128, 255, 127, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_nil_type [] =
{0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_hide_type [] =
{0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_hideblock_type [] =
{0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_char_type [] =
{0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_int_type [] =
{0, 0, 0, 0, 0, 0, 0, 0, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_float_type [] =
{0, 0, 0, 0, 0, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_vector_type [] =
{0, 0, 0, 0, 0, 0, 0, 0, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_table_type [] =
{0, 0, 0, 0, 0, 0, 0, 0, 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_func_type [] =
{0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_thread_type [] =
{0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_class_type [] =
{0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_stack_type [] =
{0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_process_type [] =
{0, 0, 0, 0, 0, 0, 0, 0, 0, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_instance_type [] =
{0, 0, 0, 0, 0, 0, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_type_type [] =
{0, 0, 0, 0, 0, 0, 0, 0, 0, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_vector_table [] =
{0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_vector [] =
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_table [] =
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_elist_element [] =
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_class_func_thread_call [] =
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_access_ident [] =
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_stmt [] =
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 224, 255, 255, 255, 247, 127, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_assign_stmt [] =
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 192, 255, 63, 0, 0, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_assign [] =
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_mult_assign [] =
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_div_assign [] =
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_rem_assign [] =
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_plus_assign [] =
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_minus_assign [] =
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 16, 0, 0, 0, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_concat_assign [] =
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_lshift_assign [] =
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 64, 0, 0, 0, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_rshift_assign [] =
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 0, 0, 0, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_ashift_assign [] =
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_and_assign [] =
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_xor_assign [] =
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_or_assign [] =
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_var_assign [] =
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 16, 0, 0, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_par_assign [] =
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_swap [] =
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 64, 0, 0, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_procedure_call [] =
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 0, 0, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_if_stmt [] =
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_for_stmt [] =
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_foreach_stmt [] =
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_for_break_contintue [] =
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 56, 0, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_break_stmt [] =
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 16, 0, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_continue_stmt [] =
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_return_without_result [] =
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 64, 0, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_return_with_result [] =
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 0, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_throw [] =
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_wait_stmt [] =
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_block [] =
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_exception [] =
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_decl [] =
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 240, 127, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_may_be_const_decl [] =
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 224, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_var [] =
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 64, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_external_var [] =
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 0, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_pub [] =
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_external_func [] =
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_func_class_ext [] =
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 124, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_func_or_class [] =
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 56, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_func [] =
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 16, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_class [] =
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 32, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_ext [] =
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 64, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_no_testing_period [] =
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 0, 0, 0, 0, 
  0
};

unsigned char _IR_SF_lvalue_period [] =
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 
  0
};

unsigned char _IR_SF_lvalue_period_and_val [] =
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 
  0
};

unsigned char _IR_SF_lvalue_index [] =
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 
  0
};

unsigned char _IR_SF_lvalue_index_and_val [] =
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 
  0
};

unsigned char _IR_SF_lvalue_key_index [] =
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 16, 0, 0, 0, 
  0
};

unsigned char _IR_SF_lvalue_key_index_and_val [] =
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 32, 0, 0, 0, 
  0
};

unsigned char _IR_SF_lvalue_no_testing_period [] =
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 64, 0, 0, 0, 
  0
};

unsigned char _IR_SF_lvalue_no_testing_period_and_val [] =
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 0, 0, 0, 
  0
};

unsigned char _IR_SF_logical_or_end [] =
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 
  0
};

unsigned char _IR_SF_logical_and_end [] =
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 
  0
};

unsigned char _IR_SF_cond_end [] =
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 
  0
};

unsigned char _IR_SF_par_assign_end [] =
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 
  0
};

unsigned char _IR_SF_par_assign_test [] =
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 16, 0, 0, 
  0
};

unsigned char _IR_SF_nil [] =
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 32, 0, 0, 
  0
};

unsigned char _IR_SF_friend [] =
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 64, 0, 0, 
  0
};

unsigned char _IR_SF_decl_in_block [] =
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 192, 58, 0, 128, 0, 0, 
  0
};

unsigned char _IR_SF_occurrence [] =
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 31, 
  0
};

unsigned char _IR_SF_external_var_occurrence [] =
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 
  0
};

unsigned char _IR_SF_local_var_occurrence [] =
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 
  0
};

unsigned char _IR_SF_var_occurrence [] =
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 
  0
};

unsigned char _IR_SF_lvalue_external_var_occurrence [] =
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 16, 0, 
  0
};

unsigned char _IR_SF_lvalue_external_var_occurrence_and_val [] =
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 32, 0, 
  0
};

unsigned char _IR_SF_local_lvalue_var_occurrence [] =
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 64, 0, 
  0
};

unsigned char _IR_SF_local_lvalue_var_occurrence_and_val [] =
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 0, 
  0
};

unsigned char _IR_SF_lvalue_var_occurrence [] =
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 
  0
};

unsigned char _IR_SF_lvalue_var_occurrence_and_val [] =
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 
  0
};

unsigned char _IR_SF_external_func_occurrence [] =
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 
  0
};

unsigned char _IR_SF_func_occurrence [] =
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 
  0
};

unsigned char _IR_SF_class_occurrence [] =
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 16, 
  0
};

unsigned char _IR_SF_if_finish [] =
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 32, 
  0
};

unsigned char _IR_SF_for_finish [] =
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 64, 
  0
};

unsigned char _IR_SF_wait_finish [] =
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 
  0
};

unsigned char _IR_SF_foreach_start [] =
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  1
};

unsigned char _IR_SF_foreach_next_iteration [] =
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  2
};

unsigned char _IR_SF_block_finish [] =
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  4
};

unsigned char _IR_SF_catches_finish [] =
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  8
};

unsigned char _IR_SF_pop_func_call [] =
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  16
};

unsigned char _IR_SF_external [] =
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 58, 0, 0, 0, 0, 
  32
};

unsigned char _IR_SF__root [] =
{255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 
  255
};

unsigned char _IR_SF__error [] =
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  128
};

unsigned char *_IR_is_type[] =
{
_IR_SF_ir_node,
_IR_SF_unique_char,
_IR_SF_generic_pos,
_IR_SF_char,
_IR_SF_unique_int,
_IR_SF_int,
_IR_SF_unique_float,
_IR_SF_float,
_IR_SF_unique_string,
_IR_SF_string,
_IR_SF_unique_ident,
_IR_SF_ident,
_IR_SF_expr,
_IR_SF_operation,
_IR_SF_binary_operation,
_IR_SF_unary_operation,
_IR_SF_in,
_IR_SF_or,
_IR_SF_xor,
_IR_SF_and,
_IR_SF_eq,
_IR_SF_ne,
_IR_SF_identity,
_IR_SF_unidentity,
_IR_SF_lt,
_IR_SF_gt,
_IR_SF_le,
_IR_SF_ge,
_IR_SF_lshift,
_IR_SF_rshift,
_IR_SF_ashift,
_IR_SF_concat,
_IR_SF_plus,
_IR_SF_minus,
_IR_SF_mult,
_IR_SF_div,
_IR_SF_mod,
_IR_SF_index,
_IR_SF_key_index,
_IR_SF_member_access,
_IR_SF_period,
_IR_SF_logical_binary_operation,
_IR_SF_logical_or,
_IR_SF_logical_and,
_IR_SF_cond,
_IR_SF_const,
_IR_SF_new,
_IR_SF_not,
_IR_SF_unary_plus,
_IR_SF_unary_minus,
_IR_SF_bitwise_not,
_IR_SF_length,
_IR_SF_typeof,
_IR_SF_charof,
_IR_SF_intof,
_IR_SF_floatof,
_IR_SF_vectorof,
_IR_SF_tableof,
_IR_SF_funcof,
_IR_SF_threadof,
_IR_SF_classof,
_IR_SF_format_vectorof,
_IR_SF_designator,
_IR_SF_type,
_IR_SF_nil_type,
_IR_SF_hide_type,
_IR_SF_hideblock_type,
_IR_SF_char_type,
_IR_SF_int_type,
_IR_SF_float_type,
_IR_SF_vector_type,
_IR_SF_table_type,
_IR_SF_func_type,
_IR_SF_thread_type,
_IR_SF_class_type,
_IR_SF_stack_type,
_IR_SF_process_type,
_IR_SF_instance_type,
_IR_SF_type_type,
_IR_SF_vector_table,
_IR_SF_vector,
_IR_SF_table,
_IR_SF_elist_element,
_IR_SF_class_func_thread_call,
_IR_SF_access_ident,
_IR_SF_stmt,
_IR_SF_assign_stmt,
_IR_SF_assign,
_IR_SF_mult_assign,
_IR_SF_div_assign,
_IR_SF_rem_assign,
_IR_SF_plus_assign,
_IR_SF_minus_assign,
_IR_SF_concat_assign,
_IR_SF_lshift_assign,
_IR_SF_rshift_assign,
_IR_SF_ashift_assign,
_IR_SF_and_assign,
_IR_SF_xor_assign,
_IR_SF_or_assign,
_IR_SF_var_assign,
_IR_SF_par_assign,
_IR_SF_swap,
_IR_SF_procedure_call,
_IR_SF_if_stmt,
_IR_SF_for_stmt,
_IR_SF_foreach_stmt,
_IR_SF_for_break_contintue,
_IR_SF_break_stmt,
_IR_SF_continue_stmt,
_IR_SF_return_without_result,
_IR_SF_return_with_result,
_IR_SF_throw,
_IR_SF_wait_stmt,
_IR_SF_block,
_IR_SF_exception,
_IR_SF_decl,
_IR_SF_may_be_const_decl,
_IR_SF_var,
_IR_SF_external_var,
_IR_SF_pub,
_IR_SF_external_func,
_IR_SF_func_class_ext,
_IR_SF_func_or_class,
_IR_SF_func,
_IR_SF_class,
_IR_SF_ext,
_IR_SF_no_testing_period,
_IR_SF_lvalue_period,
_IR_SF_lvalue_period_and_val,
_IR_SF_lvalue_index,
_IR_SF_lvalue_index_and_val,
_IR_SF_lvalue_key_index,
_IR_SF_lvalue_key_index_and_val,
_IR_SF_lvalue_no_testing_period,
_IR_SF_lvalue_no_testing_period_and_val,
_IR_SF_logical_or_end,
_IR_SF_logical_and_end,
_IR_SF_cond_end,
_IR_SF_par_assign_end,
_IR_SF_par_assign_test,
_IR_SF_nil,
_IR_SF_friend,
_IR_SF_decl_in_block,
_IR_SF_occurrence,
_IR_SF_external_var_occurrence,
_IR_SF_local_var_occurrence,
_IR_SF_var_occurrence,
_IR_SF_lvalue_external_var_occurrence,
_IR_SF_lvalue_external_var_occurrence_and_val,
_IR_SF_local_lvalue_var_occurrence,
_IR_SF_local_lvalue_var_occurrence_and_val,
_IR_SF_lvalue_var_occurrence,
_IR_SF_lvalue_var_occurrence_and_val,
_IR_SF_external_func_occurrence,
_IR_SF_func_occurrence,
_IR_SF_class_occurrence,
_IR_SF_if_finish,
_IR_SF_for_finish,
_IR_SF_wait_finish,
_IR_SF_foreach_start,
_IR_SF_foreach_next_iteration,
_IR_SF_block_finish,
_IR_SF_catches_finish,
_IR_SF_pop_func_call,
_IR_SF_external,
_IR_SF__root,
_IR_SF__error
};

unsigned char _IR_D_ident [] =
{
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0, 
  _IR_offsetof (_IR_access_ident, _IR_S_access_ident)
    + _IR_offsetof (struct _IR_S_access_ident, ident), 
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  _IR_offsetof (_IR_decl, _IR_S_decl)
    + _IR_offsetof (struct _IR_S_decl, ident), 
  _IR_offsetof (_IR_may_be_const_decl, _IR_S_may_be_const_decl)
    + _IR_offsetof (struct _IR_S_may_be_const_decl, _IR_M_decl)
    + _IR_offsetof (struct _IR_S_decl, ident), 
  _IR_offsetof (_IR_var, _IR_S_var)
    + _IR_offsetof (struct _IR_S_var, _IR_M_may_be_const_decl)
    + _IR_offsetof (struct _IR_S_may_be_const_decl, _IR_M_decl)
    + _IR_offsetof (struct _IR_S_decl, ident), 
  _IR_offsetof (_IR_external_var, _IR_S_external_var)
    + _IR_offsetof (struct _IR_S_external_var, _IR_M_may_be_const_decl)
    + _IR_offsetof (struct _IR_S_may_be_const_decl, _IR_M_decl)
    + _IR_offsetof (struct _IR_S_decl, ident), 
  _IR_offsetof (_IR_pub, _IR_S_pub)
    + _IR_offsetof (struct _IR_S_pub, _IR_M_decl)
    + _IR_offsetof (struct _IR_S_decl, ident), 
  _IR_offsetof (_IR_external_func, _IR_S_external_func)
    + _IR_offsetof (struct _IR_S_external_func, _IR_M_decl)
    + _IR_offsetof (struct _IR_S_decl, ident), 
  _IR_offsetof (_IR_func_class_ext, _IR_S_func_class_ext)
    + _IR_offsetof (struct _IR_S_func_class_ext, _IR_M_decl)
    + _IR_offsetof (struct _IR_S_decl, ident), 
  _IR_offsetof (_IR_func_or_class, _IR_S_func_or_class)
    + _IR_offsetof (struct _IR_S_func_or_class, _IR_M_func_class_ext)
    + _IR_offsetof (struct _IR_S_func_class_ext, _IR_M_decl)
    + _IR_offsetof (struct _IR_S_decl, ident), 
  _IR_offsetof (_IR_func, _IR_S_func)
    + _IR_offsetof (struct _IR_S_func, _IR_M_func_or_class)
    + _IR_offsetof (struct _IR_S_func_or_class, _IR_M_func_class_ext)
    + _IR_offsetof (struct _IR_S_func_class_ext, _IR_M_decl)
    + _IR_offsetof (struct _IR_S_decl, ident), 
  _IR_offsetof (_IR_class, _IR_S_class)
    + _IR_offsetof (struct _IR_S_class, _IR_M_func_or_class)
    + _IR_offsetof (struct _IR_S_func_or_class, _IR_M_func_class_ext)
    + _IR_offsetof (struct _IR_S_func_class_ext, _IR_M_decl)
    + _IR_offsetof (struct _IR_S_decl, ident), 
  _IR_offsetof (_IR_ext, _IR_S_ext)
    + _IR_offsetof (struct _IR_S_ext, _IR_M_func_class_ext)
    + _IR_offsetof (struct _IR_S_func_class_ext, _IR_M_decl)
    + _IR_offsetof (struct _IR_S_decl, ident), 
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
};

unsigned char _IR_D_catch_list_pc [] =
{
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  _IR_offsetof (_IR_block, _IR_S_block)
    + _IR_offsetof (struct _IR_S_block, catch_list_pc), 
  _IR_offsetof (_IR_exception, _IR_S_exception)
    + _IR_offsetof (struct _IR_S_exception, catch_list_pc), 
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0
};

unsigned char _IR_D_no [] =
{
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  _IR_offsetof (_IR_external_func, _IR_S_external_func)
    + _IR_offsetof (struct _IR_S_external_func, no), 
  0, 
  _IR_offsetof (_IR_func_or_class, _IR_S_func_or_class)
    + _IR_offsetof (struct _IR_S_func_or_class, no), 
  _IR_offsetof (_IR_func, _IR_S_func)
    + _IR_offsetof (struct _IR_S_func, _IR_M_func_or_class)
    + _IR_offsetof (struct _IR_S_func_or_class, no), 
  _IR_offsetof (_IR_class, _IR_S_class)
    + _IR_offsetof (struct _IR_S_class, _IR_M_func_or_class)
    + _IR_offsetof (struct _IR_S_func_or_class, no), 
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
};

unsigned char _IR_D_decl_number_in_block [] =
{
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  _IR_offsetof (_IR_var, _IR_S_var)
    + _IR_offsetof (struct _IR_S_var, _IR_M_decl_in_block)
    + _IR_offsetof (struct _IR_S_decl_in_block, decl_number_in_block), 
  _IR_offsetof (_IR_external_var, _IR_S_external_var)
    + _IR_offsetof (struct _IR_S_external_var, _IR_M_decl_in_block)
    + _IR_offsetof (struct _IR_S_decl_in_block, decl_number_in_block), 
  0, 
  _IR_offsetof (_IR_external_func, _IR_S_external_func)
    + _IR_offsetof (struct _IR_S_external_func, _IR_M_decl_in_block)
    + _IR_offsetof (struct _IR_S_decl_in_block, decl_number_in_block), 
  0, 
  _IR_offsetof (_IR_func_or_class, _IR_S_func_or_class)
    + _IR_offsetof (struct _IR_S_func_or_class, _IR_M_decl_in_block)
    + _IR_offsetof (struct _IR_S_decl_in_block, decl_number_in_block), 
  _IR_offsetof (_IR_func, _IR_S_func)
    + _IR_offsetof (struct _IR_S_func, _IR_M_func_or_class)
    + _IR_offsetof (struct _IR_S_func_or_class, _IR_M_decl_in_block)
    + _IR_offsetof (struct _IR_S_decl_in_block, decl_number_in_block), 
  _IR_offsetof (_IR_class, _IR_S_class)
    + _IR_offsetof (struct _IR_S_class, _IR_M_func_or_class)
    + _IR_offsetof (struct _IR_S_func_or_class, _IR_M_decl_in_block)
    + _IR_offsetof (struct _IR_S_decl_in_block, decl_number_in_block), 
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  _IR_offsetof (_IR_decl_in_block, _IR_S_decl_in_block)
    + _IR_offsetof (struct _IR_S_decl_in_block, decl_number_in_block), 
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0, 0, 0
};

unsigned char _IR_D_address [] =
{
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  _IR_offsetof (_IR_external_var, _IR_S_external_var)
    + _IR_offsetof (struct _IR_S_external_var, _IR_M_external)
    + _IR_offsetof (struct _IR_S_external, address), 
  0, 
  _IR_offsetof (_IR_external_func, _IR_S_external_func)
    + _IR_offsetof (struct _IR_S_external_func, _IR_M_external)
    + _IR_offsetof (struct _IR_S_external, address), 
  0, 
  _IR_offsetof (_IR_func_or_class, _IR_S_func_or_class)
    + _IR_offsetof (struct _IR_S_func_or_class, _IR_M_external)
    + _IR_offsetof (struct _IR_S_external, address), 
  _IR_offsetof (_IR_func, _IR_S_func)
    + _IR_offsetof (struct _IR_S_func, _IR_M_func_or_class)
    + _IR_offsetof (struct _IR_S_func_or_class, _IR_M_external)
    + _IR_offsetof (struct _IR_S_external, address), 
  _IR_offsetof (_IR_class, _IR_S_class)
    + _IR_offsetof (struct _IR_S_class, _IR_M_func_or_class)
    + _IR_offsetof (struct _IR_S_func_or_class, _IR_M_external)
    + _IR_offsetof (struct _IR_S_external, address), 
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  _IR_offsetof (_IR_external, _IR_S_external)
    + _IR_offsetof (struct _IR_S_external, address), 
  0, 0
};

void *_IR_class_structure_array [] =
{
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
};

char *IR_node_name[] =
{
  "ir_node",
  "unique_char",
  "generic_pos",
  "char",
  "unique_int",
  "int",
  "unique_float",
  "float",
  "unique_string",
  "string",
  "unique_ident",
  "ident",
  "expr",
  "operation",
  "binary_operation",
  "unary_operation",
  "in",
  "or",
  "xor",
  "and",
  "eq",
  "ne",
  "identity",
  "unidentity",
  "lt",
  "gt",
  "le",
  "ge",
  "lshift",
  "rshift",
  "ashift",
  "concat",
  "plus",
  "minus",
  "mult",
  "div",
  "mod",
  "index",
  "key_index",
  "member_access",
  "period",
  "logical_binary_operation",
  "logical_or",
  "logical_and",
  "cond",
  "const",
  "new",
  "not",
  "unary_plus",
  "unary_minus",
  "bitwise_not",
  "length",
  "typeof",
  "charof",
  "intof",
  "floatof",
  "vectorof",
  "tableof",
  "funcof",
  "threadof",
  "classof",
  "format_vectorof",
  "designator",
  "type",
  "nil_type",
  "hide_type",
  "hideblock_type",
  "char_type",
  "int_type",
  "float_type",
  "vector_type",
  "table_type",
  "func_type",
  "thread_type",
  "class_type",
  "stack_type",
  "process_type",
  "instance_type",
  "type_type",
  "vector_table",
  "vector",
  "table",
  "elist_element",
  "class_func_thread_call",
  "access_ident",
  "stmt",
  "assign_stmt",
  "assign",
  "mult_assign",
  "div_assign",
  "rem_assign",
  "plus_assign",
  "minus_assign",
  "concat_assign",
  "lshift_assign",
  "rshift_assign",
  "ashift_assign",
  "and_assign",
  "xor_assign",
  "or_assign",
  "var_assign",
  "par_assign",
  "swap",
  "procedure_call",
  "if_stmt",
  "for_stmt",
  "foreach_stmt",
  "for_break_contintue",
  "break_stmt",
  "continue_stmt",
  "return_without_result",
  "return_with_result",
  "throw",
  "wait_stmt",
  "block",
  "exception",
  "decl",
  "may_be_const_decl",
  "var",
  "external_var",
  "pub",
  "external_func",
  "func_class_ext",
  "func_or_class",
  "func",
  "class",
  "ext",
  "no_testing_period",
  "lvalue_period",
  "lvalue_period_and_val",
  "lvalue_index",
  "lvalue_index_and_val",
  "lvalue_key_index",
  "lvalue_key_index_and_val",
  "lvalue_no_testing_period",
  "lvalue_no_testing_period_and_val",
  "logical_or_end",
  "logical_and_end",
  "cond_end",
  "par_assign_end",
  "par_assign_test",
  "nil",
  "friend",
  "decl_in_block",
  "occurrence",
  "external_var_occurrence",
  "local_var_occurrence",
  "var_occurrence",
  "lvalue_external_var_occurrence",
  "lvalue_external_var_occurrence_and_val",
  "local_lvalue_var_occurrence",
  "local_lvalue_var_occurrence_and_val",
  "lvalue_var_occurrence",
  "lvalue_var_occurrence_and_val",
  "external_func_occurrence",
  "func_occurrence",
  "class_occurrence",
  "if_finish",
  "for_finish",
  "wait_finish",
  "foreach_start",
  "foreach_next_iteration",
  "block_finish",
  "catches_finish",
  "pop_func_call",
  "external",
  "%root",
  "%error"
};

unsigned char IR_node_size[] =
{
  sizeof (_IR_ir_node),
  sizeof (_IR_unique_char),
  sizeof (_IR_generic_pos),
  sizeof (_IR_char),
  sizeof (_IR_unique_int),
  sizeof (_IR_int),
  sizeof (_IR_unique_float),
  sizeof (_IR_float),
  sizeof (_IR_unique_string),
  sizeof (_IR_string),
  sizeof (_IR_unique_ident),
  sizeof (_IR_ident),
  sizeof (_IR_expr),
  sizeof (_IR_operation),
  sizeof (_IR_binary_operation),
  sizeof (_IR_unary_operation),
  sizeof (_IR_in),
  sizeof (_IR_or),
  sizeof (_IR_xor),
  sizeof (_IR_and),
  sizeof (_IR_eq),
  sizeof (_IR_ne),
  sizeof (_IR_identity),
  sizeof (_IR_unidentity),
  sizeof (_IR_lt),
  sizeof (_IR_gt),
  sizeof (_IR_le),
  sizeof (_IR_ge),
  sizeof (_IR_lshift),
  sizeof (_IR_rshift),
  sizeof (_IR_ashift),
  sizeof (_IR_concat),
  sizeof (_IR_plus),
  sizeof (_IR_minus),
  sizeof (_IR_mult),
  sizeof (_IR_div),
  sizeof (_IR_mod),
  sizeof (_IR_index),
  sizeof (_IR_key_index),
  sizeof (_IR_member_access),
  sizeof (_IR_period),
  sizeof (_IR_logical_binary_operation),
  sizeof (_IR_logical_or),
  sizeof (_IR_logical_and),
  sizeof (_IR_cond),
  sizeof (_IR_const),
  sizeof (_IR_new),
  sizeof (_IR_not),
  sizeof (_IR_unary_plus),
  sizeof (_IR_unary_minus),
  sizeof (_IR_bitwise_not),
  sizeof (_IR_length),
  sizeof (_IR_typeof),
  sizeof (_IR_charof),
  sizeof (_IR_intof),
  sizeof (_IR_floatof),
  sizeof (_IR_vectorof),
  sizeof (_IR_tableof),
  sizeof (_IR_funcof),
  sizeof (_IR_threadof),
  sizeof (_IR_classof),
  sizeof (_IR_format_vectorof),
  sizeof (_IR_designator),
  sizeof (_IR_type),
  sizeof (_IR_nil_type),
  sizeof (_IR_hide_type),
  sizeof (_IR_hideblock_type),
  sizeof (_IR_char_type),
  sizeof (_IR_int_type),
  sizeof (_IR_float_type),
  sizeof (_IR_vector_type),
  sizeof (_IR_table_type),
  sizeof (_IR_func_type),
  sizeof (_IR_thread_type),
  sizeof (_IR_class_type),
  sizeof (_IR_stack_type),
  sizeof (_IR_process_type),
  sizeof (_IR_instance_type),
  sizeof (_IR_type_type),
  sizeof (_IR_vector_table),
  sizeof (_IR_vector),
  sizeof (_IR_table),
  sizeof (_IR_elist_element),
  sizeof (_IR_class_func_thread_call),
  sizeof (_IR_access_ident),
  sizeof (_IR_stmt),
  sizeof (_IR_assign_stmt),
  sizeof (_IR_assign),
  sizeof (_IR_mult_assign),
  sizeof (_IR_div_assign),
  sizeof (_IR_rem_assign),
  sizeof (_IR_plus_assign),
  sizeof (_IR_minus_assign),
  sizeof (_IR_concat_assign),
  sizeof (_IR_lshift_assign),
  sizeof (_IR_rshift_assign),
  sizeof (_IR_ashift_assign),
  sizeof (_IR_and_assign),
  sizeof (_IR_xor_assign),
  sizeof (_IR_or_assign),
  sizeof (_IR_var_assign),
  sizeof (_IR_par_assign),
  sizeof (_IR_swap),
  sizeof (_IR_procedure_call),
  sizeof (_IR_if_stmt),
  sizeof (_IR_for_stmt),
  sizeof (_IR_foreach_stmt),
  sizeof (_IR_for_break_contintue),
  sizeof (_IR_break_stmt),
  sizeof (_IR_continue_stmt),
  sizeof (_IR_return_without_result),
  sizeof (_IR_return_with_result),
  sizeof (_IR_throw),
  sizeof (_IR_wait_stmt),
  sizeof (_IR_block),
  sizeof (_IR_exception),
  sizeof (_IR_decl),
  sizeof (_IR_may_be_const_decl),
  sizeof (_IR_var),
  sizeof (_IR_external_var),
  sizeof (_IR_pub),
  sizeof (_IR_external_func),
  sizeof (_IR_func_class_ext),
  sizeof (_IR_func_or_class),
  sizeof (_IR_func),
  sizeof (_IR_class),
  sizeof (_IR_ext),
  sizeof (_IR_no_testing_period),
  sizeof (_IR_lvalue_period),
  sizeof (_IR_lvalue_period_and_val),
  sizeof (_IR_lvalue_index),
  sizeof (_IR_lvalue_index_and_val),
  sizeof (_IR_lvalue_key_index),
  sizeof (_IR_lvalue_key_index_and_val),
  sizeof (_IR_lvalue_no_testing_period),
  sizeof (_IR_lvalue_no_testing_period_and_val),
  sizeof (_IR_logical_or_end),
  sizeof (_IR_logical_and_end),
  sizeof (_IR_cond_end),
  sizeof (_IR_par_assign_end),
  sizeof (_IR_par_assign_test),
  sizeof (_IR_nil),
  sizeof (_IR_friend),
  sizeof (_IR_decl_in_block),
  sizeof (_IR_occurrence),
  sizeof (_IR_external_var_occurrence),
  sizeof (_IR_local_var_occurrence),
  sizeof (_IR_var_occurrence),
  sizeof (_IR_lvalue_external_var_occurrence),
  sizeof (_IR_lvalue_external_var_occurrence_and_val),
  sizeof (_IR_local_lvalue_var_occurrence),
  sizeof (_IR_local_lvalue_var_occurrence_and_val),
  sizeof (_IR_lvalue_var_occurrence),
  sizeof (_IR_lvalue_var_occurrence_and_val),
  sizeof (_IR_external_func_occurrence),
  sizeof (_IR_func_occurrence),
  sizeof (_IR_class_occurrence),
  sizeof (_IR_if_finish),
  sizeof (_IR_for_finish),
  sizeof (_IR_wait_finish),
  sizeof (_IR_foreach_start),
  sizeof (_IR_foreach_next_iteration),
  sizeof (_IR_block_finish),
  sizeof (_IR_catches_finish),
  sizeof (_IR_pop_func_call),
  sizeof (_IR_external),
  sizeof (_IR__root),
  sizeof (_IR__error)
};

static int (* _IR_traverse_guard_function_variable) (IR_node_t node);

static int _IR_current_graph_pass_number;

void _IR_set_double_field_value
  (IR_double_link_t link, IR_node_t value, int disp, int flag)
{
}

IR_double_link_t IR__first_double_link (IR_node_t node)
{
  return NULL;
}

void IR__set_double_link (IR_double_link_t link, IR_node_t value)
{
#ifdef __IR_DEBUG__
  if (link == NULL)
    abort ();
#endif /* __IR_DEBUG__ */
  (*link->set_function) (link->link_owner, value);
}

static void _IR_node_field_initiation (IR_node_mode_t node_mode, IR_node_t node)
{
  switch (node_mode)
    {
    case IR_NM_ir_node:
      IR_BEGIN_IR_node_t ((((_IR_ir_node *) node)->_IR_S_ir_node.next_pc));
      break;
    case IR_NM_unique_char:
      _IR_node_field_initiation (IR_NM_ir_node, (IR_node_t) ((char *) &((_IR_unique_char *) node)->_IR_S_unique_char._IR_M_ir_node - _IR_offsetof (_IR_ir_node, _IR_S_ir_node)));
      IR_BEGIN_char_t ((((_IR_unique_char *) node)->_IR_S_unique_char.char_value));
      break;
    case IR_NM_generic_pos:
      _IR_node_field_initiation (IR_NM_ir_node, (IR_node_t) ((char *) &((_IR_generic_pos *) node)->_IR_S_generic_pos._IR_M_ir_node - _IR_offsetof (_IR_ir_node, _IR_S_ir_node)));
      IR_BEGIN_position_t ((((_IR_generic_pos *) node)->_IR_S_generic_pos.pos));
      break;
    case IR_NM_char:
      _IR_node_field_initiation (IR_NM_generic_pos, (IR_node_t) ((char *) &((_IR_char *) node)->_IR_S_char._IR_M_generic_pos - _IR_offsetof (_IR_generic_pos, _IR_S_generic_pos)));
      IR_BEGIN_IR_node_t ((((_IR_char *) node)->_IR_S_char.unique_char));
      IR_BEGIN_char_t ((((_IR_char *) node)->_IR_S_char.ch_val));
      break;
    case IR_NM_unique_int:
      _IR_node_field_initiation (IR_NM_ir_node, (IR_node_t) ((char *) &((_IR_unique_int *) node)->_IR_S_unique_int._IR_M_ir_node - _IR_offsetof (_IR_ir_node, _IR_S_ir_node)));
      IR_BEGIN_int_t ((((_IR_unique_int *) node)->_IR_S_unique_int.int_value));
      break;
    case IR_NM_int:
      _IR_node_field_initiation (IR_NM_generic_pos, (IR_node_t) ((char *) &((_IR_int *) node)->_IR_S_int._IR_M_generic_pos - _IR_offsetof (_IR_generic_pos, _IR_S_generic_pos)));
      IR_BEGIN_IR_node_t ((((_IR_int *) node)->_IR_S_int.unique_int));
      IR_BEGIN_int_t ((((_IR_int *) node)->_IR_S_int.i_val));
      break;
    case IR_NM_unique_float:
      _IR_node_field_initiation (IR_NM_ir_node, (IR_node_t) ((char *) &((_IR_unique_float *) node)->_IR_S_unique_float._IR_M_ir_node - _IR_offsetof (_IR_ir_node, _IR_S_ir_node)));
      IR_BEGIN_floating_t ((((_IR_unique_float *) node)->_IR_S_unique_float.float_value));
      break;
    case IR_NM_float:
      _IR_node_field_initiation (IR_NM_generic_pos, (IR_node_t) ((char *) &((_IR_float *) node)->_IR_S_float._IR_M_generic_pos - _IR_offsetof (_IR_generic_pos, _IR_S_generic_pos)));
      IR_BEGIN_IR_node_t ((((_IR_float *) node)->_IR_S_float.unique_float));
      IR_BEGIN_floating_t ((((_IR_float *) node)->_IR_S_float.f_val));
      break;
    case IR_NM_unique_string:
      _IR_node_field_initiation (IR_NM_ir_node, (IR_node_t) ((char *) &((_IR_unique_string *) node)->_IR_S_unique_string._IR_M_ir_node - _IR_offsetof (_IR_ir_node, _IR_S_ir_node)));
      IR_BEGIN_string_t ((((_IR_unique_string *) node)->_IR_S_unique_string.string_value));
      break;
    case IR_NM_string:
      _IR_node_field_initiation (IR_NM_generic_pos, (IR_node_t) ((char *) &((_IR_string *) node)->_IR_S_string._IR_M_generic_pos - _IR_offsetof (_IR_generic_pos, _IR_S_generic_pos)));
      IR_BEGIN_IR_node_t ((((_IR_string *) node)->_IR_S_string.unique_string));
      IR_BEGIN_string_t ((((_IR_string *) node)->_IR_S_string.str_val));
      break;
    case IR_NM_unique_ident:
      _IR_node_field_initiation (IR_NM_ir_node, (IR_node_t) ((char *) &((_IR_unique_ident *) node)->_IR_S_unique_ident._IR_M_ir_node - _IR_offsetof (_IR_ir_node, _IR_S_ir_node)));
      IR_BEGIN_string_t ((((_IR_unique_ident *) node)->_IR_S_unique_ident.ident_string));
      IR_BEGIN_integer_t ((((_IR_unique_ident *) node)->_IR_S_unique_ident.block_decl_ident_number));
      IR_BEGIN_bool_t ((((_IR_unique_ident *) node)->_IR_S_unique_ident.it_is_declared_in_block));
      break;
    case IR_NM_ident:
      _IR_node_field_initiation (IR_NM_generic_pos, (IR_node_t) ((char *) &((_IR_ident *) node)->_IR_S_ident._IR_M_generic_pos - _IR_offsetof (_IR_generic_pos, _IR_S_generic_pos)));
      IR_BEGIN_IR_node_t ((((_IR_ident *) node)->_IR_S_ident.unique_ident));
      break;
    case IR_NM_expr:
      break;
    case IR_NM_operation:
      _IR_node_field_initiation (IR_NM_generic_pos, (IR_node_t) ((char *) &((_IR_operation *) node)->_IR_S_operation._IR_M_generic_pos - _IR_offsetof (_IR_generic_pos, _IR_S_generic_pos)));
      IR_BEGIN_type_mask_t ((((_IR_operation *) node)->_IR_S_operation.value_type));
      break;
    case IR_NM_binary_operation:
      _IR_node_field_initiation (IR_NM_operation, (IR_node_t) ((char *) &((_IR_binary_operation *) node)->_IR_S_binary_operation._IR_M_operation - _IR_offsetof (_IR_operation, _IR_S_operation)));
      IR_BEGIN_IR_node_t ((((_IR_binary_operation *) node)->_IR_S_binary_operation.left_operand));
      IR_BEGIN_IR_node_t ((((_IR_binary_operation *) node)->_IR_S_binary_operation.right_operand));
      break;
    case IR_NM_unary_operation:
      _IR_node_field_initiation (IR_NM_operation, (IR_node_t) ((char *) &((_IR_unary_operation *) node)->_IR_S_unary_operation._IR_M_operation - _IR_offsetof (_IR_operation, _IR_S_operation)));
      IR_BEGIN_IR_node_t ((((_IR_unary_operation *) node)->_IR_S_unary_operation.operand));
      break;
    case IR_NM_in:
      _IR_node_field_initiation (IR_NM_binary_operation, (IR_node_t) ((char *) &((_IR_in *) node)->_IR_S_in._IR_M_binary_operation - _IR_offsetof (_IR_binary_operation, _IR_S_binary_operation)));
      break;
    case IR_NM_or:
      _IR_node_field_initiation (IR_NM_binary_operation, (IR_node_t) ((char *) &((_IR_or *) node)->_IR_S_or._IR_M_binary_operation - _IR_offsetof (_IR_binary_operation, _IR_S_binary_operation)));
      break;
    case IR_NM_xor:
      _IR_node_field_initiation (IR_NM_binary_operation, (IR_node_t) ((char *) &((_IR_xor *) node)->_IR_S_xor._IR_M_binary_operation - _IR_offsetof (_IR_binary_operation, _IR_S_binary_operation)));
      break;
    case IR_NM_and:
      _IR_node_field_initiation (IR_NM_binary_operation, (IR_node_t) ((char *) &((_IR_and *) node)->_IR_S_and._IR_M_binary_operation - _IR_offsetof (_IR_binary_operation, _IR_S_binary_operation)));
      break;
    case IR_NM_eq:
      _IR_node_field_initiation (IR_NM_binary_operation, (IR_node_t) ((char *) &((_IR_eq *) node)->_IR_S_eq._IR_M_binary_operation - _IR_offsetof (_IR_binary_operation, _IR_S_binary_operation)));
      break;
    case IR_NM_ne:
      _IR_node_field_initiation (IR_NM_binary_operation, (IR_node_t) ((char *) &((_IR_ne *) node)->_IR_S_ne._IR_M_binary_operation - _IR_offsetof (_IR_binary_operation, _IR_S_binary_operation)));
      break;
    case IR_NM_identity:
      _IR_node_field_initiation (IR_NM_binary_operation, (IR_node_t) ((char *) &((_IR_identity *) node)->_IR_S_identity._IR_M_binary_operation - _IR_offsetof (_IR_binary_operation, _IR_S_binary_operation)));
      break;
    case IR_NM_unidentity:
      _IR_node_field_initiation (IR_NM_binary_operation, (IR_node_t) ((char *) &((_IR_unidentity *) node)->_IR_S_unidentity._IR_M_binary_operation - _IR_offsetof (_IR_binary_operation, _IR_S_binary_operation)));
      break;
    case IR_NM_lt:
      _IR_node_field_initiation (IR_NM_binary_operation, (IR_node_t) ((char *) &((_IR_lt *) node)->_IR_S_lt._IR_M_binary_operation - _IR_offsetof (_IR_binary_operation, _IR_S_binary_operation)));
      break;
    case IR_NM_gt:
      _IR_node_field_initiation (IR_NM_binary_operation, (IR_node_t) ((char *) &((_IR_gt *) node)->_IR_S_gt._IR_M_binary_operation - _IR_offsetof (_IR_binary_operation, _IR_S_binary_operation)));
      break;
    case IR_NM_le:
      _IR_node_field_initiation (IR_NM_binary_operation, (IR_node_t) ((char *) &((_IR_le *) node)->_IR_S_le._IR_M_binary_operation - _IR_offsetof (_IR_binary_operation, _IR_S_binary_operation)));
      break;
    case IR_NM_ge:
      _IR_node_field_initiation (IR_NM_binary_operation, (IR_node_t) ((char *) &((_IR_ge *) node)->_IR_S_ge._IR_M_binary_operation - _IR_offsetof (_IR_binary_operation, _IR_S_binary_operation)));
      break;
    case IR_NM_lshift:
      _IR_node_field_initiation (IR_NM_binary_operation, (IR_node_t) ((char *) &((_IR_lshift *) node)->_IR_S_lshift._IR_M_binary_operation - _IR_offsetof (_IR_binary_operation, _IR_S_binary_operation)));
      break;
    case IR_NM_rshift:
      _IR_node_field_initiation (IR_NM_binary_operation, (IR_node_t) ((char *) &((_IR_rshift *) node)->_IR_S_rshift._IR_M_binary_operation - _IR_offsetof (_IR_binary_operation, _IR_S_binary_operation)));
      break;
    case IR_NM_ashift:
      _IR_node_field_initiation (IR_NM_binary_operation, (IR_node_t) ((char *) &((_IR_ashift *) node)->_IR_S_ashift._IR_M_binary_operation - _IR_offsetof (_IR_binary_operation, _IR_S_binary_operation)));
      break;
    case IR_NM_concat:
      _IR_node_field_initiation (IR_NM_binary_operation, (IR_node_t) ((char *) &((_IR_concat *) node)->_IR_S_concat._IR_M_binary_operation - _IR_offsetof (_IR_binary_operation, _IR_S_binary_operation)));
      break;
    case IR_NM_plus:
      _IR_node_field_initiation (IR_NM_binary_operation, (IR_node_t) ((char *) &((_IR_plus *) node)->_IR_S_plus._IR_M_binary_operation - _IR_offsetof (_IR_binary_operation, _IR_S_binary_operation)));
      break;
    case IR_NM_minus:
      _IR_node_field_initiation (IR_NM_binary_operation, (IR_node_t) ((char *) &((_IR_minus *) node)->_IR_S_minus._IR_M_binary_operation - _IR_offsetof (_IR_binary_operation, _IR_S_binary_operation)));
      break;
    case IR_NM_mult:
      _IR_node_field_initiation (IR_NM_binary_operation, (IR_node_t) ((char *) &((_IR_mult *) node)->_IR_S_mult._IR_M_binary_operation - _IR_offsetof (_IR_binary_operation, _IR_S_binary_operation)));
      break;
    case IR_NM_div:
      _IR_node_field_initiation (IR_NM_binary_operation, (IR_node_t) ((char *) &((_IR_div *) node)->_IR_S_div._IR_M_binary_operation - _IR_offsetof (_IR_binary_operation, _IR_S_binary_operation)));
      break;
    case IR_NM_mod:
      _IR_node_field_initiation (IR_NM_binary_operation, (IR_node_t) ((char *) &((_IR_mod *) node)->_IR_S_mod._IR_M_binary_operation - _IR_offsetof (_IR_binary_operation, _IR_S_binary_operation)));
      break;
    case IR_NM_index:
      _IR_node_field_initiation (IR_NM_binary_operation, (IR_node_t) ((char *) &((_IR_index *) node)->_IR_S_index._IR_M_binary_operation - _IR_offsetof (_IR_binary_operation, _IR_S_binary_operation)));
      break;
    case IR_NM_key_index:
      _IR_node_field_initiation (IR_NM_binary_operation, (IR_node_t) ((char *) &((_IR_key_index *) node)->_IR_S_key_index._IR_M_binary_operation - _IR_offsetof (_IR_binary_operation, _IR_S_binary_operation)));
      break;
    case IR_NM_member_access:
      _IR_node_field_initiation (IR_NM_binary_operation, (IR_node_t) ((char *) &((_IR_member_access *) node)->_IR_S_member_access._IR_M_binary_operation - _IR_offsetof (_IR_binary_operation, _IR_S_binary_operation)));
      IR_BEGIN_integer_t ((((_IR_member_access *) node)->_IR_S_member_access.right_block_decl_ident_number));
      break;
    case IR_NM_period:
      _IR_node_field_initiation (IR_NM_member_access, (IR_node_t) ((char *) &((_IR_period *) node)->_IR_S_period._IR_M_member_access - _IR_offsetof (_IR_member_access, _IR_S_member_access)));
      break;
    case IR_NM_logical_binary_operation:
      _IR_node_field_initiation (IR_NM_binary_operation, (IR_node_t) ((char *) &((_IR_logical_binary_operation *) node)->_IR_S_logical_binary_operation._IR_M_binary_operation - _IR_offsetof (_IR_binary_operation, _IR_S_binary_operation)));
      IR_BEGIN_IR_node_t ((((_IR_logical_binary_operation *) node)->_IR_S_logical_binary_operation.short_path_pc));
      break;
    case IR_NM_logical_or:
      _IR_node_field_initiation (IR_NM_logical_binary_operation, (IR_node_t) ((char *) &((_IR_logical_or *) node)->_IR_S_logical_or._IR_M_logical_binary_operation - _IR_offsetof (_IR_logical_binary_operation, _IR_S_logical_binary_operation)));
      break;
    case IR_NM_logical_and:
      _IR_node_field_initiation (IR_NM_logical_binary_operation, (IR_node_t) ((char *) &((_IR_logical_and *) node)->_IR_S_logical_and._IR_M_logical_binary_operation - _IR_offsetof (_IR_logical_binary_operation, _IR_S_logical_binary_operation)));
      break;
    case IR_NM_cond:
      _IR_node_field_initiation (IR_NM_binary_operation, (IR_node_t) ((char *) &((_IR_cond *) node)->_IR_S_cond._IR_M_binary_operation - _IR_offsetof (_IR_binary_operation, _IR_S_binary_operation)));
      IR_BEGIN_IR_node_t ((((_IR_cond *) node)->_IR_S_cond.cond));
      IR_BEGIN_IR_node_t ((((_IR_cond *) node)->_IR_S_cond.false_path_pc));
      break;
    case IR_NM_const:
      _IR_node_field_initiation (IR_NM_unary_operation, (IR_node_t) ((char *) &((_IR_const *) node)->_IR_S_const._IR_M_unary_operation - _IR_offsetof (_IR_unary_operation, _IR_S_unary_operation)));
      break;
    case IR_NM_new:
      _IR_node_field_initiation (IR_NM_unary_operation, (IR_node_t) ((char *) &((_IR_new *) node)->_IR_S_new._IR_M_unary_operation - _IR_offsetof (_IR_unary_operation, _IR_S_unary_operation)));
      break;
    case IR_NM_not:
      _IR_node_field_initiation (IR_NM_unary_operation, (IR_node_t) ((char *) &((_IR_not *) node)->_IR_S_not._IR_M_unary_operation - _IR_offsetof (_IR_unary_operation, _IR_S_unary_operation)));
      break;
    case IR_NM_unary_plus:
      _IR_node_field_initiation (IR_NM_unary_operation, (IR_node_t) ((char *) &((_IR_unary_plus *) node)->_IR_S_unary_plus._IR_M_unary_operation - _IR_offsetof (_IR_unary_operation, _IR_S_unary_operation)));
      break;
    case IR_NM_unary_minus:
      _IR_node_field_initiation (IR_NM_unary_operation, (IR_node_t) ((char *) &((_IR_unary_minus *) node)->_IR_S_unary_minus._IR_M_unary_operation - _IR_offsetof (_IR_unary_operation, _IR_S_unary_operation)));
      break;
    case IR_NM_bitwise_not:
      _IR_node_field_initiation (IR_NM_unary_operation, (IR_node_t) ((char *) &((_IR_bitwise_not *) node)->_IR_S_bitwise_not._IR_M_unary_operation - _IR_offsetof (_IR_unary_operation, _IR_S_unary_operation)));
      break;
    case IR_NM_length:
      _IR_node_field_initiation (IR_NM_unary_operation, (IR_node_t) ((char *) &((_IR_length *) node)->_IR_S_length._IR_M_unary_operation - _IR_offsetof (_IR_unary_operation, _IR_S_unary_operation)));
      break;
    case IR_NM_typeof:
      _IR_node_field_initiation (IR_NM_unary_operation, (IR_node_t) ((char *) &((_IR_typeof *) node)->_IR_S_typeof._IR_M_unary_operation - _IR_offsetof (_IR_unary_operation, _IR_S_unary_operation)));
      break;
    case IR_NM_charof:
      _IR_node_field_initiation (IR_NM_unary_operation, (IR_node_t) ((char *) &((_IR_charof *) node)->_IR_S_charof._IR_M_unary_operation - _IR_offsetof (_IR_unary_operation, _IR_S_unary_operation)));
      break;
    case IR_NM_intof:
      _IR_node_field_initiation (IR_NM_unary_operation, (IR_node_t) ((char *) &((_IR_intof *) node)->_IR_S_intof._IR_M_unary_operation - _IR_offsetof (_IR_unary_operation, _IR_S_unary_operation)));
      break;
    case IR_NM_floatof:
      _IR_node_field_initiation (IR_NM_unary_operation, (IR_node_t) ((char *) &((_IR_floatof *) node)->_IR_S_floatof._IR_M_unary_operation - _IR_offsetof (_IR_unary_operation, _IR_S_unary_operation)));
      break;
    case IR_NM_vectorof:
      _IR_node_field_initiation (IR_NM_unary_operation, (IR_node_t) ((char *) &((_IR_vectorof *) node)->_IR_S_vectorof._IR_M_unary_operation - _IR_offsetof (_IR_unary_operation, _IR_S_unary_operation)));
      break;
    case IR_NM_tableof:
      _IR_node_field_initiation (IR_NM_unary_operation, (IR_node_t) ((char *) &((_IR_tableof *) node)->_IR_S_tableof._IR_M_unary_operation - _IR_offsetof (_IR_unary_operation, _IR_S_unary_operation)));
      break;
    case IR_NM_funcof:
      _IR_node_field_initiation (IR_NM_unary_operation, (IR_node_t) ((char *) &((_IR_funcof *) node)->_IR_S_funcof._IR_M_unary_operation - _IR_offsetof (_IR_unary_operation, _IR_S_unary_operation)));
      break;
    case IR_NM_threadof:
      _IR_node_field_initiation (IR_NM_unary_operation, (IR_node_t) ((char *) &((_IR_threadof *) node)->_IR_S_threadof._IR_M_unary_operation - _IR_offsetof (_IR_unary_operation, _IR_S_unary_operation)));
      break;
    case IR_NM_classof:
      _IR_node_field_initiation (IR_NM_unary_operation, (IR_node_t) ((char *) &((_IR_classof *) node)->_IR_S_classof._IR_M_unary_operation - _IR_offsetof (_IR_unary_operation, _IR_S_unary_operation)));
      break;
    case IR_NM_format_vectorof:
      _IR_node_field_initiation (IR_NM_vectorof, (IR_node_t) ((char *) &((_IR_format_vectorof *) node)->_IR_S_format_vectorof._IR_M_vectorof - _IR_offsetof (_IR_vectorof, _IR_S_vectorof)));
      IR_BEGIN_IR_node_t ((((_IR_format_vectorof *) node)->_IR_S_format_vectorof.format));
      break;
    case IR_NM_designator:
      break;
    case IR_NM_type:
      _IR_node_field_initiation (IR_NM_generic_pos, (IR_node_t) ((char *) &((_IR_type *) node)->_IR_S_type._IR_M_generic_pos - _IR_offsetof (_IR_generic_pos, _IR_S_generic_pos)));
      break;
    case IR_NM_nil_type:
      _IR_node_field_initiation (IR_NM_type, (IR_node_t) ((char *) &((_IR_nil_type *) node)->_IR_S_nil_type._IR_M_type - _IR_offsetof (_IR_type, _IR_S_type)));
      break;
    case IR_NM_hide_type:
      _IR_node_field_initiation (IR_NM_type, (IR_node_t) ((char *) &((_IR_hide_type *) node)->_IR_S_hide_type._IR_M_type - _IR_offsetof (_IR_type, _IR_S_type)));
      break;
    case IR_NM_hideblock_type:
      _IR_node_field_initiation (IR_NM_type, (IR_node_t) ((char *) &((_IR_hideblock_type *) node)->_IR_S_hideblock_type._IR_M_type - _IR_offsetof (_IR_type, _IR_S_type)));
      break;
    case IR_NM_char_type:
      _IR_node_field_initiation (IR_NM_type, (IR_node_t) ((char *) &((_IR_char_type *) node)->_IR_S_char_type._IR_M_type - _IR_offsetof (_IR_type, _IR_S_type)));
      break;
    case IR_NM_int_type:
      _IR_node_field_initiation (IR_NM_type, (IR_node_t) ((char *) &((_IR_int_type *) node)->_IR_S_int_type._IR_M_type - _IR_offsetof (_IR_type, _IR_S_type)));
      break;
    case IR_NM_float_type:
      _IR_node_field_initiation (IR_NM_type, (IR_node_t) ((char *) &((_IR_float_type *) node)->_IR_S_float_type._IR_M_type - _IR_offsetof (_IR_type, _IR_S_type)));
      break;
    case IR_NM_vector_type:
      _IR_node_field_initiation (IR_NM_type, (IR_node_t) ((char *) &((_IR_vector_type *) node)->_IR_S_vector_type._IR_M_type - _IR_offsetof (_IR_type, _IR_S_type)));
      break;
    case IR_NM_table_type:
      _IR_node_field_initiation (IR_NM_type, (IR_node_t) ((char *) &((_IR_table_type *) node)->_IR_S_table_type._IR_M_type - _IR_offsetof (_IR_type, _IR_S_type)));
      break;
    case IR_NM_func_type:
      _IR_node_field_initiation (IR_NM_type, (IR_node_t) ((char *) &((_IR_func_type *) node)->_IR_S_func_type._IR_M_type - _IR_offsetof (_IR_type, _IR_S_type)));
      break;
    case IR_NM_thread_type:
      _IR_node_field_initiation (IR_NM_type, (IR_node_t) ((char *) &((_IR_thread_type *) node)->_IR_S_thread_type._IR_M_type - _IR_offsetof (_IR_type, _IR_S_type)));
      break;
    case IR_NM_class_type:
      _IR_node_field_initiation (IR_NM_type, (IR_node_t) ((char *) &((_IR_class_type *) node)->_IR_S_class_type._IR_M_type - _IR_offsetof (_IR_type, _IR_S_type)));
      break;
    case IR_NM_stack_type:
      _IR_node_field_initiation (IR_NM_type, (IR_node_t) ((char *) &((_IR_stack_type *) node)->_IR_S_stack_type._IR_M_type - _IR_offsetof (_IR_type, _IR_S_type)));
      break;
    case IR_NM_process_type:
      _IR_node_field_initiation (IR_NM_type, (IR_node_t) ((char *) &((_IR_process_type *) node)->_IR_S_process_type._IR_M_type - _IR_offsetof (_IR_type, _IR_S_type)));
      break;
    case IR_NM_instance_type:
      _IR_node_field_initiation (IR_NM_type, (IR_node_t) ((char *) &((_IR_instance_type *) node)->_IR_S_instance_type._IR_M_type - _IR_offsetof (_IR_type, _IR_S_type)));
      break;
    case IR_NM_type_type:
      _IR_node_field_initiation (IR_NM_type, (IR_node_t) ((char *) &((_IR_type_type *) node)->_IR_S_type_type._IR_M_type - _IR_offsetof (_IR_type, _IR_S_type)));
      break;
    case IR_NM_vector_table:
      _IR_node_field_initiation (IR_NM_generic_pos, (IR_node_t) ((char *) &((_IR_vector_table *) node)->_IR_S_vector_table._IR_M_generic_pos - _IR_offsetof (_IR_generic_pos, _IR_S_generic_pos)));
      IR_BEGIN_IR_node_t ((((_IR_vector_table *) node)->_IR_S_vector_table.elist));
      IR_BEGIN_integer_t ((((_IR_vector_table *) node)->_IR_S_vector_table.parts_number));
      break;
    case IR_NM_vector:
      _IR_node_field_initiation (IR_NM_vector_table, (IR_node_t) ((char *) &((_IR_vector *) node)->_IR_S_vector._IR_M_vector_table - _IR_offsetof (_IR_vector_table, _IR_S_vector_table)));
      break;
    case IR_NM_table:
      _IR_node_field_initiation (IR_NM_vector_table, (IR_node_t) ((char *) &((_IR_table *) node)->_IR_S_table._IR_M_vector_table - _IR_offsetof (_IR_vector_table, _IR_S_vector_table)));
      break;
    case IR_NM_elist_element:
      _IR_node_field_initiation (IR_NM_generic_pos, (IR_node_t) ((char *) &((_IR_elist_element *) node)->_IR_S_elist_element._IR_M_generic_pos - _IR_offsetof (_IR_generic_pos, _IR_S_generic_pos)));
      IR_BEGIN_IR_node_t ((((_IR_elist_element *) node)->_IR_S_elist_element.repetition_key));
      IR_BEGIN_IR_node_t ((((_IR_elist_element *) node)->_IR_S_elist_element.expr));
      IR_BEGIN_IR_node_t ((((_IR_elist_element *) node)->_IR_S_elist_element.next_elist));
      break;
    case IR_NM_class_func_thread_call:
      _IR_node_field_initiation (IR_NM_generic_pos, (IR_node_t) ((char *) &((_IR_class_func_thread_call *) node)->_IR_S_class_func_thread_call._IR_M_generic_pos - _IR_offsetof (_IR_generic_pos, _IR_S_generic_pos)));
      IR_BEGIN_IR_node_t ((((_IR_class_func_thread_call *) node)->_IR_S_class_func_thread_call.func_expr));
      IR_BEGIN_IR_node_t ((((_IR_class_func_thread_call *) node)->_IR_S_class_func_thread_call.actuals));
      IR_BEGIN_integer_t ((((_IR_class_func_thread_call *) node)->_IR_S_class_func_thread_call.class_func_thread_call_parameters_number));
      break;
    case IR_NM_access_ident:
      _IR_node_field_initiation (IR_NM_ir_node, (IR_node_t) ((char *) &((_IR_access_ident *) node)->_IR_S_access_ident._IR_M_ir_node - _IR_offsetof (_IR_ir_node, _IR_S_ir_node)));
      IR_BEGIN_IR_node_t ((((_IR_access_ident *) node)->_IR_S_access_ident.ident));
      IR_BEGIN_bool_t ((((_IR_access_ident *) node)->_IR_S_access_ident.access_ident_public_flag));
      IR_BEGIN_bool_t ((((_IR_access_ident *) node)->_IR_S_access_ident.friend_flag));
      IR_BEGIN_IR_node_t ((((_IR_access_ident *) node)->_IR_S_access_ident.next_access_ident));
      break;
    case IR_NM_stmt:
      _IR_node_field_initiation (IR_NM_generic_pos, (IR_node_t) ((char *) &((_IR_stmt *) node)->_IR_S_stmt._IR_M_generic_pos - _IR_offsetof (_IR_generic_pos, _IR_S_generic_pos)));
      IR_BEGIN_IR_node_t ((((_IR_stmt *) node)->_IR_S_stmt.next_stmt));
      break;
    case IR_NM_assign_stmt:
      _IR_node_field_initiation (IR_NM_stmt, (IR_node_t) ((char *) &((_IR_assign_stmt *) node)->_IR_S_assign_stmt._IR_M_stmt - _IR_offsetof (_IR_stmt, _IR_S_stmt)));
      IR_BEGIN_IR_node_t ((((_IR_assign_stmt *) node)->_IR_S_assign_stmt.assignment_var));
      IR_BEGIN_IR_node_t ((((_IR_assign_stmt *) node)->_IR_S_assign_stmt.assignment_expr));
      break;
    case IR_NM_assign:
      _IR_node_field_initiation (IR_NM_assign_stmt, (IR_node_t) ((char *) &((_IR_assign *) node)->_IR_S_assign._IR_M_assign_stmt - _IR_offsetof (_IR_assign_stmt, _IR_S_assign_stmt)));
      break;
    case IR_NM_mult_assign:
      _IR_node_field_initiation (IR_NM_assign_stmt, (IR_node_t) ((char *) &((_IR_mult_assign *) node)->_IR_S_mult_assign._IR_M_assign_stmt - _IR_offsetof (_IR_assign_stmt, _IR_S_assign_stmt)));
      break;
    case IR_NM_div_assign:
      _IR_node_field_initiation (IR_NM_assign_stmt, (IR_node_t) ((char *) &((_IR_div_assign *) node)->_IR_S_div_assign._IR_M_assign_stmt - _IR_offsetof (_IR_assign_stmt, _IR_S_assign_stmt)));
      break;
    case IR_NM_rem_assign:
      _IR_node_field_initiation (IR_NM_assign_stmt, (IR_node_t) ((char *) &((_IR_rem_assign *) node)->_IR_S_rem_assign._IR_M_assign_stmt - _IR_offsetof (_IR_assign_stmt, _IR_S_assign_stmt)));
      break;
    case IR_NM_plus_assign:
      _IR_node_field_initiation (IR_NM_assign_stmt, (IR_node_t) ((char *) &((_IR_plus_assign *) node)->_IR_S_plus_assign._IR_M_assign_stmt - _IR_offsetof (_IR_assign_stmt, _IR_S_assign_stmt)));
      break;
    case IR_NM_minus_assign:
      _IR_node_field_initiation (IR_NM_assign_stmt, (IR_node_t) ((char *) &((_IR_minus_assign *) node)->_IR_S_minus_assign._IR_M_assign_stmt - _IR_offsetof (_IR_assign_stmt, _IR_S_assign_stmt)));
      break;
    case IR_NM_concat_assign:
      _IR_node_field_initiation (IR_NM_assign_stmt, (IR_node_t) ((char *) &((_IR_concat_assign *) node)->_IR_S_concat_assign._IR_M_assign_stmt - _IR_offsetof (_IR_assign_stmt, _IR_S_assign_stmt)));
      break;
    case IR_NM_lshift_assign:
      _IR_node_field_initiation (IR_NM_assign_stmt, (IR_node_t) ((char *) &((_IR_lshift_assign *) node)->_IR_S_lshift_assign._IR_M_assign_stmt - _IR_offsetof (_IR_assign_stmt, _IR_S_assign_stmt)));
      break;
    case IR_NM_rshift_assign:
      _IR_node_field_initiation (IR_NM_assign_stmt, (IR_node_t) ((char *) &((_IR_rshift_assign *) node)->_IR_S_rshift_assign._IR_M_assign_stmt - _IR_offsetof (_IR_assign_stmt, _IR_S_assign_stmt)));
      break;
    case IR_NM_ashift_assign:
      _IR_node_field_initiation (IR_NM_assign_stmt, (IR_node_t) ((char *) &((_IR_ashift_assign *) node)->_IR_S_ashift_assign._IR_M_assign_stmt - _IR_offsetof (_IR_assign_stmt, _IR_S_assign_stmt)));
      break;
    case IR_NM_and_assign:
      _IR_node_field_initiation (IR_NM_assign_stmt, (IR_node_t) ((char *) &((_IR_and_assign *) node)->_IR_S_and_assign._IR_M_assign_stmt - _IR_offsetof (_IR_assign_stmt, _IR_S_assign_stmt)));
      break;
    case IR_NM_xor_assign:
      _IR_node_field_initiation (IR_NM_assign_stmt, (IR_node_t) ((char *) &((_IR_xor_assign *) node)->_IR_S_xor_assign._IR_M_assign_stmt - _IR_offsetof (_IR_assign_stmt, _IR_S_assign_stmt)));
      break;
    case IR_NM_or_assign:
      _IR_node_field_initiation (IR_NM_assign_stmt, (IR_node_t) ((char *) &((_IR_or_assign *) node)->_IR_S_or_assign._IR_M_assign_stmt - _IR_offsetof (_IR_assign_stmt, _IR_S_assign_stmt)));
      break;
    case IR_NM_var_assign:
      _IR_node_field_initiation (IR_NM_assign_stmt, (IR_node_t) ((char *) &((_IR_var_assign *) node)->_IR_S_var_assign._IR_M_assign_stmt - _IR_offsetof (_IR_assign_stmt, _IR_S_assign_stmt)));
      break;
    case IR_NM_par_assign:
      _IR_node_field_initiation (IR_NM_assign_stmt, (IR_node_t) ((char *) &((_IR_par_assign *) node)->_IR_S_par_assign._IR_M_assign_stmt - _IR_offsetof (_IR_assign_stmt, _IR_S_assign_stmt)));
      break;
    case IR_NM_swap:
      _IR_node_field_initiation (IR_NM_stmt, (IR_node_t) ((char *) &((_IR_swap *) node)->_IR_S_swap._IR_M_stmt - _IR_offsetof (_IR_stmt, _IR_S_stmt)));
      IR_BEGIN_IR_node_t ((((_IR_swap *) node)->_IR_S_swap.swap_var1));
      IR_BEGIN_IR_node_t ((((_IR_swap *) node)->_IR_S_swap.swap_var2));
      break;
    case IR_NM_procedure_call:
      _IR_node_field_initiation (IR_NM_stmt, (IR_node_t) ((char *) &((_IR_procedure_call *) node)->_IR_S_procedure_call._IR_M_stmt - _IR_offsetof (_IR_stmt, _IR_S_stmt)));
      IR_BEGIN_IR_node_t ((((_IR_procedure_call *) node)->_IR_S_procedure_call.proc_expr));
      IR_BEGIN_IR_node_t ((((_IR_procedure_call *) node)->_IR_S_procedure_call.proc_actuals));
      IR_BEGIN_integer_t ((((_IR_procedure_call *) node)->_IR_S_procedure_call.procedure_call_pars_number));
      break;
    case IR_NM_if_stmt:
      _IR_node_field_initiation (IR_NM_stmt, (IR_node_t) ((char *) &((_IR_if_stmt *) node)->_IR_S_if_stmt._IR_M_stmt - _IR_offsetof (_IR_stmt, _IR_S_stmt)));
      IR_BEGIN_IR_node_t ((((_IR_if_stmt *) node)->_IR_S_if_stmt.if_expr));
      IR_BEGIN_IR_node_t ((((_IR_if_stmt *) node)->_IR_S_if_stmt.if_part));
      IR_BEGIN_IR_node_t ((((_IR_if_stmt *) node)->_IR_S_if_stmt.else_part));
      IR_BEGIN_IR_node_t ((((_IR_if_stmt *) node)->_IR_S_if_stmt.else_part_pc));
      break;
    case IR_NM_for_stmt:
      _IR_node_field_initiation (IR_NM_stmt, (IR_node_t) ((char *) &((_IR_for_stmt *) node)->_IR_S_for_stmt._IR_M_stmt - _IR_offsetof (_IR_stmt, _IR_S_stmt)));
      IR_BEGIN_IR_node_t ((((_IR_for_stmt *) node)->_IR_S_for_stmt.for_initial_stmt));
      IR_BEGIN_IR_node_t ((((_IR_for_stmt *) node)->_IR_S_for_stmt.for_guard_expr));
      IR_BEGIN_IR_node_t ((((_IR_for_stmt *) node)->_IR_S_for_stmt.for_iterate_stmt));
      IR_BEGIN_IR_node_t ((((_IR_for_stmt *) node)->_IR_S_for_stmt.for_stmts));
      IR_BEGIN_IR_node_t ((((_IR_for_stmt *) node)->_IR_S_for_stmt.for_body_pc));
      break;
    case IR_NM_foreach_stmt:
      _IR_node_field_initiation (IR_NM_stmt, (IR_node_t) ((char *) &((_IR_foreach_stmt *) node)->_IR_S_foreach_stmt._IR_M_stmt - _IR_offsetof (_IR_stmt, _IR_S_stmt)));
      IR_BEGIN_IR_node_t ((((_IR_foreach_stmt *) node)->_IR_S_foreach_stmt.foreach_designator));
      IR_BEGIN_IR_node_t ((((_IR_foreach_stmt *) node)->_IR_S_foreach_stmt.foreach_table));
      IR_BEGIN_IR_node_t ((((_IR_foreach_stmt *) node)->_IR_S_foreach_stmt.foreach_stmts));
      IR_BEGIN_IR_node_t ((((_IR_foreach_stmt *) node)->_IR_S_foreach_stmt.foreach_body_pc));
      break;
    case IR_NM_for_break_contintue:
      _IR_node_field_initiation (IR_NM_stmt, (IR_node_t) ((char *) &((_IR_for_break_contintue *) node)->_IR_S_for_break_contintue._IR_M_stmt - _IR_offsetof (_IR_stmt, _IR_S_stmt)));
      IR_BEGIN_integer_t ((((_IR_for_break_contintue *) node)->_IR_S_for_break_contintue.number_of_surrounding_blocks));
      break;
    case IR_NM_break_stmt:
      _IR_node_field_initiation (IR_NM_for_break_contintue, (IR_node_t) ((char *) &((_IR_break_stmt *) node)->_IR_S_break_stmt._IR_M_for_break_contintue - _IR_offsetof (_IR_for_break_contintue, _IR_S_for_break_contintue)));
      break;
    case IR_NM_continue_stmt:
      _IR_node_field_initiation (IR_NM_for_break_contintue, (IR_node_t) ((char *) &((_IR_continue_stmt *) node)->_IR_S_continue_stmt._IR_M_for_break_contintue - _IR_offsetof (_IR_for_break_contintue, _IR_S_for_break_contintue)));
      break;
    case IR_NM_return_without_result:
      _IR_node_field_initiation (IR_NM_stmt, (IR_node_t) ((char *) &((_IR_return_without_result *) node)->_IR_S_return_without_result._IR_M_stmt - _IR_offsetof (_IR_stmt, _IR_S_stmt)));
      break;
    case IR_NM_return_with_result:
      _IR_node_field_initiation (IR_NM_stmt, (IR_node_t) ((char *) &((_IR_return_with_result *) node)->_IR_S_return_with_result._IR_M_stmt - _IR_offsetof (_IR_stmt, _IR_S_stmt)));
      IR_BEGIN_IR_node_t ((((_IR_return_with_result *) node)->_IR_S_return_with_result.returned_expr));
      break;
    case IR_NM_throw:
      _IR_node_field_initiation (IR_NM_stmt, (IR_node_t) ((char *) &((_IR_throw *) node)->_IR_S_throw._IR_M_stmt - _IR_offsetof (_IR_stmt, _IR_S_stmt)));
      IR_BEGIN_IR_node_t ((((_IR_throw *) node)->_IR_S_throw.throw_expr));
      break;
    case IR_NM_wait_stmt:
      _IR_node_field_initiation (IR_NM_stmt, (IR_node_t) ((char *) &((_IR_wait_stmt *) node)->_IR_S_wait_stmt._IR_M_stmt - _IR_offsetof (_IR_stmt, _IR_S_stmt)));
      IR_BEGIN_IR_node_t ((((_IR_wait_stmt *) node)->_IR_S_wait_stmt.wait_guard_expr));
      IR_BEGIN_IR_node_t ((((_IR_wait_stmt *) node)->_IR_S_wait_stmt.wait_stmt));
      IR_BEGIN_IR_node_t ((((_IR_wait_stmt *) node)->_IR_S_wait_stmt.start_wait_guard_expr_pc));
      break;
    case IR_NM_block:
      _IR_node_field_initiation (IR_NM_stmt, (IR_node_t) ((char *) &((_IR_block *) node)->_IR_S_block._IR_M_stmt - _IR_offsetof (_IR_stmt, _IR_S_stmt)));
      IR_BEGIN_IR_node_t ((((_IR_block *) node)->_IR_S_block.block_scope));
      IR_BEGIN_IR_node_t ((((_IR_block *) node)->_IR_S_block.block_stmts));
      IR_BEGIN_IR_node_t ((((_IR_block *) node)->_IR_S_block.func_class_ext));
      IR_BEGIN_IR_node_t ((((_IR_block *) node)->_IR_S_block.access_list));
      IR_BEGIN_IR_node_t ((((_IR_block *) node)->_IR_S_block.exceptions));
      IR_BEGIN_integer_t ((((_IR_block *) node)->_IR_S_block.block_level));
      IR_BEGIN_integer_t ((((_IR_block *) node)->_IR_S_block.decls_number));
      IR_BEGIN_integer_t ((((_IR_block *) node)->_IR_S_block.vars_number));
      IR_BEGIN_integer_t ((((_IR_block *) node)->_IR_S_block.temporary_vars_number));
      IR_BEGIN_integer_t ((((_IR_block *) node)->_IR_S_block.block_number));
      IR_BEGIN_IR_node_t ((((_IR_block *) node)->_IR_S_block.catch_list_pc));
      IR_BEGIN_bool_t ((((_IR_block *) node)->_IR_S_block.simple_block_flag));
{

#line 1757 "/usr/src/ports/cocom/cocom-0.996-2.i686/src/cocom-0.996/DINO/d_ir.sprut"
(((_IR_block *) node)->_IR_S_block.simple_block_flag) = FALSE;

#line 2670 "d_ir.c"
}
      IR_BEGIN_bool_t ((((_IR_block *) node)->_IR_S_block.extended_life_context_flag));
{

#line 1770 "/usr/src/ports/cocom/cocom-0.996-2.i686/src/cocom-0.996/DINO/d_ir.sprut"
(((_IR_block *) node)->_IR_S_block.extended_life_context_flag) = FALSE;

#line 2678 "d_ir.c"
}
      IR_BEGIN_IR_node_t ((((_IR_block *) node)->_IR_S_block.friends));
{

#line 1772 "/usr/src/ports/cocom/cocom-0.996-2.i686/src/cocom-0.996/DINO/d_ir.sprut"
(((_IR_block *) node)->_IR_S_block.friends) = NULL;

#line 2686 "d_ir.c"
}
      IR_BEGIN_string_t ((((_IR_block *) node)->_IR_S_block.cached_container_address));
      IR_BEGIN_integer_t ((((_IR_block *) node)->_IR_S_block.cached_container_tick));
{

#line 1969 "/usr/src/ports/cocom/cocom-0.996-2.i686/src/cocom-0.996/DINO/d_ir.sprut"
(((_IR_block *) node)->_IR_S_block.cached_container_tick) = -1;

#line 2695 "d_ir.c"
}
      IR_BEGIN_bool_t ((((_IR_block *) node)->_IR_S_block.block_saved_sync_flag));
      break;
    case IR_NM_exception:
      _IR_node_field_initiation (IR_NM_generic_pos, (IR_node_t) ((char *) &((_IR_exception *) node)->_IR_S_exception._IR_M_generic_pos - _IR_offsetof (_IR_generic_pos, _IR_S_generic_pos)));
      IR_BEGIN_IR_node_t ((((_IR_exception *) node)->_IR_S_exception.exception_class_expr));
      IR_BEGIN_IR_node_t ((((_IR_exception *) node)->_IR_S_exception.catch_block));
      IR_BEGIN_IR_node_t ((((_IR_exception *) node)->_IR_S_exception.next_exception));
      IR_BEGIN_IR_node_t ((((_IR_exception *) node)->_IR_S_exception.catch_list_pc));
      break;
    case IR_NM_decl:
      _IR_node_field_initiation (IR_NM_stmt, (IR_node_t) ((char *) &((_IR_decl *) node)->_IR_S_decl._IR_M_stmt - _IR_offsetof (_IR_stmt, _IR_S_stmt)));
      IR_BEGIN_IR_node_t ((((_IR_decl *) node)->_IR_S_decl.scope));
      IR_BEGIN_IR_node_t ((((_IR_decl *) node)->_IR_S_decl.ident));
      IR_BEGIN_implementation_func_t ((((_IR_decl *) node)->_IR_S_decl.implementation_func));
      IR_BEGIN_bool_t ((((_IR_decl *) node)->_IR_S_decl.public_flag));
      IR_BEGIN_IR_node_t ((((_IR_decl *) node)->_IR_S_decl.access_ident));
      break;
    case IR_NM_may_be_const_decl:
      _IR_node_field_initiation (IR_NM_decl, (IR_node_t) ((char *) &((_IR_may_be_const_decl *) node)->_IR_S_may_be_const_decl._IR_M_decl - _IR_offsetof (_IR_decl, _IR_S_decl)));
      IR_BEGIN_bool_t ((((_IR_may_be_const_decl *) node)->_IR_S_may_be_const_decl.const_flag));
      break;
    case IR_NM_var:
      _IR_node_field_initiation (IR_NM_may_be_const_decl, (IR_node_t) ((char *) &((_IR_var *) node)->_IR_S_var._IR_M_may_be_const_decl - _IR_offsetof (_IR_may_be_const_decl, _IR_S_may_be_const_decl)));
      _IR_node_field_initiation (IR_NM_decl_in_block, (IR_node_t) ((char *) &((_IR_var *) node)->_IR_S_var._IR_M_decl_in_block - _IR_offsetof (_IR_decl_in_block, _IR_S_decl_in_block)));
      IR_BEGIN_integer_t ((((_IR_var *) node)->_IR_S_var.var_number_in_block));
      break;
    case IR_NM_external_var:
      _IR_node_field_initiation (IR_NM_may_be_const_decl, (IR_node_t) ((char *) &((_IR_external_var *) node)->_IR_S_external_var._IR_M_may_be_const_decl - _IR_offsetof (_IR_may_be_const_decl, _IR_S_may_be_const_decl)));
      _IR_node_field_initiation (IR_NM_decl_in_block, (IR_node_t) ((char *) &((_IR_external_var *) node)->_IR_S_external_var._IR_M_decl_in_block - _IR_offsetof (_IR_decl_in_block, _IR_S_decl_in_block)));
      _IR_node_field_initiation (IR_NM_external, (IR_node_t) ((char *) &((_IR_external_var *) node)->_IR_S_external_var._IR_M_external - _IR_offsetof (_IR_external, _IR_S_external)));
      break;
    case IR_NM_pub:
      _IR_node_field_initiation (IR_NM_decl, (IR_node_t) ((char *) &((_IR_pub *) node)->_IR_S_pub._IR_M_decl - _IR_offsetof (_IR_decl, _IR_S_decl)));
      break;
    case IR_NM_external_func:
      _IR_node_field_initiation (IR_NM_decl, (IR_node_t) ((char *) &((_IR_external_func *) node)->_IR_S_external_func._IR_M_decl - _IR_offsetof (_IR_decl, _IR_S_decl)));
      _IR_node_field_initiation (IR_NM_decl_in_block, (IR_node_t) ((char *) &((_IR_external_func *) node)->_IR_S_external_func._IR_M_decl_in_block - _IR_offsetof (_IR_decl_in_block, _IR_S_decl_in_block)));
      _IR_node_field_initiation (IR_NM_external, (IR_node_t) ((char *) &((_IR_external_func *) node)->_IR_S_external_func._IR_M_external - _IR_offsetof (_IR_external, _IR_S_external)));
      IR_BEGIN_int_t ((((_IR_external_func *) node)->_IR_S_external_func.no));
{

#line 1828 "/usr/src/ports/cocom/cocom-0.996-2.i686/src/cocom-0.996/DINO/d_ir.sprut"
(((_IR_external_func *) node)->_IR_S_external_func.no) = -1;

#line 2741 "d_ir.c"
}
      break;
    case IR_NM_func_class_ext:
      _IR_node_field_initiation (IR_NM_decl, (IR_node_t) ((char *) &((_IR_func_class_ext *) node)->_IR_S_func_class_ext._IR_M_decl - _IR_offsetof (_IR_decl, _IR_S_decl)));
      break;
    case IR_NM_func_or_class:
      _IR_node_field_initiation (IR_NM_func_class_ext, (IR_node_t) ((char *) &((_IR_func_or_class *) node)->_IR_S_func_or_class._IR_M_func_class_ext - _IR_offsetof (_IR_func_class_ext, _IR_S_func_class_ext)));
      _IR_node_field_initiation (IR_NM_decl_in_block, (IR_node_t) ((char *) &((_IR_func_or_class *) node)->_IR_S_func_or_class._IR_M_decl_in_block - _IR_offsetof (_IR_decl_in_block, _IR_S_decl_in_block)));
      _IR_node_field_initiation (IR_NM_external, (IR_node_t) ((char *) &((_IR_func_or_class *) node)->_IR_S_func_or_class._IR_M_external - _IR_offsetof (_IR_external, _IR_S_external)));
      IR_BEGIN_integer_t ((((_IR_func_or_class *) node)->_IR_S_func_or_class.parameters_number));
      IR_BEGIN_bool_t ((((_IR_func_or_class *) node)->_IR_S_func_or_class.args_flag));
      IR_BEGIN_bool_t ((((_IR_func_or_class *) node)->_IR_S_func_or_class.final_flag));
      IR_BEGIN_int_t ((((_IR_func_or_class *) node)->_IR_S_func_or_class.no));
{

#line 1816 "/usr/src/ports/cocom/cocom-0.996-2.i686/src/cocom-0.996/DINO/d_ir.sprut"
(((_IR_func_or_class *) node)->_IR_S_func_or_class.no) = -1;

#line 2760 "d_ir.c"
}
      IR_BEGIN_integer_t ((((_IR_func_or_class *) node)->_IR_S_func_or_class.calls_number));
{

#line 1945 "/usr/src/ports/cocom/cocom-0.996-2.i686/src/cocom-0.996/DINO/d_ir.sprut"
(((_IR_func_or_class *) node)->_IR_S_func_or_class.calls_number) = 0;

#line 2768 "d_ir.c"
}
      IR_BEGIN_ticker_t ((((_IR_func_or_class *) node)->_IR_S_func_or_class.exec_time));
      IR_BEGIN_integer_t ((((_IR_func_or_class *) node)->_IR_S_func_or_class.interrupts_number));
      break;
    case IR_NM_func:
      _IR_node_field_initiation (IR_NM_func_or_class, (IR_node_t) ((char *) &((_IR_func *) node)->_IR_S_func._IR_M_func_or_class - _IR_offsetof (_IR_func_or_class, _IR_S_func_or_class)));
      IR_BEGIN_bool_t ((((_IR_func *) node)->_IR_S_func.thread_flag));
      break;
    case IR_NM_class:
      _IR_node_field_initiation (IR_NM_func_or_class, (IR_node_t) ((char *) &((_IR_class *) node)->_IR_S_class._IR_M_func_or_class - _IR_offsetof (_IR_func_or_class, _IR_S_func_or_class)));
      IR_BEGIN_bool_t ((((_IR_class *) node)->_IR_S_class.simple_class_flag));
{

#line 1822 "/usr/src/ports/cocom/cocom-0.996-2.i686/src/cocom-0.996/DINO/d_ir.sprut"
(((_IR_class *) node)->_IR_S_class.simple_class_flag) = FALSE;

#line 2785 "d_ir.c"
}
      break;
    case IR_NM_ext:
      _IR_node_field_initiation (IR_NM_func_class_ext, (IR_node_t) ((char *) &((_IR_ext *) node)->_IR_S_ext._IR_M_func_class_ext - _IR_offsetof (_IR_func_class_ext, _IR_S_func_class_ext)));
      break;
    case IR_NM_no_testing_period:
      _IR_node_field_initiation (IR_NM_binary_operation, (IR_node_t) ((char *) &((_IR_no_testing_period *) node)->_IR_S_no_testing_period._IR_M_binary_operation - _IR_offsetof (_IR_binary_operation, _IR_S_binary_operation)));
      break;
    case IR_NM_lvalue_period:
      _IR_node_field_initiation (IR_NM_binary_operation, (IR_node_t) ((char *) &((_IR_lvalue_period *) node)->_IR_S_lvalue_period._IR_M_binary_operation - _IR_offsetof (_IR_binary_operation, _IR_S_binary_operation)));
      break;
    case IR_NM_lvalue_period_and_val:
      _IR_node_field_initiation (IR_NM_binary_operation, (IR_node_t) ((char *) &((_IR_lvalue_period_and_val *) node)->_IR_S_lvalue_period_and_val._IR_M_binary_operation - _IR_offsetof (_IR_binary_operation, _IR_S_binary_operation)));
      break;
    case IR_NM_lvalue_index:
      _IR_node_field_initiation (IR_NM_binary_operation, (IR_node_t) ((char *) &((_IR_lvalue_index *) node)->_IR_S_lvalue_index._IR_M_binary_operation - _IR_offsetof (_IR_binary_operation, _IR_S_binary_operation)));
      break;
    case IR_NM_lvalue_index_and_val:
      _IR_node_field_initiation (IR_NM_binary_operation, (IR_node_t) ((char *) &((_IR_lvalue_index_and_val *) node)->_IR_S_lvalue_index_and_val._IR_M_binary_operation - _IR_offsetof (_IR_binary_operation, _IR_S_binary_operation)));
      break;
    case IR_NM_lvalue_key_index:
      _IR_node_field_initiation (IR_NM_binary_operation, (IR_node_t) ((char *) &((_IR_lvalue_key_index *) node)->_IR_S_lvalue_key_index._IR_M_binary_operation - _IR_offsetof (_IR_binary_operation, _IR_S_binary_operation)));
      break;
    case IR_NM_lvalue_key_index_and_val:
      _IR_node_field_initiation (IR_NM_binary_operation, (IR_node_t) ((char *) &((_IR_lvalue_key_index_and_val *) node)->_IR_S_lvalue_key_index_and_val._IR_M_binary_operation - _IR_offsetof (_IR_binary_operation, _IR_S_binary_operation)));
      break;
    case IR_NM_lvalue_no_testing_period:
      _IR_node_field_initiation (IR_NM_binary_operation, (IR_node_t) ((char *) &((_IR_lvalue_no_testing_period *) node)->_IR_S_lvalue_no_testing_period._IR_M_binary_operation - _IR_offsetof (_IR_binary_operation, _IR_S_binary_operation)));
      break;
    case IR_NM_lvalue_no_testing_period_and_val:
      _IR_node_field_initiation (IR_NM_binary_operation, (IR_node_t) ((char *) &((_IR_lvalue_no_testing_period_and_val *) node)->_IR_S_lvalue_no_testing_period_and_val._IR_M_binary_operation - _IR_offsetof (_IR_binary_operation, _IR_S_binary_operation)));
      break;
    case IR_NM_logical_or_end:
      _IR_node_field_initiation (IR_NM_generic_pos, (IR_node_t) ((char *) &((_IR_logical_or_end *) node)->_IR_S_logical_or_end._IR_M_generic_pos - _IR_offsetof (_IR_generic_pos, _IR_S_generic_pos)));
      break;
    case IR_NM_logical_and_end:
      _IR_node_field_initiation (IR_NM_generic_pos, (IR_node_t) ((char *) &((_IR_logical_and_end *) node)->_IR_S_logical_and_end._IR_M_generic_pos - _IR_offsetof (_IR_generic_pos, _IR_S_generic_pos)));
      break;
    case IR_NM_cond_end:
      _IR_node_field_initiation (IR_NM_generic_pos, (IR_node_t) ((char *) &((_IR_cond_end *) node)->_IR_S_cond_end._IR_M_generic_pos - _IR_offsetof (_IR_generic_pos, _IR_S_generic_pos)));
      break;
    case IR_NM_par_assign_end:
      _IR_node_field_initiation (IR_NM_generic_pos, (IR_node_t) ((char *) &((_IR_par_assign_end *) node)->_IR_S_par_assign_end._IR_M_generic_pos - _IR_offsetof (_IR_generic_pos, _IR_S_generic_pos)));
      break;
    case IR_NM_par_assign_test:
      _IR_node_field_initiation (IR_NM_generic_pos, (IR_node_t) ((char *) &((_IR_par_assign_test *) node)->_IR_S_par_assign_test._IR_M_generic_pos - _IR_offsetof (_IR_generic_pos, _IR_S_generic_pos)));
      IR_BEGIN_IR_node_t ((((_IR_par_assign_test *) node)->_IR_S_par_assign_test.skip_par_assign_path_pc));
      break;
    case IR_NM_nil:
      _IR_node_field_initiation (IR_NM_generic_pos, (IR_node_t) ((char *) &((_IR_nil *) node)->_IR_S_nil._IR_M_generic_pos - _IR_offsetof (_IR_generic_pos, _IR_S_generic_pos)));
      break;
    case IR_NM_friend:
      _IR_node_field_initiation (IR_NM_ir_node, (IR_node_t) ((char *) &((_IR_friend *) node)->_IR_S_friend._IR_M_ir_node - _IR_offsetof (_IR_ir_node, _IR_S_ir_node)));
      IR_BEGIN_IR_node_t ((((_IR_friend *) node)->_IR_S_friend.friend_decl));
      IR_BEGIN_IR_node_t ((((_IR_friend *) node)->_IR_S_friend.next_friend));
      break;
    case IR_NM_decl_in_block:
      IR_BEGIN_integer_t ((((_IR_decl_in_block *) node)->_IR_S_decl_in_block.decl_number_in_block));
      break;
    case IR_NM_occurrence:
      _IR_node_field_initiation (IR_NM_generic_pos, (IR_node_t) ((char *) &((_IR_occurrence *) node)->_IR_S_occurrence._IR_M_generic_pos - _IR_offsetof (_IR_generic_pos, _IR_S_generic_pos)));
      IR_BEGIN_IR_node_t ((((_IR_occurrence *) node)->_IR_S_occurrence.decl));
      break;
    case IR_NM_external_var_occurrence:
      _IR_node_field_initiation (IR_NM_occurrence, (IR_node_t) ((char *) &((_IR_external_var_occurrence *) node)->_IR_S_external_var_occurrence._IR_M_occurrence - _IR_offsetof (_IR_occurrence, _IR_S_occurrence)));
      break;
    case IR_NM_local_var_occurrence:
      _IR_node_field_initiation (IR_NM_occurrence, (IR_node_t) ((char *) &((_IR_local_var_occurrence *) node)->_IR_S_local_var_occurrence._IR_M_occurrence - _IR_offsetof (_IR_occurrence, _IR_S_occurrence)));
      break;
    case IR_NM_var_occurrence:
      _IR_node_field_initiation (IR_NM_occurrence, (IR_node_t) ((char *) &((_IR_var_occurrence *) node)->_IR_S_var_occurrence._IR_M_occurrence - _IR_offsetof (_IR_occurrence, _IR_S_occurrence)));
      break;
    case IR_NM_lvalue_external_var_occurrence:
      _IR_node_field_initiation (IR_NM_occurrence, (IR_node_t) ((char *) &((_IR_lvalue_external_var_occurrence *) node)->_IR_S_lvalue_external_var_occurrence._IR_M_occurrence - _IR_offsetof (_IR_occurrence, _IR_S_occurrence)));
      break;
    case IR_NM_lvalue_external_var_occurrence_and_val:
      _IR_node_field_initiation (IR_NM_occurrence, (IR_node_t) ((char *) &((_IR_lvalue_external_var_occurrence_and_val *) node)->_IR_S_lvalue_external_var_occurrence_and_val._IR_M_occurrence - _IR_offsetof (_IR_occurrence, _IR_S_occurrence)));
      break;
    case IR_NM_local_lvalue_var_occurrence:
      _IR_node_field_initiation (IR_NM_occurrence, (IR_node_t) ((char *) &((_IR_local_lvalue_var_occurrence *) node)->_IR_S_local_lvalue_var_occurrence._IR_M_occurrence - _IR_offsetof (_IR_occurrence, _IR_S_occurrence)));
      break;
    case IR_NM_local_lvalue_var_occurrence_and_val:
      _IR_node_field_initiation (IR_NM_occurrence, (IR_node_t) ((char *) &((_IR_local_lvalue_var_occurrence_and_val *) node)->_IR_S_local_lvalue_var_occurrence_and_val._IR_M_occurrence - _IR_offsetof (_IR_occurrence, _IR_S_occurrence)));
      break;
    case IR_NM_lvalue_var_occurrence:
      _IR_node_field_initiation (IR_NM_occurrence, (IR_node_t) ((char *) &((_IR_lvalue_var_occurrence *) node)->_IR_S_lvalue_var_occurrence._IR_M_occurrence - _IR_offsetof (_IR_occurrence, _IR_S_occurrence)));
      break;
    case IR_NM_lvalue_var_occurrence_and_val:
      _IR_node_field_initiation (IR_NM_occurrence, (IR_node_t) ((char *) &((_IR_lvalue_var_occurrence_and_val *) node)->_IR_S_lvalue_var_occurrence_and_val._IR_M_occurrence - _IR_offsetof (_IR_occurrence, _IR_S_occurrence)));
      break;
    case IR_NM_external_func_occurrence:
      _IR_node_field_initiation (IR_NM_occurrence, (IR_node_t) ((char *) &((_IR_external_func_occurrence *) node)->_IR_S_external_func_occurrence._IR_M_occurrence - _IR_offsetof (_IR_occurrence, _IR_S_occurrence)));
      break;
    case IR_NM_func_occurrence:
      _IR_node_field_initiation (IR_NM_occurrence, (IR_node_t) ((char *) &((_IR_func_occurrence *) node)->_IR_S_func_occurrence._IR_M_occurrence - _IR_offsetof (_IR_occurrence, _IR_S_occurrence)));
      break;
    case IR_NM_class_occurrence:
      _IR_node_field_initiation (IR_NM_occurrence, (IR_node_t) ((char *) &((_IR_class_occurrence *) node)->_IR_S_class_occurrence._IR_M_occurrence - _IR_offsetof (_IR_occurrence, _IR_S_occurrence)));
      break;
    case IR_NM_if_finish:
      _IR_node_field_initiation (IR_NM_generic_pos, (IR_node_t) ((char *) &((_IR_if_finish *) node)->_IR_S_if_finish._IR_M_generic_pos - _IR_offsetof (_IR_generic_pos, _IR_S_generic_pos)));
      break;
    case IR_NM_for_finish:
      _IR_node_field_initiation (IR_NM_generic_pos, (IR_node_t) ((char *) &((_IR_for_finish *) node)->_IR_S_for_finish._IR_M_generic_pos - _IR_offsetof (_IR_generic_pos, _IR_S_generic_pos)));
      break;
    case IR_NM_wait_finish:
      _IR_node_field_initiation (IR_NM_generic_pos, (IR_node_t) ((char *) &((_IR_wait_finish *) node)->_IR_S_wait_finish._IR_M_generic_pos - _IR_offsetof (_IR_generic_pos, _IR_S_generic_pos)));
      break;
    case IR_NM_foreach_start:
      _IR_node_field_initiation (IR_NM_generic_pos, (IR_node_t) ((char *) &((_IR_foreach_start *) node)->_IR_S_foreach_start._IR_M_generic_pos - _IR_offsetof (_IR_generic_pos, _IR_S_generic_pos)));
      break;
    case IR_NM_foreach_next_iteration:
      _IR_node_field_initiation (IR_NM_generic_pos, (IR_node_t) ((char *) &((_IR_foreach_next_iteration *) node)->_IR_S_foreach_next_iteration._IR_M_generic_pos - _IR_offsetof (_IR_generic_pos, _IR_S_generic_pos)));
      break;
    case IR_NM_block_finish:
      _IR_node_field_initiation (IR_NM_generic_pos, (IR_node_t) ((char *) &((_IR_block_finish *) node)->_IR_S_block_finish._IR_M_generic_pos - _IR_offsetof (_IR_generic_pos, _IR_S_generic_pos)));
      IR_BEGIN_IR_node_t ((((_IR_block_finish *) node)->_IR_S_block_finish.block));
      IR_BEGIN_bool_t ((((_IR_block_finish *) node)->_IR_S_block_finish.simple_block_finish_flag));
      break;
    case IR_NM_catches_finish:
      _IR_node_field_initiation (IR_NM_generic_pos, (IR_node_t) ((char *) &((_IR_catches_finish *) node)->_IR_S_catches_finish._IR_M_generic_pos - _IR_offsetof (_IR_generic_pos, _IR_S_generic_pos)));
      break;
    case IR_NM_pop_func_call:
      _IR_node_field_initiation (IR_NM_generic_pos, (IR_node_t) ((char *) &((_IR_pop_func_call *) node)->_IR_S_pop_func_call._IR_M_generic_pos - _IR_offsetof (_IR_generic_pos, _IR_S_generic_pos)));
      break;
    case IR_NM_external:
      IR_BEGIN_string_t ((((_IR_external *) node)->_IR_S_external.address));
{

#line 1956 "/usr/src/ports/cocom/cocom-0.996-2.i686/src/cocom-0.996/DINO/d_ir.sprut"
(((_IR_external *) node)->_IR_S_external.address) = NULL;

#line 2918 "d_ir.c"
}
      break;
    case IR_NM__error:
      break;
    default:
      abort ();
      break;
    }
}

IR_node_t IR_create_node (IR_node_mode_t node_mode)
{
 IR_node_t _result;

  IR_ALLOC (_result, IR_node_size [node_mode], IR_node_t);
#ifdef __IR_DEBUG__
  if (_result == NULL)
    abort ();
#endif /* __IR_DEBUG__ */
  IR_NODE_MODE (_result) = node_mode;
  _IR_node_field_initiation (node_mode, _result);
  return _result;
}

void IR_start (void)
{
#ifdef __IR_DEBUG__
  if (sizeof (_IR_ir_node) > 255)
    {
      fprintf (stderr, "Very long node `ir_node' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_unique_char) > 255)
    {
      fprintf (stderr, "Very long node `unique_char' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_generic_pos) > 255)
    {
      fprintf (stderr, "Very long node `generic_pos' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_char) > 255)
    {
      fprintf (stderr, "Very long node `char' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_unique_int) > 255)
    {
      fprintf (stderr, "Very long node `unique_int' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_int) > 255)
    {
      fprintf (stderr, "Very long node `int' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_unique_float) > 255)
    {
      fprintf (stderr, "Very long node `unique_float' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_float) > 255)
    {
      fprintf (stderr, "Very long node `float' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_unique_string) > 255)
    {
      fprintf (stderr, "Very long node `unique_string' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_string) > 255)
    {
      fprintf (stderr, "Very long node `string' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_unique_ident) > 255)
    {
      fprintf (stderr, "Very long node `unique_ident' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_ident) > 255)
    {
      fprintf (stderr, "Very long node `ident' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_expr) > 255)
    {
      fprintf (stderr, "Very long node `expr' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_operation) > 255)
    {
      fprintf (stderr, "Very long node `operation' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_binary_operation) > 255)
    {
      fprintf (stderr, "Very long node `binary_operation' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_unary_operation) > 255)
    {
      fprintf (stderr, "Very long node `unary_operation' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_in) > 255)
    {
      fprintf (stderr, "Very long node `in' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_or) > 255)
    {
      fprintf (stderr, "Very long node `or' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_xor) > 255)
    {
      fprintf (stderr, "Very long node `xor' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_and) > 255)
    {
      fprintf (stderr, "Very long node `and' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_eq) > 255)
    {
      fprintf (stderr, "Very long node `eq' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_ne) > 255)
    {
      fprintf (stderr, "Very long node `ne' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_identity) > 255)
    {
      fprintf (stderr, "Very long node `identity' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_unidentity) > 255)
    {
      fprintf (stderr, "Very long node `unidentity' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_lt) > 255)
    {
      fprintf (stderr, "Very long node `lt' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_gt) > 255)
    {
      fprintf (stderr, "Very long node `gt' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_le) > 255)
    {
      fprintf (stderr, "Very long node `le' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_ge) > 255)
    {
      fprintf (stderr, "Very long node `ge' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_lshift) > 255)
    {
      fprintf (stderr, "Very long node `lshift' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_rshift) > 255)
    {
      fprintf (stderr, "Very long node `rshift' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_ashift) > 255)
    {
      fprintf (stderr, "Very long node `ashift' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_concat) > 255)
    {
      fprintf (stderr, "Very long node `concat' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_plus) > 255)
    {
      fprintf (stderr, "Very long node `plus' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_minus) > 255)
    {
      fprintf (stderr, "Very long node `minus' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_mult) > 255)
    {
      fprintf (stderr, "Very long node `mult' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_div) > 255)
    {
      fprintf (stderr, "Very long node `div' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_mod) > 255)
    {
      fprintf (stderr, "Very long node `mod' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_index) > 255)
    {
      fprintf (stderr, "Very long node `index' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_key_index) > 255)
    {
      fprintf (stderr, "Very long node `key_index' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_member_access) > 255)
    {
      fprintf (stderr, "Very long node `member_access' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_period) > 255)
    {
      fprintf (stderr, "Very long node `period' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_logical_binary_operation) > 255)
    {
      fprintf (stderr, "Very long node `logical_binary_operation' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_logical_or) > 255)
    {
      fprintf (stderr, "Very long node `logical_or' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_logical_and) > 255)
    {
      fprintf (stderr, "Very long node `logical_and' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_cond) > 255)
    {
      fprintf (stderr, "Very long node `cond' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_const) > 255)
    {
      fprintf (stderr, "Very long node `const' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_new) > 255)
    {
      fprintf (stderr, "Very long node `new' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_not) > 255)
    {
      fprintf (stderr, "Very long node `not' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_unary_plus) > 255)
    {
      fprintf (stderr, "Very long node `unary_plus' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_unary_minus) > 255)
    {
      fprintf (stderr, "Very long node `unary_minus' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_bitwise_not) > 255)
    {
      fprintf (stderr, "Very long node `bitwise_not' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_length) > 255)
    {
      fprintf (stderr, "Very long node `length' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_typeof) > 255)
    {
      fprintf (stderr, "Very long node `typeof' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_charof) > 255)
    {
      fprintf (stderr, "Very long node `charof' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_intof) > 255)
    {
      fprintf (stderr, "Very long node `intof' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_floatof) > 255)
    {
      fprintf (stderr, "Very long node `floatof' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_vectorof) > 255)
    {
      fprintf (stderr, "Very long node `vectorof' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_tableof) > 255)
    {
      fprintf (stderr, "Very long node `tableof' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_funcof) > 255)
    {
      fprintf (stderr, "Very long node `funcof' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_threadof) > 255)
    {
      fprintf (stderr, "Very long node `threadof' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_classof) > 255)
    {
      fprintf (stderr, "Very long node `classof' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_format_vectorof) > 255)
    {
      fprintf (stderr, "Very long node `format_vectorof' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_designator) > 255)
    {
      fprintf (stderr, "Very long node `designator' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_type) > 255)
    {
      fprintf (stderr, "Very long node `type' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_nil_type) > 255)
    {
      fprintf (stderr, "Very long node `nil_type' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_hide_type) > 255)
    {
      fprintf (stderr, "Very long node `hide_type' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_hideblock_type) > 255)
    {
      fprintf (stderr, "Very long node `hideblock_type' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_char_type) > 255)
    {
      fprintf (stderr, "Very long node `char_type' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_int_type) > 255)
    {
      fprintf (stderr, "Very long node `int_type' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_float_type) > 255)
    {
      fprintf (stderr, "Very long node `float_type' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_vector_type) > 255)
    {
      fprintf (stderr, "Very long node `vector_type' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_table_type) > 255)
    {
      fprintf (stderr, "Very long node `table_type' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_func_type) > 255)
    {
      fprintf (stderr, "Very long node `func_type' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_thread_type) > 255)
    {
      fprintf (stderr, "Very long node `thread_type' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_class_type) > 255)
    {
      fprintf (stderr, "Very long node `class_type' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_stack_type) > 255)
    {
      fprintf (stderr, "Very long node `stack_type' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_process_type) > 255)
    {
      fprintf (stderr, "Very long node `process_type' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_instance_type) > 255)
    {
      fprintf (stderr, "Very long node `instance_type' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_type_type) > 255)
    {
      fprintf (stderr, "Very long node `type_type' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_vector_table) > 255)
    {
      fprintf (stderr, "Very long node `vector_table' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_vector) > 255)
    {
      fprintf (stderr, "Very long node `vector' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_table) > 255)
    {
      fprintf (stderr, "Very long node `table' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_elist_element) > 255)
    {
      fprintf (stderr, "Very long node `elist_element' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_class_func_thread_call) > 255)
    {
      fprintf (stderr, "Very long node `class_func_thread_call' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_access_ident) > 255)
    {
      fprintf (stderr, "Very long node `access_ident' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_stmt) > 255)
    {
      fprintf (stderr, "Very long node `stmt' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_assign_stmt) > 255)
    {
      fprintf (stderr, "Very long node `assign_stmt' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_assign) > 255)
    {
      fprintf (stderr, "Very long node `assign' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_mult_assign) > 255)
    {
      fprintf (stderr, "Very long node `mult_assign' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_div_assign) > 255)
    {
      fprintf (stderr, "Very long node `div_assign' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_rem_assign) > 255)
    {
      fprintf (stderr, "Very long node `rem_assign' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_plus_assign) > 255)
    {
      fprintf (stderr, "Very long node `plus_assign' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_minus_assign) > 255)
    {
      fprintf (stderr, "Very long node `minus_assign' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_concat_assign) > 255)
    {
      fprintf (stderr, "Very long node `concat_assign' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_lshift_assign) > 255)
    {
      fprintf (stderr, "Very long node `lshift_assign' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_rshift_assign) > 255)
    {
      fprintf (stderr, "Very long node `rshift_assign' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_ashift_assign) > 255)
    {
      fprintf (stderr, "Very long node `ashift_assign' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_and_assign) > 255)
    {
      fprintf (stderr, "Very long node `and_assign' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_xor_assign) > 255)
    {
      fprintf (stderr, "Very long node `xor_assign' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_or_assign) > 255)
    {
      fprintf (stderr, "Very long node `or_assign' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_var_assign) > 255)
    {
      fprintf (stderr, "Very long node `var_assign' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_par_assign) > 255)
    {
      fprintf (stderr, "Very long node `par_assign' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_swap) > 255)
    {
      fprintf (stderr, "Very long node `swap' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_procedure_call) > 255)
    {
      fprintf (stderr, "Very long node `procedure_call' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_if_stmt) > 255)
    {
      fprintf (stderr, "Very long node `if_stmt' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_for_stmt) > 255)
    {
      fprintf (stderr, "Very long node `for_stmt' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_foreach_stmt) > 255)
    {
      fprintf (stderr, "Very long node `foreach_stmt' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_for_break_contintue) > 255)
    {
      fprintf (stderr, "Very long node `for_break_contintue' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_break_stmt) > 255)
    {
      fprintf (stderr, "Very long node `break_stmt' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_continue_stmt) > 255)
    {
      fprintf (stderr, "Very long node `continue_stmt' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_return_without_result) > 255)
    {
      fprintf (stderr, "Very long node `return_without_result' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_return_with_result) > 255)
    {
      fprintf (stderr, "Very long node `return_with_result' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_throw) > 255)
    {
      fprintf (stderr, "Very long node `throw' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_wait_stmt) > 255)
    {
      fprintf (stderr, "Very long node `wait_stmt' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_block) > 255)
    {
      fprintf (stderr, "Very long node `block' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_exception) > 255)
    {
      fprintf (stderr, "Very long node `exception' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_decl) > 255)
    {
      fprintf (stderr, "Very long node `decl' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_may_be_const_decl) > 255)
    {
      fprintf (stderr, "Very long node `may_be_const_decl' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_var) > 255)
    {
      fprintf (stderr, "Very long node `var' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_external_var) > 255)
    {
      fprintf (stderr, "Very long node `external_var' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_pub) > 255)
    {
      fprintf (stderr, "Very long node `pub' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_external_func) > 255)
    {
      fprintf (stderr, "Very long node `external_func' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_func_class_ext) > 255)
    {
      fprintf (stderr, "Very long node `func_class_ext' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_func_or_class) > 255)
    {
      fprintf (stderr, "Very long node `func_or_class' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_func) > 255)
    {
      fprintf (stderr, "Very long node `func' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_class) > 255)
    {
      fprintf (stderr, "Very long node `class' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_ext) > 255)
    {
      fprintf (stderr, "Very long node `ext' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_no_testing_period) > 255)
    {
      fprintf (stderr, "Very long node `no_testing_period' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_lvalue_period) > 255)
    {
      fprintf (stderr, "Very long node `lvalue_period' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_lvalue_period_and_val) > 255)
    {
      fprintf (stderr, "Very long node `lvalue_period_and_val' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_lvalue_index) > 255)
    {
      fprintf (stderr, "Very long node `lvalue_index' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_lvalue_index_and_val) > 255)
    {
      fprintf (stderr, "Very long node `lvalue_index_and_val' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_lvalue_key_index) > 255)
    {
      fprintf (stderr, "Very long node `lvalue_key_index' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_lvalue_key_index_and_val) > 255)
    {
      fprintf (stderr, "Very long node `lvalue_key_index_and_val' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_lvalue_no_testing_period) > 255)
    {
      fprintf (stderr, "Very long node `lvalue_no_testing_period' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_lvalue_no_testing_period_and_val) > 255)
    {
      fprintf (stderr, "Very long node `lvalue_no_testing_period_and_val' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_logical_or_end) > 255)
    {
      fprintf (stderr, "Very long node `logical_or_end' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_logical_and_end) > 255)
    {
      fprintf (stderr, "Very long node `logical_and_end' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_cond_end) > 255)
    {
      fprintf (stderr, "Very long node `cond_end' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_par_assign_end) > 255)
    {
      fprintf (stderr, "Very long node `par_assign_end' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_par_assign_test) > 255)
    {
      fprintf (stderr, "Very long node `par_assign_test' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_nil) > 255)
    {
      fprintf (stderr, "Very long node `nil' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_friend) > 255)
    {
      fprintf (stderr, "Very long node `friend' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_decl_in_block) > 255)
    {
      fprintf (stderr, "Very long node `decl_in_block' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_occurrence) > 255)
    {
      fprintf (stderr, "Very long node `occurrence' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_external_var_occurrence) > 255)
    {
      fprintf (stderr, "Very long node `external_var_occurrence' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_local_var_occurrence) > 255)
    {
      fprintf (stderr, "Very long node `local_var_occurrence' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_var_occurrence) > 255)
    {
      fprintf (stderr, "Very long node `var_occurrence' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_lvalue_external_var_occurrence) > 255)
    {
      fprintf (stderr, "Very long node `lvalue_external_var_occurrence' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_lvalue_external_var_occurrence_and_val) > 255)
    {
      fprintf (stderr, "Very long node `lvalue_external_var_occurrence_and_val' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_local_lvalue_var_occurrence) > 255)
    {
      fprintf (stderr, "Very long node `local_lvalue_var_occurrence' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_local_lvalue_var_occurrence_and_val) > 255)
    {
      fprintf (stderr, "Very long node `local_lvalue_var_occurrence_and_val' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_lvalue_var_occurrence) > 255)
    {
      fprintf (stderr, "Very long node `lvalue_var_occurrence' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_lvalue_var_occurrence_and_val) > 255)
    {
      fprintf (stderr, "Very long node `lvalue_var_occurrence_and_val' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_external_func_occurrence) > 255)
    {
      fprintf (stderr, "Very long node `external_func_occurrence' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_func_occurrence) > 255)
    {
      fprintf (stderr, "Very long node `func_occurrence' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_class_occurrence) > 255)
    {
      fprintf (stderr, "Very long node `class_occurrence' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_if_finish) > 255)
    {
      fprintf (stderr, "Very long node `if_finish' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_for_finish) > 255)
    {
      fprintf (stderr, "Very long node `for_finish' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_wait_finish) > 255)
    {
      fprintf (stderr, "Very long node `wait_finish' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_foreach_start) > 255)
    {
      fprintf (stderr, "Very long node `foreach_start' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_foreach_next_iteration) > 255)
    {
      fprintf (stderr, "Very long node `foreach_next_iteration' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_block_finish) > 255)
    {
      fprintf (stderr, "Very long node `block_finish' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_catches_finish) > 255)
    {
      fprintf (stderr, "Very long node `catches_finish' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_pop_func_call) > 255)
    {
      fprintf (stderr, "Very long node `pop_func_call' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
#ifdef __IR_DEBUG__
  if (sizeof (_IR_external) > 255)
    {
      fprintf (stderr, "Very long node `external' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __IR_DEBUG__ */
  _IR_current_graph_pass_number = 0;
  IR_START_ALLOC ();
}

void IR_stop (void)
{
  IR_STOP_ALLOC ();
}



#line 1974 "/usr/src/ports/cocom/cocom-0.996-2.i686/src/cocom-0.996/DINO/d_ir.sprut"


/* Funcs for work with code node hash table.  The table contains pointers
   to code nodes representing unique idents, values (cardinal, integer
   and etc.), decls (i.e. nodes having members ident and scope). */

/* The node hash table. */

static hash_table_t node_hash_table;

/* Func for evaluation of hash value of code node represented by EL_PTR. */

static unsigned
hash_func (hash_table_entry_t el_ptr)
{
  IR_node_t node_ref;
  IR_node_mode_t mode;
  char *chp, ch;
  int_t int_number;
  floating_t float_number;
  size_t i, size, hash_value;

  node_ref = IR_POINTER (el_ptr);
  mode = IR_NODE_MODE (node_ref);
  if (mode == IR_NM_var || mode == IR_NM_external_var
      || mode == IR_NM_external_func || mode == IR_NM_func
      || mode == IR_NM_class || mode == IR_NM_ext)
    hash_value
      = ((unsigned) (long) IR_scope (node_ref)
	 + (unsigned) (long) IR_GET_UNIQUE_IDENT (IR_ident (node_ref)));
  else
    {
      if (mode == IR_NM_unique_char)
	{
	  size = sizeof (char_t);
          ch = IR_char_value (node_ref);
	  chp = &ch;
	}
      else if (mode == IR_NM_unique_int)
	{
	  size = sizeof (int_t);
          int_number = IR_int_value (node_ref);
	  chp = (char *) &int_number;
	}
      else if (mode == IR_NM_unique_float)
	{
	  size = sizeof (floating_t);
          float_number = IR_float_value (node_ref);
	  chp = (char *) &float_number;
	}
      else if (mode == IR_NM_unique_string)
	{
	  chp = IR_string_value (node_ref);
	  size = strlen (chp);
	}
      else if (mode == IR_NM_unique_ident)
	{
	  chp = IR_ident_string (node_ref);
	  size = strlen (chp);
	}
      else
	assert (FALSE);
      for (hash_value = 0, i = 0; i < size; i++, chp++)
	hash_value += (*chp);
    }
  return hash_value;
}

/* Func used for comparison of hash table elements represented by EL1_PTR,
   EL2_PTR.  Return TRUE if the elements represent equal nodes. */

static int
compare_func (hash_table_entry_t el1_ptr, hash_table_entry_t el2_ptr)
{
  IR_node_t node_ref1, node_ref2;
  IR_node_mode_t mode1, mode2;
  int elements_are_equal;

  node_ref1 = IR_POINTER (el1_ptr);
  node_ref2 = IR_POINTER (el2_ptr);
  mode1 = IR_NODE_MODE (node_ref1);
  mode2 = IR_NODE_MODE (node_ref2);
  if ((mode1 == IR_NM_var || mode1 == IR_NM_external_var
       || mode1 == IR_NM_external_func || mode1 == IR_NM_func
       || mode1 == IR_NM_class || mode1 == IR_NM_ext)
      && (mode2 == IR_NM_var || mode2 == IR_NM_external_var
	  || mode2 == IR_NM_external_func || mode2 == IR_NM_func
	  || mode2 == IR_NM_class || mode2 == IR_NM_ext))
    elements_are_equal
      = (IR_scope (node_ref1) == IR_scope (node_ref2)
	 && (IR_GET_UNIQUE_IDENT (IR_ident (node_ref1))
	     == IR_GET_UNIQUE_IDENT (IR_ident (node_ref2))));
  else
    {
      elements_are_equal = mode1 == mode2;
      if (elements_are_equal)
	{
	  if (mode1 == IR_NM_unique_ident)
	    elements_are_equal
	      = (strcmp (IR_ident_string (node_ref1),
			 IR_ident_string (node_ref2))
		 == 0);
	  else if (mode1 == IR_NM_unique_char)
	    elements_are_equal = (IR_char_value (node_ref1)
				  == IR_char_value (node_ref2));
	  else if (mode1 == IR_NM_unique_int)
	    elements_are_equal
	      = (IR_int_value (node_ref1) == IR_int_value (node_ref2));
	  else if (mode1 == IR_NM_unique_float)
	    elements_are_equal
	      = (IR_float_value (node_ref1) == IR_float_value (node_ref2));
	  else if (mode1 == IR_NM_unique_string)
	    elements_are_equal
	      = strcmp (IR_string_value (node_ref1),
                        IR_string_value (node_ref2)) == 0;
	  else
	    assert (FALSE);
	}
    }
  return elements_are_equal;
}

void
initiate_table (void)
{
  node_hash_table = create_hash_table (1000, hash_func, compare_func);
}

/* Delete the code node hash table. */

void
delete_table (void)
{
  delete_hash_table (node_hash_table);
}

/* Find pointer to the code node hash table entry which contains pointer to
   node with the same keys as in node starting with REF or else the empty entry
   (its value is NULL).  If RESERVE is TRUE than the empty entry is reseved
   and must be filled by node with the same keys as in node starting with
   REF. */

IR_node_t *
find_table_entry (IR_node_t ref, int reserve)
{
  return
    (IR_node_t *) find_hash_table_entry (node_hash_table,
					  (hash_table_entry_t) ref, reserve);
}

/* Include node starting with REF to the code node hash table.  If node with
   the same keys is already in the table than delete it and include the node
   starting with REF to the table. */

void
include_to_table (IR_node_t ref)
{
  IR_node_t *table_entry_pointer;

  table_entry_pointer = find_table_entry (ref, TRUE);
  *table_entry_pointer = ref;
}

/* Return pointer to unique ident node with the hash table key STRING. */

IR_node_t
find_unique_ident (char *string)
{
  IR_node_t result;

  IR_set_ident_string (temp_unique_ident, string);
  result = (*find_table_entry (temp_unique_ident, FALSE));
  return result;
}

/* Allocate memory for node with given mode and initiate its mode. */

IR_node_t
create_node (IR_node_mode_t mode)
{
  return IR_create_node (mode);
}

/* Allocate memory for node with given mode and initiate its common members
   MODE and POS. */

IR_node_t
create_node_with_pos (IR_node_mode_t mode, position_t pos)
{
  IR_node_t ref;

  ref = IR_create_node (mode);
  IR_set_pos (ref, pos);
  return ref;
}

/* Allocate memory for node with given mode and string attribute and
   initiate its common member mode.  Return pointer to the string
   attribute STR through parameter string_in_pool_ptr.  Nodes with string
   attribute are unique string, unique ident. */

IR_node_t
create_unique_node_with_string (IR_node_mode_t m,
				const char *str, char **string_in_pool_ptr)
{
  IR_node_t ref;

  ref = IR_create_node (m);
  IR_TOP_EXPAND (strlen (str) + 1);
  *string_in_pool_ptr = IR_TOP_BEGIN ();
  IR_TOP_FINISH ();
  strcpy (*string_in_pool_ptr, str);
  return ref;
}

/* Create unique ident with name STR (allocate memory, copy attribute
   in pool, initiate members and include to the hash table if the unique
   ident does not exist).  Only this func must be used for creation
   of unique ident because only this func initiates correctly some
   members. */

IR_node_t
create_unique_ident_node (const char *str)
{
  IR_node_t ref;
  char *string_in_pool;

  IR_set_ident_string (temp_unique_ident, (char *) str);
  ref = *find_table_entry (temp_unique_ident, FALSE);
  if (ref == NULL)
    {
      ref = create_unique_node_with_string (IR_NM_unique_ident, str,
                                            &string_in_pool);
      IR_set_ident_string (ref, string_in_pool);
      /* The following means that the ident is not used for access to 
         any class decl. */
      IR_set_block_decl_ident_number (ref, -1);
      include_to_table (ref);
    }
  return ref;
}

/* The func returns occurrence mode (var occurrence and etc.) for 
   corresponding DECL.  DECL must be only var, func
   or class. */

IR_node_mode_t
occurrence_mode (IR_node_t decl)
{
  assert (decl != NULL);
  if (IR_NODE_MODE (decl) == IR_NM_var)
    return IR_NM_var_occurrence;
  else if (IR_NODE_MODE (decl) == IR_NM_external_var)
    return IR_NM_external_var_occurrence;
  else if (IR_NODE_MODE (decl) == IR_NM_external_func)
    return IR_NM_external_func_occurrence;
  else if (IR_NODE_MODE (decl) == IR_NM_func)
    return IR_NM_func_occurrence;
  else if (IR_NODE_MODE (decl) == IR_NM_class)
    return IR_NM_class_occurrence;
  else
    assert (FALSE);
  return IR_NM_var_occurrence; /* No warnings */
}

/* The func creates occurrence_node (var, func or class) with
   POS for corresponding DECL.  DECL must be only var,
   func or class. */

IR_node_t
create_occurrence_node (IR_node_t decl, position_t pos, int local_p)
{
  IR_node_t occurrence_node;
  IR_node_mode_t node_mode;

  node_mode = occurrence_mode (decl);
  if (node_mode == IR_NM_var_occurrence && local_p)
    node_mode = IR_NM_local_var_occurrence;
  occurrence_node = create_node_with_pos (node_mode, pos);
  IR_set_decl (occurrence_node, decl);
  return occurrence_node;
}

/* This func should be invoked only one before any work with intermediate
   code but after initiation of table.  The func creates standard
   environment. */

void
initiate_icode (void)
{
  IR_start ();
  temp_unique_ident = IR_create_node (IR_NM_unique_ident);
  temp_unique_int = IR_create_node (IR_NM_unique_int);
  temp_unique_float = IR_create_node (IR_NM_unique_float);
  temp_unique_char = IR_create_node (IR_NM_unique_char);
  temp_unique_string = IR_create_node (IR_NM_unique_string);
  temp_ident = IR_create_node (IR_NM_ident);
  temp_decl = IR_create_node (IR_NM_var);
  temp_var_occurrence = IR_create_node (IR_NM_var_occurrence);
  destroy_unique_ident = create_unique_ident_node ("destroy");
}



/* This page contains func for searching for idents according to
   language visibility rules. */

/* The func returns pointer to decl with key (IDENT, SCOPE)
   or NULL if such decl does not exist.  IDENT is to be not NULL.
   SCOPE may be NULL. */

IR_node_t
find_decl_in_given_scope (IR_node_t ident, IR_node_t scope)
{
  IR_set_ident (temp_decl, ident);
  IR_set_scope (temp_decl, scope);
  return *find_table_entry (temp_decl, FALSE);
}

/* The func returns pointer to decl visible according language
   rule from SCOPE and designated by IDENT, or returns NULL if such
   decl does not exist.  IDENT is to be not NULL.
   SCOPE may be NULL. */

IR_node_t
find_decl (IR_node_t ident, IR_node_t scope)
{
  IR_node_t decl;

  assert (scope != NULL);
  for (;;)
    {
      decl = find_decl_in_given_scope (ident, scope);
      if (decl != NULL || scope == NULL)
	break;
      scope = IR_block_scope (scope);
    }
  return decl;
}

/* The following function sets up the variable *PTR to corresponding
   declarations from the environment with given name. */
static void
set_a_environment_declaration (IR_node_t *ptr, char *name,
			       IR_node_t environment_scope,
			       implementation_func_t func)
{
  IR_node_t unique_ident;

  unique_ident = find_unique_ident (name);
  assert (unique_ident != NULL);
  IR_set_unique_ident (temp_ident, unique_ident);
  *ptr = find_decl_in_given_scope (temp_ident, environment_scope);
  assert (*ptr != NULL);
  IR_set_implementation_func (*ptr, func);
}

/* See comments for ENVIRONMENT. */
IR_node_t except_decl;
IR_node_t error_decl;
IR_node_t signal_decl;
IR_node_t sigint_decl;
IR_node_t sigill_decl;
IR_node_t sigabrt_decl;
IR_node_t sigfpe_decl;
IR_node_t sigterm_decl;
IR_node_t sigsegv_decl;
IR_node_t invenv_decl;
IR_node_t invop_decl;
IR_node_t optype_decl;
IR_node_t opvalue_decl;
IR_node_t invindex_decl;
IR_node_t indextype_decl;
IR_node_t indexvalue_decl;
IR_node_t indexop_decl;
IR_node_t invkey_decl;
IR_node_t keyvalue_decl;
IR_node_t keyop_decl;
IR_node_t invcall_decl;
IR_node_t callop_decl;
IR_node_t partype_decl;
IR_node_t invresult_decl;
IR_node_t invinput_decl;
IR_node_t invfmt_decl;
IR_node_t eof_decl;
IR_node_t parnumber_decl;
IR_node_t syncthreadcall_decl;
IR_node_t syserror_decl;
IR_node_t eaccess_decl;
IR_node_t eagain_decl;
IR_node_t ebadf_decl;
IR_node_t ebusy_decl;
IR_node_t echild_decl;
IR_node_t edeadlk_decl;
IR_node_t edom_decl;
IR_node_t eexist_decl;
IR_node_t efault_decl;
IR_node_t efbig_decl;
IR_node_t eintr_decl;
IR_node_t einval_decl;
IR_node_t eio_decl;
IR_node_t eisdir_decl;
IR_node_t emfile_decl;
IR_node_t emlink_decl;
IR_node_t enametoolong_decl;
IR_node_t enfile_decl;
IR_node_t enodev_decl;
IR_node_t enoent_decl;
IR_node_t enoexec_decl;
IR_node_t enolck_decl;
IR_node_t enomem_decl;
IR_node_t enospc_decl;
IR_node_t enosys_decl;
IR_node_t enotdir_decl;
IR_node_t enotempty_decl;
IR_node_t enotty_decl;
IR_node_t enxio_decl;
IR_node_t eperm_decl;
IR_node_t epipe_decl;
IR_node_t erange_decl;
IR_node_t erofs_decl;
IR_node_t espipe_decl;
IR_node_t esrch_decl;
IR_node_t exdev_decl;
IR_node_t invextern_decl;
IR_node_t noextern_decl;
IR_node_t libclose_decl;
IR_node_t noexternsupp_decl;
IR_node_t invenvar_decl;
IR_node_t internal_decl;
IR_node_t systemcall_decl;
IR_node_t noshell_decl;
IR_node_t systemfail_decl;
IR_node_t invregexp_decl;
IR_node_t ebrack_decl;
IR_node_t reg_erange_decl;
IR_node_t ectype_decl;
IR_node_t eparen_decl;
IR_node_t esubreg_decl;
IR_node_t eend_decl;
IR_node_t eescape_decl;
IR_node_t badpat_decl;
IR_node_t esize_decl;
IR_node_t espace_decl;
IR_node_t invparser_decl;
IR_node_t invgrammar_decl;
IR_node_t invtoken_decl;
IR_node_t pmemory_decl;
IR_node_t invaccess_decl;
IR_node_t accessop_decl;
IR_node_t accessvalue_decl;
IR_node_t immutable_decl;
IR_node_t deadlock_decl;
IR_node_t syncwait_decl;
IR_node_t excepts_decl;
IR_node_t errors_decl;
IR_node_t signals_decl;
IR_node_t invops_decl;
IR_node_t invindexes_decl;
IR_node_t invkeys_decl;
IR_node_t syserrors_decl;
IR_node_t invcalls_decl;
IR_node_t systemcalls_decl;
IR_node_t invregexps_decl;
IR_node_t invparsers_decl;
IR_node_t invexterns_decl;
IR_node_t invaccesses_decl;
IR_node_t argv_decl;
IR_node_t env_decl;
IR_node_t version_decl;
IR_node_t main_thread_decl;
IR_node_t curr_thread_decl;
IR_node_t anode_decl;
IR_node_t token_decl;
IR_node_t code_decl;
IR_node_t nil_anode_decl;
IR_node_t error_anode_decl;
IR_node_t parser_decl;
IR_node_t ambiguous_p_decl;
IR_node_t int_earley_parse_grammar_decl;
IR_node_t int_earley_set_debug_level_decl;
IR_node_t int_earley_set_one_parse_flag_decl;
IR_node_t int_earley_set_lookahead_level_decl;
IR_node_t int_earley_set_cost_flag_decl;
IR_node_t int_earley_set_error_recovery_flag_decl;
IR_node_t int_earley_set_recovery_match_decl;
IR_node_t int_earley_parse_decl;
IR_node_t int_earley_create_grammar_decl;
IR_node_t file_decl;
IR_node_t file_ptr_decl;
IR_node_t stdin_decl;
IR_node_t stdout_decl;
IR_node_t stderr_decl;
IR_node_t min_decl;
IR_node_t max_decl;
IR_node_t tolower_decl;
IR_node_t toupper_decl;
IR_node_t trans_decl;
IR_node_t eltype_decl;
IR_node_t keys_decl;
IR_node_t context_decl;
IR_node_t inside_decl;
IR_node_t subv_decl;
IR_node_t cmpv_decl;
IR_node_t del_decl;
IR_node_t ins_decl;
IR_node_t insv_decl;
IR_node_t rev_decl;
IR_node_t sort_decl;
IR_node_t sqrt_decl;
IR_node_t exp_decl;
IR_node_t log_decl;
IR_node_t log10_decl;
IR_node_t pow_decl;
IR_node_t sin_decl;
IR_node_t cos_decl;
IR_node_t atan2_decl;
IR_node_t match_decl;
IR_node_t gmatch_decl;
IR_node_t sub_decl;
IR_node_t gsub_decl;
IR_node_t split_decl;
IR_node_t split_regex_decl;
IR_node_t srand_decl;
IR_node_t rand_decl;
IR_node_t process_errno_decl;
IR_node_t readdir_decl;
IR_node_t ftype_decl;
IR_node_t fun_decl;
IR_node_t fgn_decl;
IR_node_t fsize_decl;
IR_node_t fatime_decl;
IR_node_t fmtime_decl;
IR_node_t fctime_decl;
IR_node_t fumode_decl;
IR_node_t fgmode_decl;
IR_node_t fomode_decl;
IR_node_t time_decl;
IR_node_t strtime_decl;
IR_node_t time_format_decl;
IR_node_t clock_decl;
IR_node_t gc_decl;
IR_node_t rename_decl;
IR_node_t remove_decl;
IR_node_t mkdir_decl;
IR_node_t rmdir_decl;
IR_node_t getcwd_decl;
IR_node_t chdir_decl;
IR_node_t chumod_decl;
IR_node_t chgmod_decl;
IR_node_t chomod_decl;
IR_node_t isatty_decl;
IR_node_t open_decl;
IR_node_t close_decl;
IR_node_t flush_decl;
IR_node_t popen_decl;
IR_node_t pclose_decl;
IR_node_t tell_decl;
IR_node_t seek_decl;
IR_node_t put_decl;
IR_node_t putln_decl;
IR_node_t fput_decl;
IR_node_t fputln_decl;
IR_node_t sput_decl;
IR_node_t sputln_decl;
IR_node_t putf_decl;
IR_node_t fputf_decl;
IR_node_t sputf_decl;
IR_node_t print_decl;
IR_node_t println_decl;
IR_node_t fprint_decl;
IR_node_t fprintln_decl;
IR_node_t sprint_decl;
IR_node_t sprintln_decl;
IR_node_t get_decl;
IR_node_t getln_decl;
IR_node_t getf_decl;
IR_node_t fget_decl;
IR_node_t fgetln_decl;
IR_node_t fgetf_decl;
IR_node_t scan_decl;
IR_node_t scanln_decl;
IR_node_t fscan_decl;
IR_node_t fscanln_decl;
IR_node_t getpid_decl;
IR_node_t getpgid_decl;
IR_node_t getun_decl;
IR_node_t geteun_decl;
IR_node_t getgn_decl;
IR_node_t getegn_decl;
IR_node_t getgroups_decl;
IR_node_t system_decl;
IR_node_t exit_decl;
IR_node_t init_decl;

struct decl_entry
{
  IR_node_t *decl_ptr;
  char *name;
  IR_node_t *scope_ptr;
  implementation_func_t func_ptr;
};


static struct decl_entry decls_table [] =
{
  {&except_decl, EXCEPT_NAME, NULL, NULL},
  {&error_decl, ERROR_NAME, &except_decl, NULL},
  {&signal_decl, SIGNAL_NAME, &error_decl, NULL},
  {&sigint_decl, SIGINT_NAME, &signal_decl, NULL},
  {&sigill_decl, SIGILL_NAME, &signal_decl, NULL},
  {&sigabrt_decl, SIGABRT_NAME, &signal_decl, NULL},
  {&sigfpe_decl, SIGFPE_NAME, &signal_decl, NULL},
  {&sigterm_decl, SIGTERM_NAME, &signal_decl, NULL},
  {&sigsegv_decl, SIGSEGV_NAME, &signal_decl, NULL},
  {&invenv_decl, INVENV_NAME, &error_decl, NULL},
  {&invop_decl, INVOP_NAME, &error_decl, NULL},
  {&optype_decl, OPTYPE_NAME, &invop_decl, NULL},
  {&opvalue_decl, OPVALUE_NAME, &invop_decl, NULL},
  {&invindex_decl, INVINDEX_NAME, &error_decl, NULL},
  {&indextype_decl, INDEXTYPE_NAME, &invindex_decl, NULL},
  {&indexvalue_decl, INDEXVALUE_NAME, &invindex_decl, NULL},
  {&indexop_decl, INDEXOP_NAME, &invindex_decl, NULL},
  {&invkey_decl, INVKEY_NAME, &error_decl, NULL},
  {&keyvalue_decl, KEYVALUE_NAME, &invkey_decl, NULL},
  {&keyop_decl, KEYOP_NAME, &invkey_decl, NULL},
  {&invcall_decl, INVCALL_NAME, &error_decl, NULL},
  {&callop_decl, CALLOP_NAME, &invcall_decl, NULL},
  {&partype_decl, PARTYPE_NAME, &invcall_decl, NULL},
  {&invresult_decl, INVRESULT_NAME, &invcall_decl, NULL},
  {&invinput_decl, INVINPUT_NAME, &invcall_decl, NULL},
  {&invfmt_decl, INVFMT_NAME, &invcall_decl, NULL},
  {&eof_decl, EOF_NAME, &invcall_decl, NULL},
  {&parnumber_decl, PARNUMBER_NAME, &invcall_decl, NULL},
  {&syncthreadcall_decl, SYNCTHREADCALL_NAME, &invcall_decl, NULL},
  {&syserror_decl, SYSERROR_NAME, &invcall_decl, NULL},
  {&eaccess_decl, EACCESS_NAME, &syserror_decl, NULL},
  {&eagain_decl, EAGAIN_NAME, &syserror_decl, NULL},
  {&ebadf_decl, EBADF_NAME, &syserror_decl, NULL},
  {&ebusy_decl, EBUSY_NAME, &syserror_decl, NULL},
  {&echild_decl, ECHILD_NAME, &syserror_decl, NULL},
  {&edeadlk_decl, EDEADLK_NAME, &syserror_decl, NULL},
  {&edom_decl, EDOM_NAME, &syserror_decl, NULL},
  {&eexist_decl, EEXIST_NAME, &syserror_decl, NULL},
  {&efault_decl, EFAULT_NAME, &syserror_decl, NULL},
  {&efbig_decl, EFBIG_NAME, &syserror_decl, NULL},
  {&eintr_decl, EINTR_NAME, &syserror_decl, NULL},
  {&einval_decl, EINVAL_NAME, &syserror_decl, NULL},
  {&eio_decl, EIO_NAME, &syserror_decl, NULL},
  {&eisdir_decl, EISDIR_NAME, &syserror_decl, NULL},
  {&emfile_decl, EMFILE_NAME, &syserror_decl, NULL},
  {&emlink_decl, EMLINK_NAME, &syserror_decl, NULL},
  {&enametoolong_decl, ENAMETOOLONG_NAME, &syserror_decl, NULL},
  {&enfile_decl, ENFILE_NAME, &syserror_decl, NULL},
  {&enodev_decl, ENODEV_NAME, &syserror_decl, NULL},
  {&enoent_decl, ENOENT_NAME, &syserror_decl, NULL},
  {&enoexec_decl, ENOEXEC_NAME, &syserror_decl, NULL},
  {&enolck_decl, ENOLCK_NAME, &syserror_decl, NULL},
  {&enomem_decl, ENOMEM_NAME, &syserror_decl, NULL},
  {&enospc_decl, ENOSPC_NAME, &syserror_decl, NULL},
  {&enosys_decl, ENOSYS_NAME, &syserror_decl, NULL},
  {&enotdir_decl, ENOTDIR_NAME, &syserror_decl, NULL},
  {&enotempty_decl, ENOTEMPTY_NAME, &syserror_decl, NULL},
  {&enotty_decl, ENOTTY_NAME, &syserror_decl, NULL},
  {&enxio_decl, ENXIO_NAME, &syserror_decl, NULL},
  {&eperm_decl, EPERM_NAME, &syserror_decl, NULL},
  {&epipe_decl, EPIPE_NAME, &syserror_decl, NULL},
  {&erange_decl, ERANGE_NAME, &syserror_decl, NULL},
  {&erofs_decl, EROFS_NAME, &syserror_decl, NULL},
  {&espipe_decl, ESPIPE_NAME, &syserror_decl, NULL},
  {&esrch_decl, ESRCH_NAME, &syserror_decl, NULL},
  {&exdev_decl, EXDEV_NAME, &syserror_decl, NULL},
  {&systemcall_decl, SYSTEMCALL_NAME, &invcall_decl, NULL},
  {&noshell_decl, NOSHELL_NAME, &systemcall_decl, NULL},
  {&systemfail_decl, SYSTEMFAIL_NAME, &systemcall_decl, NULL},
  {&invregexp_decl, INVREGEXP_NAME, &invcall_decl, NULL},
  {&ebrack_decl, EBRACK_NAME, &invregexp_decl, NULL},
  {&reg_erange_decl, REG_ERANGE_NAME, &invregexp_decl, NULL},
  {&ectype_decl, ECTYPE_NAME, &invregexp_decl, NULL},
  {&eparen_decl, EPAREN_NAME, &invregexp_decl, NULL},
  {&esubreg_decl, ESUBREG_NAME, &invregexp_decl, NULL},
  {&eend_decl, EEND_NAME, &invregexp_decl, NULL},
  {&eescape_decl, EESCAPE_NAME, &invregexp_decl, NULL},
  {&badpat_decl, BADPAT_NAME, &invregexp_decl, NULL},
  {&esize_decl, ESIZE_NAME, &invregexp_decl, NULL},
  {&espace_decl, ESPACE_NAME, &invregexp_decl, NULL},
  {&invparser_decl, INVPARSER_NAME, &invcall_decl, NULL},
  {&invgrammar_decl, INVGRAMMAR_NAME, &invparser_decl, NULL},
  {&invtoken_decl, INVTOKEN_NAME, &invparser_decl, NULL},
  {&pmemory_decl, PMEMORY_NAME, &invparser_decl, NULL},
  {&invextern_decl, INVEXTERN_NAME, &invcall_decl, NULL},
  {&noextern_decl, NOEXTERN_NAME, &invextern_decl, NULL},
  {&libclose_decl, LIBCLOSE_NAME, &invextern_decl, NULL},
  {&noexternsupp_decl, NOEXTERNSUPP_NAME, &invextern_decl, NULL},
  {&invenvar_decl, INVENVAR_NAME, &invcall_decl, NULL},
  {&internal_decl, INTERNAL_NAME, &invcall_decl, NULL},
  {&invaccess_decl, INVACCESS_NAME, &error_decl, NULL},
  {&accessop_decl, ACCESSOP_NAME, &invaccess_decl, NULL},
  {&accessvalue_decl, ACCESSVALUE_NAME, &invaccess_decl, NULL},
  {&immutable_decl, IMMUTABLE_NAME, &invaccess_decl, NULL},
  {&deadlock_decl, DEADLOCK_NAME, &error_decl, NULL},
  {&syncwait_decl, SYNCWAIT_NAME, &error_decl, NULL},
  {&excepts_decl, EXCEPTS_NAME, NULL, NULL},
  {&errors_decl, ERRORS_NAME, NULL, NULL},
  {&signals_decl, SIGNALS_NAME, NULL, NULL},
  {&invops_decl, INVOPS_NAME, NULL, NULL},
  {&invindexes_decl, INVINDEXES_NAME, NULL, NULL},
  {&invkeys_decl, INVKEYS_NAME, NULL, NULL},
  {&syserrors_decl, SYSERRORS_NAME, NULL, NULL},
  {&invcalls_decl, INVCALLS_NAME, NULL, NULL},
  {&systemcalls_decl, SYSTEMCALLS_NAME, NULL, NULL},
  {&invregexps_decl, INVREGEXPS_NAME, NULL, NULL},
  {&invparsers_decl, INVPARSERS_NAME, NULL, NULL},
  {&invexterns_decl, INVEXTERNS_NAME, NULL, NULL},
  {&invaccesses_decl, INVACCESSES_NAME, NULL, NULL},
  {&argv_decl, ARGV_NAME, NULL, NULL},
  {&env_decl, ENV_NAME, NULL, NULL},
  {&version_decl, VERSION_NAME, NULL, NULL},
  {&main_thread_decl, MAIN_THREAD_NAME, NULL, NULL},
  {&curr_thread_decl, CURR_THREAD_NAME, NULL, NULL},
  {&anode_decl, ANODE_NAME, NULL, NULL},
  {&token_decl, TOKEN_NAME, NULL, NULL},
  {&code_decl, CODE_NAME, &token_decl, NULL},
  {&nil_anode_decl, NIL_ANODE_NAME, NULL, NULL},
  {&error_anode_decl, ERROR_ANODE_NAME, NULL, NULL},
  {&parser_decl, PARSER_NAME, NULL, NULL},
  {&ambiguous_p_decl, AMBIGUOUS_P_NAME, &parser_decl, NULL},
  {&int_earley_parse_grammar_decl, INT_EARLEY_PARSE_GRAMMAR_NAME,
   &parser_decl, int_earley_parse_grammar},
  {&int_earley_set_debug_level_decl, INT_EARLEY_SET_DEBUG_LEVEL_NAME,
   &parser_decl, int_earley_set_debug_level},
  {&int_earley_set_one_parse_flag_decl, INT_EARLEY_SET_ONE_PARSE_FLAG_NAME,
   &parser_decl, int_earley_set_one_parse_flag},
  {&int_earley_set_lookahead_level_decl, INT_EARLEY_SET_LOOKAHEAD_LEVEL_NAME,
   &parser_decl, int_earley_set_lookahead_level},
  {&int_earley_set_cost_flag_decl, INT_EARLEY_SET_COST_FLAG_NAME,
   &parser_decl, int_earley_set_cost_flag},
  {&int_earley_set_error_recovery_flag_decl,
   INT_EARLEY_SET_ERROR_RECOVERY_FLAG_NAME, &parser_decl,
   int_earley_set_error_recovery_flag},
  {&int_earley_set_recovery_match_decl, INT_EARLEY_SET_RECOVERY_MATCH_NAME,
   &parser_decl, int_earley_set_recovery_match},
  {&int_earley_parse_decl, INT_EARLEY_PARSE_NAME,
   &parser_decl, int_earley_parse},
  {&int_earley_create_grammar_decl, INT_EARLEY_CREATE_GRAMMAR_NAME,
   &parser_decl, int_earley_create_grammar},
  {&file_decl, FILE_NAME, NULL, NULL},
  {&file_ptr_decl, FILE_PTR_NAME, &file_decl, NULL},
  {&stdin_decl, STDIN_NAME, NULL, NULL},
  {&stdout_decl, STDOUT_NAME, NULL, NULL},
  {&stderr_decl, STDERR_NAME, NULL, NULL},
  {&min_decl, MIN_NAME, NULL, min_call},
  {&max_decl, MAX_NAME, NULL, max_call},
  {&tolower_decl, TOLOWER_NAME, NULL, tolower_call},
  {&toupper_decl, TOUPPER_NAME, NULL, toupper_call},
  {&trans_decl, TRANS_NAME, NULL, trans_call},
  {&eltype_decl, ELTYPE_NAME, NULL, eltype_call},
  {&keys_decl, KEYS_NAME, NULL, keys_call},
  {&context_decl, CONTEXT_NAME, NULL, context_call},
  {&inside_decl, INSIDE_NAME, NULL, inside_call},
  {&subv_decl, SUBV_NAME, NULL, subv_call},
  {&cmpv_decl, CMPV_NAME, NULL, cmpv_call},
  {&del_decl, DEL_NAME, NULL, del_call},
  {&ins_decl, INS_NAME, NULL, ins_call},
  {&insv_decl, INSV_NAME, NULL, insv_call},
  {&rev_decl, REV_NAME, NULL, rev_call},
  {&sort_decl, SORT_NAME, NULL, sort_call},
  {&sqrt_decl, SQRT_NAME, NULL, sqrt_call},
  {&exp_decl, EXP_NAME, NULL, exp_call},
  {&log_decl, LOG_NAME, NULL, log_call},
  {&log10_decl, LOG10_NAME, NULL, log10_call},
  {&pow_decl, POW_NAME, NULL, pow_call},
  {&sin_decl, SIN_NAME, NULL, sin_call},
  {&cos_decl, COS_NAME, NULL, cos_call},
  {&atan2_decl, ATAN2_NAME, NULL, atan2_call},
  {&match_decl, MATCH_NAME, NULL, match_call},
  {&gmatch_decl, GMATCH_NAME, NULL, gmatch_call},
  {&sub_decl, SUB_NAME, NULL, sub_call},
  {&gsub_decl, GSUB_NAME, NULL, gsub_call},
  {&split_regex_decl, SPLIT_REGEX_NAME, NULL, NULL},
  {&split_decl, SPLIT_NAME, NULL, split_call},
  {&srand_decl, SRAND_NAME, NULL, srand_call},
  {&rand_decl, RAND_NAME, NULL, rand_call},
  {&process_errno_decl, PROCESS_ERRNO_NAME, NULL, process_errno_call},
  {&readdir_decl, READDIR_NAME, NULL, readdir_call},
  {&ftype_decl, FTYPE_NAME, NULL, ftype_call},
  {&fun_decl, FUN_NAME, NULL, fun_call},
  {&fgn_decl, FGN_NAME, NULL, fgn_call},
  {&fsize_decl, FSIZE_NAME, NULL, fsize_call},
  {&fatime_decl, FATIME_NAME, NULL, fatime_call},
  {&fmtime_decl, FMTIME_NAME, NULL, fmtime_call},
  {&fctime_decl, FCTIME_NAME, NULL, fctime_call},
  {&fumode_decl, FUMODE_NAME, NULL, fumode_call},
  {&fgmode_decl, FGMODE_NAME, NULL, fgmode_call},
  {&fomode_decl, FOMODE_NAME, NULL, fomode_call},
  {&time_decl, TIME_NAME, NULL, time_call},
  {&strtime_decl, STRTIME_NAME, NULL, strtime_call},
  {&time_format_decl, TIME_FORMAT_NAME, NULL, NULL},
  {&clock_decl, CLOCK_NAME, NULL, clock_call},
  {&gc_decl, GC_NAME, NULL, gc_call},
  {&rename_decl, RENAME_NAME, NULL, rename_call},
  {&remove_decl, REMOVE_NAME, NULL, remove_call},
  {&mkdir_decl, MKDIR_NAME, NULL, mkdir_call},
  {&rmdir_decl, RMDIR_NAME, NULL, rmdir_call},
  {&getcwd_decl, GETCWD_NAME, NULL, getcwd_call},
  {&chdir_decl, CHDIR_NAME, NULL, chdir_call},
  {&chumod_decl, CHUMOD_NAME, NULL, chumod_call},
  {&chgmod_decl, CHGMOD_NAME, NULL, chgmod_call},
  {&chomod_decl, CHOMOD_NAME, NULL, chomod_call},
  {&isatty_decl, ISATTY_NAME, NULL, isatty_call},
  {&open_decl, OPEN_NAME, NULL, open_call},
  {&close_decl, CLOSE_NAME, NULL, close_call},
  {&flush_decl, FLUSH_NAME, NULL, flush_call},
  {&popen_decl, POPEN_NAME, NULL, popen_call},
  {&pclose_decl, PCLOSE_NAME, NULL, pclose_call},
  {&tell_decl, TELL_NAME, NULL, tell_call},
  {&seek_decl, SEEK_NAME, NULL, seek_call},
  {&put_decl, PUT_NAME, NULL, put_call},
  {&putln_decl, PUTLN_NAME, NULL, putln_call},
  {&fput_decl, FPUT_NAME, NULL, fput_call},
  {&fputln_decl, FPUTLN_NAME, NULL, fputln_call},
  {&sput_decl, SPUT_NAME, NULL, sput_call},
  {&sputln_decl, SPUTLN_NAME, NULL, sputln_call},
  {&putf_decl, PUTF_NAME, NULL, putf_call},
  {&fputf_decl, FPUTF_NAME, NULL, fputf_call},
  {&sputf_decl, SPUTF_NAME, NULL, sputf_call},
  {&print_decl, PRINT_NAME, NULL, print_call},
  {&println_decl, PRINTLN_NAME, NULL, println_call},
  {&fprint_decl, FPRINT_NAME, NULL, fprint_call},
  {&fprintln_decl, FPRINTLN_NAME, NULL, fprintln_call},
  {&sprint_decl, SPRINT_NAME, NULL, sprint_call},
  {&sprintln_decl, SPRINTLN_NAME, NULL, sprintln_call},
  {&get_decl, GET_NAME, NULL, get_call},
  {&getln_decl, GETLN_NAME, NULL, getln_call},
  {&getf_decl, GETF_NAME, NULL, getf_call},
  {&fget_decl, FGET_NAME, NULL, fget_call},
  {&fgetln_decl, FGETLN_NAME, NULL, fgetln_call},
  {&fgetf_decl, FGETF_NAME, NULL, fgetf_call},
  {&scan_decl, SCAN_NAME, NULL, scan_call},
  {&scanln_decl, SCANLN_NAME, NULL, scanln_call},
  {&fscan_decl, FSCAN_NAME, NULL, fscan_call},
  {&fscanln_decl, FSCANLN_NAME, NULL, fscanln_call},
  {&getpid_decl, GETPID_NAME, NULL, getpid_call},
  {&getun_decl, GETUN_NAME, NULL, getun_call},
  {&geteun_decl, GETEUN_NAME, NULL, geteun_call},
  {&getgn_decl, GETGN_NAME, NULL, getgn_call},
  {&getegn_decl, GETEGN_NAME, NULL, getegn_call},
  {&getgroups_decl, GETGROUPS_NAME, NULL, getgroups_call},
  {&system_decl, SYSTEM_NAME, NULL, system_call},
  {&exit_decl, EXIT_NAME, NULL, exit_call},
  {&init_decl, INIT_NAME, NULL, init_call}
};

/* The following function sets up the variables above to corresponding
   declarations from the environment with given scope. */
void
set_environment_declarations (IR_node_t environment_scope)
{
  int i;

  for (i = 0; i < sizeof (decls_table) / sizeof (decls_table [0]); i++)
    set_a_environment_declaration
      (decls_table[i].decl_ptr, decls_table[i].name,
       (decls_table[i].scope_ptr == NULL
	? environment_scope
	: IR_next_stmt (*decls_table[i].scope_ptr)),
       decls_table[i].func_ptr);
}



/* Return new identifier node with given NAME and POS. */

IR_node_t
get_ident_node (char *name, position_t pos)
{
  IR_node_t result;

  result = create_node_with_pos (IR_NM_ident, pos);
  IR_set_unique_ident (result, create_unique_ident_node (name));
  return result;
}

/* Return new int node with given NUMBER_VALUE and POS. */

IR_node_t
get_int_node (int_t number_value, position_t pos)
{
  IR_node_t result;
  IR_node_t unique_number_value_node;

  IR_set_int_value (temp_unique_int, number_value);
  unique_number_value_node = *find_table_entry (temp_unique_int, FALSE);
  if (unique_number_value_node == NULL)
    {
      unique_number_value_node = create_node (IR_NM_unique_int);
      IR_set_int_value (unique_number_value_node, number_value);
      include_to_table (unique_number_value_node);
    }
  result = create_node_with_pos (IR_NM_int, pos);
  IR_set_unique_int (result, unique_number_value_node);
  return result;
}


/* Return new number node with given NUMBER_VALUE and POS. */

IR_node_t
get_float_node (floating_t number_value, position_t pos)
{
  IR_node_t result;
  IR_node_t unique_number_value_node;

  IR_set_float_value (temp_unique_float, number_value);
  unique_number_value_node = *find_table_entry (temp_unique_float, FALSE);
  if (unique_number_value_node == NULL)
    {
      unique_number_value_node = create_node (IR_NM_unique_float);
      IR_set_float_value (unique_number_value_node, number_value);
      include_to_table (unique_number_value_node);
    }
  result = create_node_with_pos (IR_NM_float, pos);
  IR_set_unique_float (result, unique_number_value_node);
  return result;
}



/* This page contains functions for transformation to/from string. */

int
it_is_int_string (const char *str)
{
  for (; *str != '\0'; str++)
    if (!isdigit (*str))
      return FALSE;
  return TRUE;
}

/* The function returns int_t value for character number
   representation.  It always change the value of ERRNO. */
int_t
a2i (const char *str)
{
  int_t res;
  long int l;

  errno = 0;
#ifdef HAVE_STRTOL
  l = strtol (str, (char **) NULL, 10);
  res = l;
#ifdef ERANGE
  if (res != l)
    errno = ERANGE;
#endif
#else
  res = atoi (str);
#endif
  return res;
}

/* The function returns floating_t value for character number
   representation.  It always change the value of ERRNO. */
floating_t
a2f (const char *str)
{
  double d;
  floating_t res;

  errno = 0;
#ifdef HAVE_STRTOD
  d = strtod (str, (char **) NULL);
  res = d;
#ifdef ERANGE
  if (res != d)
    errno = ERANGE;
#endif
#else
  res = atof (str);
#endif
  return res;
}

const char *
i2a (int_t number)
{
  static char result [30];
  sprintf (result, "%ld", (long int) number);
  return result;
}

extern const char *
f2a (floating_t number)
{
  static char result [30];
  sprintf (result, "%g", number);
  return result;
}

