Overview

A reference for the P-code instruction set executed by the Visual Basic 6 runtime (MSVBVM60.DLL 6.00.8268). It is generated from vbpcode.db, reference revision 1.007. Every dispatch slot is listed with its encoding, behaviour, the VB6 source that makes the compiler emit it, and the evidence behind each claim.

Instruction encoding

A P-code procedure is a byte stream interpreted by MSVBVM60's dispatcher, which works on an evaluation stack, the procedure frame (addressed by signed offsets from EBP) and a constant pool attached to the procedure.

• The first byte indexes the primary table (table 0, 256 entries).
• Bytes FB–FF in table 0 are lead bytes: they select tables 1–5, and the next byte is the index into that table. An opcode is therefore written (table, index); for example (4,0x64) ForI4 is encoded FE 64.
• Operands follow inline, little-endian. The DB's size column counts the index byte plus operand bytes but not the lead byte, so the instruction length is size in table 0 and size+1 in tables 1–5. A size of -1/-2 marks a variable-length operand block whose first word is its byte count.
• Branch targets are 16-bit offsets from the start of the procedure's P-code.
• Frame operands (%a) are signed 16-bit offsets from EBP: negative values are locals and temporaries (vbdec shows var_XX), positive values are arguments (arg_XX).
• The interpreter keeps a cached object/structure pointer, written pr ([ebp-4Ch]). FLdPr, FLdPrThis, AryLdPr, LdPrVar and NewIfNull* load it, and the Mem* opcodes address fields relative to it.

Operand markers

vbdec printf-style templates describe operands with these markers:

Marker	Category	Bytes	Meaning
%!	literal_single	4	4-byte single literal
%1	immediate_byte	1	1-byte immediate
%2	immediate_word	2	2-byte immediate (integer)
%4	immediate_dword	4	4-byte immediate (long)
%C	literal_currency	8	8-byte currency literal
%D	literal_double	8	8-byte double literal
%E	pool_pcode_proc_off	var.	same as %e but adds arg2 offset
%G	guid_extract	var.	extract GUID variant (see CastAd %G)
%L	branch_target_no_loc	2	local jump target, no loc_xx label added
%a	local_var_ref	2	argument/local reference, esp-xx offset
%c	pool_proc_or_global	2	const pool: proc address or global var address
%d	literal_date_word	var.	date literal
%e	pool_pcode_proc	var.	read offset from pool as pcode proc to call
%g	guid_extract	var.	extract GUID from operand stream
%l	branch_target_local	2	local jump target, adds label reference
%r	vt_type_byte	1	VT type byte for variant typing
%s	pool_string	2	string from const pool offset
%t	code_object_ref	2	code object by base offset (GUID fallback)
%v	vtable_call	4	2-byte vtable offset + 2-byte pool GUID index
%x	pool_external_api	2	external API call resolved from pool index
%y	safearray_flags	var.	SafeArray flag decoder
%z	guid_property_lookup	var.	GUID from pool, call getProperty for lookup
%}	eop_marker	0	end of procedure marker (display only)

Handlers and duplicate slots

The six dispatch tables define 1165 slots, but many slots point at the same machine-code handler. After grouping by handler address, there are 775 distinct opcodes. In each group one slot is the primary, chosen in this order: emitted by the compiler, then most corpus hits, then marked primary in modOpcodes, then table 0 first. The other 390 slots are marked dup and point to it.

Slots sharing one handler	1	2	3	4	5	6	7
Handler groups	498	201	56	7	10	2	1

A shared handler means the slots behave identically at runtime. It does not always mean they are interchangeable at compile time. In 22 groups the compiler deliberately emits different slots depending on the source type (Integer vs Long `Xor`, Single vs Double `CBool`, …), so the slot still carries type information that is useful to a decompiler. Each entry's notes list these selections. Groups whose slots carry different names:

Handler	Slots	Names
#232	(0,EB),(2,24),(2,25),(2,2C),(2,2D),(2,3C),(2,3D)	CR8I2,FnCSngI2
#10	(0,0B),(0,5E),(4,21),(4,22),(4,27),(4,28)	ImpAdCallI2,ImpAdCallI4
#105	(0,6C),(2,E2),(2,E3),(2,E7),(2,E8),(3,1C)	ILdRf,FLdR4
#14	(0,0F),(4,11),(4,12),(4,17),(4,18)	VCallAd,VCallStr
#16	(0,11),(4,09),(4,0A),(4,0C),(5,2C)	ThisVCallFPR8,ThisVCallHidden
#17	(0,12),(4,01),(4,02),(4,07),(4,08)	ThisVCallAd,ThisVCallI2
#19	(0,14),(2,CE),(2,D3),(2,D4),(2,D5)	ExitProcI4,ExitProcStr
#115	(0,76),(3,A2),(3,A3),(3,A7),(3,A8)	ImpAdLdI4,ImpAdLdStr
#135	(0,8A),(3,72),(3,73),(3,77),(3,78)	MemLdStr,MemLdR4
#193	(0,C4),(1,21),(1,22),(1,23)	AndI4,AndUI1
#194	(0,C5),(1,19),(1,1A),(1,1B)	OrI4,OrI2
#65	(0,42),(2,2A),(2,32)	CR4Var,CR8Var
#102	(0,69),(4,7C),(4,84)	NextStepR8,NextR8
#121	(0,7C),(3,B4),(3,B5)	ImpAdStCy,ImpAdStR8
#140	(0,8F),(3,82),(3,83)	MemStI4,MemStR4
#141	(0,90),(3,84),(3,85)	MemStR8,MemStCy

Naming conventions

Part	Meaning
F	Frame slot: a local, temporary or ByVal argument addressed by %a.
I	Indirect: the frame slot holds a pointer, usually a ByRef argument.
Mem	Field at an offset from the cached pointer pr (class members, Static locals, multi-dimensional array elements).
FMem	Field at an offset from a pointer held in a frame slot (ActiveX DLL/EXE per-thread module variables; fields of ByRef UDT parameters).
ImpAd	Absolute address taken from the constant pool (Standard-EXE module variables; calls to imports and procedures).
WMem/IWMem	Field relative to dispatcher argument 3 ([ebp+10h]). The compiler was never observed emitting these.
Ld/St	Load (push) / store (pop).
UI1 I2 I4	Byte / Integer-Boolean / Long.
R4 R8 (in Ld/St names)	Raw 4/8-byte move. The compiler uses R4 for Long and R8 for Currency, not for floating point.
FPR4 FPR8	Single / Double-Date moved through the FPU.
R4 R8 (in arithmetic/compare names)	Floating-point operation. Single arithmetic still compiles to the R8 forms.
Cy Str Var Ad Pr Rf	Currency / String (BSTR) / Variant / object reference / object pointer into pr / address (reference).
Copy, Func, NoPop, Unk	Copy the value rather than move it / value comes from a call (adopt, no extra AddRef) / leave the value on the stack / VT_UNKNOWN rather than VT_DISPATCH.
Var suffix on operators	Variant operation; %a names the temporary that receives the result. …VarBool pushes a plain Boolean for conditions.
Text	Comparison under Option Compare Text.

Findings from compiler probes

**1. CStr slots (1,FC) and (1,FD) appear swapped

• CStr(<Byte>) emits (1,0xFC), which is labeled CStrI2.
• CStr(<Integer>) emits (1,0xFD), which is labeled CStrUI1.

The rest of the run lines up with its source type: FE=I4, FF=R4, (2,00)=R8, (2,01)=Cy. Probes: op\1_FC_CStrI2, op\1_FD_CStrUI1.

**2. Sixteen alias groups have more than one compiler-emitted slot

Phase 3b showed that these slots share a handler. The compiler still picks between them by source type, so the shared name hides a real compile-time distinction:

Slots	Label	What selects each slot
(1,0A) / (1,0B)	EqvI4	Integer/Boolean operands / Long, Single, Double, Currency, Date, String
(1,02) / (1,03)	ImpI4	same split as Eqv
(1,11) / (1,12) / (1,13)	XorI4	Byte / Integer, Boolean / Long and wider
(2,50) / (2,51)	CBoolUI1	CBool(Byte) / CBool(Integer) (Integer arithmetic on Booleans too)
(2,53) / (2,54)	CBoolR4	CBool(Single) / CBool(Double or Date)
(2,0F) / (2,10)	CUI1R4	CByte(Single) / CByte(Double)
(2,3A) / (2,3B)	FnCDblR8	CDbl(Single) / CDbl(Double)
(1,DE) / (1,DF)	FnFixR8	Fix(Single) / Fix(Double, Date, String)
(1,E6) / (1,E7)	FnIntR8	Int(Single) / Int(Double, Date, String)
(1,87) / (1,88)	BetweenR4	Case a To b on Single / on Double or Date
(2,4E) / (2,4F)	FnCDateVar	explicit CDate(v) / implicit Variant→Date coercion
(4,7E) / (4,86)	NextStepVar	Variant For with no Step / with Step
(3,CB) / (3,CC) / (3,CD)	ExitForCollObj	For Each control variable is Variant / Object / a specific class
(0,0E) / (5,2B)	VCallFPR8	see finding 5
(0,3E) / (0,51)	FLdZeroAd	both are emitted, in different object-type contexts
(0,59) / (3,C7)	PopTmpLdAdStr	(3,C7) appears for fixed-length string temporaries

Each slot's source_gen shows the source construct that selects it. This looks like strong evidence for renaming the second slot in several groups, for example EqvI2/EqvI4, CBoolI2, CBoolR8, and CUI1R8. Renaming is David's decision, so no mnemonics were changed.

**3. Single-precision math reuses the R8 (FPU) opcodes

Single + Single emits AddR8. The same holds for SubR8, MulR8, DivR8, UMiR8, EqR8, LtR8, NeR8, GeR8, GtR8, and LeR8. The *R4 arithmetic and compare slots (AddR4, MulR4, UMiR4, LtR4, NeR4, and so on) were never emitted.

**4. Old-style Print, Input, and Write item opcodes are never emitted

• Print # and form Print compile to one PrintFile (5,0E) or PrintObject (5,0D) with a descriptor.
• Input # compiles to InputFile (5,10), and Write # to WriteFile (5,0F).

None of the following came out of any variant: PrintChan/PrintComma/PrintNL/PrintItem*/PrintSpc/PrintTab/PrintObj, Input/InputDone/InputItem*, and WriteChan. They look like a legacy encoding that this compiler doesn't use.

**5. Typed (non-HRESULT) vtable calls use three slots only

A type library was built for this (probes\_tlb\probetlb.idl). Its ITyped interface has methods that return each type directly. The compiler emitted:

• VCallAd (0,0F) for I2, I4, Bool, and Str returns
• VCallUI1 (4,10) for Byte returns
• VCallFPR8 (0,0E) for Single and Double returns
• (5,2B), the second VCallFPR8 slot, for Currency returns
• (0,0E) also for calls whose result is discarded (e.g. o.GetI2 3)

VCallI2, VCallR4, VCallR8, VCallStr, VCallCy, VCallCbFrame, and every typed ThisVCall* were never emitted. The probes included 34 Me-qualified Form intrinsics (Me.TextWidth, Me.hWnd, Me.Left, ...), and none of them produced a typed ThisVCall*.

**6. Literal slots

• (0,FA), labeled LitDate, is emitted for plain Double literals (c = 2.5) as well as dates.
• (0,F6), labeled LitCy, carries Currency literals. It also carries raw double bytes when a Double literal is passed ByVal or appears in a Print # list.

This suggests FA means "8-byte literal pushed to the FPU" and F6 means "8-byte literal pushed raw onto the stack". vbdec's display then decodes F6 as Currency even when it isn't. Handler confirmation is still needed.

**7. W/IW prefix: still never emitted

None of the 64 WMem* or IWMem* slots appeared in any probe. The following contexts were tried:

• Static locals in class, form, and module procedures, and Static Sub
• Class, form, and module UDT members, including With
• With on local, global, array-element, parameter, static, and public-module UDTs
• WithEvents sinks and Implements
• ActiveX DLL and ActiveX EXE module globals of every type

DLL globals turned out to compile to **FMem***, which goes through [this+off] on the per-thread data block. So FMem is the TLS route, and it is not what the W prefix means. The [ebp+10h] base therefore still has no known source construct. It may only be reachable from the IDE or from p-code produced by a different compiler version.

**7b. W/IW and special project types (round 4)

David suggested that W/IW might belong to particular project types. Round 4 put the same body (members of every type, statics, With on a member UDT, host implicit members) into each of these:

• a UserControl, in an OCX and in an EXE
• a PropertyPage
• an ActiveX Document, as a DLL and as an EXE
• an Add-in (Connect designer plus form)
• a DHTML Application (HTMLPage designer)
• a DataReport designer

The same body was also put in a plain class, a DLL class, and a form as controls. No W/IW opcode appeared in any of them.

Member, static, and With access compiled to the same opcodes as in a plain class. The only differences came from reaching the host object:

• MemLdPr (0,58): the module's self-reference at [pr+0x10], e.g. UserControl.Width or UserDocument.Width. Now probed.
• ILdPr (0,48): a method call on a ByRef object parameter (Sub P(c As Collection): n = c.Count). It showed up through AsyncReadComplete(AsyncProp As AsyncProperty). Ordinary ByVal object parameters are copied to a local first and use FLdPr. Now probed.

The IIS Application (WebClass) remains untested. Its designer refuses to compile unless IIS or Peer Web Services 3.0+ is installed on this machine.

**8. Other compile-time observations

• (0,E7), labeled CI4UI1, is emitted for CLng(Integer) and CLng(Boolean), which is I2→I4. Assigning an integer literal to a Byte emits (2,0D) CUI1I2 first.
• Debug.Assert and Debug.Print are stripped from the compiled exe, so Assert (5,0B) cannot be probed this way.
• Records in Variants need a public UDT. Using the typelib's TPubRec, or a public class UDT in an ActiveX DLL, produced CVarUdt, CVarRefUdt, StUdtVar, RedimVarUdt, RedimPreserveVarUdt, CDargRefUdt, and ExitProcFrameCbHresult.
• IUnknown-typed function returns stored into Variants produce the *VarUnk and *VarUnkFunc stores: FStVarUnkFunc, Ary1StVarUnk, Ary1StVargUnk, MemStVarUnk, ImpAdStVarUnk[Func], FMemStVarUnkFunc, and IStDargUnkFunc.

---

Method and confidence

• Static tables (mnemonics, templates, sizes, handler addresses) come from vbdec's modOpcodes.bas and the MSVBVM60 dispatch tables.
• Handler identity was resolved with IDA/idalib against MSVBVM60.DLL 6.00.8268 (Phase 3).
• Compiler probes (Phase 4): about 3,070 small VB6 programs were compiled as P-code with VB6 SP6 and disassembled with vbdec. Every emitted slot has a minimal program, kept in probes\op\, that is proven to produce it. not emitted means no tested construct produced the slot; it does not prove the slot is unreachable.
• Descriptions are drafts written by AI agents and are not yet reviewed (status=draft). 0 drafts are marked needs revision because probe evidence contradicts them; the correction appears in their notes.
• Each existing example in vb6_source_eq was compiled and checked. The result is shown as "example check" in the entry's notes.

About

This reference was created by David Zimmer (sandsprite.com), working with Claude (Anthropic).

On the shoulders of others

None of this starts from zero. This reference stands on the shoulders of several generations of VB reversers, who mapped the runtime, the file format and the P-code engine long before AI tools existed, and who shared what they found.

Credits include the VB Decompiling community, Sarge, Napalm, VbGamer45, Mr. Unleaded, Moogman, _aLfa_, Alex Ionescu, Warning, josephCo, Darker, Trick, Firehacker, dodi, sysenter-eip and others.

Special thanks go out to:

• VbGamer45 for his work on Semi VB Decompiler
• Mr. Unleaded for allowing the old forums to be rebuilt
• Mr Silver and Mr Snow for their excellent work on the WKTVBDebugger
• Darker for his excellent work on p32Dasm
• Reginald Wong for his vb.idc script
• The OG wizards who created VB6

How it was built

The starting point was the opcode table in vbdec, the VB6 disassembler and decompiler: mnemonics, operand templates, instruction sizes and the dispatch-table address of every slot. That table was loaded into a SQLite database. AI agents then filled it in phase by phase, and each phase was handed off through written briefs and a running lessons-learned file.

Handler-level analysis was done in IDA Pro against MSVBVM60.DLL 6.00.8268, with Claude driving IDA through mrexodia's IDA MCP server (ida-pro-mcp) and idalib. Every dispatch slot was resolved to the machine code that executes it. That is how the 1,165 slots were reduced to 775 distinct handlers, how the aliases were classified, and how the operand sizes were checked.

Runtime evidence came from vbdec itself. With remote scripting enabled, vbdec publishes its live object model on the Windows Running Object Table, so an agent can open a binary and read every procedure's disassembly from a script. Claude used this first to sweep a real P-code application (PDFStreamDumper) for opcode usage, then as the disassembler in an automated test loop.

That loop is what verifies the source examples in this reference. Claude generated a few thousand small VB6 programs, compiled each one to P-code with the VB6 compiler from the command line, disassembled the result in vbdec, and recorded which opcodes each program produced. For every opcode the compiler emits, the smallest such program was then reduced line by line to the minimal source that still produces it. Description examples were compiled the same way, which is how incorrect drafts were found and fixed.

Two companion kits describe the setup in detail and are meant for anyone repeating this work with an AI agent:

• vbdec AI (the vbdec operator briefing and object-model prototypes): how an agent connects to vbdec over the ROT and reads projects, procedures and disassembly, with example tasks such as call graphs and SQL export.
• VB6 AI compile help (vbai_compile_help): how an agent builds VB6 projects headlessly, covering CRLF/ANSI source files, /make with error logs, line-number mapping, the elevation rules for OCX projects, and test-harness templates.

The descriptions are AI-written drafts that have not yet been reviewed. Treat the probe evidence and the verified source on each entry as the primary record.

Opcodes by data type

Every slot grouped by the kind of value it works on. Casts are grouped together under Conversion, with the source and target types in the detail column. Within a group, rows are sorted by operation, then mnemonic. dup marks a duplicate slot, and emitted marks slots the VB6 compiler is known to produce.

String 73 slots, 56 distinct handlers, 49 emitted

BSTR operations: concatenation, Mid/Len/InStr/StrComp, fixed-length String handling and String loads/stores.

