///////////////////////////////////////////////////////////////////////////////
//
//  Microsoft Research Singularity
//
//  Copyright (c) Microsoft Corporation.  All rights reserved.
//
///////////////////////////////////////////////////////////////////////////////

//#define CHECK
#define GEN_RESOLVE_TRACE

using System;
using System.IO;
using System.Collections;
using System.Diagnostics;

//using Microsoft.Zap;
namespace SharpSAT
{
    /// <summary>
    /// Summary description for Class1.
    /// </summary>

    public class SharpSATSolver : SATCommon
    {
        public SolverStats      stats;
        internal SATHook        hook;
        internal SolverParams   parameters;

        private int             unique_id;  //the unique id seen so far for the nodes
        private IntVector       active_area;

        //private Process currentProcess          = Process.GetCurrentProcess();
        internal VarVector      variables       = new VarVector(4);
        internal ClsVector      clauses         = new ClsVector(4);
        private ObjVector       watched_clauses = new ObjVector(4);
        private IntVector       free_clauses    = new IntVector(4);

        internal IntVector      original_clauses= new IntVector(4);

        private NodeHashMap     node_hash       = new NodeHashMap();
        private FreeList        free_nodes;
        private IntVector       zero_ref_nodes  = new IntVector(4);
        private int             constant_one;

        private MyHashtable     node_to_pi_hash = new MyHashtable();
        internal IntVector      primary_inputs  = new IntVector(4);

        private ObjVector       asgn_stack      = new ObjVector(4);
        private int             dlevel          = 0;
        private Queue           implication_queue = new Queue();
        private IntVector       conflict_array  = new IntVector(4);
        private IntVector       learned_clause  = new IntVector(4);

        private IntVector       conflict_clauses= new IntVector(128);
        private IntVector       ordered_vars    = new IntVector(4);
        private int             max_score_pos   = 0;

        private IntVector       temporary_clauses= new IntVector(16);
        private ResolutionTrace rtrace          = null;

        [Microsoft.Contracts.NotDelayed]
        internal SharpSATSolver()
        {
            stats               = new SolverStats(true);
            parameters          = new SolverParams(true);
            rtrace              = new ResolutionTrace(this);
            variables           = new VarVector(4);
            asgn_stack          = new ObjVector(4);
            watched_clauses     = new ObjVector(4);
            free_nodes          = new FreeList(variables);
            //create Variable Num. 0: Constant 1
            int s               = new_node(NodeType.CONSTANT, INVALID, INVALID);
            sharp_assert (s == 0);
            asgn_stack.push_back            (new IntVector(4)); //for decision level 0
            constant_one        = s;
            primary_inputs      = new IntVector(4);

            stats.num_free_branch_vars  = 0;    //i.e. signal 0 doesn't count;
            stats.num_free_variables    = 0;
            stats.next_restart  = parameters.first_restart;
            stats.next_gc       = parameters.gc_period;
            stats.next_decay    = parameters.decay_period;

            active_area         = new IntVector(128);
            reasoning_flag  = alloc_flag();
            marked_flag     = alloc_flag();
            branchable_flag = alloc_flag();
            in_cl_flag      = alloc_flag();
            in_cl_sign_flag = alloc_flag();
            active_flag     = alloc_flag();
        }

        int canonical(int s)
        {
            bool invert = false;
            int r;
            for (r = s; variable(NODE_ID(r)).canonical != INVALID; r = variable(NODE_ID(r)).canonical)
                if (IS_NEGATED(s))
                    invert = !invert;
            if (invert)
                return NEGATE (r) ;
            else
                return r;
        }

        internal int var_value (int i)      { return variable(i).varValue; }
        internal void var_set_value (int i, short v) { variable(i).varValue = v; }
        internal int var_dlevel (int i)     { return variable(i).dlevel; }
        internal Variable variable (int i ) { return /*(Variable)*/ variables[i]; }
        internal Variable node (int sig)        { return variable(VID(sig)); }
        internal int num_variables()            { return variables.size() - 1; }
        internal int lit_value (int s)      { return var_value(VID(s)) ^ SIGN(s);}
        internal Clause clause(int idx)     { return /*(Clause)*/ clauses[idx]; }
        internal IntVector watched_by(int svar ) { return (IntVector) watched_clauses[svar]; }
        internal IntVector assignment_stack (int l) { return (IntVector) asgn_stack[l]; }
        internal ObjVector assignment_stack(){ return asgn_stack; }
        internal int num_pi()               { return primary_inputs.size(); }
        internal int pi(int n)              { return primary_inputs[n]; }
        internal bool is_pi (int n)         { return node(n).is_pi(); }
        internal bool is_gate (int n)           { return node(n).is_gate(); }
        internal int one()                  { return constant_one; }
        internal int zero()                 { return NEGATE(constant_one); }
        internal int signal_of(int vid)     { return vid + vid; }
        internal int node_to_pi(int s)      { return (int) node_to_pi_hash[NON_NEGATED(s)]; }
        internal NodeType node_type (int s) { return node(s).type; }
        internal int pi_var_value(int k)    { return variable(pi(k)).varValue; }
        internal bool is_pure_clause_based()    { return num_variables() == stats.num_cls_vars; }
        internal int d_level()              { return dlevel; }

        internal double session_cpu_time()  { return get_cpu_time() - stats.start_cpu_time; }
        internal double total_cpu_time()        { return stats.total_cpu_time; }

        internal void enable_rtrace(bool e) { rtrace.enable_trace(e); }

        #region GID_MANAGEMENT

        private int allocated_gid;

        internal int volatile_gid()         { return 0; }

        internal int alloc_gid ()
        {
            for (ushort i=1; i<= WORD_WIDTH; ++i)
                if (is_gid_allocated(i) == false)
                {
                    allocated_gid |= (ushort) (1 << (i-1));
                    return i;
                }
            fatal();
            return volatile_gid();
        }

        internal void free_gid (int gid)
        {
            sharp_assert (gid > 0 && gid <= WORD_WIDTH);
            if (is_gid_allocated(gid)==false)
            {
                fatal();
            }
            allocated_gid &= (~(1<< (gid-1)));
        }

        internal bool is_gid_allocated(int gid)
        {
            if (gid==volatile_gid())
                return true;
            sharp_assert (gid<= WORD_WIDTH && gid > 0);
            if ((allocated_gid & (1 << (gid -1))) != 0)
                return true;
            return false;
        }

        #endregion

        #region VAR_FLAG_MANAGEMENT

        private int allocated_flag = 0;

        internal int alloc_flag()
        {
            for (int i=0; i< WORD_WIDTH; ++i)
            {
                if ((allocated_flag & (1 << i)) == 0)
                {
                    allocated_flag |= (1<<i);
                    return i;
                }
            }
            fatal();
            return 0;
        }

        internal void dealloc_flag (int idx)
        {
            sharp_assert((allocated_flag &(1<<idx)) != 0);
            allocated_flag &= (~(1<<idx));
        }

        internal void free_flag(int idx)
        {
            dealloc_flag(idx);
            clear_flag_for_all(idx);
        }

        internal void set_flag_for_all (int idx)
        {
            for (int i=0; i< variables.size();  ++i)
                variable(i).set_flag(idx);
        }

        internal void clear_flag_for_all(int idx)
        {
            for (int i=0; i< variables.size(); ++i)
                variable(i).clear_flag(idx);
        }
        internal bool is_flag_set (int s, int f)
        {
            return node(s).flag(f);
        }

        private int reasoning_flag  ;
        private int marked_flag     ;
        private int branchable_flag ;
        private int in_cl_flag      ;
        private int in_cl_sign_flag ;
        private int active_flag     ;

        internal bool is_reasoning(Variable v)      { return v.flag(reasoning_flag); }
        internal void set_reasoning(Variable v)     { v.set_flag(reasoning_flag); }
        internal void clear_reasoning(Variable v)   { v.clear_flag(reasoning_flag); }

        internal bool is_active(Variable v)         { return v.flag(active_flag); }
        internal void set_active(Variable v)        { v.set_flag(active_flag); }
        internal void clear_active(Variable v)      { v.clear_flag(active_flag); }

        internal bool is_branchable(Variable v)     { return v.flag(branchable_flag); }
        internal void set_branchable(Variable v)    { v.set_flag(branchable_flag); }
        internal void clear_branchable(Variable v)  { v.clear_flag(branchable_flag); }

        internal bool is_marked(Variable v)     { return v.flag(marked_flag); }
        internal void set_marked(Variable v)    { v.set_flag(marked_flag); }
        internal void clear_marked(Variable v)  { v.clear_flag(marked_flag); }
        #endregion


        private void include_cl_in_reasoning (int cl_id)
        {
            Clause cl = clause(cl_id);
            if (cl.num_lits > 1)
            {
                int max_idx = -1, max2_idx = -1, max_dl = -1, max2_dl = -1;
                for (int i=0; i< cl.num_lits; ++i)
                {
                    int dl = var_dlevel(cl.literal(i) >> 1);
                    if (dl < 0 || (lit_value(cl.literal(i)) == 1) ) //non-0 variable, so make it the highest possible dl
                        dl = num_variables() + 1;
                    if (dl > max_dl)
                    {
                        max2_idx = max_idx;
                        max_idx = i;
                        max2_dl = max_dl;
                        max_dl = dl;
                    }
                    else if (dl > max2_dl)
                    {
                        max2_idx = i;
                        max2_dl = dl;
                    }
                }
                //the invariance: Literal 0 and 1 are watched
                int temp = cl.literal(0);
                cl.literals[0] = cl.literal(max_idx);
                cl.literals[max_idx] = temp;
                int svar = cl.literal(0);
                watched_by(svar).push_back ( cl_id + cl_id );
                if (max2_idx == 0)
                    max2_idx = max_idx;
                temp = cl.literal(1);
                cl.literals[1] = cl.literal(max2_idx);
                cl.literals[max2_idx] = temp;
                svar = cl.literal(1);
                watched_by(svar).push_back ( cl_id + cl_id + 1);
            }
        }

        void remove_cl_from_reasoning (int cl_id)
        {
            Clause cl = clause(cl_id);
            sharp_assert (cl.num_lits > 1);
            for (int k=0; k < 2; ++k)
            { //two watched
                int lit = cl.literal(k);
                IntVector watch = watched_by(lit);
                int i, sz;
                for (i=0, sz = watch.size(); i < sz; ++i)
                {
                    if (( watch[i] >> 1) == cl_id)
                    { //found it
                        watch[i] = watch.back;
                        watch.pop_back();
                        break;
                    }
                }
            }
        }

        private void incr_lits_count (int lit)
        {
            if ((lit & 1) == 1)
                ++ variable (VID(lit)).lits_count_1;
            else
                ++ variable (VID(lit)).lits_count_0;
        }

        private void decr_lits_count (int lit)
        {
            if ((lit & 1) == 1)
                -- variable (VID(lit)).lits_count_1;
            else
                -- variable (VID(lit)).lits_count_0;
        }

        private int get_free_clause_id()
        {
            int cl_id;
            if (!free_clauses.empty())
            {
                cl_id = free_clauses.back;
                free_clauses.pop_back();
                clauses[cl_id] = new Clause();
            }
            else
            {
                cl_id = clauses.size();
                clauses.push_back (new Clause());
            }
            return cl_id;
        }

        private int add_clause_to_db (int [] lits, ClType tp, ushort gflag)
        {
            sharp_assert (lits.Length > 0);
            int cl_id = get_free_clause_id();
            Clause cl = clause(cl_id);
            cl.init( tp, lits, gflag, unique_id ++);

//          Console.Write("{0} :", cl_id);
//          for (int i=0; i< lits.Length; ++i)
//              Console.Write ("{0} ", lits[i]);
//          Console.WriteLine ("");

            for (int i=0; i< cl.num_lits; ++i )
            {
                incr_lits_count (cl.literal(i));
                reference (cl.literal(i));
            }

            if (tp == ClType.ORIGINAL)
            {
                ++ stats.num_orig_clauses;
                original_clauses.push_back(cl_id);
                stats.num_orig_literals += lits.Length;
            }
            else if (tp == ClType.CONFLICT)
            {
                ++ stats.num_learned_clauses;
                conflict_clauses.push_back (cl_id);
                stats.num_learned_literals += lits.Length;
            }
            include_cl_in_reasoning (cl_id);

            return cl_id;
        }

        internal int add_new_implication (int [] reasons, int implied_lit)
        {
            if (reasons == null)
            {
                reasons = new int[dlevel];
                for (int i=0; i< reasons.Length; ++i)
                    reasons[i] = (assignment_stack(i+1)[0]^1);
            }

            for (int i =0; i< reasons.Length; ++i)
                sharp_assert (lit_value(reasons[i]) == 0);
            sharp_assert (var_value(VID(implied_lit)) == UNKNOWN);

            int cl_id = get_free_clause_id();

            Clause cl = clause(cl_id);
            int [] lits = new int [1 + reasons.Length];
            Array.Copy(reasons,lits,reasons.Length);
            lits[reasons.Length] = implied_lit;

            cl.init( ClType.TEMP, lits, 0, unique_id ++);
            temporary_clauses.push_back(cl_id);

            queue_implication(implied_lit, cl_id, ImpType.CLAUSE);
            return cl_id;
        }

        internal int merge_clause_group(int g2, int g1)
        {
            for (int i=0, sz=clauses.size(); i<sz; ++i)
            {
                if (clause(i) != null && clause(i).gid(g1))
                {
                    clause(i).clear_gid(g1);
                    clause(i).set_gid(g2);
                }
            }
            free_gid (g1);
            return g2;
        }

        internal void delete_clause_group (int g)
        {
            reset();
            bool[] remove = new bool [clauses.size()];
            for (int i=0; i< clauses.size(); ++i)
            {
                remove[i] = false;
                if (clause(i) != null)
                    remove[i] = clause(i).gid(g);
            }
            delete_clauses(remove);
            free_gid (g);
        }

//      void delete_clause(int cl_id)
//      {
//          Clause cl = clause(cl_id);
//          if (cl.num_lits> 1)
//              remove_cl_from_reasoning (cl_id);
//
//
//          for (int i=0; i< cl.num_lits; ++i)
//              -- variable(cl.literal(i)>> 1).lits_count[cl.literal(i) & 1];
//
//          ++stats.num_deleted_clauses;
//          stats.num_deleted_literals += cl.num_lits;
//          if (cl.type == ClType.ORIGINAL)
//          {
//              --stats.num_orig_clauses;
//              stats.num_orig_literals -= cl.num_lits;
//              //              for (int j=0, n = clause(cl_id).num_lits; j < n ; ++j)
//              //                  deref (clause(cl_id).literal(j));
//          }
//          else
//          {
//              sharp_assert (cl.type == ClType.CONFLICT);
//              --stats.num_learned_clauses;
//              stats.num_learned_literals -= cl.num_lits;
//          }
//          //cl.type = ClType.DELETED;
//          clauses[cl_id] = null;
//          free_clauses.push_back(cl_id);
//      }

        void clean_up()
        {
            reset();
            bool [] remove = new bool [clauses.size()];
            for (int i=0; i< clauses.size(); ++i)
            {
                Clause cl = clause(i);
                if (cl != null && cl.type == ClType.CONFLICT)
                    remove[i] = true; //to be deleted
                else
                    remove[i] = false;
            }
            delete_clauses(remove, false);
            rtrace.reset();
        }

        //convert all variables to primary inputs
        internal void convert_vars_to_pi ()
        {
            for (int i=0; i< variables.size(); ++i)
            {
                if (variable(i).type == NodeType.VARIABLE)
                {
                    int id = num_pi();
                    int s = i + i;
                    node(s).type = NodeType.PI;
                    primary_inputs.push_back(s);
                    node_to_pi_hash[s] = id;
                }
            }
        }

        void delete_clauses(bool [] removes)
        {
            delete_clauses(removes, true);
//          Console.Write ("Remove : ");
//          for (int i=0; i< removes.Length; ++i)
//              if (removes[i])
//                  Console.Write("{0} ", i);
//          Console.WriteLine("");
        }

        void delete_clauses(bool[] removes, bool delete_original)
        {
            for (int i=1; i< variables.size(); ++i)
            {
                //Variable var = variable(i);
                for (int k=0; k< 2; ++k)
                {
                    IntVector w = watched_by(i + i + k);
                    for (int j=0; j< w.size(); ++j)
                        if ( removes[(w[j] >> 1)])
                        {
                            w[j] = w.back;
                            w.pop_back();
                            --j;
                        }
                }
            }

            for (int i=0; i< temporary_clauses.size(); ++i)
            {
                int cl_id = temporary_clauses[i];
                bool can_delete = true;
                foreach (int lit in clause(cl_id).literals)
                {
                    if (variable(VID(lit)).antecedent.type == ImpType.CLAUSE &&
                        variable(VID(lit)).antecedent.index == cl_id)
                    {
                        can_delete = false;
                        break;
                    }
                }
                if (can_delete)
                {
                    clauses[cl_id] = null;
                    temporary_clauses[i] = temporary_clauses.back;
                    temporary_clauses.pop_back();
                    --i;
                }
            }

            for (int i=0; i< removes.Length; ++i)
            {
                Clause cl = clause(i);
                if (cl == null || removes[i] == false)
                    continue;

                ++ stats.num_deleted_clauses;
                stats.num_deleted_literals += cl.num_lits;

                for (int j=0; j< cl.num_lits; ++j)
                {
                    decr_lits_count(cl.literal(j));
                    deref ( cl.literal(j));
                }

                if (cl.type == ClType.ORIGINAL)
                {
                    --stats.num_orig_clauses;
                    stats.num_orig_literals -= cl.num_lits;
                }
                else if  (cl.type == ClType.CONFLICT)
                {
                    --stats.num_learned_clauses;
                    stats.num_learned_literals -= cl.num_lits;
                }
                //cl.type = ClType.DELETED;
                clauses[i] = null;
                free_clauses.push_back(i);
            }

            IntVector temp = new IntVector(128);
            for (int i=0; i< conflict_clauses.size(); ++i)
            {
                int cl_id = conflict_clauses[i];
                if (clause(cl_id) != null)
                {
                    sharp_assert (clause(cl_id).type == ClType.CONFLICT);
                    temp.push_back (cl_id);
                }
            }
            conflict_clauses = temp;

            if (delete_original)
            {
                stats.active_area_changed = true;
                IntVector temp1 = new IntVector(16);
                for (int i=0; i< original_clauses.size(); ++i)
                {
                    int cl_id = original_clauses[i];
                    if (!removes[cl_id])
                        temp1.push_back(cl_id);
                }
                original_clauses = temp1;
            }
        }


        internal int constraint (int sig)
        {
            if (sig == one())   //don't constraint constants
                return 0;
            else if (sig == zero())
            {
                stats.constraint_zero ++;
                return -1;
            }
            int gid = alloc_gid();
            int[] cls = new int[1];
            cls[0] = sig;
            add_clause(cls, gid, false);
            return gid;
        }

        internal void release_constraint (int gid)
        {
            if (gid <= 0)
            {
                if (gid < 0)
                    stats.constraint_zero --;
                return;
            }
            sharp_assert (is_gid_allocated(gid));
            int orig = stats.num_orig_clauses;
            delete_clause_group (gid);
            sharp_assert (orig == stats.num_orig_clauses + 1);
        }

        int find_max_dl(int cl_id) { return find_max_dl (clause(cl_id)); }

        int find_max_dl (Clause cl)
        {
            int max_dl = 0;

            for (int i=0; i< cl.num_lits; ++i)
            {
                int lit = cl.literal(i);
                if (variable(lit>>1).dlevel > max_dl)
                    max_dl = variable(lit>>1).dlevel;
            }
            return max_dl;
        }

        int find_unit_lit(int cl_id) { return find_unit_lit (clause(cl_id)); }
        int find_unit_lit (Clause cl)
        {
            if (cl == null)
                throw new Exception ("Null Clause");
            if (!is_unit(cl))
                return 0;
            int v1 = var_value(cl.literal(0)>>1);
            if (v1 == UNKNOWN)
                return cl.literal(0);
            else
                return cl.literal(1);
        }

        bool is_conflicting (int cl_id) { return is_conflicting (clause(cl_id)); }

        bool is_conflicting(Clause cl)
        {
            if (lit_value(cl.literal(0)) == 0 &&
                ( cl.num_lits == 1 || lit_value(cl.literal(1)) == 0) )
                return true;
            return false;
        }

        bool is_satisfied (int cl_id )  { return is_satisfied (clause(cl_id)); }

        bool is_satisfied(Clause cl)
        {
            for (int i=0; i< cl.num_lits; ++i)
                if (lit_value(cl.literal(i)) == 1)
                    return true;
            return false;
        }

        bool is_unit (int cl_id) { return is_unit(clause(cl_id)); }

        bool is_unit(Clause cl)
        {
            if (cl.num_lits == 1)
            {
                if (var_value(cl.literal(0)>>1) == UNKNOWN)
                    return true;
                else
                    return false;
            }
            else
            {
                int v1 = var_value(cl.literal(0)>>1);
                int l1 = lit_value(cl.literal(0));
                int v2 = var_value(cl.literal(1)>>1);
                int l2 = lit_value(cl.literal(1));
                if ((v1 == UNKNOWN && l2 == 0) ||
                    (v2 == UNKNOWN && l1 == 0))
                    return true;
                else
                    return false;
            }
        }

        int find_free_node_index(int i1, int i2)
        {
            //find a free node index that is larger than the index of i1 and i2
            int at_least;
            if (i1 == INVALID || i2 == INVALID)
            {
                sharp_assert (i1 == INVALID && i2 == INVALID);
                at_least = -1;
            }
            else
                at_least = (i1>i2)? (i1>> 1): (i2>> 1);

            int idx = free_nodes.find_greater_than (at_least);
            int vid;
            if (idx < 0)
            {
                //can't find it, so enlarge the node array
                variables.push_back(new Variable());
                watched_clauses.push_back (new IntVector(4));
                watched_clauses.push_back (new IntVector(4));
                vid = variables.size() - 1;
            }
            else
                vid = idx;
            sharp_assert (vid > at_least);
            return vid;
        }

        internal int add_variable()
        {
            ++ stats.num_cls_vars;
            int sig = new_node (NodeType.VARIABLE, INVALID, INVALID);
            return VID(sig);
        }

        internal void set_num_variables(int k)
        {
            while ( num_variables() < k)
                add_variable();
        }

        void sort_var_score ()
        {
            int nvar = ordered_vars.size();
            int [] scores = new int [nvar];
            int [] ordered = new int [nvar];
            for (int i=0; i< ordered_vars.size(); ++i)
            {
                scores[i] = variable(ordered_vars[i]).score();
                ordered[i] = ordered_vars[i];
            }

            Array.Sort(scores, ordered);
            for (int i=0; i< nvar; ++i)  //reverse it
                ordered_vars[i] = ordered[nvar - i - 1];

            for (int i=0; i< nvar; ++i)
            {
                int vid = ordered_vars[i];
                variable(vid).ordered_pos = i;
            }
            max_score_pos = 0;
            for (int i=1; i< ordered_vars.size(); ++i)
                sharp_assert (variable(ordered_vars[i]).score() <= variable(ordered_vars[i-1]).score());
        }

        void incr_score (int svar)
        {
            if (SIGN(svar) == 0)
                ++ variable(VID(svar)).score_0;
            else
                ++ variable(VID(svar)).score_1;
        }

        void incr_var_score( int svar)
        {
            int vid = VID(svar);
            //int sign = SIGN(svar);
            int old_score = variable(vid).score();
            incr_score (svar);
            int new_score = variable(vid).score();
            if (old_score == new_score)
                return;

            int pos = variable(vid).ordered_pos;
            int orig_pos = pos;
            sharp_assert (ordered_vars[pos] == vid);
            int bubble_step = 0x400;
            for (pos = orig_pos - bubble_step; pos >= 0; pos -= bubble_step)
                if (variable(ordered_vars[pos]).score() >= new_score)
                    break;
            pos += bubble_step;
            for ( bubble_step = (bubble_step >> 1); bubble_step > 0; bubble_step = (bubble_step >> 1))
            {
                if ( pos - bubble_step >= 0)
                {
                    if (variable(ordered_vars[pos - bubble_step]).score() < new_score)
                        pos -= bubble_step;
                }
            }
            //now found the position, do a swap
            ordered_vars[orig_pos] = ordered_vars[pos];
            variable(ordered_vars[orig_pos]).ordered_pos = orig_pos;

            ordered_vars[pos] = vid;
            variable(ordered_vars[pos]).ordered_pos = pos;
#if CHECK
            for (int i=0; i< ordered_vars.size(); ++i)
            {
                sharp_assert (i==0 || variable(ordered_vars[i]).score() <= variable(ordered_vars[i - 1]).score());
                sharp_assert (variable(ordered_vars[i]).ordered_pos == i);
            }
#endif
        }

        int new_node(NodeType tp, int i1, int i2)
        {
            int vid = find_free_node_index(i1, i2);
            Variable n = variable(vid);

            n.clear_all_flag();
            n.clear_all_gid();

            clear_marked(n);
            n.set_flag(branchable_flag);
            n.clear_flag(in_cl_flag);
            n.clear_flag(in_cl_sign_flag);
            n.clear_flag(reasoning_flag);

            n.type          = tp;
            n.left          = i1;
            n.right         = i2;
            n.canonical     = INVALID;
            n.ref_count     = 0;
            n.lits_count_0  = 0;
            n.lits_count_1  = 0;
            n.uid           = unique_id ++;

            n.score_0       = 0;
            n.score_1       = 0;
            n.asgn_pos      = -1;

            n.varValue      = UNKNOWN;
            n.antecedent    = -1;
            n.dlevel        = -1;
            n.outputs.clear();

            ++ stats.num_free_variables;
            ++ stats.num_free_branch_vars;

            if (tp == NodeType.AND || tp == NodeType.XOR)
            {
                set_reasoning(n);
                make_node_consistent(vid + vid);
                if (tp == NodeType.AND)
                {
                    n.score_0 += 1;
                    n.score_1 += 2;
                    ++node(i1).score_0;
                    ++node(i1).score_1;
                    ++node(i2).score_0;
                    ++node(i2).score_1;
                }
                else
                {
                    sharp_assert (tp == NodeType.XOR);
                    n.score_0 += 2;
                    n.score_1 += 2;
                    node(i1).score_0 += 2;
                    node(i1).score_1 += 2;
                    node(i2).score_0 += 2;
                    node(i2).score_1 += 2;
                }
            }
            return vid + vid;
        }

        int [] remove_dup_literals(int [] orig_lits)
        {
            bool redundant = false;
            IntVector literals = new IntVector(4);
            for (int i=0; i< orig_lits.Length; ++i)
            {
                int l = orig_lits[i];
                if (l == 0) //i.e. constant 1
                {
                    redundant = true;
                    break;
                }
                else if ( l == 1) //i.e. constant 0
                    continue;

                Variable var = variable(l >>1);
                if (var.flag(in_cl_flag) == false)   //never occurred
                {
                    var.set_flag(in_cl_flag);
                    if (IS_NEGATED(l))
                        var.set_flag(in_cl_sign_flag);
                    else
                        var.clear_flag(in_cl_sign_flag);
                    literals.push_back(l);
                }
                else if (var.flag(in_cl_sign_flag) == IS_NEGATED(l)) //same phase
                    continue;
                else
                    redundant = true;
            }
            //reset back
            for (int i=0; i< orig_lits.Length; ++i)
            {
                variable(VID(orig_lits[i])).clear_flag(in_cl_flag);
                variable(VID(orig_lits[i])).clear_flag(in_cl_sign_flag);
            }
            if (redundant)
                return null;
            return literals.ToArray();
        }

        int add_clause_do_implication ( int [] lits, ClType tp, ushort gflag)
        {
            int cl_id = add_clause_to_db( lits, tp, gflag);

            if (stats.been_reset == false) // may cause implication
            {
                Clause cl = clause(cl_id);
                if (is_conflicting(cl))
                {
                    int dl = find_max_dl(cl);
                    backtrack(dl-1);
                }
                if (dlevel >= 0)
                {
                    int unit = find_unit_lit(cl);
                    if (unit != 0)
                    {
                        int l = find_max_dl(cl);
                        if (l < dlevel)
                            backtrack(l);
                        queue_implication(unit, cl_id, ImpType.CLAUSE);
                    }
                }
                else
                    stats.outcome = SATStatus.UNSATISFIABLE;
            }
            return cl_id;
        }

        int add_clause_with_gflag ( int[] orig_lits, ClType tp, ushort gflag, bool do_check )
        {
            sharp_assert (conflict_array.empty());

            int[] lits;
            if (do_check)
                lits = remove_dup_literals(orig_lits);
            else
                lits = orig_lits;

            if (lits == null)
                throw new Exception (" A clause contain a literal and its negation");
            else if (lits.Length == 0)
                throw new Exception("An empty clause occurred in the original clauses");

            int cl_id = add_clause_do_implication ( lits, tp, gflag);
            return cl_id;
        }

        int add_blocking_clause (int [] lits, int gid)
        {
            ushort gflag = 0;
            if (gid > 0)
                gflag = (ushort)(1<<(gid-1));
            foreach(int lit in lits)
                sharp_assert (is_active(node(lit)));
            return add_clause_with_gflag (lits, ClType.BLOCKING, gflag, true);
        }

        internal int add_clause (int [] lits)
        {
            return add_clause (lits, 0, true);
        }

        internal int add_clause (int [] lits, int gid)
        {
            return add_clause (lits, gid, true) ;
        }

        internal int add_clause (int [] lits, int gid, bool do_check)
        {
            ushort gflag = 0;
            if (gid > 0)
                gflag = (ushort)(1<<(gid-1));
            foreach(int lit in lits)
            {
                if (!is_active(node(lit)))
                {
                    stats.active_area_changed = true;
                    break;
                }
            }
            return add_clause_with_gflag (lits, ClType.ORIGINAL, gflag, do_check);
        }

        int add_learned_clause(int[] lits, ushort gflag)
        {
            int cl_id = add_clause_to_db( lits, ClType.CONFLICT,  gflag);
            rtrace_record_resolve_process (clause(cl_id).uid);
            return cl_id;
        }

        internal void set_branchable(int vid, bool br)
        {
            sharp_assert ( !stats.is_solving );
            Variable var = variable(vid);
            if (br && !is_branchable(var))
            {
                set_branchable(var);
                if (var_value(vid) == UNKNOWN)
                    ++ stats.num_free_branch_vars;
            }
            else if ( !br && is_branchable(var))
            {
                clear_branchable(var);
                if (var_value(vid) == UNKNOWN)
                    -- stats.num_free_branch_vars;
            }
        }

        internal void restart()
        {
            conflict_array.clear();
            implication_queue.Clear();
            if (dlevel > 0)
                backtrack(0);
            ++stats.num_restarts;
        }

        void run_garbage_collection()
        {
            bool[] remove = new bool [clauses.size()];
            for (int i=0; i< remove.Length; ++i)
                remove[i] = false;

            int headcount = conflict_clauses.size() / parameters.gc_head_tail_ratio;
            for (int i=0; i< headcount; ++i)
            {
                int cl_id = conflict_clauses[i];
                Clause cl = clause(cl_id);
                sharp_assert (cl.type == ClType.CONFLICT);
                if (cl.activity > parameters.gc_head_threshold)
                    continue;
                int num_0 = 0;
                for (int j=0; j< cl.num_lits; ++j)
                    if (lit_value(cl.literal(j)) == 0)
                        ++ num_0;
                if (cl.num_lits - num_0 < parameters.gc_head_length)
                    continue;
                remove[cl_id] = true;
            }
            for (int i=headcount; i< conflict_clauses.size(); ++i)
            {
                int cl_id = conflict_clauses[i];
                Clause cl = clause(cl_id);
                sharp_assert (cl.type == ClType.CONFLICT);
                if (cl.activity > parameters.gc_tail_threshold)
                    continue;
                int num_0 = 0;
                for (int j=0; j< cl.num_lits; ++j)
                    if (lit_value(cl.literal(j)) == 0)
                        ++ num_0;
                if (cl.num_lits - num_0 < parameters.gc_tail_length)
                    continue;
                remove[cl_id] = true;
            }

            delete_clauses(remove, false);
            ++ stats.num_garbage_collections;
        }

        void decay_variable_score()
        {
            for(int i=1, sz = variables.size(); i<sz; ++i)
            {
                Variable var = variable(i);
                var.score_0 = (short)(var.score_0 >> 1);
                var.score_1 = (short)(var.score_1 >> 1);
            }
        }

        void run_periodic_functions()
        {
            //a. restart
            if (parameters.enable_restart && stats.num_backtracks > stats.next_restart)
            {
                //System.Console.Write ("-");
                stats.next_restart = stats.num_backtracks + parameters.restart_period;
                restart();
            }
            //b. delete clauses
            if (parameters.enable_gc && stats.num_backtracks > stats.next_gc)
            {
                //System.Console.Write ("*");
                stats.next_gc = stats.num_backtracks + parameters.gc_period;
                run_garbage_collection();
            }
            //c. decay variable score
            if (stats.num_backtracks > stats.next_decay)
            {
                stats.next_decay = stats.num_backtracks + parameters.decay_period;
                decay_variable_score();
            }
        }

        internal void make_decision (int svar)
        {
            sharp_assert(implication_queue.Count == 0);
            sharp_assert (svar > 0 && var_value(svar>>1) == UNKNOWN);
            ++ dlevel;

            sharp_assert (stats.max_dlevel == asgn_stack.size() - 1);
            if (dlevel > stats.max_dlevel)
                stats.max_dlevel = dlevel;
            if (asgn_stack.size() <= dlevel)
                asgn_stack.push_back (new IntVector(32) );

            queue_implication(svar, -1, ImpType.NONE);
            ++ stats.num_decisions;
        }

        bool make_branch_decision()
        {
            if (implication_queue.Count != 0)
                return ((( Implication)(implication_queue.Peek())).lit > 1 );

            if (stats.num_free_branch_vars == 0)
                return false;

            int svar = 0;

            for ( ; max_score_pos < ordered_vars.size(); ++ max_score_pos )
            {
                int vid = ordered_vars[max_score_pos];
                if (variable(vid).varValue == UNKNOWN && is_branchable(variable(vid)))
                {
                    if (variable(vid).score_0 > variable(vid).score_1)
                        svar = vid + vid;
                    else
                        svar = vid + vid + 1;
                    break;
                }
            }
            if (svar == 0)  //even if still free branch, if all clauses are satisfied, then ok.
                return false;

            if (hook != null)
                hook.OnCaseSplit(svar);

            sharp_assert (is_active(node(svar)));
            make_decision(svar);
            return true;
        }


        void real_solve()
        {
            stats.outcome = SATStatus.UNDETERMINED;

            while (true)
            {
                if (get_cpu_time() - stats.start_cpu_time > parameters.time_limit)
                {
                    stats.outcome = SATStatus.TIME_OUT;
                    return;
                }
                if (stats.is_mem_out)
                {
                    stats.outcome = SATStatus.MEM_OUT;
                    return;
                }

                run_periodic_functions();

                bool can_branch = make_branch_decision();
                if (!can_branch)
                {
                    stats.outcome = SATStatus.SATISFIABLE;
                    return;
                }

                while(deduce() == false)
                    resolve_conflicts();

                //after above loop, the solver will stabilize in a decision level
                //with no conflict and implication. If this level is -1 then unsat
                if (dlevel < 0)
                {
                    stats.outcome = SATStatus.UNSATISFIABLE;
                    return;
                }
                if (hook != null)
                    hook.OnBCP ();
            }
        }

        internal void reset ()
        {
            if ( stats.been_reset == false)
            {
                if (dlevel >= 0)
                    backtrack( -1 );
                dlevel = 0;
                stats.outcome = SATStatus.UNDETERMINED;
                stats.been_reset = true;
            }
        }

