# Copyright (C) 2010-2016 JPEXS, All rights reserved.
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
# License as published by the Free Software Foundation; either
# version 3.0 of the License, or (at your option) any later version.
#
# This library is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
# Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public
# License along with this library.

#String for whole list generation
ui.list.heading = AVM2 Instruction list
ui.list.pageTitle = AVM2 Instruction list
ui.list.documentTitle = AVM2 Instruction list
ui.list.pageDescription = List of all known ActionScript 3 - AVM2 instructions with their operands and stack values

#various strings in UI:
ui.unknown = ???
ui.stack = Stack:\u0020
ui.stack.before = ...,\u0020
ui.stack.before.empty = ...
ui.stack.to = \u0020\u279e\u0020
ui.flags = Flags:\u0020
ui.description = Description:\u0020
ui.filter.hide = Hide:\u0020
ui.filter.byname = Find by name:\u0020
ui.filter.order = Order by:\u0020
ui.filter.order.code = code
ui.filter.order.name = name


#----------------------- Flags of the instructions
instructionFlag.undocumented = Undocumented
instructionFlag.unknownStack = Unknown stack
instructionFlag.es4NumericsMinor = ES4 numerics (ABC minor 17)
instructionFlag.floatMajor = Float values (ABC major 47)
instructionFlag.unknownOperands = Unknown operands
instructionFlag.noFlashPlayer = Not in standard Flash Player
instructionFlag.deprecated = Deprecated
instructionFlag.domainMemory = Domain memory operation

#----------------------- Operand types
operandType.multinameIndex = Multiname index
operandType.multinameIndex.description = Index into multiname constant pool
operandType.multinameIndex.name = multinameIndex
operandType.multinameIndex.uiName = multiname

operandType.argCount = Number of arguments
operandType.argCount.description = Number of following arguments
operandType.argCount.name = argCount
operandType.argCount.uiName = uint


operandType.methodIndex = Method index
operandType.methodIndex.description = Index of method in the ABC
operandType.methodIndex.name = methodIndex
operandType.methodIndex.uiName = methodIndex

operandType.stringIndex = String index
operandType.stringIndex.description = Index into string values constant pool
operandType.stringIndex.name = stringIndex
operandType.stringIndex.uiName = string


operandType.debugType = Debug type
operandType.debugType.description = Type of debug information. Currently only value of 1 is used.
operandType.debugType.name = debugType
operandType.debugType.uiName = debugType


operandType.registerIndex = Register index
operandType.registerIndex.description = Index of a local register (0-255)
operandType.registerIndex.name = registerIndex
operandType.registerIndex.uiName = uint

operandType.linenum = Line number
operandType.linenum.description = Line number of file
operandType.linenum.name = linenum
operandType.linenum.uiName = linenum


#similar as registerIndex, but U30 instead of U8
operandType.localRegIndex = Register index
operandType.localRegIndex.description = Index of a local register
operandType.localRegIndex.name = localRegIndex
operandType.localRegIndex.uiName = uint


operandType.slotIndex = Slot index
operandType.slotIndex.description = Index of the slot on an object
operandType.slotIndex.name = slotIndex
operandType.slotIndex.uiName = slotIndex

operandType.scopeIndex = Scope stack index
operandType.scopeIndex.description = Index in the scope stack
operandType.scopeIndex.name = scopeIndex
operandType.scopeIndex.uiName = scopeIndex

operandType.offset = Offset
operandType.offset.description = Offset to other location
operandType.offset.name = offset
operandType.offset.uiName = labelName

operandType.exceptionIndex = Exception index
operandType.exceptionIndex.description = Index of exception in current method info
operandType.exceptionIndex.name = exceptionIndex
operandType.exceptionIndex.uiName = exceptionIndex


operandType.classIndex = Class index
operandType.classIndex.description = Index of class in ABC
operandType.classIndex.name = classIndex
operandType.classIndex.uiName = classIndex

operandType.intIndex = Int index
operandType.intIndex.description = Index into integer values constant pool
operandType.intIndex.name = intIndex
operandType.intIndex.uiName = int

operandType.uintIndex = UInt index
operandType.uintIndex.description = Index into unsigned integer values constant pool
operandType.uintIndex.name = uintIndex
operandType.uintIndex.uiName = uint


operandType.doubleIndex = Double index
operandType.doubleIndex.description = Index into double precision floating point values constant pool
operandType.doubleIndex.name = doubleIndex
operandType.doubleIndex.uiName = double

operandType.decimalIndex = Decimal index
operandType.decimalIndex.description = Index into decimal values (128bit floating point) constant pool
operandType.decimalIndex.name = decimalIndex
operandType.decimalIndex.uiName = decimal

operandType.caseBaseoffset = Base offset
operandType.caseBaseoffset.description = Base offset of lookupswitch triggered when no value matches
operandType.caseBaseoffset.name = offset
operandType.caseBaseoffset.uiName = labelName

operandType.numberContext = Number context (ES4)
operandType.numberContext.description = Context of calculations when using EcmaScript 4 numerics (ABC minorVersion 17).\nBits 0-2 type,3-5 rounding type, 6-12 precision.\nType: 0=number,1=decimal,2=double,3=int,4=uint\nRounding: 0=ceiling,1=up,2=half_up,3=half_even,4=half_down,5=down,6=floor\nPrecision:0-34
operandType.numberContext.name = numberContext
operandType.numberContext.uiName = uint

operandType.dispatchId = Dispatch id
operandType.dispatchId.description = Id of the method dispatch
operandType.dispatchId.name = dispatchId
operandType.dispatchId.uiName = uint

operandType.floatIndex = Float index
operandType.floatIndex.description = Index into float values constant pool
operandType.floatIndex.name = floatIndex
operandType.floatIndex.uiName = float

operandType.float4Index = Float4 index
operandType.float4Index.description = Index into float4 values constant pool
operandType.float4Index.name = float4Index
operandType.float4Index.uiName = float4

operandType.namespaceIndex = Namespace index
operandType.namespaceIndex = Index into namespace constant pool
operandType.namespaceIndex.name = namespaceIndex
operandType.namespaceIndex.uiName = namespace


#----------------------- Instructions

instruction.bkpt.shortDescription = Breakpoint
instruction.bkpt.description = Breakpoint when debugging
instruction.bkpt.stackBefore =
instruction.bkpt.stackAfter =
instruction.bkpt.operands =

instruction.nop.shortDescription = No operation
instruction.nop.description = Does nothing
instruction.nop.stackBefore =
instruction.nop.stackAfter =
instruction.nop.operands =