Slot	Mnemonic	Operation	Types	Status	Summary
(1,8B)	BetweenStr	Compare	String	emitted	Case lo To hi range test on a String selector; push Boolean.
(1,8D)	BetweenTextStr	Compare	String (text compare)	emitted	Case lo To hi range test on a String selector; push Boolean.
(1,30)	EqStr	Compare	String	emitted	Compare two values with =; push Boolean result.
(1,32)	EqTextStr	Compare	String (text compare)	emitted	Compare two values with =; push Boolean result.
(1,57)	GeStr	Compare	String	emitted	Compare two values with >=; push Boolean result.
(1,59)	GeTextStr	Compare	String (text compare)	emitted	Compare two values with >=; push Boolean result.
(1,71)	GtStr	Compare	String	emitted	Compare two values with >; push Boolean result.
(1,73)	GtTextStr	Compare	String (text compare)	emitted	Compare two values with >; push Boolean result.
(1,4A)	LeStr	Compare	String	emitted	Compare two values with <=; push Boolean result.
(1,4C)	LeTextStr	Compare	String (text compare)	emitted	Compare two values with <=; push Boolean result.
(1,7E)	LikeStr	Compare	String	emitted	Pop two strings; push True if the first matches the pattern in the second.
(1,80)	LikeTextStr	Compare	String (text compare)	emitted	Like between two Strings under Option Compare Text; push Boolean.
(1,64)	LtStr	Compare	String	emitted	Compare two values with <; push Boolean result.
(1,66)	LtTextStr	Compare	String (text compare)	emitted	Compare two values with <; push Boolean result.
(1,3D)	NeStr	Compare	String	emitted	Compare two values with <>; push Boolean result.
(1,3F)	NeTextStr	Compare	String (text compare)	emitted	Compare two values with <>; push Boolean result.
(0,1B)	LitStr	Literal	String	emitted	Push a BSTR literal from the const pool.
(4,BF)	LitStr	Literal	String	never dup	Push a BSTR literal from the const pool.
(3,A2)	ImpAdLdStr	Load	String, global	never dup	Load Long from a module-level (global) variable.
(3,A3)	ImpAdLdStr	Load	String, global	never dup	Load Long from a module-level (global) variable.
(3,A7)	ImpAdLdStr	Load	String, global	never dup	Load Long from a module-level (global) variable.
(3,A8)	ImpAdLdStr	Load	String, global	never dup	Load Long from a module-level (global) variable.
(0,8A)	MemLdStr	Load	String, member via pr	emitted	Load a BSTR (VB6 String) from [pr + offset] where pr is on the stack.
(4,D2)	WMemLdStr	Load	String, W-base	never	LOAD a BSTR pointer (VB6 String) at [W-base+offset] via the procedure's secondary-object pointer [ebp+10h] (W-base) (4-byte (pointer)).
(4,D3)	WMemLdStr	Load	String, W-base	never dup	LOAD a BSTR pointer (VB6 String) at [W-base+offset] via the procedure's secondary-object pointer [ebp+10h] (W-base) (4-byte (pointer)).
(4,D7)	WMemLdStr	Load	String, W-base	never dup	LOAD a BSTR pointer (VB6 String) at [W-base+offset] via the procedure's secondary-object pointer [ebp+10h] (W-base) (4-byte (pointer)).
(4,D8)	WMemLdStr	Load	String, W-base	never dup	LOAD a BSTR pointer (VB6 String) at [W-base+offset] via the procedure's secondary-object pointer [ebp+10h] (W-base) (4-byte (pointer)).
(4,93)	FDupStr	Other		never
(3,E7)	FMemStStr	Store	String, via frame pointer	emitted	Store String into a field reached through a pointer held in a frame slot.
(0,54)	FMemStStrCopy	Store	String, via frame pointer	emitted	Store a value of suffix ` via [frame[%a] + offset] (FMemStStrCopy`).
(3,F1)	FMemStStrCopy	Store	String, via frame pointer	never dup	Store a value of suffix ` via [frame[%a] + offset] (FMemStStrCopy`).
(0,31)	FStStr	Store	String, frame	emitted	Pop a BSTR (VB6 String); store into frame slot [ebp+%a].
(2,F7)	FStStr	Store	String, frame	never dup	Pop a BSTR (VB6 String); store into frame slot [ebp+%a].
(0,43)	FStStrCopy	Store	String, frame	emitted	Pop a value of suffix `; store into frame slot [ebp+%a]`.
(3,01)	FStStrCopy	Store	String, frame	never dup	Pop a value of suffix `; store into frame slot [ebp+%a]`.
(0,23)	FStStrNoPop	Store	String, frame	emitted	Pop a value of suffix `; store into frame slot [ebp+%a]`.
(3,64)	FStStrNoPop	Store	String, frame	never dup	Pop a value of suffix `; store into frame slot [ebp+%a]`.
(3,27)	IStStr	Store	String, ByRef/indirect	emitted	Pop value and address; write the BSTR (VB6 String) through the address.
(3,31)	IStStrCopy	Store	String, ByRef/indirect	emitted	Pop value and address; write the value of suffix `` through the address.
(3,57)	IWMemStStr	Store	String, W-base indirect	never	STORE through a BSTR pointer (VB6 String) at [W-base+offset] -> [eax], one extra dereference (4-byte (pointer), W+indirect).
(3,61)	IWMemStStrCopy	Store	String, W-base indirect	never	STORE through a value of suffix `` at [W-base+offset] -> [eax], one extra dereference (unknown-size, W+indirect).
(3,B7)	ImpAdStStr	Store	String, global	emitted	Store String into a module-level (global) variable.
(3,C1)	ImpAdStStrCopy	Store	String, global	emitted	Store String (copied) into a module-level (global) variable.
(3,87)	MemStStr	Store	String, member via pr	never
(3,91)	MemStStrCopy	Store	String, member via pr	emitted	Store a value of suffix ` into [pr + offset]` (pr on the stack).
(4,E7)	WMemStStr	Store	String, W-base	never	STORE a BSTR pointer (VB6 String) at [W-base+offset] via the procedure's secondary-object pointer [ebp+10h] (W-base) (4-byte (pointer)).
(4,F1)	WMemStStrCopy	Store	String, W-base	never	STORE a value of suffix `` at [W-base+offset] via the procedure's secondary-object pointer [ebp+10h] (W-base) (unknown-size).
(0,2A)	ConcatStr	String function	String/Variant	emitted	Concatenate the top two BSTR (VB6 String)s; push the result.
(1,F0)	ConcatStr	String function	String/Variant	never dup	(alias) Concatenate the top two BSTR (VB6 String)s; push the result.
(1,EF)	ConcatVar	String function	String/Variant	emitted	Concatenate (&) where at least one operand is a Variant; result Variant in a temporary.
(4,FD)	FnInStr4	String function	String/Variant	emitted	String built-in: FnInStr4.
(4,FE)	FnInStr4Var	String function	String/Variant	emitted	String built-in: FnInStr4Var.
(4,FB)	FnInStrB4	String function	String/Variant	emitted	String built-in: FnInStrB4.
(4,FC)	FnInStrB4Var	String function	String/Variant	emitted	InStrB with Variant operands; push the Variant result.
(1,EE)	FnLenBStr	String function	String/Variant	emitted	String built-in: FnLenBStr.
(1,ED)	FnLenBVar	String function	String/Variant	emitted	LenB() of a Variant; push the Variant result.
(0,4A)	FnLenStr	String function	String/Variant	emitted	String built-in: FnLenStr.
(1,EC)	FnLenStr	String function	String/Variant	never dup	(alias) String built-in: FnLenStr.
(1,EB)	FnLenVar	String function	String/Variant	emitted	String built-in: FnLenVar.
(4,FF)	FnStrComp3	String function	String/Variant	emitted	String built-in: FnStrComp3.
(5,00)	FnStrComp3Var	String function	String/Variant	emitted	StrComp(a, b, compare) with Variant operands; push the Variant result.
(0,33)	LdFixedStr	String function	fixed-length String	emitted	Load a fixed-length String as a normal (variable-length) String.
(4,61)	LdFixedStr	String function	fixed-length String	never dup	Load a fixed-length String as a normal (variable-length) String.
(2,BC)	MidBStr	String function	String/Variant	never dup	Mid statement: replace characters inside a String variable.
(2,BE)	MidBStrB	String function	String/Variant	emitted	MidB statement: replace bytes inside a String variable.
(2,BD)	MidBVar	String function	String/Variant	emitted	String built-in: MidBVar.
(0,4F)	MidStr	String function	String/Variant	emitted	Mid statement: replace characters inside a String variable.
(2,BB)	MidVar	String function	String/Variant	emitted	String built-in: MidVar.
(0,47)	StFixedStr	String function	fixed-length String	emitted	Fixed-length string operation (StFixedStr).
(4,0F)	StFixedStrFree	String function	fixed-length String	emitted	Store a String temporary into a fixed-length String and free the temporary.
(4,1E)	StFixedStrR	String function	fixed-length String	emitted	RSet into a fixed-length String.
(4,1F)	StFixedStrRFree	String function	fixed-length String	emitted	RSet into a fixed-length String from a temporary, then free the temporary.
(4,0E)	StLsetFixStr	String function	fixed-length String	never dup	Fixed-length string operation (StFixedStr).

Integer 196 slots, 103 distinct handlers, 96 emitted

Byte, Integer/Boolean and Long values: arithmetic, logic, compares, loads/stores (including the raw 4-byte R4 moves used for Long) and integer For loops.

Slot	Mnemonic	Operation	Types	Status	Summary
(0,A9)	AddI2	Arithmetic	Integer/Boolean	emitted	Pop two 16-bit signed integer (VB6 Integer) values; push their addition result.
(1,8F)	AddI2	Arithmetic	Integer/Boolean	never dup	(alias) Pop two 16-bit signed integer (VB6 Integer) values; push their addition result.
(0,AA)	AddI4	Arithmetic	Long	emitted	Pop two 32-bit signed integer (VB6 Long) values; push their addition result.
(1,90)	AddI4	Arithmetic	Long	never dup	(alias) Pop two 32-bit signed integer (VB6 Long) values; push their addition result.
(1,8E)	AddUI1	Arithmetic	Byte	emitted	Pop two 8-bit unsigned integer (VB6 Byte) values; push their addition result.
(0,BF)	IDvI2	Arithmetic	Integer/Boolean	emitted	Pop two 16-bit signed integer (VB6 Integer) values; push their integer division (truncated) result.
(1,A7)	IDvI2	Arithmetic	Integer/Boolean	never dup	(alias) Pop two 16-bit signed integer (VB6 Integer) values; push their integer division (truncated) result.
(0,C0)	IDvI4	Arithmetic	Long	emitted	Pop two 32-bit signed integer (VB6 Long) values; push their integer division (truncated) result.
(1,A8)	IDvI4	Arithmetic	Long	never dup	(alias) Pop two 32-bit signed integer (VB6 Long) values; push their integer division (truncated) result.
(1,A6)	IDvUI1	Arithmetic	Byte	emitted	Pop two 8-bit unsigned integer (VB6 Byte) values; push their integer division (truncated) result.
(0,C1)	ModI2	Arithmetic	Integer/Boolean	emitted	Pop two 16-bit signed integer (VB6 Integer) values; push their modulo result.
(1,9F)	ModI2	Arithmetic	Integer/Boolean	never dup	(alias) Pop two 16-bit signed integer (VB6 Integer) values; push their modulo result.
(0,C2)	ModI4	Arithmetic	Long	emitted	Pop two 32-bit signed integer (VB6 Long) values; push their modulo result.
(1,A0)	ModI4	Arithmetic	Long	never dup	(alias) Pop two 32-bit signed integer (VB6 Long) values; push their modulo result.
(1,9E)	ModUI1	Arithmetic	Byte	emitted	Pop two 8-bit unsigned integer (VB6 Byte) values; push their modulo result.
(0,B1)	MulI2	Arithmetic	Integer/Boolean	emitted	Pop two 16-bit signed integer (VB6 Integer) values; push their multiplication result.
(1,AF)	MulI2	Arithmetic	Integer/Boolean	never dup	(alias) Pop two 16-bit signed integer (VB6 Integer) values; push their multiplication result.
(0,B2)	MulI4	Arithmetic	Long	emitted	Pop two 32-bit signed integer (VB6 Long) values; push their multiplication result.
(1,B0)	MulI4	Arithmetic	Long	never dup	(alias) Pop two 32-bit signed integer (VB6 Long) values; push their multiplication result.
(1,AE)	MulUI1	Arithmetic	Byte	emitted	Pop two 8-bit unsigned integer (VB6 Byte) values; push their multiplication result.
(0,AD)	SubI2	Arithmetic	Integer/Boolean	emitted	Pop two 16-bit signed integer (VB6 Integer) values; push their subtraction result.
(1,97)	SubI2	Arithmetic	Integer/Boolean	never dup	(alias) Pop two 16-bit signed integer (VB6 Integer) values; push their subtraction result.
(0,AE)	SubI4	Arithmetic	Long	emitted	Pop two 32-bit signed integer (VB6 Long) values; push their subtraction result.
(1,98)	SubI4	Arithmetic	Long	never dup	(alias) Pop two 32-bit signed integer (VB6 Long) values; push their subtraction result.
(1,96)	SubUI1	Arithmetic	Byte	emitted	Pop two 8-bit unsigned integer (VB6 Byte) values; push their subtraction result.
(0,B7)	UMiI2	Arithmetic	Integer/Boolean	emitted	Pop one 16-bit signed integer (VB6 Integer); push its arithmetic negation.
(1,C7)	UMiI2	Arithmetic	Integer/Boolean	never dup	(alias) Pop one 16-bit signed integer (VB6 Integer); push its arithmetic negation.
(1,C8)	UMiI2	Arithmetic	Integer/Boolean	never dup	Negate a 32-bit value (handler behaves as UMiI4 despite the UMiI2 name); never emitted.
(0,B8)	UMiI4	Arithmetic	Long	emitted	Pop one 32-bit signed integer (VB6 Long); push its arithmetic negation.
(4,63)	ForI2	Branch/loop	For loop, Integer/Boolean counter	emitted	Initialise a For loop with a Integer counter.
(4,64)	ForI4	Branch/loop	For loop, Long counter	emitted	Initialize a For loop (ForI4).
(4,6B)	ForStepI2	Branch/loop	For loop, Integer/Boolean counter	emitted	Initialise a For loop with a Integer counter and an explicit Step.
(4,6C)	ForStepI4	Branch/loop	For loop, Long counter	emitted	Initialise a For loop with a Long counter and an explicit Step.
(4,6A)	ForStepUI1	Branch/loop	For loop, Byte counter	emitted	Initialise a For loop with a Byte counter and explicit Step.
(4,62)	ForUI1	Branch/loop	For loop, Byte counter	emitted	Initialise a For loop with a Byte counter.
(0,64)	NextI2	Branch/loop	For loop, Integer/Boolean counter	emitted	Next of a For loop with a Integer counter.
(4,79)	NextI2	Branch/loop	For loop, Integer/Boolean counter	never dup	Next of a For loop with a Integer counter.
(0,66)	NextI4	Branch/loop	For loop, Long counter	emitted	Next of a For loop with a Long counter.
(4,7A)	NextI4	Branch/loop	For loop, Long counter	never dup	Next of a For loop with a Long counter.
(0,65)	NextStepI2	Branch/loop	For loop, Integer/Boolean counter	emitted	Next of a For loop with a Integer counter and an explicit Step.
(4,81)	NextStepI2	Branch/loop	For loop, Integer/Boolean counter	never dup	Next of a For loop with a Integer counter and an explicit Step.
(0,67)	NextStepI4	Branch/loop	For loop, Long counter	emitted	Next of a For loop with a Long counter and an explicit Step.
(4,82)	NextStepI4	Branch/loop	For loop, Long counter	never dup	Next of a For loop with a Long counter and an explicit Step.
(4,80)	NextStepUI1	Branch/loop	For loop, Byte counter	emitted dup	Next for a Byte loop counter with Step.
(4,78)	NextUI1	Branch/loop	For loop, Byte counter	emitted	Next for a Byte loop counter.
(1,85)	BetweenI2	Compare	Integer/Boolean	emitted	Case lo To hi range test on a Integer selector; push Boolean.
(1,86)	BetweenI4	Compare	Long	emitted	Case lo To hi range test on a Long selector; push Boolean.
(1,84)	BetweenUI1	Compare	Byte	emitted	Case lo To hi range test on a Byte selector; push Boolean.
(0,C6)	EqI2	Compare	Integer/Boolean	emitted	Compare two values with =; push Boolean result.
(1,29)	EqI2	Compare	Integer/Boolean	never dup	(alias) Compare two values with =; push Boolean result.
(1,2A)	EqI2	Compare	Integer/Boolean	never dup	(alias) Compare two values with =; push Boolean result.
(0,C7)	EqI4	Compare	Long	emitted	Compare two values with =; push Boolean result.
(1,2B)	EqI4	Compare	Long	never dup	(alias) Compare two values with =; push Boolean result.
(0,DF)	GeI2	Compare	Integer/Boolean	emitted	Compare two values with >=; push Boolean result.
(1,51)	GeI2	Compare	Integer/Boolean	never dup	(alias) Compare two values with >=; push Boolean result.
(0,E0)	GeI4	Compare	Long	emitted	Compare two values with >=; push Boolean result.
(1,52)	GeI4	Compare	Long	never dup	(alias) Compare two values with >=; push Boolean result.
(1,50)	GeUI1	Compare	Byte	emitted	Compare two values with >=; push Boolean result.
(0,DA)	GtI2	Compare	Integer/Boolean	emitted	Compare two values with >; push Boolean result.
(1,6B)	GtI2	Compare	Integer/Boolean	never dup	(alias) Compare two values with >; push Boolean result.
(0,DB)	GtI4	Compare	Long	emitted	Compare two values with >; push Boolean result.
(1,6C)	GtI4	Compare	Long	never dup	(alias) Compare two values with >; push Boolean result.
(1,6A)	GtUI1	Compare	Byte	emitted	Compare two values with >; push Boolean result.
(0,D5)	LeI2	Compare	Integer/Boolean	emitted	Compare two values with <=; push Boolean result.
(1,44)	LeI2	Compare	Integer/Boolean	never dup	(alias) Compare two values with <=; push Boolean result.
(0,D6)	LeI4	Compare	Long	emitted	Compare two values with <=; push Boolean result.
(1,45)	LeI4	Compare	Long	never dup	(alias) Compare two values with <=; push Boolean result.
(1,43)	LeUI1	Compare	Byte	emitted	Compare two values with <=; push Boolean result.
(0,D0)	LtI2	Compare	Integer/Boolean	emitted	Compare two values with <; push Boolean result.
(1,5E)	LtI2	Compare	Integer/Boolean	never dup	(alias) Compare two values with <; push Boolean result.
(0,D1)	LtI4	Compare	Long	emitted	Compare two values with <; push Boolean result.
(1,5F)	LtI4	Compare	Long	never dup	(alias) Compare two values with <; push Boolean result.
(1,5D)	LtUI1	Compare	Byte	emitted	Compare two values with <; push Boolean result.
(0,CB)	NeI2	Compare	Integer/Boolean	emitted	Compare two values with <>; push Boolean result.
(0,CC)	NeI4	Compare	Long	emitted	Compare two values with <>; push Boolean result.
(1,38)	NeI4	Compare	Long	never dup	(alias) Compare two values with <>; push Boolean result.
(1,36)	NeUI1	Compare	Byte	never dup	Compare two values with <>; push Boolean result.
(1,37)	NeUI1	Compare	Byte	never dup	(alias) Compare two values with <>; push Boolean result.
(0,F3)	LitI2	Literal	Integer/Long	emitted	(alias) Push a 16-bit Integer literal.
(4,B5)	LitI2	Literal	Integer/Long	never dup	(alias) Push a 16-bit Integer literal.
(0,F8)	LitI2FP	Literal	Integer/Long	never
(4,B6)	LitI2FP	Literal	Integer/Long	never dup
(0,F4)	LitI2_Byte	Literal	Integer/Long	emitted	Push a 1-byte immediate sign-extended to Integer.
(5,1A)	LitI2_Byte	Literal	Integer/Long	never dup	Push a 1-byte immediate sign-extended to Integer.
(0,F5)	LitI4	Literal	Integer/Long	emitted	Push a 32-bit Long literal.
(4,B8)	LitI4	Literal	Integer/Long	never dup	Push a 32-bit Long literal.
(4,B9)	LitI4	Literal	Integer/Long	never dup	Push a 32-bit Long literal.
(0,6B)	FLdI2	Load	Integer/Boolean, frame	emitted	Frame-relative load: FLdI2.
(2,E1)	FLdI2	Load	Integer/Boolean, frame	never dup	Frame-relative load: FLdI2.
(2,E2)	FLdR4	Load	4-byte raw (Long), frame	never dup	Re-load the pointer held in a ByRef frame slot [ebp+%a]; push it as a typed reference.
(2,E3)	FLdR4	Load	4-byte raw (Long), frame	never dup	Re-load the pointer held in a ByRef frame slot [ebp+%a]; push it as a typed reference.
(2,E7)	FLdR4	Load	4-byte raw (Long), frame	never dup	Re-load the pointer held in a ByRef frame slot [ebp+%a]; push it as a typed reference.
(2,E8)	FLdR4	Load	4-byte raw (Long), frame	never dup	Re-load the pointer held in a ByRef frame slot [ebp+%a]; push it as a typed reference.
(3,1C)	FLdR4	Load	4-byte raw (Long), frame	never dup	Re-load the pointer held in a ByRef frame slot [ebp+%a]; push it as a typed reference.
(2,E0)	FLdUI1	Load	Byte, frame	emitted	Frame-relative load: FLdUI1.
(0,93)	FMemLdI2	Load	Integer/Boolean, via frame pointer	emitted	Load a 16-bit signed integer (VB6 Integer) via [frame[%a] + offset] (FMemLdI2).
(3,D1)	FMemLdI2	Load	Integer/Boolean, via frame pointer	never dup	Load a 16-bit signed integer (VB6 Integer) via [frame[%a] + offset] (FMemLdI2).
(0,94)	FMemLdR4	Load	4-byte raw (Long), via frame pointer	emitted	Load a 4-byte value through a pointer held in a frame slot plus offset (FMem); not a Single-specific opcode.
(3,D2)	FMemLdR4	Load	4-byte raw (Long), via frame pointer	never dup	Load a 4-byte value through a pointer held in a frame slot plus offset (FMem); not a Single-specific opcode.
(3,D3)	FMemLdR4	Load	4-byte raw (Long), via frame pointer	never dup	Load a 4-byte value through a pointer held in a frame slot plus offset (FMem); not a Single-specific opcode.
(3,D7)	FMemLdR4	Load	4-byte raw (Long), via frame pointer	never dup	Load a 4-byte value through a pointer held in a frame slot plus offset (FMem); not a Single-specific opcode.
(3,D8)	FMemLdR4	Load	4-byte raw (Long), via frame pointer	never dup	Load a 4-byte value through a pointer held in a frame slot plus offset (FMem); not a Single-specific opcode.
(3,D0)	FMemLdUI1	Load	Byte, via frame pointer	emitted	Load Byte from a field reached through a pointer held in a frame slot.
(0,7F)	ILdI2	Load	Integer/Boolean, ByRef/indirect	emitted	Pop an address; push the 16-bit signed integer (VB6 Integer) read from it.
(3,11)	ILdI2	Load	Integer/Boolean, ByRef/indirect	never dup	Pop an address; push the 16-bit signed integer (VB6 Integer) read from it.
(0,80)	ILdI4	Load	Long, ByRef/indirect	emitted	Pop an address; push the 32-bit signed integer (VB6 Long) read from it.
(3,12)	ILdI4	Load	Long, ByRef/indirect	never dup	Pop an address; push the 32-bit signed integer (VB6 Long) read from it.
(3,13)	ILdI4	Load	Long, ByRef/indirect	never dup	Pop an address; push the 32-bit signed integer (VB6 Long) read from it.
(3,17)	ILdI4	Load	Long, ByRef/indirect	never dup	Pop an address; push the 32-bit signed integer (VB6 Long) read from it.
(3,18)	ILdI4	Load	Long, ByRef/indirect	never dup	Pop an address; push the 32-bit signed integer (VB6 Long) read from it.
(3,10)	ILdUI1	Load	Byte, ByRef/indirect	emitted	Pop an address; push the 8-bit unsigned integer (VB6 Byte) read from it.
(3,41)	IWMemLdI2	Load	Integer/Boolean, W-base indirect	never	LOAD through a 16-bit signed integer (VB6 Integer) at [W-base+offset] -> [eax], one extra dereference (2-byte, W+indirect).
(3,42)	IWMemLdI4	Load	Long, W-base indirect	never	LOAD through a 32-bit signed integer (VB6 Long) at [W-base+offset] -> [eax], one extra dereference (4-byte, W+indirect).
(3,43)	IWMemLdI4	Load	Long, W-base indirect	never dup	LOAD through a 32-bit signed integer (VB6 Long) at [W-base+offset] -> [eax], one extra dereference (4-byte, W+indirect).
(3,47)	IWMemLdI4	Load	Long, W-base indirect	never dup	LOAD through a 32-bit signed integer (VB6 Long) at [W-base+offset] -> [eax], one extra dereference (4-byte, W+indirect).
(3,48)	IWMemLdI4	Load	Long, W-base indirect	never dup	LOAD through a 32-bit signed integer (VB6 Long) at [W-base+offset] -> [eax], one extra dereference (4-byte, W+indirect).
(3,40)	IWMemLdUI1	Load	Byte, W-base indirect	never	LOAD through a 8-bit unsigned (VB6 Byte) at [W-base+offset] -> [eax], one extra dereference (1-byte, W+indirect).
(0,75)	ImpAdLdI2	Load	Integer/Boolean, global	emitted	Load Integer/Boolean from a module-level (global) variable.
(3,A1)	ImpAdLdI2	Load	Integer/Boolean, global	never dup	Load Integer/Boolean from a module-level (global) variable.
(0,76)	ImpAdLdI4	Load	Long, global	emitted	Load Long from a module-level (global) variable.
(3,A0)	ImpAdLdUI1	Load	Byte, global	emitted	Load Byte from a module-level (global) variable.
(0,89)	MemLdI2	Load	Integer/Boolean, member via pr	emitted	(alias) Load a 16-bit signed integer (VB6 Integer) from [pr + offset] where pr is on the stack.
(3,71)	MemLdI2	Load	Integer/Boolean, member via pr	never dup	(alias) Load a 16-bit signed integer (VB6 Integer) from [pr + offset] where pr is on the stack.
(3,72)	MemLdR4	Load	4-byte raw (Long), member via pr	never dup	Load a BSTR (VB6 String) from [pr + offset] where pr is on the stack.
(3,73)	MemLdR4	Load	4-byte raw (Long), member via pr	never dup	Load a BSTR (VB6 String) from [pr + offset] where pr is on the stack.
(3,77)	MemLdR4	Load	4-byte raw (Long), member via pr	never dup	Load a BSTR (VB6 String) from [pr + offset] where pr is on the stack.
(3,78)	MemLdR4	Load	4-byte raw (Long), member via pr	never dup	Load a BSTR (VB6 String) from [pr + offset] where pr is on the stack.
(3,70)	MemLdUI1	Load	Byte, member via pr	emitted	Load a 8-bit unsigned integer (VB6 Byte) from [pr + offset] where pr is on the stack.
(4,D1)	WMemLdI2	Load	Integer/Boolean, W-base	never	LOAD a 16-bit signed integer (VB6 Integer) at [W-base+offset] via the procedure's secondary-object pointer [ebp+10h] (W-base) (2-byte).
(4,D0)	WMemLdUI1	Load	Byte, W-base	never	LOAD a 8-bit unsigned (VB6 Byte) at [W-base+offset] via the procedure's secondary-object pointer [ebp+10h] (W-base) (1-byte).
(0,C4)	AndI4	Logic	Long	emitted	Pop operand(s); push bitwise And.
(1,21)	AndUI1	Logic	Byte	never dup	Pop operand(s); push bitwise And.
(1,22)	AndUI1	Logic	Byte	never dup	(alias) Pop operand(s); push bitwise And.
(1,23)	AndUI1	Logic	Byte	never dup	(alias) Pop operand(s); push bitwise And.
(1,0A)	EqvI4	Logic	Long	emitted	Pop two operands; push the bitwise equivalence (Eqv).
(1,0B)	EqvI4	Logic	Long	emitted dup	(alias) Pop two operands; push the bitwise equivalence (Eqv).
(1,09)	EqvUI1	Logic	Byte	emitted	Pop two operands; push the bitwise equivalence (Eqv).
(1,02)	ImpI4	Logic	Long	emitted	Pop two operands; push the logical implication (Imp).
(1,03)	ImpI4	Logic	Long	emitted dup	(alias) Pop two operands; push the logical implication (Imp).
(1,01)	ImpUI1	Logic	Byte	emitted	Pop two operands; push the logical implication (Imp).
(0,C3)	NotI4	Logic	Long	emitted	Pop operand(s); push bitwise Not.
(1,BF)	NotI4	Logic	Long	never dup	(alias) Pop operand(s); push bitwise Not.
(1,C0)	NotI4	Logic	Long	never dup	(alias) Pop operand(s); push bitwise Not.
(1,BE)	NotUI1	Logic	Byte	emitted	Pop operand(s); push bitwise Not.
(1,19)	OrI2	Logic	Integer/Boolean	never dup	Pop operand(s); push bitwise Or.
(1,1A)	OrI2	Logic	Integer/Boolean	never dup	(alias) Pop operand(s); push bitwise Or.
(1,1B)	OrI2	Logic	Integer/Boolean	never dup	(alias) Pop operand(s); push bitwise Or.
(0,C5)	OrI4	Logic	Long	emitted	Pop operand(s); push bitwise Or.
(1,11)	XorI4	Logic	Long	emitted dup	Pop operand(s); push bitwise Xor.
(1,12)	XorI4	Logic	Long	emitted	(alias) Pop operand(s); push bitwise Xor.
(1,13)	XorI4	Logic	Long	emitted dup	(alias) Pop operand(s); push bitwise Xor.
(0,BB)	FnAbsI2	Math function	Integer/Boolean	emitted	Pop one 16-bit signed integer (VB6 Integer); push its absolute value.
(1,D4)	FnAbsI2	Math function	Integer/Boolean	never dup	(alias) Pop one 16-bit signed integer (VB6 Integer); push its absolute value.
(0,BC)	FnAbsI4	Math function	Long	emitted	Pop one 32-bit signed integer (VB6 Long); push its absolute value.
(1,D5)	FnAbsI4	Math function	Long	never dup	(alias) Pop one 32-bit signed integer (VB6 Long); push its absolute value.
(1,F4)	FnSgnI4	Math function	Long	emitted	Sgn() of a Long value; push an Integer (-1, 0 or 1).
(1,F2)	FnSgnUI1	Math function	Byte	never dup	(duplicate slot of (1,F3) FnSgnUI1) (alias) Pop one 8-bit unsigned integer (VB6 Byte); push its absolute value.
(1,F3)	FnSgnUI1	Math function	Byte	emitted	Sgn() of a Integer, Boolean or Byte value; push an Integer (-1, 0 or 1).
(0,98)	FMemStI2	Store	Integer/Boolean, via frame pointer	emitted	Store a 16-bit signed integer (VB6 Integer) via [frame[%a] + offset] (FMemStI2).
(3,E1)	FMemStI2	Store	Integer/Boolean, via frame pointer	never dup	Store a 16-bit signed integer (VB6 Integer) via [frame[%a] + offset] (FMemStI2).
(0,99)	FMemStI4	Store	Long, via frame pointer	emitted	Store a 32-bit signed integer (VB6 Long) via [frame[%a] + offset] (FMemStI4).
(3,E2)	FMemStR4	Store	4-byte raw (Long), via frame pointer	never dup	Store a 32-bit signed integer (VB6 Long) via [frame[%a] + offset] (FMemStI4).
(3,E3)	FMemStR4	Store	4-byte raw (Long), via frame pointer	never dup	Store a 32-bit signed integer (VB6 Long) via [frame[%a] + offset] (FMemStI4).
(3,E0)	FMemStUI1	Store	Byte, via frame pointer	emitted	Store Byte into a field reached through a pointer held in a frame slot.
(0,70)	FStI2	Store	Integer/Boolean, frame	emitted	Pop a 16-bit signed integer (VB6 Integer); store into frame slot [ebp+%a].
(2,F1)	FStI2	Store	Integer/Boolean, frame	never dup	Pop a 16-bit signed integer (VB6 Integer); store into frame slot [ebp+%a].
(0,71)	FStR4	Store	4-byte raw (Long), frame	emitted	Pop a 4-byte value and store it into a frame slot (Long locals; not Single).
(2,F2)	FStR4	Store	4-byte raw (Long), frame	never dup	Pop a 4-byte value and store it into a frame slot (Long locals; not Single).
(2,F3)	FStR4	Store	4-byte raw (Long), frame	never dup	Pop a 4-byte value and store it into a frame slot (Long locals; not Single).
(2,F0)	FStUI1	Store	Byte, frame	emitted	Pop a 8-bit unsigned integer (VB6 Byte); store into frame slot [ebp+%a].
(0,84)	IStI2	Store	Integer/Boolean, ByRef/indirect	emitted	Pop value and address; write the 16-bit signed integer (VB6 Integer) through the address.
(3,21)	IStI2	Store	Integer/Boolean, ByRef/indirect	never dup	Pop value and address; write the 16-bit signed integer (VB6 Integer) through the address.
(0,85)	IStI4	Store	Long, ByRef/indirect	emitted	Pop value and address; write the 32-bit signed integer (VB6 Long) through the address.
(3,22)	IStI4	Store	Long, ByRef/indirect	never dup	Pop value and address; write the 32-bit signed integer (VB6 Long) through the address.
(3,23)	IStI4	Store	Long, ByRef/indirect	never dup	Pop value and address; write the 32-bit signed integer (VB6 Long) through the address.
(3,20)	IStUI1	Store	Byte, ByRef/indirect	emitted	Pop value and address; write the 8-bit unsigned integer (VB6 Byte) through the address.
(3,51)	IWMemStI2	Store	Integer/Boolean, W-base indirect	never	STORE through a 16-bit signed integer (VB6 Integer) at [W-base+offset] -> [eax], one extra dereference (2-byte, W+indirect).
(3,52)	IWMemStR4	Store	4-byte raw (Long), W-base indirect	never	Store a raw 4-byte value at [W-base + offset] plus one extra dereference (W-base = dispatcher argument [ebp+10h]); not a floating-point store.
(3,53)	IWMemStR4	Store	4-byte raw (Long), W-base indirect	never dup	Store a raw 4-byte value at [W-base + offset] plus one extra dereference (W-base = dispatcher argument [ebp+10h]); not a floating-point store.
(3,50)	IWMemStUI1	Store	Byte, W-base indirect	never	STORE through a 8-bit unsigned (VB6 Byte) at [W-base+offset] -> [eax], one extra dereference (1-byte, W+indirect).
(0,7A)	ImpAdStI2	Store	Integer/Boolean, global	emitted	Store Integer/Boolean into a module-level (global) variable.
(3,B1)	ImpAdStI2	Store	Integer/Boolean, global	never dup	Store Integer/Boolean into a module-level (global) variable.
(0,7B)	ImpAdStR4	Store	4-byte raw (Long), global	emitted	Store 4-byte value into a module-level (global) variable.
(3,B2)	ImpAdStR4	Store	4-byte raw (Long), global	never dup	Store 4-byte value into a module-level (global) variable.
(3,B3)	ImpAdStR4	Store	4-byte raw (Long), global	never dup	Store 4-byte value into a module-level (global) variable.
(3,B0)	ImpAdStUI1	Store	Byte, global	emitted	Store Byte into a module-level (global) variable.
(0,8E)	MemStI2	Store	Integer/Boolean, member via pr	emitted	(alias) Store a 16-bit signed integer (VB6 Integer) into [pr + offset] (pr on the stack).
(3,81)	MemStI2	Store	Integer/Boolean, member via pr	never dup	(alias) Store a 16-bit signed integer (VB6 Integer) into [pr + offset] (pr on the stack).
(0,8F)	MemStI4	Store	Long, member via pr	emitted	Store a 32-bit signed integer (VB6 Long) into [pr + offset] (pr on the stack).
(3,82)	MemStR4	Store	4-byte raw (Long), member via pr	never dup	Store a 32-bit signed integer (VB6 Long) into [pr + offset] (pr on the stack).
(3,83)	MemStR4	Store	4-byte raw (Long), member via pr	never dup	Store a 32-bit signed integer (VB6 Long) into [pr + offset] (pr on the stack).
(3,80)	MemStUI1	Store	Byte, member via pr	emitted	Store a 8-bit unsigned integer (VB6 Byte) into [pr + offset] (pr on the stack).
(4,E1)	WMemStI2	Store	Integer/Boolean, W-base	never	STORE a 16-bit signed integer (VB6 Integer) at [W-base+offset] via the procedure's secondary-object pointer [ebp+10h] (W-base) (2-byte).
(4,E2)	WMemStR4	Store	4-byte raw (Long), W-base	never	Store a raw 4-byte value at [W-base + offset] (W-base = dispatcher argument [ebp+10h]); not a floating-point store.
(4,E3)	WMemStR4	Store	4-byte raw (Long), W-base	never dup	Store a raw 4-byte value at [W-base + offset] (W-base = dispatcher argument [ebp+10h]); not a floating-point store.
(4,E0)	WMemStUI1	Store	Byte, W-base	never	STORE a 8-bit unsigned (VB6 Byte) at [W-base+offset] via the procedure's secondary-object pointer [ebp+10h] (W-base) (1-byte).

