Store a byte in an array The value (byte) should be on the stack The index (int) should be on the stack The array address (int) should be on the stack

bcmp

fun bcmp(): Boolean

Compare the top two bytes on the stack

bdec

fun bdec(): Boolean

Subtract the top two bytes on the stack

bdiv

fun bdiv(): Boolean

Divide the top two bytes on the stack

bdup

fun bdup(): Boolean

Duplicate the top short on the stack

binc

fun binc(): Boolean

Add the top two bytes on the stack

bload

fun bload(variable: UShort): Boolean

Load a byte from the local variable table onto the stack

bmod

fun bmod(): Boolean

Modulo the top two bytes on the stack

bmul

fun bmul(): Boolean

Multiply the top two bytes on the stack

bneg

fun bneg(): Boolean

Negate the top byte on the stack

bnot

fun bnot(): Boolean

Bitwise not the top byte on the stack

bor

fun bor(): Boolean

Bitwise or the top two bytes on the stack

bPlaceholder

fun bPlaceholder(): ShakeBytecodeInstructionGenerator.BytePlaceholder

Create a byte placeholder

bpop

fun bpop(): Boolean

Pop the top short on the stack

bpush

fun bpush(value: Boolean): Boolean

Push a boolean to the stack

fun bpush(byte: Byte): Boolean

Push a byte to the stack

@JvmName(name = "bpushUByte")

fun bpush(value: UByte): Boolean

Push an unsigned byte to the stack

bret

fun bret(): Boolean

Set the top byte on the stack as return value of the function

bshl

fun bshl(): Boolean

Shift the top byte on the stack left by the second byte on the stack

bshr

fun bshr(): Boolean

Shift the top byte on the stack left by the second byte on the stack

bshru

fun bshru(): Boolean

Shift the top byte on the stack left by the second byte on the stack

bstore

fun bstore(variable: UShort): Boolean

Store a byte from the stack into the local variable table

bsub

fun bsub(): Boolean

Subtract the top two bytes on the stack

bxor

fun bxor(): Boolean

Bitwise xor the top two bytes on the stack

byteRef

fun byteRef(value: Byte): Boolean

Add a reference to a constant pool entry

ceq

fun ceq(): Boolean

Adds true to the stack if the comparison result was equal to

cge

fun cge(): Boolean

Adds true to the stack if the comparison result was greater than or equal to

cgt

fun cgt(): Boolean

Adds true to the stack if the comparison result was greater than

classRef

fun classRef(value: String): Boolean

Add a reference to a constant pool entry

cle

fun cle(): Boolean

Adds true to the stack if the comparison result was less than or equal to

clt

fun clt(): Boolean

Adds true to the stack if the comparison result was less than

cmp

fun cmp(type: String)

Compare the top two variables on the stack Takes the type of the variables as a string

cne

fun cne(): Boolean

Adds true to the stack if the comparison result was not equal to

dadd

fun dadd(): Boolean

Add the top two doubles on the stack

dcmp

fun dcmp(): Boolean

Compare the top two doubles on the stack

ddec

fun ddec(): Boolean

Subtract the top two doubles on the stack

ddiv

fun ddiv(): Boolean

Divide the top two doubles on the stack

dec

fun dec(type: String)

Subtract the top two variables on the stack Takes the type of the variables as a string

dinc

fun dinc(): Boolean

Add the top two doubles on the stack

div

fun div(type: String)

Divide the top two variables on the stack Takes the type of the variables as a string

dmod

fun dmod(): Boolean

Modulo the top two doubles on the stack

dmul

fun dmul(): Boolean

Multiply the top two doubles on the stack

dneg

fun dneg(): Boolean

Negate the top double on the stack

doubleRef

fun doubleRef(value: Double): Boolean

Add a reference to a constant pool entry

dsub

fun dsub(): Boolean

Subtract the top two doubles on the stack

dup

fun dup(): Boolean

Duplicate the top byte on the stack

fun dup(type: String)