instruction.throw.shortDescription = Throw exception
instruction.throw.description = Pops value off the stack and throws it
instruction.throw.stackBefore = value
instruction.throw.stackAfter =
instruction.throw.operands =

instruction.getsuper.shortDescription = Get parent class property
instruction.getsuper.description =
instruction.getsuper.stackBefore = obj, [ns], [name]
instruction.getsuper.stackAfter = value
instruction.getsuper.operands = parentClassMultiname

instruction.setsuper.shortDescription = Set parent class property
instruction.setsuper.description =
instruction.setsuper.stackBefore = obj, [ns], [name], value
instruction.setsuper.stackAfter =
instruction.setsuper.operands = parentClassMultiname

instruction.dxns.shortDescription = Set default XML namespace
instruction.dxns.description =
instruction.dxns.stackBefore =
instruction.dxns.stackAfter =
instruction.dxns.operands = uriString

instruction.dxnslate.shortDescription = Set default XML namespace at runtime
instruction.dxnslate.description =
instruction.dxnslate.stackBefore = uriValue
instruction.dxnslate.stackAfter =
instruction.dxnslate.operands =

instruction.kill.shortDescription = Kill local register
instruction.kill.description =
instruction.kill.stackBefore =
instruction.kill.stackAfter =
instruction.kill.operands = killedRegister

instruction.label.shortDescription = Target of a branch
instruction.label.description = Just a mark that this is target of following branch
instruction.label.stackBefore =
instruction.label.stackAfter =
instruction.label.operands =

instruction.lf32x4.shortDescription = Load 32bit float4
instruction.lf32x4.description =
instruction.lf32x4.stackBefore = address
instruction.lf32x4.stackAfter = float4Value
instruction.lf32x4.operands =

instruction.sf32x4.shortDescription = Store 32bit float4
instruction.sf32x4.description =
instruction.sf32x4.stackBefore = float4Value, address
instruction.sf32x4.stackAfter =
instruction.sf32x4.operands =

instruction.ifnlt.shortDescription = Branch if not lower than
instruction.ifnlt.description =
instruction.ifnlt.stackBefore = value1, value2
instruction.ifnlt.stackAfter =
instruction.ifnlt.operands = branchTarget

instruction.ifnle.shortDescription = Branch if not lower or equal
instruction.ifnle.description =
instruction.ifnle.stackBefore = value1, value2
instruction.ifnle.stackAfter =
instruction.ifnle.operands = branchTarget

instruction.ifngt.shortDescription = Branch if not greater than
instruction.ifngt.description =
instruction.ifngt.stackBefore = value1, value2
instruction.ifngt.stackAfter =
instruction.ifngt.operands = branchTarget

instruction.ifnge.shortDescription = Branch if not greater ot equal
instruction.ifnge.description =
instruction.ifnge.stackBefore = value1, value2
instruction.ifnge.stackAfter =
instruction.ifnge.operands = branchTarget

instruction.jump.shortDescription = Jump to location
instruction.jump.description =
instruction.jump.stackBefore =
instruction.jump.stackAfter =
instruction.jump.operands = location

instruction.iftrue.shortDescription =  Branch if true
instruction.iftrue.description =
instruction.iftrue.stackBefore = value
instruction.iftrue.stackAfter =
instruction.iftrue.operands = branchTarget

instruction.iffalse.shortDescription = Branch if false
instruction.iffalse.description =
instruction.iffalse.stackBefore = value
instruction.iffalse.stackAfter =
instruction.iffalse.operands = branchTarget

instruction.ifeq.shortDescription = Branch if equal
instruction.ifeq.description =
instruction.ifeq.stackBefore = value1, value2
instruction.ifeq.stackAfter =
instruction.ifeq.operands = branchTarget

instruction.ifne.shortDescription = Branch if not equal
instruction.ifne.description =
instruction.ifne.stackBefore = value1, value2
instruction.ifne.stackAfter =
instruction.ifne.operands = branchTarget

instruction.iflt.shortDescription = Branch if lower than
instruction.iflt.description =
instruction.iflt.stackBefore = value1, value2
instruction.iflt.stackAfter =
instruction.iflt.operands = branchTarget

instruction.ifle.shortDescription = Branch if lower or equal
instruction.ifle.description =
instruction.ifle.stackBefore = value1, value2
instruction.ifle.stackAfter =
instruction.ifle.operands = branchTarget

instruction.ifgt.shortDescription = Branch if greater than
instruction.ifgt.description =
instruction.ifgt.stackBefore = value1, value2
instruction.ifgt.stackAfter =
instruction.ifgt.operands = branchTarget

instruction.ifge.shortDescription = Branch if greater or equal
instruction.ifge.description =
instruction.ifge.stackBefore = value1, value2
instruction.ifge.stackAfter =
instruction.ifge.operands = branchTarget

instruction.ifstricteq.shortDescription = Branch if strict equal
instruction.ifstricteq.description =
instruction.ifstricteq.stackBefore = value1, value2
instruction.ifstricteq.stackAfter =
instruction.ifstricteq.operands = branchTarget

instruction.ifstrictne.shortDescription = Branch if not strict equal
instruction.ifstrictne.description =
instruction.ifstrictne.stackBefore = value1, value2
instruction.ifstrictne.stackAfter =
instruction.ifstrictne.operands = branchTarget

instruction.lookupswitch.shortDescription = Branch based on index
instruction.lookupswitch.description =
instruction.lookupswitch.stackBefore = index
instruction.lookupswitch.stackAfter =
instruction.lookupswitch.operands = defaultTarget, caseCount, case0Target, case1Target, ...

instruction.pushwith.shortDescription = Push with onto scope stack
instruction.pushwith.description =
instruction.pushwith.stackBefore = withScope
instruction.pushwith.stackAfter =
instruction.pushwith.operands =

instruction.popscope.shortDescription = Pop from scope stack and discard value
instruction.popscope.description =
instruction.popscope.stackBefore =
instruction.popscope.stackAfter =
instruction.popscope.operands =

instruction.nextname.shortDescription = Get name of next property
instruction.nextname.description =
instruction.nextname.stackBefore = obj, index
instruction.nextname.stackAfter = name
instruction.nextname.operands =

instruction.hasnext.shortDescription = Check if the object has more properties
instruction.hasnext.description =
instruction.hasnext.stackBefore = obj, currentIndex
instruction.hasnext.stackAfter = nextIndex
instruction.hasnext.operands =

instruction.pushnull.shortDescription = Push null value on stack
instruction.pushnull.description =
instruction.pushnull.stackBefore =
instruction.pushnull.stackAfter = null
instruction.pushnull.operands =