Floating point 111 slots, 54 distinct handlers, 49 emitted

Single, Double and Date values carried on the FPU: arithmetic, compares, FPR4/FPR8 loads and stores, float literals and loops.

Slot	Mnemonic	Operation	Types	Status	Summary
(1,91)	AddR4	Arithmetic	Single	never dup	Pop two 32-bit IEEE 754 float (VB6 Single) values; push their addition result.
(1,92)	AddR4	Arithmetic	Single	never dup	(alias) Pop two 32-bit IEEE 754 float (VB6 Single) values; push their addition result.
(0,AB)	AddR8	Arithmetic	Double	emitted	Pop two 64-bit IEEE 754 float (VB6 Double) values; push their addition result.
(0,B6)	DivR8	Arithmetic	Double	emitted	Pop two 64-bit IEEE 754 float (VB6 Double) values; push their floating-point division result.
(1,B9)	DivR8	Arithmetic	Double	never dup	(alias) Pop two 64-bit IEEE 754 float (VB6 Double) values; push their floating-point division result.
(1,BA)	DivR8	Arithmetic	Double	never dup	(alias) Pop two 64-bit IEEE 754 float (VB6 Double) values; push their floating-point division result.
(1,B1)	MulR4	Arithmetic	Single	never dup	Pop two 32-bit IEEE 754 float (VB6 Single) values; push their multiplication result.
(1,B2)	MulR4	Arithmetic	Single	never dup	(alias) Pop two 32-bit IEEE 754 float (VB6 Single) values; push their multiplication result.
(0,B3)	MulR8	Arithmetic	Double	emitted	Pop two 64-bit IEEE 754 float (VB6 Double) values; push their multiplication result.
(1,D0)	PwrR8I2	Arithmetic	Double x Integer/Boolean	never	Raise a Double to an Integer power; never emitted.
(1,CF)	PwrR8R8	Arithmetic	Double x Double	emitted	Pop two 64-bit IEEE 754 float (VB6 Double) values; push their exponentiation result.
(0,AF)	SubR8	Arithmetic	Double	emitted	Pop two 64-bit IEEE 754 float (VB6 Double) values; push their subtraction result.
(1,99)	SubR8	Arithmetic	Double	never dup	(alias) Pop two 64-bit IEEE 754 float (VB6 Double) values; push their subtraction result.
(1,9A)	SubR8	Arithmetic	Double	never dup	(alias) Pop two 64-bit IEEE 754 float (VB6 Double) values; push their subtraction result.
(1,C9)	UMiR4	Arithmetic	Single	never dup	Pop one 32-bit IEEE 754 float (VB6 Single); push its arithmetic negation.
(1,CA)	UMiR4	Arithmetic	Single	never dup	(alias) Pop one 32-bit IEEE 754 float (VB6 Single); push its arithmetic negation.
(0,B9)	UMiR8	Arithmetic	Double	emitted	Pop one 64-bit IEEE 754 float (VB6 Double); push its arithmetic negation.
(4,65)	ForR4	Branch/loop	For loop, Single counter	emitted	Initialise a For loop with a Single counter.
(4,66)	ForR8	Branch/loop	For loop, Double counter	emitted	Initialise a For loop with a Double counter.
(4,6D)	ForStepR4	Branch/loop	For loop, Single counter	emitted	Initialise a For loop with a Single counter and explicit Step.
(4,6E)	ForStepR8	Branch/loop	For loop, Double counter	emitted	Initialise a For loop with a Double counter and explicit Step.
(4,7C)	NextR8	Branch/loop	For loop, Double counter	never dup	Next for a Double loop counter with Step.
(4,84)	NextR8	Branch/loop	For loop, Double counter	never dup	Next for a Double loop counter with Step.
(0,68)	NextStepR4	Branch/loop	For loop, Single counter	emitted	Next for a Single loop counter with Step.
(4,7B)	NextStepR4	Branch/loop	For loop, Single counter	never dup	Next for a Single loop counter with Step.
(4,83)	NextStepR4	Branch/loop	For loop, Single counter	never dup	Next for a Single loop counter with Step.
(0,69)	NextStepR8	Branch/loop	For loop, Double counter	emitted	Next for a Double loop counter with Step.
(1,87)	BetweenR4	Compare	Single	emitted	Case lo To hi range test on a Single selector; push Boolean.
(1,88)	BetweenR4	Compare	Single	emitted dup	Case lo To hi range test on a Double selector; push Boolean.
(0,C8)	EqR8	Compare	Double	emitted	Compare two values with =; push Boolean result.
(1,2C)	EqR8	Compare	Double	never dup	(alias) Compare two values with =; push Boolean result.
(1,2D)	EqR8	Compare	Double	never dup	(alias) Compare two values with =; push Boolean result.
(1,53)	GeR4	Compare	Single	never dup	Compare two values with >=; push Boolean result.
(1,54)	GeR4	Compare	Single	never dup	(alias) Compare two values with >=; push Boolean result.
(0,E1)	GeR8	Compare	Double	emitted	Compare two values with >=; push Boolean result.
(0,DC)	GtR8	Compare	Double	emitted	Compare two values with >; push Boolean result.
(1,6D)	GtR8	Compare	Double	never dup	(alias) Compare two values with >; push Boolean result.
(1,6E)	GtR8	Compare	Double	never dup	(alias) Compare two values with >; push Boolean result.
(1,46)	LeR4	Compare	Single	never dup	Compare two values with <=; push Boolean result.
(1,47)	LeR4	Compare	Single	never dup	(alias) Compare two values with <=; push Boolean result.
(0,D7)	LeR8	Compare	Double	emitted	Compare two values with <=; push Boolean result.
(1,60)	LtR4	Compare	Single	never dup	Compare two values with <; push Boolean result.
(1,61)	LtR4	Compare	Single	never dup	(alias) Compare two values with <; push Boolean result.
(0,D2)	LtR8	Compare	Double	emitted	Compare two values with <; push Boolean result.
(1,39)	NeR4	Compare	Single	never dup	Compare two values with <>; push Boolean result.
(1,3A)	NeR4	Compare	Single	never dup	(alias) Compare two values with <>; push Boolean result.
(0,CD)	NeR8	Compare	Double	emitted	Compare two values with <>; push Boolean result.
(0,FA)	LitDate	Literal	Double/Date (FPU)	emitted	Push an 8-byte floating-point literal onto the FPU (Double and Date literals).
(0,F9)	LitR4FP	Literal	Single (FPU)	emitted	Push a 4-byte Single literal onto the FPU.
(4,BA)	LitR4FP	Literal	Single (FPU)	never dup	Push a 4-byte Single literal onto the FPU.
(4,BB)	LitR8	Literal	Double	never dup	Push an 8-byte literal (Currency literals; also raw 8-byte double payloads).
(4,BC)	LitR8	Literal	Double	never dup	Push an 8-byte literal (Currency literals; also raw 8-byte double payloads).
(4,BD)	LitR8FP	Literal	Double (FPU)	never dup	Push an 8-byte floating-point literal onto the FPU (Double and Date literals).
(4,BE)	LitR8FP	Literal	Double (FPU)	never dup	Push an 8-byte floating-point literal onto the FPU (Double and Date literals).
(0,6E)	FLdFPR4	Load	Single (FPU), frame	emitted	Frame-relative load: FLdFPR4.
(2,E9)	FLdFPR4	Load	Single (FPU), frame	never dup	Frame-relative load: FLdFPR4.
(0,6F)	FLdFPR8	Load	Double/Date (FPU), frame	emitted	Frame-relative load: FLdFPR8.
(2,EA)	FLdFPR8	Load	Double/Date (FPU), frame	never dup	Frame-relative load: FLdFPR8.
(0,96)	FMemLdFPR4	Load	Single (FPU), via frame pointer	emitted	Load Single from a field reached through a pointer held in a frame slot.
(3,D9)	FMemLdFPR4	Load	Single (FPU), via frame pointer	never dup	Load Single from a field reached through a pointer held in a frame slot.
(0,97)	FMemLdFPR8	Load	Double/Date (FPU), via frame pointer	emitted	Load Double/Date from a field reached through a pointer held in a frame slot.
(3,DA)	FMemLdFPR8	Load	Double/Date (FPU), via frame pointer	never dup	Load Double/Date from a field reached through a pointer held in a frame slot.
(0,82)	ILdFPR4	Load	Single (FPU), ByRef/indirect	emitted	Pop an address; push the Single on the x87 FPU stack read from it.
(3,19)	ILdFPR4	Load	Single (FPU), ByRef/indirect	never dup	Pop an address; push the Single on the x87 FPU stack read from it.
(0,83)	ILdFPR8	Load	Double/Date (FPU), ByRef/indirect	emitted	Load Double/Date from the variable a ByRef argument (or other frame-held pointer) points to.
(3,1A)	ILdFPR8	Load	Double/Date (FPU), ByRef/indirect	never dup	Load Double/Date from the variable a ByRef argument (or other frame-held pointer) points to.
(3,49)	IWMemLdFPR4	Load	Single (FPU), W-base indirect	never	LOAD through a Single via x87 FPU at [W-base+offset] -> [eax], one extra dereference (4-byte (FPU), W+indirect).
(3,4A)	IWMemLdFPR8	Load	Double/Date (FPU), W-base indirect	never	LOAD through a Double via x87 FPU at [W-base+offset] -> [eax], one extra dereference (8-byte (FPU), W+indirect).
(0,78)	ImpAdLdFPR4	Load	Single (FPU), global	emitted	Load Single from a module-level (global) variable.
(3,A9)	ImpAdLdFPR4	Load	Single (FPU), global	never dup	Load Single from a module-level (global) variable.
(0,79)	ImpAdLdFPR8	Load	Double/Date (FPU), global	emitted	Load Double/Date from a module-level (global) variable.
(3,AA)	ImpAdLdFPR8	Load	Double/Date (FPU), global	never dup	Load Double/Date from a module-level (global) variable.
(0,8C)	MemLdFPR4	Load	Single (FPU), member via pr	emitted	Load Single from a field at an offset from the cached object pointer pr.
(3,79)	MemLdFPR4	Load	Single (FPU), member via pr	never dup	Load Single from a field at an offset from the cached object pointer pr.
(0,8D)	MemLdFPR8	Load	Double/Date (FPU), member via pr	emitted	Load Double/Date from a field at an offset from the cached object pointer pr.
(3,7A)	MemLdFPR8	Load	Double/Date (FPU), member via pr	never dup	Load Double/Date from a field at an offset from the cached object pointer pr.
(4,D9)	WMemLdFPR4	Load	Single (FPU), W-base	never	LOAD a Single via x87 FPU at [W-base+offset] via the procedure's secondary-object pointer [ebp+10h] (W-base) (4-byte (FPU)).
(4,DA)	WMemLdFPR8	Load	Double/Date (FPU), W-base	never	LOAD a Double via x87 FPU at [W-base+offset] via the procedure's secondary-object pointer [ebp+10h] (W-base) (8-byte (FPU)).
(0,BD)	FnAbsR4	Math function	Single	emitted	Pop one 32-bit IEEE 754 float (VB6 Single); push its absolute value.
(1,D6)	FnAbsR4	Math function	Single	never dup	(alias) Pop one 32-bit IEEE 754 float (VB6 Single); push its absolute value.
(1,D7)	FnAbsR4	Math function	Single	never dup	(alias) Pop one 32-bit IEEE 754 float (VB6 Single); push its absolute value.
(1,DE)	FnFixR8	Math function	Double	emitted	Fix() of a Single value: truncates toward zero.
(1,DF)	FnFixR8	Math function	Double	emitted dup	Fix() of a Double, Date or String value: truncates toward zero.
(1,E6)	FnIntR8	Math function	Double	emitted dup	Int() of a Single value: rounds down toward negative infinity.
(1,E7)	FnIntR8	Math function	Double	emitted	Int() of a Double, Date or String value: rounds down toward negative infinity.
(1,F6)	FnSgnR4	Math function	Single	emitted dup	Sgn() of a Double, Date, String or Variant (after coercion) value; push an Integer (-1, 0 or 1).
(1,F5)	FnSgnR8	Math function	Double	emitted	Sgn() of a Single value; push an Integer (-1, 0 or 1).
(0,9B)	FMemStFPR4	Store	Single (FPU), via frame pointer	emitted	Store Single into a field reached through a pointer held in a frame slot.
(3,E9)	FMemStFPR4	Store	Single (FPU), via frame pointer	never dup	Store Single into a field reached through a pointer held in a frame slot.
(0,9C)	FMemStFPR8	Store	Double/Date (FPU), via frame pointer	emitted	Store Double/Date into a field reached through a pointer held in a frame slot.
(3,EA)	FMemStFPR8	Store	Double/Date (FPU), via frame pointer	never dup	Store Double/Date into a field reached through a pointer held in a frame slot.
(0,73)	FStFPR4	Store	Single (FPU), frame	emitted	Pop a Single on the x87 FPU stack; store into frame slot [ebp+%a].
(2,F9)	FStFPR4	Store	Single (FPU), frame	never dup	Pop a Single on the x87 FPU stack; store into frame slot [ebp+%a].
(0,74)	FStFPR8	Store	Double/Date (FPU), frame	emitted	Pop a Double on the x87 FPU stack; store into frame slot [ebp+%a].
(2,FA)	FStFPR8	Store	Double/Date (FPU), frame	never dup	Pop a Double on the x87 FPU stack; store into frame slot [ebp+%a].
(0,87)	IStFPR4	Store	Single (FPU), ByRef/indirect	emitted	Store Single into the variable a ByRef argument (or other frame-held pointer) points to.
(3,29)	IStFPR4	Store	Single (FPU), ByRef/indirect	never dup	Store Single into the variable a ByRef argument (or other frame-held pointer) points to.
(0,88)	IStFPR8	Store	Double/Date (FPU), ByRef/indirect	emitted	Store Double/Date into the variable a ByRef argument (or other frame-held pointer) points to.
(3,2A)	IStFPR8	Store	Double/Date (FPU), ByRef/indirect	never dup	Store Double/Date into the variable a ByRef argument (or other frame-held pointer) points to.
(3,59)	IWMemStFPR4	Store	Single (FPU), W-base indirect	never	STORE through a Single via x87 FPU at [W-base+offset] -> [eax], one extra dereference (4-byte (FPU), W+indirect).
(3,5A)	IWMemStFPR8	Store	Double/Date (FPU), W-base indirect	never	STORE through a Double via x87 FPU at [W-base+offset] -> [eax], one extra dereference (8-byte (FPU), W+indirect).
(0,7D)	ImpAdStFPR4	Store	Single (FPU), global	emitted	Store Single into a module-level (global) variable.
(3,B9)	ImpAdStFPR4	Store	Single (FPU), global	never dup	Store Single into a module-level (global) variable.
(0,7E)	ImpAdStFPR8	Store	Double/Date (FPU), global	emitted	Store Double/Date into a module-level (global) variable.
(3,BA)	ImpAdStFPR8	Store	Double/Date (FPU), global	never dup	Store Double/Date into a module-level (global) variable.
(0,91)	MemStFPR4	Store	Single (FPU), member via pr	emitted	Store Single into a field at an offset from the cached object pointer pr.
(3,89)	MemStFPR4	Store	Single (FPU), member via pr	never dup	Store Single into a field at an offset from the cached object pointer pr.
(0,92)	MemStFPR8	Store	Double/Date (FPU), member via pr	emitted	Store Double/Date into a field at an offset from the cached object pointer pr.
(3,8A)	MemStFPR8	Store	Double/Date (FPU), member via pr	never dup	Store Double/Date into a field at an offset from the cached object pointer pr.
(4,E9)	WMemStFPR4	Store	Single (FPU), W-base	never	STORE a Single via x87 FPU at [W-base+offset] via the procedure's secondary-object pointer [ebp+10h] (W-base) (4-byte (FPU)).
(4,EA)	WMemStFPR8	Store	Double/Date (FPU), W-base	never	STORE a Double via x87 FPU at [W-base+offset] via the procedure's secondary-object pointer [ebp+10h] (W-base) (8-byte (FPU)).

