# 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=Lista de instru\u00e7\u00f5es AVM2.
ui.list.pageTitle=Lista de instru\u00e7\u00f5es AVM2.
ui.list.documentTitle=Lista de instru\u00e7\u00f5es AVM2.
ui.list.pageDescription=Lista de todos os Actionscript 3 conhecidos - Instru\u00e7\u00f5es AVM2 com seus operandos e valores de pilhas
#various strings in UI:
ui.unknown=???
ui.stack=Pilha: 
ui.stack.before=..., 
ui.stack.before.empty=...
ui.stack.to=\u279e 
ui.flags=Flags: 
ui.description=Descri\u00e7\u00e3o: 
ui.filter.hide=Hide: 
ui.filter.byname=Localizar por nome: 
ui.filter.order=Organizar por: 
ui.filter.order.code=c\u00f3digo
ui.filter.order.name=nome
#----------------------- Flags of the instructions
instructionFlag.undocumented=Indocumentada
instructionFlag.unknownStack=Pilha desconhecida
instructionFlag.es4NumericsMinor=Num\u00e9ricos ES4 (ABC Menor 17)
instructionFlag.floatMajor=Valores de flutuantes (ABC Maior 47)
instructionFlag.unknownOperands=Operandos desconhecidos
instructionFlag.noFlashPlayer=N\u00e3o no Flash Player padr\u00e3o
instructionFlag.deprecated=Descontinuado
instructionFlag.domainMemory=Opera\u00e7\u00e3o de dom\u00ednio de mem\u00f3ria
#----------------------- Operand types
operandType.multinameIndex=\u00cdndice multiname.
operandType.multinameIndex.description=\u00cdndice em piscina constante multiname
operandType.multinameIndex.name=multinameIndex
operandType.multinameIndex.uiName=multiname
operandType.argCount=N\u00famero de argumentos
operandType.argCount.description=N\u00famero de argumentos seguintes
operandType.argCount.name=argCount
operandType.argCount.uiName=uint
operandType.methodIndex=\u00cdndice de m\u00e9todo
operandType.methodIndex.description=\u00cdndice de m\u00e9todo no ABC
operandType.methodIndex.name=methodIndex
operandType.methodIndex.uiName=methodIndex
operandType.stringIndex=\u00cdndice de string
operandType.stringIndex.description=\u00cdndice em valores de string piscina constante
operandType.stringIndex.name=stringIndex
operandType.stringIndex.uiName=string
operandType.debugType=Tipo de depura\u00e7\u00e3o
operandType.debugType.description=Tipo de informa\u00e7\u00e3o de depura\u00e7\u00e3o. Atualmente, apenas valor de 1 \u00e9 usado.
operandType.debugType.name=debugType
operandType.debugType.uiName=debugType
operandType.registerIndex=\u00cdndice de registro
operandType.registerIndex.description=\u00cdndice de um registro local (0-255)
operandType.registerIndex.name=registerIndex
operandType.registerIndex.uiName=uint
operandType.linenum=N\u00famero da linha
operandType.linenum.description=N\u00famero de linha de arquivo
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=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
instruction.pushdnan.shortDescription=Push decimal NaN value on the stack
instruction.pushdnan.description=
instruction.pushdnan.stackBefore=
instruction.pushdnan.stackAfter=decimalNaN
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=multinameIndex
#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 from local scope stack
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=numberContext
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