instruction.pushundefined.shortDescription = Push undefined value on stack
instruction.pushundefined.description =
instruction.pushundefined.stackBefore =
instruction.pushundefined.stackAfter = undefined
instruction.pushundefined.operands =

instruction.pushfloat.shortDescription = Push float value on stack
instruction.pushfloat.description =
instruction.pushfloat.stackBefore =
instruction.pushfloat.stackAfter = floatValue
instruction.pushfloat.operands = float

instruction.nextvalue.shortDescription = Get value of next property
instruction.nextvalue.description =
instruction.nextvalue.stackBefore = obj, index
instruction.nextvalue.stackAfter = value
instruction.nextvalue.operands =

instruction.pushbyte.shortDescription = Push byte value on stack
instruction.pushbyte.description =
instruction.pushbyte.stackBefore =
instruction.pushbyte.stackAfter = byteValue
instruction.pushbyte.operands = value

instruction.pushshort.shortDescription = Push short value on stack
instruction.pushshort.description =
instruction.pushshort.stackBefore =
instruction.pushshort.stackAfter = shortValue
instruction.pushshort.operands = value

instruction.pushtrue.shortDescription = Push true on stack
instruction.pushtrue.description =
instruction.pushtrue.stackBefore =
instruction.pushtrue.stackAfter = true
instruction.pushtrue.operands =

instruction.pushfalse.shortDescription = Push false on stack
instruction.pushfalse.description =
instruction.pushfalse.stackBefore =
instruction.pushfalse.stackAfter = false
instruction.pushfalse.operands =

instruction.pushnan.shortDescription = Push NaN value on stack
instruction.pushnan.description =
instruction.pushnan.stackBefore =
instruction.pushnan.stackAfter = NaN
instruction.pushnan.operands =

instruction.pop.shortDescription = Pop top value from stack
instruction.pop.description =
instruction.pop.stackBefore = value
instruction.pop.stackAfter =
instruction.pop.operands =

instruction.dup.shortDescription = Duplicate value on stack
instruction.dup.description =
instruction.dup.stackBefore = value
instruction.dup.stackAfter = value, value
instruction.dup.operands =

instruction.swap.shortDescription = Swap two values on top of the stack
instruction.swap.description =
instruction.swap.stackBefore = value1, value2
instruction.swap.stackAfter = value2, value1
instruction.swap.operands =

instruction.pushstring.shortDescription = Push string value on the stack
instruction.pushstring.description =
instruction.pushstring.stackBefore =
instruction.pushstring.stackAfter = stringValue
instruction.pushstring.operands = value

instruction.pushint.shortDescription = Push integer value on the stack
instruction.pushint.description =
instruction.pushint.stackBefore =
instruction.pushint.stackAfter = intValue
instruction.pushint.operands = value

instruction.pushuint.shortDescription = Push unsigned integer value on the stack
instruction.pushuint.description =
instruction.pushuint.stackBefore =
instruction.pushuint.stackAfter = uintValue
instruction.pushuint.operands = value

instruction.pushdouble.shortDescription = Push double precision value on the stack
instruction.pushdouble.description =
instruction.pushdouble.stackBefore =
instruction.pushdouble.stackAfter = doubleValue
instruction.pushdouble.operands = value

instruction.pushscope.shortDescription = Push object on the scope stack
instruction.pushscope.description =
instruction.pushscope.stackBefore = obj
instruction.pushscope.stackAfter =
instruction.pushscope.operands =

instruction.pushnamespace.shortDescription = Push namespace on the stack
instruction.pushnamespace.description =
instruction.pushnamespace.stackBefore =
instruction.pushnamespace.stackAfter = namespace
instruction.pushnamespace.operands = value

instruction.hasnext2.shortDescription = Check if the object has more properties (register based)
instruction.hasnext2.description =
instruction.hasnext2.stackBefore =
instruction.hasnext2.stackAfter = boolValue
instruction.hasnext2.operands = objectReg, indexReg

instruction.pushdecimal.shortDescription = Push decimal value on the stack
instruction.pushdecimal.description =
instruction.pushdecimal.stackBefore =
instruction.pushdecimal.stackAfter = decimalValue
instruction.pushdecimal.operands = value

#Undocumented:
instruction.pushdnan.shortDescription = Push decimal NaN value on the stack
instruction.pushdnan.description =
#instruction.pushdnan.stackBefore =
#instruction.pushdnan.stackAfter =
instruction.pushdnan.operands =

instruction.li8.shortDescription = Load 8bit integer value
instruction.li8.description =
instruction.li8.stackBefore = address
instruction.li8.stackAfter = int8Value
instruction.li8.operands =

instruction.li16.shortDescription = Load 16bit integer value
instruction.li16.description =
instruction.li16.stackBefore = address
instruction.li16.stackAfter = int16Value
instruction.li16.operands =

instruction.li32.shortDescription = Load 32bit integer value
instruction.li32.description =
instruction.li32.stackBefore = address
instruction.li32.stackAfter = int32Value
instruction.li32.operands =

instruction.lf32.shortDescription = Load 32bit float value
instruction.lf32.description =
instruction.lf32.stackBefore = address
instruction.lf32.stackAfter = float32Value
instruction.lf32.operands =

instruction.lf64.shortDescription = Load 64bit float value
instruction.lf64.description =
instruction.lf64.stackBefore = address
instruction.lf64.stackAfter = float64Value
instruction.lf64.operands =

instruction.si8.shortDescription = Store 8bit integer value
instruction.si8.description =
instruction.si8.stackBefore = value, address
instruction.si8.stackAfter =
instruction.si8.operands =

instruction.si16.shortDescription = Store 16bit integer value
instruction.si16.description =
instruction.si16.stackBefore = value, address
instruction.si16.stackAfter =
instruction.si16.operands =

instruction.si32.shortDescription = Store 32bit integer value
instruction.si32.description =
instruction.si32.stackBefore = value, address
instruction.si32.stackAfter =
instruction.si32.operands =

instruction.sf32.shortDescription = Store 32bit float value
instruction.sf32.description =
instruction.sf32.stackBefore = value, address
instruction.sf32.stackAfter =
instruction.sf32.operands =

instruction.sf64.shortDescription = Store 64bit float value
instruction.sf64.description =
instruction.sf64.stackBefore = value, address
instruction.sf64.stackAfter =
instruction.sf64.operands =

instruction.newfunction.shortDescription = Create new Function object
instruction.newfunction.description =
instruction.newfunction.stackBefore =
instruction.newfunction.stackAfter = function
instruction.newfunction.operands = method