Duplicate the top variable on the stack Takes the type of the variable as a string

fadd

fun fadd(): Boolean

Add the top two floats on the stack

fcmp

fun fcmp(): Boolean

Compare the top two floats on the stack

fdec

fun fdec(): Boolean

Subtract the top two floats on the stack

fdiv

fun fdiv(): Boolean

Divide the top two floats on the stack

finc

fun finc(): Boolean

Add the top two floats on the stack

floatRef

fun floatRef(value: Float): Boolean

Add a reference to a constant pool entry

fmod

fun fmod(): Boolean

Modulo the top two floats on the stack

fmul

fun fmul(): Boolean

Multiply the top two floats on the stack

fneg

fun fneg(): Boolean

Negate the top float on the stack

fsub

fun fsub(): Boolean

Subtract the top two floats on the stack

iadd

fun iadd(): Boolean

Add the top two ints on the stack

iaload

fun iaload(): Boolean

Load an int from an array The index (int) should be on the stack The array address (int) should be on the stack

iand

fun iand(): Boolean

Bitwise and the top two ints on the stack

iastore

fun iastore(): Boolean

Store an int in an array The value (int) should be on the stack The index (int) should be on the stack The array address (int) should be on the stack

icmp

fun icmp(): Boolean

Compare the top two ints on the stack

idec

fun idec(): Boolean

Subtract the top two ints on the stack

idiv

fun idiv(): Boolean

Divide the top two ints on the stack

idup

fun idup(): Boolean

Duplicate the top long on the stack

iinc

fun iinc(): Boolean

Add the top two ints on the stack

iload

fun iload(variable: UShort): Boolean

Load an int from the local variable table onto the stack

imod

fun imod(): Boolean

Modulo the top two ints on the stack

imul

fun imul(): Boolean

Multiply the top two ints on the stack

inc

fun inc(type: String)

Add the top two variables on the stack Takes the type of the variables as a string

ineg

fun ineg(): Boolean

Negate the top int on the stack

inot

fun inot(): Boolean

Bitwise not the top int on the stack

intRef

fun intRef(value: Int): Boolean

Add a reference to a constant pool entry

invoke_static

fun invoke_static(descriptor: String)

Invoke a function

fun invoke_static(): ShakeBytecodeInstructionGenerator.IntPlaceholder

Invoke a function The address int should point to an utf8 constant pool entry in the constant pool Parameters should be on the stack

fun invoke_static(address: Int): Boolean

Invoke a function The address int should point to an utf8 constant pool entry in the constant pool

invoke_virtual

fun invoke_virtual(descriptor: String)

Invoke a function on an object

fun invoke_virtual(): ShakeBytecodeInstructionGenerator.IntPlaceholder

fun invoke_virtual(address: Int): Boolean

Invoke a function on an object The address int should point to an utf8 constant pool entry in the constant pool Parameters, and the object should be on the stack. The object should be on the stack

ior

fun ior(): Boolean

Bitwise or the top two ints on the stack

iPlaceholder

fun iPlaceholder(): ShakeBytecodeInstructionGenerator.IntPlaceholder

Create an int placeholder

ipop

fun ipop(): Boolean

Pop the top long on the stack

ipush

fun ipush(value: Float): Boolean

Push a float to the stack

fun ipush(int: Int): Boolean

Push an int to the stack

@JvmName(name = "ipushUInt")

fun ipush(value: UInt): Boolean

Push an unsigned int to the stack

iret

fun iret(): Boolean

Set the top int on the stack as return value of the function

ishl

fun ishl(): Boolean

Shift the top int on the stack left by the second int on the stack

ishr

fun ishr(): Boolean

Shift the top int on the stack left by the second int on the stack

ishru

fun ishru(): Boolean

Shift the top int on the stack left by the second int on the stack

istore

fun istore(variable: UShort): Boolean

Store an int from the stack into the local variable table

isub

fun isub(): Boolean

Subtract the top two ints on the stack

