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

#ifndef ER_START_ALLOC
#define ER_START_ALLOC()
#endif

#ifndef ER_STOP_ALLOC
#define ER_STOP_ALLOC()
#endif

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

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

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

#ifndef ER_END_ER_node_t
#define ER_END_ER_node_t(a)
#endif

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

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

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

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

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

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

#ifndef ER_END_bool_t
#define ER_END_bool_t(a)
#endif

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

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

#ifndef ER_PRINT_bool_t
#define ER_PRINT_bool_t(a)
#endif

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

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

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

#ifndef ER_END_size_t
#define ER_END_size_t(a)
#endif

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

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

#ifndef ER_PRINT_size_t
#define ER_PRINT_size_t(a)
#endif

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

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

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

#ifndef ER_END_hide_t
#define ER_END_hide_t(a)
#endif

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

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

#ifndef ER_PRINT_hide_t
#define ER_PRINT_hide_t(a)
#endif

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

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

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

#ifndef ER_END_char_t
#define ER_END_char_t(a)
#endif

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

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

#ifndef ER_PRINT_char_t
#define ER_PRINT_char_t(a)
#endif

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

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

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

#ifndef ER_END_int_t
#define ER_END_int_t(a)
#endif

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

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

#ifndef ER_PRINT_int_t
#define ER_PRINT_int_t(a)
#endif

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

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

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

#ifndef ER_END_unsigned_int_t
#define ER_END_unsigned_int_t(a)
#endif

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

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

#ifndef ER_PRINT_unsigned_int_t
#define ER_PRINT_unsigned_int_t(a)
#endif

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

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

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

#ifndef ER_END_floating_t
#define ER_END_floating_t(a)
#endif

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

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

#ifndef ER_PRINT_floating_t
#define ER_PRINT_floating_t(a)
#endif

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

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

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

#ifndef ER_END_char_ptr_t
#define ER_END_char_ptr_t(a)
#endif

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

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

#ifndef ER_PRINT_char_ptr_t
#define ER_PRINT_char_ptr_t(a)
#endif

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

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

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

#ifndef ER_END_instance_state_t
#define ER_END_instance_state_t(a)
#endif

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

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

#ifndef ER_PRINT_instance_state_t
#define ER_PRINT_instance_state_t(a)
#endif

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

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

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

#ifndef ER_END_IR_hidden_node_t
#define ER_END_IR_hidden_node_t(a)
#endif

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

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

#ifndef ER_PRINT_IR_hidden_node_t
#define ER_PRINT_IR_hidden_node_t(a)
#endif

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

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

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

#ifndef ER_END_ER_type_t
#define ER_END_ER_type_t(a)
#endif

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

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

#ifndef ER_PRINT_ER_type_t
#define ER_PRINT_ER_type_t(a)
#endif

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

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

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

#ifndef ER_END_ER_node_mode_t
#define ER_END_ER_node_mode_t(a)
#endif

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

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

#ifndef ER_PRINT_ER_node_mode_t
#define ER_PRINT_ER_node_mode_t(a)
#endif

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

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

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

#ifndef ER_END_process_status_t
#define ER_END_process_status_t(a)
#endif

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

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

#ifndef ER_PRINT_process_status_t
#define ER_PRINT_process_status_t(a)
#endif

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

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

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

#ifndef ER_END_stack_ptr_t
#define ER_END_stack_ptr_t(a)
#endif

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

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

#ifndef ER_PRINT_stack_ptr_t
#define ER_PRINT_stack_ptr_t(a)
#endif

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

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

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

#ifndef ER_END_pc_t
#define ER_END_pc_t(a)
#endif

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

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

#ifndef ER_PRINT_pc_t
#define ER_PRINT_pc_t(a)
#endif

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

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

short _ER_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,
  1,
  0,
  0
};

unsigned char _ER_SF_heap_obj [] =
{255, 7, 0, 32
};

unsigned char _ER_SF_heap_vect_tab [] =
{62, 0, 0, 32
};

unsigned char _ER_SF_heap_vect [] =
{28, 0, 0, 0
};

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

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

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

