diff --git a/src/contract/operations.rs b/src/contract/operations.rs
index 0d0eb58a..bcf65738 100644
--- a/src/contract/operations.rs
+++ b/src/contract/operations.rs
@@ -24,7 +24,7 @@ use std::cmp::Ordering;
 use std::collections::{btree_map, btree_set, BTreeMap};
 use std::iter;
 
-use amplify::confinement::{Confined, SmallBlob, TinyOrdMap, TinyOrdSet};
+use amplify::confinement::{Confined, SmallBlob, SmallOrdSet, TinyOrdMap, TinyOrdSet};
 use amplify::Wrapper;
 use commit_verify::{
     CommitEncode, CommitEngine, CommitId, Conceal, MerkleHash, MerkleLeaves, StrictHash,
@@ -105,7 +105,7 @@ impl<'a> IntoIterator for &'a Redeemed {
     derive(Serialize, Deserialize),
     serde(crate = "serde_crate", transparent)
 )]
-pub struct Inputs(TinyOrdSet<Input>);
+pub struct Inputs(SmallOrdSet<Input>);
 
 impl<'a> IntoIterator for &'a Inputs {
     type Item = Input;
diff --git a/src/stl.rs b/src/stl.rs
index 236d029e..ae92c191 100644
--- a/src/stl.rs
+++ b/src/stl.rs
@@ -34,7 +34,7 @@ use crate::{
 
 /// Strict types id for the library providing data types for RGB consensus.
 pub const LIB_ID_RGB: &str =
-    "urn:ubideco:stl:2nWgjeSMhVE2mKgC7WyE5Dn8a6tZJDMoNugDWdc4vcZZ#spring-moral-almanac";
+    "urn:ubideco:stl:HqdNNAehK3yaQ1AC5pQmEuNNS1zgyo2Jw31fdUNKb9MU#annual-virus-garlic";
 
 fn _rgb_core_stl() -> Result<TypeLib, CompileError> {
     LibBuilder::new(libname!(LIB_NAME_RGB), tiny_bset! {
diff --git a/src/vm/macroasm.rs b/src/vm/macroasm.rs
index ccc85a78..18c98d68 100644
--- a/src/vm/macroasm.rs
+++ b/src/vm/macroasm.rs
@@ -23,6 +23,8 @@
 #[macro_export]
 macro_rules! rgbasm {
     ($( $tt:tt )+) => {{ #[allow(unused_imports)] {
+        use amplify::num::{u4, u5};
+        use $crate::{AssignmentType, GlobalStateType};
         use $crate::vm::{RgbIsa, ContractOp, TimechainOp};
         use $crate::vm::aluasm_isa;
         use $crate::isa_instr;
@@ -34,8 +36,28 @@ macro_rules! rgbasm {
 macro_rules! isa_instr {
     (pcvs $no:literal) => {{ RgbIsa::Contract(ContractOp::PcVs($no.into())) }};
     (pccs $no1:literal, $no2:literal) => {{ RgbIsa::Contract(ContractOp::PcCs($no1.into(), $no2.into())) }};
-    (ldg $t:literal, $no:literal,s16[$s_idx:literal]) => {{ RgbIsa::Contract(ContractOp::LdG($t.into(), $no, RegS::from($s_idx))) }};
-    (lds $t:literal, $no:literal,s16[$s_idx:literal]) => {{ RgbIsa::Contract(ContractOp::LdS($t.into(), $no, RegS::from($s_idx))) }};
-    (ldp $t:literal, $no:literal,s16[$s_idx:literal]) => {{ RgbIsa::Contract(ContractOp::LdP($t.into(), $no, RegS::from($s_idx))) }};
+    (cng $t:literal,a8[$a_idx:literal]) => {{ RgbIsa::Contract(ContractOp::CnG($t.into(), Reg32::from(u5::with($a_idx)))) }};
+    (cnc $t:literal,a16[$a_idx:literal]) => {{ RgbIsa::Contract(ContractOp::CnC($t.into(), Reg32::from(u5::with($a_idx)))) }};
+    (ldg $t:literal,a8[$a_idx:literal],s16[$s_idx:literal]) => {{
+        RgbIsa::Contract(ContractOp::LdG(
+            GlobalStateType::from($t as u16),
+            Reg16::from(u4::with($a_idx)),
+            RegS::from($s_idx),
+        ))
+    }};
+    (ldp $t:literal,a16[$a_idx:literal],s16[$s_idx:literal]) => {{
+        RgbIsa::Contract(ContractOp::LdP(
+            AssignmentType::from($t as u16),
+            Reg16::from(u4::with($a_idx)),
+            RegS::from($s_idx),
+        ))
+    }};
+    (lds $t:literal,a16[$a_idx:literal],s16[$s_idx:literal]) => {{
+        RgbIsa::Contract(ContractOp::LdS(
+            AssignmentType::from($t as u16),
+            Reg16::from(u4::with($a_idx)),
+            RegS::from($s_idx),
+        ))
+    }};
     ($op:ident $($tt:tt)+) => {{ compile_error!(concat!("unknown RGB assembly opcode `", stringify!($op), "`")) }};
 }
diff --git a/src/vm/op_contract.rs b/src/vm/op_contract.rs
index dfc9fc03..fb6be596 100644
--- a/src/vm/op_contract.rs
+++ b/src/vm/op_contract.rs
@@ -27,7 +27,7 @@ use std::ops::RangeInclusive;
 
 use aluvm::isa::{Bytecode, BytecodeError, ExecStep, InstructionSet};
 use aluvm::library::{CodeEofError, LibSite, Read, Write};
-use aluvm::reg::{CoreRegs, Reg, Reg32, RegA, RegS};
+use aluvm::reg::{CoreRegs, Reg, Reg16, Reg32, RegA, RegS};
 use amplify::num::{u3, u4};
 use amplify::Wrapper;
 use commit_verify::CommitVerify;
@@ -61,55 +61,55 @@ pub enum ContractOp {
     #[display("cnc     {0},a16{1}")]
     CnC(AssignmentType, Reg32),
 
-    /// Loads input (previous) state with type id from the first argument and
-    /// index from the second argument into a register provided in the third
-    /// argument.
+    /// Loads input (previous) structured state with type id from the first
+    /// argument and index from the second argument `a16` register into a
+    /// register provided in the third argument.
     ///
     /// If the state is absent or is not a structured state sets `st0` to
     /// `false` and terminates the program.
     ///
     /// If the state at the index is concealed, sets destination to `None`.
-    #[display("ldp     {0},{1},{2}")]
-    LdP(AssignmentType, u16, RegS),
+    #[display("ldp     {0},a16{1},{2}")]
+    LdP(AssignmentType, Reg16, RegS),
 
     /// Loads owned structured state with type id from the first argument and
-    /// index from the second argument into a register provided in the third
-    /// argument.
+    /// index from the second argument `a16` register into a register provided
+    /// in the third argument.
     ///
     /// If the state is absent or is not a structured state sets `st0` to
     /// `false` and terminates the program.
     ///
     /// If the state at the index is concealed, sets destination to `None`.
-    #[display("lds     {0},{1},{2}")]
-    LdS(AssignmentType, u16, RegS),
+    #[display("lds     {0},a16{1},{2}")]
+    LdS(AssignmentType, Reg16, RegS),
 
     /// Loads owned fungible state with type id from the first argument and
-    /// index from the second argument into `a64` register provided in the third
-    /// argument.
+    /// index from the second argument `a16` register into `a64` register
+    /// provided in the third argument.
     ///
     /// If the state is absent or is not a fungible state sets `st0` to
     /// `false` and terminates the program.
     ///
     /// If the state at the index is concealed, sets destination to `None`.
-    #[display("ldf     {0},{1},a64{2}")]
-    LdF(AssignmentType, u16, Reg32),
+    #[display("ldf     {0},a16{1},a64{2}")]
+    LdF(AssignmentType, Reg16, Reg16),
 
     /// Loads global state from the current operation with type id from the
-    /// first argument and index from the second argument into a register
-    /// provided in the third argument.
+    /// first argument and index from the second argument `a8` register into a
+    /// register provided in the third argument.
     ///
     /// If the state is absent sets `st0` to `false` and terminates the program.
-    #[display("ldg     {0},{1},{2}")]
-    LdG(GlobalStateType, u8, RegS),
+    #[display("ldg     {0},a8{1},{2}")]
+    LdG(GlobalStateType, Reg16, RegS),
 
     /// Loads part of the contract global state with type id from the first
-    /// argument at the depth from the second argument into a register
-    /// provided in the third argument.
+    /// argument at the depth from the second argument `a32` register into a
+    /// register provided in the third argument.
     ///
     /// If the state is absent or concealed sets destination to `None`.
     /// Does not modify content of `st0` register.
-    #[display("ldc     {0},{1},{2}")]
-    LdC(GlobalStateType, u16, RegS),
+    #[display("ldc     {0},a32{1},{2}")]
+    LdC(GlobalStateType, Reg16, RegS),
 
     /// Loads operation metadata into a register provided in the third argument.
     ///
@@ -157,31 +157,45 @@ impl InstructionSet for ContractOp {
 
     fn isa_ids() -> BTreeSet<&'static str> { none!() }
 
-    fn src_regs(&self) -> BTreeSet<Reg> { bset![] }
+    fn src_regs(&self) -> BTreeSet<Reg> {
+        match self {
+            ContractOp::LdP(_, reg, _) |
+            ContractOp::LdF(_, reg, _) |
+            ContractOp::LdS(_, reg, _) => bset![Reg::A(RegA::A16, (*reg).into())],
+            ContractOp::LdG(_, reg, _) => bset![Reg::A(RegA::A8, (*reg).into())],
+            ContractOp::LdC(_, reg, _) => bset![Reg::A(RegA::A32, (*reg).into())],
+
+            ContractOp::CnP(_, _) |
+            ContractOp::CnS(_, _) |
+            ContractOp::CnG(_, _) |
+            ContractOp::CnC(_, _) => bset![],
+            ContractOp::LdM(_) => bset![],
+            ContractOp::PcVs(_) | ContractOp::PcCs(_, _) => bset![],
+            ContractOp::Fail(_) => bset![],
+        }
+    }
 
     fn dst_regs(&self) -> BTreeSet<Reg> {
         match self {
-            ContractOp::CnP(_, reg) |
-            ContractOp::CnS(_, reg) |
-            ContractOp::CnG(_, reg) |
-            ContractOp::CnC(_, reg) => {
+            ContractOp::CnG(_, reg) => {
+                bset![Reg::A(RegA::A8, *reg)]
+            }
+            ContractOp::CnP(_, reg) | ContractOp::CnS(_, reg) | ContractOp::CnC(_, reg) => {
                 bset![Reg::A(RegA::A16, *reg)]
             }
             ContractOp::LdF(_, _, reg) => {
-                bset![Reg::A(RegA::A64, *reg)]
+                bset![Reg::A(RegA::A64, (*reg).into())]
             }
-            ContractOp::LdP(_, _, reg) |
-            ContractOp::LdS(_, _, reg) |
             ContractOp::LdG(_, _, reg) |
+            ContractOp::LdS(_, _, reg) |
+            ContractOp::LdP(_, _, reg) |
             ContractOp::LdC(_, _, reg) |
             ContractOp::LdM(reg) => {
                 bset![Reg::S(*reg)]
             }
-
             ContractOp::PcVs(_) | ContractOp::PcCs(_, _) => {
                 bset![]
             }
-
             ContractOp::Fail(_) => bset![],
         }
     }
@@ -246,55 +260,76 @@ impl InstructionSet for ContractOp {
                 );
             }
             ContractOp::CnG(state_type, reg) => {
-                regs.set_n(RegA::A16, *reg, context.global.get(state_type).map(|a| a.len_u16()));
+                regs.set_n(RegA::A8, *reg, context.global.get(state_type).map(|a| a.len_u16()));
             }
             ContractOp::CnC(_state_type, _reg) => {
                 // TODO: implement global contract state
                 fail!()
             }
-            ContractOp::LdP(state_type, index, reg) => {
+            ContractOp::LdP(state_type, reg_32, reg) => {
+                let Some(reg_32) = *regs.get_n(RegA::A16, *reg_32) else {
+                    fail!()
+                };
+                let index: u16 = reg_32.into();
+
                 let Some(Ok(state)) = context
                     .prev_state
                     .get(state_type)
-                    .map(|a| a.as_structured_state_at(*index))
+                    .map(|a| a.as_structured_state_at(index))
                 else {
                     fail!()
                 };
                 let state = state.map(|s| s.value.as_inner());
                 regs.set_s(*reg, state);
             }
-            ContractOp::LdS(state_type, index, reg) => {
+            ContractOp::LdS(state_type, reg_32, reg) => {
+                let Some(reg_32) = *regs.get_n(RegA::A16, *reg_32) else {
+                    fail!()
+                };
+                let index: u16 = reg_32.into();
+
                 let Some(Ok(state)) = context
                     .owned_state
                     .get(*state_type)
-                    .map(|a| a.into_structured_state_at(*index))
+                    .map(|a| a.into_structured_state_at(index))
                 else {
                     fail!()
                 };
                 let state = state.map(|s| s.value.into_inner());
                 regs.set_s(*reg, state);
             }
-            ContractOp::LdF(state_type, index, reg) => {
+            ContractOp::LdF(state_type, reg_32, reg) => {
+                let Some(reg_32) = *regs.get_n(RegA::A16, *reg_32) else {
+                    fail!()
+                };
+                let index: u16 = reg_32.into();
+
                 let Some(Ok(state)) = context
                     .owned_state
                     .get(*state_type)
-                    .map(|a| a.into_fungible_state_at(*index))
+                    .map(|a| a.into_fungible_state_at(index))
                 else {
                     fail!()
                 };
                 regs.set_n(RegA::A64, *reg, state.map(|s| s.value.as_u64()));
             }
-            ContractOp::LdG(state_type, index, reg) => {
+            ContractOp::LdG(state_type, reg_32, reg_s) => {
+                let Some(reg_32) = *regs.get_n(RegA::A8, *reg_32) else {
+                    fail!()
+                };
+                let index: u8 = reg_32.into();
+
                 let Some(state) = context
                     .global
                     .get(state_type)
-                    .and_then(|a| a.get(*index as usize))
+                    .and_then(|a| a.get(index as usize))
                 else {
                     fail!()
                 };
-                regs.set_s(*reg, Some(state.value.as_inner()));
+                regs.set_s(*reg_s, Some(state.value.as_inner()));
             }
-            ContractOp::LdC(_state_type, _index, _reg) => {
+
+            ContractOp::LdC(_state_type, _reg_32, _reg_s) => {
                 // TODO: implement global contract state
                 fail!()
             }
@@ -360,11 +395,11 @@ impl Bytecode for ContractOp {
             ContractOp::CnG(_, _) |
             ContractOp::CnC(_, _) => 4,
 
-            ContractOp::LdP(_, _, _) |
             ContractOp::LdS(_, _, _) |
+            ContractOp::LdP(_, _, _) |
             ContractOp::LdF(_, _, _) |
-            ContractOp::LdC(_, _, _) => 6,
-            ContractOp::LdG(_, _, _) => 5,
+            ContractOp::LdC(_, _, _) |
+            ContractOp::LdG(_, _, _) => 4,
             ContractOp::LdM(_) => 2,
 
             ContractOp::PcVs(_) => 3,
@@ -383,10 +418,10 @@ impl Bytecode for ContractOp {
             ContractOp::CnG(_, _) => INSTR_CNG,
             ContractOp::CnC(_, _) => INSTR_CNC,
 
-            ContractOp::LdP(_, _, _) => INSTR_LDP,
+            ContractOp::LdG(_, _, _) => INSTR_LDG,
             ContractOp::LdS(_, _, _) => INSTR_LDS,
+            ContractOp::LdP(_, _, _) => INSTR_LDP,
             ContractOp::LdF(_, _, _) => INSTR_LDF,
-            ContractOp::LdG(_, _, _) => INSTR_LDG,
             ContractOp::LdC(_, _, _) => INSTR_LDC,
             ContractOp::LdM(_) => INSTR_LDM,
 
@@ -420,35 +455,30 @@ impl Bytecode for ContractOp {
                 writer.write_u5(reg)?;
                 writer.write_u3(u3::ZERO)?;
             }
-            ContractOp::LdP(state_type, index, reg) => {
+            ContractOp::LdP(state_type, reg_a, reg_s) => {
                 writer.write_u16(*state_type)?;
-                writer.write_u16(*index)?;
-                writer.write_u4(reg)?;
-                writer.write_u4(u4::ZERO)?;
+                writer.write_u4(reg_a)?;
+                writer.write_u4(reg_s)?;
             }
-            ContractOp::LdS(state_type, index, reg) => {
+            ContractOp::LdS(state_type, reg_a, reg_s) => {
                 writer.write_u16(*state_type)?;
-                writer.write_u16(*index)?;
-                writer.write_u4(reg)?;
-                writer.write_u4(u4::ZERO)?;
+                writer.write_u4(reg_a)?;
+                writer.write_u4(reg_s)?;
             }
-            ContractOp::LdF(state_type, index, reg) => {
+            ContractOp::LdF(state_type, reg_a, reg_dst) => {
                 writer.write_u16(*state_type)?;
-                writer.write_u16(*index)?;
-                writer.write_u5(reg)?;
-                writer.write_u3(u3::ZERO)?;
+                writer.write_u4(reg_a)?;
+                writer.write_u4(reg_dst)?;
             }
-            ContractOp::LdG(state_type, index, reg) => {
+            ContractOp::LdG(state_type, reg_a, reg_s) => {
                 writer.write_u16(*state_type)?;
-                writer.write_u8(*index)?;
-                writer.write_u4(reg)?;
-                writer.write_u4(u4::ZERO)?;
+                writer.write_u4(reg_a)?;
+                writer.write_u4(reg_s)?;
             }
-            ContractOp::LdC(state_type, index, reg) => {
+            ContractOp::LdC(state_type, reg_a, reg_s) => {
                 writer.write_u16(*state_type)?;
-                writer.write_u16(*index)?;
-                writer.write_u4(reg)?;
-                writer.write_u4(u4::ZERO)?;
+                writer.write_u4(reg_a)?;
+                writer.write_u4(reg_s)?;
             }
             ContractOp::LdM(reg) => {
                 writer.write_u4(reg)?;
@@ -474,70 +504,50 @@ impl Bytecode for ContractOp {
         Ok(match reader.read_u8()? {
             INSTR_CNP => {
                 let i = Self::CnP(reader.read_u16()?.into(), reader.read_u5()?.into());
-                reader.read_u4()?; // Discard garbage bits
+                reader.read_u3()?; // Discard garbage bits
                 i
             }
             INSTR_CNS => {
                 let i = Self::CnS(reader.read_u16()?.into(), reader.read_u5()?.into());
-                reader.read_u4()?; // Discard garbage bits
+                reader.read_u3()?; // Discard garbage bits
                 i
             }
             INSTR_CNG => {
                 let i = Self::CnG(reader.read_u16()?.into(), reader.read_u5()?.into());
-                reader.read_u4()?; // Discard garbage bits
+                reader.read_u3()?; // Discard garbage bits
                 i
             }
             INSTR_CNC => {
                 let i = Self::CnC(reader.read_u16()?.into(), reader.read_u5()?.into());
-                reader.read_u4()?; // Discard garbage bits
+                reader.read_u3()?; // Discard garbage bits
                 i
             }
 
-            INSTR_LDP => {
-                let i = Self::LdP(
-                    reader.read_u16()?.into(),
-                    reader.read_u16()?,
-                    reader.read_u4()?.into(),
-                );
-                reader.read_u4()?; // Discard garbage bits
-                i
-            }
-            INSTR_LDS => {
-                let i = Self::LdS(
-                    reader.read_u16()?.into(),
-                    reader.read_u16()?,
-                    reader.read_u4()?.into(),
-                );
-                reader.read_u4()?; // Discard garbage bits
-                i
-            }
-            INSTR_LDF => {
-                let i = Self::LdF(
-                    reader.read_u16()?.into(),
-                    reader.read_u16()?,
-                    reader.read_u5()?.into(),
-                );
-                reader.read_u4()?; // Discard garbage bits
-                i
-            }
-            INSTR_LDG => {
-                let i = Self::LdG(
-                    reader.read_u16()?.into(),
-                    reader.read_u8()?,
-                    reader.read_u4()?.into(),
-                );
-                reader.read_u4()?; // Discard garbage bits
-                i
-            }
-            INSTR_LDC => {
-                let i = Self::LdC(
-                    reader.read_u16()?.into(),
-                    reader.read_u16()?,
-                    reader.read_u4()?.into(),
-                );
-                reader.read_u4()?; // Discard garbage bits
-                i
-            }
+            INSTR_LDP => Self::LdP(
+                reader.read_u16()?.into(),
+                reader.read_u4()?.into(),
+                reader.read_u4()?.into(),
+            ),
+            INSTR_LDF => Self::LdF(
+                reader.read_u16()?.into(),
+                reader.read_u4()?.into(),
+                reader.read_u4()?.into(),
+            ),
+            INSTR_LDG => Self::LdG(
+                reader.read_u16()?.into(),
+                reader.read_u4()?.into(),
+                reader.read_u4()?.into(),
+            ),
+            INSTR_LDS => Self::LdS(
+                reader.read_u16()?.into(),
+                reader.read_u4()?.into(),
+                reader.read_u4()?.into(),
+            ),
+            INSTR_LDC => Self::LdC(
+                reader.read_u16()?.into(),
+                reader.read_u4()?.into(),
+                reader.read_u4()?.into(),
+            ),
             INSTR_LDM => {
                 let i = Self::LdM(reader.read_u4()?.into());
                 reader.read_u4()?; // Discard garbage bits
diff --git a/stl/AnchoredBundle.vesper b/stl/AnchoredBundle.vesper
index 3ab74073..d97a267c 100644
--- a/stl/AnchoredBundle.vesper
+++ b/stl/AnchoredBundle.vesper
@@ -117,7 +117,7 @@ AnchoredBundle rec
             RevealedData rec
               value bytes len=0..MAX16 aka=DataState
               salt is U128
-        inputs set len=0..MAX8 aka=Inputs
+        inputs set len=0..MAX16 aka=Inputs
           Input rec
             prevOut rec -- Opout
               op bytes len=32 aka=OpId
diff --git a/stl/RGB@0.1.0.sta b/stl/RGB@0.1.0.sta
index 55964b4c..79efbae9 100644
--- a/stl/RGB@0.1.0.sta
+++ b/stl/RGB@0.1.0.sta
@@ -1,5 +1,5 @@
 -----BEGIN STRICT TYPE LIB-----
-Id: 2nWgjeSMhVE2mKgC7WyE5Dn8a6tZJDMoNugDWdc4vcZZ#spring-moral-almanac
+Id: HqdNNAehK3yaQ1AC5pQmEuNNS1zgyo2Jw31fdUNKb9MU#annual-virus-garlic
 Name: RGB
 Dependencies: 
   c8Tnib31q1p7szyPukEGDoQzJQ5qJwPCn5uZCHUXzB9#cupid-metro-warning,
@@ -65,8 +65,8 @@ L%7X0(MZ+m5XM3^r;0|aDsVQc^f0tR$paB^jI0to-Z_Ce;SSLEx{oG{4aHr^2iyi
 LDUBh#^}_A@_MaKYL@=60F^Mce9hV@kEAv~dJM2k-Wy*xwxV$=>!YxCL);a%FS^2
 >-+OLFT7d<m=O%Fv#OJ-Vp}8O}|tl)3K`dGe1{wYoxJ*r=1Ym781z2z}Xa8AUDL%
 7X0(MZ+m5XM3^r;4nb~XXm4_5WI}arWNc*y0tR7jV`y)30X6Cu6ZFTF{1(Q>0mQB
-U&A7nhZflGzYjutGK7Ikb(*|O7Ze(m_0hXpPne(?RlQ8`&+waoz6~|Y?oZ~PA2bO
-M&(|4LuH3&g-b7gc?VP^#a00#g7Kp+4jL349yXKqquc4c8~Wn@8gbYWv?LTqVnWK
+U&A7nhZflGzYjutGK7Ikb(*|O7Ze(m_0rx{b<9+Yu`qRj%G%AgD9u}q)cm@#lClo
+8c{Gvp6EC@k!b7gc?VP^#a00#g7Kp+4jL349yXKqquc4c8~Wn@8gbYWv?LTqVnWK
 (5fY*ctqbaDg)01RVqZf0p@Wo~q7VQc^f0t9nqVQc~0idq_i6cBYN^7xEELu$lFU
 37Sf$J;ty5yrmOX|)6eb97;JWdZy&McrS|4GaIQ6{LE)1tQ>Eiz^#2Wm1QOk9#fa
 jy(YpV{dL|X=G(?bZKF1Q*>c;WdH^O1aoC!YypqE!sthuPUKDEU2%WC`V+X+(UG)
@@ -202,7 +202,7 @@ n=-%xGg*8X!CPrawgw_sqk4BX8}k^^xj-FXm+)yumJ%GNp5g;bWLG!1pxpG0`+VY
 Vk7oBr%DNv+($;q`HHK!gIHa)*%m(-e#9sm3L)b@L&d6G@+l`%qd385?K@+fP1(-
 9sgE>i7rMzqbpe&g=6W7=VqesjRYGc!>wZFzp>JB4@xD;^wu&SY_r(DK00000009
 6000000000I_Zg6#Ua|Hna2?5oOUkD7Ff~JZGMgrhZ&rP2gYrktY!x$bpv=qCl=H
-dVV000000093000000000S1Wn^h#RC#b^0|5hJZh8L*O=WapWMOn+1pxpE002M$0
+dVV000000096000000000S1Wn^h#RC#b^0|5hJZh8L*O=WapWMOn+1pxpE002M$0
 000000030{{R300000BPh(?sa&l#EV`Xy&0t0PnZU6uR18re=0006EPjEwTZEb0E
 ZDnqB1_%RYW_AJEn^6;37FKqUhx?i3R+Mr!fY&(;2BFL(m@EZk_srD>Z*Ww3aAg7
 Z;tWa*pdtf40sy7f4K>mzt7<I}8`2V1J%sNEHw4=VZDn*}WMOn+0zEM{@(!?klpc
@@ -276,13 +276,13 @@ d8&{mB<B&Cvf4{|%FX07QI<n%&HK3RH4oZgXjLX>V=@2m@wjb^+R(Q4?4eR(6nw`
 <dldlyWwJ*EtLZq0A(hECpou%+(5GZ*FvQVPkYjWC5QDEJ-@Z0;0Ob-P{Wzd?2rs
 )M&&=&l*}G;Jw22Ix-G)a$#<BX>@6CZd7@2WdSr&53UoI8eY9A{1GERg--GiI0S#
 x1is&)M%fmnGH3{GWprU=VRT^u;b~{_$H8YPU!!A-5yM58(94FP(7*JmC%?~bN>d
-RB2WM<=Vqt7^0owP`H}~XwW|nkt{7-&IWbpPi(wX$0pXUqF<#0Z84+d#&aCLNZ0q
-XH?aMFzGWq$hFvg0C@`6md)2`tzAi?CmdhpVB9ybED-b7^O8ZDnqBa{>8NbFsAF+
+RB2WM<=Vqt7^0owP`H}~XwW|nkt{7-&IWbpPi(wX$0pXUqF<#0Z84+d#&aCLNZ0j
+Z*TSChz_$|Xx}eRkFNAr%^eLl(1e@}~9=0-ijXfD2)Bb7^O8ZDnqBa{>8NbFsAF+
 NAOa9=u3y1Xa&C=4DE;gi12nFEThgaqbCrVQgh?V`*h`0o{dW0B>Pr5ftu@@z<*O
 39}j`u&O7io3b$Is?RA$O%POaVQzD2bZKvHLUnFrY-I)l2x)F`b#zT(Z~+yWXJpH
 @t3U@-^C5At>@@qQFQ2KNd+8eYXv4en`-l*0Zf|#PRB~Z%b7^#GZ*Fq{3IUbK=6W
-7=VqesjRYGc!>wZFzp>JB4@xD;^wu&SY_r(ETixq|tDc|qkEqWzEgosCv-N}OwI3
-27^9uv@M+=8<K0000000030{{R300000GRB~Z%b7^#GZ*Eg#Xk~3-1_cOhWprU=V
+7=VqesjRYGc!>wZFzp>JB4@xD;^wu&SY_r(G5e-m~8oEl#z@T$dQ;Shc2UKksAbu
+m0|FIl~hsu<b<0000000030{{R300000GRB~Z%b7^#GZ*Eg#Xk~3-1_cOhWprU=V
 RT^vNU3b>%M}yz;kwbCmqWQ?a(0yP=wbe0q{)>8+xQm0YXqYdo~D%m7H6OD0<^0n
 _2##VWXRdjy=DB@qgYOj2WM<=Vqt7^015%s?vf5kh_h+&YE#h%O8d1V_{UOl9{V;
 uR#^q%<Q2;SHo-KZ`k;Xmr`<4sJYKN!!u{G5u+^j1lf!PF4>GEG0000000000{{R
diff --git a/stl/RGB@0.1.0.stl b/stl/RGB@0.1.0.stl
index 741fb19c..d7c778e8 100644
Binary files a/stl/RGB@0.1.0.stl and b/stl/RGB@0.1.0.stl differ
diff --git a/stl/RGB@0.1.0.sty b/stl/RGB@0.1.0.sty
index f33e60b3..058065b6 100644
--- a/stl/RGB@0.1.0.sty
+++ b/stl/RGB@0.1.0.sty
@@ -1,5 +1,5 @@
 {-
-  Id: urn:ubideco:stl:2nWgjeSMhVE2mKgC7WyE5Dn8a6tZJDMoNugDWdc4vcZZ#spring-moral-almanac
+  Id: urn:ubideco:stl:HqdNNAehK3yaQ1AC5pQmEuNNS1zgyo2Jw31fdUNKb9MU#annual-virus-garlic
   Name: RGB
   Version: 0.1.0
   Description: Consensus layer for RGB smart contracts
@@ -255,8 +255,8 @@ data Input             : prevOut Opout, reserved ReservedBytes2
 @mnemonic(canada-chicken-analyze)
 data InputMap          : {Bitcoin.Vout -> ^ 1.. OpId}
 
-@mnemonic(puzzle-guru-oregano)
-data Inputs            : {Input ^ ..0xff}
+@mnemonic(liquid-meaning-convert)
+data Inputs            : {Input}
 
 @mnemonic(light-nelson-brain)
 data MediaType         : any#255
diff --git a/stl/Transition.vesper b/stl/Transition.vesper
index 46ad51e3..af8391d2 100644
--- a/stl/Transition.vesper
+++ b/stl/Transition.vesper
@@ -41,7 +41,7 @@ Transition rec
       RevealedData rec
         value bytes len=0..MAX16 aka=DataState
         salt is U128
-  inputs set len=0..MAX8 aka=Inputs
+  inputs set len=0..MAX16 aka=Inputs
     Input rec
       prevOut rec -- Opout
         op bytes len=32 aka=OpId