internal void RemoveJump(BlockEndOpcode jumpTo)
 {
     bool flag = base.IsReachableFromConditional();
     if (flag)
     {
         base.prev.DelinkFromConditional(this);
     }
     if (this.jump.ID == OpcodeID.Branch)
     {
         BranchOpcode jump = (BranchOpcode) this.jump;
         jumpTo.DeLinkJump(this);
         jump.RemoveChild(jumpTo);
         if (jump.Branches.Count == 0)
         {
             this.jump = null;
         }
     }
     else
     {
         jumpTo.DeLinkJump(this);
         this.jump = null;
     }
     if (flag && (this.jump != null))
     {
         base.prev.LinkToConditional(this);
     }
 }

 internal override void Add(Opcode opcode)
 {
     LiteralRelationOpcode opcode2 = this.ValidateOpcode(opcode);
     if (opcode2 == null)
     {
         base.Add(opcode);
     }
     else
     {
         QueryBranch literalBranch = this.branchIndex[opcode2.Literal];
         if (literalBranch == null)
         {
             this.nextID++;
             literalBranch = new QueryBranch(opcode2, this.nextID);
             opcode2.Prev = this;
             this.branchIndex[opcode2.Literal] = literalBranch;
         }
         else
         {
             literalBranch.Branch.Next.Add(opcode2.Next);
         }
         opcode2.Flags |= OpcodeFlags.InConditional;
         this.AddAlwaysBranch(literalBranch, opcode2.Next);
     }
 }

 private void AddAlwaysBranch(QueryBranch literalBranch, Opcode next)
 {
     if (OpcodeID.Branch == next.ID)
     {
         BranchOpcode opcode = (BranchOpcode) next;
         OpcodeList branches = opcode.Branches;
         for (int i = 0; i < branches.Count; i++)
         {
             Opcode opcode2 = branches[i];
             if (this.IsAlwaysBranch(opcode2))
             {
                 this.AlwaysBranches.AddInOrder(new QueryBranch(opcode2, literalBranch.ID));
             }
             else
             {
                 opcode2.Flags |= OpcodeFlags.NoContextCopy;
             }
         }
     }
     else if (this.IsAlwaysBranch(next))
     {
         this.AlwaysBranches.AddInOrder(new QueryBranch(next, literalBranch.ID));
     }
     else
     {
         next.Flags |= OpcodeFlags.NoContextCopy;
     }
 }

 internal override void DelinkFromConditional(Opcode child)
 {
     if (base.prev != null)
     {
         base.prev.DelinkFromConditional(child);
     }
 }

 internal void AddJump(BlockEndOpcode jumpTo)
 {
     bool flag = base.IsReachableFromConditional();
     if (flag)
     {
         base.prev.DelinkFromConditional(this);
     }
     if (this.jump == null)
     {
         this.jump = jumpTo;
     }
     else
     {
         BranchOpcode jump;
         if (this.jump.ID == OpcodeID.Branch)
         {
             jump = (BranchOpcode) this.jump;
         }
         else
         {
             BlockEndOpcode opcode = (BlockEndOpcode) this.jump;
             jump = new BranchOpcode();
             jump.Branches.Add(opcode);
             this.jump = jump;
         }
         jump.Branches.Add(jumpTo);
     }
     jumpTo.LinkJump(this);
     if (flag && (this.jump != null))
     {
         base.prev.LinkToConditional(this);
     }
 }

 internal virtual void DelinkFromConditional(Opcode child)
 {
     if (this.TestFlag(OpcodeFlags.InConditional))
     {
         ((QueryConditionalBranchOpcode) this.prev).RemoveAlwaysBranch(child);
     }
 }

 private SubExpr BranchAt(Opcode op, SubExprEliminator elim)
 {
     Opcode firstOp = this.FirstOp;
     if (this.parent != null)
     {
         this.parent.RemoveChild(this);
     }
     else
     {
         elim.Exprs.Remove(this);
     }
     firstOp.DetachFromParent();
     op.DetachFromParent();
     SubExpr expr = new SubExpr(this.parent, firstOp, elim.NewVarID());
     if (this.parent != null)
     {
         this.parent.AddChild(expr);
     }
     else
     {
         elim.Exprs.Add(expr);
     }
     expr.AddChild(this);
     this.parent = expr;
     this.ops = new InternalSubExprOpcode(expr);
     this.ops.Attach(op);
     return expr;
 }

 internal override bool Equals(Opcode op)
 {
     if (base.Equals(op))
     {
         return (this.op == ((RelationOpcode)op).op);
     }
     return false;
 }

 internal override bool Equals(Opcode op)
 {
     if (base.Equals(op))
     {
         NumberEqualsOpcode opcode = (NumberEqualsOpcode) op;
         return (opcode.literal == this.literal);
     }
     return false;
 }

 internal override bool Equals(Opcode opcode)
 {
     if (!base.Equals(opcode))
     {
         return false;
     }
     NumberRelationOpcode opcode2 = (NumberRelationOpcode) opcode;
     return ((opcode2.op == this.op) && (opcode2.literal == this.literal));
 }

        // Never used for inverse query, so don't need this
        internal override bool Equals(Opcode op)
        {
            if (base.Equals (op))
            {
                return (this.ordinal == ((LiteralOrdinalOpcode) op).ordinal);
            }

            return false;
        }

 internal override void AddBranch(Opcode opcode)
 {
     this.branches.Add(opcode);
     opcode.Prev = this;
     if (this.IsInConditional())
     {
         this.LinkToConditional(opcode);
     }
 }

 internal override bool Equals(Opcode op)
 {
     if (base.Equals(op))
     {
         StringPrefixOpcode opcode = (StringPrefixOpcode) op;
         return (opcode.literal == this.literal);
     }
     return false;
 }

        internal override bool Equals(Opcode op)
        {
            if (base.Equals(op))
            {
                return (this.mathOp == ((MathOpcode) op).mathOp);
            }

            return false;
        }

 internal override LiteralRelationOpcode ValidateOpcode(Opcode opcode)
 {
     StringEqualsOpcode opcode2 = opcode as StringEqualsOpcode;
     if (opcode2 != null)
     {
         return opcode2;
     }
     return null;
 }

 internal override LiteralRelationOpcode ValidateOpcode(Opcode opcode)
 {
     NumberIntervalOpcode opcode2 = opcode as NumberIntervalOpcode;
     if (opcode2 != null)
     {
         return opcode2;
     }
     return null;
 }

 internal Opcode Add(object item, Opcode ops)
 {
     List<SubExpr> list = new List<SubExpr>();
     this.removalMapping.Add(item, list);
     while (ops.Next != null)
     {
         ops = ops.Next;
     }
     Opcode opcode = ops;
     while (ops != null)
     {
         if (IsExprStarter(ops))
         {
             SubExprOpcode opcode4;
             Opcode op = ops;
             Opcode prev = ops.Prev;
             ops.DetachFromParent();
             ops = ops.Next;
             while (ops.ID == OpcodeID.Select)
             {
                 ops = ops.Next;
             }
             ops.DetachFromParent();
             SubExpr expr = null;
             for (int i = 0; i < this.exprList.Count; i++)
             {
                 if (this.exprList[i].FirstOp.Equals(op))
                 {
                     expr = this.exprList[i];
                     break;
                 }
             }
             if (expr == null)
             {
                 expr = new SubExpr(null, op, this.NewVarID());
                 this.exprList.Add(expr);
                 opcode4 = new SubExprOpcode(expr);
             }
             else
             {
                 opcode4 = expr.Add(op, this);
             }
             opcode4.Expr.IncRef();
             list.Add(opcode4.Expr);
             opcode4.Attach(ops);
             ops = opcode4;
             if (prev != null)
             {
                 prev.Attach(ops);
             }
         }
         opcode = ops;
         ops = ops.Prev;
     }
     return opcode;
 }

        internal override bool Equals(Opcode op)
        {
            if (base.Equals(op))
            {
                FunctionCallOpcode functionCall = (FunctionCallOpcode)op;
                return functionCall.function.Equals(this.function);
            }

            return false;
        }

 internal Opcode DetachChild()
 {
     Opcode next = this.next;
     if ((next != null) && this.IsInConditional())
     {
         this.DelinkFromConditional(next);
     }
     this.next = null;
     next.prev = null;
     return next;
 }

 internal override void Add(Opcode opcode)
 {
     for (int i = 0; i < this.branches.Count; i++)
     {
         if (this.branches[i].IsEquivalentForAdd(opcode))
         {
             this.branches[i].Add(opcode);
             return;
         }
     }
     this.AddBranch(opcode);
 }