# 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=Llista d'instruccions AVM2
ui.list.pageTitle=Llista d'instruccions AVM2
ui.list.documentTitle=Llista d'instruccions AVM2
ui.list.pageDescription=Llista de totes les instruccions ActionScript 3 - AVM2 conegudes amb els seus operands i valors de pila
#various strings in UI:
ui.unknown=???
ui.stack=Pila: 
ui.stack.before=..., 
ui.stack.before.empty=...
ui.stack.to=\ \u279e 
ui.flags=Banderes: 
ui.description=Descripci\u00f3: 
ui.filter.hide=Amaga: 
ui.filter.byname=Busca per nom: 
ui.filter.order=Ordena per: 
ui.filter.order.code=codi
ui.filter.order.name=nom
#----------------------- Flags of the instructions
instructionFlag.undocumented=Indocumentada
instructionFlag.unknownStack=Pila desconeguda
instructionFlag.es4NumericsMinor=Num\u00e8rica ES4 (ABC minor 17)
instructionFlag.floatMajor=Valors de coma flotant (ABC major 47)
instructionFlag.unknownOperands=Operands desconeguts
instructionFlag.noFlashPlayer=No en Flash Player est\u00e0ndard
instructionFlag.deprecated=Obsoleta
instructionFlag.domainMemory=Operaci\u00f3 de mem\u00f2ria de domini
#----------------------- Operand types
operandType.multinameIndex=\u00cdndex multinom
operandType.multinameIndex.description=\u00cdndex en pool de constants multinom
operandType.multinameIndex.name=multinameIndex
operandType.multinameIndex.uiName=multiname
operandType.argCount=Nombre d'arguments
operandType.argCount.description=N\u00famero dels seg\u00fents arguments
operandType.argCount.name=argCount
operandType.argCount.uiName=uint
operandType.methodIndex=\u00cdndex del m\u00e8tode
operandType.methodIndex.description=\u00cdndex del m\u00e8tode a l'ABC
operandType.methodIndex.name=methodIndex
operandType.methodIndex.uiName=methodIndex
operandType.stringIndex=\u00cdndex de la cadena
operandType.stringIndex.description=\u00cdndex en pool de constants de valor cadena
operandType.stringIndex.name=stringIndex
operandType.stringIndex.uiName=string
operandType.debugType=Tipus de depuraci\u00f3
operandType.debugType.description=Tipus de la informacio de depuraci\u00f3. Actualment, nom\u00e9s s'utilitza el valor de 1.
operandType.debugType.name=debugType
operandType.debugType.uiName=debugType
operandType.registerIndex=\u00cdndex de registre
operandType.registerIndex.description=\u00cdndex d'un registre local (0-255)
operandType.registerIndex.name=registerIndex
operandType.registerIndex.uiName=uint
operandType.linenum=N\u00famero de l\u00ednia
operandType.linenum.description=N\u00famero de l\u00ednia del fitxer
operandType.linenum.name=linenum
operandType.linenum.uiName=linenum
#similar as registerIndex, but U30 instead of U8
operandType.localRegIndex=\u00cdndex del registrr
operandType.localRegIndex.description=\u00cdndex d'un registre local
operandType.localRegIndex.name=localRegIndex
operandType.localRegIndex.uiName=uint
operandType.slotIndex=\u00cdndex de slot
operandType.slotIndex.description=\u00cdndex del slot sobre un objecte
operandType.slotIndex.name=slotIndex
operandType.slotIndex.uiName=slotIndex
operandType.scopeIndex=\u00cdndex de pila d'abast
operandType.scopeIndex.description=\u00cdndex en la pila d'abast
operandType.scopeIndex.name=scopeIndex
operandType.scopeIndex.uiName=scopeIndex
operandType.offset=Despla\u00e7ament
operandType.offset.description=Despla\u00e7ament a una altra ubicaci\u00f3
operandType.offset.name=offset
operandType.offset.uiName=labelName
operandType.exceptionIndex=\u00cdndex d'excepci\u00f3
operandType.exceptionIndex.description=\u00cdndex de l'excepci\u00f3 en la informaci\u00f3 del m\u00e8tode actual
operandType.exceptionIndex.name=exceptionIndex
operandType.exceptionIndex.uiName=exceptionIndex
operandType.classIndex=\u00cdndex de classe
operandType.classIndex.description=\u00cdndex de la classe a l'ABC
operandType.classIndex.name=classIndex
operandType.classIndex.uiName=classIndex
operandType.intIndex=\u00cdndex d'enter
operandType.intIndex.description=\u00cdndex en pool de constants de valors enters
operandType.intIndex.name=intIndex
operandType.intIndex.uiName=int
operandType.uintIndex=\u00cdndex d'enter sense signe
operandType.uintIndex.description=\u00cdndex en pool de constants de valors enters sense signe
operandType.uintIndex.name=uintIndex
operandType.uintIndex.uiName=uint
operandType.doubleIndex=\u00cdndex de doble precisi\u00f3
operandType.doubleIndex.description=\u00cdndex en pool de constants de valors de coma flotant de doble precisi\u00f3
operandType.doubleIndex.name=doubleIndex
operandType.doubleIndex.uiName=double
operandType.decimalIndex=\u00cdndex decimal
operandType.decimalIndex.description=\u00cdndex en pool de constants de valors decimals (coma flotant de 128 bits)
operandType.decimalIndex.name=decimalIndex
operandType.decimalIndex.uiName=decimal
operandType.caseBaseoffset=Despla\u00e7ament base
operandType.caseBaseoffset.description=Despla\u00e7ament base del lookupswitch que es dispara quan no hi ha cap valor coincident
operandType.caseBaseoffset.name=offset
operandType.caseBaseoffset.uiName=labelName
operandType.numberContext=Context de n\u00famero (ES4)
operandType.numberContext.description=Context dels c\u00e0lcukls quan s'utilitzen n\u00fameros EcmaScript 4 (versi\u00f3 menor ABC 17).\n0-2 tipus,3-5 tipus d'arrodoniment, 6-12 precisi\u00f3.\nTipus: 0=n\u00famero,1=decimal,2=doble,3=enter,4=enter sense signe\nArrodoniment: 0=sostre,1=cap amunt,2=mig cap amunt,3i=mig_justificat,4=mig cap avall,5=cap avall,6=terra\nPrecisi\u00f3:0-34
operandType.numberContext.name=numberContext
operandType.numberContext.uiName=uint
operandType.dispatchId=Id de despatx
operandType.dispatchId.description=Id del despatx de m\u00e8tode
operandType.dispatchId.name=dispatchId
operandType.dispatchId.uiName=uint
operandType.floatIndex=\u00cdndex de punt flotant
operandType.floatIndex.description=\u00cdndex en pool de constants de valors de punt flotant
operandType.floatIndex.name=floatIndex
operandType.floatIndex.uiName=float
operandType.float4Index=\u00cdndex de punt flotant
operandType.float4Index.description=\u00cdndex en pool de constants de valors  float4
operandType.float4Index.name=float4Index
operandType.float4Index.uiName=float4
operandType.namespaceIndex=\u00cdndex en pool de constants d'espai de noms
operandType.namespaceIndex.name=namespaceIndex
operandType.namespaceIndex.uiName=namespace
#----------------------- Instructions
instruction.bkpt.shortDescription=Punt de ruptura
instruction.bkpt.description=Punt de ruptura en depuraci\u00f3
instruction.bkpt.stackBefore=
instruction.bkpt.stackAfter=
instruction.bkpt.operands=
instruction.nop.shortDescription=Cap operaci\u00f3
instruction.nop.description=No fa res
instruction.nop.stackBefore=
instruction.nop.stackAfter=
instruction.nop.operands=
instruction.throw.shortDescription=Llan\u00e7a excepci\u00f3
instruction.throw.description=Treu el valor de la pila i el llan\u00e7a
instruction.throw.stackBefore=valor
instruction.throw.stackAfter=
instruction.throw.operands=
instruction.getsuper.shortDescription=Obt\u00e9 la propietat de la classe mare
instruction.getsuper.description=
instruction.getsuper.stackBefore=obj, [ns], [name]
instruction.getsuper.stackAfter=value
instruction.getsuper.operands=parentClassMultiname
instruction.setsuper.shortDescription=Estableix la propietat de la classe mare
instruction.setsuper.description=
instruction.setsuper.stackBefore=obj, [ns], [name], value
instruction.setsuper.stackAfter=
instruction.setsuper.operands=parentClassMultiname
instruction.dxns.shortDescription=Estableix l'espai de noms XML per defecte
instruction.dxns.description=
instruction.dxns.stackBefore=
instruction.dxns.stackAfter=
instruction.dxns.operands=uriString
instruction.dxnslate.shortDescription=Estableix l'espai de noms XML per defect en temps d'execuci\u00f3
instruction.dxnslate.description=
instruction.dxnslate.stackBefore=uriValue
instruction.dxnslate.stackAfter=
instruction.dxnslate.operands=
instruction.kill.shortDescription=Mata el registre local
instruction.kill.description=
instruction.kill.stackBefore=
instruction.kill.stackAfter=
instruction.kill.operands=killedRegister
instruction.label.shortDescription=Objectiu d'una branca
instruction.label.description=Nom\u00e9s una marca que diu que aix\u00f2 \u00e9s l'objectiu de la branca seg\u00fent
instruction.label.stackBefore=
instruction.label.stackAfter=
instruction.label.operands=
instruction.lf32x4.shortDescription=Carrega un float4 de 32 bits
instruction.lf32x4.description=
instruction.lf32x4.stackBefore=address
instruction.lf32x4.stackAfter=float4Value
instruction.lf32x4.operands=
instruction.sf32x4.shortDescription=Emmagatzema un float4 de 32 bits
instruction.sf32x4.description=
instruction.sf32x4.stackBefore=float4Value, address
instruction.sf32x4.stackAfter=
instruction.sf32x4.operands=
instruction.ifnlt.shortDescription=Bifurca si no \u00e9s menor que
instruction.ifnlt.description=
instruction.ifnlt.stackBefore=value1, value2
instruction.ifnlt.stackAfter=
instruction.ifnlt.operands=branchTarget
instruction.ifnle.shortDescription=Bifurca si no \u00e9s menor o igual
instruction.ifnle.description=
instruction.ifnle.stackBefore=value1, value2
instruction.ifnle.stackAfter=
instruction.ifnle.operands=branchTarget
instruction.ifngt.shortDescription=Bifurca si no \u00e9s major que
instruction.ifngt.description=
instruction.ifngt.stackBefore=value1, value2
instruction.ifngt.stackAfter=
instruction.ifngt.operands=branchTarget
instruction.ifnge.shortDescription=Bifurca si no \u00e9s major o igual
instruction.ifnge.description=
instruction.ifnge.stackBefore=value1, value2
instruction.ifnge.stackAfter=
instruction.ifnge.operands=branchTarget
instruction.jump.shortDescription=Salta a la ubicaci\u00f3
instruction.jump.description=
instruction.jump.stackBefore=
instruction.jump.stackAfter=
instruction.jump.operands=location
instruction.iftrue.shortDescription=Bifurca si \u00e9s cert
instruction.iftrue.description=
instruction.iftrue.stackBefore=value
instruction.iftrue.stackAfter=
instruction.iftrue.operands=branchTarget
instruction.iffalse.shortDescription=Bifurca si \u00e9s fals
instruction.iffalse.description=
instruction.iffalse.stackBefore=value
instruction.iffalse.stackAfter=
instruction.iffalse.operands=branchTarget
instruction.ifeq.shortDescription=Bifurca si \u00e9s igual
instruction.ifeq.description=
instruction.ifeq.stackBefore=value1, value2
instruction.ifeq.stackAfter=
instruction.ifeq.operands=branchTarget
instruction.ifne.shortDescription=Bifurca si no \u00e9s igual
instruction.ifne.description=
instruction.ifne.stackBefore=value1, value2
instruction.ifne.stackAfter=
instruction.ifne.operands=branchTarget
instruction.iflt.shortDescription=Bifurca si \u00e9s menor que
instruction.iflt.description=
instruction.iflt.stackBefore=value1, value2
instruction.iflt.stackAfter=
instruction.iflt.operands=branchTarget
instruction.ifle.shortDescription=Bifurca si \u00e9s menor o igual
instruction.ifle.description=
instruction.ifle.stackBefore=value1, value2
instruction.ifle.stackAfter=
instruction.ifle.operands=branchTarget
instruction.ifgt.shortDescription=Bifurca si es major que
instruction.ifgt.description=
instruction.ifgt.stackBefore=value1, value2
instruction.ifgt.stackAfter=
instruction.ifgt.operands=branchTarget
instruction.ifge.shortDescription=Bifurca si es major o igual
instruction.ifge.description=
instruction.ifge.stackBefore=value1, value2
instruction.ifge.stackAfter=
instruction.ifge.operands=branchTarget
instruction.ifstricteq.shortDescription=Bifurca si \u00e9s estrictament igual
instruction.ifstricteq.description=
instruction.ifstricteq.stackBefore=value1, value2
instruction.ifstricteq.stackAfter=
instruction.ifstricteq.operands=branchTarget
instruction.ifstrictne.shortDescription=Bifurca si no \u00e9s estrictament igual
instruction.ifstrictne.description=
instruction.ifstrictne.stackBefore=value1, value2
instruction.ifstrictne.stackAfter=
instruction.ifstrictne.operands=branchTarget
instruction.lookupswitch.shortDescription=Bifurca basant-se en l'\u00edndex
instruction.lookupswitch.description=
instruction.lookupswitch.stackBefore=index
instruction.lookupswitch.stackAfter=
instruction.lookupswitch.operands=defaultTarget, caseCount, case0Target, case1Target, ...
instruction.pushwith.shortDescription=Posa a la pila d'abast 
instruction.pushwith.description=
instruction.pushwith.stackBefore=withScope
instruction.pushwith.stackAfter=
instruction.pushwith.operands=
instruction.popscope.shortDescription=Treu de la pila d'abast i descarta el valor
instruction.popscope.description=
instruction.popscope.stackBefore=
instruction.popscope.stackAfter=
instruction.popscope.operands=
instruction.nextname.shortDescription=Obt\u00e9 el nom de la propietat seg\u00fent
instruction.nextname.description=
instruction.nextname.stackBefore=obj, index
instruction.nextname.stackAfter=name
instruction.nextname.operands=
instruction.hasnext.shortDescription=Comprova si l'objecte t\u00e9 m\u00e9s propietats
instruction.hasnext.description=
instruction.hasnext.stackBefore=obj, currentIndex
instruction.hasnext.stackAfter=nextIndex
instruction.hasnext.operands=
instruction.pushnull.shortDescription=Posa un valor nul a la pila
instruction.pushnull.description=
instruction.pushnull.stackBefore=
instruction.pushnull.stackAfter=null
instruction.pushnull.operands=
instruction.pushundefined.shortDescription=Posa un valor indefinit a la pila
instruction.pushundefined.description=
instruction.pushundefined.stackBefore=
instruction.pushundefined.stackAfter=undefined
instruction.pushundefined.operands=
instruction.pushfloat.shortDescription=Posa un valor de coma flotant a la pila
instruction.pushfloat.description=
instruction.pushfloat.stackBefore=
instruction.pushfloat.stackAfter=floatValue
instruction.pushfloat.operands=float
instruction.nextvalue.shortDescription=Obt\u00e9 el valor de la propietat seg\u00fent
instruction.nextvalue.description=
instruction.nextvalue.stackBefore=obj, index
instruction.nextvalue.stackAfter=value
instruction.nextvalue.operands=
instruction.pushbyte.shortDescription=Posa un valor de byte a la pila
instruction.pushbyte.description=
instruction.pushbyte.stackBefore=
instruction.pushbyte.stackAfter=byteValue
instruction.pushbyte.operands=value
instruction.pushshort.shortDescription=Posa un valor d'enter curt a la pila
instruction.pushshort.description=
instruction.pushshort.stackBefore=
instruction.pushshort.stackAfter=shortValue
instruction.pushshort.operands=value
instruction.pushtrue.shortDescription=Posa un valor de cert a la pila
instruction.pushtrue.description=
instruction.pushtrue.stackBefore=
instruction.pushtrue.stackAfter=true
instruction.pushtrue.operands=
instruction.pushfalse.shortDescription=Posa un valor de fals a la pila
instruction.pushfalse.description=
instruction.pushfalse.stackBefore=
instruction.pushfalse.stackAfter=false
instruction.pushfalse.operands=
instruction.pushnan.shortDescription=Posa un valor NaN a la pila
instruction.pushnan.description=
instruction.pushnan.stackBefore=
instruction.pushnan.stackAfter=NaN
instruction.pushnan.operands=
instruction.pop.shortDescription=Treu el valor de dalt de la pila
instruction.pop.description=
instruction.pop.stackBefore=value
instruction.pop.stackAfter=
instruction.pop.operands=
instruction.dup.shortDescription=Duplica un valor a la pila
instruction.dup.description=
instruction.dup.stackBefore=value
instruction.dup.stackAfter=value, value
instruction.dup.operands=
instruction.swap.shortDescription=Intercanvia els dos valors de dalt de la pila
instruction.swap.description=
instruction.swap.stackBefore=value1, value2
instruction.swap.stackAfter=value2, value1
instruction.swap.operands=
instruction.pushstring.shortDescription=Posa un valor de cadena a la pila
instruction.pushstring.description=
instruction.pushstring.stackBefore=
instruction.pushstring.stackAfter=stringValue
instruction.pushstring.operands=value
instruction.pushint.shortDescription=Posa un valor enter a la pila
instruction.pushint.description=
instruction.pushint.stackBefore=
instruction.pushint.stackAfter=intValue
instruction.pushint.operands=value
instruction.pushuint.shortDescription=Posa un valor enter sense signe a la pila
instruction.pushuint.description=
instruction.pushuint.stackBefore=
instruction.pushuint.stackAfter=uintValue
instruction.pushuint.operands=value
instruction.pushdouble.shortDescription=Posa un valor de doble precisi\u00f3 a la pila
instruction.pushdouble.description=
instruction.pushdouble.stackBefore=
instruction.pushdouble.stackAfter=doubleValue
instruction.pushdouble.operands=value
instruction.pushscope.shortDescription=Posa un object a la pila d'abast
instruction.pushscope.description=
instruction.pushscope.stackBefore=obj
instruction.pushscope.stackAfter=
instruction.pushscope.operands=
instruction.pushnamespace.shortDescription=Posa un espai de noms a la pila
instruction.pushnamespace.description=
instruction.pushnamespace.stackBefore=
instruction.pushnamespace.stackAfter=namespace
instruction.pushnamespace.operands=value
instruction.hasnext2.shortDescription=Comprova si l'objecte t\u00e9 m\u00e9s propietats (basant-se en el registre)
instruction.hasnext2.description=
instruction.hasnext2.stackBefore=
instruction.hasnext2.stackAfter=boolValue
instruction.hasnext2.operands=objectReg, indexReg
instruction.pushdecimal.shortDescription=Posa un valior decimal a la pila
instruction.pushdecimal.description=
instruction.pushdecimal.stackBefore=
instruction.pushdecimal.stackAfter=decimalValue
instruction.pushdecimal.operands=value
instruction.pushdnan.shortDescription=Posa un valor decimal NaN a la pila
instruction.pushdnan.description=
instruction.pushdnan.stackBefore=
instruction.pushdnan.stackAfter=decimalNaN
instruction.pushdnan.operands=
instruction.li8.shortDescription=Carrega un valor enter de 8 bits
instruction.li8.description=
instruction.li8.stackBefore=address
instruction.li8.stackAfter=int8Value
instruction.li8.operands=
instruction.li16.shortDescription=Carrega un valor enter de 16 bits
instruction.li16.description=
instruction.li16.stackBefore=address
instruction.li16.stackAfter=int16Value
instruction.li16.operands=
instruction.li32.shortDescription=Carrega un valor enter de 32 bits
instruction.li32.description=
instruction.li32.stackBefore=address
instruction.li32.stackAfter=int32Value
instruction.li32.operands=
instruction.lf32.shortDescription=Carrega un valor de coma flotant de 32 bits
instruction.lf32.description=
instruction.lf32.stackBefore=address
instruction.lf32.stackAfter=float32Value
instruction.lf32.operands=
instruction.lf64.shortDescription=Carrega un valor de coma flotant de 64 bits
instruction.lf64.description=
instruction.lf64.stackBefore=address
instruction.lf64.stackAfter=float64Value
instruction.lf64.operands=
instruction.si8.shortDescription=Emmagatzema un valor enter de 8 bits
instruction.si8.description=
instruction.si8.stackBefore=value, address
instruction.si8.stackAfter=
instruction.si8.operands=
instruction.si16.shortDescription=Emmagatzema un valor enter de 16 bits
instruction.si16.description=
instruction.si16.stackBefore=value, address
instruction.si16.stackAfter=
instruction.si16.operands=
instruction.si32.shortDescription=Emmagatzema un valor enter de 32 bits
instruction.si32.description=
instruction.si32.stackBefore=value, address
instruction.si32.stackAfter=
instruction.si32.operands=
instruction.sf32.shortDescription=Emmagatzema un valor de coma flotant de 32 bits
instruction.sf32.description=
instruction.sf32.stackBefore=value, address
instruction.sf32.stackAfter=
instruction.sf32.operands=
instruction.sf64.shortDescription=Emmagatzema un valor de coma flotant de 64 bits
instruction.sf64.description=
instruction.sf64.stackBefore=value, address
instruction.sf64.stackAfter=
instruction.sf64.operands=
instruction.newfunction.shortDescription=Crea un nou objecte Function
instruction.newfunction.description=
instruction.newfunction.stackBefore=
instruction.newfunction.stackAfter=function
instruction.newfunction.operands=method
instruction.call.shortDescription=Crida una funci\u00f3 a la pila
instruction.call.description=
instruction.call.stackBefore=function, this, arg1, ..., argN
instruction.call.stackAfter=value
instruction.call.operands=argCount
instruction.construct.shortDescription=Crida una funci\u00f3 constructora a la pila
instruction.construct.description=
instruction.construct.stackBefore=function, arg1, ..., argN
instruction.construct.stackAfter=value
instruction.construct.operands=argCount
instruction.callmethod.shortDescription=Crida una m\u00e8tode de l'objecte per id de despatx
instruction.callmethod.description=
instruction.callmethod.stackBefore=this, arg1, ..., argN
instruction.callmethod.stackAfter=value
instruction.callmethod.operands=method, argCount
instruction.callstatic.shortDescription=Crida una m\u00e8tode per id de m\u00e8tode al fitxer ABC
instruction.callstatic.description=
instruction.callstatic.stackBefore=this, arg1, ..., argN
instruction.callstatic.stackAfter=value
instruction.callstatic.operands=method, argCount
instruction.callsuper.shortDescription=Crida una m\u00e8tode a la classe mare
instruction.callsuper.description=
instruction.callsuper.stackBefore=obj, [ns], [name], arg1, ..., argN
instruction.callsuper.stackAfter=value
instruction.callsuper.operands=methodName, argCount
instruction.callproperty.shortDescription=Crida una propietat
instruction.callproperty.description=
instruction.callproperty.stackBefore=obj, [ns], [name], arg1, ..., argN
instruction.callproperty.stackAfter=value
instruction.callproperty.operands=property, argCount
instruction.returnvoid.shortDescription=Retorna d'un m\u00e8tode
instruction.returnvoid.description=
instruction.returnvoid.stackBefore=
instruction.returnvoid.stackAfter=
instruction.returnvoid.operands=
instruction.returnvalue.shortDescription=Retorna un valor d'un m\u00e8tode
instruction.returnvalue.description=
instruction.returnvalue.stackBefore=value
instruction.returnvalue.stackAfter=
instruction.returnvalue.operands=
instruction.constructsuper.shortDescription=Crida el constructor pare d'un objecte
instruction.constructsuper.description=
instruction.constructsuper.stackBefore=obj, arg1, ..., argN
instruction.constructsuper.stackAfter=
instruction.constructsuper.operands=argCount
instruction.constructprop.shortDescription=Construeix una propietat d'un objecte
instruction.constructprop.description=
instruction.constructprop.stackBefore=obj, [ns], [name], arg1, ..., argN
instruction.constructprop.stackAfter=value
instruction.constructprop.operands=property, argCount
#Undocumented:
instruction.callsuperid.shortDescription=Crida un s\u00faper id
instruction.callsuperid.description=
#instruction.callsuperid.stackBefore =
#instruction.callsuperid.stackAfter =
#instruction.callsuperid.operands =
instruction.callproplex.shortDescription=Crida una propietat amb nul
instruction.callproplex.description=
instruction.callproplex.stackBefore=obj, [ns], [name], arg1, ..., argN
instruction.callproplex.stackAfter=value
instruction.callproplex.operands=property, argCount
#Undocumented:
instruction.callinterface.shortDescription=Crida una interf\u00edcie
instruction.callinterface.description=
#instruction.callinterface.stackBefore =
#instruction.callinterface.stackAfter =
instruction.callinterface.operands=interface, argCount
instruction.callsupervoid.shortDescription=Crida un m\u00e8tode a la classe mare, descarta el valor de retorn
instruction.callsupervoid.description=
instruction.callsupervoid.stackBefore=obj, [ns], [name], arg1, ..., argN
instruction.callsupervoid.stackAfter=
instruction.callsupervoid.operands=methodName, argCount
instruction.callpropvoid.shortDescription=Crida una propietat, descarta el valor de retorn
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=Applica tipus de par\u00e0metre
instruction.applytype.description=Aplica els tipus de par\u00e0metre al tipus base. Per exemple, quan es resol Vector<String> en temps d'execuci\u00f3. String \u00e9s un par\u00e0metre, Vector \u00e9s la classe base.
instruction.applytype.stackBefore=baseType, typeParam1, ..., typeParamN
instruction.applytype.stackAfter=baseType<typeParam1, ..., typeParamN>
instruction.applytype.operands=typeParamCount
instruction.pushfloat4.shortDescription=Posa un valor float4 a la pila
instruction.pushfloat4.description=
instruction.pushfloat4.stackBefore=
instruction.pushfloat4.stackAfter=float4Value
instruction.pushfloat4.operands=float4
instruction.newobject.shortDescription=Crea un nou objecte
instruction.newobject.description=
instruction.newobject.stackBefore=name1, value1, name2, value2, ..., nameN, valueN
instruction.newobject.stackAfter=newObject
instruction.newobject.operands=propertyCount
instruction.newarray.shortDescription=Crea una nova matriu
instruction.newarray.description=
instruction.newarray.stackBefore=value1, value2, ..., valueN
instruction.newarray.stackAfter=newArray
instruction.newarray.operands=valueCount
instruction.newactivation.shortDescription=Crea un nou objecte d'activaci\u00f3
instruction.newactivation.description=
instruction.newactivation.stackBefore=
instruction.newactivation.stackAfter=newActivation
instruction.newactivation.operands=
instruction.newclass.shortDescription=Crea una nova classe
instruction.newclass.description=
instruction.newclass.stackBefore=baseType
instruction.newclass.stackAfter=newClass
instruction.newclass.operands=class
instruction.getdescendants.shortDescription=Obt\u00e9 els descendents
instruction.getdescendants.description=
instruction.getdescendants.stackBefore=obj, [ns], [name]
instruction.getdescendants.stackAfter=value
instruction.getdescendants.operands=operand1
instruction.newcatch.shortDescription=Crea un nou abast de captura
instruction.newcatch.description=
instruction.newcatch.stackBefore=
instruction.newcatch.stackAfter=catchScope
instruction.newcatch.operands=exception
#Undocumented:
instruction.deldescendants.shortDescription=Suprimeix els descendents
instruction.deldescendants.description=
#instruction.deldescendants.stackBefore =
#instruction.deldescendants.stackAfter =
instruction.deldescendants.operands=multinameIndex
#Undocumented:
instruction.findpropglobal.shortDescription=Busca una propietat a l'abast global
instruction.findpropglobal.description=
instruction.findpropglobal.stackBefore=[ns], [name]
instruction.findpropglobal.stackAfter=obj
instruction.findpropglobal.operands=property
instruction.findpropstrict.shortDescription=Busca una propietat a la pila d'abast, error quan no es troba
instruction.findpropstrict.description=
instruction.findpropstrict.stackBefore=[ns], [name]
instruction.findpropstrict.stackAfter=obj
instruction.findpropstrict.operands=property
instruction.findproperty.shortDescription=Busca una propietat a la pila d'abast, objecte de dalt quan no es troba
instruction.findproperty.description=
instruction.findproperty.stackBefore=[ns], [name]
instruction.findproperty.stackAfter=obj
instruction.findproperty.operands=property
#Undocumented:
instruction.finddef.shortDescription=Busca una definici\u00f3 de nivell de script
instruction.finddef.description=
instruction.finddef.stackBefore=[ns], [name]
instruction.finddef.stackAfter=obj
instruction.finddef.operands=property
instruction.getlex.shortDescription=Busca i obt\u00e9 una propietat
instruction.getlex.description=
instruction.getlex.stackBefore=
instruction.getlex.stackAfter=obj
instruction.getlex.operands=property
instruction.setproperty.shortDescription=Estableix una propietat
instruction.setproperty.description=
instruction.setproperty.stackBefore=obj, [ns], [name], value
instruction.setproperty.stackAfter=
instruction.setproperty.operands=property
instruction.getlocal.shortDescription=Obt\u00e9 un valor del registre local
instruction.getlocal.description=
instruction.getlocal.stackBefore=
instruction.getlocal.stackAfter=value
instruction.getlocal.operands=localRegIndex
instruction.setlocal.shortDescription=Estableix un valor del registre local
instruction.setlocal.description=
instruction.setlocal.stackBefore=value
instruction.setlocal.stackAfter=
instruction.setlocal.operands=localRegIndex
instruction.getglobalscope.shortDescription=Obt\u00e9 l'abast global
instruction.getglobalscope.description=
instruction.getglobalscope.stackBefore=
instruction.getglobalscope.stackAfter=obj
instruction.getglobalscope.operands=
instruction.getscopeobject.shortDescription=Obt\u00e9 un objecte d'abast (local)
instruction.getscopeobject.description=
instruction.getscopeobject.stackBefore=
instruction.getscopeobject.stackAfter=obj
instruction.getscopeobject.operands=scopeIndex
instruction.getproperty.shortDescription=Obt\u00e9 una propietat
instruction.getproperty.description=
instruction.getproperty.stackBefore=obj, [ns], [name]
instruction.getproperty.stackAfter=value
instruction.getproperty.operands=property
instruction.getouterscope.shortDescription=Obt\u00e9 un objecte d'abast (outer)
instruction.getouterscope.description=
instruction.getouterscope.stackBefore=
instruction.getouterscope.stackAfter=obj
instruction.getouterscope.operands=scopeIndex
instruction.initproperty.shortDescription=Inicialitza una propietat
instruction.initproperty.description=
instruction.initproperty.stackBefore=obj, [ns], [name], value
instruction.initproperty.stackAfter=
instruction.initproperty.operands=property
#Undocumented:
instruction.setpropertylate.shortDescription=Estableix una propietat (basant-se en la pila)
instruction.setpropertylate.description=
#instruction.setpropertylate.stackBefore =
#instruction.setpropertylate.stackAfter =
#instruction.setpropertylate.operands =
instruction.deleteproperty.shortDescription=Suprimeix una propietat
instruction.deleteproperty.description=
instruction.deleteproperty.stackBefore=obj, [ns], [name]
instruction.deleteproperty.stackAfter=boolResult
instruction.deleteproperty.operands=property
#Undocumented:
instruction.deletepropertylate.shortDescription=Suprimeix una propietat (basant-se en la pila)
instruction.deletepropertylate.description=
#instruction.deletepropertylate.stackBefore =
#instruction.deletepropertylate.stackAfter =
instruction.deletepropertylate.operands=
instruction.getslot.shortDescription=Obt\u00e9 el valor d'un slot
instruction.getslot.description=
instruction.getslot.stackBefore=obj
instruction.getslot.stackAfter=value
instruction.getslot.operands=slotIndex
instruction.setslot.shortDescription=Estableix el valor d'un slot
instruction.setslot.description=
instruction.setslot.stackBefore=obj, value
instruction.setslot.stackAfter=
instruction.setslot.operands=slotIndex
instruction.getglobalslot.shortDescription=Obt\u00e9 el valor d'un slot en l'abast global
instruction.getglobalslot.description=
instruction.getglobalslot.stackBefore=
instruction.getglobalslot.stackAfter=value
instruction.getglobalslot.operands=slotIndex
instruction.setglobalslot.shortDescription=Estableix el valor d'un slot en l'abast global
instruction.setglobalslot.description=
instruction.setglobalslot.stackBefore=value
instruction.setglobalslot.stackAfter=
instruction.setglobalslot.operands=slotIndex
instruction.convert_s.shortDescription=Converteix un valor a cadena
instruction.convert_s.description=
instruction.convert_s.stackBefore=value
instruction.convert_s.stackAfter=stringValue
instruction.convert_s.operands=
instruction.esc_xelem.shortDescription=Escapa un element XML
instruction.esc_xelem.description=
instruction.esc_xelem.stackBefore=value
instruction.esc_xelem.stackAfter=stringValue
instruction.esc_xelem.operands=
instruction.esc_xattr.shortDescription=Escapa un atribut XML
instruction.esc_xattr.description=
instruction.esc_xattr.stackBefore=value
instruction.esc_xattr.stackAfter=stringValue
instruction.esc_xattr.operands=
instruction.convert_i.shortDescription=Converteix un valor a enter
instruction.convert_i.description=
instruction.convert_i.stackBefore=value
instruction.convert_i.stackAfter=intValue
instruction.convert_i.operands=
instruction.convert_u.shortDescription=Converteix un valor a enter sense signe
instruction.convert_u.description=
instruction.convert_u.stackBefore=value
instruction.convert_u.stackAfter=uintValue
instruction.convert_u.operands=
instruction.convert_d.shortDescription=Converteix un valor a doble
instruction.convert_d.description=
instruction.convert_d.stackBefore=value
instruction.convert_d.stackAfter=doubleValue
instruction.convert_d.operands=
instruction.convert_b.shortDescription=Converteix un valor a boole\u00e0
instruction.convert_b.description=
instruction.convert_b.stackBefore=value
instruction.convert_b.stackAfter=booleanValue
instruction.convert_b.operands=
instruction.convert_o.shortDescription=Converteix un valor a Object
instruction.convert_o.description=
instruction.convert_o.stackBefore=value
instruction.convert_o.stackAfter=value
instruction.convert_o.operands=
instruction.checkfilter.shortDescription=Comprova que un objecte pot tenir aplicada una operaci\u00f3 de filtre
instruction.checkfilter.description=
instruction.checkfilter.stackBefore=value
instruction.checkfilter.stackAfter=value
instruction.checkfilter.operands=
instruction.convert_m.shortDescription=Converteix un valor a decimal
instruction.convert_m.description=
instruction.convert_m.stackBefore=value
instruction.convert_m.stackAfter=decimalValue
instruction.convert_m.operands=
instruction.convert_m_p.shortDescription=Converteix un valor a decimal amb context de n\u00famero
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=Converteix un valor a coma flotant
instruction.convert_f.description=
instruction.convert_f.stackBefore=value
instruction.convert_f.stackAfter=floatValue
instruction.convert_f.operands=
instruction.convert_f4.shortDescription=Converteix un valor a float4
instruction.convert_f4.description=
instruction.convert_f4.stackBefore=value
instruction.convert_f4.stackAfter=float4Value
instruction.convert_f4.operands=
instruction.coerce.shortDescription=For\u00e7a un valor a un tipus especificat
instruction.coerce.description=
instruction.coerce.stackBefore=value
instruction.coerce.stackAfter=coercedValue
instruction.coerce.operands=type
instruction.coerce_b.shortDescription=For\u00e7a un valor a boole\u00e0
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=For\u00e7a un valor a qualsevol tipus
instruction.coerce_a.description=
instruction.coerce_a.stackBefore=value
instruction.coerce_a.stackAfter=value
instruction.coerce_a.operands=
instruction.coerce_i.shortDescription=For\u00e7a un valor a enter
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=For\u00e7a un valor a doble
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=For\u00e7a un valor a cadena
instruction.coerce_s.description=
instruction.coerce_s.stackBefore=value
instruction.coerce_s.stackAfter=stringValue
instruction.coerce_s.operands=
instruction.astype.shortDescription=Retorna el mateix valor o nul si no s'especifica el tipus
instruction.astype.description=
instruction.astype.stackBefore=value
instruction.astype.stackAfter=value
instruction.astype.operands=type
instruction.astypelate.shortDescription=Retorna el mateix valor o nul si no s'especifica el tipus (basant-se en la pila)
instruction.astypelate.description=
instruction.astypelate.stackBefore=value, type
instruction.astypelate.stackAfter=value
instruction.astypelate.operands=
instruction.coerce_u.shortDescription=For\u00e7a un valor a enter sense signe
instruction.coerce_u.description=
instruction.coerce_u.stackBefore=value
instruction.coerce_u.stackAfter=uintValue
instruction.coerce_u.operands=
instruction.coerce_o.shortDescription=For\u00e7a un valor a Object
instruction.coerce_o.description=
instruction.coerce_o.stackBefore=value
instruction.coerce_o.stackAfter=value
instruction.coerce_o.operands=
instruction.negate_p.shortDescription=Nega un valor utilitzant el context de n\u00famero
instruction.negate_p.description=
instruction.negate_p.stackBefore=value
instruction.negate_p.stackAfter=-value
instruction.negate_p.operands=numberContext
instruction.negate.shortDescription=Nega un valor
instruction.negate.description=
instruction.negate.stackBefore=value
instruction.negate.stackAfter=-value
instruction.negate.operands=
instruction.increment.shortDescription=Incrementa un valor
instruction.increment.description=
instruction.increment.stackBefore=value
instruction.increment.stackAfter=incrementedValue
instruction.increment.operands=
instruction.inclocal.shortDescription=Incrementa un registre local
instruction.inclocal.description=
instruction.inclocal.stackBefore=
instruction.inclocal.stackAfter=
instruction.inclocal.operands=localRegister
instruction.decrement.shortDescription=Decrementa un valor
instruction.decrement.description=
instruction.decrement.stackBefore=value
instruction.decrement.stackAfter=decrementedValue
instruction.decrement.operands=
instruction.declocal.shortDescription=Decrementa un registre local
instruction.declocal.description=
instruction.declocal.stackBefore=
instruction.declocal.stackAfter=
instruction.declocal.operands=localRegister
instruction.typeof.shortDescription=Obt\u00e9 el nom d'un tipus de valor
instruction.typeof.description=
instruction.typeof.stackBefore=value
instruction.typeof.stackAfter=typeName
instruction.typeof.operands=
instruction.not.shortDescription=Nega un boole\u00e0
instruction.not.description=
instruction.not.stackBefore=value
instruction.not.stackAfter=!value
instruction.not.operands=
instruction.bitnot.shortDescription=Nega bit a bit
instruction.bitnot.description=
instruction.bitnot.stackBefore=value
instruction.bitnot.stackAfter=~value
instruction.bitnot.operands=
#Undocumented:
instruction.concat.shortDescription=Concatena
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=Incrementa un valor utilitzant el context de n\u00famero
instruction.increment_p.description=
instruction.increment_p.stackBefore=value
instruction.increment_p.stackAfter=incrementedValue
instruction.increment_p.operands=numberContext
instruction.inclocal_p.shortDescription=Incrementa un registre local utilitzant el context de n\u00famero
instruction.inclocal_p.description=
instruction.inclocal_p.stackBefore=
instruction.inclocal_p.stackAfter=
instruction.inclocal_p.operands=numberContext, localRegister
instruction.decrement_p.shortDescription=Decrementa un valor utilitzant el context de n\u00famero
instruction.decrement_p.description=
instruction.decrement_p.stackBefore=value
instruction.decrement_p.stackAfter=decrementedValue
instruction.decrement_p.operands=numberContext
instruction.declocal_p.shortDescription=Decrementa  un registre local utilitzant el context de n\u00famero
instruction.declocal_p.description=
instruction.declocal_p.stackBefore=
instruction.declocal_p.stackAfter=
instruction.declocal_p.operands=numberContext, localRegister
instruction.add.shortDescription=Suma dos valors
instruction.add.description=
instruction.add.stackBefore=value1, value2
instruction.add.stackAfter=value3
instruction.add.operands=
instruction.subtract.shortDescription=Resta dos valors
instruction.subtract.description=
instruction.subtract.stackBefore=value1, value2
instruction.subtract.stackAfter=value3
instruction.subtract.operands=
instruction.multiply.shortDescription=Multiplica dos valors
instruction.multiply.description=
instruction.multiply.stackBefore=value1, value2
instruction.multiply.stackAfter=value3
instruction.multiply.operands=
instruction.divide.shortDescription=Divideix dos valors
instruction.divide.description=
instruction.divide.stackBefore=value1, value2
instruction.divide.stackAfter=value3
instruction.divide.operands=
instruction.modulo.shortDescription=Fa el m\u00f2dul de dos valors
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=Compara dos valors
instruction.equals.description=
instruction.equals.stackBefore=value1, value2
instruction.equals.stackAfter=booleanResult
instruction.equals.operands=
instruction.strictequals.shortDescription=Compara estrictament dos valors
instruction.strictequals.description=
instruction.strictequals.stackBefore=value1, value2
instruction.strictequals.stackAfter=booleanResult
instruction.strictequals.operands=
instruction.lessthan.shortDescription=Comprova que un valor \u00e9s menor que l'altre
instruction.lessthan.description=
instruction.lessthan.stackBefore=value1, value2
instruction.lessthan.stackAfter=booleanResult
instruction.lessthan.operands=
instruction.lessequals.shortDescription=Comprova que un valor \u00e9s menor o igual que l'altre
instruction.lessequals.description=
instruction.lessequals.stackBefore=value1, value2
instruction.lessequals.stackAfter=booleanResult
instruction.lessequals.operands=booleanResult
instruction.greaterthan.shortDescription=Comprova que un valor \u00e9s major que l'altre
instruction.greaterthan.description=
instruction.greaterthan.stackBefore=value1, value2
instruction.greaterthan.stackAfter=booleanResult
instruction.greaterthan.operands=
instruction.greaterequals.shortDescription=Comprova que un valor \u00e9s major o igual que l'altre
instruction.greaterequals.description=
instruction.greaterequals.stackBefore=value1, value2
instruction.greaterequals.stackAfter=booleanResult
instruction.greaterequals.operands=
instruction.instanceof.shortDescription=Comprova que el tipus existeix a la cadena de prototipus de l'objecte
instruction.instanceof.description=
instruction.instanceof.stackBefore=value, type
instruction.instanceof.stackAfter=booleanResult
instruction.instanceof.operands=
instruction.istype.shortDescription=Comprova que l'objecte \u00e9s del tipus especificat
instruction.istype.description=
instruction.istype.stackBefore=value
instruction.istype.stackAfter=booleanResult
instruction.istype.operands=type
instruction.istypelate.shortDescription=Comprova que l'objecte \u00e9s del tipus especificat (basant-se en la pila)
instruction.istypelate.description=
instruction.istypelate.stackBefore=value, type
instruction.istypelate.stackAfter=booleanResult
instruction.istypelate.operands=
instruction.in.shortDescription=Comprova que l'object t\u00e9 la propietat anomenada
instruction.in.description=
instruction.in.stackBefore=name, obj
instruction.in.stackAfter=booleanResult
instruction.in.operands=
instruction.add_p.shortDescription=Suma dos valors utilitzant el context de n\u00famero
instruction.add_p.description=
instruction.add_p.stackBefore=value1, value2
instruction.add_p.stackAfter=value3
instruction.add_p.operands=numberContext
instruction.subtract_p.shortDescription=Resta dos valors utilitzant el context de n\u00famero
instruction.subtract_p.description=
instruction.subtract_p.stackBefore=value1, value2
instruction.subtract_p.stackAfter=value3
instruction.subtract_p.operands=numberContext
instruction.multiply_p.shortDescription=Multiplica dos valors utilitzant el context de n\u00famero
instruction.multiply_p.description=
instruction.multiply_p.stackBefore=value1, value2
instruction.multiply_p.stackAfter=value3
instruction.multiply_p.operands=numberContext
instruction.divide_p.shortDescription=Divideix dos valors utilitzant el context de n\u00famero
instruction.divide_p.description=
instruction.divide_p.stackBefore=value1, value2
instruction.divide_p.stackAfter=value3
instruction.divide_p.operands=numberContext
instruction.modulo_p.shortDescription=Fa el m\u00f2dul de dos valors utilitzant el context de n\u00famero
instruction.modulo_p.description=
instruction.modulo_p.stackBefore=value1, value2
instruction.modulo_p.stackAfter=value3
instruction.modulo_p.operands=numberContext
instruction.increment_i.shortDescription=Incrementa un valor enter
instruction.increment_i.description=
instruction.increment_i.stackBefore=value
instruction.increment_i.stackAfter=incrementedValue
instruction.increment_i.operands=
instruction.decrement_i.shortDescription=Decrementa un valor enter
instruction.decrement_i.description=
instruction.decrement_i.stackBefore=value
instruction.decrement_i.stackAfter=decrementedValue
instruction.decrement_i.operands=
instruction.inclocal_i.shortDescription=Incrementa un valor enter del registre local
instruction.inclocal_i.description=
instruction.inclocal_i.stackBefore=
instruction.inclocal_i.stackAfter=
instruction.inclocal_i.operands=localRegister
instruction.declocal_i.shortDescription=Decrementa un valor enter del registre local
instruction.declocal_i.description=
instruction.declocal_i.stackBefore=
instruction.declocal_i.stackAfter=
instruction.declocal_i.operands=localRegister
instruction.negate_i.shortDescription=Nega una valor enter
instruction.negate_i.description=
instruction.negate_i.stackBefore=value
instruction.negate_i.stackAfter=-value
instruction.negate_i.operands=
instruction.add_i.shortDescription=Suma dos valors enters
instruction.add_i.description=
instruction.add_i.stackBefore=value1, value2
instruction.add_i.stackAfter=value3
instruction.add_i.operands=
instruction.subtract_i.shortDescription=Resta dos valors enters
instruction.subtract_i.description=
instruction.subtract_i.stackBefore=value1, value2
instruction.subtract_i.stackAfter=value3
instruction.subtract_i.operands=
instruction.multiply_i.shortDescription=Multiplica dos valors enters
instruction.multiply_i.description=
instruction.multiply_i.stackBefore=value1, value2
instruction.multiply_i.stackAfter=value3
instruction.multiply_i.operands=
instruction.getlocal0.shortDescription=Obt\u00e9 el registre local 0
instruction.getlocal0.description=
instruction.getlocal0.stackBefore=
instruction.getlocal0.stackAfter=value
instruction.getlocal0.operands=
instruction.getlocal1.shortDescription=Obt\u00e9 el registre local 1
instruction.getlocal1.description=
instruction.getlocal1.stackBefore=
instruction.getlocal1.stackAfter=value
instruction.getlocal1.operands=
instruction.getlocal2.shortDescription=Obt\u00e9 el registre local 2
instruction.getlocal2.description=
instruction.getlocal2.stackBefore=
instruction.getlocal2.stackAfter=value
instruction.getlocal2.operands=
instruction.getlocal3.shortDescription=Obt\u00e9 el registre local 3
instruction.getlocal3.description=
instruction.getlocal3.stackBefore=
instruction.getlocal3.stackAfter=value
instruction.getlocal3.operands=
instruction.setlocal0.shortDescription=Estableix el registre local 0
instruction.setlocal0.description=
instruction.setlocal0.stackBefore=value
instruction.setlocal0.stackAfter=
instruction.setlocal0.operands=
instruction.setlocal1.shortDescription=Estableix el registre local 1
instruction.setlocal1.description=
instruction.setlocal1.stackBefore=value
instruction.setlocal1.stackAfter=
instruction.setlocal1.operands=
instruction.setlocal2.shortDescription=Estableix el registre local 2
instruction.setlocal2.description=
instruction.setlocal2.stackBefore=value
instruction.setlocal2.stackAfter=
instruction.setlocal2.operands=
instruction.setlocal3.shortDescription=Estableix el registre local 3
instruction.setlocal3.description=
instruction.setlocal3.stackBefore=value
instruction.setlocal3.stackAfter=
instruction.setlocal3.operands=
#Undocumented:
instruction.invalid.shortDescription=Inv\u00e0lid
instruction.invalid.description=
#instruction.invalid.stackBefore =
#instruction.invalid.stackAfter =
#instruction.invalid.operands =
#Undocumented:
instruction.abs_jump.shortDescription=Salt absolut
instruction.abs_jump.description=
#instruction.abs_jump.stackBefore =
#instruction.abs_jump.stackAfter =
#instruction.abs_jump.operands =
instruction.debug.shortDescription=Informaci\u00f3 de depuraci\u00f3
instruction.debug.description=
instruction.debug.stackBefore=
instruction.debug.stackAfter=
instruction.debug.operands=debugType, regName, localRegister, extra
instruction.debugline.shortDescription=Informaci\u00f3 del n\u00famero de l\u00ednia de depuraci\u00f3
instruction.debugline.description=
instruction.debugline.stackBefore=
instruction.debugline.stackAfter=
instruction.debugline.operands=lineNumber
instruction.debugfile.shortDescription=Informaci\u00f3 del fitxer de depuraci\u00f3
instruction.debugfile.description=
instruction.debugfile.stackBefore=
instruction.debugfile.stackAfter=
instruction.debugfile.operands=fileName
instruction.bkptline.shortDescription=Punt de ruptura a la l\u00ednia
instruction.bkptline.description=
instruction.bkptline.stackBefore=
instruction.bkptline.stackAfter=
instruction.bkptline.operands=lineNumber
#Undocumented:
instruction.timestamp.shortDescription=Marca hor\u00e0ria
instruction.timestamp.description=
instruction.timestamp.stackBefore=
instruction.timestamp.stackAfter=
instruction.timestamp.operands=
#Undocumented:
instruction.verifypass.shortDescription=Verifica el pas
instruction.verifypass.description=
#instruction.verifypass.stackBefore =
#instruction.verifypass.stackAfter =
#instruction.verifypass.operands =
#Undocumented:
instruction.alloc.shortDescription=Allotja
instruction.alloc.description=
#instruction.alloc.stackBefore =
#instruction.alloc.stackAfter =
#instruction.alloc.operands =
#Undocumented:
instruction.mark.shortDescription=Marca
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=Pr\u00f2leg
instruction.prologue.description=
#instruction.prologue.stackBefore =
#instruction.prologue.stackAfter =
#instruction.prologue.operands =
#Undocumented:
instruction.sendenter.shortDescription=Envia intro
instruction.sendenter.description=
#instruction.sendenter.stackBefore =
#instruction.sendenter.stackAfter =
#instruction.sendenter.operands =
#Undocumented:
instruction.doubletoatom.shortDescription=Doble a \u00e0tom
instruction.doubletoatom.description=
#instruction.doubletoatom.stackBefore =
#instruction.doubletoatom.stackAfter =
#instruction.doubletoatom.operands =
#Undocumented:
instruction.sweep.shortDescription=Escombra
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=Descodifica
instruction.decode.description=
#instruction.decode.stackBefore =
#instruction.decode.stackAfter =
#instruction.decode.operands =
instruction.unplus.shortDescription=Unary plus - for\u00e7a a num\u00e8ric
instruction.unplus.description=
instruction.unplus.stackBefore=value
instruction.unplus.stackAfter=value
instruction.unplus.operands=
instruction.pushconstant.shortDescription=Posa un valor constant a la pila
instruction.pushconstant.description=
#instruction.pushconstant.stackBefore =
#instruction.pushconstant.stackAfter = 
instruction.pushconstant.operands=value