unsigned char _ER_SF_context_heap_obj [] =
{192, 3, 0, 0
};

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

unsigned char *_ER_is_type[] =
{
_ER_SF_heap_obj,
_ER_SF_heap_vect_tab,
_ER_SF_heap_vect,
_ER_SF_heap_pack_vect,
_ER_SF_heap_unpack_vect,
_ER_SF_heap_tab,
_ER_SF_context_heap_obj,
_ER_SF_heap_instance,
_ER_SF_heap_stack,
_ER_SF_heap_process,
_ER_SF_heap_hideblock,
_ER_SF_val,
_ER_SF_nil,
_ER_SF_hide,
_ER_SF_hideblock,
_ER_SF_char,
_ER_SF_int,
_ER_SF_float,
_ER_SF_type,
_ER_SF_vect,
_ER_SF_tab,
_ER_SF_empty_entry,
_ER_SF_deleted_entry,
_ER_SF_instance,
_ER_SF_func,
_ER_SF_class,
_ER_SF_stack,
_ER_SF_process,
_ER_SF_external_var_ref,
_ER_SF_heap_redir,
_ER_SF__root,
_ER_SF__error
};

void *_ER_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,
};

char *ER_node_name[] =
{
  "heap_obj",
  "heap_vect_tab",
  "heap_vect",
  "heap_pack_vect",
  "heap_unpack_vect",
  "heap_tab",
  "context_heap_obj",
  "heap_instance",
  "heap_stack",
  "heap_process",
  "heap_hideblock",
  "val",
  "nil",
  "hide",
  "hideblock",
  "char",
  "int",
  "float",
  "type",
  "vect",
  "tab",
  "empty_entry",
  "deleted_entry",
  "instance",
  "func",
  "class",
  "stack",
  "process",
  "external_var_ref",
  "heap_redir",
  "%root",
  "%error"
};

unsigned char ER_node_size[] =
{
  sizeof (_ER_heap_obj),
  sizeof (_ER_heap_vect_tab),
  sizeof (_ER_heap_vect),
  sizeof (_ER_heap_pack_vect),
  sizeof (_ER_heap_unpack_vect),
  sizeof (_ER_heap_tab),
  sizeof (_ER_context_heap_obj),
  sizeof (_ER_heap_instance),
  sizeof (_ER_heap_stack),
  sizeof (_ER_heap_process),
  sizeof (_ER_heap_hideblock),
  sizeof (_ER_val),
  sizeof (_ER_nil),
  sizeof (_ER_hide),
  sizeof (_ER_hideblock),
  sizeof (_ER_char),
  sizeof (_ER_int),
  sizeof (_ER_float),
  sizeof (_ER_type),
  sizeof (_ER_vect),
  sizeof (_ER_tab),
  sizeof (_ER_empty_entry),
  sizeof (_ER_deleted_entry),
  sizeof (_ER_instance),
  sizeof (_ER_func),
  sizeof (_ER_class),
  sizeof (_ER_stack),
  sizeof (_ER_process),
  sizeof (_ER_external_var_ref),
  sizeof (_ER_heap_redir),
  sizeof (_ER__root),
  sizeof (_ER__error)
};

static int (* _ER_traverse_guard_function_variable) (ER_node_t node);

static int _ER_current_graph_pass_number;

void _ER_set_double_field_value
  (ER_double_link_t link, ER_node_t value, int disp, int flag)
{
}

ER_double_link_t ER__first_double_link (ER_node_t node)
{
  return NULL;
}

void ER__set_double_link (ER_double_link_t link, ER_node_t value)
{
#ifdef __ER_DEBUG__
  if (link == NULL)
    abort ();
#endif /* __ER_DEBUG__ */
  (*link->set_function) (link->link_owner, value);
}