Currency 86 slots, 41 distinct handlers, 36 emitted

Currency (scaled 64-bit integer) values: arithmetic, compares (including Currency against other numbers), the raw 8-byte R8 moves, literals and loops.

Slot	Mnemonic	Operation	Types	Status	Summary
(0,AC)	AddCy	Arithmetic	Currency	emitted	Pop two 64-bit scaled-integer Currency (×10^4) values; push their addition result.
(1,93)	AddCy	Arithmetic	Currency	never dup	(alias) Pop two 64-bit scaled-integer Currency (×10^4) values; push their addition result.
(0,B4)	MulCy	Arithmetic	Currency	emitted	Pop two 64-bit scaled-integer Currency (×10^4) values; push their multiplication result.
(1,B3)	MulCy	Arithmetic	Currency	never dup	(alias) Pop two 64-bit scaled-integer Currency (×10^4) values; push their multiplication result.
(0,B5)	MulCyI2	Arithmetic	Currency x Integer/Boolean	emitted	Multiply a Currency by an Integer; push Currency.
(1,D1)	MulCyI2	Arithmetic	Currency x Integer/Boolean	never dup	(duplicate slot of (0,B5) MulCyI2) Multiply a Currency by an Integer; push Currency.
(0,B0)	SubCy	Arithmetic	Currency	emitted	Pop two 64-bit scaled-integer Currency (×10^4) values; push their subtraction result.
(1,9B)	SubCy	Arithmetic	Currency	never dup	(alias) Pop two 64-bit scaled-integer Currency (×10^4) values; push their subtraction result.
(0,BA)	UMiCy	Arithmetic	Currency	emitted	Pop one 64-bit scaled-integer Currency (×10^4); push its arithmetic negation.
(1,CB)	UMiCy	Arithmetic	Currency	never dup	(alias) Pop one 64-bit scaled-integer Currency (×10^4); push its arithmetic negation.
(4,67)	ForCy	Branch/loop	For loop, Currency counter	emitted	Initialise a For loop with a Currency counter.
(4,6F)	ForStepCy	Branch/loop	For loop, Currency counter	emitted	Initialise a For loop with a Currency counter and explicit Step.
(0,6A)	NextStepCy	Branch/loop	For loop, Currency counter	emitted	Next for a Currency loop counter with Step.
(4,7D)	NextStepCy	Branch/loop	For loop, Currency counter	never dup	Next for a Currency loop counter with Step.
(4,85)	NextStepCy	Branch/loop	For loop, Currency counter	never dup	Next for a Currency loop counter with Step.
(1,89)	BetweenCy	Compare	Currency	emitted	Case lo To hi range test on a Currency selector; push Boolean.
(0,C9)	EqCy	Compare	Currency	emitted	Compare two values with =; push Boolean result.
(1,2E)	EqCy	Compare	Currency	never dup	(alias) Compare two values with =; push Boolean result.
(0,CA)	EqCyR8	Compare	Currency vs number	emitted	Compare a Currency with a non-Currency number using =; push Boolean.
(1,35)	EqCyR8	Compare	Currency vs number	never dup	(duplicate slot of (0,CA) EqCyR8) Compare a Currency with a non-Currency number using =; push Boolean.
(0,E2)	GeCy	Compare	Currency	emitted	Compare two values with >=; push Boolean result.
(1,55)	GeCy	Compare	Currency	never dup	(alias) Compare two values with >=; push Boolean result.
(0,E3)	GeCyR8	Compare	Currency vs number	emitted	Compare a Currency with a non-Currency number using >=; push Boolean.
(1,5C)	GeCyR8	Compare	Currency vs number	never dup	(duplicate slot of (0,E3) GeCyR8) Compare a Currency with a non-Currency number using >=; push Boolean.
(0,DD)	GtCy	Compare	Currency	emitted	Compare two values with >; push Boolean result.
(1,6F)	GtCy	Compare	Currency	never dup	(alias) Compare two values with >; push Boolean result.
(0,DE)	GtCyR8	Compare	Currency vs number	emitted	Compare a Currency with a non-Currency number using >; push Boolean.
(1,76)	GtCyR8	Compare	Currency vs number	never dup	(duplicate slot of (0,DE) GtCyR8) Compare a Currency with a non-Currency number using >; push Boolean.
(0,D8)	LeCy	Compare	Currency	emitted	Compare two values with <=; push Boolean result.
(1,48)	LeCy	Compare	Currency	never dup	(alias) Compare two values with <=; push Boolean result.
(0,D9)	LeCyR8	Compare	Currency vs number	emitted	Compare a Currency with a non-Currency number using <=; push Boolean.
(1,4F)	LeCyR8	Compare	Currency vs number	never dup	(duplicate slot of (0,D9) LeCyR8) Compare a Currency with a non-Currency number using <=; push Boolean.
(0,D3)	LtCy	Compare	Currency	emitted	Compare two values with <; push Boolean result.
(1,62)	LtCy	Compare	Currency	never dup	(alias) Compare two values with <; push Boolean result.
(0,D4)	LtCyR8	Compare	Currency vs number	emitted	Compare a Currency with a non-Currency number using <; push Boolean.
(1,69)	LtCyR8	Compare	Currency vs number	never dup	(duplicate slot of (0,D4) LtCyR8) Compare a Currency with a non-Currency number using <; push Boolean.
(0,CE)	NeCy	Compare	Currency	emitted	Compare two values with <>; push Boolean result.
(1,3B)	NeCy	Compare	Currency	never dup	(alias) Compare two values with <>; push Boolean result.
(0,CF)	NeCyR8	Compare	Currency vs number	emitted	Compare a Currency with a non-Currency number using <>; push Boolean.
(1,42)	NeCyR8	Compare	Currency vs number	never dup	(duplicate slot of (0,CF) NeCyR8) Compare a Currency with a non-Currency number using <>; push Boolean.
(0,F6)	LitCy	Literal	8-byte (Currency)	emitted	Push an 8-byte literal (Currency literals; also raw 8-byte double payloads).
(0,F7)	LitCy4	Literal	Currency	never
(4,B7)	LitCy4	Literal	Currency	never dup
(0,6D)	FLdR8	Load	8-byte raw (Currency), frame	emitted	Load 8-byte value from a frame slot (local variable, temporary or ByVal argument).
(2,E4)	FLdR8	Load	8-byte raw (Currency), frame	never dup	Load 8-byte value from a frame slot (local variable, temporary or ByVal argument).
(2,E5)	FLdR8	Load	8-byte raw (Currency), frame	never dup	Load 8-byte value from a frame slot (local variable, temporary or ByVal argument).
(0,95)	FMemLdCy	Load	Currency, via frame pointer	emitted	Load Currency from a field reached through a pointer held in a frame slot.
(3,D4)	FMemLdR8	Load	8-byte raw (Currency), via frame pointer	never dup	Load Currency from a field reached through a pointer held in a frame slot.
(3,D5)	FMemLdR8	Load	8-byte raw (Currency), via frame pointer	never dup	Load Currency from a field reached through a pointer held in a frame slot.
(0,81)	ILdR8	Load	8-byte raw (Currency), ByRef/indirect	emitted	Load 8-byte value from the variable a ByRef argument (or other frame-held pointer) points to.
(3,14)	ILdR8	Load	8-byte raw (Currency), ByRef/indirect	never dup	Load 8-byte value from the variable a ByRef argument (or other frame-held pointer) points to.
(3,15)	ILdR8	Load	8-byte raw (Currency), ByRef/indirect	never dup	Load 8-byte value from the variable a ByRef argument (or other frame-held pointer) points to.
(3,44)	IWMemLdCy	Load	Currency, W-base indirect	never	LOAD through a Currency (64-bit scaled int) at [W-base+offset] -> [eax], one extra dereference (8-byte, W+indirect).
(3,45)	IWMemLdCy	Load	Currency, W-base indirect	never dup	LOAD through a Currency (64-bit scaled int) at [W-base+offset] -> [eax], one extra dereference (8-byte, W+indirect).
(0,77)	ImpAdLdCy	Load	Currency, global	emitted	Load Currency from a module-level (global) variable.
(3,A4)	ImpAdLdCy	Load	Currency, global	never dup	Load Currency from a module-level (global) variable.
(3,A5)	ImpAdLdCy	Load	Currency, global	never dup	Load Currency from a module-level (global) variable.
(0,8B)	MemLdR8	Load	8-byte raw (Currency), member via pr	emitted	Load 8-byte value from a field at an offset from the cached object pointer pr.
(3,74)	MemLdR8	Load	8-byte raw (Currency), member via pr	never dup	Load 8-byte value from a field at an offset from the cached object pointer pr.
(3,75)	MemLdR8	Load	8-byte raw (Currency), member via pr	never dup	Load 8-byte value from a field at an offset from the cached object pointer pr.
(4,D4)	WMemLdCy	Load	Currency, W-base	never	LOAD a Currency (64-bit scaled int) at [W-base+offset] via the procedure's secondary-object pointer [ebp+10h] (W-base) (8-byte).
(4,D5)	WMemLdCy	Load	Currency, W-base	never dup	LOAD a Currency (64-bit scaled int) at [W-base+offset] via the procedure's secondary-object pointer [ebp+10h] (W-base) (8-byte).
(0,BE)	FnAbsCy	Math function	Currency	emitted	Pop one 64-bit scaled-integer Currency (×10^4); push its absolute value.
(1,D8)	FnAbsCy	Math function	Currency	never dup	(alias) Pop one 64-bit scaled-integer Currency (×10^4); push its absolute value.
(1,E0)	FnFixCy	Math function	Currency	emitted	Fix() of a Currency value: truncates toward zero.
(1,E8)	FnIntCy	Math function	Currency	emitted	Int() of a Currency value: rounds down toward negative infinity.
(1,F7)	FnSgnCy	Math function	Currency	emitted	Sgn() of a Currency value; push an Integer (-1, 0 or 1).
(0,9A)	FMemStR8	Store	8-byte raw (Currency), via frame pointer	emitted	Store 8-byte value into a field reached through a pointer held in a frame slot.
(3,E4)	FMemStR8	Store	8-byte raw (Currency), via frame pointer	never dup	Store 8-byte value into a field reached through a pointer held in a frame slot.
(3,E5)	FMemStR8	Store	8-byte raw (Currency), via frame pointer	never dup	Store 8-byte value into a field reached through a pointer held in a frame slot.
(0,72)	FStR8	Store	8-byte raw (Currency), frame	emitted	Store 8-byte value into a frame slot (local variable, temporary or ByVal argument).
(2,F4)	FStR8	Store	8-byte raw (Currency), frame	never dup	Store 8-byte value into a frame slot (local variable, temporary or ByVal argument).
(2,F5)	FStR8	Store	8-byte raw (Currency), frame	never dup	Store 8-byte value into a frame slot (local variable, temporary or ByVal argument).
(0,86)	IStR8	Store	8-byte raw (Currency), ByRef/indirect	emitted	Store 8-byte value into the variable a ByRef argument (or other frame-held pointer) points to.
(3,24)	IStR8	Store	8-byte raw (Currency), ByRef/indirect	never dup	Store 8-byte value into the variable a ByRef argument (or other frame-held pointer) points to.
(3,25)	IStR8	Store	8-byte raw (Currency), ByRef/indirect	never dup	Store 8-byte value into the variable a ByRef argument (or other frame-held pointer) points to.
(3,54)	IWMemStCy	Store	Currency, W-base indirect	never	STORE through a Currency (64-bit scaled int) at [W-base+offset] -> [eax], one extra dereference (8-byte, W+indirect).
(3,55)	IWMemStCy	Store	Currency, W-base indirect	never dup	STORE through a Currency (64-bit scaled int) at [W-base+offset] -> [eax], one extra dereference (8-byte, W+indirect).
(0,7C)	ImpAdStCy	Store	Currency, global	emitted	Store Currency into a module-level (global) variable.
(3,B4)	ImpAdStR8	Store	8-byte raw (Currency), global	never dup	Store Currency into a module-level (global) variable.
(3,B5)	ImpAdStR8	Store	8-byte raw (Currency), global	never dup	Store Currency into a module-level (global) variable.
(3,84)	MemStCy	Store	Currency, member via pr	never dup	Store 8-byte value into a field at an offset from the cached object pointer pr.
(3,85)	MemStCy	Store	Currency, member via pr	never dup	Store 8-byte value into a field at an offset from the cached object pointer pr.
(0,90)	MemStR8	Store	8-byte raw (Currency), member via pr	emitted	Store 8-byte value into a field at an offset from the cached object pointer pr.
(4,E4)	WMemStR8	Store	8-byte raw (Currency), W-base	never	Store a raw 8-byte value at [W-base + offset] (W-base = dispatcher argument [ebp+10h]); not a floating-point store.
(4,E5)	WMemStR8	Store	8-byte raw (Currency), W-base	never dup	Store a raw 8-byte value at [W-base + offset] (W-base = dispatcher argument [ebp+10h]); not a floating-point store.

Variant 129 slots, 121 distinct handlers, 96 emitted

Variant operations: Variant arithmetic, logic and compares (results in a temporary), Variant literals, loads/stores, and ByRef Variant parameters.