instruction.call.shortDescription = Call function on the stack
instruction.call.description =
instruction.call.stackBefore = function, this, arg1, ..., argN
instruction.call.stackAfter = value
instruction.call.operands = argCount

instruction.construct.shortDescription = Call constructor function on the stack
instruction.construct.description =
instruction.construct.stackBefore = function, arg1, ..., argN
instruction.construct.stackAfter = value
instruction.construct.operands = argCount

instruction.callmethod.shortDescription = Call method of object by dispatch id
instruction.callmethod.description =
instruction.callmethod.stackBefore = this, arg1, ..., argN
instruction.callmethod.stackAfter = value
instruction.callmethod.operands = method, argCount

instruction.callstatic.shortDescription = Call method by method id in ABC file
instruction.callstatic.description =
instruction.callstatic.stackBefore = this, arg1, ..., argN
instruction.callstatic.stackAfter = value
instruction.callstatic.operands = method, argCount

instruction.callsuper.shortDescription = Call method on parent class
instruction.callsuper.description =
instruction.callsuper.stackBefore = obj, [ns], [name], arg1, ..., argN
instruction.callsuper.stackAfter = value
instruction.callsuper.operands = methodName, argCount

instruction.callproperty.shortDescription = Call property
instruction.callproperty.description =
instruction.callproperty.stackBefore = obj, [ns], [name], arg1, ..., argN
instruction.callproperty.stackAfter = value
instruction.callproperty.operands = property, argCount

instruction.returnvoid.shortDescription = Return from a method
instruction.returnvoid.description =
instruction.returnvoid.stackBefore =
instruction.returnvoid.stackAfter =
instruction.returnvoid.operands =

instruction.returnvalue.shortDescription = Return value from a method
instruction.returnvalue.description =
instruction.returnvalue.stackBefore = value
instruction.returnvalue.stackAfter =
instruction.returnvalue.operands =

instruction.constructsuper.shortDescription = Call parent constructor of an object
instruction.constructsuper.description =
instruction.constructsuper.stackBefore = obj, arg1, ..., argN
instruction.constructsuper.stackAfter =
instruction.constructsuper.operands = argCount

instruction.constructprop.shortDescription = Construct a property of an object
instruction.constructprop.description =
instruction.constructprop.stackBefore = obj, [ns], [name], arg1, ..., argN
instruction.constructprop.stackAfter = value
instruction.constructprop.operands = property, argCount

#Undocumented:
instruction.callsuperid.shortDescription = Call super id
instruction.callsuperid.description =
#instruction.callsuperid.stackBefore =
#instruction.callsuperid.stackAfter =
#instruction.callsuperid.operands =

instruction.callproplex.shortDescription = Call property with null as this
instruction.callproplex.description =
instruction.callproplex.stackBefore = obj, [ns], [name], arg1, ..., argN
instruction.callproplex.stackAfter = value
instruction.callproplex.operands = property, argCount

#Undocumented:
instruction.callinterface.shortDescription = Call interface
instruction.callinterface.description =
#instruction.callinterface.stackBefore =
#instruction.callinterface.stackAfter =
instruction.callinterface.operands = interface, argCount


instruction.callsupervoid.shortDescription = Call method on parent class, discard return value
instruction.callsupervoid.description =
instruction.callsupervoid.stackBefore = obj, [ns], [name], arg1, ..., argN
instruction.callsupervoid.stackAfter =
instruction.callsupervoid.operands = methodName, argCount


instruction.callpropvoid.shortDescription = Call property, discard return value
instruction.callpropvoid.description =
instruction.callpropvoid.stackBefore = obj, [ns], [name], arg1, ..., argN
instruction.callpropvoid.stackAfter = 
instruction.callpropvoid.operands = property, argCount

instruction.sxi1.shortDescription = Sign extend 1bit value to 32bits
instruction.sxi1.description =
instruction.sxi1.stackBefore = value
instruction.sxi1.stackAfter = valueExtended
instruction.sxi1.operands =

instruction.sxi8.shortDescription = Sign extend 8bit value to 32bits
instruction.sxi8.description =
instruction.sxi8.stackBefore = value
instruction.sxi8.stackAfter = valueExtended
instruction.sxi8.operands =

instruction.sxi16.shortDescription = Sign extend 16bit value to 32bits
instruction.sxi16.description =
instruction.sxi16.stackBefore = value
instruction.sxi16.stackAfter = valueExtended
instruction.sxi16.operands =

instruction.applytype.shortDescription = Apply type parameters
instruction.applytype.description = Apply parameter types to base type. For example when Vector<String> is resolved at runtime. String is parameter, Vector is baseclass.
instruction.applytype.stackBefore = baseType, typeParam1, ..., typeParamN
instruction.applytype.stackAfter = baseType<typeParam1, ..., typeParamN>
instruction.applytype.operands = typeParamCount

instruction.pushfloat4.shortDescription = Push float4 value on the stack
instruction.pushfloat4.description =
instruction.pushfloat4.stackBefore =
instruction.pushfloat4.stackAfter = float4Value
instruction.pushfloat4.operands = float4

instruction.newobject.shortDescription = Creates new object
instruction.newobject.description =
instruction.newobject.stackBefore = name1, value1, name2, value2, ..., nameN, valueN
instruction.newobject.stackAfter = newObject
instruction.newobject.operands = propertyCount

instruction.newarray.shortDescription = Creates new array
instruction.newarray.description =
instruction.newarray.stackBefore = value1, value2, ..., valueN
instruction.newarray.stackAfter = newArray
instruction.newarray.operands = valueCount

instruction.newactivation.shortDescription = Creates new activation object
instruction.newactivation.description =
instruction.newactivation.stackBefore =
instruction.newactivation.stackAfter = newActivation
instruction.newactivation.operands =

instruction.newclass.shortDescription = Creates new class
instruction.newclass.description =
instruction.newclass.stackBefore = baseType
instruction.newclass.stackAfter = newClass
instruction.newclass.operands = class

instruction.getdescendants.shortDescription = Get descendants
instruction.getdescendants.description =
instruction.getdescendants.stackBefore = obj, [ns], [name]
instruction.getdescendants.stackAfter = value
instruction.getdescendants.operands = operand1

instruction.newcatch.shortDescription = Create new catch scope
instruction.newcatch.description =
instruction.newcatch.stackBefore =
instruction.newcatch.stackAfter = catchScope
instruction.newcatch.operands = exception

#Undocumented:
instruction.deldescendants.shortDescription = Delete descendants
instruction.deldescendants.description =
#instruction.deldescendants.stackBefore =
#instruction.deldescendants.stackAfter =
instruction.deldescendants.operands =