        double get_cpu_time ()
        {
            /*
            currentProcess.Refresh();
            TimeSpan cputime = currentProcess.TotalProcessorTime;
            return cputime.Hours * 3600 + cputime.Seconds + cputime.Milliseconds / 1000.0;
            */
            return DateTime.Now.Ticks / 1e7;
        }

        void init ()
        {
            if (!stats.active_area_changed)
                return;
            //so, we need to figure out new active area
            for (int i=0; i< active_area.size(); ++i)
            {
                Variable var = node(active_area[i]);
                var.clear_flag(reasoning_flag);
                clear_active(var);
            }
            active_area.clear();

            for (int i=0; i< original_clauses.size(); ++i)
            {
                int cl_id = original_clauses[i];
                Clause cl = clause(cl_id);
                foreach (int lit in cl.literals)
                {
                    if (!node(lit).flag(active_flag))
                    {
                        active_area.push_back(NON_NEGATED(lit));
                        set_active(node(lit));
                    }
                }
            }
            mark_transitive_fanins(active_area, active_flag);

            ordered_vars.clear();
            for (int i=0; i< active_area.size(); ++i)
            {
                int vid = VID(active_area[i]);
                Variable var = variable(vid);
                sharp_assert (var.flag(active_flag));
                if (is_branchable(var)) //add it into vars for branching
                {
                    var.score_0 = variable(i).lits_count_0;
                    var.score_1 = variable(i).lits_count_1;
                    var.ordered_pos = ordered_vars.size();
                    ordered_vars.push_back(vid);
                }
                if (var.is_gate())
                    var.set_flag(reasoning_flag);
                else
                    var.clear_flag(reasoning_flag);
            }
        }

        internal SATStatus solve()
        {
            if (stats.constraint_zero > 0)
            {
                stats.outcome = SATStatus.UNSATISFIABLE;
                return stats.outcome;
            }

            stats.start_cpu_time = get_cpu_time();

            init();

            //enable_rtrace(true);
            sharp_assert (stats.is_solving == false);
            stats.is_solving = true;

            if (stats.been_reset == true)
                preprocess();

            stats.been_reset = false;

            if (dlevel < 0)
                stats.outcome = SATStatus.UNSATISFIABLE;
            else
                real_solve();

            stats.finish_cpu_time = get_cpu_time();
            stats.total_cpu_time += stats.finish_cpu_time - stats.start_cpu_time;
            ++ stats.num_rounds;
            stats.is_solving = false;

            //rtrace.dump_trace("trace");
            //if (stats.outcome == SATStatus.UNSATISFIABLE)
            //  dump_unsat_core("core.cnf");
            return stats.outcome;
        }

        void preprocess()
        {
            sharp_assert (dlevel == 0);
            for (int i=0; i< clauses.size(); ++i)
            {
                Clause cl = clause(i);
                if (cl == null)
                    continue;
                if (is_conflicting(cl))
                    queue_conflict(i, ImpType.CLAUSE);
                else
                {
                    int unit = find_unit_lit(cl);
                    if (unit != 0)
                        queue_implication(unit, i, ImpType.CLAUSE);
                }
            }

            if (deduce() == false)
            {
                resolve_conflicts();
                sharp_assert ( dlevel < 0);
                stats.outcome = SATStatus.UNSATISFIABLE;
            }
        }


        void mark_involved_var(int vid)
        {
            Variable var = variable(vid);
            if (is_marked(var) == false)
            {
                set_marked(var);
                if (var.dlevel == dlevel)
                    ++ stats.marked_current_dl;
                else
                    learned_clause.push_back(vid + vid + var_value(vid));
            }
        }

        void rtrace_add_resolvent(int uid)
        {
#if GEN_RESOLVE_TRACE
            rtrace.add_reason(uid);
#endif
        }

        void rtrace_add_resolvent(int uid, int r)
        {
#if GEN_RESOLVE_TRACE
            rtrace.add_reason(uid + (r << UIDSHIFT));
#endif
        }

        void rtrace_record_resolve_process (int uid)
        {
#if GEN_RESOLVE_TRACE
            rtrace.set_resolvent (uid);
#endif
        }

        void rtrace_gen_empty_clause(Antecedent conf)
        {
#if GEN_RESOLVE_TRACE
            sharp_assert ( stats.marked_current_dl == 0);
            sharp_assert (dlevel == 0);

            mark_conflict(conf) ;
            IntVector assignments = assignment_stack(dlevel);
            for (int i = assignments.size() - 1; i >= 0; --i)
            {
                int lit = assignments[i];
                int vid = (lit >> 1);
                Variable var = variable(vid);
                if (is_marked(var))
                {
                    mark_reason (vid);
                    clear_marked(var);
                    -- stats.marked_current_dl;
                }
            }
            sharp_assert ( stats.marked_current_dl == 0);
            sharp_assert ( learned_clause.size() == 0);

            //now record the generation process
            rtrace.set_empty_resolvents();
#endif
        }


        ushort mark_conflict(Antecedent conf)
        {
            // return the group flag of id of type
            switch(conf.type)
            {
                case ImpType.CLAUSE:    //implied by a clause
                {
                    Clause cl = clause(conf.index);
                    for (int i=0; i< cl.num_lits; ++i)
                        mark_involved_var(VID(cl.literal(i)));

                    rtrace_add_resolvent (cl.uid);
                    ++cl.activity;
                    return cl.gflag;
                }
                case ImpType.PB:    //implied by a pseudo boolean constraint
                {
                    fatal();
                    break;
                }
                case ImpType.NODE:      //implied by a combinational gate
                {
                    int r = node_mark_conflict(conf.index);
                    Variable nd = variable(conf.index);
                    rtrace_add_resolvent (nd.uid, r);
                    return nd.gflag;
                }
                default:
                    sharp_assert(false);
                    break;
            }
            return 0;
        }

        ushort mark_reason(int vid)
        {
            Variable var = variable(vid);
            Antecedent ante = var.antecedent;
            switch(ante.type)
            {
                case ImpType.CLAUSE:    //implied by a clause
                {
                    Clause cl = clause(ante.index);

                    for (int i=0; i< cl.num_lits; ++i)
                        if ((cl.literal(i)>>1) != vid)
                            mark_involved_var(cl.literal(i) >> 1);
                    rtrace_add_resolvent (cl.uid);
                    ++cl.activity;
                    return cl.gflag;
                }
                case ImpType.PB:    //implied by a pseudo boolean constraint
                {
                    fatal();
                    break;
                }
                case ImpType.NODE:      //implied by a combinational gate
                {
                    int r = node_mark_reason(vid);
                    Variable nd = variable(ante.index);
                    rtrace_add_resolvent (nd.uid, r);
                    return nd.gflag;
                }
                default:
                    sharp_assert(false);
                    break;
            }
            fatal();
            return 0;
        }

        /*
         * return value: which clause is responsible
         * a == i0, b == i1, c == out
         * for AND
         * 1: (a + c')
         * 2: (b + c')
         * 3: (a' + b' + c)
         * for XOR
         * 4: (a' + b + c)
         * 5: (a + b' + c)
         * 6: (a + b + c')
         * 7: (a' + b' + c')
         */
        int node_mark_conflict(int vid)
        {
            Variable n = variable(vid);
            sharp_assert (var_value(vid) != UNKNOWN);
            mark_involved_var( vid );

            int r = 0;
            int i0 = n.left;
            int vid0 = NODE_ID(i0);
            int i1 = n.right;
            int vid1 = NODE_ID(i1);
            if (n.type == NodeType.AND)
            {
                if (var_value(vid) == 0)
                {
                    sharp_assert (lit_value(i0) == 1);
                    sharp_assert (lit_value(i1) == 1);
                    mark_involved_var( vid0 );
                    mark_involved_var( vid1 );
                    r = 3;
                }
                else
                { //var value == 1
                    sharp_assert (lit_value(i0) == 0 || lit_value(i1) == 0);
                    if (lit_value(i0) != 0)
                    {
                        mark_involved_var( vid1 );
                        r = 2;
                    }
                    else if (lit_value(i1) != 0)
                    {
                        mark_involved_var( vid0 );
                        r = 1;
                    }
                    else
                    {
                        sharp_assert (variable(vid0).dlevel == variable(vid1).dlevel);
                        if (variable(vid0).asgn_pos < variable(vid1).asgn_pos)
                        {
                            mark_involved_var( vid0 );
                            r = 1;
                        }
                        else
                        {
                            mark_involved_var( vid1 );
                            r = 2;
                        }
                    }
                }
            }
            else
            {
                sharp_assert (n.type == NodeType.XOR);
                sharp_assert (lit_value(i0) == 0 || lit_value(i0) == 1);
                sharp_assert (lit_value(i1) == 0 || lit_value(i1) == 1);
                sharp_assert ((lit_value(i0) ^ lit_value(i1)) != var_value(vid));
                mark_involved_var( vid0 );
                mark_involved_var( vid1 );
#if GEN_RESOLVE_TRACE
                int va = lit_value(i0);
                int vb = lit_value(i1);
                int vc = var_value(vid);
                if (va == 1 && vb == 0 && vc == 0)
                    r = 4;
                else if (va == 0 && vb == 1 && vc == 0)
                    r = 5;
                else if (va == 0 && vb == 0 && vc == 1)
                    r = 6;
                else
                {
                    sharp_assert (va == 1 && vb == 1 && vc == 1);
                    r = 7;
                }
#endif
            }
            return r;
        }

        int node_mark_reason(int vid)
        {
            sharp_assert (variable(vid).antecedent.type == ImpType.NODE);
            int ante = variable(vid).antecedent.index;

            int r = 0;
            Variable n = variable(ante);
            int i0 = n.input(0);
            int vid0 = NODE_ID(i0);
            int i1 = n.input(1);
            int vid1 = NODE_ID(i1);

            if (n.type == NodeType.AND)
            {
                if (vid == ante)
                { //by itself, so it's propagation, the reason is it's input
                    if (var_value(vid) == 1)
                    {
                        sharp_assert (lit_value(i0) == 1);
                        sharp_assert (lit_value(i1) == 1);
                        mark_involved_var( vid0 );
                        mark_involved_var( vid1 );
                        r = 3;
                    }
                    else
                    {
                        sharp_assert (lit_value(i0) == 0 || lit_value(i1) == 0);
                        if (lit_value(i0) != 0)
                        {
                            mark_involved_var( vid1 );
                            r = 2;
                        }
                        else if (lit_value(i1) != 0)
                        {
                            mark_involved_var( vid0 );
                            r = 1;
                        }
                        else
                        {
                            sharp_assert (var_dlevel(vid0) == var_dlevel(vid1));
                            if (variable(vid0).asgn_pos < variable(vid1).asgn_pos)
                            {
                                mark_involved_var( vid0 );
                                r = 1;
                            }
                            else
                            {
                                mark_involved_var( vid1 );
                                r = 2;
                            }
                        }
                    }
                }
                else
                { //it's justification, the reason is it's output (ante), and maybe the other input of ante
                    int other_vid;
                    int other_input;
                    int self_input;

                    sharp_assert (vid0 == vid || vid1 == vid);
                    if (vid0 == vid)
                    {
                        other_vid = vid1;
                        other_input = i1;
                        self_input = i0;
                        r = 1;
                    }
                    else
                    {
                        other_vid = vid0;
                        other_input = i0;
                        self_input = i1;
                        r = 2;
                    }
                    if (lit_value(self_input) == 1)
                    {
                        sharp_assert (var_value(ante) == 1);
                        mark_involved_var( ante );
                    }
                    else
                    {
                        sharp_assert (var_value(ante) == 0);
                        sharp_assert (lit_value(other_input) == 1);
                        mark_involved_var( ante );
                        mark_involved_var( other_vid );
                        r = 3;
                    }
                }
            }
            else
            {
                sharp_assert (n.type == NodeType.XOR);
                if (ante == vid)
                {
                    mark_involved_var( vid0 );
                    mark_involved_var( vid1 );
#if GEN_RESOLVE_TRACE
                    int va = lit_value(i0);
                    int vb = lit_value(i1);
                    int vc = var_value(ante);
                    if (vc == 1)
                    {
                        if (va == 1 && vb == 0)
                            r = 4;
                        else
                        {
                            sharp_assert (va == 0 && vb == 1);
                            r = 5;
                        }
                    }
                    else
                    {
                        if (va == 0 && vb == 0)
                            r = 6;
                        else
                        {
                            sharp_assert (va == 1 && vb == 1);
                            r = 7;
                        }
                    }
#endif
                }
                else
                {
                    mark_involved_var( ante );
                    sharp_assert (vid0 == vid || vid1 == vid);
                    if (vid0 == vid)
                        mark_involved_var( vid1 );
                    else
                        mark_involved_var( vid0 );
#if GEN_RESOLVE_TRACE
                    int va = lit_value(i0);
                    //int vb = lit_value(i1);
                    int vc = var_value(ante);
                    if (vc == 0)
                    {
                        if (va == 0)
                            r = 4;
                        else
                            r = 5;
                    }
                    else
                    {
                        if (va == 0)
                            r = 6;
                        else
                            r = 7;
                    }
#endif
                }
            }
            return r;
        }

        void resolve_conflicts()
        {
            sharp_assert (!conflict_array.empty());
            sharp_assert (implication_queue.Count == 0);
            sharp_assert ( stats.marked_current_dl == 0 );
            sharp_assert ( learned_clause.empty() );

            ++ stats.num_conflicts;

            if (dlevel == 0)
            {
                rtrace_gen_empty_clause(conflict_array[0]);
                backtrack(-1);
                conflict_array.clear();
                return;
            }

            ushort gflag = 0;

            Antecedent conf = (Antecedent) conflict_array[0];

            for (int i=1, sz = conflict_array.size(); i< sz; ++i)
            {
                if ( ((Antecedent)conflict_array[i]).type == ImpType.NODE)
                {
                    conf = (Antecedent) conflict_array[i];
                    break;
                }
            }

            gflag |= mark_conflict(conf);

            sharp_assert (stats.marked_current_dl > 1);

            IntVector assignments = assignment_stack(dlevel);
            for (int i = assignments.size() - 1; i >= 0; --i)
            {
                int lit = assignments[i];
                int vid = (lit >> 1);
                Variable var = variable(vid);

                if (!is_marked(var))
                    continue;

                if (stats.marked_current_dl == 1)
                {
                    learned_clause.push_back(lit^1);
                    break;
                }
                else
                {
                    gflag |= mark_reason (vid);
                    clear_marked(var);
                    -- stats.marked_current_dl;
                }
            }
            sharp_assert ( stats.marked_current_dl == 1);

            int sharp_assert_level = 0;
            int sharp_assert_lit = learned_clause.back;
            sharp_assert (lit_value(sharp_assert_lit) == 0);
            clear_marked(node(sharp_assert_lit));
            -- stats.marked_current_dl;

            for (int i = 0; i < learned_clause.size() - 1; ++i)
            {
                int lit = learned_clause[i];
                incr_var_score (lit);
                sharp_assert (lit_value(lit) == 0);

                Variable var = variable(lit>>1);
                sharp_assert (is_marked(var));
                clear_marked(var);
                if (var.dlevel > sharp_assert_level)
                    sharp_assert_level = var.dlevel;
            }
            backtrack(sharp_assert_level);

            int cl_id = add_learned_clause(learned_clause.ToArray(), gflag);
            learned_clause.clear();
            sharp_assert (is_unit(cl_id));
            queue_implication(sharp_assert_lit, cl_id, ImpType.CLAUSE);
            conflict_array.clear();
        }


        void queue_conflict (int ante, ImpType type)
        {
            Antecedent antecedent = new Antecedent(type, ante);
            conflict_array.push_back ((int) antecedent);
        }

        void queue_implication(int lit, int ante, ImpType type)
        {
            if (is_active(node(lit))) //it is in the active area
            {
                Implication imp = new Implication();
                imp.lit = lit;
                imp.ante.type = type;
                imp.ante.index = ante;
                implication_queue.Enqueue (imp);
            }
        }

        bool deduce()
        {
            while (implication_queue.Count != 0 && conflict_array.empty())
            {
                Implication imp = (Implication) implication_queue.Dequeue();
                int lit = imp.lit;
                int vid = lit>> 1;
                if(var_value(vid) == UNKNOWN)
                {
                    propagate_implication ( imp );
                    variable(vid).asgn_pos = assignment_stack(dlevel).size();
                    assignment_stack(dlevel).push_back(lit);
                }
                else
                {
                    if (lit_value(lit) == 0)    //conflict
                        queue_conflict(imp.ante.index, imp.ante.type);
                }
#if CHECK
                for (int i=0; i< clauses.size(); ++i)
                {
                    Clause cl = clause(i);
                    if (cl != null && is_conflicting(i))
                        sharp_assert (!conflict_array.empty());
                }
#endif
            }
            if (!conflict_array.empty())
            {
                implication_queue.Clear();
                return false;
            }
            return true;
        }

        void propagate_implication (Implication imp)
        {
            int vid = imp.lit>> 1;

            Variable var = variable(vid);
            sharp_assert (var_value(vid) == UNKNOWN);

            var.dlevel = dlevel;
            var.antecedent = imp.ante;

            var_set_value (vid, (short) (1 - (imp.lit&1)));

            set_svar_value(imp.lit);

            ++ stats.num_implications ;
            -- stats.num_free_variables;
            if (is_branchable(var))
                -- stats.num_free_branch_vars;
        }

        void unset_variable(int v)
        {
            if (v == 0) return;
            Variable var = variable(v);
            var.dlevel      = -1;
            var.antecedent  = -1;
            var.asgn_pos    = -1;
            var_set_value (v, UNKNOWN);
            ++ stats.num_free_variables;
            if (is_branchable(var))
            {
                ++ stats.num_free_branch_vars;
                if (var.ordered_pos < max_score_pos)
                    max_score_pos = var.ordered_pos;
            }
        }

        void backtrack(int blevel)
        {
            sharp_assert(blevel < dlevel);
            implication_queue.Clear();

            for (int i= dlevel; i> blevel; --i)
            {
                IntVector assignments = assignment_stack(i);
                for (int j=assignments.size()-1 ; j>=0; --j)
                    unset_variable (assignments[j]>>1);
                assignment_stack(i).clear();
            }

            dlevel = blevel;
            ++ stats.num_backtracks;

            if (hook != null)
                hook.OnBacktrack(blevel);
        }

        void set_svar_value(int s)
        {
            //Implication On the Network
            Variable var = variable(VID(s));
            //propagate forward
            for (int i=0; i< var.outputs.size(); ++i)
                make_node_consistent(var.output(i));
            //justify backward
            make_node_consistent(s);

            //Implication On the clauses
            IntVector watched = watched_by (s ^ 1); //the neg watched
            for (int i=0; i< watched.size(); ++i)
            {
                int cl_idx = (watched[i] >> 1);
                int w_idx = (watched[i] & 1);
                Clause cl = clause(cl_idx);
                int[] lits = cl.literals;
                sharp_assert (lits[w_idx] == (s ^ 1));
                int other_watch_lit = lits[1 - w_idx];
                int other_value = lit_value(other_watch_lit);
                if (other_value == 0)
                {
                    sharp_assert (variable(other_watch_lit>> 1).dlevel == dlevel);
                    queue_conflict(cl_idx, ImpType.CLAUSE);
                }
                else if (other_value != 1)
                {
                    int j;
                    for (j=2; j< cl.num_lits; ++j)
                        if (lit_value(lits[j]) != 0)
                            break;
                    if (j < cl.num_lits)
                    { //found another non-0 lit
                        int temp = lits[j];
                        lits[j] = lits[w_idx];
                        lits[w_idx] = temp;
                        watched_by(temp).push_back(cl_idx + cl_idx + w_idx);
                        watched[i] = watched.back;
                        watched.pop_back();
                        -- i;
                    }
                    else
                        queue_implication(other_watch_lit, cl_idx, ImpType.CLAUSE);
                }
            }
        }

        internal int new_pi()
        {
            int s = new_node( NodeType.PI, INVALID, INVALID);
            primary_inputs.push_back(s);
            node_to_pi_hash[s] = primary_inputs.size() - 1;
            return s;
        }

        internal int nth_pi(int n)
        {
            while (num_pi() <= n)
                new_pi();
            return pi(n);
        }


        internal int left_child (int s) { return node(s).left; }
        internal int right_child (int s){ return node(s).right; }

        internal int band (int i1, int i2)
        {
            int l = canonical (i1);
            int r = canonical (i2);
            int result =  create( NodeType.AND, l, r );
            //          dump_file.WriteLine ("{0} = AND {1} {2}", result, i1, i2);
            return result;
        }

        internal int bxor (int i1, int i2)
        {
            int l = canonical (i1);
            int r = canonical (i2);
            int result = create( NodeType.XOR, l, r );
            //          dump_file.WriteLine ("{0} = XOR {1} {2}", result, i1, i2);
            return result;
        }

        internal int  bor  (int i1, int i2) { return NEGATE( band( NEGATE(i1), NEGATE(i2)) );}
        internal int    bequ (int i1, int i2)   { return NEGATE( bxor( i1, i2 ));}
        internal int    bimp (int i1, int i2)   { return bor (NEGATE(i1), i2);}
        internal int    bnot (int i)            { return NEGATE(i); }

        /*
          Create a node. Don't do recursive optimization. But do lookup and simplification
          if possible.
         */
        int create_op_node(NodeType op, int i1, int i2)
        {
            if (op == NodeType.AND)
            {
                if (i1 == zero() || i2 == zero() || i1 == NEGATE(i2))
                    return zero();
                if (i1 == one())
                    return i2;
                if (i2 == one())
                    return i1;
                if (i1 == i2)
                    return i1;
            }
            else
            {
                sharp_assert (op == NodeType.XOR);
                if (i1 == zero())
                    return i2;
                if (i1 == one())
                    return NEGATE(i2);
                if (i2 == zero())
                    return i1;
                if (i2 == one())
                    return NEGATE(i1);
                if (i1 == i2)
                    return zero();
                if (i1 == NEGATE(i2))
                    return one();
            }

            int r = node_hash.lookup(op, i1, i2);
            if (r != INVALID)
                return r;

            r = create_op_node2(op, i1, i2);

            return r;
        }

        /*
          create an op node, Do recursive optimization and other possible optimizations
         */
        int create (NodeType op, int i1, int i2)
        {
            if (op == NodeType.AND)
            {
                if (i1 == zero() || i2 == zero() || i1 == NEGATE(i2))
                    return zero();
                if (i1 == one())
                    return i2;
                if (i2 == one())
                    return i1;
                if (i1 == i2)
                    return i1;
            }
            else
            {
                sharp_assert (op == NodeType.XOR);
                if (i1 == zero())
                    return i2;
                if (i1 == one())
                    return NEGATE(i2);
                if (i2 == zero())
                    return i1;
                if (i2 == one())
                    return NEGATE(i1);
                if (i1 == i2)
                    return zero();
                if (i1 == NEGATE(i2))
                    return one();
            }

            int r = node_hash.lookup(op, i1, i2);

            if (r != INVALID)
                return r;

            //          r = create_op_node2(op, i1, i2);
            if ( is_pi(i1) && is_pi(i2))
                r = create_op_node2(op, i1, i2);
            else if (is_pi(i1) || is_pi(i2))
                r = create_op_node3(op, i1, i2);
            else
                r = create_op_node4(op, i1, i2);

            return r;
        }

        int get_signature4(NodeType op, int l, int r)
        {
            int sig = 0;
            int ll = node(l).left;
            int lr = node(l).right;

            int rl = node(r).left;
            int rr = node(r).right;

            sharp_assert ( ll < lr );
            sharp_assert ( rl < rr );
            sharp_assert ( ll < rl || ll == rl ); // to reduce lookup table size

            if (IS_NEGATED(ll))         sig |= (1<<0);
            if (IS_NEGATED(lr))         sig |= (1<<1);
            if (IS_NEGATED(rl))         sig |= (1<<2);
            if (IS_NEGATED(rr))         sig |= (1<<3);
            if (IS_NEGATED(l))          sig |= (1<<4);
            if (IS_NEGATED(r))          sig |= (1<<5);
            if (node(l).type == NodeType.XOR)   sig |= (1<<6);
            if (node(r).type == NodeType.XOR)   sig |= (1<<7);
            if (op == NodeType.XOR)         sig |= (1<<8);

            int v_ll = NODE_ID( ll );
            int v_lr = NODE_ID( lr );
            int v_rl = NODE_ID( rl );
            int v_rr = NODE_ID( rr );

            if (v_lr < v_rl)        sig |= (0 << 9);    //a < b < c < d
            else if (v_lr == v_rl)  sig |= (1 << 9);    //a < b = c < d
            else if (v_lr < v_rr)
            {
                if (v_ll < v_rl )   sig |= (2 << 9);        //a < c < b < d
                else            sig |= (3 << 9);    //a = c < b < d
            }
            else if (v_lr == v_rr)
            {
                if (v_ll < v_rl )   sig |= (4 << 9);        //a < c < b = d
                else            sig |= (5 << 9);    //a = c < b = d
            }
            else
            { // v_lr > v_rr
                if (v_ll < v_rl )   sig |= (6 << 9);        //a < c < d < b
                else            sig |= (7 << 9);    //a = c < d < b
            }
            return sig;
        }

        int  get_signature3(NodeType op, int l, int r)
        {
            //Functions that contains 3 operands:
            //it is assumed that the structure is like this:
            //               o
            //             l    (op)  r
            //        ll (op1) lr
            int sig = 0;
            sharp_assert (!is_pi(l));
            sharp_assert (is_pi(r));
            int ll = node(l).left;
            int lr = node(l).right;

            sharp_assert (ll < lr);

            if (IS_NEGATED(ll))         sig |= (1<<0);
            if (IS_NEGATED(lr))         sig |= (1<<1);
            if (IS_NEGATED(l))          sig |= (1<<2);
            if (IS_NEGATED(r))          sig |= (1<<3);
            if (node(l).type == NodeType.XOR)   sig |= (1<<4);
            if (op == NodeType.XOR)         sig |= (1<<5);

            int v_r = NODE_ID(r);
            int v_ll = NODE_ID(ll);
            int v_lr = NODE_ID(lr);

            if (v_r > v_lr )        sig |= (0 << 6);    //a < b < c
            else if (v_r == v_lr )  sig |= (1 << 6);    //a < b = c
            else if (v_ll < v_r )   sig |= (2 << 6);    //a < c < b
            else if (v_ll == v_r )  sig |= (3 << 6);    //a = c < b
            else            sig |= (4 << 6);    //c < a < b

            return sig;
        }

        /*
          Create an op node and add it to hash table.
          Just do it, don't do lookup or simplification
         */
        int create_op_node2(NodeType op, int i1, int i2)
        {
            sharp_assert (op == NodeType.AND || op == NodeType.XOR);

            // do need to make it canonical
            //1. left input always has smaller index than right
            if (i1 > i2)
            {
                int temp = i1;
                i1 = i2;
                i2 = temp;
            }
            //2. For XOR gate, both of its input must be in positive phase
            bool do_NEGATE = false;
            if (op == NodeType.XOR)
            {
                if (IS_NEGATED(i1))
                {
                    i1 = NEGATE(i1);
                    do_NEGATE = !do_NEGATE;
                }
                if (IS_NEGATED(i2))
                {
                    i2 = NEGATE(i2);
                    do_NEGATE = !do_NEGATE;
                }
            }

            int o = new_node(op, i1, i2);
            sharp_assert (o > i1 && o > i2);

            node(i1).outputs.push_back(o);      //i.e. the sign is 0: Left child
            node(i2).outputs.push_back(NEGATE(o));  //i.e. the sign is 1: Right child
            reference (i1);
            reference (i2);

            //add it to the hash
            node_hash.insert( o, op, i1, i2);

            //return the actual result
            if (do_NEGATE)
                o = NEGATE(o);

            return o;
        }

        /*
          Create a node, one of its inputs is a PI
         */
        int create_op_node3(NodeType op, int i1, int i2)
        {
            if (is_pi(i1))
            {
                sharp_assert (!is_pi(i2));
                int temp = i2;
                i2 = i1;
                i1 = temp;
            }

            int sig = get_signature3(op, i1, i2);
            int r = look_up_3_input_node ( op, i1, i2, sig);
            return r;
        }

        /*
          Create a node, none of its inputs is PI
         */
        int create_op_node4(NodeType op, int i1, int i2)
        {
            if (node(i1).left > node(i2).left)
            {
                int temp = i1;
                i1 = i2;
                i2 = temp;
            }

            int sig = get_signature4(op, i1, i2);
            int r = look_up_4_input_node ( op, i1, i2, sig);
            return r;
        }

        /*
          Merge two ints, always keep the one() with smaller index
         */
        int merge (int i1, int i2)
        {
            return real_merge(canonical(i1), canonical(i2));
        }

        int real_merge(int i1, int i2)
        {
            if (i1 == i2)
                return i1;
            else if (i1 == NEGATE(i2))
                return INVALID;

            if (i1 > i2)
            {
                int temp = i2;
                i2 = i1;
                i1 = temp;
            }

            for (int i=0; i< node(i2).outputs.size(); ++i)
            {
                int o = node(i2).output(i);
                int output = NON_NEGATED (o);
                int l_r = SIGN(o); //the left or the right input
                int other_input = node(output).input(1 - l_r);
                if (node(output).input(l_r) == i2)
                {
                    int r_node = create (node(output).type, i1, other_input);
                    real_merge(r_node, output);
                }
                else
                {
                    sharp_assert (node(output).input(l_r) == NEGATE(i2));
                    int r_node = create (node(output).type, NEGATE(i1), other_input);
                    real_merge(r_node, output);
                }
            }

            node(i2).outputs.clear();

            if (IS_NEGATED(i2))
                node(i2).canonical = NEGATE(i1);
            else
                node(i2).canonical = i1;

            return i1;
        }

        internal void reference(int lit)
        {
            variable(lit>>1).ref_count ++;
        }

        internal void deref (int lit)
        {
            //          if (--variable(VID (lit)).ref_count != 0)
            //              return;
            //
            //          IntVector to_be_processed = new IntVector(16);
            //          to_be_processed.push_back(VID (lit));
            //          for (int i=0; i< to_be_processed.size(); ++i)
            //          {
            //              int vid = to_be_processed[i];
            //              Variable var = variable(vid);
            //              if (var.is_gate())
            //              {
            //                  for (int j=0; j< 2; ++j)
            //                  {
            //                      int vin = (j==0)? VID(var.left): VID(var.right);
            //                      Variable var_in =  variable(vin);
            //                      int size = var_in.outputs.size();
            //                      for (int k=0; k< size; ++k)
            //                      {
            //                          if (VID(var_in.output(k)) == vid)
            //                          {
            //                              var_in.outputs[k] = var_in.outputs.back;
            //                              var_in.outputs.pop_back();
            //                              break;
            //                          }
            //                      }
            //                      sharp_assert (size > var_in.outputs.size());
            //                      if ( --var_in.ref_count == 0)
            //                          to_be_processed.push_back(vin);
            //                  }
            //              }
            //          }
            //          free_nodes.add (to_be_processed);
        }
        /*
          Compose: i.e. replace some ints with other ints
          input : the output node and the replacement correspondence
          output: the result of the composition
         */
        internal int compose ( int output, int [] orig, int [] replace)
        {
            sharp_assert (orig.Length == replace.Length);

            if (node(output).type == NodeType.CONSTANT)
                return output;

            MyHashtable sig_map = new MyHashtable();
            for (int i=0; i< orig.Length; ++i)
            {
                int s_orig = orig[i];
                int s_new = replace[i];
                if (IS_NEGATED(s_orig))
                {
                    s_orig = NEGATE(s_orig);
                    s_new = NEGATE(s_new);
                }
                sig_map[s_orig] = s_new;
            }
            return real_compose(canonical(output), sig_map);
        }

        int real_compose(int old, MyHashtable sig_map )
        {
            int result;

            bool invert = false;

            if (IS_NEGATED(old))
            {
                old = NEGATE(old);
                invert = true;
            }
            object item = sig_map[old];
            if (item != null)
                result = (int) item;
            else
            {
                if (is_pi(old))     //so, if a pi is not replaced, use it as is
                    result  = old;
                else
                {
                    int left = real_compose(node(old).left, sig_map);
                    int right = real_compose(node(old).right, sig_map);
                    result = create(node(old).type, left, right);
                    sig_map[old] = result;
                }
            }
            return (invert ? NEGATE(result): result);
        }

        internal int gen_interpolant_from_clauses(int gid1, int gid2)
        {
            clean_up();
            rtrace.enable_trace(true);
            SATStatus status = solve();
            rtrace.enable_trace(false);
            reset();

            if (status != SATStatus.UNSATISFIABLE)
                return -1;
            return rtrace.gen_interpolant_from_clauses (gid1, gid2);
        }

        internal int gen_interpolant_from_signals(int s1, int s2)
        {
            clean_up();

            int gid = alloc_gid();
            int [] cl1 = new int [] {s1};
            int c_1 = add_clause(cl1, gid);
            int [] cl2 = new int [] {s2};
            int c_2 = add_clause(cl2, gid);

            rtrace.enable_trace(true);
            SATStatus status = solve();
            rtrace.enable_trace(false);
            reset();

            int r;
            if (status != SATStatus.UNSATISFIABLE)
                r =  -1;
            else
                r = rtrace.gen_interpolant_from_signals (s1, c_1, s2, c_2);
            delete_clause_group(gid);
            return r;
        }

        // gretay - change start
        internal int gen_interpolant_from_signals_ex(int s1, int s2)
        {
            // don't cleanup because conflict clauses
            //clean_up();

            int gid = alloc_gid();
            int [] cl1 = new int [] {s1};
            int c_1 = add_clause(cl1, gid, false);
            int [] cl2 = new int [] {s2};
            int c_2 = add_clause(cl2, gid, false);

            rtrace.enable_trace(true);
            SATStatus status = solve();
            rtrace.enable_trace(false);
            reset();

            int r;
            if (status != SATStatus.UNSATISFIABLE)
                r =  -1;
            else
                r = rtrace.gen_interpolant_from_signals_ex (s1, c_1, s2, c_2, c_cls_id.ToArray(), c_interp.ToArray());
            return r;
        }

        Hashtable interpolants = new Hashtable();  // maps clause_uid to signal that describes the interpolant provided for that clause
        IntVector c_cls_id = new IntVector(4);
        IntVector c_interp = new IntVector(4);

        public bool has_interpolant(int cl_uid)
        {
            return interpolants.Contains(cl_uid);
        }
        public void set_interpolant(int cl_uid, int interp)
        {
            Debug.Assert(!has_interpolant(cl_uid));
            interpolants[cl_uid] = interp;
            c_cls_id.push_back(cl_uid);
            c_interp.push_back(interp);
        }
        public int  get_interpolant_by_clause_uid(int cl_uid)
        {
            Debug.Assert(has_interpolant(cl_uid));
            return (int) interpolants[cl_uid];
        }
        // end gretay - change end

        internal UnsatCore gen_unsat_core ()
        {
            clean_up();
            rtrace.enable_trace(true);
            SATStatus status = solve();
            rtrace.enable_trace(false);

            if (status != SATStatus.UNSATISFIABLE)
                return null;

            MyHashtable hash = rtrace.generate_unsat_core();
            UnsatCore core = new UnsatCore();
            IntVector core_cls = new IntVector(4);
            IntVector core_nodes = new IntVector(4);
            for (int i=0; i< clauses.size(); ++i)
            {
                Clause cl = clause(i);
                if (cl == null)
                    continue;
                if (hash.Contains(cl.uid))
                {
                    sharp_assert (cl.type == ClType.ORIGINAL);
                    core_cls.push_back (i);
                }
            }
            for (int i=1; i < variables.size(); ++i)
            {
                Variable v = variable(i);
                if (hash.Contains(v.uid))
                {
                    sharp_assert (v.type == NodeType.AND || v.type == NodeType.XOR);
                    core_nodes.push_back ( i + i);
                }
            }
            core.core_clauses = core_cls.ToArray();
            core.core_nodes = core_nodes.ToArray();
            return core;
        }