static void _ER_node_field_initiation (ER_node_mode_t node_mode, ER_node_t node)
{
  switch (node_mode)
    {
    case ER_NM_heap_obj:
      ER_BEGIN_bool_t ((((_ER_heap_obj *) node)->_ER_S_heap_obj.immutable));
      ER_BEGIN_bool_t ((((_ER_heap_obj *) node)->_ER_S_heap_obj.it_was_processed));
      ER_BEGIN_instance_state_t ((((_ER_heap_obj *) node)->_ER_S_heap_obj.state));
      ER_BEGIN_char_ptr_t ((((_ER_heap_obj *) node)->_ER_S_heap_obj.new_place));
      ER_BEGIN_size_t ((((_ER_heap_obj *) node)->_ER_S_heap_obj.unique_number));
      break;
    case ER_NM_heap_vect_tab:
      _ER_node_field_initiation (ER_NM_heap_obj, (ER_node_t) ((char *) &((_ER_heap_vect_tab *) node)->_ER_S_heap_vect_tab._ER_M_heap_obj - _ER_offsetof (_ER_heap_obj, _ER_S_heap_obj)));
      ER_BEGIN_size_t ((((_ER_heap_vect_tab *) node)->_ER_S_heap_vect_tab.allocated_length));
      ER_BEGIN_size_t ((((_ER_heap_vect_tab *) node)->_ER_S_heap_vect_tab.els_number));
      break;
    case ER_NM_heap_vect:
      _ER_node_field_initiation (ER_NM_heap_vect_tab, (ER_node_t) ((char *) &((_ER_heap_vect *) node)->_ER_S_heap_vect._ER_M_heap_vect_tab - _ER_offsetof (_ER_heap_vect_tab, _ER_S_heap_vect_tab)));
      ER_BEGIN_ER_node_mode_t ((((_ER_heap_vect *) node)->_ER_S_heap_vect.pack_vect_el_type));
      ER_BEGIN_size_t ((((_ER_heap_vect *) node)->_ER_S_heap_vect.disp));
      break;
    case ER_NM_heap_pack_vect:
      _ER_node_field_initiation (ER_NM_heap_vect, (ER_node_t) ((char *) &((_ER_heap_pack_vect *) node)->_ER_S_heap_pack_vect._ER_M_heap_vect - _ER_offsetof (_ER_heap_vect, _ER_S_heap_vect)));
      break;
    case ER_NM_heap_unpack_vect:
      _ER_node_field_initiation (ER_NM_heap_vect, (ER_node_t) ((char *) &((_ER_heap_unpack_vect *) node)->_ER_S_heap_unpack_vect._ER_M_heap_vect - _ER_offsetof (_ER_heap_vect, _ER_S_heap_vect)));
      break;
    case ER_NM_heap_tab:
      _ER_node_field_initiation (ER_NM_heap_vect_tab, (ER_node_t) ((char *) &((_ER_heap_tab *) node)->_ER_S_heap_tab._ER_M_heap_vect_tab - _ER_offsetof (_ER_heap_vect_tab, _ER_S_heap_vect_tab)));
      ER_BEGIN_size_t ((((_ER_heap_tab *) node)->_ER_S_heap_tab.entries_number));
      ER_BEGIN_size_t ((((_ER_heap_tab *) node)->_ER_S_heap_tab.deleted_els_number));
      ER_BEGIN_int_t ((((_ER_heap_tab *) node)->_ER_S_heap_tab.last_key_index));
      break;
    case ER_NM_context_heap_obj:
      _ER_node_field_initiation (ER_NM_heap_obj, (ER_node_t) ((char *) &((_ER_context_heap_obj *) node)->_ER_S_context_heap_obj._ER_M_heap_obj - _ER_offsetof (_ER_heap_obj, _ER_S_heap_obj)));
      ER_BEGIN_ER_node_t ((((_ER_context_heap_obj *) node)->_ER_S_context_heap_obj.context));
      ER_BEGIN_IR_hidden_node_t ((((_ER_context_heap_obj *) node)->_ER_S_context_heap_obj.block_node));
      ER_BEGIN_int_t ((((_ER_context_heap_obj *) node)->_ER_S_context_heap_obj.context_number));
      break;
    case ER_NM_heap_instance:
      _ER_node_field_initiation (ER_NM_context_heap_obj, (ER_node_t) ((char *) &((_ER_heap_instance *) node)->_ER_S_heap_instance._ER_M_context_heap_obj - _ER_offsetof (_ER_context_heap_obj, _ER_S_context_heap_obj)));
      ER_BEGIN_IR_hidden_node_t ((((_ER_heap_instance *) node)->_ER_S_heap_instance.instance_class));
      break;
    case ER_NM_heap_stack:
      _ER_node_field_initiation (ER_NM_context_heap_obj, (ER_node_t) ((char *) &((_ER_heap_stack *) node)->_ER_S_heap_stack._ER_M_context_heap_obj - _ER_offsetof (_ER_context_heap_obj, _ER_S_context_heap_obj)));
      ER_BEGIN_ER_node_t ((((_ER_heap_stack *) node)->_ER_S_heap_stack.prev_stack));
      ER_BEGIN_char_ptr_t ((((_ER_heap_stack *) node)->_ER_S_heap_stack.ctop));
      ER_BEGIN_pc_t ((((_ER_heap_stack *) node)->_ER_S_heap_stack.return_pc));
      break;
    case ER_NM_heap_process:
      _ER_node_field_initiation (ER_NM_context_heap_obj, (ER_node_t) ((char *) &((_ER_heap_process *) node)->_ER_S_heap_process._ER_M_context_heap_obj - _ER_offsetof (_ER_context_heap_obj, _ER_S_context_heap_obj)));
      ER_BEGIN_IR_hidden_node_t ((((_ER_heap_process *) node)->_ER_S_heap_process.thread_func));
      ER_BEGIN_process_status_t ((((_ER_heap_process *) node)->_ER_S_heap_process.process_status));
      ER_BEGIN_ER_node_t ((((_ER_heap_process *) node)->_ER_S_heap_process.father));
      ER_BEGIN_ER_node_t ((((_ER_heap_process *) node)->_ER_S_heap_process.prev));
      ER_BEGIN_ER_node_t ((((_ER_heap_process *) node)->_ER_S_heap_process.next));
      ER_BEGIN_ER_node_t ((((_ER_heap_process *) node)->_ER_S_heap_process.saved_cstack));
      ER_BEGIN_int_t ((((_ER_heap_process *) node)->_ER_S_heap_process.process_number));
      ER_BEGIN_pc_t ((((_ER_heap_process *) node)->_ER_S_heap_process.saved_pc));
      break;
    case ER_NM_heap_hideblock:
      _ER_node_field_initiation (ER_NM_heap_obj, (ER_node_t) ((char *) &((_ER_heap_hideblock *) node)->_ER_S_heap_hideblock._ER_M_heap_obj - _ER_offsetof (_ER_heap_obj, _ER_S_heap_obj)));
      ER_BEGIN_int_t ((((_ER_heap_hideblock *) node)->_ER_S_heap_hideblock.hideblock_length));
      break;
    case ER_NM_val:
      break;
    case ER_NM_nil:
      break;
    case ER_NM_hide:
      ER_BEGIN_hide_t ((((_ER_hide *) node)->_ER_S_hide.hide));
      break;
    case ER_NM_hideblock:
      ER_BEGIN_ER_node_t ((((_ER_hideblock *) node)->_ER_S_hideblock.hideblock));
      break;
    case ER_NM_char:
      ER_BEGIN_char_t ((((_ER_char *) node)->_ER_S_char.ch));
      break;
    case ER_NM_int:
      ER_BEGIN_int_t ((((_ER_int *) node)->_ER_S_int.i));
      break;
    case ER_NM_float:
      ER_BEGIN_floating_t ((((_ER_float *) node)->_ER_S_float.f));
      break;
    case ER_NM_type:
      ER_BEGIN_ER_type_t ((((_ER_type *) node)->_ER_S_type.type));
      break;
    case ER_NM_vect:
      ER_BEGIN_ER_node_t ((((_ER_vect *) node)->_ER_S_vect.vect));
      break;
    case ER_NM_tab:
      ER_BEGIN_ER_node_t ((((_ER_tab *) node)->_ER_S_tab.tab));
      break;
    case ER_NM_empty_entry:
      break;
    case ER_NM_deleted_entry:
      break;
    case ER_NM_instance:
      ER_BEGIN_ER_node_t ((((_ER_instance *) node)->_ER_S_instance.instance));
      break;
    case ER_NM_func:
      ER_BEGIN_ER_node_t ((((_ER_func *) node)->_ER_S_func.func_context));
      ER_BEGIN_int_t ((((_ER_func *) node)->_ER_S_func.func_no));
      break;
    case ER_NM_class:
      ER_BEGIN_ER_node_t ((((_ER_class *) node)->_ER_S_class.class_context));
      ER_BEGIN_int_t ((((_ER_class *) node)->_ER_S_class.class_no));
      break;
    case ER_NM_stack:
      ER_BEGIN_ER_node_t ((((_ER_stack *) node)->_ER_S_stack.stack));
      break;
    case ER_NM_process:
      ER_BEGIN_ER_node_t ((((_ER_process *) node)->_ER_S_process.process));
      break;
    case ER_NM_external_var_ref:
      ER_BEGIN_char_ptr_t ((((_ER_external_var_ref *) node)->_ER_S_external_var_ref.external_var_ref));
      break;
    case ER_NM_heap_redir:
      _ER_node_field_initiation (ER_NM_heap_vect_tab, (ER_node_t) ((char *) &((_ER_heap_redir *) node)->_ER_S_heap_redir._ER_M_heap_vect_tab - _ER_offsetof (_ER_heap_vect_tab, _ER_S_heap_vect_tab)));
      ER_BEGIN_ER_node_t ((((_ER_heap_redir *) node)->_ER_S_heap_redir.redir));
      break;
    case ER_NM__error:
      break;
    default:
      abort ();
      break;
    }
}