Slot	Mnemonic	Operation	Types	Status	Summary
(1,94)	AddVar	Arithmetic	Variant	emitted	Pop two VBA Variant values; push their addition result.
(1,BC)	DivVar	Arithmetic	Variant	emitted	Pop two VBA Variant values; push their floating-point division result.
(1,AC)	IDvVar	Arithmetic	Variant	emitted	Variant integer division (\); result Variant in a temporary.
(1,A4)	ModVar	Arithmetic	Variant	emitted	Pop two VBA Variant values; push their modulo result.
(1,B4)	MulVar	Arithmetic	Variant	emitted	Pop two VBA Variant values; push their multiplication result.
(1,CE)	PwrVar	Arithmetic	Variant	emitted	Variant exponentiation (^); result Variant in a temporary.
(1,9C)	SubVar	Arithmetic	Variant	emitted	Pop two VBA Variant values; push their subtraction result.
(1,CC)	UMiVar	Arithmetic	Variant	emitted	Variant unary minus; result Variant in a temporary.
(4,70)	ForStepVar	Branch/loop	For loop, Variant counter	emitted	Initialise a For loop with a Variant counter and an explicit Step.
(4,68)	ForVar	Branch/loop	For loop, Variant counter	emitted	Initialise a For loop with a Variant counter.
(4,7E)	NextStepVar	Branch/loop	For loop, Variant counter	emitted	Step and re-test a For loop (NextStepVar).
(4,86)	NextStepVar	Branch/loop	For loop, Variant counter	emitted dup	(alias) Step and re-test a For loop (NextStepVar).
(1,8C)	BetweenTextVar	Compare	Variant (text compare)	emitted	Case lo To hi range test on a Variant selector; push Boolean.
(1,8A)	BetweenVar	Compare	Variant	emitted	Pop three values (val, lo, hi); push True if lo <= val <= hi, else False.
(1,31)	EqTextVar	Compare	Variant (text compare)	emitted	Variant = comparison (case-insensitive (Option Compare Text)); result Variant in a temporary.
(1,34)	EqTextVarBool	Compare	Variant (text compare)	emitted	Variant = comparison (text mode) whose result is used directly as a condition; push Boolean.
(1,2F)	EqVar	Compare	Variant	emitted	Compare two values with =; push Boolean result.
(1,33)	EqVarBool	Compare	Variant	emitted	Variant = comparison (binary mode) whose result is used directly as a condition; push Boolean.
(1,58)	GeTextVar	Compare	Variant (text compare)	emitted	Variant >= comparison (case-insensitive (Option Compare Text)); result Variant in a temporary.
(1,5B)	GeTextVarBool	Compare	Variant (text compare)	emitted	Variant >= comparison (text mode) whose result is used directly as a condition; push Boolean.
(1,56)	GeVar	Compare	Variant	emitted	Compare two values with >=; push Boolean result.
(1,5A)	GeVarBool	Compare	Variant	emitted	Variant >= comparison (binary mode) whose result is used directly as a condition; push Boolean.
(1,72)	GtTextVar	Compare	Variant (text compare)	emitted	Variant > comparison (case-insensitive (Option Compare Text)); result Variant in a temporary.
(1,75)	GtTextVarBool	Compare	Variant (text compare)	emitted	Variant > comparison (text mode) whose result is used directly as a condition; push Boolean.
(1,70)	GtVar	Compare	Variant	emitted	Compare two values with >; push Boolean result.
(1,74)	GtVarBool	Compare	Variant	emitted	Variant > comparison (binary mode) whose result is used directly as a condition; push Boolean.
(1,4B)	LeTextVar	Compare	Variant (text compare)	emitted	Variant <= comparison (case-insensitive (Option Compare Text)); result Variant in a temporary.
(1,4E)	LeTextVarBool	Compare	Variant (text compare)	emitted	Variant <= comparison (text mode) whose result is used directly as a condition; push Boolean.
(1,49)	LeVar	Compare	Variant	emitted	Variant <= comparison (binary); result Variant in a temporary.
(1,4D)	LeVarBool	Compare	Variant	emitted	Variant <= comparison (binary mode) whose result is used directly as a condition; push Boolean.
(1,7F)	LikeTextVar	Compare	Variant (text compare)	emitted	Variant Like comparison (case-insensitive (Option Compare Text)); result Variant in a temporary.
(1,82)	LikeTextVarBool	Compare	Variant (text compare)	never	Like (text mode) with Variant operands, Boolean form; never emitted.
(1,7D)	LikeVar	Compare	Variant	emitted	Like with a Variant operand; result Variant in a temporary.
(1,81)	LikeVarBool	Compare	Variant	never	Like with Variant operands, Boolean form; never emitted.
(1,65)	LtTextVar	Compare	Variant (text compare)	emitted	Variant < comparison (case-insensitive (Option Compare Text)); result Variant in a temporary.
(1,68)	LtTextVarBool	Compare	Variant (text compare)	emitted	Variant < comparison (text mode) whose result is used directly as a condition; push Boolean.
(1,63)	LtVar	Compare	Variant	emitted	Compare two values with <; push Boolean result.
(1,67)	LtVarBool	Compare	Variant	emitted	Variant < comparison (binary mode) whose result is used directly as a condition; push Boolean.
(1,3E)	NeTextVar	Compare	Variant (text compare)	emitted	Variant <> comparison (case-insensitive (Option Compare Text)); result Variant in a temporary.
(1,41)	NeTextVarBool	Compare	Variant (text compare)	emitted	Variant <> comparison (text mode) whose result is used directly as a condition; push Boolean.
(1,3C)	NeVar	Compare	Variant	emitted	Compare two values with <>; push Boolean result.
(1,40)	NeVarBool	Compare	Variant	emitted	Variant <> comparison (binary mode) whose result is used directly as a condition; push Boolean.
(4,C3)	LitVarCy	Literal	Variant literal	emitted	Create a Variant Currency literal (VT_CY) in a temporary.
(4,C5)	LitVarDate	Literal	Variant literal	emitted	Create a Variant Date literal (VT_DATE) in a temporary.
(0,28)	LitVarI2	Literal	Variant literal	emitted	Create a Variant Integer literal (VT_I2) in a temporary.
(4,C0)	LitVarI2	Literal	Variant literal	never dup	Create a Variant Integer literal (VT_I2) in a temporary.
(4,C1)	LitVarI4	Literal	Variant literal	emitted	Create a Variant Long literal (VT_I4) in a temporary.
(4,C2)	LitVarR4	Literal	Variant literal	emitted	Create a Variant Single literal (VT_R4) in a temporary.
(4,C4)	LitVarR8	Literal	Variant literal	emitted	Create a Variant Double literal (VT_R8) in a temporary.
(0,3A)	LitVarStr	Literal	Variant literal	emitted	Push variant literal (LitVarStr).
(4,C6)	LitVarStr	Literal	Variant literal	never dup	Push variant literal (LitVarStr).
(4,3D)	LitVarUI1	Literal	Variant literal	never
(2,67)	LitVar_Empty	Literal	Variant literal	emitted	Create a Variant Empty literal in a temporary.
(2,66)	LitVar_FALSE	Literal	Variant literal	emitted	Push Variant False (0, subtype Boolean).
(0,27)	LitVar_Missing	Literal	Variant literal	emitted	Create a Variant Missing value (an omitted Optional argument) in a temporary.
(2,68)	LitVar_Missing	Literal	Variant literal	never dup	Create a Variant Missing value (an omitted Optional argument) in a temporary.
(2,64)	LitVar_Null	Literal	Variant literal	emitted	Create a Variant Null (VT_NULL) in a temporary.
(0,63)	LitVar_TRUE	Literal	Variant literal	emitted	Push Variant True (-1, subtype Boolean).
(2,65)	LitVar_TRUE	Literal	Variant literal	never dup	Push Variant True (-1, subtype Boolean).
(2,ED)	FLdVar	Load	Variant, frame	emitted	Frame-relative load: FLdVar.
(3,DD)	FMemLdVar	Load	Variant, via frame pointer	never
(3,1D)	ILdDarg	Load	ByRef Variant parameter, ByRef/indirect	never	Pop an address; push the value of suffix `` read from it.
(3,16)	ILdRfDarg	Load	ByRef Variant parameter, ByRef/indirect	emitted	Pop an address; push the value of suffix `` read from it.
(3,4D)	IWMemLdDarg	Load	ByRef Variant parameter, W-base indirect	never	LOAD through a value of suffix `` at [W-base+offset] -> [eax], one extra dereference (unknown-size, W+indirect).
(3,46)	IWMemLdRfDarg	Load	ByRef Variant parameter, W-base indirect	never	LOAD through a value of suffix `` at [W-base+offset] -> [eax], one extra dereference (unknown-size, W+indirect).
(3,AD)	ImpAdLdVar	Load	Variant, global	never
(3,7D)	MemLdVar	Load	Variant, member via pr	never
(4,DD)	WMemLdVar	Load	Variant, W-base	never	LOAD a Variant at [W-base+offset] via the procedure's secondary-object pointer [ebp+10h] (W-base) (16-byte).
(1,27)	AndVar	Logic	Variant	emitted	Pop operand(s); push bitwise And.
(1,0F)	EqvVar	Logic	Variant	emitted	Variant bitwise equivalence (Eqv); result Variant in a temporary.
(1,07)	ImpVar	Logic	Variant	emitted	Variant bitwise implication (Imp); result Variant in a temporary.
(1,C4)	NotVar	Logic	Variant	emitted	Pop operand(s); push bitwise Not.
(1,1F)	OrVar	Logic	Variant	emitted	Pop operand(s); push bitwise Or.
(1,17)	XorVar	Logic	Variant	emitted	Variant bitwise exclusive-or (Xor); result Variant in a temporary.
(1,D9)	FnAbsVar	Math function	Variant	emitted	Variant Abs(); result Variant in a temporary.
(1,E1)	FnFixVar	Math function	Variant	emitted	Variant Fix(); result Variant in a temporary.
(1,E9)	FnIntVar	Math function	Variant	emitted	Variant Int(); result Variant in a temporary.
(4,92)	FDupVar	Other		emitted	Duplicate the top-of-stack (FDupVar).
(3,E6)	FMemStVar	Store	Variant, via frame pointer	emitted	Store Variant into a field reached through a pointer held in a frame slot.
(3,EB)	FMemStVarAd	Store	Variant <- object, via frame pointer	emitted	Store object into a Variant into a field reached through a pointer held in a frame slot.
(3,EC)	FMemStVarAdFunc	Store	Variant <- object, via frame pointer	emitted	Store object from a call into a Variant into a field reached through a pointer held in a frame slot.
(3,F0)	FMemStVarCopy	Store	Variant, via frame pointer	emitted	Store Variant (copied) into a field reached through a pointer held in a frame slot.
(3,ED)	FMemStVarUnk	Store	Variant <- IUnknown, via frame pointer	emitted	Store IUnknown into a Variant into a field reached through a pointer held in a frame slot.
(3,EE)	FMemStVarUnkFunc	Store	Variant <- IUnknown, via frame pointer	emitted	Store IUnknown from a call into a Variant into a field reached through a pointer held in a frame slot.
(2,F6)	FStVar	Store	Variant, frame	emitted	Pop a VBA Variant; store into frame slot [ebp+%a].
(2,FB)	FStVarAd	Store	Variant <- object, frame	emitted	Store object into a Variant into a frame slot (local variable, temporary or ByVal argument).
(2,FC)	FStVarAdFunc	Store	Variant <- object, frame	emitted	Pop a value of suffix `; store into frame slot [ebp+%a]`.
(3,00)	FStVarCopy	Store	Variant, frame	emitted	Pop a value of suffix `; store into frame slot [ebp+%a]`.
(0,4E)	FStVarCopyObj	Store	Variant, frame	emitted	Pop a value of suffix `; store into frame slot [ebp+%a]`.
(4,F8)	FStVarCopyObj	Store	Variant, frame	never dup	Pop a value of suffix `; store into frame slot [ebp+%a]`.
(3,63)	FStVarNoPop	Store	Variant, frame	never
(2,FD)	FStVarUnk	Store	Variant <- IUnknown, frame	emitted	Store IUnknown into a Variant into a frame slot (local variable, temporary or ByVal argument).
(2,FE)	FStVarUnkFunc	Store	Variant <- IUnknown, frame	emitted	Store IUnknown from a call into a Variant into a frame slot (local variable, temporary or ByVal argument).
(4,F7)	FStVarZero	Store	Variant, frame	emitted	Store a Variant temporary into a frame slot and zero the source (move semantics).
(5,39)	FStVarZero	Store	Variant, frame	never dup	Store a Variant temporary into a frame slot and zero the source (move semantics).
(0,62)	IStDarg	Store	ByRef Variant parameter, ByRef/indirect	emitted	(alias) Pop value and address; write the value of suffix `` through the address.
(3,26)	IStDarg	Store	ByRef Variant parameter, ByRef/indirect	never dup	(alias) Pop value and address; write the value of suffix `` through the address.
(3,2B)	IStDargAd	Store	ByRef Variant parameter, ByRef/indirect	emitted	Set a ByRef Variant parameter to an object reference (VT_DISPATCH).
(3,2C)	IStDargAdFunc	Store	ByRef Variant parameter, ByRef/indirect	emitted	Set a ByRef Variant parameter to an object returned by a call.
(3,30)	IStDargCopy	Store	ByRef Variant parameter, ByRef/indirect	emitted	Store a Variant into a ByRef Variant parameter (deep copy).
(3,2D)	IStDargUnk	Store	ByRef Variant parameter, ByRef/indirect	emitted	Set a ByRef Variant parameter to an IUnknown reference (VT_UNKNOWN).
(3,2E)	IStDargUnkFunc	Store	ByRef Variant parameter, ByRef/indirect	emitted	Set a ByRef Variant parameter to an IUnknown returned by a call.
(5,09)	IStVarCopyObj	Store	Variant, ByRef/indirect	never
(3,56)	IWMemStDarg	Store	ByRef Variant parameter, W-base indirect	never	STORE through a value of suffix `` at [W-base+offset] -> [eax], one extra dereference (unknown-size, W+indirect).
(3,5B)	IWMemStDargAd	Store	ByRef Variant parameter, W-base indirect	never	STORE through a raw 32-bit address at [W-base+offset] -> [eax], one extra dereference (4-byte (address), W+indirect).
(3,5C)	IWMemStDargAdFunc	Store	ByRef Variant parameter, W-base indirect	never	STORE through a value of suffix `` at [W-base+offset] -> [eax], one extra dereference (unknown-size, W+indirect).
(3,60)	IWMemStDargCopy	Store	ByRef Variant parameter, W-base indirect	never	STORE through a value of suffix `` at [W-base+offset] -> [eax], one extra dereference (unknown-size, W+indirect).
(3,5D)	IWMemStDargUnk	Store	ByRef Variant parameter, W-base indirect	never	STORE through a value of suffix `` at [W-base+offset] -> [eax], one extra dereference (unknown-size, W+indirect).
(3,5E)	IWMemStDargUnkFunc	Store	ByRef Variant parameter, W-base indirect	never	STORE through a value of suffix `` at [W-base+offset] -> [eax], one extra dereference (unknown-size, W+indirect).
(3,B6)	ImpAdStVar	Store	Variant, global	emitted	Store Variant into a module-level (global) variable.
(3,BB)	ImpAdStVarAd	Store	Variant <- object, global	emitted	Store object into a Variant into a module-level (global) variable.
(3,BC)	ImpAdStVarAdFunc	Store	Variant <- object, global	emitted	Store object from a call into a Variant into a module-level (global) variable.
(3,C0)	ImpAdStVarCopy	Store	Variant, global	emitted	Store Variant (copied) into a module-level (global) variable.
(3,BD)	ImpAdStVarUnk	Store	Variant <- IUnknown, global	emitted	Store IUnknown into a Variant into a module-level (global) variable.
(3,BE)	ImpAdStVarUnkFunc	Store	Variant <- IUnknown, global	emitted	Store IUnknown from a call into a Variant into a module-level (global) variable.
(3,86)	MemStVar	Store	Variant, member via pr	emitted	Store Variant into a field at an offset from the cached object pointer pr.
(3,8B)	MemStVarAd	Store	Variant <- object, member via pr	emitted	Store object into a Variant into a field at an offset from the cached object pointer pr.
(3,8C)	MemStVarAdFunc	Store	Variant <- object, member via pr	never
(3,90)	MemStVarCopy	Store	Variant, member via pr	emitted	Store Variant (copied) into a field at an offset from the cached object pointer pr.
(3,8D)	MemStVarUnk	Store	Variant <- IUnknown, member via pr	emitted	Store IUnknown into a Variant into a field at an offset from the cached object pointer pr.
(3,8E)	MemStVarUnkFunc	Store	Variant <- IUnknown, member via pr	never
(4,4D)	SetVarVar	Store	Set Variant = Variant	emitted	Frame-slot manipulation (SetVarVar).
(4,4E)	SetVarVarFunc	Store	Set Variant = Variant	emitted	Frame-slot manipulation (SetVarVarFunc).
(4,E6)	WMemStVar	Store	Variant, W-base	never	STORE a Variant at [W-base+offset] via the procedure's secondary-object pointer [ebp+10h] (W-base) (16-byte).
(4,EB)	WMemStVarAd	Store	Variant <- object, W-base	never	STORE a raw 32-bit address at [W-base+offset] via the procedure's secondary-object pointer [ebp+10h] (W-base) (4-byte (address)).
(4,EC)	WMemStVarAdFunc	Store	Variant <- object, W-base	never	STORE a value of suffix `` at [W-base+offset] via the procedure's secondary-object pointer [ebp+10h] (W-base) (unknown-size).
(4,F0)	WMemStVarCopy	Store	Variant, W-base	never	STORE a value of suffix `` at [W-base+offset] via the procedure's secondary-object pointer [ebp+10h] (W-base) (unknown-size).
(4,ED)	WMemStVarUnk	Store	Variant <- IUnknown, W-base	never	STORE a value of suffix `` at [W-base+offset] via the procedure's secondary-object pointer [ebp+10h] (W-base) (unknown-size).
(4,EE)	WMemStVarUnkFunc	Store	Variant <- IUnknown, W-base	never	STORE a value of suffix `` at [W-base+offset] via the procedure's secondary-object pointer [ebp+10h] (W-base) (unknown-size).

Object / COM 131 slots, 95 distinct handlers, 72 emitted

Object references and COM calls: early-bound vtable calls, late-bound IDispatch (by name or DISPID), New/As New, Set, Is/TypeOf, events and For Each over collections.