        void dump_unsat_core( string filename)
        {
            StreamWriter writer = new StreamWriter(filename);
            UnsatCore core = gen_unsat_core();

            writer.WriteLine ("p cnf {0} {1} ", num_variables() , core.core_clauses.Length);
            foreach (int cl_id in core.core_clauses)
            {
                foreach (int lit in clause(cl_id).literals)
                {
                    if ((lit & 1) == 1)
                        writer.Write("-");
                    writer.Write ("{0} ", lit>>1);
                }
                writer.WriteLine ("0");
            }
            writer.Close();
            if (core.core_nodes.Length != 0)
            {
                Console.WriteLine ("Warning: Contains Nodes in the UNSAT core " );
                foreach (int s in core.core_nodes)
                {
                    Console.Write ("{0} ", s);
                }
                Console.WriteLine("");
            }
        }

        internal void dump_node (StreamWriter wt, int s)
        {
            int flag = alloc_flag();
            mark_transitive_fanins(s, flag);
            for (int i=1; i< variables.size(); ++i)
            {
                Variable var = variable(i);
                if (var.flag(flag))
                {
                    switch (var.type)
                    {
                        case NodeType.PI:
                            wt.WriteLine("{0} = PI", i + i);
                            break;
                        case NodeType.AND:
                            wt.WriteLine("{0} = AND {1} {2}", i + i, var.left, var.right);
                            break;
                        case NodeType.XOR:
                            wt.WriteLine("{0} = XOR {1} {2}", i + i, var.left, var.right);
                            break;
                    }
                }
            }
            free_flag(flag);
        }

        internal int get_structure (SharpSATSolver solver, int output)
        {
            int f = solver.alloc_flag();
            solver.mark_transitive_fanins(output,f);
            int [] lookup = new int [solver.variables.size() * 2];
            for (int i=0; i< lookup.Length; ++i)
                lookup[i] = -1;
            for (int i=1; i< solver.variables.size(); ++i)
            {
                Variable var = solver.variable(i);
                if (!var.flag(f))
                    continue;
                int l = var.left;
                int r = var.right;
                int s ;
                switch(var.type)
                {
                    case NodeType.AND:
                        sharp_assert (solver.node(l).flag(f));
                        sharp_assert (solver.node(r).flag(f));
                        sharp_assert (lookup[l] != -1);
                        sharp_assert (lookup[r] != -1);
                        s = band(lookup[l], lookup[r]);
                        //                      sharp_assert (node(s).left == lookup[l]);
                        //                      sharp_assert (node(s).right == lookup[r]);
                        lookup[i + i] = s;
                        lookup[i + i + 1] = s ^ 1;
                        break;
                    case NodeType.XOR:
                        sharp_assert (solver.node(l).flag(f));
                        sharp_assert (solver.node(r).flag(f));
                        sharp_assert (lookup[l] != -1);
                        sharp_assert (lookup[r] != -1);
                        s = bxor(lookup[l], lookup[r]);
                        //                      sharp_assert (node(s).left == lookup[l]);
                        //                      sharp_assert (node(s).right == lookup[r]);
                        lookup[i + i] = s;
                        lookup[i + i + 1] = s ^ 1;
                        break;
                    case NodeType.PI:
                        s = new_pi();
                        lookup[i + i] = s;
                        lookup[i + i + 1] = s ^ 1;
                        break;
                    default:
                        sharp_assert(false);
                        break;
                }
            }
            return lookup[output];
        }

        internal void dump_original_clauses ( StreamWriter wt )
        {
//          IntVector originals = new IntVector(128);
//          foreach (object k in original_clauses.Keys)
//              originals.push_back((int)k);
//          originals.sort();
            for (int i=0; i< original_clauses.size(); ++i)
            {
                int cl_id = original_clauses[i];
                sharp_assert (clause(cl_id).type == ClType.ORIGINAL);
                wt.Write ("{0} = CL", i);
                foreach (int lit in clause(cl_id).literals)
                    wt.Write(" {0}", lit);
                wt.Write("\n");
            }
        }
        /* =========================================================================

        Simulation Etc. on the Boolean Network

           ========================================================================= */
        internal IntVector mark_transitive_fanouts(int s, int flag_id)
        {
            IntVector to_be_processed = new IntVector(64);
            to_be_processed.push_back(s);
            node(s).set_flag(flag_id);
            for (int i = 0; i< to_be_processed.size(); ++i)
            {
                Variable nd = node (to_be_processed[i]);
                for (int j=0, sz = nd.outputs.size(); j < sz;  ++j)
                    if (node(nd.output(j)).flag(flag_id) == false)
                    {
                        node(nd.output(j)).set_flag(flag_id);
                        to_be_processed.push_back(nd.output(j));
                    }
            }
            return to_be_processed;
        }

        internal IntVector find_transitive_fanins  (int s)
        {
            int flag = alloc_flag();
            IntVector result = mark_transitive_fanins(s, flag);
            free_flag(flag);
            return result;
        }

        internal IntVector mark_transitive_fanins(IntVector to_be_processed, int flag_id)
        {
            for (int i = 0, sz = to_be_processed.size(); i < sz; ++i)
            {
                Variable nd = node (to_be_processed[i]);
                nd.set_flag(flag_id);
            }
            for (int i = 0; i< to_be_processed.size(); ++i)
            {
                Variable nd = node (to_be_processed[i]);
                if (nd.left == INVALID || nd.right == INVALID)
                {
                    sharp_assert (nd.left == INVALID && nd.right == INVALID);
                    continue;
                }
                if (node(nd.left).flag(flag_id) == false)
                {
                    node(nd.left).set_flag(flag_id);
                    to_be_processed.push_back(nd.left);
                }
                if (node(nd.right).flag(flag_id) == false)
                {
                    node(nd.right).set_flag(flag_id);
                    to_be_processed.push_back(nd.right);
                }
            }
            return to_be_processed;
        }

        internal IntVector mark_transitive_fanins(int s, int flag_id)
        {
            sharp_assert (s != INVALID);
            if (node(s).type == NodeType.CONSTANT)
                return null;
            IntVector to_be_processed = new IntVector(4);
            to_be_processed.push_back(s);
            node(s).set_flag(flag_id);
            for (int i = 0; i< to_be_processed.size(); ++i)
            {
                Variable nd = node (to_be_processed[i]);
                if (nd.left == INVALID || nd.right == INVALID)
                {
                    sharp_assert (nd.left == INVALID && nd.right == INVALID);
                    continue;
                }

                if (node(nd.left).flag(flag_id) == false)
                {
                    node(nd.left).set_flag(flag_id);
                    to_be_processed.push_back(nd.left);
                }
                if (node(nd.right).flag(flag_id) == false)
                {
                    node(nd.right).set_flag(flag_id);
                    to_be_processed.push_back(nd.right);
                }
            }
            return to_be_processed;
        }

        public int [] find_small_model()
        {
            return find_small_model_greed();
        }

        private int [] find_small_model_greed ()
        {
            sharp_assert ( stats.outcome == SATStatus.SATISFIABLE);
            sharp_assert ( stats.num_free_branch_vars == 0);
            int f = alloc_flag();
            //1. collect all the lits that needs to be true for clauses
            for (int i=0; i< clauses.size(); ++i)
            {
                if (clauses[i] == null || clauses[i].type == ClType.CONFLICT) //??? is this correct, do we need to satisfy the temp clauses?
                    continue;
                bool cls_sat = false;
                foreach (int lit in clause(i).literals)
                {
                    if (lit_value(lit) == 1)
                    {
                        variable(VID(lit)).set_flag(f);
                        cls_sat = true;
                        break;
                    }
                }
                if (cls_sat == false)
                {
                    fatal ("A clause does not contain true lit even though formula is SAT");
                }
            }
            //now traverse the tree in reverse topological order
            for (int i=variables.size()-1; i > 0 ; --i)
            {
                Variable var = variable(i);
                if (!var.flag(f))
                    continue;
                sharp_assert (var_value(i) != UNKNOWN);
                switch (var.type)
                {
                    case NodeType.AND:
                        if (var_value(i) == 1) //both inputs must be true
                        {
                            sharp_assert (lit_value(var.left) == 1);
                            sharp_assert (lit_value(var.right) == 1);
                            variable(VID(var.left)).set_flag(f);
                            variable(VID(var.right)).set_flag(f);
                        }
                        else
                        {
                            sharp_assert (var_value(i) == 0);
                            if (lit_value(var.left) == 0)
                                variable(VID(var.left)).set_flag(f);
                            else if (lit_value(var.right) == 0)
                                variable(VID(var.right)).set_flag(f);
                            else
                                fatal ("Variable unjustifiable");
                        }
                        break;
                    case NodeType.XOR:
                        variable(VID(var.left)).set_flag(f);
                        variable(VID(var.right)).set_flag(f);
                        break;
                    default:
                        break;
                }
            }
            IntVector cube = new IntVector(16);
            for (int i=0; i< variables.size(); ++i)
            {
                if (variable(i).flag(f))
                {
                    sharp_assert (var_value(i) != UNKNOWN);
                    cube.push_back (i + i + 1 - var_value(i));
                }
            }
            free_flag(f);
            return cube.ToArray();
        }

        private class EnumQuantification
        {
            SharpSATSolver solver;

            IntVector visiting_queue;
            IntVector blocking_lits;
            int bound_flag;
            int visited_flag;
            int occ_flag ;
            int sign_flag ;
            IntVector involved_signals;
            Hashtable blocking_clauses;

            ObjVector cls_occurrence;

            Variable variable(int vid) { return solver.variable(vid); }
            Variable node(int lit) { return solver.node(lit); }
            Clause clause (int id) { return solver.clause(id); }
            int band (int a, int b) { return solver.band(a, b); }
            int bor (int a, int b) { return solver.bor(a, b); }
            int alloc_flag () { return solver.alloc_flag(); }

            [Microsoft.Contracts.NotDelayed]
            public EnumQuantification(SharpSATSolver sol)
            {
                solver = sol;
                visiting_queue  = new IntVector(128);
                blocking_lits   = new IntVector(64);
                involved_signals= new IntVector(128);
                cls_occurrence  = new ObjVector(128);
                blocking_clauses= new Hashtable();
                bound_flag      = solver.alloc_flag();
                visited_flag    = solver.alloc_flag();
                occ_flag        = solver.alloc_flag();
                sign_flag       = solver.alloc_flag();
            }

            void finalize_quantification ()
            {
                solver.free_flag (visited_flag);
                solver.free_flag(bound_flag);
                solver.free_flag(occ_flag);
                solver.free_flag(sign_flag);
            }

            void init_quantification (int s, int [] bounded, bool block_with_pi_only)
            {

                involved_signals = solver.find_transitive_fanins(s);
                if (block_with_pi_only)
                {
                    foreach (int sig in bounded)
                    {
                        sharp_assert (node(sig).is_pi());
                        node(sig).set_flag(bound_flag);
                    }
                    for (int i=0; i< involved_signals.size(); ++i)
                    {
                        Variable var = node(involved_signals[i]);
                        if (!var.is_pi())
                            var.set_flag(bound_flag);
                    }
                }
                else
                {
                    foreach (int sig in bounded)
                    {
                        sharp_assert (node(sig).is_pi());
                        solver.mark_transitive_fanouts(sig,bound_flag);
                    }
                }

                cls_occurrence = new ObjVector(solver.variables.size());
                for (int i = 0; i< involved_signals.size(); ++i)
                    cls_occurrence[VID(involved_signals[i])] = new IntVector(4);
            }

            int build_balanced_or (int [] signals, int start, int end)
            {
                if (signals.Length == 0)
                    return solver.zero();
                else if (start == end)
                    return signals[start];
                else
                {
                    int middle = (end - start) /2 + start;
                    int s1 = build_balanced_or(signals, start, middle);
                    int s2 = build_balanced_or(signals, middle + 1, end);
                    return bor (s1, s2);
                }
            }

            int build_balanced_and (int [] signals, int start, int end)
            {
                if (signals.Length == 0)
                    return solver.one();
                else if (start == end)
                    return signals[start];
                else
                {
                    int middle = (end - start) /2 + start;
                    int s1 = build_balanced_and(signals, start, middle);
                    int s2 = build_balanced_and(signals, middle + 1, end);
                    return band (s1, s2);
                }
            }

            int build_struct_balanced (IntVector cls_ids)
            {
                int [] cl_sigs = new int[cls_ids.size()];
                for (int i=0; i< cls_ids.size(); ++i)
                {
                    int [] lits = clause(cls_ids[i]).literals;
                    cl_sigs[i] = build_balanced_or ( lits, 0, lits.Length - 1);
                }
                int result = build_balanced_and(cl_sigs, 0, cl_sigs.Length - 1);
                return result;
            }


            int build_struct (IntVector cls)
            {
                //return build_struct_simple(cls);
                return build_struct_balanced (cls);
            }

            int build_struct_simple(IntVector cls)
            {
                int sig = solver.one();
                for (int i=0; i< cls.size(); ++i)
                {
                    int s = solver.zero();
                    foreach (int lit in clause(cls[i]).literals)
                        s = bor(s, lit);
                    sig = band(sig, s);
                }
                return sig;
            }

            static IntVector intersect (IntVector a, IntVector b)
            {
                IntVector result = new IntVector(4);
                for (int i=0, j=0; i< a.size() && j < b.size(); )
                {
                    if (a[i] < b[j])
                        ++ i;
                    else if (a [i] > b[j])
                        ++ j;
                    else
                    {
                        result.push_back (a[i]);
                        ++i;
                        ++j;
                    }
                }
                return result;
            }

            IntVector resolve (IntVector a, int [] b)
            {
                IntVector result = new IntVector(b.Length - 1);
                sharp_assert (a.size() == b.Length);
                foreach (int lit in b)
                {
                    Variable var = variable (VID(lit));
                    var.set_flag (occ_flag);
                    if (IS_NEGATED(lit))
                        var.set_flag (sign_flag);
                }
                for (int i=0; i< a.size(); ++i)
                {
                    int lit = a[i];
                    Variable var = variable (VID(lit));
                    sharp_assert (var.flag(occ_flag));
                    if (var.flag(sign_flag) == IS_NEGATED(lit))
                        result.push_back(lit);
                    var.clear_flag (occ_flag);
                    var.clear_flag (sign_flag);
                }
                if (result.size() == a.size() - 1)
                    return result;
                else
                    return null;
            }

            bool subsume (IntVector a, int [] b)
            {
                sharp_assert (a.size() < b.Length);
                for (int i=0; i< a.size(); ++i)
                {
                    int lit = a[i];
                    Variable var = variable (VID(lit));
                    var.set_flag (occ_flag);
                    if (IS_NEGATED(lit))
                        var.set_flag (sign_flag);
                }
                int same_lit = 0;
                int same_var = 0;
                foreach (int lit in b)
                {
                    Variable var = variable (VID(lit));
                    if (var.flag(occ_flag))
                    {
                        same_var ++;
                        if (IS_NEGATED(lit) == var.flag(sign_flag))
                            same_lit ++;
                        var.clear_flag (occ_flag);
                        var.clear_flag (sign_flag);
                    }
                }
                sharp_assert (same_var == a.size());
                return (same_lit == same_var);
            }

            void remove_blocking (int cl_id)
            {
                blocking_clauses.Remove(cl_id);
                foreach (int lit in solver.clause(cl_id).literals)
                {
                    int vid = VID(lit);
                    IntVector occur = (IntVector)cls_occurrence[vid];
                    int i;
                    for (i=0; occur[i] != cl_id; ++i);
                    for ( i = i + 1; i < occur.size(); ++i )
                        occur[i-1] = occur[i];
                    occur.pop_back();
                }

                Clause cl = solver.clause(cl_id);
                if (cl.num_lits> 1)
                    solver.remove_cl_from_reasoning (cl_id);


                for (int i=0; i< cl.num_lits; ++i)
                    solver.decr_lits_count(cl.literal(i));

                ++ solver.stats.num_deleted_clauses;
                solver.stats.num_deleted_literals += cl.num_lits;
                solver.clauses[cl_id] = null;
                solver.free_clauses.push_back(cl_id);
            }

            void add_blocking (int gid)
            {
                int cl_id = solver.add_blocking_clause(blocking_lits.ToArray(), gid);
                for (int i=0; i< blocking_lits.size(); ++i)
                {
                    int lit = blocking_lits[i];
                    IntVector occ_array = (IntVector) cls_occurrence[VID(lit)];
                    occ_array.push_back(cl_id);
                    //bubble down
                    for (int j=occ_array.size()-2; j >= 0; --j)
                    {
                        if (occ_array[j] > cl_id)
                        {
                            occ_array[j+1] = occ_array[j];
                            occ_array[j] = cl_id;
                        }
                        else
                            break;
                    }
                }
                blocking_clauses.Add(cl_id, null);
            }

            int n_tab = 1;
            void tab () { for (int i=0; i< n_tab; ++i) Console.Write("  "); }

            void dump_lits (int [] a)
            {
                IntVector cp = new IntVector (4);
                foreach (int lit in a)
                    cp.push_back(lit);
                cp.sort();
                for (int i=0; i< cp.size(); ++i)
                    Console.Write ("{0}{1}", IS_NEGATED(cp[i])?" -":" +", VID(cp[i]));
                Console.WriteLine("");
            }

            void dump_lits (IntVector a)
            {
                IntVector cp = new IntVector (4);
                for (int i=0; i< a.size(); ++i)
                    cp.push_back(a[i]);
                cp.sort();
                for (int i=0; i< cp.size(); ++i)
                    Console.Write ("{0}{1}", IS_NEGATED(cp[i])?" -":" +", VID(cp[i]));
                Console.WriteLine("");
            }

            void try_reduce()
            {
                if (blocking_lits.size() == 0)
                    return;
//              tab(); System.Console.Write ("Try to Reduce ");dump_lits(blocking_lit); ++ n_tab;

                IntVector common = new IntVector((IntVector) cls_occurrence[VID(blocking_lits[0])]);
                for (int i=1; i< blocking_lits.size(); ++i)
                {
                    int vid = VID(blocking_lits[i]);
                    IntVector next = (IntVector) cls_occurrence[vid];
                    common = intersect (common, next);
                }
                bool resolved = false;
                for (int i=0; i< common.size(); ++i)
                {
                    int cl_id = common[i];
                    int [] lits = solver.clause(cl_id).literals;
                    sharp_assert (lits.Length >= blocking_lits.size());
                    if (lits.Length > blocking_lits.size())
                    {
                        if (subsume (blocking_lits, lits))
                        {
//                          tab();Console.Write ("Subsume CL:{0} ->", cl_id); dump_lits(lits);
                            remove_blocking (cl_id);
                        }
                    }
                    else
                    {
                        IntVector r = resolve (blocking_lits, lits);
                        if (r != null)
                        {
//                          tab();Console.Write ("Resolve CL:{0} ->", cl_id); dump_lits(lits);
                            resolved = true;
                            blocking_lits = r;
                            remove_blocking (cl_id);
                            break;
                        }
                    }
                }
                if (resolved)
                    try_reduce();
                //-- n_tab;
            }

            bool find_blocking_cls (int s)
            {
                blocking_lits.clear();
                visiting_queue.clear();
                SATStatus status = solver.solve();
                if (status == SATStatus.UNSATISFIABLE)
                    return false;
                sharp_assert (status == SATStatus.SATISFIABLE);
                int vid = VID(s);
                visiting_queue.push_back( vid );
                variable(vid).set_flag(visited_flag);
                for (int i=0; i< visiting_queue.size(); ++i)
                {
                    vid = visiting_queue[i];
                    Variable var = variable(vid);
                    if (!var.flag(bound_flag)) //so it doesn't depends on bounded vars.
                        blocking_lits.push_back(vid + vid + solver.var_value(vid));
                    else
                    {
                        if (var.type == NodeType.PI)
                            continue;
                        if (var.type == NodeType.AND && solver.var_value(vid) == 0)
                        {
                            int l;
                            if (solver.lit_value(var.left) != 0)
                                l = var.right;
                            else if (solver.lit_value(var.right) != 0)
                                l = var.left;
                            else
                            { // both inputs are 0
                                if (node(var.left).flag(visited_flag))
                                    l = var.left;
                                else if (node(var.right).flag(visited_flag))
                                    l = var.right;
                                else //neither has been visited
                                    l = var.left;
                            }
                            if (!node(l).flag(visited_flag))
                            {
                                node(l).set_flag(visited_flag);
                                visiting_queue.push_back(VID(l));
                            }
                        }
                        else
                        {
                            sharp_assert (var.type == NodeType.XOR || var.type == NodeType.AND);
                            int l = var.left;
                            if (!node(l).flag(visited_flag))
                            {
                                node(l).set_flag(visited_flag);
                                visiting_queue.push_back(VID(l));
                            }
                            l = var.right;
                            if (!node(l).flag(visited_flag))
                            {
                                node(l).set_flag(visited_flag);
                                visiting_queue.push_back(VID(l));
                            }
                        }
                    }
                }
                for (int i=0; i< visiting_queue.size(); ++i)
                    variable(visiting_queue[i]).clear_flag(visited_flag);
                return true;
            }

            public int enum_exist_quantify (int s, int [] bounded, bool block_with_pi_only)
            {
                int c = solver.constraint(s);
                int block_gid = solver.alloc_gid();
                init_quantification(s, bounded, block_with_pi_only);
                bool empty_cl = false;
                int total_solution = 0;
                //int total_clauses;
                while (find_blocking_cls(s))
                {
                    //solver.restart();
                    ++ total_solution;
                    try_reduce();
                    if (blocking_lits.size() == 0)
                    { //blocking clause size 0, i.e. no literal
                        empty_cl = true;
                        break;
                    }
                    else
                        add_blocking(block_gid);
                }
                solver.release_constraint(c);
                int r;
                if (empty_cl)
                    r = solver.zero();
                else if (blocking_clauses.Count == 0)
                    r = solver.one();
                else
                {
                    IntVector blocking = new IntVector(4);
                    foreach (object k in blocking_clauses.Keys)
                        blocking.push_back((int)k);
                    //total_clauses = blocking.size();
                    r = build_struct (blocking);
                }
                solver.delete_clause_group(block_gid);
                finalize_quantification();
//              Console.WriteLine ("Enum {0} solutions, total blocking clauses {1}", total_solution, total_clauses);
                return solver.bnot(r);
            }

            public int enum_exist_quantify_dumb (int s, int [] bounded, bool with_pi_only)
            {
                if (node(s).type == NodeType.CONSTANT)
                    return s;

                int c = solver.constraint(s);
                int block_gid = solver.alloc_gid();
                init_quantification(s, bounded, with_pi_only);
                bool empty_cl = false;
                IntVector blocking = new IntVector(16);
                while (find_blocking_cls(s))
                {
                    if (blocking_lits.size() == 0)
                    { //blocking clause size 0, i.e. no literal
                        empty_cl = true;
                        break;
                    }
                    else
                    {
                        int cl_id = solver.add_blocking_clause(blocking_lits.ToArray(), block_gid);
                        blocking.push_back(cl_id);
                    }
                }
                solver.release_constraint(c);
                int r;
                if (empty_cl)
                    r = solver.zero();
                else if (blocking.size() == 0)
                    r = solver.one();
                else
                    r = build_struct (blocking);
                solver.delete_clause_group(block_gid);
                finalize_quantification();
                return solver.bnot(r);
            }
        }

        public int enum_exist_quantify_smart (int s, int [] bounded)
        {
            if (node(s).type == NodeType.CONSTANT)
                return s;

            EnumQuantification quant = new EnumQuantification(this);
            int r = quant.enum_exist_quantify (s, bounded, false);
            return r;
        }

        public int enum_exist_quantify_dumb (int s, int [] bounded)
        {
            EnumQuantification quant = new EnumQuantification(this);
            int r = quant.enum_exist_quantify_dumb (s, bounded, false);
            return r;
        }

        public int expand_exist_quantify (int s, int [] bounded)
        {
            int flag = alloc_flag();
            mark_transitive_fanins(s, flag);
            int result = s;
            foreach (int input in bounded)
            {
                sharp_assert (node(input).is_pi());
                int [] orig = { input };
                int [] replace = { zero() };
                int cofactor_i = compose(result, orig, replace);
                replace = new int [] { one () };
                int cofactor_ip = compose(result, orig, replace);
                result = bor (cofactor_i, cofactor_ip);
            }
            free_flag(flag);
            return result;
        }

