public override int Run(InterpretedFrame frame)
 {
     int index = frame.StackIndex - this._argumentCount;
     frame.Data[index] = this._site.Target(this._site, new ArgumentArray(frame.Data, index, this._argumentCount));
     frame.StackIndex = index + 1;
     return 1;
 }

 public override int Run(InterpretedFrame frame)
 {
     object obj2 = frame.Pop();
     object obj3 = frame.Pop();
     frame.Push(ScriptingRuntimeHelpers.BooleanToObject((obj3 != null) && (obj3.GetType() == obj2)));
     return 1;
 }

 public override int Run(InterpretedFrame frame)
 {
     object obj2 = frame.Pop();
     object obj3 = frame.Pop();
     this._field.SetValue(obj3, obj2);
     return 1;
 }

 internal System.Management.Automation.Interpreter.ThreadLocal<InterpretedFrame>.StorageInfo Enter()
 {
     var storageInfo = CurrentFrame.GetStorageInfo();
     this._parent = storageInfo.Value;
     storageInfo.Value = this;
     return storageInfo;
 }

 public override int Run(InterpretedFrame frame)
 {
     object value = frame.Pop();
     object self = frame.Pop();
     _field.SetValue(self, value);
     return +1;
 }

 public override int Run(InterpretedFrame frame)
 {
     object obj2 = frame.Data[frame.StackIndex - 2];
     object obj3 = frame.Data[frame.StackIndex - 1];
     frame.Data[frame.StackIndex - 2] = (short) (((short) obj2) * ((short) obj3));
     frame.StackIndex--;
     return 1;
 }

 public override int Run(InterpretedFrame frame)
 {
     if ((bool) frame.Pop())
     {
         return base._offset;
     }
     return 1;
 }

 public override int Run(InterpretedFrame frame)
 {
     object obj2 = frame.Data[frame.StackIndex - 2];
     object obj3 = frame.Data[frame.StackIndex - 1];
     frame.Data[frame.StackIndex - 2] = ((double) obj2) + ((double) obj3);
     frame.StackIndex--;
     return 1;
 }

 public override int Run(InterpretedFrame frame)
 {
     object l = frame.Data[frame.StackIndex - 2];
     object r = frame.Data[frame.StackIndex - 1];
     frame.Data[frame.StackIndex - 2] = (UInt32)unchecked((UInt32)l - (UInt32)r);
     frame.StackIndex--;
     return +1;
 }

 public override int Run(InterpretedFrame frame)
 {
     if (frame.Peek() != null)
     {
         return base._offset;
     }
     return 1;
 }

 public override int Run(InterpretedFrame frame)
 {
     object l = frame.Data[frame.StackIndex - 2];
     object r = frame.Data[frame.StackIndex - 1];
     frame.Data[frame.StackIndex - 2] = (UInt16)((UInt16)l / (UInt16)r);
     frame.StackIndex--;
     return 1;
 }

 public override int Run(InterpretedFrame frame)
 {
     frame.PopPendingContinuation();
     if (!frame.IsJumpHappened())
     {
         return 1;
     }
     return frame.YieldToPendingContinuation();
 }

 internal int GotoHandler(InterpretedFrame frame, object exception, out ExceptionHandler handler)
 {
     handler = this._handlers.FirstOrDefault<ExceptionHandler>(t => t.Matches(exception.GetType()));
     if (handler == null)
     {
         return 0;
     }
     return frame.Goto(handler.LabelIndex, exception, true);
 }

 public override int Run(InterpretedFrame frame)
 {
     int num;
     if (!this._cases.TryGetValue((int) frame.Pop(), out num))
     {
         return 1;
     }
     return num;
 }

 public override int Run(InterpretedFrame frame)
 {
     Exception exception = (Exception) frame.Pop();
     if (this._rethrow)
     {
         throw new RethrowException();
     }
     throw exception;
 }

        public override int Run(InterpretedFrame frame)
        {
            int first = frame.StackIndex - _argumentCount;
            object ret = _site.Target(_site, new ArgumentArray(frame.Data, first, _argumentCount));
            frame.Data[first] = ret;
            frame.StackIndex = first + 1;

            return 1;
        }

 public override int Run(InterpretedFrame frame)
 {
     IStrongBox[] boxes = new IStrongBox[this._count];
     for (int i = boxes.Length - 1; i >= 0; i--)
     {
         boxes[i] = (IStrongBox) frame.Pop();
     }
     frame.Push(System.Management.Automation.Interpreter.RuntimeVariables.Create(boxes));
     return 1;
 }

 public override int Run(InterpretedFrame frame)
 {
     if (!frame.IsJumpHappened())
     {
         frame.SetStackDepth(base.GetLabel(frame).StackDepth);
     }
     frame.PushPendingContinuation();
     frame.RemoveContinuation();
     return 1;
 }

 public void Run(InterpretedFrame frame)
 {
     Instruction[] instructions = this._instructions.Instructions;
     int instructionIndex = frame.InstructionIndex;
     while (instructionIndex < instructions.Length)
     {
         instructionIndex += instructions[instructionIndex].Run(frame);
         frame.InstructionIndex = instructionIndex;
     }
 }

 public override int Run(InterpretedFrame frame)
 {
     int[] lengths = new int[this._rank];
     for (int i = this._rank - 1; i >= 0; i--)
     {
         lengths[i] = (int) frame.Pop();
     }
     Array array = Array.CreateInstance(this._elementType, lengths);
     frame.Push(array);
     return 1;
 }