/* translation of file(s)
	"commonrep.k"
	"cr_uniq.k"
 */
/* generated by:
 *	@(#)$Author: Kimwitu version: V3_8P5 (c) 1990 University of Twente $
 */
#define KC_TYPES
#define KIMW_TYPES /* for backwards compatibility */
#include <stdio.h>
#include <ctype.h>
#include <string.h>
#if ((!defined(__STDC__)) && defined(sun))
   extern char *sprintf();
#endif
#include <sys/types.h>
#if defined(__STDC__)
# include <stdlib.h>
#else
#  include <memory.h> /*for memset*/
#endif
typedef size_t kc_memset_size_t; /* needed for sun */

#include "k.h"
#if ! defined(__STDC__)
extern void exit KC__P((int));
#endif

#if ((!defined(__STDC__)) && defined(sun))
  /* kc_memset_firstarg_t should be void* kc_voidptr_t, but sun's include files are dumb */
# ifndef KC_MEMSET_FIRSTARG_T
  typedef char *kc_memset_firstarg_t;
# else
  typedef KC_MEMSET_FIRSTARG_T kc_memset_firstarg_t;
# endif
#else
  typedef kc_voidptr_t kc_memset_firstarg_t;
#endif

static kc_voidfnptr_t kc_out_of_storage_handler = 0;
kc_voidfnptr_t kc_set_out_of_storage_handler
#ifdef KC_USE_PROTOTYPES
( kc_voidfnptr_t kc_handler )
#else
(kc_handler) kc_voidfnptr_t kc_handler;
#endif
{	kc_voidfnptr_t kc_tmp_handler = kc_out_of_storage_handler;
	kc_out_of_storage_handler = kc_handler;
	return kc_tmp_handler;
}

kc_voidptr_t emalloc	/* check return from malloc */
#ifdef KC_USE_PROTOTYPES
(kc_size_t kc_n)
#else
(kc_n) kc_size_t kc_n;
#endif
{	kc_voidptr_t kc_p;
	while ((kc_p = (kc_voidptr_t)malloc((kc_size_t)kc_n)) == 0) {
		if (kc_out_of_storage_handler) {
			(*kc_out_of_storage_handler)();
		} else {
			(void)fflush(stdout);
			(void)fprintf(stderr,"out of memory in emalloc\n");
			exit( 1 ); /*NOTREACHED*/
	}	}
	return kc_p;
}

kc_voidptr_t ecalloc	/* check return from calloc */
#ifdef KC_USE_PROTOTYPES
(kc_size_t kc_n, kc_size_t kc_s)
#else
(kc_n,kc_s) kc_size_t kc_n, kc_s;
#endif
{	kc_voidptr_t kc_p;
	while ((kc_p = (kc_voidptr_t)calloc((kc_size_t)kc_n,(kc_size_t)kc_s)) == 0) {
		if (kc_out_of_storage_handler) {
			(*kc_out_of_storage_handler)();
		} else {
			(void)fflush(stdout);
			(void)fprintf(stderr,"out of memory in ecalloc\n");
			exit( 1 ); /*NOTREACHED*/
	}	}
	return kc_p;
}

kc_voidptr_t erealloc	/* check return from realloc */
#ifdef KC_USE_PROTOTYPES
(kc_voidptr_t kc_r, kc_size_t kc_s)
#else
(kc_r,kc_s) kc_voidptr_t kc_r; kc_size_t kc_s;
#endif
{	kc_voidptr_t kc_p;
	while ((kc_p = (kc_voidptr_t)realloc((kc_realloc_arg_t)kc_r,(kc_size_t)kc_s)) == 0) {
		if (kc_out_of_storage_handler) {
			(*kc_out_of_storage_handler)();
		} else {
			(void)fflush(stdout);
			(void)fprintf(stderr,"out of memory in erealloc\n");
			exit( 1 ); /*NOTREACHED*/
	}	}
	return kc_p;
}

void kc_bzero
#ifdef KC_USE_PROTOTYPES
(register char *kc_p, register int kc_s)
#else
(kc_p,kc_s) register char *kc_p; register int kc_s;
#endif
{	while (kc_s--) {
		*kc_p++ = '\0';
	}
}

KC_PHYLUM_INFO kc_PhylumInfo[] = {
	{ "", 0, kc_one_before_first_operator, kc_one_before_first_operator, (kc_storageclass_t)0, 0 }, /* dummy element */
	{ "nocasestring", sizeof(struct kc_tag_nocasestring), sel_NoCaseStr, sel_NoCaseStr, uniq, 0 },
	{ "casestring", sizeof(struct kc_tag_casestring), sel__Str, sel__Str, uniq, 0 },
	{ "float", sizeof(float), sel__Real, sel__Real, uniq, 0 },
	{ "int", sizeof(int), sel__Int, sel__Int, uniq, 0 },
	{ "cr_specification", sizeof(struct kc_tag_cr_specification), sel_CR_Spec, sel_CR_Spec, kc_not_uniq, 0 },
	{ "cr_specification_type", sizeof(struct kc_tag_cr_specification_type), sel_CR_IS8807, sel_CR_Basic_LOTOS, kc_not_uniq, 0 },
	{ "cr_boolean_indication", sizeof(struct kc_tag_cr_boolean_indication), sel_CR_Booleans_NotChecked, sel_CR_Booleans_Ok, kc_not_uniq, 0 },
	{ "cr_definition_block", sizeof(struct kc_tag_cr_definition_block), sel_CR_Definition_block, sel_CR_Definition_block, kc_not_uniq, 0 },
	{ "cr_process_definition_list", sizeof(struct kc_tag_cr_process_definition_list), sel_Nilcr_process_definition_list, sel_Conscr_process_definition_list, kc_not_uniq, 0 },
	{ "cr_process_definition", sizeof(struct kc_tag_cr_process_definition), sel_CR_Process_definition, sel_CR_Process_definition, kc_not_uniq, 0 },
	{ "cr_functionality", sizeof(struct kc_tag_cr_functionality), sel_CR_Exit_part, sel_CR_Noexit_part, kc_not_uniq, 0 },
	{ "cr_sort_identifier_list", sizeof(struct kc_tag_cr_sort_identifier_list), sel_Nilcr_sort_identifier_list, sel_Conscr_sort_identifier_list, kc_not_uniq, 0 },
	{ "cr_data_type_definition_list", sizeof(struct kc_tag_cr_data_type_definition_list), sel_Nilcr_data_type_definition_list, sel_Conscr_data_type_definition_list, kc_not_uniq, 0 },
	{ "cr_data_type_definition", sizeof(struct kc_tag_cr_data_type_definition), sel_CR_Data_type_definition, sel_CR_Library_reference, kc_not_uniq, 0 },
	{ "cr_completeness_indication", sizeof(struct kc_tag_cr_completeness_indication), sel_CR_Completeness_NotChecked, sel_CR_Not_Complete, kc_not_uniq, 0 },
	{ "cr_persistency_indication", sizeof(struct kc_tag_cr_persistency_indication), sel_CR_Persistency_NotChecked, sel_CR_Not_Persistent, kc_not_uniq, 0 },
	{ "cr_p_expression", sizeof(struct kc_tag_cr_p_expression), sel_CR_P_Spec, sel_CR_Renaming, kc_not_uniq, 0 },
	{ "cr_type_identifier_list", sizeof(struct kc_tag_cr_type_identifier_list), sel_Nilcr_type_identifier_list, sel_Conscr_type_identifier_list, kc_not_uniq, 0 },
	{ "cr_replacement", sizeof(struct kc_tag_cr_replacement), sel_CR_Replacement, sel_CR_Replacement, kc_not_uniq, 0 },
	{ "cr_sort_replacement_list", sizeof(struct kc_tag_cr_sort_replacement_list), sel_Nilcr_sort_replacement_list, sel_Conscr_sort_replacement_list, kc_not_uniq, 0 },
	{ "cr_sort_replacement", sizeof(struct kc_tag_cr_sort_replacement), sel_CR_Sort_replacement, sel_CR_Sort_replacement, kc_not_uniq, 0 },
	{ "cr_sort_declaration_list", sizeof(struct kc_tag_cr_sort_declaration_list), sel_Nilcr_sort_declaration_list, sel_Conscr_sort_declaration_list, kc_not_uniq, 0 },
	{ "cr_sort_declaration", sizeof(struct kc_tag_cr_sort_declaration), sel_CR_Sort_declaration, sel_CR_Sort_declaration, kc_not_uniq, 0 },
	{ "cr_operation_replacement_list", sizeof(struct kc_tag_cr_operation_replacement_list), sel_Nilcr_operation_replacement_list, sel_Conscr_operation_replacement_list, kc_not_uniq, 0 },
	{ "cr_operation_replacement", sizeof(struct kc_tag_cr_operation_replacement), sel_CR_Operation_replacement, sel_CR_Operation_replacement, kc_not_uniq, 0 },
	{ "cr_flattened_type_definition", sizeof(struct kc_tag_cr_flattened_type_definition), sel_CR_Formal_type, sel_CR_Actual_type, kc_not_uniq, 0 },
	{ "cr_operation_list", sizeof(struct kc_tag_cr_operation_list), sel_Nilcr_operation_list, sel_Conscr_operation_list, kc_not_uniq, 0 },
	{ "cr_operation", sizeof(struct kc_tag_cr_operation), sel_CR_Operation, sel_CR_Operation, kc_not_uniq, 0 },
	{ "cr_prefix_infix", sizeof(struct kc_tag_cr_prefix_infix), sel_CR_Infix, sel_CR_Prefix, kc_not_uniq, 0 },
	{ "cr_rewrite_strategy", sizeof(struct kc_tag_cr_rewrite_strategy), sel_CR_Default, sel_CR_Projection, kc_not_uniq, 0 },
	{ "cr_operator_class", sizeof(struct kc_tag_cr_operator_class), sel_CR_Unknown, sel_CR_Derived, kc_not_uniq, 0 },
	{ "cr_equations_option", sizeof(struct kc_tag_cr_equations_option), sel_CR_NoEquations, sel_CR_YesEquations, kc_not_uniq, 0 },
	{ "cr_equation_structure_list", sizeof(struct kc_tag_cr_equation_structure_list), sel_Nilcr_equation_structure_list, sel_Conscr_equation_structure_list, kc_not_uniq, 0 },
	{ "cr_equation_structure", sizeof(struct kc_tag_cr_equation_structure), sel_CR_Equation_structure, sel_CR_Equation_structure, kc_not_uniq, 0 },
	{ "cr_equation_list", sizeof(struct kc_tag_cr_equation_list), sel_Nilcr_equation_list, sel_Conscr_equation_list, kc_not_uniq, 0 },
	{ "cr_equation", sizeof(struct kc_tag_cr_equation), sel_CR_Equation, sel_CR_Equation, kc_not_uniq, 0 },
	{ "cr_premiss_list", sizeof(struct kc_tag_cr_premiss_list), sel_Nilcr_premiss_list, sel_Conscr_premiss_list, kc_not_uniq, 0 },
	{ "cr_equality", sizeof(struct kc_tag_cr_equality), sel_CR_Equals, sel_CR_Equals, uniq, 0 },
	{ "cr_identifier_declaration_list", sizeof(struct kc_tag_cr_identifier_declaration_list), sel_Nilcr_identifier_declaration_list, sel_Conscr_identifier_declaration_list, uniq, 0 },
	{ "cr_identifier_declaration", sizeof(struct kc_tag_cr_identifier_declaration), sel_CR_Identifier_declaration, sel_CR_Identifier_declaration, uniq, 0 },
	{ "cr_value_identifier_list", sizeof(struct kc_tag_cr_value_identifier_list), sel_Nilcr_value_identifier_list, sel_Conscr_value_identifier_list, uniq, 0 },
	{ "cr_annotated_value_identifier", sizeof(struct kc_tag_cr_annotated_value_identifier), sel_CR_annotated_val_id, sel_CR_annotated_val_id, uniq, 0 },
	{ "cr_behaviour_expression", sizeof(struct kc_tag_cr_behaviour_expression), sel_CR_Stop_expression, sel_CR_Annotated_behaviour, uniq, 0 },
	{ "cr_parallel_operator", sizeof(struct kc_tag_cr_parallel_operator), sel_CR_Synchronization_operator, sel_CR_General_parallel_operator, uniq, 0 },
	{ "cr_gate_declaration_list", sizeof(struct kc_tag_cr_gate_declaration_list), sel_Nilcr_gate_declaration_list, sel_Conscr_gate_declaration_list, uniq, 0 },
	{ "cr_gate_declaration", sizeof(struct kc_tag_cr_gate_declaration), sel_CR_Gate_declaration, sel_CR_Gate_declaration, uniq, 0 },
	{ "cr_gate_identifier_list", sizeof(struct kc_tag_cr_gate_identifier_list), sel_Nilcr_gate_identifier_list, sel_Conscr_gate_identifier_list, uniq, 0 },
	{ "cr_exit_entry_list", sizeof(struct kc_tag_cr_exit_entry_list), sel_Nilcr_exit_entry_list, sel_Conscr_exit_entry_list, uniq, 0 },
	{ "cr_exit_entry", sizeof(struct kc_tag_cr_exit_entry), sel_CR_Value_expression_exit_entry, sel_CR_Sort_identifier_exit_entry, uniq, 0 },
	{ "cr_identifier_equation_list", sizeof(struct kc_tag_cr_identifier_equation_list), sel_Nilcr_identifier_equation_list, sel_Conscr_identifier_equation_list, uniq, 0 },
	{ "cr_identifier_equation", sizeof(struct kc_tag_cr_identifier_equation), sel_CR_Identifier_equation, sel_CR_Identifier_equation, uniq, 0 },
	{ "cr_action_denotation", sizeof(struct kc_tag_cr_action_denotation), sel_CR_Communication, sel_CR_Internal_event, uniq, 0 },
	{ "cr_experiment_option", sizeof(struct kc_tag_cr_experiment_option), sel_CR_NoExperiment, sel_CR_YesExperiment, uniq, 0 },
	{ "cr_experiment_offer_list", sizeof(struct kc_tag_cr_experiment_offer_list), sel_Nilcr_experiment_offer_list, sel_Conscr_experiment_offer_list, uniq, 0 },
	{ "cr_experiment_offer", sizeof(struct kc_tag_cr_experiment_offer), sel_CR_Query_offer, sel_CR_Exclam_offer, uniq, 0 },
	{ "cr_guard_option", sizeof(struct kc_tag_cr_guard_option), sel_CR_NoGuard, sel_CR_YesGuard, uniq, 0 },
	{ "cr_value_expression_list", sizeof(struct kc_tag_cr_value_expression_list), sel_Nilcr_value_expression_list, sel_Conscr_value_expression_list, uniq, 0 },
	{ "cr_value_expression", sizeof(struct kc_tag_cr_value_expression), sel_CR_Term, sel_CR_Annotated_value_expression, uniq, 0 },
	{ "cr_specification_identifier", sizeof(struct kc_tag_cr_specification_identifier), sel_CR_Specification_id, sel_CR_Specification_id, uniq, 0 },
	{ "cr_operation_identifier", sizeof(struct kc_tag_cr_operation_identifier), sel_CR_Operation_id, sel_CR_Operation_id, uniq, 0 },
	{ "cr_type_identifier", sizeof(struct kc_tag_cr_type_identifier), sel_CR_Type_id, sel_CR_Type_id, uniq, 0 },
	{ "cr_sort_identifier", sizeof(struct kc_tag_cr_sort_identifier), sel_CR_Sort_id, sel_CR_Sort_id, uniq, 0 },
	{ "cr_gate_identifier", sizeof(struct kc_tag_cr_gate_identifier), sel_CR_Gate_id, sel_CR_Gate_id, uniq, 0 },
	{ "cr_value_identifier", sizeof(struct kc_tag_cr_value_identifier), sel_CR_Value_id, sel_CR_Value_id, uniq, 0 },
	{ "cr_process_identifier", sizeof(struct kc_tag_cr_process_identifier), sel_CR_Process_id, sel_CR_Process_id, uniq, 0 },
	{ "cr_identifier", sizeof(struct kc_tag_cr_identifier), sel_CR_Identifier, sel_CR_Identifier, uniq, 0 },
	{ "cr_extension", sizeof(struct kc_tag_cr_extension), sel_CR_NullExtension, sel_CR_DefExtension, uniq, 0 },
	{ "cr_operation_name", sizeof(struct kc_tag_cr_operation_name), sel_CR_Operation_name, sel_CR_Operation_name, uniq, 0 },
	{ "cr_sort_name", sizeof(struct kc_tag_cr_sort_name), sel_CR_Sort_name, sel_CR_Sort_name, uniq, 0 },
	{ "cr_name", sizeof(struct kc_tag_cr_name), sel_CR_Name, sel_CR_Name, uniq, 0 },
	{ "cr_comment_list", sizeof(struct kc_tag_cr_comment_list), sel_Nilcr_comment_list, sel_Conscr_comment_list, uniq, 0 },
	{ "cr_annotation_list", sizeof(struct kc_tag_cr_annotation_list), sel_Nilcr_annotation_list, sel_Conscr_annotation_list, uniq, 0 },
	{ "cr_LABEL", sizeof(struct kc_tag_cr_LABEL), sel_CR_Label, sel_CR_Label, uniq, 0 },
	{ "", 0, kc_one_before_first_operator, kc_one_before_first_operator, (kc_storageclass_t)0, 0 } /* last element */
};

static kc_enum_phyla kc_subphyla_CR_Spec[] = { kc_phylum_cr_LABEL, kc_phylum_cr_comment_list, kc_phylum_cr_specification_identifier, kc_phylum_cr_gate_identifier_list, kc_phylum_cr_identifier_declaration_list, kc_phylum_cr_functionality, kc_phylum_cr_data_type_definition_list, kc_phylum_cr_comment_list, kc_phylum_cr_definition_block, kc_phylum_cr_boolean_indication, kc_phylum_cr_annotation_list, kc_phylum_cr_specification_type };
static kc_enum_phyla kc_subphyla_CR_Definition_block[] = { kc_phylum_cr_behaviour_expression, kc_phylum_cr_data_type_definition_list, kc_phylum_cr_process_definition_list };
static kc_enum_phyla kc_subphyla_Conscr_process_definition_list[] = { kc_phylum_cr_process_definition, kc_phylum_cr_process_definition_list };
static kc_enum_phyla kc_subphyla_CR_Process_definition[] = { kc_phylum_cr_comment_list, kc_phylum_cr_process_identifier, kc_phylum_cr_gate_identifier_list, kc_phylum_cr_identifier_declaration_list, kc_phylum_cr_functionality, kc_phylum_cr_definition_block, kc_phylum_cr_LABEL };
static kc_enum_phyla kc_subphyla_CR_Exit_part[] = { kc_phylum_cr_sort_identifier_list };
static kc_enum_phyla kc_subphyla_Conscr_sort_identifier_list[] = { kc_phylum_cr_sort_identifier, kc_phylum_cr_sort_identifier_list };
static kc_enum_phyla kc_subphyla_Conscr_data_type_definition_list[] = { kc_phylum_cr_data_type_definition, kc_phylum_cr_data_type_definition_list };
static kc_enum_phyla kc_subphyla_CR_Data_type_definition[] = { kc_phylum_cr_comment_list, kc_phylum_cr_type_identifier, kc_phylum_cr_p_expression, kc_phylum_cr_completeness_indication, kc_phylum_cr_persistency_indication, kc_phylum_cr_flattened_type_definition, kc_phylum_cr_annotation_list };
static kc_enum_phyla kc_subphyla_CR_Library_reference[] = { kc_phylum_cr_type_identifier, kc_phylum_cr_flattened_type_definition, kc_phylum_cr_annotation_list };
static kc_enum_phyla kc_subphyla_CR_P_Spec[] = { kc_phylum_cr_type_identifier_list, kc_phylum_cr_sort_declaration_list, kc_phylum_cr_operation_list, kc_phylum_cr_equations_option, kc_phylum_cr_sort_declaration_list, kc_phylum_cr_operation_list, kc_phylum_cr_equations_option, kc_phylum_cr_LABEL };
static kc_enum_phyla kc_subphyla_CR_Actualization[] = { kc_phylum_cr_type_identifier, kc_phylum_cr_type_identifier_list, kc_phylum_cr_replacement, kc_phylum_cr_LABEL };
static kc_enum_phyla kc_subphyla_CR_Renaming[] = { kc_phylum_cr_type_identifier, kc_phylum_cr_replacement, kc_phylum_cr_LABEL };
static kc_enum_phyla kc_subphyla_Conscr_type_identifier_list[] = { kc_phylum_cr_type_identifier, kc_phylum_cr_type_identifier_list };
static kc_enum_phyla kc_subphyla_CR_Replacement[] = { kc_phylum_cr_sort_replacement_list, kc_phylum_cr_operation_replacement_list };
static kc_enum_phyla kc_subphyla_Conscr_sort_replacement_list[] = { kc_phylum_cr_sort_replacement, kc_phylum_cr_sort_replacement_list };
static kc_enum_phyla kc_subphyla_CR_Sort_replacement[] = { kc_phylum_cr_sort_name, kc_phylum_cr_sort_name, kc_phylum_cr_LABEL };
static kc_enum_phyla kc_subphyla_Conscr_sort_declaration_list[] = { kc_phylum_cr_sort_declaration, kc_phylum_cr_sort_declaration_list };
static kc_enum_phyla kc_subphyla_CR_Sort_declaration[] = { kc_phylum_cr_sort_identifier, kc_phylum_cr_LABEL, kc_phylum_cr_annotation_list };
static kc_enum_phyla kc_subphyla_Conscr_operation_replacement_list[] = { kc_phylum_cr_operation_replacement, kc_phylum_cr_operation_replacement_list };
static kc_enum_phyla kc_subphyla_CR_Operation_replacement[] = { kc_phylum_cr_operation_name, kc_phylum_cr_operation_name, kc_phylum_cr_LABEL };
static kc_enum_phyla kc_subphyla_CR_Formal_type[] = { kc_phylum_cr_type_identifier_list, kc_phylum_cr_sort_declaration_list, kc_phylum_cr_operation_list, kc_phylum_cr_equations_option, kc_phylum_cr_sort_declaration_list, kc_phylum_cr_operation_list, kc_phylum_cr_equations_option };
static kc_enum_phyla kc_subphyla_CR_Actual_type[] = { kc_phylum_cr_type_identifier_list, kc_phylum_cr_sort_declaration_list, kc_phylum_cr_operation_list, kc_phylum_cr_equations_option };
static kc_enum_phyla kc_subphyla_Conscr_operation_list[] = { kc_phylum_cr_operation, kc_phylum_cr_operation_list };
static kc_enum_phyla kc_subphyla_CR_Operation[] = { kc_phylum_cr_operation_identifier, kc_phylum_cr_prefix_infix, kc_phylum_cr_sort_identifier_list, kc_phylum_cr_sort_identifier, kc_phylum_cr_rewrite_strategy, kc_phylum_cr_operator_class, kc_phylum_cr_LABEL, kc_phylum_cr_annotation_list };
static kc_enum_phyla kc_subphyla_CR_YesEquations[] = { kc_phylum_cr_identifier_declaration_list, kc_phylum_cr_equation_structure_list };
static kc_enum_phyla kc_subphyla_Conscr_equation_structure_list[] = { kc_phylum_cr_equation_structure, kc_phylum_cr_equation_structure_list };
static kc_enum_phyla kc_subphyla_CR_Equation_structure[] = { kc_phylum_cr_sort_identifier, kc_phylum_cr_identifier_declaration_list, kc_phylum_cr_equation_list };
static kc_enum_phyla kc_subphyla_Conscr_equation_list[] = { kc_phylum_cr_equation, kc_phylum_cr_equation_list };
static kc_enum_phyla kc_subphyla_CR_Equation[] = { kc_phylum_cr_premiss_list, kc_phylum_cr_equality, kc_phylum_cr_LABEL };
static kc_enum_phyla kc_subphyla_Conscr_premiss_list[] = { kc_phylum_cr_equality, kc_phylum_cr_premiss_list };
static kc_enum_phyla kc_subphyla_CR_Equals[] = { kc_phylum_cr_value_expression, kc_phylum_cr_value_expression };
static kc_enum_phyla kc_subphyla_Conscr_identifier_declaration_list[] = { kc_phylum_cr_identifier_declaration, kc_phylum_cr_identifier_declaration_list };
static kc_enum_phyla kc_subphyla_CR_Identifier_declaration[] = { kc_phylum_cr_value_identifier_list, kc_phylum_cr_sort_identifier };
static kc_enum_phyla kc_subphyla_Conscr_value_identifier_list[] = { kc_phylum_cr_annotated_value_identifier, kc_phylum_cr_value_identifier_list };
static kc_enum_phyla kc_subphyla_CR_annotated_val_id[] = { kc_phylum_cr_value_identifier, kc_phylum_cr_annotation_list };
static kc_enum_phyla kc_subphyla_CR_Stop_expression[] = { kc_phylum_cr_LABEL, kc_phylum_cr_annotation_list };
static kc_enum_phyla kc_subphyla_CR_Exit_expression[] = { kc_phylum_cr_exit_entry_list, kc_phylum_cr_LABEL, kc_phylum_cr_annotation_list };
static kc_enum_phyla kc_subphyla_CR_Process_instantiation[] = { kc_phylum_cr_process_identifier, kc_phylum_cr_gate_identifier_list, kc_phylum_cr_value_expression_list, kc_phylum_cr_LABEL, kc_phylum_cr_annotation_list };
static kc_enum_phyla kc_subphyla_CR_Action_prefix_expression[] = { kc_phylum_cr_action_denotation, kc_phylum_cr_behaviour_expression, kc_phylum_cr_LABEL, kc_phylum_cr_annotation_list };
static kc_enum_phyla kc_subphyla_CR_Local_definition_expression[] = { kc_phylum_cr_identifier_equation_list, kc_phylum_cr_behaviour_expression };
static kc_enum_phyla kc_subphyla_CR_Sum_identifier_expression[] = { kc_phylum_cr_identifier_declaration_list, kc_phylum_cr_behaviour_expression };
static kc_enum_phyla kc_subphyla_CR_Sum_gate_expression[] = { kc_phylum_cr_gate_declaration_list, kc_phylum_cr_behaviour_expression };
static kc_enum_phyla kc_subphyla_CR_Par_expression[] = { kc_phylum_cr_gate_declaration_list, kc_phylum_cr_parallel_operator, kc_phylum_cr_behaviour_expression, kc_phylum_cr_LABEL };
static kc_enum_phyla kc_subphyla_CR_Hiding_expression[] = { kc_phylum_cr_gate_identifier_list, kc_phylum_cr_behaviour_expression };
static kc_enum_phyla kc_subphyla_CR_Enable_expression[] = { kc_phylum_cr_behaviour_expression, kc_phylum_cr_identifier_declaration_list, kc_phylum_cr_behaviour_expression };
static kc_enum_phyla kc_subphyla_CR_Disable_expression[] = { kc_phylum_cr_behaviour_expression, kc_phylum_cr_behaviour_expression };
static kc_enum_phyla kc_subphyla_CR_Parallel_expression[] = { kc_phylum_cr_behaviour_expression, kc_phylum_cr_parallel_operator, kc_phylum_cr_behaviour_expression, kc_phylum_cr_LABEL };
static kc_enum_phyla kc_subphyla_CR_Choice_expression[] = { kc_phylum_cr_behaviour_expression, kc_phylum_cr_behaviour_expression };
static kc_enum_phyla kc_subphyla_CR_Guarded_expression[] = { kc_phylum_cr_equality, kc_phylum_cr_behaviour_expression };
static kc_enum_phyla kc_subphyla_CR_Annotated_behaviour[] = { kc_phylum_cr_annotation_list, kc_phylum_cr_behaviour_expression };
static kc_enum_phyla kc_subphyla_CR_General_parallel_operator[] = { kc_phylum_cr_gate_identifier_list };
static kc_enum_phyla kc_subphyla_Conscr_gate_declaration_list[] = { kc_phylum_cr_gate_declaration, kc_phylum_cr_gate_declaration_list };
static kc_enum_phyla kc_subphyla_CR_Gate_declaration[] = { kc_phylum_cr_gate_identifier_list, kc_phylum_cr_gate_identifier_list };
static kc_enum_phyla kc_subphyla_Conscr_gate_identifier_list[] = { kc_phylum_cr_gate_identifier, kc_phylum_cr_gate_identifier_list };
static kc_enum_phyla kc_subphyla_Conscr_exit_entry_list[] = { kc_phylum_cr_exit_entry, kc_phylum_cr_exit_entry_list };
static kc_enum_phyla kc_subphyla_CR_Value_expression_exit_entry[] = { kc_phylum_cr_value_expression };
static kc_enum_phyla kc_subphyla_CR_Sort_identifier_exit_entry[] = { kc_phylum_cr_sort_identifier };
static kc_enum_phyla kc_subphyla_Conscr_identifier_equation_list[] = { kc_phylum_cr_identifier_equation, kc_phylum_cr_identifier_equation_list };
static kc_enum_phyla kc_subphyla_CR_Identifier_equation[] = { kc_phylum_cr_identifier_declaration, kc_phylum_cr_value_expression };
static kc_enum_phyla kc_subphyla_CR_Communication[] = { kc_phylum_cr_gate_identifier, kc_phylum_cr_experiment_option };
static kc_enum_phyla kc_subphyla_CR_YesExperiment[] = { kc_phylum_cr_experiment_offer_list, kc_phylum_cr_guard_option };
static kc_enum_phyla kc_subphyla_Conscr_experiment_offer_list[] = { kc_phylum_cr_experiment_offer, kc_phylum_cr_experiment_offer_list };
static kc_enum_phyla kc_subphyla_CR_Query_offer[] = { kc_phylum_cr_identifier_declaration };
static kc_enum_phyla kc_subphyla_CR_Exclam_offer[] = { kc_phylum_cr_value_expression };
static kc_enum_phyla kc_subphyla_CR_YesGuard[] = { kc_phylum_cr_equality };
static kc_enum_phyla kc_subphyla_Conscr_value_expression_list[] = { kc_phylum_cr_value_expression, kc_phylum_cr_value_expression_list };
static kc_enum_phyla kc_subphyla_CR_Term[] = { kc_phylum_cr_operation_identifier, kc_phylum_cr_value_expression_list, kc_phylum_cr_sort_identifier };
static kc_enum_phyla kc_subphyla_CR_Value[] = { kc_phylum_cr_value_identifier, kc_phylum_cr_sort_identifier };
static kc_enum_phyla kc_subphyla_CR_Annotated_value_expression[] = { kc_phylum_cr_value_expression, kc_phylum_cr_annotation_list };
static kc_enum_phyla kc_subphyla_CR_Specification_id[] = { kc_phylum_cr_identifier };
static kc_enum_phyla kc_subphyla_CR_Operation_id[] = { kc_phylum_cr_identifier };
static kc_enum_phyla kc_subphyla_CR_Type_id[] = { kc_phylum_cr_identifier };
static kc_enum_phyla kc_subphyla_CR_Sort_id[] = { kc_phylum_cr_identifier };
static kc_enum_phyla kc_subphyla_CR_Gate_id[] = { kc_phylum_cr_identifier };
static kc_enum_phyla kc_subphyla_CR_Value_id[] = { kc_phylum_cr_identifier };
static kc_enum_phyla kc_subphyla_CR_Process_id[] = { kc_phylum_cr_identifier };
static kc_enum_phyla kc_subphyla_CR_Identifier[] = { kc_phylum_nocasestring, kc_phylum_cr_extension };
static kc_enum_phyla kc_subphyla_CR_DefExtension[] = { kc_phylum_nocasestring };
static kc_enum_phyla kc_subphyla_CR_Operation_name[] = { kc_phylum_cr_name };
static kc_enum_phyla kc_subphyla_CR_Sort_name[] = { kc_phylum_cr_name };
static kc_enum_phyla kc_subphyla_CR_Name[] = { kc_phylum_nocasestring };
static kc_enum_phyla kc_subphyla_Conscr_comment_list[] = { kc_phylum_casestring, kc_phylum_cr_comment_list };
static kc_enum_phyla kc_subphyla_Conscr_annotation_list[] = { kc_phylum_casestring, kc_phylum_cr_annotation_list };
static kc_enum_phyla kc_subphyla_CR_Label[] = { kc_phylum_casestring };


#ifndef KC_OFFSETOF
#  define KC_OFFSETOF(kc_record, kc_operator, kc_subphylum) ((kc_size_t) \
   ((char*)(&((kc_record *)0)->u.kc_operator.kc_subphylum) - (char*)((kc_record *)0)))
#endif
static kc_size_t kc_suboffsets_CR_Spec[] = { KC_OFFSETOF( struct kc_tag_cr_specification, CR_Spec, cr_LABEL_1 ), KC_OFFSETOF( struct kc_tag_cr_specification, CR_Spec, cr_comment_list_1 ), KC_OFFSETOF( struct kc_tag_cr_specification, CR_Spec, cr_specification_identifier_1 ), KC_OFFSETOF( struct kc_tag_cr_specification, CR_Spec, cr_gate_identifier_list_1 ), KC_OFFSETOF( struct kc_tag_cr_specification, CR_Spec, cr_identifier_declaration_list_1 ), KC_OFFSETOF( struct kc_tag_cr_specification, CR_Spec, cr_functionality_1 ), KC_OFFSETOF( struct kc_tag_cr_specification, CR_Spec, cr_data_type_definition_list_1 ), KC_OFFSETOF( struct kc_tag_cr_specification, CR_Spec, cr_comment_list_2 ), KC_OFFSETOF( struct kc_tag_cr_specification, CR_Spec, cr_definition_block_1 ), KC_OFFSETOF( struct kc_tag_cr_specification, CR_Spec, cr_boolean_indication_1 ), KC_OFFSETOF( struct kc_tag_cr_specification, CR_Spec, cr_annotation_list_1 ), KC_OFFSETOF( struct kc_tag_cr_specification, CR_Spec, cr_specification_type_1 ) };
static kc_size_t kc_suboffsets_CR_Definition_block[] = { KC_OFFSETOF( struct kc_tag_cr_definition_block, CR_Definition_block, cr_behaviour_expression_1 ), KC_OFFSETOF( struct kc_tag_cr_definition_block, CR_Definition_block, cr_data_type_definition_list_1 ), KC_OFFSETOF( struct kc_tag_cr_definition_block, CR_Definition_block, cr_process_definition_list_1 ) };
static kc_size_t kc_suboffsets_Conscr_process_definition_list[] = { KC_OFFSETOF( struct kc_tag_cr_process_definition_list, Conscr_process_definition_list, cr_process_definition_1 ), KC_OFFSETOF( struct kc_tag_cr_process_definition_list, Conscr_process_definition_list, cr_process_definition_list_1 ) };
static kc_size_t kc_suboffsets_CR_Process_definition[] = { KC_OFFSETOF( struct kc_tag_cr_process_definition, CR_Process_definition, cr_comment_list_1 ), KC_OFFSETOF( struct kc_tag_cr_process_definition, CR_Process_definition, cr_process_identifier_1 ), KC_OFFSETOF( struct kc_tag_cr_process_definition, CR_Process_definition, cr_gate_identifier_list_1 ), KC_OFFSETOF( struct kc_tag_cr_process_definition, CR_Process_definition, cr_identifier_declaration_list_1 ), KC_OFFSETOF( struct kc_tag_cr_process_definition, CR_Process_definition, cr_functionality_1 ), KC_OFFSETOF( struct kc_tag_cr_process_definition, CR_Process_definition, cr_definition_block_1 ), KC_OFFSETOF( struct kc_tag_cr_process_definition, CR_Process_definition, cr_LABEL_1 ) };
static kc_size_t kc_suboffsets_CR_Exit_part[] = { KC_OFFSETOF( struct kc_tag_cr_functionality, CR_Exit_part, cr_sort_identifier_list_1 ) };
static kc_size_t kc_suboffsets_Conscr_sort_identifier_list[] = { KC_OFFSETOF( struct kc_tag_cr_sort_identifier_list, Conscr_sort_identifier_list, cr_sort_identifier_1 ), KC_OFFSETOF( struct kc_tag_cr_sort_identifier_list, Conscr_sort_identifier_list, cr_sort_identifier_list_1 ) };
static kc_size_t kc_suboffsets_Conscr_data_type_definition_list[] = { KC_OFFSETOF( struct kc_tag_cr_data_type_definition_list, Conscr_data_type_definition_list, cr_data_type_definition_1 ), KC_OFFSETOF( struct kc_tag_cr_data_type_definition_list, Conscr_data_type_definition_list, cr_data_type_definition_list_1 ) };
static kc_size_t kc_suboffsets_CR_Data_type_definition[] = { KC_OFFSETOF( struct kc_tag_cr_data_type_definition, CR_Data_type_definition, cr_comment_list_1 ), KC_OFFSETOF( struct kc_tag_cr_data_type_definition, CR_Data_type_definition, cr_type_identifier_1 ), KC_OFFSETOF( struct kc_tag_cr_data_type_definition, CR_Data_type_definition, cr_p_expression_1 ), KC_OFFSETOF( struct kc_tag_cr_data_type_definition, CR_Data_type_definition, cr_completeness_indication_1 ), KC_OFFSETOF( struct kc_tag_cr_data_type_definition, CR_Data_type_definition, cr_persistency_indication_1 ), KC_OFFSETOF( struct kc_tag_cr_data_type_definition, CR_Data_type_definition, cr_flattened_type_definition_1 ), KC_OFFSETOF( struct kc_tag_cr_data_type_definition, CR_Data_type_definition, cr_annotation_list_1 ) };
static kc_size_t kc_suboffsets_CR_Library_reference[] = { KC_OFFSETOF( struct kc_tag_cr_data_type_definition, CR_Library_reference, cr_type_identifier_1 ), KC_OFFSETOF( struct kc_tag_cr_data_type_definition, CR_Library_reference, cr_flattened_type_definition_1 ), KC_OFFSETOF( struct kc_tag_cr_data_type_definition, CR_Library_reference, cr_annotation_list_1 ) };
static kc_size_t kc_suboffsets_CR_P_Spec[] = { KC_OFFSETOF( struct kc_tag_cr_p_expression, CR_P_Spec, cr_type_identifier_list_1 ), KC_OFFSETOF( struct kc_tag_cr_p_expression, CR_P_Spec, cr_sort_declaration_list_1 ), KC_OFFSETOF( struct kc_tag_cr_p_expression, CR_P_Spec, cr_operation_list_1 ), KC_OFFSETOF( struct kc_tag_cr_p_expression, CR_P_Spec, cr_equations_option_1 ), KC_OFFSETOF( struct kc_tag_cr_p_expression, CR_P_Spec, cr_sort_declaration_list_2 ), KC_OFFSETOF( struct kc_tag_cr_p_expression, CR_P_Spec, cr_operation_list_2 ), KC_OFFSETOF( struct kc_tag_cr_p_expression, CR_P_Spec, cr_equations_option_2 ), KC_OFFSETOF( struct kc_tag_cr_p_expression, CR_P_Spec, cr_LABEL_1 ) };
static kc_size_t kc_suboffsets_CR_Actualization[] = { KC_OFFSETOF( struct kc_tag_cr_p_expression, CR_Actualization, cr_type_identifier_1 ), KC_OFFSETOF( struct kc_tag_cr_p_expression, CR_Actualization, cr_type_identifier_list_1 ), KC_OFFSETOF( struct kc_tag_cr_p_expression, CR_Actualization, cr_replacement_1 ), KC_OFFSETOF( struct kc_tag_cr_p_expression, CR_Actualization, cr_LABEL_1 ) };
static kc_size_t kc_suboffsets_CR_Renaming[] = { KC_OFFSETOF( struct kc_tag_cr_p_expression, CR_Renaming, cr_type_identifier_1 ), KC_OFFSETOF( struct kc_tag_cr_p_expression, CR_Renaming, cr_replacement_1 ), KC_OFFSETOF( struct kc_tag_cr_p_expression, CR_Renaming, cr_LABEL_1 ) };
static kc_size_t kc_suboffsets_Conscr_type_identifier_list[] = { KC_OFFSETOF( struct kc_tag_cr_type_identifier_list, Conscr_type_identifier_list, cr_type_identifier_1 ), KC_OFFSETOF( struct kc_tag_cr_type_identifier_list, Conscr_type_identifier_list, cr_type_identifier_list_1 ) };
static kc_size_t kc_suboffsets_CR_Replacement[] = { KC_OFFSETOF( struct kc_tag_cr_replacement, CR_Replacement, cr_sort_replacement_list_1 ), KC_OFFSETOF( struct kc_tag_cr_replacement, CR_Replacement, cr_operation_replacement_list_1 ) };
static kc_size_t kc_suboffsets_Conscr_sort_replacement_list[] = { KC_OFFSETOF( struct kc_tag_cr_sort_replacement_list, Conscr_sort_replacement_list, cr_sort_replacement_1 ), KC_OFFSETOF( struct kc_tag_cr_sort_replacement_list, Conscr_sort_replacement_list, cr_sort_replacement_list_1 ) };
static kc_size_t kc_suboffsets_CR_Sort_replacement[] = { KC_OFFSETOF( struct kc_tag_cr_sort_replacement, CR_Sort_replacement, cr_sort_name_1 ), KC_OFFSETOF( struct kc_tag_cr_sort_replacement, CR_Sort_replacement, cr_sort_name_2 ), KC_OFFSETOF( struct kc_tag_cr_sort_replacement, CR_Sort_replacement, cr_LABEL_1 ) };
static kc_size_t kc_suboffsets_Conscr_sort_declaration_list[] = { KC_OFFSETOF( struct kc_tag_cr_sort_declaration_list, Conscr_sort_declaration_list, cr_sort_declaration_1 ), KC_OFFSETOF( struct kc_tag_cr_sort_declaration_list, Conscr_sort_declaration_list, cr_sort_declaration_list_1 ) };
static kc_size_t kc_suboffsets_CR_Sort_declaration[] = { KC_OFFSETOF( struct kc_tag_cr_sort_declaration, CR_Sort_declaration, cr_sort_identifier_1 ), KC_OFFSETOF( struct kc_tag_cr_sort_declaration, CR_Sort_declaration, cr_LABEL_1 ), KC_OFFSETOF( struct kc_tag_cr_sort_declaration, CR_Sort_declaration, cr_annotation_list_1 ) };
static kc_size_t kc_suboffsets_Conscr_operation_replacement_list[] = { KC_OFFSETOF( struct kc_tag_cr_operation_replacement_list, Conscr_operation_replacement_list, cr_operation_replacement_1 ), KC_OFFSETOF( struct kc_tag_cr_operation_replacement_list, Conscr_operation_replacement_list, cr_operation_replacement_list_1 ) };
static kc_size_t kc_suboffsets_CR_Operation_replacement[] = { KC_OFFSETOF( struct kc_tag_cr_operation_replacement, CR_Operation_replacement, cr_operation_name_1 ), KC_OFFSETOF( struct kc_tag_cr_operation_replacement, CR_Operation_replacement, cr_operation_name_2 ), KC_OFFSETOF( struct kc_tag_cr_operation_replacement, CR_Operation_replacement, cr_LABEL_1 ) };
static kc_size_t kc_suboffsets_CR_Formal_type[] = { KC_OFFSETOF( struct kc_tag_cr_flattened_type_definition, CR_Formal_type, cr_type_identifier_list_1 ), KC_OFFSETOF( struct kc_tag_cr_flattened_type_definition, CR_Formal_type, cr_sort_declaration_list_1 ), KC_OFFSETOF( struct kc_tag_cr_flattened_type_definition, CR_Formal_type, cr_operation_list_1 ), KC_OFFSETOF( struct kc_tag_cr_flattened_type_definition, CR_Formal_type, cr_equations_option_1 ), KC_OFFSETOF( struct kc_tag_cr_flattened_type_definition, CR_Formal_type, cr_sort_declaration_list_2 ), KC_OFFSETOF( struct kc_tag_cr_flattened_type_definition, CR_Formal_type, cr_operation_list_2 ), KC_OFFSETOF( struct kc_tag_cr_flattened_type_definition, CR_Formal_type, cr_equations_option_2 ) };
static kc_size_t kc_suboffsets_CR_Actual_type[] = { KC_OFFSETOF( struct kc_tag_cr_flattened_type_definition, CR_Actual_type, cr_type_identifier_list_1 ), KC_OFFSETOF( struct kc_tag_cr_flattened_type_definition, CR_Actual_type, cr_sort_declaration_list_1 ), KC_OFFSETOF( struct kc_tag_cr_flattened_type_definition, CR_Actual_type, cr_operation_list_1 ), KC_OFFSETOF( struct kc_tag_cr_flattened_type_definition, CR_Actual_type, cr_equations_option_1 ) };
static kc_size_t kc_suboffsets_Conscr_operation_list[] = { KC_OFFSETOF( struct kc_tag_cr_operation_list, Conscr_operation_list, cr_operation_1 ), KC_OFFSETOF( struct kc_tag_cr_operation_list, Conscr_operation_list, cr_operation_list_1 ) };
static kc_size_t kc_suboffsets_CR_Operation[] = { KC_OFFSETOF( struct kc_tag_cr_operation, CR_Operation, cr_operation_identifier_1 ), KC_OFFSETOF( struct kc_tag_cr_operation, CR_Operation, cr_prefix_infix_1 ), KC_OFFSETOF( struct kc_tag_cr_operation, CR_Operation, cr_sort_identifier_list_1 ), KC_OFFSETOF( struct kc_tag_cr_operation, CR_Operation, cr_sort_identifier_1 ), KC_OFFSETOF( struct kc_tag_cr_operation, CR_Operation, cr_rewrite_strategy_1 ), KC_OFFSETOF( struct kc_tag_cr_operation, CR_Operation, cr_operator_class_1 ), KC_OFFSETOF( struct kc_tag_cr_operation, CR_Operation, cr_LABEL_1 ), KC_OFFSETOF( struct kc_tag_cr_operation, CR_Operation, cr_annotation_list_1 ) };
static kc_size_t kc_suboffsets_CR_YesEquations[] = { KC_OFFSETOF( struct kc_tag_cr_equations_option, CR_YesEquations, cr_identifier_declaration_list_1 ), KC_OFFSETOF( struct kc_tag_cr_equations_option, CR_YesEquations, cr_equation_structure_list_1 ) };
static kc_size_t kc_suboffsets_Conscr_equation_structure_list[] = { KC_OFFSETOF( struct kc_tag_cr_equation_structure_list, Conscr_equation_structure_list, cr_equation_structure_1 ), KC_OFFSETOF( struct kc_tag_cr_equation_structure_list, Conscr_equation_structure_list, cr_equation_structure_list_1 ) };
static kc_size_t kc_suboffsets_CR_Equation_structure[] = { KC_OFFSETOF( struct kc_tag_cr_equation_structure, CR_Equation_structure, cr_sort_identifier_1 ), KC_OFFSETOF( struct kc_tag_cr_equation_structure, CR_Equation_structure, cr_identifier_declaration_list_1 ), KC_OFFSETOF( struct kc_tag_cr_equation_structure, CR_Equation_structure, cr_equation_list_1 ) };
static kc_size_t kc_suboffsets_Conscr_equation_list[] = { KC_OFFSETOF( struct kc_tag_cr_equation_list, Conscr_equation_list, cr_equation_1 ), KC_OFFSETOF( struct kc_tag_cr_equation_list, Conscr_equation_list, cr_equation_list_1 ) };
static kc_size_t kc_suboffsets_CR_Equation[] = { KC_OFFSETOF( struct kc_tag_cr_equation, CR_Equation, cr_premiss_list_1 ), KC_OFFSETOF( struct kc_tag_cr_equation, CR_Equation, cr_equality_1 ), KC_OFFSETOF( struct kc_tag_cr_equation, CR_Equation, cr_LABEL_1 ) };
static kc_size_t kc_suboffsets_Conscr_premiss_list[] = { KC_OFFSETOF( struct kc_tag_cr_premiss_list, Conscr_premiss_list, cr_equality_1 ), KC_OFFSETOF( struct kc_tag_cr_premiss_list, Conscr_premiss_list, cr_premiss_list_1 ) };
static kc_size_t kc_suboffsets_CR_Equals[] = { KC_OFFSETOF( struct kc_tag_cr_equality, CR_Equals, cr_value_expression_1 ), KC_OFFSETOF( struct kc_tag_cr_equality, CR_Equals, cr_value_expression_2 ) };
static kc_size_t kc_suboffsets_Conscr_identifier_declaration_list[] = { KC_OFFSETOF( struct kc_tag_cr_identifier_declaration_list, Conscr_identifier_declaration_list, cr_identifier_declaration_1 ), KC_OFFSETOF( struct kc_tag_cr_identifier_declaration_list, Conscr_identifier_declaration_list, cr_identifier_declaration_list_1 ) };
static kc_size_t kc_suboffsets_CR_Identifier_declaration[] = { KC_OFFSETOF( struct kc_tag_cr_identifier_declaration, CR_Identifier_declaration, cr_value_identifier_list_1 ), KC_OFFSETOF( struct kc_tag_cr_identifier_declaration, CR_Identifier_declaration, cr_sort_identifier_1 ) };
static kc_size_t kc_suboffsets_Conscr_value_identifier_list[] = { KC_OFFSETOF( struct kc_tag_cr_value_identifier_list, Conscr_value_identifier_list, cr_annotated_value_identifier_1 ), KC_OFFSETOF( struct kc_tag_cr_value_identifier_list, Conscr_value_identifier_list, cr_value_identifier_list_1 ) };
static kc_size_t kc_suboffsets_CR_annotated_val_id[] = { KC_OFFSETOF( struct kc_tag_cr_annotated_value_identifier, CR_annotated_val_id, cr_value_identifier_1 ), KC_OFFSETOF( struct kc_tag_cr_annotated_value_identifier, CR_annotated_val_id, cr_annotation_list_1 ) };
static kc_size_t kc_suboffsets_CR_Stop_expression[] = { KC_OFFSETOF( struct kc_tag_cr_behaviour_expression, CR_Stop_expression, cr_LABEL_1 ), KC_OFFSETOF( struct kc_tag_cr_behaviour_expression, CR_Stop_expression, cr_annotation_list_1 ) };
static kc_size_t kc_suboffsets_CR_Exit_expression[] = { KC_OFFSETOF( struct kc_tag_cr_behaviour_expression, CR_Exit_expression, cr_exit_entry_list_1 ), KC_OFFSETOF( struct kc_tag_cr_behaviour_expression, CR_Exit_expression, cr_LABEL_1 ), KC_OFFSETOF( struct kc_tag_cr_behaviour_expression, CR_Exit_expression, cr_annotation_list_1 ) };
static kc_size_t kc_suboffsets_CR_Process_instantiation[] = { KC_OFFSETOF( struct kc_tag_cr_behaviour_expression, CR_Process_instantiation, cr_process_identifier_1 ), KC_OFFSETOF( struct kc_tag_cr_behaviour_expression, CR_Process_instantiation, cr_gate_identifier_list_1 ), KC_OFFSETOF( struct kc_tag_cr_behaviour_expression, CR_Process_instantiation, cr_value_expression_list_1 ), KC_OFFSETOF( struct kc_tag_cr_behaviour_expression, CR_Process_instantiation, cr_LABEL_1 ), KC_OFFSETOF( struct kc_tag_cr_behaviour_expression, CR_Process_instantiation, cr_annotation_list_1 ) };
static kc_size_t kc_suboffsets_CR_Action_prefix_expression[] = { KC_OFFSETOF( struct kc_tag_cr_behaviour_expression, CR_Action_prefix_expression, cr_action_denotation_1 ), KC_OFFSETOF( struct kc_tag_cr_behaviour_expression, CR_Action_prefix_expression, cr_behaviour_expression_1 ), KC_OFFSETOF( struct kc_tag_cr_behaviour_expression, CR_Action_prefix_expression, cr_LABEL_1 ), KC_OFFSETOF( struct kc_tag_cr_behaviour_expression, CR_Action_prefix_expression, cr_annotation_list_1 ) };
static kc_size_t kc_suboffsets_CR_Local_definition_expression[] = { KC_OFFSETOF( struct kc_tag_cr_behaviour_expression, CR_Local_definition_expression, cr_identifier_equation_list_1 ), KC_OFFSETOF( struct kc_tag_cr_behaviour_expression, CR_Local_definition_expression, cr_behaviour_expression_1 ) };
static kc_size_t kc_suboffsets_CR_Sum_identifier_expression[] = { KC_OFFSETOF( struct kc_tag_cr_behaviour_expression, CR_Sum_identifier_expression, cr_identifier_declaration_list_1 ), KC_OFFSETOF( struct kc_tag_cr_behaviour_expression, CR_Sum_identifier_expression, cr_behaviour_expression_1 ) };
static kc_size_t kc_suboffsets_CR_Sum_gate_expression[] = { KC_OFFSETOF( struct kc_tag_cr_behaviour_expression, CR_Sum_gate_expression, cr_gate_declaration_list_1 ), KC_OFFSETOF( struct kc_tag_cr_behaviour_expression, CR_Sum_gate_expression, cr_behaviour_expression_1 ) };
static kc_size_t kc_suboffsets_CR_Par_expression[] = { KC_OFFSETOF( struct kc_tag_cr_behaviour_expression, CR_Par_expression, cr_gate_declaration_list_1 ), KC_OFFSETOF( struct kc_tag_cr_behaviour_expression, CR_Par_expression, cr_parallel_operator_1 ), KC_OFFSETOF( struct kc_tag_cr_behaviour_expression, CR_Par_expression, cr_behaviour_expression_1 ), KC_OFFSETOF( struct kc_tag_cr_behaviour_expression, CR_Par_expression, cr_LABEL_1 ) };
static kc_size_t kc_suboffsets_CR_Hiding_expression[] = { KC_OFFSETOF( struct kc_tag_cr_behaviour_expression, CR_Hiding_expression, cr_gate_identifier_list_1 ), KC_OFFSETOF( struct kc_tag_cr_behaviour_expression, CR_Hiding_expression, cr_behaviour_expression_1 ) };
static kc_size_t kc_suboffsets_CR_Enable_expression[] = { KC_OFFSETOF( struct kc_tag_cr_behaviour_expression, CR_Enable_expression, cr_behaviour_expression_1 ), KC_OFFSETOF( struct kc_tag_cr_behaviour_expression, CR_Enable_expression, cr_identifier_declaration_list_1 ), KC_OFFSETOF( struct kc_tag_cr_behaviour_expression, CR_Enable_expression, cr_behaviour_expression_2 ) };
static kc_size_t kc_suboffsets_CR_Disable_expression[] = { KC_OFFSETOF( struct kc_tag_cr_behaviour_expression, CR_Disable_expression, cr_behaviour_expression_1 ), KC_OFFSETOF( struct kc_tag_cr_behaviour_expression, CR_Disable_expression, cr_behaviour_expression_2 ) };
static kc_size_t kc_suboffsets_CR_Parallel_expression[] = { KC_OFFSETOF( struct kc_tag_cr_behaviour_expression, CR_Parallel_expression, cr_behaviour_expression_1 ), KC_OFFSETOF( struct kc_tag_cr_behaviour_expression, CR_Parallel_expression, cr_parallel_operator_1 ), KC_OFFSETOF( struct kc_tag_cr_behaviour_expression, CR_Parallel_expression, cr_behaviour_expression_2 ), KC_OFFSETOF( struct kc_tag_cr_behaviour_expression, CR_Parallel_expression, cr_LABEL_1 ) };
static kc_size_t kc_suboffsets_CR_Choice_expression[] = { KC_OFFSETOF( struct kc_tag_cr_behaviour_expression, CR_Choice_expression, cr_behaviour_expression_1 ), KC_OFFSETOF( struct kc_tag_cr_behaviour_expression, CR_Choice_expression, cr_behaviour_expression_2 ) };
static kc_size_t kc_suboffsets_CR_Guarded_expression[] = { KC_OFFSETOF( struct kc_tag_cr_behaviour_expression, CR_Guarded_expression, cr_equality_1 ), KC_OFFSETOF( struct kc_tag_cr_behaviour_expression, CR_Guarded_expression, cr_behaviour_expression_1 ) };
static kc_size_t kc_suboffsets_CR_Annotated_behaviour[] = { KC_OFFSETOF( struct kc_tag_cr_behaviour_expression, CR_Annotated_behaviour, cr_annotation_list_1 ), KC_OFFSETOF( struct kc_tag_cr_behaviour_expression, CR_Annotated_behaviour, cr_behaviour_expression_1 ) };
static kc_size_t kc_suboffsets_CR_General_parallel_operator[] = { KC_OFFSETOF( struct kc_tag_cr_parallel_operator, CR_General_parallel_operator, cr_gate_identifier_list_1 ) };
static kc_size_t kc_suboffsets_Conscr_gate_declaration_list[] = { KC_OFFSETOF( struct kc_tag_cr_gate_declaration_list, Conscr_gate_declaration_list, cr_gate_declaration_1 ), KC_OFFSETOF( struct kc_tag_cr_gate_declaration_list, Conscr_gate_declaration_list, cr_gate_declaration_list_1 ) };
static kc_size_t kc_suboffsets_CR_Gate_declaration[] = { KC_OFFSETOF( struct kc_tag_cr_gate_declaration, CR_Gate_declaration, cr_gate_identifier_list_1 ), KC_OFFSETOF( struct kc_tag_cr_gate_declaration, CR_Gate_declaration, cr_gate_identifier_list_2 ) };
static kc_size_t kc_suboffsets_Conscr_gate_identifier_list[] = { KC_OFFSETOF( struct kc_tag_cr_gate_identifier_list, Conscr_gate_identifier_list, cr_gate_identifier_1 ), KC_OFFSETOF( struct kc_tag_cr_gate_identifier_list, Conscr_gate_identifier_list, cr_gate_identifier_list_1 ) };
static kc_size_t kc_suboffsets_Conscr_exit_entry_list[] = { KC_OFFSETOF( struct kc_tag_cr_exit_entry_list, Conscr_exit_entry_list, cr_exit_entry_1 ), KC_OFFSETOF( struct kc_tag_cr_exit_entry_list, Conscr_exit_entry_list, cr_exit_entry_list_1 ) };
static kc_size_t kc_suboffsets_CR_Value_expression_exit_entry[] = { KC_OFFSETOF( struct kc_tag_cr_exit_entry, CR_Value_expression_exit_entry, cr_value_expression_1 ) };
static kc_size_t kc_suboffsets_CR_Sort_identifier_exit_entry[] = { KC_OFFSETOF( struct kc_tag_cr_exit_entry, CR_Sort_identifier_exit_entry, cr_sort_identifier_1 ) };
static kc_size_t kc_suboffsets_Conscr_identifier_equation_list[] = { KC_OFFSETOF( struct kc_tag_cr_identifier_equation_list, Conscr_identifier_equation_list, cr_identifier_equation_1 ), KC_OFFSETOF( struct kc_tag_cr_identifier_equation_list, Conscr_identifier_equation_list, cr_identifier_equation_list_1 ) };
static kc_size_t kc_suboffsets_CR_Identifier_equation[] = { KC_OFFSETOF( struct kc_tag_cr_identifier_equation, CR_Identifier_equation, cr_identifier_declaration_1 ), KC_OFFSETOF( struct kc_tag_cr_identifier_equation, CR_Identifier_equation, cr_value_expression_1 ) };
static kc_size_t kc_suboffsets_CR_Communication[] = { KC_OFFSETOF( struct kc_tag_cr_action_denotation, CR_Communication, cr_gate_identifier_1 ), KC_OFFSETOF( struct kc_tag_cr_action_denotation, CR_Communication, cr_experiment_option_1 ) };
static kc_size_t kc_suboffsets_CR_YesExperiment[] = { KC_OFFSETOF( struct kc_tag_cr_experiment_option, CR_YesExperiment, cr_experiment_offer_list_1 ), KC_OFFSETOF( struct kc_tag_cr_experiment_option, CR_YesExperiment, cr_guard_option_1 ) };
static kc_size_t kc_suboffsets_Conscr_experiment_offer_list[] = { KC_OFFSETOF( struct kc_tag_cr_experiment_offer_list, Conscr_experiment_offer_list, cr_experiment_offer_1 ), KC_OFFSETOF( struct kc_tag_cr_experiment_offer_list, Conscr_experiment_offer_list, cr_experiment_offer_list_1 ) };
static kc_size_t kc_suboffsets_CR_Query_offer[] = { KC_OFFSETOF( struct kc_tag_cr_experiment_offer, CR_Query_offer, cr_identifier_declaration_1 ) };
static kc_size_t kc_suboffsets_CR_Exclam_offer[] = { KC_OFFSETOF( struct kc_tag_cr_experiment_offer, CR_Exclam_offer, cr_value_expression_1 ) };
static kc_size_t kc_suboffsets_CR_YesGuard[] = { KC_OFFSETOF( struct kc_tag_cr_guard_option, CR_YesGuard, cr_equality_1 ) };
static kc_size_t kc_suboffsets_Conscr_value_expression_list[] = { KC_OFFSETOF( struct kc_tag_cr_value_expression_list, Conscr_value_expression_list, cr_value_expression_1 ), KC_OFFSETOF( struct kc_tag_cr_value_expression_list, Conscr_value_expression_list, cr_value_expression_list_1 ) };
static kc_size_t kc_suboffsets_CR_Term[] = { KC_OFFSETOF( struct kc_tag_cr_value_expression, CR_Term, cr_operation_identifier_1 ), KC_OFFSETOF( struct kc_tag_cr_value_expression, CR_Term, cr_value_expression_list_1 ), KC_OFFSETOF( struct kc_tag_cr_value_expression, CR_Term, cr_sort_identifier_1 ) };
static kc_size_t kc_suboffsets_CR_Value[] = { KC_OFFSETOF( struct kc_tag_cr_value_expression, CR_Value, cr_value_identifier_1 ), KC_OFFSETOF( struct kc_tag_cr_value_expression, CR_Value, cr_sort_identifier_1 ) };
static kc_size_t kc_suboffsets_CR_Annotated_value_expression[] = { KC_OFFSETOF( struct kc_tag_cr_value_expression, CR_Annotated_value_expression, cr_value_expression_1 ), KC_OFFSETOF( struct kc_tag_cr_value_expression, CR_Annotated_value_expression, cr_annotation_list_1 ) };
static kc_size_t kc_suboffsets_CR_Specification_id[] = { KC_OFFSETOF( struct kc_tag_cr_specification_identifier, CR_Specification_id, cr_identifier_1 ) };
static kc_size_t kc_suboffsets_CR_Operation_id[] = { KC_OFFSETOF( struct kc_tag_cr_operation_identifier, CR_Operation_id, cr_identifier_1 ) };
static kc_size_t kc_suboffsets_CR_Type_id[] = { KC_OFFSETOF( struct kc_tag_cr_type_identifier, CR_Type_id, cr_identifier_1 ) };
static kc_size_t kc_suboffsets_CR_Sort_id[] = { KC_OFFSETOF( struct kc_tag_cr_sort_identifier, CR_Sort_id, cr_identifier_1 ) };
static kc_size_t kc_suboffsets_CR_Gate_id[] = { KC_OFFSETOF( struct kc_tag_cr_gate_identifier, CR_Gate_id, cr_identifier_1 ) };
static kc_size_t kc_suboffsets_CR_Value_id[] = { KC_OFFSETOF( struct kc_tag_cr_value_identifier, CR_Value_id, cr_identifier_1 ) };
static kc_size_t kc_suboffsets_CR_Process_id[] = { KC_OFFSETOF( struct kc_tag_cr_process_identifier, CR_Process_id, cr_identifier_1 ) };
static kc_size_t kc_suboffsets_CR_Identifier[] = { KC_OFFSETOF( struct kc_tag_cr_identifier, CR_Identifier, nocasestring_1 ), KC_OFFSETOF( struct kc_tag_cr_identifier, CR_Identifier, cr_extension_1 ) };
static kc_size_t kc_suboffsets_CR_DefExtension[] = { KC_OFFSETOF( struct kc_tag_cr_extension, CR_DefExtension, nocasestring_1 ) };
static kc_size_t kc_suboffsets_CR_Operation_name[] = { KC_OFFSETOF( struct kc_tag_cr_operation_name, CR_Operation_name, cr_name_1 ) };
static kc_size_t kc_suboffsets_CR_Sort_name[] = { KC_OFFSETOF( struct kc_tag_cr_sort_name, CR_Sort_name, cr_name_1 ) };
static kc_size_t kc_suboffsets_CR_Name[] = { KC_OFFSETOF( struct kc_tag_cr_name, CR_Name, nocasestring_1 ) };
static kc_size_t kc_suboffsets_Conscr_comment_list[] = { KC_OFFSETOF( struct kc_tag_cr_comment_list, Conscr_comment_list, casestring_1 ), KC_OFFSETOF( struct kc_tag_cr_comment_list, Conscr_comment_list, cr_comment_list_1 ) };
static kc_size_t kc_suboffsets_Conscr_annotation_list[] = { KC_OFFSETOF( struct kc_tag_cr_annotation_list, Conscr_annotation_list, casestring_1 ), KC_OFFSETOF( struct kc_tag_cr_annotation_list, Conscr_annotation_list, cr_annotation_list_1 ) };
static kc_size_t kc_suboffsets_CR_Label[] = { KC_OFFSETOF( struct kc_tag_cr_LABEL, CR_Label, casestring_1 ) };


KC_OPERATOR_INFO kc_OperatorInfo[] = {
	{ "", 0, 0, kc_one_before_first_phylum, (kc_enum_phyla_list)0, (kc_size_t_list)0, (kc_storageclass_t)0, 0 }, /* dummy element */
	{ "NoCaseStr", 0, 1, kc_phylum_nocasestring, (kc_enum_phyla_list)0, (kc_size_t_list)0, kc_uniq_nullary_operator, 0 },
	{ "_Str", 0, 1, kc_phylum_casestring, (kc_enum_phyla_list)0, (kc_size_t_list)0, kc_uniq_nullary_operator, 0 },
	{ "_Real", 0, 1, kc_phylum_float, (kc_enum_phyla_list)0, (kc_size_t_list)0, kc_uniq_nullary_operator, 0 },
	{ "_Int", 0, 1, kc_phylum_int, (kc_enum_phyla_list)0, (kc_size_t_list)0, kc_uniq_nullary_operator, 0 },
	{ "CR_Spec", 12, 0, kc_phylum_cr_specification, kc_subphyla_CR_Spec, kc_suboffsets_CR_Spec, kc_not_uniq, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))CR_Spec },
	{ "CR_IS8807", 0, 0, kc_phylum_cr_specification_type, (kc_enum_phyla_list)0, (kc_size_t_list)0, kc_uniq_nullary_operator, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))CR_IS8807 },
	{ "CR_Basic_LOTOS", 0, 0, kc_phylum_cr_specification_type, (kc_enum_phyla_list)0, (kc_size_t_list)0, kc_uniq_nullary_operator, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))CR_Basic_LOTOS },
	{ "CR_Booleans_NotChecked", 0, 0, kc_phylum_cr_boolean_indication, (kc_enum_phyla_list)0, (kc_size_t_list)0, kc_uniq_nullary_operator, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))CR_Booleans_NotChecked },
	{ "CR_Booleans_NotOk", 0, 0, kc_phylum_cr_boolean_indication, (kc_enum_phyla_list)0, (kc_size_t_list)0, kc_uniq_nullary_operator, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))CR_Booleans_NotOk },
	{ "CR_Booleans_Ok", 0, 0, kc_phylum_cr_boolean_indication, (kc_enum_phyla_list)0, (kc_size_t_list)0, kc_uniq_nullary_operator, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))CR_Booleans_Ok },
	{ "CR_Definition_block", 3, 0, kc_phylum_cr_definition_block, kc_subphyla_CR_Definition_block, kc_suboffsets_CR_Definition_block, kc_not_uniq, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))CR_Definition_block },
	{ "Nilcr_process_definition_list", 0, 0, kc_phylum_cr_process_definition_list, (kc_enum_phyla_list)0, (kc_size_t_list)0, kc_uniq_nullary_operator, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))Nilcr_process_definition_list },
	{ "Conscr_process_definition_list", 2, 0, kc_phylum_cr_process_definition_list, kc_subphyla_Conscr_process_definition_list, kc_suboffsets_Conscr_process_definition_list, kc_not_uniq, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))Conscr_process_definition_list },
	{ "CR_Process_definition", 7, 0, kc_phylum_cr_process_definition, kc_subphyla_CR_Process_definition, kc_suboffsets_CR_Process_definition, kc_not_uniq, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))CR_Process_definition },
	{ "CR_Exit_part", 1, 0, kc_phylum_cr_functionality, kc_subphyla_CR_Exit_part, kc_suboffsets_CR_Exit_part, kc_not_uniq, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))CR_Exit_part },
	{ "CR_Noexit_part", 0, 0, kc_phylum_cr_functionality, (kc_enum_phyla_list)0, (kc_size_t_list)0, kc_uniq_nullary_operator, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))CR_Noexit_part },
	{ "Nilcr_sort_identifier_list", 0, 0, kc_phylum_cr_sort_identifier_list, (kc_enum_phyla_list)0, (kc_size_t_list)0, kc_uniq_nullary_operator, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))Nilcr_sort_identifier_list },
	{ "Conscr_sort_identifier_list", 2, 0, kc_phylum_cr_sort_identifier_list, kc_subphyla_Conscr_sort_identifier_list, kc_suboffsets_Conscr_sort_identifier_list, kc_not_uniq, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))Conscr_sort_identifier_list },
	{ "Nilcr_data_type_definition_list", 0, 0, kc_phylum_cr_data_type_definition_list, (kc_enum_phyla_list)0, (kc_size_t_list)0, kc_uniq_nullary_operator, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))Nilcr_data_type_definition_list },
	{ "Conscr_data_type_definition_list", 2, 0, kc_phylum_cr_data_type_definition_list, kc_subphyla_Conscr_data_type_definition_list, kc_suboffsets_Conscr_data_type_definition_list, kc_not_uniq, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))Conscr_data_type_definition_list },
	{ "CR_Data_type_definition", 7, 0, kc_phylum_cr_data_type_definition, kc_subphyla_CR_Data_type_definition, kc_suboffsets_CR_Data_type_definition, kc_not_uniq, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))CR_Data_type_definition },
	{ "CR_Library_reference", 3, 0, kc_phylum_cr_data_type_definition, kc_subphyla_CR_Library_reference, kc_suboffsets_CR_Library_reference, kc_not_uniq, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))CR_Library_reference },
	{ "CR_Completeness_NotChecked", 0, 0, kc_phylum_cr_completeness_indication, (kc_enum_phyla_list)0, (kc_size_t_list)0, kc_uniq_nullary_operator, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))CR_Completeness_NotChecked },
	{ "CR_Complete", 0, 0, kc_phylum_cr_completeness_indication, (kc_enum_phyla_list)0, (kc_size_t_list)0, kc_uniq_nullary_operator, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))CR_Complete },
	{ "CR_Not_Complete", 0, 0, kc_phylum_cr_completeness_indication, (kc_enum_phyla_list)0, (kc_size_t_list)0, kc_uniq_nullary_operator, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))CR_Not_Complete },
	{ "CR_Persistency_NotChecked", 0, 0, kc_phylum_cr_persistency_indication, (kc_enum_phyla_list)0, (kc_size_t_list)0, kc_uniq_nullary_operator, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))CR_Persistency_NotChecked },
	{ "CR_Persistent", 0, 0, kc_phylum_cr_persistency_indication, (kc_enum_phyla_list)0, (kc_size_t_list)0, kc_uniq_nullary_operator, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))CR_Persistent },
	{ "CR_Not_Persistent", 0, 0, kc_phylum_cr_persistency_indication, (kc_enum_phyla_list)0, (kc_size_t_list)0, kc_uniq_nullary_operator, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))CR_Not_Persistent },
	{ "CR_P_Spec", 8, 0, kc_phylum_cr_p_expression, kc_subphyla_CR_P_Spec, kc_suboffsets_CR_P_Spec, kc_not_uniq, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))CR_P_Spec },
	{ "CR_Actualization", 4, 0, kc_phylum_cr_p_expression, kc_subphyla_CR_Actualization, kc_suboffsets_CR_Actualization, kc_not_uniq, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))CR_Actualization },
	{ "CR_Renaming", 3, 0, kc_phylum_cr_p_expression, kc_subphyla_CR_Renaming, kc_suboffsets_CR_Renaming, kc_not_uniq, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))CR_Renaming },
	{ "Nilcr_type_identifier_list", 0, 0, kc_phylum_cr_type_identifier_list, (kc_enum_phyla_list)0, (kc_size_t_list)0, kc_uniq_nullary_operator, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))Nilcr_type_identifier_list },
	{ "Conscr_type_identifier_list", 2, 0, kc_phylum_cr_type_identifier_list, kc_subphyla_Conscr_type_identifier_list, kc_suboffsets_Conscr_type_identifier_list, kc_not_uniq, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))Conscr_type_identifier_list },
	{ "CR_Replacement", 2, 0, kc_phylum_cr_replacement, kc_subphyla_CR_Replacement, kc_suboffsets_CR_Replacement, kc_not_uniq, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))CR_Replacement },
	{ "Nilcr_sort_replacement_list", 0, 0, kc_phylum_cr_sort_replacement_list, (kc_enum_phyla_list)0, (kc_size_t_list)0, kc_uniq_nullary_operator, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))Nilcr_sort_replacement_list },
	{ "Conscr_sort_replacement_list", 2, 0, kc_phylum_cr_sort_replacement_list, kc_subphyla_Conscr_sort_replacement_list, kc_suboffsets_Conscr_sort_replacement_list, kc_not_uniq, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))Conscr_sort_replacement_list },
	{ "CR_Sort_replacement", 3, 0, kc_phylum_cr_sort_replacement, kc_subphyla_CR_Sort_replacement, kc_suboffsets_CR_Sort_replacement, kc_not_uniq, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))CR_Sort_replacement },
	{ "Nilcr_sort_declaration_list", 0, 0, kc_phylum_cr_sort_declaration_list, (kc_enum_phyla_list)0, (kc_size_t_list)0, kc_uniq_nullary_operator, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))Nilcr_sort_declaration_list },
	{ "Conscr_sort_declaration_list", 2, 0, kc_phylum_cr_sort_declaration_list, kc_subphyla_Conscr_sort_declaration_list, kc_suboffsets_Conscr_sort_declaration_list, kc_not_uniq, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))Conscr_sort_declaration_list },
	{ "CR_Sort_declaration", 3, 0, kc_phylum_cr_sort_declaration, kc_subphyla_CR_Sort_declaration, kc_suboffsets_CR_Sort_declaration, kc_not_uniq, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))CR_Sort_declaration },
	{ "Nilcr_operation_replacement_list", 0, 0, kc_phylum_cr_operation_replacement_list, (kc_enum_phyla_list)0, (kc_size_t_list)0, kc_uniq_nullary_operator, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))Nilcr_operation_replacement_list },
	{ "Conscr_operation_replacement_list", 2, 0, kc_phylum_cr_operation_replacement_list, kc_subphyla_Conscr_operation_replacement_list, kc_suboffsets_Conscr_operation_replacement_list, kc_not_uniq, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))Conscr_operation_replacement_list },
	{ "CR_Operation_replacement", 3, 0, kc_phylum_cr_operation_replacement, kc_subphyla_CR_Operation_replacement, kc_suboffsets_CR_Operation_replacement, kc_not_uniq, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))CR_Operation_replacement },
	{ "CR_Formal_type", 7, 0, kc_phylum_cr_flattened_type_definition, kc_subphyla_CR_Formal_type, kc_suboffsets_CR_Formal_type, kc_not_uniq, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))CR_Formal_type },
	{ "CR_Actual_type", 4, 0, kc_phylum_cr_flattened_type_definition, kc_subphyla_CR_Actual_type, kc_suboffsets_CR_Actual_type, kc_not_uniq, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))CR_Actual_type },
	{ "Nilcr_operation_list", 0, 0, kc_phylum_cr_operation_list, (kc_enum_phyla_list)0, (kc_size_t_list)0, kc_uniq_nullary_operator, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))Nilcr_operation_list },
	{ "Conscr_operation_list", 2, 0, kc_phylum_cr_operation_list, kc_subphyla_Conscr_operation_list, kc_suboffsets_Conscr_operation_list, kc_not_uniq, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))Conscr_operation_list },
	{ "CR_Operation", 8, 0, kc_phylum_cr_operation, kc_subphyla_CR_Operation, kc_suboffsets_CR_Operation, kc_not_uniq, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))CR_Operation },
	{ "CR_Infix", 0, 0, kc_phylum_cr_prefix_infix, (kc_enum_phyla_list)0, (kc_size_t_list)0, kc_uniq_nullary_operator, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))CR_Infix },
	{ "CR_Prefix", 0, 0, kc_phylum_cr_prefix_infix, (kc_enum_phyla_list)0, (kc_size_t_list)0, kc_uniq_nullary_operator, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))CR_Prefix },
	{ "CR_Default", 0, 0, kc_phylum_cr_rewrite_strategy, (kc_enum_phyla_list)0, (kc_size_t_list)0, kc_uniq_nullary_operator, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))CR_Default },
	{ "CR_Leftmost_innermost", 0, 0, kc_phylum_cr_rewrite_strategy, (kc_enum_phyla_list)0, (kc_size_t_list)0, kc_uniq_nullary_operator, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))CR_Leftmost_innermost },
	{ "CR_Leftmost_outermost", 0, 0, kc_phylum_cr_rewrite_strategy, (kc_enum_phyla_list)0, (kc_size_t_list)0, kc_uniq_nullary_operator, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))CR_Leftmost_outermost },
	{ "CR_If_then_else", 0, 0, kc_phylum_cr_rewrite_strategy, (kc_enum_phyla_list)0, (kc_size_t_list)0, kc_uniq_nullary_operator, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))CR_If_then_else },
	{ "CR_Projection", 0, 0, kc_phylum_cr_rewrite_strategy, (kc_enum_phyla_list)0, (kc_size_t_list)0, kc_uniq_nullary_operator, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))CR_Projection },
	{ "CR_Unknown", 0, 0, kc_phylum_cr_operator_class, (kc_enum_phyla_list)0, (kc_size_t_list)0, kc_uniq_nullary_operator, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))CR_Unknown },
	{ "CR_Constructor", 0, 0, kc_phylum_cr_operator_class, (kc_enum_phyla_list)0, (kc_size_t_list)0, kc_uniq_nullary_operator, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))CR_Constructor },
	{ "CR_Derived", 0, 0, kc_phylum_cr_operator_class, (kc_enum_phyla_list)0, (kc_size_t_list)0, kc_uniq_nullary_operator, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))CR_Derived },
	{ "CR_NoEquations", 0, 0, kc_phylum_cr_equations_option, (kc_enum_phyla_list)0, (kc_size_t_list)0, kc_uniq_nullary_operator, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))CR_NoEquations },
	{ "CR_YesEquations", 2, 0, kc_phylum_cr_equations_option, kc_subphyla_CR_YesEquations, kc_suboffsets_CR_YesEquations, kc_not_uniq, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))CR_YesEquations },
	{ "Nilcr_equation_structure_list", 0, 0, kc_phylum_cr_equation_structure_list, (kc_enum_phyla_list)0, (kc_size_t_list)0, kc_uniq_nullary_operator, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))Nilcr_equation_structure_list },
	{ "Conscr_equation_structure_list", 2, 0, kc_phylum_cr_equation_structure_list, kc_subphyla_Conscr_equation_structure_list, kc_suboffsets_Conscr_equation_structure_list, kc_not_uniq, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))Conscr_equation_structure_list },
	{ "CR_Equation_structure", 3, 0, kc_phylum_cr_equation_structure, kc_subphyla_CR_Equation_structure, kc_suboffsets_CR_Equation_structure, kc_not_uniq, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))CR_Equation_structure },
	{ "Nilcr_equation_list", 0, 0, kc_phylum_cr_equation_list, (kc_enum_phyla_list)0, (kc_size_t_list)0, kc_uniq_nullary_operator, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))Nilcr_equation_list },
	{ "Conscr_equation_list", 2, 0, kc_phylum_cr_equation_list, kc_subphyla_Conscr_equation_list, kc_suboffsets_Conscr_equation_list, kc_not_uniq, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))Conscr_equation_list },
	{ "CR_Equation", 3, 0, kc_phylum_cr_equation, kc_subphyla_CR_Equation, kc_suboffsets_CR_Equation, kc_not_uniq, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))CR_Equation },
	{ "Nilcr_premiss_list", 0, 0, kc_phylum_cr_premiss_list, (kc_enum_phyla_list)0, (kc_size_t_list)0, kc_uniq_nullary_operator, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))Nilcr_premiss_list },
	{ "Conscr_premiss_list", 2, 0, kc_phylum_cr_premiss_list, kc_subphyla_Conscr_premiss_list, kc_suboffsets_Conscr_premiss_list, kc_not_uniq, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))Conscr_premiss_list },
	{ "CR_Equals", 2, 0, kc_phylum_cr_equality, kc_subphyla_CR_Equals, kc_suboffsets_CR_Equals, uniq, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))CR_Equals },
	{ "Nilcr_identifier_declaration_list", 0, 0, kc_phylum_cr_identifier_declaration_list, (kc_enum_phyla_list)0, (kc_size_t_list)0, kc_uniq_nullary_operator, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))Nilcr_identifier_declaration_list },
	{ "Conscr_identifier_declaration_list", 2, 0, kc_phylum_cr_identifier_declaration_list, kc_subphyla_Conscr_identifier_declaration_list, kc_suboffsets_Conscr_identifier_declaration_list, uniq, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))Conscr_identifier_declaration_list },
	{ "CR_Identifier_declaration", 2, 0, kc_phylum_cr_identifier_declaration, kc_subphyla_CR_Identifier_declaration, kc_suboffsets_CR_Identifier_declaration, uniq, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))CR_Identifier_declaration },
	{ "Nilcr_value_identifier_list", 0, 0, kc_phylum_cr_value_identifier_list, (kc_enum_phyla_list)0, (kc_size_t_list)0, kc_uniq_nullary_operator, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))Nilcr_value_identifier_list },
	{ "Conscr_value_identifier_list", 2, 0, kc_phylum_cr_value_identifier_list, kc_subphyla_Conscr_value_identifier_list, kc_suboffsets_Conscr_value_identifier_list, uniq, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))Conscr_value_identifier_list },
	{ "CR_annotated_val_id", 2, 0, kc_phylum_cr_annotated_value_identifier, kc_subphyla_CR_annotated_val_id, kc_suboffsets_CR_annotated_val_id, uniq, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))CR_annotated_val_id },
	{ "CR_Stop_expression", 2, 0, kc_phylum_cr_behaviour_expression, kc_subphyla_CR_Stop_expression, kc_suboffsets_CR_Stop_expression, uniq, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))CR_Stop_expression },
	{ "CR_Exit_expression", 3, 0, kc_phylum_cr_behaviour_expression, kc_subphyla_CR_Exit_expression, kc_suboffsets_CR_Exit_expression, uniq, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))CR_Exit_expression },
	{ "CR_Process_instantiation", 5, 0, kc_phylum_cr_behaviour_expression, kc_subphyla_CR_Process_instantiation, kc_suboffsets_CR_Process_instantiation, uniq, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))CR_Process_instantiation },
	{ "CR_Action_prefix_expression", 4, 0, kc_phylum_cr_behaviour_expression, kc_subphyla_CR_Action_prefix_expression, kc_suboffsets_CR_Action_prefix_expression, uniq, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))CR_Action_prefix_expression },
	{ "CR_Local_definition_expression", 2, 0, kc_phylum_cr_behaviour_expression, kc_subphyla_CR_Local_definition_expression, kc_suboffsets_CR_Local_definition_expression, uniq, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))CR_Local_definition_expression },
	{ "CR_Sum_identifier_expression", 2, 0, kc_phylum_cr_behaviour_expression, kc_subphyla_CR_Sum_identifier_expression, kc_suboffsets_CR_Sum_identifier_expression, uniq, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))CR_Sum_identifier_expression },
	{ "CR_Sum_gate_expression", 2, 0, kc_phylum_cr_behaviour_expression, kc_subphyla_CR_Sum_gate_expression, kc_suboffsets_CR_Sum_gate_expression, uniq, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))CR_Sum_gate_expression },
	{ "CR_Par_expression", 4, 0, kc_phylum_cr_behaviour_expression, kc_subphyla_CR_Par_expression, kc_suboffsets_CR_Par_expression, uniq, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))CR_Par_expression },
	{ "CR_Hiding_expression", 2, 0, kc_phylum_cr_behaviour_expression, kc_subphyla_CR_Hiding_expression, kc_suboffsets_CR_Hiding_expression, uniq, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))CR_Hiding_expression },
	{ "CR_Enable_expression", 3, 0, kc_phylum_cr_behaviour_expression, kc_subphyla_CR_Enable_expression, kc_suboffsets_CR_Enable_expression, uniq, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))CR_Enable_expression },
	{ "CR_Disable_expression", 2, 0, kc_phylum_cr_behaviour_expression, kc_subphyla_CR_Disable_expression, kc_suboffsets_CR_Disable_expression, uniq, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))CR_Disable_expression },
	{ "CR_Parallel_expression", 4, 0, kc_phylum_cr_behaviour_expression, kc_subphyla_CR_Parallel_expression, kc_suboffsets_CR_Parallel_expression, uniq, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))CR_Parallel_expression },
	{ "CR_Choice_expression", 2, 0, kc_phylum_cr_behaviour_expression, kc_subphyla_CR_Choice_expression, kc_suboffsets_CR_Choice_expression, uniq, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))CR_Choice_expression },
	{ "CR_Guarded_expression", 2, 0, kc_phylum_cr_behaviour_expression, kc_subphyla_CR_Guarded_expression, kc_suboffsets_CR_Guarded_expression, uniq, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))CR_Guarded_expression },
	{ "CR_Annotated_behaviour", 2, 0, kc_phylum_cr_behaviour_expression, kc_subphyla_CR_Annotated_behaviour, kc_suboffsets_CR_Annotated_behaviour, uniq, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))CR_Annotated_behaviour },
	{ "CR_Synchronization_operator", 0, 0, kc_phylum_cr_parallel_operator, (kc_enum_phyla_list)0, (kc_size_t_list)0, kc_uniq_nullary_operator, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))CR_Synchronization_operator },
	{ "CR_Interleave_operator", 0, 0, kc_phylum_cr_parallel_operator, (kc_enum_phyla_list)0, (kc_size_t_list)0, kc_uniq_nullary_operator, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))CR_Interleave_operator },
	{ "CR_General_parallel_operator", 1, 0, kc_phylum_cr_parallel_operator, kc_subphyla_CR_General_parallel_operator, kc_suboffsets_CR_General_parallel_operator, uniq, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))CR_General_parallel_operator },
	{ "Nilcr_gate_declaration_list", 0, 0, kc_phylum_cr_gate_declaration_list, (kc_enum_phyla_list)0, (kc_size_t_list)0, kc_uniq_nullary_operator, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))Nilcr_gate_declaration_list },
	{ "Conscr_gate_declaration_list", 2, 0, kc_phylum_cr_gate_declaration_list, kc_subphyla_Conscr_gate_declaration_list, kc_suboffsets_Conscr_gate_declaration_list, uniq, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))Conscr_gate_declaration_list },
	{ "CR_Gate_declaration", 2, 0, kc_phylum_cr_gate_declaration, kc_subphyla_CR_Gate_declaration, kc_suboffsets_CR_Gate_declaration, uniq, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))CR_Gate_declaration },
	{ "Nilcr_gate_identifier_list", 0, 0, kc_phylum_cr_gate_identifier_list, (kc_enum_phyla_list)0, (kc_size_t_list)0, kc_uniq_nullary_operator, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))Nilcr_gate_identifier_list },
	{ "Conscr_gate_identifier_list", 2, 0, kc_phylum_cr_gate_identifier_list, kc_subphyla_Conscr_gate_identifier_list, kc_suboffsets_Conscr_gate_identifier_list, uniq, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))Conscr_gate_identifier_list },
	{ "Nilcr_exit_entry_list", 0, 0, kc_phylum_cr_exit_entry_list, (kc_enum_phyla_list)0, (kc_size_t_list)0, kc_uniq_nullary_operator, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))Nilcr_exit_entry_list },
	{ "Conscr_exit_entry_list", 2, 0, kc_phylum_cr_exit_entry_list, kc_subphyla_Conscr_exit_entry_list, kc_suboffsets_Conscr_exit_entry_list, uniq, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))Conscr_exit_entry_list },
	{ "CR_Value_expression_exit_entry", 1, 0, kc_phylum_cr_exit_entry, kc_subphyla_CR_Value_expression_exit_entry, kc_suboffsets_CR_Value_expression_exit_entry, uniq, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))CR_Value_expression_exit_entry },
	{ "CR_Sort_identifier_exit_entry", 1, 0, kc_phylum_cr_exit_entry, kc_subphyla_CR_Sort_identifier_exit_entry, kc_suboffsets_CR_Sort_identifier_exit_entry, uniq, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))CR_Sort_identifier_exit_entry },
	{ "Nilcr_identifier_equation_list", 0, 0, kc_phylum_cr_identifier_equation_list, (kc_enum_phyla_list)0, (kc_size_t_list)0, kc_uniq_nullary_operator, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))Nilcr_identifier_equation_list },
	{ "Conscr_identifier_equation_list", 2, 0, kc_phylum_cr_identifier_equation_list, kc_subphyla_Conscr_identifier_equation_list, kc_suboffsets_Conscr_identifier_equation_list, uniq, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))Conscr_identifier_equation_list },
	{ "CR_Identifier_equation", 2, 0, kc_phylum_cr_identifier_equation, kc_subphyla_CR_Identifier_equation, kc_suboffsets_CR_Identifier_equation, uniq, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))CR_Identifier_equation },
	{ "CR_Communication", 2, 0, kc_phylum_cr_action_denotation, kc_subphyla_CR_Communication, kc_suboffsets_CR_Communication, uniq, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))CR_Communication },
	{ "CR_Internal_event", 0, 0, kc_phylum_cr_action_denotation, (kc_enum_phyla_list)0, (kc_size_t_list)0, kc_uniq_nullary_operator, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))CR_Internal_event },
	{ "CR_NoExperiment", 0, 0, kc_phylum_cr_experiment_option, (kc_enum_phyla_list)0, (kc_size_t_list)0, kc_uniq_nullary_operator, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))CR_NoExperiment },
	{ "CR_YesExperiment", 2, 0, kc_phylum_cr_experiment_option, kc_subphyla_CR_YesExperiment, kc_suboffsets_CR_YesExperiment, uniq, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))CR_YesExperiment },
	{ "Nilcr_experiment_offer_list", 0, 0, kc_phylum_cr_experiment_offer_list, (kc_enum_phyla_list)0, (kc_size_t_list)0, kc_uniq_nullary_operator, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))Nilcr_experiment_offer_list },
	{ "Conscr_experiment_offer_list", 2, 0, kc_phylum_cr_experiment_offer_list, kc_subphyla_Conscr_experiment_offer_list, kc_suboffsets_Conscr_experiment_offer_list, uniq, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))Conscr_experiment_offer_list },
	{ "CR_Query_offer", 1, 0, kc_phylum_cr_experiment_offer, kc_subphyla_CR_Query_offer, kc_suboffsets_CR_Query_offer, uniq, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))CR_Query_offer },
	{ "CR_Exclam_offer", 1, 0, kc_phylum_cr_experiment_offer, kc_subphyla_CR_Exclam_offer, kc_suboffsets_CR_Exclam_offer, uniq, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))CR_Exclam_offer },
	{ "CR_NoGuard", 0, 0, kc_phylum_cr_guard_option, (kc_enum_phyla_list)0, (kc_size_t_list)0, kc_uniq_nullary_operator, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))CR_NoGuard },
	{ "CR_YesGuard", 1, 0, kc_phylum_cr_guard_option, kc_subphyla_CR_YesGuard, kc_suboffsets_CR_YesGuard, uniq, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))CR_YesGuard },
	{ "Nilcr_value_expression_list", 0, 0, kc_phylum_cr_value_expression_list, (kc_enum_phyla_list)0, (kc_size_t_list)0, kc_uniq_nullary_operator, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))Nilcr_value_expression_list },
	{ "Conscr_value_expression_list", 2, 0, kc_phylum_cr_value_expression_list, kc_subphyla_Conscr_value_expression_list, kc_suboffsets_Conscr_value_expression_list, uniq, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))Conscr_value_expression_list },
	{ "CR_Term", 3, 0, kc_phylum_cr_value_expression, kc_subphyla_CR_Term, kc_suboffsets_CR_Term, uniq, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))CR_Term },
	{ "CR_Value", 2, 0, kc_phylum_cr_value_expression, kc_subphyla_CR_Value, kc_suboffsets_CR_Value, uniq, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))CR_Value },
	{ "CR_Annotated_value_expression", 2, 0, kc_phylum_cr_value_expression, kc_subphyla_CR_Annotated_value_expression, kc_suboffsets_CR_Annotated_value_expression, uniq, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))CR_Annotated_value_expression },
	{ "CR_Specification_id", 1, 0, kc_phylum_cr_specification_identifier, kc_subphyla_CR_Specification_id, kc_suboffsets_CR_Specification_id, uniq, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))CR_Specification_id },
	{ "CR_Operation_id", 1, 0, kc_phylum_cr_operation_identifier, kc_subphyla_CR_Operation_id, kc_suboffsets_CR_Operation_id, uniq, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))CR_Operation_id },
	{ "CR_Type_id", 1, 0, kc_phylum_cr_type_identifier, kc_subphyla_CR_Type_id, kc_suboffsets_CR_Type_id, uniq, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))CR_Type_id },
	{ "CR_Sort_id", 1, 0, kc_phylum_cr_sort_identifier, kc_subphyla_CR_Sort_id, kc_suboffsets_CR_Sort_id, uniq, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))CR_Sort_id },
	{ "CR_Gate_id", 1, 0, kc_phylum_cr_gate_identifier, kc_subphyla_CR_Gate_id, kc_suboffsets_CR_Gate_id, uniq, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))CR_Gate_id },
	{ "CR_Value_id", 1, 0, kc_phylum_cr_value_identifier, kc_subphyla_CR_Value_id, kc_suboffsets_CR_Value_id, uniq, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))CR_Value_id },
	{ "CR_Process_id", 1, 0, kc_phylum_cr_process_identifier, kc_subphyla_CR_Process_id, kc_suboffsets_CR_Process_id, uniq, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))CR_Process_id },
	{ "CR_Identifier", 2, 0, kc_phylum_cr_identifier, kc_subphyla_CR_Identifier, kc_suboffsets_CR_Identifier, uniq, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))CR_Identifier },
	{ "CR_NullExtension", 0, 0, kc_phylum_cr_extension, (kc_enum_phyla_list)0, (kc_size_t_list)0, kc_uniq_nullary_operator, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))CR_NullExtension },
	{ "CR_DefExtension", 1, 0, kc_phylum_cr_extension, kc_subphyla_CR_DefExtension, kc_suboffsets_CR_DefExtension, uniq, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))CR_DefExtension },
	{ "CR_Operation_name", 1, 0, kc_phylum_cr_operation_name, kc_subphyla_CR_Operation_name, kc_suboffsets_CR_Operation_name, uniq, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))CR_Operation_name },
	{ "CR_Sort_name", 1, 0, kc_phylum_cr_sort_name, kc_subphyla_CR_Sort_name, kc_suboffsets_CR_Sort_name, uniq, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))CR_Sort_name },
	{ "CR_Name", 1, 0, kc_phylum_cr_name, kc_subphyla_CR_Name, kc_suboffsets_CR_Name, uniq, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))CR_Name },
	{ "Nilcr_comment_list", 0, 0, kc_phylum_cr_comment_list, (kc_enum_phyla_list)0, (kc_size_t_list)0, kc_uniq_nullary_operator, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))Nilcr_comment_list },
	{ "Conscr_comment_list", 2, 0, kc_phylum_cr_comment_list, kc_subphyla_Conscr_comment_list, kc_suboffsets_Conscr_comment_list, uniq, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))Conscr_comment_list },
	{ "Nilcr_annotation_list", 0, 0, kc_phylum_cr_annotation_list, (kc_enum_phyla_list)0, (kc_size_t_list)0, kc_uniq_nullary_operator, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))Nilcr_annotation_list },
	{ "Conscr_annotation_list", 2, 0, kc_phylum_cr_annotation_list, kc_subphyla_Conscr_annotation_list, kc_suboffsets_Conscr_annotation_list, uniq, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))Conscr_annotation_list },
	{ "CR_Label", 1, 0, kc_phylum_cr_LABEL, kc_subphyla_CR_Label, kc_suboffsets_CR_Label, uniq, (kc_voidptr_t(*) KC__P((KC_DOTDOTDOT)))CR_Label },
	{ (char*)0, 0, 0, kc_one_before_first_phylum, (kc_enum_phyla_list)0, (kc_size_t_list)0, (kc_storageclass_t)0, 0 } /* last element */
};

static kc_enum_phyla kc_phylumstorageclass_uniq[] = { kc_one_before_first_phylum, kc_phylum_nocasestring, kc_phylum_casestring, kc_phylum_float, kc_phylum_int, kc_phylum_cr_equality, kc_phylum_cr_identifier_declaration_list, kc_phylum_cr_identifier_declaration, kc_phylum_cr_value_identifier_list, kc_phylum_cr_annotated_value_identifier, kc_phylum_cr_behaviour_expression, kc_phylum_cr_parallel_operator, kc_phylum_cr_gate_declaration_list, kc_phylum_cr_gate_declaration, kc_phylum_cr_gate_identifier_list, kc_phylum_cr_exit_entry_list, kc_phylum_cr_exit_entry, kc_phylum_cr_identifier_equation_list, kc_phylum_cr_identifier_equation, kc_phylum_cr_action_denotation, kc_phylum_cr_experiment_option, kc_phylum_cr_experiment_offer_list, kc_phylum_cr_experiment_offer, kc_phylum_cr_guard_option, kc_phylum_cr_value_expression_list, kc_phylum_cr_value_expression, kc_phylum_cr_specification_identifier, kc_phylum_cr_operation_identifier, kc_phylum_cr_type_identifier, kc_phylum_cr_sort_identifier, kc_phylum_cr_gate_identifier, kc_phylum_cr_value_identifier, kc_phylum_cr_process_identifier, kc_phylum_cr_identifier, kc_phylum_cr_extension, kc_phylum_cr_operation_name, kc_phylum_cr_sort_name, kc_phylum_cr_name, kc_phylum_cr_comment_list, kc_phylum_cr_annotation_list, kc_phylum_cr_LABEL, kc_last_phylum };

KC_UNIQ_INFO kc_UniqInfo[] = {
	(KC_UNIQ_INFO)0,
	(KC_UNIQ_INFO)0,
	kc_phylumstorageclass_uniq
};
#if defined(lint)
   int kc_zero_constant = 0;
#endif

void kc_no_default_in_with
#ifdef KC_USE_PROTOTYPES
( char *kc_func, int kc_line, char *kc_file )
#else
( kc_func, kc_line, kc_file ) char *kc_func; int kc_line; char *kc_file;
#endif
{	(void)fflush(stdout);
	(void)fprintf( stderr, KC_NO_DEFAULT_IN_WITH, kc_func, kc_line, kc_file );
#ifndef KC_NODEFAULT_NO_ABORT
	abort();
#else
	exit( 1 );
#endif
}

void kc_returnless_function
#ifdef KC_USE_PROTOTYPES
( char *kc_func, int kc_line, char *kc_file )
#else
( kc_func, kc_line, kc_file ) char *kc_func; int kc_line; char *kc_file;
#endif
{	(void)fflush(stdout);
	(void)fprintf( stderr, "Internal Error: function %s does not return a value, at line %d of %s", kc_func, kc_line, kc_file );
#ifndef KC_NODEFAULT_NO_ABORT
	abort();
#else
	exit( 1 );
#endif
}

void kc_assertionFailed
#ifdef KC_USE_PROTOTYPES
(char *kc_fn, int kc_l)
#else
(kc_fn, kc_l) char *kc_fn; int kc_l;
#endif
{	(void)fflush(stdout);
	(void)fprintf( stderr, "Internal Error: Assertion failed: file %s, line %d\n", kc_fn, kc_l );
#ifndef KC_ASSERT_NO_ABORT
	abort();
#else
	exit( 1 );
#endif
}

void kc_assertionReasonFailed
#ifdef KC_USE_PROTOTYPES
(char *kc_fn, int kc_l, char *kc_s)
#else
(kc_fn, kc_l, kc_s) char *kc_fn; int kc_l; char *kc_s;
#endif
{	(void)fflush(stdout);
	(void)fprintf( stderr, "Internal Error: Assertion failed: file %s, line %d: %s\n", kc_fn, kc_l, kc_s );
#ifndef KC_ASSERT_NO_ABORT
	abort();
#else
	exit( 1 );
#endif
}

void kc_assertionNonNullFailed
#ifdef KC_USE_PROTOTYPES
(char *kc_str, char *kc_fn, int kc_l)
#else
(kc_str, kc_fn, kc_l) char *kc_str; char *kc_fn; int kc_l;
#endif
{	(void)fflush(stdout);
	(void)fprintf( stderr, "Internal Error: Assertion failed at file %s, line %d: pointer %s is NULL\n", kc_fn, kc_l, kc_str );
#ifndef KC_ASSERT_NO_ABORT
	abort();
#else
	exit( 1 );
#endif
}

void kc_assertionOperatorInPhylumFailed
#ifdef KC_USE_PROTOTYPES
(int kc_op, char *kc_str1, char *kc_str2, int kc_phy, char *kc_fn, int kc_l)
#else
(kc_op, kc_str1, kc_str2, kc_phy, kc_fn, kc_l) int kc_op; char *kc_str1; char *kc_str2; int kc_phy; char *kc_fn; int kc_l;
#endif
{	(void)fflush(stdout);
	if ((kc_op <= (int)kc_one_before_first_operator) || (kc_op >= (int)kc_last_operator)) {
		(void)fprintf( stderr, "Internal Error: Assertion failed at file %s, line %d: illegal value for (%s) %s%s: %d not a valid operator\n", kc_fn, kc_l, kc_PhylumInfo[(int)kc_phy].name, kc_str1, kc_str2, kc_op );
	} else {
		(void)fprintf( stderr, "Internal Error: Assertion failed at file %s, line %d: illegal value for (%s) %s%s: %s (%d) is a value of %s\n", kc_fn, kc_l, kc_PhylumInfo[(int)kc_phy].name, kc_str1, kc_str2, kc_OperatorInfo[kc_op].name, kc_op, kc_PhylumInfo[(int)kc_OperatorInfo[kc_op].phylum].name );
	}
#ifndef KC_ASSERT_NO_ABORT
	abort();
#else
	exit( 1 );
#endif
}

static void kc_invalid_operator
#ifdef KC_USE_PROTOTYPES
( char *kc_func_prefix, kc_enum_phyla kc_phy, int kc_line, char *kc_file, int kc_oper )
#else
( kc_func_prefix, kc_phy, kc_line, kc_file, kc_oper ) char *kc_func_prefix; kc_enum_phyla kc_phy; int kc_line; char *kc_file; int kc_oper;
#endif
{	(void)fflush(stdout);
	(void)fprintf( stderr, "Internal Error: invalid operator code in %s%s at line %d of %s: %s\n", kc_func_prefix, kc_phylumname_or_error( (int)kc_phy ), kc_line, kc_file, kc_operatorname_or_error( kc_oper ));
#ifndef KC_INVALID_OPERATOR_NO_ABORT
	abort();
#else
	exit( 1 );
#endif
}

/* macro's that do the string concatenation */
#define KC_MIdStr(s) s
#ifdef __STDC__
#  define KC_MStrConc(s1,s2) s1 ## s2
#else
#  define KC_MStrConc(s1,s2) KC_MIdStr(s1)s2
#endif

#ifndef KC_MEMORY_BLOCKSIZE
#  define KC_MEMORY_BLOCKSIZE 20000
#endif
#ifndef LARGEPRIME
#  define LARGEPRIME 80021
#endif
#if LARGEPRIME < 0
#  define LARGEPRIME 0
#endif
#ifndef KC_BUCKET_INC
#  define KC_BUCKET_INC 8
#endif
#ifndef HASH
#  define HASH(x) kc_hashval = ((kc_hashval<<3) + (((unsigned)x)>>2))
#endif
#ifndef INTHASH
#  define INTHASH(x) kc_hashval = ((kc_hashval<<10) + (unsigned)x)
#endif
#ifndef FLOATHASH
#  define FLOATHASH(x) kc_hashval = ((kc_hashval<<10) + (unsigned)x)
#endif
#ifndef OPERATORHASH
#  define OPERATORHASH(x) kc_hashval = (kc_hashval + (unsigned)x * 73)
#endif
#ifndef CASESTRHASH
#  define CASESTRHASH(x) kc_hashval = ((kc_hashval<<3) + (unsigned)kc_casestrhash(x))
#endif
#ifndef NOCASESTRHASH
#  define NOCASESTRHASH(x) kc_hashval = ((kc_hashval<<3) + (unsigned)kc_nocasestrhash(x))
#endif
#ifndef MALLOC
#  define MALLOC emalloc
#endif
#ifndef CALLOC
#  define CALLOC ecalloc
#endif
#ifndef REALLOC

#  define REALLOC erealloc

#endif
#ifndef FREE
#  define FREE efree
#endif
#ifndef efree

#  define efree(kc_p) free((kc_malloc_t)(kc_p))

#endif
#ifndef KC_ALIGN
typedef union kc_Align_tag { long l; int i; } kc_Align;
#else
typedef KC_ALIGN kc_Align;
#endif
#ifndef UNIQMALLOCINIT
#  define UNIQMALLOCINIT uniqmallocinit
#  ifndef UNIQMALLOC2
#    define UNIQMALLOC2 uniqmalloc
#  endif
#  ifndef UNIQFREEELEMENT
#    define UNIQFREEELEMENT uniqfreeelement
#  endif
#  ifndef UNIQFREEALL
#    define UNIQFREEALL uniqfreeall
#  endif
#  ifndef INUNIQBLOCK
#    define INUNIQBLOCK isinuniqmalloccedblock
#  endif
#  ifndef UNIQMEMORYINFO
#    define UNIQMEMORYINFO kc_print_memory_info_statistics
#  endif
#else
#  ifndef UNIQFREEELEMENT
#    define UNIQFREEELEMENT 0
#  endif
#  ifndef UNIQFREEALL
#    define UNIQFREEALL 0
#  endif
#  ifndef INUNIQBLOCK
#    define INUNIQBLOCK 0
#  endif
#  ifndef UNIQMEMORYINFO
#    define UNIQMEMORYINFO 0
#  endif
#endif
#ifndef BUCKETALLOCINIT
#  define BUCKETALLOCINIT 0
#  ifndef BUCKETCALLOC
#    define BUCKETCALLOC kc_wrap_bucket_malloc
#  endif
#  ifndef BUCKETREALLOC
#    define BUCKETREALLOC kc_wrap_bucket_realloc
#  endif
#  ifndef BUCKETFREE
#    define BUCKETFREE kc_wrap_bucket_free
#  endif
#  ifndef BUCKETSFREE
#    define BUCKETSFREE 0
#  endif
#  ifndef BUCKETMEMORYINFO
#    define BUCKETMEMORYINFO 0
#  endif
#else
#  ifndef BUCKETFREE
#    define BUCKETFREE 0
#  endif
#  ifndef BUCKETSFREE
#    define BUCKETSFREE 0
#  endif
#  ifndef BUCKETMEMORYINFO
#    define BUCKETMEMORYINFO 0
#  endif
#endif
#ifndef BUCKETINC
#  define BUCKETINC KC_BUCKET_INC
#endif
#ifndef NONUNIQMALLOC
#  define NONUNIQMALLOC emalloc
#endif
#ifndef NONUNIQFREE
#  define NONUNIQFREE efree
#endif
#ifndef KC_BZERO
#  define KC_BZERO(kc_p, kc_s) (void)memset((kc_memset_firstarg_t)kc_p, 0, (kc_memset_size_t)kc_s)
#endif

typedef struct kc_tag_kc_memory_blockinfo_t *kc_memory_blocksinfo_t;
typedef struct kc_tag_kc_memory_blockinfo_t kc_memory_blockinfo_t;
typedef struct kc_tag_kc_memory_info_t kc_memory_info_t;

static kc_memory_blocksinfo_t kc_mainmemory_freelist = 0;

struct kc_tag_kc_memory_blockinfo_t {
	kc_voidptr_t block; /* pointer to the allocated structure */
	kc_size_t size; /* size of allocated structure */
	kc_memory_blocksinfo_t next; /* next block in list */
	kc_memory_blocksinfo_t prev; /* prev block in list */
};

struct kc_tag_kc_memory_info_t {
	kc_memory_blocksinfo_t kc_memory_blocklist; /* points to block currently in use */
	int kc_memory_left; /* remaining bytes in current block */
	kc_voidptr_t kc_memory_ptr; /* address of first free byte in current block */
	kc_memory_blocksinfo_t *kc_memory_freelist; /* pointer to variable that holds freelist */
	int kc_to_be_freed; /* should be 0 for statically created nodes, and 1 for dynamically created ones */
	kc_size_t kc_wanted_blocksize; /* prefered size of chunks */
};

static kc_memory_blocksinfo_t kc_memory_createblock
#ifdef KC_USE_PROTOTYPES
(kc_size_t kc_n, kc_memory_info_t *kc_malloc_private_info)
#else
(kc_n, kc_malloc_private_info) kc_size_t kc_n; kc_memory_info_t *kc_malloc_private_info;
#endif
{	kc_voidptr_t kc_p;
	kc_memory_blocksinfo_t kc_l;
	kc_size_t kc_size;

	/* we use plain malloc for adminstrative things, and test for the return status */
	kc_l = (kc_memory_blocksinfo_t)MALLOC((kc_size_t)sizeof(kc_memory_blockinfo_t));
	kc_size = (kc_malloc_private_info->kc_wanted_blocksize > kc_n) ?  kc_malloc_private_info->kc_wanted_blocksize : kc_n;
	kc_p = (kc_voidptr_t)MALLOC((kc_size_t)kc_size);
	kc_l->block = kc_p;
	kc_l->size = kc_size;
	return kc_l;
}


static kc_memory_blocksinfo_t kc_memory_reuseblock
#ifdef KC_USE_PROTOTYPES
(kc_size_t kc_n, kc_memory_info_t *kc_malloc_private_info)
#else
(kc_n, kc_malloc_private_info) kc_size_t kc_n; kc_memory_info_t *kc_malloc_private_info;
#endif
{	kc_memory_blocksinfo_t kc_l;
	if (*kc_malloc_private_info->kc_memory_freelist == 0) { /* no elements in freelist */
		return (kc_memory_blocksinfo_t)0;
	}
	kc_l = *kc_malloc_private_info->kc_memory_freelist;
	do { /* at least one time, because we have at least one element */
		if (kc_l->size >= kc_n) {
			if (kc_l->next != kc_l) { /* the list contains > 1 elements */
				kc_l->prev->next = kc_l->next;
				kc_l->next->prev = kc_l->prev;
				/* make sure that we don't loose the handle to the list */
				if (kc_l ==  *kc_malloc_private_info->kc_memory_freelist) {
					*kc_malloc_private_info->kc_memory_freelist = kc_l->next;
				}
			} else { /* we release the last free element */
				*kc_malloc_private_info->kc_memory_freelist = 0;
			}
			return kc_l;
		}
		kc_l = kc_l->next;
	} while(kc_l != *kc_malloc_private_info->kc_memory_freelist);
	return (kc_memory_blocksinfo_t)0;
}

static void kc_memory_newblock
#ifdef KC_USE_PROTOTYPES
(kc_size_t kc_n, kc_memory_info_t *kc_malloc_private_info)
#else
(kc_n, kc_malloc_private_info) kc_size_t kc_n; kc_memory_info_t *kc_malloc_private_info;
#endif
{	kc_memory_blocksinfo_t kc_l;
	if ((kc_l = kc_memory_reuseblock(kc_n, kc_malloc_private_info)) == 0) {
		kc_l = kc_memory_createblock(kc_n, kc_malloc_private_info);
	}
	if (kc_malloc_private_info->kc_memory_blocklist != 0) {
		kc_l->next = kc_malloc_private_info->kc_memory_blocklist;
		kc_malloc_private_info->kc_memory_blocklist->prev->next = kc_l;
		kc_l->prev = kc_malloc_private_info->kc_memory_blocklist->prev;
		kc_malloc_private_info->kc_memory_blocklist->prev = kc_l;
	} else {
		kc_l->next = kc_l;
		kc_l->prev = kc_l;
	}
	kc_malloc_private_info->kc_memory_blocklist = kc_l;
	kc_malloc_private_info->kc_memory_left = kc_l->size;
	kc_malloc_private_info->kc_memory_ptr = kc_l->block;
}

static void kc_print_memory_blocks_info_statistics
#ifdef KC_USE_PROTOTYPES
(FILE *kc_f, kc_memory_blocksinfo_t kc_a_memory_blocksinfo_t)
#else
(kc_f, kc_a_memory_blocksinfo_t) FILE *kc_f; kc_memory_blocksinfo_t kc_a_memory_blocksinfo_t;
#endif
{	kc_memory_blocksinfo_t kc_tmp = kc_a_memory_blocksinfo_t;
	if (kc_tmp) {
		/* at least one block? */
		do {
			fprintf(kc_f, "		block-size (at %p): %d\n", kc_tmp->block, kc_tmp->size);
			kc_tmp = kc_tmp->next;
		} while(kc_tmp && (kc_tmp != kc_a_memory_blocksinfo_t));
	} else {
		fprintf(kc_f, "		no blocks allocated\n");
	}
}

void kc_print_memory_info_statistics
#ifdef KC_USE_PROTOTYPES
(FILE *kc_f, kc_voidptr_t kc_malloc_private_info)
#else
(kc_f, kc_malloc_private_info) FILE *kc_f; kc_voidptr_t kc_malloc_private_info;
#endif
{
	kc_memory_info_t *kc_a_memory_info_t = (kc_memory_info_t *)kc_malloc_private_info;
	fprintf(kc_f, "	to-be-freed: %s\n", (kc_a_memory_info_t->kc_to_be_freed ? "yes" : "no"));
	fprintf(kc_f, "	wanted block-size: %d\n", kc_a_memory_info_t->kc_wanted_blocksize);
	fprintf(kc_f, "	remaining in current block: %d\n", kc_a_memory_info_t->kc_memory_left);
	fprintf(kc_f, "	blocks-info (at %p):\n", kc_a_memory_info_t->kc_memory_blocklist);
	kc_print_memory_blocks_info_statistics(kc_f, kc_a_memory_info_t->kc_memory_blocklist);
	fprintf(kc_f, "	freelist-info (at %p):\n", *kc_a_memory_info_t->kc_memory_freelist);
	kc_print_memory_blocks_info_statistics(kc_f, *kc_a_memory_info_t->kc_memory_freelist);
}	


void kc_print_hashtable_memory_statistics
#ifdef KC_USE_PROTOTYPES
(FILE *kc_f, kc_hashtable_t kc_a_hashtable_t)
#else
(kc_f, kc_a_hashtable_t) FILE *kc_f; kc_hashtable_t kc_a_hashtable_t;
#endif
{	kc_private_malloc_t kc_tmp;
	int kc_i;
	fprintf(kc_f, "current allocation scheme: %s\n",
		((kc_a_hashtable_t->mode == kc_ht_store_static) ? "static" : "dynamic"));
	if (kc_a_hashtable_t->malloc_info) {
		fprintf(kc_f, "static allocation info (info ptr: %p):\n", kc_a_hashtable_t->static_malloc_private_data);
		(*kc_a_hashtable_t->malloc_info)(kc_f, kc_a_hashtable_t->static_malloc_private_data);
		kc_tmp = kc_a_hashtable_t->dynamic_malloc_private_data;
		kc_i = 0;
		fprintf(kc_f, "dynamic allocation info: counting from top (level 0) of level stack\n");
		while(kc_tmp) {
			fprintf(kc_f, "dynamic allocation info for level %d,(info ptr: %p):\n", kc_i, kc_tmp->malloc_private_data);
			(*kc_a_hashtable_t->malloc_info)(kc_f, kc_tmp->malloc_private_data);
			kc_i++;
			kc_tmp = kc_tmp->next;
		}
		kc_tmp = kc_a_hashtable_t->dec_dynamic_malloc_private_data;
		kc_i = 0;
		fprintf(kc_f, "dynamic allocation info: levels to be freed, counting from bottom\n");
		while(kc_tmp) {
			fprintf(kc_f, "dynamic allocation info for level %d,(info ptr: %p):\n", kc_i, kc_tmp->malloc_private_data);
			(*kc_a_hashtable_t->malloc_info)(kc_f, kc_tmp->malloc_private_data);
			kc_i++;
			kc_tmp = kc_tmp->prev;
		}
	}
}


kc_voidptr_t uniqmalloc	/* check return from malloc */
#ifdef KC_USE_PROTOTYPES
(kc_size_t kc_n, kc_voidptr_t kc_malloc_private_info)
#else
(kc_n, kc_malloc_private_info) kc_size_t kc_n; kc_voidptr_t kc_malloc_private_info;
#endif
{	kc_voidptr_t kc_p;
	kc_memory_info_t *kc_a_memory_info_t = (kc_memory_info_t *)kc_malloc_private_info;	
	/* all blocks should be a multiple of the alignment requirement */
	kc_n += sizeof(kc_Align) - 1 - ((kc_n - 1) % sizeof(kc_Align));
	if (kc_n > kc_a_memory_info_t->kc_memory_left) kc_memory_newblock(kc_n, kc_a_memory_info_t);
	kc_a_memory_info_t->kc_memory_left -= kc_n;
	kc_p = kc_a_memory_info_t->kc_memory_ptr;
	kc_a_memory_info_t->kc_memory_ptr = (kc_voidptr_t)((char*)(kc_a_memory_info_t->kc_memory_ptr) + kc_n);
	return kc_p;
}

kc_memory_info_t *uniqmallocinit
#ifdef KC_USE_PROTOTYPES
( /*kc_size_t kc_n*/ )
#else
( /*kc_n*/ ) /*kc_size_t kc_n;*/
#endif
{	kc_memory_info_t *kc_p;
	kc_p = (kc_memory_info_t*)MALLOC((kc_size_t)sizeof(kc_memory_info_t));
	kc_p->kc_memory_blocklist = 0;
	kc_p->kc_memory_left = 0;
	kc_p->kc_memory_ptr = 0;
	kc_p->kc_memory_freelist = &kc_mainmemory_freelist;
	kc_p->kc_to_be_freed = 1;
	kc_p->kc_wanted_blocksize = /*(kc_n <= 0) ?*/ KC_MEMORY_BLOCKSIZE /*: kc_n*/;
	return kc_p;
}

boolean isinuniqmalloccedblock
#ifdef KC_USE_PROTOTYPES
(kc_voidptr_t kc_p, kc_voidptr_t kc_malloc_private_info)
#else
(kc_p, kc_malloc_private_info) kc_voidptr_t kc_p; kc_voidptr_t kc_malloc_private_info;
#endif
{	kc_memory_blocksinfo_t kc_l;
	kc_memory_info_t *kc_a_memory_info_t = (kc_memory_info_t *)kc_malloc_private_info;
	if (kc_a_memory_info_t->kc_memory_blocklist == 0) {
		return False;
	}
	kc_l = kc_a_memory_info_t->kc_memory_blocklist;
	do {
		if (((char*)kc_p >= (char*)kc_l->block) && ((char*)kc_p < (char*)((char*)kc_l->block + kc_l->size))) {
			return True;
		}
		kc_l = kc_l->next;
	} while(kc_l != kc_a_memory_info_t->kc_memory_blocklist);
	return False;
}

/*ARGSUSED*/
void uniqfreeelement	/* free (prepare for reuse of) one element in private info */
#ifdef KC_USE_PROTOTYPES
(kc_voidptr_t kc_ptr, kc_voidptr_t kc_malloc_private_info)
#else
(kc_ptr, kc_malloc_private_info) kc_voidptr_t kc_ptr; kc_voidptr_t kc_malloc_private_info;
#endif
{
}

void uniqfreeall	/* free (prepare for reuse of) everything in private info */
#ifdef KC_USE_PROTOTYPES
(kc_voidptr_t kc_malloc_private_info)
#else
(kc_malloc_private_info) kc_voidptr_t kc_malloc_private_info;
#endif
{
	kc_memory_info_t *kc_a_memory_info_t = (kc_memory_info_t *)kc_malloc_private_info;
	if (kc_a_memory_info_t->kc_memory_blocklist != 0) {
		kc_memory_blocksinfo_t kc_a_memory_blocklist = kc_a_memory_info_t->kc_memory_blocklist;
		kc_memory_blocksinfo_t kc_blockptr = kc_a_memory_blocklist;
		do {
			KC_BZERO(kc_blockptr->block, kc_blockptr->size);
			kc_blockptr = kc_blockptr->next;
		} while (kc_blockptr != kc_a_memory_blocklist);
		if (*kc_a_memory_info_t->kc_memory_freelist == 0) {
			*kc_a_memory_info_t->kc_memory_freelist = kc_a_memory_info_t->kc_memory_blocklist;
		} else {
			kc_a_memory_info_t->kc_memory_blocklist->prev->next = (*kc_a_memory_info_t->kc_memory_freelist)->prev;
			(*kc_a_memory_info_t->kc_memory_freelist)->prev->next = kc_a_memory_info_t->kc_memory_blocklist->prev;
			kc_a_memory_info_t->kc_memory_blocklist->prev = *kc_a_memory_info_t->kc_memory_freelist;
			(*kc_a_memory_info_t->kc_memory_freelist)->prev = kc_a_memory_info_t->kc_memory_blocklist;
	}	}
	/* just to be sure, this is NECESSARY in case kc_a_memory_info_t->kc_to_be_freed holds */
	kc_a_memory_info_t->kc_memory_blocklist = 0;
	kc_a_memory_info_t->kc_memory_left = 0;
	kc_a_memory_info_t->kc_memory_ptr = 0;
	kc_a_memory_info_t->kc_memory_left = 0;
	if (kc_a_memory_info_t->kc_to_be_freed) { /* we must be sure that it wasn't dynamically allocated */
		KC_BZERO(kc_a_memory_info_t, sizeof(kc_memory_info_t));
		FREE((kc_voidptr_t)kc_a_memory_info_t);
}	}

/*ARGSUSED*/
kc_voidptr_t kc_wrap_bucket_malloc
#ifdef KC_USE_PROTOTYPES
(kc_size_t kc_a_size, kc_size_t kc_a_number, kc_voidptr_t kc_a_private_malloc_info)
#else
(kc_a_size, kc_a_number, kc_a_private_malloc_info)
kc_size_t kc_a_size; kc_size_t kc_a_number; kc_voidptr_t kc_a_private_malloc_info;
#endif
{	return MALLOC((kc_size_t)kc_a_size*kc_a_number);
}

/*ARGSUSED*/
kc_voidptr_t kc_wrap_bucket_realloc
#ifdef KC_USE_PROTOTYPES
(kc_voidptr_t kc_ptr, kc_size_t kc_a_oldsize, kc_size_t kc_a_newsize, kc_voidptr_t kc_a_private_malloc_info)
#else
(kc_ptr, kc_a_oldsize, kc_a_newsize, kc_a_private_malloc_info)
kc_voidptr_t kc_ptr; kc_size_t kc_a_oldsize; kc_size_t kc_a_newsize; kc_voidptr_t kc_a_private_malloc_info;
#endif
{	return REALLOC(kc_ptr, kc_a_newsize);
}

/*ARGSUSED*/
void kc_wrap_bucket_free
#ifdef KC_USE_PROTOTYPES
(kc_voidptr_t kc_ptr, kc_size_t kc_a_size, kc_voidptr_t kc_a_private_malloc_info)
#else
(kc_ptr, kc_a_size, kc_a_private_malloc_info)
kc_voidptr_t kc_ptr; kc_size_t kc_a_size; kc_voidptr_t kc_a_private_malloc_info;
#endif
{	(void)FREE(kc_ptr);
}

#ifdef KC_STATISTICS
   KC_OPERATOR_STATISTICS kc_OperatorStatistics[KC_NO_OF_OPERATORS];
#  define KC_COLLECT_STATS0(v) v
#else
#  define KC_COLLECT_STATS0(v) 
#endif

#ifndef KC_CREATE_STATS
#  define KC_CREATE_STATS(oper) kc_OperatorStatistics[(int)oper].create++;
#endif
#ifndef KC_EXISTINGNOTFOUND_STATS
#  define KC_EXISTINGNOTFOUND_STATS(oper) kc_OperatorStatistics[(int)oper].existing_not_found++;
#endif

#ifndef KC_FREE_CALLED_STATS
#  define KC_FREE_CALLED_STATS(oper,rec) kc_OperatorStatistics[(int)oper].free_called[(int)(rec?True:False)]++;
#endif

#ifndef KC_FREED_STATS
#  define KC_FREED_STATS(oper,rec) kc_OperatorStatistics[(int)oper].freed[(int)(rec?True:False)]++;
#endif


static kc_hashtableentry_t kc_mainhasharray_kc_not_uniq[1][(int)kc_last_storage_mode];
static kc_hashtableentry_t kc_mainhasharray_kc_uniq_nullary_operator[1][(int)kc_last_storage_mode];
static kc_hashtableentry_t kc_mainhasharray_uniq[LARGEPRIME+1][(int)kc_last_storage_mode]; /* +1 because LARGEPRIME can be 0 */


static boolean kc_storageclass_still_uniq[] = {
True, True, True };

static kc_memory_info_t kc_memory_info_kc_not_uniq = { 0, 0, 0, &kc_mainmemory_freelist, 0, KC_MEMORY_BLOCKSIZE };
static kc_memory_info_t kc_memory_info_kc_uniq_nullary_operator = { 0, 0, 0, &kc_mainmemory_freelist, 0, KC_MEMORY_BLOCKSIZE };
static kc_memory_info_t kc_memory_info_uniq = { 0, 0, 0, &kc_mainmemory_freelist, 0, KC_MEMORY_BLOCKSIZE };


#if ! (defined(lint) || defined(SABER)) /* currently not used */
static kc_memory_info_t *kc_memory_info[] = { &kc_memory_info_kc_not_uniq, &kc_memory_info_kc_uniq_nullary_operator, &kc_memory_info_uniq };
#endif

static kc_hashtable_struct_t kc_static_hashtables[] = {
{ kc_mainhasharray_kc_not_uniq,
 0 /*size*/,
 0 /*kc_to_be_freed*/,
 &kc_static_hashtables[1],
 &kc_static_hashtables[2],
 /* node allocation*/
 (kc_voidptr_t(*)())UNIQMALLOCINIT,
 UNIQMALLOC2,
 0 /*UNIQFREEELEMENT*/,
 UNIQFREEALL,
 INUNIQBLOCK,
 (kc_voidptr_t)&kc_memory_info_kc_not_uniq /*malloc_private_data*/,
 (kc_voidptr_t)&kc_memory_info_kc_not_uniq /*static_malloc_private_data*/,
 0 /*dynamic_malloc_private_data*/,
 0 /*dec_dynamic_malloc_private_data*/,
 kc_ht_store_static,
 UNIQMEMORYINFO,
 /* bucket allocation */
 BUCKETALLOCINIT,
 BUCKETCALLOC,
 BUCKETREALLOC,
 0 /*bucket_alloc_private_data*/,
 BUCKETFREE,
 BUCKETSFREE,
 BUCKETINC,
 BUCKETMEMORYINFO
 },
{ kc_mainhasharray_kc_uniq_nullary_operator,
 0 /*size*/,
 0 /*kc_to_be_freed*/,
 &kc_static_hashtables[2],
 &kc_static_hashtables[0],
 /* node allocation*/
 (kc_voidptr_t(*)())UNIQMALLOCINIT,
 UNIQMALLOC2,
 0 /*UNIQFREEELEMENT*/,
 UNIQFREEALL,
 INUNIQBLOCK,
 (kc_voidptr_t)&kc_memory_info_kc_uniq_nullary_operator /*malloc_private_data*/,
 (kc_voidptr_t)&kc_memory_info_kc_uniq_nullary_operator /*static_malloc_private_data*/,
 0 /*dynamic_malloc_private_data*/,
 0 /*dec_dynamic_malloc_private_data*/,
 kc_ht_store_static,
 UNIQMEMORYINFO,
 /* bucket allocation */
 BUCKETALLOCINIT,
 BUCKETCALLOC,
 BUCKETREALLOC,
 0 /*bucket_alloc_private_data*/,
 BUCKETFREE,
 BUCKETSFREE,
 BUCKETINC,
 BUCKETMEMORYINFO
 },
{ kc_mainhasharray_uniq,
 LARGEPRIME /*size*/,
 0 /*kc_to_be_freed*/,
 &kc_static_hashtables[0],
 &kc_static_hashtables[1],
 /* node allocation*/
 (kc_voidptr_t(*)())UNIQMALLOCINIT,
 UNIQMALLOC2,
 0 /*UNIQFREEELEMENT*/,
 UNIQFREEALL,
 INUNIQBLOCK,
 (kc_voidptr_t)&kc_memory_info_uniq,
 (kc_voidptr_t)&kc_memory_info_uniq,
 0 /*dynamic_malloc_private_data*/,
 0 /*dec_dynamic_malloc_private_data*/,
 kc_ht_store_static,
 UNIQMEMORYINFO,
 /* bucket allocation */
 BUCKETALLOCINIT,
 BUCKETCALLOC,
 BUCKETREALLOC,
 0 /*bucket_alloc_private_data*/,
 BUCKETFREE,
 BUCKETSFREE,
 BUCKETINC,
 BUCKETMEMORYINFO
 }};

static kc_hashtable_t kc_hashtables[] = {
&kc_static_hashtables[(int)kc_not_uniq], &kc_static_hashtables[(int)kc_uniq_nullary_operator], &kc_static_hashtables[(int)uniq]};

static char* kc_storageclassnames[] = { "kc_not_uniq", "kc_uniq_nullary_operator", "uniq" };

static kc_hashtable_t kc_all_hashtables = &kc_static_hashtables[0];

static int kc_primes[] = {
	1009,
	1091,
	1193,
	1297,
	1423,
	1543,
	1693,
	1847,
	2003,
	2203,
	2381,
	2609,
	2833,
	3089,
	3371,
	3673,
	4007,
	4373,
	4783,
	5209,
	5683,
	6197,
	6761,
	7369,
	8039,
	8761,
	9587,
	10427,
	11383,
	12409,
	13537,
	14767,
	16111,
	17569,
	19181,
	20921,
	22807,
	24889,
	27143,
	29611,
	32299,
	35251,
	38447,
	41941,
	45751,
	49919,
	54443,
	59387,
	64793,
	70687,
	77101,
	80021,
	84121,
	91753,
	100103,
	109199,
	119129,
	129953,
	141761,
	154643,
	168713,
	184039,
	200771,
	219017,
	238939,
	260647,
	284357,
	310223,
	338407,
	369169,
	402739,
	439339,
	479263,
	522829,
	570359,
	622241,
	678773,
	740477,
	807797,
	881233,
	961339,
	1048759,
	1144081,
	1248083,
	1361573,
	1485347,
	1620347,
	1767679,
	1928351,
	2103653,
	2294891,
	2503511,
	2731103,
	2979391,
	3250243,
	3545719,
	3868057,
	4219687,
	4603297,
	5021773,
	5478299,
	5976329,
	6519647,
	7112351,
	7758899,
	8464273,
	9233729,
	10073153,
	10988893,
	11987891,
	13077707,
	14266573,
	15563531,
	16978399,
	18521897,
	20205697,
	22042607,
	24046487,
	26232491,
	28617269,
	31218823,
	34056907,
	37152979,
	40530541,
	44215117,
	48234733,
	52619639,
	57403277,
	62621729,
	68314613,
	74525021,
	81300017,
	88690949,
	96753739,
	105549557,
	115144957,
	125612671,
	137032001,
	149489477,
	163079431,
	177904801,
	194077981,
	211721429,
	230968853,
	251966009,
	274871969,
	299860369,
	327120389,
	356858597,
	389300293,
	424691207,
	463299493,
	505417691,
	551364677,
	601488779,
	656169539,
	715821317,
	780896041,
	851886569,
	929330767,
	1013815373,
	1105980433,
	1206524183,
	1316208139,
	1435863449,
	1566396463,
	1708796171,
	1864141193,
	2033608601,
0, 0 /* last two elements should ALWAYS be 0 */ };

#ifdef KC_STATISTICS
static int kc_casestring_strlen =0;
static int kc_nocasestring_strlen =0;

void kc_do_print_operator_statistics
#ifdef KC_USE_PROTOTYPES
(FILE * kc_f)
#else
(kc_f) FILE *kc_f;
#endif
{	unsigned int kc_i;
	assertNonNull( kc_f,"kc_f" );
	(void)fprintf(kc_f, "%-*s| %-*s| %-*s| %-*s| %-*s| %-*s| %-*s| %-*s| %-*s| %-*s\n", 38 , "Operator", 3, "Sz", 8, "#oper", 8, "#new", 8, "#exist", 8, "#frnrec", 8, "#frrec", 8, "#freed", 8, "#rem", 9, "total (bytes)");
	(void)fprintf(kc_f, "%-*s|%*s |%*d |%*d |%*d |%*d |%*d |%*d |%*d |%*d\n", 38, "case sensitive strings", 3, "-", 8, kc_OperatorStatistics[(int)sel__Str].create, 8, kc_OperatorStatistics[(int)sel__Str].existing_not_found, 8, kc_OperatorStatistics[(int)sel__Str].create-kc_OperatorStatistics[(int)sel__Str].existing_not_found, 8, 0, 8, 0, 8, 0, 8, 0, 9, kc_casestring_strlen);
	(void)fprintf(kc_f, "%-*s|%*s |%*d |%*d |%*d |%*d |%*d |%*d |%*d |%*d\n", 38, "case insensitive strings", 3, "-", 8, kc_OperatorStatistics[(int)sel_NoCaseStr].create, 8, kc_OperatorStatistics[(int)sel_NoCaseStr].existing_not_found, 8, kc_OperatorStatistics[(int)sel_NoCaseStr].create-kc_OperatorStatistics[(int)sel_NoCaseStr].existing_not_found, 8, 0, 8, 0, 8, 0, 8, 0, 9, kc_nocasestring_strlen);
	for (kc_i = (int)kc_one_before_first_operator+1; kc_i < (int)kc_last_operator; kc_i++) {
		(void)fprintf(kc_f, "%-*s|%*d |%*d |%*d |%*d |%*d |%*d |%*d |%*d |%*d\n", 38, kc_OperatorInfo[kc_i].name, 3, kc_PhylumInfo[(int)kc_OperatorInfo[kc_i].phylum].size, 8, kc_OperatorStatistics[kc_i].create, 8, kc_OperatorStatistics[kc_i].existing_not_found, 8, kc_OperatorStatistics[kc_i].create-kc_OperatorStatistics[kc_i].existing_not_found, 8, kc_OperatorStatistics[kc_i].free_called[(int)False], 8, kc_OperatorStatistics[kc_i].free_called[(int)True], 8, kc_OperatorStatistics[kc_i].freed[(int)False]+kc_OperatorStatistics[kc_i].freed[(int)True], 8, kc_OperatorStatistics[kc_i].existing_not_found-(kc_OperatorStatistics[kc_i].freed[(int)False]+kc_OperatorStatistics[kc_i].freed[(int)True]), 9, (kc_PhylumInfo[(int)kc_OperatorInfo[(int)kc_i].phylum].size)*(kc_OperatorStatistics[kc_i].existing_not_found-(kc_OperatorStatistics[kc_i].freed[(int)False]+kc_OperatorStatistics[kc_i].freed[(int)True])));
	}
}
#endif /* KC_STATISTICS */

void kc_print_hash_statistics
#ifdef KC_USE_PROTOTYPES
(FILE *kc_f)
#else
(kc_f) FILE *kc_f;
#endif
{	unsigned int kc_k;
	/*assertNonNull(kc_f,"kc_f");*/ if (kc_f == NULL) kc_f = stdout;
	for (kc_k=0; kc_k < (int)kc_last_storageclass; kc_k++) {
		(void)fprintf(kc_f, "Information for storage class %s: \n", kc_storageclassnames[kc_k]);
		kc_print_hashtable_statistics(kc_f, kc_hashtables[kc_k]);
}	}

void kc_print_all_hashtable_statistics
#ifdef KC_USE_PROTOTYPES
(FILE *kc_f)
#else
(kc_f) FILE *kc_f;
#endif
{	kc_hashtable_t kc_a_hashtable_t = kc_all_hashtables;
	unsigned int kc_k;
	boolean kc_st_found;
	/*assertNonNull(kc_f,"kc_f");*/ if (kc_f == NULL) kc_f = stdout;
	do { /* at least one time, because we have at least one element */
		kc_st_found = False;
		for (kc_k=0; kc_k < (int)kc_last_storageclass; kc_k++) {
			if (kc_hashtables[kc_k] == kc_a_hashtable_t) {
				kc_st_found = True;
				(void)fprintf(kc_f, "Information for storage class %s: \n", kc_storageclassnames[kc_k]);
		}	}
		if (! kc_st_found) {
			(void)fprintf(kc_f, "Information for unknown storage class: \n");
		}
		kc_print_hashtable_statistics(kc_f, kc_a_hashtable_t);
		kc_print_hashtable_memory_statistics(kc_f, kc_a_hashtable_t);
		kc_a_hashtable_t = kc_a_hashtable_t->next;
	} while(kc_a_hashtable_t != kc_all_hashtables);
}

void kc_print_hashtable_statistics
#ifdef KC_USE_PROTOTYPES
(FILE *kc_f, kc_hashtable_t kc_a_hashtable_t)
#else
(kc_f, kc_a_hashtable_t) FILE *kc_f; kc_hashtable_t kc_a_hashtable_t;
#endif
{
	boolean kc_goon;
	int kc_entries[9];
	int kc_o_8 = 0;
	int kc_o_20 = 0;
	int kc_o_100 = 0;
	int kc_total = 0;
	int kc_i, kc_j;

	/*assertNonNull(kc_f,"kc_f");*/ if (kc_f == NULL) kc_f = stdout;
	(void)fprintf(kc_f, "\tsize:\t%d\n",kc_a_hashtable_t->size);
	for (kc_i=0; kc_i < 9; kc_i++) kc_entries[kc_i]=0;
	for (kc_i=0;kc_i<kc_a_hashtable_t->size;kc_i++) {
		int kc_m=0, kc_n;
		for (kc_n=0;kc_n<(int)kc_last_storage_mode;kc_n++) {
			kc_m += kc_a_hashtable_t->hashtable[kc_i][kc_n].nr;
		}
		kc_total += kc_m;
		if (kc_m >100) {kc_o_100 ++; (void)fprintf(kc_f, ">100: key %d (%d elts)\n",kc_i,kc_m); }
		else if (kc_m >20) {kc_o_20 ++; (void)fprintf(kc_f, ">20: key %d (%d elts)\n",kc_i,kc_m); }
		else if (kc_m > 8) kc_o_8 ++;
		else {
			kc_j =0; kc_goon = True;
			while ( kc_goon && (kc_j < 9)) {
				if (kc_m == kc_j) { kc_entries[kc_j]++; kc_goon = False; }
				else kc_j++;
	}	}	}
	(void)fprintf(kc_f, "The spreading is: \n");
	for (kc_j=0; kc_j < 9; kc_j++) {
		(void)fprintf(kc_f, "\t%d elts:\t%d\n",kc_j, kc_entries[kc_j]);
	}
	(void)fprintf(kc_f, "\tOver 8 elts:\t%d\n",kc_o_8);
	(void)fprintf(kc_f, "\tOver 20 elts:\t%d\n",kc_o_20);
	(void)fprintf(kc_f, "\tOver 100 elts:\t%d\n",kc_o_100);
	(void)fprintf(kc_f, " Total number of cells: %d\n",kc_total);
	(void)fprintf(kc_f, " Number of buckets: %d\n",kc_a_hashtable_t->size);
}

static void kc_growindex
#ifdef KC_USE_PROTOTYPES
(kc_hashtableentry_t *kc_hte, kc_hashtable_t kc_a_ht)
#else
(kc_hte, kc_a_ht) kc_hashtableentry_t *kc_hte; kc_hashtable_t kc_a_ht;
#endif
{	int kc_newsize = kc_hte->ibound + kc_a_ht->bucket_alloc_inc;
	if (kc_newsize == kc_a_ht->bucket_alloc_inc)
		kc_hte->index = (YYSTYPE *) (*kc_a_ht->bucket_calloc)((kc_size_t)kc_newsize, (kc_size_t)sizeof(YYSTYPE), kc_a_ht->bucket_alloc_private_data);
	else
		kc_hte->index = (YYSTYPE *) (*kc_a_ht->bucket_realloc)((kc_voidptr_t)kc_hte->index, (kc_size_t)kc_hte->ibound * sizeof(YYSTYPE), (kc_size_t)kc_newsize * sizeof(YYSTYPE), kc_a_ht->bucket_alloc_private_data);
	kc_hte->ibound = kc_newsize;
}

void kc_ht_static
#ifdef KC_USE_PROTOTYPES
(kc_storageclass_t kc_a_storageclass_t)
#else
(kc_a_storageclass_t) kc_storageclass_t kc_a_storageclass_t;
#endif
{
	kc_hashtables[(int)kc_a_storageclass_t]->mode = kc_ht_store_static;
	kc_hashtables[(int)kc_a_storageclass_t]->malloc_private_data = kc_hashtables[(int)kc_a_storageclass_t]->static_malloc_private_data;
}

void kc_ht_dynamic
#ifdef KC_USE_PROTOTYPES
(kc_storageclass_t kc_a_storageclass_t)
#else
(kc_a_storageclass_t) kc_storageclass_t kc_a_storageclass_t;
#endif
{
	kc_hashtables[(int)kc_a_storageclass_t]->mode = kc_ht_store_dynamic;
	if (kc_hashtables[(int)kc_a_storageclass_t]->dynamic_malloc_private_data != 0) {
		kc_ht_inc_level(kc_a_storageclass_t);
	}
	kc_hashtables[(int)kc_a_storageclass_t]->malloc_private_data = kc_hashtables[(int)kc_a_storageclass_t]->dynamic_malloc_private_data->malloc_private_data;
}

void kc_ht_inc_level
#ifdef KC_USE_PROTOTYPES
(kc_storageclass_t kc_a_storageclass_t)
#else
(kc_a_storageclass_t) kc_storageclass_t kc_a_storageclass_t;
#endif
{
	kc_private_malloc_t kc_a_private_malloc_t = (kc_private_malloc_t)MALLOC(sizeof(struct kc_tag_kc_private_malloc_t));
	kc_a_private_malloc_t->next = kc_hashtables[(int)kc_a_storageclass_t]->dynamic_malloc_private_data;
	if (kc_hashtables[(int)kc_a_storageclass_t]->dynamic_malloc_private_data != 0 ) {
		kc_hashtables[(int)kc_a_storageclass_t]->dynamic_malloc_private_data->prev = kc_a_private_malloc_t;
	}
	kc_a_private_malloc_t->prev = kc_hashtables[(int)kc_a_storageclass_t]->dec_dynamic_malloc_private_data;
	kc_a_private_malloc_t->malloc_private_data = (*kc_hashtables[(int)kc_a_storageclass_t]->malloc_initialise)();
	kc_hashtables[(int)kc_a_storageclass_t]->dynamic_malloc_private_data = kc_a_private_malloc_t;
}

void kc_ht_dec_level
#ifdef KC_USE_PROTOTYPES
(kc_storageclass_t kc_a_storageclass_t)
#else
(kc_a_storageclass_t) kc_storageclass_t kc_a_storageclass_t;
#endif
{
	int kc_i, kc_j, kc_m;
	kc_hashtableentry_t* kc_hte;

	kc_hashtable_t kc_a_hashtable_t = kc_hashtables[(int)kc_a_storageclass_t];
	if (kc_a_hashtable_t->dynamic_malloc_private_data != 0) {
		kc_a_hashtable_t->dec_dynamic_malloc_private_data = kc_a_hashtable_t->dynamic_malloc_private_data;
		kc_a_hashtable_t->dynamic_malloc_private_data = kc_a_hashtable_t->dynamic_malloc_private_data->next;
		for (kc_i=0; kc_i < kc_a_hashtable_t->size; kc_i++) {
			kc_m = (int)kc_ht_store_dynamic;
			kc_hte = &kc_a_hashtable_t->hashtable[kc_i][kc_m];
			for (kc_j=kc_hte->nr -1; kc_j >= 0; kc_j--) {
				kc_private_malloc_t kc_a_private_malloc_t = kc_a_hashtable_t->dec_dynamic_malloc_private_data;
				boolean kc_is_in_block = (*kc_a_hashtable_t->in_block)((kc_voidptr_t)kc_hte->index[kc_j].yt_casestring, kc_a_private_malloc_t->malloc_private_data);
#if 0 /* not necessary, because every kc_ht_dec_level call takes care of its own level */
				while ((!kc_is_in_block) && kc_a_private_malloc_t->prev) {
					kc_a_private_malloc_t = kc_a_private_malloc_t->prev;
					kc_is_in_block = (*kc_a_hashtable_t->in_block)((kc_voidptr_t)kc_hte->index[kc_j].yt_casestring, kc_a_private_malloc_t->malloc_private_data);
				}
#endif
				if (kc_is_in_block) {
					kc_hte->nr--;
					kc_hte->index[kc_j] = kc_hte->index[kc_hte->nr];
					kc_hte->index[kc_hte->nr].yt_casestring = 0;
				}
#ifdef KC_SEPARATE_HASH_LEVELS
				  else {
					break;
				}
#endif
		}	}
	} else {
		/* should be a better error message */
		assert(kc_zero_constant); 
}	}

/* free the previous level(s) in the level-list, ie
 * the sublist that is reachable via dec_dynamic_malloc_private_data,
 * and via the prev field of the current dynamic node, if defined
 * follow prev's to the left start, freeing the blocks while moving
 * and freeing the administration nodes themselves
 */
static void kc_ht_do_free_level
#ifdef KC_USE_PROTOTYPES
(kc_hashtable_t kc_a_hashtable_t)
#else
(kc_a_hashtable_t) kc_hashtable_t kc_a_hashtable_t;
#endif
{	kc_private_malloc_t kc_a_private_malloc_t, kc_b_private_malloc_t;
	if (kc_a_hashtable_t->dec_dynamic_malloc_private_data != 0) {
		kc_a_private_malloc_t = kc_a_hashtable_t->dec_dynamic_malloc_private_data;
		while (kc_a_private_malloc_t != 0) {
			if (kc_a_hashtable_t->free_all_elements != 0) {
				(*kc_a_hashtable_t->free_all_elements)(kc_a_private_malloc_t->malloc_private_data);
			}
			kc_b_private_malloc_t = kc_a_private_malloc_t;
			kc_a_private_malloc_t = kc_a_private_malloc_t->prev;
			KC_BZERO(kc_b_private_malloc_t, sizeof(struct kc_tag_kc_private_malloc_t));
			FREE((kc_voidptr_t)kc_b_private_malloc_t);
		}
		kc_a_hashtable_t->dec_dynamic_malloc_private_data = 0;
		if (kc_a_hashtable_t->dynamic_malloc_private_data != 0) {
			kc_a_hashtable_t->dynamic_malloc_private_data->prev = 0;
}	}	}

void kc_ht_free_level
#ifdef KC_USE_PROTOTYPES
(kc_storageclass_t kc_a_storageclass_t)
#else
(kc_a_storageclass_t) kc_storageclass_t kc_a_storageclass_t;
#endif
{
	kc_ht_do_free_level(kc_hashtables[(int)kc_a_storageclass_t]);
}

static int kc_choose_prime
#ifdef KC_USE_PROTOTYPES
(int kc_a_size)
#else
(kc_a_size) int kc_a_size;
#endif
{	int kc_i =0;
	while((kc_primes[kc_i] < kc_a_size) && (kc_primes[kc_i+1] > 0)) {
		kc_i++;
	}
	return kc_primes[kc_i];
}

kc_hashtable_t kc_ht_create_bucketmanagement
#ifdef KC_USE_PROTOTYPES
(int kc_a_size,
 kc_voidptr_t (*kc_a_malloc_initialise)(),
 kc_voidptr_t (*kc_a_malloc)(kc_size_t, kc_voidptr_t),
 void (*kc_a_free_element)(kc_voidptr_t, kc_voidptr_t),
 void (*kc_a_free_all_elements)(kc_voidptr_t),
 boolean (*kc_a_in_block)(kc_voidptr_t, kc_voidptr_t),
 void (*kc_a_malloc_info)(FILE*, kc_voidptr_t),
 kc_voidptr_t (*kc_a_bucket_alloc_initialise)(),
 kc_voidptr_t (*kc_a_bucket_calloc)(kc_size_t, kc_size_t, kc_voidptr_t),
 kc_voidptr_t (*kc_a_bucket_realloc)( kc_voidptr_t, kc_size_t, kc_size_t, kc_voidptr_t),
 void (*kc_a_free_bucket)(kc_voidptr_t, kc_size_t, kc_voidptr_t),
 void (*kc_a_free_buckets)(kc_voidptr_t),
 int kc_a_bucket_alloc_inc,
 void (*kc_a_bucket_alloc_info)(FILE*, kc_voidptr_t)
)
#else
(kc_a_size,
 kc_a_malloc_initialise,
 kc_a_malloc,
 kc_a_free_element,
 kc_a_free_all_elements,
 kc_a_in_block,
 kc_a_malloc_info,
 kc_a_bucket_alloc_initialise,
 kc_a_bucket_calloc,
 kc_a_bucket_realloc,
 kc_a_free_bucket,
 kc_a_free_buckets,
 kc_a_bucket_alloc_inc,
 kc_a_bucket_alloc_info
)
 int kc_a_size;
 kc_voidptr_t (*kc_a_malloc_initialise)KC__P(());
 kc_voidptr_t (*kc_a_malloc)KC__P((kc_size_t, kc_voidptr_t));
 void (*kc_a_free_element)KC__P((kc_voidptr_t, kc_voidptr_t));
 void (*kc_a_free_all_elements)KC__P((kc_voidptr_t));
 boolean (*kc_a_in_block)KC__P((kc_voidptr_t, kc_voidptr_t));
 void (*kc_a_malloc_info)KC__P((FILE*, kc_voidptr_t));
 kc_voidptr_t (*kc_a_bucket_alloc_initialise)KC__P(());
 kc_voidptr_t (*kc_a_bucket_calloc)KC__P((kc_size_t, size_t, kc_voidptr_t));
 kc_voidptr_t (*kc_a_bucket_realloc)KC__P(( kc_voidptr_t, kc_size_t, kc_size_t, kc_voidptr_t));
 void (*kc_a_free_bucket)KC__P((kc_voidptr_t, kc_size_t, kc_voidptr_t));
 void (*kc_a_free_buckets)KC__P((kc_voidptr_t));
 int kc_a_bucket_alloc_inc;
 void (*kc_a_bucket_alloc_info)KC__P((FILE*, kc_voidptr_t));
#endif
{	kc_hashtable_t kc_a_hashtable_t = (kc_hashtable_t)MALLOC(sizeof(kc_hashtable_struct_t));
	kc_a_hashtable_t->size = kc_choose_prime(kc_a_size);
	kc_a_hashtable_t->hashtable = (kc_hashtableentry_t(*)[(int)kc_last_storage_mode])CALLOC((kc_size_t)kc_a_hashtable_t->size*((int)kc_last_storage_mode), (kc_size_t)sizeof(kc_hashtableentry_t));

	kc_a_hashtable_t->malloc_initialise = kc_a_malloc_initialise;
	kc_a_hashtable_t->malloc = kc_a_malloc;
	kc_a_hashtable_t->free_element = kc_a_free_element;
	kc_a_hashtable_t->free_all_elements = kc_a_free_all_elements;
	kc_a_hashtable_t->in_block = kc_a_in_block;
	kc_a_hashtable_t->static_malloc_private_data = (kc_voidptr_t)(*kc_a_hashtable_t->malloc_initialise)();
	kc_a_hashtable_t->malloc_private_data = kc_a_hashtable_t->static_malloc_private_data;
	kc_a_hashtable_t->dynamic_malloc_private_data = 0;
	kc_a_hashtable_t->dec_dynamic_malloc_private_data = 0;
	kc_a_hashtable_t->mode = kc_ht_store_static;
	kc_a_hashtable_t->malloc_info = kc_a_malloc_info;

	kc_a_hashtable_t->bucket_alloc_initialise = kc_a_bucket_alloc_initialise;
	kc_a_hashtable_t->bucket_calloc = kc_a_bucket_calloc;
	kc_a_hashtable_t->bucket_realloc = kc_a_bucket_realloc;
	kc_a_hashtable_t->free_bucket = kc_a_free_bucket;
	kc_a_hashtable_t->free_buckets = kc_a_free_buckets;
	kc_a_hashtable_t->bucket_alloc_info = kc_a_bucket_alloc_info;
	kc_a_hashtable_t->bucket_alloc_inc = (kc_a_bucket_alloc_inc ? kc_a_bucket_alloc_inc : KC_BUCKET_INC);
	kc_a_hashtable_t->bucket_alloc_private_data = (kc_a_hashtable_t->bucket_alloc_initialise)
						      ? (kc_voidptr_t)(*kc_a_hashtable_t->bucket_alloc_initialise)()
						      : 0;

	kc_a_hashtable_t->kc_to_be_freed = 1;
	kc_a_hashtable_t->next = kc_all_hashtables;
	kc_a_hashtable_t->prev = kc_all_hashtables->prev;
	kc_all_hashtables->prev->next = kc_a_hashtable_t;
	kc_all_hashtables->prev = kc_a_hashtable_t;
	kc_all_hashtables = kc_a_hashtable_t;
	return kc_a_hashtable_t;
}

kc_hashtable_t kc_ht_create
#ifdef KC_USE_PROTOTYPES
(int kc_a_size, kc_voidptr_t (*kc_a_malloc_initialise)(), kc_voidptr_t (*kc_a_malloc)(kc_size_t, kc_voidptr_t),
 void (*kc_a_free_element)(kc_voidptr_t, kc_voidptr_t), void (*kc_a_free_all_elements)(kc_voidptr_t),
 boolean (*kc_a_in_block)(kc_voidptr_t, kc_voidptr_t))
#else
(kc_a_size, kc_a_malloc_initialise, kc_a_malloc, kc_a_free_element, kc_a_free_all_elements, kc_a_in_block)
 int kc_a_size; kc_voidptr_t (*kc_a_malloc_initialise)KC__P(()); kc_voidptr_t (*kc_a_malloc)KC__P((kc_size_t, kc_voidptr_t));
 void (*kc_a_free_element)KC__P((kc_voidptr_t, kc_voidptr_t)); void (*kc_a_free_all_elements)KC__P((kc_voidptr_t));
 boolean (*kc_a_in_block)KC__P((kc_voidptr_t, kc_voidptr_t));
#endif
{
	kc_voidptr_t (*kc_tmp_malloc_initialise)KC__P(()) = (kc_voidptr_t(*)())UNIQMALLOCINIT;
	void (*kc_tmp_malloc_info)KC__P((FILE*, kc_voidptr_t)) = (kc_tmp_malloc_initialise == kc_a_malloc_initialise)
								? (void(*)KC__P((FILE*, kc_voidptr_t)))UNIQMEMORYINFO
								: (void(*)KC__P((FILE*, kc_voidptr_t)))0
								;
	/* do something special (wrt mallocinfo?) if we know that our malloc is being used */
	return kc_ht_create_bucketmanagement(kc_a_size, kc_a_malloc_initialise, kc_a_malloc, kc_a_free_element, kc_a_free_all_elements, kc_a_in_block, kc_tmp_malloc_info,
					    (kc_voidptr_t(*)())BUCKETALLOCINIT, BUCKETCALLOC, BUCKETREALLOC, BUCKETFREE, (void(*)KC__P((kc_voidptr_t)))BUCKETSFREE,
					     BUCKETINC, (void(*)KC__P((FILE*, kc_voidptr_t)))BUCKETMEMORYINFO);
}

kc_hashtable_t kc_ht_create_simple
#ifdef KC_USE_PROTOTYPES
(int kc_a_size)
#else
(kc_a_size) int kc_a_size;
#endif
{
	return kc_ht_create_bucketmanagement(kc_a_size, (kc_voidptr_t(*)())UNIQMALLOCINIT, UNIQMALLOC2, (void (*)KC__P((kc_voidptr_t, kc_voidptr_t)))0/*UNIQFREEELEMENT*/, UNIQFREEALL, INUNIQBLOCK,
			    UNIQMEMORYINFO, (kc_voidptr_t(*)())BUCKETALLOCINIT, BUCKETCALLOC, BUCKETREALLOC, BUCKETFREE, (void(*)KC__P((kc_voidptr_t)))BUCKETSFREE, BUCKETINC, (void(*)KC__P((FILE*, kc_voidptr_t)))BUCKETMEMORYINFO);
}

kc_hashtable_t kc_ht_assign
#ifdef KC_USE_PROTOTYPES
(kc_hashtable_t kc_a_hashtable_t, kc_storageclass_t kc_a_storageclass_t)
#else
(kc_a_hashtable_t, kc_a_storageclass_t) kc_hashtable_t kc_a_hashtable_t; kc_storageclass_t kc_a_storageclass_t;
#endif
{	kc_hashtable_t kc_tmp = kc_hashtables[(int)kc_a_storageclass_t];
	kc_hashtables[(int)kc_a_storageclass_t] = kc_a_hashtable_t;
	kc_storageclass_still_uniq[(int)kc_a_storageclass_t] = False;
	return kc_tmp;
}

kc_hashtable_t kc_ht_assigned
#ifdef KC_USE_PROTOTYPES
(kc_storageclass_t kc_a_storageclass_t)
#else
(kc_a_storageclass_t) kc_storageclass_t kc_a_storageclass_t;
#endif
{	return kc_hashtables[(int)kc_a_storageclass_t];
}

static void kc_ht_free_single_elements
#ifdef KC_USE_PROTOTYPES
(kc_hashtable_t kc_a_hashtable_t, int kc_i, int kc_m)
#else
(kc_a_hashtable_t, kc_i, kc_m) kc_hashtable_t kc_a_hashtable_t; int kc_i; int kc_m;
#endif
{	int kc_j;
	if ((int)kc_m == (int)kc_ht_store_static) {
		for (kc_j=0; kc_j < kc_a_hashtable_t->hashtable[kc_i][kc_m].nr; kc_j++) {
			(*kc_a_hashtable_t->free_element)((kc_voidptr_t)kc_a_hashtable_t->hashtable[kc_i][kc_m].index[kc_j].yt_casestring, kc_a_hashtable_t->static_malloc_private_data);
		}
	} else {
		kc_voidptr_t kc_a_private_data;
		if ((kc_a_hashtable_t->dynamic_malloc_private_data == 0) || (kc_a_hashtable_t->dynamic_malloc_private_data->malloc_private_data == 0)) {
			kc_a_private_data = 0;
		} else if (kc_a_hashtable_t->dynamic_malloc_private_data->next == 0) {
			kc_a_private_data = kc_a_hashtable_t->dynamic_malloc_private_data->malloc_private_data;
		}
		for (kc_j=0; kc_j < kc_a_hashtable_t->hashtable[kc_i][kc_m].nr; kc_j++) {
			(*kc_a_hashtable_t->free_element)((kc_voidptr_t)kc_a_hashtable_t->hashtable[kc_i][kc_m].index[kc_j].yt_casestring, kc_a_private_data);
		}
	}
}

static void kc_ht_do_clear_all_elements
#ifdef KC_USE_PROTOTYPES
(kc_hashtable_t kc_a_hashtable_t, boolean kc_reuse, boolean kc_reinit)
#else
(kc_a_hashtable_t, kc_reuse, kc_reinit) kc_hashtable_t kc_a_hashtable_t; boolean kc_reuse; boolean kc_reinit;
#endif
{	int kc_i, kc_m;
	kc_private_malloc_t kc_a_private_malloc_t;
/* free all static stuff */
	(*kc_a_hashtable_t->free_all_elements)(kc_a_hashtable_t->static_malloc_private_data);
/* free all dynamic stuff */
	/* walk to end of list of levels, kc_ht_do_free_level will free last and all
	 * previous levels in the list
	 */
	if (kc_a_hashtable_t->dynamic_malloc_private_data != 0) {
		kc_a_private_malloc_t = kc_a_hashtable_t->dynamic_malloc_private_data;
		while(kc_a_private_malloc_t->next != 0) {
			kc_a_private_malloc_t = kc_a_private_malloc_t->next;
		}
		kc_a_hashtable_t->dec_dynamic_malloc_private_data = kc_a_private_malloc_t;
		kc_a_hashtable_t->dynamic_malloc_private_data = 0;
		kc_ht_do_free_level(kc_a_hashtable_t);
	}
/* free/reuse the buckets, and re-initialize the hashtable-entries */
	if (kc_reuse) { /* zero the buckets; reset nr field */
		for (kc_i=0; kc_i < kc_a_hashtable_t->size; kc_i++) {
			for (kc_m=0; kc_m < (int)kc_last_storage_mode; kc_m++) {
				/* we only do something if nr !=0, else there is nothing to do
				 * because of our 'invariant'
				 */
				if (kc_a_hashtable_t->hashtable[kc_i][kc_m].nr) {
					KC_BZERO((kc_voidptr_t)kc_a_hashtable_t->hashtable[kc_i][kc_m].index,
					 	 (kc_size_t)kc_a_hashtable_t->hashtable[kc_i][kc_m].ibound * sizeof(YYSTYPE));
					kc_a_hashtable_t->hashtable[kc_i][kc_m].nr = 0;
		}	}	}
	} else if (kc_reinit) { /* zero & free the buckets; reset nr, index, ibound fields */
		if (kc_a_hashtable_t->free_buckets) {
			(*kc_a_hashtable_t->free_buckets)(kc_a_hashtable_t->bucket_alloc_private_data);
			KC_BZERO(kc_a_hashtable_t->hashtable, (kc_size_t)kc_a_hashtable_t->size*((int)kc_last_storage_mode)*sizeof(kc_hashtableentry_t));
#if 0
			for (kc_i=0; kc_i < kc_a_hashtable_t->size; kc_i++) {
				for (kc_m=0; kc_m < (int)kc_last_storage_mode; kc_m++) {
					/* we do something if ibound !=0, it is not suficient to
					 * look only at the nr field, because the nr field might be
					 * reset in a previous reuse operation.
					 * we could as well look for an non-null index field.
					 */
					if (kc_a_hashtable_t->hashtable[kc_i][kc_m].ibound) {
						kc_a_hashtable_t->hashtable[kc_i][kc_m].index = 0;
						kc_a_hashtable_t->hashtable[kc_i][kc_m].ibound = 0;
						kc_a_hashtable_t->hashtable[kc_i][kc_m].nr = 0;
			}	}	}
#endif
		} else if (kc_a_hashtable_t->free_bucket) {
			for (kc_i=0; kc_i < kc_a_hashtable_t->size; kc_i++) {
				for (kc_m=0; kc_m < (int)kc_last_storage_mode; kc_m++) {
					/* we do something if ibound !=0, it is not suficient to
					 * look only at the nr field, because the nr field might be
					 * reset in a previous reuse operation.
					 * we could as well look for an non-null index field.
					 */
					if (kc_a_hashtable_t->hashtable[kc_i][kc_m].ibound) {
						KC_BZERO((kc_voidptr_t)kc_a_hashtable_t->hashtable[kc_i][kc_m].index,
							  (kc_size_t)kc_a_hashtable_t->hashtable[kc_i][kc_m].ibound * sizeof(YYSTYPE));
						(*kc_a_hashtable_t->free_bucket)((kc_voidptr_t)kc_a_hashtable_t->hashtable[kc_i][kc_m].index,
										 (kc_size_t)kc_a_hashtable_t->hashtable[kc_i][kc_m].ibound * sizeof(YYSTYPE),
										 kc_a_hashtable_t->bucket_alloc_private_data);
						kc_a_hashtable_t->hashtable[kc_i][kc_m].index = 0;
						kc_a_hashtable_t->hashtable[kc_i][kc_m].ibound = 0;
						kc_a_hashtable_t->hashtable[kc_i][kc_m].nr = 0;
			}	}	}
		} else {
			/* should be a better error message */
			assert(kc_zero_constant); 
		}
	} else { /* zero & free the buckets */
		if (kc_a_hashtable_t->free_buckets) {
			(*kc_a_hashtable_t->free_buckets)(kc_a_hashtable_t->bucket_alloc_private_data);
		} else if (kc_a_hashtable_t->free_bucket) {
			for (kc_i=0; kc_i < kc_a_hashtable_t->size; kc_i++) {
				for (kc_m=0; kc_m < (int)kc_last_storage_mode; kc_m++) {
					/* we do something if index !=0, it is not suficient to
					 * look only at the nr field, because the nr field might be
					 * reset in a previous reuse operation.
					 * we could as well look for an non-null ibound field.
					 */
					if (kc_a_hashtable_t->hashtable[kc_i][kc_m].index) {
						KC_BZERO((kc_voidptr_t)kc_a_hashtable_t->hashtable[kc_i][kc_m].index,
							  (kc_size_t)kc_a_hashtable_t->hashtable[kc_i][kc_m].ibound * sizeof(YYSTYPE));
						(*kc_a_hashtable_t->free_bucket)((kc_voidptr_t)kc_a_hashtable_t->hashtable[kc_i][kc_m].index,
										 (kc_size_t)kc_a_hashtable_t->hashtable[kc_i][kc_m].ibound * sizeof(YYSTYPE),
										 kc_a_hashtable_t->bucket_alloc_private_data);
			}	}	}
		} else {
			/* should be a better error message */
			assert(kc_zero_constant); 
		}
	}
}

static void kc_ht_do_clear_no_all_elements
#ifdef KC_USE_PROTOTYPES
(kc_hashtable_t kc_a_hashtable_t, boolean kc_reuse, boolean kc_reinit)
#else
(kc_a_hashtable_t, kc_reuse, kc_reinit) kc_hashtable_t kc_a_hashtable_t; boolean kc_reuse; boolean kc_reinit;
#endif
{	int kc_i, kc_m;
/* free all static stuff */
	/* done on the fly, below */
/* free all dynamic stuff */
	/* done on the fly, below */
/* free/reuse the buckets, and re-initialize the hashtable-entries */
	if (kc_reuse) { /* zero the buckets; reset nr field */
		for (kc_i=0; kc_i < kc_a_hashtable_t->size; kc_i++) {
			for (kc_m=0; kc_m < (int)kc_last_storage_mode; kc_m++) {
				/* we only do something if nr !=0, else there is nothing to do
				 * because of our 'invariant'
				 */
				if (kc_a_hashtable_t->hashtable[kc_i][kc_m].nr) {
					kc_ht_free_single_elements(kc_a_hashtable_t, kc_i, kc_m);
					KC_BZERO((kc_voidptr_t)kc_a_hashtable_t->hashtable[kc_i][kc_m].index,
					 	 (kc_size_t)kc_a_hashtable_t->hashtable[kc_i][kc_m].ibound * sizeof(YYSTYPE));
					kc_a_hashtable_t->hashtable[kc_i][kc_m].nr = 0;
		}	}	}
	} else if (kc_reinit) { /* zero & free the buckets; reset nr, index, ibound fields */
		if (kc_a_hashtable_t->free_buckets) {
			(*kc_a_hashtable_t->free_buckets)(kc_a_hashtable_t->bucket_alloc_private_data);
			KC_BZERO(kc_a_hashtable_t->hashtable, (kc_size_t)kc_a_hashtable_t->size*((int)kc_last_storage_mode)*sizeof(kc_hashtableentry_t));
#if 0
			for (kc_i=0; kc_i < kc_a_hashtable_t->size; kc_i++) {
				for (kc_m=0; kc_m < (int)kc_last_storage_mode; kc_m++) {
					/* we do something if ibound !=0, it is not suficient to
					 * look only at the nr field, because the nr field might be
					 * reset in a previous reuse operation.
					 * we could as well look for an non-null index field.
					 */
					if (kc_a_hashtable_t->hashtable[kc_i][kc_m].ibound) {
						kc_ht_free_single_elements(kc_a_hashtable_t, kc_i, kc_m);
						kc_a_hashtable_t->hashtable[kc_i][kc_m].index = 0;
						kc_a_hashtable_t->hashtable[kc_i][kc_m].ibound = 0;
						kc_a_hashtable_t->hashtable[kc_i][kc_m].nr = 0;
			}	}	}
#endif
		} else if (kc_a_hashtable_t->free_bucket) {
			for (kc_i=0; kc_i < kc_a_hashtable_t->size; kc_i++) {
				for (kc_m=0; kc_m < (int)kc_last_storage_mode; kc_m++) {
					/* we do something if ibound !=0, it is not suficient to
					 * look only at the nr field, because the nr field might be
					 * reset in a previous reuse operation.
					 * we could as well look for an non-null index field.
					 */
					if (kc_a_hashtable_t->hashtable[kc_i][kc_m].ibound) {
						kc_ht_free_single_elements(kc_a_hashtable_t, kc_i, kc_m);
						KC_BZERO((kc_voidptr_t)kc_a_hashtable_t->hashtable[kc_i][kc_m].index,
							  (kc_size_t)kc_a_hashtable_t->hashtable[kc_i][kc_m].ibound * sizeof(YYSTYPE));
						(*kc_a_hashtable_t->free_bucket)((kc_voidptr_t)kc_a_hashtable_t->hashtable[kc_i][kc_m].index,
										 (kc_size_t)kc_a_hashtable_t->hashtable[kc_i][kc_m].ibound * sizeof(YYSTYPE),
										 kc_a_hashtable_t->bucket_alloc_private_data);
						kc_a_hashtable_t->hashtable[kc_i][kc_m].index = 0;
						kc_a_hashtable_t->hashtable[kc_i][kc_m].ibound = 0;
						kc_a_hashtable_t->hashtable[kc_i][kc_m].nr = 0;
			}	}	}
		} else {
			/* should be a better error message */
			assert(kc_zero_constant); 
		}
	} else { /* zero & free the buckets */
		if (kc_a_hashtable_t->free_buckets) {
			(*kc_a_hashtable_t->free_buckets)(kc_a_hashtable_t->bucket_alloc_private_data);
		} else if (kc_a_hashtable_t->free_bucket) {
			for (kc_i=0; kc_i < kc_a_hashtable_t->size; kc_i++) {
				for (kc_m=0; kc_m < (int)kc_last_storage_mode; kc_m++) {
					/* we do something if index !=0, it is not suficient to
					 * look only at the nr field, because the nr field might be
					 * reset in a previous reuse operation.
					 * we could as well look for an non-null ibound field.
					 */
					if (kc_a_hashtable_t->hashtable[kc_i][kc_m].index) {
						kc_ht_free_single_elements(kc_a_hashtable_t, kc_i, kc_m);
						KC_BZERO((kc_voidptr_t)kc_a_hashtable_t->hashtable[kc_i][kc_m].index,
							  (kc_size_t)kc_a_hashtable_t->hashtable[kc_i][kc_m].ibound * sizeof(YYSTYPE));
						(*kc_a_hashtable_t->free_bucket)((kc_voidptr_t)kc_a_hashtable_t->hashtable[kc_i][kc_m].index,
										 (kc_size_t)kc_a_hashtable_t->hashtable[kc_i][kc_m].ibound * sizeof(YYSTYPE),
										 kc_a_hashtable_t->bucket_alloc_private_data);
			}	}	}
		} else {
			/* should be a better error message */
			assert(kc_zero_constant); 
		}
	}
}

static void kc_ht_do_clear
#ifdef KC_USE_PROTOTYPES
(kc_hashtable_t kc_a_hashtable_t, boolean kc_reuse, boolean kc_reinit)
#else
(kc_a_hashtable_t, kc_reuse, kc_reinit) kc_hashtable_t kc_a_hashtable_t; boolean kc_reuse; boolean kc_reinit;
#endif
{
	if (kc_a_hashtable_t->free_all_elements) {
		kc_ht_do_clear_all_elements(kc_a_hashtable_t, kc_reuse, kc_reinit);
	} else {
		kc_ht_do_clear_no_all_elements(kc_a_hashtable_t, kc_reuse, kc_reinit);
	}
}

void kc_ht_clear
#ifdef KC_USE_PROTOTYPES
(kc_hashtable_t kc_a_hashtable_t)
#else
(kc_a_hashtable_t) kc_hashtable_t kc_a_hashtable_t;
#endif
{
	kc_ht_do_clear(kc_a_hashtable_t, False, True );
	if (kc_a_hashtable_t->kc_to_be_freed) {
		kc_a_hashtable_t->static_malloc_private_data = (kc_voidptr_t)(*kc_a_hashtable_t->malloc_initialise)();
	} /* else: it is a statically allocated hashtable with a statically allocated
	   * static_malloc_private_data that will not be freed either... we have to
	   * trust that our free_all_elements routine (called via kc_ht_do_clear)
	   * prepares the static_malloc_private_data for reuse
	   */
	kc_a_hashtable_t->malloc_private_data = kc_a_hashtable_t->static_malloc_private_data;
	kc_a_hashtable_t->dynamic_malloc_private_data = 0;
	kc_a_hashtable_t->dec_dynamic_malloc_private_data = 0;
	kc_a_hashtable_t->mode = kc_ht_store_static;
	kc_a_hashtable_t->bucket_alloc_private_data = (kc_a_hashtable_t->bucket_alloc_initialise)
						      ? (kc_voidptr_t)(*kc_a_hashtable_t->bucket_alloc_initialise)()
						      : 0;
}

void kc_ht_reuse
#ifdef KC_USE_PROTOTYPES
(kc_hashtable_t kc_a_hashtable_t)
#else
(kc_a_hashtable_t) kc_hashtable_t kc_a_hashtable_t;
#endif
{
	kc_ht_do_clear(kc_a_hashtable_t, True, True );
	if (kc_a_hashtable_t->kc_to_be_freed) {
		kc_a_hashtable_t->static_malloc_private_data = (kc_voidptr_t)(*kc_a_hashtable_t->malloc_initialise)();
	} /* else: it is a statically allocated hashtable with a statically allocated
	   * static_malloc_private_data that will not be freed either... we have to
	   * trust that our free_all_elements routine (called via kc_ht_do_clear)
	   * prepares the static_malloc_private_data for reuse
	   */
	kc_a_hashtable_t->malloc_private_data = kc_a_hashtable_t->static_malloc_private_data;
	kc_a_hashtable_t->dynamic_malloc_private_data = 0;
	kc_a_hashtable_t->dec_dynamic_malloc_private_data = 0;
	kc_a_hashtable_t->mode = kc_ht_store_static;
	kc_a_hashtable_t->bucket_alloc_private_data = (kc_a_hashtable_t->bucket_alloc_initialise)
						      ? (kc_voidptr_t)(*kc_a_hashtable_t->bucket_alloc_initialise)()
						      : 0;
}

void kc_ht_delete
#ifdef KC_USE_PROTOTYPES
(kc_hashtable_t kc_a_hashtable_t)
#else
(kc_a_hashtable_t) kc_hashtable_t kc_a_hashtable_t;
#endif
{
	kc_ht_do_clear(kc_a_hashtable_t, False, False);
	if (kc_a_hashtable_t->kc_to_be_freed) {
		kc_a_hashtable_t->next->prev = kc_a_hashtable_t->prev;
		kc_a_hashtable_t->prev->next = kc_a_hashtable_t->next;
		if (kc_all_hashtables == kc_a_hashtable_t) {
			kc_all_hashtables = kc_a_hashtable_t->next;
		}
		KC_BZERO((kc_voidptr_t)kc_a_hashtable_t->hashtable,
			 (kc_size_t)sizeof(struct kc_tag_kc_hashtableentry_t) * kc_a_hashtable_t->size);
		FREE((kc_voidptr_t)kc_a_hashtable_t->hashtable);
		KC_BZERO((kc_voidptr_t)kc_a_hashtable_t, sizeof(struct kc_tag_kc_hashtable_struct_t));
		FREE((kc_voidptr_t)kc_a_hashtable_t);
}	}


/* atoms creation */
#ifdef __STDC__
#  define kc_mylower(c) (isupper(c) ? tolower(c) : c)
#else
#  define kc_mylower(c) ((isascii(c) && isupper(c)) ? tolower(c) : c)
#endif
/* should be static, maybe? */
int kc_ci_strcmp
#ifdef KC_USE_PROTOTYPES
(char *kc_s1, char *kc_s2)
#else
(kc_s1, kc_s2) char *kc_s1, *kc_s2;
#endif
{	int tmp;
	while ((*kc_s1 != '\0') && (*kc_s2 != '\0')) {
		if ( (tmp = kc_mylower(*kc_s1) - kc_mylower(*kc_s2)) != 0 ) return tmp;
		kc_s1++;
		kc_s2++;
	}
	return( (*kc_s1 != '\0') - (*kc_s2 != '\0') );
}

static unsigned kc_casestrhash
#ifdef KC_USE_PROTOTYPES
(char *kc_s)
#else
(kc_s) char *kc_s;
#endif
{	register unsigned kc_i = 0;
	register char *kc_sp;

	for (kc_sp = kc_s; *kc_sp != '\0'; kc_sp++)
		kc_i = (unsigned)((kc_i * 75) + *kc_sp);
	return kc_i;
}

static unsigned kc_nocasestrhash
#ifdef KC_USE_PROTOTYPES
(char *kc_s)
#else
(kc_s) char *kc_s;
#endif
{	register unsigned kc_i = 0;
	register char *kc_sp;

	for (kc_sp = kc_s; *kc_sp != '\0'; kc_sp++)
		kc_i = (unsigned)((kc_i * 75) + kc_mylower(*kc_sp));
	return kc_i;
}

#undef kc_mylower

casestring mkcasestring
#ifdef KC_USE_PROTOTYPES
(char *kc_s)
#else
(kc_s) char *kc_s;
#endif
{	register casestring kc_x;
	int kc_i;
	register kc_hashtableentry_t* kc_hte;
	unsigned kc_hashval = (unsigned)0;
	YYSTYPE *kc_ptr, *kc_beyond;
	kc_hashtable_t kc_a_ht = kc_hashtables[(int)uniq];

	KC_COLLECT_STATS0(KC_CREATE_STATS(sel__Str));
	OPERATORHASH((unsigned) sel__Str);
	CASESTRHASH(kc_s);
	kc_hashval = kc_hashval%kc_a_ht->size;
	for (kc_i=0; kc_i < (int)kc_last_storage_mode; kc_i++) {
		kc_hte = &(kc_a_ht->hashtable[kc_hashval][kc_i]);
		if (kc_hte->nr != 0) {
			kc_beyond = &kc_hte->index[kc_hte->nr];
			for (kc_ptr = &kc_hte->index[0]; kc_ptr < kc_beyond; kc_ptr++){
				kc_x= kc_ptr->yt_casestring;
				if ((kc_x->prod_sel == sel__Str) && (strcmp(kc_x->name, kc_s) == 0))
					return(kc_x);
	}	}	}
	KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel__Str));
	kc_hte = &(kc_a_ht->hashtable[kc_hashval][(int)kc_a_ht->mode]);
	if (kc_hte->nr >= kc_hte->ibound) kc_growindex(kc_hte, kc_a_ht);
	kc_x = (casestring)(*kc_a_ht->malloc)((kc_size_t)sizeof(struct kc_tag_casestring), kc_a_ht->malloc_private_data);
	kc_x->name = (char*)(*kc_a_ht->malloc)((kc_size_t)(strlen(kc_s))+1, kc_a_ht->malloc_private_data);
	kc_x->prod_sel = sel__Str;
	(void)strcpy(kc_x->name, kc_s);
	kc_hte->index[kc_hte->nr++].yt_casestring = kc_x;
	KC_COLLECT_STATS0(kc_casestring_strlen += strlen(kc_s)+1;);
	return kc_x;
}

nocasestring mknocasestring
#ifdef KC_USE_PROTOTYPES
(char *kc_s)
#else
(kc_s) char *kc_s;
#endif
{	register nocasestring kc_x;
	int kc_i;
	register kc_hashtableentry_t* kc_hte;
	unsigned kc_hashval = (unsigned)0;
	YYSTYPE *kc_ptr, *kc_beyond;
	kc_hashtable_t kc_a_ht = kc_hashtables[(int)uniq];

	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_NoCaseStr));
	OPERATORHASH((unsigned) sel_NoCaseStr);
	NOCASESTRHASH(kc_s);
	kc_hashval = kc_hashval%kc_a_ht->size;
	for (kc_i=0; kc_i < (int)kc_last_storage_mode; kc_i++) {
		kc_hte = &(kc_a_ht->hashtable[kc_hashval][kc_i]);
		if (kc_hte->nr != 0) {
			kc_beyond = &kc_hte->index[kc_hte->nr];
			for (kc_ptr = &kc_hte->index[0]; kc_ptr < kc_beyond; kc_ptr++){
				kc_x= kc_ptr->yt_nocasestring;
				if ((kc_x->prod_sel == sel_NoCaseStr) && (kc_ci_strcmp(kc_x->name, kc_s) == 0))
					return(kc_x);
	}	}	}
	KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_NoCaseStr));
	kc_hte = &(kc_a_ht->hashtable[kc_hashval][(int)kc_a_ht->mode]);
	if (kc_hte->nr >= kc_hte->ibound) kc_growindex(kc_hte, kc_a_ht);
	kc_x = (nocasestring)(*kc_a_ht->malloc)((kc_size_t)sizeof(struct kc_tag_nocasestring), kc_a_ht->malloc_private_data);
	kc_x->name = (char*)(*kc_a_ht->malloc)((kc_size_t)(strlen(kc_s))+1, kc_a_ht->malloc_private_data);
	kc_x->prod_sel = sel_NoCaseStr;
	(void)strcpy(kc_x->name, kc_s);
	kc_hte->index[kc_hte->nr++].yt_nocasestring = kc_x;
	KC_COLLECT_STATS0(kc_nocasestring_strlen += strlen(kc_s)+1;);
	return kc_x;
}

kc_hashnode_t kc_mkhashnode
#ifdef KC_USE_PROTOTYPES
(kc_voidptr_t kc_s, kc_hashtable_t kc_a_ht)
#else
(kc_s, kc_a_ht) kc_voidptr_t kc_s; kc_hashtable_t kc_a_ht;
#endif
{
#ifndef KC_CSGIO_NO_SHARING
	register kc_hashnode_t kc_x;
	int kc_i;
	register kc_hashtableentry_t* kc_hte;
	unsigned kc_hashval = (unsigned)0;
	YYSTYPE *kc_ptr, *kc_beyond;

	INTHASH((int)kc_s);
	kc_hashval = kc_hashval%kc_a_ht->size;
	for (kc_i=0; kc_i < (int)kc_last_storage_mode; kc_i++) {
		kc_hte = &(kc_a_ht->hashtable[kc_hashval][kc_i]);
		if (kc_hte->nr != 0) {
			kc_beyond = &kc_hte->index[kc_hte->nr];
			for (kc_ptr = &kc_hte->index[0]; kc_ptr < kc_beyond; kc_ptr++){
				kc_x= kc_ptr->yt_kc_hashnode_t;
				if ((kc_x->prod_sel == (kc_enum_operators)0) && (kc_x->ptr == kc_s))
					return(kc_x);
	}	}	}
	kc_hte = &(kc_a_ht->hashtable[kc_hashval][(int)kc_a_ht->mode]);
	if (kc_hte->nr >= kc_hte->ibound) kc_growindex(kc_hte, kc_a_ht);
	kc_x = (kc_hashnode_t)(*kc_a_ht->malloc)((kc_size_t)sizeof(struct kc_tag_kc_hashnode_t), kc_a_ht->malloc_private_data);
	kc_x->ptr = kc_s;
	kc_x->number = -1; /* IMPORTANT: some code depends on this -1 */
	kc_x->created = False;
	kc_x->prod_sel = (kc_enum_operators)0;
	kc_hte->index[kc_hte->nr++].yt_kc_hashnode_t = kc_x;
	return kc_x;
#else /* KC_CSGIO_NO_SHARING */
	static struct kc_tag_kc_hashnode_t kc_x_struct;
	kc_x_struct.number = -1; /* IMPORTANT: some code depends on this -1 */
	kc_x_struct.created = False;
	return &kc_x_struct;
#endif /* !KC_CSGIO_NO_SHARING */
}

cr_specification CR_Spec
#ifdef KC_USE_PROTOTYPES
(cr_LABEL cr_LABEL_1, cr_comment_list cr_comment_list_1, cr_specification_identifier cr_specification_identifier_1, cr_gate_identifier_list cr_gate_identifier_list_1, cr_identifier_declaration_list cr_identifier_declaration_list_1, cr_functionality cr_functionality_1, cr_data_type_definition_list cr_data_type_definition_list_1, cr_comment_list cr_comment_list_2, cr_definition_block cr_definition_block_1, cr_boolean_indication cr_boolean_indication_1, cr_annotation_list cr_annotation_list_1, cr_specification_type cr_specification_type_1)
#else
(cr_LABEL_1, cr_comment_list_1, cr_specification_identifier_1, cr_gate_identifier_list_1, cr_identifier_declaration_list_1, cr_functionality_1, cr_data_type_definition_list_1, cr_comment_list_2, cr_definition_block_1, cr_boolean_indication_1, cr_annotation_list_1, cr_specification_type_1) cr_LABEL cr_LABEL_1;  cr_comment_list cr_comment_list_1;  cr_specification_identifier cr_specification_identifier_1;  cr_gate_identifier_list cr_gate_identifier_list_1;  cr_identifier_declaration_list cr_identifier_declaration_list_1;  cr_functionality cr_functionality_1;  cr_data_type_definition_list cr_data_type_definition_list_1;  cr_comment_list cr_comment_list_2;  cr_definition_block cr_definition_block_1;  cr_boolean_indication cr_boolean_indication_1;  cr_annotation_list cr_annotation_list_1;  cr_specification_type cr_specification_type_1; 
#endif
{	register cr_specification kc_x = (cr_specification) NONUNIQMALLOC((kc_size_t)sizeof(struct kc_tag_cr_specification));
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_CR_Spec));
	KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_CR_Spec));
	assert_cr_LABEL( cr_LABEL_1, "cr_LABEL_1" );
	assert_cr_comment_list( cr_comment_list_1, "cr_comment_list_1" );
	assert_cr_specification_identifier( cr_specification_identifier_1, "cr_specification_identifier_1" );
	assert_cr_gate_identifier_list( cr_gate_identifier_list_1, "cr_gate_identifier_list_1" );
	assert_cr_identifier_declaration_list( cr_identifier_declaration_list_1, "cr_identifier_declaration_list_1" );
	assert_cr_functionality( cr_functionality_1, "cr_functionality_1" );
	assert_cr_data_type_definition_list( cr_data_type_definition_list_1, "cr_data_type_definition_list_1" );
	assert_cr_comment_list( cr_comment_list_2, "cr_comment_list_2" );
	assert_cr_definition_block( cr_definition_block_1, "cr_definition_block_1" );
	assert_cr_boolean_indication( cr_boolean_indication_1, "cr_boolean_indication_1" );
	assert_cr_annotation_list( cr_annotation_list_1, "cr_annotation_list_1" );
	assert_cr_specification_type( cr_specification_type_1, "cr_specification_type_1" );
	kc_x->prod_sel = sel_CR_Spec;
	kc_x->u.CR_Spec.cr_LABEL_1 = cr_LABEL_1;
	kc_x->u.CR_Spec.cr_comment_list_1 = cr_comment_list_1;
	kc_x->u.CR_Spec.cr_specification_identifier_1 = cr_specification_identifier_1;
	kc_x->u.CR_Spec.cr_gate_identifier_list_1 = cr_gate_identifier_list_1;
	kc_x->u.CR_Spec.cr_identifier_declaration_list_1 = cr_identifier_declaration_list_1;
	kc_x->u.CR_Spec.cr_functionality_1 = cr_functionality_1;
	kc_x->u.CR_Spec.cr_data_type_definition_list_1 = cr_data_type_definition_list_1;
	kc_x->u.CR_Spec.cr_comment_list_2 = cr_comment_list_2;
	kc_x->u.CR_Spec.cr_definition_block_1 = cr_definition_block_1;
	kc_x->u.CR_Spec.cr_boolean_indication_1 = cr_boolean_indication_1;
	kc_x->u.CR_Spec.cr_annotation_list_1 = cr_annotation_list_1;
	kc_x->u.CR_Spec.cr_specification_type_1 = cr_specification_type_1;
	return kc_x;
}

cr_specification_type CR_IS8807
#ifdef KC_USE_PROTOTYPES
()
#else
()
#endif
{	static cr_specification_type kc_x = (cr_specification_type)0;
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_CR_IS8807));
	if (kc_x == (cr_specification_type)0) {
		KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_CR_IS8807 ));
		kc_x = (cr_specification_type)(*kc_hashtables[(int)kc_uniq_nullary_operator]->malloc)((kc_size_t)sizeof(struct kc_tag_cr_specification_type), kc_hashtables[(int)kc_uniq_nullary_operator]->malloc_private_data);
		kc_x->prod_sel = sel_CR_IS8807;
	}
	return kc_x;
}

cr_specification_type CR_Basic_LOTOS
#ifdef KC_USE_PROTOTYPES
()
#else
()
#endif
{	static cr_specification_type kc_x = (cr_specification_type)0;
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_CR_Basic_LOTOS));
	if (kc_x == (cr_specification_type)0) {
		KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_CR_Basic_LOTOS ));
		kc_x = (cr_specification_type)(*kc_hashtables[(int)kc_uniq_nullary_operator]->malloc)((kc_size_t)sizeof(struct kc_tag_cr_specification_type), kc_hashtables[(int)kc_uniq_nullary_operator]->malloc_private_data);
		kc_x->prod_sel = sel_CR_Basic_LOTOS;
	}
	return kc_x;
}

cr_boolean_indication CR_Booleans_NotChecked
#ifdef KC_USE_PROTOTYPES
()
#else
()
#endif
{	static cr_boolean_indication kc_x = (cr_boolean_indication)0;
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_CR_Booleans_NotChecked));
	if (kc_x == (cr_boolean_indication)0) {
		KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_CR_Booleans_NotChecked ));
		kc_x = (cr_boolean_indication)(*kc_hashtables[(int)kc_uniq_nullary_operator]->malloc)((kc_size_t)sizeof(struct kc_tag_cr_boolean_indication), kc_hashtables[(int)kc_uniq_nullary_operator]->malloc_private_data);
		kc_x->prod_sel = sel_CR_Booleans_NotChecked;
	}
	return kc_x;
}

cr_boolean_indication CR_Booleans_NotOk
#ifdef KC_USE_PROTOTYPES
()
#else
()
#endif
{	static cr_boolean_indication kc_x = (cr_boolean_indication)0;
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_CR_Booleans_NotOk));
	if (kc_x == (cr_boolean_indication)0) {
		KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_CR_Booleans_NotOk ));
		kc_x = (cr_boolean_indication)(*kc_hashtables[(int)kc_uniq_nullary_operator]->malloc)((kc_size_t)sizeof(struct kc_tag_cr_boolean_indication), kc_hashtables[(int)kc_uniq_nullary_operator]->malloc_private_data);
		kc_x->prod_sel = sel_CR_Booleans_NotOk;
	}
	return kc_x;
}

cr_boolean_indication CR_Booleans_Ok
#ifdef KC_USE_PROTOTYPES
()
#else
()
#endif
{	static cr_boolean_indication kc_x = (cr_boolean_indication)0;
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_CR_Booleans_Ok));
	if (kc_x == (cr_boolean_indication)0) {
		KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_CR_Booleans_Ok ));
		kc_x = (cr_boolean_indication)(*kc_hashtables[(int)kc_uniq_nullary_operator]->malloc)((kc_size_t)sizeof(struct kc_tag_cr_boolean_indication), kc_hashtables[(int)kc_uniq_nullary_operator]->malloc_private_data);
		kc_x->prod_sel = sel_CR_Booleans_Ok;
	}
	return kc_x;
}

cr_definition_block CR_Definition_block
#ifdef KC_USE_PROTOTYPES
(cr_behaviour_expression cr_behaviour_expression_1, cr_data_type_definition_list cr_data_type_definition_list_1, cr_process_definition_list cr_process_definition_list_1)
#else
(cr_behaviour_expression_1, cr_data_type_definition_list_1, cr_process_definition_list_1) cr_behaviour_expression cr_behaviour_expression_1;  cr_data_type_definition_list cr_data_type_definition_list_1;  cr_process_definition_list cr_process_definition_list_1; 
#endif
{	register cr_definition_block kc_x = (cr_definition_block) NONUNIQMALLOC((kc_size_t)sizeof(struct kc_tag_cr_definition_block));
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_CR_Definition_block));
	KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_CR_Definition_block));
	assert_cr_behaviour_expression( cr_behaviour_expression_1, "cr_behaviour_expression_1" );
	assert_cr_data_type_definition_list( cr_data_type_definition_list_1, "cr_data_type_definition_list_1" );
	assert_cr_process_definition_list( cr_process_definition_list_1, "cr_process_definition_list_1" );
	kc_x->prod_sel = sel_CR_Definition_block;
	kc_x->u.CR_Definition_block.cr_behaviour_expression_1 = cr_behaviour_expression_1;
	kc_x->u.CR_Definition_block.cr_data_type_definition_list_1 = cr_data_type_definition_list_1;
	kc_x->u.CR_Definition_block.cr_process_definition_list_1 = cr_process_definition_list_1;
	return kc_x;
}

cr_process_definition_list Nilcr_process_definition_list
#ifdef KC_USE_PROTOTYPES
()
#else
()
#endif
{	static cr_process_definition_list kc_x = (cr_process_definition_list)0;
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_Nilcr_process_definition_list));
	if (kc_x == (cr_process_definition_list)0) {
		KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_Nilcr_process_definition_list ));
		kc_x = (cr_process_definition_list)(*kc_hashtables[(int)kc_uniq_nullary_operator]->malloc)((kc_size_t)sizeof(struct kc_tag_cr_process_definition_list), kc_hashtables[(int)kc_uniq_nullary_operator]->malloc_private_data);
		kc_x->prod_sel = sel_Nilcr_process_definition_list;
	}
	return kc_x;
}

cr_process_definition_list Conscr_process_definition_list
#ifdef KC_USE_PROTOTYPES
(cr_process_definition cr_process_definition_1, cr_process_definition_list cr_process_definition_list_1)
#else
(cr_process_definition_1, cr_process_definition_list_1) cr_process_definition cr_process_definition_1;  cr_process_definition_list cr_process_definition_list_1; 
#endif
{	register cr_process_definition_list kc_x = (cr_process_definition_list) NONUNIQMALLOC((kc_size_t)sizeof(struct kc_tag_cr_process_definition_list));
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_Conscr_process_definition_list));
	KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_Conscr_process_definition_list));
	assert_cr_process_definition( cr_process_definition_1, "cr_process_definition_1" );
	assert_cr_process_definition_list( cr_process_definition_list_1, "cr_process_definition_list_1" );
	kc_x->prod_sel = sel_Conscr_process_definition_list;
	kc_x->u.Conscr_process_definition_list.cr_process_definition_1 = cr_process_definition_1;
	kc_x->u.Conscr_process_definition_list.cr_process_definition_list_1 = cr_process_definition_list_1;
	return kc_x;
}

cr_process_definition CR_Process_definition
#ifdef KC_USE_PROTOTYPES
(cr_comment_list cr_comment_list_1, cr_process_identifier cr_process_identifier_1, cr_gate_identifier_list cr_gate_identifier_list_1, cr_identifier_declaration_list cr_identifier_declaration_list_1, cr_functionality cr_functionality_1, cr_definition_block cr_definition_block_1, cr_LABEL cr_LABEL_1)
#else
(cr_comment_list_1, cr_process_identifier_1, cr_gate_identifier_list_1, cr_identifier_declaration_list_1, cr_functionality_1, cr_definition_block_1, cr_LABEL_1) cr_comment_list cr_comment_list_1;  cr_process_identifier cr_process_identifier_1;  cr_gate_identifier_list cr_gate_identifier_list_1;  cr_identifier_declaration_list cr_identifier_declaration_list_1;  cr_functionality cr_functionality_1;  cr_definition_block cr_definition_block_1;  cr_LABEL cr_LABEL_1; 
#endif
{	register cr_process_definition kc_x = (cr_process_definition) NONUNIQMALLOC((kc_size_t)sizeof(struct kc_tag_cr_process_definition));
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_CR_Process_definition));
	KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_CR_Process_definition));
	assert_cr_comment_list( cr_comment_list_1, "cr_comment_list_1" );
	assert_cr_process_identifier( cr_process_identifier_1, "cr_process_identifier_1" );
	assert_cr_gate_identifier_list( cr_gate_identifier_list_1, "cr_gate_identifier_list_1" );
	assert_cr_identifier_declaration_list( cr_identifier_declaration_list_1, "cr_identifier_declaration_list_1" );
	assert_cr_functionality( cr_functionality_1, "cr_functionality_1" );
	assert_cr_definition_block( cr_definition_block_1, "cr_definition_block_1" );
	assert_cr_LABEL( cr_LABEL_1, "cr_LABEL_1" );
	kc_x->prod_sel = sel_CR_Process_definition;
	kc_x->u.CR_Process_definition.cr_comment_list_1 = cr_comment_list_1;
	kc_x->u.CR_Process_definition.cr_process_identifier_1 = cr_process_identifier_1;
	kc_x->u.CR_Process_definition.cr_gate_identifier_list_1 = cr_gate_identifier_list_1;
	kc_x->u.CR_Process_definition.cr_identifier_declaration_list_1 = cr_identifier_declaration_list_1;
	kc_x->u.CR_Process_definition.cr_functionality_1 = cr_functionality_1;
	kc_x->u.CR_Process_definition.cr_definition_block_1 = cr_definition_block_1;
	kc_x->u.CR_Process_definition.cr_LABEL_1 = cr_LABEL_1;
	return kc_x;
}

cr_functionality CR_Exit_part
#ifdef KC_USE_PROTOTYPES
(cr_sort_identifier_list cr_sort_identifier_list_1)
#else
(cr_sort_identifier_list_1) cr_sort_identifier_list cr_sort_identifier_list_1; 
#endif
{	register cr_functionality kc_x = (cr_functionality) NONUNIQMALLOC((kc_size_t)sizeof(struct kc_tag_cr_functionality));
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_CR_Exit_part));
	KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_CR_Exit_part));
	assert_cr_sort_identifier_list( cr_sort_identifier_list_1, "cr_sort_identifier_list_1" );
	kc_x->prod_sel = sel_CR_Exit_part;
	kc_x->u.CR_Exit_part.cr_sort_identifier_list_1 = cr_sort_identifier_list_1;
	return kc_x;
}

cr_functionality CR_Noexit_part
#ifdef KC_USE_PROTOTYPES
()
#else
()
#endif
{	static cr_functionality kc_x = (cr_functionality)0;
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_CR_Noexit_part));
	if (kc_x == (cr_functionality)0) {
		KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_CR_Noexit_part ));
		kc_x = (cr_functionality)(*kc_hashtables[(int)kc_uniq_nullary_operator]->malloc)((kc_size_t)sizeof(struct kc_tag_cr_functionality), kc_hashtables[(int)kc_uniq_nullary_operator]->malloc_private_data);
		kc_x->prod_sel = sel_CR_Noexit_part;
	}
	return kc_x;
}

cr_sort_identifier_list Nilcr_sort_identifier_list
#ifdef KC_USE_PROTOTYPES
()
#else
()
#endif
{	static cr_sort_identifier_list kc_x = (cr_sort_identifier_list)0;
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_Nilcr_sort_identifier_list));
	if (kc_x == (cr_sort_identifier_list)0) {
		KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_Nilcr_sort_identifier_list ));
		kc_x = (cr_sort_identifier_list)(*kc_hashtables[(int)kc_uniq_nullary_operator]->malloc)((kc_size_t)sizeof(struct kc_tag_cr_sort_identifier_list), kc_hashtables[(int)kc_uniq_nullary_operator]->malloc_private_data);
		kc_x->prod_sel = sel_Nilcr_sort_identifier_list;
	}
	return kc_x;
}

cr_sort_identifier_list Conscr_sort_identifier_list
#ifdef KC_USE_PROTOTYPES
(cr_sort_identifier cr_sort_identifier_1, cr_sort_identifier_list cr_sort_identifier_list_1)
#else
(cr_sort_identifier_1, cr_sort_identifier_list_1) cr_sort_identifier cr_sort_identifier_1;  cr_sort_identifier_list cr_sort_identifier_list_1; 
#endif
{	register cr_sort_identifier_list kc_x = (cr_sort_identifier_list) NONUNIQMALLOC((kc_size_t)sizeof(struct kc_tag_cr_sort_identifier_list));
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_Conscr_sort_identifier_list));
	KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_Conscr_sort_identifier_list));
	assert_cr_sort_identifier( cr_sort_identifier_1, "cr_sort_identifier_1" );
	assert_cr_sort_identifier_list( cr_sort_identifier_list_1, "cr_sort_identifier_list_1" );
	kc_x->prod_sel = sel_Conscr_sort_identifier_list;
	kc_x->u.Conscr_sort_identifier_list.cr_sort_identifier_1 = cr_sort_identifier_1;
	kc_x->u.Conscr_sort_identifier_list.cr_sort_identifier_list_1 = cr_sort_identifier_list_1;
	return kc_x;
}

cr_data_type_definition_list Nilcr_data_type_definition_list
#ifdef KC_USE_PROTOTYPES
()
#else
()
#endif
{	static cr_data_type_definition_list kc_x = (cr_data_type_definition_list)0;
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_Nilcr_data_type_definition_list));
	if (kc_x == (cr_data_type_definition_list)0) {
		KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_Nilcr_data_type_definition_list ));
		kc_x = (cr_data_type_definition_list)(*kc_hashtables[(int)kc_uniq_nullary_operator]->malloc)((kc_size_t)sizeof(struct kc_tag_cr_data_type_definition_list), kc_hashtables[(int)kc_uniq_nullary_operator]->malloc_private_data);
		kc_x->prod_sel = sel_Nilcr_data_type_definition_list;
	}
	return kc_x;
}

cr_data_type_definition_list Conscr_data_type_definition_list
#ifdef KC_USE_PROTOTYPES
(cr_data_type_definition cr_data_type_definition_1, cr_data_type_definition_list cr_data_type_definition_list_1)
#else
(cr_data_type_definition_1, cr_data_type_definition_list_1) cr_data_type_definition cr_data_type_definition_1;  cr_data_type_definition_list cr_data_type_definition_list_1; 
#endif
{	register cr_data_type_definition_list kc_x = (cr_data_type_definition_list) NONUNIQMALLOC((kc_size_t)sizeof(struct kc_tag_cr_data_type_definition_list));
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_Conscr_data_type_definition_list));
	KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_Conscr_data_type_definition_list));
	assert_cr_data_type_definition( cr_data_type_definition_1, "cr_data_type_definition_1" );
	assert_cr_data_type_definition_list( cr_data_type_definition_list_1, "cr_data_type_definition_list_1" );
	kc_x->prod_sel = sel_Conscr_data_type_definition_list;
	kc_x->u.Conscr_data_type_definition_list.cr_data_type_definition_1 = cr_data_type_definition_1;
	kc_x->u.Conscr_data_type_definition_list.cr_data_type_definition_list_1 = cr_data_type_definition_list_1;
	return kc_x;
}

cr_data_type_definition CR_Data_type_definition
#ifdef KC_USE_PROTOTYPES
(cr_comment_list cr_comment_list_1, cr_type_identifier cr_type_identifier_1, cr_p_expression cr_p_expression_1, cr_completeness_indication cr_completeness_indication_1, cr_persistency_indication cr_persistency_indication_1, cr_flattened_type_definition cr_flattened_type_definition_1, cr_annotation_list cr_annotation_list_1)
#else
(cr_comment_list_1, cr_type_identifier_1, cr_p_expression_1, cr_completeness_indication_1, cr_persistency_indication_1, cr_flattened_type_definition_1, cr_annotation_list_1) cr_comment_list cr_comment_list_1;  cr_type_identifier cr_type_identifier_1;  cr_p_expression cr_p_expression_1;  cr_completeness_indication cr_completeness_indication_1;  cr_persistency_indication cr_persistency_indication_1;  cr_flattened_type_definition cr_flattened_type_definition_1;  cr_annotation_list cr_annotation_list_1; 
#endif
{	register cr_data_type_definition kc_x = (cr_data_type_definition) NONUNIQMALLOC((kc_size_t)sizeof(struct kc_tag_cr_data_type_definition));
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_CR_Data_type_definition));
	KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_CR_Data_type_definition));
	assert_cr_comment_list( cr_comment_list_1, "cr_comment_list_1" );
	assert_cr_type_identifier( cr_type_identifier_1, "cr_type_identifier_1" );
	assert_cr_p_expression( cr_p_expression_1, "cr_p_expression_1" );
	assert_cr_completeness_indication( cr_completeness_indication_1, "cr_completeness_indication_1" );
	assert_cr_persistency_indication( cr_persistency_indication_1, "cr_persistency_indication_1" );
	assert_cr_flattened_type_definition( cr_flattened_type_definition_1, "cr_flattened_type_definition_1" );
	assert_cr_annotation_list( cr_annotation_list_1, "cr_annotation_list_1" );
	kc_x->prod_sel = sel_CR_Data_type_definition;
	kc_x->u.CR_Data_type_definition.cr_comment_list_1 = cr_comment_list_1;
	kc_x->u.CR_Data_type_definition.cr_type_identifier_1 = cr_type_identifier_1;
	kc_x->u.CR_Data_type_definition.cr_p_expression_1 = cr_p_expression_1;
	kc_x->u.CR_Data_type_definition.cr_completeness_indication_1 = cr_completeness_indication_1;
	kc_x->u.CR_Data_type_definition.cr_persistency_indication_1 = cr_persistency_indication_1;
	kc_x->u.CR_Data_type_definition.cr_flattened_type_definition_1 = cr_flattened_type_definition_1;
	kc_x->u.CR_Data_type_definition.cr_annotation_list_1 = cr_annotation_list_1;
	return kc_x;
}

cr_data_type_definition CR_Library_reference
#ifdef KC_USE_PROTOTYPES
(cr_type_identifier cr_type_identifier_1, cr_flattened_type_definition cr_flattened_type_definition_1, cr_annotation_list cr_annotation_list_1)
#else
(cr_type_identifier_1, cr_flattened_type_definition_1, cr_annotation_list_1) cr_type_identifier cr_type_identifier_1;  cr_flattened_type_definition cr_flattened_type_definition_1;  cr_annotation_list cr_annotation_list_1; 
#endif
{	register cr_data_type_definition kc_x = (cr_data_type_definition) NONUNIQMALLOC((kc_size_t)sizeof(struct kc_tag_cr_data_type_definition));
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_CR_Library_reference));
	KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_CR_Library_reference));
	assert_cr_type_identifier( cr_type_identifier_1, "cr_type_identifier_1" );
	assert_cr_flattened_type_definition( cr_flattened_type_definition_1, "cr_flattened_type_definition_1" );
	assert_cr_annotation_list( cr_annotation_list_1, "cr_annotation_list_1" );
	kc_x->prod_sel = sel_CR_Library_reference;
	kc_x->u.CR_Library_reference.cr_type_identifier_1 = cr_type_identifier_1;
	kc_x->u.CR_Library_reference.cr_flattened_type_definition_1 = cr_flattened_type_definition_1;
	kc_x->u.CR_Library_reference.cr_annotation_list_1 = cr_annotation_list_1;
	return kc_x;
}

cr_completeness_indication CR_Completeness_NotChecked
#ifdef KC_USE_PROTOTYPES
()
#else
()
#endif
{	static cr_completeness_indication kc_x = (cr_completeness_indication)0;
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_CR_Completeness_NotChecked));
	if (kc_x == (cr_completeness_indication)0) {
		KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_CR_Completeness_NotChecked ));
		kc_x = (cr_completeness_indication)(*kc_hashtables[(int)kc_uniq_nullary_operator]->malloc)((kc_size_t)sizeof(struct kc_tag_cr_completeness_indication), kc_hashtables[(int)kc_uniq_nullary_operator]->malloc_private_data);
		kc_x->prod_sel = sel_CR_Completeness_NotChecked;
	}
	return kc_x;
}

cr_completeness_indication CR_Complete
#ifdef KC_USE_PROTOTYPES
()
#else
()
#endif
{	static cr_completeness_indication kc_x = (cr_completeness_indication)0;
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_CR_Complete));
	if (kc_x == (cr_completeness_indication)0) {
		KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_CR_Complete ));
		kc_x = (cr_completeness_indication)(*kc_hashtables[(int)kc_uniq_nullary_operator]->malloc)((kc_size_t)sizeof(struct kc_tag_cr_completeness_indication), kc_hashtables[(int)kc_uniq_nullary_operator]->malloc_private_data);
		kc_x->prod_sel = sel_CR_Complete;
	}
	return kc_x;
}

cr_completeness_indication CR_Not_Complete
#ifdef KC_USE_PROTOTYPES
()
#else
()
#endif
{	static cr_completeness_indication kc_x = (cr_completeness_indication)0;
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_CR_Not_Complete));
	if (kc_x == (cr_completeness_indication)0) {
		KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_CR_Not_Complete ));
		kc_x = (cr_completeness_indication)(*kc_hashtables[(int)kc_uniq_nullary_operator]->malloc)((kc_size_t)sizeof(struct kc_tag_cr_completeness_indication), kc_hashtables[(int)kc_uniq_nullary_operator]->malloc_private_data);
		kc_x->prod_sel = sel_CR_Not_Complete;
	}
	return kc_x;
}

cr_persistency_indication CR_Persistency_NotChecked
#ifdef KC_USE_PROTOTYPES
()
#else
()
#endif
{	static cr_persistency_indication kc_x = (cr_persistency_indication)0;
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_CR_Persistency_NotChecked));
	if (kc_x == (cr_persistency_indication)0) {
		KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_CR_Persistency_NotChecked ));
		kc_x = (cr_persistency_indication)(*kc_hashtables[(int)kc_uniq_nullary_operator]->malloc)((kc_size_t)sizeof(struct kc_tag_cr_persistency_indication), kc_hashtables[(int)kc_uniq_nullary_operator]->malloc_private_data);
		kc_x->prod_sel = sel_CR_Persistency_NotChecked;
	}
	return kc_x;
}

cr_persistency_indication CR_Persistent
#ifdef KC_USE_PROTOTYPES
()
#else
()
#endif
{	static cr_persistency_indication kc_x = (cr_persistency_indication)0;
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_CR_Persistent));
	if (kc_x == (cr_persistency_indication)0) {
		KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_CR_Persistent ));
		kc_x = (cr_persistency_indication)(*kc_hashtables[(int)kc_uniq_nullary_operator]->malloc)((kc_size_t)sizeof(struct kc_tag_cr_persistency_indication), kc_hashtables[(int)kc_uniq_nullary_operator]->malloc_private_data);
		kc_x->prod_sel = sel_CR_Persistent;
	}
	return kc_x;
}

cr_persistency_indication CR_Not_Persistent
#ifdef KC_USE_PROTOTYPES
()
#else
()
#endif
{	static cr_persistency_indication kc_x = (cr_persistency_indication)0;
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_CR_Not_Persistent));
	if (kc_x == (cr_persistency_indication)0) {
		KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_CR_Not_Persistent ));
		kc_x = (cr_persistency_indication)(*kc_hashtables[(int)kc_uniq_nullary_operator]->malloc)((kc_size_t)sizeof(struct kc_tag_cr_persistency_indication), kc_hashtables[(int)kc_uniq_nullary_operator]->malloc_private_data);
		kc_x->prod_sel = sel_CR_Not_Persistent;
	}
	return kc_x;
}

cr_p_expression CR_P_Spec
#ifdef KC_USE_PROTOTYPES
(cr_type_identifier_list cr_type_identifier_list_1, cr_sort_declaration_list cr_sort_declaration_list_1, cr_operation_list cr_operation_list_1, cr_equations_option cr_equations_option_1, cr_sort_declaration_list cr_sort_declaration_list_2, cr_operation_list cr_operation_list_2, cr_equations_option cr_equations_option_2, cr_LABEL cr_LABEL_1)
#else
(cr_type_identifier_list_1, cr_sort_declaration_list_1, cr_operation_list_1, cr_equations_option_1, cr_sort_declaration_list_2, cr_operation_list_2, cr_equations_option_2, cr_LABEL_1) cr_type_identifier_list cr_type_identifier_list_1;  cr_sort_declaration_list cr_sort_declaration_list_1;  cr_operation_list cr_operation_list_1;  cr_equations_option cr_equations_option_1;  cr_sort_declaration_list cr_sort_declaration_list_2;  cr_operation_list cr_operation_list_2;  cr_equations_option cr_equations_option_2;  cr_LABEL cr_LABEL_1; 
#endif
{	register cr_p_expression kc_x = (cr_p_expression) NONUNIQMALLOC((kc_size_t)sizeof(struct kc_tag_cr_p_expression));
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_CR_P_Spec));
	KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_CR_P_Spec));
	assert_cr_type_identifier_list( cr_type_identifier_list_1, "cr_type_identifier_list_1" );
	assert_cr_sort_declaration_list( cr_sort_declaration_list_1, "cr_sort_declaration_list_1" );
	assert_cr_operation_list( cr_operation_list_1, "cr_operation_list_1" );
	assert_cr_equations_option( cr_equations_option_1, "cr_equations_option_1" );
	assert_cr_sort_declaration_list( cr_sort_declaration_list_2, "cr_sort_declaration_list_2" );
	assert_cr_operation_list( cr_operation_list_2, "cr_operation_list_2" );
	assert_cr_equations_option( cr_equations_option_2, "cr_equations_option_2" );
	assert_cr_LABEL( cr_LABEL_1, "cr_LABEL_1" );
	kc_x->prod_sel = sel_CR_P_Spec;
	kc_x->u.CR_P_Spec.cr_type_identifier_list_1 = cr_type_identifier_list_1;
	kc_x->u.CR_P_Spec.cr_sort_declaration_list_1 = cr_sort_declaration_list_1;
	kc_x->u.CR_P_Spec.cr_operation_list_1 = cr_operation_list_1;
	kc_x->u.CR_P_Spec.cr_equations_option_1 = cr_equations_option_1;
	kc_x->u.CR_P_Spec.cr_sort_declaration_list_2 = cr_sort_declaration_list_2;
	kc_x->u.CR_P_Spec.cr_operation_list_2 = cr_operation_list_2;
	kc_x->u.CR_P_Spec.cr_equations_option_2 = cr_equations_option_2;
	kc_x->u.CR_P_Spec.cr_LABEL_1 = cr_LABEL_1;
	return kc_x;
}

cr_p_expression CR_Actualization
#ifdef KC_USE_PROTOTYPES
(cr_type_identifier cr_type_identifier_1, cr_type_identifier_list cr_type_identifier_list_1, cr_replacement cr_replacement_1, cr_LABEL cr_LABEL_1)
#else
(cr_type_identifier_1, cr_type_identifier_list_1, cr_replacement_1, cr_LABEL_1) cr_type_identifier cr_type_identifier_1;  cr_type_identifier_list cr_type_identifier_list_1;  cr_replacement cr_replacement_1;  cr_LABEL cr_LABEL_1; 
#endif
{	register cr_p_expression kc_x = (cr_p_expression) NONUNIQMALLOC((kc_size_t)sizeof(struct kc_tag_cr_p_expression));
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_CR_Actualization));
	KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_CR_Actualization));
	assert_cr_type_identifier( cr_type_identifier_1, "cr_type_identifier_1" );
	assert_cr_type_identifier_list( cr_type_identifier_list_1, "cr_type_identifier_list_1" );
	assert_cr_replacement( cr_replacement_1, "cr_replacement_1" );
	assert_cr_LABEL( cr_LABEL_1, "cr_LABEL_1" );
	kc_x->prod_sel = sel_CR_Actualization;
	kc_x->u.CR_Actualization.cr_type_identifier_1 = cr_type_identifier_1;
	kc_x->u.CR_Actualization.cr_type_identifier_list_1 = cr_type_identifier_list_1;
	kc_x->u.CR_Actualization.cr_replacement_1 = cr_replacement_1;
	kc_x->u.CR_Actualization.cr_LABEL_1 = cr_LABEL_1;
	return kc_x;
}

cr_p_expression CR_Renaming
#ifdef KC_USE_PROTOTYPES
(cr_type_identifier cr_type_identifier_1, cr_replacement cr_replacement_1, cr_LABEL cr_LABEL_1)
#else
(cr_type_identifier_1, cr_replacement_1, cr_LABEL_1) cr_type_identifier cr_type_identifier_1;  cr_replacement cr_replacement_1;  cr_LABEL cr_LABEL_1; 
#endif
{	register cr_p_expression kc_x = (cr_p_expression) NONUNIQMALLOC((kc_size_t)sizeof(struct kc_tag_cr_p_expression));
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_CR_Renaming));
	KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_CR_Renaming));
	assert_cr_type_identifier( cr_type_identifier_1, "cr_type_identifier_1" );
	assert_cr_replacement( cr_replacement_1, "cr_replacement_1" );
	assert_cr_LABEL( cr_LABEL_1, "cr_LABEL_1" );
	kc_x->prod_sel = sel_CR_Renaming;
	kc_x->u.CR_Renaming.cr_type_identifier_1 = cr_type_identifier_1;
	kc_x->u.CR_Renaming.cr_replacement_1 = cr_replacement_1;
	kc_x->u.CR_Renaming.cr_LABEL_1 = cr_LABEL_1;
	return kc_x;
}

cr_type_identifier_list Nilcr_type_identifier_list
#ifdef KC_USE_PROTOTYPES
()
#else
()
#endif
{	static cr_type_identifier_list kc_x = (cr_type_identifier_list)0;
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_Nilcr_type_identifier_list));
	if (kc_x == (cr_type_identifier_list)0) {
		KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_Nilcr_type_identifier_list ));
		kc_x = (cr_type_identifier_list)(*kc_hashtables[(int)kc_uniq_nullary_operator]->malloc)((kc_size_t)sizeof(struct kc_tag_cr_type_identifier_list), kc_hashtables[(int)kc_uniq_nullary_operator]->malloc_private_data);
		kc_x->prod_sel = sel_Nilcr_type_identifier_list;
	}
	return kc_x;
}

cr_type_identifier_list Conscr_type_identifier_list
#ifdef KC_USE_PROTOTYPES
(cr_type_identifier cr_type_identifier_1, cr_type_identifier_list cr_type_identifier_list_1)
#else
(cr_type_identifier_1, cr_type_identifier_list_1) cr_type_identifier cr_type_identifier_1;  cr_type_identifier_list cr_type_identifier_list_1; 
#endif
{	register cr_type_identifier_list kc_x = (cr_type_identifier_list) NONUNIQMALLOC((kc_size_t)sizeof(struct kc_tag_cr_type_identifier_list));
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_Conscr_type_identifier_list));
	KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_Conscr_type_identifier_list));
	assert_cr_type_identifier( cr_type_identifier_1, "cr_type_identifier_1" );
	assert_cr_type_identifier_list( cr_type_identifier_list_1, "cr_type_identifier_list_1" );
	kc_x->prod_sel = sel_Conscr_type_identifier_list;
	kc_x->u.Conscr_type_identifier_list.cr_type_identifier_1 = cr_type_identifier_1;
	kc_x->u.Conscr_type_identifier_list.cr_type_identifier_list_1 = cr_type_identifier_list_1;
	return kc_x;
}

cr_replacement CR_Replacement
#ifdef KC_USE_PROTOTYPES
(cr_sort_replacement_list cr_sort_replacement_list_1, cr_operation_replacement_list cr_operation_replacement_list_1)
#else
(cr_sort_replacement_list_1, cr_operation_replacement_list_1) cr_sort_replacement_list cr_sort_replacement_list_1;  cr_operation_replacement_list cr_operation_replacement_list_1; 
#endif
{	register cr_replacement kc_x = (cr_replacement) NONUNIQMALLOC((kc_size_t)sizeof(struct kc_tag_cr_replacement));
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_CR_Replacement));
	KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_CR_Replacement));
	assert_cr_sort_replacement_list( cr_sort_replacement_list_1, "cr_sort_replacement_list_1" );
	assert_cr_operation_replacement_list( cr_operation_replacement_list_1, "cr_operation_replacement_list_1" );
	kc_x->prod_sel = sel_CR_Replacement;
	kc_x->u.CR_Replacement.cr_sort_replacement_list_1 = cr_sort_replacement_list_1;
	kc_x->u.CR_Replacement.cr_operation_replacement_list_1 = cr_operation_replacement_list_1;
	return kc_x;
}

cr_sort_replacement_list Nilcr_sort_replacement_list
#ifdef KC_USE_PROTOTYPES
()
#else
()
#endif
{	static cr_sort_replacement_list kc_x = (cr_sort_replacement_list)0;
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_Nilcr_sort_replacement_list));
	if (kc_x == (cr_sort_replacement_list)0) {
		KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_Nilcr_sort_replacement_list ));
		kc_x = (cr_sort_replacement_list)(*kc_hashtables[(int)kc_uniq_nullary_operator]->malloc)((kc_size_t)sizeof(struct kc_tag_cr_sort_replacement_list), kc_hashtables[(int)kc_uniq_nullary_operator]->malloc_private_data);
		kc_x->prod_sel = sel_Nilcr_sort_replacement_list;
	}
	return kc_x;
}

cr_sort_replacement_list Conscr_sort_replacement_list
#ifdef KC_USE_PROTOTYPES
(cr_sort_replacement cr_sort_replacement_1, cr_sort_replacement_list cr_sort_replacement_list_1)
#else
(cr_sort_replacement_1, cr_sort_replacement_list_1) cr_sort_replacement cr_sort_replacement_1;  cr_sort_replacement_list cr_sort_replacement_list_1; 
#endif
{	register cr_sort_replacement_list kc_x = (cr_sort_replacement_list) NONUNIQMALLOC((kc_size_t)sizeof(struct kc_tag_cr_sort_replacement_list));
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_Conscr_sort_replacement_list));
	KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_Conscr_sort_replacement_list));
	assert_cr_sort_replacement( cr_sort_replacement_1, "cr_sort_replacement_1" );
	assert_cr_sort_replacement_list( cr_sort_replacement_list_1, "cr_sort_replacement_list_1" );
	kc_x->prod_sel = sel_Conscr_sort_replacement_list;
	kc_x->u.Conscr_sort_replacement_list.cr_sort_replacement_1 = cr_sort_replacement_1;
	kc_x->u.Conscr_sort_replacement_list.cr_sort_replacement_list_1 = cr_sort_replacement_list_1;
	return kc_x;
}

cr_sort_replacement CR_Sort_replacement
#ifdef KC_USE_PROTOTYPES
(cr_sort_name cr_sort_name_1, cr_sort_name cr_sort_name_2, cr_LABEL cr_LABEL_1)
#else
(cr_sort_name_1, cr_sort_name_2, cr_LABEL_1) cr_sort_name cr_sort_name_1;  cr_sort_name cr_sort_name_2;  cr_LABEL cr_LABEL_1; 
#endif
{	register cr_sort_replacement kc_x = (cr_sort_replacement) NONUNIQMALLOC((kc_size_t)sizeof(struct kc_tag_cr_sort_replacement));
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_CR_Sort_replacement));
	KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_CR_Sort_replacement));
	assert_cr_sort_name( cr_sort_name_1, "cr_sort_name_1" );
	assert_cr_sort_name( cr_sort_name_2, "cr_sort_name_2" );
	assert_cr_LABEL( cr_LABEL_1, "cr_LABEL_1" );
	kc_x->prod_sel = sel_CR_Sort_replacement;
	kc_x->u.CR_Sort_replacement.cr_sort_name_1 = cr_sort_name_1;
	kc_x->u.CR_Sort_replacement.cr_sort_name_2 = cr_sort_name_2;
	kc_x->u.CR_Sort_replacement.cr_LABEL_1 = cr_LABEL_1;
	return kc_x;
}

cr_sort_declaration_list Nilcr_sort_declaration_list
#ifdef KC_USE_PROTOTYPES
()
#else
()
#endif
{	static cr_sort_declaration_list kc_x = (cr_sort_declaration_list)0;
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_Nilcr_sort_declaration_list));
	if (kc_x == (cr_sort_declaration_list)0) {
		KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_Nilcr_sort_declaration_list ));
		kc_x = (cr_sort_declaration_list)(*kc_hashtables[(int)kc_uniq_nullary_operator]->malloc)((kc_size_t)sizeof(struct kc_tag_cr_sort_declaration_list), kc_hashtables[(int)kc_uniq_nullary_operator]->malloc_private_data);
		kc_x->prod_sel = sel_Nilcr_sort_declaration_list;
	}
	return kc_x;
}

cr_sort_declaration_list Conscr_sort_declaration_list
#ifdef KC_USE_PROTOTYPES
(cr_sort_declaration cr_sort_declaration_1, cr_sort_declaration_list cr_sort_declaration_list_1)
#else
(cr_sort_declaration_1, cr_sort_declaration_list_1) cr_sort_declaration cr_sort_declaration_1;  cr_sort_declaration_list cr_sort_declaration_list_1; 
#endif
{	register cr_sort_declaration_list kc_x = (cr_sort_declaration_list) NONUNIQMALLOC((kc_size_t)sizeof(struct kc_tag_cr_sort_declaration_list));
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_Conscr_sort_declaration_list));
	KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_Conscr_sort_declaration_list));
	assert_cr_sort_declaration( cr_sort_declaration_1, "cr_sort_declaration_1" );
	assert_cr_sort_declaration_list( cr_sort_declaration_list_1, "cr_sort_declaration_list_1" );
	kc_x->prod_sel = sel_Conscr_sort_declaration_list;
	kc_x->u.Conscr_sort_declaration_list.cr_sort_declaration_1 = cr_sort_declaration_1;
	kc_x->u.Conscr_sort_declaration_list.cr_sort_declaration_list_1 = cr_sort_declaration_list_1;
	return kc_x;
}

cr_sort_declaration CR_Sort_declaration
#ifdef KC_USE_PROTOTYPES
(cr_sort_identifier cr_sort_identifier_1, cr_LABEL cr_LABEL_1, cr_annotation_list cr_annotation_list_1)
#else
(cr_sort_identifier_1, cr_LABEL_1, cr_annotation_list_1) cr_sort_identifier cr_sort_identifier_1;  cr_LABEL cr_LABEL_1;  cr_annotation_list cr_annotation_list_1; 
#endif
{	register cr_sort_declaration kc_x = (cr_sort_declaration) NONUNIQMALLOC((kc_size_t)sizeof(struct kc_tag_cr_sort_declaration));
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_CR_Sort_declaration));
	KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_CR_Sort_declaration));
	assert_cr_sort_identifier( cr_sort_identifier_1, "cr_sort_identifier_1" );
	assert_cr_LABEL( cr_LABEL_1, "cr_LABEL_1" );
	assert_cr_annotation_list( cr_annotation_list_1, "cr_annotation_list_1" );
	kc_x->prod_sel = sel_CR_Sort_declaration;
	kc_x->u.CR_Sort_declaration.cr_sort_identifier_1 = cr_sort_identifier_1;
	kc_x->u.CR_Sort_declaration.cr_LABEL_1 = cr_LABEL_1;
	kc_x->u.CR_Sort_declaration.cr_annotation_list_1 = cr_annotation_list_1;
	return kc_x;
}

cr_operation_replacement_list Nilcr_operation_replacement_list
#ifdef KC_USE_PROTOTYPES
()
#else
()
#endif
{	static cr_operation_replacement_list kc_x = (cr_operation_replacement_list)0;
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_Nilcr_operation_replacement_list));
	if (kc_x == (cr_operation_replacement_list)0) {
		KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_Nilcr_operation_replacement_list ));
		kc_x = (cr_operation_replacement_list)(*kc_hashtables[(int)kc_uniq_nullary_operator]->malloc)((kc_size_t)sizeof(struct kc_tag_cr_operation_replacement_list), kc_hashtables[(int)kc_uniq_nullary_operator]->malloc_private_data);
		kc_x->prod_sel = sel_Nilcr_operation_replacement_list;
	}
	return kc_x;
}

cr_operation_replacement_list Conscr_operation_replacement_list
#ifdef KC_USE_PROTOTYPES
(cr_operation_replacement cr_operation_replacement_1, cr_operation_replacement_list cr_operation_replacement_list_1)
#else
(cr_operation_replacement_1, cr_operation_replacement_list_1) cr_operation_replacement cr_operation_replacement_1;  cr_operation_replacement_list cr_operation_replacement_list_1; 
#endif
{	register cr_operation_replacement_list kc_x = (cr_operation_replacement_list) NONUNIQMALLOC((kc_size_t)sizeof(struct kc_tag_cr_operation_replacement_list));
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_Conscr_operation_replacement_list));
	KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_Conscr_operation_replacement_list));
	assert_cr_operation_replacement( cr_operation_replacement_1, "cr_operation_replacement_1" );
	assert_cr_operation_replacement_list( cr_operation_replacement_list_1, "cr_operation_replacement_list_1" );
	kc_x->prod_sel = sel_Conscr_operation_replacement_list;
	kc_x->u.Conscr_operation_replacement_list.cr_operation_replacement_1 = cr_operation_replacement_1;
	kc_x->u.Conscr_operation_replacement_list.cr_operation_replacement_list_1 = cr_operation_replacement_list_1;
	return kc_x;
}

cr_operation_replacement CR_Operation_replacement
#ifdef KC_USE_PROTOTYPES
(cr_operation_name cr_operation_name_1, cr_operation_name cr_operation_name_2, cr_LABEL cr_LABEL_1)
#else
(cr_operation_name_1, cr_operation_name_2, cr_LABEL_1) cr_operation_name cr_operation_name_1;  cr_operation_name cr_operation_name_2;  cr_LABEL cr_LABEL_1; 
#endif
{	register cr_operation_replacement kc_x = (cr_operation_replacement) NONUNIQMALLOC((kc_size_t)sizeof(struct kc_tag_cr_operation_replacement));
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_CR_Operation_replacement));
	KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_CR_Operation_replacement));
	assert_cr_operation_name( cr_operation_name_1, "cr_operation_name_1" );
	assert_cr_operation_name( cr_operation_name_2, "cr_operation_name_2" );
	assert_cr_LABEL( cr_LABEL_1, "cr_LABEL_1" );
	kc_x->prod_sel = sel_CR_Operation_replacement;
	kc_x->u.CR_Operation_replacement.cr_operation_name_1 = cr_operation_name_1;
	kc_x->u.CR_Operation_replacement.cr_operation_name_2 = cr_operation_name_2;
	kc_x->u.CR_Operation_replacement.cr_LABEL_1 = cr_LABEL_1;
	return kc_x;
}

cr_flattened_type_definition CR_Formal_type
#ifdef KC_USE_PROTOTYPES
(cr_type_identifier_list cr_type_identifier_list_1, cr_sort_declaration_list cr_sort_declaration_list_1, cr_operation_list cr_operation_list_1, cr_equations_option cr_equations_option_1, cr_sort_declaration_list cr_sort_declaration_list_2, cr_operation_list cr_operation_list_2, cr_equations_option cr_equations_option_2)
#else
(cr_type_identifier_list_1, cr_sort_declaration_list_1, cr_operation_list_1, cr_equations_option_1, cr_sort_declaration_list_2, cr_operation_list_2, cr_equations_option_2) cr_type_identifier_list cr_type_identifier_list_1;  cr_sort_declaration_list cr_sort_declaration_list_1;  cr_operation_list cr_operation_list_1;  cr_equations_option cr_equations_option_1;  cr_sort_declaration_list cr_sort_declaration_list_2;  cr_operation_list cr_operation_list_2;  cr_equations_option cr_equations_option_2; 
#endif
{	register cr_flattened_type_definition kc_x = (cr_flattened_type_definition) NONUNIQMALLOC((kc_size_t)sizeof(struct kc_tag_cr_flattened_type_definition));
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_CR_Formal_type));
	KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_CR_Formal_type));
	assert_cr_type_identifier_list( cr_type_identifier_list_1, "cr_type_identifier_list_1" );
	assert_cr_sort_declaration_list( cr_sort_declaration_list_1, "cr_sort_declaration_list_1" );
	assert_cr_operation_list( cr_operation_list_1, "cr_operation_list_1" );
	assert_cr_equations_option( cr_equations_option_1, "cr_equations_option_1" );
	assert_cr_sort_declaration_list( cr_sort_declaration_list_2, "cr_sort_declaration_list_2" );
	assert_cr_operation_list( cr_operation_list_2, "cr_operation_list_2" );
	assert_cr_equations_option( cr_equations_option_2, "cr_equations_option_2" );
	kc_x->prod_sel = sel_CR_Formal_type;
	kc_x->u.CR_Formal_type.cr_type_identifier_list_1 = cr_type_identifier_list_1;
	kc_x->u.CR_Formal_type.cr_sort_declaration_list_1 = cr_sort_declaration_list_1;
	kc_x->u.CR_Formal_type.cr_operation_list_1 = cr_operation_list_1;
	kc_x->u.CR_Formal_type.cr_equations_option_1 = cr_equations_option_1;
	kc_x->u.CR_Formal_type.cr_sort_declaration_list_2 = cr_sort_declaration_list_2;
	kc_x->u.CR_Formal_type.cr_operation_list_2 = cr_operation_list_2;
	kc_x->u.CR_Formal_type.cr_equations_option_2 = cr_equations_option_2;
	return kc_x;
}

cr_flattened_type_definition CR_Actual_type
#ifdef KC_USE_PROTOTYPES
(cr_type_identifier_list cr_type_identifier_list_1, cr_sort_declaration_list cr_sort_declaration_list_1, cr_operation_list cr_operation_list_1, cr_equations_option cr_equations_option_1)
#else
(cr_type_identifier_list_1, cr_sort_declaration_list_1, cr_operation_list_1, cr_equations_option_1) cr_type_identifier_list cr_type_identifier_list_1;  cr_sort_declaration_list cr_sort_declaration_list_1;  cr_operation_list cr_operation_list_1;  cr_equations_option cr_equations_option_1; 
#endif
{	register cr_flattened_type_definition kc_x = (cr_flattened_type_definition) NONUNIQMALLOC((kc_size_t)sizeof(struct kc_tag_cr_flattened_type_definition));
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_CR_Actual_type));
	KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_CR_Actual_type));
	assert_cr_type_identifier_list( cr_type_identifier_list_1, "cr_type_identifier_list_1" );
	assert_cr_sort_declaration_list( cr_sort_declaration_list_1, "cr_sort_declaration_list_1" );
	assert_cr_operation_list( cr_operation_list_1, "cr_operation_list_1" );
	assert_cr_equations_option( cr_equations_option_1, "cr_equations_option_1" );
	kc_x->prod_sel = sel_CR_Actual_type;
	kc_x->u.CR_Actual_type.cr_type_identifier_list_1 = cr_type_identifier_list_1;
	kc_x->u.CR_Actual_type.cr_sort_declaration_list_1 = cr_sort_declaration_list_1;
	kc_x->u.CR_Actual_type.cr_operation_list_1 = cr_operation_list_1;
	kc_x->u.CR_Actual_type.cr_equations_option_1 = cr_equations_option_1;
	return kc_x;
}

cr_operation_list Nilcr_operation_list
#ifdef KC_USE_PROTOTYPES
()
#else
()
#endif
{	static cr_operation_list kc_x = (cr_operation_list)0;
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_Nilcr_operation_list));
	if (kc_x == (cr_operation_list)0) {
		KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_Nilcr_operation_list ));
		kc_x = (cr_operation_list)(*kc_hashtables[(int)kc_uniq_nullary_operator]->malloc)((kc_size_t)sizeof(struct kc_tag_cr_operation_list), kc_hashtables[(int)kc_uniq_nullary_operator]->malloc_private_data);
		kc_x->prod_sel = sel_Nilcr_operation_list;
	}
	return kc_x;
}

cr_operation_list Conscr_operation_list
#ifdef KC_USE_PROTOTYPES
(cr_operation cr_operation_1, cr_operation_list cr_operation_list_1)
#else
(cr_operation_1, cr_operation_list_1) cr_operation cr_operation_1;  cr_operation_list cr_operation_list_1; 
#endif
{	register cr_operation_list kc_x = (cr_operation_list) NONUNIQMALLOC((kc_size_t)sizeof(struct kc_tag_cr_operation_list));
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_Conscr_operation_list));
	KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_Conscr_operation_list));
	assert_cr_operation( cr_operation_1, "cr_operation_1" );
	assert_cr_operation_list( cr_operation_list_1, "cr_operation_list_1" );
	kc_x->prod_sel = sel_Conscr_operation_list;
	kc_x->u.Conscr_operation_list.cr_operation_1 = cr_operation_1;
	kc_x->u.Conscr_operation_list.cr_operation_list_1 = cr_operation_list_1;
	return kc_x;
}

cr_operation CR_Operation
#ifdef KC_USE_PROTOTYPES
(cr_operation_identifier cr_operation_identifier_1, cr_prefix_infix cr_prefix_infix_1, cr_sort_identifier_list cr_sort_identifier_list_1, cr_sort_identifier cr_sort_identifier_1, cr_rewrite_strategy cr_rewrite_strategy_1, cr_operator_class cr_operator_class_1, cr_LABEL cr_LABEL_1, cr_annotation_list cr_annotation_list_1)
#else
(cr_operation_identifier_1, cr_prefix_infix_1, cr_sort_identifier_list_1, cr_sort_identifier_1, cr_rewrite_strategy_1, cr_operator_class_1, cr_LABEL_1, cr_annotation_list_1) cr_operation_identifier cr_operation_identifier_1;  cr_prefix_infix cr_prefix_infix_1;  cr_sort_identifier_list cr_sort_identifier_list_1;  cr_sort_identifier cr_sort_identifier_1;  cr_rewrite_strategy cr_rewrite_strategy_1;  cr_operator_class cr_operator_class_1;  cr_LABEL cr_LABEL_1;  cr_annotation_list cr_annotation_list_1; 
#endif
{	register cr_operation kc_x = (cr_operation) NONUNIQMALLOC((kc_size_t)sizeof(struct kc_tag_cr_operation));
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_CR_Operation));
	KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_CR_Operation));
	assert_cr_operation_identifier( cr_operation_identifier_1, "cr_operation_identifier_1" );
	assert_cr_prefix_infix( cr_prefix_infix_1, "cr_prefix_infix_1" );
	assert_cr_sort_identifier_list( cr_sort_identifier_list_1, "cr_sort_identifier_list_1" );
	assert_cr_sort_identifier( cr_sort_identifier_1, "cr_sort_identifier_1" );
	assert_cr_rewrite_strategy( cr_rewrite_strategy_1, "cr_rewrite_strategy_1" );
	assert_cr_operator_class( cr_operator_class_1, "cr_operator_class_1" );
	assert_cr_LABEL( cr_LABEL_1, "cr_LABEL_1" );
	assert_cr_annotation_list( cr_annotation_list_1, "cr_annotation_list_1" );
	kc_x->prod_sel = sel_CR_Operation;
	kc_x->u.CR_Operation.cr_operation_identifier_1 = cr_operation_identifier_1;
	kc_x->u.CR_Operation.cr_prefix_infix_1 = cr_prefix_infix_1;
	kc_x->u.CR_Operation.cr_sort_identifier_list_1 = cr_sort_identifier_list_1;
	kc_x->u.CR_Operation.cr_sort_identifier_1 = cr_sort_identifier_1;
	kc_x->u.CR_Operation.cr_rewrite_strategy_1 = cr_rewrite_strategy_1;
	kc_x->u.CR_Operation.cr_operator_class_1 = cr_operator_class_1;
	kc_x->u.CR_Operation.cr_LABEL_1 = cr_LABEL_1;
	kc_x->u.CR_Operation.cr_annotation_list_1 = cr_annotation_list_1;
	return kc_x;
}

cr_prefix_infix CR_Infix
#ifdef KC_USE_PROTOTYPES
()
#else
()
#endif
{	static cr_prefix_infix kc_x = (cr_prefix_infix)0;
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_CR_Infix));
	if (kc_x == (cr_prefix_infix)0) {
		KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_CR_Infix ));
		kc_x = (cr_prefix_infix)(*kc_hashtables[(int)kc_uniq_nullary_operator]->malloc)((kc_size_t)sizeof(struct kc_tag_cr_prefix_infix), kc_hashtables[(int)kc_uniq_nullary_operator]->malloc_private_data);
		kc_x->prod_sel = sel_CR_Infix;
	}
	return kc_x;
}

cr_prefix_infix CR_Prefix
#ifdef KC_USE_PROTOTYPES
()
#else
()
#endif
{	static cr_prefix_infix kc_x = (cr_prefix_infix)0;
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_CR_Prefix));
	if (kc_x == (cr_prefix_infix)0) {
		KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_CR_Prefix ));
		kc_x = (cr_prefix_infix)(*kc_hashtables[(int)kc_uniq_nullary_operator]->malloc)((kc_size_t)sizeof(struct kc_tag_cr_prefix_infix), kc_hashtables[(int)kc_uniq_nullary_operator]->malloc_private_data);
		kc_x->prod_sel = sel_CR_Prefix;
	}
	return kc_x;
}

cr_rewrite_strategy CR_Default
#ifdef KC_USE_PROTOTYPES
()
#else
()
#endif
{	static cr_rewrite_strategy kc_x = (cr_rewrite_strategy)0;
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_CR_Default));
	if (kc_x == (cr_rewrite_strategy)0) {
		KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_CR_Default ));
		kc_x = (cr_rewrite_strategy)(*kc_hashtables[(int)kc_uniq_nullary_operator]->malloc)((kc_size_t)sizeof(struct kc_tag_cr_rewrite_strategy), kc_hashtables[(int)kc_uniq_nullary_operator]->malloc_private_data);
		kc_x->prod_sel = sel_CR_Default;
	}
	return kc_x;
}

cr_rewrite_strategy CR_Leftmost_innermost
#ifdef KC_USE_PROTOTYPES
()
#else
()
#endif
{	static cr_rewrite_strategy kc_x = (cr_rewrite_strategy)0;
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_CR_Leftmost_innermost));
	if (kc_x == (cr_rewrite_strategy)0) {
		KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_CR_Leftmost_innermost ));
		kc_x = (cr_rewrite_strategy)(*kc_hashtables[(int)kc_uniq_nullary_operator]->malloc)((kc_size_t)sizeof(struct kc_tag_cr_rewrite_strategy), kc_hashtables[(int)kc_uniq_nullary_operator]->malloc_private_data);
		kc_x->prod_sel = sel_CR_Leftmost_innermost;
	}
	return kc_x;
}

cr_rewrite_strategy CR_Leftmost_outermost
#ifdef KC_USE_PROTOTYPES
()
#else
()
#endif
{	static cr_rewrite_strategy kc_x = (cr_rewrite_strategy)0;
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_CR_Leftmost_outermost));
	if (kc_x == (cr_rewrite_strategy)0) {
		KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_CR_Leftmost_outermost ));
		kc_x = (cr_rewrite_strategy)(*kc_hashtables[(int)kc_uniq_nullary_operator]->malloc)((kc_size_t)sizeof(struct kc_tag_cr_rewrite_strategy), kc_hashtables[(int)kc_uniq_nullary_operator]->malloc_private_data);
		kc_x->prod_sel = sel_CR_Leftmost_outermost;
	}
	return kc_x;
}

cr_rewrite_strategy CR_If_then_else
#ifdef KC_USE_PROTOTYPES
()
#else
()
#endif
{	static cr_rewrite_strategy kc_x = (cr_rewrite_strategy)0;
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_CR_If_then_else));
	if (kc_x == (cr_rewrite_strategy)0) {
		KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_CR_If_then_else ));
		kc_x = (cr_rewrite_strategy)(*kc_hashtables[(int)kc_uniq_nullary_operator]->malloc)((kc_size_t)sizeof(struct kc_tag_cr_rewrite_strategy), kc_hashtables[(int)kc_uniq_nullary_operator]->malloc_private_data);
		kc_x->prod_sel = sel_CR_If_then_else;
	}
	return kc_x;
}

cr_rewrite_strategy CR_Projection
#ifdef KC_USE_PROTOTYPES
()
#else
()
#endif
{	static cr_rewrite_strategy kc_x = (cr_rewrite_strategy)0;
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_CR_Projection));
	if (kc_x == (cr_rewrite_strategy)0) {
		KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_CR_Projection ));
		kc_x = (cr_rewrite_strategy)(*kc_hashtables[(int)kc_uniq_nullary_operator]->malloc)((kc_size_t)sizeof(struct kc_tag_cr_rewrite_strategy), kc_hashtables[(int)kc_uniq_nullary_operator]->malloc_private_data);
		kc_x->prod_sel = sel_CR_Projection;
	}
	return kc_x;
}

cr_operator_class CR_Unknown
#ifdef KC_USE_PROTOTYPES
()
#else
()
#endif
{	static cr_operator_class kc_x = (cr_operator_class)0;
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_CR_Unknown));
	if (kc_x == (cr_operator_class)0) {
		KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_CR_Unknown ));
		kc_x = (cr_operator_class)(*kc_hashtables[(int)kc_uniq_nullary_operator]->malloc)((kc_size_t)sizeof(struct kc_tag_cr_operator_class), kc_hashtables[(int)kc_uniq_nullary_operator]->malloc_private_data);
		kc_x->prod_sel = sel_CR_Unknown;
	}
	return kc_x;
}

cr_operator_class CR_Constructor
#ifdef KC_USE_PROTOTYPES
()
#else
()
#endif
{	static cr_operator_class kc_x = (cr_operator_class)0;
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_CR_Constructor));
	if (kc_x == (cr_operator_class)0) {
		KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_CR_Constructor ));
		kc_x = (cr_operator_class)(*kc_hashtables[(int)kc_uniq_nullary_operator]->malloc)((kc_size_t)sizeof(struct kc_tag_cr_operator_class), kc_hashtables[(int)kc_uniq_nullary_operator]->malloc_private_data);
		kc_x->prod_sel = sel_CR_Constructor;
	}
	return kc_x;
}

cr_operator_class CR_Derived
#ifdef KC_USE_PROTOTYPES
()
#else
()
#endif
{	static cr_operator_class kc_x = (cr_operator_class)0;
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_CR_Derived));
	if (kc_x == (cr_operator_class)0) {
		KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_CR_Derived ));
		kc_x = (cr_operator_class)(*kc_hashtables[(int)kc_uniq_nullary_operator]->malloc)((kc_size_t)sizeof(struct kc_tag_cr_operator_class), kc_hashtables[(int)kc_uniq_nullary_operator]->malloc_private_data);
		kc_x->prod_sel = sel_CR_Derived;
	}
	return kc_x;
}

cr_equations_option CR_NoEquations
#ifdef KC_USE_PROTOTYPES
()
#else
()
#endif
{	static cr_equations_option kc_x = (cr_equations_option)0;
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_CR_NoEquations));
	if (kc_x == (cr_equations_option)0) {
		KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_CR_NoEquations ));
		kc_x = (cr_equations_option)(*kc_hashtables[(int)kc_uniq_nullary_operator]->malloc)((kc_size_t)sizeof(struct kc_tag_cr_equations_option), kc_hashtables[(int)kc_uniq_nullary_operator]->malloc_private_data);
		kc_x->prod_sel = sel_CR_NoEquations;
	}
	return kc_x;
}

cr_equations_option CR_YesEquations
#ifdef KC_USE_PROTOTYPES
(cr_identifier_declaration_list cr_identifier_declaration_list_1, cr_equation_structure_list cr_equation_structure_list_1)
#else
(cr_identifier_declaration_list_1, cr_equation_structure_list_1) cr_identifier_declaration_list cr_identifier_declaration_list_1;  cr_equation_structure_list cr_equation_structure_list_1; 
#endif
{	register cr_equations_option kc_x = (cr_equations_option) NONUNIQMALLOC((kc_size_t)sizeof(struct kc_tag_cr_equations_option));
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_CR_YesEquations));
	KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_CR_YesEquations));
	assert_cr_identifier_declaration_list( cr_identifier_declaration_list_1, "cr_identifier_declaration_list_1" );
	assert_cr_equation_structure_list( cr_equation_structure_list_1, "cr_equation_structure_list_1" );
	kc_x->prod_sel = sel_CR_YesEquations;
	kc_x->u.CR_YesEquations.cr_identifier_declaration_list_1 = cr_identifier_declaration_list_1;
	kc_x->u.CR_YesEquations.cr_equation_structure_list_1 = cr_equation_structure_list_1;
	return kc_x;
}

cr_equation_structure_list Nilcr_equation_structure_list
#ifdef KC_USE_PROTOTYPES
()
#else
()
#endif
{	static cr_equation_structure_list kc_x = (cr_equation_structure_list)0;
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_Nilcr_equation_structure_list));
	if (kc_x == (cr_equation_structure_list)0) {
		KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_Nilcr_equation_structure_list ));
		kc_x = (cr_equation_structure_list)(*kc_hashtables[(int)kc_uniq_nullary_operator]->malloc)((kc_size_t)sizeof(struct kc_tag_cr_equation_structure_list), kc_hashtables[(int)kc_uniq_nullary_operator]->malloc_private_data);
		kc_x->prod_sel = sel_Nilcr_equation_structure_list;
	}
	return kc_x;
}

cr_equation_structure_list Conscr_equation_structure_list
#ifdef KC_USE_PROTOTYPES
(cr_equation_structure cr_equation_structure_1, cr_equation_structure_list cr_equation_structure_list_1)
#else
(cr_equation_structure_1, cr_equation_structure_list_1) cr_equation_structure cr_equation_structure_1;  cr_equation_structure_list cr_equation_structure_list_1; 
#endif
{	register cr_equation_structure_list kc_x = (cr_equation_structure_list) NONUNIQMALLOC((kc_size_t)sizeof(struct kc_tag_cr_equation_structure_list));
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_Conscr_equation_structure_list));
	KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_Conscr_equation_structure_list));
	assert_cr_equation_structure( cr_equation_structure_1, "cr_equation_structure_1" );
	assert_cr_equation_structure_list( cr_equation_structure_list_1, "cr_equation_structure_list_1" );
	kc_x->prod_sel = sel_Conscr_equation_structure_list;
	kc_x->u.Conscr_equation_structure_list.cr_equation_structure_1 = cr_equation_structure_1;
	kc_x->u.Conscr_equation_structure_list.cr_equation_structure_list_1 = cr_equation_structure_list_1;
	return kc_x;
}

cr_equation_structure CR_Equation_structure
#ifdef KC_USE_PROTOTYPES
(cr_sort_identifier cr_sort_identifier_1, cr_identifier_declaration_list cr_identifier_declaration_list_1, cr_equation_list cr_equation_list_1)
#else
(cr_sort_identifier_1, cr_identifier_declaration_list_1, cr_equation_list_1) cr_sort_identifier cr_sort_identifier_1;  cr_identifier_declaration_list cr_identifier_declaration_list_1;  cr_equation_list cr_equation_list_1; 
#endif
{	register cr_equation_structure kc_x = (cr_equation_structure) NONUNIQMALLOC((kc_size_t)sizeof(struct kc_tag_cr_equation_structure));
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_CR_Equation_structure));
	KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_CR_Equation_structure));
	assert_cr_sort_identifier( cr_sort_identifier_1, "cr_sort_identifier_1" );
	assert_cr_identifier_declaration_list( cr_identifier_declaration_list_1, "cr_identifier_declaration_list_1" );
	assert_cr_equation_list( cr_equation_list_1, "cr_equation_list_1" );
	kc_x->prod_sel = sel_CR_Equation_structure;
	kc_x->u.CR_Equation_structure.cr_sort_identifier_1 = cr_sort_identifier_1;
	kc_x->u.CR_Equation_structure.cr_identifier_declaration_list_1 = cr_identifier_declaration_list_1;
	kc_x->u.CR_Equation_structure.cr_equation_list_1 = cr_equation_list_1;
	return kc_x;
}

cr_equation_list Nilcr_equation_list
#ifdef KC_USE_PROTOTYPES
()
#else
()
#endif
{	static cr_equation_list kc_x = (cr_equation_list)0;
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_Nilcr_equation_list));
	if (kc_x == (cr_equation_list)0) {
		KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_Nilcr_equation_list ));
		kc_x = (cr_equation_list)(*kc_hashtables[(int)kc_uniq_nullary_operator]->malloc)((kc_size_t)sizeof(struct kc_tag_cr_equation_list), kc_hashtables[(int)kc_uniq_nullary_operator]->malloc_private_data);
		kc_x->prod_sel = sel_Nilcr_equation_list;
	}
	return kc_x;
}

cr_equation_list Conscr_equation_list
#ifdef KC_USE_PROTOTYPES
(cr_equation cr_equation_1, cr_equation_list cr_equation_list_1)
#else
(cr_equation_1, cr_equation_list_1) cr_equation cr_equation_1;  cr_equation_list cr_equation_list_1; 
#endif
{	register cr_equation_list kc_x = (cr_equation_list) NONUNIQMALLOC((kc_size_t)sizeof(struct kc_tag_cr_equation_list));
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_Conscr_equation_list));
	KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_Conscr_equation_list));
	assert_cr_equation( cr_equation_1, "cr_equation_1" );
	assert_cr_equation_list( cr_equation_list_1, "cr_equation_list_1" );
	kc_x->prod_sel = sel_Conscr_equation_list;
	kc_x->u.Conscr_equation_list.cr_equation_1 = cr_equation_1;
	kc_x->u.Conscr_equation_list.cr_equation_list_1 = cr_equation_list_1;
	return kc_x;
}

cr_equation CR_Equation
#ifdef KC_USE_PROTOTYPES
(cr_premiss_list cr_premiss_list_1, cr_equality cr_equality_1, cr_LABEL cr_LABEL_1)
#else
(cr_premiss_list_1, cr_equality_1, cr_LABEL_1) cr_premiss_list cr_premiss_list_1;  cr_equality cr_equality_1;  cr_LABEL cr_LABEL_1; 
#endif
{	register cr_equation kc_x = (cr_equation) NONUNIQMALLOC((kc_size_t)sizeof(struct kc_tag_cr_equation));
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_CR_Equation));
	KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_CR_Equation));
	assert_cr_premiss_list( cr_premiss_list_1, "cr_premiss_list_1" );
	assert_cr_equality( cr_equality_1, "cr_equality_1" );
	assert_cr_LABEL( cr_LABEL_1, "cr_LABEL_1" );
	kc_x->prod_sel = sel_CR_Equation;
	kc_x->u.CR_Equation.cr_premiss_list_1 = cr_premiss_list_1;
	kc_x->u.CR_Equation.cr_equality_1 = cr_equality_1;
	kc_x->u.CR_Equation.cr_LABEL_1 = cr_LABEL_1;
	return kc_x;
}

cr_premiss_list Nilcr_premiss_list
#ifdef KC_USE_PROTOTYPES
()
#else
()
#endif
{	static cr_premiss_list kc_x = (cr_premiss_list)0;
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_Nilcr_premiss_list));
	if (kc_x == (cr_premiss_list)0) {
		KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_Nilcr_premiss_list ));
		kc_x = (cr_premiss_list)(*kc_hashtables[(int)kc_uniq_nullary_operator]->malloc)((kc_size_t)sizeof(struct kc_tag_cr_premiss_list), kc_hashtables[(int)kc_uniq_nullary_operator]->malloc_private_data);
		kc_x->prod_sel = sel_Nilcr_premiss_list;
	}
	return kc_x;
}

cr_premiss_list Conscr_premiss_list
#ifdef KC_USE_PROTOTYPES
(cr_equality cr_equality_1, cr_premiss_list cr_premiss_list_1)
#else
(cr_equality_1, cr_premiss_list_1) cr_equality cr_equality_1;  cr_premiss_list cr_premiss_list_1; 
#endif
{	register cr_premiss_list kc_x = (cr_premiss_list) NONUNIQMALLOC((kc_size_t)sizeof(struct kc_tag_cr_premiss_list));
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_Conscr_premiss_list));
	KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_Conscr_premiss_list));
	assert_cr_equality( cr_equality_1, "cr_equality_1" );
	assert_cr_premiss_list( cr_premiss_list_1, "cr_premiss_list_1" );
	kc_x->prod_sel = sel_Conscr_premiss_list;
	kc_x->u.Conscr_premiss_list.cr_equality_1 = cr_equality_1;
	kc_x->u.Conscr_premiss_list.cr_premiss_list_1 = cr_premiss_list_1;
	return kc_x;
}

cr_equality CR_Equals
#ifdef KC_USE_PROTOTYPES
(cr_value_expression cr_value_expression_1, cr_value_expression cr_value_expression_2)
#else
(cr_value_expression_1, cr_value_expression_2) cr_value_expression cr_value_expression_1;  cr_value_expression cr_value_expression_2; 
#endif
{	register cr_equality kc_x;
	int kc_i;
	register kc_hashtableentry_t* kc_hte;
	unsigned kc_hashval = (unsigned)0;
	YYSTYPE *kc_ptr, *kc_beyond;
	kc_hashtable_t kc_a_ht = kc_hashtables[(int)uniq];

	assert_cr_value_expression( cr_value_expression_1, "cr_value_expression_1" );
	assert_cr_value_expression( cr_value_expression_2, "cr_value_expression_2" );
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_CR_Equals));
	OPERATORHASH((unsigned) sel_CR_Equals);
	HASH(cr_value_expression_1);
	HASH(cr_value_expression_2);
	kc_hashval = kc_hashval%kc_a_ht->size;
	for (kc_i=0; kc_i < (int)kc_last_storage_mode; kc_i++) {
		kc_hte = &(kc_a_ht->hashtable[kc_hashval][kc_i]);
		if (kc_hte->nr != 0) {
			kc_beyond = &kc_hte->index[kc_hte->nr];
			for (kc_ptr = &kc_hte->index[0]; kc_ptr < kc_beyond; kc_ptr++){
				kc_x= kc_ptr->yt_cr_equality;
				if ((kc_x->prod_sel == sel_CR_Equals)  && (kc_x->u.CR_Equals.cr_value_expression_1 == cr_value_expression_1) && (kc_x->u.CR_Equals.cr_value_expression_2 == cr_value_expression_2) )
					return(kc_x);
	}	}	}
	KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_CR_Equals));
	kc_hte = &(kc_a_ht->hashtable[kc_hashval][(int)kc_a_ht->mode]);
	if (kc_hte->nr >= kc_hte->ibound) kc_growindex(kc_hte, kc_a_ht);
	kc_x = (cr_equality)(*kc_a_ht->malloc)((kc_size_t)sizeof(struct kc_tag_cr_equality), kc_a_ht->malloc_private_data);
	kc_x->prod_sel = sel_CR_Equals;
	kc_x->u.CR_Equals.cr_value_expression_1 = cr_value_expression_1;
	kc_x->u.CR_Equals.cr_value_expression_2 = cr_value_expression_2;
	kc_hte->index[kc_hte->nr++].yt_cr_equality = kc_x;
	return kc_x;
}

cr_identifier_declaration_list Nilcr_identifier_declaration_list
#ifdef KC_USE_PROTOTYPES
()
#else
()
#endif
{	static cr_identifier_declaration_list kc_x = (cr_identifier_declaration_list)0;
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_Nilcr_identifier_declaration_list));
	if (kc_x == (cr_identifier_declaration_list)0) {
		KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_Nilcr_identifier_declaration_list ));
		kc_x = (cr_identifier_declaration_list)(*kc_hashtables[(int)kc_uniq_nullary_operator]->malloc)((kc_size_t)sizeof(struct kc_tag_cr_identifier_declaration_list), kc_hashtables[(int)kc_uniq_nullary_operator]->malloc_private_data);
		kc_x->prod_sel = sel_Nilcr_identifier_declaration_list;
	}
	return kc_x;
}

cr_identifier_declaration_list Conscr_identifier_declaration_list
#ifdef KC_USE_PROTOTYPES
(cr_identifier_declaration cr_identifier_declaration_1, cr_identifier_declaration_list cr_identifier_declaration_list_1)
#else
(cr_identifier_declaration_1, cr_identifier_declaration_list_1) cr_identifier_declaration cr_identifier_declaration_1;  cr_identifier_declaration_list cr_identifier_declaration_list_1; 
#endif
{	register cr_identifier_declaration_list kc_x;
	int kc_i;
	register kc_hashtableentry_t* kc_hte;
	unsigned kc_hashval = (unsigned)0;
	YYSTYPE *kc_ptr, *kc_beyond;
	kc_hashtable_t kc_a_ht = kc_hashtables[(int)uniq];

	assert_cr_identifier_declaration( cr_identifier_declaration_1, "cr_identifier_declaration_1" );
	assert_cr_identifier_declaration_list( cr_identifier_declaration_list_1, "cr_identifier_declaration_list_1" );
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_Conscr_identifier_declaration_list));
	OPERATORHASH((unsigned) sel_Conscr_identifier_declaration_list);
	HASH(cr_identifier_declaration_1);
	HASH(cr_identifier_declaration_list_1);
	kc_hashval = kc_hashval%kc_a_ht->size;
	for (kc_i=0; kc_i < (int)kc_last_storage_mode; kc_i++) {
		kc_hte = &(kc_a_ht->hashtable[kc_hashval][kc_i]);
		if (kc_hte->nr != 0) {
			kc_beyond = &kc_hte->index[kc_hte->nr];
			for (kc_ptr = &kc_hte->index[0]; kc_ptr < kc_beyond; kc_ptr++){
				kc_x= kc_ptr->yt_cr_identifier_declaration_list;
				if ((kc_x->prod_sel == sel_Conscr_identifier_declaration_list)  && (kc_x->u.Conscr_identifier_declaration_list.cr_identifier_declaration_1 == cr_identifier_declaration_1) && (kc_x->u.Conscr_identifier_declaration_list.cr_identifier_declaration_list_1 == cr_identifier_declaration_list_1) )
					return(kc_x);
	}	}	}
	KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_Conscr_identifier_declaration_list));
	kc_hte = &(kc_a_ht->hashtable[kc_hashval][(int)kc_a_ht->mode]);
	if (kc_hte->nr >= kc_hte->ibound) kc_growindex(kc_hte, kc_a_ht);
	kc_x = (cr_identifier_declaration_list)(*kc_a_ht->malloc)((kc_size_t)sizeof(struct kc_tag_cr_identifier_declaration_list), kc_a_ht->malloc_private_data);
	kc_x->prod_sel = sel_Conscr_identifier_declaration_list;
	kc_x->u.Conscr_identifier_declaration_list.cr_identifier_declaration_1 = cr_identifier_declaration_1;
	kc_x->u.Conscr_identifier_declaration_list.cr_identifier_declaration_list_1 = cr_identifier_declaration_list_1;
	kc_hte->index[kc_hte->nr++].yt_cr_identifier_declaration_list = kc_x;
	return kc_x;
}

cr_identifier_declaration CR_Identifier_declaration
#ifdef KC_USE_PROTOTYPES
(cr_value_identifier_list cr_value_identifier_list_1, cr_sort_identifier cr_sort_identifier_1)
#else
(cr_value_identifier_list_1, cr_sort_identifier_1) cr_value_identifier_list cr_value_identifier_list_1;  cr_sort_identifier cr_sort_identifier_1; 
#endif
{	register cr_identifier_declaration kc_x;
	int kc_i;
	register kc_hashtableentry_t* kc_hte;
	unsigned kc_hashval = (unsigned)0;
	YYSTYPE *kc_ptr, *kc_beyond;
	kc_hashtable_t kc_a_ht = kc_hashtables[(int)uniq];

	assert_cr_value_identifier_list( cr_value_identifier_list_1, "cr_value_identifier_list_1" );
	assert_cr_sort_identifier( cr_sort_identifier_1, "cr_sort_identifier_1" );
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_CR_Identifier_declaration));
	OPERATORHASH((unsigned) sel_CR_Identifier_declaration);
	HASH(cr_value_identifier_list_1);
	HASH(cr_sort_identifier_1);
	kc_hashval = kc_hashval%kc_a_ht->size;
	for (kc_i=0; kc_i < (int)kc_last_storage_mode; kc_i++) {
		kc_hte = &(kc_a_ht->hashtable[kc_hashval][kc_i]);
		if (kc_hte->nr != 0) {
			kc_beyond = &kc_hte->index[kc_hte->nr];
			for (kc_ptr = &kc_hte->index[0]; kc_ptr < kc_beyond; kc_ptr++){
				kc_x= kc_ptr->yt_cr_identifier_declaration;
				if ((kc_x->prod_sel == sel_CR_Identifier_declaration)  && (kc_x->u.CR_Identifier_declaration.cr_value_identifier_list_1 == cr_value_identifier_list_1) && (kc_x->u.CR_Identifier_declaration.cr_sort_identifier_1 == cr_sort_identifier_1) )
					return(kc_x);
	}	}	}
	KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_CR_Identifier_declaration));
	kc_hte = &(kc_a_ht->hashtable[kc_hashval][(int)kc_a_ht->mode]);
	if (kc_hte->nr >= kc_hte->ibound) kc_growindex(kc_hte, kc_a_ht);
	kc_x = (cr_identifier_declaration)(*kc_a_ht->malloc)((kc_size_t)sizeof(struct kc_tag_cr_identifier_declaration), kc_a_ht->malloc_private_data);
	kc_x->prod_sel = sel_CR_Identifier_declaration;
	kc_x->u.CR_Identifier_declaration.cr_value_identifier_list_1 = cr_value_identifier_list_1;
	kc_x->u.CR_Identifier_declaration.cr_sort_identifier_1 = cr_sort_identifier_1;
	kc_hte->index[kc_hte->nr++].yt_cr_identifier_declaration = kc_x;
	return kc_x;
}

cr_value_identifier_list Nilcr_value_identifier_list
#ifdef KC_USE_PROTOTYPES
()
#else
()
#endif
{	static cr_value_identifier_list kc_x = (cr_value_identifier_list)0;
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_Nilcr_value_identifier_list));
	if (kc_x == (cr_value_identifier_list)0) {
		KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_Nilcr_value_identifier_list ));
		kc_x = (cr_value_identifier_list)(*kc_hashtables[(int)kc_uniq_nullary_operator]->malloc)((kc_size_t)sizeof(struct kc_tag_cr_value_identifier_list), kc_hashtables[(int)kc_uniq_nullary_operator]->malloc_private_data);
		kc_x->prod_sel = sel_Nilcr_value_identifier_list;
	}
	return kc_x;
}

cr_value_identifier_list Conscr_value_identifier_list
#ifdef KC_USE_PROTOTYPES
(cr_annotated_value_identifier cr_annotated_value_identifier_1, cr_value_identifier_list cr_value_identifier_list_1)
#else
(cr_annotated_value_identifier_1, cr_value_identifier_list_1) cr_annotated_value_identifier cr_annotated_value_identifier_1;  cr_value_identifier_list cr_value_identifier_list_1; 
#endif
{	register cr_value_identifier_list kc_x;
	int kc_i;
	register kc_hashtableentry_t* kc_hte;
	unsigned kc_hashval = (unsigned)0;
	YYSTYPE *kc_ptr, *kc_beyond;
	kc_hashtable_t kc_a_ht = kc_hashtables[(int)uniq];

	assert_cr_annotated_value_identifier( cr_annotated_value_identifier_1, "cr_annotated_value_identifier_1" );
	assert_cr_value_identifier_list( cr_value_identifier_list_1, "cr_value_identifier_list_1" );
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_Conscr_value_identifier_list));
	OPERATORHASH((unsigned) sel_Conscr_value_identifier_list);
	HASH(cr_annotated_value_identifier_1);
	HASH(cr_value_identifier_list_1);
	kc_hashval = kc_hashval%kc_a_ht->size;
	for (kc_i=0; kc_i < (int)kc_last_storage_mode; kc_i++) {
		kc_hte = &(kc_a_ht->hashtable[kc_hashval][kc_i]);
		if (kc_hte->nr != 0) {
			kc_beyond = &kc_hte->index[kc_hte->nr];
			for (kc_ptr = &kc_hte->index[0]; kc_ptr < kc_beyond; kc_ptr++){
				kc_x= kc_ptr->yt_cr_value_identifier_list;
				if ((kc_x->prod_sel == sel_Conscr_value_identifier_list)  && (kc_x->u.Conscr_value_identifier_list.cr_annotated_value_identifier_1 == cr_annotated_value_identifier_1) && (kc_x->u.Conscr_value_identifier_list.cr_value_identifier_list_1 == cr_value_identifier_list_1) )
					return(kc_x);
	}	}	}
	KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_Conscr_value_identifier_list));
	kc_hte = &(kc_a_ht->hashtable[kc_hashval][(int)kc_a_ht->mode]);
	if (kc_hte->nr >= kc_hte->ibound) kc_growindex(kc_hte, kc_a_ht);
	kc_x = (cr_value_identifier_list)(*kc_a_ht->malloc)((kc_size_t)sizeof(struct kc_tag_cr_value_identifier_list), kc_a_ht->malloc_private_data);
	kc_x->prod_sel = sel_Conscr_value_identifier_list;
	kc_x->u.Conscr_value_identifier_list.cr_annotated_value_identifier_1 = cr_annotated_value_identifier_1;
	kc_x->u.Conscr_value_identifier_list.cr_value_identifier_list_1 = cr_value_identifier_list_1;
	kc_hte->index[kc_hte->nr++].yt_cr_value_identifier_list = kc_x;
	return kc_x;
}

cr_annotated_value_identifier CR_annotated_val_id
#ifdef KC_USE_PROTOTYPES
(cr_value_identifier cr_value_identifier_1, cr_annotation_list cr_annotation_list_1)
#else
(cr_value_identifier_1, cr_annotation_list_1) cr_value_identifier cr_value_identifier_1;  cr_annotation_list cr_annotation_list_1; 
#endif
{	register cr_annotated_value_identifier kc_x;
	int kc_i;
	register kc_hashtableentry_t* kc_hte;
	unsigned kc_hashval = (unsigned)0;
	YYSTYPE *kc_ptr, *kc_beyond;
	kc_hashtable_t kc_a_ht = kc_hashtables[(int)uniq];

	assert_cr_value_identifier( cr_value_identifier_1, "cr_value_identifier_1" );
	assert_cr_annotation_list( cr_annotation_list_1, "cr_annotation_list_1" );
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_CR_annotated_val_id));
	OPERATORHASH((unsigned) sel_CR_annotated_val_id);
	HASH(cr_value_identifier_1);
	HASH(cr_annotation_list_1);
	kc_hashval = kc_hashval%kc_a_ht->size;
	for (kc_i=0; kc_i < (int)kc_last_storage_mode; kc_i++) {
		kc_hte = &(kc_a_ht->hashtable[kc_hashval][kc_i]);
		if (kc_hte->nr != 0) {
			kc_beyond = &kc_hte->index[kc_hte->nr];
			for (kc_ptr = &kc_hte->index[0]; kc_ptr < kc_beyond; kc_ptr++){
				kc_x= kc_ptr->yt_cr_annotated_value_identifier;
				if ((kc_x->prod_sel == sel_CR_annotated_val_id)  && (kc_x->u.CR_annotated_val_id.cr_value_identifier_1 == cr_value_identifier_1) && (kc_x->u.CR_annotated_val_id.cr_annotation_list_1 == cr_annotation_list_1) )
					return(kc_x);
	}	}	}
	KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_CR_annotated_val_id));
	kc_hte = &(kc_a_ht->hashtable[kc_hashval][(int)kc_a_ht->mode]);
	if (kc_hte->nr >= kc_hte->ibound) kc_growindex(kc_hte, kc_a_ht);
	kc_x = (cr_annotated_value_identifier)(*kc_a_ht->malloc)((kc_size_t)sizeof(struct kc_tag_cr_annotated_value_identifier), kc_a_ht->malloc_private_data);
	kc_x->prod_sel = sel_CR_annotated_val_id;
	kc_x->u.CR_annotated_val_id.cr_value_identifier_1 = cr_value_identifier_1;
	kc_x->u.CR_annotated_val_id.cr_annotation_list_1 = cr_annotation_list_1;
	kc_hte->index[kc_hte->nr++].yt_cr_annotated_value_identifier = kc_x;
	return kc_x;
}

cr_behaviour_expression CR_Stop_expression
#ifdef KC_USE_PROTOTYPES
(cr_LABEL cr_LABEL_1, cr_annotation_list cr_annotation_list_1)
#else
(cr_LABEL_1, cr_annotation_list_1) cr_LABEL cr_LABEL_1;  cr_annotation_list cr_annotation_list_1; 
#endif
{	register cr_behaviour_expression kc_x;
	int kc_i;
	register kc_hashtableentry_t* kc_hte;
	unsigned kc_hashval = (unsigned)0;
	YYSTYPE *kc_ptr, *kc_beyond;
	kc_hashtable_t kc_a_ht = kc_hashtables[(int)uniq];

	assert_cr_LABEL( cr_LABEL_1, "cr_LABEL_1" );
	assert_cr_annotation_list( cr_annotation_list_1, "cr_annotation_list_1" );
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_CR_Stop_expression));
	OPERATORHASH((unsigned) sel_CR_Stop_expression);
	HASH(cr_LABEL_1);
	HASH(cr_annotation_list_1);
	kc_hashval = kc_hashval%kc_a_ht->size;
	for (kc_i=0; kc_i < (int)kc_last_storage_mode; kc_i++) {
		kc_hte = &(kc_a_ht->hashtable[kc_hashval][kc_i]);
		if (kc_hte->nr != 0) {
			kc_beyond = &kc_hte->index[kc_hte->nr];
			for (kc_ptr = &kc_hte->index[0]; kc_ptr < kc_beyond; kc_ptr++){
				kc_x= kc_ptr->yt_cr_behaviour_expression;
				if ((kc_x->prod_sel == sel_CR_Stop_expression)  && (kc_x->u.CR_Stop_expression.cr_LABEL_1 == cr_LABEL_1) && (kc_x->u.CR_Stop_expression.cr_annotation_list_1 == cr_annotation_list_1) )
					return(kc_x);
	}	}	}
	KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_CR_Stop_expression));
	kc_hte = &(kc_a_ht->hashtable[kc_hashval][(int)kc_a_ht->mode]);
	if (kc_hte->nr >= kc_hte->ibound) kc_growindex(kc_hte, kc_a_ht);
	kc_x = (cr_behaviour_expression)(*kc_a_ht->malloc)((kc_size_t)sizeof(struct kc_tag_cr_behaviour_expression), kc_a_ht->malloc_private_data);
	kc_x->prod_sel = sel_CR_Stop_expression;
	kc_x->u.CR_Stop_expression.cr_LABEL_1 = cr_LABEL_1;
	kc_x->u.CR_Stop_expression.cr_annotation_list_1 = cr_annotation_list_1;
	kc_hte->index[kc_hte->nr++].yt_cr_behaviour_expression = kc_x;
	return kc_x;
}

cr_behaviour_expression CR_Exit_expression
#ifdef KC_USE_PROTOTYPES
(cr_exit_entry_list cr_exit_entry_list_1, cr_LABEL cr_LABEL_1, cr_annotation_list cr_annotation_list_1)
#else
(cr_exit_entry_list_1, cr_LABEL_1, cr_annotation_list_1) cr_exit_entry_list cr_exit_entry_list_1;  cr_LABEL cr_LABEL_1;  cr_annotation_list cr_annotation_list_1; 
#endif
{	register cr_behaviour_expression kc_x;
	int kc_i;
	register kc_hashtableentry_t* kc_hte;
	unsigned kc_hashval = (unsigned)0;
	YYSTYPE *kc_ptr, *kc_beyond;
	kc_hashtable_t kc_a_ht = kc_hashtables[(int)uniq];

	assert_cr_exit_entry_list( cr_exit_entry_list_1, "cr_exit_entry_list_1" );
	assert_cr_LABEL( cr_LABEL_1, "cr_LABEL_1" );
	assert_cr_annotation_list( cr_annotation_list_1, "cr_annotation_list_1" );
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_CR_Exit_expression));
	OPERATORHASH((unsigned) sel_CR_Exit_expression);
	HASH(cr_exit_entry_list_1);
	HASH(cr_LABEL_1);
	HASH(cr_annotation_list_1);
	kc_hashval = kc_hashval%kc_a_ht->size;
	for (kc_i=0; kc_i < (int)kc_last_storage_mode; kc_i++) {
		kc_hte = &(kc_a_ht->hashtable[kc_hashval][kc_i]);
		if (kc_hte->nr != 0) {
			kc_beyond = &kc_hte->index[kc_hte->nr];
			for (kc_ptr = &kc_hte->index[0]; kc_ptr < kc_beyond; kc_ptr++){
				kc_x= kc_ptr->yt_cr_behaviour_expression;
				if ((kc_x->prod_sel == sel_CR_Exit_expression)  && (kc_x->u.CR_Exit_expression.cr_exit_entry_list_1 == cr_exit_entry_list_1) && (kc_x->u.CR_Exit_expression.cr_LABEL_1 == cr_LABEL_1) && (kc_x->u.CR_Exit_expression.cr_annotation_list_1 == cr_annotation_list_1) )
					return(kc_x);
	}	}	}
	KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_CR_Exit_expression));
	kc_hte = &(kc_a_ht->hashtable[kc_hashval][(int)kc_a_ht->mode]);
	if (kc_hte->nr >= kc_hte->ibound) kc_growindex(kc_hte, kc_a_ht);
	kc_x = (cr_behaviour_expression)(*kc_a_ht->malloc)((kc_size_t)sizeof(struct kc_tag_cr_behaviour_expression), kc_a_ht->malloc_private_data);
	kc_x->prod_sel = sel_CR_Exit_expression;
	kc_x->u.CR_Exit_expression.cr_exit_entry_list_1 = cr_exit_entry_list_1;
	kc_x->u.CR_Exit_expression.cr_LABEL_1 = cr_LABEL_1;
	kc_x->u.CR_Exit_expression.cr_annotation_list_1 = cr_annotation_list_1;
	kc_hte->index[kc_hte->nr++].yt_cr_behaviour_expression = kc_x;
	return kc_x;
}

cr_behaviour_expression CR_Process_instantiation
#ifdef KC_USE_PROTOTYPES
(cr_process_identifier cr_process_identifier_1, cr_gate_identifier_list cr_gate_identifier_list_1, cr_value_expression_list cr_value_expression_list_1, cr_LABEL cr_LABEL_1, cr_annotation_list cr_annotation_list_1)
#else
(cr_process_identifier_1, cr_gate_identifier_list_1, cr_value_expression_list_1, cr_LABEL_1, cr_annotation_list_1) cr_process_identifier cr_process_identifier_1;  cr_gate_identifier_list cr_gate_identifier_list_1;  cr_value_expression_list cr_value_expression_list_1;  cr_LABEL cr_LABEL_1;  cr_annotation_list cr_annotation_list_1; 
#endif
{	register cr_behaviour_expression kc_x;
	int kc_i;
	register kc_hashtableentry_t* kc_hte;
	unsigned kc_hashval = (unsigned)0;
	YYSTYPE *kc_ptr, *kc_beyond;
	kc_hashtable_t kc_a_ht = kc_hashtables[(int)uniq];

	assert_cr_process_identifier( cr_process_identifier_1, "cr_process_identifier_1" );
	assert_cr_gate_identifier_list( cr_gate_identifier_list_1, "cr_gate_identifier_list_1" );
	assert_cr_value_expression_list( cr_value_expression_list_1, "cr_value_expression_list_1" );
	assert_cr_LABEL( cr_LABEL_1, "cr_LABEL_1" );
	assert_cr_annotation_list( cr_annotation_list_1, "cr_annotation_list_1" );
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_CR_Process_instantiation));
	OPERATORHASH((unsigned) sel_CR_Process_instantiation);
	HASH(cr_process_identifier_1);
	HASH(cr_gate_identifier_list_1);
	HASH(cr_value_expression_list_1);
	HASH(cr_LABEL_1);
	HASH(cr_annotation_list_1);
	kc_hashval = kc_hashval%kc_a_ht->size;
	for (kc_i=0; kc_i < (int)kc_last_storage_mode; kc_i++) {
		kc_hte = &(kc_a_ht->hashtable[kc_hashval][kc_i]);
		if (kc_hte->nr != 0) {
			kc_beyond = &kc_hte->index[kc_hte->nr];
			for (kc_ptr = &kc_hte->index[0]; kc_ptr < kc_beyond; kc_ptr++){
				kc_x= kc_ptr->yt_cr_behaviour_expression;
				if ((kc_x->prod_sel == sel_CR_Process_instantiation)  && (kc_x->u.CR_Process_instantiation.cr_process_identifier_1 == cr_process_identifier_1) && (kc_x->u.CR_Process_instantiation.cr_gate_identifier_list_1 == cr_gate_identifier_list_1) && (kc_x->u.CR_Process_instantiation.cr_value_expression_list_1 == cr_value_expression_list_1) && (kc_x->u.CR_Process_instantiation.cr_LABEL_1 == cr_LABEL_1) && (kc_x->u.CR_Process_instantiation.cr_annotation_list_1 == cr_annotation_list_1) )
					return(kc_x);
	}	}	}
	KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_CR_Process_instantiation));
	kc_hte = &(kc_a_ht->hashtable[kc_hashval][(int)kc_a_ht->mode]);
	if (kc_hte->nr >= kc_hte->ibound) kc_growindex(kc_hte, kc_a_ht);
	kc_x = (cr_behaviour_expression)(*kc_a_ht->malloc)((kc_size_t)sizeof(struct kc_tag_cr_behaviour_expression), kc_a_ht->malloc_private_data);
	kc_x->prod_sel = sel_CR_Process_instantiation;
	kc_x->u.CR_Process_instantiation.cr_process_identifier_1 = cr_process_identifier_1;
	kc_x->u.CR_Process_instantiation.cr_gate_identifier_list_1 = cr_gate_identifier_list_1;
	kc_x->u.CR_Process_instantiation.cr_value_expression_list_1 = cr_value_expression_list_1;
	kc_x->u.CR_Process_instantiation.cr_LABEL_1 = cr_LABEL_1;
	kc_x->u.CR_Process_instantiation.cr_annotation_list_1 = cr_annotation_list_1;
	kc_hte->index[kc_hte->nr++].yt_cr_behaviour_expression = kc_x;
	return kc_x;
}

cr_behaviour_expression CR_Action_prefix_expression
#ifdef KC_USE_PROTOTYPES
(cr_action_denotation cr_action_denotation_1, cr_behaviour_expression cr_behaviour_expression_1, cr_LABEL cr_LABEL_1, cr_annotation_list cr_annotation_list_1)
#else
(cr_action_denotation_1, cr_behaviour_expression_1, cr_LABEL_1, cr_annotation_list_1) cr_action_denotation cr_action_denotation_1;  cr_behaviour_expression cr_behaviour_expression_1;  cr_LABEL cr_LABEL_1;  cr_annotation_list cr_annotation_list_1; 
#endif
{	register cr_behaviour_expression kc_x;
	int kc_i;
	register kc_hashtableentry_t* kc_hte;
	unsigned kc_hashval = (unsigned)0;
	YYSTYPE *kc_ptr, *kc_beyond;
	kc_hashtable_t kc_a_ht = kc_hashtables[(int)uniq];

	assert_cr_action_denotation( cr_action_denotation_1, "cr_action_denotation_1" );
	assert_cr_behaviour_expression( cr_behaviour_expression_1, "cr_behaviour_expression_1" );
	assert_cr_LABEL( cr_LABEL_1, "cr_LABEL_1" );
	assert_cr_annotation_list( cr_annotation_list_1, "cr_annotation_list_1" );
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_CR_Action_prefix_expression));
	OPERATORHASH((unsigned) sel_CR_Action_prefix_expression);
	HASH(cr_action_denotation_1);
	HASH(cr_behaviour_expression_1);
	HASH(cr_LABEL_1);
	HASH(cr_annotation_list_1);
	kc_hashval = kc_hashval%kc_a_ht->size;
	for (kc_i=0; kc_i < (int)kc_last_storage_mode; kc_i++) {
		kc_hte = &(kc_a_ht->hashtable[kc_hashval][kc_i]);
		if (kc_hte->nr != 0) {
			kc_beyond = &kc_hte->index[kc_hte->nr];
			for (kc_ptr = &kc_hte->index[0]; kc_ptr < kc_beyond; kc_ptr++){
				kc_x= kc_ptr->yt_cr_behaviour_expression;
				if ((kc_x->prod_sel == sel_CR_Action_prefix_expression)  && (kc_x->u.CR_Action_prefix_expression.cr_action_denotation_1 == cr_action_denotation_1) && (kc_x->u.CR_Action_prefix_expression.cr_behaviour_expression_1 == cr_behaviour_expression_1) && (kc_x->u.CR_Action_prefix_expression.cr_LABEL_1 == cr_LABEL_1) && (kc_x->u.CR_Action_prefix_expression.cr_annotation_list_1 == cr_annotation_list_1) )
					return(kc_x);
	}	}	}
	KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_CR_Action_prefix_expression));
	kc_hte = &(kc_a_ht->hashtable[kc_hashval][(int)kc_a_ht->mode]);
	if (kc_hte->nr >= kc_hte->ibound) kc_growindex(kc_hte, kc_a_ht);
	kc_x = (cr_behaviour_expression)(*kc_a_ht->malloc)((kc_size_t)sizeof(struct kc_tag_cr_behaviour_expression), kc_a_ht->malloc_private_data);
	kc_x->prod_sel = sel_CR_Action_prefix_expression;
	kc_x->u.CR_Action_prefix_expression.cr_action_denotation_1 = cr_action_denotation_1;
	kc_x->u.CR_Action_prefix_expression.cr_behaviour_expression_1 = cr_behaviour_expression_1;
	kc_x->u.CR_Action_prefix_expression.cr_LABEL_1 = cr_LABEL_1;
	kc_x->u.CR_Action_prefix_expression.cr_annotation_list_1 = cr_annotation_list_1;
	kc_hte->index[kc_hte->nr++].yt_cr_behaviour_expression = kc_x;
	return kc_x;
}

cr_behaviour_expression CR_Local_definition_expression
#ifdef KC_USE_PROTOTYPES
(cr_identifier_equation_list cr_identifier_equation_list_1, cr_behaviour_expression cr_behaviour_expression_1)
#else
(cr_identifier_equation_list_1, cr_behaviour_expression_1) cr_identifier_equation_list cr_identifier_equation_list_1;  cr_behaviour_expression cr_behaviour_expression_1; 
#endif
{	register cr_behaviour_expression kc_x;
	int kc_i;
	register kc_hashtableentry_t* kc_hte;
	unsigned kc_hashval = (unsigned)0;
	YYSTYPE *kc_ptr, *kc_beyond;
	kc_hashtable_t kc_a_ht = kc_hashtables[(int)uniq];

	assert_cr_identifier_equation_list( cr_identifier_equation_list_1, "cr_identifier_equation_list_1" );
	assert_cr_behaviour_expression( cr_behaviour_expression_1, "cr_behaviour_expression_1" );
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_CR_Local_definition_expression));
	OPERATORHASH((unsigned) sel_CR_Local_definition_expression);
	HASH(cr_identifier_equation_list_1);
	HASH(cr_behaviour_expression_1);
	kc_hashval = kc_hashval%kc_a_ht->size;
	for (kc_i=0; kc_i < (int)kc_last_storage_mode; kc_i++) {
		kc_hte = &(kc_a_ht->hashtable[kc_hashval][kc_i]);
		if (kc_hte->nr != 0) {
			kc_beyond = &kc_hte->index[kc_hte->nr];
			for (kc_ptr = &kc_hte->index[0]; kc_ptr < kc_beyond; kc_ptr++){
				kc_x= kc_ptr->yt_cr_behaviour_expression;
				if ((kc_x->prod_sel == sel_CR_Local_definition_expression)  && (kc_x->u.CR_Local_definition_expression.cr_identifier_equation_list_1 == cr_identifier_equation_list_1) && (kc_x->u.CR_Local_definition_expression.cr_behaviour_expression_1 == cr_behaviour_expression_1) )
					return(kc_x);
	}	}	}
	KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_CR_Local_definition_expression));
	kc_hte = &(kc_a_ht->hashtable[kc_hashval][(int)kc_a_ht->mode]);
	if (kc_hte->nr >= kc_hte->ibound) kc_growindex(kc_hte, kc_a_ht);
	kc_x = (cr_behaviour_expression)(*kc_a_ht->malloc)((kc_size_t)sizeof(struct kc_tag_cr_behaviour_expression), kc_a_ht->malloc_private_data);
	kc_x->prod_sel = sel_CR_Local_definition_expression;
	kc_x->u.CR_Local_definition_expression.cr_identifier_equation_list_1 = cr_identifier_equation_list_1;
	kc_x->u.CR_Local_definition_expression.cr_behaviour_expression_1 = cr_behaviour_expression_1;
	kc_hte->index[kc_hte->nr++].yt_cr_behaviour_expression = kc_x;
	return kc_x;
}

cr_behaviour_expression CR_Sum_identifier_expression
#ifdef KC_USE_PROTOTYPES
(cr_identifier_declaration_list cr_identifier_declaration_list_1, cr_behaviour_expression cr_behaviour_expression_1)
#else
(cr_identifier_declaration_list_1, cr_behaviour_expression_1) cr_identifier_declaration_list cr_identifier_declaration_list_1;  cr_behaviour_expression cr_behaviour_expression_1; 
#endif
{	register cr_behaviour_expression kc_x;
	int kc_i;
	register kc_hashtableentry_t* kc_hte;
	unsigned kc_hashval = (unsigned)0;
	YYSTYPE *kc_ptr, *kc_beyond;
	kc_hashtable_t kc_a_ht = kc_hashtables[(int)uniq];

	assert_cr_identifier_declaration_list( cr_identifier_declaration_list_1, "cr_identifier_declaration_list_1" );
	assert_cr_behaviour_expression( cr_behaviour_expression_1, "cr_behaviour_expression_1" );
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_CR_Sum_identifier_expression));
	OPERATORHASH((unsigned) sel_CR_Sum_identifier_expression);
	HASH(cr_identifier_declaration_list_1);
	HASH(cr_behaviour_expression_1);
	kc_hashval = kc_hashval%kc_a_ht->size;
	for (kc_i=0; kc_i < (int)kc_last_storage_mode; kc_i++) {
		kc_hte = &(kc_a_ht->hashtable[kc_hashval][kc_i]);
		if (kc_hte->nr != 0) {
			kc_beyond = &kc_hte->index[kc_hte->nr];
			for (kc_ptr = &kc_hte->index[0]; kc_ptr < kc_beyond; kc_ptr++){
				kc_x= kc_ptr->yt_cr_behaviour_expression;
				if ((kc_x->prod_sel == sel_CR_Sum_identifier_expression)  && (kc_x->u.CR_Sum_identifier_expression.cr_identifier_declaration_list_1 == cr_identifier_declaration_list_1) && (kc_x->u.CR_Sum_identifier_expression.cr_behaviour_expression_1 == cr_behaviour_expression_1) )
					return(kc_x);
	}	}	}
	KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_CR_Sum_identifier_expression));
	kc_hte = &(kc_a_ht->hashtable[kc_hashval][(int)kc_a_ht->mode]);
	if (kc_hte->nr >= kc_hte->ibound) kc_growindex(kc_hte, kc_a_ht);
	kc_x = (cr_behaviour_expression)(*kc_a_ht->malloc)((kc_size_t)sizeof(struct kc_tag_cr_behaviour_expression), kc_a_ht->malloc_private_data);
	kc_x->prod_sel = sel_CR_Sum_identifier_expression;
	kc_x->u.CR_Sum_identifier_expression.cr_identifier_declaration_list_1 = cr_identifier_declaration_list_1;
	kc_x->u.CR_Sum_identifier_expression.cr_behaviour_expression_1 = cr_behaviour_expression_1;
	kc_hte->index[kc_hte->nr++].yt_cr_behaviour_expression = kc_x;
	return kc_x;
}

cr_behaviour_expression CR_Sum_gate_expression
#ifdef KC_USE_PROTOTYPES
(cr_gate_declaration_list cr_gate_declaration_list_1, cr_behaviour_expression cr_behaviour_expression_1)
#else
(cr_gate_declaration_list_1, cr_behaviour_expression_1) cr_gate_declaration_list cr_gate_declaration_list_1;  cr_behaviour_expression cr_behaviour_expression_1; 
#endif
{	register cr_behaviour_expression kc_x;
	int kc_i;
	register kc_hashtableentry_t* kc_hte;
	unsigned kc_hashval = (unsigned)0;
	YYSTYPE *kc_ptr, *kc_beyond;
	kc_hashtable_t kc_a_ht = kc_hashtables[(int)uniq];

	assert_cr_gate_declaration_list( cr_gate_declaration_list_1, "cr_gate_declaration_list_1" );
	assert_cr_behaviour_expression( cr_behaviour_expression_1, "cr_behaviour_expression_1" );
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_CR_Sum_gate_expression));
	OPERATORHASH((unsigned) sel_CR_Sum_gate_expression);
	HASH(cr_gate_declaration_list_1);
	HASH(cr_behaviour_expression_1);
	kc_hashval = kc_hashval%kc_a_ht->size;
	for (kc_i=0; kc_i < (int)kc_last_storage_mode; kc_i++) {
		kc_hte = &(kc_a_ht->hashtable[kc_hashval][kc_i]);
		if (kc_hte->nr != 0) {
			kc_beyond = &kc_hte->index[kc_hte->nr];
			for (kc_ptr = &kc_hte->index[0]; kc_ptr < kc_beyond; kc_ptr++){
				kc_x= kc_ptr->yt_cr_behaviour_expression;
				if ((kc_x->prod_sel == sel_CR_Sum_gate_expression)  && (kc_x->u.CR_Sum_gate_expression.cr_gate_declaration_list_1 == cr_gate_declaration_list_1) && (kc_x->u.CR_Sum_gate_expression.cr_behaviour_expression_1 == cr_behaviour_expression_1) )
					return(kc_x);
	}	}	}
	KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_CR_Sum_gate_expression));
	kc_hte = &(kc_a_ht->hashtable[kc_hashval][(int)kc_a_ht->mode]);
	if (kc_hte->nr >= kc_hte->ibound) kc_growindex(kc_hte, kc_a_ht);
	kc_x = (cr_behaviour_expression)(*kc_a_ht->malloc)((kc_size_t)sizeof(struct kc_tag_cr_behaviour_expression), kc_a_ht->malloc_private_data);
	kc_x->prod_sel = sel_CR_Sum_gate_expression;
	kc_x->u.CR_Sum_gate_expression.cr_gate_declaration_list_1 = cr_gate_declaration_list_1;
	kc_x->u.CR_Sum_gate_expression.cr_behaviour_expression_1 = cr_behaviour_expression_1;
	kc_hte->index[kc_hte->nr++].yt_cr_behaviour_expression = kc_x;
	return kc_x;
}

cr_behaviour_expression CR_Par_expression
#ifdef KC_USE_PROTOTYPES
(cr_gate_declaration_list cr_gate_declaration_list_1, cr_parallel_operator cr_parallel_operator_1, cr_behaviour_expression cr_behaviour_expression_1, cr_LABEL cr_LABEL_1)
#else
(cr_gate_declaration_list_1, cr_parallel_operator_1, cr_behaviour_expression_1, cr_LABEL_1) cr_gate_declaration_list cr_gate_declaration_list_1;  cr_parallel_operator cr_parallel_operator_1;  cr_behaviour_expression cr_behaviour_expression_1;  cr_LABEL cr_LABEL_1; 
#endif
{	register cr_behaviour_expression kc_x;
	int kc_i;
	register kc_hashtableentry_t* kc_hte;
	unsigned kc_hashval = (unsigned)0;
	YYSTYPE *kc_ptr, *kc_beyond;
	kc_hashtable_t kc_a_ht = kc_hashtables[(int)uniq];

	assert_cr_gate_declaration_list( cr_gate_declaration_list_1, "cr_gate_declaration_list_1" );
	assert_cr_parallel_operator( cr_parallel_operator_1, "cr_parallel_operator_1" );
	assert_cr_behaviour_expression( cr_behaviour_expression_1, "cr_behaviour_expression_1" );
	assert_cr_LABEL( cr_LABEL_1, "cr_LABEL_1" );
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_CR_Par_expression));
	OPERATORHASH((unsigned) sel_CR_Par_expression);
	HASH(cr_gate_declaration_list_1);
	HASH(cr_parallel_operator_1);
	HASH(cr_behaviour_expression_1);
	HASH(cr_LABEL_1);
	kc_hashval = kc_hashval%kc_a_ht->size;
	for (kc_i=0; kc_i < (int)kc_last_storage_mode; kc_i++) {
		kc_hte = &(kc_a_ht->hashtable[kc_hashval][kc_i]);
		if (kc_hte->nr != 0) {
			kc_beyond = &kc_hte->index[kc_hte->nr];
			for (kc_ptr = &kc_hte->index[0]; kc_ptr < kc_beyond; kc_ptr++){
				kc_x= kc_ptr->yt_cr_behaviour_expression;
				if ((kc_x->prod_sel == sel_CR_Par_expression)  && (kc_x->u.CR_Par_expression.cr_gate_declaration_list_1 == cr_gate_declaration_list_1) && (kc_x->u.CR_Par_expression.cr_parallel_operator_1 == cr_parallel_operator_1) && (kc_x->u.CR_Par_expression.cr_behaviour_expression_1 == cr_behaviour_expression_1) && (kc_x->u.CR_Par_expression.cr_LABEL_1 == cr_LABEL_1) )
					return(kc_x);
	}	}	}
	KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_CR_Par_expression));
	kc_hte = &(kc_a_ht->hashtable[kc_hashval][(int)kc_a_ht->mode]);
	if (kc_hte->nr >= kc_hte->ibound) kc_growindex(kc_hte, kc_a_ht);
	kc_x = (cr_behaviour_expression)(*kc_a_ht->malloc)((kc_size_t)sizeof(struct kc_tag_cr_behaviour_expression), kc_a_ht->malloc_private_data);
	kc_x->prod_sel = sel_CR_Par_expression;
	kc_x->u.CR_Par_expression.cr_gate_declaration_list_1 = cr_gate_declaration_list_1;
	kc_x->u.CR_Par_expression.cr_parallel_operator_1 = cr_parallel_operator_1;
	kc_x->u.CR_Par_expression.cr_behaviour_expression_1 = cr_behaviour_expression_1;
	kc_x->u.CR_Par_expression.cr_LABEL_1 = cr_LABEL_1;
	kc_hte->index[kc_hte->nr++].yt_cr_behaviour_expression = kc_x;
	return kc_x;
}

cr_behaviour_expression CR_Hiding_expression
#ifdef KC_USE_PROTOTYPES
(cr_gate_identifier_list cr_gate_identifier_list_1, cr_behaviour_expression cr_behaviour_expression_1)
#else
(cr_gate_identifier_list_1, cr_behaviour_expression_1) cr_gate_identifier_list cr_gate_identifier_list_1;  cr_behaviour_expression cr_behaviour_expression_1; 
#endif
{	register cr_behaviour_expression kc_x;
	int kc_i;
	register kc_hashtableentry_t* kc_hte;
	unsigned kc_hashval = (unsigned)0;
	YYSTYPE *kc_ptr, *kc_beyond;
	kc_hashtable_t kc_a_ht = kc_hashtables[(int)uniq];

	assert_cr_gate_identifier_list( cr_gate_identifier_list_1, "cr_gate_identifier_list_1" );
	assert_cr_behaviour_expression( cr_behaviour_expression_1, "cr_behaviour_expression_1" );
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_CR_Hiding_expression));
	OPERATORHASH((unsigned) sel_CR_Hiding_expression);
	HASH(cr_gate_identifier_list_1);
	HASH(cr_behaviour_expression_1);
	kc_hashval = kc_hashval%kc_a_ht->size;
	for (kc_i=0; kc_i < (int)kc_last_storage_mode; kc_i++) {
		kc_hte = &(kc_a_ht->hashtable[kc_hashval][kc_i]);
		if (kc_hte->nr != 0) {
			kc_beyond = &kc_hte->index[kc_hte->nr];
			for (kc_ptr = &kc_hte->index[0]; kc_ptr < kc_beyond; kc_ptr++){
				kc_x= kc_ptr->yt_cr_behaviour_expression;
				if ((kc_x->prod_sel == sel_CR_Hiding_expression)  && (kc_x->u.CR_Hiding_expression.cr_gate_identifier_list_1 == cr_gate_identifier_list_1) && (kc_x->u.CR_Hiding_expression.cr_behaviour_expression_1 == cr_behaviour_expression_1) )
					return(kc_x);
	}	}	}
	KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_CR_Hiding_expression));
	kc_hte = &(kc_a_ht->hashtable[kc_hashval][(int)kc_a_ht->mode]);
	if (kc_hte->nr >= kc_hte->ibound) kc_growindex(kc_hte, kc_a_ht);
	kc_x = (cr_behaviour_expression)(*kc_a_ht->malloc)((kc_size_t)sizeof(struct kc_tag_cr_behaviour_expression), kc_a_ht->malloc_private_data);
	kc_x->prod_sel = sel_CR_Hiding_expression;
	kc_x->u.CR_Hiding_expression.cr_gate_identifier_list_1 = cr_gate_identifier_list_1;
	kc_x->u.CR_Hiding_expression.cr_behaviour_expression_1 = cr_behaviour_expression_1;
	kc_hte->index[kc_hte->nr++].yt_cr_behaviour_expression = kc_x;
	return kc_x;
}

cr_behaviour_expression CR_Enable_expression
#ifdef KC_USE_PROTOTYPES
(cr_behaviour_expression cr_behaviour_expression_1, cr_identifier_declaration_list cr_identifier_declaration_list_1, cr_behaviour_expression cr_behaviour_expression_2)
#else
(cr_behaviour_expression_1, cr_identifier_declaration_list_1, cr_behaviour_expression_2) cr_behaviour_expression cr_behaviour_expression_1;  cr_identifier_declaration_list cr_identifier_declaration_list_1;  cr_behaviour_expression cr_behaviour_expression_2; 
#endif
{	register cr_behaviour_expression kc_x;
	int kc_i;
	register kc_hashtableentry_t* kc_hte;
	unsigned kc_hashval = (unsigned)0;
	YYSTYPE *kc_ptr, *kc_beyond;
	kc_hashtable_t kc_a_ht = kc_hashtables[(int)uniq];

	assert_cr_behaviour_expression( cr_behaviour_expression_1, "cr_behaviour_expression_1" );
	assert_cr_identifier_declaration_list( cr_identifier_declaration_list_1, "cr_identifier_declaration_list_1" );
	assert_cr_behaviour_expression( cr_behaviour_expression_2, "cr_behaviour_expression_2" );
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_CR_Enable_expression));
	OPERATORHASH((unsigned) sel_CR_Enable_expression);
	HASH(cr_behaviour_expression_1);
	HASH(cr_identifier_declaration_list_1);
	HASH(cr_behaviour_expression_2);
	kc_hashval = kc_hashval%kc_a_ht->size;
	for (kc_i=0; kc_i < (int)kc_last_storage_mode; kc_i++) {
		kc_hte = &(kc_a_ht->hashtable[kc_hashval][kc_i]);
		if (kc_hte->nr != 0) {
			kc_beyond = &kc_hte->index[kc_hte->nr];
			for (kc_ptr = &kc_hte->index[0]; kc_ptr < kc_beyond; kc_ptr++){
				kc_x= kc_ptr->yt_cr_behaviour_expression;
				if ((kc_x->prod_sel == sel_CR_Enable_expression)  && (kc_x->u.CR_Enable_expression.cr_behaviour_expression_1 == cr_behaviour_expression_1) && (kc_x->u.CR_Enable_expression.cr_identifier_declaration_list_1 == cr_identifier_declaration_list_1) && (kc_x->u.CR_Enable_expression.cr_behaviour_expression_2 == cr_behaviour_expression_2) )
					return(kc_x);
	}	}	}
	KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_CR_Enable_expression));
	kc_hte = &(kc_a_ht->hashtable[kc_hashval][(int)kc_a_ht->mode]);
	if (kc_hte->nr >= kc_hte->ibound) kc_growindex(kc_hte, kc_a_ht);
	kc_x = (cr_behaviour_expression)(*kc_a_ht->malloc)((kc_size_t)sizeof(struct kc_tag_cr_behaviour_expression), kc_a_ht->malloc_private_data);
	kc_x->prod_sel = sel_CR_Enable_expression;
	kc_x->u.CR_Enable_expression.cr_behaviour_expression_1 = cr_behaviour_expression_1;
	kc_x->u.CR_Enable_expression.cr_identifier_declaration_list_1 = cr_identifier_declaration_list_1;
	kc_x->u.CR_Enable_expression.cr_behaviour_expression_2 = cr_behaviour_expression_2;
	kc_hte->index[kc_hte->nr++].yt_cr_behaviour_expression = kc_x;
	return kc_x;
}

cr_behaviour_expression CR_Disable_expression
#ifdef KC_USE_PROTOTYPES
(cr_behaviour_expression cr_behaviour_expression_1, cr_behaviour_expression cr_behaviour_expression_2)
#else
(cr_behaviour_expression_1, cr_behaviour_expression_2) cr_behaviour_expression cr_behaviour_expression_1;  cr_behaviour_expression cr_behaviour_expression_2; 
#endif
{	register cr_behaviour_expression kc_x;
	int kc_i;
	register kc_hashtableentry_t* kc_hte;
	unsigned kc_hashval = (unsigned)0;
	YYSTYPE *kc_ptr, *kc_beyond;
	kc_hashtable_t kc_a_ht = kc_hashtables[(int)uniq];

	assert_cr_behaviour_expression( cr_behaviour_expression_1, "cr_behaviour_expression_1" );
	assert_cr_behaviour_expression( cr_behaviour_expression_2, "cr_behaviour_expression_2" );
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_CR_Disable_expression));
	OPERATORHASH((unsigned) sel_CR_Disable_expression);
	HASH(cr_behaviour_expression_1);
	HASH(cr_behaviour_expression_2);
	kc_hashval = kc_hashval%kc_a_ht->size;
	for (kc_i=0; kc_i < (int)kc_last_storage_mode; kc_i++) {
		kc_hte = &(kc_a_ht->hashtable[kc_hashval][kc_i]);
		if (kc_hte->nr != 0) {
			kc_beyond = &kc_hte->index[kc_hte->nr];
			for (kc_ptr = &kc_hte->index[0]; kc_ptr < kc_beyond; kc_ptr++){
				kc_x= kc_ptr->yt_cr_behaviour_expression;
				if ((kc_x->prod_sel == sel_CR_Disable_expression)  && (kc_x->u.CR_Disable_expression.cr_behaviour_expression_1 == cr_behaviour_expression_1) && (kc_x->u.CR_Disable_expression.cr_behaviour_expression_2 == cr_behaviour_expression_2) )
					return(kc_x);
	}	}	}
	KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_CR_Disable_expression));
	kc_hte = &(kc_a_ht->hashtable[kc_hashval][(int)kc_a_ht->mode]);
	if (kc_hte->nr >= kc_hte->ibound) kc_growindex(kc_hte, kc_a_ht);
	kc_x = (cr_behaviour_expression)(*kc_a_ht->malloc)((kc_size_t)sizeof(struct kc_tag_cr_behaviour_expression), kc_a_ht->malloc_private_data);
	kc_x->prod_sel = sel_CR_Disable_expression;
	kc_x->u.CR_Disable_expression.cr_behaviour_expression_1 = cr_behaviour_expression_1;
	kc_x->u.CR_Disable_expression.cr_behaviour_expression_2 = cr_behaviour_expression_2;
	kc_hte->index[kc_hte->nr++].yt_cr_behaviour_expression = kc_x;
	return kc_x;
}

cr_behaviour_expression CR_Parallel_expression
#ifdef KC_USE_PROTOTYPES
(cr_behaviour_expression cr_behaviour_expression_1, cr_parallel_operator cr_parallel_operator_1, cr_behaviour_expression cr_behaviour_expression_2, cr_LABEL cr_LABEL_1)
#else
(cr_behaviour_expression_1, cr_parallel_operator_1, cr_behaviour_expression_2, cr_LABEL_1) cr_behaviour_expression cr_behaviour_expression_1;  cr_parallel_operator cr_parallel_operator_1;  cr_behaviour_expression cr_behaviour_expression_2;  cr_LABEL cr_LABEL_1; 
#endif
{	register cr_behaviour_expression kc_x;
	int kc_i;
	register kc_hashtableentry_t* kc_hte;
	unsigned kc_hashval = (unsigned)0;
	YYSTYPE *kc_ptr, *kc_beyond;
	kc_hashtable_t kc_a_ht = kc_hashtables[(int)uniq];

	assert_cr_behaviour_expression( cr_behaviour_expression_1, "cr_behaviour_expression_1" );
	assert_cr_parallel_operator( cr_parallel_operator_1, "cr_parallel_operator_1" );
	assert_cr_behaviour_expression( cr_behaviour_expression_2, "cr_behaviour_expression_2" );
	assert_cr_LABEL( cr_LABEL_1, "cr_LABEL_1" );
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_CR_Parallel_expression));
	OPERATORHASH((unsigned) sel_CR_Parallel_expression);
	HASH(cr_behaviour_expression_1);
	HASH(cr_parallel_operator_1);
	HASH(cr_behaviour_expression_2);
	HASH(cr_LABEL_1);
	kc_hashval = kc_hashval%kc_a_ht->size;
	for (kc_i=0; kc_i < (int)kc_last_storage_mode; kc_i++) {
		kc_hte = &(kc_a_ht->hashtable[kc_hashval][kc_i]);
		if (kc_hte->nr != 0) {
			kc_beyond = &kc_hte->index[kc_hte->nr];
			for (kc_ptr = &kc_hte->index[0]; kc_ptr < kc_beyond; kc_ptr++){
				kc_x= kc_ptr->yt_cr_behaviour_expression;
				if ((kc_x->prod_sel == sel_CR_Parallel_expression)  && (kc_x->u.CR_Parallel_expression.cr_behaviour_expression_1 == cr_behaviour_expression_1) && (kc_x->u.CR_Parallel_expression.cr_parallel_operator_1 == cr_parallel_operator_1) && (kc_x->u.CR_Parallel_expression.cr_behaviour_expression_2 == cr_behaviour_expression_2) && (kc_x->u.CR_Parallel_expression.cr_LABEL_1 == cr_LABEL_1) )
					return(kc_x);
	}	}	}
	KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_CR_Parallel_expression));
	kc_hte = &(kc_a_ht->hashtable[kc_hashval][(int)kc_a_ht->mode]);
	if (kc_hte->nr >= kc_hte->ibound) kc_growindex(kc_hte, kc_a_ht);
	kc_x = (cr_behaviour_expression)(*kc_a_ht->malloc)((kc_size_t)sizeof(struct kc_tag_cr_behaviour_expression), kc_a_ht->malloc_private_data);
	kc_x->prod_sel = sel_CR_Parallel_expression;
	kc_x->u.CR_Parallel_expression.cr_behaviour_expression_1 = cr_behaviour_expression_1;
	kc_x->u.CR_Parallel_expression.cr_parallel_operator_1 = cr_parallel_operator_1;
	kc_x->u.CR_Parallel_expression.cr_behaviour_expression_2 = cr_behaviour_expression_2;
	kc_x->u.CR_Parallel_expression.cr_LABEL_1 = cr_LABEL_1;
	kc_hte->index[kc_hte->nr++].yt_cr_behaviour_expression = kc_x;
	return kc_x;
}

cr_behaviour_expression CR_Choice_expression
#ifdef KC_USE_PROTOTYPES
(cr_behaviour_expression cr_behaviour_expression_1, cr_behaviour_expression cr_behaviour_expression_2)
#else
(cr_behaviour_expression_1, cr_behaviour_expression_2) cr_behaviour_expression cr_behaviour_expression_1;  cr_behaviour_expression cr_behaviour_expression_2; 
#endif
{	register cr_behaviour_expression kc_x;
	int kc_i;
	register kc_hashtableentry_t* kc_hte;
	unsigned kc_hashval = (unsigned)0;
	YYSTYPE *kc_ptr, *kc_beyond;
	kc_hashtable_t kc_a_ht = kc_hashtables[(int)uniq];

	assert_cr_behaviour_expression( cr_behaviour_expression_1, "cr_behaviour_expression_1" );
	assert_cr_behaviour_expression( cr_behaviour_expression_2, "cr_behaviour_expression_2" );
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_CR_Choice_expression));
	OPERATORHASH((unsigned) sel_CR_Choice_expression);
	HASH(cr_behaviour_expression_1);
	HASH(cr_behaviour_expression_2);
	kc_hashval = kc_hashval%kc_a_ht->size;
	for (kc_i=0; kc_i < (int)kc_last_storage_mode; kc_i++) {
		kc_hte = &(kc_a_ht->hashtable[kc_hashval][kc_i]);
		if (kc_hte->nr != 0) {
			kc_beyond = &kc_hte->index[kc_hte->nr];
			for (kc_ptr = &kc_hte->index[0]; kc_ptr < kc_beyond; kc_ptr++){
				kc_x= kc_ptr->yt_cr_behaviour_expression;
				if ((kc_x->prod_sel == sel_CR_Choice_expression)  && (kc_x->u.CR_Choice_expression.cr_behaviour_expression_1 == cr_behaviour_expression_1) && (kc_x->u.CR_Choice_expression.cr_behaviour_expression_2 == cr_behaviour_expression_2) )
					return(kc_x);
	}	}	}
	KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_CR_Choice_expression));
	kc_hte = &(kc_a_ht->hashtable[kc_hashval][(int)kc_a_ht->mode]);
	if (kc_hte->nr >= kc_hte->ibound) kc_growindex(kc_hte, kc_a_ht);
	kc_x = (cr_behaviour_expression)(*kc_a_ht->malloc)((kc_size_t)sizeof(struct kc_tag_cr_behaviour_expression), kc_a_ht->malloc_private_data);
	kc_x->prod_sel = sel_CR_Choice_expression;
	kc_x->u.CR_Choice_expression.cr_behaviour_expression_1 = cr_behaviour_expression_1;
	kc_x->u.CR_Choice_expression.cr_behaviour_expression_2 = cr_behaviour_expression_2;
	kc_hte->index[kc_hte->nr++].yt_cr_behaviour_expression = kc_x;
	return kc_x;
}

cr_behaviour_expression CR_Guarded_expression
#ifdef KC_USE_PROTOTYPES
(cr_equality cr_equality_1, cr_behaviour_expression cr_behaviour_expression_1)
#else
(cr_equality_1, cr_behaviour_expression_1) cr_equality cr_equality_1;  cr_behaviour_expression cr_behaviour_expression_1; 
#endif
{	register cr_behaviour_expression kc_x;
	int kc_i;
	register kc_hashtableentry_t* kc_hte;
	unsigned kc_hashval = (unsigned)0;
	YYSTYPE *kc_ptr, *kc_beyond;
	kc_hashtable_t kc_a_ht = kc_hashtables[(int)uniq];

	assert_cr_equality( cr_equality_1, "cr_equality_1" );
	assert_cr_behaviour_expression( cr_behaviour_expression_1, "cr_behaviour_expression_1" );
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_CR_Guarded_expression));
	OPERATORHASH((unsigned) sel_CR_Guarded_expression);
	HASH(cr_equality_1);
	HASH(cr_behaviour_expression_1);
	kc_hashval = kc_hashval%kc_a_ht->size;
	for (kc_i=0; kc_i < (int)kc_last_storage_mode; kc_i++) {
		kc_hte = &(kc_a_ht->hashtable[kc_hashval][kc_i]);
		if (kc_hte->nr != 0) {
			kc_beyond = &kc_hte->index[kc_hte->nr];
			for (kc_ptr = &kc_hte->index[0]; kc_ptr < kc_beyond; kc_ptr++){
				kc_x= kc_ptr->yt_cr_behaviour_expression;
				if ((kc_x->prod_sel == sel_CR_Guarded_expression)  && (kc_x->u.CR_Guarded_expression.cr_equality_1 == cr_equality_1) && (kc_x->u.CR_Guarded_expression.cr_behaviour_expression_1 == cr_behaviour_expression_1) )
					return(kc_x);
	}	}	}
	KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_CR_Guarded_expression));
	kc_hte = &(kc_a_ht->hashtable[kc_hashval][(int)kc_a_ht->mode]);
	if (kc_hte->nr >= kc_hte->ibound) kc_growindex(kc_hte, kc_a_ht);
	kc_x = (cr_behaviour_expression)(*kc_a_ht->malloc)((kc_size_t)sizeof(struct kc_tag_cr_behaviour_expression), kc_a_ht->malloc_private_data);
	kc_x->prod_sel = sel_CR_Guarded_expression;
	kc_x->u.CR_Guarded_expression.cr_equality_1 = cr_equality_1;
	kc_x->u.CR_Guarded_expression.cr_behaviour_expression_1 = cr_behaviour_expression_1;
	kc_hte->index[kc_hte->nr++].yt_cr_behaviour_expression = kc_x;
	return kc_x;
}

cr_behaviour_expression CR_Annotated_behaviour
#ifdef KC_USE_PROTOTYPES
(cr_annotation_list cr_annotation_list_1, cr_behaviour_expression cr_behaviour_expression_1)
#else
(cr_annotation_list_1, cr_behaviour_expression_1) cr_annotation_list cr_annotation_list_1;  cr_behaviour_expression cr_behaviour_expression_1; 
#endif
{	register cr_behaviour_expression kc_x;
	int kc_i;
	register kc_hashtableentry_t* kc_hte;
	unsigned kc_hashval = (unsigned)0;
	YYSTYPE *kc_ptr, *kc_beyond;
	kc_hashtable_t kc_a_ht = kc_hashtables[(int)uniq];

	assert_cr_annotation_list( cr_annotation_list_1, "cr_annotation_list_1" );
	assert_cr_behaviour_expression( cr_behaviour_expression_1, "cr_behaviour_expression_1" );
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_CR_Annotated_behaviour));
	OPERATORHASH((unsigned) sel_CR_Annotated_behaviour);
	HASH(cr_annotation_list_1);
	HASH(cr_behaviour_expression_1);
	kc_hashval = kc_hashval%kc_a_ht->size;
	for (kc_i=0; kc_i < (int)kc_last_storage_mode; kc_i++) {
		kc_hte = &(kc_a_ht->hashtable[kc_hashval][kc_i]);
		if (kc_hte->nr != 0) {
			kc_beyond = &kc_hte->index[kc_hte->nr];
			for (kc_ptr = &kc_hte->index[0]; kc_ptr < kc_beyond; kc_ptr++){
				kc_x= kc_ptr->yt_cr_behaviour_expression;
				if ((kc_x->prod_sel == sel_CR_Annotated_behaviour)  && (kc_x->u.CR_Annotated_behaviour.cr_annotation_list_1 == cr_annotation_list_1) && (kc_x->u.CR_Annotated_behaviour.cr_behaviour_expression_1 == cr_behaviour_expression_1) )
					return(kc_x);
	}	}	}
	KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_CR_Annotated_behaviour));
	kc_hte = &(kc_a_ht->hashtable[kc_hashval][(int)kc_a_ht->mode]);
	if (kc_hte->nr >= kc_hte->ibound) kc_growindex(kc_hte, kc_a_ht);
	kc_x = (cr_behaviour_expression)(*kc_a_ht->malloc)((kc_size_t)sizeof(struct kc_tag_cr_behaviour_expression), kc_a_ht->malloc_private_data);
	kc_x->prod_sel = sel_CR_Annotated_behaviour;
	kc_x->u.CR_Annotated_behaviour.cr_annotation_list_1 = cr_annotation_list_1;
	kc_x->u.CR_Annotated_behaviour.cr_behaviour_expression_1 = cr_behaviour_expression_1;
	kc_hte->index[kc_hte->nr++].yt_cr_behaviour_expression = kc_x;
	return kc_x;
}

cr_parallel_operator CR_Synchronization_operator
#ifdef KC_USE_PROTOTYPES
()
#else
()
#endif
{	static cr_parallel_operator kc_x = (cr_parallel_operator)0;
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_CR_Synchronization_operator));
	if (kc_x == (cr_parallel_operator)0) {
		KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_CR_Synchronization_operator ));
		kc_x = (cr_parallel_operator)(*kc_hashtables[(int)kc_uniq_nullary_operator]->malloc)((kc_size_t)sizeof(struct kc_tag_cr_parallel_operator), kc_hashtables[(int)kc_uniq_nullary_operator]->malloc_private_data);
		kc_x->prod_sel = sel_CR_Synchronization_operator;
	}
	return kc_x;
}

cr_parallel_operator CR_Interleave_operator
#ifdef KC_USE_PROTOTYPES
()
#else
()
#endif
{	static cr_parallel_operator kc_x = (cr_parallel_operator)0;
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_CR_Interleave_operator));
	if (kc_x == (cr_parallel_operator)0) {
		KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_CR_Interleave_operator ));
		kc_x = (cr_parallel_operator)(*kc_hashtables[(int)kc_uniq_nullary_operator]->malloc)((kc_size_t)sizeof(struct kc_tag_cr_parallel_operator), kc_hashtables[(int)kc_uniq_nullary_operator]->malloc_private_data);
		kc_x->prod_sel = sel_CR_Interleave_operator;
	}
	return kc_x;
}

cr_parallel_operator CR_General_parallel_operator
#ifdef KC_USE_PROTOTYPES
(cr_gate_identifier_list cr_gate_identifier_list_1)
#else
(cr_gate_identifier_list_1) cr_gate_identifier_list cr_gate_identifier_list_1; 
#endif
{	register cr_parallel_operator kc_x;
	int kc_i;
	register kc_hashtableentry_t* kc_hte;
	unsigned kc_hashval = (unsigned)0;
	YYSTYPE *kc_ptr, *kc_beyond;
	kc_hashtable_t kc_a_ht = kc_hashtables[(int)uniq];

	assert_cr_gate_identifier_list( cr_gate_identifier_list_1, "cr_gate_identifier_list_1" );
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_CR_General_parallel_operator));
	OPERATORHASH((unsigned) sel_CR_General_parallel_operator);
	HASH(cr_gate_identifier_list_1);
	kc_hashval = kc_hashval%kc_a_ht->size;
	for (kc_i=0; kc_i < (int)kc_last_storage_mode; kc_i++) {
		kc_hte = &(kc_a_ht->hashtable[kc_hashval][kc_i]);
		if (kc_hte->nr != 0) {
			kc_beyond = &kc_hte->index[kc_hte->nr];
			for (kc_ptr = &kc_hte->index[0]; kc_ptr < kc_beyond; kc_ptr++){
				kc_x= kc_ptr->yt_cr_parallel_operator;
				if ((kc_x->prod_sel == sel_CR_General_parallel_operator)  && (kc_x->u.CR_General_parallel_operator.cr_gate_identifier_list_1 == cr_gate_identifier_list_1) )
					return(kc_x);
	}	}	}
	KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_CR_General_parallel_operator));
	kc_hte = &(kc_a_ht->hashtable[kc_hashval][(int)kc_a_ht->mode]);
	if (kc_hte->nr >= kc_hte->ibound) kc_growindex(kc_hte, kc_a_ht);
	kc_x = (cr_parallel_operator)(*kc_a_ht->malloc)((kc_size_t)sizeof(struct kc_tag_cr_parallel_operator), kc_a_ht->malloc_private_data);
	kc_x->prod_sel = sel_CR_General_parallel_operator;
	kc_x->u.CR_General_parallel_operator.cr_gate_identifier_list_1 = cr_gate_identifier_list_1;
	kc_hte->index[kc_hte->nr++].yt_cr_parallel_operator = kc_x;
	return kc_x;
}

cr_gate_declaration_list Nilcr_gate_declaration_list
#ifdef KC_USE_PROTOTYPES
()
#else
()
#endif
{	static cr_gate_declaration_list kc_x = (cr_gate_declaration_list)0;
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_Nilcr_gate_declaration_list));
	if (kc_x == (cr_gate_declaration_list)0) {
		KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_Nilcr_gate_declaration_list ));
		kc_x = (cr_gate_declaration_list)(*kc_hashtables[(int)kc_uniq_nullary_operator]->malloc)((kc_size_t)sizeof(struct kc_tag_cr_gate_declaration_list), kc_hashtables[(int)kc_uniq_nullary_operator]->malloc_private_data);
		kc_x->prod_sel = sel_Nilcr_gate_declaration_list;
	}
	return kc_x;
}

cr_gate_declaration_list Conscr_gate_declaration_list
#ifdef KC_USE_PROTOTYPES
(cr_gate_declaration cr_gate_declaration_1, cr_gate_declaration_list cr_gate_declaration_list_1)
#else
(cr_gate_declaration_1, cr_gate_declaration_list_1) cr_gate_declaration cr_gate_declaration_1;  cr_gate_declaration_list cr_gate_declaration_list_1; 
#endif
{	register cr_gate_declaration_list kc_x;
	int kc_i;
	register kc_hashtableentry_t* kc_hte;
	unsigned kc_hashval = (unsigned)0;
	YYSTYPE *kc_ptr, *kc_beyond;
	kc_hashtable_t kc_a_ht = kc_hashtables[(int)uniq];

	assert_cr_gate_declaration( cr_gate_declaration_1, "cr_gate_declaration_1" );
	assert_cr_gate_declaration_list( cr_gate_declaration_list_1, "cr_gate_declaration_list_1" );
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_Conscr_gate_declaration_list));
	OPERATORHASH((unsigned) sel_Conscr_gate_declaration_list);
	HASH(cr_gate_declaration_1);
	HASH(cr_gate_declaration_list_1);
	kc_hashval = kc_hashval%kc_a_ht->size;
	for (kc_i=0; kc_i < (int)kc_last_storage_mode; kc_i++) {
		kc_hte = &(kc_a_ht->hashtable[kc_hashval][kc_i]);
		if (kc_hte->nr != 0) {
			kc_beyond = &kc_hte->index[kc_hte->nr];
			for (kc_ptr = &kc_hte->index[0]; kc_ptr < kc_beyond; kc_ptr++){
				kc_x= kc_ptr->yt_cr_gate_declaration_list;
				if ((kc_x->prod_sel == sel_Conscr_gate_declaration_list)  && (kc_x->u.Conscr_gate_declaration_list.cr_gate_declaration_1 == cr_gate_declaration_1) && (kc_x->u.Conscr_gate_declaration_list.cr_gate_declaration_list_1 == cr_gate_declaration_list_1) )
					return(kc_x);
	}	}	}
	KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_Conscr_gate_declaration_list));
	kc_hte = &(kc_a_ht->hashtable[kc_hashval][(int)kc_a_ht->mode]);
	if (kc_hte->nr >= kc_hte->ibound) kc_growindex(kc_hte, kc_a_ht);
	kc_x = (cr_gate_declaration_list)(*kc_a_ht->malloc)((kc_size_t)sizeof(struct kc_tag_cr_gate_declaration_list), kc_a_ht->malloc_private_data);
	kc_x->prod_sel = sel_Conscr_gate_declaration_list;
	kc_x->u.Conscr_gate_declaration_list.cr_gate_declaration_1 = cr_gate_declaration_1;
	kc_x->u.Conscr_gate_declaration_list.cr_gate_declaration_list_1 = cr_gate_declaration_list_1;
	kc_hte->index[kc_hte->nr++].yt_cr_gate_declaration_list = kc_x;
	return kc_x;
}

cr_gate_declaration CR_Gate_declaration
#ifdef KC_USE_PROTOTYPES
(cr_gate_identifier_list cr_gate_identifier_list_1, cr_gate_identifier_list cr_gate_identifier_list_2)
#else
(cr_gate_identifier_list_1, cr_gate_identifier_list_2) cr_gate_identifier_list cr_gate_identifier_list_1;  cr_gate_identifier_list cr_gate_identifier_list_2; 
#endif
{	register cr_gate_declaration kc_x;
	int kc_i;
	register kc_hashtableentry_t* kc_hte;
	unsigned kc_hashval = (unsigned)0;
	YYSTYPE *kc_ptr, *kc_beyond;
	kc_hashtable_t kc_a_ht = kc_hashtables[(int)uniq];

	assert_cr_gate_identifier_list( cr_gate_identifier_list_1, "cr_gate_identifier_list_1" );
	assert_cr_gate_identifier_list( cr_gate_identifier_list_2, "cr_gate_identifier_list_2" );
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_CR_Gate_declaration));
	OPERATORHASH((unsigned) sel_CR_Gate_declaration);
	HASH(cr_gate_identifier_list_1);
	HASH(cr_gate_identifier_list_2);
	kc_hashval = kc_hashval%kc_a_ht->size;
	for (kc_i=0; kc_i < (int)kc_last_storage_mode; kc_i++) {
		kc_hte = &(kc_a_ht->hashtable[kc_hashval][kc_i]);
		if (kc_hte->nr != 0) {
			kc_beyond = &kc_hte->index[kc_hte->nr];
			for (kc_ptr = &kc_hte->index[0]; kc_ptr < kc_beyond; kc_ptr++){
				kc_x= kc_ptr->yt_cr_gate_declaration;
				if ((kc_x->prod_sel == sel_CR_Gate_declaration)  && (kc_x->u.CR_Gate_declaration.cr_gate_identifier_list_1 == cr_gate_identifier_list_1) && (kc_x->u.CR_Gate_declaration.cr_gate_identifier_list_2 == cr_gate_identifier_list_2) )
					return(kc_x);
	}	}	}
	KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_CR_Gate_declaration));
	kc_hte = &(kc_a_ht->hashtable[kc_hashval][(int)kc_a_ht->mode]);
	if (kc_hte->nr >= kc_hte->ibound) kc_growindex(kc_hte, kc_a_ht);
	kc_x = (cr_gate_declaration)(*kc_a_ht->malloc)((kc_size_t)sizeof(struct kc_tag_cr_gate_declaration), kc_a_ht->malloc_private_data);
	kc_x->prod_sel = sel_CR_Gate_declaration;
	kc_x->u.CR_Gate_declaration.cr_gate_identifier_list_1 = cr_gate_identifier_list_1;
	kc_x->u.CR_Gate_declaration.cr_gate_identifier_list_2 = cr_gate_identifier_list_2;
	kc_hte->index[kc_hte->nr++].yt_cr_gate_declaration = kc_x;
	return kc_x;
}

cr_gate_identifier_list Nilcr_gate_identifier_list
#ifdef KC_USE_PROTOTYPES
()
#else
()
#endif
{	static cr_gate_identifier_list kc_x = (cr_gate_identifier_list)0;
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_Nilcr_gate_identifier_list));
	if (kc_x == (cr_gate_identifier_list)0) {
		KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_Nilcr_gate_identifier_list ));
		kc_x = (cr_gate_identifier_list)(*kc_hashtables[(int)kc_uniq_nullary_operator]->malloc)((kc_size_t)sizeof(struct kc_tag_cr_gate_identifier_list), kc_hashtables[(int)kc_uniq_nullary_operator]->malloc_private_data);
		kc_x->prod_sel = sel_Nilcr_gate_identifier_list;
	}
	return kc_x;
}

cr_gate_identifier_list Conscr_gate_identifier_list
#ifdef KC_USE_PROTOTYPES
(cr_gate_identifier cr_gate_identifier_1, cr_gate_identifier_list cr_gate_identifier_list_1)
#else
(cr_gate_identifier_1, cr_gate_identifier_list_1) cr_gate_identifier cr_gate_identifier_1;  cr_gate_identifier_list cr_gate_identifier_list_1; 
#endif
{	register cr_gate_identifier_list kc_x;
	int kc_i;
	register kc_hashtableentry_t* kc_hte;
	unsigned kc_hashval = (unsigned)0;
	YYSTYPE *kc_ptr, *kc_beyond;
	kc_hashtable_t kc_a_ht = kc_hashtables[(int)uniq];

	assert_cr_gate_identifier( cr_gate_identifier_1, "cr_gate_identifier_1" );
	assert_cr_gate_identifier_list( cr_gate_identifier_list_1, "cr_gate_identifier_list_1" );
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_Conscr_gate_identifier_list));
	OPERATORHASH((unsigned) sel_Conscr_gate_identifier_list);
	HASH(cr_gate_identifier_1);
	HASH(cr_gate_identifier_list_1);
	kc_hashval = kc_hashval%kc_a_ht->size;
	for (kc_i=0; kc_i < (int)kc_last_storage_mode; kc_i++) {
		kc_hte = &(kc_a_ht->hashtable[kc_hashval][kc_i]);
		if (kc_hte->nr != 0) {
			kc_beyond = &kc_hte->index[kc_hte->nr];
			for (kc_ptr = &kc_hte->index[0]; kc_ptr < kc_beyond; kc_ptr++){
				kc_x= kc_ptr->yt_cr_gate_identifier_list;
				if ((kc_x->prod_sel == sel_Conscr_gate_identifier_list)  && (kc_x->u.Conscr_gate_identifier_list.cr_gate_identifier_1 == cr_gate_identifier_1) && (kc_x->u.Conscr_gate_identifier_list.cr_gate_identifier_list_1 == cr_gate_identifier_list_1) )
					return(kc_x);
	}	}	}
	KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_Conscr_gate_identifier_list));
	kc_hte = &(kc_a_ht->hashtable[kc_hashval][(int)kc_a_ht->mode]);
	if (kc_hte->nr >= kc_hte->ibound) kc_growindex(kc_hte, kc_a_ht);
	kc_x = (cr_gate_identifier_list)(*kc_a_ht->malloc)((kc_size_t)sizeof(struct kc_tag_cr_gate_identifier_list), kc_a_ht->malloc_private_data);
	kc_x->prod_sel = sel_Conscr_gate_identifier_list;
	kc_x->u.Conscr_gate_identifier_list.cr_gate_identifier_1 = cr_gate_identifier_1;
	kc_x->u.Conscr_gate_identifier_list.cr_gate_identifier_list_1 = cr_gate_identifier_list_1;
	kc_hte->index[kc_hte->nr++].yt_cr_gate_identifier_list = kc_x;
	return kc_x;
}

cr_exit_entry_list Nilcr_exit_entry_list
#ifdef KC_USE_PROTOTYPES
()
#else
()
#endif
{	static cr_exit_entry_list kc_x = (cr_exit_entry_list)0;
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_Nilcr_exit_entry_list));
	if (kc_x == (cr_exit_entry_list)0) {
		KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_Nilcr_exit_entry_list ));
		kc_x = (cr_exit_entry_list)(*kc_hashtables[(int)kc_uniq_nullary_operator]->malloc)((kc_size_t)sizeof(struct kc_tag_cr_exit_entry_list), kc_hashtables[(int)kc_uniq_nullary_operator]->malloc_private_data);
		kc_x->prod_sel = sel_Nilcr_exit_entry_list;
	}
	return kc_x;
}

cr_exit_entry_list Conscr_exit_entry_list
#ifdef KC_USE_PROTOTYPES
(cr_exit_entry cr_exit_entry_1, cr_exit_entry_list cr_exit_entry_list_1)
#else
(cr_exit_entry_1, cr_exit_entry_list_1) cr_exit_entry cr_exit_entry_1;  cr_exit_entry_list cr_exit_entry_list_1; 
#endif
{	register cr_exit_entry_list kc_x;
	int kc_i;
	register kc_hashtableentry_t* kc_hte;
	unsigned kc_hashval = (unsigned)0;
	YYSTYPE *kc_ptr, *kc_beyond;
	kc_hashtable_t kc_a_ht = kc_hashtables[(int)uniq];

	assert_cr_exit_entry( cr_exit_entry_1, "cr_exit_entry_1" );
	assert_cr_exit_entry_list( cr_exit_entry_list_1, "cr_exit_entry_list_1" );
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_Conscr_exit_entry_list));
	OPERATORHASH((unsigned) sel_Conscr_exit_entry_list);
	HASH(cr_exit_entry_1);
	HASH(cr_exit_entry_list_1);
	kc_hashval = kc_hashval%kc_a_ht->size;
	for (kc_i=0; kc_i < (int)kc_last_storage_mode; kc_i++) {
		kc_hte = &(kc_a_ht->hashtable[kc_hashval][kc_i]);
		if (kc_hte->nr != 0) {
			kc_beyond = &kc_hte->index[kc_hte->nr];
			for (kc_ptr = &kc_hte->index[0]; kc_ptr < kc_beyond; kc_ptr++){
				kc_x= kc_ptr->yt_cr_exit_entry_list;
				if ((kc_x->prod_sel == sel_Conscr_exit_entry_list)  && (kc_x->u.Conscr_exit_entry_list.cr_exit_entry_1 == cr_exit_entry_1) && (kc_x->u.Conscr_exit_entry_list.cr_exit_entry_list_1 == cr_exit_entry_list_1) )
					return(kc_x);
	}	}	}
	KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_Conscr_exit_entry_list));
	kc_hte = &(kc_a_ht->hashtable[kc_hashval][(int)kc_a_ht->mode]);
	if (kc_hte->nr >= kc_hte->ibound) kc_growindex(kc_hte, kc_a_ht);
	kc_x = (cr_exit_entry_list)(*kc_a_ht->malloc)((kc_size_t)sizeof(struct kc_tag_cr_exit_entry_list), kc_a_ht->malloc_private_data);
	kc_x->prod_sel = sel_Conscr_exit_entry_list;
	kc_x->u.Conscr_exit_entry_list.cr_exit_entry_1 = cr_exit_entry_1;
	kc_x->u.Conscr_exit_entry_list.cr_exit_entry_list_1 = cr_exit_entry_list_1;
	kc_hte->index[kc_hte->nr++].yt_cr_exit_entry_list = kc_x;
	return kc_x;
}

cr_exit_entry CR_Value_expression_exit_entry
#ifdef KC_USE_PROTOTYPES
(cr_value_expression cr_value_expression_1)
#else
(cr_value_expression_1) cr_value_expression cr_value_expression_1; 
#endif
{	register cr_exit_entry kc_x;
	int kc_i;
	register kc_hashtableentry_t* kc_hte;
	unsigned kc_hashval = (unsigned)0;
	YYSTYPE *kc_ptr, *kc_beyond;
	kc_hashtable_t kc_a_ht = kc_hashtables[(int)uniq];

	assert_cr_value_expression( cr_value_expression_1, "cr_value_expression_1" );
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_CR_Value_expression_exit_entry));
	OPERATORHASH((unsigned) sel_CR_Value_expression_exit_entry);
	HASH(cr_value_expression_1);
	kc_hashval = kc_hashval%kc_a_ht->size;
	for (kc_i=0; kc_i < (int)kc_last_storage_mode; kc_i++) {
		kc_hte = &(kc_a_ht->hashtable[kc_hashval][kc_i]);
		if (kc_hte->nr != 0) {
			kc_beyond = &kc_hte->index[kc_hte->nr];
			for (kc_ptr = &kc_hte->index[0]; kc_ptr < kc_beyond; kc_ptr++){
				kc_x= kc_ptr->yt_cr_exit_entry;
				if ((kc_x->prod_sel == sel_CR_Value_expression_exit_entry)  && (kc_x->u.CR_Value_expression_exit_entry.cr_value_expression_1 == cr_value_expression_1) )
					return(kc_x);
	}	}	}
	KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_CR_Value_expression_exit_entry));
	kc_hte = &(kc_a_ht->hashtable[kc_hashval][(int)kc_a_ht->mode]);
	if (kc_hte->nr >= kc_hte->ibound) kc_growindex(kc_hte, kc_a_ht);
	kc_x = (cr_exit_entry)(*kc_a_ht->malloc)((kc_size_t)sizeof(struct kc_tag_cr_exit_entry), kc_a_ht->malloc_private_data);
	kc_x->prod_sel = sel_CR_Value_expression_exit_entry;
	kc_x->u.CR_Value_expression_exit_entry.cr_value_expression_1 = cr_value_expression_1;
	kc_hte->index[kc_hte->nr++].yt_cr_exit_entry = kc_x;
	return kc_x;
}

cr_exit_entry CR_Sort_identifier_exit_entry
#ifdef KC_USE_PROTOTYPES
(cr_sort_identifier cr_sort_identifier_1)
#else
(cr_sort_identifier_1) cr_sort_identifier cr_sort_identifier_1; 
#endif
{	register cr_exit_entry kc_x;
	int kc_i;
	register kc_hashtableentry_t* kc_hte;
	unsigned kc_hashval = (unsigned)0;
	YYSTYPE *kc_ptr, *kc_beyond;
	kc_hashtable_t kc_a_ht = kc_hashtables[(int)uniq];

	assert_cr_sort_identifier( cr_sort_identifier_1, "cr_sort_identifier_1" );
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_CR_Sort_identifier_exit_entry));
	OPERATORHASH((unsigned) sel_CR_Sort_identifier_exit_entry);
	HASH(cr_sort_identifier_1);
	kc_hashval = kc_hashval%kc_a_ht->size;
	for (kc_i=0; kc_i < (int)kc_last_storage_mode; kc_i++) {
		kc_hte = &(kc_a_ht->hashtable[kc_hashval][kc_i]);
		if (kc_hte->nr != 0) {
			kc_beyond = &kc_hte->index[kc_hte->nr];
			for (kc_ptr = &kc_hte->index[0]; kc_ptr < kc_beyond; kc_ptr++){
				kc_x= kc_ptr->yt_cr_exit_entry;
				if ((kc_x->prod_sel == sel_CR_Sort_identifier_exit_entry)  && (kc_x->u.CR_Sort_identifier_exit_entry.cr_sort_identifier_1 == cr_sort_identifier_1) )
					return(kc_x);
	}	}	}
	KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_CR_Sort_identifier_exit_entry));
	kc_hte = &(kc_a_ht->hashtable[kc_hashval][(int)kc_a_ht->mode]);
	if (kc_hte->nr >= kc_hte->ibound) kc_growindex(kc_hte, kc_a_ht);
	kc_x = (cr_exit_entry)(*kc_a_ht->malloc)((kc_size_t)sizeof(struct kc_tag_cr_exit_entry), kc_a_ht->malloc_private_data);
	kc_x->prod_sel = sel_CR_Sort_identifier_exit_entry;
	kc_x->u.CR_Sort_identifier_exit_entry.cr_sort_identifier_1 = cr_sort_identifier_1;
	kc_hte->index[kc_hte->nr++].yt_cr_exit_entry = kc_x;
	return kc_x;
}

cr_identifier_equation_list Nilcr_identifier_equation_list
#ifdef KC_USE_PROTOTYPES
()
#else
()
#endif
{	static cr_identifier_equation_list kc_x = (cr_identifier_equation_list)0;
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_Nilcr_identifier_equation_list));
	if (kc_x == (cr_identifier_equation_list)0) {
		KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_Nilcr_identifier_equation_list ));
		kc_x = (cr_identifier_equation_list)(*kc_hashtables[(int)kc_uniq_nullary_operator]->malloc)((kc_size_t)sizeof(struct kc_tag_cr_identifier_equation_list), kc_hashtables[(int)kc_uniq_nullary_operator]->malloc_private_data);
		kc_x->prod_sel = sel_Nilcr_identifier_equation_list;
	}
	return kc_x;
}

cr_identifier_equation_list Conscr_identifier_equation_list
#ifdef KC_USE_PROTOTYPES
(cr_identifier_equation cr_identifier_equation_1, cr_identifier_equation_list cr_identifier_equation_list_1)
#else
(cr_identifier_equation_1, cr_identifier_equation_list_1) cr_identifier_equation cr_identifier_equation_1;  cr_identifier_equation_list cr_identifier_equation_list_1; 
#endif
{	register cr_identifier_equation_list kc_x;
	int kc_i;
	register kc_hashtableentry_t* kc_hte;
	unsigned kc_hashval = (unsigned)0;
	YYSTYPE *kc_ptr, *kc_beyond;
	kc_hashtable_t kc_a_ht = kc_hashtables[(int)uniq];

	assert_cr_identifier_equation( cr_identifier_equation_1, "cr_identifier_equation_1" );
	assert_cr_identifier_equation_list( cr_identifier_equation_list_1, "cr_identifier_equation_list_1" );
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_Conscr_identifier_equation_list));
	OPERATORHASH((unsigned) sel_Conscr_identifier_equation_list);
	HASH(cr_identifier_equation_1);
	HASH(cr_identifier_equation_list_1);
	kc_hashval = kc_hashval%kc_a_ht->size;
	for (kc_i=0; kc_i < (int)kc_last_storage_mode; kc_i++) {
		kc_hte = &(kc_a_ht->hashtable[kc_hashval][kc_i]);
		if (kc_hte->nr != 0) {
			kc_beyond = &kc_hte->index[kc_hte->nr];
			for (kc_ptr = &kc_hte->index[0]; kc_ptr < kc_beyond; kc_ptr++){
				kc_x= kc_ptr->yt_cr_identifier_equation_list;
				if ((kc_x->prod_sel == sel_Conscr_identifier_equation_list)  && (kc_x->u.Conscr_identifier_equation_list.cr_identifier_equation_1 == cr_identifier_equation_1) && (kc_x->u.Conscr_identifier_equation_list.cr_identifier_equation_list_1 == cr_identifier_equation_list_1) )
					return(kc_x);
	}	}	}
	KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_Conscr_identifier_equation_list));
	kc_hte = &(kc_a_ht->hashtable[kc_hashval][(int)kc_a_ht->mode]);
	if (kc_hte->nr >= kc_hte->ibound) kc_growindex(kc_hte, kc_a_ht);
	kc_x = (cr_identifier_equation_list)(*kc_a_ht->malloc)((kc_size_t)sizeof(struct kc_tag_cr_identifier_equation_list), kc_a_ht->malloc_private_data);
	kc_x->prod_sel = sel_Conscr_identifier_equation_list;
	kc_x->u.Conscr_identifier_equation_list.cr_identifier_equation_1 = cr_identifier_equation_1;
	kc_x->u.Conscr_identifier_equation_list.cr_identifier_equation_list_1 = cr_identifier_equation_list_1;
	kc_hte->index[kc_hte->nr++].yt_cr_identifier_equation_list = kc_x;
	return kc_x;
}

cr_identifier_equation CR_Identifier_equation
#ifdef KC_USE_PROTOTYPES
(cr_identifier_declaration cr_identifier_declaration_1, cr_value_expression cr_value_expression_1)
#else
(cr_identifier_declaration_1, cr_value_expression_1) cr_identifier_declaration cr_identifier_declaration_1;  cr_value_expression cr_value_expression_1; 
#endif
{	register cr_identifier_equation kc_x;
	int kc_i;
	register kc_hashtableentry_t* kc_hte;
	unsigned kc_hashval = (unsigned)0;
	YYSTYPE *kc_ptr, *kc_beyond;
	kc_hashtable_t kc_a_ht = kc_hashtables[(int)uniq];

	assert_cr_identifier_declaration( cr_identifier_declaration_1, "cr_identifier_declaration_1" );
	assert_cr_value_expression( cr_value_expression_1, "cr_value_expression_1" );
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_CR_Identifier_equation));
	OPERATORHASH((unsigned) sel_CR_Identifier_equation);
	HASH(cr_identifier_declaration_1);
	HASH(cr_value_expression_1);
	kc_hashval = kc_hashval%kc_a_ht->size;
	for (kc_i=0; kc_i < (int)kc_last_storage_mode; kc_i++) {
		kc_hte = &(kc_a_ht->hashtable[kc_hashval][kc_i]);
		if (kc_hte->nr != 0) {
			kc_beyond = &kc_hte->index[kc_hte->nr];
			for (kc_ptr = &kc_hte->index[0]; kc_ptr < kc_beyond; kc_ptr++){
				kc_x= kc_ptr->yt_cr_identifier_equation;
				if ((kc_x->prod_sel == sel_CR_Identifier_equation)  && (kc_x->u.CR_Identifier_equation.cr_identifier_declaration_1 == cr_identifier_declaration_1) && (kc_x->u.CR_Identifier_equation.cr_value_expression_1 == cr_value_expression_1) )
					return(kc_x);
	}	}	}
	KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_CR_Identifier_equation));
	kc_hte = &(kc_a_ht->hashtable[kc_hashval][(int)kc_a_ht->mode]);
	if (kc_hte->nr >= kc_hte->ibound) kc_growindex(kc_hte, kc_a_ht);
	kc_x = (cr_identifier_equation)(*kc_a_ht->malloc)((kc_size_t)sizeof(struct kc_tag_cr_identifier_equation), kc_a_ht->malloc_private_data);
	kc_x->prod_sel = sel_CR_Identifier_equation;
	kc_x->u.CR_Identifier_equation.cr_identifier_declaration_1 = cr_identifier_declaration_1;
	kc_x->u.CR_Identifier_equation.cr_value_expression_1 = cr_value_expression_1;
	kc_hte->index[kc_hte->nr++].yt_cr_identifier_equation = kc_x;
	return kc_x;
}

cr_action_denotation CR_Communication
#ifdef KC_USE_PROTOTYPES
(cr_gate_identifier cr_gate_identifier_1, cr_experiment_option cr_experiment_option_1)
#else
(cr_gate_identifier_1, cr_experiment_option_1) cr_gate_identifier cr_gate_identifier_1;  cr_experiment_option cr_experiment_option_1; 
#endif
{	register cr_action_denotation kc_x;
	int kc_i;
	register kc_hashtableentry_t* kc_hte;
	unsigned kc_hashval = (unsigned)0;
	YYSTYPE *kc_ptr, *kc_beyond;
	kc_hashtable_t kc_a_ht = kc_hashtables[(int)uniq];

	assert_cr_gate_identifier( cr_gate_identifier_1, "cr_gate_identifier_1" );
	assert_cr_experiment_option( cr_experiment_option_1, "cr_experiment_option_1" );
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_CR_Communication));
	OPERATORHASH((unsigned) sel_CR_Communication);
	HASH(cr_gate_identifier_1);
	HASH(cr_experiment_option_1);
	kc_hashval = kc_hashval%kc_a_ht->size;
	for (kc_i=0; kc_i < (int)kc_last_storage_mode; kc_i++) {
		kc_hte = &(kc_a_ht->hashtable[kc_hashval][kc_i]);
		if (kc_hte->nr != 0) {
			kc_beyond = &kc_hte->index[kc_hte->nr];
			for (kc_ptr = &kc_hte->index[0]; kc_ptr < kc_beyond; kc_ptr++){
				kc_x= kc_ptr->yt_cr_action_denotation;
				if ((kc_x->prod_sel == sel_CR_Communication)  && (kc_x->u.CR_Communication.cr_gate_identifier_1 == cr_gate_identifier_1) && (kc_x->u.CR_Communication.cr_experiment_option_1 == cr_experiment_option_1) )
					return(kc_x);
	}	}	}
	KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_CR_Communication));
	kc_hte = &(kc_a_ht->hashtable[kc_hashval][(int)kc_a_ht->mode]);
	if (kc_hte->nr >= kc_hte->ibound) kc_growindex(kc_hte, kc_a_ht);
	kc_x = (cr_action_denotation)(*kc_a_ht->malloc)((kc_size_t)sizeof(struct kc_tag_cr_action_denotation), kc_a_ht->malloc_private_data);
	kc_x->prod_sel = sel_CR_Communication;
	kc_x->u.CR_Communication.cr_gate_identifier_1 = cr_gate_identifier_1;
	kc_x->u.CR_Communication.cr_experiment_option_1 = cr_experiment_option_1;
	kc_hte->index[kc_hte->nr++].yt_cr_action_denotation = kc_x;
	return kc_x;
}

cr_action_denotation CR_Internal_event
#ifdef KC_USE_PROTOTYPES
()
#else
()
#endif
{	static cr_action_denotation kc_x = (cr_action_denotation)0;
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_CR_Internal_event));
	if (kc_x == (cr_action_denotation)0) {
		KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_CR_Internal_event ));
		kc_x = (cr_action_denotation)(*kc_hashtables[(int)kc_uniq_nullary_operator]->malloc)((kc_size_t)sizeof(struct kc_tag_cr_action_denotation), kc_hashtables[(int)kc_uniq_nullary_operator]->malloc_private_data);
		kc_x->prod_sel = sel_CR_Internal_event;
	}
	return kc_x;
}

cr_experiment_option CR_NoExperiment
#ifdef KC_USE_PROTOTYPES
()
#else
()
#endif
{	static cr_experiment_option kc_x = (cr_experiment_option)0;
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_CR_NoExperiment));
	if (kc_x == (cr_experiment_option)0) {
		KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_CR_NoExperiment ));
		kc_x = (cr_experiment_option)(*kc_hashtables[(int)kc_uniq_nullary_operator]->malloc)((kc_size_t)sizeof(struct kc_tag_cr_experiment_option), kc_hashtables[(int)kc_uniq_nullary_operator]->malloc_private_data);
		kc_x->prod_sel = sel_CR_NoExperiment;
	}
	return kc_x;
}

cr_experiment_option CR_YesExperiment
#ifdef KC_USE_PROTOTYPES
(cr_experiment_offer_list cr_experiment_offer_list_1, cr_guard_option cr_guard_option_1)
#else
(cr_experiment_offer_list_1, cr_guard_option_1) cr_experiment_offer_list cr_experiment_offer_list_1;  cr_guard_option cr_guard_option_1; 
#endif
{	register cr_experiment_option kc_x;
	int kc_i;
	register kc_hashtableentry_t* kc_hte;
	unsigned kc_hashval = (unsigned)0;
	YYSTYPE *kc_ptr, *kc_beyond;
	kc_hashtable_t kc_a_ht = kc_hashtables[(int)uniq];

	assert_cr_experiment_offer_list( cr_experiment_offer_list_1, "cr_experiment_offer_list_1" );
	assert_cr_guard_option( cr_guard_option_1, "cr_guard_option_1" );
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_CR_YesExperiment));
	OPERATORHASH((unsigned) sel_CR_YesExperiment);
	HASH(cr_experiment_offer_list_1);
	HASH(cr_guard_option_1);
	kc_hashval = kc_hashval%kc_a_ht->size;
	for (kc_i=0; kc_i < (int)kc_last_storage_mode; kc_i++) {
		kc_hte = &(kc_a_ht->hashtable[kc_hashval][kc_i]);
		if (kc_hte->nr != 0) {
			kc_beyond = &kc_hte->index[kc_hte->nr];
			for (kc_ptr = &kc_hte->index[0]; kc_ptr < kc_beyond; kc_ptr++){
				kc_x= kc_ptr->yt_cr_experiment_option;
				if ((kc_x->prod_sel == sel_CR_YesExperiment)  && (kc_x->u.CR_YesExperiment.cr_experiment_offer_list_1 == cr_experiment_offer_list_1) && (kc_x->u.CR_YesExperiment.cr_guard_option_1 == cr_guard_option_1) )
					return(kc_x);
	}	}	}
	KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_CR_YesExperiment));
	kc_hte = &(kc_a_ht->hashtable[kc_hashval][(int)kc_a_ht->mode]);
	if (kc_hte->nr >= kc_hte->ibound) kc_growindex(kc_hte, kc_a_ht);
	kc_x = (cr_experiment_option)(*kc_a_ht->malloc)((kc_size_t)sizeof(struct kc_tag_cr_experiment_option), kc_a_ht->malloc_private_data);
	kc_x->prod_sel = sel_CR_YesExperiment;
	kc_x->u.CR_YesExperiment.cr_experiment_offer_list_1 = cr_experiment_offer_list_1;
	kc_x->u.CR_YesExperiment.cr_guard_option_1 = cr_guard_option_1;
	kc_hte->index[kc_hte->nr++].yt_cr_experiment_option = kc_x;
	return kc_x;
}

cr_experiment_offer_list Nilcr_experiment_offer_list
#ifdef KC_USE_PROTOTYPES
()
#else
()
#endif
{	static cr_experiment_offer_list kc_x = (cr_experiment_offer_list)0;
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_Nilcr_experiment_offer_list));
	if (kc_x == (cr_experiment_offer_list)0) {
		KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_Nilcr_experiment_offer_list ));
		kc_x = (cr_experiment_offer_list)(*kc_hashtables[(int)kc_uniq_nullary_operator]->malloc)((kc_size_t)sizeof(struct kc_tag_cr_experiment_offer_list), kc_hashtables[(int)kc_uniq_nullary_operator]->malloc_private_data);
		kc_x->prod_sel = sel_Nilcr_experiment_offer_list;
	}
	return kc_x;
}

cr_experiment_offer_list Conscr_experiment_offer_list
#ifdef KC_USE_PROTOTYPES
(cr_experiment_offer cr_experiment_offer_1, cr_experiment_offer_list cr_experiment_offer_list_1)
#else
(cr_experiment_offer_1, cr_experiment_offer_list_1) cr_experiment_offer cr_experiment_offer_1;  cr_experiment_offer_list cr_experiment_offer_list_1; 
#endif
{	register cr_experiment_offer_list kc_x;
	int kc_i;
	register kc_hashtableentry_t* kc_hte;
	unsigned kc_hashval = (unsigned)0;
	YYSTYPE *kc_ptr, *kc_beyond;
	kc_hashtable_t kc_a_ht = kc_hashtables[(int)uniq];

	assert_cr_experiment_offer( cr_experiment_offer_1, "cr_experiment_offer_1" );
	assert_cr_experiment_offer_list( cr_experiment_offer_list_1, "cr_experiment_offer_list_1" );
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_Conscr_experiment_offer_list));
	OPERATORHASH((unsigned) sel_Conscr_experiment_offer_list);
	HASH(cr_experiment_offer_1);
	HASH(cr_experiment_offer_list_1);
	kc_hashval = kc_hashval%kc_a_ht->size;
	for (kc_i=0; kc_i < (int)kc_last_storage_mode; kc_i++) {
		kc_hte = &(kc_a_ht->hashtable[kc_hashval][kc_i]);
		if (kc_hte->nr != 0) {
			kc_beyond = &kc_hte->index[kc_hte->nr];
			for (kc_ptr = &kc_hte->index[0]; kc_ptr < kc_beyond; kc_ptr++){
				kc_x= kc_ptr->yt_cr_experiment_offer_list;
				if ((kc_x->prod_sel == sel_Conscr_experiment_offer_list)  && (kc_x->u.Conscr_experiment_offer_list.cr_experiment_offer_1 == cr_experiment_offer_1) && (kc_x->u.Conscr_experiment_offer_list.cr_experiment_offer_list_1 == cr_experiment_offer_list_1) )
					return(kc_x);
	}	}	}
	KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_Conscr_experiment_offer_list));
	kc_hte = &(kc_a_ht->hashtable[kc_hashval][(int)kc_a_ht->mode]);
	if (kc_hte->nr >= kc_hte->ibound) kc_growindex(kc_hte, kc_a_ht);
	kc_x = (cr_experiment_offer_list)(*kc_a_ht->malloc)((kc_size_t)sizeof(struct kc_tag_cr_experiment_offer_list), kc_a_ht->malloc_private_data);
	kc_x->prod_sel = sel_Conscr_experiment_offer_list;
	kc_x->u.Conscr_experiment_offer_list.cr_experiment_offer_1 = cr_experiment_offer_1;
	kc_x->u.Conscr_experiment_offer_list.cr_experiment_offer_list_1 = cr_experiment_offer_list_1;
	kc_hte->index[kc_hte->nr++].yt_cr_experiment_offer_list = kc_x;
	return kc_x;
}

cr_experiment_offer CR_Query_offer
#ifdef KC_USE_PROTOTYPES
(cr_identifier_declaration cr_identifier_declaration_1)
#else
(cr_identifier_declaration_1) cr_identifier_declaration cr_identifier_declaration_1; 
#endif
{	register cr_experiment_offer kc_x;
	int kc_i;
	register kc_hashtableentry_t* kc_hte;
	unsigned kc_hashval = (unsigned)0;
	YYSTYPE *kc_ptr, *kc_beyond;
	kc_hashtable_t kc_a_ht = kc_hashtables[(int)uniq];

	assert_cr_identifier_declaration( cr_identifier_declaration_1, "cr_identifier_declaration_1" );
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_CR_Query_offer));
	OPERATORHASH((unsigned) sel_CR_Query_offer);
	HASH(cr_identifier_declaration_1);
	kc_hashval = kc_hashval%kc_a_ht->size;
	for (kc_i=0; kc_i < (int)kc_last_storage_mode; kc_i++) {
		kc_hte = &(kc_a_ht->hashtable[kc_hashval][kc_i]);
		if (kc_hte->nr != 0) {
			kc_beyond = &kc_hte->index[kc_hte->nr];
			for (kc_ptr = &kc_hte->index[0]; kc_ptr < kc_beyond; kc_ptr++){
				kc_x= kc_ptr->yt_cr_experiment_offer;
				if ((kc_x->prod_sel == sel_CR_Query_offer)  && (kc_x->u.CR_Query_offer.cr_identifier_declaration_1 == cr_identifier_declaration_1) )
					return(kc_x);
	}	}	}
	KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_CR_Query_offer));
	kc_hte = &(kc_a_ht->hashtable[kc_hashval][(int)kc_a_ht->mode]);
	if (kc_hte->nr >= kc_hte->ibound) kc_growindex(kc_hte, kc_a_ht);
	kc_x = (cr_experiment_offer)(*kc_a_ht->malloc)((kc_size_t)sizeof(struct kc_tag_cr_experiment_offer), kc_a_ht->malloc_private_data);
	kc_x->prod_sel = sel_CR_Query_offer;
	kc_x->u.CR_Query_offer.cr_identifier_declaration_1 = cr_identifier_declaration_1;
	kc_hte->index[kc_hte->nr++].yt_cr_experiment_offer = kc_x;
	return kc_x;
}

cr_experiment_offer CR_Exclam_offer
#ifdef KC_USE_PROTOTYPES
(cr_value_expression cr_value_expression_1)
#else
(cr_value_expression_1) cr_value_expression cr_value_expression_1; 
#endif
{	register cr_experiment_offer kc_x;
	int kc_i;
	register kc_hashtableentry_t* kc_hte;
	unsigned kc_hashval = (unsigned)0;
	YYSTYPE *kc_ptr, *kc_beyond;
	kc_hashtable_t kc_a_ht = kc_hashtables[(int)uniq];

	assert_cr_value_expression( cr_value_expression_1, "cr_value_expression_1" );
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_CR_Exclam_offer));
	OPERATORHASH((unsigned) sel_CR_Exclam_offer);
	HASH(cr_value_expression_1);
	kc_hashval = kc_hashval%kc_a_ht->size;
	for (kc_i=0; kc_i < (int)kc_last_storage_mode; kc_i++) {
		kc_hte = &(kc_a_ht->hashtable[kc_hashval][kc_i]);
		if (kc_hte->nr != 0) {
			kc_beyond = &kc_hte->index[kc_hte->nr];
			for (kc_ptr = &kc_hte->index[0]; kc_ptr < kc_beyond; kc_ptr++){
				kc_x= kc_ptr->yt_cr_experiment_offer;
				if ((kc_x->prod_sel == sel_CR_Exclam_offer)  && (kc_x->u.CR_Exclam_offer.cr_value_expression_1 == cr_value_expression_1) )
					return(kc_x);
	}	}	}
	KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_CR_Exclam_offer));
	kc_hte = &(kc_a_ht->hashtable[kc_hashval][(int)kc_a_ht->mode]);
	if (kc_hte->nr >= kc_hte->ibound) kc_growindex(kc_hte, kc_a_ht);
	kc_x = (cr_experiment_offer)(*kc_a_ht->malloc)((kc_size_t)sizeof(struct kc_tag_cr_experiment_offer), kc_a_ht->malloc_private_data);
	kc_x->prod_sel = sel_CR_Exclam_offer;
	kc_x->u.CR_Exclam_offer.cr_value_expression_1 = cr_value_expression_1;
	kc_hte->index[kc_hte->nr++].yt_cr_experiment_offer = kc_x;
	return kc_x;
}

cr_guard_option CR_NoGuard
#ifdef KC_USE_PROTOTYPES
()
#else
()
#endif
{	static cr_guard_option kc_x = (cr_guard_option)0;
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_CR_NoGuard));
	if (kc_x == (cr_guard_option)0) {
		KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_CR_NoGuard ));
		kc_x = (cr_guard_option)(*kc_hashtables[(int)kc_uniq_nullary_operator]->malloc)((kc_size_t)sizeof(struct kc_tag_cr_guard_option), kc_hashtables[(int)kc_uniq_nullary_operator]->malloc_private_data);
		kc_x->prod_sel = sel_CR_NoGuard;
	}
	return kc_x;
}

cr_guard_option CR_YesGuard
#ifdef KC_USE_PROTOTYPES
(cr_equality cr_equality_1)
#else
(cr_equality_1) cr_equality cr_equality_1; 
#endif
{	register cr_guard_option kc_x;
	int kc_i;
	register kc_hashtableentry_t* kc_hte;
	unsigned kc_hashval = (unsigned)0;
	YYSTYPE *kc_ptr, *kc_beyond;
	kc_hashtable_t kc_a_ht = kc_hashtables[(int)uniq];

	assert_cr_equality( cr_equality_1, "cr_equality_1" );
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_CR_YesGuard));
	OPERATORHASH((unsigned) sel_CR_YesGuard);
	HASH(cr_equality_1);
	kc_hashval = kc_hashval%kc_a_ht->size;
	for (kc_i=0; kc_i < (int)kc_last_storage_mode; kc_i++) {
		kc_hte = &(kc_a_ht->hashtable[kc_hashval][kc_i]);
		if (kc_hte->nr != 0) {
			kc_beyond = &kc_hte->index[kc_hte->nr];
			for (kc_ptr = &kc_hte->index[0]; kc_ptr < kc_beyond; kc_ptr++){
				kc_x= kc_ptr->yt_cr_guard_option;
				if ((kc_x->prod_sel == sel_CR_YesGuard)  && (kc_x->u.CR_YesGuard.cr_equality_1 == cr_equality_1) )
					return(kc_x);
	}	}	}
	KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_CR_YesGuard));
	kc_hte = &(kc_a_ht->hashtable[kc_hashval][(int)kc_a_ht->mode]);
	if (kc_hte->nr >= kc_hte->ibound) kc_growindex(kc_hte, kc_a_ht);
	kc_x = (cr_guard_option)(*kc_a_ht->malloc)((kc_size_t)sizeof(struct kc_tag_cr_guard_option), kc_a_ht->malloc_private_data);
	kc_x->prod_sel = sel_CR_YesGuard;
	kc_x->u.CR_YesGuard.cr_equality_1 = cr_equality_1;
	kc_hte->index[kc_hte->nr++].yt_cr_guard_option = kc_x;
	return kc_x;
}

cr_value_expression_list Nilcr_value_expression_list
#ifdef KC_USE_PROTOTYPES
()
#else
()
#endif
{	static cr_value_expression_list kc_x = (cr_value_expression_list)0;
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_Nilcr_value_expression_list));
	if (kc_x == (cr_value_expression_list)0) {
		KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_Nilcr_value_expression_list ));
		kc_x = (cr_value_expression_list)(*kc_hashtables[(int)kc_uniq_nullary_operator]->malloc)((kc_size_t)sizeof(struct kc_tag_cr_value_expression_list), kc_hashtables[(int)kc_uniq_nullary_operator]->malloc_private_data);
		kc_x->prod_sel = sel_Nilcr_value_expression_list;
	}
	return kc_x;
}

cr_value_expression_list Conscr_value_expression_list
#ifdef KC_USE_PROTOTYPES
(cr_value_expression cr_value_expression_1, cr_value_expression_list cr_value_expression_list_1)
#else
(cr_value_expression_1, cr_value_expression_list_1) cr_value_expression cr_value_expression_1;  cr_value_expression_list cr_value_expression_list_1; 
#endif
{	register cr_value_expression_list kc_x;
	int kc_i;
	register kc_hashtableentry_t* kc_hte;
	unsigned kc_hashval = (unsigned)0;
	YYSTYPE *kc_ptr, *kc_beyond;
	kc_hashtable_t kc_a_ht = kc_hashtables[(int)uniq];

	assert_cr_value_expression( cr_value_expression_1, "cr_value_expression_1" );
	assert_cr_value_expression_list( cr_value_expression_list_1, "cr_value_expression_list_1" );
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_Conscr_value_expression_list));
	OPERATORHASH((unsigned) sel_Conscr_value_expression_list);
	HASH(cr_value_expression_1);
	HASH(cr_value_expression_list_1);
	kc_hashval = kc_hashval%kc_a_ht->size;
	for (kc_i=0; kc_i < (int)kc_last_storage_mode; kc_i++) {
		kc_hte = &(kc_a_ht->hashtable[kc_hashval][kc_i]);
		if (kc_hte->nr != 0) {
			kc_beyond = &kc_hte->index[kc_hte->nr];
			for (kc_ptr = &kc_hte->index[0]; kc_ptr < kc_beyond; kc_ptr++){
				kc_x= kc_ptr->yt_cr_value_expression_list;
				if ((kc_x->prod_sel == sel_Conscr_value_expression_list)  && (kc_x->u.Conscr_value_expression_list.cr_value_expression_1 == cr_value_expression_1) && (kc_x->u.Conscr_value_expression_list.cr_value_expression_list_1 == cr_value_expression_list_1) )
					return(kc_x);
	}	}	}
	KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_Conscr_value_expression_list));
	kc_hte = &(kc_a_ht->hashtable[kc_hashval][(int)kc_a_ht->mode]);
	if (kc_hte->nr >= kc_hte->ibound) kc_growindex(kc_hte, kc_a_ht);
	kc_x = (cr_value_expression_list)(*kc_a_ht->malloc)((kc_size_t)sizeof(struct kc_tag_cr_value_expression_list), kc_a_ht->malloc_private_data);
	kc_x->prod_sel = sel_Conscr_value_expression_list;
	kc_x->u.Conscr_value_expression_list.cr_value_expression_1 = cr_value_expression_1;
	kc_x->u.Conscr_value_expression_list.cr_value_expression_list_1 = cr_value_expression_list_1;
	kc_hte->index[kc_hte->nr++].yt_cr_value_expression_list = kc_x;
	return kc_x;
}

cr_value_expression CR_Term
#ifdef KC_USE_PROTOTYPES
(cr_operation_identifier cr_operation_identifier_1, cr_value_expression_list cr_value_expression_list_1, cr_sort_identifier cr_sort_identifier_1)
#else
(cr_operation_identifier_1, cr_value_expression_list_1, cr_sort_identifier_1) cr_operation_identifier cr_operation_identifier_1;  cr_value_expression_list cr_value_expression_list_1;  cr_sort_identifier cr_sort_identifier_1; 
#endif
{	register cr_value_expression kc_x;
	int kc_i;
	register kc_hashtableentry_t* kc_hte;
	unsigned kc_hashval = (unsigned)0;
	YYSTYPE *kc_ptr, *kc_beyond;
	kc_hashtable_t kc_a_ht = kc_hashtables[(int)uniq];

	assert_cr_operation_identifier( cr_operation_identifier_1, "cr_operation_identifier_1" );
	assert_cr_value_expression_list( cr_value_expression_list_1, "cr_value_expression_list_1" );
	assert_cr_sort_identifier( cr_sort_identifier_1, "cr_sort_identifier_1" );
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_CR_Term));
	OPERATORHASH((unsigned) sel_CR_Term);
	HASH(cr_operation_identifier_1);
	HASH(cr_value_expression_list_1);
	HASH(cr_sort_identifier_1);
	kc_hashval = kc_hashval%kc_a_ht->size;
	for (kc_i=0; kc_i < (int)kc_last_storage_mode; kc_i++) {
		kc_hte = &(kc_a_ht->hashtable[kc_hashval][kc_i]);
		if (kc_hte->nr != 0) {
			kc_beyond = &kc_hte->index[kc_hte->nr];
			for (kc_ptr = &kc_hte->index[0]; kc_ptr < kc_beyond; kc_ptr++){
				kc_x= kc_ptr->yt_cr_value_expression;
				if ((kc_x->prod_sel == sel_CR_Term)  && (kc_x->u.CR_Term.cr_operation_identifier_1 == cr_operation_identifier_1) && (kc_x->u.CR_Term.cr_value_expression_list_1 == cr_value_expression_list_1) && (kc_x->u.CR_Term.cr_sort_identifier_1 == cr_sort_identifier_1) )
					return(kc_x);
	}	}	}
	KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_CR_Term));
	kc_hte = &(kc_a_ht->hashtable[kc_hashval][(int)kc_a_ht->mode]);
	if (kc_hte->nr >= kc_hte->ibound) kc_growindex(kc_hte, kc_a_ht);
	kc_x = (cr_value_expression)(*kc_a_ht->malloc)((kc_size_t)sizeof(struct kc_tag_cr_value_expression), kc_a_ht->malloc_private_data);
	kc_x->prod_sel = sel_CR_Term;
	kc_x->u.CR_Term.cr_operation_identifier_1 = cr_operation_identifier_1;
	kc_x->u.CR_Term.cr_value_expression_list_1 = cr_value_expression_list_1;
	kc_x->u.CR_Term.cr_sort_identifier_1 = cr_sort_identifier_1;
	kc_hte->index[kc_hte->nr++].yt_cr_value_expression = kc_x;
	return kc_x;
}

cr_value_expression CR_Value
#ifdef KC_USE_PROTOTYPES
(cr_value_identifier cr_value_identifier_1, cr_sort_identifier cr_sort_identifier_1)
#else
(cr_value_identifier_1, cr_sort_identifier_1) cr_value_identifier cr_value_identifier_1;  cr_sort_identifier cr_sort_identifier_1; 
#endif
{	register cr_value_expression kc_x;
	int kc_i;
	register kc_hashtableentry_t* kc_hte;
	unsigned kc_hashval = (unsigned)0;
	YYSTYPE *kc_ptr, *kc_beyond;
	kc_hashtable_t kc_a_ht = kc_hashtables[(int)uniq];

	assert_cr_value_identifier( cr_value_identifier_1, "cr_value_identifier_1" );
	assert_cr_sort_identifier( cr_sort_identifier_1, "cr_sort_identifier_1" );
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_CR_Value));
	OPERATORHASH((unsigned) sel_CR_Value);
	HASH(cr_value_identifier_1);
	HASH(cr_sort_identifier_1);
	kc_hashval = kc_hashval%kc_a_ht->size;
	for (kc_i=0; kc_i < (int)kc_last_storage_mode; kc_i++) {
		kc_hte = &(kc_a_ht->hashtable[kc_hashval][kc_i]);
		if (kc_hte->nr != 0) {
			kc_beyond = &kc_hte->index[kc_hte->nr];
			for (kc_ptr = &kc_hte->index[0]; kc_ptr < kc_beyond; kc_ptr++){
				kc_x= kc_ptr->yt_cr_value_expression;
				if ((kc_x->prod_sel == sel_CR_Value)  && (kc_x->u.CR_Value.cr_value_identifier_1 == cr_value_identifier_1) && (kc_x->u.CR_Value.cr_sort_identifier_1 == cr_sort_identifier_1) )
					return(kc_x);
	}	}	}
	KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_CR_Value));
	kc_hte = &(kc_a_ht->hashtable[kc_hashval][(int)kc_a_ht->mode]);
	if (kc_hte->nr >= kc_hte->ibound) kc_growindex(kc_hte, kc_a_ht);
	kc_x = (cr_value_expression)(*kc_a_ht->malloc)((kc_size_t)sizeof(struct kc_tag_cr_value_expression), kc_a_ht->malloc_private_data);
	kc_x->prod_sel = sel_CR_Value;
	kc_x->u.CR_Value.cr_value_identifier_1 = cr_value_identifier_1;
	kc_x->u.CR_Value.cr_sort_identifier_1 = cr_sort_identifier_1;
	kc_hte->index[kc_hte->nr++].yt_cr_value_expression = kc_x;
	return kc_x;
}

cr_value_expression CR_Annotated_value_expression
#ifdef KC_USE_PROTOTYPES
(cr_value_expression cr_value_expression_1, cr_annotation_list cr_annotation_list_1)
#else
(cr_value_expression_1, cr_annotation_list_1) cr_value_expression cr_value_expression_1;  cr_annotation_list cr_annotation_list_1; 
#endif
{	register cr_value_expression kc_x;
	int kc_i;
	register kc_hashtableentry_t* kc_hte;
	unsigned kc_hashval = (unsigned)0;
	YYSTYPE *kc_ptr, *kc_beyond;
	kc_hashtable_t kc_a_ht = kc_hashtables[(int)uniq];

	assert_cr_value_expression( cr_value_expression_1, "cr_value_expression_1" );
	assert_cr_annotation_list( cr_annotation_list_1, "cr_annotation_list_1" );
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_CR_Annotated_value_expression));
	OPERATORHASH((unsigned) sel_CR_Annotated_value_expression);
	HASH(cr_value_expression_1);
	HASH(cr_annotation_list_1);
	kc_hashval = kc_hashval%kc_a_ht->size;
	for (kc_i=0; kc_i < (int)kc_last_storage_mode; kc_i++) {
		kc_hte = &(kc_a_ht->hashtable[kc_hashval][kc_i]);
		if (kc_hte->nr != 0) {
			kc_beyond = &kc_hte->index[kc_hte->nr];
			for (kc_ptr = &kc_hte->index[0]; kc_ptr < kc_beyond; kc_ptr++){
				kc_x= kc_ptr->yt_cr_value_expression;
				if ((kc_x->prod_sel == sel_CR_Annotated_value_expression)  && (kc_x->u.CR_Annotated_value_expression.cr_value_expression_1 == cr_value_expression_1) && (kc_x->u.CR_Annotated_value_expression.cr_annotation_list_1 == cr_annotation_list_1) )
					return(kc_x);
	}	}	}
	KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_CR_Annotated_value_expression));
	kc_hte = &(kc_a_ht->hashtable[kc_hashval][(int)kc_a_ht->mode]);
	if (kc_hte->nr >= kc_hte->ibound) kc_growindex(kc_hte, kc_a_ht);
	kc_x = (cr_value_expression)(*kc_a_ht->malloc)((kc_size_t)sizeof(struct kc_tag_cr_value_expression), kc_a_ht->malloc_private_data);
	kc_x->prod_sel = sel_CR_Annotated_value_expression;
	kc_x->u.CR_Annotated_value_expression.cr_value_expression_1 = cr_value_expression_1;
	kc_x->u.CR_Annotated_value_expression.cr_annotation_list_1 = cr_annotation_list_1;
	kc_hte->index[kc_hte->nr++].yt_cr_value_expression = kc_x;
	return kc_x;
}

cr_specification_identifier CR_Specification_id
#ifdef KC_USE_PROTOTYPES
(cr_identifier cr_identifier_1)
#else
(cr_identifier_1) cr_identifier cr_identifier_1; 
#endif
{	register cr_specification_identifier kc_x;
	int kc_i;
	register kc_hashtableentry_t* kc_hte;
	unsigned kc_hashval = (unsigned)0;
	YYSTYPE *kc_ptr, *kc_beyond;
	kc_hashtable_t kc_a_ht = kc_hashtables[(int)uniq];

	assert_cr_identifier( cr_identifier_1, "cr_identifier_1" );
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_CR_Specification_id));
	OPERATORHASH((unsigned) sel_CR_Specification_id);
	HASH(cr_identifier_1);
	kc_hashval = kc_hashval%kc_a_ht->size;
	for (kc_i=0; kc_i < (int)kc_last_storage_mode; kc_i++) {
		kc_hte = &(kc_a_ht->hashtable[kc_hashval][kc_i]);
		if (kc_hte->nr != 0) {
			kc_beyond = &kc_hte->index[kc_hte->nr];
			for (kc_ptr = &kc_hte->index[0]; kc_ptr < kc_beyond; kc_ptr++){
				kc_x= kc_ptr->yt_cr_specification_identifier;
				if ((kc_x->prod_sel == sel_CR_Specification_id)  && (kc_x->u.CR_Specification_id.cr_identifier_1 == cr_identifier_1) )
					return(kc_x);
	}	}	}
	KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_CR_Specification_id));
	kc_hte = &(kc_a_ht->hashtable[kc_hashval][(int)kc_a_ht->mode]);
	if (kc_hte->nr >= kc_hte->ibound) kc_growindex(kc_hte, kc_a_ht);
	kc_x = (cr_specification_identifier)(*kc_a_ht->malloc)((kc_size_t)sizeof(struct kc_tag_cr_specification_identifier), kc_a_ht->malloc_private_data);
	kc_x->prod_sel = sel_CR_Specification_id;
	kc_x->u.CR_Specification_id.cr_identifier_1 = cr_identifier_1;
	kc_hte->index[kc_hte->nr++].yt_cr_specification_identifier = kc_x;
	return kc_x;
}

cr_operation_identifier CR_Operation_id
#ifdef KC_USE_PROTOTYPES
(cr_identifier cr_identifier_1)
#else
(cr_identifier_1) cr_identifier cr_identifier_1; 
#endif
{	register cr_operation_identifier kc_x;
	int kc_i;
	register kc_hashtableentry_t* kc_hte;
	unsigned kc_hashval = (unsigned)0;
	YYSTYPE *kc_ptr, *kc_beyond;
	kc_hashtable_t kc_a_ht = kc_hashtables[(int)uniq];

	assert_cr_identifier( cr_identifier_1, "cr_identifier_1" );
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_CR_Operation_id));
	OPERATORHASH((unsigned) sel_CR_Operation_id);
	HASH(cr_identifier_1);
	kc_hashval = kc_hashval%kc_a_ht->size;
	for (kc_i=0; kc_i < (int)kc_last_storage_mode; kc_i++) {
		kc_hte = &(kc_a_ht->hashtable[kc_hashval][kc_i]);
		if (kc_hte->nr != 0) {
			kc_beyond = &kc_hte->index[kc_hte->nr];
			for (kc_ptr = &kc_hte->index[0]; kc_ptr < kc_beyond; kc_ptr++){
				kc_x= kc_ptr->yt_cr_operation_identifier;
				if ((kc_x->prod_sel == sel_CR_Operation_id)  && (kc_x->u.CR_Operation_id.cr_identifier_1 == cr_identifier_1) )
					return(kc_x);
	}	}	}
	KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_CR_Operation_id));
	kc_hte = &(kc_a_ht->hashtable[kc_hashval][(int)kc_a_ht->mode]);
	if (kc_hte->nr >= kc_hte->ibound) kc_growindex(kc_hte, kc_a_ht);
	kc_x = (cr_operation_identifier)(*kc_a_ht->malloc)((kc_size_t)sizeof(struct kc_tag_cr_operation_identifier), kc_a_ht->malloc_private_data);
	kc_x->prod_sel = sel_CR_Operation_id;
	kc_x->u.CR_Operation_id.cr_identifier_1 = cr_identifier_1;
	kc_hte->index[kc_hte->nr++].yt_cr_operation_identifier = kc_x;
	return kc_x;
}

cr_type_identifier CR_Type_id
#ifdef KC_USE_PROTOTYPES
(cr_identifier cr_identifier_1)
#else
(cr_identifier_1) cr_identifier cr_identifier_1; 
#endif
{	register cr_type_identifier kc_x;
	int kc_i;
	register kc_hashtableentry_t* kc_hte;
	unsigned kc_hashval = (unsigned)0;
	YYSTYPE *kc_ptr, *kc_beyond;
	kc_hashtable_t kc_a_ht = kc_hashtables[(int)uniq];

	assert_cr_identifier( cr_identifier_1, "cr_identifier_1" );
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_CR_Type_id));
	OPERATORHASH((unsigned) sel_CR_Type_id);
	HASH(cr_identifier_1);
	kc_hashval = kc_hashval%kc_a_ht->size;
	for (kc_i=0; kc_i < (int)kc_last_storage_mode; kc_i++) {
		kc_hte = &(kc_a_ht->hashtable[kc_hashval][kc_i]);
		if (kc_hte->nr != 0) {
			kc_beyond = &kc_hte->index[kc_hte->nr];
			for (kc_ptr = &kc_hte->index[0]; kc_ptr < kc_beyond; kc_ptr++){
				kc_x= kc_ptr->yt_cr_type_identifier;
				if ((kc_x->prod_sel == sel_CR_Type_id)  && (kc_x->u.CR_Type_id.cr_identifier_1 == cr_identifier_1) )
					return(kc_x);
	}	}	}
	KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_CR_Type_id));
	kc_hte = &(kc_a_ht->hashtable[kc_hashval][(int)kc_a_ht->mode]);
	if (kc_hte->nr >= kc_hte->ibound) kc_growindex(kc_hte, kc_a_ht);
	kc_x = (cr_type_identifier)(*kc_a_ht->malloc)((kc_size_t)sizeof(struct kc_tag_cr_type_identifier), kc_a_ht->malloc_private_data);
	kc_x->prod_sel = sel_CR_Type_id;
	kc_x->u.CR_Type_id.cr_identifier_1 = cr_identifier_1;
	kc_hte->index[kc_hte->nr++].yt_cr_type_identifier = kc_x;
	return kc_x;
}

cr_sort_identifier CR_Sort_id
#ifdef KC_USE_PROTOTYPES
(cr_identifier cr_identifier_1)
#else
(cr_identifier_1) cr_identifier cr_identifier_1; 
#endif
{	register cr_sort_identifier kc_x;
	int kc_i;
	register kc_hashtableentry_t* kc_hte;
	unsigned kc_hashval = (unsigned)0;
	YYSTYPE *kc_ptr, *kc_beyond;
	kc_hashtable_t kc_a_ht = kc_hashtables[(int)uniq];

	assert_cr_identifier( cr_identifier_1, "cr_identifier_1" );
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_CR_Sort_id));
	OPERATORHASH((unsigned) sel_CR_Sort_id);
	HASH(cr_identifier_1);
	kc_hashval = kc_hashval%kc_a_ht->size;
	for (kc_i=0; kc_i < (int)kc_last_storage_mode; kc_i++) {
		kc_hte = &(kc_a_ht->hashtable[kc_hashval][kc_i]);
		if (kc_hte->nr != 0) {
			kc_beyond = &kc_hte->index[kc_hte->nr];
			for (kc_ptr = &kc_hte->index[0]; kc_ptr < kc_beyond; kc_ptr++){
				kc_x= kc_ptr->yt_cr_sort_identifier;
				if ((kc_x->prod_sel == sel_CR_Sort_id)  && (kc_x->u.CR_Sort_id.cr_identifier_1 == cr_identifier_1) )
					return(kc_x);
	}	}	}
	KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_CR_Sort_id));
	kc_hte = &(kc_a_ht->hashtable[kc_hashval][(int)kc_a_ht->mode]);
	if (kc_hte->nr >= kc_hte->ibound) kc_growindex(kc_hte, kc_a_ht);
	kc_x = (cr_sort_identifier)(*kc_a_ht->malloc)((kc_size_t)sizeof(struct kc_tag_cr_sort_identifier), kc_a_ht->malloc_private_data);
	kc_x->prod_sel = sel_CR_Sort_id;
	kc_x->u.CR_Sort_id.cr_identifier_1 = cr_identifier_1;
	kc_hte->index[kc_hte->nr++].yt_cr_sort_identifier = kc_x;
	return kc_x;
}

cr_gate_identifier CR_Gate_id
#ifdef KC_USE_PROTOTYPES
(cr_identifier cr_identifier_1)
#else
(cr_identifier_1) cr_identifier cr_identifier_1; 
#endif
{	register cr_gate_identifier kc_x;
	int kc_i;
	register kc_hashtableentry_t* kc_hte;
	unsigned kc_hashval = (unsigned)0;
	YYSTYPE *kc_ptr, *kc_beyond;
	kc_hashtable_t kc_a_ht = kc_hashtables[(int)uniq];

	assert_cr_identifier( cr_identifier_1, "cr_identifier_1" );
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_CR_Gate_id));
	OPERATORHASH((unsigned) sel_CR_Gate_id);
	HASH(cr_identifier_1);
	kc_hashval = kc_hashval%kc_a_ht->size;
	for (kc_i=0; kc_i < (int)kc_last_storage_mode; kc_i++) {
		kc_hte = &(kc_a_ht->hashtable[kc_hashval][kc_i]);
		if (kc_hte->nr != 0) {
			kc_beyond = &kc_hte->index[kc_hte->nr];
			for (kc_ptr = &kc_hte->index[0]; kc_ptr < kc_beyond; kc_ptr++){
				kc_x= kc_ptr->yt_cr_gate_identifier;
				if ((kc_x->prod_sel == sel_CR_Gate_id)  && (kc_x->u.CR_Gate_id.cr_identifier_1 == cr_identifier_1) )
					return(kc_x);
	}	}	}
	KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_CR_Gate_id));
	kc_hte = &(kc_a_ht->hashtable[kc_hashval][(int)kc_a_ht->mode]);
	if (kc_hte->nr >= kc_hte->ibound) kc_growindex(kc_hte, kc_a_ht);
	kc_x = (cr_gate_identifier)(*kc_a_ht->malloc)((kc_size_t)sizeof(struct kc_tag_cr_gate_identifier), kc_a_ht->malloc_private_data);
	kc_x->prod_sel = sel_CR_Gate_id;
	kc_x->u.CR_Gate_id.cr_identifier_1 = cr_identifier_1;
	kc_hte->index[kc_hte->nr++].yt_cr_gate_identifier = kc_x;
	return kc_x;
}

cr_value_identifier CR_Value_id
#ifdef KC_USE_PROTOTYPES
(cr_identifier cr_identifier_1)
#else
(cr_identifier_1) cr_identifier cr_identifier_1; 
#endif
{	register cr_value_identifier kc_x;
	int kc_i;
	register kc_hashtableentry_t* kc_hte;
	unsigned kc_hashval = (unsigned)0;
	YYSTYPE *kc_ptr, *kc_beyond;
	kc_hashtable_t kc_a_ht = kc_hashtables[(int)uniq];

	assert_cr_identifier( cr_identifier_1, "cr_identifier_1" );
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_CR_Value_id));
	OPERATORHASH((unsigned) sel_CR_Value_id);
	HASH(cr_identifier_1);
	kc_hashval = kc_hashval%kc_a_ht->size;
	for (kc_i=0; kc_i < (int)kc_last_storage_mode; kc_i++) {
		kc_hte = &(kc_a_ht->hashtable[kc_hashval][kc_i]);
		if (kc_hte->nr != 0) {
			kc_beyond = &kc_hte->index[kc_hte->nr];
			for (kc_ptr = &kc_hte->index[0]; kc_ptr < kc_beyond; kc_ptr++){
				kc_x= kc_ptr->yt_cr_value_identifier;
				if ((kc_x->prod_sel == sel_CR_Value_id)  && (kc_x->u.CR_Value_id.cr_identifier_1 == cr_identifier_1) )
					return(kc_x);
	}	}	}
	KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_CR_Value_id));
	kc_hte = &(kc_a_ht->hashtable[kc_hashval][(int)kc_a_ht->mode]);
	if (kc_hte->nr >= kc_hte->ibound) kc_growindex(kc_hte, kc_a_ht);
	kc_x = (cr_value_identifier)(*kc_a_ht->malloc)((kc_size_t)sizeof(struct kc_tag_cr_value_identifier), kc_a_ht->malloc_private_data);
	kc_x->prod_sel = sel_CR_Value_id;
	kc_x->u.CR_Value_id.cr_identifier_1 = cr_identifier_1;
	kc_hte->index[kc_hte->nr++].yt_cr_value_identifier = kc_x;
	return kc_x;
}

cr_process_identifier CR_Process_id
#ifdef KC_USE_PROTOTYPES
(cr_identifier cr_identifier_1)
#else
(cr_identifier_1) cr_identifier cr_identifier_1; 
#endif
{	register cr_process_identifier kc_x;
	int kc_i;
	register kc_hashtableentry_t* kc_hte;
	unsigned kc_hashval = (unsigned)0;
	YYSTYPE *kc_ptr, *kc_beyond;
	kc_hashtable_t kc_a_ht = kc_hashtables[(int)uniq];

	assert_cr_identifier( cr_identifier_1, "cr_identifier_1" );
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_CR_Process_id));
	OPERATORHASH((unsigned) sel_CR_Process_id);
	HASH(cr_identifier_1);
	kc_hashval = kc_hashval%kc_a_ht->size;
	for (kc_i=0; kc_i < (int)kc_last_storage_mode; kc_i++) {
		kc_hte = &(kc_a_ht->hashtable[kc_hashval][kc_i]);
		if (kc_hte->nr != 0) {
			kc_beyond = &kc_hte->index[kc_hte->nr];
			for (kc_ptr = &kc_hte->index[0]; kc_ptr < kc_beyond; kc_ptr++){
				kc_x= kc_ptr->yt_cr_process_identifier;
				if ((kc_x->prod_sel == sel_CR_Process_id)  && (kc_x->u.CR_Process_id.cr_identifier_1 == cr_identifier_1) )
					return(kc_x);
	}	}	}
	KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_CR_Process_id));
	kc_hte = &(kc_a_ht->hashtable[kc_hashval][(int)kc_a_ht->mode]);
	if (kc_hte->nr >= kc_hte->ibound) kc_growindex(kc_hte, kc_a_ht);
	kc_x = (cr_process_identifier)(*kc_a_ht->malloc)((kc_size_t)sizeof(struct kc_tag_cr_process_identifier), kc_a_ht->malloc_private_data);
	kc_x->prod_sel = sel_CR_Process_id;
	kc_x->u.CR_Process_id.cr_identifier_1 = cr_identifier_1;
	kc_hte->index[kc_hte->nr++].yt_cr_process_identifier = kc_x;
	return kc_x;
}

cr_identifier CR_Identifier
#ifdef KC_USE_PROTOTYPES
(nocasestring nocasestring_1, cr_extension cr_extension_1)
#else
(nocasestring_1, cr_extension_1) nocasestring nocasestring_1;  cr_extension cr_extension_1; 
#endif
{	register cr_identifier kc_x;
	int kc_i;
	register kc_hashtableentry_t* kc_hte;
	unsigned kc_hashval = (unsigned)0;
	YYSTYPE *kc_ptr, *kc_beyond;
	kc_hashtable_t kc_a_ht = kc_hashtables[(int)uniq];

	assert_nocasestring( nocasestring_1, "nocasestring_1" );
	assert_cr_extension( cr_extension_1, "cr_extension_1" );
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_CR_Identifier));
	OPERATORHASH((unsigned) sel_CR_Identifier);
	HASH(nocasestring_1);
	HASH(cr_extension_1);
	kc_hashval = kc_hashval%kc_a_ht->size;
	for (kc_i=0; kc_i < (int)kc_last_storage_mode; kc_i++) {
		kc_hte = &(kc_a_ht->hashtable[kc_hashval][kc_i]);
		if (kc_hte->nr != 0) {
			kc_beyond = &kc_hte->index[kc_hte->nr];
			for (kc_ptr = &kc_hte->index[0]; kc_ptr < kc_beyond; kc_ptr++){
				kc_x= kc_ptr->yt_cr_identifier;
				if ((kc_x->prod_sel == sel_CR_Identifier)  && (kc_x->u.CR_Identifier.nocasestring_1 == nocasestring_1) && (kc_x->u.CR_Identifier.cr_extension_1 == cr_extension_1) )
					return(kc_x);
	}	}	}
	KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_CR_Identifier));
	kc_hte = &(kc_a_ht->hashtable[kc_hashval][(int)kc_a_ht->mode]);
	if (kc_hte->nr >= kc_hte->ibound) kc_growindex(kc_hte, kc_a_ht);
	kc_x = (cr_identifier)(*kc_a_ht->malloc)((kc_size_t)sizeof(struct kc_tag_cr_identifier), kc_a_ht->malloc_private_data);
	kc_x->prod_sel = sel_CR_Identifier;
	kc_x->u.CR_Identifier.nocasestring_1 = nocasestring_1;
	kc_x->u.CR_Identifier.cr_extension_1 = cr_extension_1;
	kc_hte->index[kc_hte->nr++].yt_cr_identifier = kc_x;
	return kc_x;
}

cr_extension CR_NullExtension
#ifdef KC_USE_PROTOTYPES
()
#else
()
#endif
{	static cr_extension kc_x = (cr_extension)0;
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_CR_NullExtension));
	if (kc_x == (cr_extension)0) {
		KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_CR_NullExtension ));
		kc_x = (cr_extension)(*kc_hashtables[(int)kc_uniq_nullary_operator]->malloc)((kc_size_t)sizeof(struct kc_tag_cr_extension), kc_hashtables[(int)kc_uniq_nullary_operator]->malloc_private_data);
		kc_x->prod_sel = sel_CR_NullExtension;
	}
	return kc_x;
}

cr_extension CR_DefExtension
#ifdef KC_USE_PROTOTYPES
(nocasestring nocasestring_1)
#else
(nocasestring_1) nocasestring nocasestring_1; 
#endif
{	register cr_extension kc_x;
	int kc_i;
	register kc_hashtableentry_t* kc_hte;
	unsigned kc_hashval = (unsigned)0;
	YYSTYPE *kc_ptr, *kc_beyond;
	kc_hashtable_t kc_a_ht = kc_hashtables[(int)uniq];

	assert_nocasestring( nocasestring_1, "nocasestring_1" );
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_CR_DefExtension));
	OPERATORHASH((unsigned) sel_CR_DefExtension);
	HASH(nocasestring_1);
	kc_hashval = kc_hashval%kc_a_ht->size;
	for (kc_i=0; kc_i < (int)kc_last_storage_mode; kc_i++) {
		kc_hte = &(kc_a_ht->hashtable[kc_hashval][kc_i]);
		if (kc_hte->nr != 0) {
			kc_beyond = &kc_hte->index[kc_hte->nr];
			for (kc_ptr = &kc_hte->index[0]; kc_ptr < kc_beyond; kc_ptr++){
				kc_x= kc_ptr->yt_cr_extension;
				if ((kc_x->prod_sel == sel_CR_DefExtension)  && (kc_x->u.CR_DefExtension.nocasestring_1 == nocasestring_1) )
					return(kc_x);
	}	}	}
	KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_CR_DefExtension));
	kc_hte = &(kc_a_ht->hashtable[kc_hashval][(int)kc_a_ht->mode]);
	if (kc_hte->nr >= kc_hte->ibound) kc_growindex(kc_hte, kc_a_ht);
	kc_x = (cr_extension)(*kc_a_ht->malloc)((kc_size_t)sizeof(struct kc_tag_cr_extension), kc_a_ht->malloc_private_data);
	kc_x->prod_sel = sel_CR_DefExtension;
	kc_x->u.CR_DefExtension.nocasestring_1 = nocasestring_1;
	kc_hte->index[kc_hte->nr++].yt_cr_extension = kc_x;
	return kc_x;
}

cr_operation_name CR_Operation_name
#ifdef KC_USE_PROTOTYPES
(cr_name cr_name_1)
#else
(cr_name_1) cr_name cr_name_1; 
#endif
{	register cr_operation_name kc_x;
	int kc_i;
	register kc_hashtableentry_t* kc_hte;
	unsigned kc_hashval = (unsigned)0;
	YYSTYPE *kc_ptr, *kc_beyond;
	kc_hashtable_t kc_a_ht = kc_hashtables[(int)uniq];

	assert_cr_name( cr_name_1, "cr_name_1" );
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_CR_Operation_name));
	OPERATORHASH((unsigned) sel_CR_Operation_name);
	HASH(cr_name_1);
	kc_hashval = kc_hashval%kc_a_ht->size;
	for (kc_i=0; kc_i < (int)kc_last_storage_mode; kc_i++) {
		kc_hte = &(kc_a_ht->hashtable[kc_hashval][kc_i]);
		if (kc_hte->nr != 0) {
			kc_beyond = &kc_hte->index[kc_hte->nr];
			for (kc_ptr = &kc_hte->index[0]; kc_ptr < kc_beyond; kc_ptr++){
				kc_x= kc_ptr->yt_cr_operation_name;
				if ((kc_x->prod_sel == sel_CR_Operation_name)  && (kc_x->u.CR_Operation_name.cr_name_1 == cr_name_1) )
					return(kc_x);
	}	}	}
	KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_CR_Operation_name));
	kc_hte = &(kc_a_ht->hashtable[kc_hashval][(int)kc_a_ht->mode]);
	if (kc_hte->nr >= kc_hte->ibound) kc_growindex(kc_hte, kc_a_ht);
	kc_x = (cr_operation_name)(*kc_a_ht->malloc)((kc_size_t)sizeof(struct kc_tag_cr_operation_name), kc_a_ht->malloc_private_data);
	kc_x->prod_sel = sel_CR_Operation_name;
	kc_x->u.CR_Operation_name.cr_name_1 = cr_name_1;
	kc_hte->index[kc_hte->nr++].yt_cr_operation_name = kc_x;
	return kc_x;
}

cr_sort_name CR_Sort_name
#ifdef KC_USE_PROTOTYPES
(cr_name cr_name_1)
#else
(cr_name_1) cr_name cr_name_1; 
#endif
{	register cr_sort_name kc_x;
	int kc_i;
	register kc_hashtableentry_t* kc_hte;
	unsigned kc_hashval = (unsigned)0;
	YYSTYPE *kc_ptr, *kc_beyond;
	kc_hashtable_t kc_a_ht = kc_hashtables[(int)uniq];

	assert_cr_name( cr_name_1, "cr_name_1" );
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_CR_Sort_name));
	OPERATORHASH((unsigned) sel_CR_Sort_name);
	HASH(cr_name_1);
	kc_hashval = kc_hashval%kc_a_ht->size;
	for (kc_i=0; kc_i < (int)kc_last_storage_mode; kc_i++) {
		kc_hte = &(kc_a_ht->hashtable[kc_hashval][kc_i]);
		if (kc_hte->nr != 0) {
			kc_beyond = &kc_hte->index[kc_hte->nr];
			for (kc_ptr = &kc_hte->index[0]; kc_ptr < kc_beyond; kc_ptr++){
				kc_x= kc_ptr->yt_cr_sort_name;
				if ((kc_x->prod_sel == sel_CR_Sort_name)  && (kc_x->u.CR_Sort_name.cr_name_1 == cr_name_1) )
					return(kc_x);
	}	}	}
	KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_CR_Sort_name));
	kc_hte = &(kc_a_ht->hashtable[kc_hashval][(int)kc_a_ht->mode]);
	if (kc_hte->nr >= kc_hte->ibound) kc_growindex(kc_hte, kc_a_ht);
	kc_x = (cr_sort_name)(*kc_a_ht->malloc)((kc_size_t)sizeof(struct kc_tag_cr_sort_name), kc_a_ht->malloc_private_data);
	kc_x->prod_sel = sel_CR_Sort_name;
	kc_x->u.CR_Sort_name.cr_name_1 = cr_name_1;
	kc_hte->index[kc_hte->nr++].yt_cr_sort_name = kc_x;
	return kc_x;
}

cr_name CR_Name
#ifdef KC_USE_PROTOTYPES
(nocasestring nocasestring_1)
#else
(nocasestring_1) nocasestring nocasestring_1; 
#endif
{	register cr_name kc_x;
	int kc_i;
	register kc_hashtableentry_t* kc_hte;
	unsigned kc_hashval = (unsigned)0;
	YYSTYPE *kc_ptr, *kc_beyond;
	kc_hashtable_t kc_a_ht = kc_hashtables[(int)uniq];

	assert_nocasestring( nocasestring_1, "nocasestring_1" );
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_CR_Name));
	OPERATORHASH((unsigned) sel_CR_Name);
	HASH(nocasestring_1);
	kc_hashval = kc_hashval%kc_a_ht->size;
	for (kc_i=0; kc_i < (int)kc_last_storage_mode; kc_i++) {
		kc_hte = &(kc_a_ht->hashtable[kc_hashval][kc_i]);
		if (kc_hte->nr != 0) {
			kc_beyond = &kc_hte->index[kc_hte->nr];
			for (kc_ptr = &kc_hte->index[0]; kc_ptr < kc_beyond; kc_ptr++){
				kc_x= kc_ptr->yt_cr_name;
				if ((kc_x->prod_sel == sel_CR_Name)  && (kc_x->u.CR_Name.nocasestring_1 == nocasestring_1) )
					return(kc_x);
	}	}	}
	KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_CR_Name));
	kc_hte = &(kc_a_ht->hashtable[kc_hashval][(int)kc_a_ht->mode]);
	if (kc_hte->nr >= kc_hte->ibound) kc_growindex(kc_hte, kc_a_ht);
	kc_x = (cr_name)(*kc_a_ht->malloc)((kc_size_t)sizeof(struct kc_tag_cr_name), kc_a_ht->malloc_private_data);
	kc_x->prod_sel = sel_CR_Name;
	kc_x->u.CR_Name.nocasestring_1 = nocasestring_1;
	kc_hte->index[kc_hte->nr++].yt_cr_name = kc_x;
	return kc_x;
}

cr_comment_list Nilcr_comment_list
#ifdef KC_USE_PROTOTYPES
()
#else
()
#endif
{	static cr_comment_list kc_x = (cr_comment_list)0;
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_Nilcr_comment_list));
	if (kc_x == (cr_comment_list)0) {
		KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_Nilcr_comment_list ));
		kc_x = (cr_comment_list)(*kc_hashtables[(int)kc_uniq_nullary_operator]->malloc)((kc_size_t)sizeof(struct kc_tag_cr_comment_list), kc_hashtables[(int)kc_uniq_nullary_operator]->malloc_private_data);
		kc_x->prod_sel = sel_Nilcr_comment_list;
	}
	return kc_x;
}

cr_comment_list Conscr_comment_list
#ifdef KC_USE_PROTOTYPES
(casestring casestring_1, cr_comment_list cr_comment_list_1)
#else
(casestring_1, cr_comment_list_1) casestring casestring_1;  cr_comment_list cr_comment_list_1; 
#endif
{	register cr_comment_list kc_x;
	int kc_i;
	register kc_hashtableentry_t* kc_hte;
	unsigned kc_hashval = (unsigned)0;
	YYSTYPE *kc_ptr, *kc_beyond;
	kc_hashtable_t kc_a_ht = kc_hashtables[(int)uniq];

	assert_casestring( casestring_1, "casestring_1" );
	assert_cr_comment_list( cr_comment_list_1, "cr_comment_list_1" );
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_Conscr_comment_list));
	OPERATORHASH((unsigned) sel_Conscr_comment_list);
	HASH(casestring_1);
	HASH(cr_comment_list_1);
	kc_hashval = kc_hashval%kc_a_ht->size;
	for (kc_i=0; kc_i < (int)kc_last_storage_mode; kc_i++) {
		kc_hte = &(kc_a_ht->hashtable[kc_hashval][kc_i]);
		if (kc_hte->nr != 0) {
			kc_beyond = &kc_hte->index[kc_hte->nr];
			for (kc_ptr = &kc_hte->index[0]; kc_ptr < kc_beyond; kc_ptr++){
				kc_x= kc_ptr->yt_cr_comment_list;
				if ((kc_x->prod_sel == sel_Conscr_comment_list)  && (kc_x->u.Conscr_comment_list.casestring_1 == casestring_1) && (kc_x->u.Conscr_comment_list.cr_comment_list_1 == cr_comment_list_1) )
					return(kc_x);
	}	}	}
	KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_Conscr_comment_list));
	kc_hte = &(kc_a_ht->hashtable[kc_hashval][(int)kc_a_ht->mode]);
	if (kc_hte->nr >= kc_hte->ibound) kc_growindex(kc_hte, kc_a_ht);
	kc_x = (cr_comment_list)(*kc_a_ht->malloc)((kc_size_t)sizeof(struct kc_tag_cr_comment_list), kc_a_ht->malloc_private_data);
	kc_x->prod_sel = sel_Conscr_comment_list;
	kc_x->u.Conscr_comment_list.casestring_1 = casestring_1;
	kc_x->u.Conscr_comment_list.cr_comment_list_1 = cr_comment_list_1;
	kc_hte->index[kc_hte->nr++].yt_cr_comment_list = kc_x;
	return kc_x;
}

cr_annotation_list Nilcr_annotation_list
#ifdef KC_USE_PROTOTYPES
()
#else
()
#endif
{	static cr_annotation_list kc_x = (cr_annotation_list)0;
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_Nilcr_annotation_list));
	if (kc_x == (cr_annotation_list)0) {
		KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_Nilcr_annotation_list ));
		kc_x = (cr_annotation_list)(*kc_hashtables[(int)kc_uniq_nullary_operator]->malloc)((kc_size_t)sizeof(struct kc_tag_cr_annotation_list), kc_hashtables[(int)kc_uniq_nullary_operator]->malloc_private_data);
		kc_x->prod_sel = sel_Nilcr_annotation_list;
	}
	return kc_x;
}

cr_annotation_list Conscr_annotation_list
#ifdef KC_USE_PROTOTYPES
(casestring casestring_1, cr_annotation_list cr_annotation_list_1)
#else
(casestring_1, cr_annotation_list_1) casestring casestring_1;  cr_annotation_list cr_annotation_list_1; 
#endif
{	register cr_annotation_list kc_x;
	int kc_i;
	register kc_hashtableentry_t* kc_hte;
	unsigned kc_hashval = (unsigned)0;
	YYSTYPE *kc_ptr, *kc_beyond;
	kc_hashtable_t kc_a_ht = kc_hashtables[(int)uniq];

	assert_casestring( casestring_1, "casestring_1" );
	assert_cr_annotation_list( cr_annotation_list_1, "cr_annotation_list_1" );
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_Conscr_annotation_list));
	OPERATORHASH((unsigned) sel_Conscr_annotation_list);
	HASH(casestring_1);
	HASH(cr_annotation_list_1);
	kc_hashval = kc_hashval%kc_a_ht->size;
	for (kc_i=0; kc_i < (int)kc_last_storage_mode; kc_i++) {
		kc_hte = &(kc_a_ht->hashtable[kc_hashval][kc_i]);
		if (kc_hte->nr != 0) {
			kc_beyond = &kc_hte->index[kc_hte->nr];
			for (kc_ptr = &kc_hte->index[0]; kc_ptr < kc_beyond; kc_ptr++){
				kc_x= kc_ptr->yt_cr_annotation_list;
				if ((kc_x->prod_sel == sel_Conscr_annotation_list)  && (kc_x->u.Conscr_annotation_list.casestring_1 == casestring_1) && (kc_x->u.Conscr_annotation_list.cr_annotation_list_1 == cr_annotation_list_1) )
					return(kc_x);
	}	}	}
	KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_Conscr_annotation_list));
	kc_hte = &(kc_a_ht->hashtable[kc_hashval][(int)kc_a_ht->mode]);
	if (kc_hte->nr >= kc_hte->ibound) kc_growindex(kc_hte, kc_a_ht);
	kc_x = (cr_annotation_list)(*kc_a_ht->malloc)((kc_size_t)sizeof(struct kc_tag_cr_annotation_list), kc_a_ht->malloc_private_data);
	kc_x->prod_sel = sel_Conscr_annotation_list;
	kc_x->u.Conscr_annotation_list.casestring_1 = casestring_1;
	kc_x->u.Conscr_annotation_list.cr_annotation_list_1 = cr_annotation_list_1;
	kc_hte->index[kc_hte->nr++].yt_cr_annotation_list = kc_x;
	return kc_x;
}

cr_LABEL CR_Label
#ifdef KC_USE_PROTOTYPES
(casestring casestring_1)
#else
(casestring_1) casestring casestring_1; 
#endif
{	register cr_LABEL kc_x;
	int kc_i;
	register kc_hashtableentry_t* kc_hte;
	unsigned kc_hashval = (unsigned)0;
	YYSTYPE *kc_ptr, *kc_beyond;
	kc_hashtable_t kc_a_ht = kc_hashtables[(int)uniq];

	assert_casestring( casestring_1, "casestring_1" );
	KC_COLLECT_STATS0(KC_CREATE_STATS(sel_CR_Label));
	OPERATORHASH((unsigned) sel_CR_Label);
	HASH(casestring_1);
	kc_hashval = kc_hashval%kc_a_ht->size;
	for (kc_i=0; kc_i < (int)kc_last_storage_mode; kc_i++) {
		kc_hte = &(kc_a_ht->hashtable[kc_hashval][kc_i]);
		if (kc_hte->nr != 0) {
			kc_beyond = &kc_hte->index[kc_hte->nr];
			for (kc_ptr = &kc_hte->index[0]; kc_ptr < kc_beyond; kc_ptr++){
				kc_x= kc_ptr->yt_cr_LABEL;
				if ((kc_x->prod_sel == sel_CR_Label)  && (kc_x->u.CR_Label.casestring_1 == casestring_1) )
					return(kc_x);
	}	}	}
	KC_COLLECT_STATS0(KC_EXISTINGNOTFOUND_STATS(sel_CR_Label));
	kc_hte = &(kc_a_ht->hashtable[kc_hashval][(int)kc_a_ht->mode]);
	if (kc_hte->nr >= kc_hte->ibound) kc_growindex(kc_hte, kc_a_ht);
	kc_x = (cr_LABEL)(*kc_a_ht->malloc)((kc_size_t)sizeof(struct kc_tag_cr_LABEL), kc_a_ht->malloc_private_data);
	kc_x->prod_sel = sel_CR_Label;
	kc_x->u.CR_Label.casestring_1 = casestring_1;
	kc_hte->index[kc_hte->nr++].yt_cr_LABEL = kc_x;
	return kc_x;
}

char *kc_phylumname_or_error
#ifdef KC_USE_PROTOTYPES
(int kc_phylum)
#else
(kc_phylum) int kc_phylum;
#endif
{	if ((kc_phylum <= (int)kc_one_before_first_phylum) || (kc_phylum >= (int)kc_last_phylum)) {
		char *kc_strof_error;
		(void)sprintf((kc_strof_error=(char*)MALLOC(69)), "Internal Error: unknown phylum number: %d", kc_phylum);
		return kc_strof_error;
	} else {
		return kc_PhylumInfo[kc_phylum].name;
}	}


char *kc_operatorname_or_error( kc_operator ) int kc_operator;
{	if ((kc_operator <= (int)kc_one_before_first_operator) || (kc_operator >= (int)kc_last_operator)) {
		char *kc_strof_error;
		(void)sprintf((kc_strof_error=(char*)MALLOC(71)), "Internal Error: unknown operator number: %d", kc_operator);
		return kc_strof_error;
	} else {
		return kc_OperatorInfo[kc_operator].name;
}	}

/*ARGSUSED*/ static void kc_do_free_phylum
#ifdef KC_USE_PROTOTYPES
(kc_voidptr_t kc_p, boolean kc_rec, kc_enum_phyla kc_phylum)
#else
(kc_p, kc_rec, kc_phylum) kc_voidptr_t kc_p; boolean kc_rec; kc_enum_phyla kc_phylum;
#endif
{	kc_enum_operators kc_prodsel;
	KC_OPERATOR_INFO *kc_op_info;
	assertPhylum(((casestring)kc_p),"kc_p",kc_phylum);
	kc_prodsel = (kc_phylum == kc_phylum_int ? sel__Int : (kc_phylum == kc_phylum_float ? sel__Real :((casestring)kc_p)->prod_sel));
	kc_op_info = &kc_OperatorInfo[(int)kc_prodsel];
	KC_COLLECT_STATS0(KC_FREE_CALLED_STATS((int)kc_prodsel, kc_rec));
	if (! kc_op_info->uniq_stored) {
		if (kc_rec) {
			int kc_i;
			for (kc_i=0; kc_i < kc_op_info->no_sons; kc_i++) {
				kc_do_free_phylum( (kc_voidptr_t)KC_SUBPHYLUM(kc_p, kc_op_info->suboffset[kc_i]), kc_rec, kc_op_info->subphylum[kc_i] );
		}	}
		KC_COLLECT_STATS0(KC_FREED_STATS((int)kc_prodsel, kc_rec));
		KC_BZERO((kc_voidptr_t)kc_p, kc_PhylumInfo[(int)kc_phylum].size);
		NONUNIQFREE((kc_voidptr_t)kc_p);
}	}	
/*ARGSUSED*/ void free_nocasestring
#ifdef KC_USE_PROTOTYPES
(nocasestring kc_p, boolean kc_rec)
#else
(kc_p, kc_rec) nocasestring kc_p; boolean kc_rec;
#endif
{ KC_COLLECT_STATS0(KC_FREE_CALLED_STATS((int)sel_NoCaseStr, kc_rec)); }
/*ARGSUSED*/ void free_casestring
#ifdef KC_USE_PROTOTYPES
(casestring kc_p, boolean kc_rec)
#else
(kc_p, kc_rec) casestring kc_p; boolean kc_rec;
#endif
{ KC_COLLECT_STATS0(KC_FREE_CALLED_STATS((int)sel__Str, kc_rec)); }
/*ARGSUSED*/ void free_float
#ifdef KC_USE_PROTOTYPES
(float kc_p, boolean kc_rec)
#else
(kc_p, kc_rec) float kc_p; boolean kc_rec;
#endif
{ KC_COLLECT_STATS0(KC_FREE_CALLED_STATS((int)sel__Real, kc_rec)); }
/*ARGSUSED*/ void free_int
#ifdef KC_USE_PROTOTYPES
(int kc_p, boolean kc_rec)
#else
(kc_p, kc_rec) int kc_p; boolean kc_rec;
#endif
{ KC_COLLECT_STATS0(KC_FREE_CALLED_STATS((int)sel__Int, kc_rec)); }
/*ARGSUSED*/ void free_cr_specification
#ifdef KC_USE_PROTOTYPES
(cr_specification kc_p, boolean kc_rec)
#else
(kc_p, kc_rec) cr_specification kc_p; boolean kc_rec;
#endif
{ kc_do_free_phylum( (kc_voidptr_t)kc_p, kc_rec, kc_phylum_cr_specification);  }
/*ARGSUSED*/ void free_cr_specification_type
#ifdef KC_USE_PROTOTYPES
(cr_specification_type kc_p, boolean kc_rec)
#else
(kc_p, kc_rec) cr_specification_type kc_p; boolean kc_rec;
#endif
{ kc_do_free_phylum( (kc_voidptr_t)kc_p, kc_rec, kc_phylum_cr_specification_type);  }
/*ARGSUSED*/ void free_cr_boolean_indication
#ifdef KC_USE_PROTOTYPES
(cr_boolean_indication kc_p, boolean kc_rec)
#else
(kc_p, kc_rec) cr_boolean_indication kc_p; boolean kc_rec;
#endif
{ kc_do_free_phylum( (kc_voidptr_t)kc_p, kc_rec, kc_phylum_cr_boolean_indication);  }
/*ARGSUSED*/ void free_cr_definition_block
#ifdef KC_USE_PROTOTYPES
(cr_definition_block kc_p, boolean kc_rec)
#else
(kc_p, kc_rec) cr_definition_block kc_p; boolean kc_rec;
#endif
{ kc_do_free_phylum( (kc_voidptr_t)kc_p, kc_rec, kc_phylum_cr_definition_block);  }
/*ARGSUSED*/ void free_cr_process_definition_list
#ifdef KC_USE_PROTOTYPES
(cr_process_definition_list kc_p, boolean kc_rec)
#else
(kc_p, kc_rec) cr_process_definition_list kc_p; boolean kc_rec;
#endif
{ kc_do_free_phylum( (kc_voidptr_t)kc_p, kc_rec, kc_phylum_cr_process_definition_list);  }
/*ARGSUSED*/ void free_cr_process_definition
#ifdef KC_USE_PROTOTYPES
(cr_process_definition kc_p, boolean kc_rec)
#else
(kc_p, kc_rec) cr_process_definition kc_p; boolean kc_rec;
#endif
{ kc_do_free_phylum( (kc_voidptr_t)kc_p, kc_rec, kc_phylum_cr_process_definition);  }
/*ARGSUSED*/ void free_cr_functionality
#ifdef KC_USE_PROTOTYPES
(cr_functionality kc_p, boolean kc_rec)
#else
(kc_p, kc_rec) cr_functionality kc_p; boolean kc_rec;
#endif
{ kc_do_free_phylum( (kc_voidptr_t)kc_p, kc_rec, kc_phylum_cr_functionality);  }
/*ARGSUSED*/ void free_cr_sort_identifier_list
#ifdef KC_USE_PROTOTYPES
(cr_sort_identifier_list kc_p, boolean kc_rec)
#else
(kc_p, kc_rec) cr_sort_identifier_list kc_p; boolean kc_rec;
#endif
{ kc_do_free_phylum( (kc_voidptr_t)kc_p, kc_rec, kc_phylum_cr_sort_identifier_list);  }
/*ARGSUSED*/ void free_cr_data_type_definition_list
#ifdef KC_USE_PROTOTYPES
(cr_data_type_definition_list kc_p, boolean kc_rec)
#else
(kc_p, kc_rec) cr_data_type_definition_list kc_p; boolean kc_rec;
#endif
{ kc_do_free_phylum( (kc_voidptr_t)kc_p, kc_rec, kc_phylum_cr_data_type_definition_list);  }
/*ARGSUSED*/ void free_cr_data_type_definition
#ifdef KC_USE_PROTOTYPES
(cr_data_type_definition kc_p, boolean kc_rec)
#else
(kc_p, kc_rec) cr_data_type_definition kc_p; boolean kc_rec;
#endif
{ kc_do_free_phylum( (kc_voidptr_t)kc_p, kc_rec, kc_phylum_cr_data_type_definition);  }
/*ARGSUSED*/ void free_cr_completeness_indication
#ifdef KC_USE_PROTOTYPES
(cr_completeness_indication kc_p, boolean kc_rec)
#else
(kc_p, kc_rec) cr_completeness_indication kc_p; boolean kc_rec;
#endif
{ kc_do_free_phylum( (kc_voidptr_t)kc_p, kc_rec, kc_phylum_cr_completeness_indication);  }
/*ARGSUSED*/ void free_cr_persistency_indication
#ifdef KC_USE_PROTOTYPES
(cr_persistency_indication kc_p, boolean kc_rec)
#else
(kc_p, kc_rec) cr_persistency_indication kc_p; boolean kc_rec;
#endif
{ kc_do_free_phylum( (kc_voidptr_t)kc_p, kc_rec, kc_phylum_cr_persistency_indication);  }
/*ARGSUSED*/ void free_cr_p_expression
#ifdef KC_USE_PROTOTYPES
(cr_p_expression kc_p, boolean kc_rec)
#else
(kc_p, kc_rec) cr_p_expression kc_p; boolean kc_rec;
#endif
{ kc_do_free_phylum( (kc_voidptr_t)kc_p, kc_rec, kc_phylum_cr_p_expression);  }
/*ARGSUSED*/ void free_cr_type_identifier_list
#ifdef KC_USE_PROTOTYPES
(cr_type_identifier_list kc_p, boolean kc_rec)
#else
(kc_p, kc_rec) cr_type_identifier_list kc_p; boolean kc_rec;
#endif
{ kc_do_free_phylum( (kc_voidptr_t)kc_p, kc_rec, kc_phylum_cr_type_identifier_list);  }
/*ARGSUSED*/ void free_cr_replacement
#ifdef KC_USE_PROTOTYPES
(cr_replacement kc_p, boolean kc_rec)
#else
(kc_p, kc_rec) cr_replacement kc_p; boolean kc_rec;
#endif
{ kc_do_free_phylum( (kc_voidptr_t)kc_p, kc_rec, kc_phylum_cr_replacement);  }
/*ARGSUSED*/ void free_cr_sort_replacement_list
#ifdef KC_USE_PROTOTYPES
(cr_sort_replacement_list kc_p, boolean kc_rec)
#else
(kc_p, kc_rec) cr_sort_replacement_list kc_p; boolean kc_rec;
#endif
{ kc_do_free_phylum( (kc_voidptr_t)kc_p, kc_rec, kc_phylum_cr_sort_replacement_list);  }
/*ARGSUSED*/ void free_cr_sort_replacement
#ifdef KC_USE_PROTOTYPES
(cr_sort_replacement kc_p, boolean kc_rec)
#else
(kc_p, kc_rec) cr_sort_replacement kc_p; boolean kc_rec;
#endif
{ kc_do_free_phylum( (kc_voidptr_t)kc_p, kc_rec, kc_phylum_cr_sort_replacement);  }
/*ARGSUSED*/ void free_cr_sort_declaration_list
#ifdef KC_USE_PROTOTYPES
(cr_sort_declaration_list kc_p, boolean kc_rec)
#else
(kc_p, kc_rec) cr_sort_declaration_list kc_p; boolean kc_rec;
#endif
{ kc_do_free_phylum( (kc_voidptr_t)kc_p, kc_rec, kc_phylum_cr_sort_declaration_list);  }
/*ARGSUSED*/ void free_cr_sort_declaration
#ifdef KC_USE_PROTOTYPES
(cr_sort_declaration kc_p, boolean kc_rec)
#else
(kc_p, kc_rec) cr_sort_declaration kc_p; boolean kc_rec;
#endif
{ kc_do_free_phylum( (kc_voidptr_t)kc_p, kc_rec, kc_phylum_cr_sort_declaration);  }
/*ARGSUSED*/ void free_cr_operation_replacement_list
#ifdef KC_USE_PROTOTYPES
(cr_operation_replacement_list kc_p, boolean kc_rec)
#else
(kc_p, kc_rec) cr_operation_replacement_list kc_p; boolean kc_rec;
#endif
{ kc_do_free_phylum( (kc_voidptr_t)kc_p, kc_rec, kc_phylum_cr_operation_replacement_list);  }
/*ARGSUSED*/ void free_cr_operation_replacement
#ifdef KC_USE_PROTOTYPES
(cr_operation_replacement kc_p, boolean kc_rec)
#else
(kc_p, kc_rec) cr_operation_replacement kc_p; boolean kc_rec;
#endif
{ kc_do_free_phylum( (kc_voidptr_t)kc_p, kc_rec, kc_phylum_cr_operation_replacement);  }
/*ARGSUSED*/ void free_cr_flattened_type_definition
#ifdef KC_USE_PROTOTYPES
(cr_flattened_type_definition kc_p, boolean kc_rec)
#else
(kc_p, kc_rec) cr_flattened_type_definition kc_p; boolean kc_rec;
#endif
{ kc_do_free_phylum( (kc_voidptr_t)kc_p, kc_rec, kc_phylum_cr_flattened_type_definition);  }
/*ARGSUSED*/ void free_cr_operation_list
#ifdef KC_USE_PROTOTYPES
(cr_operation_list kc_p, boolean kc_rec)
#else
(kc_p, kc_rec) cr_operation_list kc_p; boolean kc_rec;
#endif
{ kc_do_free_phylum( (kc_voidptr_t)kc_p, kc_rec, kc_phylum_cr_operation_list);  }
/*ARGSUSED*/ void free_cr_operation
#ifdef KC_USE_PROTOTYPES
(cr_operation kc_p, boolean kc_rec)
#else
(kc_p, kc_rec) cr_operation kc_p; boolean kc_rec;
#endif
{ kc_do_free_phylum( (kc_voidptr_t)kc_p, kc_rec, kc_phylum_cr_operation);  }
/*ARGSUSED*/ void free_cr_prefix_infix
#ifdef KC_USE_PROTOTYPES
(cr_prefix_infix kc_p, boolean kc_rec)
#else
(kc_p, kc_rec) cr_prefix_infix kc_p; boolean kc_rec;
#endif
{ kc_do_free_phylum( (kc_voidptr_t)kc_p, kc_rec, kc_phylum_cr_prefix_infix);  }
/*ARGSUSED*/ void free_cr_rewrite_strategy
#ifdef KC_USE_PROTOTYPES
(cr_rewrite_strategy kc_p, boolean kc_rec)
#else
(kc_p, kc_rec) cr_rewrite_strategy kc_p; boolean kc_rec;
#endif
{ kc_do_free_phylum( (kc_voidptr_t)kc_p, kc_rec, kc_phylum_cr_rewrite_strategy);  }
/*ARGSUSED*/ void free_cr_operator_class
#ifdef KC_USE_PROTOTYPES
(cr_operator_class kc_p, boolean kc_rec)
#else
(kc_p, kc_rec) cr_operator_class kc_p; boolean kc_rec;
#endif
{ kc_do_free_phylum( (kc_voidptr_t)kc_p, kc_rec, kc_phylum_cr_operator_class);  }
/*ARGSUSED*/ void free_cr_equations_option
#ifdef KC_USE_PROTOTYPES
(cr_equations_option kc_p, boolean kc_rec)
#else
(kc_p, kc_rec) cr_equations_option kc_p; boolean kc_rec;
#endif
{ kc_do_free_phylum( (kc_voidptr_t)kc_p, kc_rec, kc_phylum_cr_equations_option);  }
/*ARGSUSED*/ void free_cr_equation_structure_list
#ifdef KC_USE_PROTOTYPES
(cr_equation_structure_list kc_p, boolean kc_rec)
#else
(kc_p, kc_rec) cr_equation_structure_list kc_p; boolean kc_rec;
#endif
{ kc_do_free_phylum( (kc_voidptr_t)kc_p, kc_rec, kc_phylum_cr_equation_structure_list);  }
/*ARGSUSED*/ void free_cr_equation_structure
#ifdef KC_USE_PROTOTYPES
(cr_equation_structure kc_p, boolean kc_rec)
#else
(kc_p, kc_rec) cr_equation_structure kc_p; boolean kc_rec;
#endif
{ kc_do_free_phylum( (kc_voidptr_t)kc_p, kc_rec, kc_phylum_cr_equation_structure);  }
/*ARGSUSED*/ void free_cr_equation_list
#ifdef KC_USE_PROTOTYPES
(cr_equation_list kc_p, boolean kc_rec)
#else
(kc_p, kc_rec) cr_equation_list kc_p; boolean kc_rec;
#endif
{ kc_do_free_phylum( (kc_voidptr_t)kc_p, kc_rec, kc_phylum_cr_equation_list);  }
/*ARGSUSED*/ void free_cr_equation
#ifdef KC_USE_PROTOTYPES
(cr_equation kc_p, boolean kc_rec)
#else
(kc_p, kc_rec) cr_equation kc_p; boolean kc_rec;
#endif
{ kc_do_free_phylum( (kc_voidptr_t)kc_p, kc_rec, kc_phylum_cr_equation);  }
/*ARGSUSED*/ void free_cr_premiss_list
#ifdef KC_USE_PROTOTYPES
(cr_premiss_list kc_p, boolean kc_rec)
#else
(kc_p, kc_rec) cr_premiss_list kc_p; boolean kc_rec;
#endif
{ kc_do_free_phylum( (kc_voidptr_t)kc_p, kc_rec, kc_phylum_cr_premiss_list);  }
/*ARGSUSED*/ void free_cr_equality
#ifdef KC_USE_PROTOTYPES
(cr_equality kc_p, boolean kc_rec)
#else
(kc_p, kc_rec) cr_equality kc_p; boolean kc_rec;
#endif
{ kc_do_free_phylum( (kc_voidptr_t)kc_p, kc_rec, kc_phylum_cr_equality);  }
/*ARGSUSED*/ void free_cr_identifier_declaration_list
#ifdef KC_USE_PROTOTYPES
(cr_identifier_declaration_list kc_p, boolean kc_rec)
#else
(kc_p, kc_rec) cr_identifier_declaration_list kc_p; boolean kc_rec;
#endif
{ kc_do_free_phylum( (kc_voidptr_t)kc_p, kc_rec, kc_phylum_cr_identifier_declaration_list);  }
/*ARGSUSED*/ void free_cr_identifier_declaration
#ifdef KC_USE_PROTOTYPES
(cr_identifier_declaration kc_p, boolean kc_rec)
#else
(kc_p, kc_rec) cr_identifier_declaration kc_p; boolean kc_rec;
#endif
{ kc_do_free_phylum( (kc_voidptr_t)kc_p, kc_rec, kc_phylum_cr_identifier_declaration);  }
/*ARGSUSED*/ void free_cr_value_identifier_list
#ifdef KC_USE_PROTOTYPES
(cr_value_identifier_list kc_p, boolean kc_rec)
#else
(kc_p, kc_rec) cr_value_identifier_list kc_p; boolean kc_rec;
#endif
{ kc_do_free_phylum( (kc_voidptr_t)kc_p, kc_rec, kc_phylum_cr_value_identifier_list);  }
/*ARGSUSED*/ void free_cr_annotated_value_identifier
#ifdef KC_USE_PROTOTYPES
(cr_annotated_value_identifier kc_p, boolean kc_rec)
#else
(kc_p, kc_rec) cr_annotated_value_identifier kc_p; boolean kc_rec;
#endif
{ kc_do_free_phylum( (kc_voidptr_t)kc_p, kc_rec, kc_phylum_cr_annotated_value_identifier);  }
/*ARGSUSED*/ void free_cr_behaviour_expression
#ifdef KC_USE_PROTOTYPES
(cr_behaviour_expression kc_p, boolean kc_rec)
#else
(kc_p, kc_rec) cr_behaviour_expression kc_p; boolean kc_rec;
#endif
{ kc_do_free_phylum( (kc_voidptr_t)kc_p, kc_rec, kc_phylum_cr_behaviour_expression);  }
/*ARGSUSED*/ void free_cr_parallel_operator
#ifdef KC_USE_PROTOTYPES
(cr_parallel_operator kc_p, boolean kc_rec)
#else
(kc_p, kc_rec) cr_parallel_operator kc_p; boolean kc_rec;
#endif
{ kc_do_free_phylum( (kc_voidptr_t)kc_p, kc_rec, kc_phylum_cr_parallel_operator);  }
/*ARGSUSED*/ void free_cr_gate_declaration_list
#ifdef KC_USE_PROTOTYPES
(cr_gate_declaration_list kc_p, boolean kc_rec)
#else
(kc_p, kc_rec) cr_gate_declaration_list kc_p; boolean kc_rec;
#endif
{ kc_do_free_phylum( (kc_voidptr_t)kc_p, kc_rec, kc_phylum_cr_gate_declaration_list);  }
/*ARGSUSED*/ void free_cr_gate_declaration
#ifdef KC_USE_PROTOTYPES
(cr_gate_declaration kc_p, boolean kc_rec)
#else
(kc_p, kc_rec) cr_gate_declaration kc_p; boolean kc_rec;
#endif
{ kc_do_free_phylum( (kc_voidptr_t)kc_p, kc_rec, kc_phylum_cr_gate_declaration);  }
/*ARGSUSED*/ void free_cr_gate_identifier_list
#ifdef KC_USE_PROTOTYPES
(cr_gate_identifier_list kc_p, boolean kc_rec)
#else
(kc_p, kc_rec) cr_gate_identifier_list kc_p; boolean kc_rec;
#endif
{ kc_do_free_phylum( (kc_voidptr_t)kc_p, kc_rec, kc_phylum_cr_gate_identifier_list);  }
/*ARGSUSED*/ void free_cr_exit_entry_list
#ifdef KC_USE_PROTOTYPES
(cr_exit_entry_list kc_p, boolean kc_rec)
#else
(kc_p, kc_rec) cr_exit_entry_list kc_p; boolean kc_rec;
#endif
{ kc_do_free_phylum( (kc_voidptr_t)kc_p, kc_rec, kc_phylum_cr_exit_entry_list);  }
/*ARGSUSED*/ void free_cr_exit_entry
#ifdef KC_USE_PROTOTYPES
(cr_exit_entry kc_p, boolean kc_rec)
#else
(kc_p, kc_rec) cr_exit_entry kc_p; boolean kc_rec;
#endif
{ kc_do_free_phylum( (kc_voidptr_t)kc_p, kc_rec, kc_phylum_cr_exit_entry);  }
/*ARGSUSED*/ void free_cr_identifier_equation_list
#ifdef KC_USE_PROTOTYPES
(cr_identifier_equation_list kc_p, boolean kc_rec)
#else
(kc_p, kc_rec) cr_identifier_equation_list kc_p; boolean kc_rec;
#endif
{ kc_do_free_phylum( (kc_voidptr_t)kc_p, kc_rec, kc_phylum_cr_identifier_equation_list);  }
/*ARGSUSED*/ void free_cr_identifier_equation
#ifdef KC_USE_PROTOTYPES
(cr_identifier_equation kc_p, boolean kc_rec)
#else
(kc_p, kc_rec) cr_identifier_equation kc_p; boolean kc_rec;
#endif
{ kc_do_free_phylum( (kc_voidptr_t)kc_p, kc_rec, kc_phylum_cr_identifier_equation);  }
/*ARGSUSED*/ void free_cr_action_denotation
#ifdef KC_USE_PROTOTYPES
(cr_action_denotation kc_p, boolean kc_rec)
#else
(kc_p, kc_rec) cr_action_denotation kc_p; boolean kc_rec;
#endif
{ kc_do_free_phylum( (kc_voidptr_t)kc_p, kc_rec, kc_phylum_cr_action_denotation);  }
/*ARGSUSED*/ void free_cr_experiment_option
#ifdef KC_USE_PROTOTYPES
(cr_experiment_option kc_p, boolean kc_rec)
#else
(kc_p, kc_rec) cr_experiment_option kc_p; boolean kc_rec;
#endif
{ kc_do_free_phylum( (kc_voidptr_t)kc_p, kc_rec, kc_phylum_cr_experiment_option);  }
/*ARGSUSED*/ void free_cr_experiment_offer_list
#ifdef KC_USE_PROTOTYPES
(cr_experiment_offer_list kc_p, boolean kc_rec)
#else
(kc_p, kc_rec) cr_experiment_offer_list kc_p; boolean kc_rec;
#endif
{ kc_do_free_phylum( (kc_voidptr_t)kc_p, kc_rec, kc_phylum_cr_experiment_offer_list);  }
/*ARGSUSED*/ void free_cr_experiment_offer
#ifdef KC_USE_PROTOTYPES
(cr_experiment_offer kc_p, boolean kc_rec)
#else
(kc_p, kc_rec) cr_experiment_offer kc_p; boolean kc_rec;
#endif
{ kc_do_free_phylum( (kc_voidptr_t)kc_p, kc_rec, kc_phylum_cr_experiment_offer);  }
/*ARGSUSED*/ void free_cr_guard_option
#ifdef KC_USE_PROTOTYPES
(cr_guard_option kc_p, boolean kc_rec)
#else
(kc_p, kc_rec) cr_guard_option kc_p; boolean kc_rec;
#endif
{ kc_do_free_phylum( (kc_voidptr_t)kc_p, kc_rec, kc_phylum_cr_guard_option);  }
/*ARGSUSED*/ void free_cr_value_expression_list
#ifdef KC_USE_PROTOTYPES
(cr_value_expression_list kc_p, boolean kc_rec)
#else
(kc_p, kc_rec) cr_value_expression_list kc_p; boolean kc_rec;
#endif
{ kc_do_free_phylum( (kc_voidptr_t)kc_p, kc_rec, kc_phylum_cr_value_expression_list);  }
/*ARGSUSED*/ void free_cr_value_expression
#ifdef KC_USE_PROTOTYPES
(cr_value_expression kc_p, boolean kc_rec)
#else
(kc_p, kc_rec) cr_value_expression kc_p; boolean kc_rec;
#endif
{ kc_do_free_phylum( (kc_voidptr_t)kc_p, kc_rec, kc_phylum_cr_value_expression);  }
/*ARGSUSED*/ void free_cr_specification_identifier
#ifdef KC_USE_PROTOTYPES
(cr_specification_identifier kc_p, boolean kc_rec)
#else
(kc_p, kc_rec) cr_specification_identifier kc_p; boolean kc_rec;
#endif
{ kc_do_free_phylum( (kc_voidptr_t)kc_p, kc_rec, kc_phylum_cr_specification_identifier);  }
/*ARGSUSED*/ void free_cr_operation_identifier
#ifdef KC_USE_PROTOTYPES
(cr_operation_identifier kc_p, boolean kc_rec)
#else
(kc_p, kc_rec) cr_operation_identifier kc_p; boolean kc_rec;
#endif
{ kc_do_free_phylum( (kc_voidptr_t)kc_p, kc_rec, kc_phylum_cr_operation_identifier);  }
/*ARGSUSED*/ void free_cr_type_identifier
#ifdef KC_USE_PROTOTYPES
(cr_type_identifier kc_p, boolean kc_rec)
#else
(kc_p, kc_rec) cr_type_identifier kc_p; boolean kc_rec;
#endif
{ kc_do_free_phylum( (kc_voidptr_t)kc_p, kc_rec, kc_phylum_cr_type_identifier);  }
/*ARGSUSED*/ void free_cr_sort_identifier
#ifdef KC_USE_PROTOTYPES
(cr_sort_identifier kc_p, boolean kc_rec)
#else
(kc_p, kc_rec) cr_sort_identifier kc_p; boolean kc_rec;
#endif
{ kc_do_free_phylum( (kc_voidptr_t)kc_p, kc_rec, kc_phylum_cr_sort_identifier);  }
/*ARGSUSED*/ void free_cr_gate_identifier
#ifdef KC_USE_PROTOTYPES
(cr_gate_identifier kc_p, boolean kc_rec)
#else
(kc_p, kc_rec) cr_gate_identifier kc_p; boolean kc_rec;
#endif
{ kc_do_free_phylum( (kc_voidptr_t)kc_p, kc_rec, kc_phylum_cr_gate_identifier);  }
/*ARGSUSED*/ void free_cr_value_identifier
#ifdef KC_USE_PROTOTYPES
(cr_value_identifier kc_p, boolean kc_rec)
#else
(kc_p, kc_rec) cr_value_identifier kc_p; boolean kc_rec;
#endif
{ kc_do_free_phylum( (kc_voidptr_t)kc_p, kc_rec, kc_phylum_cr_value_identifier);  }
/*ARGSUSED*/ void free_cr_process_identifier
#ifdef KC_USE_PROTOTYPES
(cr_process_identifier kc_p, boolean kc_rec)
#else
(kc_p, kc_rec) cr_process_identifier kc_p; boolean kc_rec;
#endif
{ kc_do_free_phylum( (kc_voidptr_t)kc_p, kc_rec, kc_phylum_cr_process_identifier);  }
/*ARGSUSED*/ void free_cr_identifier
#ifdef KC_USE_PROTOTYPES
(cr_identifier kc_p, boolean kc_rec)
#else
(kc_p, kc_rec) cr_identifier kc_p; boolean kc_rec;
#endif
{ kc_do_free_phylum( (kc_voidptr_t)kc_p, kc_rec, kc_phylum_cr_identifier);  }
/*ARGSUSED*/ void free_cr_extension
#ifdef KC_USE_PROTOTYPES
(cr_extension kc_p, boolean kc_rec)
#else
(kc_p, kc_rec) cr_extension kc_p; boolean kc_rec;
#endif
{ kc_do_free_phylum( (kc_voidptr_t)kc_p, kc_rec, kc_phylum_cr_extension);  }
/*ARGSUSED*/ void free_cr_operation_name
#ifdef KC_USE_PROTOTYPES
(cr_operation_name kc_p, boolean kc_rec)
#else
(kc_p, kc_rec) cr_operation_name kc_p; boolean kc_rec;
#endif
{ kc_do_free_phylum( (kc_voidptr_t)kc_p, kc_rec, kc_phylum_cr_operation_name);  }
/*ARGSUSED*/ void free_cr_sort_name
#ifdef KC_USE_PROTOTYPES
(cr_sort_name kc_p, boolean kc_rec)
#else
(kc_p, kc_rec) cr_sort_name kc_p; boolean kc_rec;
#endif
{ kc_do_free_phylum( (kc_voidptr_t)kc_p, kc_rec, kc_phylum_cr_sort_name);  }
/*ARGSUSED*/ void free_cr_name
#ifdef KC_USE_PROTOTYPES
(cr_name kc_p, boolean kc_rec)
#else
(kc_p, kc_rec) cr_name kc_p; boolean kc_rec;
#endif
{ kc_do_free_phylum( (kc_voidptr_t)kc_p, kc_rec, kc_phylum_cr_name);  }
/*ARGSUSED*/ void free_cr_comment_list
#ifdef KC_USE_PROTOTYPES
(cr_comment_list kc_p, boolean kc_rec)
#else
(kc_p, kc_rec) cr_comment_list kc_p; boolean kc_rec;
#endif
{ kc_do_free_phylum( (kc_voidptr_t)kc_p, kc_rec, kc_phylum_cr_comment_list);  }
/*ARGSUSED*/ void free_cr_annotation_list
#ifdef KC_USE_PROTOTYPES
(cr_annotation_list kc_p, boolean kc_rec)
#else
(kc_p, kc_rec) cr_annotation_list kc_p; boolean kc_rec;
#endif
{ kc_do_free_phylum( (kc_voidptr_t)kc_p, kc_rec, kc_phylum_cr_annotation_list);  }
/*ARGSUSED*/ void free_cr_LABEL
#ifdef KC_USE_PROTOTYPES
(cr_LABEL kc_p, boolean kc_rec)
#else
(kc_p, kc_rec) cr_LABEL kc_p; boolean kc_rec;
#endif
{ kc_do_free_phylum( (kc_voidptr_t)kc_p, kc_rec, kc_phylum_cr_LABEL);  }
/*ARGSUSED*/ static boolean kc_do_eq_phylum
#ifdef KC_USE_PROTOTYPES
(kc_voidptr_t kc_p1, kc_voidptr_t kc_p2, kc_enum_phyla kc_phylum)
#else
(kc_p1, kc_p2, kc_phylum) kc_voidptr_t kc_p1, kc_p2; kc_enum_phyla kc_phylum;
#endif
{	int kc_i;
	kc_enum_operators kc_prodsel;
	int kc_st;
	KC_OPERATOR_INFO *kc_op_info;
	kc_hashtable_t kc_a_ht;
	if (kc_p1 == kc_p2) return True;
	if ((kc_phylum == kc_phylum_int) || (kc_phylum == kc_phylum_float)) return False;
	assertPhylum(((casestring)kc_p1),"kc_p1",kc_phylum);
	assertPhylum(((casestring)kc_p2),"kc_p2",kc_phylum);
	if ((kc_prodsel = ((casestring)kc_p1)->prod_sel) != ((casestring)kc_p2)->prod_sel) return False;
	kc_op_info = &kc_OperatorInfo[(int)kc_prodsel];
	kc_st = (int)kc_op_info->uniq_stored;
	kc_a_ht = kc_hashtables[kc_st];
	if (kc_st
	   && (kc_storageclass_still_uniq[kc_st]
	       || ((kc_a_ht->in_block != 0)
		  && (*kc_a_ht->in_block)((kc_voidptr_t)kc_p1, kc_a_ht->malloc_private_data)
		  && (*kc_a_ht->in_block)((kc_voidptr_t)kc_p2, kc_a_ht->malloc_private_data)))) return False;
	for (kc_i=0; kc_i < kc_op_info->no_sons; kc_i++) {
		if (! kc_do_eq_phylum( (kc_voidptr_t)KC_SUBPHYLUM(kc_p1, kc_op_info->suboffset[kc_i]), (kc_voidptr_t)KC_SUBPHYLUM(kc_p2, kc_op_info->suboffset[kc_i]), kc_op_info->subphylum[kc_i] )) {
			return False;
	}	}
	return True;
}		
/*ARGSUSED*/ boolean eq_nocasestring
#ifdef KC_USE_PROTOTYPES
(nocasestring kc_p1, nocasestring kc_p2)
#else
(kc_p1, kc_p2) nocasestring kc_p1, kc_p2;
#endif
{ return (boolean)(kc_p1 == kc_p2); }
/*ARGSUSED*/ boolean eq_casestring
#ifdef KC_USE_PROTOTYPES
(casestring kc_p1, casestring kc_p2)
#else
(kc_p1, kc_p2) casestring kc_p1, kc_p2;
#endif
{ return (boolean)(kc_p1 == kc_p2); }
/*ARGSUSED*/ boolean eq_float
#ifdef KC_USE_PROTOTYPES
(float kc_p1, float kc_p2)
#else
(kc_p1, kc_p2) float kc_p1, kc_p2;
#endif
{ return (boolean)(kc_p1 == kc_p2); }
/*ARGSUSED*/ boolean eq_int
#ifdef KC_USE_PROTOTYPES
(int kc_p1, int kc_p2)
#else
(kc_p1, kc_p2) int kc_p1, kc_p2;
#endif
{ return (boolean)(kc_p1 == kc_p2); }
/*ARGSUSED*/ boolean eq_cr_specification
#ifdef KC_USE_PROTOTYPES
(cr_specification kc_p1, cr_specification  kc_p2)
#else
(kc_p1, kc_p2) cr_specification kc_p1, kc_p2;
#endif
{ return kc_do_eq_phylum( (kc_voidptr_t)kc_p1, (kc_voidptr_t)kc_p2, kc_phylum_cr_specification);  }
/*ARGSUSED*/ boolean eq_cr_specification_type
#ifdef KC_USE_PROTOTYPES
(cr_specification_type kc_p1, cr_specification_type  kc_p2)
#else
(kc_p1, kc_p2) cr_specification_type kc_p1, kc_p2;
#endif
{ return kc_do_eq_phylum( (kc_voidptr_t)kc_p1, (kc_voidptr_t)kc_p2, kc_phylum_cr_specification_type);  }
/*ARGSUSED*/ boolean eq_cr_boolean_indication
#ifdef KC_USE_PROTOTYPES
(cr_boolean_indication kc_p1, cr_boolean_indication  kc_p2)
#else
(kc_p1, kc_p2) cr_boolean_indication kc_p1, kc_p2;
#endif
{ return kc_do_eq_phylum( (kc_voidptr_t)kc_p1, (kc_voidptr_t)kc_p2, kc_phylum_cr_boolean_indication);  }
/*ARGSUSED*/ boolean eq_cr_definition_block
#ifdef KC_USE_PROTOTYPES
(cr_definition_block kc_p1, cr_definition_block  kc_p2)
#else
(kc_p1, kc_p2) cr_definition_block kc_p1, kc_p2;
#endif
{ return kc_do_eq_phylum( (kc_voidptr_t)kc_p1, (kc_voidptr_t)kc_p2, kc_phylum_cr_definition_block);  }
/*ARGSUSED*/ boolean eq_cr_process_definition_list
#ifdef KC_USE_PROTOTYPES
(cr_process_definition_list kc_p1, cr_process_definition_list  kc_p2)
#else
(kc_p1, kc_p2) cr_process_definition_list kc_p1, kc_p2;
#endif
{ return kc_do_eq_phylum( (kc_voidptr_t)kc_p1, (kc_voidptr_t)kc_p2, kc_phylum_cr_process_definition_list);  }
/*ARGSUSED*/ boolean eq_cr_process_definition
#ifdef KC_USE_PROTOTYPES
(cr_process_definition kc_p1, cr_process_definition  kc_p2)
#else
(kc_p1, kc_p2) cr_process_definition kc_p1, kc_p2;
#endif
{ return kc_do_eq_phylum( (kc_voidptr_t)kc_p1, (kc_voidptr_t)kc_p2, kc_phylum_cr_process_definition);  }
/*ARGSUSED*/ boolean eq_cr_functionality
#ifdef KC_USE_PROTOTYPES
(cr_functionality kc_p1, cr_functionality  kc_p2)
#else
(kc_p1, kc_p2) cr_functionality kc_p1, kc_p2;
#endif
{ return kc_do_eq_phylum( (kc_voidptr_t)kc_p1, (kc_voidptr_t)kc_p2, kc_phylum_cr_functionality);  }
/*ARGSUSED*/ boolean eq_cr_sort_identifier_list
#ifdef KC_USE_PROTOTYPES
(cr_sort_identifier_list kc_p1, cr_sort_identifier_list  kc_p2)
#else
(kc_p1, kc_p2) cr_sort_identifier_list kc_p1, kc_p2;
#endif
{ return kc_do_eq_phylum( (kc_voidptr_t)kc_p1, (kc_voidptr_t)kc_p2, kc_phylum_cr_sort_identifier_list);  }
/*ARGSUSED*/ boolean eq_cr_data_type_definition_list
#ifdef KC_USE_PROTOTYPES
(cr_data_type_definition_list kc_p1, cr_data_type_definition_list  kc_p2)
#else
(kc_p1, kc_p2) cr_data_type_definition_list kc_p1, kc_p2;
#endif
{ return kc_do_eq_phylum( (kc_voidptr_t)kc_p1, (kc_voidptr_t)kc_p2, kc_phylum_cr_data_type_definition_list);  }
/*ARGSUSED*/ boolean eq_cr_data_type_definition
#ifdef KC_USE_PROTOTYPES
(cr_data_type_definition kc_p1, cr_data_type_definition  kc_p2)
#else
(kc_p1, kc_p2) cr_data_type_definition kc_p1, kc_p2;
#endif
{ return kc_do_eq_phylum( (kc_voidptr_t)kc_p1, (kc_voidptr_t)kc_p2, kc_phylum_cr_data_type_definition);  }
/*ARGSUSED*/ boolean eq_cr_completeness_indication
#ifdef KC_USE_PROTOTYPES
(cr_completeness_indication kc_p1, cr_completeness_indication  kc_p2)
#else
(kc_p1, kc_p2) cr_completeness_indication kc_p1, kc_p2;
#endif
{ return kc_do_eq_phylum( (kc_voidptr_t)kc_p1, (kc_voidptr_t)kc_p2, kc_phylum_cr_completeness_indication);  }
/*ARGSUSED*/ boolean eq_cr_persistency_indication
#ifdef KC_USE_PROTOTYPES
(cr_persistency_indication kc_p1, cr_persistency_indication  kc_p2)
#else
(kc_p1, kc_p2) cr_persistency_indication kc_p1, kc_p2;
#endif
{ return kc_do_eq_phylum( (kc_voidptr_t)kc_p1, (kc_voidptr_t)kc_p2, kc_phylum_cr_persistency_indication);  }
/*ARGSUSED*/ boolean eq_cr_p_expression
#ifdef KC_USE_PROTOTYPES
(cr_p_expression kc_p1, cr_p_expression  kc_p2)
#else
(kc_p1, kc_p2) cr_p_expression kc_p1, kc_p2;
#endif
{ return kc_do_eq_phylum( (kc_voidptr_t)kc_p1, (kc_voidptr_t)kc_p2, kc_phylum_cr_p_expression);  }
/*ARGSUSED*/ boolean eq_cr_type_identifier_list
#ifdef KC_USE_PROTOTYPES
(cr_type_identifier_list kc_p1, cr_type_identifier_list  kc_p2)
#else
(kc_p1, kc_p2) cr_type_identifier_list kc_p1, kc_p2;
#endif
{ return kc_do_eq_phylum( (kc_voidptr_t)kc_p1, (kc_voidptr_t)kc_p2, kc_phylum_cr_type_identifier_list);  }
/*ARGSUSED*/ boolean eq_cr_replacement
#ifdef KC_USE_PROTOTYPES
(cr_replacement kc_p1, cr_replacement  kc_p2)
#else
(kc_p1, kc_p2) cr_replacement kc_p1, kc_p2;
#endif
{ return kc_do_eq_phylum( (kc_voidptr_t)kc_p1, (kc_voidptr_t)kc_p2, kc_phylum_cr_replacement);  }
/*ARGSUSED*/ boolean eq_cr_sort_replacement_list
#ifdef KC_USE_PROTOTYPES
(cr_sort_replacement_list kc_p1, cr_sort_replacement_list  kc_p2)
#else
(kc_p1, kc_p2) cr_sort_replacement_list kc_p1, kc_p2;
#endif
{ return kc_do_eq_phylum( (kc_voidptr_t)kc_p1, (kc_voidptr_t)kc_p2, kc_phylum_cr_sort_replacement_list);  }
/*ARGSUSED*/ boolean eq_cr_sort_replacement
#ifdef KC_USE_PROTOTYPES
(cr_sort_replacement kc_p1, cr_sort_replacement  kc_p2)
#else
(kc_p1, kc_p2) cr_sort_replacement kc_p1, kc_p2;
#endif
{ return kc_do_eq_phylum( (kc_voidptr_t)kc_p1, (kc_voidptr_t)kc_p2, kc_phylum_cr_sort_replacement);  }
/*ARGSUSED*/ boolean eq_cr_sort_declaration_list
#ifdef KC_USE_PROTOTYPES
(cr_sort_declaration_list kc_p1, cr_sort_declaration_list  kc_p2)
#else
(kc_p1, kc_p2) cr_sort_declaration_list kc_p1, kc_p2;
#endif
{ return kc_do_eq_phylum( (kc_voidptr_t)kc_p1, (kc_voidptr_t)kc_p2, kc_phylum_cr_sort_declaration_list);  }
/*ARGSUSED*/ boolean eq_cr_sort_declaration
#ifdef KC_USE_PROTOTYPES
(cr_sort_declaration kc_p1, cr_sort_declaration  kc_p2)
#else
(kc_p1, kc_p2) cr_sort_declaration kc_p1, kc_p2;
#endif
{ return kc_do_eq_phylum( (kc_voidptr_t)kc_p1, (kc_voidptr_t)kc_p2, kc_phylum_cr_sort_declaration);  }
/*ARGSUSED*/ boolean eq_cr_operation_replacement_list
#ifdef KC_USE_PROTOTYPES
(cr_operation_replacement_list kc_p1, cr_operation_replacement_list  kc_p2)
#else
(kc_p1, kc_p2) cr_operation_replacement_list kc_p1, kc_p2;
#endif
{ return kc_do_eq_phylum( (kc_voidptr_t)kc_p1, (kc_voidptr_t)kc_p2, kc_phylum_cr_operation_replacement_list);  }
/*ARGSUSED*/ boolean eq_cr_operation_replacement
#ifdef KC_USE_PROTOTYPES
(cr_operation_replacement kc_p1, cr_operation_replacement  kc_p2)
#else
(kc_p1, kc_p2) cr_operation_replacement kc_p1, kc_p2;
#endif
{ return kc_do_eq_phylum( (kc_voidptr_t)kc_p1, (kc_voidptr_t)kc_p2, kc_phylum_cr_operation_replacement);  }
/*ARGSUSED*/ boolean eq_cr_flattened_type_definition
#ifdef KC_USE_PROTOTYPES
(cr_flattened_type_definition kc_p1, cr_flattened_type_definition  kc_p2)
#else
(kc_p1, kc_p2) cr_flattened_type_definition kc_p1, kc_p2;
#endif
{ return kc_do_eq_phylum( (kc_voidptr_t)kc_p1, (kc_voidptr_t)kc_p2, kc_phylum_cr_flattened_type_definition);  }
/*ARGSUSED*/ boolean eq_cr_operation_list
#ifdef KC_USE_PROTOTYPES
(cr_operation_list kc_p1, cr_operation_list  kc_p2)
#else
(kc_p1, kc_p2) cr_operation_list kc_p1, kc_p2;
#endif
{ return kc_do_eq_phylum( (kc_voidptr_t)kc_p1, (kc_voidptr_t)kc_p2, kc_phylum_cr_operation_list);  }
/*ARGSUSED*/ boolean eq_cr_operation
#ifdef KC_USE_PROTOTYPES
(cr_operation kc_p1, cr_operation  kc_p2)
#else
(kc_p1, kc_p2) cr_operation kc_p1, kc_p2;
#endif
{ return kc_do_eq_phylum( (kc_voidptr_t)kc_p1, (kc_voidptr_t)kc_p2, kc_phylum_cr_operation);  }
/*ARGSUSED*/ boolean eq_cr_prefix_infix
#ifdef KC_USE_PROTOTYPES
(cr_prefix_infix kc_p1, cr_prefix_infix  kc_p2)
#else
(kc_p1, kc_p2) cr_prefix_infix kc_p1, kc_p2;
#endif
{ return kc_do_eq_phylum( (kc_voidptr_t)kc_p1, (kc_voidptr_t)kc_p2, kc_phylum_cr_prefix_infix);  }
/*ARGSUSED*/ boolean eq_cr_rewrite_strategy
#ifdef KC_USE_PROTOTYPES
(cr_rewrite_strategy kc_p1, cr_rewrite_strategy  kc_p2)
#else
(kc_p1, kc_p2) cr_rewrite_strategy kc_p1, kc_p2;
#endif
{ return kc_do_eq_phylum( (kc_voidptr_t)kc_p1, (kc_voidptr_t)kc_p2, kc_phylum_cr_rewrite_strategy);  }
/*ARGSUSED*/ boolean eq_cr_operator_class
#ifdef KC_USE_PROTOTYPES
(cr_operator_class kc_p1, cr_operator_class  kc_p2)
#else
(kc_p1, kc_p2) cr_operator_class kc_p1, kc_p2;
#endif
{ return kc_do_eq_phylum( (kc_voidptr_t)kc_p1, (kc_voidptr_t)kc_p2, kc_phylum_cr_operator_class);  }
/*ARGSUSED*/ boolean eq_cr_equations_option
#ifdef KC_USE_PROTOTYPES
(cr_equations_option kc_p1, cr_equations_option  kc_p2)
#else
(kc_p1, kc_p2) cr_equations_option kc_p1, kc_p2;
#endif
{ return kc_do_eq_phylum( (kc_voidptr_t)kc_p1, (kc_voidptr_t)kc_p2, kc_phylum_cr_equations_option);  }
/*ARGSUSED*/ boolean eq_cr_equation_structure_list
#ifdef KC_USE_PROTOTYPES
(cr_equation_structure_list kc_p1, cr_equation_structure_list  kc_p2)
#else
(kc_p1, kc_p2) cr_equation_structure_list kc_p1, kc_p2;
#endif
{ return kc_do_eq_phylum( (kc_voidptr_t)kc_p1, (kc_voidptr_t)kc_p2, kc_phylum_cr_equation_structure_list);  }
/*ARGSUSED*/ boolean eq_cr_equation_structure
#ifdef KC_USE_PROTOTYPES
(cr_equation_structure kc_p1, cr_equation_structure  kc_p2)
#else
(kc_p1, kc_p2) cr_equation_structure kc_p1, kc_p2;
#endif
{ return kc_do_eq_phylum( (kc_voidptr_t)kc_p1, (kc_voidptr_t)kc_p2, kc_phylum_cr_equation_structure);  }
/*ARGSUSED*/ boolean eq_cr_equation_list
#ifdef KC_USE_PROTOTYPES
(cr_equation_list kc_p1, cr_equation_list  kc_p2)
#else
(kc_p1, kc_p2) cr_equation_list kc_p1, kc_p2;
#endif
{ return kc_do_eq_phylum( (kc_voidptr_t)kc_p1, (kc_voidptr_t)kc_p2, kc_phylum_cr_equation_list);  }
/*ARGSUSED*/ boolean eq_cr_equation
#ifdef KC_USE_PROTOTYPES
(cr_equation kc_p1, cr_equation  kc_p2)
#else
(kc_p1, kc_p2) cr_equation kc_p1, kc_p2;
#endif
{ return kc_do_eq_phylum( (kc_voidptr_t)kc_p1, (kc_voidptr_t)kc_p2, kc_phylum_cr_equation);  }
/*ARGSUSED*/ boolean eq_cr_premiss_list
#ifdef KC_USE_PROTOTYPES
(cr_premiss_list kc_p1, cr_premiss_list  kc_p2)
#else
(kc_p1, kc_p2) cr_premiss_list kc_p1, kc_p2;
#endif
{ return kc_do_eq_phylum( (kc_voidptr_t)kc_p1, (kc_voidptr_t)kc_p2, kc_phylum_cr_premiss_list);  }
/*ARGSUSED*/ boolean eq_cr_equality
#ifdef KC_USE_PROTOTYPES
(cr_equality kc_p1, cr_equality  kc_p2)
#else
(kc_p1, kc_p2) cr_equality kc_p1, kc_p2;
#endif
{ return kc_do_eq_phylum( (kc_voidptr_t)kc_p1, (kc_voidptr_t)kc_p2, kc_phylum_cr_equality);  }
/*ARGSUSED*/ boolean eq_cr_identifier_declaration_list
#ifdef KC_USE_PROTOTYPES
(cr_identifier_declaration_list kc_p1, cr_identifier_declaration_list  kc_p2)
#else
(kc_p1, kc_p2) cr_identifier_declaration_list kc_p1, kc_p2;
#endif
{ return kc_do_eq_phylum( (kc_voidptr_t)kc_p1, (kc_voidptr_t)kc_p2, kc_phylum_cr_identifier_declaration_list);  }
/*ARGSUSED*/ boolean eq_cr_identifier_declaration
#ifdef KC_USE_PROTOTYPES
(cr_identifier_declaration kc_p1, cr_identifier_declaration  kc_p2)
#else
(kc_p1, kc_p2) cr_identifier_declaration kc_p1, kc_p2;
#endif
{ return kc_do_eq_phylum( (kc_voidptr_t)kc_p1, (kc_voidptr_t)kc_p2, kc_phylum_cr_identifier_declaration);  }
/*ARGSUSED*/ boolean eq_cr_value_identifier_list
#ifdef KC_USE_PROTOTYPES
(cr_value_identifier_list kc_p1, cr_value_identifier_list  kc_p2)
#else
(kc_p1, kc_p2) cr_value_identifier_list kc_p1, kc_p2;
#endif
{ return kc_do_eq_phylum( (kc_voidptr_t)kc_p1, (kc_voidptr_t)kc_p2, kc_phylum_cr_value_identifier_list);  }
/*ARGSUSED*/ boolean eq_cr_annotated_value_identifier
#ifdef KC_USE_PROTOTYPES
(cr_annotated_value_identifier kc_p1, cr_annotated_value_identifier  kc_p2)
#else
(kc_p1, kc_p2) cr_annotated_value_identifier kc_p1, kc_p2;
#endif
{ return kc_do_eq_phylum( (kc_voidptr_t)kc_p1, (kc_voidptr_t)kc_p2, kc_phylum_cr_annotated_value_identifier);  }
/*ARGSUSED*/ boolean eq_cr_behaviour_expression
#ifdef KC_USE_PROTOTYPES
(cr_behaviour_expression kc_p1, cr_behaviour_expression  kc_p2)
#else
(kc_p1, kc_p2) cr_behaviour_expression kc_p1, kc_p2;
#endif
{ return kc_do_eq_phylum( (kc_voidptr_t)kc_p1, (kc_voidptr_t)kc_p2, kc_phylum_cr_behaviour_expression);  }
/*ARGSUSED*/ boolean eq_cr_parallel_operator
#ifdef KC_USE_PROTOTYPES
(cr_parallel_operator kc_p1, cr_parallel_operator  kc_p2)
#else
(kc_p1, kc_p2) cr_parallel_operator kc_p1, kc_p2;
#endif
{ return kc_do_eq_phylum( (kc_voidptr_t)kc_p1, (kc_voidptr_t)kc_p2, kc_phylum_cr_parallel_operator);  }
/*ARGSUSED*/ boolean eq_cr_gate_declaration_list
#ifdef KC_USE_PROTOTYPES
(cr_gate_declaration_list kc_p1, cr_gate_declaration_list  kc_p2)
#else
(kc_p1, kc_p2) cr_gate_declaration_list kc_p1, kc_p2;
#endif
{ return kc_do_eq_phylum( (kc_voidptr_t)kc_p1, (kc_voidptr_t)kc_p2, kc_phylum_cr_gate_declaration_list);  }
/*ARGSUSED*/ boolean eq_cr_gate_declaration
#ifdef KC_USE_PROTOTYPES
(cr_gate_declaration kc_p1, cr_gate_declaration  kc_p2)
#else
(kc_p1, kc_p2) cr_gate_declaration kc_p1, kc_p2;
#endif
{ return kc_do_eq_phylum( (kc_voidptr_t)kc_p1, (kc_voidptr_t)kc_p2, kc_phylum_cr_gate_declaration);  }
/*ARGSUSED*/ boolean eq_cr_gate_identifier_list
#ifdef KC_USE_PROTOTYPES
(cr_gate_identifier_list kc_p1, cr_gate_identifier_list  kc_p2)
#else
(kc_p1, kc_p2) cr_gate_identifier_list kc_p1, kc_p2;
#endif
{ return kc_do_eq_phylum( (kc_voidptr_t)kc_p1, (kc_voidptr_t)kc_p2, kc_phylum_cr_gate_identifier_list);  }
/*ARGSUSED*/ boolean eq_cr_exit_entry_list
#ifdef KC_USE_PROTOTYPES
(cr_exit_entry_list kc_p1, cr_exit_entry_list  kc_p2)
#else
(kc_p1, kc_p2) cr_exit_entry_list kc_p1, kc_p2;
#endif
{ return kc_do_eq_phylum( (kc_voidptr_t)kc_p1, (kc_voidptr_t)kc_p2, kc_phylum_cr_exit_entry_list);  }
/*ARGSUSED*/ boolean eq_cr_exit_entry
#ifdef KC_USE_PROTOTYPES
(cr_exit_entry kc_p1, cr_exit_entry  kc_p2)
#else
(kc_p1, kc_p2) cr_exit_entry kc_p1, kc_p2;
#endif
{ return kc_do_eq_phylum( (kc_voidptr_t)kc_p1, (kc_voidptr_t)kc_p2, kc_phylum_cr_exit_entry);  }
/*ARGSUSED*/ boolean eq_cr_identifier_equation_list
#ifdef KC_USE_PROTOTYPES
(cr_identifier_equation_list kc_p1, cr_identifier_equation_list  kc_p2)
#else
(kc_p1, kc_p2) cr_identifier_equation_list kc_p1, kc_p2;
#endif
{ return kc_do_eq_phylum( (kc_voidptr_t)kc_p1, (kc_voidptr_t)kc_p2, kc_phylum_cr_identifier_equation_list);  }
/*ARGSUSED*/ boolean eq_cr_identifier_equation
#ifdef KC_USE_PROTOTYPES
(cr_identifier_equation kc_p1, cr_identifier_equation  kc_p2)
#else
(kc_p1, kc_p2) cr_identifier_equation kc_p1, kc_p2;
#endif
{ return kc_do_eq_phylum( (kc_voidptr_t)kc_p1, (kc_voidptr_t)kc_p2, kc_phylum_cr_identifier_equation);  }
/*ARGSUSED*/ boolean eq_cr_action_denotation
#ifdef KC_USE_PROTOTYPES
(cr_action_denotation kc_p1, cr_action_denotation  kc_p2)
#else
(kc_p1, kc_p2) cr_action_denotation kc_p1, kc_p2;
#endif
{ return kc_do_eq_phylum( (kc_voidptr_t)kc_p1, (kc_voidptr_t)kc_p2, kc_phylum_cr_action_denotation);  }
/*ARGSUSED*/ boolean eq_cr_experiment_option
#ifdef KC_USE_PROTOTYPES
(cr_experiment_option kc_p1, cr_experiment_option  kc_p2)
#else
(kc_p1, kc_p2) cr_experiment_option kc_p1, kc_p2;
#endif
{ return kc_do_eq_phylum( (kc_voidptr_t)kc_p1, (kc_voidptr_t)kc_p2, kc_phylum_cr_experiment_option);  }
/*ARGSUSED*/ boolean eq_cr_experiment_offer_list
#ifdef KC_USE_PROTOTYPES
(cr_experiment_offer_list kc_p1, cr_experiment_offer_list  kc_p2)
#else
(kc_p1, kc_p2) cr_experiment_offer_list kc_p1, kc_p2;
#endif
{ return kc_do_eq_phylum( (kc_voidptr_t)kc_p1, (kc_voidptr_t)kc_p2, kc_phylum_cr_experiment_offer_list);  }
/*ARGSUSED*/ boolean eq_cr_experiment_offer
#ifdef KC_USE_PROTOTYPES
(cr_experiment_offer kc_p1, cr_experiment_offer  kc_p2)
#else
(kc_p1, kc_p2) cr_experiment_offer kc_p1, kc_p2;
#endif
{ return kc_do_eq_phylum( (kc_voidptr_t)kc_p1, (kc_voidptr_t)kc_p2, kc_phylum_cr_experiment_offer);  }
/*ARGSUSED*/ boolean eq_cr_guard_option
#ifdef KC_USE_PROTOTYPES
(cr_guard_option kc_p1, cr_guard_option  kc_p2)
#else
(kc_p1, kc_p2) cr_guard_option kc_p1, kc_p2;
#endif
{ return kc_do_eq_phylum( (kc_voidptr_t)kc_p1, (kc_voidptr_t)kc_p2, kc_phylum_cr_guard_option);  }
/*ARGSUSED*/ boolean eq_cr_value_expression_list
#ifdef KC_USE_PROTOTYPES
(cr_value_expression_list kc_p1, cr_value_expression_list  kc_p2)
#else
(kc_p1, kc_p2) cr_value_expression_list kc_p1, kc_p2;
#endif
{ return kc_do_eq_phylum( (kc_voidptr_t)kc_p1, (kc_voidptr_t)kc_p2, kc_phylum_cr_value_expression_list);  }
/*ARGSUSED*/ boolean eq_cr_value_expression
#ifdef KC_USE_PROTOTYPES
(cr_value_expression kc_p1, cr_value_expression  kc_p2)
#else
(kc_p1, kc_p2) cr_value_expression kc_p1, kc_p2;
#endif
{ return kc_do_eq_phylum( (kc_voidptr_t)kc_p1, (kc_voidptr_t)kc_p2, kc_phylum_cr_value_expression);  }
/*ARGSUSED*/ boolean eq_cr_specification_identifier
#ifdef KC_USE_PROTOTYPES
(cr_specification_identifier kc_p1, cr_specification_identifier  kc_p2)
#else
(kc_p1, kc_p2) cr_specification_identifier kc_p1, kc_p2;
#endif
{ return kc_do_eq_phylum( (kc_voidptr_t)kc_p1, (kc_voidptr_t)kc_p2, kc_phylum_cr_specification_identifier);  }
/*ARGSUSED*/ boolean eq_cr_operation_identifier
#ifdef KC_USE_PROTOTYPES
(cr_operation_identifier kc_p1, cr_operation_identifier  kc_p2)
#else
(kc_p1, kc_p2) cr_operation_identifier kc_p1, kc_p2;
#endif
{ return kc_do_eq_phylum( (kc_voidptr_t)kc_p1, (kc_voidptr_t)kc_p2, kc_phylum_cr_operation_identifier);  }
/*ARGSUSED*/ boolean eq_cr_type_identifier
#ifdef KC_USE_PROTOTYPES
(cr_type_identifier kc_p1, cr_type_identifier  kc_p2)
#else
(kc_p1, kc_p2) cr_type_identifier kc_p1, kc_p2;
#endif
{ return kc_do_eq_phylum( (kc_voidptr_t)kc_p1, (kc_voidptr_t)kc_p2, kc_phylum_cr_type_identifier);  }
/*ARGSUSED*/ boolean eq_cr_sort_identifier
#ifdef KC_USE_PROTOTYPES
(cr_sort_identifier kc_p1, cr_sort_identifier  kc_p2)
#else
(kc_p1, kc_p2) cr_sort_identifier kc_p1, kc_p2;
#endif
{ return kc_do_eq_phylum( (kc_voidptr_t)kc_p1, (kc_voidptr_t)kc_p2, kc_phylum_cr_sort_identifier);  }
/*ARGSUSED*/ boolean eq_cr_gate_identifier
#ifdef KC_USE_PROTOTYPES
(cr_gate_identifier kc_p1, cr_gate_identifier  kc_p2)
#else
(kc_p1, kc_p2) cr_gate_identifier kc_p1, kc_p2;
#endif
{ return kc_do_eq_phylum( (kc_voidptr_t)kc_p1, (kc_voidptr_t)kc_p2, kc_phylum_cr_gate_identifier);  }
/*ARGSUSED*/ boolean eq_cr_value_identifier
#ifdef KC_USE_PROTOTYPES
(cr_value_identifier kc_p1, cr_value_identifier  kc_p2)
#else
(kc_p1, kc_p2) cr_value_identifier kc_p1, kc_p2;
#endif
{ return kc_do_eq_phylum( (kc_voidptr_t)kc_p1, (kc_voidptr_t)kc_p2, kc_phylum_cr_value_identifier);  }
/*ARGSUSED*/ boolean eq_cr_process_identifier
#ifdef KC_USE_PROTOTYPES
(cr_process_identifier kc_p1, cr_process_identifier  kc_p2)
#else
(kc_p1, kc_p2) cr_process_identifier kc_p1, kc_p2;
#endif
{ return kc_do_eq_phylum( (kc_voidptr_t)kc_p1, (kc_voidptr_t)kc_p2, kc_phylum_cr_process_identifier);  }
/*ARGSUSED*/ boolean eq_cr_identifier
#ifdef KC_USE_PROTOTYPES
(cr_identifier kc_p1, cr_identifier  kc_p2)
#else
(kc_p1, kc_p2) cr_identifier kc_p1, kc_p2;
#endif
{ return kc_do_eq_phylum( (kc_voidptr_t)kc_p1, (kc_voidptr_t)kc_p2, kc_phylum_cr_identifier);  }
/*ARGSUSED*/ boolean eq_cr_extension
#ifdef KC_USE_PROTOTYPES
(cr_extension kc_p1, cr_extension  kc_p2)
#else
(kc_p1, kc_p2) cr_extension kc_p1, kc_p2;
#endif
{ return kc_do_eq_phylum( (kc_voidptr_t)kc_p1, (kc_voidptr_t)kc_p2, kc_phylum_cr_extension);  }
/*ARGSUSED*/ boolean eq_cr_operation_name
#ifdef KC_USE_PROTOTYPES
(cr_operation_name kc_p1, cr_operation_name  kc_p2)
#else
(kc_p1, kc_p2) cr_operation_name kc_p1, kc_p2;
#endif
{ return kc_do_eq_phylum( (kc_voidptr_t)kc_p1, (kc_voidptr_t)kc_p2, kc_phylum_cr_operation_name);  }
/*ARGSUSED*/ boolean eq_cr_sort_name
#ifdef KC_USE_PROTOTYPES
(cr_sort_name kc_p1, cr_sort_name  kc_p2)
#else
(kc_p1, kc_p2) cr_sort_name kc_p1, kc_p2;
#endif
{ return kc_do_eq_phylum( (kc_voidptr_t)kc_p1, (kc_voidptr_t)kc_p2, kc_phylum_cr_sort_name);  }
/*ARGSUSED*/ boolean eq_cr_name
#ifdef KC_USE_PROTOTYPES
(cr_name kc_p1, cr_name  kc_p2)
#else
(kc_p1, kc_p2) cr_name kc_p1, kc_p2;
#endif
{ return kc_do_eq_phylum( (kc_voidptr_t)kc_p1, (kc_voidptr_t)kc_p2, kc_phylum_cr_name);  }
/*ARGSUSED*/ boolean eq_cr_comment_list
#ifdef KC_USE_PROTOTYPES
(cr_comment_list kc_p1, cr_comment_list  kc_p2)
#else
(kc_p1, kc_p2) cr_comment_list kc_p1, kc_p2;
#endif
{ return kc_do_eq_phylum( (kc_voidptr_t)kc_p1, (kc_voidptr_t)kc_p2, kc_phylum_cr_comment_list);  }
/*ARGSUSED*/ boolean eq_cr_annotation_list
#ifdef KC_USE_PROTOTYPES
(cr_annotation_list kc_p1, cr_annotation_list  kc_p2)
#else
(kc_p1, kc_p2) cr_annotation_list kc_p1, kc_p2;
#endif
{ return kc_do_eq_phylum( (kc_voidptr_t)kc_p1, (kc_voidptr_t)kc_p2, kc_phylum_cr_annotation_list);  }
/*ARGSUSED*/ boolean eq_cr_LABEL
#ifdef KC_USE_PROTOTYPES
(cr_LABEL kc_p1, cr_LABEL  kc_p2)
#else
(kc_p1, kc_p2) cr_LABEL kc_p1, kc_p2;
#endif
{ return kc_do_eq_phylum( (kc_voidptr_t)kc_p1, (kc_voidptr_t)kc_p2, kc_phylum_cr_LABEL);  }
static void kc_do_print_phylum
#ifdef KC_USE_PROTOTYPES
(kc_voidptr_t kc_p, kc_enum_phyla kc_phylum)
#else
(kc_p, kc_phylum) kc_voidptr_t kc_p; kc_enum_phyla kc_phylum;
#endif
{	int kc_i;
	static int kc_indentation = 0;
	static char *kc_printformat_not_nullair_open = "%*s%s(\n";
	static char *kc_printformat_not_nullair_close = "%*s)\n";
	static char *kc_printformat_nullair = "%*s%s()\n";

	assertPhylum(((casestring)kc_p),"kc_p",kc_phylum);
	if (kc_phylum == kc_phylum_int) {
		(void)printf("%*s%d\n", kc_indentation, "", (int)kc_p);
	} else if (kc_phylum == kc_phylum_float) {
		YYSTYPE kc_y;
		kc_y.yt_int = (int)kc_p; /* VERY DIRTY */
		(void)printf("%*s%f\n", kc_indentation, "", (float)kc_y.yt_float);
	} else if ((kc_phylum == kc_phylum_casestring) || (kc_phylum == kc_phylum_nocasestring)) {
		(void)printf("%*s%s\n", kc_indentation, "", ((casestring)kc_p)->name);
	} else {
		kc_enum_operators kc_prodsel = ((casestring)kc_p)->prod_sel;
		KC_OPERATOR_INFO *kc_op_info = &kc_OperatorInfo[(int)kc_prodsel];
		if (! kc_op_info->no_sons) {
			(void)printf(kc_printformat_nullair, kc_indentation, "", kc_op_info->name);
		} else {
			(void)printf(kc_printformat_not_nullair_open, kc_indentation, "", kc_op_info->name);
			kc_indentation++;
			for (kc_i=0; kc_i < kc_op_info->no_sons; kc_i++) {
				kc_do_print_phylum( (kc_voidptr_t)KC_SUBPHYLUM(kc_p, kc_op_info->suboffset[kc_i]), kc_op_info->subphylum[kc_i] );
			}
			kc_indentation--;
			(void)printf(kc_printformat_not_nullair_close, kc_indentation, "");
}	}	}	
void print_nocasestring
#ifdef KC_USE_PROTOTYPES
(nocasestring kc_p)
#else
(kc_p) nocasestring kc_p;
#endif
{ kc_do_print_phylum( (kc_voidptr_t)kc_p, kc_phylum_nocasestring);  }
void print_casestring
#ifdef KC_USE_PROTOTYPES
(casestring kc_p)
#else
(kc_p) casestring kc_p;
#endif
{ kc_do_print_phylum( (kc_voidptr_t)kc_p, kc_phylum_casestring);  }
void print_float
#ifdef KC_USE_PROTOTYPES
(float kc_p)
#else
(kc_p) float kc_p;
#endif
{ 	YYSTYPE kc_y;
	kc_y.yt_float = kc_p; /* VERY DIRTY */
	kc_do_print_phylum( (kc_voidptr_t)kc_y.yt_int, kc_phylum_float);
}
void print_int
#ifdef KC_USE_PROTOTYPES
(int kc_p)
#else
(kc_p) int kc_p;
#endif
{ kc_do_print_phylum( (kc_voidptr_t)kc_p, kc_phylum_int);  }
void print_cr_specification
#ifdef KC_USE_PROTOTYPES
(cr_specification kc_p)
#else
(kc_p) cr_specification kc_p;
#endif
{ kc_do_print_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_specification);  }
void print_cr_specification_type
#ifdef KC_USE_PROTOTYPES
(cr_specification_type kc_p)
#else
(kc_p) cr_specification_type kc_p;
#endif
{ kc_do_print_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_specification_type);  }
void print_cr_boolean_indication
#ifdef KC_USE_PROTOTYPES
(cr_boolean_indication kc_p)
#else
(kc_p) cr_boolean_indication kc_p;
#endif
{ kc_do_print_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_boolean_indication);  }
void print_cr_definition_block
#ifdef KC_USE_PROTOTYPES
(cr_definition_block kc_p)
#else
(kc_p) cr_definition_block kc_p;
#endif
{ kc_do_print_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_definition_block);  }
void print_cr_process_definition_list
#ifdef KC_USE_PROTOTYPES
(cr_process_definition_list kc_p)
#else
(kc_p) cr_process_definition_list kc_p;
#endif
{ kc_do_print_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_process_definition_list);  }
void print_cr_process_definition
#ifdef KC_USE_PROTOTYPES
(cr_process_definition kc_p)
#else
(kc_p) cr_process_definition kc_p;
#endif
{ kc_do_print_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_process_definition);  }
void print_cr_functionality
#ifdef KC_USE_PROTOTYPES
(cr_functionality kc_p)
#else
(kc_p) cr_functionality kc_p;
#endif
{ kc_do_print_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_functionality);  }
void print_cr_sort_identifier_list
#ifdef KC_USE_PROTOTYPES
(cr_sort_identifier_list kc_p)
#else
(kc_p) cr_sort_identifier_list kc_p;
#endif
{ kc_do_print_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_sort_identifier_list);  }
void print_cr_data_type_definition_list
#ifdef KC_USE_PROTOTYPES
(cr_data_type_definition_list kc_p)
#else
(kc_p) cr_data_type_definition_list kc_p;
#endif
{ kc_do_print_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_data_type_definition_list);  }
void print_cr_data_type_definition
#ifdef KC_USE_PROTOTYPES
(cr_data_type_definition kc_p)
#else
(kc_p) cr_data_type_definition kc_p;
#endif
{ kc_do_print_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_data_type_definition);  }
void print_cr_completeness_indication
#ifdef KC_USE_PROTOTYPES
(cr_completeness_indication kc_p)
#else
(kc_p) cr_completeness_indication kc_p;
#endif
{ kc_do_print_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_completeness_indication);  }
void print_cr_persistency_indication
#ifdef KC_USE_PROTOTYPES
(cr_persistency_indication kc_p)
#else
(kc_p) cr_persistency_indication kc_p;
#endif
{ kc_do_print_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_persistency_indication);  }
void print_cr_p_expression
#ifdef KC_USE_PROTOTYPES
(cr_p_expression kc_p)
#else
(kc_p) cr_p_expression kc_p;
#endif
{ kc_do_print_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_p_expression);  }
void print_cr_type_identifier_list
#ifdef KC_USE_PROTOTYPES
(cr_type_identifier_list kc_p)
#else
(kc_p) cr_type_identifier_list kc_p;
#endif
{ kc_do_print_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_type_identifier_list);  }
void print_cr_replacement
#ifdef KC_USE_PROTOTYPES
(cr_replacement kc_p)
#else
(kc_p) cr_replacement kc_p;
#endif
{ kc_do_print_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_replacement);  }
void print_cr_sort_replacement_list
#ifdef KC_USE_PROTOTYPES
(cr_sort_replacement_list kc_p)
#else
(kc_p) cr_sort_replacement_list kc_p;
#endif
{ kc_do_print_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_sort_replacement_list);  }
void print_cr_sort_replacement
#ifdef KC_USE_PROTOTYPES
(cr_sort_replacement kc_p)
#else
(kc_p) cr_sort_replacement kc_p;
#endif
{ kc_do_print_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_sort_replacement);  }
void print_cr_sort_declaration_list
#ifdef KC_USE_PROTOTYPES
(cr_sort_declaration_list kc_p)
#else
(kc_p) cr_sort_declaration_list kc_p;
#endif
{ kc_do_print_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_sort_declaration_list);  }
void print_cr_sort_declaration
#ifdef KC_USE_PROTOTYPES
(cr_sort_declaration kc_p)
#else
(kc_p) cr_sort_declaration kc_p;
#endif
{ kc_do_print_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_sort_declaration);  }
void print_cr_operation_replacement_list
#ifdef KC_USE_PROTOTYPES
(cr_operation_replacement_list kc_p)
#else
(kc_p) cr_operation_replacement_list kc_p;
#endif
{ kc_do_print_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_operation_replacement_list);  }
void print_cr_operation_replacement
#ifdef KC_USE_PROTOTYPES
(cr_operation_replacement kc_p)
#else
(kc_p) cr_operation_replacement kc_p;
#endif
{ kc_do_print_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_operation_replacement);  }
void print_cr_flattened_type_definition
#ifdef KC_USE_PROTOTYPES
(cr_flattened_type_definition kc_p)
#else
(kc_p) cr_flattened_type_definition kc_p;
#endif
{ kc_do_print_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_flattened_type_definition);  }
void print_cr_operation_list
#ifdef KC_USE_PROTOTYPES
(cr_operation_list kc_p)
#else
(kc_p) cr_operation_list kc_p;
#endif
{ kc_do_print_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_operation_list);  }
void print_cr_operation
#ifdef KC_USE_PROTOTYPES
(cr_operation kc_p)
#else
(kc_p) cr_operation kc_p;
#endif
{ kc_do_print_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_operation);  }
void print_cr_prefix_infix
#ifdef KC_USE_PROTOTYPES
(cr_prefix_infix kc_p)
#else
(kc_p) cr_prefix_infix kc_p;
#endif
{ kc_do_print_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_prefix_infix);  }
void print_cr_rewrite_strategy
#ifdef KC_USE_PROTOTYPES
(cr_rewrite_strategy kc_p)
#else
(kc_p) cr_rewrite_strategy kc_p;
#endif
{ kc_do_print_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_rewrite_strategy);  }
void print_cr_operator_class
#ifdef KC_USE_PROTOTYPES
(cr_operator_class kc_p)
#else
(kc_p) cr_operator_class kc_p;
#endif
{ kc_do_print_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_operator_class);  }
void print_cr_equations_option
#ifdef KC_USE_PROTOTYPES
(cr_equations_option kc_p)
#else
(kc_p) cr_equations_option kc_p;
#endif
{ kc_do_print_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_equations_option);  }
void print_cr_equation_structure_list
#ifdef KC_USE_PROTOTYPES
(cr_equation_structure_list kc_p)
#else
(kc_p) cr_equation_structure_list kc_p;
#endif
{ kc_do_print_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_equation_structure_list);  }
void print_cr_equation_structure
#ifdef KC_USE_PROTOTYPES
(cr_equation_structure kc_p)
#else
(kc_p) cr_equation_structure kc_p;
#endif
{ kc_do_print_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_equation_structure);  }
void print_cr_equation_list
#ifdef KC_USE_PROTOTYPES
(cr_equation_list kc_p)
#else
(kc_p) cr_equation_list kc_p;
#endif
{ kc_do_print_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_equation_list);  }
void print_cr_equation
#ifdef KC_USE_PROTOTYPES
(cr_equation kc_p)
#else
(kc_p) cr_equation kc_p;
#endif
{ kc_do_print_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_equation);  }
void print_cr_premiss_list
#ifdef KC_USE_PROTOTYPES
(cr_premiss_list kc_p)
#else
(kc_p) cr_premiss_list kc_p;
#endif
{ kc_do_print_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_premiss_list);  }
void print_cr_equality
#ifdef KC_USE_PROTOTYPES
(cr_equality kc_p)
#else
(kc_p) cr_equality kc_p;
#endif
{ kc_do_print_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_equality);  }
void print_cr_identifier_declaration_list
#ifdef KC_USE_PROTOTYPES
(cr_identifier_declaration_list kc_p)
#else
(kc_p) cr_identifier_declaration_list kc_p;
#endif
{ kc_do_print_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_identifier_declaration_list);  }
void print_cr_identifier_declaration
#ifdef KC_USE_PROTOTYPES
(cr_identifier_declaration kc_p)
#else
(kc_p) cr_identifier_declaration kc_p;
#endif
{ kc_do_print_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_identifier_declaration);  }
void print_cr_value_identifier_list
#ifdef KC_USE_PROTOTYPES
(cr_value_identifier_list kc_p)
#else
(kc_p) cr_value_identifier_list kc_p;
#endif
{ kc_do_print_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_value_identifier_list);  }
void print_cr_annotated_value_identifier
#ifdef KC_USE_PROTOTYPES
(cr_annotated_value_identifier kc_p)
#else
(kc_p) cr_annotated_value_identifier kc_p;
#endif
{ kc_do_print_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_annotated_value_identifier);  }
void print_cr_behaviour_expression
#ifdef KC_USE_PROTOTYPES
(cr_behaviour_expression kc_p)
#else
(kc_p) cr_behaviour_expression kc_p;
#endif
{ kc_do_print_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_behaviour_expression);  }
void print_cr_parallel_operator
#ifdef KC_USE_PROTOTYPES
(cr_parallel_operator kc_p)
#else
(kc_p) cr_parallel_operator kc_p;
#endif
{ kc_do_print_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_parallel_operator);  }
void print_cr_gate_declaration_list
#ifdef KC_USE_PROTOTYPES
(cr_gate_declaration_list kc_p)
#else
(kc_p) cr_gate_declaration_list kc_p;
#endif
{ kc_do_print_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_gate_declaration_list);  }
void print_cr_gate_declaration
#ifdef KC_USE_PROTOTYPES
(cr_gate_declaration kc_p)
#else
(kc_p) cr_gate_declaration kc_p;
#endif
{ kc_do_print_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_gate_declaration);  }
void print_cr_gate_identifier_list
#ifdef KC_USE_PROTOTYPES
(cr_gate_identifier_list kc_p)
#else
(kc_p) cr_gate_identifier_list kc_p;
#endif
{ kc_do_print_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_gate_identifier_list);  }
void print_cr_exit_entry_list
#ifdef KC_USE_PROTOTYPES
(cr_exit_entry_list kc_p)
#else
(kc_p) cr_exit_entry_list kc_p;
#endif
{ kc_do_print_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_exit_entry_list);  }
void print_cr_exit_entry
#ifdef KC_USE_PROTOTYPES
(cr_exit_entry kc_p)
#else
(kc_p) cr_exit_entry kc_p;
#endif
{ kc_do_print_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_exit_entry);  }
void print_cr_identifier_equation_list
#ifdef KC_USE_PROTOTYPES
(cr_identifier_equation_list kc_p)
#else
(kc_p) cr_identifier_equation_list kc_p;
#endif
{ kc_do_print_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_identifier_equation_list);  }
void print_cr_identifier_equation
#ifdef KC_USE_PROTOTYPES
(cr_identifier_equation kc_p)
#else
(kc_p) cr_identifier_equation kc_p;
#endif
{ kc_do_print_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_identifier_equation);  }
void print_cr_action_denotation
#ifdef KC_USE_PROTOTYPES
(cr_action_denotation kc_p)
#else
(kc_p) cr_action_denotation kc_p;
#endif
{ kc_do_print_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_action_denotation);  }
void print_cr_experiment_option
#ifdef KC_USE_PROTOTYPES
(cr_experiment_option kc_p)
#else
(kc_p) cr_experiment_option kc_p;
#endif
{ kc_do_print_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_experiment_option);  }
void print_cr_experiment_offer_list
#ifdef KC_USE_PROTOTYPES
(cr_experiment_offer_list kc_p)
#else
(kc_p) cr_experiment_offer_list kc_p;
#endif
{ kc_do_print_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_experiment_offer_list);  }
void print_cr_experiment_offer
#ifdef KC_USE_PROTOTYPES
(cr_experiment_offer kc_p)
#else
(kc_p) cr_experiment_offer kc_p;
#endif
{ kc_do_print_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_experiment_offer);  }
void print_cr_guard_option
#ifdef KC_USE_PROTOTYPES
(cr_guard_option kc_p)
#else
(kc_p) cr_guard_option kc_p;
#endif
{ kc_do_print_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_guard_option);  }
void print_cr_value_expression_list
#ifdef KC_USE_PROTOTYPES
(cr_value_expression_list kc_p)
#else
(kc_p) cr_value_expression_list kc_p;
#endif
{ kc_do_print_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_value_expression_list);  }
void print_cr_value_expression
#ifdef KC_USE_PROTOTYPES
(cr_value_expression kc_p)
#else
(kc_p) cr_value_expression kc_p;
#endif
{ kc_do_print_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_value_expression);  }
void print_cr_specification_identifier
#ifdef KC_USE_PROTOTYPES
(cr_specification_identifier kc_p)
#else
(kc_p) cr_specification_identifier kc_p;
#endif
{ kc_do_print_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_specification_identifier);  }
void print_cr_operation_identifier
#ifdef KC_USE_PROTOTYPES
(cr_operation_identifier kc_p)
#else
(kc_p) cr_operation_identifier kc_p;
#endif
{ kc_do_print_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_operation_identifier);  }
void print_cr_type_identifier
#ifdef KC_USE_PROTOTYPES
(cr_type_identifier kc_p)
#else
(kc_p) cr_type_identifier kc_p;
#endif
{ kc_do_print_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_type_identifier);  }
void print_cr_sort_identifier
#ifdef KC_USE_PROTOTYPES
(cr_sort_identifier kc_p)
#else
(kc_p) cr_sort_identifier kc_p;
#endif
{ kc_do_print_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_sort_identifier);  }
void print_cr_gate_identifier
#ifdef KC_USE_PROTOTYPES
(cr_gate_identifier kc_p)
#else
(kc_p) cr_gate_identifier kc_p;
#endif
{ kc_do_print_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_gate_identifier);  }
void print_cr_value_identifier
#ifdef KC_USE_PROTOTYPES
(cr_value_identifier kc_p)
#else
(kc_p) cr_value_identifier kc_p;
#endif
{ kc_do_print_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_value_identifier);  }
void print_cr_process_identifier
#ifdef KC_USE_PROTOTYPES
(cr_process_identifier kc_p)
#else
(kc_p) cr_process_identifier kc_p;
#endif
{ kc_do_print_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_process_identifier);  }
void print_cr_identifier
#ifdef KC_USE_PROTOTYPES
(cr_identifier kc_p)
#else
(kc_p) cr_identifier kc_p;
#endif
{ kc_do_print_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_identifier);  }
void print_cr_extension
#ifdef KC_USE_PROTOTYPES
(cr_extension kc_p)
#else
(kc_p) cr_extension kc_p;
#endif
{ kc_do_print_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_extension);  }
void print_cr_operation_name
#ifdef KC_USE_PROTOTYPES
(cr_operation_name kc_p)
#else
(kc_p) cr_operation_name kc_p;
#endif
{ kc_do_print_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_operation_name);  }
void print_cr_sort_name
#ifdef KC_USE_PROTOTYPES
(cr_sort_name kc_p)
#else
(kc_p) cr_sort_name kc_p;
#endif
{ kc_do_print_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_sort_name);  }
void print_cr_name
#ifdef KC_USE_PROTOTYPES
(cr_name kc_p)
#else
(kc_p) cr_name kc_p;
#endif
{ kc_do_print_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_name);  }
void print_cr_comment_list
#ifdef KC_USE_PROTOTYPES
(cr_comment_list kc_p)
#else
(kc_p) cr_comment_list kc_p;
#endif
{ kc_do_print_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_comment_list);  }
void print_cr_annotation_list
#ifdef KC_USE_PROTOTYPES
(cr_annotation_list kc_p)
#else
(kc_p) cr_annotation_list kc_p;
#endif
{ kc_do_print_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_annotation_list);  }
void print_cr_LABEL
#ifdef KC_USE_PROTOTYPES
(cr_LABEL kc_p)
#else
(kc_p) cr_LABEL kc_p;
#endif
{ kc_do_print_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_LABEL);  }
static char *kc_error_concat = "concat_";
static char *kc_error_reverse = "reverse_";
static char *kc_error_length = "length_";
static char *kc_error_last = "last_";
static char *kc_error_last_with_nil_argument = "Internal Error: last_%s was called with argument Nil%s\n";
static char *kc_error_map = "map_";
static char *kc_error_filter = "filter_";
static char *kc_error_freelist = "freelist_";

static int kc_do_length_phylum
#ifdef KC_USE_PROTOTYPES
(kc_voidptr_t kc_p, kc_enum_phyla kc_phylum )
#else
(kc_p, kc_phylum) kc_voidptr_t kc_p; kc_enum_phyla kc_phylum;
#endif
{	boolean kc_not_ready = True;
	int kc_length = 0;
	kc_enum_operators kc_prodsel;
	while(kc_not_ready) {
		assertPhylum(((casestring)kc_p),"kc_p",kc_phylum);
		kc_prodsel = ((casestring)kc_p)->prod_sel;
		if (kc_prodsel == kc_PhylumInfo[(int)kc_phylum].first_operator) {
			kc_not_ready=False;
		} else if (kc_prodsel == kc_PhylumInfo[(int)kc_phylum].last_operator) {
			kc_length++;
			kc_p = (kc_voidptr_t)KC_SUBPHYLUM(kc_p, kc_OperatorInfo[(int)kc_prodsel].suboffset[1]);
		} else {
			kc_invalid_operator(kc_error_length, kc_phylum, __LINE__, __FILE__, (int)kc_prodsel);/*NOTREACHED*/
	}	}
	return kc_length;
}

static void kc_do_freelist_phylum
#ifdef KC_USE_PROTOTYPES
(kc_voidptr_t kc_p, kc_enum_phyla kc_phylum )
#else
(kc_p, kc_phylum) kc_voidptr_t kc_p; kc_enum_phyla kc_phylum;
#endif
{	boolean kc_not_ready = True;
	kc_enum_operators kc_prodsel;
	kc_voidptr_t kc_tmp_p;
	while(kc_not_ready) {
		assertPhylum(((casestring)kc_p),"kc_p",kc_phylum);
		kc_prodsel = ((casestring)kc_p)->prod_sel;
		if (kc_prodsel == kc_PhylumInfo[(int)kc_phylum].first_operator) {
			kc_do_free_phylum(kc_p, False, kc_phylum);
			kc_not_ready=False;
		} else if (kc_prodsel == kc_PhylumInfo[(int)kc_phylum].last_operator) {
			kc_tmp_p = kc_p;
			kc_p = (kc_voidptr_t)KC_SUBPHYLUM(kc_p, kc_OperatorInfo[(int)kc_prodsel].suboffset[1]);
			kc_do_free_phylum(kc_tmp_p, False, kc_phylum);
		} else {
			kc_invalid_operator(kc_error_freelist, kc_phylum, __LINE__, __FILE__, (int)kc_prodsel);/*NOTREACHED*/
}	}	}

static kc_voidptr_t kc_do_concat_phylum
#ifdef KC_USE_PROTOTYPES
(kc_voidptr_t kc_p1, kc_voidptr_t kc_p2, kc_enum_phyla kc_phylum)
#else
(kc_p1, kc_p2, kc_phylum) kc_voidptr_t kc_p1, kc_p2; kc_enum_phyla kc_phylum;
#endif
{	kc_enum_operators kc_prodsel;
	assertPhylum(((casestring)kc_p1),"kc_p1",kc_phylum);
	kc_prodsel = ((casestring)kc_p1)->prod_sel;
	if (kc_prodsel == kc_PhylumInfo[(int)kc_phylum].first_operator) {
		return kc_p2;
	} else if (kc_prodsel == kc_PhylumInfo[(int)kc_phylum].last_operator) {
		return (kc_voidptr_t)(*kc_OperatorInfo[(int)kc_prodsel].create_routine)(
			(kc_voidptr_t)KC_SUBPHYLUM(kc_p1, kc_OperatorInfo[(int)kc_prodsel].suboffset[0]),
			 kc_do_concat_phylum( (kc_voidptr_t)KC_SUBPHYLUM(kc_p1, kc_OperatorInfo[(int)kc_prodsel].suboffset[1]), kc_p2, kc_phylum ) );
	} else {
		kc_invalid_operator(kc_error_concat, kc_phylum, __LINE__, __FILE__, (int)kc_prodsel);/*NOTREACHED*/
}	}

static kc_voidptr_t kc_do_reverse_phylum
#ifdef KC_USE_PROTOTYPES
(kc_voidptr_t kc_p, kc_enum_phyla kc_phylum)
#else
(kc_p, kc_phylum) kc_voidptr_t kc_p; kc_enum_phyla kc_phylum;
#endif
{	boolean kc_not_ready = True;
	kc_enum_operators kc_prodsel;
	KC_PHYLUM_INFO *kc_phy_info = &kc_PhylumInfo[(int)kc_phylum];
	KC_OPERATOR_INFO *kc_firstop_info = &kc_OperatorInfo[(int)kc_phy_info->first_operator];
	KC_OPERATOR_INFO *kc_lastop_info = &kc_OperatorInfo[(int)kc_phy_info->last_operator];
	kc_voidptr_t kc_tmp = (*kc_firstop_info->create_routine)();
	while(kc_not_ready) {
		assertPhylum(((casestring)kc_p),"kc_p",kc_phylum);
		kc_prodsel = ((casestring)kc_p)->prod_sel;
		if (kc_prodsel == kc_phy_info->first_operator) {
			kc_not_ready=False;
		} else if (kc_prodsel == kc_phy_info->last_operator) {
			kc_tmp = (kc_voidptr_t)(*kc_lastop_info->create_routine)((kc_voidptr_t)KC_SUBPHYLUM(kc_p, kc_lastop_info->suboffset[0]), kc_tmp);
			kc_p = (kc_voidptr_t)KC_SUBPHYLUM(kc_p, kc_lastop_info->suboffset[1]);
		} else {
			kc_invalid_operator(kc_error_reverse, kc_phylum, __LINE__, __FILE__, (int)kc_prodsel);/*NOTREACHED*/
	}	}
	return kc_tmp;
}

static kc_voidptr_t kc_do_last_phylum
#ifdef KC_USE_PROTOTYPES
(kc_voidptr_t kc_p, kc_enum_phyla kc_phylum)
#else
(kc_p, kc_phylum) kc_voidptr_t kc_p; kc_enum_phyla kc_phylum;
#endif
{	boolean kc_not_ready = True;
	kc_voidptr_t kc_tmp = (kc_voidptr_t)0;
	kc_enum_operators kc_prodsel;
	KC_PHYLUM_INFO *kc_phy_info = &kc_PhylumInfo[(int)kc_phylum];
	KC_OPERATOR_INFO *kc_lastop_info = &kc_OperatorInfo[(int)kc_phy_info->last_operator];
	assertPhylum(((casestring)kc_p),"kc_p",kc_phylum);
	if (((casestring)kc_p)->prod_sel == kc_phy_info->first_operator) {
		(void)fflush(stdout); (void)fprintf(stderr, kc_error_last_with_nil_argument, kc_phy_info->name,  kc_phy_info->name); exit( 1 ); /*NOTREACHED*/
	}
	while(kc_not_ready) {
		assertPhylum(((casestring)kc_p),"kc_p",kc_phylum);
		kc_prodsel = ((casestring)kc_p)->prod_sel;
		if (kc_prodsel == kc_phy_info->first_operator) {
			kc_not_ready=False;
		} else if (kc_prodsel == kc_phy_info->last_operator) {
			kc_tmp = (kc_voidptr_t)KC_SUBPHYLUM(kc_p, kc_lastop_info->suboffset[0]);
			kc_p = (kc_voidptr_t)KC_SUBPHYLUM(kc_p, kc_lastop_info->suboffset[1]);
		} else {
			kc_invalid_operator(kc_error_last, kc_phylum, __LINE__, __FILE__, (int)kc_prodsel);/*NOTREACHED*/
	}	}
	return kc_tmp;
}

static kc_voidptr_t kc_do_map_phylum
#ifdef KC_USE_PROTOTYPES
(kc_voidptr_t kc_p, kc_voidptr_t (*kc_fp)(kc_voidptr_t), kc_enum_phyla kc_phylum)
#else
(kc_p, kc_fp, kc_phylum) kc_voidptr_t kc_p; kc_voidptr_t (*kc_fp)KC__P((kc_voidptr_t)); kc_enum_phyla kc_phylum;
#endif
{	kc_enum_operators kc_prodsel;
	assertPhylum(((casestring)kc_p),"kc_p",kc_phylum);
	kc_prodsel = ((casestring)kc_p)->prod_sel;
	if (kc_prodsel == kc_PhylumInfo[(int)kc_phylum].first_operator) {
		return kc_p;
	} else if (kc_prodsel == kc_PhylumInfo[(int)kc_phylum].last_operator) {
		return (kc_voidptr_t)(*kc_OperatorInfo[(int)kc_prodsel].create_routine)(
			(*kc_fp)((kc_voidptr_t)KC_SUBPHYLUM(kc_p, kc_OperatorInfo[(int)kc_prodsel].suboffset[0])),
			kc_do_map_phylum((kc_voidptr_t)KC_SUBPHYLUM(kc_p, kc_OperatorInfo[(int)kc_prodsel].suboffset[1]), kc_fp, kc_phylum));
	} else {
		kc_invalid_operator(kc_error_map, kc_phylum, __LINE__, __FILE__, (int)kc_prodsel);/*NOTREACHED*/
}	}

static kc_voidptr_t kc_do_filter_phylum
#ifdef KC_USE_PROTOTYPES
(kc_voidptr_t kc_p,  boolean (*kc_fp)(kc_voidptr_t), kc_enum_phyla kc_phylum)
#else
(kc_p, kc_fp, kc_phylum) kc_voidptr_t kc_p; boolean (*kc_fp)KC__P((kc_voidptr_t)); kc_enum_phyla kc_phylum;
#endif
{	kc_enum_operators kc_prodsel;
	assertPhylum(((casestring)kc_p),"kc_p",kc_phylum);
	kc_prodsel = ((casestring)kc_p)->prod_sel;
	if (kc_prodsel == kc_PhylumInfo[(int)kc_phylum].first_operator) {
		return kc_p;
	} else if (kc_prodsel == kc_PhylumInfo[(int)kc_phylum].last_operator) {
		if ((*kc_fp)((kc_voidptr_t)KC_SUBPHYLUM(kc_p, kc_OperatorInfo[(int)kc_prodsel].suboffset[0]))) {
			return (kc_voidptr_t)(*kc_OperatorInfo[(int)kc_prodsel].create_routine)(
				(kc_voidptr_t)KC_SUBPHYLUM(kc_p, kc_OperatorInfo[(int)kc_prodsel].suboffset[0]),
				kc_do_filter_phylum((kc_voidptr_t)KC_SUBPHYLUM(kc_p, kc_OperatorInfo[(int)kc_prodsel].suboffset[1]), kc_fp, kc_phylum));
		} else {
			return kc_do_filter_phylum((kc_voidptr_t)KC_SUBPHYLUM(kc_p, kc_OperatorInfo[(int)kc_prodsel].suboffset[1]), kc_fp, kc_phylum);
		}
	} else {
		kc_invalid_operator(kc_error_filter, kc_phylum, __LINE__, __FILE__, (int)kc_prodsel);/*NOTREACHED*/
}	}

cr_process_definition_list concat_cr_process_definition_list
#ifdef KC_USE_PROTOTYPES
(cr_process_definition_list kc_p1, cr_process_definition_list kc_p2)
#else
(kc_p1, kc_p2) cr_process_definition_list kc_p1, kc_p2;
#endif
{ return (cr_process_definition_list)kc_do_concat_phylum( (kc_voidptr_t)kc_p1, (kc_voidptr_t)kc_p2, kc_phylum_cr_process_definition_list ); }
cr_process_definition_list reverse_cr_process_definition_list
#ifdef KC_USE_PROTOTYPES
(cr_process_definition_list kc_p)
#else
(kc_p) cr_process_definition_list kc_p;
#endif
{ return (cr_process_definition_list)kc_do_reverse_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_process_definition_list ); }
int length_cr_process_definition_list
#ifdef KC_USE_PROTOTYPES
(cr_process_definition_list kc_p)
#else
(kc_p) cr_process_definition_list kc_p;
#endif
{ return kc_do_length_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_process_definition_list ); }
cr_process_definition last_cr_process_definition_list
#ifdef KC_USE_PROTOTYPES
(cr_process_definition_list kc_p)
#else
(kc_p) cr_process_definition_list kc_p;
#endif
{ return (cr_process_definition)kc_do_last_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_process_definition_list ); }
cr_process_definition_list map_cr_process_definition_list
#ifdef KC_USE_PROTOTYPES
(cr_process_definition_list kc_p, cr_process_definition (*kc_fp)(cr_process_definition))
#else
(kc_p, kc_fp) cr_process_definition_list kc_p; cr_process_definition (*kc_fp)KC__P((cr_process_definition));
#endif
{ return (cr_process_definition_list)kc_do_map_phylum( (kc_voidptr_t)kc_p, (kc_voidptr_t (*)KC__P((kc_voidptr_t)))kc_fp, kc_phylum_cr_process_definition_list ); }
cr_process_definition_list filter_cr_process_definition_list
#ifdef KC_USE_PROTOTYPES
(cr_process_definition_list kc_p, boolean (*kc_fp)(cr_process_definition))
#else
(kc_p, kc_fp) cr_process_definition_list kc_p; boolean (*kc_fp)KC__P((cr_process_definition));
#endif
{ return (cr_process_definition_list)kc_do_filter_phylum( (kc_voidptr_t)kc_p, (boolean (*)KC__P((kc_voidptr_t)))kc_fp, kc_phylum_cr_process_definition_list ); }
void freelist_cr_process_definition_list
#ifdef KC_USE_PROTOTYPES
(cr_process_definition_list kc_p)
#else
(kc_p) cr_process_definition_list kc_p;
#endif
{ kc_do_freelist_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_process_definition_list ); }
cr_sort_identifier_list concat_cr_sort_identifier_list
#ifdef KC_USE_PROTOTYPES
(cr_sort_identifier_list kc_p1, cr_sort_identifier_list kc_p2)
#else
(kc_p1, kc_p2) cr_sort_identifier_list kc_p1, kc_p2;
#endif
{ return (cr_sort_identifier_list)kc_do_concat_phylum( (kc_voidptr_t)kc_p1, (kc_voidptr_t)kc_p2, kc_phylum_cr_sort_identifier_list ); }
cr_sort_identifier_list reverse_cr_sort_identifier_list
#ifdef KC_USE_PROTOTYPES
(cr_sort_identifier_list kc_p)
#else
(kc_p) cr_sort_identifier_list kc_p;
#endif
{ return (cr_sort_identifier_list)kc_do_reverse_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_sort_identifier_list ); }
int length_cr_sort_identifier_list
#ifdef KC_USE_PROTOTYPES
(cr_sort_identifier_list kc_p)
#else
(kc_p) cr_sort_identifier_list kc_p;
#endif
{ return kc_do_length_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_sort_identifier_list ); }
cr_sort_identifier last_cr_sort_identifier_list
#ifdef KC_USE_PROTOTYPES
(cr_sort_identifier_list kc_p)
#else
(kc_p) cr_sort_identifier_list kc_p;
#endif
{ return (cr_sort_identifier)kc_do_last_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_sort_identifier_list ); }
cr_sort_identifier_list map_cr_sort_identifier_list
#ifdef KC_USE_PROTOTYPES
(cr_sort_identifier_list kc_p, cr_sort_identifier (*kc_fp)(cr_sort_identifier))
#else
(kc_p, kc_fp) cr_sort_identifier_list kc_p; cr_sort_identifier (*kc_fp)KC__P((cr_sort_identifier));
#endif
{ return (cr_sort_identifier_list)kc_do_map_phylum( (kc_voidptr_t)kc_p, (kc_voidptr_t (*)KC__P((kc_voidptr_t)))kc_fp, kc_phylum_cr_sort_identifier_list ); }
cr_sort_identifier_list filter_cr_sort_identifier_list
#ifdef KC_USE_PROTOTYPES
(cr_sort_identifier_list kc_p, boolean (*kc_fp)(cr_sort_identifier))
#else
(kc_p, kc_fp) cr_sort_identifier_list kc_p; boolean (*kc_fp)KC__P((cr_sort_identifier));
#endif
{ return (cr_sort_identifier_list)kc_do_filter_phylum( (kc_voidptr_t)kc_p, (boolean (*)KC__P((kc_voidptr_t)))kc_fp, kc_phylum_cr_sort_identifier_list ); }
void freelist_cr_sort_identifier_list
#ifdef KC_USE_PROTOTYPES
(cr_sort_identifier_list kc_p)
#else
(kc_p) cr_sort_identifier_list kc_p;
#endif
{ kc_do_freelist_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_sort_identifier_list ); }
cr_data_type_definition_list concat_cr_data_type_definition_list
#ifdef KC_USE_PROTOTYPES
(cr_data_type_definition_list kc_p1, cr_data_type_definition_list kc_p2)
#else
(kc_p1, kc_p2) cr_data_type_definition_list kc_p1, kc_p2;
#endif
{ return (cr_data_type_definition_list)kc_do_concat_phylum( (kc_voidptr_t)kc_p1, (kc_voidptr_t)kc_p2, kc_phylum_cr_data_type_definition_list ); }
cr_data_type_definition_list reverse_cr_data_type_definition_list
#ifdef KC_USE_PROTOTYPES
(cr_data_type_definition_list kc_p)
#else
(kc_p) cr_data_type_definition_list kc_p;
#endif
{ return (cr_data_type_definition_list)kc_do_reverse_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_data_type_definition_list ); }
int length_cr_data_type_definition_list
#ifdef KC_USE_PROTOTYPES
(cr_data_type_definition_list kc_p)
#else
(kc_p) cr_data_type_definition_list kc_p;
#endif
{ return kc_do_length_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_data_type_definition_list ); }
cr_data_type_definition last_cr_data_type_definition_list
#ifdef KC_USE_PROTOTYPES
(cr_data_type_definition_list kc_p)
#else
(kc_p) cr_data_type_definition_list kc_p;
#endif
{ return (cr_data_type_definition)kc_do_last_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_data_type_definition_list ); }
cr_data_type_definition_list map_cr_data_type_definition_list
#ifdef KC_USE_PROTOTYPES
(cr_data_type_definition_list kc_p, cr_data_type_definition (*kc_fp)(cr_data_type_definition))
#else
(kc_p, kc_fp) cr_data_type_definition_list kc_p; cr_data_type_definition (*kc_fp)KC__P((cr_data_type_definition));
#endif
{ return (cr_data_type_definition_list)kc_do_map_phylum( (kc_voidptr_t)kc_p, (kc_voidptr_t (*)KC__P((kc_voidptr_t)))kc_fp, kc_phylum_cr_data_type_definition_list ); }
cr_data_type_definition_list filter_cr_data_type_definition_list
#ifdef KC_USE_PROTOTYPES
(cr_data_type_definition_list kc_p, boolean (*kc_fp)(cr_data_type_definition))
#else
(kc_p, kc_fp) cr_data_type_definition_list kc_p; boolean (*kc_fp)KC__P((cr_data_type_definition));
#endif
{ return (cr_data_type_definition_list)kc_do_filter_phylum( (kc_voidptr_t)kc_p, (boolean (*)KC__P((kc_voidptr_t)))kc_fp, kc_phylum_cr_data_type_definition_list ); }
void freelist_cr_data_type_definition_list
#ifdef KC_USE_PROTOTYPES
(cr_data_type_definition_list kc_p)
#else
(kc_p) cr_data_type_definition_list kc_p;
#endif
{ kc_do_freelist_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_data_type_definition_list ); }
cr_type_identifier_list concat_cr_type_identifier_list
#ifdef KC_USE_PROTOTYPES
(cr_type_identifier_list kc_p1, cr_type_identifier_list kc_p2)
#else
(kc_p1, kc_p2) cr_type_identifier_list kc_p1, kc_p2;
#endif
{ return (cr_type_identifier_list)kc_do_concat_phylum( (kc_voidptr_t)kc_p1, (kc_voidptr_t)kc_p2, kc_phylum_cr_type_identifier_list ); }
cr_type_identifier_list reverse_cr_type_identifier_list
#ifdef KC_USE_PROTOTYPES
(cr_type_identifier_list kc_p)
#else
(kc_p) cr_type_identifier_list kc_p;
#endif
{ return (cr_type_identifier_list)kc_do_reverse_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_type_identifier_list ); }
int length_cr_type_identifier_list
#ifdef KC_USE_PROTOTYPES
(cr_type_identifier_list kc_p)
#else
(kc_p) cr_type_identifier_list kc_p;
#endif
{ return kc_do_length_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_type_identifier_list ); }
cr_type_identifier last_cr_type_identifier_list
#ifdef KC_USE_PROTOTYPES
(cr_type_identifier_list kc_p)
#else
(kc_p) cr_type_identifier_list kc_p;
#endif
{ return (cr_type_identifier)kc_do_last_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_type_identifier_list ); }
cr_type_identifier_list map_cr_type_identifier_list
#ifdef KC_USE_PROTOTYPES
(cr_type_identifier_list kc_p, cr_type_identifier (*kc_fp)(cr_type_identifier))
#else
(kc_p, kc_fp) cr_type_identifier_list kc_p; cr_type_identifier (*kc_fp)KC__P((cr_type_identifier));
#endif
{ return (cr_type_identifier_list)kc_do_map_phylum( (kc_voidptr_t)kc_p, (kc_voidptr_t (*)KC__P((kc_voidptr_t)))kc_fp, kc_phylum_cr_type_identifier_list ); }
cr_type_identifier_list filter_cr_type_identifier_list
#ifdef KC_USE_PROTOTYPES
(cr_type_identifier_list kc_p, boolean (*kc_fp)(cr_type_identifier))
#else
(kc_p, kc_fp) cr_type_identifier_list kc_p; boolean (*kc_fp)KC__P((cr_type_identifier));
#endif
{ return (cr_type_identifier_list)kc_do_filter_phylum( (kc_voidptr_t)kc_p, (boolean (*)KC__P((kc_voidptr_t)))kc_fp, kc_phylum_cr_type_identifier_list ); }
void freelist_cr_type_identifier_list
#ifdef KC_USE_PROTOTYPES
(cr_type_identifier_list kc_p)
#else
(kc_p) cr_type_identifier_list kc_p;
#endif
{ kc_do_freelist_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_type_identifier_list ); }
cr_sort_replacement_list concat_cr_sort_replacement_list
#ifdef KC_USE_PROTOTYPES
(cr_sort_replacement_list kc_p1, cr_sort_replacement_list kc_p2)
#else
(kc_p1, kc_p2) cr_sort_replacement_list kc_p1, kc_p2;
#endif
{ return (cr_sort_replacement_list)kc_do_concat_phylum( (kc_voidptr_t)kc_p1, (kc_voidptr_t)kc_p2, kc_phylum_cr_sort_replacement_list ); }
cr_sort_replacement_list reverse_cr_sort_replacement_list
#ifdef KC_USE_PROTOTYPES
(cr_sort_replacement_list kc_p)
#else
(kc_p) cr_sort_replacement_list kc_p;
#endif
{ return (cr_sort_replacement_list)kc_do_reverse_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_sort_replacement_list ); }
int length_cr_sort_replacement_list
#ifdef KC_USE_PROTOTYPES
(cr_sort_replacement_list kc_p)
#else
(kc_p) cr_sort_replacement_list kc_p;
#endif
{ return kc_do_length_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_sort_replacement_list ); }
cr_sort_replacement last_cr_sort_replacement_list
#ifdef KC_USE_PROTOTYPES
(cr_sort_replacement_list kc_p)
#else
(kc_p) cr_sort_replacement_list kc_p;
#endif
{ return (cr_sort_replacement)kc_do_last_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_sort_replacement_list ); }
cr_sort_replacement_list map_cr_sort_replacement_list
#ifdef KC_USE_PROTOTYPES
(cr_sort_replacement_list kc_p, cr_sort_replacement (*kc_fp)(cr_sort_replacement))
#else
(kc_p, kc_fp) cr_sort_replacement_list kc_p; cr_sort_replacement (*kc_fp)KC__P((cr_sort_replacement));
#endif
{ return (cr_sort_replacement_list)kc_do_map_phylum( (kc_voidptr_t)kc_p, (kc_voidptr_t (*)KC__P((kc_voidptr_t)))kc_fp, kc_phylum_cr_sort_replacement_list ); }
cr_sort_replacement_list filter_cr_sort_replacement_list
#ifdef KC_USE_PROTOTYPES
(cr_sort_replacement_list kc_p, boolean (*kc_fp)(cr_sort_replacement))
#else
(kc_p, kc_fp) cr_sort_replacement_list kc_p; boolean (*kc_fp)KC__P((cr_sort_replacement));
#endif
{ return (cr_sort_replacement_list)kc_do_filter_phylum( (kc_voidptr_t)kc_p, (boolean (*)KC__P((kc_voidptr_t)))kc_fp, kc_phylum_cr_sort_replacement_list ); }
void freelist_cr_sort_replacement_list
#ifdef KC_USE_PROTOTYPES
(cr_sort_replacement_list kc_p)
#else
(kc_p) cr_sort_replacement_list kc_p;
#endif
{ kc_do_freelist_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_sort_replacement_list ); }
cr_sort_declaration_list concat_cr_sort_declaration_list
#ifdef KC_USE_PROTOTYPES
(cr_sort_declaration_list kc_p1, cr_sort_declaration_list kc_p2)
#else
(kc_p1, kc_p2) cr_sort_declaration_list kc_p1, kc_p2;
#endif
{ return (cr_sort_declaration_list)kc_do_concat_phylum( (kc_voidptr_t)kc_p1, (kc_voidptr_t)kc_p2, kc_phylum_cr_sort_declaration_list ); }
cr_sort_declaration_list reverse_cr_sort_declaration_list
#ifdef KC_USE_PROTOTYPES
(cr_sort_declaration_list kc_p)
#else
(kc_p) cr_sort_declaration_list kc_p;
#endif
{ return (cr_sort_declaration_list)kc_do_reverse_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_sort_declaration_list ); }
int length_cr_sort_declaration_list
#ifdef KC_USE_PROTOTYPES
(cr_sort_declaration_list kc_p)
#else
(kc_p) cr_sort_declaration_list kc_p;
#endif
{ return kc_do_length_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_sort_declaration_list ); }
cr_sort_declaration last_cr_sort_declaration_list
#ifdef KC_USE_PROTOTYPES
(cr_sort_declaration_list kc_p)
#else
(kc_p) cr_sort_declaration_list kc_p;
#endif
{ return (cr_sort_declaration)kc_do_last_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_sort_declaration_list ); }
cr_sort_declaration_list map_cr_sort_declaration_list
#ifdef KC_USE_PROTOTYPES
(cr_sort_declaration_list kc_p, cr_sort_declaration (*kc_fp)(cr_sort_declaration))
#else
(kc_p, kc_fp) cr_sort_declaration_list kc_p; cr_sort_declaration (*kc_fp)KC__P((cr_sort_declaration));
#endif
{ return (cr_sort_declaration_list)kc_do_map_phylum( (kc_voidptr_t)kc_p, (kc_voidptr_t (*)KC__P((kc_voidptr_t)))kc_fp, kc_phylum_cr_sort_declaration_list ); }
cr_sort_declaration_list filter_cr_sort_declaration_list
#ifdef KC_USE_PROTOTYPES
(cr_sort_declaration_list kc_p, boolean (*kc_fp)(cr_sort_declaration))
#else
(kc_p, kc_fp) cr_sort_declaration_list kc_p; boolean (*kc_fp)KC__P((cr_sort_declaration));
#endif
{ return (cr_sort_declaration_list)kc_do_filter_phylum( (kc_voidptr_t)kc_p, (boolean (*)KC__P((kc_voidptr_t)))kc_fp, kc_phylum_cr_sort_declaration_list ); }
void freelist_cr_sort_declaration_list
#ifdef KC_USE_PROTOTYPES
(cr_sort_declaration_list kc_p)
#else
(kc_p) cr_sort_declaration_list kc_p;
#endif
{ kc_do_freelist_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_sort_declaration_list ); }
cr_operation_replacement_list concat_cr_operation_replacement_list
#ifdef KC_USE_PROTOTYPES
(cr_operation_replacement_list kc_p1, cr_operation_replacement_list kc_p2)
#else
(kc_p1, kc_p2) cr_operation_replacement_list kc_p1, kc_p2;
#endif
{ return (cr_operation_replacement_list)kc_do_concat_phylum( (kc_voidptr_t)kc_p1, (kc_voidptr_t)kc_p2, kc_phylum_cr_operation_replacement_list ); }
cr_operation_replacement_list reverse_cr_operation_replacement_list
#ifdef KC_USE_PROTOTYPES
(cr_operation_replacement_list kc_p)
#else
(kc_p) cr_operation_replacement_list kc_p;
#endif
{ return (cr_operation_replacement_list)kc_do_reverse_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_operation_replacement_list ); }
int length_cr_operation_replacement_list
#ifdef KC_USE_PROTOTYPES
(cr_operation_replacement_list kc_p)
#else
(kc_p) cr_operation_replacement_list kc_p;
#endif
{ return kc_do_length_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_operation_replacement_list ); }
cr_operation_replacement last_cr_operation_replacement_list
#ifdef KC_USE_PROTOTYPES
(cr_operation_replacement_list kc_p)
#else
(kc_p) cr_operation_replacement_list kc_p;
#endif
{ return (cr_operation_replacement)kc_do_last_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_operation_replacement_list ); }
cr_operation_replacement_list map_cr_operation_replacement_list
#ifdef KC_USE_PROTOTYPES
(cr_operation_replacement_list kc_p, cr_operation_replacement (*kc_fp)(cr_operation_replacement))
#else
(kc_p, kc_fp) cr_operation_replacement_list kc_p; cr_operation_replacement (*kc_fp)KC__P((cr_operation_replacement));
#endif
{ return (cr_operation_replacement_list)kc_do_map_phylum( (kc_voidptr_t)kc_p, (kc_voidptr_t (*)KC__P((kc_voidptr_t)))kc_fp, kc_phylum_cr_operation_replacement_list ); }
cr_operation_replacement_list filter_cr_operation_replacement_list
#ifdef KC_USE_PROTOTYPES
(cr_operation_replacement_list kc_p, boolean (*kc_fp)(cr_operation_replacement))
#else
(kc_p, kc_fp) cr_operation_replacement_list kc_p; boolean (*kc_fp)KC__P((cr_operation_replacement));
#endif
{ return (cr_operation_replacement_list)kc_do_filter_phylum( (kc_voidptr_t)kc_p, (boolean (*)KC__P((kc_voidptr_t)))kc_fp, kc_phylum_cr_operation_replacement_list ); }
void freelist_cr_operation_replacement_list
#ifdef KC_USE_PROTOTYPES
(cr_operation_replacement_list kc_p)
#else
(kc_p) cr_operation_replacement_list kc_p;
#endif
{ kc_do_freelist_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_operation_replacement_list ); }
cr_operation_list concat_cr_operation_list
#ifdef KC_USE_PROTOTYPES
(cr_operation_list kc_p1, cr_operation_list kc_p2)
#else
(kc_p1, kc_p2) cr_operation_list kc_p1, kc_p2;
#endif
{ return (cr_operation_list)kc_do_concat_phylum( (kc_voidptr_t)kc_p1, (kc_voidptr_t)kc_p2, kc_phylum_cr_operation_list ); }
cr_operation_list reverse_cr_operation_list
#ifdef KC_USE_PROTOTYPES
(cr_operation_list kc_p)
#else
(kc_p) cr_operation_list kc_p;
#endif
{ return (cr_operation_list)kc_do_reverse_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_operation_list ); }
int length_cr_operation_list
#ifdef KC_USE_PROTOTYPES
(cr_operation_list kc_p)
#else
(kc_p) cr_operation_list kc_p;
#endif
{ return kc_do_length_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_operation_list ); }
cr_operation last_cr_operation_list
#ifdef KC_USE_PROTOTYPES
(cr_operation_list kc_p)
#else
(kc_p) cr_operation_list kc_p;
#endif
{ return (cr_operation)kc_do_last_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_operation_list ); }
cr_operation_list map_cr_operation_list
#ifdef KC_USE_PROTOTYPES
(cr_operation_list kc_p, cr_operation (*kc_fp)(cr_operation))
#else
(kc_p, kc_fp) cr_operation_list kc_p; cr_operation (*kc_fp)KC__P((cr_operation));
#endif
{ return (cr_operation_list)kc_do_map_phylum( (kc_voidptr_t)kc_p, (kc_voidptr_t (*)KC__P((kc_voidptr_t)))kc_fp, kc_phylum_cr_operation_list ); }
cr_operation_list filter_cr_operation_list
#ifdef KC_USE_PROTOTYPES
(cr_operation_list kc_p, boolean (*kc_fp)(cr_operation))
#else
(kc_p, kc_fp) cr_operation_list kc_p; boolean (*kc_fp)KC__P((cr_operation));
#endif
{ return (cr_operation_list)kc_do_filter_phylum( (kc_voidptr_t)kc_p, (boolean (*)KC__P((kc_voidptr_t)))kc_fp, kc_phylum_cr_operation_list ); }
void freelist_cr_operation_list
#ifdef KC_USE_PROTOTYPES
(cr_operation_list kc_p)
#else
(kc_p) cr_operation_list kc_p;
#endif
{ kc_do_freelist_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_operation_list ); }
cr_equation_structure_list concat_cr_equation_structure_list
#ifdef KC_USE_PROTOTYPES
(cr_equation_structure_list kc_p1, cr_equation_structure_list kc_p2)
#else
(kc_p1, kc_p2) cr_equation_structure_list kc_p1, kc_p2;
#endif
{ return (cr_equation_structure_list)kc_do_concat_phylum( (kc_voidptr_t)kc_p1, (kc_voidptr_t)kc_p2, kc_phylum_cr_equation_structure_list ); }
cr_equation_structure_list reverse_cr_equation_structure_list
#ifdef KC_USE_PROTOTYPES
(cr_equation_structure_list kc_p)
#else
(kc_p) cr_equation_structure_list kc_p;
#endif
{ return (cr_equation_structure_list)kc_do_reverse_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_equation_structure_list ); }
int length_cr_equation_structure_list
#ifdef KC_USE_PROTOTYPES
(cr_equation_structure_list kc_p)
#else
(kc_p) cr_equation_structure_list kc_p;
#endif
{ return kc_do_length_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_equation_structure_list ); }
cr_equation_structure last_cr_equation_structure_list
#ifdef KC_USE_PROTOTYPES
(cr_equation_structure_list kc_p)
#else
(kc_p) cr_equation_structure_list kc_p;
#endif
{ return (cr_equation_structure)kc_do_last_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_equation_structure_list ); }
cr_equation_structure_list map_cr_equation_structure_list
#ifdef KC_USE_PROTOTYPES
(cr_equation_structure_list kc_p, cr_equation_structure (*kc_fp)(cr_equation_structure))
#else
(kc_p, kc_fp) cr_equation_structure_list kc_p; cr_equation_structure (*kc_fp)KC__P((cr_equation_structure));
#endif
{ return (cr_equation_structure_list)kc_do_map_phylum( (kc_voidptr_t)kc_p, (kc_voidptr_t (*)KC__P((kc_voidptr_t)))kc_fp, kc_phylum_cr_equation_structure_list ); }
cr_equation_structure_list filter_cr_equation_structure_list
#ifdef KC_USE_PROTOTYPES
(cr_equation_structure_list kc_p, boolean (*kc_fp)(cr_equation_structure))
#else
(kc_p, kc_fp) cr_equation_structure_list kc_p; boolean (*kc_fp)KC__P((cr_equation_structure));
#endif
{ return (cr_equation_structure_list)kc_do_filter_phylum( (kc_voidptr_t)kc_p, (boolean (*)KC__P((kc_voidptr_t)))kc_fp, kc_phylum_cr_equation_structure_list ); }
void freelist_cr_equation_structure_list
#ifdef KC_USE_PROTOTYPES
(cr_equation_structure_list kc_p)
#else
(kc_p) cr_equation_structure_list kc_p;
#endif
{ kc_do_freelist_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_equation_structure_list ); }
cr_equation_list concat_cr_equation_list
#ifdef KC_USE_PROTOTYPES
(cr_equation_list kc_p1, cr_equation_list kc_p2)
#else
(kc_p1, kc_p2) cr_equation_list kc_p1, kc_p2;
#endif
{ return (cr_equation_list)kc_do_concat_phylum( (kc_voidptr_t)kc_p1, (kc_voidptr_t)kc_p2, kc_phylum_cr_equation_list ); }
cr_equation_list reverse_cr_equation_list
#ifdef KC_USE_PROTOTYPES
(cr_equation_list kc_p)
#else
(kc_p) cr_equation_list kc_p;
#endif
{ return (cr_equation_list)kc_do_reverse_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_equation_list ); }
int length_cr_equation_list
#ifdef KC_USE_PROTOTYPES
(cr_equation_list kc_p)
#else
(kc_p) cr_equation_list kc_p;
#endif
{ return kc_do_length_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_equation_list ); }
cr_equation last_cr_equation_list
#ifdef KC_USE_PROTOTYPES
(cr_equation_list kc_p)
#else
(kc_p) cr_equation_list kc_p;
#endif
{ return (cr_equation)kc_do_last_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_equation_list ); }
cr_equation_list map_cr_equation_list
#ifdef KC_USE_PROTOTYPES
(cr_equation_list kc_p, cr_equation (*kc_fp)(cr_equation))
#else
(kc_p, kc_fp) cr_equation_list kc_p; cr_equation (*kc_fp)KC__P((cr_equation));
#endif
{ return (cr_equation_list)kc_do_map_phylum( (kc_voidptr_t)kc_p, (kc_voidptr_t (*)KC__P((kc_voidptr_t)))kc_fp, kc_phylum_cr_equation_list ); }
cr_equation_list filter_cr_equation_list
#ifdef KC_USE_PROTOTYPES
(cr_equation_list kc_p, boolean (*kc_fp)(cr_equation))
#else
(kc_p, kc_fp) cr_equation_list kc_p; boolean (*kc_fp)KC__P((cr_equation));
#endif
{ return (cr_equation_list)kc_do_filter_phylum( (kc_voidptr_t)kc_p, (boolean (*)KC__P((kc_voidptr_t)))kc_fp, kc_phylum_cr_equation_list ); }
void freelist_cr_equation_list
#ifdef KC_USE_PROTOTYPES
(cr_equation_list kc_p)
#else
(kc_p) cr_equation_list kc_p;
#endif
{ kc_do_freelist_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_equation_list ); }
cr_premiss_list concat_cr_premiss_list
#ifdef KC_USE_PROTOTYPES
(cr_premiss_list kc_p1, cr_premiss_list kc_p2)
#else
(kc_p1, kc_p2) cr_premiss_list kc_p1, kc_p2;
#endif
{ return (cr_premiss_list)kc_do_concat_phylum( (kc_voidptr_t)kc_p1, (kc_voidptr_t)kc_p2, kc_phylum_cr_premiss_list ); }
cr_premiss_list reverse_cr_premiss_list
#ifdef KC_USE_PROTOTYPES
(cr_premiss_list kc_p)
#else
(kc_p) cr_premiss_list kc_p;
#endif
{ return (cr_premiss_list)kc_do_reverse_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_premiss_list ); }
int length_cr_premiss_list
#ifdef KC_USE_PROTOTYPES
(cr_premiss_list kc_p)
#else
(kc_p) cr_premiss_list kc_p;
#endif
{ return kc_do_length_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_premiss_list ); }
cr_equality last_cr_premiss_list
#ifdef KC_USE_PROTOTYPES
(cr_premiss_list kc_p)
#else
(kc_p) cr_premiss_list kc_p;
#endif
{ return (cr_equality)kc_do_last_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_premiss_list ); }
cr_premiss_list map_cr_premiss_list
#ifdef KC_USE_PROTOTYPES
(cr_premiss_list kc_p, cr_equality (*kc_fp)(cr_equality))
#else
(kc_p, kc_fp) cr_premiss_list kc_p; cr_equality (*kc_fp)KC__P((cr_equality));
#endif
{ return (cr_premiss_list)kc_do_map_phylum( (kc_voidptr_t)kc_p, (kc_voidptr_t (*)KC__P((kc_voidptr_t)))kc_fp, kc_phylum_cr_premiss_list ); }
cr_premiss_list filter_cr_premiss_list
#ifdef KC_USE_PROTOTYPES
(cr_premiss_list kc_p, boolean (*kc_fp)(cr_equality))
#else
(kc_p, kc_fp) cr_premiss_list kc_p; boolean (*kc_fp)KC__P((cr_equality));
#endif
{ return (cr_premiss_list)kc_do_filter_phylum( (kc_voidptr_t)kc_p, (boolean (*)KC__P((kc_voidptr_t)))kc_fp, kc_phylum_cr_premiss_list ); }
void freelist_cr_premiss_list
#ifdef KC_USE_PROTOTYPES
(cr_premiss_list kc_p)
#else
(kc_p) cr_premiss_list kc_p;
#endif
{ kc_do_freelist_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_premiss_list ); }
cr_identifier_declaration_list concat_cr_identifier_declaration_list
#ifdef KC_USE_PROTOTYPES
(cr_identifier_declaration_list kc_p1, cr_identifier_declaration_list kc_p2)
#else
(kc_p1, kc_p2) cr_identifier_declaration_list kc_p1, kc_p2;
#endif
{ return (cr_identifier_declaration_list)kc_do_concat_phylum( (kc_voidptr_t)kc_p1, (kc_voidptr_t)kc_p2, kc_phylum_cr_identifier_declaration_list ); }
cr_identifier_declaration_list reverse_cr_identifier_declaration_list
#ifdef KC_USE_PROTOTYPES
(cr_identifier_declaration_list kc_p)
#else
(kc_p) cr_identifier_declaration_list kc_p;
#endif
{ return (cr_identifier_declaration_list)kc_do_reverse_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_identifier_declaration_list ); }
int length_cr_identifier_declaration_list
#ifdef KC_USE_PROTOTYPES
(cr_identifier_declaration_list kc_p)
#else
(kc_p) cr_identifier_declaration_list kc_p;
#endif
{ return kc_do_length_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_identifier_declaration_list ); }
cr_identifier_declaration last_cr_identifier_declaration_list
#ifdef KC_USE_PROTOTYPES
(cr_identifier_declaration_list kc_p)
#else
(kc_p) cr_identifier_declaration_list kc_p;
#endif
{ return (cr_identifier_declaration)kc_do_last_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_identifier_declaration_list ); }
cr_identifier_declaration_list map_cr_identifier_declaration_list
#ifdef KC_USE_PROTOTYPES
(cr_identifier_declaration_list kc_p, cr_identifier_declaration (*kc_fp)(cr_identifier_declaration))
#else
(kc_p, kc_fp) cr_identifier_declaration_list kc_p; cr_identifier_declaration (*kc_fp)KC__P((cr_identifier_declaration));
#endif
{ return (cr_identifier_declaration_list)kc_do_map_phylum( (kc_voidptr_t)kc_p, (kc_voidptr_t (*)KC__P((kc_voidptr_t)))kc_fp, kc_phylum_cr_identifier_declaration_list ); }
cr_identifier_declaration_list filter_cr_identifier_declaration_list
#ifdef KC_USE_PROTOTYPES
(cr_identifier_declaration_list kc_p, boolean (*kc_fp)(cr_identifier_declaration))
#else
(kc_p, kc_fp) cr_identifier_declaration_list kc_p; boolean (*kc_fp)KC__P((cr_identifier_declaration));
#endif
{ return (cr_identifier_declaration_list)kc_do_filter_phylum( (kc_voidptr_t)kc_p, (boolean (*)KC__P((kc_voidptr_t)))kc_fp, kc_phylum_cr_identifier_declaration_list ); }
void freelist_cr_identifier_declaration_list
#ifdef KC_USE_PROTOTYPES
(cr_identifier_declaration_list kc_p)
#else
(kc_p) cr_identifier_declaration_list kc_p;
#endif
{ kc_do_freelist_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_identifier_declaration_list ); }
cr_value_identifier_list concat_cr_value_identifier_list
#ifdef KC_USE_PROTOTYPES
(cr_value_identifier_list kc_p1, cr_value_identifier_list kc_p2)
#else
(kc_p1, kc_p2) cr_value_identifier_list kc_p1, kc_p2;
#endif
{ return (cr_value_identifier_list)kc_do_concat_phylum( (kc_voidptr_t)kc_p1, (kc_voidptr_t)kc_p2, kc_phylum_cr_value_identifier_list ); }
cr_value_identifier_list reverse_cr_value_identifier_list
#ifdef KC_USE_PROTOTYPES
(cr_value_identifier_list kc_p)
#else
(kc_p) cr_value_identifier_list kc_p;
#endif
{ return (cr_value_identifier_list)kc_do_reverse_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_value_identifier_list ); }
int length_cr_value_identifier_list
#ifdef KC_USE_PROTOTYPES
(cr_value_identifier_list kc_p)
#else
(kc_p) cr_value_identifier_list kc_p;
#endif
{ return kc_do_length_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_value_identifier_list ); }
cr_annotated_value_identifier last_cr_value_identifier_list
#ifdef KC_USE_PROTOTYPES
(cr_value_identifier_list kc_p)
#else
(kc_p) cr_value_identifier_list kc_p;
#endif
{ return (cr_annotated_value_identifier)kc_do_last_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_value_identifier_list ); }
cr_value_identifier_list map_cr_value_identifier_list
#ifdef KC_USE_PROTOTYPES
(cr_value_identifier_list kc_p, cr_annotated_value_identifier (*kc_fp)(cr_annotated_value_identifier))
#else
(kc_p, kc_fp) cr_value_identifier_list kc_p; cr_annotated_value_identifier (*kc_fp)KC__P((cr_annotated_value_identifier));
#endif
{ return (cr_value_identifier_list)kc_do_map_phylum( (kc_voidptr_t)kc_p, (kc_voidptr_t (*)KC__P((kc_voidptr_t)))kc_fp, kc_phylum_cr_value_identifier_list ); }
cr_value_identifier_list filter_cr_value_identifier_list
#ifdef KC_USE_PROTOTYPES
(cr_value_identifier_list kc_p, boolean (*kc_fp)(cr_annotated_value_identifier))
#else
(kc_p, kc_fp) cr_value_identifier_list kc_p; boolean (*kc_fp)KC__P((cr_annotated_value_identifier));
#endif
{ return (cr_value_identifier_list)kc_do_filter_phylum( (kc_voidptr_t)kc_p, (boolean (*)KC__P((kc_voidptr_t)))kc_fp, kc_phylum_cr_value_identifier_list ); }
void freelist_cr_value_identifier_list
#ifdef KC_USE_PROTOTYPES
(cr_value_identifier_list kc_p)
#else
(kc_p) cr_value_identifier_list kc_p;
#endif
{ kc_do_freelist_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_value_identifier_list ); }
cr_gate_declaration_list concat_cr_gate_declaration_list
#ifdef KC_USE_PROTOTYPES
(cr_gate_declaration_list kc_p1, cr_gate_declaration_list kc_p2)
#else
(kc_p1, kc_p2) cr_gate_declaration_list kc_p1, kc_p2;
#endif
{ return (cr_gate_declaration_list)kc_do_concat_phylum( (kc_voidptr_t)kc_p1, (kc_voidptr_t)kc_p2, kc_phylum_cr_gate_declaration_list ); }
cr_gate_declaration_list reverse_cr_gate_declaration_list
#ifdef KC_USE_PROTOTYPES
(cr_gate_declaration_list kc_p)
#else
(kc_p) cr_gate_declaration_list kc_p;
#endif
{ return (cr_gate_declaration_list)kc_do_reverse_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_gate_declaration_list ); }
int length_cr_gate_declaration_list
#ifdef KC_USE_PROTOTYPES
(cr_gate_declaration_list kc_p)
#else
(kc_p) cr_gate_declaration_list kc_p;
#endif
{ return kc_do_length_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_gate_declaration_list ); }
cr_gate_declaration last_cr_gate_declaration_list
#ifdef KC_USE_PROTOTYPES
(cr_gate_declaration_list kc_p)
#else
(kc_p) cr_gate_declaration_list kc_p;
#endif
{ return (cr_gate_declaration)kc_do_last_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_gate_declaration_list ); }
cr_gate_declaration_list map_cr_gate_declaration_list
#ifdef KC_USE_PROTOTYPES
(cr_gate_declaration_list kc_p, cr_gate_declaration (*kc_fp)(cr_gate_declaration))
#else
(kc_p, kc_fp) cr_gate_declaration_list kc_p; cr_gate_declaration (*kc_fp)KC__P((cr_gate_declaration));
#endif
{ return (cr_gate_declaration_list)kc_do_map_phylum( (kc_voidptr_t)kc_p, (kc_voidptr_t (*)KC__P((kc_voidptr_t)))kc_fp, kc_phylum_cr_gate_declaration_list ); }
cr_gate_declaration_list filter_cr_gate_declaration_list
#ifdef KC_USE_PROTOTYPES
(cr_gate_declaration_list kc_p, boolean (*kc_fp)(cr_gate_declaration))
#else
(kc_p, kc_fp) cr_gate_declaration_list kc_p; boolean (*kc_fp)KC__P((cr_gate_declaration));
#endif
{ return (cr_gate_declaration_list)kc_do_filter_phylum( (kc_voidptr_t)kc_p, (boolean (*)KC__P((kc_voidptr_t)))kc_fp, kc_phylum_cr_gate_declaration_list ); }
void freelist_cr_gate_declaration_list
#ifdef KC_USE_PROTOTYPES
(cr_gate_declaration_list kc_p)
#else
(kc_p) cr_gate_declaration_list kc_p;
#endif
{ kc_do_freelist_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_gate_declaration_list ); }
cr_gate_identifier_list concat_cr_gate_identifier_list
#ifdef KC_USE_PROTOTYPES
(cr_gate_identifier_list kc_p1, cr_gate_identifier_list kc_p2)
#else
(kc_p1, kc_p2) cr_gate_identifier_list kc_p1, kc_p2;
#endif
{ return (cr_gate_identifier_list)kc_do_concat_phylum( (kc_voidptr_t)kc_p1, (kc_voidptr_t)kc_p2, kc_phylum_cr_gate_identifier_list ); }
cr_gate_identifier_list reverse_cr_gate_identifier_list
#ifdef KC_USE_PROTOTYPES
(cr_gate_identifier_list kc_p)
#else
(kc_p) cr_gate_identifier_list kc_p;
#endif
{ return (cr_gate_identifier_list)kc_do_reverse_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_gate_identifier_list ); }
int length_cr_gate_identifier_list
#ifdef KC_USE_PROTOTYPES
(cr_gate_identifier_list kc_p)
#else
(kc_p) cr_gate_identifier_list kc_p;
#endif
{ return kc_do_length_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_gate_identifier_list ); }
cr_gate_identifier last_cr_gate_identifier_list
#ifdef KC_USE_PROTOTYPES
(cr_gate_identifier_list kc_p)
#else
(kc_p) cr_gate_identifier_list kc_p;
#endif
{ return (cr_gate_identifier)kc_do_last_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_gate_identifier_list ); }
cr_gate_identifier_list map_cr_gate_identifier_list
#ifdef KC_USE_PROTOTYPES
(cr_gate_identifier_list kc_p, cr_gate_identifier (*kc_fp)(cr_gate_identifier))
#else
(kc_p, kc_fp) cr_gate_identifier_list kc_p; cr_gate_identifier (*kc_fp)KC__P((cr_gate_identifier));
#endif
{ return (cr_gate_identifier_list)kc_do_map_phylum( (kc_voidptr_t)kc_p, (kc_voidptr_t (*)KC__P((kc_voidptr_t)))kc_fp, kc_phylum_cr_gate_identifier_list ); }
cr_gate_identifier_list filter_cr_gate_identifier_list
#ifdef KC_USE_PROTOTYPES
(cr_gate_identifier_list kc_p, boolean (*kc_fp)(cr_gate_identifier))
#else
(kc_p, kc_fp) cr_gate_identifier_list kc_p; boolean (*kc_fp)KC__P((cr_gate_identifier));
#endif
{ return (cr_gate_identifier_list)kc_do_filter_phylum( (kc_voidptr_t)kc_p, (boolean (*)KC__P((kc_voidptr_t)))kc_fp, kc_phylum_cr_gate_identifier_list ); }
void freelist_cr_gate_identifier_list
#ifdef KC_USE_PROTOTYPES
(cr_gate_identifier_list kc_p)
#else
(kc_p) cr_gate_identifier_list kc_p;
#endif
{ kc_do_freelist_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_gate_identifier_list ); }
cr_exit_entry_list concat_cr_exit_entry_list
#ifdef KC_USE_PROTOTYPES
(cr_exit_entry_list kc_p1, cr_exit_entry_list kc_p2)
#else
(kc_p1, kc_p2) cr_exit_entry_list kc_p1, kc_p2;
#endif
{ return (cr_exit_entry_list)kc_do_concat_phylum( (kc_voidptr_t)kc_p1, (kc_voidptr_t)kc_p2, kc_phylum_cr_exit_entry_list ); }
cr_exit_entry_list reverse_cr_exit_entry_list
#ifdef KC_USE_PROTOTYPES
(cr_exit_entry_list kc_p)
#else
(kc_p) cr_exit_entry_list kc_p;
#endif
{ return (cr_exit_entry_list)kc_do_reverse_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_exit_entry_list ); }
int length_cr_exit_entry_list
#ifdef KC_USE_PROTOTYPES
(cr_exit_entry_list kc_p)
#else
(kc_p) cr_exit_entry_list kc_p;
#endif
{ return kc_do_length_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_exit_entry_list ); }
cr_exit_entry last_cr_exit_entry_list
#ifdef KC_USE_PROTOTYPES
(cr_exit_entry_list kc_p)
#else
(kc_p) cr_exit_entry_list kc_p;
#endif
{ return (cr_exit_entry)kc_do_last_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_exit_entry_list ); }
cr_exit_entry_list map_cr_exit_entry_list
#ifdef KC_USE_PROTOTYPES
(cr_exit_entry_list kc_p, cr_exit_entry (*kc_fp)(cr_exit_entry))
#else
(kc_p, kc_fp) cr_exit_entry_list kc_p; cr_exit_entry (*kc_fp)KC__P((cr_exit_entry));
#endif
{ return (cr_exit_entry_list)kc_do_map_phylum( (kc_voidptr_t)kc_p, (kc_voidptr_t (*)KC__P((kc_voidptr_t)))kc_fp, kc_phylum_cr_exit_entry_list ); }
cr_exit_entry_list filter_cr_exit_entry_list
#ifdef KC_USE_PROTOTYPES
(cr_exit_entry_list kc_p, boolean (*kc_fp)(cr_exit_entry))
#else
(kc_p, kc_fp) cr_exit_entry_list kc_p; boolean (*kc_fp)KC__P((cr_exit_entry));
#endif
{ return (cr_exit_entry_list)kc_do_filter_phylum( (kc_voidptr_t)kc_p, (boolean (*)KC__P((kc_voidptr_t)))kc_fp, kc_phylum_cr_exit_entry_list ); }
void freelist_cr_exit_entry_list
#ifdef KC_USE_PROTOTYPES
(cr_exit_entry_list kc_p)
#else
(kc_p) cr_exit_entry_list kc_p;
#endif
{ kc_do_freelist_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_exit_entry_list ); }
cr_identifier_equation_list concat_cr_identifier_equation_list
#ifdef KC_USE_PROTOTYPES
(cr_identifier_equation_list kc_p1, cr_identifier_equation_list kc_p2)
#else
(kc_p1, kc_p2) cr_identifier_equation_list kc_p1, kc_p2;
#endif
{ return (cr_identifier_equation_list)kc_do_concat_phylum( (kc_voidptr_t)kc_p1, (kc_voidptr_t)kc_p2, kc_phylum_cr_identifier_equation_list ); }
cr_identifier_equation_list reverse_cr_identifier_equation_list
#ifdef KC_USE_PROTOTYPES
(cr_identifier_equation_list kc_p)
#else
(kc_p) cr_identifier_equation_list kc_p;
#endif
{ return (cr_identifier_equation_list)kc_do_reverse_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_identifier_equation_list ); }
int length_cr_identifier_equation_list
#ifdef KC_USE_PROTOTYPES
(cr_identifier_equation_list kc_p)
#else
(kc_p) cr_identifier_equation_list kc_p;
#endif
{ return kc_do_length_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_identifier_equation_list ); }
cr_identifier_equation last_cr_identifier_equation_list
#ifdef KC_USE_PROTOTYPES
(cr_identifier_equation_list kc_p)
#else
(kc_p) cr_identifier_equation_list kc_p;
#endif
{ return (cr_identifier_equation)kc_do_last_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_identifier_equation_list ); }
cr_identifier_equation_list map_cr_identifier_equation_list
#ifdef KC_USE_PROTOTYPES
(cr_identifier_equation_list kc_p, cr_identifier_equation (*kc_fp)(cr_identifier_equation))
#else
(kc_p, kc_fp) cr_identifier_equation_list kc_p; cr_identifier_equation (*kc_fp)KC__P((cr_identifier_equation));
#endif
{ return (cr_identifier_equation_list)kc_do_map_phylum( (kc_voidptr_t)kc_p, (kc_voidptr_t (*)KC__P((kc_voidptr_t)))kc_fp, kc_phylum_cr_identifier_equation_list ); }
cr_identifier_equation_list filter_cr_identifier_equation_list
#ifdef KC_USE_PROTOTYPES
(cr_identifier_equation_list kc_p, boolean (*kc_fp)(cr_identifier_equation))
#else
(kc_p, kc_fp) cr_identifier_equation_list kc_p; boolean (*kc_fp)KC__P((cr_identifier_equation));
#endif
{ return (cr_identifier_equation_list)kc_do_filter_phylum( (kc_voidptr_t)kc_p, (boolean (*)KC__P((kc_voidptr_t)))kc_fp, kc_phylum_cr_identifier_equation_list ); }
void freelist_cr_identifier_equation_list
#ifdef KC_USE_PROTOTYPES
(cr_identifier_equation_list kc_p)
#else
(kc_p) cr_identifier_equation_list kc_p;
#endif
{ kc_do_freelist_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_identifier_equation_list ); }
cr_experiment_offer_list concat_cr_experiment_offer_list
#ifdef KC_USE_PROTOTYPES
(cr_experiment_offer_list kc_p1, cr_experiment_offer_list kc_p2)
#else
(kc_p1, kc_p2) cr_experiment_offer_list kc_p1, kc_p2;
#endif
{ return (cr_experiment_offer_list)kc_do_concat_phylum( (kc_voidptr_t)kc_p1, (kc_voidptr_t)kc_p2, kc_phylum_cr_experiment_offer_list ); }
cr_experiment_offer_list reverse_cr_experiment_offer_list
#ifdef KC_USE_PROTOTYPES
(cr_experiment_offer_list kc_p)
#else
(kc_p) cr_experiment_offer_list kc_p;
#endif
{ return (cr_experiment_offer_list)kc_do_reverse_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_experiment_offer_list ); }
int length_cr_experiment_offer_list
#ifdef KC_USE_PROTOTYPES
(cr_experiment_offer_list kc_p)
#else
(kc_p) cr_experiment_offer_list kc_p;
#endif
{ return kc_do_length_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_experiment_offer_list ); }
cr_experiment_offer last_cr_experiment_offer_list
#ifdef KC_USE_PROTOTYPES
(cr_experiment_offer_list kc_p)
#else
(kc_p) cr_experiment_offer_list kc_p;
#endif
{ return (cr_experiment_offer)kc_do_last_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_experiment_offer_list ); }
cr_experiment_offer_list map_cr_experiment_offer_list
#ifdef KC_USE_PROTOTYPES
(cr_experiment_offer_list kc_p, cr_experiment_offer (*kc_fp)(cr_experiment_offer))
#else
(kc_p, kc_fp) cr_experiment_offer_list kc_p; cr_experiment_offer (*kc_fp)KC__P((cr_experiment_offer));
#endif
{ return (cr_experiment_offer_list)kc_do_map_phylum( (kc_voidptr_t)kc_p, (kc_voidptr_t (*)KC__P((kc_voidptr_t)))kc_fp, kc_phylum_cr_experiment_offer_list ); }
cr_experiment_offer_list filter_cr_experiment_offer_list
#ifdef KC_USE_PROTOTYPES
(cr_experiment_offer_list kc_p, boolean (*kc_fp)(cr_experiment_offer))
#else
(kc_p, kc_fp) cr_experiment_offer_list kc_p; boolean (*kc_fp)KC__P((cr_experiment_offer));
#endif
{ return (cr_experiment_offer_list)kc_do_filter_phylum( (kc_voidptr_t)kc_p, (boolean (*)KC__P((kc_voidptr_t)))kc_fp, kc_phylum_cr_experiment_offer_list ); }
void freelist_cr_experiment_offer_list
#ifdef KC_USE_PROTOTYPES
(cr_experiment_offer_list kc_p)
#else
(kc_p) cr_experiment_offer_list kc_p;
#endif
{ kc_do_freelist_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_experiment_offer_list ); }
cr_value_expression_list concat_cr_value_expression_list
#ifdef KC_USE_PROTOTYPES
(cr_value_expression_list kc_p1, cr_value_expression_list kc_p2)
#else
(kc_p1, kc_p2) cr_value_expression_list kc_p1, kc_p2;
#endif
{ return (cr_value_expression_list)kc_do_concat_phylum( (kc_voidptr_t)kc_p1, (kc_voidptr_t)kc_p2, kc_phylum_cr_value_expression_list ); }
cr_value_expression_list reverse_cr_value_expression_list
#ifdef KC_USE_PROTOTYPES
(cr_value_expression_list kc_p)
#else
(kc_p) cr_value_expression_list kc_p;
#endif
{ return (cr_value_expression_list)kc_do_reverse_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_value_expression_list ); }
int length_cr_value_expression_list
#ifdef KC_USE_PROTOTYPES
(cr_value_expression_list kc_p)
#else
(kc_p) cr_value_expression_list kc_p;
#endif
{ return kc_do_length_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_value_expression_list ); }
cr_value_expression last_cr_value_expression_list
#ifdef KC_USE_PROTOTYPES
(cr_value_expression_list kc_p)
#else
(kc_p) cr_value_expression_list kc_p;
#endif
{ return (cr_value_expression)kc_do_last_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_value_expression_list ); }
cr_value_expression_list map_cr_value_expression_list
#ifdef KC_USE_PROTOTYPES
(cr_value_expression_list kc_p, cr_value_expression (*kc_fp)(cr_value_expression))
#else
(kc_p, kc_fp) cr_value_expression_list kc_p; cr_value_expression (*kc_fp)KC__P((cr_value_expression));
#endif
{ return (cr_value_expression_list)kc_do_map_phylum( (kc_voidptr_t)kc_p, (kc_voidptr_t (*)KC__P((kc_voidptr_t)))kc_fp, kc_phylum_cr_value_expression_list ); }
cr_value_expression_list filter_cr_value_expression_list
#ifdef KC_USE_PROTOTYPES
(cr_value_expression_list kc_p, boolean (*kc_fp)(cr_value_expression))
#else
(kc_p, kc_fp) cr_value_expression_list kc_p; boolean (*kc_fp)KC__P((cr_value_expression));
#endif
{ return (cr_value_expression_list)kc_do_filter_phylum( (kc_voidptr_t)kc_p, (boolean (*)KC__P((kc_voidptr_t)))kc_fp, kc_phylum_cr_value_expression_list ); }
void freelist_cr_value_expression_list
#ifdef KC_USE_PROTOTYPES
(cr_value_expression_list kc_p)
#else
(kc_p) cr_value_expression_list kc_p;
#endif
{ kc_do_freelist_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_value_expression_list ); }
cr_comment_list concat_cr_comment_list
#ifdef KC_USE_PROTOTYPES
(cr_comment_list kc_p1, cr_comment_list kc_p2)
#else
(kc_p1, kc_p2) cr_comment_list kc_p1, kc_p2;
#endif
{ return (cr_comment_list)kc_do_concat_phylum( (kc_voidptr_t)kc_p1, (kc_voidptr_t)kc_p2, kc_phylum_cr_comment_list ); }
cr_comment_list reverse_cr_comment_list
#ifdef KC_USE_PROTOTYPES
(cr_comment_list kc_p)
#else
(kc_p) cr_comment_list kc_p;
#endif
{ return (cr_comment_list)kc_do_reverse_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_comment_list ); }
int length_cr_comment_list
#ifdef KC_USE_PROTOTYPES
(cr_comment_list kc_p)
#else
(kc_p) cr_comment_list kc_p;
#endif
{ return kc_do_length_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_comment_list ); }
casestring last_cr_comment_list
#ifdef KC_USE_PROTOTYPES
(cr_comment_list kc_p)
#else
(kc_p) cr_comment_list kc_p;
#endif
{ return (casestring)kc_do_last_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_comment_list ); }
cr_comment_list map_cr_comment_list
#ifdef KC_USE_PROTOTYPES
(cr_comment_list kc_p, casestring (*kc_fp)(casestring))
#else
(kc_p, kc_fp) cr_comment_list kc_p; casestring (*kc_fp)KC__P((casestring));
#endif
{ return (cr_comment_list)kc_do_map_phylum( (kc_voidptr_t)kc_p, (kc_voidptr_t (*)KC__P((kc_voidptr_t)))kc_fp, kc_phylum_cr_comment_list ); }
cr_comment_list filter_cr_comment_list
#ifdef KC_USE_PROTOTYPES
(cr_comment_list kc_p, boolean (*kc_fp)(casestring))
#else
(kc_p, kc_fp) cr_comment_list kc_p; boolean (*kc_fp)KC__P((casestring));
#endif
{ return (cr_comment_list)kc_do_filter_phylum( (kc_voidptr_t)kc_p, (boolean (*)KC__P((kc_voidptr_t)))kc_fp, kc_phylum_cr_comment_list ); }
void freelist_cr_comment_list
#ifdef KC_USE_PROTOTYPES
(cr_comment_list kc_p)
#else
(kc_p) cr_comment_list kc_p;
#endif
{ kc_do_freelist_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_comment_list ); }
cr_annotation_list concat_cr_annotation_list
#ifdef KC_USE_PROTOTYPES
(cr_annotation_list kc_p1, cr_annotation_list kc_p2)
#else
(kc_p1, kc_p2) cr_annotation_list kc_p1, kc_p2;
#endif
{ return (cr_annotation_list)kc_do_concat_phylum( (kc_voidptr_t)kc_p1, (kc_voidptr_t)kc_p2, kc_phylum_cr_annotation_list ); }
cr_annotation_list reverse_cr_annotation_list
#ifdef KC_USE_PROTOTYPES
(cr_annotation_list kc_p)
#else
(kc_p) cr_annotation_list kc_p;
#endif
{ return (cr_annotation_list)kc_do_reverse_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_annotation_list ); }
int length_cr_annotation_list
#ifdef KC_USE_PROTOTYPES
(cr_annotation_list kc_p)
#else
(kc_p) cr_annotation_list kc_p;
#endif
{ return kc_do_length_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_annotation_list ); }
casestring last_cr_annotation_list
#ifdef KC_USE_PROTOTYPES
(cr_annotation_list kc_p)
#else
(kc_p) cr_annotation_list kc_p;
#endif
{ return (casestring)kc_do_last_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_annotation_list ); }
cr_annotation_list map_cr_annotation_list
#ifdef KC_USE_PROTOTYPES
(cr_annotation_list kc_p, casestring (*kc_fp)(casestring))
#else
(kc_p, kc_fp) cr_annotation_list kc_p; casestring (*kc_fp)KC__P((casestring));
#endif
{ return (cr_annotation_list)kc_do_map_phylum( (kc_voidptr_t)kc_p, (kc_voidptr_t (*)KC__P((kc_voidptr_t)))kc_fp, kc_phylum_cr_annotation_list ); }
cr_annotation_list filter_cr_annotation_list
#ifdef KC_USE_PROTOTYPES
(cr_annotation_list kc_p, boolean (*kc_fp)(casestring))
#else
(kc_p, kc_fp) cr_annotation_list kc_p; boolean (*kc_fp)KC__P((casestring));
#endif
{ return (cr_annotation_list)kc_do_filter_phylum( (kc_voidptr_t)kc_p, (boolean (*)KC__P((kc_voidptr_t)))kc_fp, kc_phylum_cr_annotation_list ); }
void freelist_cr_annotation_list
#ifdef KC_USE_PROTOTYPES
(cr_annotation_list kc_p)
#else
(kc_p) cr_annotation_list kc_p;
#endif
{ kc_do_freelist_phylum( (kc_voidptr_t)kc_p, kc_phylum_cr_annotation_list ); }
/*ARGSUSED*/ kc_voidptr_t kc_do_copy_phylum
#ifdef KC_USE_PROTOTYPES
(kc_voidptr_t kc_p, boolean kc_copy_attributes, kc_enum_phyla kc_phylum)
#else
(kc_p, kc_copy_attributes, kc_phylum) kc_voidptr_t kc_p; boolean kc_copy_attributes; kc_enum_phyla kc_phylum;
#endif
{	kc_voidptr_t kc_subtmp[12];
	kc_voidptr_t kc_answer;
	int kc_i;
	kc_enum_operators kc_prodsel;
	KC_OPERATOR_INFO *kc_op_info;
	int kc_st;
	kc_hashtable_t kc_a_ht;
	assertPhylum(((casestring)kc_p),"kc_p",kc_phylum);
	if ((kc_phylum == kc_phylum_int) || (kc_phylum == kc_phylum_float)) return kc_p;
	kc_prodsel = ((casestring)kc_p)->prod_sel;
	kc_op_info = &kc_OperatorInfo[(int)kc_prodsel];
	kc_st = (int)kc_op_info->uniq_stored;
	kc_a_ht = kc_hashtables[kc_st];
	if (kc_st
	   && (/* kc_storageclass_still_uniq[kc_st]
	       || */ ((kc_a_ht->in_block != 0)
		  && (*kc_a_ht->in_block)((kc_voidptr_t)kc_p, kc_a_ht->malloc_private_data)))) {
		return kc_p;
	} else if (kc_phylum == kc_phylum_casestring) {
		return (kc_voidptr_t)mkcasestring(((casestring)kc_p)->name);
	} else if (kc_phylum == kc_phylum_nocasestring) {
		return (kc_voidptr_t)mknocasestring(((nocasestring)kc_p)->name);
	}
	for (kc_i = 0; kc_i < kc_op_info->no_sons; kc_i++) {
		kc_subtmp[kc_i] = kc_do_copy_phylum((kc_voidptr_t)KC_SUBPHYLUM(kc_p, kc_op_info->suboffset[kc_i]), kc_copy_attributes, kc_op_info->subphylum[kc_i] );
	}
	switch(kc_op_info->no_sons) {
	case 0: kc_answer = (kc_voidptr_t) (*kc_op_info->create_routine)(); break;
	case 1: kc_answer = (kc_voidptr_t) (*kc_op_info->create_routine)( kc_subtmp[0] ); break;
	case 2: kc_answer = (kc_voidptr_t) (*kc_op_info->create_routine)( kc_subtmp[0], kc_subtmp[1] ); break;
	case 3: kc_answer = (kc_voidptr_t) (*kc_op_info->create_routine)( kc_subtmp[0], kc_subtmp[1], kc_subtmp[2] ); break;
	case 4: kc_answer = (kc_voidptr_t) (*kc_op_info->create_routine)( kc_subtmp[0], kc_subtmp[1], kc_subtmp[2], kc_subtmp[3] ); break;
	case 5: kc_answer = (kc_voidptr_t) (*kc_op_info->create_routine)( kc_subtmp[0], kc_subtmp[1], kc_subtmp[2], kc_subtmp[3], kc_subtmp[4] ); break;
	case 7: kc_answer = (kc_voidptr_t) (*kc_op_info->create_routine)( kc_subtmp[0], kc_subtmp[1], kc_subtmp[2], kc_subtmp[3], kc_subtmp[4], kc_subtmp[5], kc_subtmp[6] ); break;
	case 8: kc_answer = (kc_voidptr_t) (*kc_op_info->create_routine)( kc_subtmp[0], kc_subtmp[1], kc_subtmp[2], kc_subtmp[3], kc_subtmp[4], kc_subtmp[5], kc_subtmp[6], kc_subtmp[7] ); break;
	case 12: kc_answer = (kc_voidptr_t) (*kc_op_info->create_routine)( kc_subtmp[0], kc_subtmp[1], kc_subtmp[2], kc_subtmp[3], kc_subtmp[4], kc_subtmp[5], kc_subtmp[6], kc_subtmp[7], kc_subtmp[8], kc_subtmp[9], kc_subtmp[10], kc_subtmp[11] ); break;
	default: assertReason(kc_zero_constant, "unexpected number of sub-phyla");/*NOTREACHED*/
	}
	if (kc_copy_attributes && (kc_PhylumInfo[(int)kc_phylum].copy_attributes != 0)) {
		(*kc_PhylumInfo[(int)kc_phylum].copy_attributes)(kc_p, kc_answer);
	}
	return kc_answer;
}

nocasestring copy_nocasestring
#ifdef KC_USE_PROTOTYPES
(nocasestring kc_p, boolean kc_copy_attributes)
#else
(kc_p, kc_copy_attributes) nocasestring kc_p; boolean kc_copy_attributes;
#endif
{ return (nocasestring)kc_do_copy_phylum( (kc_voidptr_t)kc_p, kc_copy_attributes, kc_phylum_nocasestring);  }
casestring copy_casestring
#ifdef KC_USE_PROTOTYPES
(casestring kc_p, boolean kc_copy_attributes)
#else
(kc_p, kc_copy_attributes) casestring kc_p; boolean kc_copy_attributes;
#endif
{ return (casestring)kc_do_copy_phylum( (kc_voidptr_t)kc_p, kc_copy_attributes, kc_phylum_casestring);  }
float copy_float
#ifdef KC_USE_PROTOTYPES
(float kc_p, boolean kc_copy_attributes)
#else
(kc_p, kc_copy_attributes) float kc_p; boolean kc_copy_attributes;
#endif
{	YYSTYPE kc_y, kc_a;
	kc_y.yt_float = kc_p; /* VERY DIRTY */
	kc_a.yt_int = (int)kc_do_copy_phylum( (kc_voidptr_t)kc_y.yt_int, kc_copy_attributes, kc_phylum_float);
	return (float)kc_a.yt_float;
}
int copy_int
#ifdef KC_USE_PROTOTYPES
(int kc_p, boolean kc_copy_attributes)
#else
(kc_p, kc_copy_attributes) int kc_p; boolean kc_copy_attributes;
#endif
{ return (int)kc_do_copy_phylum( (kc_voidptr_t)kc_p, kc_copy_attributes, kc_phylum_int);  }
cr_specification copy_cr_specification
#ifdef KC_USE_PROTOTYPES
(cr_specification kc_p, boolean kc_copy_attributes)
#else
(kc_p, kc_copy_attributes) cr_specification kc_p; boolean kc_copy_attributes;
#endif
{ return (cr_specification)kc_do_copy_phylum( (kc_voidptr_t)kc_p, kc_copy_attributes, kc_phylum_cr_specification);  }
cr_specification_type copy_cr_specification_type
#ifdef KC_USE_PROTOTYPES
(cr_specification_type kc_p, boolean kc_copy_attributes)
#else
(kc_p, kc_copy_attributes) cr_specification_type kc_p; boolean kc_copy_attributes;
#endif
{ return (cr_specification_type)kc_do_copy_phylum( (kc_voidptr_t)kc_p, kc_copy_attributes, kc_phylum_cr_specification_type);  }
cr_boolean_indication copy_cr_boolean_indication
#ifdef KC_USE_PROTOTYPES
(cr_boolean_indication kc_p, boolean kc_copy_attributes)
#else
(kc_p, kc_copy_attributes) cr_boolean_indication kc_p; boolean kc_copy_attributes;
#endif
{ return (cr_boolean_indication)kc_do_copy_phylum( (kc_voidptr_t)kc_p, kc_copy_attributes, kc_phylum_cr_boolean_indication);  }
cr_definition_block copy_cr_definition_block
#ifdef KC_USE_PROTOTYPES
(cr_definition_block kc_p, boolean kc_copy_attributes)
#else
(kc_p, kc_copy_attributes) cr_definition_block kc_p; boolean kc_copy_attributes;
#endif
{ return (cr_definition_block)kc_do_copy_phylum( (kc_voidptr_t)kc_p, kc_copy_attributes, kc_phylum_cr_definition_block);  }
cr_process_definition_list copy_cr_process_definition_list
#ifdef KC_USE_PROTOTYPES
(cr_process_definition_list kc_p, boolean kc_copy_attributes)
#else
(kc_p, kc_copy_attributes) cr_process_definition_list kc_p; boolean kc_copy_attributes;
#endif
{ return (cr_process_definition_list)kc_do_copy_phylum( (kc_voidptr_t)kc_p, kc_copy_attributes, kc_phylum_cr_process_definition_list);  }
cr_process_definition copy_cr_process_definition
#ifdef KC_USE_PROTOTYPES
(cr_process_definition kc_p, boolean kc_copy_attributes)
#else
(kc_p, kc_copy_attributes) cr_process_definition kc_p; boolean kc_copy_attributes;
#endif
{ return (cr_process_definition)kc_do_copy_phylum( (kc_voidptr_t)kc_p, kc_copy_attributes, kc_phylum_cr_process_definition);  }
cr_functionality copy_cr_functionality
#ifdef KC_USE_PROTOTYPES
(cr_functionality kc_p, boolean kc_copy_attributes)
#else
(kc_p, kc_copy_attributes) cr_functionality kc_p; boolean kc_copy_attributes;
#endif
{ return (cr_functionality)kc_do_copy_phylum( (kc_voidptr_t)kc_p, kc_copy_attributes, kc_phylum_cr_functionality);  }
cr_sort_identifier_list copy_cr_sort_identifier_list
#ifdef KC_USE_PROTOTYPES
(cr_sort_identifier_list kc_p, boolean kc_copy_attributes)
#else
(kc_p, kc_copy_attributes) cr_sort_identifier_list kc_p; boolean kc_copy_attributes;
#endif
{ return (cr_sort_identifier_list)kc_do_copy_phylum( (kc_voidptr_t)kc_p, kc_copy_attributes, kc_phylum_cr_sort_identifier_list);  }
cr_data_type_definition_list copy_cr_data_type_definition_list
#ifdef KC_USE_PROTOTYPES
(cr_data_type_definition_list kc_p, boolean kc_copy_attributes)
#else
(kc_p, kc_copy_attributes) cr_data_type_definition_list kc_p; boolean kc_copy_attributes;
#endif
{ return (cr_data_type_definition_list)kc_do_copy_phylum( (kc_voidptr_t)kc_p, kc_copy_attributes, kc_phylum_cr_data_type_definition_list);  }
cr_data_type_definition copy_cr_data_type_definition
#ifdef KC_USE_PROTOTYPES
(cr_data_type_definition kc_p, boolean kc_copy_attributes)
#else
(kc_p, kc_copy_attributes) cr_data_type_definition kc_p; boolean kc_copy_attributes;
#endif
{ return (cr_data_type_definition)kc_do_copy_phylum( (kc_voidptr_t)kc_p, kc_copy_attributes, kc_phylum_cr_data_type_definition);  }
cr_completeness_indication copy_cr_completeness_indication
#ifdef KC_USE_PROTOTYPES
(cr_completeness_indication kc_p, boolean kc_copy_attributes)
#else
(kc_p, kc_copy_attributes) cr_completeness_indication kc_p; boolean kc_copy_attributes;
#endif
{ return (cr_completeness_indication)kc_do_copy_phylum( (kc_voidptr_t)kc_p, kc_copy_attributes, kc_phylum_cr_completeness_indication);  }
cr_persistency_indication copy_cr_persistency_indication
#ifdef KC_USE_PROTOTYPES
(cr_persistency_indication kc_p, boolean kc_copy_attributes)
#else
(kc_p, kc_copy_attributes) cr_persistency_indication kc_p; boolean kc_copy_attributes;
#endif
{ return (cr_persistency_indication)kc_do_copy_phylum( (kc_voidptr_t)kc_p, kc_copy_attributes, kc_phylum_cr_persistency_indication);  }
cr_p_expression copy_cr_p_expression
#ifdef KC_USE_PROTOTYPES
(cr_p_expression kc_p, boolean kc_copy_attributes)
#else
(kc_p, kc_copy_attributes) cr_p_expression kc_p; boolean kc_copy_attributes;
#endif
{ return (cr_p_expression)kc_do_copy_phylum( (kc_voidptr_t)kc_p, kc_copy_attributes, kc_phylum_cr_p_expression);  }
cr_type_identifier_list copy_cr_type_identifier_list
#ifdef KC_USE_PROTOTYPES
(cr_type_identifier_list kc_p, boolean kc_copy_attributes)
#else
(kc_p, kc_copy_attributes) cr_type_identifier_list kc_p; boolean kc_copy_attributes;
#endif
{ return (cr_type_identifier_list)kc_do_copy_phylum( (kc_voidptr_t)kc_p, kc_copy_attributes, kc_phylum_cr_type_identifier_list);  }
cr_replacement copy_cr_replacement
#ifdef KC_USE_PROTOTYPES
(cr_replacement kc_p, boolean kc_copy_attributes)
#else
(kc_p, kc_copy_attributes) cr_replacement kc_p; boolean kc_copy_attributes;
#endif
{ return (cr_replacement)kc_do_copy_phylum( (kc_voidptr_t)kc_p, kc_copy_attributes, kc_phylum_cr_replacement);  }
cr_sort_replacement_list copy_cr_sort_replacement_list
#ifdef KC_USE_PROTOTYPES
(cr_sort_replacement_list kc_p, boolean kc_copy_attributes)
#else
(kc_p, kc_copy_attributes) cr_sort_replacement_list kc_p; boolean kc_copy_attributes;
#endif
{ return (cr_sort_replacement_list)kc_do_copy_phylum( (kc_voidptr_t)kc_p, kc_copy_attributes, kc_phylum_cr_sort_replacement_list);  }
cr_sort_replacement copy_cr_sort_replacement
#ifdef KC_USE_PROTOTYPES
(cr_sort_replacement kc_p, boolean kc_copy_attributes)
#else
(kc_p, kc_copy_attributes) cr_sort_replacement kc_p; boolean kc_copy_attributes;
#endif
{ return (cr_sort_replacement)kc_do_copy_phylum( (kc_voidptr_t)kc_p, kc_copy_attributes, kc_phylum_cr_sort_replacement);  }
cr_sort_declaration_list copy_cr_sort_declaration_list
#ifdef KC_USE_PROTOTYPES
(cr_sort_declaration_list kc_p, boolean kc_copy_attributes)
#else
(kc_p, kc_copy_attributes) cr_sort_declaration_list kc_p; boolean kc_copy_attributes;
#endif
{ return (cr_sort_declaration_list)kc_do_copy_phylum( (kc_voidptr_t)kc_p, kc_copy_attributes, kc_phylum_cr_sort_declaration_list);  }
cr_sort_declaration copy_cr_sort_declaration
#ifdef KC_USE_PROTOTYPES
(cr_sort_declaration kc_p, boolean kc_copy_attributes)
#else
(kc_p, kc_copy_attributes) cr_sort_declaration kc_p; boolean kc_copy_attributes;
#endif
{ return (cr_sort_declaration)kc_do_copy_phylum( (kc_voidptr_t)kc_p, kc_copy_attributes, kc_phylum_cr_sort_declaration);  }
cr_operation_replacement_list copy_cr_operation_replacement_list
#ifdef KC_USE_PROTOTYPES
(cr_operation_replacement_list kc_p, boolean kc_copy_attributes)
#else
(kc_p, kc_copy_attributes) cr_operation_replacement_list kc_p; boolean kc_copy_attributes;
#endif
{ return (cr_operation_replacement_list)kc_do_copy_phylum( (kc_voidptr_t)kc_p, kc_copy_attributes, kc_phylum_cr_operation_replacement_list);  }
cr_operation_replacement copy_cr_operation_replacement
#ifdef KC_USE_PROTOTYPES
(cr_operation_replacement kc_p, boolean kc_copy_attributes)
#else
(kc_p, kc_copy_attributes) cr_operation_replacement kc_p; boolean kc_copy_attributes;
#endif
{ return (cr_operation_replacement)kc_do_copy_phylum( (kc_voidptr_t)kc_p, kc_copy_attributes, kc_phylum_cr_operation_replacement);  }
cr_flattened_type_definition copy_cr_flattened_type_definition
#ifdef KC_USE_PROTOTYPES
(cr_flattened_type_definition kc_p, boolean kc_copy_attributes)
#else
(kc_p, kc_copy_attributes) cr_flattened_type_definition kc_p; boolean kc_copy_attributes;
#endif
{ return (cr_flattened_type_definition)kc_do_copy_phylum( (kc_voidptr_t)kc_p, kc_copy_attributes, kc_phylum_cr_flattened_type_definition);  }
cr_operation_list copy_cr_operation_list
#ifdef KC_USE_PROTOTYPES
(cr_operation_list kc_p, boolean kc_copy_attributes)
#else
(kc_p, kc_copy_attributes) cr_operation_list kc_p; boolean kc_copy_attributes;
#endif
{ return (cr_operation_list)kc_do_copy_phylum( (kc_voidptr_t)kc_p, kc_copy_attributes, kc_phylum_cr_operation_list);  }
cr_operation copy_cr_operation
#ifdef KC_USE_PROTOTYPES
(cr_operation kc_p, boolean kc_copy_attributes)
#else
(kc_p, kc_copy_attributes) cr_operation kc_p; boolean kc_copy_attributes;
#endif
{ return (cr_operation)kc_do_copy_phylum( (kc_voidptr_t)kc_p, kc_copy_attributes, kc_phylum_cr_operation);  }
cr_prefix_infix copy_cr_prefix_infix
#ifdef KC_USE_PROTOTYPES
(cr_prefix_infix kc_p, boolean kc_copy_attributes)
#else
(kc_p, kc_copy_attributes) cr_prefix_infix kc_p; boolean kc_copy_attributes;
#endif
{ return (cr_prefix_infix)kc_do_copy_phylum( (kc_voidptr_t)kc_p, kc_copy_attributes, kc_phylum_cr_prefix_infix);  }
cr_rewrite_strategy copy_cr_rewrite_strategy
#ifdef KC_USE_PROTOTYPES
(cr_rewrite_strategy kc_p, boolean kc_copy_attributes)
#else
(kc_p, kc_copy_attributes) cr_rewrite_strategy kc_p; boolean kc_copy_attributes;
#endif
{ return (cr_rewrite_strategy)kc_do_copy_phylum( (kc_voidptr_t)kc_p, kc_copy_attributes, kc_phylum_cr_rewrite_strategy);  }
cr_operator_class copy_cr_operator_class
#ifdef KC_USE_PROTOTYPES
(cr_operator_class kc_p, boolean kc_copy_attributes)
#else
(kc_p, kc_copy_attributes) cr_operator_class kc_p; boolean kc_copy_attributes;
#endif
{ return (cr_operator_class)kc_do_copy_phylum( (kc_voidptr_t)kc_p, kc_copy_attributes, kc_phylum_cr_operator_class);  }
cr_equations_option copy_cr_equations_option
#ifdef KC_USE_PROTOTYPES
(cr_equations_option kc_p, boolean kc_copy_attributes)
#else
(kc_p, kc_copy_attributes) cr_equations_option kc_p; boolean kc_copy_attributes;
#endif
{ return (cr_equations_option)kc_do_copy_phylum( (kc_voidptr_t)kc_p, kc_copy_attributes, kc_phylum_cr_equations_option);  }
cr_equation_structure_list copy_cr_equation_structure_list
#ifdef KC_USE_PROTOTYPES
(cr_equation_structure_list kc_p, boolean kc_copy_attributes)
#else
(kc_p, kc_copy_attributes) cr_equation_structure_list kc_p; boolean kc_copy_attributes;
#endif
{ return (cr_equation_structure_list)kc_do_copy_phylum( (kc_voidptr_t)kc_p, kc_copy_attributes, kc_phylum_cr_equation_structure_list);  }
cr_equation_structure copy_cr_equation_structure
#ifdef KC_USE_PROTOTYPES
(cr_equation_structure kc_p, boolean kc_copy_attributes)
#else
(kc_p, kc_copy_attributes) cr_equation_structure kc_p; boolean kc_copy_attributes;
#endif
{ return (cr_equation_structure)kc_do_copy_phylum( (kc_voidptr_t)kc_p, kc_copy_attributes, kc_phylum_cr_equation_structure);  }
cr_equation_list copy_cr_equation_list
#ifdef KC_USE_PROTOTYPES
(cr_equation_list kc_p, boolean kc_copy_attributes)
#else
(kc_p, kc_copy_attributes) cr_equation_list kc_p; boolean kc_copy_attributes;
#endif
{ return (cr_equation_list)kc_do_copy_phylum( (kc_voidptr_t)kc_p, kc_copy_attributes, kc_phylum_cr_equation_list);  }
cr_equation copy_cr_equation
#ifdef KC_USE_PROTOTYPES
(cr_equation kc_p, boolean kc_copy_attributes)
#else
(kc_p, kc_copy_attributes) cr_equation kc_p; boolean kc_copy_attributes;
#endif
{ return (cr_equation)kc_do_copy_phylum( (kc_voidptr_t)kc_p, kc_copy_attributes, kc_phylum_cr_equation);  }
cr_premiss_list copy_cr_premiss_list
#ifdef KC_USE_PROTOTYPES
(cr_premiss_list kc_p, boolean kc_copy_attributes)
#else
(kc_p, kc_copy_attributes) cr_premiss_list kc_p; boolean kc_copy_attributes;
#endif
{ return (cr_premiss_list)kc_do_copy_phylum( (kc_voidptr_t)kc_p, kc_copy_attributes, kc_phylum_cr_premiss_list);  }
cr_equality copy_cr_equality
#ifdef KC_USE_PROTOTYPES
(cr_equality kc_p, boolean kc_copy_attributes)
#else
(kc_p, kc_copy_attributes) cr_equality kc_p; boolean kc_copy_attributes;
#endif
{ return (cr_equality)kc_do_copy_phylum( (kc_voidptr_t)kc_p, kc_copy_attributes, kc_phylum_cr_equality);  }
cr_identifier_declaration_list copy_cr_identifier_declaration_list
#ifdef KC_USE_PROTOTYPES
(cr_identifier_declaration_list kc_p, boolean kc_copy_attributes)
#else
(kc_p, kc_copy_attributes) cr_identifier_declaration_list kc_p; boolean kc_copy_attributes;
#endif
{ return (cr_identifier_declaration_list)kc_do_copy_phylum( (kc_voidptr_t)kc_p, kc_copy_attributes, kc_phylum_cr_identifier_declaration_list);  }
cr_identifier_declaration copy_cr_identifier_declaration
#ifdef KC_USE_PROTOTYPES
(cr_identifier_declaration kc_p, boolean kc_copy_attributes)
#else
(kc_p, kc_copy_attributes) cr_identifier_declaration kc_p; boolean kc_copy_attributes;
#endif
{ return (cr_identifier_declaration)kc_do_copy_phylum( (kc_voidptr_t)kc_p, kc_copy_attributes, kc_phylum_cr_identifier_declaration);  }
cr_value_identifier_list copy_cr_value_identifier_list
#ifdef KC_USE_PROTOTYPES
(cr_value_identifier_list kc_p, boolean kc_copy_attributes)
#else
(kc_p, kc_copy_attributes) cr_value_identifier_list kc_p; boolean kc_copy_attributes;
#endif
{ return (cr_value_identifier_list)kc_do_copy_phylum( (kc_voidptr_t)kc_p, kc_copy_attributes, kc_phylum_cr_value_identifier_list);  }
cr_annotated_value_identifier copy_cr_annotated_value_identifier
#ifdef KC_USE_PROTOTYPES
(cr_annotated_value_identifier kc_p, boolean kc_copy_attributes)
#else
(kc_p, kc_copy_attributes) cr_annotated_value_identifier kc_p; boolean kc_copy_attributes;
#endif
{ return (cr_annotated_value_identifier)kc_do_copy_phylum( (kc_voidptr_t)kc_p, kc_copy_attributes, kc_phylum_cr_annotated_value_identifier);  }
cr_behaviour_expression copy_cr_behaviour_expression
#ifdef KC_USE_PROTOTYPES
(cr_behaviour_expression kc_p, boolean kc_copy_attributes)
#else
(kc_p, kc_copy_attributes) cr_behaviour_expression kc_p; boolean kc_copy_attributes;
#endif
{ return (cr_behaviour_expression)kc_do_copy_phylum( (kc_voidptr_t)kc_p, kc_copy_attributes, kc_phylum_cr_behaviour_expression);  }
cr_parallel_operator copy_cr_parallel_operator
#ifdef KC_USE_PROTOTYPES
(cr_parallel_operator kc_p, boolean kc_copy_attributes)
#else
(kc_p, kc_copy_attributes) cr_parallel_operator kc_p; boolean kc_copy_attributes;
#endif
{ return (cr_parallel_operator)kc_do_copy_phylum( (kc_voidptr_t)kc_p, kc_copy_attributes, kc_phylum_cr_parallel_operator);  }
cr_gate_declaration_list copy_cr_gate_declaration_list
#ifdef KC_USE_PROTOTYPES
(cr_gate_declaration_list kc_p, boolean kc_copy_attributes)
#else
(kc_p, kc_copy_attributes) cr_gate_declaration_list kc_p; boolean kc_copy_attributes;
#endif
{ return (cr_gate_declaration_list)kc_do_copy_phylum( (kc_voidptr_t)kc_p, kc_copy_attributes, kc_phylum_cr_gate_declaration_list);  }
cr_gate_declaration copy_cr_gate_declaration
#ifdef KC_USE_PROTOTYPES
(cr_gate_declaration kc_p, boolean kc_copy_attributes)
#else
(kc_p, kc_copy_attributes) cr_gate_declaration kc_p; boolean kc_copy_attributes;
#endif
{ return (cr_gate_declaration)kc_do_copy_phylum( (kc_voidptr_t)kc_p, kc_copy_attributes, kc_phylum_cr_gate_declaration);  }
cr_gate_identifier_list copy_cr_gate_identifier_list
#ifdef KC_USE_PROTOTYPES
(cr_gate_identifier_list kc_p, boolean kc_copy_attributes)
#else
(kc_p, kc_copy_attributes) cr_gate_identifier_list kc_p; boolean kc_copy_attributes;
#endif
{ return (cr_gate_identifier_list)kc_do_copy_phylum( (kc_voidptr_t)kc_p, kc_copy_attributes, kc_phylum_cr_gate_identifier_list);  }
cr_exit_entry_list copy_cr_exit_entry_list
#ifdef KC_USE_PROTOTYPES
(cr_exit_entry_list kc_p, boolean kc_copy_attributes)
#else
(kc_p, kc_copy_attributes) cr_exit_entry_list kc_p; boolean kc_copy_attributes;
#endif
{ return (cr_exit_entry_list)kc_do_copy_phylum( (kc_voidptr_t)kc_p, kc_copy_attributes, kc_phylum_cr_exit_entry_list);  }
cr_exit_entry copy_cr_exit_entry
#ifdef KC_USE_PROTOTYPES
(cr_exit_entry kc_p, boolean kc_copy_attributes)
#else
(kc_p, kc_copy_attributes) cr_exit_entry kc_p; boolean kc_copy_attributes;
#endif
{ return (cr_exit_entry)kc_do_copy_phylum( (kc_voidptr_t)kc_p, kc_copy_attributes, kc_phylum_cr_exit_entry);  }
cr_identifier_equation_list copy_cr_identifier_equation_list
#ifdef KC_USE_PROTOTYPES
(cr_identifier_equation_list kc_p, boolean kc_copy_attributes)
#else
(kc_p, kc_copy_attributes) cr_identifier_equation_list kc_p; boolean kc_copy_attributes;
#endif
{ return (cr_identifier_equation_list)kc_do_copy_phylum( (kc_voidptr_t)kc_p, kc_copy_attributes, kc_phylum_cr_identifier_equation_list);  }
cr_identifier_equation copy_cr_identifier_equation
#ifdef KC_USE_PROTOTYPES
(cr_identifier_equation kc_p, boolean kc_copy_attributes)
#else
(kc_p, kc_copy_attributes) cr_identifier_equation kc_p; boolean kc_copy_attributes;
#endif
{ return (cr_identifier_equation)kc_do_copy_phylum( (kc_voidptr_t)kc_p, kc_copy_attributes, kc_phylum_cr_identifier_equation);  }
cr_action_denotation copy_cr_action_denotation
#ifdef KC_USE_PROTOTYPES
(cr_action_denotation kc_p, boolean kc_copy_attributes)
#else
(kc_p, kc_copy_attributes) cr_action_denotation kc_p; boolean kc_copy_attributes;
#endif
{ return (cr_action_denotation)kc_do_copy_phylum( (kc_voidptr_t)kc_p, kc_copy_attributes, kc_phylum_cr_action_denotation);  }
cr_experiment_option copy_cr_experiment_option
#ifdef KC_USE_PROTOTYPES
(cr_experiment_option kc_p, boolean kc_copy_attributes)
#else
(kc_p, kc_copy_attributes) cr_experiment_option kc_p; boolean kc_copy_attributes;
#endif
{ return (cr_experiment_option)kc_do_copy_phylum( (kc_voidptr_t)kc_p, kc_copy_attributes, kc_phylum_cr_experiment_option);  }
cr_experiment_offer_list copy_cr_experiment_offer_list
#ifdef KC_USE_PROTOTYPES
(cr_experiment_offer_list kc_p, boolean kc_copy_attributes)
#else
(kc_p, kc_copy_attributes) cr_experiment_offer_list kc_p; boolean kc_copy_attributes;
#endif
{ return (cr_experiment_offer_list)kc_do_copy_phylum( (kc_voidptr_t)kc_p, kc_copy_attributes, kc_phylum_cr_experiment_offer_list);  }
cr_experiment_offer copy_cr_experiment_offer
#ifdef KC_USE_PROTOTYPES
(cr_experiment_offer kc_p, boolean kc_copy_attributes)
#else
(kc_p, kc_copy_attributes) cr_experiment_offer kc_p; boolean kc_copy_attributes;
#endif
{ return (cr_experiment_offer)kc_do_copy_phylum( (kc_voidptr_t)kc_p, kc_copy_attributes, kc_phylum_cr_experiment_offer);  }
cr_guard_option copy_cr_guard_option
#ifdef KC_USE_PROTOTYPES
(cr_guard_option kc_p, boolean kc_copy_attributes)
#else
(kc_p, kc_copy_attributes) cr_guard_option kc_p; boolean kc_copy_attributes;
#endif
{ return (cr_guard_option)kc_do_copy_phylum( (kc_voidptr_t)kc_p, kc_copy_attributes, kc_phylum_cr_guard_option);  }
cr_value_expression_list copy_cr_value_expression_list
#ifdef KC_USE_PROTOTYPES
(cr_value_expression_list kc_p, boolean kc_copy_attributes)
#else
(kc_p, kc_copy_attributes) cr_value_expression_list kc_p; boolean kc_copy_attributes;
#endif
{ return (cr_value_expression_list)kc_do_copy_phylum( (kc_voidptr_t)kc_p, kc_copy_attributes, kc_phylum_cr_value_expression_list);  }
cr_value_expression copy_cr_value_expression
#ifdef KC_USE_PROTOTYPES
(cr_value_expression kc_p, boolean kc_copy_attributes)
#else
(kc_p, kc_copy_attributes) cr_value_expression kc_p; boolean kc_copy_attributes;
#endif
{ return (cr_value_expression)kc_do_copy_phylum( (kc_voidptr_t)kc_p, kc_copy_attributes, kc_phylum_cr_value_expression);  }
cr_specification_identifier copy_cr_specification_identifier
#ifdef KC_USE_PROTOTYPES
(cr_specification_identifier kc_p, boolean kc_copy_attributes)
#else
(kc_p, kc_copy_attributes) cr_specification_identifier kc_p; boolean kc_copy_attributes;
#endif
{ return (cr_specification_identifier)kc_do_copy_phylum( (kc_voidptr_t)kc_p, kc_copy_attributes, kc_phylum_cr_specification_identifier);  }
cr_operation_identifier copy_cr_operation_identifier
#ifdef KC_USE_PROTOTYPES
(cr_operation_identifier kc_p, boolean kc_copy_attributes)
#else
(kc_p, kc_copy_attributes) cr_operation_identifier kc_p; boolean kc_copy_attributes;
#endif
{ return (cr_operation_identifier)kc_do_copy_phylum( (kc_voidptr_t)kc_p, kc_copy_attributes, kc_phylum_cr_operation_identifier);  }
cr_type_identifier copy_cr_type_identifier
#ifdef KC_USE_PROTOTYPES
(cr_type_identifier kc_p, boolean kc_copy_attributes)
#else
(kc_p, kc_copy_attributes) cr_type_identifier kc_p; boolean kc_copy_attributes;
#endif
{ return (cr_type_identifier)kc_do_copy_phylum( (kc_voidptr_t)kc_p, kc_copy_attributes, kc_phylum_cr_type_identifier);  }
cr_sort_identifier copy_cr_sort_identifier
#ifdef KC_USE_PROTOTYPES
(cr_sort_identifier kc_p, boolean kc_copy_attributes)
#else
(kc_p, kc_copy_attributes) cr_sort_identifier kc_p; boolean kc_copy_attributes;
#endif
{ return (cr_sort_identifier)kc_do_copy_phylum( (kc_voidptr_t)kc_p, kc_copy_attributes, kc_phylum_cr_sort_identifier);  }
cr_gate_identifier copy_cr_gate_identifier
#ifdef KC_USE_PROTOTYPES
(cr_gate_identifier kc_p, boolean kc_copy_attributes)
#else
(kc_p, kc_copy_attributes) cr_gate_identifier kc_p; boolean kc_copy_attributes;
#endif
{ return (cr_gate_identifier)kc_do_copy_phylum( (kc_voidptr_t)kc_p, kc_copy_attributes, kc_phylum_cr_gate_identifier);  }
cr_value_identifier copy_cr_value_identifier
#ifdef KC_USE_PROTOTYPES
(cr_value_identifier kc_p, boolean kc_copy_attributes)
#else
(kc_p, kc_copy_attributes) cr_value_identifier kc_p; boolean kc_copy_attributes;
#endif
{ return (cr_value_identifier)kc_do_copy_phylum( (kc_voidptr_t)kc_p, kc_copy_attributes, kc_phylum_cr_value_identifier);  }
cr_process_identifier copy_cr_process_identifier
#ifdef KC_USE_PROTOTYPES
(cr_process_identifier kc_p, boolean kc_copy_attributes)
#else
(kc_p, kc_copy_attributes) cr_process_identifier kc_p; boolean kc_copy_attributes;
#endif
{ return (cr_process_identifier)kc_do_copy_phylum( (kc_voidptr_t)kc_p, kc_copy_attributes, kc_phylum_cr_process_identifier);  }
cr_identifier copy_cr_identifier
#ifdef KC_USE_PROTOTYPES
(cr_identifier kc_p, boolean kc_copy_attributes)
#else
(kc_p, kc_copy_attributes) cr_identifier kc_p; boolean kc_copy_attributes;
#endif
{ return (cr_identifier)kc_do_copy_phylum( (kc_voidptr_t)kc_p, kc_copy_attributes, kc_phylum_cr_identifier);  }
cr_extension copy_cr_extension
#ifdef KC_USE_PROTOTYPES
(cr_extension kc_p, boolean kc_copy_attributes)
#else
(kc_p, kc_copy_attributes) cr_extension kc_p; boolean kc_copy_attributes;
#endif
{ return (cr_extension)kc_do_copy_phylum( (kc_voidptr_t)kc_p, kc_copy_attributes, kc_phylum_cr_extension);  }
cr_operation_name copy_cr_operation_name
#ifdef KC_USE_PROTOTYPES
(cr_operation_name kc_p, boolean kc_copy_attributes)
#else
(kc_p, kc_copy_attributes) cr_operation_name kc_p; boolean kc_copy_attributes;
#endif
{ return (cr_operation_name)kc_do_copy_phylum( (kc_voidptr_t)kc_p, kc_copy_attributes, kc_phylum_cr_operation_name);  }
cr_sort_name copy_cr_sort_name
#ifdef KC_USE_PROTOTYPES
(cr_sort_name kc_p, boolean kc_copy_attributes)
#else
(kc_p, kc_copy_attributes) cr_sort_name kc_p; boolean kc_copy_attributes;
#endif
{ return (cr_sort_name)kc_do_copy_phylum( (kc_voidptr_t)kc_p, kc_copy_attributes, kc_phylum_cr_sort_name);  }
cr_name copy_cr_name
#ifdef KC_USE_PROTOTYPES
(cr_name kc_p, boolean kc_copy_attributes)
#else
(kc_p, kc_copy_attributes) cr_name kc_p; boolean kc_copy_attributes;
#endif
{ return (cr_name)kc_do_copy_phylum( (kc_voidptr_t)kc_p, kc_copy_attributes, kc_phylum_cr_name);  }
cr_comment_list copy_cr_comment_list
#ifdef KC_USE_PROTOTYPES
(cr_comment_list kc_p, boolean kc_copy_attributes)
#else
(kc_p, kc_copy_attributes) cr_comment_list kc_p; boolean kc_copy_attributes;
#endif
{ return (cr_comment_list)kc_do_copy_phylum( (kc_voidptr_t)kc_p, kc_copy_attributes, kc_phylum_cr_comment_list);  }
cr_annotation_list copy_cr_annotation_list
#ifdef KC_USE_PROTOTYPES
(cr_annotation_list kc_p, boolean kc_copy_attributes)
#else
(kc_p, kc_copy_attributes) cr_annotation_list kc_p; boolean kc_copy_attributes;
#endif
{ return (cr_annotation_list)kc_do_copy_phylum( (kc_voidptr_t)kc_p, kc_copy_attributes, kc_phylum_cr_annotation_list);  }
cr_LABEL copy_cr_LABEL
#ifdef KC_USE_PROTOTYPES
(cr_LABEL kc_p, boolean kc_copy_attributes)
#else
(kc_p, kc_copy_attributes) cr_LABEL kc_p; boolean kc_copy_attributes;
#endif
{ return (cr_LABEL)kc_do_copy_phylum( (kc_voidptr_t)kc_p, kc_copy_attributes, kc_phylum_cr_LABEL);  }