Slot	Mnemonic	Operation	Types	Status	Summary
(4,74)	ForEachCollAd	Branch/loop	For Each over a collection	emitted	Start a For Each over a collection with an Object-typed control variable.
(4,88)	ForEachCollObj	Branch/loop	For Each over a collection	emitted	Start a For Each loop over a collection, with the control variable typed as a specific class (or Object).
(4,72)	ForEachCollVar	Branch/loop	For Each over a collection	emitted	Start a For Each loop over a collection or object, with a Variant control variable.
(4,89)	ForEachVar	Branch/loop	For Each over a collection	emitted	Initialize a For Each iteration (ForEachVar).
(4,8A)	ForEachVarFree	Branch/loop	For Each over a collection	never
(4,75)	NextEachCollAd	Branch/loop	For Each over a collection	emitted	Next of a For Each over a collection with an Object-typed control variable.
(4,8B)	NextEachCollObj	Branch/loop	For Each over a collection	emitted	Next of a For Each loop over a collection, with the control variable typed as a specific class (or Object).
(4,73)	NextEachCollVar	Branch/loop	For Each over a collection	emitted	Next of a For Each loop over a collection or object, with a Variant control variable.
(4,8C)	NextEachVar	Branch/loop	For Each over a collection	emitted	Advance a For Each iteration (NextEachVar).
(4,A0)	LateIdCall	Call	late-bound IDispatch	emitted	Late-bound method call by compile-time DISPID (statement form, result discarded).
(4,A2)	LateIdCallLdVar	Call	late-bound IDispatch	emitted	Late-bound call by pre-resolved DispID (LateIdCallLdVar).
(4,A4)	LateIdCallSt	Call	late-bound IDispatch	emitted	Late-bound property-put by DISPID with arguments (o(i) = v / o.P(i) = v).
(4,AA)	LateIdNamedCall	Call	late-bound IDispatch	emitted	Late-bound method call by DISPID with named arguments.
(4,AB)	LateIdNamedCallLdVar	Call	late-bound IDispatch	emitted	Late-bound function call by DISPID with named arguments; push the result Variant.
(4,AC)	LateIdNamedCallSt	Call	late-bound IDispatch	emitted	Late-bound property-put by DISPID with named index arguments.
(4,98)	LateMemCall	Call	late-bound IDispatch	emitted	Late-bound method call by name (LateMemCall).
(4,9A)	LateMemCallLdVar	Call	late-bound IDispatch	emitted	Late-bound function call by name with arguments; result Variant in a temporary.
(4,9C)	LateMemCallSt	Call	late-bound IDispatch	emitted	Late-bound property-put by name with arguments (o.Prop(i) = v).
(4,A6)	LateMemNamedCall	Call	late-bound IDispatch	emitted	Late-bound method call by name with named arguments.
(4,A7)	LateMemNamedCallLdVar	Call	late-bound IDispatch	emitted	Late-bound function call by name with named arguments; push the result Variant.
(4,A8)	LateMemNamedCallSt	Call	late-bound IDispatch	emitted	Late-bound property-put by name with named index arguments.
(5,0C)	RaiseEvent	Call		emitted	RaiseEvent: fire one of the class's events, by DISPID, on every connected WithEvents sink.
(0,12)	ThisVCallAd	Call	early-bound vtable call	never
(4,0D)	ThisVCallCbFrame	Call	early-bound vtable call	never
(4,05)	ThisVCallCy	Call	early-bound vtable call	never
(0,11)	ThisVCallFPR8	Call	early-bound vtable call	never
(4,09)	ThisVCallHidden	Call	early-bound vtable call	never dup
(4,0A)	ThisVCallHidden	Call	early-bound vtable call	never dup
(4,0C)	ThisVCallHidden	Call	early-bound vtable call	never dup
(5,2C)	ThisVCallHidden	Call	early-bound vtable call	never dup
(0,10)	ThisVCallHresult	Call	early-bound vtable call	emitted	vtable call of one of the current object's own methods, written without Me.; check the HRESULT.
(2,6A)	ThisVCallHresult	Call	early-bound vtable call	never dup	vtable call of one of the current object's own methods, written without Me.; check the HRESULT.
(4,01)	ThisVCallI2	Call	early-bound vtable call	never dup
(4,02)	ThisVCallI2	Call	early-bound vtable call	never dup
(4,07)	ThisVCallI2	Call	early-bound vtable call	never dup
(4,08)	ThisVCallI2	Call	early-bound vtable call	never dup
(4,03)	ThisVCallR4	Call	early-bound vtable call	never
(4,04)	ThisVCallR8	Call	early-bound vtable call	never
(4,00)	ThisVCallUI1	Call	early-bound vtable call	never
(0,0F)	VCallAd	Call	early-bound vtable call	emitted	vtable call returning a 32-bit value in EAX (non-HRESULT method); push the result.
(4,1D)	VCallCbFrame	Call	early-bound vtable call	never
(4,15)	VCallCy	Call	early-bound vtable call	never
(0,0E)	VCallFPR8	Call	early-bound vtable call	emitted	vtable call whose return value comes back on the FPU (Single/Double), or whose result is discarded.
(4,19)	VCallFPR8	Call	early-bound vtable call	never dup	vtable call whose return value comes back on the FPU (Single/Double), or whose result is discarded.
(4,1A)	VCallFPR8	Call	early-bound vtable call	never dup	vtable call whose return value comes back on the FPU (Single/Double), or whose result is discarded.
(4,1C)	VCallFPR8	Call	early-bound vtable call	never dup	vtable call whose return value comes back on the FPU (Single/Double), or whose result is discarded.
(5,2B)	VCallFPR8	Call	early-bound vtable call	emitted dup	vtable call whose return value comes back on the FPU (Single/Double), or whose result is discarded.
(0,0D)	VCallHresult	Call	early-bound vtable call	emitted	vtable call of an early-bound COM method or property; check the HRESULT.
(2,69)	VCallHresult	Call	early-bound vtable call	never dup	vtable call of an early-bound COM method or property; check the HRESULT.
(4,13)	VCallR4	Call	early-bound vtable call	never
(4,14)	VCallR8	Call	early-bound vtable call	never
(4,11)	VCallStr	Call	early-bound vtable call	never dup	vtable call returning a 32-bit value in EAX (non-HRESULT method); push the result.
(4,12)	VCallStr	Call	early-bound vtable call	never dup	vtable call returning a 32-bit value in EAX (non-HRESULT method); push the result.
(4,17)	VCallStr	Call	early-bound vtable call	never dup	vtable call returning a 32-bit value in EAX (non-HRESULT method); push the result.
(4,18)	VCallStr	Call	early-bound vtable call	never dup	vtable call returning a 32-bit value in EAX (non-HRESULT method); push the result.
(4,10)	VCallUI1	Call	early-bound vtable call	emitted	vtable call returning a Byte in AL (non-HRESULT method); push the result.
(5,3E)	VarLateMemCallLdRfVar	Call	late-bound IDispatch	emitted	Late-bound method call with arguments on a Variant-held object; result passed on by reference.
(5,42)	VarLateMemCallLdVar	Call	late-bound IDispatch	emitted	Late-bound function call by name on an object held in a Variant; push the result.
(5,44)	VarLateMemCallSt	Call	late-bound IDispatch	emitted	Late-bound indexed property-put by name on an object held in a Variant.
(2,63)	LitNothing	Literal	Nothing	emitted	Push a literal: LitNothing.
(2,74)	FLdLateIdUnkVar	Load		never
(0,08)	FLdPr	Load	object pointer, frame	emitted	Load an object reference from a frame slot into the cached object register pr.
(2,EB)	FLdPr	Load	object pointer, frame	never dup	Load an object reference from a frame slot into the cached object register pr.
(0,21)	FLdPrThis	Load	object pointer, frame	emitted	Load Me for a call on the host object's built-in interface (form, UserControl, UserDocument).
(3,9E)	FLdPrThis	Load	object pointer, frame	never dup	(alias) Frame-relative load: FLdPrThis.
(0,3E)	FLdZeroAd	Load	object, frame	emitted	Frame-relative load: FLdZeroAd.
(0,51)	FLdZeroAd	Load	object, frame	emitted dup	(alias) Frame-relative load: FLdZeroAd.
(3,3F)	FLdZeroAd	Load	object, frame	never dup	Frame-relative load: FLdZeroAd.
(3,62)	FLdZeroAd	Load	object, frame	never dup	Frame-relative load: FLdZeroAd.
(5,38)	FLdZeroAry	Load		never
(0,5F)	FMemLdPr	Load	object pointer, via frame pointer	emitted	Load object pointer to pr from a field reached through a pointer held in a frame slot.
(3,DB)	FMemLdPr	Load	object pointer, via frame pointer	never dup	Load object pointer to pr from a field reached through a pointer held in a frame slot.
(0,48)	ILdPr	Load	object pointer, ByRef/indirect	emitted	Pop an address; push the object pointer read from it.
(3,1B)	ILdPr	Load	object pointer, ByRef/indirect	never dup	Pop an address; push the object pointer read from it.
(3,4B)	IWMemLdPr	Load	object pointer, W-base indirect	never	LOAD through a object pointer at [W-base+offset] -> [eax], one extra dereference (4-byte, W+indirect).
(4,DB)	IWMemLdPr	Load	object pointer, W-base indirect	never dup	LOAD through a object pointer at [W-base+offset] -> [eax], one extra dereference (4-byte, W+indirect).
(0,22)	ImpAdLdPr	Load	object pointer, global	never
(3,AB)	ImpAdLdPr	Load	object pointer, global	never dup
(0,61)	LateIdLdVar	Load	late-bound IDispatch	emitted	Late-bound property-get by compile-time DISPID; push the result Variant.
(4,A1)	LateIdLdVar	Load	late-bound IDispatch	never dup	Late-bound property-get by compile-time DISPID; push the result Variant.
(0,57)	LateMemLdVar	Load	late-bound IDispatch	emitted	Late-bound property get (LateMemLdVar).
(4,99)	LateMemLdVar	Load	late-bound IDispatch	never dup	Late-bound property get (LateMemLdVar).
(0,58)	MemLdPr	Load	object pointer, member via pr	emitted	(alias) Load a object pointer from [pr + offset] where pr is on the stack.
(3,7B)	MemLdPr	Load	object pointer, member via pr	never dup	(alias) Load a object pointer from [pr + offset] where pr is on the stack.
(5,3D)	VarLateMemLdRfVar	Load	late-bound IDispatch	emitted	Late-bound property get by name on a Variant-held object, passed on by reference.
(5,41)	VarLateMemLdVar	Load	late-bound IDispatch	emitted	Late-bound property get by name on an object held in a Variant; push the result Variant.
(4,97)	AddRef	Other		never	COM reference-count operation: AddRef.
(5,08)	CExtInstUnk	Other		never	Type conversion (CExtInstUnk).
(0,3D)	CastAd	Other		emitted	Type conversion (CastAd).
(3,F2)	CastAd	Other		never dup	Type conversion (CastAd).
(3,F3)	CastAdVar	Other		emitted	Type conversion (CastAdVar).
(4,8D)	CheckType	Other		emitted	TypeOf obj Is Class: test an object reference against an interface.
(2,6F)	CheckTypeVar	Other		emitted	TypeOf v Is Class where the operand is a Variant.
(1,D2)	Is	Other		emitted	Is operator: compare two object references for identity; push Boolean.
(2,73)	LdPrUnkVar	Other		never	Frame-slot manipulation (LdPrUnkVar).
(3,9F)	LdPrVar	Other		emitted	Frame-slot manipulation (LdPrVar).
(3,F4)	New	Other		emitted	Create a new object instance (New Class).
(0,56)	NewIfNullAd	Other		emitted	As New auto-instancing: create the object if Nothing, then push the reference.
(3,F6)	NewIfNullAd	Other		never dup	As New auto-instancing: create the object if Nothing, then push the reference.
(0,24)	NewIfNullPr	Other		emitted	As New auto-instancing: create the object if the variable is Nothing, then load it into pr.
(3,F7)	NewIfNullPr	Other		never dup	As New auto-instancing: create the object if the variable is Nothing, then load it into pr.
(3,F5)	NewIfNullRf	Other		emitted	As New auto-instancing: create the object if Nothing, then push the variable's address (ByRef).
(4,FA)	VerifyPVarObj	Other		never	Type check / verify (VerifyPVarObj).
(4,F9)	VerifyVarObj	Other		emitted	Type check / verify (VerifyVarObj).
(3,E8)	FMemStAd	Store	object, via frame pointer	emitted	Store object reference into a field reached through a pointer held in a frame slot.
(3,EF)	FMemStAdFunc	Store	object, via frame pointer	emitted	Store object reference from a call into a field reached through a pointer held in a frame slot.
(2,F8)	FStAd	Store	object, frame	emitted	Pop a raw 32-bit address (pointer); store into frame slot [ebp+%a].
(0,19)	FStAdFunc	Store	object, frame	emitted	Store an object reference returned by New or a call into an object variable, without an extra AddRef.
(2,FF)	FStAdFunc	Store	object, frame	never dup	Store an object reference returned by New or a call into an object variable, without an extra AddRef.
(0,5B)	FStAdFuncNoPop	Store	object, frame	emitted	Pop a value of suffix `; store into frame slot [ebp+%a]`.
(3,9D)	FStAdFuncNoPop	Store	object, frame	never dup	Pop a value of suffix `; store into frame slot [ebp+%a]`.
(3,9C)	FStAdNoPop	Store	object, frame	emitted	Pop a value of suffix `; store into frame slot [ebp+%a]`.
(3,28)	IStAd	Store	object, ByRef/indirect	emitted	Pop value and address; write the raw 32-bit address (pointer) through the address.
(3,2F)	IStAdFunc	Store	object, ByRef/indirect	emitted	Pop value and address; write the value of suffix `` through the address.
(3,58)	IWMemStAd	Store	object, W-base indirect	never	STORE through a raw 32-bit address at [W-base+offset] -> [eax], one extra dereference (4-byte (address), W+indirect).
(3,5F)	IWMemStAdFunc	Store	object, W-base indirect	never	STORE through a value of suffix `` at [W-base+offset] -> [eax], one extra dereference (unknown-size, W+indirect).
(3,B8)	ImpAdStAd	Store	object, global	emitted	Store object reference into a module-level (global) variable.
(3,BF)	ImpAdStAdFunc	Store	object, global	emitted	Store through an imported address (ImpAdStAdFunc).
(4,AD)	LateIdNamedStAd	Store	late-bound IDispatch	emitted	Late-bound property-putref (Set) by DISPID with named index arguments.
(0,2C)	LateIdSt	Store	late-bound IDispatch	emitted	Late-bound property-put by compile-time DISPID.
(4,A3)	LateIdSt	Store	late-bound IDispatch	never dup	Late-bound property-put by compile-time DISPID.
(4,A5)	LateIdStAd	Store	late-bound IDispatch	emitted	Late-bound property-putref by DISPID (Set o(i) = obj).
(4,A9)	LateMemNamedStAd	Store	late-bound IDispatch	emitted	Late-bound property-putref by name with named index arguments.
(4,9B)	LateMemSt	Store	late-bound IDispatch	emitted	Late-bound property put (LateMemSt).
(4,9D)	LateMemStAd	Store	late-bound IDispatch	emitted	Late-bound property-putref by name (Set o.Prop = obj).
(3,88)	MemStAd	Store	object, member via pr	emitted	Store a raw 32-bit address (pointer) into [pr + offset] (pr on the stack).
(3,8F)	MemStAdFunc	Store	object, member via pr	never
(5,43)	VarLateMemSt	Store	late-bound IDispatch	emitted	Late-bound property put by name on an object held in a Variant.
(5,45)	VarLateMemStAd	Store	late-bound IDispatch	emitted	Late-bound property-putref by name on an object held in a Variant.
(4,E8)	WMemStAd	Store	object, W-base	never	STORE a raw 32-bit address at [W-base+offset] via the procedure's secondary-object pointer [ebp+10h] (W-base) (4-byte (address)).
(4,EF)	WMemStAdFunc	Store	object, W-base	never	STORE a value of suffix `` at [W-base+offset] via the procedure's secondary-object pointer [ebp+10h] (W-base) (unknown-size).

UDT / record 35 slots, 32 distinct handlers, 25 emitted

User-defined types: record assignment and destruction, UDT function returns, UDTs in Variants (public records), UDTs passed to APIs, Get/Put of records, fixed arrays inside UDTs.

Slot	Mnemonic	Operation	Types	Status	Summary
(4,2D)	ImpAdCallCbFrame	Call	user-defined type	emitted	Call a module Function that returns a user-defined type into a frame buffer.
(5,32)	CDargRefUdt	Convert	user-defined type	emitted	Pass a UDT by reference to a late-bound call as a VT_RECORD|VT_BYREF Variant.
(0,1F)	CRec2Ansi	Convert	user-defined type	emitted	Convert top-of-stack 2Ansi to Rec.
(0,20)	CRec2Uni	Convert	user-defined type	emitted	Convert top-of-stack 2Uni to Rec.
(2,5D)	CRecAnsi2Uni	Convert	user-defined type	never dup	Convert top-of-stack 2Uni to Rec.
(2,5E)	CRecUni2Ansi	Convert	user-defined type	never dup	Convert top-of-stack 2Ansi to Rec.
(5,3A)	CVarAryUdt	Convert	user-defined type	emitted	Convert an array to a Variant (v = a), descriptor-driven.
(5,33)	CVarRefUdt	Convert	user-defined type	emitted	Pass a public-record UDT ByRef to a Variant parameter (VT_RECORD|VT_BYREF).
(5,34)	CVarUdt	Convert	user-defined type	emitted	Copy a public-record UDT into a Variant (VT_RECORD).
(0,38)	CopyBytes	Convert	user-defined type	emitted	Copy a fixed number of bytes from one address to another (plain-data UDT assignment).
(3,CA)	CopyBytes	Convert	user-defined type	never dup	Copy a fixed number of bytes from one address to another (plain-data UDT assignment).
(5,37)	CopyBytesZero	Convert	user-defined type	never
(3,FF)	DestructOFrame	Free/cleanup	user-defined type	emitted	Initialise (zero) a UDT temporary in the frame before a call that fills it.
(5,2A)	DestructRecord	Free/cleanup	user-defined type	emitted	Release the reference-counted members of a UDT (destruct before overwrite).
(5,31)	EraseDestrKeepData	Free/cleanup	user-defined type	never
(4,60)	EraseDestruct	Free/cleanup	user-defined type	emitted	Erase a fixed-size array of UDTs: destruct every element's reference members.
(5,16)	GetRecOwn3	I/O	user-defined type	emitted	File I/O primitive: GetRecOwn3.
(5,17)	GetRecOwn4	I/O	user-defined type	emitted	File I/O primitive: GetRecOwn4.
(2,79)	GetRecOwner3	I/O	user-defined type	never
(2,7A)	GetRecOwner4	I/O	user-defined type	never
(5,18)	PutRecOwn3	I/O	user-defined type	emitted	File I/O primitive: PutRecOwn3.
(5,19)	PutRecOwn4	I/O	user-defined type	emitted	File I/O primitive: PutRecOwn4.
(2,7B)	PutRecOwner3	I/O	user-defined type	never
(2,7C)	PutRecOwner4	I/O	user-defined type	never
(5,06)	AryInRecLdPr	Other	user-defined type	emitted	SafeArray operation: AryInRecLdPr.
(5,07)	AryInRecLdRf	Other	user-defined type	never	SafeArray operation: AryInRecLdRf.
(5,3C)	RedimPreserveVarUdt	Other	user-defined type	emitted	ReDim Preserve a Variant-held array of a public record type.
(5,3B)	RedimVarUdt	Other	user-defined type	emitted	ReDim a Variant as an array of a public record type.
(4,9E)	ExitProcFrameCb	Return	user-defined type	emitted	Return a user-defined type from a module Function by copying it to the caller's buffer.
(5,30)	ExitProcFrameCbHresult	Return	user-defined type	emitted	Return a user-defined type from a class/COM method (HRESULT-returning) by copying it to the [out] buffer.
(4,9F)	ExitProcFrameCbStack	Return	user-defined type	emitted	Return a small (8-byte) user-defined type from a module Function.
(4,F5)	AssignRecord	Store	user-defined type	emitted	Assign one UDT to another (deep copy honouring String/Variant/Object members).
(5,04)	StAryRecCopy	Store	user-defined type	emitted	Assign one dynamic array of UDTs to another (deep copy).
(5,03)	StAryRecMove	Store	user-defined type	emitted	Move a temporary array of UDTs (function result) into an array variable.
(5,35)	StUdtVar	Store	user-defined type	emitted	Store a Variant holding a record into a UDT variable (udt = v).

Array 87 slots, 60 distinct handlers, 50 emitted

SAFEARRAY operations: element loads/stores, ReDim/Erase, bounds, array assignment and For Each over arrays.

Slot	Mnemonic	Operation	Types	Status	Summary
(4,76)	ForEachAryVar	Branch/loop	For Each over an array	emitted	Start a For Each loop over an array, with a Variant control variable.
(4,77)	NextEachAryVar	Branch/loop	For Each over an array	emitted	Next of a For Each loop over an array, with a Variant control variable.
(0,9F)	Ary1LdCy	Load		emitted	SafeArray operation: Ary1LdCy.
(0,A0)	Ary1LdFPR4	Load		emitted	SafeArray operation: Ary1LdFPR4.
(2,99)	Ary1LdFPR4	Load		never dup	(alias) SafeArray operation: Ary1LdFPR4.
(0,A1)	Ary1LdFPR8	Load		emitted	SafeArray operation: Ary1LdFPR8.
(2,9A)	Ary1LdFPR8	Load		never dup	(alias) SafeArray operation: Ary1LdFPR8.
(0,9D)	Ary1LdI2	Load		emitted	SafeArray operation: Ary1LdI2.
(2,91)	Ary1LdI2	Load		never dup	(alias) SafeArray operation: Ary1LdI2.
(0,9E)	Ary1LdI4	Load		emitted	SafeArray operation: Ary1LdI4.
(2,92)	Ary1LdI4	Load		never dup	(alias) SafeArray operation: Ary1LdI4.
(2,93)	Ary1LdI4	Load		never dup	(alias) SafeArray operation: Ary1LdI4.
(2,97)	Ary1LdI4	Load		never dup	(alias) SafeArray operation: Ary1LdI4.
(2,98)	Ary1LdI4	Load		never dup	(alias) SafeArray operation: Ary1LdI4.
(0,41)	Ary1LdPr	Load		emitted	SafeArray operation: Ary1LdPr.
(2,9B)	Ary1LdPr	Load		never dup	(alias) SafeArray operation: Ary1LdPr.
(2,94)	Ary1LdR8	Load		never dup	SafeArray operation: Ary1LdR8.
(2,95)	Ary1LdR8	Load		never dup	(alias) SafeArray operation: Ary1LdR8.
(0,40)	Ary1LdRf	Load		emitted	SafeArray operation: Ary1LdRf.
(2,9C)	Ary1LdRf	Load		never dup	(alias) SafeArray operation: Ary1LdRf.
(2,96)	Ary1LdRfVar	Load		emitted	SafeArray operation: Ary1LdRfVar.
(2,B2)	Ary1LdRfVarg	Load		emitted	SafeArray operation: Ary1LdRfVarg.
(2,B4)	Ary1LdRfVargParam	Load		emitted	SafeArray operation: Ary1LdRfVargParam.
(2,90)	Ary1LdUI1	Load		emitted	SafeArray operation: Ary1LdUI1.
(2,9D)	Ary1LdVar	Load		never	SafeArray operation: Ary1LdVar.
(2,B3)	Ary1LdVarg	Load		never	SafeArray operation: Ary1LdVarg.
(0,A7)	AryLdPr	Load		emitted	Compute the address of a multi-dimensional array element and load it into pr.
(2,8D)	AryLdPr	Load		never dup	Compute the address of a multi-dimensional array element and load it into pr.
(0,A8)	AryLdRf	Load		never
(2,8E)	AryLdRf	Load		never dup
(4,AF)	VarIndexLdRfVar	Load		emitted	Index into an array held in a Variant and push a reference to the element Variant.
(4,F2)	VarIndexLdRfVarLock	Load		emitted	SafeArray operation: VarIndexLdRfVarLock.
(4,AE)	VarIndexLdVar	Load		emitted	SafeArray operation: VarIndexLdVar.
(5,0A)	ArrayRebase1Var	Other		emitted	SafeArray operation: ArrayRebase1Var.
(0,26)	AryDescTemp	Other		emitted	SafeArray operation: AryDescTemp.
(3,0F)	AryDescTemp	Other		never dup	SafeArray operation: AryDescTemp.
(0,2E)	AryLock	Other		emitted	SafeArray operation: AryLock.
(3,0D)	AryLock	Other		never dup	SafeArray operation: AryLock.
(0,2D)	AryUnlock	Other		emitted	SafeArray operation: AryUnlock.
(3,0E)	AryUnlock	Other		never dup	SafeArray operation: AryUnlock.
(0,5A)	Erase	Other		emitted	Erase an array: Erase.
(2,C3)	Erase	Other		never dup	(alias) Erase an array: Erase.
(4,CF)	EraseNoPop	Other		never	Frame-slot manipulation (EraseNoPop).
(0,4C)	FnLBound	Other		emitted	SafeArray operation: FnLBound.
(2,CA)	FnLBound	Other		never dup	(alias) SafeArray operation: FnLBound.
(2,CB)	FnUBound	Other		emitted	SafeArray operation: FnUBound.
(4,8E)	Redim	Other		emitted	Resize a dynamic array (Redim).
(4,8F)	RedimPreserve	Other		emitted	Resize a dynamic array (RedimPreserve).
(4,91)	RedimPreserveVar	Other		emitted	ReDim Preserve an array held in a Variant.
(4,90)	RedimVar	Other		emitted	ReDim an array held in a Variant.
(2,A8)	Ary1StAd	Store		emitted	SafeArray operation: Ary1StAd.
(2,AF)	Ary1StAdFunc	Store		never	SafeArray operation: Ary1StAdFunc.
(0,A4)	Ary1StCy	Store		emitted	SafeArray operation: Ary1StCy.
(2,A4)	Ary1StCy	Store		never dup	(alias) SafeArray operation: Ary1StCy.
(2,A5)	Ary1StCy	Store		never dup	(alias) SafeArray operation: Ary1StCy.
(0,A5)	Ary1StFPR4	Store		emitted	SafeArray operation: Ary1StFPR4.
(2,A9)	Ary1StFPR4	Store		never dup	(alias) SafeArray operation: Ary1StFPR4.
(0,A6)	Ary1StFPR8	Store		emitted	SafeArray operation: Ary1StFPR8.
(2,AA)	Ary1StFPR8	Store		never dup	(alias) SafeArray operation: Ary1StFPR8.
(0,A2)	Ary1StI2	Store		emitted	SafeArray operation: Ary1StI2.
(2,A1)	Ary1StI2	Store		never dup	(alias) SafeArray operation: Ary1StI2.
(0,A3)	Ary1StI4	Store		emitted	SafeArray operation: Ary1StI4.
(2,A2)	Ary1StR4	Store		never dup	SafeArray operation: Ary1StR4.
(2,A3)	Ary1StR4	Store		never dup	(alias) SafeArray operation: Ary1StR4.
(2,A7)	Ary1StStr	Store		never	SafeArray operation: Ary1StStr.
(0,3B)	Ary1StStrCopy	Store		emitted	SafeArray operation: Ary1StStrCopy.
(2,B1)	Ary1StStrCopy	Store		never dup	(alias) SafeArray operation: Ary1StStrCopy.
(2,A0)	Ary1StUI1	Store		emitted	SafeArray operation: Ary1StUI1.
(0,52)	Ary1StVar	Store		emitted	SafeArray operation: Ary1StVar.
(2,A6)	Ary1StVar	Store		never dup	(alias) SafeArray operation: Ary1StVar.
(2,AB)	Ary1StVarAd	Store		emitted	SafeArray operation: Ary1StVarAd.
(2,AC)	Ary1StVarAdFunc	Store		never	SafeArray operation: Ary1StVarAdFunc.
(2,B0)	Ary1StVarCopy	Store		emitted	SafeArray operation: Ary1StVarCopy.
(2,AD)	Ary1StVarUnk	Store		emitted	SafeArray operation: Ary1StVarUnk.
(2,AE)	Ary1StVarUnkFunc	Store		never	SafeArray operation: Ary1StVarUnkFunc.
(2,B5)	Ary1StVarg	Store		emitted	SafeArray operation: Ary1StVarg.
(2,B7)	Ary1StVargAd	Store		emitted	SafeArray operation: Ary1StVargAd.
(2,B8)	Ary1StVargAdFunc	Store		never	SafeArray operation: Ary1StVargAdFunc.
(2,B6)	Ary1StVargCopy	Store		emitted	SafeArray operation: Ary1StVargCopy.
(2,B9)	Ary1StVargUnk	Store		emitted	SafeArray operation: Ary1StVargUnk.
(2,BA)	Ary1StVargUnkFunc	Store		never	SafeArray operation: Ary1StVargUnkFunc.
(2,8F)	ParmAry1St	Store		emitted	SafeArray operation: ParmAry1St.
(5,02)	StAryCopy	Store		emitted	SafeArray operation: StAryCopy.
(5,01)	StAryMove	Store		emitted	SafeArray operation: StAryMove.
(5,36)	StAryVar	Store		emitted	SafeArray operation: StAryVar.
(4,B0)	VarIndexSt	Store		emitted	SafeArray operation: VarIndexSt.
(4,B1)	VarIndexStAd	Store		emitted	Set an element of a Variant-held array to an object.