#Undocumented:
instruction.findpropglobal.shortDescription = Search property in global scope
instruction.findpropglobal.description =
instruction.findpropglobal.stackBefore = [ns], [name]
instruction.findpropglobal.stackAfter = obj
instruction.findpropglobal.operands = property

instruction.findpropstrict.shortDescription = Search property in scope stack, error when not found
instruction.findpropstrict.description =
instruction.findpropstrict.stackBefore = [ns], [name]
instruction.findpropstrict.stackAfter = obj
instruction.findpropstrict.operands = property

instruction.findproperty.shortDescription = Search property in scope stack, top object when not found
instruction.findproperty.description =
instruction.findproperty.stackBefore = [ns], [name]
instruction.findproperty.stackAfter = obj
instruction.findproperty.operands = property

#Undocumented:
instruction.finddef.shortDescription = Search script level definition
instruction.finddef.description =
instruction.finddef.stackBefore = [ns], [name]
instruction.finddef.stackAfter = obj
instruction.finddef.operands = property

instruction.getlex.shortDescription = Find and get property
instruction.getlex.description =
instruction.getlex.stackBefore =
instruction.getlex.stackAfter = obj
instruction.getlex.operands = property

instruction.setproperty.shortDescription = Set property
instruction.setproperty.description =
instruction.setproperty.stackBefore = obj, [ns], [name], value
instruction.setproperty.stackAfter =
instruction.setproperty.operands = property

instruction.getlocal.shortDescription = Get local register value
instruction.getlocal.description =
instruction.getlocal.stackBefore =
instruction.getlocal.stackAfter = value
instruction.getlocal.operands = localRegIndex

instruction.setlocal.shortDescription = Set local register value
instruction.setlocal.description =
instruction.setlocal.stackBefore = value
instruction.setlocal.stackAfter =
instruction.setlocal.operands = localRegIndex

instruction.getglobalscope.shortDescription = Get global scope
instruction.getglobalscope.description =
instruction.getglobalscope.stackBefore =
instruction.getglobalscope.stackAfter = obj
instruction.getglobalscope.operands =

instruction.getscopeobject.shortDescription = Get scope object
instruction.getscopeobject.description =
instruction.getscopeobject.stackBefore =
instruction.getscopeobject.stackAfter = obj
instruction.getscopeobject.operands = scopeIndex

instruction.getproperty.shortDescription = Get property
instruction.getproperty.description =
instruction.getproperty.stackBefore = obj, [ns], [name]
instruction.getproperty.stackAfter = value
instruction.getproperty.operands = property

instruction.getouterscope.shortDescription = Get scope object on all levels
instruction.getouterscope.description =
instruction.getouterscope.stackBefore =
instruction.getouterscope.stackAfter = obj
instruction.getouterscope.operands = allLevelScopeIndex

instruction.initproperty.shortDescription = Initialize property
instruction.initproperty.description =
instruction.initproperty.stackBefore = obj, [ns], [name], value
instruction.initproperty.stackAfter =
instruction.initproperty.operands = property

#Undocumented:
instruction.setpropertylate.shortDescription = Set property (stack based)
instruction.setpropertylate.description =
#instruction.setpropertylate.stackBefore =
#instruction.setpropertylate.stackAfter =
#instruction.setpropertylate.operands =

instruction.deleteproperty.shortDescription = Delete property
instruction.deleteproperty.description =
instruction.deleteproperty.stackBefore = obj, [ns], [name]
instruction.deleteproperty.stackAfter = boolResult
instruction.deleteproperty.operands = property

#Undocumented:
instruction.deletepropertylate.shortDescription = Delete property (stack based)
instruction.deletepropertylate.description =
#instruction.deletepropertylate.stackBefore =
#instruction.deletepropertylate.stackAfter =
instruction.deletepropertylate.operands =

instruction.getslot.shortDescription = Get value of a slot
instruction.getslot.description =
instruction.getslot.stackBefore = obj
instruction.getslot.stackAfter = value
instruction.getslot.operands = slotIndex

instruction.setslot.shortDescription = Set value of a slot
instruction.setslot.description =
instruction.setslot.stackBefore = obj, value
instruction.setslot.stackAfter =
instruction.setslot.operands = slotIndex

instruction.getglobalslot.shortDescription = Get value of slot on global scope
instruction.getglobalslot.description =
instruction.getglobalslot.stackBefore =
instruction.getglobalslot.stackAfter = value
instruction.getglobalslot.operands = slotIndex

instruction.setglobalslot.shortDescription = Set value of slot on global scope
instruction.setglobalslot.description =
instruction.setglobalslot.stackBefore = value
instruction.setglobalslot.stackAfter =
instruction.setglobalslot.operands = slotIndex

instruction.convert_s.shortDescription = Convert value to string
instruction.convert_s.description =
instruction.convert_s.stackBefore = value
instruction.convert_s.stackAfter = stringValue
instruction.convert_s.operands =

instruction.esc_xelem.shortDescription = Escape XML element
instruction.esc_xelem.description =
instruction.esc_xelem.stackBefore = value
instruction.esc_xelem.stackAfter = stringValue
instruction.esc_xelem.operands =

instruction.esc_xattr.shortDescription = Escape XML attribute
instruction.esc_xattr.description =
instruction.esc_xattr.stackBefore = value
instruction.esc_xattr.stackAfter = stringValue
instruction.esc_xattr.operands =

instruction.convert_i.shortDescription = Convert value to integer
instruction.convert_i.description =
instruction.convert_i.stackBefore = value
instruction.convert_i.stackAfter = intValue
instruction.convert_i.operands =

instruction.convert_u.shortDescription = Convert value to unsigned integer
instruction.convert_u.description =
instruction.convert_u.stackBefore = value
instruction.convert_u.stackAfter = uintValue
instruction.convert_u.operands =

instruction.convert_d.shortDescription = Convert value to double
instruction.convert_d.description =
instruction.convert_d.stackBefore = value
instruction.convert_d.stackAfter = doubleValue
instruction.convert_d.operands =

instruction.convert_b.shortDescription = Convert value to boolean
instruction.convert_b.description =
instruction.convert_b.stackBefore = value
instruction.convert_b.stackAfter = booleanValue
instruction.convert_b.operands =

instruction.convert_o.shortDescription = Convert value to Object
instruction.convert_o.description =
instruction.convert_o.stackBefore = value
instruction.convert_o.stackAfter = value
instruction.convert_o.operands =

instruction.checkfilter.shortDescription = Check that object can have filter operation applied
instruction.checkfilter.description =
instruction.checkfilter.stackBefore = value
instruction.checkfilter.stackAfter = value
instruction.checkfilter.operands =