        #region NODE_CONSISTENCY_LOOKUP
        void make_node_consistent (int s)
        {
            Variable n = node(s);
            if (!is_reasoning(n))
                return;

            int output = NON_NEGATED(s);
            int input0 = n.left;
            int input1 = n.right;

            int signature;
            signature = lit_value(output);
            signature = (signature << 2);
            signature |= lit_value(input0);
            signature = (signature << 2);
            signature |= lit_value(input1);

            if (n.type == NodeType.AND)
            {
                switch(signature)
                {
                    case 34:    //100010     : x0x
                    case 35:    //100011     : x0x
                    case 50:    //110010     : x0x
                    case 51:    //110011     : x0x
                    case 40:    //101000     : xx0
                    case 44:    //101100     : xx0
                    case 56:    //111000     : xx0
                    case 60:    //111100     : xx0
                    case 36:    //100100     : x10
                    case 52:    //110100     : x10
                    case 33:    //100001     : x01
                    case 49:    //110001     : x01
                    case 32:    //100000     : x00
                    case 48:    //110000     : x00
                        queue_implication(output^1, VID (output), ImpType.NODE);
                        break;
                    case 37:    //100101     : x11
                    case 53:    //110101     : x11
                        queue_implication(output, VID (output), ImpType.NODE);
                        break;
                    case 6:     //000110     : 01x
                    case 7:     //000111     : 01x
                        queue_implication(input1^1, VID (output), ImpType.NODE);
                        break;
                    case 13:    //001101     : 0x1
                    case 9:     //001001     : 0x1
                        queue_implication(input0^1, VID (output), ImpType.NODE);
                        break;
                    case 22:    //010110     : 11x
                    case 23:    //010111     : 11x
                        queue_implication(input1, VID (output), ImpType.NODE);
                        break;
                    case 29:    //011101     : 1x1
                    case 25:    //011001     : 1x1
                        queue_implication(input0, VID (output), ImpType.NODE);
                        break;
                    case 30:    //011110     : 1xx
                    case 31:    //011111     : 1xx
                    case 26:    //011010     : 1xx
                    case 27:    //011011     : 1xx
                        queue_implication(input0, VID (output), ImpType.NODE);
                        queue_implication(input1, VID (output), ImpType.NODE);
                        break;
                    case 18:    //010010     : 10x
                    case 19:    //010011     : 10x
                    case 24:    //011000     : 1x0
                    case 28:    //011100     : 1x0

                    case 17:    //010001     : 101
                    case 20:    //010100     : 110
                    case 16:    //010000     : 100
                    case 5:     //000101     : 011
                        queue_conflict(VID (output), ImpType.NODE);
                        break;
                    case 42:    //101010     : xxx
                    case 43:    //101011     : xxx
                    case 46:    //101110     : xxx
                    case 47:    //101111     : xxx

                    case 58:    //111010     : xxx
                    case 59:    //111011     : xxx
                    case 62:    //111110     : xxx
                    case 63:    //111111     : xxx
                        break;
                    case 41:    //101001     : xx1
                    case 45:    //101101     : xx1
                    case 57:    //111001     : xx1
                    case 61:    //111101     : xx1

                    case 38:    //100110     : x1x
                    case 39:    //100111     : x1x
                    case 54:    //110110     : x1x
                    case 55:    //110111     : x1x

                    case 2:     //000010     : 00x
                    case 3:     //000011     : 00x
                    case 8:     //001000     : 0x0
                    case 12:    //001100     : 0x0

                    case 10:    //001010     : 0xx
                    case 11:    //001011     : 0xx
                    case 14:    //001110     : 0xx
                    case 15:    //001111     : 0xx

                    case 21:    //010101     : 111
                    case 4:     //000100     : 010
                    case 1:     //000001     : 001
                    case 0:     //000000     : 000
                        break;
                }
            }
            else
            {
                sharp_assert (n.type == NodeType.XOR);
                switch(signature)
                {
                    case 32:    //100000     : x00
                    case 48:    //110000     : x00
                    case 37:    //100101     : x11
                    case 53:    //110101     : x11
                        queue_implication(output^1, VID (output), ImpType.NODE);
                        break;
                    case 33:    //100001     : x01
                    case 49:    //110001     : x01
                    case 36:    //100100     : x10
                    case 52:    //110100     : x10
                        queue_implication(output, VID (output), ImpType.NODE);
                        break;
                    case 3:     //000011     : 00x
                    case 2:     //000010     : 00x
                    case 23:    //010111     : 11x
                    case 22:    //010110     : 11x
                        queue_implication(input1^1, VID (output), ImpType.NODE);
                        break;
                    case 7:     //000111     : 01x
                    case 6:     //000110     : 01x
                    case 19:    //010011     : 10x
                    case 18:    //010010     : 10x
                        queue_implication(input1, VID (output), ImpType.NODE);
                        break;
                    case 13:    //001101     : 0x1
                    case 9:     //001001     : 0x1
                    case 28:    //011100     : 1x0
                    case 24:    //011000     : 1x0
                        queue_implication(input0, VID (output), ImpType.NODE);
                        break;
                    case 12:    //001100     : 0x0
                    case 8:     //001000     : 0x0
                    case 29:    //011101     : 1x1
                    case 25:    //011001     : 1x1
                        queue_implication(input0^1, VID (output), ImpType.NODE);
                        break;
                    case 1:     //000001     : 001
                    case 4:     //000100     : 010
                    case 16:    //010000     : 100
                    case 21:    //010101     : 111
                        queue_conflict(VID (output), ImpType.NODE);
                        break;
                    case 42:    //101010     : xxx
                    case 43:    //101011     : xxx
                    case 46:    //101110     : xxx
                    case 47:    //101111     : xxx
                    case 58:    //111010     : xxx
                    case 59:    //111011     : xxx
                    case 62:    //111110     : xxx
                    case 63:    //111111     : xxx
                        break;
                    case 41:    //101001     : xx1
                    case 45:    //101101     : xx1
                    case 57:    //111001     : xx1
                    case 61:    //111101     : xx1

                    case 40:    //101000     : xx0
                    case 44:    //101100     : xx0
                    case 56:    //111000     : xx0
                    case 60:    //111100     : xx0

                    case 38:    //100110     : x1x
                    case 39:    //100111     : x1x
                    case 54:    //110110     : x1x
                    case 55:    //110111     : x1x

                    case 34:    //100010     : x0x
                    case 35:    //100011     : x0x
                    case 50:    //110010     : x0x
                    case 51:    //110011     : x0x

                    case 10:    //001010     : 0xx
                    case 11:    //001011     : 0xx
                    case 14:    //001110     : 0xx
                    case 15:    //001111     : 0xx

                    case 26:    //011010     : 1xx
                    case 27:    //011011     : 1xx
                    case 30:    //011110     : 1xx
                    case 31:    //011111     : 1xx

                    case 20:    //010100     : 110
                    case 17:    //010001     : 101
                    case 5:     //000101     : 011
                    case 0:     //000000     : 000
                        break;
                }
            }
        }
        #endregion
        #region CANONICAL_TABLE_LOOKUP
        private static readonly int [] lookup_table_3_inputs =
            new int[320] {
                             /* 0 */  0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
                             /* 10 */  10, 11, 12, 13, 14, 15, 16, 17, 17, 16,
                             /* 20 */  17, 16, 16, 17, 18, 19, 19, 18, 19, 18,
                             /* 30 */  18, 19, 20, 21, 22, 23, 24, 25, 26, 27,
                             /* 40 */  24, 25, 26, 27, 20, 21, 22, 23, 28, 29,
                             /* 50 */  29, 28, 29, 28, 28, 29, 29, 28, 28, 29,
                             /* 60 */  28, 29, 29, 28, 30, 31, 32, 32, 31, 30,
                             /* 70 */  33, 33, 32, 32, 34, 35, 36, 36, 35, 34,
                             /* 80 */  31, 30, 30, 31, 30, 31, 31, 30, 34, 35,
                             /* 90 */  35, 34, 35, 34, 34, 35, 31, 30, 37, 38,
                             /* 100 */  39, 40, 35, 34, 39, 40, 35, 34, 31, 30,
                             /* 110 */  37, 38, 41, 42, 42, 41, 42, 41, 41, 42,
                             /* 120 */  42, 41, 41, 42, 41, 42, 42, 41, 43, 44,
                             /* 130 */  45, 46, 4, 5, 6, 7, 47, 48, 49, 50,
                             /* 140 */  12, 13, 14, 15, 16, 17, 17, 16, 17, 16,
                             /* 150 */  16, 17, 18, 19, 19, 18, 19, 18, 18, 19,
                             /* 160 */  20, 21, 22, 23, 24, 25, 26, 27, 24, 25,
                             /* 170 */  26, 27, 20, 21, 22, 23, 51, 52, 52, 51,
                             /* 180 */  52, 51, 51, 52, 52, 51, 51, 52, 51, 52,
                             /* 190 */  52, 51, 30, 32, 34, 32, 34, 41, 30, 41,
                             /* 200 */  32, 31, 32, 35, 42, 35, 42, 31, 34, 30,
                             /* 210 */  30, 34, 30, 34, 34, 30, 31, 35, 35, 31,
                             /* 220 */  35, 31, 31, 35, 34, 37, 30, 39, 38, 35,
                             /* 230 */  40, 31, 38, 35, 40, 31, 34, 37, 30, 39,
                             /* 240 */  33, 36, 36, 33, 36, 33, 33, 36, 36, 33,
                             /* 250 */  33, 36, 33, 36, 36, 33, 53, 54, 55, 56,
                             /* 260 */  4, 5, 6, 7, 57, 58, 59, 60, 12, 13,
                             /* 270 */  14, 15, 16, 17, 17, 16, 17, 16, 16, 17,
                             /* 280 */  18, 19, 19, 18, 19, 18, 18, 19, 20, 21,
                             /* 290 */  22, 23, 24, 25, 26, 27, 24, 25, 26, 27,
                             /* 300 */  20, 21, 22, 23, 61, 62, 62, 61, 62, 61,
                             /* 310 */  61, 62, 62, 61, 61, 62, 61, 62, 62, 61  };
        private static readonly int [] lookup_table_4_inputs =
            new int [4096] {
                               /* 0 */  0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
                               /* 10 */  10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
                               /* 20 */  20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
                               /* 30 */  30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
                               /* 40 */  40, 41, 42, 43, 44, 45, 46, 47, 48, 49,
                               /* 50 */  50, 51, 52, 53, 54, 55, 56, 57, 58, 59,
                               /* 60 */  60, 61, 62, 63, 64, 65, 65, 64, 66, 67,
                               /* 70 */  67, 66, 68, 69, 69, 68, 70, 71, 71, 70,
                               /* 80 */  65, 64, 64, 65, 67, 66, 66, 67, 69, 68,
                               /* 90 */  68, 69, 71, 70, 70, 71, 72, 73, 73, 72,
                               /* 100 */  74, 75, 75, 74, 76, 77, 77, 76, 78, 79,
                               /* 110 */  79, 78, 73, 72, 72, 73, 75, 74, 74, 75,
                               /* 120 */  77, 76, 76, 77, 79, 78, 78, 79, 80, 81,
                               /* 130 */  82, 83, 84, 85, 86, 87, 84, 85, 86, 87,
                               /* 140 */  80, 81, 82, 83, 88, 89, 90, 91, 92, 93,
                               /* 150 */  94, 95, 92, 93, 94, 95, 88, 89, 90, 91,
                               /* 160 */  84, 85, 86, 87, 80, 81, 82, 83, 80, 81,
                               /* 170 */  82, 83, 84, 85, 86, 87, 92, 93, 94, 95,
                               /* 180 */  88, 89, 90, 91, 88, 89, 90, 91, 92, 93,
                               /* 190 */  94, 95, 96, 97, 97, 96, 98, 99, 99, 98,
                               /* 200 */  98, 99, 99, 98, 96, 97, 97, 96, 97, 96,
                               /* 210 */  96, 97, 99, 98, 98, 99, 99, 98, 98, 99,
                               /* 220 */  97, 96, 96, 97, 98, 99, 99, 98, 96, 97,
                               /* 230 */  97, 96, 96, 97, 97, 96, 98, 99, 99, 98,
                               /* 240 */  99, 98, 98, 99, 97, 96, 96, 97, 97, 96,
                               /* 250 */  96, 97, 99, 98, 98, 99, 100, 101, 102, 103,
                               /* 260 */  104, 105, 106, 107, 108, 109, 110, 111, 112, 113,
                               /* 270 */  114, 115, 116, 117, 118, 119, 120, 121, 122, 123,
                               /* 280 */  124, 125, 126, 127, 128, 129, 130, 131, 116, 117,
                               /* 290 */  118, 119, 120, 121, 122, 123, 124, 125, 126, 127,
                               /* 300 */  128, 129, 130, 131, 100, 101, 102, 103, 104, 105,
                               /* 310 */  106, 107, 108, 109, 110, 111, 112, 113, 114, 115,
                               /* 320 */  132, 133, 133, 132, 134, 135, 135, 134, 136, 137,
                               /* 330 */  137, 136, 138, 139, 139, 138, 133, 132, 132, 133,
                               /* 340 */  135, 134, 134, 135, 137, 136, 136, 137, 139, 138,
                               /* 350 */  138, 139, 133, 132, 132, 133, 135, 134, 134, 135,
                               /* 360 */  137, 136, 136, 137, 139, 138, 138, 139, 132, 133,
                               /* 370 */  133, 132, 134, 135, 135, 134, 136, 137, 137, 136,
                               /* 380 */  138, 139, 139, 138, 140, 141, 142, 143, 144, 145,
                               /* 390 */  146, 147, 144, 145, 146, 147, 140, 141, 142, 143,
                               /* 400 */  144, 145, 146, 147, 140, 141, 142, 143, 140, 141,
                               /* 410 */  142, 143, 144, 145, 146, 147, 144, 145, 146, 147,
                               /* 420 */  140, 141, 142, 143, 140, 141, 142, 143, 144, 145,
                               /* 430 */  146, 147, 140, 141, 142, 143, 144, 145, 146, 147,
                               /* 440 */  144, 145, 146, 147, 140, 141, 142, 143, 148, 149,
                               /* 450 */  149, 148, 149, 148, 148, 149, 149, 148, 148, 149,
                               /* 460 */  148, 149, 149, 148, 149, 148, 148, 149, 148, 149,
                               /* 470 */  149, 148, 148, 149, 149, 148, 149, 148, 148, 149,
                               /* 480 */  149, 148, 148, 149, 148, 149, 149, 148, 148, 149,
                               /* 490 */  149, 148, 149, 148, 148, 149, 148, 149, 149, 148,
                               /* 500 */  149, 148, 148, 149, 149, 148, 148, 149, 148, 149,
                               /* 510 */  149, 148, 150, 151, 152, 152, 152, 152, 153, 154,
                               /* 520 */  155, 156, 152, 152, 152, 152, 157, 158, 151, 150,
                               /* 530 */  159, 159, 160, 160, 154, 153, 156, 155, 161, 161,
                               /* 540 */  162, 162, 158, 157, 155, 156, 163, 164, 165, 166,
                               /* 550 */  157, 158, 150, 151, 163, 164, 165, 166, 153, 154,
                               /* 560 */  167, 168, 169, 170, 171, 172, 173, 174, 175, 176,
                               /* 570 */  177, 178, 179, 180, 181, 182, 151, 150, 150, 151,
                               /* 580 */  153, 154, 154, 153, 156, 155, 155, 156, 157, 158,
                               /* 590 */  158, 157, 150, 151, 151, 150, 154, 153, 153, 154,
                               /* 600 */  155, 156, 156, 155, 158, 157, 157, 158, 183, 184,
                               /* 610 */  184, 183, 185, 186, 186, 185, 187, 188, 188, 187,
                               /* 620 */  189, 190, 190, 189, 184, 183, 183, 184, 186, 185,
                               /* 630 */  185, 186, 188, 187, 187, 188, 190, 189, 189, 190,
                               /* 640 */  155, 156, 153, 154, 150, 151, 157, 158, 150, 151,
                               /* 650 */  157, 158, 155, 156, 153, 154, 191, 192, 193, 194,
                               /* 660 */  195, 196, 197, 198, 195, 196, 197, 198, 191, 192,
                               /* 670 */  193, 194, 150, 151, 157, 158, 155, 156, 153, 154,
                               /* 680 */  155, 156, 153, 154, 150, 151, 157, 158, 195, 196,
                               /* 690 */  197, 198, 191, 192, 193, 194, 191, 192, 193, 194,
                               /* 700 */  195, 196, 197, 198, 199, 200, 200, 199, 201, 202,
                               /* 710 */  202, 201, 201, 202, 202, 201, 199, 200, 200, 199,
                               /* 720 */  200, 199, 199, 200, 202, 201, 201, 202, 202, 201,
                               /* 730 */  201, 202, 200, 199, 199, 200, 201, 202, 202, 201,
                               /* 740 */  199, 200, 200, 199, 199, 200, 200, 199, 201, 202,
                               /* 750 */  202, 201, 202, 201, 201, 202, 200, 199, 199, 200,
                               /* 760 */  200, 199, 199, 200, 202, 201, 201, 202, 203, 204,
                               /* 770 */  178, 177, 180, 179, 205, 206, 204, 203, 170, 169,
                               /* 780 */  172, 171, 206, 205, 207, 208, 169, 170, 171, 172,
                               /* 790 */  209, 210, 208, 207, 177, 178, 179, 180, 210, 209,
                               /* 800 */  207, 208, 169, 170, 171, 172, 209, 210, 208, 207,
                               /* 810 */  177, 178, 179, 180, 210, 209, 203, 204, 178, 177,
                               /* 820 */  180, 179, 205, 206, 204, 203, 170, 169, 172, 171,
                               /* 830 */  206, 205, 211, 212, 212, 211, 213, 214, 214, 213,
                               /* 840 */  215, 216, 216, 215, 217, 218, 218, 217, 212, 211,
                               /* 850 */  211, 212, 214, 213, 213, 214, 216, 215, 215, 216,
                               /* 860 */  218, 217, 217, 218, 212, 211, 211, 212, 214, 213,
                               /* 870 */  213, 214, 216, 215, 215, 216, 218, 217, 217, 218,
                               /* 880 */  211, 212, 212, 211, 213, 214, 214, 213, 215, 216,
                               /* 890 */  216, 215, 217, 218, 218, 217, 219, 220, 221, 222,
                               /* 900 */  223, 224, 225, 226, 223, 224, 225, 226, 219, 220,
                               /* 910 */  221, 222, 223, 224, 225, 226, 219, 220, 221, 222,
                               /* 920 */  219, 220, 221, 222, 223, 224, 225, 226, 223, 224,
                               /* 930 */  225, 226, 219, 220, 221, 222, 219, 220, 221, 222,
                               /* 940 */  223, 224, 225, 226, 219, 220, 221, 222, 223, 224,
                               /* 950 */  225, 226, 223, 224, 225, 226, 219, 220, 221, 222,
                               /* 960 */  227, 228, 228, 227, 228, 227, 227, 228, 228, 227,
                               /* 970 */  227, 228, 227, 228, 228, 227, 228, 227, 227, 228,
                               /* 980 */  227, 228, 228, 227, 227, 228, 228, 227, 228, 227,
                               /* 990 */  227, 228, 228, 227, 227, 228, 227, 228, 228, 227,
                               /* 1000 */  227, 228, 228, 227, 228, 227, 227, 228, 227, 228,
                               /* 1010 */  228, 227, 228, 227, 227, 228, 228, 227, 227, 228,
                               /* 1020 */  227, 228, 228, 227, 229, 230, 231, 232, 233, 234,
                               /* 1030 */  235, 236, 237, 238, 239, 240, 241, 242, 243, 244,
                               /* 1040 */  16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
                               /* 1050 */  26, 27, 28, 29, 30, 31, 32, 33, 34, 35,
                               /* 1060 */  36, 37, 38, 39, 40, 41, 42, 43, 44, 45,
                               /* 1070 */  46, 47, 48, 49, 50, 51, 52, 53, 54, 55,
                               /* 1080 */  56, 57, 58, 59, 60, 61, 62, 63, 64, 65,
                               /* 1090 */  65, 64, 66, 67, 67, 66, 68, 69, 69, 68,
                               /* 1100 */  70, 71, 71, 70, 65, 64, 64, 65, 67, 66,
                               /* 1110 */  66, 67, 69, 68, 68, 69, 71, 70, 70, 71,
                               /* 1120 */  72, 73, 73, 72, 74, 75, 75, 74, 76, 77,
                               /* 1130 */  77, 76, 78, 79, 79, 78, 73, 72, 72, 73,
                               /* 1140 */  75, 74, 74, 75, 77, 76, 76, 77, 79, 78,
                               /* 1150 */  78, 79, 80, 81, 82, 83, 84, 85, 86, 87,
                               /* 1160 */  84, 85, 86, 87, 80, 81, 82, 83, 88, 89,
                               /* 1170 */  90, 91, 92, 93, 94, 95, 92, 93, 94, 95,
                               /* 1180 */  88, 89, 90, 91, 84, 85, 86, 87, 80, 81,
                               /* 1190 */  82, 83, 80, 81, 82, 83, 84, 85, 86, 87,
                               /* 1200 */  92, 93, 94, 95, 88, 89, 90, 91, 88, 89,
                               /* 1210 */  90, 91, 92, 93, 94, 95, 96, 97, 97, 96,
                               /* 1220 */  98, 99, 99, 98, 98, 99, 99, 98, 96, 97,
                               /* 1230 */  97, 96, 97, 96, 96, 97, 99, 98, 98, 99,
                               /* 1240 */  99, 98, 98, 99, 97, 96, 96, 97, 98, 99,
                               /* 1250 */  99, 98, 96, 97, 97, 96, 96, 97, 97, 96,
                               /* 1260 */  98, 99, 99, 98, 99, 98, 98, 99, 97, 96,
                               /* 1270 */  96, 97, 97, 96, 96, 97, 99, 98, 98, 99,
                               /* 1280 */  100, 101, 102, 103, 104, 105, 106, 107, 108, 109,
                               /* 1290 */  110, 111, 112, 113, 114, 115, 116, 117, 118, 119,
                               /* 1300 */  120, 121, 122, 123, 124, 125, 126, 127, 128, 129,
                               /* 1310 */  130, 131, 116, 117, 118, 119, 120, 121, 122, 123,
                               /* 1320 */  124, 125, 126, 127, 128, 129, 130, 131, 100, 101,
                               /* 1330 */  102, 103, 104, 105, 106, 107, 108, 109, 110, 111,
                               /* 1340 */  112, 113, 114, 115, 132, 133, 133, 132, 134, 135,
                               /* 1350 */  135, 134, 136, 137, 137, 136, 138, 139, 139, 138,
                               /* 1360 */  133, 132, 132, 133, 135, 134, 134, 135, 137, 136,
                               /* 1370 */  136, 137, 139, 138, 138, 139, 133, 132, 132, 133,
                               /* 1380 */  135, 134, 134, 135, 137, 136, 136, 137, 139, 138,
                               /* 1390 */  138, 139, 132, 133, 133, 132, 134, 135, 135, 134,
                               /* 1400 */  136, 137, 137, 136, 138, 139, 139, 138, 140, 141,
                               /* 1410 */  142, 143, 144, 145, 146, 147, 144, 145, 146, 147,
                               /* 1420 */  140, 141, 142, 143, 144, 145, 146, 147, 140, 141,
                               /* 1430 */  142, 143, 140, 141, 142, 143, 144, 145, 146, 147,
                               /* 1440 */  144, 145, 146, 147, 140, 141, 142, 143, 140, 141,
                               /* 1450 */  142, 143, 144, 145, 146, 147, 140, 141, 142, 143,
                               /* 1460 */  144, 145, 146, 147, 144, 145, 146, 147, 140, 141,
                               /* 1470 */  142, 143, 245, 246, 246, 245, 246, 245, 245, 246,
                               /* 1480 */  246, 245, 245, 246, 245, 246, 246, 245, 246, 245,
                               /* 1490 */  245, 246, 245, 246, 246, 245, 245, 246, 246, 245,
                               /* 1500 */  246, 245, 245, 246, 246, 245, 245, 246, 245, 246,
                               /* 1510 */  246, 245, 245, 246, 246, 245, 246, 245, 245, 246,
                               /* 1520 */  245, 246, 246, 245, 246, 245, 245, 246, 246, 245,
                               /* 1530 */  245, 246, 245, 246, 246, 245, 150, 152, 153, 152,
                               /* 1540 */  152, 151, 152, 154, 155, 152, 157, 152, 152, 156,
                               /* 1550 */  152, 158, 153, 247, 150, 247, 248, 154, 248, 151,
                               /* 1560 */  157, 249, 155, 249, 250, 158, 250, 156, 155, 166,
                               /* 1570 */  157, 164, 165, 156, 163, 158, 150, 166, 153, 164,
                               /* 1580 */  165, 151, 163, 154, 251, 252, 253, 254, 255, 256,
                               /* 1590 */  257, 258, 259, 260, 261, 262, 263, 264, 265, 266,
                               /* 1600 */  153, 150, 150, 153, 151, 154, 154, 151, 157, 155,
                               /* 1610 */  155, 157, 156, 158, 158, 156, 150, 153, 153, 150,
                               /* 1620 */  154, 151, 151, 154, 155, 157, 157, 155, 158, 156,
                               /* 1630 */  156, 158, 185, 184, 184, 185, 183, 186, 186, 183,
                               /* 1640 */  189, 188, 188, 189, 187, 190, 190, 187, 184, 185,
                               /* 1650 */  185, 184, 186, 183, 183, 186, 188, 189, 189, 188,
                               /* 1660 */  190, 187, 187, 190, 155, 151, 157, 154, 150, 156,
                               /* 1670 */  153, 158, 150, 156, 153, 158, 155, 151, 157, 154,
                               /* 1680 */  267, 268, 269, 270, 271, 272, 273, 274, 271, 272,
                               /* 1690 */  273, 274, 267, 268, 269, 270, 150, 156, 153, 158,
                               /* 1700 */  155, 151, 157, 154, 155, 151, 157, 154, 150, 156,
                               /* 1710 */  153, 158, 271, 272, 273, 274, 267, 268, 269, 270,
                               /* 1720 */  267, 268, 269, 270, 271, 272, 273, 274, 201, 200,
                               /* 1730 */  200, 201, 199, 202, 202, 199, 199, 202, 202, 199,
                               /* 1740 */  201, 200, 200, 201, 200, 201, 201, 200, 202, 199,
                               /* 1750 */  199, 202, 202, 199, 199, 202, 200, 201, 201, 200,
                               /* 1760 */  199, 202, 202, 199, 201, 200, 200, 201, 201, 200,
                               /* 1770 */  200, 201, 199, 202, 202, 199, 202, 199, 199, 202,
                               /* 1780 */  200, 201, 201, 200, 200, 201, 201, 200, 202, 199,
                               /* 1790 */  199, 202, 275, 262, 276, 260, 265, 277, 263, 278,
                               /* 1800 */  276, 254, 275, 252, 257, 278, 255, 277, 279, 252,
                               /* 1810 */  280, 254, 255, 281, 257, 282, 280, 260, 279, 262,
                               /* 1820 */  263, 282, 265, 281, 279, 252, 280, 254, 255, 281,
                               /* 1830 */  257, 282, 280, 260, 279, 262, 263, 282, 265, 281,
                               /* 1840 */  275, 262, 276, 260, 265, 277, 263, 278, 276, 254,
                               /* 1850 */  275, 252, 257, 278, 255, 277, 283, 284, 284, 283,
                               /* 1860 */  285, 286, 286, 285, 287, 288, 288, 287, 289, 290,
                               /* 1870 */  290, 289, 284, 283, 283, 284, 286, 285, 285, 286,
                               /* 1880 */  288, 287, 287, 288, 290, 289, 289, 290, 284, 283,
                               /* 1890 */  283, 284, 286, 285, 285, 286, 288, 287, 287, 288,
                               /* 1900 */  290, 289, 289, 290, 283, 284, 284, 283, 285, 286,
                               /* 1910 */  286, 285, 287, 288, 288, 287, 289, 290, 290, 289,
                               /* 1920 */  226, 221, 220, 223, 222, 225, 224, 219, 222, 225,
                               /* 1930 */  224, 219, 226, 221, 220, 223, 222, 225, 224, 219,
                               /* 1940 */  226, 221, 220, 223, 226, 221, 220, 223, 222, 225,
                               /* 1950 */  224, 219, 222, 225, 224, 219, 226, 221, 220, 223,
                               /* 1960 */  226, 221, 220, 223, 222, 225, 224, 219, 226, 221,
                               /* 1970 */  220, 223, 222, 225, 224, 219, 222, 225, 224, 219,
                               /* 1980 */  226, 221, 220, 223, 291, 292, 292, 291, 292, 291,
                               /* 1990 */  291, 292, 292, 291, 291, 292, 291, 292, 292, 291,
                               /* 2000 */  292, 291, 291, 292, 291, 292, 292, 291, 291, 292,
                               /* 2010 */  292, 291, 292, 291, 291, 292, 292, 291, 291, 292,
                               /* 2020 */  291, 292, 292, 291, 291, 292, 292, 291, 292, 291,
                               /* 2030 */  291, 292, 291, 292, 292, 291, 292, 291, 291, 292,
                               /* 2040 */  292, 291, 291, 292, 291, 292, 292, 291, 293, 294,
                               /* 2050 */  152, 152, 295, 296, 152, 152, 152, 152, 297, 298,
                               /* 2060 */  152, 152, 299, 300, 294, 293, 301, 301, 296, 295,
                               /* 2070 */  302, 302, 303, 303, 298, 297, 304, 304, 300, 299,
                               /* 2080 */  295, 296, 163, 164, 293, 294, 163, 164, 165, 166,
                               /* 2090 */  299, 300, 165, 166, 297, 298, 305, 306, 307, 308,
                               /* 2100 */  309, 310, 311, 312, 313, 314, 315, 316, 317, 318,
                               /* 2110 */  319, 320, 294, 293, 293, 294, 296, 295, 295, 296,
                               /* 2120 */  297, 298, 298, 297, 299, 300, 300, 299, 293, 294,
                               /* 2130 */  294, 293, 295, 296, 296, 295, 298, 297, 297, 298,
                               /* 2140 */  300, 299, 299, 300, 321, 322, 322, 321, 323, 324,
                               /* 2150 */  324, 323, 325, 326, 326, 325, 327, 328, 328, 327,
                               /* 2160 */  322, 321, 321, 322, 324, 323, 323, 324, 326, 325,
                               /* 2170 */  325, 326, 328, 327, 327, 328, 295, 296, 297, 298,
                               /* 2180 */  293, 294, 299, 300, 293, 294, 299, 300, 295, 296,
                               /* 2190 */  297, 298, 329, 330, 331, 332, 333, 334, 335, 336,
                               /* 2200 */  333, 334, 335, 336, 329, 330, 331, 332, 293, 294,
                               /* 2210 */  299, 300, 295, 296, 297, 298, 295, 296, 297, 298,
                               /* 2220 */  293, 294, 299, 300, 333, 334, 335, 336, 329, 330,
                               /* 2230 */  331, 332, 329, 330, 331, 332, 333, 334, 335, 336,
                               /* 2240 */  337, 338, 338, 337, 339, 340, 340, 339, 339, 340,
                               /* 2250 */  340, 339, 337, 338, 338, 337, 338, 337, 337, 338,
                               /* 2260 */  340, 339, 339, 340, 340, 339, 339, 340, 338, 337,
                               /* 2270 */  337, 338, 339, 340, 340, 339, 337, 338, 338, 337,
                               /* 2280 */  337, 338, 338, 337, 339, 340, 340, 339, 340, 339,
                               /* 2290 */  339, 340, 338, 337, 337, 338, 338, 337, 337, 338,
                               /* 2300 */  340, 339, 339, 340, 341, 342, 312, 311, 342, 341,
                               /* 2310 */  308, 307, 318, 317, 343, 344, 314, 313, 344, 343,
                               /* 2320 */  345, 346, 307, 308, 346, 345, 311, 312, 313, 314,
                               /* 2330 */  347, 348, 317, 318, 348, 347, 345, 346, 307, 308,
                               /* 2340 */  346, 345, 311, 312, 313, 314, 347, 348, 317, 318,
                               /* 2350 */  348, 347, 341, 342, 312, 311, 342, 341, 308, 307,
                               /* 2360 */  318, 317, 343, 344, 314, 313, 344, 343, 349, 350,
                               /* 2370 */  350, 349, 351, 352, 352, 351, 353, 354, 354, 353,
                               /* 2380 */  355, 356, 356, 355, 350, 349, 349, 350, 352, 351,
                               /* 2390 */  351, 352, 354, 353, 353, 354, 356, 355, 355, 356,
                               /* 2400 */  350, 349, 349, 350, 352, 351, 351, 352, 354, 353,
                               /* 2410 */  353, 354, 356, 355, 355, 356, 349, 350, 350, 349,
                               /* 2420 */  351, 352, 352, 351, 353, 354, 354, 353, 355, 356,
                               /* 2430 */  356, 355, 357, 358, 359, 360, 361, 362, 363, 364,
                               /* 2440 */  361, 362, 363, 364, 357, 358, 359, 360, 361, 362,
                               /* 2450 */  363, 364, 357, 358, 359, 360, 357, 358, 359, 360,
                               /* 2460 */  361, 362, 363, 364, 361, 362, 363, 364, 357, 358,
                               /* 2470 */  359, 360, 357, 358, 359, 360, 361, 362, 363, 364,
                               /* 2480 */  357, 358, 359, 360, 361, 362, 363, 364, 361, 362,
                               /* 2490 */  363, 364, 357, 358, 359, 360, 365, 366, 366, 365,
                               /* 2500 */  366, 365, 365, 366, 366, 365, 365, 366, 365, 366,
                               /* 2510 */  366, 365, 366, 365, 365, 366, 365, 366, 366, 365,
                               /* 2520 */  365, 366, 366, 365, 366, 365, 365, 366, 366, 365,
                               /* 2530 */  365, 366, 365, 366, 366, 365, 365, 366, 366, 365,
                               /* 2540 */  366, 365, 365, 366, 365, 366, 366, 365, 366, 365,
                               /* 2550 */  365, 366, 366, 365, 365, 366, 365, 366, 366, 365,
                               /* 2560 */  165, 152, 152, 152, 152, 166, 152, 152, 152, 152,
                               /* 2570 */  163, 152, 152, 152, 152, 164, 152, 165, 165, 165,
                               /* 2580 */  166, 152, 166, 166, 163, 163, 152, 163, 164, 164,
                               /* 2590 */  164, 152, 152, 166, 163, 164, 165, 152, 163, 164,
                               /* 2600 */  165, 166, 152, 164, 165, 166, 163, 152, 367, 368,
                               /* 2610 */  369, 370, 368, 371, 372, 373, 369, 372, 374, 375,
                               /* 2620 */  370, 373, 375, 376, 152, 165, 165, 152, 166, 152,
                               /* 2630 */  152, 166, 163, 152, 152, 163, 152, 164, 164, 152,
                               /* 2640 */  165, 152, 152, 165, 152, 166, 166, 152, 152, 163,
                               /* 2650 */  163, 152, 164, 152, 152, 164, 370, 164, 164, 370,
                               /* 2660 */  163, 372, 372, 163, 166, 372, 372, 166, 370, 165,
                               /* 2670 */  165, 370, 164, 370, 370, 164, 372, 163, 163, 372,
                               /* 2680 */  372, 166, 166, 372, 165, 370, 370, 165, 152, 166,
                               /* 2690 */  163, 152, 165, 152, 152, 164, 165, 152, 152, 164,
                               /* 2700 */  152, 166, 163, 152, 370, 163, 166, 370, 164, 372,
                               /* 2710 */  372, 165, 164, 372, 372, 165, 370, 163, 166, 370,
                               /* 2720 */  165, 152, 152, 164, 152, 166, 163, 152, 152, 166,
                               /* 2730 */  163, 152, 165, 152, 152, 164, 164, 372, 372, 165,
                               /* 2740 */  370, 163, 166, 370, 370, 163, 166, 370, 164, 372,
                               /* 2750 */  372, 165, 370, 152, 152, 370, 152, 372, 372, 152,
                               /* 2760 */  152, 372, 372, 152, 370, 152, 152, 370, 152, 370,
                               /* 2770 */  370, 152, 372, 152, 152, 372, 372, 152, 152, 372,
                               /* 2780 */  152, 370, 370, 152, 152, 372, 372, 152, 370, 152,
                               /* 2790 */  152, 370, 370, 152, 152, 370, 152, 372, 372, 152,
                               /* 2800 */  372, 152, 152, 372, 152, 370, 370, 152, 152, 370,
                               /* 2810 */  370, 152, 372, 152, 152, 372, 152, 375, 373, 372,
                               /* 2820 */  375, 152, 370, 369, 373, 370, 152, 368, 372, 369,
                               /* 2830 */  368, 152, 377, 368, 369, 370, 368, 377, 372, 373,
                               /* 2840 */  369, 372, 377, 375, 370, 373, 375, 377, 377, 368,
                               /* 2850 */  369, 370, 368, 377, 372, 373, 369, 372, 377, 375,
                               /* 2860 */  370, 373, 375, 377, 152, 375, 373, 372, 375, 152,
                               /* 2870 */  370, 369, 373, 370, 152, 368, 372, 369, 368, 152,
                               /* 2880 */  376, 164, 164, 376, 163, 374, 374, 163, 166, 371,
                               /* 2890 */  371, 166, 367, 165, 165, 367, 164, 376, 376, 164,
                               /* 2900 */  374, 163, 163, 374, 371, 166, 166, 371, 165, 367,
                               /* 2910 */  367, 165, 164, 376, 376, 164, 374, 163, 163, 374,
                               /* 2920 */  371, 166, 166, 371, 165, 367, 367, 165, 376, 164,
                               /* 2930 */  164, 376, 163, 374, 374, 163, 166, 371, 371, 166,
                               /* 2940 */  367, 165, 165, 367, 376, 163, 166, 367, 164, 374,
                               /* 2950 */  371, 165, 164, 374, 371, 165, 376, 163, 166, 367,
                               /* 2960 */  164, 374, 371, 165, 376, 163, 166, 367, 376, 163,
                               /* 2970 */  166, 367, 164, 374, 371, 165, 164, 374, 371, 165,
                               /* 2980 */  376, 163, 166, 367, 376, 163, 166, 367, 164, 374,
                               /* 2990 */  371, 165, 376, 163, 166, 367, 164, 374, 371, 165,
                               /* 3000 */  164, 374, 371, 165, 376, 163, 166, 367, 152, 377,
                               /* 3010 */  377, 152, 377, 152, 152, 377, 377, 152, 152, 377,
                               /* 3020 */  152, 377, 377, 152, 377, 152, 152, 377, 152, 377,
                               /* 3030 */  377, 152, 152, 377, 377, 152, 377, 152, 152, 377,
                               /* 3040 */  377, 152, 152, 377, 152, 377, 377, 152, 152, 377,
                               /* 3050 */  377, 152, 377, 152, 152, 377, 152, 377, 377, 152,
                               /* 3060 */  377, 152, 152, 377, 377, 152, 152, 377, 152, 377,
                               /* 3070 */  377, 152, 378, 379, 380, 381, 382, 383, 384, 385,
                               /* 3080 */  386, 387, 388, 389, 390, 391, 392, 393, 16, 17,
                               /* 3090 */  18, 19, 20, 21, 22, 23, 24, 25, 26, 27,
                               /* 3100 */  28, 29, 30, 31, 32, 33, 34, 35, 36, 37,
                               /* 3110 */  38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
                               /* 3120 */  48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
                               /* 3130 */  58, 59, 60, 61, 62, 63, 64, 65, 65, 64,
                               /* 3140 */  66, 67, 67, 66, 68, 69, 69, 68, 70, 71,
                               /* 3150 */  71, 70, 65, 64, 64, 65, 67, 66, 66, 67,
                               /* 3160 */  69, 68, 68, 69, 71, 70, 70, 71, 72, 73,
                               /* 3170 */  73, 72, 74, 75, 75, 74, 76, 77, 77, 76,
                               /* 3180 */  78, 79, 79, 78, 73, 72, 72, 73, 75, 74,
                               /* 3190 */  74, 75, 77, 76, 76, 77, 79, 78, 78, 79,
                               /* 3200 */  80, 81, 82, 83, 84, 85, 86, 87, 84, 85,
                               /* 3210 */  86, 87, 80, 81, 82, 83, 88, 89, 90, 91,
                               /* 3220 */  92, 93, 94, 95, 92, 93, 94, 95, 88, 89,
                               /* 3230 */  90, 91, 84, 85, 86, 87, 80, 81, 82, 83,
                               /* 3240 */  80, 81, 82, 83, 84, 85, 86, 87, 92, 93,
                               /* 3250 */  94, 95, 88, 89, 90, 91, 88, 89, 90, 91,
                               /* 3260 */  92, 93, 94, 95, 96, 97, 97, 96, 98, 99,
                               /* 3270 */  99, 98, 98, 99, 99, 98, 96, 97, 97, 96,
                               /* 3280 */  97, 96, 96, 97, 99, 98, 98, 99, 99, 98,
                               /* 3290 */  98, 99, 97, 96, 96, 97, 98, 99, 99, 98,
                               /* 3300 */  96, 97, 97, 96, 96, 97, 97, 96, 98, 99,
                               /* 3310 */  99, 98, 99, 98, 98, 99, 97, 96, 96, 97,
                               /* 3320 */  97, 96, 96, 97, 99, 98, 98, 99, 100, 101,
                               /* 3330 */  102, 103, 104, 105, 106, 107, 108, 109, 110, 111,
                               /* 3340 */  112, 113, 114, 115, 116, 117, 118, 119, 120, 121,
                               /* 3350 */  122, 123, 124, 125, 126, 127, 128, 129, 130, 131,
                               /* 3360 */  116, 117, 118, 119, 120, 121, 122, 123, 124, 125,
                               /* 3370 */  126, 127, 128, 129, 130, 131, 100, 101, 102, 103,
                               /* 3380 */  104, 105, 106, 107, 108, 109, 110, 111, 112, 113,
                               /* 3390 */  114, 115, 132, 133, 133, 132, 134, 135, 135, 134,
                               /* 3400 */  136, 137, 137, 136, 138, 139, 139, 138, 133, 132,
                               /* 3410 */  132, 133, 135, 134, 134, 135, 137, 136, 136, 137,
                               /* 3420 */  139, 138, 138, 139, 133, 132, 132, 133, 135, 134,
                               /* 3430 */  134, 135, 137, 136, 136, 137, 139, 138, 138, 139,
                               /* 3440 */  132, 133, 133, 132, 134, 135, 135, 134, 136, 137,
                               /* 3450 */  137, 136, 138, 139, 139, 138, 140, 141, 142, 143,
                               /* 3460 */  144, 145, 146, 147, 144, 145, 146, 147, 140, 141,
                               /* 3470 */  142, 143, 144, 145, 146, 147, 140, 141, 142, 143,
                               /* 3480 */  140, 141, 142, 143, 144, 145, 146, 147, 144, 145,
                               /* 3490 */  146, 147, 140, 141, 142, 143, 140, 141, 142, 143,
                               /* 3500 */  144, 145, 146, 147, 140, 141, 142, 143, 144, 145,
                               /* 3510 */  146, 147, 144, 145, 146, 147, 140, 141, 142, 143,
                               /* 3520 */  394, 395, 395, 394, 395, 394, 394, 395, 395, 394,
                               /* 3530 */  394, 395, 394, 395, 395, 394, 395, 394, 394, 395,
                               /* 3540 */  394, 395, 395, 394, 394, 395, 395, 394, 395, 394,
                               /* 3550 */  394, 395, 395, 394, 394, 395, 394, 395, 395, 394,
                               /* 3560 */  394, 395, 395, 394, 395, 394, 394, 395, 394, 395,
                               /* 3570 */  395, 394, 395, 394, 394, 395, 395, 394, 394, 395,
                               /* 3580 */  394, 395, 395, 394, 396, 152, 397, 152, 152, 398,
                               /* 3590 */  152, 399, 400, 152, 401, 152, 152, 402, 152, 403,
                               /* 3600 */  397, 247, 396, 247, 248, 399, 248, 398, 401, 249,
                               /* 3610 */  400, 249, 250, 403, 250, 402, 400, 166, 401, 164,
                               /* 3620 */  165, 402, 163, 403, 396, 166, 397, 164, 165, 398,
                               /* 3630 */  163, 399, 404, 405, 406, 407, 408, 409, 410, 411,
                               /* 3640 */  412, 413, 414, 415, 416, 417, 418, 419, 397, 396,
                               /* 3650 */  396, 397, 398, 399, 399, 398, 401, 400, 400, 401,
                               /* 3660 */  402, 403, 403, 402, 396, 397, 397, 396, 399, 398,
                               /* 3670 */  398, 399, 400, 401, 401, 400, 403, 402, 402, 403,
                               /* 3680 */  420, 421, 421, 420, 422, 423, 423, 422, 424, 425,
                               /* 3690 */  425, 424, 426, 427, 427, 426, 421, 420, 420, 421,
                               /* 3700 */  423, 422, 422, 423, 425, 424, 424, 425, 427, 426,
                               /* 3710 */  426, 427, 400, 398, 401, 399, 396, 402, 397, 403,
                               /* 3720 */  396, 402, 397, 403, 400, 398, 401, 399, 428, 429,
                               /* 3730 */  430, 431, 432, 433, 434, 435, 432, 433, 434, 435,
                               /* 3740 */  428, 429, 430, 431, 396, 402, 397, 403, 400, 398,
                               /* 3750 */  401, 399, 400, 398, 401, 399, 396, 402, 397, 403,
                               /* 3760 */  432, 433, 434, 435, 428, 429, 430, 431, 428, 429,
                               /* 3770 */  430, 431, 432, 433, 434, 435, 436, 437, 437, 436,
                               /* 3780 */  438, 439, 439, 438, 438, 439, 439, 438, 436, 437,
                               /* 3790 */  437, 436, 437, 436, 436, 437, 439, 438, 438, 439,
                               /* 3800 */  439, 438, 438, 439, 437, 436, 436, 437, 438, 439,
                               /* 3810 */  439, 438, 436, 437, 437, 436, 436, 437, 437, 436,
                               /* 3820 */  438, 439, 439, 438, 439, 438, 438, 439, 437, 436,
                               /* 3830 */  436, 437, 437, 436, 436, 437, 439, 438, 438, 439,
                               /* 3840 */  440, 415, 441, 413, 418, 442, 416, 443, 441, 407,
                               /* 3850 */  440, 405, 410, 443, 408, 442, 444, 405, 445, 407,
                               /* 3860 */  408, 446, 410, 447, 445, 413, 444, 415, 416, 447,
                               /* 3870 */  418, 446, 444, 405, 445, 407, 408, 446, 410, 447,
                               /* 3880 */  445, 413, 444, 415, 416, 447, 418, 446, 440, 415,
                               /* 3890 */  441, 413, 418, 442, 416, 443, 441, 407, 440, 405,
                               /* 3900 */  410, 443, 408, 442, 283, 284, 284, 283, 285, 286,
                               /* 3910 */  286, 285, 287, 288, 288, 287, 289, 290, 290, 289,
                               /* 3920 */  284, 283, 283, 284, 286, 285, 285, 286, 288, 287,
                               /* 3930 */  287, 288, 290, 289, 289, 290, 284, 283, 283, 284,
                               /* 3940 */  286, 285, 285, 286, 288, 287, 287, 288, 290, 289,
                               /* 3950 */  289, 290, 283, 284, 284, 283, 285, 286, 286, 285,
                               /* 3960 */  287, 288, 288, 287, 289, 290, 290, 289, 226, 221,
                               /* 3970 */  220, 223, 222, 225, 224, 219, 222, 225, 224, 219,
                               /* 3980 */  226, 221, 220, 223, 222, 225, 224, 219, 226, 221,
                               /* 3990 */  220, 223, 226, 221, 220, 223, 222, 225, 224, 219,
                               /* 4000 */  222, 225, 224, 219, 226, 221, 220, 223, 226, 221,
                               /* 4010 */  220, 223, 222, 225, 224, 219, 226, 221, 220, 223,
                               /* 4020 */  222, 225, 224, 219, 222, 225, 224, 219, 226, 221,
                               /* 4030 */  220, 223, 448, 449, 449, 448, 449, 448, 448, 449,
                               /* 4040 */  449, 448, 448, 449, 448, 449, 449, 448, 449, 448,
                               /* 4050 */  448, 449, 448, 449, 449, 448, 448, 449, 449, 448,
                               /* 4060 */  449, 448, 448, 449, 449, 448, 448, 449, 448, 449,
                               /* 4070 */  449, 448, 448, 449, 449, 448, 449, 448, 448, 449,
                               /* 4080 */  448, 449, 449, 448, 449, 448, 448, 449, 449, 448,
                               /* 4090 */  448, 449, 448, 449, 449, 448  };