Conversion 140 slots, 91 distinct handlers, 96 emitted

Type conversions, implicit and explicit (CInt, CStr, ...). The detail column gives source -> target.

Slot	Mnemonic	Operation	Types	Status	Summary
(2,34)	CAdVar	Convert		emitted	Convert top-of-stack Variant to address.
(0,53)	CBoolCy	Convert	Currency -> Boolean	emitted	Convert top-of-stack Currency to Boolean.
(2,55)	CBoolCy	Convert	Currency -> Boolean	never dup	(alias) Convert top-of-stack Currency to Boolean.
(2,52)	CBoolI4	Convert	Long -> Boolean	emitted	Convert top-of-stack Long to Boolean.
(2,53)	CBoolR4	Convert	Single -> Boolean	emitted	Convert top-of-stack Single to Boolean.
(2,54)	CBoolR4	Convert	Single -> Boolean	emitted dup	(alias) Convert top-of-stack Single to Boolean.
(2,57)	CBoolStr	Convert	String -> Boolean	emitted	Convert top-of-stack String to Boolean.
(2,50)	CBoolUI1	Convert	Byte -> Boolean	emitted dup	Convert top-of-stack Byte to Boolean.
(2,51)	CBoolUI1	Convert	Byte -> Boolean	emitted	(alias) Convert top-of-stack Byte to Boolean.
(2,56)	CBoolVar	Convert	Variant -> Boolean	emitted	Implicitly coerce a Variant to Boolean (assignment, typed argument or typed expression context).
(5,1B)	CBoolVarNull	Convert	VarNull -> Boolean	emitted	Type conversion (CBoolVarNull).
(0,EF)	CCyI2	Convert	Integer/Boolean -> Currency	emitted	Convert top-of-stack Integer to Currency.
(2,04)	CCyI2	Convert	Integer/Boolean -> Currency	never dup	(alias) Convert top-of-stack Integer to Currency.
(2,05)	CCyI2	Convert	Integer/Boolean -> Currency	never dup	(alias) Convert top-of-stack Integer to Currency.
(0,F0)	CCyI4	Convert	Long -> Currency	emitted	Convert top-of-stack Long to Currency.
(2,06)	CCyI4	Convert	Long -> Currency	never dup	(alias) Convert top-of-stack Long to Currency.
(0,F1)	CCyR4	Convert	Single -> Currency	emitted	Convert top-of-stack Single to Currency.
(2,07)	CCyR4	Convert	Single -> Currency	never dup	(alias) Convert top-of-stack Single to Currency.
(2,08)	CCyR4	Convert	Single -> Currency	never dup	(alias) Convert top-of-stack Single to Currency.
(2,0B)	CCyStr	Convert	String -> Currency	emitted	Convert top-of-stack String to Currency.
(2,0A)	CCyVar	Convert	Variant -> Currency	emitted	Implicitly coerce a Variant to Currency (assignment, typed argument or typed expression context).
(3,93)	CDargRef	Convert		emitted	Convert top-of-stack Ref to Darg.
(0,F2)	CDateR8	Convert	Double -> Date	emitted	Type conversion (CDateR8).
(2,47)	CDateR8	Convert	Double -> Date	never dup	(alias) Type conversion (CDateR8).
(4,C9)	CDateStr	Convert	String -> Date	emitted	Type conversion (CDateStr).
(0,E6)	CI2Cy	Convert	Currency -> Integer/Boolean	emitted	Convert top-of-stack Currency to Integer.
(2,19)	CI2Cy	Convert	Currency -> Integer/Boolean	never dup	(alias) Convert top-of-stack Currency to Integer.
(0,E4)	CI2I4	Convert	Long -> Integer/Boolean	emitted	Convert top-of-stack Long to Integer.
(2,16)	CI2I4	Convert	Long -> Integer/Boolean	never dup	(alias) Convert top-of-stack Long to Integer.
(0,E5)	CI2R8	Convert	Double -> Integer/Boolean	emitted	Convert top-of-stack Double to Integer.
(2,17)	CI2R8	Convert	Double -> Integer/Boolean	never dup	(alias) Convert top-of-stack Double to Integer.
(2,18)	CI2R8	Convert	Double -> Integer/Boolean	never dup	(alias) Convert top-of-stack Double to Integer.
(2,1B)	CI2Str	Convert	String -> Integer/Boolean	emitted	Convert top-of-stack String to Integer.
(2,14)	CI2UI1	Convert	Byte -> Integer/Boolean	emitted	Convert top-of-stack Byte to Integer.
(0,55)	CI2Var	Convert	Variant -> Integer/Boolean	emitted	Implicitly coerce a Variant to Integer (assignment, typed argument or typed expression context).
(2,1A)	CI2Var	Convert	Variant -> Integer/Boolean	never dup	(duplicate slot of (0,55) CI2Var) Implicitly coerce a Variant to Integer (assignment, typed argument or typed expression context).
(0,E9)	CI4Cy	Convert	Currency -> Long	emitted	Convert top-of-stack Currency to Long.
(2,21)	CI4Cy	Convert	Currency -> Long	never dup	(alias) Convert top-of-stack Currency to Long.
(0,E8)	CI4R8	Convert	Double -> Long	emitted	Convert top-of-stack Double to Long.
(2,1F)	CI4R8	Convert	Double -> Long	never dup	(alias) Convert top-of-stack Double to Long.
(2,20)	CI4R8	Convert	Double -> Long	never dup	(alias) Convert top-of-stack Double to Long.
(0,50)	CI4Str	Convert	String -> Long	emitted	Convert top-of-stack String to Long.
(2,23)	CI4Str	Convert	String -> Long	never dup	(alias) Convert top-of-stack String to Long.
(0,E7)	CI4UI1	Convert	Byte -> Long	emitted	Convert top-of-stack Byte to Long.
(2,1C)	CI4UI1	Convert	Byte -> Long	never dup	(alias) Convert top-of-stack Byte to Long.
(2,1D)	CI4UI1	Convert	Byte -> Long	never dup	(alias) Convert top-of-stack Byte to Long.
(2,22)	CI4Var	Convert	Variant -> Long	emitted	Implicitly coerce a Variant to Long (assignment, typed argument or typed expression context).
(2,26)	CR4I4	Convert	Long -> Single	never dup	(duplicate slot of (0,EC) CR8I4) Convert top-of-stack Long to Double.
(2,2E)	CR4I4	Convert	Long -> Single	never dup	(duplicate slot of (0,EC) CR8I4) Convert top-of-stack Long to Double.
(0,EA)	CR4R4	Convert	Single -> Single	emitted	Round the floating-point value on the FPU stack to Single precision.
(2,27)	CR4R8	Convert	Double -> Single	never dup	(duplicate slot of (0,EA) CR4R4) Round the floating-point value on the FPU stack to Single precision.
(2,28)	CR4R8	Convert	Double -> Single	never dup	(duplicate slot of (0,EA) CR4R4) Round the floating-point value on the FPU stack to Single precision.
(2,2B)	CR4Str	Convert	String -> Single	emitted	Convert top-of-stack String to Single.
(0,42)	CR4Var	Convert	Variant -> Single	emitted dup	Implicitly coerce a Variant to Double (the slot is named CR4Var, but the compiler uses it for Double targets).
(0,EE)	CR8Cy	Convert	Currency -> Double	emitted	Convert a Currency on the evaluation stack to floating point (FPU).
(2,29)	CR8Cy	Convert	Currency -> Double	never dup	(duplicate slot of (0,EE) CR8Cy) Convert a Currency on the evaluation stack to floating point (FPU).
(2,31)	CR8Cy	Convert	Currency -> Double	never dup	(duplicate slot of (0,EE) CR8Cy) Convert a Currency on the evaluation stack to floating point (FPU).
(0,EB)	CR8I2	Convert	Integer/Boolean -> Double	emitted	Convert top-of-stack Integer to Double.
(0,EC)	CR8I4	Convert	Long -> Double	emitted	Convert top-of-stack Long to Double.
(2,2F)	CR8R4	Convert	Single -> Double	never dup	(duplicate slot of (0,ED) CR8R8) Retype the FPU value as Double (used for Date to Double).
(2,30)	CR8R4	Convert	Single -> Double	never dup	(duplicate slot of (0,ED) CR8R8) Retype the FPU value as Double (used for Date to Double).
(0,ED)	CR8R8	Convert	Double -> Double	emitted	Retype the FPU value as Double (used for Date to Double).
(2,33)	CR8Str	Convert	String -> Double	emitted	Convert top-of-stack String to Double.
(2,2A)	CR8Var	Convert	Variant -> Double	emitted	Implicitly coerce a Variant to Single (the slot is named CR8Var, but the compiler uses it for Single targets).
(2,32)	CR8Var	Convert	Variant -> Double	never dup	(duplicate slot of (2,2A) CR8Var) Implicitly coerce a Variant to Single (the slot is named CR8Var, but the compiler uses it for Single targets).
(2,35)	CRefVarAry	Convert		emitted	Type conversion (CRefVarAry).
(2,3F)	CSng	Convert	Double/Date -> Single	never dup	Type conversion (CSng).
(2,40)	CSng	Convert	Double/Date -> Single	emitted	(alias) Type conversion (CSng).
(0,34)	CStr2Ansi	Convert	2Ansi -> String	emitted	Convert a String argument from Unicode to ANSI for a Declare'd API call.
(2,5A)	CStr2Ansi	Convert	2Ansi -> String	never dup	(duplicate slot of (0,34) CStr2Ansi) Convert a String argument from Unicode to ANSI for a Declare'd API call.
(2,58)	CStr2Uni	Convert	2Uni -> String	emitted	Convert a String from ANSI back to Unicode after a Declare'd API call.
(2,5F)	CStr2Vec	Convert	2Vec -> String	emitted	Convert a String to a Byte array (b() = s).
(2,5B)	CStrAry2Ansi	Convert	Ary2Ansi -> String	emitted	Type conversion (CStrAry2Ansi).
(2,59)	CStrAry2Uni	Convert	Ary2Uni -> String	emitted	Type conversion (CStrAry2Uni).
(4,C7)	CStrBool	Convert	Boolean -> String	emitted	Convert top-of-stack Boolean to String.
(2,01)	CStrCy	Convert	Currency -> String	emitted	Convert top-of-stack Currency to String.
(4,C8)	CStrDate	Convert	Date -> String	emitted	Type conversion (CStrDate).
(1,FC)	CStrI2	Convert	Integer/Boolean -> String	emitted dup	Convert a Byte to a String. (The slot is named CStrI2, but the compiler uses it for Byte sources.)
(1,FE)	CStrI4	Convert	Long -> String	emitted	Convert top-of-stack Long to String.
(1,FF)	CStrR4	Convert	Single -> String	emitted	Convert top-of-stack Single to String.
(2,00)	CStrR8	Convert	Double -> String	emitted	Convert top-of-stack Double to String.
(1,FD)	CStrUI1	Convert	Byte -> String	emitted	Convert an Integer (or Boolean) to a String. (The slot is named CStrUI1, but the compiler uses it for Integer sources.)
(2,02)	CStrVar	Convert	Variant -> String	emitted	Implicitly coerce a Variant to String (assignment, typed argument or typed expression context).
(0,60)	CStrVarTmp	Convert	VarTmp -> String	emitted	Convert a Variant temporary to a String and free the temporary.
(3,FD)	CStrVarTmp	Convert	VarTmp -> String	never dup	(duplicate slot of (0,60) CStrVarTmp) Convert a Variant temporary to a String and free the temporary.
(3,FE)	CStrVarVal	Convert	VarVal -> String	emitted	Convert a Variant to a String in a temporary, without consuming the Variant (ByVal String argument).
(2,38)	CUI1Bool	Convert	Boolean -> Byte	emitted	Convert top-of-stack Boolean to Byte.
(2,11)	CUI1Cy	Convert	Currency -> Byte	emitted	Convert top-of-stack Currency to Byte.
(2,0D)	CUI1I2	Convert	Integer/Boolean -> Byte	emitted	Convert top-of-stack Integer to Byte.
(2,0E)	CUI1I4	Convert	Long -> Byte	emitted	Convert top-of-stack Long to Byte.
(2,0F)	CUI1R4	Convert	Single -> Byte	emitted	Convert top-of-stack Single to Byte.
(2,10)	CUI1R4	Convert	Single -> Byte	emitted dup	(alias) Convert top-of-stack Single to Byte.
(2,13)	CUI1Str	Convert	String -> Byte	emitted	Convert top-of-stack String to Byte.
(2,12)	CUI1Var	Convert	Variant -> Byte	emitted	Implicitly coerce a Variant to Byte (assignment, typed argument or typed expression context).
(2,71)	CUnkVar	Convert		emitted	Type conversion (CUnkVar).
(2,60)	CVar2Vec	Convert	2Vec -> Variant	emitted	Type conversion (CVar2Vec).
(3,6F)	CVarAd	Convert	object -> Variant	emitted	Wrap an object reference in a Variant (VT_DISPATCH) temporary.
(3,FC)	CVarAryVarg	Convert	AryVarg -> Variant	never
(3,F8)	CVarBoolI2	Convert	BoolI2 -> Variant	emitted	Convert top-of-stack Integer to VarBool.
(0,3F)	CVarCy	Convert	Currency -> Variant	emitted	Convert a Currency to a Variant (VT_CY) in a temporary.
(3,6C)	CVarCy	Convert	Currency -> Variant	never dup	Convert a Currency to a Variant (VT_CY) in a temporary.
(3,FB)	CVarDate	Convert	Date -> Variant	emitted	Convert a Date to a Variant (VT_DATE) in a temporary.
(3,F9)	CVarDateVar	Convert	DateVar -> Variant	never
(3,FA)	CVarErrI4	Convert	ErrI4 -> Variant	emitted	Build a VT_ERROR Variant from a Long (CVErr).
(0,44)	CVarI2	Convert	Integer/Boolean -> Variant	emitted	(alias) Convert top-of-stack Integer to Variant.
(3,68)	CVarI2	Convert	Integer/Boolean -> Variant	never dup	(alias) Convert top-of-stack Integer to Variant.
(3,69)	CVarI4	Convert	Long -> Variant	emitted	Convert top-of-stack Long to Variant.
(3,6A)	CVarR4	Convert	Single -> Variant	emitted	Convert top-of-stack Single to Variant.
(3,6B)	CVarR8	Convert	Double -> Variant	emitted	Convert top-of-stack Double to Variant.
(0,4D)	CVarRef	Convert	Ref -> Variant	emitted	Pass a typed variable ByRef to a Variant parameter (build a VT_BYREF Variant in a temporary).
(3,94)	CVarRef	Convert	Ref -> Variant	never dup	Pass a typed variable ByRef to a Variant parameter (build a VT_BYREF Variant in a temporary).
(0,46)	CVarStr	Convert	String -> Variant	emitted	Convert top-of-stack String to Variant.
(3,6E)	CVarStr	Convert	String -> Variant	never dup	Convert top-of-stack String to Variant.
(3,67)	CVarUI1	Convert	Byte -> Variant	emitted	Convert top-of-stack Byte to Variant.
(2,72)	CVarUnk	Convert	IUnknown -> Variant	emitted	Convert an IUnknown reference to a Variant (VT_UNKNOWN).
(2,61)	CVec2Var	Convert		never
(2,4D)	FnCBoolVar	Convert	Variant -> Boolean	emitted	Type conversion (FnCBoolVar).
(2,44)	FnCByteVar	Convert	Variant -> Byte	emitted	Type conversion (FnCByteVar).
(2,49)	FnCCurVar	Convert	Variant -> Currency	emitted	Type conversion (FnCCurVar).
(2,4E)	FnCDateVar	Convert	Variant -> Date	emitted	Type conversion (FnCDateVar).
(2,4F)	FnCDateVar	Convert	Variant -> Date	emitted dup	(alias) Type conversion (FnCDateVar).
(2,39)	FnCDblCy	Convert	Currency -> Double	emitted	Type conversion (FnCDblCy).
(2,3A)	FnCDblR8	Convert	Double -> Double	emitted	Type conversion (FnCDblR8).
(2,3B)	FnCDblR8	Convert	Double -> Double	emitted dup	(alias) Type conversion (FnCDblR8).
(2,48)	FnCDblVar	Convert	Variant -> Double	emitted	Type conversion (FnCDblVar).
(2,45)	FnCIntVar	Convert	Variant -> Integer	emitted	Type conversion (FnCIntVar).
(2,46)	FnCLngVar	Convert	Variant -> Long	emitted	Type conversion (FnCLngVar).
(2,41)	FnCSngCy	Convert	Currency -> Single	emitted	Type conversion (FnCSngCy).
(2,24)	FnCSngI2	Convert	Integer/Boolean -> Single	never dup	Type conversion (FnCSngI2).
(2,25)	FnCSngI2	Convert	Integer/Boolean -> Single	never dup	(alias) Type conversion (FnCSngI2).
(2,2C)	FnCSngI2	Convert	Integer/Boolean -> Single	never dup	(alias) Type conversion (FnCSngI2).
(2,2D)	FnCSngI2	Convert	Integer/Boolean -> Single	never dup	(alias) Type conversion (FnCSngI2).
(2,3C)	FnCSngI2	Convert	Integer/Boolean -> Single	never dup	(alias) Type conversion (FnCSngI2).
(2,3D)	FnCSngI2	Convert	Integer/Boolean -> Single	never dup	(alias) Type conversion (FnCSngI2).
(2,3E)	FnCSngI4	Convert	Long -> Single	emitted	Type conversion (FnCSngI4).
(2,43)	FnCSngStr	Convert	String -> Single	emitted dup	Type conversion (FnCSngStr).
(2,42)	FnCSngVar	Convert	Variant -> Single	emitted	Type conversion (FnCSngVar).
(2,4B)	FnCStrVar	Convert	Variant -> String	emitted	Type conversion (FnCStrVar).
(0,5D)	HardType	Convert		emitted	Type conversion (HardType).
(3,02)	HardType	Convert		never dup	(alias) Type conversion (HardType).

Control flow 27 slots, 18 distinct handlers, 15 emitted

Branches, statement boundaries (BoS), GoSub/On GoTo, End/Stop and For Each exits.