instruction.convert_m.shortDescription = Convert value to decimal
instruction.convert_m.description =
instruction.convert_m.stackBefore = value
instruction.convert_m.stackAfter = decimalValue
instruction.convert_m.operands =

instruction.convert_m_p.shortDescription = Convert value to decimal with number context
instruction.convert_m_p.description =
instruction.convert_m_p.stackBefore = value
instruction.convert_m_p.stackAfter = decimalValue
instruction.convert_m_p.operands = numberContext

instruction.convert_f.shortDescription = Convert value to float
instruction.convert_f.description =
instruction.convert_f.stackBefore = value
instruction.convert_f.stackAfter = floatValue
instruction.convert_f.operands =

instruction.convert_f4.shortDescription = Convert value to float4
instruction.convert_f4.description =
instruction.convert_f4.stackBefore = value
instruction.convert_f4.stackAfter = float4Value
instruction.convert_f4.operands =

instruction.coerce.shortDescription = Coerce value to specified type
instruction.coerce.description =
instruction.coerce.stackBefore = value
instruction.coerce.stackAfter = coercedValue
instruction.coerce.operands = type

instruction.coerce_b.shortDescription = Coerce value to boolean
instruction.coerce_b.description =
instruction.coerce_b.stackBefore = value
instruction.coerce_b.stackAfter = booleanValue
instruction.coerce_b.operands =
instruction.coerce_b.deprecated = Use convert_b instead

instruction.coerce_a.shortDescription = Coerce value to any type
instruction.coerce_a.description =
instruction.coerce_a.stackBefore = value
instruction.coerce_a.stackAfter = value
instruction.coerce_a.operands =

instruction.coerce_i.shortDescription = Coerce value to integer
instruction.coerce_i.description =
instruction.coerce_i.stackBefore = value
instruction.coerce_i.stackAfter = intValue
instruction.coerce_i.operands =
instruction.coerce_i.deprecated = Use convert_i instead

instruction.coerce_d.shortDescription = Coerce value to double
instruction.coerce_d.description =
instruction.coerce_d.stackBefore = value
instruction.coerce_d.stackAfter = doubleValue
instruction.coerce_d.operands =
instruction.coerce_d.deprecated = Use convert_d instead

instruction.coerce_s.shortDescription = Coerce value to string
instruction.coerce_s.description =
instruction.coerce_s.stackBefore = value
instruction.coerce_s.stackAfter = stringValue
instruction.coerce_s.operands =

instruction.astype.shortDescription = Return same value or null if not specified type
instruction.astype.description =
instruction.astype.stackBefore = value
instruction.astype.stackAfter = value
instruction.astype.operands = type

instruction.astypelate.shortDescription = Return same value or null if not specified type (stack based)
instruction.astypelate.description =
instruction.astypelate.stackBefore = value, type
instruction.astypelate.stackAfter = value
instruction.astypelate.operands =

instruction.coerce_u.shortDescription = Coerce value to unsigned integer
instruction.coerce_u.description =
instruction.coerce_u.stackBefore = value
instruction.coerce_u.stackAfter = uintValue
instruction.coerce_u.operands =

instruction.coerce_o.shortDescription = Coerce value to Object
instruction.coerce_o.description =
instruction.coerce_o.stackBefore = value
instruction.coerce_o.stackAfter = value
instruction.coerce_o.operands =

instruction.negate_p.shortDescription = Negate value using number context
instruction.negate_p.description =
instruction.negate_p.stackBefore = value
instruction.negate_p.stackAfter = -value
instruction.negate_p.operands = operand1

instruction.negate.shortDescription = Negate value
instruction.negate.description =
instruction.negate.stackBefore = value
instruction.negate.stackAfter = -value
instruction.negate.operands =

instruction.increment.shortDescription = Increment value
instruction.increment.description =
instruction.increment.stackBefore = value
instruction.increment.stackAfter = incrementedValue
instruction.increment.operands =

instruction.inclocal.shortDescription = Increment local register
instruction.inclocal.description =
instruction.inclocal.stackBefore =
instruction.inclocal.stackAfter =
instruction.inclocal.operands = localRegister

instruction.decrement.shortDescription = Decrement value
instruction.decrement.description =
instruction.decrement.stackBefore = value
instruction.decrement.stackAfter = decrementedValue
instruction.decrement.operands =

instruction.declocal.shortDescription = Decrement local register
instruction.declocal.description =
instruction.declocal.stackBefore =
instruction.declocal.stackAfter =
instruction.declocal.operands = localRegister

instruction.typeof.shortDescription = Get name of value type
instruction.typeof.description =
instruction.typeof.stackBefore = value
instruction.typeof.stackAfter = typeName
instruction.typeof.operands =

instruction.not.shortDescription = Boolean negate
instruction.not.description =
instruction.not.stackBefore = value
instruction.not.stackAfter = !value
instruction.not.operands =

instruction.bitnot.shortDescription = Bitwise negate
instruction.bitnot.description =
instruction.bitnot.stackBefore = value
instruction.bitnot.stackAfter = ~value
instruction.bitnot.operands =

#Undocumented:
instruction.concat.shortDescription = Concat
instruction.concat.description =
#instruction.concat.stackBefore =
#instruction.concat.stackAfter =
#instruction.concat.operands =

#Undocumented:
instruction.add_d.shortDescription = Add_d
instruction.add_d.description =
#instruction.add_d.stackBefore =
#instruction.add_d.stackAfter =
#instruction.add_d.operands =

instruction.increment_p.shortDescription = Increment value using number context
instruction.increment_p.description =
instruction.increment_p.stackBefore = value
instruction.increment_p.stackAfter = incrementedValue
instruction.increment_p.operands = numberContext

instruction.inclocal_p.shortDescription = Increment local register using number context
instruction.inclocal_p.description =
instruction.inclocal_p.stackBefore =
instruction.inclocal_p.stackAfter =
instruction.inclocal_p.operands = numberContext, localRegister

instruction.decrement_p.shortDescription = Decrement value using number context
instruction.decrement_p.description =
instruction.decrement_p.stackBefore = value
instruction.decrement_p.stackAfter = decrementedValue
instruction.decrement_p.operands = numberContext

instruction.declocal_p.shortDescription = Decrement local register using number context
instruction.declocal_p.description =
instruction.declocal_p.stackBefore =
instruction.declocal_p.stackAfter =
instruction.declocal_p.operands = numberContext, localRegister

instruction.add.shortDescription = Add two values
instruction.add.description =
instruction.add.stackBefore = value1, value2
instruction.add.stackAfter = value3
instruction.add.operands =