ER_node_t ER_create_node (ER_node_mode_t node_mode)
{
 ER_node_t _result;

  ER_ALLOC (_result, ER_node_size [node_mode], ER_node_t);
#ifdef __ER_DEBUG__
  if (_result == NULL)
    abort ();
#endif /* __ER_DEBUG__ */
  ER_NODE_MODE (_result) = node_mode;
  _ER_node_field_initiation (node_mode, _result);
  return _result;
}

void ER_start (void)
{
#ifdef __ER_DEBUG__
  if (sizeof (_ER_heap_obj) > 255)
    {
      fprintf (stderr, "Very long node `heap_obj' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __ER_DEBUG__ */
#ifdef __ER_DEBUG__
  if (sizeof (_ER_heap_vect_tab) > 255)
    {
      fprintf (stderr, "Very long node `heap_vect_tab' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __ER_DEBUG__ */
#ifdef __ER_DEBUG__
  if (sizeof (_ER_heap_vect) > 255)
    {
      fprintf (stderr, "Very long node `heap_vect' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __ER_DEBUG__ */
#ifdef __ER_DEBUG__
  if (sizeof (_ER_heap_pack_vect) > 255)
    {
      fprintf (stderr, "Very long node `heap_pack_vect' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __ER_DEBUG__ */
#ifdef __ER_DEBUG__
  if (sizeof (_ER_heap_unpack_vect) > 255)
    {
      fprintf (stderr, "Very long node `heap_unpack_vect' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __ER_DEBUG__ */
#ifdef __ER_DEBUG__
  if (sizeof (_ER_heap_tab) > 255)
    {
      fprintf (stderr, "Very long node `heap_tab' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __ER_DEBUG__ */
#ifdef __ER_DEBUG__
  if (sizeof (_ER_context_heap_obj) > 255)
    {
      fprintf (stderr, "Very long node `context_heap_obj' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __ER_DEBUG__ */
#ifdef __ER_DEBUG__
  if (sizeof (_ER_heap_instance) > 255)
    {
      fprintf (stderr, "Very long node `heap_instance' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __ER_DEBUG__ */
#ifdef __ER_DEBUG__
  if (sizeof (_ER_heap_stack) > 255)
    {
      fprintf (stderr, "Very long node `heap_stack' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __ER_DEBUG__ */
#ifdef __ER_DEBUG__
  if (sizeof (_ER_heap_process) > 255)
    {
      fprintf (stderr, "Very long node `heap_process' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __ER_DEBUG__ */
#ifdef __ER_DEBUG__
  if (sizeof (_ER_heap_hideblock) > 255)
    {
      fprintf (stderr, "Very long node `heap_hideblock' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __ER_DEBUG__ */
#ifdef __ER_DEBUG__
  if (sizeof (_ER_val) > 255)
    {
      fprintf (stderr, "Very long node `val' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __ER_DEBUG__ */
#ifdef __ER_DEBUG__
  if (sizeof (_ER_nil) > 255)
    {
      fprintf (stderr, "Very long node `nil' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __ER_DEBUG__ */
#ifdef __ER_DEBUG__
  if (sizeof (_ER_hide) > 255)
    {
      fprintf (stderr, "Very long node `hide' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __ER_DEBUG__ */
#ifdef __ER_DEBUG__
  if (sizeof (_ER_hideblock) > 255)
    {
      fprintf (stderr, "Very long node `hideblock' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __ER_DEBUG__ */
#ifdef __ER_DEBUG__
  if (sizeof (_ER_char) > 255)
    {
      fprintf (stderr, "Very long node `char' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __ER_DEBUG__ */
#ifdef __ER_DEBUG__
  if (sizeof (_ER_int) > 255)
    {
      fprintf (stderr, "Very long node `int' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __ER_DEBUG__ */
#ifdef __ER_DEBUG__
  if (sizeof (_ER_float) > 255)
    {
      fprintf (stderr, "Very long node `float' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __ER_DEBUG__ */
#ifdef __ER_DEBUG__
  if (sizeof (_ER_type) > 255)
    {
      fprintf (stderr, "Very long node `type' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __ER_DEBUG__ */
#ifdef __ER_DEBUG__
  if (sizeof (_ER_vect) > 255)
    {
      fprintf (stderr, "Very long node `vect' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __ER_DEBUG__ */
#ifdef __ER_DEBUG__
  if (sizeof (_ER_tab) > 255)
    {
      fprintf (stderr, "Very long node `tab' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __ER_DEBUG__ */
#ifdef __ER_DEBUG__
  if (sizeof (_ER_empty_entry) > 255)
    {
      fprintf (stderr, "Very long node `empty_entry' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __ER_DEBUG__ */
#ifdef __ER_DEBUG__
  if (sizeof (_ER_deleted_entry) > 255)
    {
      fprintf (stderr, "Very long node `deleted_entry' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __ER_DEBUG__ */
#ifdef __ER_DEBUG__
  if (sizeof (_ER_instance) > 255)
    {
      fprintf (stderr, "Very long node `instance' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __ER_DEBUG__ */
#ifdef __ER_DEBUG__
  if (sizeof (_ER_func) > 255)
    {
      fprintf (stderr, "Very long node `func' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __ER_DEBUG__ */
#ifdef __ER_DEBUG__
  if (sizeof (_ER_class) > 255)
    {
      fprintf (stderr, "Very long node `class' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __ER_DEBUG__ */
#ifdef __ER_DEBUG__
  if (sizeof (_ER_stack) > 255)
    {
      fprintf (stderr, "Very long node `stack' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __ER_DEBUG__ */
#ifdef __ER_DEBUG__
  if (sizeof (_ER_process) > 255)
    {
      fprintf (stderr, "Very long node `process' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __ER_DEBUG__ */
#ifdef __ER_DEBUG__
  if (sizeof (_ER_external_var_ref) > 255)
    {
      fprintf (stderr, "Very long node `external_var_ref' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __ER_DEBUG__ */
#ifdef __ER_DEBUG__
  if (sizeof (_ER_heap_redir) > 255)
    {
      fprintf (stderr, "Very long node `heap_redir' use option `-long-node-size' or `-short-node-size'\n");
      exit (1);
    }
#endif /* __ER_DEBUG__ */
  _ER_current_graph_pass_number = 0;
  ER_START_ALLOC ();
}

void ER_stop (void)
{
  ER_STOP_ALLOC ();
}



#line 527 "/usr/src/ports/cocom/cocom-0.996-2.i686/src/cocom-0.996/DINO/d_extern.sprut"



#line 235 "/usr/src/ports/cocom/cocom-0.996-2.i686/src/cocom-0.996/DINO/d_run.sprut"