ixor

fun ixor(): Boolean

Bitwise xor the top two ints on the stack

fun je(): ShakeBytecodeInstructionGenerator.IntPlaceholder

fun je(address: Int): Boolean

Jump to the given address if the comparison result was equal to

jge

fun jge(): ShakeBytecodeInstructionGenerator.IntPlaceholder

fun jge(address: Int): Boolean

Jump to the given address if the comparison result was greater than or equal to

jgt

fun jgt(): ShakeBytecodeInstructionGenerator.IntPlaceholder

fun jgt(address: Int): Boolean

Jump to the given address if the comparison result was greater than

jle

fun jle(): ShakeBytecodeInstructionGenerator.IntPlaceholder

fun jle(address: Int): Boolean

Jump to the given address if the comparison result was less than or equal to

jlt

fun jlt(): ShakeBytecodeInstructionGenerator.IntPlaceholder

fun jlt(address: Int): Boolean

Jump to the given address if the comparison result was less than

jmp

fun jmp(): ShakeBytecodeInstructionGenerator.IntPlaceholder

fun jmp(address: Int): Boolean

Jump to the given address

jne

fun jne(): ShakeBytecodeInstructionGenerator.IntPlaceholder

fun jne(address: Int): Boolean

Jump to the given address if the comparison result was not equal to

jnz

fun jnz(): ShakeBytecodeInstructionGenerator.IntPlaceholder

fun jnz(address: Int): Boolean

Jump to the given address if the top variable byte on the stack is not 0

fun jz(): ShakeBytecodeInstructionGenerator.IntPlaceholder

fun jz(address: Int): Boolean

Jump to the given address if the top variable byte on the stack is 0

ladd

fun ladd(): Boolean

Add the top two longs on the stack

laload

fun laload(): Boolean

Load a long from an array The index (int) should be on the stack The array address (int) should be on the stack

land

fun land(): Boolean

Bitwise and the top two longs on the stack

lastore

fun lastore(): Boolean

Store a long in an array The value (long) should be on the stack The index (int) should be on the stack The array address (int) should be on the stack

lcmp

fun lcmp(): Boolean

Compare the top two longs on the stack

ldec

fun ldec(): Boolean

Subtract the top two longs on the stack

ldiv

fun ldiv(): Boolean

Divide the top two longs on the stack

ldup

fun ldup(): Boolean

Duplicate the top float on the stack

linc

fun linc(): Boolean

Add the top two longs on the stack

lload

fun lload(variable: UShort): Boolean

Load a long from the local variable table onto the stack

lmod

fun lmod(): Boolean

Modulo the top two longs on the stack

lmul

fun lmul(): Boolean

Multiply the top two longs on the stack

lneg

fun lneg(): Boolean

Negate the top long on the stack

lnot

fun lnot(): Boolean

Bitwise not the top long on the stack

load

fun load(type: String, variable: UShort)

Load a variable from the local variable table onto the stack Takes the type of the variable as a string

load_static

fun load_static(descriptor: String)

Load a static variable

fun load_static(): ShakeBytecodeInstructionGenerator.IntPlaceholder

fun load_static(address: Int): Boolean

Load a static variable The address int should point to an utf8 constant pool entry

load_virtual

fun load_virtual(descriptor: String)

Load a virtual variable

fun load_virtual(): ShakeBytecodeInstructionGenerator.IntPlaceholder

fun load_virtual(address: Int): Boolean

Load a virtual variable The address int should point to an utf8 constant pool entry

longRef

fun longRef(value: Long): Boolean

Add a reference to a constant pool entry

lor

fun lor(): Boolean

Bitwise or the top two longs on the stack

lPlaceholder

fun lPlaceholder(): ShakeBytecodeInstructionGenerator.LongPlaceholder

Create a long placeholder

lpop

fun lpop(): Boolean

Pop the top float on the stack

lpush

fun lpush(value: Double): Boolean

Push a double to the stack

fun lpush(long: Long): Boolean