instruction.subtract.shortDescription = Subtract two values
instruction.subtract.description =
instruction.subtract.stackBefore = value1, value2
instruction.subtract.stackAfter = value3
instruction.subtract.operands =

instruction.multiply.shortDescription = Multiply two values
instruction.multiply.description =
instruction.multiply.stackBefore = value1, value2
instruction.multiply.stackAfter = value3
instruction.multiply.operands =

instruction.divide.shortDescription = Divide two values
instruction.divide.description =
instruction.divide.stackBefore = value1, value2
instruction.divide.stackAfter = value3
instruction.divide.operands =

instruction.modulo.shortDescription = Modulo divide two values
instruction.modulo.description =
instruction.modulo.stackBefore = value1, value2
instruction.modulo.stackAfter = value3
instruction.modulo.operands =

instruction.lshift.shortDescription = Bitwise left shift
instruction.lshift.description =
instruction.lshift.stackBefore = value1, value2
instruction.lshift.stackAfter = value3
instruction.lshift.operands =

instruction.rshift.shortDescription = Bitwise right shift
instruction.rshift.description =
instruction.rshift.stackBefore = value1, value2
instruction.rshift.stackAfter = value3
instruction.rshift.operands =

instruction.urshift.shortDescription = Unsigned bitwise right shift
instruction.urshift.description =
instruction.urshift.stackBefore = value1, value2
instruction.urshift.stackAfter = value3
instruction.urshift.operands =

instruction.bitand.shortDescription = Bitwise and
instruction.bitand.description =
instruction.bitand.stackBefore = value1, value2
instruction.bitand.stackAfter = value3
instruction.bitand.operands =

instruction.bitor.shortDescription = Bitwise or
instruction.bitor.description =
instruction.bitor.stackBefore = value1, value2
instruction.bitor.stackAfter = value3
instruction.bitor.operands =

instruction.bitxor.shortDescription = Bitwise xor
instruction.bitxor.description =
instruction.bitxor.stackBefore = value1, value2
instruction.bitxor.stackAfter = value3
instruction.bitxor.operands =

instruction.equals.shortDescription = Compare two values
instruction.equals.description =
instruction.equals.stackBefore = value1, value2
instruction.equals.stackAfter = booleanResult
instruction.equals.operands =

instruction.strictequals.shortDescription = Strict compare two values
instruction.strictequals.description =
instruction.strictequals.stackBefore = value1, value2
instruction.strictequals.stackAfter = booleanResult
instruction.strictequals.operands =

instruction.lessthan.shortDescription = Check that value is less than other value
instruction.lessthan.description =
instruction.lessthan.stackBefore = value1, value2
instruction.lessthan.stackAfter = booleanResult
instruction.lessthan.operands =

instruction.lessequals.shortDescription = Check that value is less or equal than other value
instruction.lessequals.description =
instruction.lessequals.stackBefore = value1, value2
instruction.lessequals.stackAfter = booleanResult
instruction.lessequals.operands = booleanResult

instruction.greaterthan.shortDescription = Check that value is greater or equal than other value
instruction.greaterthan.description =
instruction.greaterthan.stackBefore = value1, value2
instruction.greaterthan.stackAfter = booleanResult
instruction.greaterthan.operands =

instruction.greaterequals.shortDescription = Check that value is greater or equal than other value
instruction.greaterequals.description =
instruction.greaterequals.stackBefore = value1, value2
instruction.greaterequals.stackAfter = booleanResult
instruction.greaterequals.operands =

instruction.instanceof.shortDescription = Check that type exists in object prototype chain
instruction.instanceof.description =
instruction.instanceof.stackBefore = value, type
instruction.instanceof.stackAfter = booleanResult
instruction.instanceof.operands =

instruction.istype.shortDescription = Check that object is of specified type
instruction.istype.description =
instruction.istype.stackBefore = value
instruction.istype.stackAfter = booleanResult
instruction.istype.operands = type

instruction.istypelate.shortDescription = Check that object is of specified type (stack based)
instruction.istypelate.description =
instruction.istypelate.stackBefore = value, type
instruction.istypelate.stackAfter = booleanResult
instruction.istypelate.operands =

instruction.in.shortDescription = Check that object has named property
instruction.in.description =
instruction.in.stackBefore = name, obj
instruction.in.stackAfter = booleanResult
instruction.in.operands =

instruction.add_p.shortDescription = Add two values using number context
instruction.add_p.description =
instruction.add_p.stackBefore = value1, value2
instruction.add_p.stackAfter = value3
instruction.add_p.operands = numberContext

instruction.subtract_p.shortDescription = Subtract two values using number context
instruction.subtract_p.description =
instruction.subtract_p.stackBefore = value1, value2
instruction.subtract_p.stackAfter = value3
instruction.subtract_p.operands = numberContext

instruction.multiply_p.shortDescription = Multiply two values using number context
instruction.multiply_p.description =
instruction.multiply_p.stackBefore = value1, value2
instruction.multiply_p.stackAfter = value3
instruction.multiply_p.operands = numberContext

instruction.divide_p.shortDescription = Divide two values using number context
instruction.divide_p.description =
instruction.divide_p.stackBefore = value1, value2
instruction.divide_p.stackAfter = value3
instruction.divide_p.operands = numberContext

instruction.modulo_p.shortDescription = Modulo divide two values using number context
instruction.modulo_p.description =
instruction.modulo_p.stackBefore = value1, value2
instruction.modulo_p.stackAfter = value3
instruction.modulo_p.operands = numberContext

instruction.increment_i.shortDescription = Increment integer value
instruction.increment_i.description =
instruction.increment_i.stackBefore = value
instruction.increment_i.stackAfter = incrementedValue
instruction.increment_i.operands =

instruction.decrement_i.shortDescription = Decrement integer value
instruction.decrement_i.description =
instruction.decrement_i.stackBefore = value
instruction.decrement_i.stackAfter = decrementedValue
instruction.decrement_i.operands =

instruction.inclocal_i.shortDescription = Increment local register integer value
instruction.inclocal_i.description =
instruction.inclocal_i.stackBefore =
instruction.inclocal_i.stackAfter =
instruction.inclocal_i.operands = localRegister

instruction.declocal_i.shortDescription = Decrement local register integer value
instruction.declocal_i.description =
instruction.declocal_i.stackBefore =
instruction.declocal_i.stackAfter =
instruction.declocal_i.operands = localRegister

instruction.negate_i.shortDescription = Negate integer value
instruction.negate_i.description =
instruction.negate_i.stackBefore = value
instruction.negate_i.stackAfter = -value
instruction.negate_i.operands =

