/*
 File: fsc_filesym.cpp
 Date and Time: Fri Jan 30 18:55:11 2015 
*/
#include "fsc_file.h"
using namespace NS_yacco2_T_enum;// enumerate
using namespace NS_yacco2_err_symbols;// error symbols
using namespace NS_yacco2_k_symbols;// lrk 
using namespace NS_yacco2_terminals;// terminals
using namespace NS_yacco2_characters;// rc 
using namespace yacco2;// yacco2 library
using namespace NS_fsc_file;// grammar's ns
// first set terminals
// monolithic grammar --- no thread
void 
Cfsc_file::reduce_rhs_of_rule
    (yacco2::UINT Sub_rule_no,yacco2::Rule_s_reuse_entry** Recycled_rule){
   int reducing_rule = rhs_to_rules_mapping_[Sub_rule_no];
   Per_rule_s_reuse_table* rule_reuse_tbl_ptr = 
        fsm_rules_reuse_table.per_rule_s_table_[reducing_rule];
   Rule_s_reuse_entry* re(0);
   find_a_recycled_rule(rule_reuse_tbl_ptr,&re);
   (*Recycled_rule) = re;
   fnd_re: switch (Sub_rule_no){
    case rhs1_Rfsc_file_:{
       Rfsc_file* sym;
     if(re->rule_ == 0){
       sym = new Rfsc_file(parser__);
       re->rule_ = sym;
     }else{
       sym = (Rfsc_file*)re->rule_;
     }
    // no rule's constructor directive
     (*Recycled_rule)->rule_ = sym;
     sym->rule_info__.rhs_no_of_parms__ = 12;
    

     sym->op();
     return;}
    case rhs1_Rtransitive_phrase_:{
       Rtransitive_phrase* sym;
     if(re->rule_ == 0){
       sym = new Rtransitive_phrase(parser__);
       re->rule_ = sym;
     }else{
       sym = (Rtransitive_phrase*)re->rule_;
     }
    // no rule's constructor directive
     (*Recycled_rule)->rule_ = sym;
     sym->rule_info__.rhs_no_of_parms__ = 2;
    

     return;}
    case rhs1_Rtransitive_:{
       Rtransitive* sym;
     if(re->rule_ == 0){
       sym = new Rtransitive(parser__);
       re->rule_ = sym;
     }else{
       sym = (Rtransitive*)re->rule_;
     }
    // no rule's constructor directive
     (*Recycled_rule)->rule_ = sym;
     sym->rule_info__.rhs_no_of_parms__ = 1;
    

     return;}
    case rhs2_Rtransitive_:{
       Rtransitive* sym;
     if(re->rule_ == 0){
       sym = new Rtransitive(parser__);
       re->rule_ = sym;
     }else{
       sym = (Rtransitive*)re->rule_;
     }
    // no rule's constructor directive
     (*Recycled_rule)->rule_ = sym;
     sym->rule_info__.rhs_no_of_parms__ = 1;
    

     sym->sr2();
     return;}
    case rhs1_Rtransitive_value_:{
       Rtransitive_value* sym;
     if(re->rule_ == 0){
       sym = new Rtransitive_value(parser__);
       re->rule_ = sym;
     }else{
       sym = (Rtransitive_value*)re->rule_;
     }
    // no rule's constructor directive
     (*Recycled_rule)->rule_ = sym;
     sym->rule_info__.rhs_no_of_parms__ = 1;
    

     sym->sr1();
     return;}
    case rhs2_Rtransitive_value_:{
       Rtransitive_value* sym;
     if(re->rule_ == 0){
       sym = new Rtransitive_value(parser__);
       re->rule_ = sym;
     }else{
       sym = (Rtransitive_value*)re->rule_;
     }
    // no rule's constructor directive
     (*Recycled_rule)->rule_ = sym;
     sym->rule_info__.rhs_no_of_parms__ = 1;
    

     sym->sr2();
     return;}
    case rhs1_Rgrammar_name_phrase_:{
       Rgrammar_name_phrase* sym;
     if(re->rule_ == 0){
       sym = new Rgrammar_name_phrase(parser__);
       re->rule_ = sym;
     }else{
       sym = (Rgrammar_name_phrase*)re->rule_;
     }
    // no rule's constructor directive
     (*Recycled_rule)->rule_ = sym;
     sym->rule_info__.rhs_no_of_parms__ = 2;
    

     return;}
    case rhs1_Rgrammar_name_:{
       Rgrammar_name* sym;
     if(re->rule_ == 0){
       sym = new Rgrammar_name(parser__);
       re->rule_ = sym;
     }else{
       sym = (Rgrammar_name*)re->rule_;
     }
    // no rule's constructor directive
     (*Recycled_rule)->rule_ = sym;
     sym->rule_info__.rhs_no_of_parms__ = 1;
    

     return;}
    case rhs2_Rgrammar_name_:{
       Rgrammar_name* sym;
     if(re->rule_ == 0){
       sym = new Rgrammar_name(parser__);
       re->rule_ = sym;
     }else{
       sym = (Rgrammar_name*)re->rule_;
     }
    // no rule's constructor directive
     (*Recycled_rule)->rule_ = sym;
     sym->rule_info__.rhs_no_of_parms__ = 1;
    

     sym->sr2();
     return;}
    case rhs1_Rgrammar_name_value_:{
       Rgrammar_name_value* sym;
     if(re->rule_ == 0){
       sym = new Rgrammar_name_value(parser__);
       re->rule_ = sym;
     }else{
       sym = (Rgrammar_name_value*)re->rule_;
     }
    // no rule's constructor directive
     (*Recycled_rule)->rule_ = sym;
     sym->rule_info__.rhs_no_of_parms__ = 1;
    

     sym->sr1();
     return;}
    case rhs2_Rgrammar_name_value_:{
       Rgrammar_name_value* sym;
     if(re->rule_ == 0){
       sym = new Rgrammar_name_value(parser__);
       re->rule_ = sym;
     }else{
       sym = (Rgrammar_name_value*)re->rule_;
     }
    // no rule's constructor directive
     (*Recycled_rule)->rule_ = sym;
     sym->rule_info__.rhs_no_of_parms__ = 1;
    

     sym->sr2();
     return;}
    case rhs1_Rnamespace_phrase_:{
       Rnamespace_phrase* sym;
     if(re->rule_ == 0){
       sym = new Rnamespace_phrase(parser__);
       re->rule_ = sym;
     }else{
       sym = (Rnamespace_phrase*)re->rule_;
     }
    // no rule's constructor directive
     (*Recycled_rule)->rule_ = sym;
     sym->rule_info__.rhs_no_of_parms__ = 2;
    

     return;}
    case rhs1_Rnamespace_:{
       Rnamespace* sym;
     if(re->rule_ == 0){
       sym = new Rnamespace(parser__);
       re->rule_ = sym;
     }else{
       sym = (Rnamespace*)re->rule_;
     }
    // no rule's constructor directive
     (*Recycled_rule)->rule_ = sym;
     sym->rule_info__.rhs_no_of_parms__ = 1;
    

     return;}
    case rhs2_Rnamespace_:{
       Rnamespace* sym;
     if(re->rule_ == 0){
       sym = new Rnamespace(parser__);
       re->rule_ = sym;
     }else{
       sym = (Rnamespace*)re->rule_;
     }
    // no rule's constructor directive
     (*Recycled_rule)->rule_ = sym;
     sym->rule_info__.rhs_no_of_parms__ = 1;
    

     sym->sr2();
     return;}
    case rhs1_Rnamespace_value_:{
       Rnamespace_value* sym;
     if(re->rule_ == 0){
       sym = new Rnamespace_value(parser__);
       re->rule_ = sym;
     }else{
       sym = (Rnamespace_value*)re->rule_;
     }
    // no rule's constructor directive
     (*Recycled_rule)->rule_ = sym;
     sym->rule_info__.rhs_no_of_parms__ = 1;
    

     sym->sr1();
     return;}
    case rhs2_Rnamespace_value_:{
       Rnamespace_value* sym;
     if(re->rule_ == 0){
       sym = new Rnamespace_value(parser__);
       re->rule_ = sym;
     }else{
       sym = (Rnamespace_value*)re->rule_;
     }
    // no rule's constructor directive
     (*Recycled_rule)->rule_ = sym;
     sym->rule_info__.rhs_no_of_parms__ = 1;
    

     sym->sr2();
     return;}
    case rhs1_Rthreadname_phrase_:{
       Rthreadname_phrase* sym;
     if(re->rule_ == 0){
       sym = new Rthreadname_phrase(parser__);
       re->rule_ = sym;
     }else{
       sym = (Rthreadname_phrase*)re->rule_;
     }
    // no rule's constructor directive
     (*Recycled_rule)->rule_ = sym;
     sym->rule_info__.rhs_no_of_parms__ = 2;
    

     return;}
    case rhs1_Rthreadname_:{
       Rthreadname* sym;
     if(re->rule_ == 0){
       sym = new Rthreadname(parser__);
       re->rule_ = sym;
     }else{
       sym = (Rthreadname*)re->rule_;
     }
    // no rule's constructor directive
     (*Recycled_rule)->rule_ = sym;
     sym->rule_info__.rhs_no_of_parms__ = 1;
    

     return;}
    case rhs2_Rthreadname_:{
       Rthreadname* sym;
     if(re->rule_ == 0){
       sym = new Rthreadname(parser__);
       re->rule_ = sym;
     }else{
       sym = (Rthreadname*)re->rule_;
     }
    // no rule's constructor directive
     (*Recycled_rule)->rule_ = sym;
     sym->rule_info__.rhs_no_of_parms__ = 1;
    

     sym->sr2();
     return;}
    case rhs1_Rthreadname_value_:{
       Rthreadname_value* sym;
     if(re->rule_ == 0){
       sym = new Rthreadname_value(parser__);
       re->rule_ = sym;
     }else{
       sym = (Rthreadname_value*)re->rule_;
     }
    // no rule's constructor directive
     (*Recycled_rule)->rule_ = sym;
     sym->rule_info__.rhs_no_of_parms__ = 1;
    

     sym->sr1();
     return;}
    case rhs2_Rthreadname_value_:{
       Rthreadname_value* sym;
     if(re->rule_ == 0){
       sym = new Rthreadname_value(parser__);
       re->rule_ = sym;
     }else{
       sym = (Rthreadname_value*)re->rule_;
     }
    // no rule's constructor directive
     (*Recycled_rule)->rule_ = sym;
     sym->rule_info__.rhs_no_of_parms__ = 1;
    

     sym->sr2();
     return;}
    case rhs1_Rmonolithic_phrase_:{
       Rmonolithic_phrase* sym;
     if(re->rule_ == 0){
       sym = new Rmonolithic_phrase(parser__);
       re->rule_ = sym;
     }else{
       sym = (Rmonolithic_phrase*)re->rule_;
     }
    // no rule's constructor directive
     (*Recycled_rule)->rule_ = sym;
     sym->rule_info__.rhs_no_of_parms__ = 2;
    

     return;}
    case rhs1_Rmonolithic_:{
       Rmonolithic* sym;
     if(re->rule_ == 0){
       sym = new Rmonolithic(parser__);
       re->rule_ = sym;
     }else{
       sym = (Rmonolithic*)re->rule_;
     }
    // no rule's constructor directive
     (*Recycled_rule)->rule_ = sym;
     sym->rule_info__.rhs_no_of_parms__ = 1;
    

     return;}
    case rhs2_Rmonolithic_:{
       Rmonolithic* sym;
     if(re->rule_ == 0){
       sym = new Rmonolithic(parser__);
       re->rule_ = sym;
     }else{
       sym = (Rmonolithic*)re->rule_;
     }
    // no rule's constructor directive
     (*Recycled_rule)->rule_ = sym;
     sym->rule_info__.rhs_no_of_parms__ = 1;
    

     sym->sr2();
     return;}
    case rhs1_Rmonolithic_value_:{
       Rmonolithic_value* sym;
     if(re->rule_ == 0){
       sym = new Rmonolithic_value(parser__);
       re->rule_ = sym;
     }else{
       sym = (Rmonolithic_value*)re->rule_;
     }
    // no rule's constructor directive
     (*Recycled_rule)->rule_ = sym;
     sym->rule_info__.rhs_no_of_parms__ = 1;
    

     sym->sr1();
     return;}
    case rhs2_Rmonolithic_value_:{
       Rmonolithic_value* sym;
     if(re->rule_ == 0){
       sym = new Rmonolithic_value(parser__);
       re->rule_ = sym;
     }else{
       sym = (Rmonolithic_value*)re->rule_;
     }
    // no rule's constructor directive
     (*Recycled_rule)->rule_ = sym;
     sym->rule_info__.rhs_no_of_parms__ = 1;
    

     sym->sr2();
     return;}
    case rhs1_Rfilename_phrase_:{
       Rfilename_phrase* sym;
     if(re->rule_ == 0){
       sym = new Rfilename_phrase(parser__);
       re->rule_ = sym;
     }else{
       sym = (Rfilename_phrase*)re->rule_;
     }
    // no rule's constructor directive
     (*Recycled_rule)->rule_ = sym;
     sym->rule_info__.rhs_no_of_parms__ = 2;
    

     return;}
    case rhs1_Rfilename_:{
       Rfilename* sym;
     if(re->rule_ == 0){
       sym = new Rfilename(parser__);
       re->rule_ = sym;
     }else{
       sym = (Rfilename*)re->rule_;
     }
    // no rule's constructor directive
     (*Recycled_rule)->rule_ = sym;
     sym->rule_info__.rhs_no_of_parms__ = 1;
    

     return;}
    case rhs2_Rfilename_:{
       Rfilename* sym;
     if(re->rule_ == 0){
       sym = new Rfilename(parser__);
       re->rule_ = sym;
     }else{
       sym = (Rfilename*)re->rule_;
     }
    // no rule's constructor directive
     (*Recycled_rule)->rule_ = sym;
     sym->rule_info__.rhs_no_of_parms__ = 1;
    

     sym->sr2();
     return;}
    case rhs1_Rfilename_value_:{
       Rfilename_value* sym;
     if(re->rule_ == 0){
       sym = new Rfilename_value(parser__);
       re->rule_ = sym;
     }else{
       sym = (Rfilename_value*)re->rule_;
     }
    // no rule's constructor directive
     (*Recycled_rule)->rule_ = sym;
     sym->rule_info__.rhs_no_of_parms__ = 1;
    

     sym->sr1();
     return;}
    case rhs2_Rfilename_value_:{
       Rfilename_value* sym;
     if(re->rule_ == 0){
       sym = new Rfilename_value(parser__);
       re->rule_ = sym;
     }else{
       sym = (Rfilename_value*)re->rule_;
     }
    // no rule's constructor directive
     (*Recycled_rule)->rule_ = sym;
     sym->rule_info__.rhs_no_of_parms__ = 1;
    

     sym->sr2();
     return;}
    case rhs1_Rno_of_T_phrase_:{
       Rno_of_T_phrase* sym;
     if(re->rule_ == 0){
       sym = new Rno_of_T_phrase(parser__);
       re->rule_ = sym;
     }else{
       sym = (Rno_of_T_phrase*)re->rule_;
     }
    // no rule's constructor directive
     (*Recycled_rule)->rule_ = sym;
     sym->rule_info__.rhs_no_of_parms__ = 2;
    

     return;}
    case rhs1_Rno_of_T_:{
       Rno_of_T* sym;
     if(re->rule_ == 0){
       sym = new Rno_of_T(parser__);
       re->rule_ = sym;
     }else{
       sym = (Rno_of_T*)re->rule_;
     }
    // no rule's constructor directive
     (*Recycled_rule)->rule_ = sym;
     sym->rule_info__.rhs_no_of_parms__ = 1;
    

     return;}
    case rhs2_Rno_of_T_:{
       Rno_of_T* sym;
     if(re->rule_ == 0){
       sym = new Rno_of_T(parser__);
       re->rule_ = sym;
     }else{
       sym = (Rno_of_T*)re->rule_;
     }
    // no rule's constructor directive
     (*Recycled_rule)->rule_ = sym;
     sym->rule_info__.rhs_no_of_parms__ = 1;
    

     sym->sr2();
     return;}
    case rhs1_Rno_of_T_value_:{
       Rno_of_T_value* sym;
     if(re->rule_ == 0){
       sym = new Rno_of_T_value(parser__);
       re->rule_ = sym;
     }else{
       sym = (Rno_of_T_value*)re->rule_;
     }
    // no rule's constructor directive
     (*Recycled_rule)->rule_ = sym;
     sym->rule_info__.rhs_no_of_parms__ = 1;
    

     sym->sr1();
     return;}
    case rhs2_Rno_of_T_value_:{
       Rno_of_T_value* sym;
     if(re->rule_ == 0){
       sym = new Rno_of_T_value(parser__);
       re->rule_ = sym;
     }else{
       sym = (Rno_of_T_value*)re->rule_;
     }
    // no rule's constructor directive
     (*Recycled_rule)->rule_ = sym;
     sym->rule_info__.rhs_no_of_parms__ = 1;
    

     sym->sr2();
     return;}
    case rhs1_Rlist_of_native_terminals_phrase_:{
       Rlist_of_native_terminals_phrase* sym;
     if(re->rule_ == 0){
       sym = new Rlist_of_native_terminals_phrase(parser__);
       re->rule_ = sym;
     }else{
       sym = (Rlist_of_native_terminals_phrase*)re->rule_;
     }
    // no rule's constructor directive
     (*Recycled_rule)->rule_ = sym;
     sym->rule_info__.rhs_no_of_parms__ = 4;
    

     return;}
    case rhs1_Rlist_of_native_fset_terminals_:{
       Rlist_of_native_fset_terminals* sym;
     if(re->rule_ == 0){
       sym = new Rlist_of_native_fset_terminals(parser__);
       re->rule_ = sym;
     }else{
       sym = (Rlist_of_native_fset_terminals*)re->rule_;
     }
    // no rule's constructor directive
     (*Recycled_rule)->rule_ = sym;
     sym->rule_info__.rhs_no_of_parms__ = 1;
    

     return;}
    case rhs2_Rlist_of_native_fset_terminals_:{
       Rlist_of_native_fset_terminals* sym;
     if(re->rule_ == 0){
       sym = new Rlist_of_native_fset_terminals(parser__);
       re->rule_ = sym;
     }else{
       sym = (Rlist_of_native_fset_terminals*)re->rule_;
     }
    // no rule's constructor directive
     (*Recycled_rule)->rule_ = sym;
     sym->rule_info__.rhs_no_of_parms__ = 1;
    

     sym->sr2();
     return;}
    case rhs1_Rno_of_native_fset_terminals_:{
       Rno_of_native_fset_terminals* sym;
     if(re->rule_ == 0){
       sym = new Rno_of_native_fset_terminals(parser__);
       re->rule_ = sym;
     }else{
       sym = (Rno_of_native_fset_terminals*)re->rule_;
     }
    // no rule's constructor directive
     (*Recycled_rule)->rule_ = sym;
     sym->rule_info__.rhs_no_of_parms__ = 1;
    

     sym->sr1();
     return;}
    case rhs2_Rno_of_native_fset_terminals_:{
       Rno_of_native_fset_terminals* sym;
     if(re->rule_ == 0){
       sym = new Rno_of_native_fset_terminals(parser__);
       re->rule_ = sym;
     }else{
       sym = (Rno_of_native_fset_terminals*)re->rule_;
     }
    // no rule's constructor directive
     (*Recycled_rule)->rule_ = sym;
     sym->rule_info__.rhs_no_of_parms__ = 1;
    

     sym->sr2();
     return;}
    case rhs1_Rfset_terminals_epi_:{
       Rfset_terminals_epi* sym;
     if(re->rule_ == 0){
       sym = new Rfset_terminals_epi(parser__);
       re->rule_ = sym;
     }else{
       sym = (Rfset_terminals_epi*)re->rule_;
     }
    // no rule's constructor directive
     (*Recycled_rule)->rule_ = sym;
     sym->rule_info__.rhs_no_of_parms__ = 1;
    

     return;}
    case rhs2_Rfset_terminals_epi_:{
       Rfset_terminals_epi* sym;
     if(re->rule_ == 0){
       sym = new Rfset_terminals_epi(parser__);
       re->rule_ = sym;
     }else{
       sym = (Rfset_terminals_epi*)re->rule_;
     }
    // no rule's constructor directive
     (*Recycled_rule)->rule_ = sym;
     sym->rule_info__.rhs_no_of_parms__ = 0;
    

     return;}
    case rhs1_Rfset_terminals_:{
       Rfset_terminals* sym;
     if(re->rule_ == 0){
       sym = new Rfset_terminals(parser__);
       re->rule_ = sym;
     }else{
       sym = (Rfset_terminals*)re->rule_;
     }
    // no rule's constructor directive
     (*Recycled_rule)->rule_ = sym;
     sym->rule_info__.rhs_no_of_parms__ = 1;
    

     return;}
    case rhs2_Rfset_terminals_:{
       Rfset_terminals* sym;
     if(re->rule_ == 0){
       sym = new Rfset_terminals(parser__);
       re->rule_ = sym;
     }else{
       sym = (Rfset_terminals*)re->rule_;
     }
    // no rule's constructor directive
     (*Recycled_rule)->rule_ = sym;
     sym->rule_info__.rhs_no_of_parms__ = 2;
    

     return;}
    case rhs1_Ra_T_:{
       Ra_T* sym;
     if(re->rule_ == 0){
       sym = new Ra_T(parser__);
       re->rule_ = sym;
     }else{
       sym = (Ra_T*)re->rule_;
     }
    // no rule's constructor directive
     (*Recycled_rule)->rule_ = sym;
     sym->rule_info__.rhs_no_of_parms__ = 1;
    

     sym->sr1();
     return;}
    case rhs2_Ra_T_:{
       Ra_T* sym;
     if(re->rule_ == 0){
       sym = new Ra_T(parser__);
       re->rule_ = sym;
     }else{
       sym = (Ra_T*)re->rule_;
     }
    // no rule's constructor directive
     (*Recycled_rule)->rule_ = sym;
     sym->rule_info__.rhs_no_of_parms__ = 1;
    

     sym->sr2();
     return;}
    case rhs1_Rend_list_of_native_fset_terminals_:{
       Rend_list_of_native_fset_terminals* sym;
     if(re->rule_ == 0){
       sym = new Rend_list_of_native_fset_terminals(parser__);
       re->rule_ = sym;
     }else{
       sym = (Rend_list_of_native_fset_terminals*)re->rule_;
     }
    // no rule's constructor directive
     (*Recycled_rule)->rule_ = sym;
     sym->rule_info__.rhs_no_of_parms__ = 1;
    

     return;}
    case rhs2_Rend_list_of_native_fset_terminals_:{
       Rend_list_of_native_fset_terminals* sym;
     if(re->rule_ == 0){
       sym = new Rend_list_of_native_fset_terminals(parser__);
       re->rule_ = sym;
     }else{
       sym = (Rend_list_of_native_fset_terminals*)re->rule_;
     }
    // no rule's constructor directive
     (*Recycled_rule)->rule_ = sym;
     sym->rule_info__.rhs_no_of_parms__ = 1;
    

     sym->sr2();
     return;}
    case rhs1_Rlist_of_transitive_threads_phrase_:{
       Rlist_of_transitive_threads_phrase* sym;
     if(re->rule_ == 0){
       sym = new Rlist_of_transitive_threads_phrase(parser__);
       re->rule_ = sym;
     }else{
       sym = (Rlist_of_transitive_threads_phrase*)re->rule_;
     }
    // no rule's constructor directive
     (*Recycled_rule)->rule_ = sym;
     sym->rule_info__.rhs_no_of_parms__ = 4;
    

     return;}
    case rhs1_Rlist_of_transitive_threads_:{
       Rlist_of_transitive_threads* sym;
     if(re->rule_ == 0){
       sym = new Rlist_of_transitive_threads(parser__);
       re->rule_ = sym;
     }else{
       sym = (Rlist_of_transitive_threads*)re->rule_;
     }
    // no rule's constructor directive
     (*Recycled_rule)->rule_ = sym;
     sym->rule_info__.rhs_no_of_parms__ = 1;
    

     return;}
    case rhs2_Rlist_of_transitive_threads_:{
       Rlist_of_transitive_threads* sym;
     if(re->rule_ == 0){
       sym = new Rlist_of_transitive_threads(parser__);
       re->rule_ = sym;
     }else{
       sym = (Rlist_of_transitive_threads*)re->rule_;
     }
    // no rule's constructor directive
     (*Recycled_rule)->rule_ = sym;
     sym->rule_info__.rhs_no_of_parms__ = 1;
    

     sym->sr2();
     return;}
    case rhs1_Rno_of_transitive_threads_:{
       Rno_of_transitive_threads* sym;
     if(re->rule_ == 0){
       sym = new Rno_of_transitive_threads(parser__);
       re->rule_ = sym;
     }else{
       sym = (Rno_of_transitive_threads*)re->rule_;
     }
    // no rule's constructor directive
     (*Recycled_rule)->rule_ = sym;
     sym->rule_info__.rhs_no_of_parms__ = 1;
    

     sym->sr1();
     return;}
    case rhs2_Rno_of_transitive_threads_:{
       Rno_of_transitive_threads* sym;
     if(re->rule_ == 0){
       sym = new Rno_of_transitive_threads(parser__);
       re->rule_ = sym;
     }else{
       sym = (Rno_of_transitive_threads*)re->rule_;
     }
    // no rule's constructor directive
     (*Recycled_rule)->rule_ = sym;
     sym->rule_info__.rhs_no_of_parms__ = 1;
    

     sym->sr2();
     return;}
    case rhs1_Rtransitive_threads_epi_:{
       Rtransitive_threads_epi* sym;
     if(re->rule_ == 0){
       sym = new Rtransitive_threads_epi(parser__);
       re->rule_ = sym;
     }else{
       sym = (Rtransitive_threads_epi*)re->rule_;
     }
    // no rule's constructor directive
     (*Recycled_rule)->rule_ = sym;
     sym->rule_info__.rhs_no_of_parms__ = 1;
    

     return;}
    case rhs2_Rtransitive_threads_epi_:{
       Rtransitive_threads_epi* sym;
     if(re->rule_ == 0){
       sym = new Rtransitive_threads_epi(parser__);
       re->rule_ = sym;
     }else{
       sym = (Rtransitive_threads_epi*)re->rule_;
     }
    // no rule's constructor directive
     (*Recycled_rule)->rule_ = sym;
     sym->rule_info__.rhs_no_of_parms__ = 0;
    

     return;}
    case rhs1_Rtransitive_threads_:{
       Rtransitive_threads* sym;
     if(re->rule_ == 0){
       sym = new Rtransitive_threads(parser__);
       re->rule_ = sym;
     }else{
       sym = (Rtransitive_threads*)re->rule_;
     }
    // no rule's constructor directive
     (*Recycled_rule)->rule_ = sym;
     sym->rule_info__.rhs_no_of_parms__ = 1;
    

     return;}
    case rhs2_Rtransitive_threads_:{
       Rtransitive_threads* sym;
     if(re->rule_ == 0){
       sym = new Rtransitive_threads(parser__);
       re->rule_ = sym;
     }else{
       sym = (Rtransitive_threads*)re->rule_;
     }
    // no rule's constructor directive
     (*Recycled_rule)->rule_ = sym;
     sym->rule_info__.rhs_no_of_parms__ = 2;
    

     return;}
    case rhs1_Ra_th_:{
       Ra_th* sym;
     if(re->rule_ == 0){
       sym = new Ra_th(parser__);
       re->rule_ = sym;
     }else{
       sym = (Ra_th*)re->rule_;
     }
    // no rule's constructor directive
     (*Recycled_rule)->rule_ = sym;
     sym->rule_info__.rhs_no_of_parms__ = 1;
    

     sym->sr1();
     return;}
    case rhs2_Ra_th_:{
       Ra_th* sym;
     if(re->rule_ == 0){
       sym = new Ra_th(parser__);
       re->rule_ = sym;
     }else{
       sym = (Ra_th*)re->rule_;
     }
    // no rule's constructor directive
     (*Recycled_rule)->rule_ = sym;
     sym->rule_info__.rhs_no_of_parms__ = 1;
    

     sym->sr2();
     return;}
    case rhs1_Rend_list_of_transitive_threads_:{
       Rend_list_of_transitive_threads* sym;
     if(re->rule_ == 0){
       sym = new Rend_list_of_transitive_threads(parser__);
       re->rule_ = sym;
     }else{
       sym = (Rend_list_of_transitive_threads*)re->rule_;
     }
    // no rule's constructor directive
     (*Recycled_rule)->rule_ = sym;
     sym->rule_info__.rhs_no_of_parms__ = 1;
    

     return;}
    case rhs2_Rend_list_of_transitive_threads_:{
       Rend_list_of_transitive_threads* sym;
     if(re->rule_ == 0){
       sym = new Rend_list_of_transitive_threads(parser__);
       re->rule_ = sym;
     }else{
       sym = (Rend_list_of_transitive_threads*)re->rule_;
     }
    // no rule's constructor directive
     (*Recycled_rule)->rule_ = sym;
     sym->rule_info__.rhs_no_of_parms__ = 1;
    

     sym->sr2();
     return;}
    case rhs1_Rlist_of_used_threads_phrase_:{
       Rlist_of_used_threads_phrase* sym;
     if(re->rule_ == 0){
       sym = new Rlist_of_used_threads_phrase(parser__);
       re->rule_ = sym;
     }else{
       sym = (Rlist_of_used_threads_phrase*)re->rule_;
     }
    // no rule's constructor directive
     (*Recycled_rule)->rule_ = sym;
     sym->rule_info__.rhs_no_of_parms__ = 4;
    

     return;}
    case rhs1_Rlist_of_used_threads_:{
       Rlist_of_used_threads* sym;
     if(re->rule_ == 0){
       sym = new Rlist_of_used_threads(parser__);
       re->rule_ = sym;
     }else{
       sym = (Rlist_of_used_threads*)re->rule_;
     }
    // no rule's constructor directive
     (*Recycled_rule)->rule_ = sym;
     sym->rule_info__.rhs_no_of_parms__ = 1;
    

     return;}
    case rhs2_Rlist_of_used_threads_:{
       Rlist_of_used_threads* sym;
     if(re->rule_ == 0){
       sym = new Rlist_of_used_threads(parser__);
       re->rule_ = sym;
     }else{
       sym = (Rlist_of_used_threads*)re->rule_;
     }
    // no rule's constructor directive
     (*Recycled_rule)->rule_ = sym;
     sym->rule_info__.rhs_no_of_parms__ = 1;
    

     sym->sr2();
     return;}
    case rhs1_Rno_of_used_threads_:{
       Rno_of_used_threads* sym;
     if(re->rule_ == 0){
       sym = new Rno_of_used_threads(parser__);
       re->rule_ = sym;
     }else{
       sym = (Rno_of_used_threads*)re->rule_;
     }
    // no rule's constructor directive
     (*Recycled_rule)->rule_ = sym;
     sym->rule_info__.rhs_no_of_parms__ = 1;
    

     sym->sr1();
     return;}
    case rhs2_Rno_of_used_threads_:{
       Rno_of_used_threads* sym;
     if(re->rule_ == 0){
       sym = new Rno_of_used_threads(parser__);
       re->rule_ = sym;
     }else{
       sym = (Rno_of_used_threads*)re->rule_;
     }
    // no rule's constructor directive
     (*Recycled_rule)->rule_ = sym;
     sym->rule_info__.rhs_no_of_parms__ = 1;
    

     sym->sr2();
     return;}
    case rhs1_Rused_threads_epi_:{
       Rused_threads_epi* sym;
     if(re->rule_ == 0){
       sym = new Rused_threads_epi(parser__);
       re->rule_ = sym;
     }else{
       sym = (Rused_threads_epi*)re->rule_;
     }
    // no rule's constructor directive
     (*Recycled_rule)->rule_ = sym;
     sym->rule_info__.rhs_no_of_parms__ = 1;
    

     return;}
    case rhs2_Rused_threads_epi_:{
       Rused_threads_epi* sym;
     if(re->rule_ == 0){
       sym = new Rused_threads_epi(parser__);
       re->rule_ = sym;
     }else{
       sym = (Rused_threads_epi*)re->rule_;
     }
    // no rule's constructor directive
     (*Recycled_rule)->rule_ = sym;
     sym->rule_info__.rhs_no_of_parms__ = 0;
    

     return;}
    case rhs1_Rused_threads_:{
       Rused_threads* sym;
     if(re->rule_ == 0){
       sym = new Rused_threads(parser__);
       re->rule_ = sym;
     }else{
       sym = (Rused_threads*)re->rule_;
     }
    // no rule's constructor directive
     (*Recycled_rule)->rule_ = sym;
     sym->rule_info__.rhs_no_of_parms__ = 1;
    

     return;}
    case rhs2_Rused_threads_:{
       Rused_threads* sym;
     if(re->rule_ == 0){
       sym = new Rused_threads(parser__);
       re->rule_ = sym;
     }else{
       sym = (Rused_threads*)re->rule_;
     }
    // no rule's constructor directive
     (*Recycled_rule)->rule_ = sym;
     sym->rule_info__.rhs_no_of_parms__ = 2;
    

     return;}
    case rhs1_Rb_th_:{
       Rb_th* sym;
     if(re->rule_ == 0){
       sym = new Rb_th(parser__);
       re->rule_ = sym;
     }else{
       sym = (Rb_th*)re->rule_;
     }
    // no rule's constructor directive
     (*Recycled_rule)->rule_ = sym;
     sym->rule_info__.rhs_no_of_parms__ = 1;
    

     sym->sr1();
     return;}
    case rhs2_Rb_th_:{
       Rb_th* sym;
     if(re->rule_ == 0){
       sym = new Rb_th(parser__);
       re->rule_ = sym;
     }else{
       sym = (Rb_th*)re->rule_;
     }
    // no rule's constructor directive
     (*Recycled_rule)->rule_ = sym;
     sym->rule_info__.rhs_no_of_parms__ = 1;
    

     sym->sr2();
     return;}
    case rhs1_Rend_list_of_used_threads_:{
       Rend_list_of_used_threads* sym;
     if(re->rule_ == 0){
       sym = new Rend_list_of_used_threads(parser__);
       re->rule_ = sym;
     }else{
       sym = (Rend_list_of_used_threads*)re->rule_;
     }
    // no rule's constructor directive
     (*Recycled_rule)->rule_ = sym;
     sym->rule_info__.rhs_no_of_parms__ = 1;
    

     return;}
    case rhs2_Rend_list_of_used_threads_:{
       Rend_list_of_used_threads* sym;
     if(re->rule_ == 0){
       sym = new Rend_list_of_used_threads(parser__);
       re->rule_ = sym;
     }else{
       sym = (Rend_list_of_used_threads*)re->rule_;
     }
    // no rule's constructor directive
     (*Recycled_rule)->rule_ = sym;
     sym->rule_info__.rhs_no_of_parms__ = 1;
    

     sym->sr2();
     return;}
    case rhs1_Rfsm_comments_phrase_:{
       Rfsm_comments_phrase* sym;
     if(re->rule_ == 0){
       sym = new Rfsm_comments_phrase(parser__);
       re->rule_ = sym;
     }else{
       sym = (Rfsm_comments_phrase*)re->rule_;
     }
    // no rule's constructor directive
     (*Recycled_rule)->rule_ = sym;
     sym->rule_info__.rhs_no_of_parms__ = 2;
    

     return;}
    case rhs1_Rfsm_comments_:{
       Rfsm_comments* sym;
     if(re->rule_ == 0){
       sym = new Rfsm_comments(parser__);
       re->rule_ = sym;
     }else{
       sym = (Rfsm_comments*)re->rule_;
     }
    // no rule's constructor directive
     (*Recycled_rule)->rule_ = sym;
     sym->rule_info__.rhs_no_of_parms__ = 1;
    

     return;}
    case rhs1_Rfsm_comments_value_:{
       Rfsm_comments_value* sym;
     if(re->rule_ == 0){
       sym = new Rfsm_comments_value(parser__);
       re->rule_ = sym;
     }else{
       sym = (Rfsm_comments_value*)re->rule_;
     }
    // no rule's constructor directive
     (*Recycled_rule)->rule_ = sym;
     sym->rule_info__.rhs_no_of_parms__ = 1;
    

     sym->sr1();
     return;}
    default: return;
   }
}