Push a long to the stack

@JvmName(name = "lpushULong")

fun lpush(value: ULong): Boolean

Push an unsigned long to the stack

lret

fun lret(): Boolean

Set the top long on the stack as return value of the function

lshl

fun lshl(): Boolean

Shift the top long on the stack left by the second long on the stack

lshr

fun lshr(): Boolean

Shift the top long on the stack left by the second long on the stack

lshru

fun lshru(): Boolean

Shift the top long on the stack left by the second long on the stack

lstore

fun lstore(variable: UShort): Boolean

Store a long from the stack into the local variable table

lsub

fun lsub(): Boolean

Subtract the top two longs on the stack

lxor

fun lxor(): Boolean

Bitwise xor the top two longs on the stack

mod

fun mod(type: String)

Modulo the top two variables on the stack Takes the type of the variables as a string

mul

fun mul(type: String)

Multiply the top two variables on the stack Takes the type of the variables as a string

neg

fun neg(type: String)

Negate the top variable on the stack Takes the type of the variable as a string

new_array

fun new_array(descriptor: String)

fun new_array(): ShakeBytecodeInstructionGenerator.IntPlaceholder

fun new_array(type: Int): Boolean

Create a new array The type is stored in an utf8 constant pool entry

new_obj

fun new_obj(descriptor: String)

fun new_obj(): ShakeBytecodeInstructionGenerator.IntPlaceholder

fun new_obj(type: Int): Boolean

Create a new object The type is stored in an utf8 constant pool entry

nop

fun nop(): Boolean

Add a nop instruction to the bytecode

not

fun not(type: String)

Bitwise not the top variable on the stack Takes the type of the variable as a string

fun or(type: String)

Bitwise or the top two variables on the stack Take the type of the variables as a string

pcast

fun pcast(from: String, to: String)

fun pcast(from: UByte, to: UByte): Boolean

Perform a cast operation on the top of the stack

pointer

fun pointer(): Int

Get a pointer to the current position in the bytecode

pop

fun pop(): Boolean

Pop the top byte on the stack

fun pop(type: String)

Pop the top variable on the stack Takes the type of the variable as a string

ret

fun ret(): Boolean

Return from the current function

fun ret(type: String)

Return the given type from the current function Takes the type of the return value as a string

sadd

fun sadd(): Boolean

Add the top two shorts on the stack

saload

fun saload(): Boolean

Load a short from an array The index (int) should be on the stack The array address (int) should be on the stack

sand

fun sand(): Boolean

Bitwise and the top two shorts on the stack

sastore

fun sastore(): Boolean

Store a short in an array The value (short) should be on the stack The index (int) should be on the stack The array address (int) should be on the stack

scmp

fun scmp(): Boolean

Compare the top two shorts on the stack

sdec

fun sdec(): Boolean

Subtract the top two shorts on the stack

sdiv

fun sdiv(): Boolean

Divide the top two shorts on the stack

sdup

fun sdup(): Boolean

Duplicate the top int on the stack

shl

fun shl(type: String)

Shift the top variable on the stack left by the second variable on the stack Takes the type of the variables as a string

shortRef

fun shortRef(value: Short): Boolean

Add a reference to a constant pool entry

shr

fun shr(type: String)

Shift the top variable on the stack left by the second variable on the stack Takes the type of the variables as a string

shru

fun shru(type: String)

Shift the top variable on the stack left by the second variable on the stack Takes the type of the variables as a string

sinc

fun sinc(): Boolean

Add the top two shorts on the stack

sload

fun sload(variable: UShort): Boolean

Load a short from the local variable table onto the stack

smod

fun smod(): Boolean

Modulo the top two shorts on the stack

smul

fun smul(): Boolean

Multiply the top two shorts on the stack

sneg

fun sneg(): Boolean

Negate the top short on the stack

snot

fun snot(): Boolean

Bitwise not the top short on the stack

sor

fun sor(): Boolean

Bitwise or the top two shorts on the stack