instruction.add_i.shortDescription = Add two integer values
instruction.add_i.description =
instruction.add_i.stackBefore = value1, value2
instruction.add_i.stackAfter = value3
instruction.add_i.operands =

instruction.subtract_i.shortDescription = Subtract two integer values
instruction.subtract_i.description =
instruction.subtract_i.stackBefore = value1, value2
instruction.subtract_i.stackAfter = value3
instruction.subtract_i.operands =

instruction.multiply_i.shortDescription = Multiply two integer values
instruction.multiply_i.description =
instruction.multiply_i.stackBefore = value1, value2
instruction.multiply_i.stackAfter = value3
instruction.multiply_i.operands =

instruction.getlocal0.shortDescription = Get local register 0
instruction.getlocal0.description =
instruction.getlocal0.stackBefore =
instruction.getlocal0.stackAfter = value
instruction.getlocal0.operands =

instruction.getlocal1.shortDescription = Get local register 1
instruction.getlocal1.description =
instruction.getlocal1.stackBefore =
instruction.getlocal1.stackAfter = value
instruction.getlocal1.operands =

instruction.getlocal2.shortDescription = Get local register 2
instruction.getlocal2.description =
instruction.getlocal2.stackBefore =
instruction.getlocal2.stackAfter = value
instruction.getlocal2.operands =

instruction.getlocal3.shortDescription = Get local register 3
instruction.getlocal3.description =
instruction.getlocal3.stackBefore =
instruction.getlocal3.stackAfter = value
instruction.getlocal3.operands =

instruction.setlocal0.shortDescription = Set local register 0
instruction.setlocal0.description =
instruction.setlocal0.stackBefore = value
instruction.setlocal0.stackAfter =
instruction.setlocal0.operands =

instruction.setlocal1.shortDescription = Set local register 1
instruction.setlocal1.description =
instruction.setlocal1.stackBefore = value
instruction.setlocal1.stackAfter =
instruction.setlocal1.operands =

instruction.setlocal2.shortDescription = Set local register 2
instruction.setlocal2.description =
instruction.setlocal2.stackBefore = value
instruction.setlocal2.stackAfter =
instruction.setlocal2.operands =

instruction.setlocal3.shortDescription = Set local register 3
instruction.setlocal3.description =
instruction.setlocal3.stackBefore = value
instruction.setlocal3.stackAfter =
instruction.setlocal3.operands =

#Undocumented:
instruction.invalid.shortDescription = Invalid
instruction.invalid.description =
#instruction.invalid.stackBefore =
#instruction.invalid.stackAfter =
#instruction.invalid.operands =

#Undocumented:
instruction.abs_jump.shortDescription = Absolute jump
instruction.abs_jump.description =
#instruction.abs_jump.stackBefore =
#instruction.abs_jump.stackAfter =
#instruction.abs_jump.operands =

instruction.debug.shortDescription = Debugging info
instruction.debug.description =
instruction.debug.stackBefore =
instruction.debug.stackAfter =
instruction.debug.operands = debugType, regName, localRegister, extra

instruction.debugline.shortDescription = Debugging line number info
instruction.debugline.description =
instruction.debugline.stackBefore =
instruction.debugline.stackAfter =
instruction.debugline.operands = lineNumber

instruction.debugfile.shortDescription = Debugging file info
instruction.debugfile.description =
instruction.debugfile.stackBefore =
instruction.debugfile.stackAfter =
instruction.debugfile.operands = fileName

instruction.bkptline.shortDescription = Breakpoint on line
instruction.bkptline.description =
instruction.bkptline.stackBefore =
instruction.bkptline.stackAfter =
instruction.bkptline.operands = lineNumber

#Undocumented:
instruction.timestamp.shortDescription = Timestamp
instruction.timestamp.description =
instruction.timestamp.stackBefore =
instruction.timestamp.stackAfter =
instruction.timestamp.operands =

#Undocumented:
instruction.verifypass.shortDescription = Verify pass
instruction.verifypass.description =
#instruction.verifypass.stackBefore =
#instruction.verifypass.stackAfter =
#instruction.verifypass.operands =

#Undocumented:
instruction.alloc.shortDescription = Alloc
instruction.alloc.description =
#instruction.alloc.stackBefore =
#instruction.alloc.stackAfter =
#instruction.alloc.operands =

#Undocumented:
instruction.mark.shortDescription = Mark
instruction.mark.description =
#instruction.mark.stackBefore =
#instruction.mark.stackAfter =
#instruction.mark.operands =

#Undocumented:
instruction.wb.shortDescription = Wb
instruction.wb.description =
#instruction.wb.stackBefore =
#instruction.wb.stackAfter =
#instruction.wb.operands =

#Undocumented:
instruction.prologue.shortDescription = Prologue
instruction.prologue.description =
#instruction.prologue.stackBefore =
#instruction.prologue.stackAfter =
#instruction.prologue.operands =

#Undocumented:
instruction.sendenter.shortDescription = Send enter
instruction.sendenter.description =
#instruction.sendenter.stackBefore =
#instruction.sendenter.stackAfter =
#instruction.sendenter.operands =

#Undocumented:
instruction.doubletoatom.shortDescription = Double to atom
instruction.doubletoatom.description =
#instruction.doubletoatom.stackBefore =
#instruction.doubletoatom.stackAfter =
#instruction.doubletoatom.operands =

#Undocumented:
instruction.sweep.shortDescription = Sweep
instruction.sweep.description =
#instruction.sweep.stackBefore =
#instruction.sweep.stackAfter =
#instruction.sweep.operands =

#Undocumented:
instruction.codegenop.shortDescription = CodeGenOp
instruction.codegenop.description =
#instruction.codegenop.stackBefore =
#instruction.codegenop.stackAfter =
#instruction.codegenop.operands =

#Undocumented:
instruction.verifyop.shortDescription = VerifyOp
instruction.verifyop.description =
#instruction.verifyop.stackBefore =
#instruction.verifyop.stackAfter =
#instruction.verifyop.operands =

#Undocumented:
instruction.decode.shortDescription = Decode
instruction.decode.description =
#instruction.decode.stackBefore =
#instruction.decode.stackAfter =
#instruction.decode.operands =


instruction.unplus.shortDescription = Unary plus - coerce to numeric
instruction.unplus.description =
instruction.unplus.stackBefore = value
instruction.unplus.stackAfter = value
instruction.unplus.operands =

instruction.pushconstant.shortDescription = Push constant value on stack
instruction.pushconstant.description =
#instruction.pushconstant.stackBefore =
#instruction.pushconstant.stackAfter = 
instruction.pushconstant.operands = value