Slot	Mnemonic	Operation	Types	Status	Summary
(5,0B)	Assert	Branch/loop		never	Control-flow primitive: Assert.
(0,00)	BoS	Branch/loop		emitted	Control-flow primitive: BoS.
(0,02)	BoS	Branch/loop		never dup	(alias) Control-flow primitive: BoS.
(2,C4)	BoS	Branch/loop		never dup	Control-flow primitive: BoS.
(5,1C)	BoS	Branch/loop		never dup	Control-flow primitive: BoS.
(0,1E)	Branch	Branch/loop		emitted	Control flow branch (Branch).
(3,03)	Branch	Branch/loop		never dup	Control flow branch (Branch).
(0,1C)	BranchF	Branch/loop		emitted	Control flow branch (BranchF).
(3,04)	BranchF	Branch/loop		never dup	Control flow branch (BranchF).
(0,5C)	BranchFVar	Branch/loop		never
(3,05)	BranchFVar	Branch/loop		never dup
(3,06)	BranchFVarFree	Branch/loop		never
(0,1D)	BranchT	Branch/loop		emitted	Pop a Boolean and branch if it is True.
(3,07)	BranchT	Branch/loop		never dup	Pop a Boolean and branch if it is True.
(3,08)	BranchTVar	Branch/loop		never
(3,09)	BranchTVarFree	Branch/loop		never
(2,C8)	End	Branch/loop		emitted	Control-flow primitive: End.
(3,CE)	ExitForAryVar	Branch/loop	For Each exit	emitted	Exit For out of a For Each loop over an array, with a Variant control variable.
(3,CB)	ExitForCollObj	Branch/loop	For Each exit	emitted dup	Exit For out of a For Each over a collection whose control variable is a specific class.
(3,CC)	ExitForCollObj	Branch/loop	For Each exit	emitted dup	Exit For out of a For Each over a collection whose control variable is a specific class.
(3,CD)	ExitForCollObj	Branch/loop	For Each exit	emitted	Exit For out of a For Each over a collection whose control variable is a specific class.
(3,CF)	ExitForVar	Branch/loop	For Each exit	emitted	Exit For out of a For Each over a Variant-held collection/array.
(3,0A)	Gosub	Branch/loop		emitted	Push a return address and jump to a local GoSub label.
(4,95)	OnGosub	Branch/loop		emitted	Computed On n GoSub: pop an Integer selector and GoSub to the n-th label.
(4,96)	OnGoto	Branch/loop		emitted	Computed On n GoTo: pop an Integer selector and jump to the n-th label.
(2,C9)	Return	Branch/loop		emitted	Control-flow primitive: Return.
(2,C2)	Stop	Branch/loop		emitted	Control-flow primitive: Stop.

Error handling 7 slots, 4 distinct handlers, 4 emitted

On Error, Resume, Error and the LastDllError capture after Declare calls.

Slot	Mnemonic	Operation	Types	Status	Summary
(0,45)	Error	Other		emitted	Error n statement: raise run-time error n.
(2,C1)	Error	Other		never dup	(duplicate slot of (0,45) Error) Error n statement: raise run-time error n.
(0,4B)	OnErrorGoto	Other		emitted	On Error statement: set the procedure's error-handling mode.
(3,0B)	OnErrorGoto	Other		never dup	On Error statement: set the procedure's error-handling mode.
(3,0C)	Resume	Other		emitted	Resume statement: leave an error handler and continue execution.
(0,3C)	SetLastSystemError	Other		emitted	Capture GetLastError after a Declare'd API call (for Err.LastDllError).
(2,62)	SetLastSystemError	Other		never dup	(duplicate slot of (0,3C) SetLastSystemError) Capture GetLastError after a Declare'd API call (for Err.LastDllError).

Procedure call/return 37 slots, 18 distinct handlers, 16 emitted

Calls to module procedures, Declare'd APIs and runtime functions, and procedure epilogues (ExitProc*).

Slot	Mnemonic	Operation	Types	Status	Summary
(0,0C)	ImpAdCallCy	Call	module procedure / Declare / runtime	emitted	Call a procedure/import that returns Currency (EDX:EAX); push the result.
(4,25)	ImpAdCallCy	Call	module procedure / Declare / runtime	never dup	Call a procedure/import that returns Currency (EDX:EAX); push the result.
(0,0A)	ImpAdCallFPR4	Call	module procedure / Declare / runtime	emitted	Call a procedure or import whose result is not returned in EAX: Subs, discarded results, and FPU/Variant returns.
(4,29)	ImpAdCallFPR4	Call	module procedure / Declare / runtime	never dup	Call a procedure or import whose result is not returned in EAX: Subs, discarded results, and FPU/Variant returns.
(4,2A)	ImpAdCallFPR4	Call	module procedure / Declare / runtime	never dup	Call a procedure or import whose result is not returned in EAX: Subs, discarded results, and FPU/Variant returns.
(4,2C)	ImpAdCallFPR4	Call	module procedure / Declare / runtime	never dup	Call a procedure or import whose result is not returned in EAX: Subs, discarded results, and FPU/Variant returns.
(0,09)	ImpAdCallHresult	Call	module procedure / Declare / runtime	emitted	Call an HRESULT-returning runtime helper; raise on failure.
(4,4F)	ImpAdCallHresult	Call	module procedure / Declare / runtime	never dup	Call an HRESULT-returning runtime helper; raise on failure.
(0,0B)	ImpAdCallI2	Call	module procedure / Declare / runtime	emitted	Call a procedure or import and push its 32-bit EAX result (Integer, Boolean, String or Object returns).
(0,5E)	ImpAdCallI4	Call	module procedure / Declare / runtime	emitted dup	Call a procedure or import and push its 32-bit Long result (EAX).
(4,21)	ImpAdCallI4	Call	module procedure / Declare / runtime	never dup	Call a procedure or import and push its 32-bit EAX result (Integer, Boolean, String or Object returns).
(4,22)	ImpAdCallI4	Call	module procedure / Declare / runtime	never dup	Call a procedure or import and push its 32-bit EAX result (Integer, Boolean, String or Object returns).
(4,27)	ImpAdCallI4	Call	module procedure / Declare / runtime	never dup	Call a procedure or import and push its 32-bit EAX result (Integer, Boolean, String or Object returns).
(4,28)	ImpAdCallI4	Call	module procedure / Declare / runtime	never dup	Call a procedure or import and push its 32-bit EAX result (Integer, Boolean, String or Object returns).
(5,1E)	ImpAdCallNonVirt	Call	module procedure / Declare / runtime	emitted	Non-virtual (direct) call to a Friend procedure of a class.
(4,23)	ImpAdCallR4	Call	module procedure / Declare / runtime	never
(4,24)	ImpAdCallR8	Call	module procedure / Declare / runtime	never
(4,20)	ImpAdCallUI1	Call	module procedure / Declare / runtime	emitted	Call a runtime/import function that returns a Byte (AL); push the result.
(3,95)	ExitProcCb	Return	Variant via buffer	emitted	Return from a module Function returning a Variant (copy the result to the caller's buffer).
(5,2F)	ExitProcCbHresult	Return	COM method value	emitted	Return from a class/form method that produces a value: copy it to the [out, retval] parameter and return S_OK.
(3,96)	ExitProcCbStack	Return	stack args	never
(0,18)	ExitProcCy	Return	Currency	emitted	Return from a Function whose return type is Currency.
(2,D1)	ExitProcCy	Return	Currency	never dup	Return from a Function whose return type is Currency.
(0,13)	ExitProcHresult	Return	COM method (HRESULT)	emitted	Return S_OK from a class/form method that produces no value (Sub, Property Let/Set).
(2,6D)	ExitProcHresult	Return	COM method (HRESULT)	never dup	Return S_OK from a class/form method that produces no value (Sub, Property Let/Set).
(0,15)	ExitProcI2	Return	Integer/Boolean	emitted	Return from a module Function returning Integer or Boolean.
(2,CD)	ExitProcI2	Return	Integer/Boolean	never dup	Return from a module Function returning Integer or Boolean.
(0,14)	ExitProcI4	Return	Long/String/Sub	emitted	Return from a module Sub, or from a Function returning Long or String.
(0,16)	ExitProcR4	Return	Single	emitted	Return from a module Function returning Single (FPU).
(2,CF)	ExitProcR4	Return	Single	never dup	Return from a module Function returning Single (FPU).
(0,17)	ExitProcR8	Return	Double/Date	emitted	Return from a Function whose return type is Double or Date (FPU return).
(2,D0)	ExitProcR8	Return	Double/Date	never dup	Return from a Function whose return type is Double or Date (FPU return).
(2,CE)	ExitProcStr	Return	String	never dup	Return from a module Sub, or from a Function returning Long or String.
(2,D3)	ExitProcStr	Return	String	never dup	(duplicate slot of (0,14) ExitProcI4) Return from a module Sub, or from a Function returning Long or String.
(2,D4)	ExitProcStr	Return	String	never dup	(duplicate slot of (0,14) ExitProcI4) Return from a module Sub, or from a Function returning Long or String.
(2,D5)	ExitProcStr	Return	String	never dup	(duplicate slot of (0,14) ExitProcI4) Return from a module Sub, or from a Function returning Long or String.
(2,CC)	ExitProcUI1	Return	Byte	emitted	Return from a Function whose return type is Byte.

File I/O & Print 43 slots, 43 distinct handlers, 20 emitted

Open/Close, Get/Put, Input/Write/Print #, Lock and Seek, plus the never-emitted legacy per-item Print opcodes.

Slot	Mnemonic	Operation	Types	Status	Summary
(3,3D)	Close	I/O		emitted	File I/O primitive: Close.
(3,3E)	CloseAll	I/O		emitted	File I/O primitive: CloseAll.
(2,75)	GetRec3	I/O		emitted	File I/O primitive: GetRec3.
(2,76)	GetRec4	I/O		emitted	File I/O primitive: GetRec4.
(5,12)	GetRecFxStr3	I/O		emitted	File I/O primitive: GetRecFxStr3.
(5,13)	GetRecFxStr4	I/O		emitted	File I/O primitive: GetRecFxStr4.
(2,7D)	Input	I/O		never	File I/O primitive: Input.
(2,7E)	InputDone	I/O		never	File I/O primitive: InputDone.
(5,10)	InputFile	I/O		emitted	Input # statement: read a list of items, one descriptor-driven call.
(2,87)	InputItemBool	I/O		never	File I/O primitive: InputItemBool.
(2,84)	InputItemCy	I/O		never	File I/O primitive: InputItemCy.
(2,88)	InputItemDate	I/O		never	File I/O primitive: InputItemDate.
(2,80)	InputItemI2	I/O		never	File I/O primitive: InputItemI2.
(2,81)	InputItemI4	I/O		never	File I/O primitive: InputItemI4.
(2,82)	InputItemR4	I/O		never	File I/O primitive: InputItemR4.
(2,83)	InputItemR8	I/O		never	File I/O primitive: InputItemR8.
(2,86)	InputItemStr	I/O		never	File I/O primitive: InputItemStr.
(2,7F)	InputItemUI1	I/O		never	File I/O primitive: InputItemUI1.
(2,85)	InputItemVar	I/O		never	File I/O primitive: InputItemVar.
(2,C0)	LineInputStr	I/O		emitted	File I/O primitive: LineInputStr.
(2,BF)	LineInputVar	I/O		emitted	File I/O primitive: LineInputVar.
(4,5E)	LockFile	I/O		emitted	Lock / Unlock statement.
(1,FB)	NameFile	I/O		emitted	File I/O primitive: NameFile.
(4,5D)	OpenFile	I/O		emitted	Open statement: pop file name, file number and record length; open the file.
(3,32)	PrintChan	I/O		never	Legacy per-item Print opcode (selects the output channel (file number)); never emitted by VB6 SP6.
(3,34)	PrintComma	I/O		never	Legacy per-item Print opcode (advances to the next print zone (,)); never emitted by VB6 SP6.
(3,35)	PrintEos	I/O		never	Legacy per-item Print opcode (ends the statement (flushes, no newline)); never emitted by VB6 SP6.
(5,0E)	PrintFile	I/O		emitted	Write a value to a #-numbered file or to the immediate window.
(3,37)	PrintItemComma	I/O		never	Legacy per-item Print opcode (prints one item followed by ,); never emitted by VB6 SP6.
(3,39)	PrintItemNL	I/O		never	Legacy per-item Print opcode (prints one item followed by a newline); never emitted by VB6 SP6.
(3,38)	PrintItemSemi	I/O		never	Legacy per-item Print opcode (prints one item followed by ;); never emitted by VB6 SP6.
(3,36)	PrintNL	I/O		never	Legacy per-item Print opcode (writes a newline); never emitted by VB6 SP6.
(3,3A)	PrintObj	I/O		never
(5,0D)	PrintObject	I/O		emitted	Print method on an object (form, picture box, Printer): one descriptor-driven call for the whole item list.
(3,3B)	PrintSpc	I/O		never	Legacy per-item Print opcode (writes Spc(n) spaces); never emitted by VB6 SP6.
(3,3C)	PrintTab	I/O		never	Legacy per-item Print opcode (moves to Tab(n) column); never emitted by VB6 SP6.
(2,77)	PutRec3	I/O		emitted	File I/O primitive: PutRec3.
(2,78)	PutRec4	I/O		emitted	File I/O primitive: PutRec4.
(5,14)	PutRecFxStr3	I/O		emitted	File I/O primitive: PutRecFxStr3.
(5,15)	PutRecFxStr4	I/O		emitted	File I/O primitive: PutRecFxStr4.
(1,FA)	SeekFile	I/O		emitted	File I/O primitive: SeekFile.
(3,33)	WriteChan	I/O		never	File I/O primitive: WriteChan.
(5,0F)	WriteFile	I/O		emitted	Write # statement: write a list of items, one descriptor-driven call.

Stack & frame 56 slots, 33 distinct handlers, 26 emitted

Frame-slot references, temporaries, pops and cleanup (FFree*) that are not tied to one value type.

Slot	Mnemonic	Operation	Types	Status	Summary
(0,1A)	FFree1Ad	Free/cleanup	String/Variant/object temporaries	emitted	Free heap-backed frame slot(s): FFree1Ad.
(3,9B)	FFree1Ad	Free/cleanup	String/Variant/object temporaries	never dup	Free heap-backed frame slot(s): FFree1Ad.
(0,2F)	FFree1Str	Free/cleanup	String/Variant/object temporaries	emitted	Free heap-backed frame slot(s): FFree1Str.
(3,9A)	FFree1Str	Free/cleanup	String/Variant/object temporaries	never dup	Free heap-backed frame slot(s): FFree1Str.
(0,35)	FFree1Var	Free/cleanup	String/Variant/object temporaries	emitted	Free heap-backed frame slot(s): FFree1Var.
(3,99)	FFree1Var	Free/cleanup	String/Variant/object temporaries	never dup	Free heap-backed frame slot(s): FFree1Var.
(0,29)	FFreeAd	Free/cleanup	String/Variant/object temporaries	emitted	Free heap-backed frame slot(s): FFreeAd.
(4,B4)	FFreeAd	Free/cleanup	String/Variant/object temporaries	never dup	Free heap-backed frame slot(s): FFreeAd.
(0,32)	FFreeStr	Free/cleanup	String/Variant/object temporaries	emitted	Free heap-backed frame slot(s): FFreeStr.
(4,B3)	FFreeStr	Free/cleanup	String/Variant/object temporaries	never dup	Free heap-backed frame slot(s): FFreeStr.
(0,36)	FFreeVar	Free/cleanup	String/Variant/object temporaries	emitted	Free heap-backed frame slot(s): FFreeVar.
(4,B2)	FFreeVar	Free/cleanup	String/Variant/object temporaries	never dup	Free heap-backed frame slot(s): FFreeVar.
(4,CE)	FreeAdNoPop	Free/cleanup	String/Variant/object temporaries	never	Free heap-backed frame slot(s): FreeAdNoPop.
(4,CC)	FreeStrNoPop	Free/cleanup	String/Variant/object temporaries	never	Free heap-backed frame slot(s): FreeStrNoPop.
(4,CD)	FreeVarNoPop	Free/cleanup	String/Variant/object temporaries	never	Free heap-backed frame slot(s): FreeVarNoPop.
(0,07)	FMemLdRf	Load	address (reference), via frame pointer	emitted	Load a reference (ByRef slot) via [frame[%a] + offset] (FMemLdRf).
(3,D6)	FMemLdRf	Load	address (reference), via frame pointer	never dup	Load a reference (ByRef slot) via [frame[%a] + offset] (FMemLdRf).
(3,DC)	FMemLdRf	Load	address (reference), via frame pointer	never dup	Load a reference (ByRef slot) via [frame[%a] + offset] (FMemLdRf).
(0,6C)	ILdRf	Load	address (reference), ByRef/indirect	emitted	Re-load the pointer held in a ByRef frame slot [ebp+%a]; push it as a typed reference.
(3,4C)	IWMemLdRf	Load	address (reference), W-base indirect	never	LOAD through a reference / ByRef slot at [W-base+offset] -> [eax], one extra dereference (4-byte (reference), W+indirect).
(0,05)	ImpAdLdRf	Load	address (reference), global	emitted	Load through an imported address (ImpAdLdRf).
(3,A6)	ImpAdLdRf	Load	address (reference), global	never dup	Load through an imported address (ImpAdLdRf).
(3,AC)	ImpAdLdRf	Load	address (reference), global	never dup	Load through an imported address (ImpAdLdRf).
(4,F6)	DestructAnsiOFrame	Other		emitted	Frame-slot manipulation (DestructAnsiOFrame).
(0,04)	FLdRfVar	Other		emitted	Push a reference (ByRef pointer) to a Variant local/argument at [ebp+%a].
(2,E6)	FLdRfVar	Other		never dup	Push a reference (ByRef pointer) to a Variant local/argument at [ebp+%a].
(2,EC)	FLdRfVar	Other		never dup	Push a reference (ByRef pointer) to a Variant local/argument at [ebp+%a].
(4,2F)	LdFrameRf	Other		never
(4,2E)	LdStkRf	Other		never
(0,06)	MemLdRfVar	Other		emitted	Load a ByRef Variant slot from [pr + offset] where pr is on the stack.
(3,76)	MemLdRfVar	Other		never dup	Load a ByRef Variant slot from [pr + offset] where pr is on the stack.
(3,7C)	MemLdRfVar	Other		never dup	Load a ByRef Variant slot from [pr + offset] where pr is on the stack.
(2,8B)	PopAd	Other		emitted	Discard the top raw 32-bit address (pointer) from the stack.
(0,49)	PopAdLd4	Other		emitted	Discard the top value from the stack.
(2,5C)	PopAdLd4	Other		never dup	(alias) Discard the top value from the stack.
(0,25)	PopAdLdVar	Other		emitted	Discard the top VBA Variant from the stack.
(2,8C)	PopAdLdVar	Other		never dup	(alias) Discard the top VBA Variant from the stack.
(0,37)	PopFPR4	Other		emitted	Discard the top Single on the x87 FPU stack from the stack.
(2,89)	PopFPR4	Other		never dup	(alias) Discard the top Single on the x87 FPU stack from the stack.
(0,39)	PopFPR8	Other		emitted	Discard the top Double on the x87 FPU stack from the stack.
(2,8A)	PopFPR8	Other		never dup	(alias) Discard the top Double on the x87 FPU stack from the stack.
(3,C2)	PopTmpLdAd1	Other		emitted	Pop temporary and reload value (PopTmpLdAd1).
(0,2B)	PopTmpLdAd2	Other		emitted	Pop temporary and reload value (PopTmpLdAd2).
(3,C3)	PopTmpLdAd2	Other		never dup	Pop temporary and reload value (PopTmpLdAd2).
(0,30)	PopTmpLdAd8	Other		emitted	Pop an 8-byte value into a temporary and push the temporary's address (ByRef temp for Currency).
(3,C5)	PopTmpLdAd8	Other		never dup	Pop an 8-byte value into a temporary and push the temporary's address (ByRef temp for Currency).
(3,C8)	PopTmpLdAdFPR4	Other		emitted	Pop a Single from the FPU into a temporary and push its address (ByRef temp).
(3,C9)	PopTmpLdAdFPR8	Other		emitted	Pop a Double from the FPU into a temporary and push its address (ByRef temp).
(0,59)	PopTmpLdAdStr	Other		emitted	(alias) Pop temporary and reload value (PopTmpLdAdStr).
(3,C4)	PopTmpLdAdStr	Other		never dup	(alias) Pop temporary and reload value (PopTmpLdAdStr).
(3,C7)	PopTmpLdAdStr	Other		emitted dup	(alias) Pop temporary and reload value (PopTmpLdAdStr).
(3,C6)	PopTmpLdAdVar	Other		never
(4,D6)	WMemLdRfVar	Other		never	LOAD a Variant ByRef reference at [W-base+offset] via the procedure's secondary-object pointer [ebp+10h] (W-base) (4-byte (reference)).
(4,DC)	WMemLdRfVar	Other		never dup	LOAD a Variant ByRef reference at [W-base+offset] via the procedure's secondary-object pointer [ebp+10h] (W-base) (4-byte (reference)).
(5,2D)	ZeroRetVal	Other		emitted	Frame-slot manipulation (ZeroRetVal).
(5,2E)	ZeroRetValVar	Other		emitted	Frame-slot manipulation (ZeroRetValVar).

Structural 7 slots, 6 distinct handlers, 0 emitted

Dispatch-table trampolines (lead bytes) and invalid slots.

Slot	Mnemonic	Operation	Types	Status	Summary
(0,03)	InvalidExcode	Other	dispatch trampoline / invalid slot	- dup
(0,FB)	Lead0	Other	dispatch trampoline / invalid slot	-
(0,FC)	Lead1	Other	dispatch trampoline / invalid slot	-
(0,FD)	Lead2	Other	dispatch trampoline / invalid slot	-
(0,FE)	Lead3	Other	dispatch trampoline / invalid slot	-
(0,FF)	Lead4	Other	dispatch trampoline / invalid slot	-
(0,01)	vbDecNop	Other	dispatch trampoline / invalid slot	-