sPlaceholder

fun sPlaceholder(): ShakeBytecodeInstructionGenerator.ShortPlaceholder

Create a short placeholder

spop

fun spop(): Boolean

Pop the top int on the stack

spush

fun spush(value: Char): Boolean

Push a char to the stack

fun spush(short: Short): Boolean

Push a short to the stack

@JvmName(name = "spushUShort")

fun spush(value: UShort): Boolean

Push an unsigned short to the stack

sret

fun sret(): Boolean

Set the top short on the stack as return value of the function

sshl

fun sshl(): Boolean

Shift the top short on the stack left by the second short on the stack

sshr

fun sshr(): Boolean

Shift the top short on the stack left by the second short on the stack

sshru

fun sshru(): Boolean

Shift the top short on the stack left by the second short on the stack

sstore

fun sstore(variable: UShort): Boolean

Store a short from the stack into the local variable table

ssub

fun ssub(): Boolean

Subtract the top two shorts on the stack

store

fun store(type: String, variable: UShort)

Store a variable from the stack into the local variable table Takes the type of the variable as a string

store_static

fun store_static(descriptor: String)

Store a static variable

fun store_static(): ShakeBytecodeInstructionGenerator.IntPlaceholder

fun store_static(address: Int): Boolean

Store a static variable The address int should point to an utf8 constant pool entry The value should be on the stack

store_virtual

fun store_virtual(descriptor: String)

Store a virtual variable

fun store_virtual(): ShakeBytecodeInstructionGenerator.IntPlaceholder

fun store_virtual(address: Int): Boolean

Store a virtual variable The address int should point to an utf8 constant pool entry The value should be on the stack

sub

fun sub(type: String)

Subtract the top two variables on the stack Takes the type of the variables as a string

sxor

fun sxor(): Boolean

Bitwise xor the top two shorts on the stack

toByteArray

fun toByteArray(): ByteArray

Output a ByteArray of the bytecode

ubcmp

fun ubcmp(): Boolean

Compare the top two unsigned bytes on the stack

ubdiv

fun ubdiv(): Boolean

Divide the top two unsigned bytes on the stack

ubmod

fun ubmod(): Boolean

Modulo the top two unsigned bytes on the stack

ubmul

fun ubmul(): Boolean

Multiply the top two unsigned bytes on the stack

ubsub

fun ubsub(): Boolean

Subtract the top two unsigned bytes on the stack

uicmp

fun uicmp(): Boolean

Compare the top two unsigned ints on the stack

uidiv

fun uidiv(): Boolean

Divide the top two unsigned ints on the stack

uimod

fun uimod(): Boolean

Modulo the top two unsigned ints on the stack

uimul

fun uimul(): Boolean

Multiply the top two unsigned ints on the stack

uisub

fun uisub(): Boolean

Subtract the top two unsigned ints on the stack

ulcmp

fun ulcmp(): Boolean

Compare the top two unsigned longs on the stack

uldiv

fun uldiv(): Boolean

Divide the top two unsigned longs on the stack

ulmod

fun ulmod(): Boolean

Modulo the top two unsigned longs on the stack

ulmul

fun ulmul(): Boolean

Multiply the top two unsigned longs on the stack

ulsub

fun ulsub(): Boolean

Subtract the top two unsigned longs on the stack

uscmp

fun uscmp(): Boolean

Compare the top two unsigned shorts on the stack

usdiv

fun usdiv(): Boolean

Divide the top two unsigned shorts on the stack

usmod

fun usmod(): Boolean

Modulo the top two unsigned shorts on the stack

usmul

fun usmul(): Boolean

Multiply the top two unsigned shorts on the stack

ussub

fun ussub(): Boolean

Subtract the top two unsigned shorts on the stack

utf8Ref

fun utf8Ref(value: String): Boolean

Add a reference to a constant pool entry

xor

fun xor(type: String)

Bitwise xor the top two variables on the stack Takes the type of the variables as a string