        int look_up_3_input_node (NodeType op, int i1, int i2, int signature)
        {
            int ll_nn = NON_NEGATED( node(i1).left );
            int lr_nn = NON_NEGATED( node(i1).right );
            int r_nn = NON_NEGATED( i2 );

            int result = INVALID;
            int idx = lookup_table_3_inputs[signature];

            switch (idx)
            {
                case 0: // i1 i2 and i3 and
                {
                    int temp0 = create (NodeType.AND, ll_nn, lr_nn );
                    int temp1 = create_op_node (NodeType.AND, temp0, r_nn );
                    result = temp1;
                    break;
                }
                case 1: // i1 neg i2 and i3 and
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), lr_nn );
                    int temp1 = create_op_node (NodeType.AND, temp0, r_nn );
                    result = temp1;
                    break;
                }
                case 2: // i1 i2 neg and i3 and
                {
                    int temp0 = create (NodeType.AND, ll_nn, NEGATE( lr_nn ) );
                    int temp1 = create_op_node (NodeType.AND, temp0, r_nn );
                    result = temp1;
                    break;
                }
                case 3: // i1 neg i2 neg and i3 and
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), NEGATE( lr_nn ) );
                    int temp1 = create_op_node (NodeType.AND, temp0, r_nn );
                    result = temp1;
                    break;
                }
                case 4: // i1 i2 and neg i3 and
                {
                    int temp0 = create (NodeType.AND, ll_nn, lr_nn );
                    int temp1 = create_op_node (NodeType.AND, NEGATE( temp0 ), r_nn );
                    result = temp1;
                    break;
                }
                case 5: // i1 neg i2 and neg i3 and
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), lr_nn );
                    int temp1 = create_op_node (NodeType.AND, NEGATE( temp0 ), r_nn );
                    result = temp1;
                    break;
                }
                case 6: // i1 i2 neg and neg i3 and
                {
                    int temp0 = create (NodeType.AND, ll_nn, NEGATE( lr_nn ) );
                    int temp1 = create_op_node (NodeType.AND, NEGATE( temp0 ), r_nn );
                    result = temp1;
                    break;
                }
                case 7: // i1 neg i2 neg and neg i3 and
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), NEGATE( lr_nn ) );
                    int temp1 = create_op_node (NodeType.AND, NEGATE( temp0 ), r_nn );
                    result = temp1;
                    break;
                }
                case 8: // i1 i2 and i3 neg and
                {
                    int temp0 = create (NodeType.AND, ll_nn, lr_nn );
                    int temp1 = create_op_node (NodeType.AND, temp0, NEGATE( r_nn ) );
                    result = temp1;
                    break;
                }
                case 9: // i1 neg i2 and i3 neg and
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), lr_nn );
                    int temp1 = create_op_node (NodeType.AND, temp0, NEGATE( r_nn ) );
                    result = temp1;
                    break;
                }
                case 10: // i1 i2 neg and i3 neg and
                {
                    int temp0 = create (NodeType.AND, ll_nn, NEGATE( lr_nn ) );
                    int temp1 = create_op_node (NodeType.AND, temp0, NEGATE( r_nn ) );
                    result = temp1;
                    break;
                }
                case 11: // i1 neg i2 neg and i3 neg and
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), NEGATE( lr_nn ) );
                    int temp1 = create_op_node (NodeType.AND, temp0, NEGATE( r_nn ) );
                    result = temp1;
                    break;
                }
                case 12: // i1 i2 and neg i3 neg and
                {
                    int temp0 = create (NodeType.AND, ll_nn, lr_nn );
                    int temp1 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( r_nn ) );
                    result = temp1;
                    break;
                }
                case 13: // i1 neg i2 and neg i3 neg and
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), lr_nn );
                    int temp1 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( r_nn ) );
                    result = temp1;
                    break;
                }
                case 14: // i1 i2 neg and neg i3 neg and
                {
                    int temp0 = create (NodeType.AND, ll_nn, NEGATE( lr_nn ) );
                    int temp1 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( r_nn ) );
                    result = temp1;
                    break;
                }
                case 15: // i1 neg i2 neg and neg i3 neg and
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), NEGATE( lr_nn ) );
                    int temp1 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( r_nn ) );
                    result = temp1;
                    break;
                }
                case 16: // i1 i2 xor i3 and
                {
                    int temp0 = create (NodeType.XOR, ll_nn, lr_nn );
                    int temp1 = create_op_node (NodeType.AND, temp0, r_nn );
                    result = temp1;
                    break;
                }
                case 17: // i1 i2 xor neg i3 and
                {
                    int temp0 = create (NodeType.XOR, ll_nn, lr_nn );
                    int temp1 = create_op_node (NodeType.AND, NEGATE( temp0 ), r_nn );
                    result = temp1;
                    break;
                }
                case 18: // i1 i2 xor i3 neg and
                {
                    int temp0 = create (NodeType.XOR, ll_nn, lr_nn );
                    int temp1 = create_op_node (NodeType.AND, temp0, NEGATE( r_nn ) );
                    result = temp1;
                    break;
                }
                case 19: // i1 i2 xor neg i3 neg and
                {
                    int temp0 = create (NodeType.XOR, ll_nn, lr_nn );
                    int temp1 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( r_nn ) );
                    result = temp1;
                    break;
                }
                case 20: // i1 i2 and i3 xor
                {
                    int temp0 = create (NodeType.AND, ll_nn, lr_nn );
                    int temp1 = create_op_node (NodeType.XOR, temp0, r_nn );
                    result = temp1;
                    break;
                }
                case 21: // i1 neg i2 and i3 xor
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), lr_nn );
                    int temp1 = create_op_node (NodeType.XOR, temp0, r_nn );
                    result = temp1;
                    break;
                }
                case 22: // i1 i2 neg and i3 xor
                {
                    int temp0 = create (NodeType.AND, ll_nn, NEGATE( lr_nn ) );
                    int temp1 = create_op_node (NodeType.XOR, temp0, r_nn );
                    result = temp1;
                    break;
                }
                case 23: // i1 neg i2 neg and i3 xor
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), NEGATE( lr_nn ) );
                    int temp1 = create_op_node (NodeType.XOR, temp0, r_nn );
                    result = temp1;
                    break;
                }
                case 24: // i1 i2 and i3 xor neg
                {
                    int temp0 = create (NodeType.AND, ll_nn, lr_nn );
                    int temp1 = create_op_node (NodeType.XOR, temp0, r_nn );
                    result = NEGATE( temp1 );
                    break;
                }
                case 25: // i1 neg i2 and i3 xor neg
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), lr_nn );
                    int temp1 = create_op_node (NodeType.XOR, temp0, r_nn );
                    result = NEGATE( temp1 );
                    break;
                }
                case 26: // i1 i2 neg and i3 xor neg
                {
                    int temp0 = create (NodeType.AND, ll_nn, NEGATE( lr_nn ) );
                    int temp1 = create_op_node (NodeType.XOR, temp0, r_nn );
                    result = NEGATE( temp1 );
                    break;
                }
                case 27: // i1 neg i2 neg and i3 xor neg
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), NEGATE( lr_nn ) );
                    int temp1 = create_op_node (NodeType.XOR, temp0, r_nn );
                    result = NEGATE( temp1 );
                    break;
                }
                case 28: // i1 i2 xor i3 xor
                {
                    int temp0 = create (NodeType.XOR, ll_nn, lr_nn );
                    int temp1 = create_op_node (NodeType.XOR, temp0, r_nn );
                    result = temp1;
                    break;
                }
                case 29: // i1 i2 xor i3 xor neg
                {
                    int temp0 = create (NodeType.XOR, ll_nn, lr_nn );
                    int temp1 = create_op_node (NodeType.XOR, temp0, r_nn );
                    result = NEGATE( temp1 );
                    break;
                }
                case 30: // i1 i2 and
                {
                    int temp0 = create_op_node (NodeType.AND, ll_nn, lr_nn );
                    result = temp0;
                    break;
                }
                case 31: // i1 neg i2 and
                {
                    int temp0 = create_op_node (NodeType.AND, NEGATE( ll_nn ), lr_nn );
                    result = temp0;
                    break;
                }
                case 32: // neg
                {
                    result = zero();
                    break;
                }
                case 33: // i2
                {
                    result = lr_nn;
                    break;
                }
                case 34: // i1 i2 neg and
                {
                    int temp0 = create_op_node (NodeType.AND, ll_nn, NEGATE( lr_nn ) );
                    result = temp0;
                    break;
                }
                case 35: // i1 neg i2 neg and
                {
                    int temp0 = create_op_node (NodeType.AND, NEGATE( ll_nn ), NEGATE( lr_nn ) );
                    result = temp0;
                    break;
                }
                case 36: // i2 neg
                {
                    result = NEGATE( lr_nn );
                    break;
                }
                case 37: // i1 neg i2 neg and neg
                {
                    int temp0 = create_op_node (NodeType.AND, NEGATE( ll_nn ), NEGATE( lr_nn ) );
                    result = NEGATE( temp0 );
                    break;
                }
                case 38: // i1 i2 neg and neg
                {
                    int temp0 = create_op_node (NodeType.AND, ll_nn, NEGATE( lr_nn ) );
                    result = NEGATE( temp0 );
                    break;
                }
                case 39: // i1 neg i2 and neg
                {
                    int temp0 = create_op_node (NodeType.AND, NEGATE( ll_nn ), lr_nn );
                    result = NEGATE( temp0 );
                    break;
                }
                case 40: // i1 i2 and neg
                {
                    int temp0 = create_op_node (NodeType.AND, ll_nn, lr_nn );
                    result = NEGATE( temp0 );
                    break;
                }
                case 41: // i1
                {
                    result = ll_nn;
                    break;
                }
                case 42: // i1 neg
                {
                    result = NEGATE( ll_nn );
                    break;
                }
                case 43: // i1 i3 and i2 and
                {
                    int temp0 = create (NodeType.AND, ll_nn, r_nn );
                    int temp1 = create_op_node (NodeType.AND, temp0, lr_nn );
                    result = temp1;
                    break;
                }
                case 44: // i1 neg i3 and i2 and
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), r_nn );
                    int temp1 = create_op_node (NodeType.AND, temp0, lr_nn );
                    result = temp1;
                    break;
                }
                case 45: // i1 i3 and i2 neg and
                {
                    int temp0 = create (NodeType.AND, ll_nn, r_nn );
                    int temp1 = create_op_node (NodeType.AND, temp0, NEGATE( lr_nn ) );
                    result = temp1;
                    break;
                }
                case 46: // i1 neg i3 and i2 neg and
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), r_nn );
                    int temp1 = create_op_node (NodeType.AND, temp0, NEGATE( lr_nn ) );
                    result = temp1;
                    break;
                }
                case 47: // i1 i3 neg and i2 and
                {
                    int temp0 = create (NodeType.AND, ll_nn, NEGATE( r_nn ) );
                    int temp1 = create_op_node (NodeType.AND, temp0, lr_nn );
                    result = temp1;
                    break;
                }
                case 48: // i1 neg i3 neg and i2 and
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), NEGATE( r_nn ) );
                    int temp1 = create_op_node (NodeType.AND, temp0, lr_nn );
                    result = temp1;
                    break;
                }
                case 49: // i1 i3 neg and i2 neg and
                {
                    int temp0 = create (NodeType.AND, ll_nn, NEGATE( r_nn ) );
                    int temp1 = create_op_node (NodeType.AND, temp0, NEGATE( lr_nn ) );
                    result = temp1;
                    break;
                }
                case 50: // i1 neg i3 neg and i2 neg and
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), NEGATE( r_nn ) );
                    int temp1 = create_op_node (NodeType.AND, temp0, NEGATE( lr_nn ) );
                    result = temp1;
                    break;
                }
                case 51: // i1 i3 xor i2 xor
                {
                    int temp0 = create (NodeType.XOR, ll_nn, r_nn );
                    int temp1 = create_op_node (NodeType.XOR, temp0, lr_nn );
                    result = temp1;
                    break;
                }
                case 52: // i1 i3 xor i2 xor neg
                {
                    int temp0 = create (NodeType.XOR, ll_nn, r_nn );
                    int temp1 = create_op_node (NodeType.XOR, temp0, lr_nn );
                    result = NEGATE( temp1 );
                    break;
                }
                case 53: // i3 i1 and i2 and
                {
                    int temp0 = create (NodeType.AND, r_nn, ll_nn );
                    int temp1 = create_op_node (NodeType.AND, temp0, lr_nn );
                    result = temp1;
                    break;
                }
                case 54: // i3 i1 neg and i2 and
                {
                    int temp0 = create (NodeType.AND, r_nn, NEGATE( ll_nn ) );
                    int temp1 = create_op_node (NodeType.AND, temp0, lr_nn );
                    result = temp1;
                    break;
                }
                case 55: // i3 i1 and i2 neg and
                {
                    int temp0 = create (NodeType.AND, r_nn, ll_nn );
                    int temp1 = create_op_node (NodeType.AND, temp0, NEGATE( lr_nn ) );
                    result = temp1;
                    break;
                }
                case 56: // i3 i1 neg and i2 neg and
                {
                    int temp0 = create (NodeType.AND, r_nn, NEGATE( ll_nn ) );
                    int temp1 = create_op_node (NodeType.AND, temp0, NEGATE( lr_nn ) );
                    result = temp1;
                    break;
                }
                case 57: // i3 neg i1 and i2 and
                {
                    int temp0 = create (NodeType.AND, NEGATE( r_nn ), ll_nn );
                    int temp1 = create_op_node (NodeType.AND, temp0, lr_nn );
                    result = temp1;
                    break;
                }
                case 58: // i3 neg i1 neg and i2 and
                {
                    int temp0 = create (NodeType.AND, NEGATE( r_nn ), NEGATE( ll_nn ) );
                    int temp1 = create_op_node (NodeType.AND, temp0, lr_nn );
                    result = temp1;
                    break;
                }
                case 59: // i3 neg i1 and i2 neg and
                {
                    int temp0 = create (NodeType.AND, NEGATE( r_nn ), ll_nn );
                    int temp1 = create_op_node (NodeType.AND, temp0, NEGATE( lr_nn ) );
                    result = temp1;
                    break;
                }
                case 60: // i3 neg i1 neg and i2 neg and
                {
                    int temp0 = create (NodeType.AND, NEGATE( r_nn ), NEGATE( ll_nn ) );
                    int temp1 = create_op_node (NodeType.AND, temp0, NEGATE( lr_nn ) );
                    result = temp1;
                    break;
                }
                case 61: // i3 i1 xor i2 xor
                {
                    int temp0 = create (NodeType.XOR, r_nn, ll_nn );
                    int temp1 = create_op_node (NodeType.XOR, temp0, lr_nn );
                    result = temp1;
                    break;
                }
                case 62: // i3 i1 xor i2 xor neg
                {
                    int temp0 = create (NodeType.XOR, r_nn, ll_nn );
                    int temp1 = create_op_node (NodeType.XOR, temp0, lr_nn );
                    result = NEGATE( temp1 );
                    break;
                }
                default:
                    throw new Exception ("Unknown Cases");
            }
            return result;
        }

        int look_up_4_input_node (NodeType op, int i1, int i2, int signature)
        {
            int ll_nn = NON_NEGATED( node(i1).input(0) );
            int lr_nn = NON_NEGATED( node(i1).input(1) );
            int rl_nn = NON_NEGATED( node(i2).input(0) );
            int rr_nn = NON_NEGATED( node(i2).input(1) );

            int result = INVALID;
            int idx = lookup_table_4_inputs[signature];

            switch (idx)
            {
                case 0: // i1 i2 and i3 i4 and and
                {
                    int temp0 = create (NodeType.AND, ll_nn, lr_nn );
                    int temp1 = create (NodeType.AND, rl_nn, rr_nn );
                    int temp2 = create_op_node (NodeType.AND, temp0, temp1 );
                    result = temp2;
                    break;
                }
                case 1: // i1 neg i2 and i3 i4 and and
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), lr_nn );
                    int temp1 = create (NodeType.AND, rl_nn, rr_nn );
                    int temp2 = create_op_node (NodeType.AND, temp0, temp1 );
                    result = temp2;
                    break;
                }
                case 2: // i1 i2 neg and i3 i4 and and
                {
                    int temp0 = create (NodeType.AND, ll_nn, NEGATE( lr_nn ) );
                    int temp1 = create (NodeType.AND, rl_nn, rr_nn );
                    int temp2 = create_op_node (NodeType.AND, temp0, temp1 );
                    result = temp2;
                    break;
                }
                case 3: // i1 neg i2 neg and i3 i4 and and
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), NEGATE( lr_nn ) );
                    int temp1 = create (NodeType.AND, rl_nn, rr_nn );
                    int temp2 = create_op_node (NodeType.AND, temp0, temp1 );
                    result = temp2;
                    break;
                }
                case 4: // i1 i2 and i3 neg i4 and and
                {
                    int temp0 = create (NodeType.AND, ll_nn, lr_nn );
                    int temp1 = create (NodeType.AND, NEGATE( rl_nn ), rr_nn );
                    int temp2 = create_op_node (NodeType.AND, temp0, temp1 );
                    result = temp2;
                    break;
                }
                case 5: // i1 neg i2 and i3 neg i4 and and
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), lr_nn );
                    int temp1 = create (NodeType.AND, NEGATE( rl_nn ), rr_nn );
                    int temp2 = create_op_node (NodeType.AND, temp0, temp1 );
                    result = temp2;
                    break;
                }
                case 6: // i1 i2 neg and i3 neg i4 and and
                {
                    int temp0 = create (NodeType.AND, ll_nn, NEGATE( lr_nn ) );
                    int temp1 = create (NodeType.AND, NEGATE( rl_nn ), rr_nn );
                    int temp2 = create_op_node (NodeType.AND, temp0, temp1 );
                    result = temp2;
                    break;
                }
                case 7: // i1 neg i2 neg and i3 neg i4 and and
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), NEGATE( lr_nn ) );
                    int temp1 = create (NodeType.AND, NEGATE( rl_nn ), rr_nn );
                    int temp2 = create_op_node (NodeType.AND, temp0, temp1 );
                    result = temp2;
                    break;
                }
                case 8: // i1 i2 and i3 i4 neg and and
                {
                    int temp0 = create (NodeType.AND, ll_nn, lr_nn );
                    int temp1 = create (NodeType.AND, rl_nn, NEGATE( rr_nn ) );
                    int temp2 = create_op_node (NodeType.AND, temp0, temp1 );
                    result = temp2;
                    break;
                }
                case 9: // i1 neg i2 and i3 i4 neg and and
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), lr_nn );
                    int temp1 = create (NodeType.AND, rl_nn, NEGATE( rr_nn ) );
                    int temp2 = create_op_node (NodeType.AND, temp0, temp1 );
                    result = temp2;
                    break;
                }
                case 10: // i1 i2 neg and i3 i4 neg and and
                {
                    int temp0 = create (NodeType.AND, ll_nn, NEGATE( lr_nn ) );
                    int temp1 = create (NodeType.AND, rl_nn, NEGATE( rr_nn ) );
                    int temp2 = create_op_node (NodeType.AND, temp0, temp1 );
                    result = temp2;
                    break;
                }
                case 11: // i1 neg i2 neg and i3 i4 neg and and
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), NEGATE( lr_nn ) );
                    int temp1 = create (NodeType.AND, rl_nn, NEGATE( rr_nn ) );
                    int temp2 = create_op_node (NodeType.AND, temp0, temp1 );
                    result = temp2;
                    break;
                }
                case 12: // i1 i2 and i3 neg i4 neg and and
                {
                    int temp0 = create (NodeType.AND, ll_nn, lr_nn );
                    int temp1 = create (NodeType.AND, NEGATE( rl_nn ), NEGATE( rr_nn ) );
                    int temp2 = create_op_node (NodeType.AND, temp0, temp1 );
                    result = temp2;
                    break;
                }
                case 13: // i1 neg i2 and i3 neg i4 neg and and
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), lr_nn );
                    int temp1 = create (NodeType.AND, NEGATE( rl_nn ), NEGATE( rr_nn ) );
                    int temp2 = create_op_node (NodeType.AND, temp0, temp1 );
                    result = temp2;
                    break;
                }
                case 14: // i1 i2 neg and i3 neg i4 neg and and
                {
                    int temp0 = create (NodeType.AND, ll_nn, NEGATE( lr_nn ) );
                    int temp1 = create (NodeType.AND, NEGATE( rl_nn ), NEGATE( rr_nn ) );
                    int temp2 = create_op_node (NodeType.AND, temp0, temp1 );
                    result = temp2;
                    break;
                }
                case 15: // i1 neg i2 neg and i3 neg i4 neg and and
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), NEGATE( lr_nn ) );
                    int temp1 = create (NodeType.AND, NEGATE( rl_nn ), NEGATE( rr_nn ) );
                    int temp2 = create_op_node (NodeType.AND, temp0, temp1 );
                    result = temp2;
                    break;
                }
                case 16: // i1 i2 and neg i3 i4 and and
                {
                    int temp0 = create (NodeType.AND, ll_nn, lr_nn );
                    int temp1 = create (NodeType.AND, rl_nn, rr_nn );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), temp1 );
                    result = temp2;
                    break;
                }
                case 17: // i1 neg i2 and neg i3 i4 and and
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), lr_nn );
                    int temp1 = create (NodeType.AND, rl_nn, rr_nn );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), temp1 );
                    result = temp2;
                    break;
                }
                case 18: // i1 i2 neg and neg i3 i4 and and
                {
                    int temp0 = create (NodeType.AND, ll_nn, NEGATE( lr_nn ) );
                    int temp1 = create (NodeType.AND, rl_nn, rr_nn );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), temp1 );
                    result = temp2;
                    break;
                }
                case 19: // i1 neg i2 neg and neg i3 i4 and and
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), NEGATE( lr_nn ) );
                    int temp1 = create (NodeType.AND, rl_nn, rr_nn );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), temp1 );
                    result = temp2;
                    break;
                }
                case 20: // i1 i2 and neg i3 neg i4 and and
                {
                    int temp0 = create (NodeType.AND, ll_nn, lr_nn );
                    int temp1 = create (NodeType.AND, NEGATE( rl_nn ), rr_nn );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), temp1 );
                    result = temp2;
                    break;
                }
                case 21: // i1 neg i2 and neg i3 neg i4 and and
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), lr_nn );
                    int temp1 = create (NodeType.AND, NEGATE( rl_nn ), rr_nn );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), temp1 );
                    result = temp2;
                    break;
                }
                case 22: // i1 i2 neg and neg i3 neg i4 and and
                {
                    int temp0 = create (NodeType.AND, ll_nn, NEGATE( lr_nn ) );
                    int temp1 = create (NodeType.AND, NEGATE( rl_nn ), rr_nn );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), temp1 );
                    result = temp2;
                    break;
                }
                case 23: // i1 neg i2 neg and neg i3 neg i4 and and
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), NEGATE( lr_nn ) );
                    int temp1 = create (NodeType.AND, NEGATE( rl_nn ), rr_nn );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), temp1 );
                    result = temp2;
                    break;
                }
                case 24: // i1 i2 and neg i3 i4 neg and and
                {
                    int temp0 = create (NodeType.AND, ll_nn, lr_nn );
                    int temp1 = create (NodeType.AND, rl_nn, NEGATE( rr_nn ) );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), temp1 );
                    result = temp2;
                    break;
                }
                case 25: // i1 neg i2 and neg i3 i4 neg and and
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), lr_nn );
                    int temp1 = create (NodeType.AND, rl_nn, NEGATE( rr_nn ) );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), temp1 );
                    result = temp2;
                    break;
                }
                case 26: // i1 i2 neg and neg i3 i4 neg and and
                {
                    int temp0 = create (NodeType.AND, ll_nn, NEGATE( lr_nn ) );
                    int temp1 = create (NodeType.AND, rl_nn, NEGATE( rr_nn ) );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), temp1 );
                    result = temp2;
                    break;
                }
                case 27: // i1 neg i2 neg and neg i3 i4 neg and and
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), NEGATE( lr_nn ) );
                    int temp1 = create (NodeType.AND, rl_nn, NEGATE( rr_nn ) );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), temp1 );
                    result = temp2;
                    break;
                }
                case 28: // i1 i2 and neg i3 neg i4 neg and and
                {
                    int temp0 = create (NodeType.AND, ll_nn, lr_nn );
                    int temp1 = create (NodeType.AND, NEGATE( rl_nn ), NEGATE( rr_nn ) );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), temp1 );
                    result = temp2;
                    break;
                }
                case 29: // i1 neg i2 and neg i3 neg i4 neg and and
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), lr_nn );
                    int temp1 = create (NodeType.AND, NEGATE( rl_nn ), NEGATE( rr_nn ) );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), temp1 );
                    result = temp2;
                    break;
                }
                case 30: // i1 i2 neg and neg i3 neg i4 neg and and
                {
                    int temp0 = create (NodeType.AND, ll_nn, NEGATE( lr_nn ) );
                    int temp1 = create (NodeType.AND, NEGATE( rl_nn ), NEGATE( rr_nn ) );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), temp1 );
                    result = temp2;
                    break;
                }
                case 31: // i1 neg i2 neg and neg i3 neg i4 neg and and
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), NEGATE( lr_nn ) );
                    int temp1 = create (NodeType.AND, NEGATE( rl_nn ), NEGATE( rr_nn ) );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), temp1 );
                    result = temp2;
                    break;
                }
                case 32: // i1 i2 and i3 i4 and neg and
                {
                    int temp0 = create (NodeType.AND, ll_nn, lr_nn );
                    int temp1 = create (NodeType.AND, rl_nn, rr_nn );
                    int temp2 = create_op_node (NodeType.AND, temp0, NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 33: // i1 neg i2 and i3 i4 and neg and
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), lr_nn );
                    int temp1 = create (NodeType.AND, rl_nn, rr_nn );
                    int temp2 = create_op_node (NodeType.AND, temp0, NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 34: // i1 i2 neg and i3 i4 and neg and
                {
                    int temp0 = create (NodeType.AND, ll_nn, NEGATE( lr_nn ) );
                    int temp1 = create (NodeType.AND, rl_nn, rr_nn );
                    int temp2 = create_op_node (NodeType.AND, temp0, NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 35: // i1 neg i2 neg and i3 i4 and neg and
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), NEGATE( lr_nn ) );
                    int temp1 = create (NodeType.AND, rl_nn, rr_nn );
                    int temp2 = create_op_node (NodeType.AND, temp0, NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 36: // i1 i2 and i3 neg i4 and neg and
                {
                    int temp0 = create (NodeType.AND, ll_nn, lr_nn );
                    int temp1 = create (NodeType.AND, NEGATE( rl_nn ), rr_nn );
                    int temp2 = create_op_node (NodeType.AND, temp0, NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 37: // i1 neg i2 and i3 neg i4 and neg and
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), lr_nn );
                    int temp1 = create (NodeType.AND, NEGATE( rl_nn ), rr_nn );
                    int temp2 = create_op_node (NodeType.AND, temp0, NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 38: // i1 i2 neg and i3 neg i4 and neg and
                {
                    int temp0 = create (NodeType.AND, ll_nn, NEGATE( lr_nn ) );
                    int temp1 = create (NodeType.AND, NEGATE( rl_nn ), rr_nn );
                    int temp2 = create_op_node (NodeType.AND, temp0, NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 39: // i1 neg i2 neg and i3 neg i4 and neg and
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), NEGATE( lr_nn ) );
                    int temp1 = create (NodeType.AND, NEGATE( rl_nn ), rr_nn );
                    int temp2 = create_op_node (NodeType.AND, temp0, NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 40: // i1 i2 and i3 i4 neg and neg and
                {
                    int temp0 = create (NodeType.AND, ll_nn, lr_nn );
                    int temp1 = create (NodeType.AND, rl_nn, NEGATE( rr_nn ) );
                    int temp2 = create_op_node (NodeType.AND, temp0, NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 41: // i1 neg i2 and i3 i4 neg and neg and
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), lr_nn );
                    int temp1 = create (NodeType.AND, rl_nn, NEGATE( rr_nn ) );
                    int temp2 = create_op_node (NodeType.AND, temp0, NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 42: // i1 i2 neg and i3 i4 neg and neg and
                {
                    int temp0 = create (NodeType.AND, ll_nn, NEGATE( lr_nn ) );
                    int temp1 = create (NodeType.AND, rl_nn, NEGATE( rr_nn ) );
                    int temp2 = create_op_node (NodeType.AND, temp0, NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 43: // i1 neg i2 neg and i3 i4 neg and neg and
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), NEGATE( lr_nn ) );
                    int temp1 = create (NodeType.AND, rl_nn, NEGATE( rr_nn ) );
                    int temp2 = create_op_node (NodeType.AND, temp0, NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 44: // i1 i2 and i3 neg i4 neg and neg and
                {
                    int temp0 = create (NodeType.AND, ll_nn, lr_nn );
                    int temp1 = create (NodeType.AND, NEGATE( rl_nn ), NEGATE( rr_nn ) );
                    int temp2 = create_op_node (NodeType.AND, temp0, NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 45: // i1 neg i2 and i3 neg i4 neg and neg and
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), lr_nn );
                    int temp1 = create (NodeType.AND, NEGATE( rl_nn ), NEGATE( rr_nn ) );
                    int temp2 = create_op_node (NodeType.AND, temp0, NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 46: // i1 i2 neg and i3 neg i4 neg and neg and
                {
                    int temp0 = create (NodeType.AND, ll_nn, NEGATE( lr_nn ) );
                    int temp1 = create (NodeType.AND, NEGATE( rl_nn ), NEGATE( rr_nn ) );
                    int temp2 = create_op_node (NodeType.AND, temp0, NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 47: // i1 neg i2 neg and i3 neg i4 neg and neg and
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), NEGATE( lr_nn ) );
                    int temp1 = create (NodeType.AND, NEGATE( rl_nn ), NEGATE( rr_nn ) );
                    int temp2 = create_op_node (NodeType.AND, temp0, NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 48: // i1 i2 and neg i3 i4 and neg and
                {
                    int temp0 = create (NodeType.AND, ll_nn, lr_nn );
                    int temp1 = create (NodeType.AND, rl_nn, rr_nn );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 49: // i1 neg i2 and neg i3 i4 and neg and
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), lr_nn );
                    int temp1 = create (NodeType.AND, rl_nn, rr_nn );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 50: // i1 i2 neg and neg i3 i4 and neg and
                {
                    int temp0 = create (NodeType.AND, ll_nn, NEGATE( lr_nn ) );
                    int temp1 = create (NodeType.AND, rl_nn, rr_nn );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 51: // i1 neg i2 neg and neg i3 i4 and neg and
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), NEGATE( lr_nn ) );
                    int temp1 = create (NodeType.AND, rl_nn, rr_nn );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 52: // i1 i2 and neg i3 neg i4 and neg and
                {
                    int temp0 = create (NodeType.AND, ll_nn, lr_nn );
                    int temp1 = create (NodeType.AND, NEGATE( rl_nn ), rr_nn );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 53: // i1 neg i2 and neg i3 neg i4 and neg and
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), lr_nn );
                    int temp1 = create (NodeType.AND, NEGATE( rl_nn ), rr_nn );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 54: // i1 i2 neg and neg i3 neg i4 and neg and
                {
                    int temp0 = create (NodeType.AND, ll_nn, NEGATE( lr_nn ) );
                    int temp1 = create (NodeType.AND, NEGATE( rl_nn ), rr_nn );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 55: // i1 neg i2 neg and neg i3 neg i4 and neg and
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), NEGATE( lr_nn ) );
                    int temp1 = create (NodeType.AND, NEGATE( rl_nn ), rr_nn );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 56: // i1 i2 and neg i3 i4 neg and neg and
                {
                    int temp0 = create (NodeType.AND, ll_nn, lr_nn );
                    int temp1 = create (NodeType.AND, rl_nn, NEGATE( rr_nn ) );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 57: // i1 neg i2 and neg i3 i4 neg and neg and
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), lr_nn );
                    int temp1 = create (NodeType.AND, rl_nn, NEGATE( rr_nn ) );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 58: // i1 i2 neg and neg i3 i4 neg and neg and
                {
                    int temp0 = create (NodeType.AND, ll_nn, NEGATE( lr_nn ) );
                    int temp1 = create (NodeType.AND, rl_nn, NEGATE( rr_nn ) );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 59: // i1 neg i2 neg and neg i3 i4 neg and neg and
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), NEGATE( lr_nn ) );
                    int temp1 = create (NodeType.AND, rl_nn, NEGATE( rr_nn ) );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 60: // i1 i2 and neg i3 neg i4 neg and neg and
                {
                    int temp0 = create (NodeType.AND, ll_nn, lr_nn );
                    int temp1 = create (NodeType.AND, NEGATE( rl_nn ), NEGATE( rr_nn ) );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 61: // i1 neg i2 and neg i3 neg i4 neg and neg and
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), lr_nn );
                    int temp1 = create (NodeType.AND, NEGATE( rl_nn ), NEGATE( rr_nn ) );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 62: // i1 i2 neg and neg i3 neg i4 neg and neg and
                {
                    int temp0 = create (NodeType.AND, ll_nn, NEGATE( lr_nn ) );
                    int temp1 = create (NodeType.AND, NEGATE( rl_nn ), NEGATE( rr_nn ) );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 63: // i1 neg i2 neg and neg i3 neg i4 neg and neg and
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), NEGATE( lr_nn ) );
                    int temp1 = create (NodeType.AND, NEGATE( rl_nn ), NEGATE( rr_nn ) );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 64: // i1 i2 xor i3 i4 and and
                {
                    int temp0 = create (NodeType.XOR, ll_nn, lr_nn );
                    int temp1 = create (NodeType.AND, rl_nn, rr_nn );
                    int temp2 = create_op_node (NodeType.AND, temp0, temp1 );
                    result = temp2;
                    break;
                }
                case 65: // i1 i2 xor neg i3 i4 and and
                {
                    int temp0 = create (NodeType.XOR, ll_nn, lr_nn );
                    int temp1 = create (NodeType.AND, rl_nn, rr_nn );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), temp1 );
                    result = temp2;
                    break;
                }
                case 66: // i1 i2 xor i3 neg i4 and and
                {
                    int temp0 = create (NodeType.XOR, ll_nn, lr_nn );
                    int temp1 = create (NodeType.AND, NEGATE( rl_nn ), rr_nn );
                    int temp2 = create_op_node (NodeType.AND, temp0, temp1 );
                    result = temp2;
                    break;
                }
                case 67: // i1 i2 xor neg i3 neg i4 and and
                {
                    int temp0 = create (NodeType.XOR, ll_nn, lr_nn );
                    int temp1 = create (NodeType.AND, NEGATE( rl_nn ), rr_nn );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), temp1 );
                    result = temp2;
                    break;
                }
                case 68: // i1 i2 xor i3 i4 neg and and
                {
                    int temp0 = create (NodeType.XOR, ll_nn, lr_nn );
                    int temp1 = create (NodeType.AND, rl_nn, NEGATE( rr_nn ) );
                    int temp2 = create_op_node (NodeType.AND, temp0, temp1 );
                    result = temp2;
                    break;
                }
                case 69: // i1 i2 xor neg i3 i4 neg and and
                {
                    int temp0 = create (NodeType.XOR, ll_nn, lr_nn );
                    int temp1 = create (NodeType.AND, rl_nn, NEGATE( rr_nn ) );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), temp1 );
                    result = temp2;
                    break;
                }
                case 70: // i1 i2 xor i3 neg i4 neg and and
                {
                    int temp0 = create (NodeType.XOR, ll_nn, lr_nn );
                    int temp1 = create (NodeType.AND, NEGATE( rl_nn ), NEGATE( rr_nn ) );
                    int temp2 = create_op_node (NodeType.AND, temp0, temp1 );
                    result = temp2;
                    break;
                }
                case 71: // i1 i2 xor neg i3 neg i4 neg and and
                {
                    int temp0 = create (NodeType.XOR, ll_nn, lr_nn );
                    int temp1 = create (NodeType.AND, NEGATE( rl_nn ), NEGATE( rr_nn ) );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), temp1 );
                    result = temp2;
                    break;
                }
                case 72: // i1 i2 xor i3 i4 and neg and
                {
                    int temp0 = create (NodeType.XOR, ll_nn, lr_nn );
                    int temp1 = create (NodeType.AND, rl_nn, rr_nn );
                    int temp2 = create_op_node (NodeType.AND, temp0, NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 73: // i1 i2 xor neg i3 i4 and neg and
                {
                    int temp0 = create (NodeType.XOR, ll_nn, lr_nn );
                    int temp1 = create (NodeType.AND, rl_nn, rr_nn );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 74: // i1 i2 xor i3 neg i4 and neg and
                {
                    int temp0 = create (NodeType.XOR, ll_nn, lr_nn );
                    int temp1 = create (NodeType.AND, NEGATE( rl_nn ), rr_nn );
                    int temp2 = create_op_node (NodeType.AND, temp0, NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 75: // i1 i2 xor neg i3 neg i4 and neg and
                {
                    int temp0 = create (NodeType.XOR, ll_nn, lr_nn );
                    int temp1 = create (NodeType.AND, NEGATE( rl_nn ), rr_nn );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 76: // i1 i2 xor i3 i4 neg and neg and
                {
                    int temp0 = create (NodeType.XOR, ll_nn, lr_nn );
                    int temp1 = create (NodeType.AND, rl_nn, NEGATE( rr_nn ) );
                    int temp2 = create_op_node (NodeType.AND, temp0, NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 77: // i1 i2 xor neg i3 i4 neg and neg and
                {
                    int temp0 = create (NodeType.XOR, ll_nn, lr_nn );
                    int temp1 = create (NodeType.AND, rl_nn, NEGATE( rr_nn ) );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 78: // i1 i2 xor i3 neg i4 neg and neg and
                {
                    int temp0 = create (NodeType.XOR, ll_nn, lr_nn );
                    int temp1 = create (NodeType.AND, NEGATE( rl_nn ), NEGATE( rr_nn ) );
                    int temp2 = create_op_node (NodeType.AND, temp0, NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 79: // i1 i2 xor neg i3 neg i4 neg and neg and
                {
                    int temp0 = create (NodeType.XOR, ll_nn, lr_nn );
                    int temp1 = create (NodeType.AND, NEGATE( rl_nn ), NEGATE( rr_nn ) );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 80: // i1 i2 and i3 i4 xor and
                {
                    int temp0 = create (NodeType.AND, ll_nn, lr_nn );
                    int temp1 = create (NodeType.XOR, rl_nn, rr_nn );
                    int temp2 = create_op_node (NodeType.AND, temp0, temp1 );
                    result = temp2;
                    break;
                }
                case 81: // i1 neg i2 and i3 i4 xor and
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), lr_nn );
                    int temp1 = create (NodeType.XOR, rl_nn, rr_nn );
                    int temp2 = create_op_node (NodeType.AND, temp0, temp1 );
                    result = temp2;
                    break;
                }
                case 82: // i1 i2 neg and i3 i4 xor and
                {
                    int temp0 = create (NodeType.AND, ll_nn, NEGATE( lr_nn ) );
                    int temp1 = create (NodeType.XOR, rl_nn, rr_nn );
                    int temp2 = create_op_node (NodeType.AND, temp0, temp1 );
                    result = temp2;
                    break;
                }
                case 83: // i1 neg i2 neg and i3 i4 xor and
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), NEGATE( lr_nn ) );
                    int temp1 = create (NodeType.XOR, rl_nn, rr_nn );
                    int temp2 = create_op_node (NodeType.AND, temp0, temp1 );
                    result = temp2;
                    break;
                }
                case 84: // i1 i2 and i3 i4 xor neg and
                {
                    int temp0 = create (NodeType.AND, ll_nn, lr_nn );
                    int temp1 = create (NodeType.XOR, rl_nn, rr_nn );
                    int temp2 = create_op_node (NodeType.AND, temp0, NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 85: // i1 neg i2 and i3 i4 xor neg and
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), lr_nn );
                    int temp1 = create (NodeType.XOR, rl_nn, rr_nn );
                    int temp2 = create_op_node (NodeType.AND, temp0, NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 86: // i1 i2 neg and i3 i4 xor neg and
                {
                    int temp0 = create (NodeType.AND, ll_nn, NEGATE( lr_nn ) );
                    int temp1 = create (NodeType.XOR, rl_nn, rr_nn );
                    int temp2 = create_op_node (NodeType.AND, temp0, NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 87: // i1 neg i2 neg and i3 i4 xor neg and
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), NEGATE( lr_nn ) );
                    int temp1 = create (NodeType.XOR, rl_nn, rr_nn );
                    int temp2 = create_op_node (NodeType.AND, temp0, NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 88: // i1 i2 and neg i3 i4 xor and
                {
                    int temp0 = create (NodeType.AND, ll_nn, lr_nn );
                    int temp1 = create (NodeType.XOR, rl_nn, rr_nn );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), temp1 );
                    result = temp2;
                    break;
                }
                case 89: // i1 neg i2 and neg i3 i4 xor and
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), lr_nn );
                    int temp1 = create (NodeType.XOR, rl_nn, rr_nn );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), temp1 );
                    result = temp2;
                    break;
                }
                case 90: // i1 i2 neg and neg i3 i4 xor and
                {
                    int temp0 = create (NodeType.AND, ll_nn, NEGATE( lr_nn ) );
                    int temp1 = create (NodeType.XOR, rl_nn, rr_nn );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), temp1 );
                    result = temp2;
                    break;
                }
                case 91: // i1 neg i2 neg and neg i3 i4 xor and
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), NEGATE( lr_nn ) );
                    int temp1 = create (NodeType.XOR, rl_nn, rr_nn );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), temp1 );
                    result = temp2;
                    break;
                }
                case 92: // i1 i2 and neg i3 i4 xor neg and
                {
                    int temp0 = create (NodeType.AND, ll_nn, lr_nn );
                    int temp1 = create (NodeType.XOR, rl_nn, rr_nn );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 93: // i1 neg i2 and neg i3 i4 xor neg and
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), lr_nn );
                    int temp1 = create (NodeType.XOR, rl_nn, rr_nn );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 94: // i1 i2 neg and neg i3 i4 xor neg and
                {
                    int temp0 = create (NodeType.AND, ll_nn, NEGATE( lr_nn ) );
                    int temp1 = create (NodeType.XOR, rl_nn, rr_nn );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 95: // i1 neg i2 neg and neg i3 i4 xor neg and
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), NEGATE( lr_nn ) );
                    int temp1 = create (NodeType.XOR, rl_nn, rr_nn );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 96: // i1 i2 xor i3 i4 xor and
                {
                    int temp0 = create (NodeType.XOR, ll_nn, lr_nn );
                    int temp1 = create (NodeType.XOR, rl_nn, rr_nn );
                    int temp2 = create_op_node (NodeType.AND, temp0, temp1 );
                    result = temp2;
                    break;
                }
                case 97: // i1 i2 xor neg i3 i4 xor and
                {
                    int temp0 = create (NodeType.XOR, ll_nn, lr_nn );
                    int temp1 = create (NodeType.XOR, rl_nn, rr_nn );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), temp1 );
                    result = temp2;
                    break;
                }
                case 98: // i1 i2 xor i3 i4 xor neg and
                {
                    int temp0 = create (NodeType.XOR, ll_nn, lr_nn );
                    int temp1 = create (NodeType.XOR, rl_nn, rr_nn );
                    int temp2 = create_op_node (NodeType.AND, temp0, NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 99: // i1 i2 xor neg i3 i4 xor neg and
                {
                    int temp0 = create (NodeType.XOR, ll_nn, lr_nn );
                    int temp1 = create (NodeType.XOR, rl_nn, rr_nn );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 100: // i1 i2 and i3 i4 and xor
                {
                    int temp0 = create (NodeType.AND, ll_nn, lr_nn );
                    int temp1 = create (NodeType.AND, rl_nn, rr_nn );
                    int temp2 = create_op_node (NodeType.XOR, temp0, temp1 );
                    result = temp2;
                    break;
                }
                case 101: // i1 neg i2 and i3 i4 and xor
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), lr_nn );
                    int temp1 = create (NodeType.AND, rl_nn, rr_nn );
                    int temp2 = create_op_node (NodeType.XOR, temp0, temp1 );
                    result = temp2;
                    break;
                }
                case 102: // i1 i2 neg and i3 i4 and xor
                {
                    int temp0 = create (NodeType.AND, ll_nn, NEGATE( lr_nn ) );
                    int temp1 = create (NodeType.AND, rl_nn, rr_nn );
                    int temp2 = create_op_node (NodeType.XOR, temp0, temp1 );
                    result = temp2;
                    break;
                }
                case 103: // i1 neg i2 neg and i3 i4 and xor
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), NEGATE( lr_nn ) );
                    int temp1 = create (NodeType.AND, rl_nn, rr_nn );
                    int temp2 = create_op_node (NodeType.XOR, temp0, temp1 );
                    result = temp2;
                    break;
                }
                case 104: // i1 i2 and i3 neg i4 and xor
                {
                    int temp0 = create (NodeType.AND, ll_nn, lr_nn );
                    int temp1 = create (NodeType.AND, NEGATE( rl_nn ), rr_nn );
                    int temp2 = create_op_node (NodeType.XOR, temp0, temp1 );
                    result = temp2;
                    break;
                }
                case 105: // i1 neg i2 and i3 neg i4 and xor
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), lr_nn );
                    int temp1 = create (NodeType.AND, NEGATE( rl_nn ), rr_nn );
                    int temp2 = create_op_node (NodeType.XOR, temp0, temp1 );
                    result = temp2;
                    break;
                }
                case 106: // i1 i2 neg and i3 neg i4 and xor
                {
                    int temp0 = create (NodeType.AND, ll_nn, NEGATE( lr_nn ) );
                    int temp1 = create (NodeType.AND, NEGATE( rl_nn ), rr_nn );
                    int temp2 = create_op_node (NodeType.XOR, temp0, temp1 );
                    result = temp2;
                    break;
                }
                case 107: // i1 neg i2 neg and i3 neg i4 and xor
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), NEGATE( lr_nn ) );
                    int temp1 = create (NodeType.AND, NEGATE( rl_nn ), rr_nn );
                    int temp2 = create_op_node (NodeType.XOR, temp0, temp1 );
                    result = temp2;
                    break;
                }
                case 108: // i1 i2 and i3 i4 neg and xor
                {
                    int temp0 = create (NodeType.AND, ll_nn, lr_nn );
                    int temp1 = create (NodeType.AND, rl_nn, NEGATE( rr_nn ) );
                    int temp2 = create_op_node (NodeType.XOR, temp0, temp1 );
                    result = temp2;
                    break;
                }
                case 109: // i1 neg i2 and i3 i4 neg and xor
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), lr_nn );
                    int temp1 = create (NodeType.AND, rl_nn, NEGATE( rr_nn ) );
                    int temp2 = create_op_node (NodeType.XOR, temp0, temp1 );
                    result = temp2;
                    break;
                }
                case 110: // i1 i2 neg and i3 i4 neg and xor
                {
                    int temp0 = create (NodeType.AND, ll_nn, NEGATE( lr_nn ) );
                    int temp1 = create (NodeType.AND, rl_nn, NEGATE( rr_nn ) );
                    int temp2 = create_op_node (NodeType.XOR, temp0, temp1 );
                    result = temp2;
                    break;
                }
                case 111: // i1 neg i2 neg and i3 i4 neg and xor
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), NEGATE( lr_nn ) );
                    int temp1 = create (NodeType.AND, rl_nn, NEGATE( rr_nn ) );
                    int temp2 = create_op_node (NodeType.XOR, temp0, temp1 );
                    result = temp2;
                    break;
                }
                case 112: // i1 i2 and i3 neg i4 neg and xor
                {
                    int temp0 = create (NodeType.AND, ll_nn, lr_nn );
                    int temp1 = create (NodeType.AND, NEGATE( rl_nn ), NEGATE( rr_nn ) );
                    int temp2 = create_op_node (NodeType.XOR, temp0, temp1 );
                    result = temp2;
                    break;
                }
                case 113: // i1 neg i2 and i3 neg i4 neg and xor
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), lr_nn );
                    int temp1 = create (NodeType.AND, NEGATE( rl_nn ), NEGATE( rr_nn ) );
                    int temp2 = create_op_node (NodeType.XOR, temp0, temp1 );
                    result = temp2;
                    break;
                }
                case 114: // i1 i2 neg and i3 neg i4 neg and xor
                {
                    int temp0 = create (NodeType.AND, ll_nn, NEGATE( lr_nn ) );
                    int temp1 = create (NodeType.AND, NEGATE( rl_nn ), NEGATE( rr_nn ) );
                    int temp2 = create_op_node (NodeType.XOR, temp0, temp1 );
                    result = temp2;
                    break;
                }
                case 115: // i1 neg i2 neg and i3 neg i4 neg and xor
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), NEGATE( lr_nn ) );
                    int temp1 = create (NodeType.AND, NEGATE( rl_nn ), NEGATE( rr_nn ) );
                    int temp2 = create_op_node (NodeType.XOR, temp0, temp1 );
                    result = temp2;
                    break;
                }
                case 116: // i1 i2 and i3 i4 and xor neg
                {
                    int temp0 = create (NodeType.AND, ll_nn, lr_nn );
                    int temp1 = create (NodeType.AND, rl_nn, rr_nn );
                    int temp2 = create_op_node (NodeType.XOR, temp0, temp1 );
                    result = NEGATE( temp2 );
                    break;
                }
                case 117: // i1 neg i2 and i3 i4 and xor neg
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), lr_nn );
                    int temp1 = create (NodeType.AND, rl_nn, rr_nn );
                    int temp2 = create_op_node (NodeType.XOR, temp0, temp1 );
                    result = NEGATE( temp2 );
                    break;
                }
                case 118: // i1 i2 neg and i3 i4 and xor neg
                {
                    int temp0 = create (NodeType.AND, ll_nn, NEGATE( lr_nn ) );
                    int temp1 = create (NodeType.AND, rl_nn, rr_nn );
                    int temp2 = create_op_node (NodeType.XOR, temp0, temp1 );
                    result = NEGATE( temp2 );
                    break;
                }
                case 119: // i1 neg i2 neg and i3 i4 and xor neg
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), NEGATE( lr_nn ) );
                    int temp1 = create (NodeType.AND, rl_nn, rr_nn );
                    int temp2 = create_op_node (NodeType.XOR, temp0, temp1 );
                    result = NEGATE( temp2 );
                    break;
                }
                case 120: // i1 i2 and i3 neg i4 and xor neg
                {
                    int temp0 = create (NodeType.AND, ll_nn, lr_nn );
                    int temp1 = create (NodeType.AND, NEGATE( rl_nn ), rr_nn );
                    int temp2 = create_op_node (NodeType.XOR, temp0, temp1 );
                    result = NEGATE( temp2 );
                    break;
                }
                case 121: // i1 neg i2 and i3 neg i4 and xor neg
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), lr_nn );
                    int temp1 = create (NodeType.AND, NEGATE( rl_nn ), rr_nn );
                    int temp2 = create_op_node (NodeType.XOR, temp0, temp1 );
                    result = NEGATE( temp2 );
                    break;
                }
                case 122: // i1 i2 neg and i3 neg i4 and xor neg
                {
                    int temp0 = create (NodeType.AND, ll_nn, NEGATE( lr_nn ) );
                    int temp1 = create (NodeType.AND, NEGATE( rl_nn ), rr_nn );
                    int temp2 = create_op_node (NodeType.XOR, temp0, temp1 );
                    result = NEGATE( temp2 );
                    break;
                }
                case 123: // i1 neg i2 neg and i3 neg i4 and xor neg
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), NEGATE( lr_nn ) );
                    int temp1 = create (NodeType.AND, NEGATE( rl_nn ), rr_nn );
                    int temp2 = create_op_node (NodeType.XOR, temp0, temp1 );
                    result = NEGATE( temp2 );
                    break;
                }
                case 124: // i1 i2 and i3 i4 neg and xor neg
                {
                    int temp0 = create (NodeType.AND, ll_nn, lr_nn );
                    int temp1 = create (NodeType.AND, rl_nn, NEGATE( rr_nn ) );
                    int temp2 = create_op_node (NodeType.XOR, temp0, temp1 );
                    result = NEGATE( temp2 );
                    break;
                }
                case 125: // i1 neg i2 and i3 i4 neg and xor neg
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), lr_nn );
                    int temp1 = create (NodeType.AND, rl_nn, NEGATE( rr_nn ) );
                    int temp2 = create_op_node (NodeType.XOR, temp0, temp1 );
                    result = NEGATE( temp2 );
                    break;
                }
                case 126: // i1 i2 neg and i3 i4 neg and xor neg
                {
                    int temp0 = create (NodeType.AND, ll_nn, NEGATE( lr_nn ) );
                    int temp1 = create (NodeType.AND, rl_nn, NEGATE( rr_nn ) );
                    int temp2 = create_op_node (NodeType.XOR, temp0, temp1 );
                    result = NEGATE( temp2 );
                    break;
                }
                case 127: // i1 neg i2 neg and i3 i4 neg and xor neg
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), NEGATE( lr_nn ) );
                    int temp1 = create (NodeType.AND, rl_nn, NEGATE( rr_nn ) );
                    int temp2 = create_op_node (NodeType.XOR, temp0, temp1 );
                    result = NEGATE( temp2 );
                    break;
                }
                case 128: // i1 i2 and i3 neg i4 neg and xor neg
                {
                    int temp0 = create (NodeType.AND, ll_nn, lr_nn );
                    int temp1 = create (NodeType.AND, NEGATE( rl_nn ), NEGATE( rr_nn ) );
                    int temp2 = create_op_node (NodeType.XOR, temp0, temp1 );
                    result = NEGATE( temp2 );
                    break;
                }
                case 129: // i1 neg i2 and i3 neg i4 neg and xor neg
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), lr_nn );
                    int temp1 = create (NodeType.AND, NEGATE( rl_nn ), NEGATE( rr_nn ) );
                    int temp2 = create_op_node (NodeType.XOR, temp0, temp1 );
                    result = NEGATE( temp2 );
                    break;
                }
                case 130: // i1 i2 neg and i3 neg i4 neg and xor neg
                {
                    int temp0 = create (NodeType.AND, ll_nn, NEGATE( lr_nn ) );
                    int temp1 = create (NodeType.AND, NEGATE( rl_nn ), NEGATE( rr_nn ) );
                    int temp2 = create_op_node (NodeType.XOR, temp0, temp1 );
                    result = NEGATE( temp2 );
                    break;
                }
                case 131: // i1 neg i2 neg and i3 neg i4 neg and xor neg
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), NEGATE( lr_nn ) );
                    int temp1 = create (NodeType.AND, NEGATE( rl_nn ), NEGATE( rr_nn ) );
                    int temp2 = create_op_node (NodeType.XOR, temp0, temp1 );
                    result = NEGATE( temp2 );
                    break;
                }
                case 132: // i1 i2 xor i3 i4 and xor
                {
                    int temp0 = create (NodeType.XOR, ll_nn, lr_nn );
                    int temp1 = create (NodeType.AND, rl_nn, rr_nn );
                    int temp2 = create_op_node (NodeType.XOR, temp0, temp1 );
                    result = temp2;
                    break;
                }
                case 133: // i1 i2 xor i3 i4 and xor neg
                {
                    int temp0 = create (NodeType.XOR, ll_nn, lr_nn );
                    int temp1 = create (NodeType.AND, rl_nn, rr_nn );
                    int temp2 = create_op_node (NodeType.XOR, temp0, temp1 );
                    result = NEGATE( temp2 );
                    break;
                }
                case 134: // i1 i2 xor i3 neg i4 and xor
                {
                    int temp0 = create (NodeType.XOR, ll_nn, lr_nn );
                    int temp1 = create (NodeType.AND, NEGATE( rl_nn ), rr_nn );
                    int temp2 = create_op_node (NodeType.XOR, temp0, temp1 );
                    result = temp2;
                    break;
                }
                case 135: // i1 i2 xor i3 neg i4 and xor neg
                {
                    int temp0 = create (NodeType.XOR, ll_nn, lr_nn );
                    int temp1 = create (NodeType.AND, NEGATE( rl_nn ), rr_nn );
                    int temp2 = create_op_node (NodeType.XOR, temp0, temp1 );
                    result = NEGATE( temp2 );
                    break;
                }
                case 136: // i1 i2 xor i3 i4 neg and xor
                {
                    int temp0 = create (NodeType.XOR, ll_nn, lr_nn );
                    int temp1 = create (NodeType.AND, rl_nn, NEGATE( rr_nn ) );
                    int temp2 = create_op_node (NodeType.XOR, temp0, temp1 );
                    result = temp2;
                    break;
                }
                case 137: // i1 i2 xor i3 i4 neg and xor neg
                {
                    int temp0 = create (NodeType.XOR, ll_nn, lr_nn );
                    int temp1 = create (NodeType.AND, rl_nn, NEGATE( rr_nn ) );
                    int temp2 = create_op_node (NodeType.XOR, temp0, temp1 );
                    result = NEGATE( temp2 );
                    break;
                }
                case 138: // i1 i2 xor i3 neg i4 neg and xor
                {
                    int temp0 = create (NodeType.XOR, ll_nn, lr_nn );
                    int temp1 = create (NodeType.AND, NEGATE( rl_nn ), NEGATE( rr_nn ) );
                    int temp2 = create_op_node (NodeType.XOR, temp0, temp1 );
                    result = temp2;
                    break;
                }
                case 139: // i1 i2 xor i3 neg i4 neg and xor neg
                {
                    int temp0 = create (NodeType.XOR, ll_nn, lr_nn );
                    int temp1 = create (NodeType.AND, NEGATE( rl_nn ), NEGATE( rr_nn ) );
                    int temp2 = create_op_node (NodeType.XOR, temp0, temp1 );
                    result = NEGATE( temp2 );
                    break;
                }
                case 140: // i1 i2 and i3 i4 xor xor
                {
                    int temp0 = create (NodeType.AND, ll_nn, lr_nn );
                    int temp1 = create (NodeType.XOR, rl_nn, rr_nn );
                    int temp2 = create_op_node (NodeType.XOR, temp0, temp1 );
                    result = temp2;
                    break;
                }
                case 141: // i1 neg i2 and i3 i4 xor xor
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), lr_nn );
                    int temp1 = create (NodeType.XOR, rl_nn, rr_nn );
                    int temp2 = create_op_node (NodeType.XOR, temp0, temp1 );
                    result = temp2;
                    break;
                }
                case 142: // i1 i2 neg and i3 i4 xor xor
                {
                    int temp0 = create (NodeType.AND, ll_nn, NEGATE( lr_nn ) );
                    int temp1 = create (NodeType.XOR, rl_nn, rr_nn );
                    int temp2 = create_op_node (NodeType.XOR, temp0, temp1 );
                    result = temp2;
                    break;
                }
                case 143: // i1 neg i2 neg and i3 i4 xor xor
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), NEGATE( lr_nn ) );
                    int temp1 = create (NodeType.XOR, rl_nn, rr_nn );
                    int temp2 = create_op_node (NodeType.XOR, temp0, temp1 );
                    result = temp2;
                    break;
                }
                case 144: // i1 i2 and i3 i4 xor xor neg
                {
                    int temp0 = create (NodeType.AND, ll_nn, lr_nn );
                    int temp1 = create (NodeType.XOR, rl_nn, rr_nn );
                    int temp2 = create_op_node (NodeType.XOR, temp0, temp1 );
                    result = NEGATE( temp2 );
                    break;
                }
                case 145: // i1 neg i2 and i3 i4 xor xor neg
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), lr_nn );
                    int temp1 = create (NodeType.XOR, rl_nn, rr_nn );
                    int temp2 = create_op_node (NodeType.XOR, temp0, temp1 );
                    result = NEGATE( temp2 );
                    break;
                }
                case 146: // i1 i2 neg and i3 i4 xor xor neg
                {
                    int temp0 = create (NodeType.AND, ll_nn, NEGATE( lr_nn ) );
                    int temp1 = create (NodeType.XOR, rl_nn, rr_nn );
                    int temp2 = create_op_node (NodeType.XOR, temp0, temp1 );
                    result = NEGATE( temp2 );
                    break;
                }
                case 147: // i1 neg i2 neg and i3 i4 xor xor neg
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), NEGATE( lr_nn ) );
                    int temp1 = create (NodeType.XOR, rl_nn, rr_nn );
                    int temp2 = create_op_node (NodeType.XOR, temp0, temp1 );
                    result = NEGATE( temp2 );
                    break;
                }
                case 148: // i1 i2 xor i3 i4 xor xor
                {
                    int temp0 = create (NodeType.XOR, ll_nn, lr_nn );
                    int temp1 = create (NodeType.XOR, rl_nn, rr_nn );
                    int temp2 = create_op_node (NodeType.XOR, temp0, temp1 );
                    result = temp2;
                    break;
                }
                case 149: // i1 i2 xor i3 i4 xor xor neg
                {
                    int temp0 = create (NodeType.XOR, ll_nn, lr_nn );
                    int temp1 = create (NodeType.XOR, rl_nn, rr_nn );
                    int temp2 = create_op_node (NodeType.XOR, temp0, temp1 );
                    result = NEGATE( temp2 );
                    break;
                }
                case 150: // i1 i2 and i4 and
                {
                    int temp0 = create (NodeType.AND, ll_nn, lr_nn );
                    int temp1 = create_op_node (NodeType.AND, temp0, rr_nn );
                    result = temp1;
                    break;
                }
                case 151: // i1 neg i2 and i4 and
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), lr_nn );
                    int temp1 = create_op_node (NodeType.AND, temp0, rr_nn );
                    result = temp1;
                    break;
                }
                case 152: // neg
                {
                    result = zero();
                    break;
                }
                case 153: // i1 i2 neg and i4 and
                {
                    int temp0 = create (NodeType.AND, ll_nn, NEGATE( lr_nn ) );
                    int temp1 = create_op_node (NodeType.AND, temp0, rr_nn );
                    result = temp1;
                    break;
                }
                case 154: // i1 neg i2 neg and i4 and
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), NEGATE( lr_nn ) );
                    int temp1 = create_op_node (NodeType.AND, temp0, rr_nn );
                    result = temp1;
                    break;
                }
                case 155: // i1 i2 and i4 neg and
                {
                    int temp0 = create (NodeType.AND, ll_nn, lr_nn );
                    int temp1 = create_op_node (NodeType.AND, temp0, NEGATE( rr_nn ) );
                    result = temp1;
                    break;
                }
                case 156: // i1 neg i2 and i4 neg and
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), lr_nn );
                    int temp1 = create_op_node (NodeType.AND, temp0, NEGATE( rr_nn ) );
                    result = temp1;
                    break;
                }
                case 157: // i1 i2 neg and i4 neg and
                {
                    int temp0 = create (NodeType.AND, ll_nn, NEGATE( lr_nn ) );
                    int temp1 = create_op_node (NodeType.AND, temp0, NEGATE( rr_nn ) );
                    result = temp1;
                    break;
                }
                case 158: // i1 neg i2 neg and i4 neg and
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), NEGATE( lr_nn ) );
                    int temp1 = create_op_node (NodeType.AND, temp0, NEGATE( rr_nn ) );
                    result = temp1;
                    break;
                }
                case 159: // i2 i4 and
                {
                    int temp0 = create_op_node (NodeType.AND, lr_nn, rr_nn );
                    result = temp0;
                    break;
                }
                case 160: // i2 neg i4 and
                {
                    int temp0 = create_op_node (NodeType.AND, NEGATE( lr_nn ), rr_nn );
                    result = temp0;
                    break;
                }
                case 161: // i2 i4 neg and
                {
                    int temp0 = create_op_node (NodeType.AND, lr_nn, NEGATE( rr_nn ) );
                    result = temp0;
                    break;
                }
                case 162: // i2 neg i4 neg and
                {
                    int temp0 = create_op_node (NodeType.AND, NEGATE( lr_nn ), NEGATE( rr_nn ) );
                    result = temp0;
                    break;
                }
                case 163: // i1 i2 neg and
                {
                    int temp0 = create_op_node (NodeType.AND, ll_nn, NEGATE( lr_nn ) );
                    result = temp0;
                    break;
                }
                case 164: // i1 neg i2 neg and
                {
                    int temp0 = create_op_node (NodeType.AND, NEGATE( ll_nn ), NEGATE( lr_nn ) );
                    result = temp0;
                    break;
                }
                case 165: // i1 i2 and
                {
                    int temp0 = create_op_node (NodeType.AND, ll_nn, lr_nn );
                    result = temp0;
                    break;
                }
                case 166: // i1 neg i2 and
                {
                    int temp0 = create_op_node (NodeType.AND, NEGATE( ll_nn ), lr_nn );
                    result = temp0;
                    break;
                }
                case 167: // i1 neg i4 neg and neg i2 and neg
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), NEGATE( rr_nn ) );
                    int temp1 = create_op_node (NodeType.AND, NEGATE( temp0 ), lr_nn );
                    result = NEGATE( temp1 );
                    break;
                }
                case 168: // i1 i4 neg and neg i2 and neg
                {
                    int temp0 = create (NodeType.AND, ll_nn, NEGATE( rr_nn ) );
                    int temp1 = create_op_node (NodeType.AND, NEGATE( temp0 ), lr_nn );
                    result = NEGATE( temp1 );
                    break;
                }
                case 169: // i1 i2 neg and neg i2 i4 and neg and
                {
                    int temp0 = create (NodeType.AND, ll_nn, NEGATE( lr_nn ) );
                    int temp1 = create (NodeType.AND, lr_nn, rr_nn );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 170: // i1 i2 neg and neg i2 i4 neg and neg and neg
                {
                    int temp0 = create (NodeType.AND, ll_nn, NEGATE( lr_nn ) );
                    int temp1 = create (NodeType.AND, lr_nn, NEGATE( rr_nn ) );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( temp1 ) );
                    result = NEGATE( temp2 );
                    break;
                }
                case 171: // i1 i2 and neg i2 neg i4 and neg and
                {
                    int temp0 = create (NodeType.AND, ll_nn, lr_nn );
                    int temp1 = create (NodeType.AND, NEGATE( lr_nn ), rr_nn );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 172: // i1 i2 and neg i2 neg i4 neg and neg and neg
                {
                    int temp0 = create (NodeType.AND, ll_nn, lr_nn );
                    int temp1 = create (NodeType.AND, NEGATE( lr_nn ), NEGATE( rr_nn ) );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( temp1 ) );
                    result = NEGATE( temp2 );
                    break;
                }
                case 173: // i1 neg i4 neg and neg i2 neg and neg
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), NEGATE( rr_nn ) );
                    int temp1 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( lr_nn ) );
                    result = NEGATE( temp1 );
                    break;
                }
                case 174: // i1 i4 neg and neg i2 neg and neg
                {
                    int temp0 = create (NodeType.AND, ll_nn, NEGATE( rr_nn ) );
                    int temp1 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( lr_nn ) );
                    result = NEGATE( temp1 );
                    break;
                }
                case 175: // i1 neg i4 and neg i2 and neg
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), rr_nn );
                    int temp1 = create_op_node (NodeType.AND, NEGATE( temp0 ), lr_nn );
                    result = NEGATE( temp1 );
                    break;
                }
                case 176: // i1 i4 and neg i2 and neg
                {
                    int temp0 = create (NodeType.AND, ll_nn, rr_nn );
                    int temp1 = create_op_node (NodeType.AND, NEGATE( temp0 ), lr_nn );
                    result = NEGATE( temp1 );
                    break;
                }
                case 177: // i1 i2 neg and neg i2 i4 neg and neg and
                {
                    int temp0 = create (NodeType.AND, ll_nn, NEGATE( lr_nn ) );
                    int temp1 = create (NodeType.AND, lr_nn, NEGATE( rr_nn ) );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 178: // i1 i2 neg and neg i2 i4 and neg and neg
                {
                    int temp0 = create (NodeType.AND, ll_nn, NEGATE( lr_nn ) );
                    int temp1 = create (NodeType.AND, lr_nn, rr_nn );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( temp1 ) );
                    result = NEGATE( temp2 );
                    break;
                }
                case 179: // i1 i2 and neg i2 neg i4 neg and neg and
                {
                    int temp0 = create (NodeType.AND, ll_nn, lr_nn );
                    int temp1 = create (NodeType.AND, NEGATE( lr_nn ), NEGATE( rr_nn ) );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 180: // i1 i2 and neg i2 neg i4 and neg and neg
                {
                    int temp0 = create (NodeType.AND, ll_nn, lr_nn );
                    int temp1 = create (NodeType.AND, NEGATE( lr_nn ), rr_nn );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( temp1 ) );
                    result = NEGATE( temp2 );
                    break;
                }
                case 181: // i1 neg i4 and neg i2 neg and neg
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), rr_nn );
                    int temp1 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( lr_nn ) );
                    result = NEGATE( temp1 );
                    break;
                }
                case 182: // i1 i4 and neg i2 neg and neg
                {
                    int temp0 = create (NodeType.AND, ll_nn, rr_nn );
                    int temp1 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( lr_nn ) );
                    result = NEGATE( temp1 );
                    break;
                }
                case 183: // i1 i2 xor i2 i4 and neg and
                {
                    int temp0 = create (NodeType.XOR, ll_nn, lr_nn );
                    int temp1 = create (NodeType.AND, lr_nn, rr_nn );
                    int temp2 = create_op_node (NodeType.AND, temp0, NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 184: // i1 i2 xor neg i1 i4 and neg and
                {
                    int temp0 = create (NodeType.XOR, ll_nn, lr_nn );
                    int temp1 = create (NodeType.AND, ll_nn, rr_nn );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 185: // i1 i2 xor i1 i4 and neg and
                {
                    int temp0 = create (NodeType.XOR, ll_nn, lr_nn );
                    int temp1 = create (NodeType.AND, ll_nn, rr_nn );
                    int temp2 = create_op_node (NodeType.AND, temp0, NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 186: // i1 i2 xor neg i1 neg i4 and neg and
                {
                    int temp0 = create (NodeType.XOR, ll_nn, lr_nn );
                    int temp1 = create (NodeType.AND, NEGATE( ll_nn ), rr_nn );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 187: // i1 i2 xor i2 i4 neg and neg and
                {
                    int temp0 = create (NodeType.XOR, ll_nn, lr_nn );
                    int temp1 = create (NodeType.AND, lr_nn, NEGATE( rr_nn ) );
                    int temp2 = create_op_node (NodeType.AND, temp0, NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 188: // i1 i2 xor neg i1 i4 neg and neg and
                {
                    int temp0 = create (NodeType.XOR, ll_nn, lr_nn );
                    int temp1 = create (NodeType.AND, ll_nn, NEGATE( rr_nn ) );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 189: // i1 i2 xor i1 i4 neg and neg and
                {
                    int temp0 = create (NodeType.XOR, ll_nn, lr_nn );
                    int temp1 = create (NodeType.AND, ll_nn, NEGATE( rr_nn ) );
                    int temp2 = create_op_node (NodeType.AND, temp0, NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 190: // i1 i2 xor neg i1 neg i4 neg and neg and
                {
                    int temp0 = create (NodeType.XOR, ll_nn, lr_nn );
                    int temp1 = create (NodeType.AND, NEGATE( ll_nn ), NEGATE( rr_nn ) );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 191: // i1 i2 and neg i2 i4 xor and
                {
                    int temp0 = create (NodeType.AND, ll_nn, lr_nn );
                    int temp1 = create (NodeType.XOR, lr_nn, rr_nn );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), temp1 );
                    result = temp2;
                    break;
                }
                case 192: // i1 neg i2 and neg i2 i4 xor and
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), lr_nn );
                    int temp1 = create (NodeType.XOR, lr_nn, rr_nn );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), temp1 );
                    result = temp2;
                    break;
                }
                case 193: // i1 i4 and neg i2 i4 xor and
                {
                    int temp0 = create (NodeType.AND, ll_nn, rr_nn );
                    int temp1 = create (NodeType.XOR, lr_nn, rr_nn );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), temp1 );
                    result = temp2;
                    break;
                }
                case 194: // i1 neg i4 and neg i2 i4 xor and
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), rr_nn );
                    int temp1 = create (NodeType.XOR, lr_nn, rr_nn );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), temp1 );
                    result = temp2;
                    break;
                }
                case 195: // i1 i2 and neg i2 i4 xor neg and
                {
                    int temp0 = create (NodeType.AND, ll_nn, lr_nn );
                    int temp1 = create (NodeType.XOR, lr_nn, rr_nn );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 196: // i1 neg i2 and neg i2 i4 xor neg and
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), lr_nn );
                    int temp1 = create (NodeType.XOR, lr_nn, rr_nn );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 197: // i1 i2 neg and neg i2 i4 xor neg and
                {
                    int temp0 = create (NodeType.AND, ll_nn, NEGATE( lr_nn ) );
                    int temp1 = create (NodeType.XOR, lr_nn, rr_nn );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 198: // i1 neg i2 neg and neg i2 i4 xor neg and
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), NEGATE( lr_nn ) );
                    int temp1 = create (NodeType.XOR, lr_nn, rr_nn );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 199: // i1 i2 xor i2 i4 xor and
                {
                    int temp0 = create (NodeType.XOR, ll_nn, lr_nn );
                    int temp1 = create (NodeType.XOR, lr_nn, rr_nn );
                    int temp2 = create_op_node (NodeType.AND, temp0, temp1 );
                    result = temp2;
                    break;
                }
                case 200: // i1 i4 xor i2 i4 xor and
                {
                    int temp0 = create (NodeType.XOR, ll_nn, rr_nn );
                    int temp1 = create (NodeType.XOR, lr_nn, rr_nn );
                    int temp2 = create_op_node (NodeType.AND, temp0, temp1 );
                    result = temp2;
                    break;
                }
                case 201: // i1 i2 xor i1 i4 xor and
                {
                    int temp0 = create (NodeType.XOR, ll_nn, lr_nn );
                    int temp1 = create (NodeType.XOR, ll_nn, rr_nn );
                    int temp2 = create_op_node (NodeType.AND, temp0, temp1 );
                    result = temp2;
                    break;
                }
                case 202: // i1 i2 xor neg i1 i4 xor neg and
                {
                    int temp0 = create (NodeType.XOR, ll_nn, lr_nn );
                    int temp1 = create (NodeType.XOR, ll_nn, rr_nn );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 203: // i1 i4 xor i2 and
                {
                    int temp0 = create (NodeType.XOR, ll_nn, rr_nn );
                    int temp1 = create_op_node (NodeType.AND, temp0, lr_nn );
                    result = temp1;
                    break;
                }
                case 204: // i1 i4 xor neg i2 and
                {
                    int temp0 = create (NodeType.XOR, ll_nn, rr_nn );
                    int temp1 = create_op_node (NodeType.AND, NEGATE( temp0 ), lr_nn );
                    result = temp1;
                    break;
                }
                case 205: // i1 i4 xor i2 neg and
                {
                    int temp0 = create (NodeType.XOR, ll_nn, rr_nn );
                    int temp1 = create_op_node (NodeType.AND, temp0, NEGATE( lr_nn ) );
                    result = temp1;
                    break;
                }
                case 206: // i1 i4 xor neg i2 neg and
                {
                    int temp0 = create (NodeType.XOR, ll_nn, rr_nn );
                    int temp1 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( lr_nn ) );
                    result = temp1;
                    break;
                }
                case 207: // i1 i4 xor i2 and neg
                {
                    int temp0 = create (NodeType.XOR, ll_nn, rr_nn );
                    int temp1 = create_op_node (NodeType.AND, temp0, lr_nn );
                    result = NEGATE( temp1 );
                    break;
                }
                case 208: // i1 i4 xor neg i2 and neg
                {
                    int temp0 = create (NodeType.XOR, ll_nn, rr_nn );
                    int temp1 = create_op_node (NodeType.AND, NEGATE( temp0 ), lr_nn );
                    result = NEGATE( temp1 );
                    break;
                }
                case 209: // i1 i4 xor i2 neg and neg
                {
                    int temp0 = create (NodeType.XOR, ll_nn, rr_nn );
                    int temp1 = create_op_node (NodeType.AND, temp0, NEGATE( lr_nn ) );
                    result = NEGATE( temp1 );
                    break;
                }
                case 210: // i1 i4 xor neg i2 neg and neg
                {
                    int temp0 = create (NodeType.XOR, ll_nn, rr_nn );
                    int temp1 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( lr_nn ) );
                    result = NEGATE( temp1 );
                    break;
                }
                case 211: // i2 i4 neg and i1 xor
                {
                    int temp0 = create (NodeType.AND, lr_nn, NEGATE( rr_nn ) );
                    int temp1 = create_op_node (NodeType.XOR, temp0, ll_nn );
                    result = temp1;
                    break;
                }
                case 212: // i2 i4 neg and i1 xor neg
                {
                    int temp0 = create (NodeType.AND, lr_nn, NEGATE( rr_nn ) );
                    int temp1 = create_op_node (NodeType.XOR, temp0, ll_nn );
                    result = NEGATE( temp1 );
                    break;
                }
                case 213: // i2 neg i4 neg and i1 xor neg
                {
                    int temp0 = create (NodeType.AND, NEGATE( lr_nn ), NEGATE( rr_nn ) );
                    int temp1 = create_op_node (NodeType.XOR, temp0, ll_nn );
                    result = NEGATE( temp1 );
                    break;
                }
                case 214: // i2 neg i4 neg and i1 xor
                {
                    int temp0 = create (NodeType.AND, NEGATE( lr_nn ), NEGATE( rr_nn ) );
                    int temp1 = create_op_node (NodeType.XOR, temp0, ll_nn );
                    result = temp1;
                    break;
                }
                case 215: // i2 i4 and i1 xor
                {
                    int temp0 = create (NodeType.AND, lr_nn, rr_nn );
                    int temp1 = create_op_node (NodeType.XOR, temp0, ll_nn );
                    result = temp1;
                    break;
                }
                case 216: // i2 i4 and i1 xor neg
                {
                    int temp0 = create (NodeType.AND, lr_nn, rr_nn );
                    int temp1 = create_op_node (NodeType.XOR, temp0, ll_nn );
                    result = NEGATE( temp1 );
                    break;
                }
                case 217: // i2 neg i4 and i1 xor neg
                {
                    int temp0 = create (NodeType.AND, NEGATE( lr_nn ), rr_nn );
                    int temp1 = create_op_node (NodeType.XOR, temp0, ll_nn );
                    result = NEGATE( temp1 );
                    break;
                }
                case 218: // i2 neg i4 and i1 xor
                {
                    int temp0 = create (NodeType.AND, NEGATE( lr_nn ), rr_nn );
                    int temp1 = create_op_node (NodeType.XOR, temp0, ll_nn );
                    result = temp1;
                    break;
                }
                case 219: // i1 neg i2 and i4 xor
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), lr_nn );
                    int temp1 = create_op_node (NodeType.XOR, temp0, rr_nn );
                    result = temp1;
                    break;
                }
                case 220: // i1 i2 and i4 xor
                {
                    int temp0 = create (NodeType.AND, ll_nn, lr_nn );
                    int temp1 = create_op_node (NodeType.XOR, temp0, rr_nn );
                    result = temp1;
                    break;
                }
                case 221: // i1 neg i2 neg and i4 xor neg
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), NEGATE( lr_nn ) );
                    int temp1 = create_op_node (NodeType.XOR, temp0, rr_nn );
                    result = NEGATE( temp1 );
                    break;
                }
                case 222: // i1 i2 neg and i4 xor neg
                {
                    int temp0 = create (NodeType.AND, ll_nn, NEGATE( lr_nn ) );
                    int temp1 = create_op_node (NodeType.XOR, temp0, rr_nn );
                    result = NEGATE( temp1 );
                    break;
                }
                case 223: // i1 neg i2 and i4 xor neg
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), lr_nn );
                    int temp1 = create_op_node (NodeType.XOR, temp0, rr_nn );
                    result = NEGATE( temp1 );
                    break;
                }
                case 224: // i1 i2 and i4 xor neg
                {
                    int temp0 = create (NodeType.AND, ll_nn, lr_nn );
                    int temp1 = create_op_node (NodeType.XOR, temp0, rr_nn );
                    result = NEGATE( temp1 );
                    break;
                }
                case 225: // i1 neg i2 neg and i4 xor
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), NEGATE( lr_nn ) );
                    int temp1 = create_op_node (NodeType.XOR, temp0, rr_nn );
                    result = temp1;
                    break;
                }
                case 226: // i1 i2 neg and i4 xor
                {
                    int temp0 = create (NodeType.AND, ll_nn, NEGATE( lr_nn ) );
                    int temp1 = create_op_node (NodeType.XOR, temp0, rr_nn );
                    result = temp1;
                    break;
                }
                case 227: // i1 i4 xor
                {
                    int temp0 = create_op_node (NodeType.XOR, ll_nn, rr_nn );
                    result = temp0;
                    break;
                }
                case 228: // i1 i4 xor neg
                {
                    int temp0 = create_op_node (NodeType.XOR, ll_nn, rr_nn );
                    result = NEGATE( temp0 );
                    break;
                }
                case 229: // i1 i3 and i2 i4 and and
                {
                    int temp0 = create (NodeType.AND, ll_nn, rl_nn );
                    int temp1 = create (NodeType.AND, lr_nn, rr_nn );
                    int temp2 = create_op_node (NodeType.AND, temp0, temp1 );
                    result = temp2;
                    break;
                }
                case 230: // i1 neg i3 and i2 i4 and and
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), rl_nn );
                    int temp1 = create (NodeType.AND, lr_nn, rr_nn );
                    int temp2 = create_op_node (NodeType.AND, temp0, temp1 );
                    result = temp2;
                    break;
                }
                case 231: // i1 i3 and i2 neg i4 and and
                {
                    int temp0 = create (NodeType.AND, ll_nn, rl_nn );
                    int temp1 = create (NodeType.AND, NEGATE( lr_nn ), rr_nn );
                    int temp2 = create_op_node (NodeType.AND, temp0, temp1 );
                    result = temp2;
                    break;
                }
                case 232: // i1 neg i3 and i2 neg i4 and and
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), rl_nn );
                    int temp1 = create (NodeType.AND, NEGATE( lr_nn ), rr_nn );
                    int temp2 = create_op_node (NodeType.AND, temp0, temp1 );
                    result = temp2;
                    break;
                }
                case 233: // i1 i3 neg and i2 i4 and and
                {
                    int temp0 = create (NodeType.AND, ll_nn, NEGATE( rl_nn ) );
                    int temp1 = create (NodeType.AND, lr_nn, rr_nn );
                    int temp2 = create_op_node (NodeType.AND, temp0, temp1 );
                    result = temp2;
                    break;
                }
                case 234: // i1 neg i3 neg and i2 i4 and and
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), NEGATE( rl_nn ) );
                    int temp1 = create (NodeType.AND, lr_nn, rr_nn );
                    int temp2 = create_op_node (NodeType.AND, temp0, temp1 );
                    result = temp2;
                    break;
                }
                case 235: // i1 i3 neg and i2 neg i4 and and
                {
                    int temp0 = create (NodeType.AND, ll_nn, NEGATE( rl_nn ) );
                    int temp1 = create (NodeType.AND, NEGATE( lr_nn ), rr_nn );
                    int temp2 = create_op_node (NodeType.AND, temp0, temp1 );
                    result = temp2;
                    break;
                }
                case 236: // i1 neg i3 neg and i2 neg i4 and and
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), NEGATE( rl_nn ) );
                    int temp1 = create (NodeType.AND, NEGATE( lr_nn ), rr_nn );
                    int temp2 = create_op_node (NodeType.AND, temp0, temp1 );
                    result = temp2;
                    break;
                }
                case 237: // i1 i3 and i2 i4 neg and and
                {
                    int temp0 = create (NodeType.AND, ll_nn, rl_nn );
                    int temp1 = create (NodeType.AND, lr_nn, NEGATE( rr_nn ) );
                    int temp2 = create_op_node (NodeType.AND, temp0, temp1 );
                    result = temp2;
                    break;
                }
                case 238: // i1 neg i3 and i2 i4 neg and and
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), rl_nn );
                    int temp1 = create (NodeType.AND, lr_nn, NEGATE( rr_nn ) );
                    int temp2 = create_op_node (NodeType.AND, temp0, temp1 );
                    result = temp2;
                    break;
                }
                case 239: // i1 i3 and i2 neg i4 neg and and
                {
                    int temp0 = create (NodeType.AND, ll_nn, rl_nn );
                    int temp1 = create (NodeType.AND, NEGATE( lr_nn ), NEGATE( rr_nn ) );
                    int temp2 = create_op_node (NodeType.AND, temp0, temp1 );
                    result = temp2;
                    break;
                }
                case 240: // i1 neg i3 and i2 neg i4 neg and and
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), rl_nn );
                    int temp1 = create (NodeType.AND, NEGATE( lr_nn ), NEGATE( rr_nn ) );
                    int temp2 = create_op_node (NodeType.AND, temp0, temp1 );
                    result = temp2;
                    break;
                }
                case 241: // i1 i3 neg and i2 i4 neg and and
                {
                    int temp0 = create (NodeType.AND, ll_nn, NEGATE( rl_nn ) );
                    int temp1 = create (NodeType.AND, lr_nn, NEGATE( rr_nn ) );
                    int temp2 = create_op_node (NodeType.AND, temp0, temp1 );
                    result = temp2;
                    break;
                }
                case 242: // i1 neg i3 neg and i2 i4 neg and and
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), NEGATE( rl_nn ) );
                    int temp1 = create (NodeType.AND, lr_nn, NEGATE( rr_nn ) );
                    int temp2 = create_op_node (NodeType.AND, temp0, temp1 );
                    result = temp2;
                    break;
                }
                case 243: // i1 i3 neg and i2 neg i4 neg and and
                {
                    int temp0 = create (NodeType.AND, ll_nn, NEGATE( rl_nn ) );
                    int temp1 = create (NodeType.AND, NEGATE( lr_nn ), NEGATE( rr_nn ) );
                    int temp2 = create_op_node (NodeType.AND, temp0, temp1 );
                    result = temp2;
                    break;
                }
                case 244: // i1 neg i3 neg and i2 neg i4 neg and and
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), NEGATE( rl_nn ) );
                    int temp1 = create (NodeType.AND, NEGATE( lr_nn ), NEGATE( rr_nn ) );
                    int temp2 = create_op_node (NodeType.AND, temp0, temp1 );
                    result = temp2;
                    break;
                }
                case 245: // i1 i3 xor i2 i4 xor xor
                {
                    int temp0 = create (NodeType.XOR, ll_nn, rl_nn );
                    int temp1 = create (NodeType.XOR, lr_nn, rr_nn );
                    int temp2 = create_op_node (NodeType.XOR, temp0, temp1 );
                    result = temp2;
                    break;
                }
                case 246: // i1 i3 xor i2 i4 xor xor neg
                {
                    int temp0 = create (NodeType.XOR, ll_nn, rl_nn );
                    int temp1 = create (NodeType.XOR, lr_nn, rr_nn );
                    int temp2 = create_op_node (NodeType.XOR, temp0, temp1 );
                    result = NEGATE( temp2 );
                    break;
                }
                case 247: // i1 i4 and
                {
                    int temp0 = create_op_node (NodeType.AND, ll_nn, rr_nn );
                    result = temp0;
                    break;
                }
                case 248: // i1 neg i4 and
                {
                    int temp0 = create_op_node (NodeType.AND, NEGATE( ll_nn ), rr_nn );
                    result = temp0;
                    break;
                }
                case 249: // i1 i4 neg and
                {
                    int temp0 = create_op_node (NodeType.AND, ll_nn, NEGATE( rr_nn ) );
                    result = temp0;
                    break;
                }
                case 250: // i1 neg i4 neg and
                {
                    int temp0 = create_op_node (NodeType.AND, NEGATE( ll_nn ), NEGATE( rr_nn ) );
                    result = temp0;
                    break;
                }
                case 251: // i2 neg i4 neg and neg i1 and neg
                {
                    int temp0 = create (NodeType.AND, NEGATE( lr_nn ), NEGATE( rr_nn ) );
                    int temp1 = create_op_node (NodeType.AND, NEGATE( temp0 ), ll_nn );
                    result = NEGATE( temp1 );
                    break;
                }
                case 252: // i1 neg i2 and neg i1 i4 and neg and
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), lr_nn );
                    int temp1 = create (NodeType.AND, ll_nn, rr_nn );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 253: // i2 i4 neg and neg i1 and neg
                {
                    int temp0 = create (NodeType.AND, lr_nn, NEGATE( rr_nn ) );
                    int temp1 = create_op_node (NodeType.AND, NEGATE( temp0 ), ll_nn );
                    result = NEGATE( temp1 );
                    break;
                }
                case 254: // i1 neg i2 and neg i1 i4 neg and neg and neg
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), lr_nn );
                    int temp1 = create (NodeType.AND, ll_nn, NEGATE( rr_nn ) );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( temp1 ) );
                    result = NEGATE( temp2 );
                    break;
                }
                case 255: // i1 i2 and neg i1 neg i4 and neg and
                {
                    int temp0 = create (NodeType.AND, ll_nn, lr_nn );
                    int temp1 = create (NodeType.AND, NEGATE( ll_nn ), rr_nn );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 256: // i2 neg i4 neg and neg i1 neg and neg
                {
                    int temp0 = create (NodeType.AND, NEGATE( lr_nn ), NEGATE( rr_nn ) );
                    int temp1 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( ll_nn ) );
                    result = NEGATE( temp1 );
                    break;
                }
                case 257: // i1 i2 and neg i1 neg i4 neg and neg and neg
                {
                    int temp0 = create (NodeType.AND, ll_nn, lr_nn );
                    int temp1 = create (NodeType.AND, NEGATE( ll_nn ), NEGATE( rr_nn ) );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( temp1 ) );
                    result = NEGATE( temp2 );
                    break;
                }
                case 258: // i2 i4 neg and neg i1 neg and neg
                {
                    int temp0 = create (NodeType.AND, lr_nn, NEGATE( rr_nn ) );
                    int temp1 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( ll_nn ) );
                    result = NEGATE( temp1 );
                    break;
                }
                case 259: // i2 neg i4 and neg i1 and neg
                {
                    int temp0 = create (NodeType.AND, NEGATE( lr_nn ), rr_nn );
                    int temp1 = create_op_node (NodeType.AND, NEGATE( temp0 ), ll_nn );
                    result = NEGATE( temp1 );
                    break;
                }
                case 260: // i1 neg i2 and neg i1 i4 neg and neg and
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), lr_nn );
                    int temp1 = create (NodeType.AND, ll_nn, NEGATE( rr_nn ) );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 261: // i2 i4 and neg i1 and neg
                {
                    int temp0 = create (NodeType.AND, lr_nn, rr_nn );
                    int temp1 = create_op_node (NodeType.AND, NEGATE( temp0 ), ll_nn );
                    result = NEGATE( temp1 );
                    break;
                }
                case 262: // i1 neg i2 and neg i1 i4 and neg and neg
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), lr_nn );
                    int temp1 = create (NodeType.AND, ll_nn, rr_nn );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( temp1 ) );
                    result = NEGATE( temp2 );
                    break;
                }
                case 263: // i1 i2 and neg i1 neg i4 neg and neg and
                {
                    int temp0 = create (NodeType.AND, ll_nn, lr_nn );
                    int temp1 = create (NodeType.AND, NEGATE( ll_nn ), NEGATE( rr_nn ) );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 264: // i2 neg i4 and neg i1 neg and neg
                {
                    int temp0 = create (NodeType.AND, NEGATE( lr_nn ), rr_nn );
                    int temp1 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( ll_nn ) );
                    result = NEGATE( temp1 );
                    break;
                }
                case 265: // i1 i2 and neg i1 neg i4 and neg and neg
                {
                    int temp0 = create (NodeType.AND, ll_nn, lr_nn );
                    int temp1 = create (NodeType.AND, NEGATE( ll_nn ), rr_nn );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( temp1 ) );
                    result = NEGATE( temp2 );
                    break;
                }
                case 266: // i2 i4 and neg i1 neg and neg
                {
                    int temp0 = create (NodeType.AND, lr_nn, rr_nn );
                    int temp1 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( ll_nn ) );
                    result = NEGATE( temp1 );
                    break;
                }
                case 267: // i1 i2 and neg i1 i4 xor and
                {
                    int temp0 = create (NodeType.AND, ll_nn, lr_nn );
                    int temp1 = create (NodeType.XOR, ll_nn, rr_nn );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), temp1 );
                    result = temp2;
                    break;
                }
                case 268: // i1 i4 xor i2 i4 and neg and
                {
                    int temp0 = create (NodeType.XOR, ll_nn, rr_nn );
                    int temp1 = create (NodeType.AND, lr_nn, rr_nn );
                    int temp2 = create_op_node (NodeType.AND, temp0, NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 269: // i1 i2 neg and neg i1 i4 xor and
                {
                    int temp0 = create (NodeType.AND, ll_nn, NEGATE( lr_nn ) );
                    int temp1 = create (NodeType.XOR, ll_nn, rr_nn );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), temp1 );
                    result = temp2;
                    break;
                }
                case 270: // i1 i4 xor i2 neg i4 and neg and
                {
                    int temp0 = create (NodeType.XOR, ll_nn, rr_nn );
                    int temp1 = create (NodeType.AND, NEGATE( lr_nn ), rr_nn );
                    int temp2 = create_op_node (NodeType.AND, temp0, NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 271: // i1 i2 and neg i1 i4 xor neg and
                {
                    int temp0 = create (NodeType.AND, ll_nn, lr_nn );
                    int temp1 = create (NodeType.XOR, ll_nn, rr_nn );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 272: // i1 neg i2 and neg i1 i4 xor neg and
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), lr_nn );
                    int temp1 = create (NodeType.XOR, ll_nn, rr_nn );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 273: // i1 i2 neg and neg i1 i4 xor neg and
                {
                    int temp0 = create (NodeType.AND, ll_nn, NEGATE( lr_nn ) );
                    int temp1 = create (NodeType.XOR, ll_nn, rr_nn );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 274: // i1 neg i2 neg and neg i1 i4 xor neg and
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), NEGATE( lr_nn ) );
                    int temp1 = create (NodeType.XOR, ll_nn, rr_nn );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 275: // i2 i4 xor i1 and
                {
                    int temp0 = create (NodeType.XOR, lr_nn, rr_nn );
                    int temp1 = create_op_node (NodeType.AND, temp0, ll_nn );
                    result = temp1;
                    break;
                }
                case 276: // i2 i4 xor neg i1 and
                {
                    int temp0 = create (NodeType.XOR, lr_nn, rr_nn );
                    int temp1 = create_op_node (NodeType.AND, NEGATE( temp0 ), ll_nn );
                    result = temp1;
                    break;
                }
                case 277: // i2 i4 xor i1 neg and
                {
                    int temp0 = create (NodeType.XOR, lr_nn, rr_nn );
                    int temp1 = create_op_node (NodeType.AND, temp0, NEGATE( ll_nn ) );
                    result = temp1;
                    break;
                }
                case 278: // i2 i4 xor neg i1 neg and
                {
                    int temp0 = create (NodeType.XOR, lr_nn, rr_nn );
                    int temp1 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( ll_nn ) );
                    result = temp1;
                    break;
                }
                case 279: // i2 i4 xor i1 and neg
                {
                    int temp0 = create (NodeType.XOR, lr_nn, rr_nn );
                    int temp1 = create_op_node (NodeType.AND, temp0, ll_nn );
                    result = NEGATE( temp1 );
                    break;
                }
                case 280: // i2 i4 xor neg i1 and neg
                {
                    int temp0 = create (NodeType.XOR, lr_nn, rr_nn );
                    int temp1 = create_op_node (NodeType.AND, NEGATE( temp0 ), ll_nn );
                    result = NEGATE( temp1 );
                    break;
                }
                case 281: // i2 i4 xor i1 neg and neg
                {
                    int temp0 = create (NodeType.XOR, lr_nn, rr_nn );
                    int temp1 = create_op_node (NodeType.AND, temp0, NEGATE( ll_nn ) );
                    result = NEGATE( temp1 );
                    break;
                }
                case 282: // i2 i4 xor neg i1 neg and neg
                {
                    int temp0 = create (NodeType.XOR, lr_nn, rr_nn );
                    int temp1 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( ll_nn ) );
                    result = NEGATE( temp1 );
                    break;
                }
                case 283: // i1 i4 neg and i2 xor
                {
                    int temp0 = create (NodeType.AND, ll_nn, NEGATE( rr_nn ) );
                    int temp1 = create_op_node (NodeType.XOR, temp0, lr_nn );
                    result = temp1;
                    break;
                }
                case 284: // i1 i4 neg and i2 xor neg
                {
                    int temp0 = create (NodeType.AND, ll_nn, NEGATE( rr_nn ) );
                    int temp1 = create_op_node (NodeType.XOR, temp0, lr_nn );
                    result = NEGATE( temp1 );
                    break;
                }
                case 285: // i1 neg i4 neg and i2 xor neg
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), NEGATE( rr_nn ) );
                    int temp1 = create_op_node (NodeType.XOR, temp0, lr_nn );
                    result = NEGATE( temp1 );
                    break;
                }
                case 286: // i1 neg i4 neg and i2 xor
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), NEGATE( rr_nn ) );
                    int temp1 = create_op_node (NodeType.XOR, temp0, lr_nn );
                    result = temp1;
                    break;
                }
                case 287: // i1 i4 and i2 xor
                {
                    int temp0 = create (NodeType.AND, ll_nn, rr_nn );
                    int temp1 = create_op_node (NodeType.XOR, temp0, lr_nn );
                    result = temp1;
                    break;
                }
                case 288: // i1 i4 and i2 xor neg
                {
                    int temp0 = create (NodeType.AND, ll_nn, rr_nn );
                    int temp1 = create_op_node (NodeType.XOR, temp0, lr_nn );
                    result = NEGATE( temp1 );
                    break;
                }
                case 289: // i1 neg i4 and i2 xor neg
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), rr_nn );
                    int temp1 = create_op_node (NodeType.XOR, temp0, lr_nn );
                    result = NEGATE( temp1 );
                    break;
                }
                case 290: // i1 neg i4 and i2 xor
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), rr_nn );
                    int temp1 = create_op_node (NodeType.XOR, temp0, lr_nn );
                    result = temp1;
                    break;
                }
                case 291: // i2 i4 xor
                {
                    int temp0 = create_op_node (NodeType.XOR, lr_nn, rr_nn );
                    result = temp0;
                    break;
                }
                case 292: // i2 i4 xor neg
                {
                    int temp0 = create_op_node (NodeType.XOR, lr_nn, rr_nn );
                    result = NEGATE( temp0 );
                    break;
                }
                case 293: // i1 i3 and i2 and
                {
                    int temp0 = create (NodeType.AND, ll_nn, rl_nn );
                    int temp1 = create_op_node (NodeType.AND, temp0, lr_nn );
                    result = temp1;
                    break;
                }
                case 294: // i1 neg i3 and i2 and
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), rl_nn );
                    int temp1 = create_op_node (NodeType.AND, temp0, lr_nn );
                    result = temp1;
                    break;
                }
                case 295: // i1 i3 neg and i2 and
                {
                    int temp0 = create (NodeType.AND, ll_nn, NEGATE( rl_nn ) );
                    int temp1 = create_op_node (NodeType.AND, temp0, lr_nn );
                    result = temp1;
                    break;
                }
                case 296: // i1 neg i3 neg and i2 and
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), NEGATE( rl_nn ) );
                    int temp1 = create_op_node (NodeType.AND, temp0, lr_nn );
                    result = temp1;
                    break;
                }
                case 297: // i1 i3 and i2 neg and
                {
                    int temp0 = create (NodeType.AND, ll_nn, rl_nn );
                    int temp1 = create_op_node (NodeType.AND, temp0, NEGATE( lr_nn ) );
                    result = temp1;
                    break;
                }
                case 298: // i1 neg i3 and i2 neg and
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), rl_nn );
                    int temp1 = create_op_node (NodeType.AND, temp0, NEGATE( lr_nn ) );
                    result = temp1;
                    break;
                }
                case 299: // i1 i3 neg and i2 neg and
                {
                    int temp0 = create (NodeType.AND, ll_nn, NEGATE( rl_nn ) );
                    int temp1 = create_op_node (NodeType.AND, temp0, NEGATE( lr_nn ) );
                    result = temp1;
                    break;
                }
                case 300: // i1 neg i3 neg and i2 neg and
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), NEGATE( rl_nn ) );
                    int temp1 = create_op_node (NodeType.AND, temp0, NEGATE( lr_nn ) );
                    result = temp1;
                    break;
                }
                case 301: // i3 i2 and
                {
                    int temp0 = create_op_node (NodeType.AND, rl_nn, lr_nn );
                    result = temp0;
                    break;
                }
                case 302: // i3 neg i2 and
                {
                    int temp0 = create_op_node (NodeType.AND, NEGATE( rl_nn ), lr_nn );
                    result = temp0;
                    break;
                }
                case 303: // i3 i2 neg and
                {
                    int temp0 = create_op_node (NodeType.AND, rl_nn, NEGATE( lr_nn ) );
                    result = temp0;
                    break;
                }
                case 304: // i3 neg i2 neg and
                {
                    int temp0 = create_op_node (NodeType.AND, NEGATE( rl_nn ), NEGATE( lr_nn ) );
                    result = temp0;
                    break;
                }
                case 305: // i1 neg i3 neg and neg i2 and neg
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), NEGATE( rl_nn ) );
                    int temp1 = create_op_node (NodeType.AND, NEGATE( temp0 ), lr_nn );
                    result = NEGATE( temp1 );
                    break;
                }
                case 306: // i1 i3 neg and neg i2 and neg
                {
                    int temp0 = create (NodeType.AND, ll_nn, NEGATE( rl_nn ) );
                    int temp1 = create_op_node (NodeType.AND, NEGATE( temp0 ), lr_nn );
                    result = NEGATE( temp1 );
                    break;
                }
                case 307: // i1 i2 neg and neg i3 i2 and neg and
                {
                    int temp0 = create (NodeType.AND, ll_nn, NEGATE( lr_nn ) );
                    int temp1 = create (NodeType.AND, rl_nn, lr_nn );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 308: // i1 i2 neg and neg i3 neg i2 and neg and neg
                {
                    int temp0 = create (NodeType.AND, ll_nn, NEGATE( lr_nn ) );
                    int temp1 = create (NodeType.AND, NEGATE( rl_nn ), lr_nn );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( temp1 ) );
                    result = NEGATE( temp2 );
                    break;
                }
                case 309: // i1 neg i3 and neg i2 and neg
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), rl_nn );
                    int temp1 = create_op_node (NodeType.AND, NEGATE( temp0 ), lr_nn );
                    result = NEGATE( temp1 );
                    break;
                }
                case 310: // i1 i3 and neg i2 and neg
                {
                    int temp0 = create (NodeType.AND, ll_nn, rl_nn );
                    int temp1 = create_op_node (NodeType.AND, NEGATE( temp0 ), lr_nn );
                    result = NEGATE( temp1 );
                    break;
                }
                case 311: // i1 i2 neg and neg i3 neg i2 and neg and
                {
                    int temp0 = create (NodeType.AND, ll_nn, NEGATE( lr_nn ) );
                    int temp1 = create (NodeType.AND, NEGATE( rl_nn ), lr_nn );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 312: // i1 i2 neg and neg i3 i2 and neg and neg
                {
                    int temp0 = create (NodeType.AND, ll_nn, NEGATE( lr_nn ) );
                    int temp1 = create (NodeType.AND, rl_nn, lr_nn );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( temp1 ) );
                    result = NEGATE( temp2 );
                    break;
                }
                case 313: // i1 i2 and neg i3 i2 neg and neg and
                {
                    int temp0 = create (NodeType.AND, ll_nn, lr_nn );
                    int temp1 = create (NodeType.AND, rl_nn, NEGATE( lr_nn ) );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 314: // i1 i2 and neg i3 neg i2 neg and neg and neg
                {
                    int temp0 = create (NodeType.AND, ll_nn, lr_nn );
                    int temp1 = create (NodeType.AND, NEGATE( rl_nn ), NEGATE( lr_nn ) );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( temp1 ) );
                    result = NEGATE( temp2 );
                    break;
                }
                case 315: // i1 neg i3 neg and neg i2 neg and neg
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), NEGATE( rl_nn ) );
                    int temp1 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( lr_nn ) );
                    result = NEGATE( temp1 );
                    break;
                }
                case 316: // i1 i3 neg and neg i2 neg and neg
                {
                    int temp0 = create (NodeType.AND, ll_nn, NEGATE( rl_nn ) );
                    int temp1 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( lr_nn ) );
                    result = NEGATE( temp1 );
                    break;
                }
                case 317: // i1 i2 and neg i3 neg i2 neg and neg and
                {
                    int temp0 = create (NodeType.AND, ll_nn, lr_nn );
                    int temp1 = create (NodeType.AND, NEGATE( rl_nn ), NEGATE( lr_nn ) );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 318: // i1 i2 and neg i3 i2 neg and neg and neg
                {
                    int temp0 = create (NodeType.AND, ll_nn, lr_nn );
                    int temp1 = create (NodeType.AND, rl_nn, NEGATE( lr_nn ) );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( temp1 ) );
                    result = NEGATE( temp2 );
                    break;
                }
                case 319: // i1 neg i3 and neg i2 neg and neg
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), rl_nn );
                    int temp1 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( lr_nn ) );
                    result = NEGATE( temp1 );
                    break;
                }
                case 320: // i1 i3 and neg i2 neg and neg
                {
                    int temp0 = create (NodeType.AND, ll_nn, rl_nn );
                    int temp1 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( lr_nn ) );
                    result = NEGATE( temp1 );
                    break;
                }
                case 321: // i1 i2 xor i3 i2 and neg and
                {
                    int temp0 = create (NodeType.XOR, ll_nn, lr_nn );
                    int temp1 = create (NodeType.AND, rl_nn, lr_nn );
                    int temp2 = create_op_node (NodeType.AND, temp0, NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 322: // i1 i3 and neg i1 i2 xor neg and
                {
                    int temp0 = create (NodeType.AND, ll_nn, rl_nn );
                    int temp1 = create (NodeType.XOR, ll_nn, lr_nn );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 323: // i1 i2 xor i3 neg i2 and neg and
                {
                    int temp0 = create (NodeType.XOR, ll_nn, lr_nn );
                    int temp1 = create (NodeType.AND, NEGATE( rl_nn ), lr_nn );
                    int temp2 = create_op_node (NodeType.AND, temp0, NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 324: // i1 i3 neg and neg i1 i2 xor neg and
                {
                    int temp0 = create (NodeType.AND, ll_nn, NEGATE( rl_nn ) );
                    int temp1 = create (NodeType.XOR, ll_nn, lr_nn );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 325: // i1 i3 and neg i1 i2 xor and
                {
                    int temp0 = create (NodeType.AND, ll_nn, rl_nn );
                    int temp1 = create (NodeType.XOR, ll_nn, lr_nn );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), temp1 );
                    result = temp2;
                    break;
                }
                case 326: // i1 neg i3 and neg i1 i2 xor neg and
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), rl_nn );
                    int temp1 = create (NodeType.XOR, ll_nn, lr_nn );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 327: // i1 i3 neg and neg i1 i2 xor and
                {
                    int temp0 = create (NodeType.AND, ll_nn, NEGATE( rl_nn ) );
                    int temp1 = create (NodeType.XOR, ll_nn, lr_nn );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), temp1 );
                    result = temp2;
                    break;
                }
                case 328: // i1 neg i3 neg and neg i1 i2 xor neg and
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), NEGATE( rl_nn ) );
                    int temp1 = create (NodeType.XOR, ll_nn, lr_nn );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 329: // i1 i2 and neg i3 i2 xor and
                {
                    int temp0 = create (NodeType.AND, ll_nn, lr_nn );
                    int temp1 = create (NodeType.XOR, rl_nn, lr_nn );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), temp1 );
                    result = temp2;
                    break;
                }
                case 330: // i1 neg i2 and neg i3 i2 xor and
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), lr_nn );
                    int temp1 = create (NodeType.XOR, rl_nn, lr_nn );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), temp1 );
                    result = temp2;
                    break;
                }
                case 331: // i1 i3 and neg i3 i2 xor and
                {
                    int temp0 = create (NodeType.AND, ll_nn, rl_nn );
                    int temp1 = create (NodeType.XOR, rl_nn, lr_nn );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), temp1 );
                    result = temp2;
                    break;
                }
                case 332: // i1 neg i3 and neg i3 i2 xor and
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), rl_nn );
                    int temp1 = create (NodeType.XOR, rl_nn, lr_nn );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), temp1 );
                    result = temp2;
                    break;
                }
                case 333: // i1 i3 and neg i3 i2 xor neg and
                {
                    int temp0 = create (NodeType.AND, ll_nn, rl_nn );
                    int temp1 = create (NodeType.XOR, rl_nn, lr_nn );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 334: // i1 neg i3 and neg i3 i2 xor neg and
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), rl_nn );
                    int temp1 = create (NodeType.XOR, rl_nn, lr_nn );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 335: // i1 i3 neg and neg i3 i2 xor neg and
                {
                    int temp0 = create (NodeType.AND, ll_nn, NEGATE( rl_nn ) );
                    int temp1 = create (NodeType.XOR, rl_nn, lr_nn );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 336: // i1 neg i3 neg and neg i3 i2 xor neg and
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), NEGATE( rl_nn ) );
                    int temp1 = create (NodeType.XOR, rl_nn, lr_nn );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 337: // i1 i2 xor i3 i2 xor and
                {
                    int temp0 = create (NodeType.XOR, ll_nn, lr_nn );
                    int temp1 = create (NodeType.XOR, rl_nn, lr_nn );
                    int temp2 = create_op_node (NodeType.AND, temp0, temp1 );
                    result = temp2;
                    break;
                }
                case 338: // i1 i3 xor i3 i2 xor and
                {
                    int temp0 = create (NodeType.XOR, ll_nn, rl_nn );
                    int temp1 = create (NodeType.XOR, rl_nn, lr_nn );
                    int temp2 = create_op_node (NodeType.AND, temp0, temp1 );
                    result = temp2;
                    break;
                }
                case 339: // i1 i3 xor i1 i2 xor and
                {
                    int temp0 = create (NodeType.XOR, ll_nn, rl_nn );
                    int temp1 = create (NodeType.XOR, ll_nn, lr_nn );
                    int temp2 = create_op_node (NodeType.AND, temp0, temp1 );
                    result = temp2;
                    break;
                }
                case 340: // i1 i3 xor neg i1 i2 xor neg and
                {
                    int temp0 = create (NodeType.XOR, ll_nn, rl_nn );
                    int temp1 = create (NodeType.XOR, ll_nn, lr_nn );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 341: // i1 i3 xor i2 and
                {
                    int temp0 = create (NodeType.XOR, ll_nn, rl_nn );
                    int temp1 = create_op_node (NodeType.AND, temp0, lr_nn );
                    result = temp1;
                    break;
                }
                case 342: // i1 i3 xor neg i2 and
                {
                    int temp0 = create (NodeType.XOR, ll_nn, rl_nn );
                    int temp1 = create_op_node (NodeType.AND, NEGATE( temp0 ), lr_nn );
                    result = temp1;
                    break;
                }
                case 343: // i1 i3 xor i2 neg and
                {
                    int temp0 = create (NodeType.XOR, ll_nn, rl_nn );
                    int temp1 = create_op_node (NodeType.AND, temp0, NEGATE( lr_nn ) );
                    result = temp1;
                    break;
                }
                case 344: // i1 i3 xor neg i2 neg and
                {
                    int temp0 = create (NodeType.XOR, ll_nn, rl_nn );
                    int temp1 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( lr_nn ) );
                    result = temp1;
                    break;
                }
                case 345: // i1 i3 xor i2 and neg
                {
                    int temp0 = create (NodeType.XOR, ll_nn, rl_nn );
                    int temp1 = create_op_node (NodeType.AND, temp0, lr_nn );
                    result = NEGATE( temp1 );
                    break;
                }
                case 346: // i1 i3 xor neg i2 and neg
                {
                    int temp0 = create (NodeType.XOR, ll_nn, rl_nn );
                    int temp1 = create_op_node (NodeType.AND, NEGATE( temp0 ), lr_nn );
                    result = NEGATE( temp1 );
                    break;
                }
                case 347: // i1 i3 xor i2 neg and neg
                {
                    int temp0 = create (NodeType.XOR, ll_nn, rl_nn );
                    int temp1 = create_op_node (NodeType.AND, temp0, NEGATE( lr_nn ) );
                    result = NEGATE( temp1 );
                    break;
                }
                case 348: // i1 i3 xor neg i2 neg and neg
                {
                    int temp0 = create (NodeType.XOR, ll_nn, rl_nn );
                    int temp1 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( lr_nn ) );
                    result = NEGATE( temp1 );
                    break;
                }
                case 349: // i3 neg i2 and i1 xor
                {
                    int temp0 = create (NodeType.AND, NEGATE( rl_nn ), lr_nn );
                    int temp1 = create_op_node (NodeType.XOR, temp0, ll_nn );
                    result = temp1;
                    break;
                }
                case 350: // i3 neg i2 and i1 xor neg
                {
                    int temp0 = create (NodeType.AND, NEGATE( rl_nn ), lr_nn );
                    int temp1 = create_op_node (NodeType.XOR, temp0, ll_nn );
                    result = NEGATE( temp1 );
                    break;
                }
                case 351: // i3 i2 and i1 xor
                {
                    int temp0 = create (NodeType.AND, rl_nn, lr_nn );
                    int temp1 = create_op_node (NodeType.XOR, temp0, ll_nn );
                    result = temp1;
                    break;
                }
                case 352: // i3 i2 and i1 xor neg
                {
                    int temp0 = create (NodeType.AND, rl_nn, lr_nn );
                    int temp1 = create_op_node (NodeType.XOR, temp0, ll_nn );
                    result = NEGATE( temp1 );
                    break;
                }
                case 353: // i3 neg i2 neg and i1 xor neg
                {
                    int temp0 = create (NodeType.AND, NEGATE( rl_nn ), NEGATE( lr_nn ) );
                    int temp1 = create_op_node (NodeType.XOR, temp0, ll_nn );
                    result = NEGATE( temp1 );
                    break;
                }
                case 354: // i3 neg i2 neg and i1 xor
                {
                    int temp0 = create (NodeType.AND, NEGATE( rl_nn ), NEGATE( lr_nn ) );
                    int temp1 = create_op_node (NodeType.XOR, temp0, ll_nn );
                    result = temp1;
                    break;
                }
                case 355: // i3 i2 neg and i1 xor neg
                {
                    int temp0 = create (NodeType.AND, rl_nn, NEGATE( lr_nn ) );
                    int temp1 = create_op_node (NodeType.XOR, temp0, ll_nn );
                    result = NEGATE( temp1 );
                    break;
                }
                case 356: // i3 i2 neg and i1 xor
                {
                    int temp0 = create (NodeType.AND, rl_nn, NEGATE( lr_nn ) );
                    int temp1 = create_op_node (NodeType.XOR, temp0, ll_nn );
                    result = temp1;
                    break;
                }
                case 357: // i1 neg i2 and i3 xor
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), lr_nn );
                    int temp1 = create_op_node (NodeType.XOR, temp0, rl_nn );
                    result = temp1;
                    break;
                }
                case 358: // i1 i2 and i3 xor
                {
                    int temp0 = create (NodeType.AND, ll_nn, lr_nn );
                    int temp1 = create_op_node (NodeType.XOR, temp0, rl_nn );
                    result = temp1;
                    break;
                }
                case 359: // i1 neg i2 neg and i3 xor neg
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), NEGATE( lr_nn ) );
                    int temp1 = create_op_node (NodeType.XOR, temp0, rl_nn );
                    result = NEGATE( temp1 );
                    break;
                }
                case 360: // i1 i2 neg and i3 xor neg
                {
                    int temp0 = create (NodeType.AND, ll_nn, NEGATE( lr_nn ) );
                    int temp1 = create_op_node (NodeType.XOR, temp0, rl_nn );
                    result = NEGATE( temp1 );
                    break;
                }
                case 361: // i1 neg i2 and i3 xor neg
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), lr_nn );
                    int temp1 = create_op_node (NodeType.XOR, temp0, rl_nn );
                    result = NEGATE( temp1 );
                    break;
                }
                case 362: // i1 i2 and i3 xor neg
                {
                    int temp0 = create (NodeType.AND, ll_nn, lr_nn );
                    int temp1 = create_op_node (NodeType.XOR, temp0, rl_nn );
                    result = NEGATE( temp1 );
                    break;
                }
                case 363: // i1 neg i2 neg and i3 xor
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), NEGATE( lr_nn ) );
                    int temp1 = create_op_node (NodeType.XOR, temp0, rl_nn );
                    result = temp1;
                    break;
                }
                case 364: // i1 i2 neg and i3 xor
                {
                    int temp0 = create (NodeType.AND, ll_nn, NEGATE( lr_nn ) );
                    int temp1 = create_op_node (NodeType.XOR, temp0, rl_nn );
                    result = temp1;
                    break;
                }
                case 365: // i1 i3 xor
                {
                    int temp0 = create_op_node (NodeType.XOR, ll_nn, rl_nn );
                    result = temp0;
                    break;
                }
                case 366: // i1 i3 xor neg
                {
                    int temp0 = create_op_node (NodeType.XOR, ll_nn, rl_nn );
                    result = NEGATE( temp0 );
                    break;
                }
                case 367: // i1 i2 and neg
                {
                    int temp0 = create_op_node (NodeType.AND, ll_nn, lr_nn );
                    result = NEGATE( temp0 );
                    break;
                }
                case 368: // i2 neg
                {
                    result = NEGATE( lr_nn );
                    break;
                }
                case 369: // i1 neg
                {
                    result = NEGATE( ll_nn );
                    break;
                }
                case 370: // i1 i2 xor
                {
                    int temp0 = create_op_node (NodeType.XOR, ll_nn, lr_nn );
                    result = temp0;
                    break;
                }
                case 371: // i1 neg i2 and neg
                {
                    int temp0 = create_op_node (NodeType.AND, NEGATE( ll_nn ), lr_nn );
                    result = NEGATE( temp0 );
                    break;
                }
                case 372: // i1 i2 xor neg
                {
                    int temp0 = create_op_node (NodeType.XOR, ll_nn, lr_nn );
                    result = NEGATE( temp0 );
                    break;
                }
                case 373: // i1
                {
                    result = ll_nn;
                    break;
                }
                case 374: // i1 i2 neg and neg
                {
                    int temp0 = create_op_node (NodeType.AND, ll_nn, NEGATE( lr_nn ) );
                    result = NEGATE( temp0 );
                    break;
                }
                case 375: // i2
                {
                    result = lr_nn;
                    break;
                }
                case 376: // i1 neg i2 neg and neg
                {
                    int temp0 = create_op_node (NodeType.AND, NEGATE( ll_nn ), NEGATE( lr_nn ) );
                    result = NEGATE( temp0 );
                    break;
                }
                case 377: //
                {
                    result = one();
                    break;
                }
                case 378: // i1 i3 and i4 i2 and and
                {
                    int temp0 = create (NodeType.AND, ll_nn, rl_nn );
                    int temp1 = create (NodeType.AND, rr_nn, lr_nn );
                    int temp2 = create_op_node (NodeType.AND, temp0, temp1 );
                    result = temp2;
                    break;
                }
                case 379: // i1 neg i3 and i4 i2 and and
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), rl_nn );
                    int temp1 = create (NodeType.AND, rr_nn, lr_nn );
                    int temp2 = create_op_node (NodeType.AND, temp0, temp1 );
                    result = temp2;
                    break;
                }
                case 380: // i1 i3 and i4 i2 neg and and
                {
                    int temp0 = create (NodeType.AND, ll_nn, rl_nn );
                    int temp1 = create (NodeType.AND, rr_nn, NEGATE( lr_nn ) );
                    int temp2 = create_op_node (NodeType.AND, temp0, temp1 );
                    result = temp2;
                    break;
                }
                case 381: // i1 neg i3 and i4 i2 neg and and
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), rl_nn );
                    int temp1 = create (NodeType.AND, rr_nn, NEGATE( lr_nn ) );
                    int temp2 = create_op_node (NodeType.AND, temp0, temp1 );
                    result = temp2;
                    break;
                }
                case 382: // i1 i3 neg and i4 i2 and and
                {
                    int temp0 = create (NodeType.AND, ll_nn, NEGATE( rl_nn ) );
                    int temp1 = create (NodeType.AND, rr_nn, lr_nn );
                    int temp2 = create_op_node (NodeType.AND, temp0, temp1 );
                    result = temp2;
                    break;
                }
                case 383: // i1 neg i3 neg and i4 i2 and and
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), NEGATE( rl_nn ) );
                    int temp1 = create (NodeType.AND, rr_nn, lr_nn );
                    int temp2 = create_op_node (NodeType.AND, temp0, temp1 );
                    result = temp2;
                    break;
                }
                case 384: // i1 i3 neg and i4 i2 neg and and
                {
                    int temp0 = create (NodeType.AND, ll_nn, NEGATE( rl_nn ) );
                    int temp1 = create (NodeType.AND, rr_nn, NEGATE( lr_nn ) );
                    int temp2 = create_op_node (NodeType.AND, temp0, temp1 );
                    result = temp2;
                    break;
                }
                case 385: // i1 neg i3 neg and i4 i2 neg and and
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), NEGATE( rl_nn ) );
                    int temp1 = create (NodeType.AND, rr_nn, NEGATE( lr_nn ) );
                    int temp2 = create_op_node (NodeType.AND, temp0, temp1 );
                    result = temp2;
                    break;
                }
                case 386: // i1 i3 and i4 neg i2 and and
                {
                    int temp0 = create (NodeType.AND, ll_nn, rl_nn );
                    int temp1 = create (NodeType.AND, NEGATE( rr_nn ), lr_nn );
                    int temp2 = create_op_node (NodeType.AND, temp0, temp1 );
                    result = temp2;
                    break;
                }
                case 387: // i1 neg i3 and i4 neg i2 and and
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), rl_nn );
                    int temp1 = create (NodeType.AND, NEGATE( rr_nn ), lr_nn );
                    int temp2 = create_op_node (NodeType.AND, temp0, temp1 );
                    result = temp2;
                    break;
                }
                case 388: // i1 i3 and i4 neg i2 neg and and
                {
                    int temp0 = create (NodeType.AND, ll_nn, rl_nn );
                    int temp1 = create (NodeType.AND, NEGATE( rr_nn ), NEGATE( lr_nn ) );
                    int temp2 = create_op_node (NodeType.AND, temp0, temp1 );
                    result = temp2;
                    break;
                }
                case 389: // i1 neg i3 and i4 neg i2 neg and and
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), rl_nn );
                    int temp1 = create (NodeType.AND, NEGATE( rr_nn ), NEGATE( lr_nn ) );
                    int temp2 = create_op_node (NodeType.AND, temp0, temp1 );
                    result = temp2;
                    break;
                }
                case 390: // i1 i3 neg and i4 neg i2 and and
                {
                    int temp0 = create (NodeType.AND, ll_nn, NEGATE( rl_nn ) );
                    int temp1 = create (NodeType.AND, NEGATE( rr_nn ), lr_nn );
                    int temp2 = create_op_node (NodeType.AND, temp0, temp1 );
                    result = temp2;
                    break;
                }
                case 391: // i1 neg i3 neg and i4 neg i2 and and
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), NEGATE( rl_nn ) );
                    int temp1 = create (NodeType.AND, NEGATE( rr_nn ), lr_nn );
                    int temp2 = create_op_node (NodeType.AND, temp0, temp1 );
                    result = temp2;
                    break;
                }
                case 392: // i1 i3 neg and i4 neg i2 neg and and
                {
                    int temp0 = create (NodeType.AND, ll_nn, NEGATE( rl_nn ) );
                    int temp1 = create (NodeType.AND, NEGATE( rr_nn ), NEGATE( lr_nn ) );
                    int temp2 = create_op_node (NodeType.AND, temp0, temp1 );
                    result = temp2;
                    break;
                }
                case 393: // i1 neg i3 neg and i4 neg i2 neg and and
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), NEGATE( rl_nn ) );
                    int temp1 = create (NodeType.AND, NEGATE( rr_nn ), NEGATE( lr_nn ) );
                    int temp2 = create_op_node (NodeType.AND, temp0, temp1 );
                    result = temp2;
                    break;
                }
                case 394: // i1 i3 xor i4 i2 xor xor
                {
                    int temp0 = create (NodeType.XOR, ll_nn, rl_nn );
                    int temp1 = create (NodeType.XOR, rr_nn, lr_nn );
                    int temp2 = create_op_node (NodeType.XOR, temp0, temp1 );
                    result = temp2;
                    break;
                }
                case 395: // i1 i3 xor i4 i2 xor xor neg
                {
                    int temp0 = create (NodeType.XOR, ll_nn, rl_nn );
                    int temp1 = create (NodeType.XOR, rr_nn, lr_nn );
                    int temp2 = create_op_node (NodeType.XOR, temp0, temp1 );
                    result = NEGATE( temp2 );
                    break;
                }
                case 396: // i1 i4 and i2 and
                {
                    int temp0 = create (NodeType.AND, ll_nn, rr_nn );
                    int temp1 = create_op_node (NodeType.AND, temp0, lr_nn );
                    result = temp1;
                    break;
                }
                case 397: // i1 i4 and i2 neg and
                {
                    int temp0 = create (NodeType.AND, ll_nn, rr_nn );
                    int temp1 = create_op_node (NodeType.AND, temp0, NEGATE( lr_nn ) );
                    result = temp1;
                    break;
                }
                case 398: // i1 neg i4 and i2 and
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), rr_nn );
                    int temp1 = create_op_node (NodeType.AND, temp0, lr_nn );
                    result = temp1;
                    break;
                }
                case 399: // i1 neg i4 and i2 neg and
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), rr_nn );
                    int temp1 = create_op_node (NodeType.AND, temp0, NEGATE( lr_nn ) );
                    result = temp1;
                    break;
                }
                case 400: // i1 i4 neg and i2 and
                {
                    int temp0 = create (NodeType.AND, ll_nn, NEGATE( rr_nn ) );
                    int temp1 = create_op_node (NodeType.AND, temp0, lr_nn );
                    result = temp1;
                    break;
                }
                case 401: // i1 i4 neg and i2 neg and
                {
                    int temp0 = create (NodeType.AND, ll_nn, NEGATE( rr_nn ) );
                    int temp1 = create_op_node (NodeType.AND, temp0, NEGATE( lr_nn ) );
                    result = temp1;
                    break;
                }
                case 402: // i1 neg i4 neg and i2 and
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), NEGATE( rr_nn ) );
                    int temp1 = create_op_node (NodeType.AND, temp0, lr_nn );
                    result = temp1;
                    break;
                }
                case 403: // i1 neg i4 neg and i2 neg and
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), NEGATE( rr_nn ) );
                    int temp1 = create_op_node (NodeType.AND, temp0, NEGATE( lr_nn ) );
                    result = temp1;
                    break;
                }
                case 404: // i4 neg i2 neg and neg i1 and neg
                {
                    int temp0 = create (NodeType.AND, NEGATE( rr_nn ), NEGATE( lr_nn ) );
                    int temp1 = create_op_node (NodeType.AND, NEGATE( temp0 ), ll_nn );
                    result = NEGATE( temp1 );
                    break;
                }
                case 405: // i1 i4 and neg i1 neg i2 and neg and
                {
                    int temp0 = create (NodeType.AND, ll_nn, rr_nn );
                    int temp1 = create (NodeType.AND, NEGATE( ll_nn ), lr_nn );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 406: // i4 neg i2 and neg i1 and neg
                {
                    int temp0 = create (NodeType.AND, NEGATE( rr_nn ), lr_nn );
                    int temp1 = create_op_node (NodeType.AND, NEGATE( temp0 ), ll_nn );
                    result = NEGATE( temp1 );
                    break;
                }
                case 407: // i1 i4 and neg i1 neg i2 neg and neg and
                {
                    int temp0 = create (NodeType.AND, ll_nn, rr_nn );
                    int temp1 = create (NodeType.AND, NEGATE( ll_nn ), NEGATE( lr_nn ) );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 408: // i1 neg i4 and neg i1 i2 and neg and
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), rr_nn );
                    int temp1 = create (NodeType.AND, ll_nn, lr_nn );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 409: // i4 neg i2 neg and neg i1 neg and neg
                {
                    int temp0 = create (NodeType.AND, NEGATE( rr_nn ), NEGATE( lr_nn ) );
                    int temp1 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( ll_nn ) );
                    result = NEGATE( temp1 );
                    break;
                }
                case 410: // i1 neg i4 and neg i1 i2 neg and neg and
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), rr_nn );
                    int temp1 = create (NodeType.AND, ll_nn, NEGATE( lr_nn ) );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 411: // i4 neg i2 and neg i1 neg and neg
                {
                    int temp0 = create (NodeType.AND, NEGATE( rr_nn ), lr_nn );
                    int temp1 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( ll_nn ) );
                    result = NEGATE( temp1 );
                    break;
                }
                case 412: // i4 i2 neg and neg i1 and neg
                {
                    int temp0 = create (NodeType.AND, rr_nn, NEGATE( lr_nn ) );
                    int temp1 = create_op_node (NodeType.AND, NEGATE( temp0 ), ll_nn );
                    result = NEGATE( temp1 );
                    break;
                }
                case 413: // i1 i4 and neg i1 neg i2 neg and neg and neg
                {
                    int temp0 = create (NodeType.AND, ll_nn, rr_nn );
                    int temp1 = create (NodeType.AND, NEGATE( ll_nn ), NEGATE( lr_nn ) );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( temp1 ) );
                    result = NEGATE( temp2 );
                    break;
                }
                case 414: // i4 i2 and neg i1 and neg
                {
                    int temp0 = create (NodeType.AND, rr_nn, lr_nn );
                    int temp1 = create_op_node (NodeType.AND, NEGATE( temp0 ), ll_nn );
                    result = NEGATE( temp1 );
                    break;
                }
                case 415: // i1 i4 and neg i1 neg i2 and neg and neg
                {
                    int temp0 = create (NodeType.AND, ll_nn, rr_nn );
                    int temp1 = create (NodeType.AND, NEGATE( ll_nn ), lr_nn );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( temp1 ) );
                    result = NEGATE( temp2 );
                    break;
                }
                case 416: // i1 neg i4 and neg i1 i2 neg and neg and neg
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), rr_nn );
                    int temp1 = create (NodeType.AND, ll_nn, NEGATE( lr_nn ) );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( temp1 ) );
                    result = NEGATE( temp2 );
                    break;
                }
                case 417: // i4 i2 neg and neg i1 neg and neg
                {
                    int temp0 = create (NodeType.AND, rr_nn, NEGATE( lr_nn ) );
                    int temp1 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( ll_nn ) );
                    result = NEGATE( temp1 );
                    break;
                }
                case 418: // i1 neg i4 and neg i1 i2 and neg and neg
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), rr_nn );
                    int temp1 = create (NodeType.AND, ll_nn, lr_nn );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( temp1 ) );
                    result = NEGATE( temp2 );
                    break;
                }
                case 419: // i4 i2 and neg i1 neg and neg
                {
                    int temp0 = create (NodeType.AND, rr_nn, lr_nn );
                    int temp1 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( ll_nn ) );
                    result = NEGATE( temp1 );
                    break;
                }
                case 420: // i1 i4 and neg i1 i2 xor and
                {
                    int temp0 = create (NodeType.AND, ll_nn, rr_nn );
                    int temp1 = create (NodeType.XOR, ll_nn, lr_nn );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), temp1 );
                    result = temp2;
                    break;
                }
                case 421: // i1 i4 and neg i1 i2 xor neg and
                {
                    int temp0 = create (NodeType.AND, ll_nn, rr_nn );
                    int temp1 = create (NodeType.XOR, ll_nn, lr_nn );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 422: // i1 i2 xor i4 i2 and neg and
                {
                    int temp0 = create (NodeType.XOR, ll_nn, lr_nn );
                    int temp1 = create (NodeType.AND, rr_nn, lr_nn );
                    int temp2 = create_op_node (NodeType.AND, temp0, NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 423: // i1 neg i4 and neg i1 i2 xor neg and
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), rr_nn );
                    int temp1 = create (NodeType.XOR, ll_nn, lr_nn );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 424: // i1 i4 neg and neg i1 i2 xor and
                {
                    int temp0 = create (NodeType.AND, ll_nn, NEGATE( rr_nn ) );
                    int temp1 = create (NodeType.XOR, ll_nn, lr_nn );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), temp1 );
                    result = temp2;
                    break;
                }
                case 425: // i1 i4 neg and neg i1 i2 xor neg and
                {
                    int temp0 = create (NodeType.AND, ll_nn, NEGATE( rr_nn ) );
                    int temp1 = create (NodeType.XOR, ll_nn, lr_nn );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 426: // i1 i2 xor i4 neg i2 and neg and
                {
                    int temp0 = create (NodeType.XOR, ll_nn, lr_nn );
                    int temp1 = create (NodeType.AND, NEGATE( rr_nn ), lr_nn );
                    int temp2 = create_op_node (NodeType.AND, temp0, NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 427: // i1 neg i4 neg and neg i1 i2 xor neg and
                {
                    int temp0 = create (NodeType.AND, NEGATE( ll_nn ), NEGATE( rr_nn ) );
                    int temp1 = create (NodeType.XOR, ll_nn, lr_nn );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 428: // i1 i4 xor i1 i2 and neg and
                {
                    int temp0 = create (NodeType.XOR, ll_nn, rr_nn );
                    int temp1 = create (NodeType.AND, ll_nn, lr_nn );
                    int temp2 = create_op_node (NodeType.AND, temp0, NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 429: // i1 i4 xor i4 i2 and neg and
                {
                    int temp0 = create (NodeType.XOR, ll_nn, rr_nn );
                    int temp1 = create (NodeType.AND, rr_nn, lr_nn );
                    int temp2 = create_op_node (NodeType.AND, temp0, NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 430: // i1 i4 xor i1 i2 neg and neg and
                {
                    int temp0 = create (NodeType.XOR, ll_nn, rr_nn );
                    int temp1 = create (NodeType.AND, ll_nn, NEGATE( lr_nn ) );
                    int temp2 = create_op_node (NodeType.AND, temp0, NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 431: // i1 i4 xor i4 i2 neg and neg and
                {
                    int temp0 = create (NodeType.XOR, ll_nn, rr_nn );
                    int temp1 = create (NodeType.AND, rr_nn, NEGATE( lr_nn ) );
                    int temp2 = create_op_node (NodeType.AND, temp0, NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 432: // i1 i4 xor neg i1 i2 and neg and
                {
                    int temp0 = create (NodeType.XOR, ll_nn, rr_nn );
                    int temp1 = create (NodeType.AND, ll_nn, lr_nn );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 433: // i1 i4 xor neg i1 neg i2 and neg and
                {
                    int temp0 = create (NodeType.XOR, ll_nn, rr_nn );
                    int temp1 = create (NodeType.AND, NEGATE( ll_nn ), lr_nn );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 434: // i1 i4 xor neg i1 i2 neg and neg and
                {
                    int temp0 = create (NodeType.XOR, ll_nn, rr_nn );
                    int temp1 = create (NodeType.AND, ll_nn, NEGATE( lr_nn ) );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 435: // i1 i4 xor neg i1 neg i2 neg and neg and
                {
                    int temp0 = create (NodeType.XOR, ll_nn, rr_nn );
                    int temp1 = create (NodeType.AND, NEGATE( ll_nn ), NEGATE( lr_nn ) );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 436: // i1 i4 xor i1 i2 xor and
                {
                    int temp0 = create (NodeType.XOR, ll_nn, rr_nn );
                    int temp1 = create (NodeType.XOR, ll_nn, lr_nn );
                    int temp2 = create_op_node (NodeType.AND, temp0, temp1 );
                    result = temp2;
                    break;
                }
                case 437: // i1 i4 xor i4 i2 xor and
                {
                    int temp0 = create (NodeType.XOR, ll_nn, rr_nn );
                    int temp1 = create (NodeType.XOR, rr_nn, lr_nn );
                    int temp2 = create_op_node (NodeType.AND, temp0, temp1 );
                    result = temp2;
                    break;
                }
                case 438: // i1 i2 xor i4 i2 xor and
                {
                    int temp0 = create (NodeType.XOR, ll_nn, lr_nn );
                    int temp1 = create (NodeType.XOR, rr_nn, lr_nn );
                    int temp2 = create_op_node (NodeType.AND, temp0, temp1 );
                    result = temp2;
                    break;
                }
                case 439: // i1 i4 xor neg i1 i2 xor neg and
                {
                    int temp0 = create (NodeType.XOR, ll_nn, rr_nn );
                    int temp1 = create (NodeType.XOR, ll_nn, lr_nn );
                    int temp2 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( temp1 ) );
                    result = temp2;
                    break;
                }
                case 440: // i4 i2 xor i1 and
                {
                    int temp0 = create (NodeType.XOR, rr_nn, lr_nn );
                    int temp1 = create_op_node (NodeType.AND, temp0, ll_nn );
                    result = temp1;
                    break;
                }
                case 441: // i4 i2 xor neg i1 and
                {
                    int temp0 = create (NodeType.XOR, rr_nn, lr_nn );
                    int temp1 = create_op_node (NodeType.AND, NEGATE( temp0 ), ll_nn );
                    result = temp1;
                    break;
                }
                case 442: // i4 i2 xor i1 neg and
                {
                    int temp0 = create (NodeType.XOR, rr_nn, lr_nn );
                    int temp1 = create_op_node (NodeType.AND, temp0, NEGATE( ll_nn ) );
                    result = temp1;
                    break;
                }
                case 443: // i4 i2 xor neg i1 neg and
                {
                    int temp0 = create (NodeType.XOR, rr_nn, lr_nn );
                    int temp1 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( ll_nn ) );
                    result = temp1;
                    break;
                }
                case 444: // i4 i2 xor i1 and neg
                {
                    int temp0 = create (NodeType.XOR, rr_nn, lr_nn );
                    int temp1 = create_op_node (NodeType.AND, temp0, ll_nn );
                    result = NEGATE( temp1 );
                    break;
                }
                case 445: // i4 i2 xor neg i1 and neg
                {
                    int temp0 = create (NodeType.XOR, rr_nn, lr_nn );
                    int temp1 = create_op_node (NodeType.AND, NEGATE( temp0 ), ll_nn );
                    result = NEGATE( temp1 );
                    break;
                }
                case 446: // i4 i2 xor i1 neg and neg
                {
                    int temp0 = create (NodeType.XOR, rr_nn, lr_nn );
                    int temp1 = create_op_node (NodeType.AND, temp0, NEGATE( ll_nn ) );
                    result = NEGATE( temp1 );
                    break;
                }
                case 447: // i4 i2 xor neg i1 neg and neg
                {
                    int temp0 = create (NodeType.XOR, rr_nn, lr_nn );
                    int temp1 = create_op_node (NodeType.AND, NEGATE( temp0 ), NEGATE( ll_nn ) );
                    result = NEGATE( temp1 );
                    break;
                }
                case 448: // i4 i2 xor
                {
                    int temp0 = create_op_node (NodeType.XOR, rr_nn, lr_nn );
                    result = temp0;
                    break;
                }
                case 449: // i4 i2 xor neg
                {
                    int temp0 = create_op_node (NodeType.XOR, rr_nn, lr_nn );
                    result = NEGATE( temp0 );
                    break;
                }
                default:
                    throw new Exception ("Unknown Cases");

            }
            return result;
        }
        #endregion

    }
}