From 77b9548689a3fc89a2d729947f54c66b0e8df39d Mon Sep 17 00:00:00 2001
From: Georgy Shepelev <geo.shepelev@gmail.com>
Date: Tue, 15 Aug 2023 10:02:57 +0300
Subject: [PATCH] refactor(sandbox-host): Process wasm-globals on wasmer side
 (#2969)

---
 Cargo.lock                                    |    2 +
 core-backend/codegen/src/host.rs              |    4 +-
 core-backend/common/src/funcs.rs              |  209 +-
 core-backend/common/src/runtime.rs            |   10 +-
 core-backend/sandbox/Cargo.toml               |    1 +
 core-backend/sandbox/src/env.rs               |  151 +-
 core-backend/sandbox/src/runtime.rs           |   63 +-
 core-backend/wasmi/src/funcs_tree.rs          |    9 +-
 core-backend/wasmi/src/runtime.rs             |   13 +-
 pallets/gear/src/weights.rs                   | 2874 ++++++++--------
 runtime-interface/src/gear_sandbox/detail.rs  |    4 +-
 runtime-interface/src/gear_sandbox/mod.rs     |   30 +-
 runtime/gear/src/weights/frame_system.rs      |   78 +-
 runtime/gear/src/weights/pallet_balances.rs   |   58 +-
 runtime/gear/src/weights/pallet_gear.rs       | 2874 ++++++++--------
 .../gear/src/weights/pallet_gear_voucher.rs   |   10 +-
 runtime/gear/src/weights/pallet_timestamp.rs  |   18 +-
 runtime/gear/src/weights/pallet_utility.rs    |   66 +-
 runtime/vara/src/tests.rs                     |    2 +-
 runtime/vara/src/weights/frame_system.rs      |   78 +-
 runtime/vara/src/weights/pallet_airdrop.rs    |   28 +-
 runtime/vara/src/weights/pallet_balances.rs   |   58 +-
 runtime/vara/src/weights/pallet_gear.rs       | 2882 ++++++++---------
 .../vara/src/weights/pallet_gear_voucher.rs   |   10 +-
 runtime/vara/src/weights/pallet_timestamp.rs  |   18 +-
 runtime/vara/src/weights/pallet_utility.rs    |   66 +-
 sandbox/env/Cargo.toml                        |    2 +
 sandbox/env/src/lib.rs                        |   27 +-
 sandbox/host/src/sandbox.rs                   |    4 +-
 sandbox/host/src/sandbox/wasmer_backend.rs    |  168 +-
 sandbox/sandbox/src/embedded_executor.rs      |   53 +-
 sandbox/sandbox/src/host_executor.rs          |   41 +-
 sandbox/sandbox/src/lib.rs                    |   44 +-
 utils/wasm-instrument/src/lib.rs              |    1 +
 utils/wasm-proc/src/main.rs                   |    3 +-
 35 files changed, 5121 insertions(+), 4838 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 292826cf063..6f1eac910fe 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -3756,6 +3756,7 @@ dependencies = [
  "gear-core",
  "gear-core-errors",
  "gear-sandbox",
+ "gear-sandbox-env",
  "gear-wasm-instrument",
  "gsys",
  "log",
@@ -4188,6 +4189,7 @@ dependencies = [
  "parity-scale-codec",
  "sp-core 7.0.0 (git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox)",
  "sp-std 5.0.0 (git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox)",
+ "sp-wasm-interface 7.0.0 (git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox)",
 ]
 
 [[package]]
diff --git a/core-backend/codegen/src/host.rs b/core-backend/codegen/src/host.rs
index e19eab19dbb..dd241427d31 100644
--- a/core-backend/codegen/src/host.rs
+++ b/core-backend/codegen/src/host.rs
@@ -122,14 +122,14 @@ impl HostFn {
         let run: Expr = match self.meta.call_type {
             CallType::Any => {
                 parse_quote! {
-                    ctx.run_any(#cost, |ctx| {
+                    ctx.run_any(gas, #cost, |ctx| {
                         #inner_block
                     })
                 }
             }
             CallType::Fallible => {
                 parse_quote! {
-                    ctx.run_fallible::<_, _, #err>(err_mid_ptr, #cost, |ctx| {
+                    ctx.run_fallible::<_, _, #err>(gas, err_mid_ptr, #cost, |ctx| {
                         #inner_block
                     })
                 }
diff --git a/core-backend/common/src/funcs.rs b/core-backend/common/src/funcs.rs
index 25958775ea4..31efa8b0d73 100644
--- a/core-backend/common/src/funcs.rs
+++ b/core-backend/common/src/funcs.rs
@@ -77,14 +77,17 @@ where
             .map_err(RunFallibleError::FallibleExt)
     }
 
+    // TODO #3037
+    #[allow(clippy::too_many_arguments)]
     #[host(fallible, wgas, cost = RuntimeCosts::Send(len))]
     pub fn send(
         ctx: &mut R,
+        gas: u64,
         pid_value_ptr: u32,
         payload_ptr: u32,
         len: u32,
         delay: u32,
-    ) -> Result<(), R::Error> {
+    ) -> Result<(u64, ()), R::Error> {
         let read_hash_val = ctx.register_read_as(pid_value_ptr);
         let read_payload = ctx.register_read(payload_ptr, len);
         let HashWithValue {
@@ -101,10 +104,11 @@ where
     #[host(fallible, wgas, cost = RuntimeCosts::SendCommit)]
     pub fn send_commit(
         ctx: &mut R,
+        gas: u64,
         handle: u32,
         pid_value_ptr: u32,
         delay: u32,
-    ) -> Result<(), R::Error> {
+    ) -> Result<(u64, ()), R::Error> {
         let read_pid_value = ctx.register_read_as(pid_value_ptr);
         let HashWithValue {
             hash: destination,
@@ -121,12 +125,18 @@ where
     }
 
     #[host(fallible, cost = RuntimeCosts::SendInit, err = ErrorWithHandle)]
-    pub fn send_init(ctx: &mut R) -> Result<(), R::Error> {
+    pub fn send_init(ctx: &mut R, gas: u64) -> Result<(u64, ()), R::Error> {
         ctx.ext_mut().send_init().map_err(Into::into)
     }
 
     #[host(fallible, cost = RuntimeCosts::SendPush(len), err = ErrorBytes)]
-    pub fn send_push(ctx: &mut R, handle: u32, payload_ptr: u32, len: u32) -> Result<(), R::Error> {
+    pub fn send_push(
+        ctx: &mut R,
+        gas: u64,
+        handle: u32,
+        payload_ptr: u32,
+        len: u32,
+    ) -> Result<(u64, ()), R::Error> {
         let read_payload = ctx.register_read(payload_ptr, len);
         let payload = ctx.read(read_payload)?;
 
@@ -138,11 +148,12 @@ where
     #[host(fallible, cost = RuntimeCosts::ReservationSend(len))]
     pub fn reservation_send(
         ctx: &mut R,
+        gas: u64,
         rid_pid_value_ptr: u32,
         payload_ptr: u32,
         len: u32,
         delay: u32,
-    ) -> Result<(), R::Error> {
+    ) -> Result<(u64, ()), R::Error> {
         let read_rid_pid_value = ctx.register_read_as(rid_pid_value_ptr);
         let read_payload = ctx.register_read(payload_ptr, len);
         let TwoHashesWithValue {
@@ -164,10 +175,11 @@ where
     #[host(fallible, cost = RuntimeCosts::ReservationSendCommit)]
     pub fn reservation_send_commit(
         ctx: &mut R,
+        gas: u64,
         handle: u32,
         rid_pid_value_ptr: u32,
         delay: u32,
-    ) -> Result<(), R::Error> {
+    ) -> Result<(u64, ()), R::Error> {
         let read_rid_pid_value = ctx.register_read_as(rid_pid_value_ptr);
         let TwoHashesWithValue {
             hash1: reservation_id,
@@ -186,7 +198,13 @@ where
     }
 
     #[host(fallible, cost = RuntimeCosts::Read, err = ErrorBytes)]
-    pub fn read(ctx: &mut R, at: u32, len: u32, buffer_ptr: u32) -> Result<(), R::Error> {
+    pub fn read(
+        ctx: &mut R,
+        gas: u64,
+        at: u32,
+        len: u32,
+        buffer_ptr: u32,
+    ) -> Result<(u64, ()), R::Error> {
         let payload_lock = ctx.ext_mut().lock_payload(at, len)?;
         payload_lock
             .drop_with::<MemoryAccessError, _>(|payload_access| {
@@ -201,7 +219,7 @@ where
     }
 
     #[host(cost = RuntimeCosts::Size)]
-    pub fn size(ctx: &mut R, size_ptr: u32) -> Result<(), R::Error> {
+    pub fn size(ctx: &mut R, gas: u64, size_ptr: u32) -> Result<(u64, ()), R::Error> {
         let size = ctx.ext_mut().size()? as u32;
 
         let write_size = ctx.register_write_as(size_ptr);
@@ -210,14 +228,14 @@ where
     }
 
     #[host(cost = RuntimeCosts::Exit)]
-    pub fn exit(ctx: &mut R, inheritor_id_ptr: u32) -> Result<(), R::Error> {
+    pub fn exit(ctx: &mut R, gas: u64, inheritor_id_ptr: u32) -> Result<(u64, ()), R::Error> {
         let read_inheritor_id = ctx.register_read_decoded(inheritor_id_ptr);
         let inheritor_id = ctx.read_decoded(read_inheritor_id)?;
         Err(ActorTerminationReason::Exit(inheritor_id).into())
     }
 
     #[host(fallible, cost = RuntimeCosts::ReplyCode, err = ErrorWithReplyCode)]
-    pub fn reply_code(ctx: &mut R) -> Result<(), R::Error> {
+    pub fn reply_code(ctx: &mut R, gas: u64) -> Result<(u64, ()), R::Error> {
         ctx.ext_mut()
             .reply_code()
             .map(ReplyCode::to_bytes)
@@ -226,7 +244,7 @@ where
 
     // TODO: write proper benchmark #2825
     #[host(fallible, cost = RuntimeCosts::ReplyCode, err = ErrorWithSignalCode)]
-    pub fn signal_code(ctx: &mut R) -> Result<(), R::Error> {
+    pub fn signal_code(ctx: &mut R, gas: u64) -> Result<(u64, ()), R::Error> {
         ctx.ext_mut()
             .signal_code()
             .map(SignalCode::to_u32)
@@ -234,7 +252,7 @@ where
     }
 
     #[host(cost = RuntimeCosts::Alloc(pages))]
-    pub fn alloc(ctx: &mut R, pages: u32) -> Result<u32, R::Error> {
+    pub fn alloc(ctx: &mut R, gas: u64, pages: u32) -> Result<(u64, u32), R::Error> {
         let res = ctx.alloc(pages);
         let res = ctx.process_alloc_func_result(res)?;
 
@@ -252,7 +270,7 @@ where
     }
 
     #[host(cost = RuntimeCosts::Free)]
-    pub fn free(ctx: &mut R, page_no: u32) -> Result<i32, R::Error> {
+    pub fn free(ctx: &mut R, gas: u64, page_no: u32) -> Result<(u64, i32), R::Error> {
         let page = WasmPage::new(page_no).map_err(|_| {
             UndefinedTerminationReason::Actor(ActorTerminationReason::Trap(
                 TrapExplanation::Unknown,
@@ -275,7 +293,7 @@ where
     }
 
     #[host(cost = RuntimeCosts::BlockHeight)]
-    pub fn block_height(ctx: &mut R, height_ptr: u32) -> Result<(), R::Error> {
+    pub fn block_height(ctx: &mut R, gas: u64, height_ptr: u32) -> Result<(u64, ()), R::Error> {
         let height = ctx.ext_mut().block_height()?;
 
         let write_height = ctx.register_write_as(height_ptr);
@@ -284,7 +302,11 @@ where
     }
 
     #[host(cost = RuntimeCosts::BlockTimestamp)]
-    pub fn block_timestamp(ctx: &mut R, timestamp_ptr: u32) -> Result<(), R::Error> {
+    pub fn block_timestamp(
+        ctx: &mut R,
+        gas: u64,
+        timestamp_ptr: u32,
+    ) -> Result<(u64, ()), R::Error> {
         let timestamp = ctx.ext_mut().block_timestamp()?;
 
         let write_timestamp = ctx.register_write_as(timestamp_ptr);
@@ -293,7 +315,12 @@ where
     }
 
     #[host(cost = RuntimeCosts::Random)]
-    pub fn random(ctx: &mut R, subject_ptr: u32, bn_random_ptr: u32) -> Result<(), R::Error> {
+    pub fn random(
+        ctx: &mut R,
+        gas: u64,
+        subject_ptr: u32,
+        bn_random_ptr: u32,
+    ) -> Result<(u64, ()), R::Error> {
         let read_subject = ctx.register_read_decoded(subject_ptr);
         let write_bn_random = ctx.register_write_as(bn_random_ptr);
 
@@ -310,7 +337,13 @@ where
     }
 
     #[host(fallible, wgas, cost = RuntimeCosts::Reply(len))]
-    pub fn reply(ctx: &mut R, payload_ptr: u32, len: u32, value_ptr: u32) -> Result<(), R::Error> {
+    pub fn reply(
+        ctx: &mut R,
+        gas: u64,
+        payload_ptr: u32,
+        len: u32,
+        value_ptr: u32,
+    ) -> Result<(u64, ()), R::Error> {
         let read_payload = ctx.register_read(payload_ptr, len);
         let value = Self::register_and_read_value(ctx, value_ptr)?;
         let payload = Self::read_message_payload(ctx, read_payload)?;
@@ -321,7 +354,7 @@ where
     }
 
     #[host(fallible, wgas, cost = RuntimeCosts::ReplyCommit)]
-    pub fn reply_commit(ctx: &mut R, value_ptr: u32) -> Result<(), R::Error> {
+    pub fn reply_commit(ctx: &mut R, gas: u64, value_ptr: u32) -> Result<(u64, ()), R::Error> {
         let value = Self::register_and_read_value(ctx, value_ptr)?;
 
         ctx.ext_mut()
@@ -332,10 +365,11 @@ where
     #[host(fallible, cost = RuntimeCosts::ReservationReply(len))]
     pub fn reservation_reply(
         ctx: &mut R,
+        gas: u64,
         rid_value_ptr: u32,
         payload_ptr: u32,
         len: u32,
-    ) -> Result<(), R::Error> {
+    ) -> Result<(u64, ()), R::Error> {
         let read_rid_value = ctx.register_read_as(rid_value_ptr);
         let read_payload = ctx.register_read(payload_ptr, len);
         let HashWithValue {
@@ -350,7 +384,11 @@ where
     }
 
     #[host(fallible, cost = RuntimeCosts::ReservationReplyCommit)]
-    pub fn reservation_reply_commit(ctx: &mut R, rid_value_ptr: u32) -> Result<(), R::Error> {
+    pub fn reservation_reply_commit(
+        ctx: &mut R,
+        gas: u64,
+        rid_value_ptr: u32,
+    ) -> Result<(u64, ()), R::Error> {
         let read_rid_value = ctx.register_read_as(rid_value_ptr);
         let HashWithValue {
             hash: reservation_id,
@@ -366,18 +404,23 @@ where
     }
 
     #[host(fallible, cost = RuntimeCosts::ReplyTo)]
-    pub fn reply_to(ctx: &mut R) -> Result<(), R::Error> {
+    pub fn reply_to(ctx: &mut R, gas: u64) -> Result<(u64, ()), R::Error> {
         ctx.ext_mut().reply_to().map_err(Into::into)
     }
 
     // TODO: write proper benchmark #2825
     #[host(fallible, cost = RuntimeCosts::SignalFrom)]
-    pub fn signal_from(ctx: &mut R) -> Result<(), R::Error> {
+    pub fn signal_from(ctx: &mut R, gas: u64) -> Result<(u64, ()), R::Error> {
         ctx.ext_mut().signal_from().map_err(Into::into)
     }
 
     #[host(fallible, cost = RuntimeCosts::ReplyPush(len), err = ErrorBytes)]
-    pub fn reply_push(ctx: &mut R, payload_ptr: u32, len: u32) -> Result<(), R::Error> {
+    pub fn reply_push(
+        ctx: &mut R,
+        gas: u64,
+        payload_ptr: u32,
+        len: u32,
+    ) -> Result<(u64, ()), R::Error> {
         let read_payload = ctx.register_read(payload_ptr, len);
         let payload = ctx.read(read_payload)?;
 
@@ -385,7 +428,13 @@ where
     }
 
     #[host(fallible, wgas, cost = RuntimeCosts::ReplyInput)]
-    pub fn reply_input(ctx: &mut R, offset: u32, len: u32, value_ptr: u32) -> Result<(), R::Error> {
+    pub fn reply_input(
+        ctx: &mut R,
+        gas: u64,
+        offset: u32,
+        len: u32,
+        value_ptr: u32,
+    ) -> Result<(u64, ()), R::Error> {
         // Charge for `len` is inside `reply_push_input`
         let value = Self::register_and_read_value(ctx, value_ptr)?;
 
@@ -399,20 +448,27 @@ where
     }
 
     #[host(fallible, cost = RuntimeCosts::ReplyPushInput, err = ErrorBytes)]
-    pub fn reply_push_input(ctx: &mut R, offset: u32, len: u32) -> Result<(), R::Error> {
+    pub fn reply_push_input(
+        ctx: &mut R,
+        gas: u64,
+        offset: u32,
+        len: u32,
+    ) -> Result<(u64, ()), R::Error> {
         ctx.ext_mut()
             .reply_push_input(offset, len)
             .map_err(Into::into)
     }
 
+    #[allow(clippy::too_many_arguments)]
     #[host(fallible, wgas, cost = RuntimeCosts::SendInput)]
     pub fn send_input(
         ctx: &mut R,
+        gas: u64,
         pid_value_ptr: u32,
         offset: u32,
         len: u32,
         delay: u32,
-    ) -> Result<(), R::Error> {
+    ) -> Result<(u64, ()), R::Error> {
         // Charge for `len` inside `send_push_input`
         let read_pid_value = ctx.register_read_as(pid_value_ptr);
         let HashWithValue {
@@ -436,17 +492,23 @@ where
     #[host(fallible, cost = RuntimeCosts::SendPushInput, err = ErrorBytes)]
     pub fn send_push_input(
         ctx: &mut R,
+        gas: u64,
         handle: u32,
         offset: u32,
         len: u32,
-    ) -> Result<(), R::Error> {
+    ) -> Result<(u64, ()), R::Error> {
         ctx.ext_mut()
             .send_push_input(handle, offset, len)
             .map_err(Into::into)
     }
 
     #[host(cost = RuntimeCosts::Debug(data_len))]
-    pub fn debug(ctx: &mut R, data_ptr: u32, data_len: u32) -> Result<(), R::Error> {
+    pub fn debug(
+        ctx: &mut R,
+        gas: u64,
+        data_ptr: u32,
+        data_len: u32,
+    ) -> Result<(u64, ()), R::Error> {
         let read_data = ctx.register_read(data_ptr, data_len);
         let data: RuntimeBuffer = ctx
             .read(read_data)?
@@ -465,7 +527,12 @@ where
     }
 
     #[host(cost = RuntimeCosts::Null)]
-    pub fn panic(ctx: &mut R, data_ptr: u32, data_len: u32) -> Result<(), R::Error> {
+    pub fn panic(
+        ctx: &mut R,
+        gas: u64,
+        data_ptr: u32,
+        data_len: u32,
+    ) -> Result<(u64, ()), R::Error> {
         let read_data = ctx.register_read(data_ptr, data_len);
         let data = ctx.read(read_data).unwrap_or_default();
 
@@ -475,27 +542,43 @@ where
     }
 
     #[host(cost = RuntimeCosts::Null)]
-    pub fn oom_panic(ctx: &mut R) -> Result<(), R::Error> {
+    pub fn oom_panic(ctx: &mut R, gas: u64) -> Result<(u64, ()), R::Error> {
         Err(ActorTerminationReason::Trap(TrapExplanation::ProgramAllocOutOfBounds).into())
     }
 
     #[host(fallible, cost = RuntimeCosts::ReserveGas)]
-    pub fn reserve_gas(ctx: &mut R, gas: u64, duration: u32) -> Result<(), R::Error> {
-        ctx.ext_mut().reserve_gas(gas, duration).map_err(Into::into)
+    pub fn reserve_gas(
+        ctx: &mut R,
+        gas: u64,
+        gas_value: u64,
+        duration: u32,
+    ) -> Result<(u64, ()), R::Error> {
+        ctx.ext_mut()
+            .reserve_gas(gas_value, duration)
+            .map_err(Into::into)
     }
 
     #[host(fallible, cost = RuntimeCosts::ReplyDeposit, err = ErrorBytes)]
-    pub fn reply_deposit(ctx: &mut R, message_id_ptr: u32, gas: u64) -> Result<(), R::Error> {
+    pub fn reply_deposit(
+        ctx: &mut R,
+        gas: u64,
+        message_id_ptr: u32,
+        gas_value: u64,
+    ) -> Result<(u64, ()), R::Error> {
         let read_message_id = ctx.register_read_decoded(message_id_ptr);
         let message_id = ctx.read_decoded(read_message_id)?;
 
         ctx.ext_mut()
-            .reply_deposit(message_id, gas)
+            .reply_deposit(message_id, gas_value)
             .map_err(Into::into)
     }
 
     #[host(fallible, cost = RuntimeCosts::UnreserveGas, err = ErrorWithGas)]
-    pub fn unreserve_gas(ctx: &mut R, reservation_id_ptr: u32) -> Result<(), R::Error> {
+    pub fn unreserve_gas(
+        ctx: &mut R,
+        gas: u64,
+        reservation_id_ptr: u32,
+    ) -> Result<(u64, ()), R::Error> {
         let read_reservation_id = ctx.register_read_decoded(reservation_id_ptr);
         let reservation_id = ctx.read_decoded(read_reservation_id)?;
 
@@ -505,21 +588,27 @@ where
     }
 
     #[host(fallible, cost = RuntimeCosts::SystemReserveGas, err = ErrorBytes)]
-    pub fn system_reserve_gas(ctx: &mut R, gas: u64) -> Result<(), R::Error> {
-        ctx.ext_mut().system_reserve_gas(gas).map_err(Into::into)
+    pub fn system_reserve_gas(
+        ctx: &mut R,
+        gas: u64,
+        gas_value: u64,
+    ) -> Result<(u64, ()), R::Error> {
+        ctx.ext_mut()
+            .system_reserve_gas(gas_value)
+            .map_err(Into::into)
     }
 
     #[host(cost = RuntimeCosts::GasAvailable)]
-    pub fn gas_available(ctx: &mut R, gas_ptr: u32) -> Result<(), R::Error> {
-        let gas = ctx.ext_mut().gas_available()?;
+    pub fn gas_available(ctx: &mut R, gas: u64, gas_ptr: u32) -> Result<(u64, ()), R::Error> {
+        let gas_available = ctx.ext_mut().gas_available()?;
 
         let write_gas = ctx.register_write_as(gas_ptr);
-        ctx.write_as(write_gas, gas.to_le_bytes())
+        ctx.write_as(write_gas, gas_available.to_le_bytes())
             .map_err(Into::into)
     }
 
     #[host(cost = RuntimeCosts::MsgId)]
-    pub fn message_id(ctx: &mut R, message_id_ptr: u32) -> Result<(), R::Error> {
+    pub fn message_id(ctx: &mut R, gas: u64, message_id_ptr: u32) -> Result<(u64, ()), R::Error> {
         let message_id = ctx.ext_mut().message_id()?;
 
         let write_message_id = ctx.register_write_as(message_id_ptr);
@@ -528,7 +617,7 @@ where
     }
 
     #[host(cost = RuntimeCosts::ProgramId)]
-    pub fn program_id(ctx: &mut R, program_id_ptr: u32) -> Result<(), R::Error> {
+    pub fn program_id(ctx: &mut R, gas: u64, program_id_ptr: u32) -> Result<(u64, ()), R::Error> {
         let program_id = ctx.ext_mut().program_id()?;
 
         let write_program_id = ctx.register_write_as(program_id_ptr);
@@ -537,7 +626,11 @@ where
     }
 
     #[host(fallible, cost = RuntimeCosts::PayProgramRent, err = ErrorWithBlockNumberAndValue)]
-    pub fn pay_program_rent(ctx: &mut R, rent_pid_ptr: u32) -> Result<(), R::Error> {
+    pub fn pay_program_rent(
+        ctx: &mut R,
+        gas: u64,
+        rent_pid_ptr: u32,
+    ) -> Result<(u64, ()), R::Error> {
         let read_rent_pid = ctx.register_read_as(rent_pid_ptr);
 
         let HashWithValue {
@@ -551,7 +644,7 @@ where
     }
 
     #[host(cost = RuntimeCosts::Source)]
-    pub fn source(ctx: &mut R, source_ptr: u32) -> Result<(), R::Error> {
+    pub fn source(ctx: &mut R, gas: u64, source_ptr: u32) -> Result<(u64, ()), R::Error> {
         let source = ctx.ext_mut().source()?;
 
         let write_source = ctx.register_write_as(source_ptr);
@@ -560,7 +653,7 @@ where
     }
 
     #[host(cost = RuntimeCosts::Value)]
-    pub fn value(ctx: &mut R, value_ptr: u32) -> Result<(), R::Error> {
+    pub fn value(ctx: &mut R, gas: u64, value_ptr: u32) -> Result<(u64, ()), R::Error> {
         let value = ctx.ext_mut().value()?;
 
         let write_value = ctx.register_write_as(value_ptr);
@@ -569,7 +662,7 @@ where
     }
 
     #[host(cost = RuntimeCosts::ValueAvailable)]
-    pub fn value_available(ctx: &mut R, value_ptr: u32) -> Result<(), R::Error> {
+    pub fn value_available(ctx: &mut R, gas: u64, value_ptr: u32) -> Result<(u64, ()), R::Error> {
         let value_available = ctx.ext_mut().value_available()?;
 
         let write_value = ctx.register_write_as(value_ptr);
@@ -578,24 +671,24 @@ where
     }
 
     #[host(cost = RuntimeCosts::Leave)]
-    pub fn leave(ctx: &mut R) -> Result<(), R::Error> {
+    pub fn leave(ctx: &mut R, gas: u64) -> Result<(u64, ()), R::Error> {
         Err(ActorTerminationReason::Leave.into())
     }
 
     #[host(cost = RuntimeCosts::Wait)]
-    pub fn wait(ctx: &mut R) -> Result<(), R::Error> {
+    pub fn wait(ctx: &mut R, gas: u64) -> Result<(u64, ()), R::Error> {
         ctx.ext_mut().wait()?;
         Err(ActorTerminationReason::Wait(None, MessageWaitedType::Wait).into())
     }
 
     #[host(cost = RuntimeCosts::WaitFor)]
-    pub fn wait_for(ctx: &mut R, duration: u32) -> Result<(), R::Error> {
+    pub fn wait_for(ctx: &mut R, gas: u64, duration: u32) -> Result<(u64, ()), R::Error> {
         ctx.ext_mut().wait_for(duration)?;
         Err(ActorTerminationReason::Wait(Some(duration), MessageWaitedType::WaitFor).into())
     }
 
     #[host(cost = RuntimeCosts::WaitUpTo)]
-    pub fn wait_up_to(ctx: &mut R, duration: u32) -> Result<(), R::Error> {
+    pub fn wait_up_to(ctx: &mut R, gas: u64, duration: u32) -> Result<(u64, ()), R::Error> {
         let waited_type = if ctx.ext_mut().wait_up_to(duration)? {
             MessageWaitedType::WaitUpToFull
         } else {
@@ -605,7 +698,12 @@ where
     }
 
     #[host(fallible, cost = RuntimeCosts::Wake, err = ErrorBytes)]
-    pub fn wake(ctx: &mut R, message_id_ptr: u32, delay: u32) -> Result<(), R::Error> {
+    pub fn wake(
+        ctx: &mut R,
+        gas: u64,
+        message_id_ptr: u32,
+        delay: u32,
+    ) -> Result<(u64, ()), R::Error> {
         let read_message_id = ctx.register_read_decoded(message_id_ptr);
         let message_id = ctx.read_decoded(read_message_id)?;
 
@@ -616,13 +714,14 @@ where
     #[host(fallible, wgas, cost = RuntimeCosts::CreateProgram(payload_len, salt_len), err = ErrorWithTwoHashes)]
     pub fn create_program(
         ctx: &mut R,
+        gas: u64,
         cid_value_ptr: u32,
         salt_ptr: u32,
         salt_len: u32,
         payload_ptr: u32,
         payload_len: u32,
         delay: u32,
-    ) -> Result<(), R::Error> {
+    ) -> Result<(u64, ()), R::Error> {
         let read_cid_value = ctx.register_read_as(cid_value_ptr);
         let read_salt = ctx.register_read(salt_ptr, salt_len);
         let read_payload = ctx.register_read(payload_ptr, payload_len);
@@ -638,15 +737,15 @@ where
             .map_err(Into::into)
     }
 
-    pub fn forbidden(ctx: &mut R) -> Result<(), R::Error> {
+    pub fn forbidden(ctx: &mut R, gas: u64) -> Result<(u64, ()), R::Error> {
         syscall_trace!("forbidden");
 
-        ctx.run_any(RuntimeCosts::Null, |_| {
+        ctx.run_any(gas, RuntimeCosts::Null, |_| {
             Err(ActorTerminationReason::Trap(TrapExplanation::ForbiddenFunction).into())
         })
     }
 
-    pub fn out_of_gas(ctx: &mut R) -> Result<(), R::Error> {
+    pub fn out_of_gas(ctx: &mut R, _gas: u64) -> Result<(u64, ()), R::Error> {
         syscall_trace!("out_of_gas");
 
         let ext = ctx.ext_mut();
diff --git a/core-backend/common/src/runtime.rs b/core-backend/common/src/runtime.rs
index 64f59471aa4..308d3a1db53 100644
--- a/core-backend/common/src/runtime.rs
+++ b/core-backend/common/src/runtime.rs
@@ -50,16 +50,22 @@ pub trait Runtime<Ext: BackendExternalities>:
 
     fn ext_mut(&mut self) -> &mut Ext;
 
-    fn run_any<T, F>(&mut self, cost: RuntimeCosts, f: F) -> Result<T, Self::Error>
+    fn run_any<T, F>(
+        &mut self,
+        gas: u64,
+        cost: RuntimeCosts,
+        f: F,
+    ) -> Result<(u64, T), Self::Error>
     where
         F: FnOnce(&mut Self) -> Result<T, UndefinedTerminationReason>;
 
     fn run_fallible<T: Sized, F, R>(
         &mut self,
+        gas: u64,
         res_ptr: u32,
         cost: RuntimeCosts,
         f: F,
-    ) -> Result<(), Self::Error>
+    ) -> Result<(u64, ()), Self::Error>
     where
         F: FnOnce(&mut Self) -> Result<T, RunFallibleError>,
         R: From<Result<T, u32>> + Sized;
diff --git a/core-backend/sandbox/Cargo.toml b/core-backend/sandbox/Cargo.toml
index 4d9b264c6d3..9c0e6e710ef 100644
--- a/core-backend/sandbox/Cargo.toml
+++ b/core-backend/sandbox/Cargo.toml
@@ -13,6 +13,7 @@ gsys ={ workspace = true }
 
 gear-wasm-instrument.workspace = true
 gear-sandbox.workspace = true
+gear-sandbox-env.workspace = true
 # Use max_level_debug feature to remove tracing in sys-calls by default.
 log.workspace = true
 derive_more.workspace = true
diff --git a/core-backend/sandbox/src/env.rs b/core-backend/sandbox/src/env.rs
index 42375e9f5f8..efb2691e6a8 100644
--- a/core-backend/sandbox/src/env.rs
+++ b/core-backend/sandbox/src/env.rs
@@ -38,9 +38,10 @@ use gear_core::{
 };
 use gear_sandbox::{
     default_executor::{EnvironmentDefinitionBuilder, Instance, Memory as DefaultExecutorMemory},
-    HostError, HostFuncType, InstanceGlobals, ReturnValue, SandboxEnvironmentBuilder,
-    SandboxInstance, SandboxMemory, Value,
+    HostError, HostFuncType, IntoValue, ReturnValue, SandboxEnvironmentBuilder, SandboxInstance,
+    SandboxMemory, Value,
 };
+use gear_sandbox_env::WasmReturnValue;
 use gear_wasm_instrument::{
     syscalls::SysCallName::{self, *},
     GLOBAL_NAME_GAS, STACK_END_EXPORT_NAME,
@@ -93,16 +94,24 @@ impl TryFrom<SandboxValue> for u64 {
 
 macro_rules! wrap_common_func_internal_ret{
     ($func:path, $($arg_no:expr),*) => {
-        |ctx, args| -> Result<ReturnValue, HostError> {
-            $func(ctx, $(SandboxValue(args[$arg_no]).try_into()?,)*).map(|ret| Into::<SandboxValue>::into(ret).0.into())
+        |ctx, args: &[Value]| -> Result<WasmReturnValue, HostError> {
+            $func(ctx, $(SandboxValue(args[$arg_no]).try_into()?,)*)
+            .map(|(gas, r)| WasmReturnValue {
+                gas: gas as i64,
+                inner: r.into_value().into(),
+            })
         }
     }
 }
 
 macro_rules! wrap_common_func_internal_no_ret{
     ($func:path, $($arg_no:expr),*) => {
-        |ctx, _args| -> Result<ReturnValue, HostError> {
-            $func(ctx, $(SandboxValue(_args[$arg_no]).try_into()?,)*).map(|_| ReturnValue::Unit)
+        |ctx, _args: &[Value]| -> Result<WasmReturnValue, HostError> {
+            $func(ctx, $(SandboxValue(_args[$arg_no]).try_into()?,)*)
+            .map(|(gas, _)| WasmReturnValue {
+                gas: gas as i64,
+                inner: ReturnValue::Unit,
+            })
         }
     }
 }
@@ -118,6 +127,8 @@ macro_rules! wrap_common_func {
     ($func:path, (6) -> ()) =>  { wrap_common_func_internal_no_ret!($func, 0, 1, 2, 3, 4, 5) };
     ($func:path, (7) -> ()) =>  { wrap_common_func_internal_no_ret!($func, 0, 1, 2, 3, 4, 5, 6) };
     ($func:path, (8) -> ()) =>  { wrap_common_func_internal_no_ret!($func, 0, 1, 2, 3, 4, 5, 6, 7) };
+    ($func:path, (9) -> ()) =>  { wrap_common_func_internal_no_ret!($func, 0, 1, 2, 3, 4, 5, 6, 7, 8) };
+    ($func:path, (10) -> ()) =>  { wrap_common_func_internal_no_ret!($func, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9) };
 
     ($func:path, () -> (1)) =>  { wrap_common_func_internal_ret!($func,) };
     ($func:path, (1) -> (1)) => { wrap_common_func_internal_ret!($func, 0) };
@@ -127,6 +138,8 @@ macro_rules! wrap_common_func {
     ($func:path, (5) -> (1)) => { wrap_common_func_internal_ret!($func, 0, 1, 2, 3, 4) };
     ($func:path, (6) -> (1)) => { wrap_common_func_internal_ret!($func, 0, 1, 2, 3, 4, 5) };
     ($func:path, (7) -> (1)) => { wrap_common_func_internal_ret!($func, 0, 1, 2, 3, 4, 5, 6) };
+    ($func:path, (8) -> (1)) => { wrap_common_func_internal_ret!($func, 0, 1, 2, 3, 4, 5, 6, 7) };
+    ($func:path, (9) -> (1)) => { wrap_common_func_internal_ret!($func, 0, 1, 2, 3, 4, 5, 6, 7, 8) };
 }
 
 #[derive(Debug, derive_more::Display)]
@@ -171,7 +184,7 @@ where
             self.env_def_builder.add_host_func(
                 "env",
                 name.to_str(),
-                wrap_common_func!(FuncsHandler::forbidden, () -> ()),
+                wrap_common_func!(FuncsHandler::forbidden, (1) -> ()),
             );
         } else {
             self.env_def_builder.add_host_func("env", name.to_str(), f);
@@ -203,62 +216,62 @@ where
 {
     #[rustfmt::skip]
     fn bind_funcs(builder: &mut EnvBuilder<Ext>) {
-        builder.add_func(BlockHeight, wrap_common_func!(FuncsHandler::block_height, (1) -> ()));
-        builder.add_func(BlockTimestamp,wrap_common_func!(FuncsHandler::block_timestamp, (1) -> ()));
-        builder.add_func(CreateProgram, wrap_common_func!(FuncsHandler::create_program, (7) -> ()));
-        builder.add_func(CreateProgramWGas, wrap_common_func!(FuncsHandler::create_program_wgas, (8) -> ()));
-        builder.add_func(Debug, wrap_common_func!(FuncsHandler::debug, (2) -> ()));
-        builder.add_func(Panic, wrap_common_func!(FuncsHandler::panic, (2) -> ()));
-        builder.add_func(OomPanic, wrap_common_func!(FuncsHandler::oom_panic, () -> ()));
-        builder.add_func(Exit, wrap_common_func!(FuncsHandler::exit, (1) -> ()));
-        builder.add_func(ReplyCode, wrap_common_func!(FuncsHandler::reply_code, (1) -> ()));
-        builder.add_func(SignalCode, wrap_common_func!(FuncsHandler::signal_code, (1) -> ()));
-        builder.add_func(ReserveGas, wrap_common_func!(FuncsHandler::reserve_gas, (3) -> ()));
-        builder.add_func(ReplyDeposit, wrap_common_func!(FuncsHandler::reply_deposit, (3) -> ()));
-        builder.add_func(UnreserveGas, wrap_common_func!(FuncsHandler::unreserve_gas, (2) -> ()));
-        builder.add_func(GasAvailable, wrap_common_func!(FuncsHandler::gas_available, (1) -> ()));
-        builder.add_func(Leave, wrap_common_func!(FuncsHandler::leave, () -> ()));
-        builder.add_func(MessageId, wrap_common_func!(FuncsHandler::message_id, (1) -> ()));
-        builder.add_func(PayProgramRent, wrap_common_func!(FuncsHandler::pay_program_rent, (2) -> ()));
-        builder.add_func(ProgramId, wrap_common_func!(FuncsHandler::program_id, (1) -> ()));
-        builder.add_func(Random, wrap_common_func!(FuncsHandler::random, (2) -> ()));
-        builder.add_func(Read, wrap_common_func!(FuncsHandler::read, (4) -> ()));
-        builder.add_func(Reply, wrap_common_func!(FuncsHandler::reply, (4) -> ()));
-        builder.add_func(ReplyCommit, wrap_common_func!(FuncsHandler::reply_commit, (2) -> ()));
-        builder.add_func(ReplyCommitWGas, wrap_common_func!(FuncsHandler::reply_commit_wgas, (3) -> ()));
-        builder.add_func(ReplyPush, wrap_common_func!(FuncsHandler::reply_push, (3) -> ()));
-        builder.add_func(ReplyTo, wrap_common_func!(FuncsHandler::reply_to, (1) -> ()));
-        builder.add_func(SignalFrom, wrap_common_func!(FuncsHandler::signal_from, (1) -> ()));
-        builder.add_func(ReplyWGas, wrap_common_func!(FuncsHandler::reply_wgas, (5) -> ()));
-        builder.add_func(ReplyInput, wrap_common_func!(FuncsHandler::reply_input, (4) -> ()));
-        builder.add_func(ReplyPushInput, wrap_common_func!(FuncsHandler::reply_push_input, (3) -> ()));
-        builder.add_func(ReplyInputWGas, wrap_common_func!(FuncsHandler::reply_input_wgas, (5) -> ()));
-        builder.add_func(Send, wrap_common_func!(FuncsHandler::send, (5) -> ()));
-        builder.add_func(SendCommit, wrap_common_func!(FuncsHandler::send_commit, (4) -> ()));
-        builder.add_func(SendCommitWGas, wrap_common_func!(FuncsHandler::send_commit_wgas, (5) -> ()));
-        builder.add_func(SendInit, wrap_common_func!(FuncsHandler::send_init, (1) -> ()));
-        builder.add_func(SendPush, wrap_common_func!(FuncsHandler::send_push, (4) -> ()));
-        builder.add_func(SendWGas, wrap_common_func!(FuncsHandler::send_wgas, (6) -> ()));
-        builder.add_func(SendInput, wrap_common_func!(FuncsHandler::send_input, (5) -> ()));
-        builder.add_func(SendPushInput, wrap_common_func!(FuncsHandler::send_push_input, (4) -> ()));
-        builder.add_func(SendInputWGas, wrap_common_func!(FuncsHandler::send_input_wgas, (6) -> ()));
-        builder.add_func(Size, wrap_common_func!(FuncsHandler::size, (1) -> ()));
-        builder.add_func(Source, wrap_common_func!(FuncsHandler::source, (1) -> ()));
-        builder.add_func(Value, wrap_common_func!(FuncsHandler::value, (1) -> ()));
-        builder.add_func(ValueAvailable, wrap_common_func!(FuncsHandler::value_available, (1) -> ()));
-        builder.add_func(Wait, wrap_common_func!(FuncsHandler::wait, () -> ()));
-        builder.add_func(WaitFor, wrap_common_func!(FuncsHandler::wait_for, (1) -> ()));
-        builder.add_func(WaitUpTo, wrap_common_func!(FuncsHandler::wait_up_to, (1) -> ()));
-        builder.add_func(Wake, wrap_common_func!(FuncsHandler::wake, (3) -> ()));
-        builder.add_func(SystemReserveGas, wrap_common_func!(FuncsHandler::system_reserve_gas, (2) -> ()));
-        builder.add_func(ReservationReply, wrap_common_func!(FuncsHandler::reservation_reply, (4) -> ()));
-        builder.add_func(ReservationReplyCommit, wrap_common_func!(FuncsHandler::reservation_reply_commit, (2) -> ()));
-        builder.add_func(ReservationSend, wrap_common_func!(FuncsHandler::reservation_send, (5) -> ()));
-        builder.add_func(ReservationSendCommit, wrap_common_func!(FuncsHandler::reservation_send_commit, (4) -> ()));
-        builder.add_func(OutOfGas, wrap_common_func!(FuncsHandler::out_of_gas, () -> ()));
-
-        builder.add_func(Alloc, wrap_common_func!(FuncsHandler::alloc, (1) -> (1)));
-        builder.add_func(Free, wrap_common_func!(FuncsHandler::free, (1) -> (1)));
+        builder.add_func(BlockHeight, wrap_common_func!(FuncsHandler::block_height, (2) -> ()));
+        builder.add_func(BlockTimestamp,wrap_common_func!(FuncsHandler::block_timestamp, (2) -> ()));
+        builder.add_func(CreateProgram, wrap_common_func!(FuncsHandler::create_program, (8) -> ()));
+        builder.add_func(CreateProgramWGas, wrap_common_func!(FuncsHandler::create_program_wgas, (9) -> ()));
+        builder.add_func(Debug, wrap_common_func!(FuncsHandler::debug, (3) -> ()));
+        builder.add_func(Panic, wrap_common_func!(FuncsHandler::panic, (3) -> ()));
+        builder.add_func(OomPanic, wrap_common_func!(FuncsHandler::oom_panic, (1) -> ()));
+        builder.add_func(Exit, wrap_common_func!(FuncsHandler::exit, (2) -> ()));
+        builder.add_func(ReplyCode, wrap_common_func!(FuncsHandler::reply_code, (2) -> ()));
+        builder.add_func(SignalCode, wrap_common_func!(FuncsHandler::signal_code, (2) -> ()));
+        builder.add_func(ReserveGas, wrap_common_func!(FuncsHandler::reserve_gas, (4) -> ()));
+        builder.add_func(ReplyDeposit, wrap_common_func!(FuncsHandler::reply_deposit, (4) -> ()));
+        builder.add_func(UnreserveGas, wrap_common_func!(FuncsHandler::unreserve_gas, (3) -> ()));
+        builder.add_func(GasAvailable, wrap_common_func!(FuncsHandler::gas_available, (2) -> ()));
+        builder.add_func(Leave, wrap_common_func!(FuncsHandler::leave, (1) -> ()));
+        builder.add_func(MessageId, wrap_common_func!(FuncsHandler::message_id, (2) -> ()));
+        builder.add_func(PayProgramRent, wrap_common_func!(FuncsHandler::pay_program_rent, (3) -> ()));
+        builder.add_func(ProgramId, wrap_common_func!(FuncsHandler::program_id, (2) -> ()));
+        builder.add_func(Random, wrap_common_func!(FuncsHandler::random, (3) -> ()));
+        builder.add_func(Read, wrap_common_func!(FuncsHandler::read, (5) -> ()));
+        builder.add_func(Reply, wrap_common_func!(FuncsHandler::reply, (5) -> ()));
+        builder.add_func(ReplyCommit, wrap_common_func!(FuncsHandler::reply_commit, (3) -> ()));
+        builder.add_func(ReplyCommitWGas, wrap_common_func!(FuncsHandler::reply_commit_wgas, (4) -> ()));
+        builder.add_func(ReplyPush, wrap_common_func!(FuncsHandler::reply_push, (4) -> ()));
+        builder.add_func(ReplyTo, wrap_common_func!(FuncsHandler::reply_to, (2) -> ()));
+        builder.add_func(SignalFrom, wrap_common_func!(FuncsHandler::signal_from, (2) -> ()));
+        builder.add_func(ReplyWGas, wrap_common_func!(FuncsHandler::reply_wgas, (6) -> ()));
+        builder.add_func(ReplyInput, wrap_common_func!(FuncsHandler::reply_input, (5) -> ()));
+        builder.add_func(ReplyPushInput, wrap_common_func!(FuncsHandler::reply_push_input, (4) -> ()));
+        builder.add_func(ReplyInputWGas, wrap_common_func!(FuncsHandler::reply_input_wgas, (6) -> ()));
+        builder.add_func(Send, wrap_common_func!(FuncsHandler::send, (6) -> ()));
+        builder.add_func(SendCommit, wrap_common_func!(FuncsHandler::send_commit, (5) -> ()));
+        builder.add_func(SendCommitWGas, wrap_common_func!(FuncsHandler::send_commit_wgas, (6) -> ()));
+        builder.add_func(SendInit, wrap_common_func!(FuncsHandler::send_init, (2) -> ()));
+        builder.add_func(SendPush, wrap_common_func!(FuncsHandler::send_push, (5) -> ()));
+        builder.add_func(SendWGas, wrap_common_func!(FuncsHandler::send_wgas, (7) -> ()));
+        builder.add_func(SendInput, wrap_common_func!(FuncsHandler::send_input, (6) -> ()));
+        builder.add_func(SendPushInput, wrap_common_func!(FuncsHandler::send_push_input, (5) -> ()));
+        builder.add_func(SendInputWGas, wrap_common_func!(FuncsHandler::send_input_wgas, (7) -> ()));
+        builder.add_func(Size, wrap_common_func!(FuncsHandler::size, (2) -> ()));
+        builder.add_func(Source, wrap_common_func!(FuncsHandler::source, (2) -> ()));
+        builder.add_func(Value, wrap_common_func!(FuncsHandler::value, (2) -> ()));
+        builder.add_func(ValueAvailable, wrap_common_func!(FuncsHandler::value_available, (2) -> ()));
+        builder.add_func(Wait, wrap_common_func!(FuncsHandler::wait, (1) -> ()));
+        builder.add_func(WaitFor, wrap_common_func!(FuncsHandler::wait_for, (2) -> ()));
+        builder.add_func(WaitUpTo, wrap_common_func!(FuncsHandler::wait_up_to, (2) -> ()));
+        builder.add_func(Wake, wrap_common_func!(FuncsHandler::wake, (4) -> ()));
+        builder.add_func(SystemReserveGas, wrap_common_func!(FuncsHandler::system_reserve_gas, (3) -> ()));
+        builder.add_func(ReservationReply, wrap_common_func!(FuncsHandler::reservation_reply, (5) -> ()));
+        builder.add_func(ReservationReplyCommit, wrap_common_func!(FuncsHandler::reservation_reply_commit, (3) -> ()));
+        builder.add_func(ReservationSend, wrap_common_func!(FuncsHandler::reservation_send, (6) -> ()));
+        builder.add_func(ReservationSendCommit, wrap_common_func!(FuncsHandler::reservation_send_commit, (5) -> ()));
+        builder.add_func(OutOfGas, wrap_common_func!(FuncsHandler::out_of_gas, (1) -> ()));
+
+        builder.add_func(Alloc, wrap_common_func!(FuncsHandler::alloc, (2) -> (1)));
+        builder.add_func(Free, wrap_common_func!(FuncsHandler::free, (2) -> (1)));
     }
 }
 
@@ -324,7 +337,6 @@ where
         let mut runtime = Runtime {
             ext,
             memory: MemoryWrap::new(memory),
-            globals: Default::default(),
             memory_manager: Default::default(),
             termination_reason: ActorTerminationReason::Success.into(),
         };
@@ -367,15 +379,9 @@ where
             .and_then(|global| global.as_i32())
             .map(|global| global as u32);
 
-        runtime.globals = instance
-            .instance_globals()
-            .ok_or(System(GlobalsNotSupported))?;
-
         let gas = runtime.ext.define_current_counter();
 
-        // Setting initial value of global.
-        runtime
-            .globals
+        instance
             .set_global_val(GLOBAL_NAME_GAS, Value::I64(gas as i64))
             .map_err(|_| System(WrongInjectedGas))?;
 
@@ -405,8 +411,7 @@ where
             .unwrap_or(Ok(ReturnValue::Unit));
 
         // Fetching global value.
-        let gas = runtime
-            .globals
+        let gas = instance
             .get_global_val(GLOBAL_NAME_GAS)
             .and_then(runtime::as_u64)
             .ok_or(System(WrongInjectedGas))?;
diff --git a/core-backend/sandbox/src/runtime.rs b/core-backend/sandbox/src/runtime.rs
index 62d5bbcf91f..1e2573239b4 100644
--- a/core-backend/sandbox/src/runtime.rs
+++ b/core-backend/sandbox/src/runtime.rs
@@ -30,8 +30,7 @@ use gear_backend_common::{
     BackendExternalities, BackendState, BackendTermination, UndefinedTerminationReason,
 };
 use gear_core::{costs::RuntimeCosts, pages::WasmPage};
-use gear_sandbox::{HostError, InstanceGlobals, Value};
-use gear_wasm_instrument::GLOBAL_NAME_GAS;
+use gear_sandbox::{HostError, Value};
 
 pub(crate) fn as_i64(v: Value) -> Option<i64> {
     match v {
@@ -48,7 +47,6 @@ pub(crate) struct Runtime<Ext> {
     pub ext: Ext,
     pub memory: MemoryWrap,
     pub termination_reason: UndefinedTerminationReason,
-    pub globals: gear_sandbox::default_executor::InstanceGlobals,
     // TODO: make wrapper around runtime and move memory_manager there (issue #2067)
     pub memory_manager: MemoryAccessManager<Ext>,
 }
@@ -64,28 +62,37 @@ impl<Ext: BackendExternalities> CommonRuntime<Ext> for Runtime<Ext> {
         HostError
     }
 
-    fn run_any<T, F>(&mut self, cost: RuntimeCosts, f: F) -> Result<T, Self::Error>
+    fn run_any<T, F>(&mut self, gas: u64, cost: RuntimeCosts, f: F) -> Result<(u64, T), Self::Error>
     where
         F: FnOnce(&mut Self) -> Result<T, UndefinedTerminationReason>,
     {
-        self.with_globals_update(|ctx| {
-            ctx.prepare_run();
-            ctx.ext.charge_gas_runtime(cost)?;
-            f(ctx)
-        })
+        self.prepare_run(gas);
+
+        let run = || {
+            self.ext.charge_gas_runtime(cost)?;
+            f(self)
+        };
+
+        run()
+            .map_err(|err| {
+                self.set_termination_reason(err);
+                HostError
+            })
+            .map(|r| (self.ext.define_current_counter(), r))
     }
 
     fn run_fallible<T: Sized, F, R>(
         &mut self,
+        gas: u64,
         res_ptr: u32,
         cost: RuntimeCosts,
         f: F,
-    ) -> Result<(), Self::Error>
+    ) -> Result<(u64, ()), Self::Error>
     where
         F: FnOnce(&mut Self) -> Result<T, RunFallibleError>,
         R: From<Result<T, u32>> + Sized,
     {
-        self.run_any(cost, |ctx| {
+        self.run_any(gas, cost, |ctx| {
             let res = f(ctx);
             let res = ctx.process_fallible_func_result(res)?;
 
@@ -94,7 +101,6 @@ impl<Ext: BackendExternalities> CommonRuntime<Ext> for Runtime<Ext> {
 
             ctx.write_as(write_res, R::from(res)).map_err(Into::into)
         })
-        .map(|_| ())
     }
 
     fn alloc(&mut self, pages: u32) -> Result<WasmPage, <Ext>::AllocError> {
@@ -104,43 +110,12 @@ impl<Ext: BackendExternalities> CommonRuntime<Ext> for Runtime<Ext> {
 
 impl<Ext: BackendExternalities> Runtime<Ext> {
     // Cleans `memory_manager`, updates ext counters based on globals.
-    fn prepare_run(&mut self) {
+    fn prepare_run(&mut self, gas: u64) {
         self.memory_manager = Default::default();
 
-        let gas = self
-            .globals
-            .get_global_val(GLOBAL_NAME_GAS)
-            .and_then(as_u64)
-            .unwrap_or_else(|| unreachable!("Globals must be checked during env creation"));
-
         self.ext.decrease_current_counter_to(gas);
     }
 
-    // Updates globals after execution.
-    fn update_globals(&mut self) {
-        let gas = self.ext.define_current_counter();
-
-        self.globals
-            .set_global_val(GLOBAL_NAME_GAS, Value::I64(gas as i64))
-            .unwrap_or_else(|e| {
-                unreachable!("Globals must be checked during env creation: {:?}", e)
-            });
-    }
-
-    fn with_globals_update<T, F>(&mut self, f: F) -> Result<T, HostError>
-    where
-        F: FnOnce(&mut Self) -> Result<T, UndefinedTerminationReason>,
-    {
-        let result = f(self).map_err(|err| {
-            self.set_termination_reason(err);
-            HostError
-        });
-
-        self.update_globals();
-
-        result
-    }
-
     fn with_memory<R, F>(&mut self, f: F) -> Result<R, MemoryAccessError>
     where
         F: FnOnce(
diff --git a/core-backend/wasmi/src/funcs_tree.rs b/core-backend/wasmi/src/funcs_tree.rs
index ac0d6d2e9f9..dba1ef58a79 100644
--- a/core-backend/wasmi/src/funcs_tree.rs
+++ b/core-backend/wasmi/src/funcs_tree.rs
@@ -46,7 +46,9 @@ macro_rules! wrap_common_func_internal_ret {
             let func = move |caller: Caller<'_, HostState<Ext>>, $($arg_name,)*| -> Result<(_, ), Trap>
             {
                 let mut ctx = CallerWrap::prepare(caller, forbidden, memory)?;
-                $func(&mut ctx, $($arg_name,)*).map(|ret| (ret,))
+                // Zero-value argument is an unused gas value for wasmi backend as well
+                // as the first element of the result tuple.
+                $func(&mut ctx, 0, $($arg_name,)*).map(|(_, r)| (r,))
             };
             Func::wrap(store, func)
         }
@@ -59,7 +61,10 @@ macro_rules! wrap_common_func_internal_no_ret {
             let func = move |caller: Caller<'_, HostState<Ext>>, $($arg_name,)*| -> Result<(), Trap>
             {
                 let mut ctx = CallerWrap::prepare(caller, forbidden, memory)?;
-                $func(&mut ctx, $($arg_name,)*)
+                // Zero-value argument is an unused gas value for wasmi backend as well
+                // as the first element of the result tuple.
+                $func(&mut ctx, 0, $($arg_name,)*)
+                .map(|(_, r)| r)
             };
             Func::wrap(store, func)
         }
diff --git a/core-backend/wasmi/src/runtime.rs b/core-backend/wasmi/src/runtime.rs
index 2c702561542..da154a83905 100644
--- a/core-backend/wasmi/src/runtime.rs
+++ b/core-backend/wasmi/src/runtime.rs
@@ -80,28 +80,35 @@ impl<'a, Ext: BackendExternalities + 'static> Runtime<Ext> for CallerWrap<'a, Ex
     }
 
     #[track_caller]
-    fn run_any<T, F>(&mut self, cost: RuntimeCosts, f: F) -> Result<T, Self::Error>
+    fn run_any<T, F>(
+        &mut self,
+        _gas: u64,
+        cost: RuntimeCosts,
+        f: F,
+    ) -> Result<(u64, T), Self::Error>
     where
         F: FnOnce(&mut Self) -> Result<T, UndefinedTerminationReason>,
     {
         self.with_globals_update(|ctx| {
             ctx.host_state_mut().ext.charge_gas_runtime(cost)?;
-            f(ctx)
+            f(ctx).map(|r| (0, r))
         })
     }
 
     #[track_caller]
     fn run_fallible<T: Sized, F, R>(
         &mut self,
+        gas: u64,
         res_ptr: u32,
         cost: RuntimeCosts,
         f: F,
-    ) -> Result<(), Self::Error>
+    ) -> Result<(u64, ()), Self::Error>
     where
         F: FnOnce(&mut Self) -> Result<T, RunFallibleError>,
         R: From<Result<T, u32>> + Sized,
     {
         self.run_any(
+            gas,
             cost,
             |ctx: &mut Self| -> Result<_, UndefinedTerminationReason> {
                 let res = f(ctx);
diff --git a/pallets/gear/src/weights.rs b/pallets/gear/src/weights.rs
index 7a7a7a774c7..ccc5aa6d48e 100644
--- a/pallets/gear/src/weights.rs
+++ b/pallets/gear/src/weights.rs
@@ -19,7 +19,7 @@
 //! Autogenerated weights for pallet_gear
 //!
 //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
-//! DATE: 2023-08-01, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! DATE: 2023-08-07, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
 //! WORST CASE MAP SIZE: `1000000`
 //! CPU: `Intel(R) Xeon(R) Platinum 8375C CPU @ 2.90GHz`
 //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("gear-dev"), DB CACHE: 1024
@@ -246,10 +246,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 965_000 picoseconds.
-        Weight::from_parts(1_020_000, 0)
-            // Standard Error: 753
-            .saturating_add(Weight::from_parts(247_354, 0).saturating_mul(c.into()))
+        // Minimum execution time: 954_000 picoseconds.
+        Weight::from_parts(1_004_000, 0)
+            // Standard Error: 802
+            .saturating_add(Weight::from_parts(249_956, 0).saturating_mul(c.into()))
             .saturating_add(T::DbWeight::get().writes(1_u64))
     }
     /// The range of component `c` is `[0, 512]`.
@@ -257,10 +257,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
         // Proof Size summary in bytes:
         //  Measured:  `42 + c * (1024 ±0)`
         //  Estimated: `3506 + c * (1024 ±0)`
-        // Minimum execution time: 2_780_000 picoseconds.
-        Weight::from_parts(2_874_000, 3506)
-            // Standard Error: 924
-            .saturating_add(Weight::from_parts(674_078, 0).saturating_mul(c.into()))
+        // Minimum execution time: 2_808_000 picoseconds.
+        Weight::from_parts(2_895_000, 3506)
+            // Standard Error: 1_086
+            .saturating_add(Weight::from_parts(680_150, 0).saturating_mul(c.into()))
             .saturating_add(T::DbWeight::get().reads(1_u64))
             .saturating_add(Weight::from_parts(0, 1024).saturating_mul(c.into()))
     }
@@ -269,17 +269,17 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 51_392_000 picoseconds.
-        Weight::from_parts(63_325_658, 0)
-            // Standard Error: 13_432
-            .saturating_add(Weight::from_parts(2_671_521, 0).saturating_mul(c.into()))
+        // Minimum execution time: 52_458_000 picoseconds.
+        Weight::from_parts(84_558_500, 0)
+            // Standard Error: 7_412
+            .saturating_add(Weight::from_parts(2_377_997, 0).saturating_mul(c.into()))
     }
     fn claim_value() -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `979`
         //  Estimated: `42236`
-        // Minimum execution time: 85_039_000 picoseconds.
-        Weight::from_parts(86_523_000, 42236)
+        // Minimum execution time: 81_302_000 picoseconds.
+        Weight::from_parts(83_307_000, 42236)
             .saturating_add(T::DbWeight::get().reads(13_u64))
             .saturating_add(T::DbWeight::get().writes(10_u64))
     }
@@ -287,8 +287,8 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
         // Proof Size summary in bytes:
         //  Measured:  `886`
         //  Estimated: `21261`
-        // Minimum execution time: 54_302_000 picoseconds.
-        Weight::from_parts(56_159_000, 21261)
+        // Minimum execution time: 52_219_000 picoseconds.
+        Weight::from_parts(53_704_000, 21261)
             .saturating_add(T::DbWeight::get().reads(7_u64))
             .saturating_add(T::DbWeight::get().writes(6_u64))
     }
@@ -296,8 +296,8 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
         // Proof Size summary in bytes:
         //  Measured:  `534`
         //  Estimated: `17070`
-        // Minimum execution time: 29_099_000 picoseconds.
-        Weight::from_parts(30_610_000, 17070)
+        // Minimum execution time: 28_408_000 picoseconds.
+        Weight::from_parts(29_714_000, 17070)
             .saturating_add(T::DbWeight::get().reads(6_u64))
             .saturating_add(T::DbWeight::get().writes(4_u64))
     }
@@ -306,10 +306,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
         // Proof Size summary in bytes:
         //  Measured:  `355`
         //  Estimated: `7640`
-        // Minimum execution time: 8_259_000 picoseconds.
-        Weight::from_parts(6_228_584, 7640)
-            // Standard Error: 37_556
-            .saturating_add(Weight::from_parts(16_519_610, 0).saturating_mul(c.into()))
+        // Minimum execution time: 7_918_000 picoseconds.
+        Weight::from_parts(6_745_647, 7640)
+            // Standard Error: 37_300
+            .saturating_add(Weight::from_parts(13_885_473, 0).saturating_mul(c.into()))
             .saturating_add(T::DbWeight::get().reads(2_u64))
             .saturating_add(T::DbWeight::get().writes(2_u64))
     }
@@ -318,10 +318,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
         // Proof Size summary in bytes:
         //  Measured:  `1297 + c * (16389 ±0)`
         //  Estimated: `40898 + c * (131112 ±0)`
-        // Minimum execution time: 70_699_000 picoseconds.
-        Weight::from_parts(71_447_000, 40898)
-            // Standard Error: 139_719
-            .saturating_add(Weight::from_parts(54_319_486, 0).saturating_mul(c.into()))
+        // Minimum execution time: 68_486_000 picoseconds.
+        Weight::from_parts(69_079_000, 40898)
+            // Standard Error: 164_982
+            .saturating_add(Weight::from_parts(55_774_264, 0).saturating_mul(c.into()))
             .saturating_add(T::DbWeight::get().reads(11_u64))
             .saturating_add(T::DbWeight::get().writes(9_u64))
             .saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(c.into())))
@@ -332,10 +332,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
         // Proof Size summary in bytes:
         //  Measured:  `10`
         //  Estimated: `4990`
-        // Minimum execution time: 60_906_000 picoseconds.
-        Weight::from_parts(18_999_485, 4990)
-            // Standard Error: 57_215
-            .saturating_add(Weight::from_parts(53_057_311, 0).saturating_mul(c.into()))
+        // Minimum execution time: 61_635_000 picoseconds.
+        Weight::from_parts(64_537_590, 4990)
+            // Standard Error: 40_298
+            .saturating_add(Weight::from_parts(52_820_238, 0).saturating_mul(c.into()))
             .saturating_add(T::DbWeight::get().reads(2_u64))
             .saturating_add(T::DbWeight::get().writes(4_u64))
     }
@@ -344,10 +344,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
         // Proof Size summary in bytes:
         //  Measured:  `671`
         //  Estimated: `38638`
-        // Minimum execution time: 65_623_000 picoseconds.
-        Weight::from_parts(88_392_610, 38638)
+        // Minimum execution time: 63_344_000 picoseconds.
+        Weight::from_parts(76_968_021, 38638)
             // Standard Error: 0
-            .saturating_add(Weight::from_parts(2_635, 0).saturating_mul(s.into()))
+            .saturating_add(Weight::from_parts(2_598, 0).saturating_mul(s.into()))
             .saturating_add(T::DbWeight::get().reads(13_u64))
             .saturating_add(T::DbWeight::get().writes(10_u64))
     }
@@ -357,12 +357,12 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
         // Proof Size summary in bytes:
         //  Measured:  `235`
         //  Estimated: `34312`
-        // Minimum execution time: 11_247_503_000 picoseconds.
-        Weight::from_parts(302_469_923, 34312)
-            // Standard Error: 147_459
-            .saturating_add(Weight::from_parts(54_400_528, 0).saturating_mul(c.into()))
-            // Standard Error: 8
-            .saturating_add(Weight::from_parts(2_571, 0).saturating_mul(s.into()))
+        // Minimum execution time: 10_980_969_000 picoseconds.
+        Weight::from_parts(301_891_685, 34312)
+            // Standard Error: 164_203
+            .saturating_add(Weight::from_parts(54_383_779, 0).saturating_mul(c.into()))
+            // Standard Error: 9
+            .saturating_add(Weight::from_parts(2_548, 0).saturating_mul(s.into()))
             .saturating_add(T::DbWeight::get().reads(13_u64))
             .saturating_add(T::DbWeight::get().writes(14_u64))
     }
@@ -371,10 +371,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
         // Proof Size summary in bytes:
         //  Measured:  `348`
         //  Estimated: `23853`
-        // Minimum execution time: 56_802_000 picoseconds.
-        Weight::from_parts(33_250_791, 23853)
-            // Standard Error: 1
-            .saturating_add(Weight::from_parts(1_182, 0).saturating_mul(p.into()))
+        // Minimum execution time: 53_732_000 picoseconds.
+        Weight::from_parts(35_204_611, 23853)
+            // Standard Error: 0
+            .saturating_add(Weight::from_parts(1_021, 0).saturating_mul(p.into()))
             .saturating_add(T::DbWeight::get().reads(9_u64))
             .saturating_add(T::DbWeight::get().writes(8_u64))
     }
@@ -383,10 +383,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
         // Proof Size summary in bytes:
         //  Measured:  `451`
         //  Estimated: `27177`
-        // Minimum execution time: 59_487_000 picoseconds.
-        Weight::from_parts(37_481_444, 27177)
-            // Standard Error: 1
-            .saturating_add(Weight::from_parts(1_182, 0).saturating_mul(p.into()))
+        // Minimum execution time: 57_078_000 picoseconds.
+        Weight::from_parts(37_366_780, 27177)
+            // Standard Error: 0
+            .saturating_add(Weight::from_parts(1_023, 0).saturating_mul(p.into()))
             .saturating_add(T::DbWeight::get().reads(10_u64))
             .saturating_add(T::DbWeight::get().writes(9_u64))
     }
@@ -395,10 +395,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
         // Proof Size summary in bytes:
         //  Measured:  `978`
         //  Estimated: `42227`
-        // Minimum execution time: 86_239_000 picoseconds.
-        Weight::from_parts(32_106_516, 42227)
-            // Standard Error: 3
-            .saturating_add(Weight::from_parts(1_249, 0).saturating_mul(p.into()))
+        // Minimum execution time: 82_297_000 picoseconds.
+        Weight::from_parts(62_302_593, 42227)
+            // Standard Error: 1
+            .saturating_add(Weight::from_parts(1_042, 0).saturating_mul(p.into()))
             .saturating_add(T::DbWeight::get().reads(13_u64))
             .saturating_add(T::DbWeight::get().writes(10_u64))
     }
@@ -407,10 +407,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
         // Proof Size summary in bytes:
         //  Measured:  `1081`
         //  Estimated: `45757`
-        // Minimum execution time: 98_413_000 picoseconds.
-        Weight::from_parts(52_381_439, 45757)
-            // Standard Error: 3
-            .saturating_add(Weight::from_parts(1_252, 0).saturating_mul(p.into()))
+        // Minimum execution time: 93_602_000 picoseconds.
+        Weight::from_parts(69_941_334, 45757)
+            // Standard Error: 1
+            .saturating_add(Weight::from_parts(1_057, 0).saturating_mul(p.into()))
             .saturating_add(T::DbWeight::get().reads(14_u64))
             .saturating_add(T::DbWeight::get().writes(11_u64))
     }
@@ -419,8 +419,8 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
         // Proof Size summary in bytes:
         //  Measured:  `760`
         //  Estimated: `74319`
-        // Minimum execution time: 302_634_000 picoseconds.
-        Weight::from_parts(320_223_637, 74319)
+        // Minimum execution time: 298_083_000 picoseconds.
+        Weight::from_parts(314_192_353, 74319)
             .saturating_add(T::DbWeight::get().reads(27_u64))
             .saturating_add(T::DbWeight::get().writes(22_u64))
     }
@@ -429,10 +429,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
         // Proof Size summary in bytes:
         //  Measured:  `760`
         //  Estimated: `74319`
-        // Minimum execution time: 315_859_000 picoseconds.
-        Weight::from_parts(328_138_594, 74319)
-            // Standard Error: 1_557
-            .saturating_add(Weight::from_parts(8_014, 0).saturating_mul(q.into()))
+        // Minimum execution time: 312_856_000 picoseconds.
+        Weight::from_parts(326_607_586, 74319)
+            // Standard Error: 1_507
+            .saturating_add(Weight::from_parts(723, 0).saturating_mul(q.into()))
             .saturating_add(T::DbWeight::get().reads(27_u64))
             .saturating_add(T::DbWeight::get().writes(22_u64))
     }
@@ -441,10 +441,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
         // Proof Size summary in bytes:
         //  Measured:  `211 + c * (1075 ±0)`
         //  Estimated: `3899 + c * (2150 ±0)`
-        // Minimum execution time: 45_804_000 picoseconds.
-        Weight::from_parts(46_226_000, 3899)
-            // Standard Error: 51_090
-            .saturating_add(Weight::from_parts(51_940_069, 0).saturating_mul(c.into()))
+        // Minimum execution time: 45_478_000 picoseconds.
+        Weight::from_parts(45_769_000, 3899)
+            // Standard Error: 42_221
+            .saturating_add(Weight::from_parts(51_492_007, 0).saturating_mul(c.into()))
             .saturating_add(T::DbWeight::get().reads(1_u64))
             .saturating_add(T::DbWeight::get().writes(2_u64))
             .saturating_add(Weight::from_parts(0, 2150).saturating_mul(c.into()))
@@ -454,630 +454,630 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 80_872_000 picoseconds.
-        Weight::from_parts(82_358_000, 0)
-            // Standard Error: 3_946_533
-            .saturating_add(Weight::from_parts(617_270_552, 0).saturating_mul(r.into()))
+        // Minimum execution time: 85_248_000 picoseconds.
+        Weight::from_parts(87_224_000, 0)
+            // Standard Error: 4_031_043
+            .saturating_add(Weight::from_parts(559_145_890, 0).saturating_mul(r.into()))
     }
     /// The range of component `p` is `[1, 512]`.
     fn alloc_per_page(p: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 365_182_000 picoseconds.
-        Weight::from_parts(292_523_651, 0)
-            // Standard Error: 7_087
-            .saturating_add(Weight::from_parts(31_059_002, 0).saturating_mul(p.into()))
+        // Minimum execution time: 304_310_000 picoseconds.
+        Weight::from_parts(240_640_662, 0)
+            // Standard Error: 7_875
+            .saturating_add(Weight::from_parts(30_931_778, 0).saturating_mul(p.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn free(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 196_771_000 picoseconds.
-        Weight::from_parts(219_836_156, 0)
-            // Standard Error: 406_704
-            .saturating_add(Weight::from_parts(120_742_843, 0).saturating_mul(r.into()))
+        // Minimum execution time: 144_728_000 picoseconds.
+        Weight::from_parts(127_694_995, 0)
+            // Standard Error: 344_021
+            .saturating_add(Weight::from_parts(63_008_235, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 256]`.
     fn gr_reserve_gas(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 86_043_000 picoseconds.
-        Weight::from_parts(92_117_781, 0)
-            // Standard Error: 7_334
-            .saturating_add(Weight::from_parts(3_640_301, 0).saturating_mul(r.into()))
+        // Minimum execution time: 85_763_000 picoseconds.
+        Weight::from_parts(93_302_515, 0)
+            // Standard Error: 3_873
+            .saturating_add(Weight::from_parts(2_723_217, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 256]`.
     fn gr_unreserve_gas(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 146_803_000 picoseconds.
-        Weight::from_parts(168_908_676, 0)
-            // Standard Error: 28_070
-            .saturating_add(Weight::from_parts(3_989_643, 0).saturating_mul(r.into()))
+        // Minimum execution time: 134_987_000 picoseconds.
+        Weight::from_parts(141_052_149, 0)
+            // Standard Error: 29_498
+            .saturating_add(Weight::from_parts(3_252_053, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_system_reserve_gas(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 82_421_000 picoseconds.
-        Weight::from_parts(109_902_108, 0)
-            // Standard Error: 458_197
-            .saturating_add(Weight::from_parts(186_560_355, 0).saturating_mul(r.into()))
+        // Minimum execution time: 82_532_000 picoseconds.
+        Weight::from_parts(111_956_884, 0)
+            // Standard Error: 420_651
+            .saturating_add(Weight::from_parts(124_761_103, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_message_id(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 85_173_000 picoseconds.
-        Weight::from_parts(81_703_608, 0)
-            // Standard Error: 318_823
-            .saturating_add(Weight::from_parts(183_602_076, 0).saturating_mul(r.into()))
+        // Minimum execution time: 82_442_000 picoseconds.
+        Weight::from_parts(76_262_730, 0)
+            // Standard Error: 310_067
+            .saturating_add(Weight::from_parts(115_334_131, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_program_id(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 85_999_000 picoseconds.
-        Weight::from_parts(81_002_605, 0)
-            // Standard Error: 269_075
-            .saturating_add(Weight::from_parts(183_154_106, 0).saturating_mul(r.into()))
+        // Minimum execution time: 82_322_000 picoseconds.
+        Weight::from_parts(71_153_919, 0)
+            // Standard Error: 293_317
+            .saturating_add(Weight::from_parts(115_508_333, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_source(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 82_306_000 picoseconds.
-        Weight::from_parts(79_166_166, 0)
-            // Standard Error: 332_502
-            .saturating_add(Weight::from_parts(182_666_522, 0).saturating_mul(r.into()))
+        // Minimum execution time: 82_586_000 picoseconds.
+        Weight::from_parts(73_401_225, 0)
+            // Standard Error: 306_089
+            .saturating_add(Weight::from_parts(115_530_298, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_value(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 82_459_000 picoseconds.
-        Weight::from_parts(80_301_392, 0)
-            // Standard Error: 340_598
-            .saturating_add(Weight::from_parts(184_099_120, 0).saturating_mul(r.into()))
+        // Minimum execution time: 86_537_000 picoseconds.
+        Weight::from_parts(80_327_682, 0)
+            // Standard Error: 275_679
+            .saturating_add(Weight::from_parts(114_024_859, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_value_available(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 81_140_000 picoseconds.
-        Weight::from_parts(72_987_262, 0)
-            // Standard Error: 388_909
-            .saturating_add(Weight::from_parts(186_920_851, 0).saturating_mul(r.into()))
+        // Minimum execution time: 84_226_000 picoseconds.
+        Weight::from_parts(74_308_323, 0)
+            // Standard Error: 291_460
+            .saturating_add(Weight::from_parts(115_396_428, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_gas_available(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 81_336_000 picoseconds.
-        Weight::from_parts(79_078_269, 0)
-            // Standard Error: 276_322
-            .saturating_add(Weight::from_parts(182_690_178, 0).saturating_mul(r.into()))
+        // Minimum execution time: 81_250_000 picoseconds.
+        Weight::from_parts(74_761_588, 0)
+            // Standard Error: 317_797
+            .saturating_add(Weight::from_parts(115_173_001, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_size(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 84_201_000 picoseconds.
-        Weight::from_parts(79_459_558, 0)
-            // Standard Error: 357_406
-            .saturating_add(Weight::from_parts(182_989_857, 0).saturating_mul(r.into()))
+        // Minimum execution time: 85_673_000 picoseconds.
+        Weight::from_parts(70_907_772, 0)
+            // Standard Error: 347_682
+            .saturating_add(Weight::from_parts(118_189_625, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_read(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 709_298_000 picoseconds.
-        Weight::from_parts(792_701_124, 0)
-            // Standard Error: 581_476
-            .saturating_add(Weight::from_parts(264_833_637, 0).saturating_mul(r.into()))
+        // Minimum execution time: 700_530_000 picoseconds.
+        Weight::from_parts(774_384_678, 0)
+            // Standard Error: 512_748
+            .saturating_add(Weight::from_parts(194_331_468, 0).saturating_mul(r.into()))
     }
     /// The range of component `n` is `[0, 2048]`.
     fn gr_read_per_kb(n: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 958_553_000 picoseconds.
-        Weight::from_parts(1_002_082_000, 0)
-            // Standard Error: 51_056
-            .saturating_add(Weight::from_parts(13_349_580, 0).saturating_mul(n.into()))
+        // Minimum execution time: 866_889_000 picoseconds.
+        Weight::from_parts(872_993_000, 0)
+            // Standard Error: 59_048
+            .saturating_add(Weight::from_parts(13_399_620, 0).saturating_mul(n.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_block_height(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 81_092_000 picoseconds.
-        Weight::from_parts(70_460_333, 0)
-            // Standard Error: 322_779
-            .saturating_add(Weight::from_parts(182_652_206, 0).saturating_mul(r.into()))
+        // Minimum execution time: 85_291_000 picoseconds.
+        Weight::from_parts(75_543_485, 0)
+            // Standard Error: 320_701
+            .saturating_add(Weight::from_parts(115_757_456, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_block_timestamp(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 82_315_000 picoseconds.
-        Weight::from_parts(77_285_940, 0)
-            // Standard Error: 310_862
-            .saturating_add(Weight::from_parts(183_154_588, 0).saturating_mul(r.into()))
+        // Minimum execution time: 83_780_000 picoseconds.
+        Weight::from_parts(68_090_338, 0)
+            // Standard Error: 330_050
+            .saturating_add(Weight::from_parts(117_803_137, 0).saturating_mul(r.into()))
     }
     /// The range of component `n` is `[0, 20]`.
     fn gr_random(n: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 82_813_000 picoseconds.
-        Weight::from_parts(83_631_977, 0)
-            // Standard Error: 426_894
-            .saturating_add(Weight::from_parts(250_044_040, 0).saturating_mul(n.into()))
+        // Minimum execution time: 84_394_000 picoseconds.
+        Weight::from_parts(88_472_912, 0)
+            // Standard Error: 340_524
+            .saturating_add(Weight::from_parts(190_044_477, 0).saturating_mul(n.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_reply_deposit(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 87_342_000 picoseconds.
-        Weight::from_parts(88_861_000, 0)
-            // Standard Error: 4_034_065
-            .saturating_add(Weight::from_parts(1_070_363_129, 0).saturating_mul(r.into()))
+        // Minimum execution time: 83_081_000 picoseconds.
+        Weight::from_parts(85_006_000, 0)
+            // Standard Error: 3_456_961
+            .saturating_add(Weight::from_parts(860_188_117, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_send(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 82_887_000 picoseconds.
-        Weight::from_parts(154_402_402, 0)
-            // Standard Error: 504_137
-            .saturating_add(Weight::from_parts(389_538_545, 0).saturating_mul(r.into()))
+        // Minimum execution time: 81_490_000 picoseconds.
+        Weight::from_parts(136_619_765, 0)
+            // Standard Error: 439_674
+            .saturating_add(Weight::from_parts(308_552_304, 0).saturating_mul(r.into()))
     }
     /// The range of component `n` is `[0, 2048]`.
     fn gr_send_per_kb(n: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 467_573_000 picoseconds.
-        Weight::from_parts(471_685_000, 0)
-            // Standard Error: 64_140
-            .saturating_add(Weight::from_parts(22_109_126, 0).saturating_mul(n.into()))
+        // Minimum execution time: 386_929_000 picoseconds.
+        Weight::from_parts(393_325_000, 0)
+            // Standard Error: 61_932
+            .saturating_add(Weight::from_parts(21_101_790, 0).saturating_mul(n.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_send_wgas(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 86_853_000 picoseconds.
-        Weight::from_parts(152_053_498, 0)
-            // Standard Error: 538_330
-            .saturating_add(Weight::from_parts(397_711_575, 0).saturating_mul(r.into()))
+        // Minimum execution time: 84_625_000 picoseconds.
+        Weight::from_parts(162_584_483, 0)
+            // Standard Error: 494_553
+            .saturating_add(Weight::from_parts(313_684_139, 0).saturating_mul(r.into()))
     }
     /// The range of component `n` is `[0, 2048]`.
     fn gr_send_wgas_per_kb(n: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 471_875_000 picoseconds.
-        Weight::from_parts(475_692_000, 0)
-            // Standard Error: 57_997
-            .saturating_add(Weight::from_parts(21_385_701, 0).saturating_mul(n.into()))
+        // Minimum execution time: 390_932_000 picoseconds.
+        Weight::from_parts(393_883_000, 0)
+            // Standard Error: 68_646
+            .saturating_add(Weight::from_parts(21_188_381, 0).saturating_mul(n.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_send_input(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 716_684_000 picoseconds.
-        Weight::from_parts(781_328_373, 0)
-            // Standard Error: 479_933
-            .saturating_add(Weight::from_parts(411_727_995, 0).saturating_mul(r.into()))
+        // Minimum execution time: 708_623_000 picoseconds.
+        Weight::from_parts(781_094_266, 0)
+            // Standard Error: 460_683
+            .saturating_add(Weight::from_parts(328_993_362, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_send_input_wgas(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 746_421_000 picoseconds.
-        Weight::from_parts(889_163_923, 0)
-            // Standard Error: 621_967
-            .saturating_add(Weight::from_parts(412_763_026, 0).saturating_mul(r.into()))
+        // Minimum execution time: 710_228_000 picoseconds.
+        Weight::from_parts(774_190_634, 0)
+            // Standard Error: 483_646
+            .saturating_add(Weight::from_parts(330_057_876, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_send_init(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 81_961_000 picoseconds.
-        Weight::from_parts(86_031_226, 0)
-            // Standard Error: 355_690
-            .saturating_add(Weight::from_parts(191_347_968, 0).saturating_mul(r.into()))
+        // Minimum execution time: 83_510_000 picoseconds.
+        Weight::from_parts(64_097_635, 0)
+            // Standard Error: 358_570
+            .saturating_add(Weight::from_parts(126_095_109, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_send_push(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 3_797_807_000 picoseconds.
-        Weight::from_parts(3_948_397_472, 0)
-            // Standard Error: 396_090
-            .saturating_add(Weight::from_parts(284_341_649, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_430_098_000 picoseconds.
+        Weight::from_parts(2_605_278_898, 0)
+            // Standard Error: 439_185
+            .saturating_add(Weight::from_parts(217_479_981, 0).saturating_mul(r.into()))
     }
     /// The range of component `n` is `[0, 2048]`.
     fn gr_send_push_per_kb(n: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 485_799_000 picoseconds.
-        Weight::from_parts(486_862_000, 0)
-            // Standard Error: 47_704
-            .saturating_add(Weight::from_parts(31_360_292, 0).saturating_mul(n.into()))
+        // Minimum execution time: 358_553_000 picoseconds.
+        Weight::from_parts(364_183_000, 0)
+            // Standard Error: 51_397
+            .saturating_add(Weight::from_parts(30_914_040, 0).saturating_mul(n.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_send_commit(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 3_842_120_000 picoseconds.
-        Weight::from_parts(3_943_431_716, 0)
-            // Standard Error: 766_406
-            .saturating_add(Weight::from_parts(339_379_953, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_464_581_000 picoseconds.
+        Weight::from_parts(2_580_044_243, 0)
+            // Standard Error: 461_216
+            .saturating_add(Weight::from_parts(272_575_116, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_send_commit_wgas(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 3_828_327_000 picoseconds.
-        Weight::from_parts(3_976_283_101, 0)
-            // Standard Error: 768_169
-            .saturating_add(Weight::from_parts(353_252_083, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_438_114_000 picoseconds.
+        Weight::from_parts(2_597_881_615, 0)
+            // Standard Error: 400_982
+            .saturating_add(Weight::from_parts(275_718_502, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_reservation_send(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 256_679_000 picoseconds.
-        Weight::from_parts(330_245_572, 0)
-            // Standard Error: 519_345
-            .saturating_add(Weight::from_parts(404_879_225, 0).saturating_mul(r.into()))
+        // Minimum execution time: 244_206_000 picoseconds.
+        Weight::from_parts(321_175_021, 0)
+            // Standard Error: 460_445
+            .saturating_add(Weight::from_parts(322_059_081, 0).saturating_mul(r.into()))
     }
     /// The range of component `n` is `[0, 2048]`.
     fn gr_reservation_send_per_kb(n: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 640_004_000 picoseconds.
-        Weight::from_parts(646_769_000, 0)
-            // Standard Error: 55_122
-            .saturating_add(Weight::from_parts(21_616_125, 0).saturating_mul(n.into()))
+        // Minimum execution time: 559_346_000 picoseconds.
+        Weight::from_parts(571_004_000, 0)
+            // Standard Error: 59_840
+            .saturating_add(Weight::from_parts(21_370_093, 0).saturating_mul(n.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_reservation_send_commit(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 3_981_155_000 picoseconds.
-        Weight::from_parts(4_086_072_221, 0)
-            // Standard Error: 1_076_069
-            .saturating_add(Weight::from_parts(362_989_310, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_620_633_000 picoseconds.
+        Weight::from_parts(2_741_869_292, 0)
+            // Standard Error: 620_120
+            .saturating_add(Weight::from_parts(289_781_719, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 1]`.
     fn gr_reply(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 84_145_000 picoseconds.
-        Weight::from_parts(88_260_563, 0)
-            // Standard Error: 277_576
-            .saturating_add(Weight::from_parts(20_209_036, 0).saturating_mul(r.into()))
+        // Minimum execution time: 83_438_000 picoseconds.
+        Weight::from_parts(86_817_816, 0)
+            // Standard Error: 234_731
+            .saturating_add(Weight::from_parts(19_849_283, 0).saturating_mul(r.into()))
     }
     /// The range of component `n` is `[0, 2048]`.
     fn gr_reply_per_kb(n: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 102_930_000 picoseconds.
-        Weight::from_parts(90_280_376, 0)
-            // Standard Error: 1_072
-            .saturating_add(Weight::from_parts(427_777, 0).saturating_mul(n.into()))
+        // Minimum execution time: 105_002_000 picoseconds.
+        Weight::from_parts(88_114_999, 0)
+            // Standard Error: 1_128
+            .saturating_add(Weight::from_parts(427_426, 0).saturating_mul(n.into()))
     }
     /// The range of component `r` is `[0, 1]`.
     fn gr_reply_wgas(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 84_156_000 picoseconds.
-        Weight::from_parts(89_778_763, 0)
-            // Standard Error: 365_767
-            .saturating_add(Weight::from_parts(24_157_936, 0).saturating_mul(r.into()))
+        // Minimum execution time: 82_436_000 picoseconds.
+        Weight::from_parts(88_440_285, 0)
+            // Standard Error: 277_544
+            .saturating_add(Weight::from_parts(17_399_914, 0).saturating_mul(r.into()))
     }
     /// The range of component `n` is `[0, 2048]`.
     fn gr_reply_wgas_per_kb(n: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 105_315_000 picoseconds.
-        Weight::from_parts(94_894_394, 0)
-            // Standard Error: 993
-            .saturating_add(Weight::from_parts(426_364, 0).saturating_mul(n.into()))
+        // Minimum execution time: 103_800_000 picoseconds.
+        Weight::from_parts(89_756_983, 0)
+            // Standard Error: 907
+            .saturating_add(Weight::from_parts(428_998, 0).saturating_mul(n.into()))
     }
     /// The range of component `r` is `[0, 1]`.
     fn gr_reply_commit(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 81_595_000 picoseconds.
-        Weight::from_parts(86_259_504, 0)
-            // Standard Error: 284_882
-            .saturating_add(Weight::from_parts(25_873_595, 0).saturating_mul(r.into()))
+        // Minimum execution time: 81_754_000 picoseconds.
+        Weight::from_parts(87_296_014, 0)
+            // Standard Error: 336_747
+            .saturating_add(Weight::from_parts(20_299_385, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 1]`.
     fn gr_reply_commit_wgas(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 80_771_000 picoseconds.
-        Weight::from_parts(85_313_802, 0)
-            // Standard Error: 265_474
-            .saturating_add(Weight::from_parts(25_863_597, 0).saturating_mul(r.into()))
+        // Minimum execution time: 81_952_000 picoseconds.
+        Weight::from_parts(86_840_575, 0)
+            // Standard Error: 272_708
+            .saturating_add(Weight::from_parts(19_217_524, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_reply_push(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 82_396_000 picoseconds.
-        Weight::from_parts(126_819_617, 0)
-            // Standard Error: 518_749
-            .saturating_add(Weight::from_parts(272_821_836, 0).saturating_mul(r.into()))
+        // Minimum execution time: 85_498_000 picoseconds.
+        Weight::from_parts(126_431_779, 0)
+            // Standard Error: 460_480
+            .saturating_add(Weight::from_parts(198_940_536, 0).saturating_mul(r.into()))
     }
     /// The range of component `n` is `[0, 8192]`.
     fn gr_reply_push_per_kb(n: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 98_266_000 picoseconds.
-        Weight::from_parts(100_843_000, 0)
-            // Standard Error: 2_828
-            .saturating_add(Weight::from_parts(662_117, 0).saturating_mul(n.into()))
+        // Minimum execution time: 96_862_000 picoseconds.
+        Weight::from_parts(98_611_000, 0)
+            // Standard Error: 2_677
+            .saturating_add(Weight::from_parts(662_266, 0).saturating_mul(n.into()))
     }
     /// The range of component `r` is `[0, 1]`.
     fn gr_reply_input(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 707_150_000 picoseconds.
-        Weight::from_parts(754_398_128, 0)
-            // Standard Error: 5_119_788
-            .saturating_add(Weight::from_parts(7_037_071, 0).saturating_mul(r.into()))
+        // Minimum execution time: 698_914_000 picoseconds.
+        Weight::from_parts(718_405_100, 0)
+            // Standard Error: 1_891_960
+            .saturating_add(Weight::from_parts(24_867_800, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 1]`.
     fn gr_reply_input_wgas(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 712_091_000 picoseconds.
-        Weight::from_parts(751_999_544, 0)
-            // Standard Error: 4_003_265
-            .saturating_add(Weight::from_parts(43_818_555, 0).saturating_mul(r.into()))
+        // Minimum execution time: 699_975_000 picoseconds.
+        Weight::from_parts(718_806_789, 0)
+            // Standard Error: 1_919_531
+            .saturating_add(Weight::from_parts(51_192_710, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 1]`.
     fn gr_reservation_reply(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 92_234_000 picoseconds.
-        Weight::from_parts(96_192_773, 0)
-            // Standard Error: 271_871
-            .saturating_add(Weight::from_parts(13_338_726, 0).saturating_mul(r.into()))
+        // Minimum execution time: 95_002_000 picoseconds.
+        Weight::from_parts(99_331_989, 0)
+            // Standard Error: 287_602
+            .saturating_add(Weight::from_parts(9_719_710, 0).saturating_mul(r.into()))
     }
     /// The range of component `n` is `[0, 2048]`.
     fn gr_reservation_reply_per_kb(n: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 108_190_000 picoseconds.
-        Weight::from_parts(92_525_926, 0)
-            // Standard Error: 1_134
-            .saturating_add(Weight::from_parts(433_806, 0).saturating_mul(n.into()))
+        // Minimum execution time: 102_501_000 picoseconds.
+        Weight::from_parts(87_026_327, 0)
+            // Standard Error: 1_214
+            .saturating_add(Weight::from_parts(429_134, 0).saturating_mul(n.into()))
     }
     /// The range of component `r` is `[0, 1]`.
     fn gr_reservation_reply_commit(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 92_297_000 picoseconds.
-        Weight::from_parts(98_054_616, 0)
-            // Standard Error: 394_791
-            .saturating_add(Weight::from_parts(7_680_683, 0).saturating_mul(r.into()))
+        // Minimum execution time: 93_228_000 picoseconds.
+        Weight::from_parts(97_923_691, 0)
+            // Standard Error: 288_469
+            .saturating_add(Weight::from_parts(9_669_908, 0).saturating_mul(r.into()))
     }
     /// The range of component `n` is `[0, 2048]`.
     fn gr_reservation_reply_commit_per_kb(n: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 106_932_000 picoseconds.
-        Weight::from_parts(91_150_785, 0)
-            // Standard Error: 1_067
-            .saturating_add(Weight::from_parts(424_570, 0).saturating_mul(n.into()))
+        // Minimum execution time: 100_908_000 picoseconds.
+        Weight::from_parts(87_613_705, 0)
+            // Standard Error: 1_237
+            .saturating_add(Weight::from_parts(431_412, 0).saturating_mul(n.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_reply_to(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 80_591_000 picoseconds.
-        Weight::from_parts(79_590_461, 0)
-            // Standard Error: 360_038
-            .saturating_add(Weight::from_parts(185_313_242, 0).saturating_mul(r.into()))
+        // Minimum execution time: 84_385_000 picoseconds.
+        Weight::from_parts(74_453_057, 0)
+            // Standard Error: 309_931
+            .saturating_add(Weight::from_parts(117_172_527, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_signal_from(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 83_379_000 picoseconds.
-        Weight::from_parts(82_304_672, 0)
-            // Standard Error: 371_508
-            .saturating_add(Weight::from_parts(184_895_719, 0).saturating_mul(r.into()))
+        // Minimum execution time: 82_437_000 picoseconds.
+        Weight::from_parts(78_951_443, 0)
+            // Standard Error: 294_227
+            .saturating_add(Weight::from_parts(116_066_384, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_reply_push_input(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 714_906_000 picoseconds.
-        Weight::from_parts(784_837_322, 0)
-            // Standard Error: 485_874
-            .saturating_add(Weight::from_parts(198_529_306, 0).saturating_mul(r.into()))
+        // Minimum execution time: 704_954_000 picoseconds.
+        Weight::from_parts(752_735_182, 0)
+            // Standard Error: 455_998
+            .saturating_add(Weight::from_parts(135_154_607, 0).saturating_mul(r.into()))
     }
     /// The range of component `n` is `[0, 2048]`.
     fn gr_reply_push_input_per_kb(n: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 735_164_000 picoseconds.
-        Weight::from_parts(760_829_418, 0)
-            // Standard Error: 2_049
-            .saturating_add(Weight::from_parts(164_862, 0).saturating_mul(n.into()))
+        // Minimum execution time: 724_451_000 picoseconds.
+        Weight::from_parts(738_722_668, 0)
+            // Standard Error: 1_014
+            .saturating_add(Weight::from_parts(154_329, 0).saturating_mul(n.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_send_push_input(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 4_467_125_000 picoseconds.
-        Weight::from_parts(4_668_343_697, 0)
-            // Standard Error: 529_569
-            .saturating_add(Weight::from_parts(214_709_155, 0).saturating_mul(r.into()))
+        // Minimum execution time: 3_092_586_000 picoseconds.
+        Weight::from_parts(3_231_311_035, 0)
+            // Standard Error: 506_742
+            .saturating_add(Weight::from_parts(159_545_582, 0).saturating_mul(r.into()))
     }
     /// The range of component `n` is `[0, 2048]`.
     fn gr_send_push_input_per_kb(n: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 4_716_693_000 picoseconds.
-        Weight::from_parts(4_810_590_943, 0)
-            // Standard Error: 12_440
-            .saturating_add(Weight::from_parts(13_814_475, 0).saturating_mul(n.into()))
+        // Minimum execution time: 3_299_872_000 picoseconds.
+        Weight::from_parts(3_317_022_894, 0)
+            // Standard Error: 8_542
+            .saturating_add(Weight::from_parts(13_645_472, 0).saturating_mul(n.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_debug(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 81_721_000 picoseconds.
-        Weight::from_parts(95_360_878, 0)
-            // Standard Error: 488_163
-            .saturating_add(Weight::from_parts(198_923_476, 0).saturating_mul(r.into()))
+        // Minimum execution time: 85_966_000 picoseconds.
+        Weight::from_parts(106_319_310, 0)
+            // Standard Error: 424_534
+            .saturating_add(Weight::from_parts(139_885_203, 0).saturating_mul(r.into()))
     }
     /// The range of component `n` is `[0, 2048]`.
     fn gr_debug_per_kb(n: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 189_069_000 picoseconds.
-        Weight::from_parts(191_834_000, 0)
-            // Standard Error: 53_942
-            .saturating_add(Weight::from_parts(26_059_121, 0).saturating_mul(n.into()))
+        // Minimum execution time: 142_910_000 picoseconds.
+        Weight::from_parts(144_843_000, 0)
+            // Standard Error: 54_401
+            .saturating_add(Weight::from_parts(25_535_472, 0).saturating_mul(n.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_reply_code(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 83_023_000 picoseconds.
-        Weight::from_parts(70_919_161, 0)
-            // Standard Error: 442_134
-            .saturating_add(Weight::from_parts(186_467_769, 0).saturating_mul(r.into()))
+        // Minimum execution time: 82_117_000 picoseconds.
+        Weight::from_parts(80_202_149, 0)
+            // Standard Error: 296_880
+            .saturating_add(Weight::from_parts(114_586_990, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 1]`.
     fn gr_exit(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 80_187_000 picoseconds.
-        Weight::from_parts(86_256_124, 0)
-            // Standard Error: 333_120
-            .saturating_add(Weight::from_parts(27_182_075, 0).saturating_mul(r.into()))
+        // Minimum execution time: 81_802_000 picoseconds.
+        Weight::from_parts(85_064_295, 0)
+            // Standard Error: 248_874
+            .saturating_add(Weight::from_parts(27_314_604, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 1]`.
     fn gr_leave(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 80_373_000 picoseconds.
-        Weight::from_parts(83_957_387, 0)
-            // Standard Error: 258_914
-            .saturating_add(Weight::from_parts(14_637_112, 0).saturating_mul(r.into()))
+        // Minimum execution time: 82_854_000 picoseconds.
+        Weight::from_parts(86_180_314, 0)
+            // Standard Error: 239_162
+            .saturating_add(Weight::from_parts(16_391_885, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 1]`.
     fn gr_wait(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 82_886_000 picoseconds.
-        Weight::from_parts(86_536_767, 0)
-            // Standard Error: 237_087
-            .saturating_add(Weight::from_parts(15_456_732, 0).saturating_mul(r.into()))
+        // Minimum execution time: 80_883_000 picoseconds.
+        Weight::from_parts(87_058_214, 0)
+            // Standard Error: 256_392
+            .saturating_add(Weight::from_parts(13_333_285, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 1]`.
     fn gr_wait_for(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 82_962_000 picoseconds.
-        Weight::from_parts(87_038_165, 0)
-            // Standard Error: 267_652
-            .saturating_add(Weight::from_parts(14_141_234, 0).saturating_mul(r.into()))
+        // Minimum execution time: 81_417_000 picoseconds.
+        Weight::from_parts(85_403_451, 0)
+            // Standard Error: 249_767
+            .saturating_add(Weight::from_parts(14_474_948, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 1]`.
     fn gr_wait_up_to(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 82_976_000 picoseconds.
-        Weight::from_parts(87_105_967, 0)
-            // Standard Error: 237_581
-            .saturating_add(Weight::from_parts(13_365_932, 0).saturating_mul(r.into()))
+        // Minimum execution time: 84_020_000 picoseconds.
+        Weight::from_parts(88_080_622, 0)
+            // Standard Error: 253_221
+            .saturating_add(Weight::from_parts(11_403_277, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_wake(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 139_585_000 picoseconds.
-        Weight::from_parts(203_512_831, 0)
-            // Standard Error: 393_346
-            .saturating_add(Weight::from_parts(283_538_921, 0).saturating_mul(r.into()))
+        // Minimum execution time: 138_317_000 picoseconds.
+        Weight::from_parts(187_894_162, 0)
+            // Standard Error: 376_519
+            .saturating_add(Weight::from_parts(209_723_429, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_create_program(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 98_330_000 picoseconds.
-        Weight::from_parts(158_669_516, 0)
-            // Standard Error: 440_421
-            .saturating_add(Weight::from_parts(473_163_025, 0).saturating_mul(r.into()))
+        // Minimum execution time: 93_047_000 picoseconds.
+        Weight::from_parts(151_715_771, 0)
+            // Standard Error: 425_606
+            .saturating_add(Weight::from_parts(396_733_544, 0).saturating_mul(r.into()))
     }
     /// The range of component `p` is `[0, 2048]`.
     /// The range of component `s` is `[1, 2048]`.
@@ -1085,22 +1085,22 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 43_492_772_000 picoseconds.
-        Weight::from_parts(43_692_998_000, 0)
-            // Standard Error: 263_249
-            .saturating_add(Weight::from_parts(8_169_821, 0).saturating_mul(p.into()))
-            // Standard Error: 263_236
-            .saturating_add(Weight::from_parts(180_732_778, 0).saturating_mul(s.into()))
+        // Minimum execution time: 45_923_081_000 picoseconds.
+        Weight::from_parts(45_981_736_000, 0)
+            // Standard Error: 274_662
+            .saturating_add(Weight::from_parts(6_858_186, 0).saturating_mul(p.into()))
+            // Standard Error: 274_649
+            .saturating_add(Weight::from_parts(177_291_831, 0).saturating_mul(s.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_create_program_wgas(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 97_189_000 picoseconds.
-        Weight::from_parts(158_677_248, 0)
-            // Standard Error: 452_648
-            .saturating_add(Weight::from_parts(478_043_506, 0).saturating_mul(r.into()))
+        // Minimum execution time: 95_680_000 picoseconds.
+        Weight::from_parts(157_350_147, 0)
+            // Standard Error: 440_994
+            .saturating_add(Weight::from_parts(402_511_567, 0).saturating_mul(r.into()))
     }
     /// The range of component `p` is `[0, 2048]`.
     /// The range of component `s` is `[1, 2048]`.
@@ -1108,32 +1108,32 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 43_613_488_000 picoseconds.
-        Weight::from_parts(43_758_304_000, 0)
-            // Standard Error: 268_412
-            .saturating_add(Weight::from_parts(7_987_894, 0).saturating_mul(p.into()))
-            // Standard Error: 268_399
-            .saturating_add(Weight::from_parts(180_769_004, 0).saturating_mul(s.into()))
+        // Minimum execution time: 42_842_395_000 picoseconds.
+        Weight::from_parts(42_890_931_000, 0)
+            // Standard Error: 264_187
+            .saturating_add(Weight::from_parts(7_896_879, 0).saturating_mul(p.into()))
+            // Standard Error: 264_174
+            .saturating_add(Weight::from_parts(178_082_248, 0).saturating_mul(s.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_pay_program_rent(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 84_210_000 picoseconds.
-        Weight::from_parts(99_996_695, 0)
-            // Standard Error: 31_808
-            .saturating_add(Weight::from_parts(3_523_987, 0).saturating_mul(r.into()))
+        // Minimum execution time: 82_272_000 picoseconds.
+        Weight::from_parts(100_008_395, 0)
+            // Standard Error: 36_430
+            .saturating_add(Weight::from_parts(2_544_223, 0).saturating_mul(r.into()))
     }
     /// The range of component `p` is `[0, 512]`.
     fn lazy_pages_signal_read(p: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `141`
         //  Estimated: `1131 + p * (9900 ±0)`
-        // Minimum execution time: 82_940_000 picoseconds.
-        Weight::from_parts(123_540_441, 1131)
-            // Standard Error: 7_143
-            .saturating_add(Weight::from_parts(11_789_871, 0).saturating_mul(p.into()))
+        // Minimum execution time: 83_139_000 picoseconds.
+        Weight::from_parts(122_967_835, 1131)
+            // Standard Error: 6_454
+            .saturating_add(Weight::from_parts(11_784_103, 0).saturating_mul(p.into()))
             .saturating_add(T::DbWeight::get().reads((4_u64).saturating_mul(p.into())))
             .saturating_add(Weight::from_parts(0, 9900).saturating_mul(p.into()))
     }
@@ -1142,10 +1142,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
         // Proof Size summary in bytes:
         //  Measured:  `141`
         //  Estimated: `1131 + p * (9900 ±0)`
-        // Minimum execution time: 83_752_000 picoseconds.
-        Weight::from_parts(84_858_000, 1131)
-            // Standard Error: 48_161
-            .saturating_add(Weight::from_parts(36_181_117, 0).saturating_mul(p.into()))
+        // Minimum execution time: 83_229_000 picoseconds.
+        Weight::from_parts(83_885_000, 1131)
+            // Standard Error: 37_558
+            .saturating_add(Weight::from_parts(35_503_677, 0).saturating_mul(p.into()))
             .saturating_add(T::DbWeight::get().reads((4_u64).saturating_mul(p.into())))
             .saturating_add(Weight::from_parts(0, 9900).saturating_mul(p.into()))
     }
@@ -1154,10 +1154,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
         // Proof Size summary in bytes:
         //  Measured:  `141`
         //  Estimated: `5069931`
-        // Minimum execution time: 6_125_138_000 picoseconds.
-        Weight::from_parts(5_869_525_563, 5069931)
-            // Standard Error: 46_521
-            .saturating_add(Weight::from_parts(36_899_111, 0).saturating_mul(p.into()))
+        // Minimum execution time: 6_139_187_000 picoseconds.
+        Weight::from_parts(5_806_599_304, 5069931)
+            // Standard Error: 75_881
+            .saturating_add(Weight::from_parts(36_513_688, 0).saturating_mul(p.into()))
             .saturating_add(T::DbWeight::get().reads(2048_u64))
     }
     /// The range of component `p` is `[0, 512]`.
@@ -1165,10 +1165,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
         // Proof Size summary in bytes:
         //  Measured:  `1813 + p * (65580 ±0)`
         //  Estimated: `1939 + p * (75482 ±0)`
-        // Minimum execution time: 82_516_000 picoseconds.
-        Weight::from_parts(83_470_000, 1939)
-            // Standard Error: 29_769
-            .saturating_add(Weight::from_parts(46_665_657, 0).saturating_mul(p.into()))
+        // Minimum execution time: 82_177_000 picoseconds.
+        Weight::from_parts(83_595_000, 1939)
+            // Standard Error: 45_778
+            .saturating_add(Weight::from_parts(47_155_630, 0).saturating_mul(p.into()))
             .saturating_add(T::DbWeight::get().reads((4_u64).saturating_mul(p.into())))
             .saturating_add(Weight::from_parts(0, 75482).saturating_mul(p.into()))
     }
@@ -1177,10 +1177,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
         // Proof Size summary in bytes:
         //  Measured:  `141`
         //  Estimated: `1131 + p * (9900 ±0)`
-        // Minimum execution time: 87_344_000 picoseconds.
-        Weight::from_parts(94_873_151, 1131)
-            // Standard Error: 55_429
-            .saturating_add(Weight::from_parts(35_724_871, 0).saturating_mul(p.into()))
+        // Minimum execution time: 90_231_000 picoseconds.
+        Weight::from_parts(95_944_378, 1131)
+            // Standard Error: 61_821
+            .saturating_add(Weight::from_parts(35_941_066, 0).saturating_mul(p.into()))
             .saturating_add(T::DbWeight::get().reads((4_u64).saturating_mul(p.into())))
             .saturating_add(Weight::from_parts(0, 9900).saturating_mul(p.into()))
     }
@@ -1189,10 +1189,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
         // Proof Size summary in bytes:
         //  Measured:  `141`
         //  Estimated: `1496 + p * (9883 ±2)`
-        // Minimum execution time: 735_393_000 picoseconds.
-        Weight::from_parts(754_062_397, 1496)
-            // Standard Error: 166_437
-            .saturating_add(Weight::from_parts(43_966_900, 0).saturating_mul(p.into()))
+        // Minimum execution time: 734_006_000 picoseconds.
+        Weight::from_parts(717_384_508, 1496)
+            // Standard Error: 375_292
+            .saturating_add(Weight::from_parts(47_930_581, 0).saturating_mul(p.into()))
             .saturating_add(T::DbWeight::get().reads((4_u64).saturating_mul(p.into())))
             .saturating_add(Weight::from_parts(0, 9883).saturating_mul(p.into()))
     }
@@ -1201,10 +1201,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
         // Proof Size summary in bytes:
         //  Measured:  `141`
         //  Estimated: `317931`
-        // Minimum execution time: 1_124_371_000 picoseconds.
-        Weight::from_parts(1_147_901_415, 317931)
-            // Standard Error: 145_342
-            .saturating_add(Weight::from_parts(43_795_511, 0).saturating_mul(p.into()))
+        // Minimum execution time: 1_121_849_000 picoseconds.
+        Weight::from_parts(1_147_558_033, 317931)
+            // Standard Error: 373_146
+            .saturating_add(Weight::from_parts(45_393_418, 0).saturating_mul(p.into()))
             .saturating_add(T::DbWeight::get().reads(128_u64))
     }
     /// The range of component `r` is `[0, 20]`.
@@ -1212,885 +1212,885 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 1_510_000 picoseconds.
-        Weight::from_parts(1_448_006, 0)
-            // Standard Error: 9_868
-            .saturating_add(Weight::from_parts(24_061_691, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_162_000 picoseconds.
+        Weight::from_parts(2_220_392, 0)
+            // Standard Error: 8_848
+            .saturating_add(Weight::from_parts(24_205_605, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[50, 500]`.
     fn instr_i64load(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 4_337_991_000 picoseconds.
-        Weight::from_parts(4_151_991_287, 0)
-            // Standard Error: 60_683
-            .saturating_add(Weight::from_parts(4_818_799, 0).saturating_mul(r.into()))
+        // Minimum execution time: 4_352_664_000 picoseconds.
+        Weight::from_parts(4_153_366_897, 0)
+            // Standard Error: 60_193
+            .saturating_add(Weight::from_parts(4_722_164, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[50, 500]`.
     fn instr_i32load(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 4_341_162_000 picoseconds.
-        Weight::from_parts(4_200_807_294, 0)
-            // Standard Error: 51_442
-            .saturating_add(Weight::from_parts(4_527_839, 0).saturating_mul(r.into()))
+        // Minimum execution time: 4_357_649_000 picoseconds.
+        Weight::from_parts(4_256_499_798, 0)
+            // Standard Error: 57_942
+            .saturating_add(Weight::from_parts(4_200_870, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[50, 500]`.
     fn instr_i64store(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 10_322_767_000 picoseconds.
-        Weight::from_parts(11_038_976_057, 0)
-            // Standard Error: 150_113
-            .saturating_add(Weight::from_parts(10_655_640, 0).saturating_mul(r.into()))
+        // Minimum execution time: 10_269_998_000 picoseconds.
+        Weight::from_parts(11_525_100_351, 0)
+            // Standard Error: 204_230
+            .saturating_add(Weight::from_parts(8_423_588, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[50, 500]`.
     fn instr_i32store(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 10_367_826_000 picoseconds.
-        Weight::from_parts(11_310_983_745, 0)
-            // Standard Error: 145_202
-            .saturating_add(Weight::from_parts(7_541_832, 0).saturating_mul(r.into()))
+        // Minimum execution time: 10_204_810_000 picoseconds.
+        Weight::from_parts(10_982_673_143, 0)
+            // Standard Error: 145_327
+            .saturating_add(Weight::from_parts(9_198_033, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_select(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_251_000 picoseconds.
-        Weight::from_parts(2_304_000, 0)
-            // Standard Error: 8_520
-            .saturating_add(Weight::from_parts(3_798_413, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_074_000 picoseconds.
+        Weight::from_parts(2_108_000, 0)
+            // Standard Error: 9_031
+            .saturating_add(Weight::from_parts(3_829_182, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_if(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_168_000 picoseconds.
-        Weight::from_parts(573_722, 0)
-            // Standard Error: 11_642
-            .saturating_add(Weight::from_parts(3_174_691, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_020_000 picoseconds.
+        Weight::from_parts(2_118_000, 0)
+            // Standard Error: 5_295
+            .saturating_add(Weight::from_parts(2_980_329, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_br(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_227_000 picoseconds.
-        Weight::from_parts(3_155_512, 0)
-            // Standard Error: 1_212
-            .saturating_add(Weight::from_parts(1_586_585, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_032_000 picoseconds.
+        Weight::from_parts(3_411_359, 0)
+            // Standard Error: 1_146
+            .saturating_add(Weight::from_parts(1_563_906, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_br_if(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_160_000 picoseconds.
-        Weight::from_parts(2_219_000, 0)
-            // Standard Error: 8_627
-            .saturating_add(Weight::from_parts(2_929_529, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_096_000 picoseconds.
+        Weight::from_parts(2_140_000, 0)
+            // Standard Error: 8_349
+            .saturating_add(Weight::from_parts(2_904_673, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_br_table(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_227_000 picoseconds.
-        Weight::from_parts(1_609_241, 0)
-            // Standard Error: 19_812
-            .saturating_add(Weight::from_parts(5_162_833, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_128_000 picoseconds.
+        Weight::from_parts(2_159_000, 0)
+            // Standard Error: 8_100
+            .saturating_add(Weight::from_parts(5_229_400, 0).saturating_mul(r.into()))
     }
     /// The range of component `e` is `[1, 256]`.
     fn instr_br_table_per_entry(e: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 6_892_000 picoseconds.
-        Weight::from_parts(5_316_811, 0)
-            // Standard Error: 1_578
-            .saturating_add(Weight::from_parts(163_377, 0).saturating_mul(e.into()))
+        // Minimum execution time: 6_838_000 picoseconds.
+        Weight::from_parts(5_309_346, 0)
+            // Standard Error: 2_580
+            .saturating_add(Weight::from_parts(129_982, 0).saturating_mul(e.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_call_const(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_304_000 picoseconds.
-        Weight::from_parts(4_554_683, 0)
-            // Standard Error: 7_319
-            .saturating_add(Weight::from_parts(2_595_958, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_100_000 picoseconds.
+        Weight::from_parts(3_593_285, 0)
+            // Standard Error: 6_648
+            .saturating_add(Weight::from_parts(2_597_926, 0).saturating_mul(r.into()))
     }
     fn instr_i64const(r: u32, ) -> Weight {
         Weight::from_parts(0, 0)
-            .saturating_add(Weight::from_parts(2_595_958 -
-            2_422_191, 0).saturating_mul(r.into()))
+            .saturating_add(Weight::from_parts(2_597_926 -
+            2_429_048, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_call(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_273_000 picoseconds.
-        Weight::from_parts(5_046_075, 0)
-            // Standard Error: 13_702
-            .saturating_add(Weight::from_parts(2_422_191, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_086_000 picoseconds.
+        Weight::from_parts(3_972_773, 0)
+            // Standard Error: 12_538
+            .saturating_add(Weight::from_parts(2_429_048, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_call_indirect(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_684_000 picoseconds.
-        Weight::from_parts(17_324_871, 0)
-            // Standard Error: 38_532
-            .saturating_add(Weight::from_parts(10_260_872, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_591_000 picoseconds.
+        Weight::from_parts(12_798_134, 0)
+            // Standard Error: 23_023
+            .saturating_add(Weight::from_parts(9_786_464, 0).saturating_mul(r.into()))
     }
     /// The range of component `p` is `[0, 128]`.
     fn instr_call_indirect_per_param(p: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 12_206_000 picoseconds.
-        Weight::from_parts(2_634_425, 0)
-            // Standard Error: 5_954
-            .saturating_add(Weight::from_parts(1_275_538, 0).saturating_mul(p.into()))
+        // Minimum execution time: 12_274_000 picoseconds.
+        Weight::from_parts(1_706_188, 0)
+            // Standard Error: 6_199
+            .saturating_add(Weight::from_parts(1_212_443, 0).saturating_mul(p.into()))
     }
     /// The range of component `l` is `[0, 1024]`.
     fn instr_call_per_local(l: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 5_288_000 picoseconds.
-        Weight::from_parts(5_570_870, 0)
+        // Minimum execution time: 5_221_000 picoseconds.
+        Weight::from_parts(5_538_574, 0)
             // Standard Error: 12
-            .saturating_add(Weight::from_parts(61, 0).saturating_mul(l.into()))
+            .saturating_add(Weight::from_parts(12, 0).saturating_mul(l.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_local_get(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_203_000 picoseconds.
-        Weight::from_parts(1_788_159, 0)
-            // Standard Error: 3_152
-            .saturating_add(Weight::from_parts(267_842, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_100_000 picoseconds.
+        Weight::from_parts(1_785_103, 0)
+            // Standard Error: 2_948
+            .saturating_add(Weight::from_parts(249_981, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_local_set(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_164_000 picoseconds.
-        Weight::from_parts(2_223_000, 0)
-            // Standard Error: 4_611
-            .saturating_add(Weight::from_parts(721_127, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_123_000 picoseconds.
+        Weight::from_parts(2_187_000, 0)
+            // Standard Error: 5_664
+            .saturating_add(Weight::from_parts(719_187, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_local_tee(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_252_000 picoseconds.
-        Weight::from_parts(2_347_000, 0)
-            // Standard Error: 5_971
-            .saturating_add(Weight::from_parts(742_209, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_137_000 picoseconds.
+        Weight::from_parts(2_214_000, 0)
+            // Standard Error: 5_625
+            .saturating_add(Weight::from_parts(709_067, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_global_get(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 6_406_000 picoseconds.
-        Weight::from_parts(2_894_577, 0)
-            // Standard Error: 8_027
-            .saturating_add(Weight::from_parts(801_493, 0).saturating_mul(r.into()))
+        // Minimum execution time: 6_168_000 picoseconds.
+        Weight::from_parts(2_290_203, 0)
+            // Standard Error: 8_984
+            .saturating_add(Weight::from_parts(761_843, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_global_set(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 6_345_000 picoseconds.
-        Weight::from_parts(31_295, 0)
-            // Standard Error: 10_231
-            .saturating_add(Weight::from_parts(1_543_569, 0).saturating_mul(r.into()))
+        // Minimum execution time: 6_249_000 picoseconds.
+        Weight::from_parts(6_302_000, 0)
+            // Standard Error: 8_682
+            .saturating_add(Weight::from_parts(1_329_653, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_memory_current(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 3_937_000 picoseconds.
-        Weight::from_parts(62_049, 0)
-            // Standard Error: 12_087
-            .saturating_add(Weight::from_parts(7_172_920, 0).saturating_mul(r.into()))
+        // Minimum execution time: 3_791_000 picoseconds.
+        Weight::from_parts(3_929_000, 0)
+            // Standard Error: 9_270
+            .saturating_add(Weight::from_parts(6_742_685, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64clz(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_262_000 picoseconds.
-        Weight::from_parts(2_306_000, 0)
-            // Standard Error: 6_042
-            .saturating_add(Weight::from_parts(3_394_526, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_113_000 picoseconds.
+        Weight::from_parts(2_192_000, 0)
+            // Standard Error: 6_734
+            .saturating_add(Weight::from_parts(3_327_207, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32clz(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_151_000 picoseconds.
-        Weight::from_parts(2_260_000, 0)
-            // Standard Error: 5_891
-            .saturating_add(Weight::from_parts(3_138_523, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_095_000 picoseconds.
+        Weight::from_parts(2_141_000, 0)
+            // Standard Error: 6_506
+            .saturating_add(Weight::from_parts(3_061_891, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64ctz(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_218_000 picoseconds.
-        Weight::from_parts(2_277_000, 0)
-            // Standard Error: 8_196
-            .saturating_add(Weight::from_parts(3_167_033, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_108_000 picoseconds.
+        Weight::from_parts(2_141_000, 0)
+            // Standard Error: 6_738
+            .saturating_add(Weight::from_parts(3_101_844, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32ctz(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_246_000 picoseconds.
-        Weight::from_parts(2_289_000, 0)
-            // Standard Error: 5_536
-            .saturating_add(Weight::from_parts(2_668_164, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_138_000 picoseconds.
+        Weight::from_parts(2_155_000, 0)
+            // Standard Error: 4_379
+            .saturating_add(Weight::from_parts(2_613_794, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64popcnt(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_259_000 picoseconds.
-        Weight::from_parts(45_432, 0)
-            // Standard Error: 6_223
-            .saturating_add(Weight::from_parts(645_076, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_046_000 picoseconds.
+        Weight::from_parts(2_127_000, 0)
+            // Standard Error: 3_513
+            .saturating_add(Weight::from_parts(525_212, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32popcnt(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_168_000 picoseconds.
-        Weight::from_parts(1_301_007, 0)
-            // Standard Error: 4_929
-            .saturating_add(Weight::from_parts(446_280, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_127_000 picoseconds.
+        Weight::from_parts(1_669_179, 0)
+            // Standard Error: 2_817
+            .saturating_add(Weight::from_parts(367_599, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64eqz(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_130_000 picoseconds.
-        Weight::from_parts(2_205_000, 0)
-            // Standard Error: 10_412
-            .saturating_add(Weight::from_parts(1_894_722, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_131_000 picoseconds.
+        Weight::from_parts(2_169_000, 0)
+            // Standard Error: 11_816
+            .saturating_add(Weight::from_parts(1_810_781, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32eqz(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_170_000 picoseconds.
-        Weight::from_parts(2_257_000, 0)
-            // Standard Error: 7_708
-            .saturating_add(Weight::from_parts(1_162_246, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_087_000 picoseconds.
+        Weight::from_parts(2_194_000, 0)
+            // Standard Error: 7_361
+            .saturating_add(Weight::from_parts(1_130_773, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32extend8s(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_153_000 picoseconds.
-        Weight::from_parts(1_682_106, 0)
-            // Standard Error: 3_839
-            .saturating_add(Weight::from_parts(384_381, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_061_000 picoseconds.
+        Weight::from_parts(1_850_477, 0)
+            // Standard Error: 2_695
+            .saturating_add(Weight::from_parts(318_827, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32extend16s(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_162_000 picoseconds.
-        Weight::from_parts(1_669_708, 0)
-            // Standard Error: 3_126
-            .saturating_add(Weight::from_parts(384_474, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_115_000 picoseconds.
+        Weight::from_parts(1_764_589, 0)
+            // Standard Error: 2_923
+            .saturating_add(Weight::from_parts(329_840, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64extend8s(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_249_000 picoseconds.
-        Weight::from_parts(2_291_000, 0)
-            // Standard Error: 4_476
-            .saturating_add(Weight::from_parts(497_277, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_109_000 picoseconds.
+        Weight::from_parts(859_995, 0)
+            // Standard Error: 4_546
+            .saturating_add(Weight::from_parts(467_944, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64extend16s(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_217_000 picoseconds.
-        Weight::from_parts(2_287_000, 0)
-            // Standard Error: 4_107
-            .saturating_add(Weight::from_parts(524_095, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_010_000 picoseconds.
+        Weight::from_parts(2_081_000, 0)
+            // Standard Error: 3_959
+            .saturating_add(Weight::from_parts(472_947, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64extend32s(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_163_000 picoseconds.
-        Weight::from_parts(2_233_000, 0)
-            // Standard Error: 3_690
-            .saturating_add(Weight::from_parts(501_277, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_105_000 picoseconds.
+        Weight::from_parts(1_247_124, 0)
+            // Standard Error: 4_390
+            .saturating_add(Weight::from_parts(436_907, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64extendsi32(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_132_000 picoseconds.
-        Weight::from_parts(1_082_506, 0)
-            // Standard Error: 5_421
-            .saturating_add(Weight::from_parts(400_448, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_140_000 picoseconds.
+        Weight::from_parts(2_251_532, 0)
+            // Standard Error: 2_995
+            .saturating_add(Weight::from_parts(280_490, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64extendui32(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_211_000 picoseconds.
-        Weight::from_parts(3_085_764, 0)
-            // Standard Error: 1_912
-            .saturating_add(Weight::from_parts(162_384, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_119_000 picoseconds.
+        Weight::from_parts(2_808_547, 0)
+            // Standard Error: 1_453
+            .saturating_add(Weight::from_parts(143_409, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32wrapi64(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_161_000 picoseconds.
-        Weight::from_parts(2_849_158, 0)
-            // Standard Error: 1_635
-            .saturating_add(Weight::from_parts(153_763, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_043_000 picoseconds.
+        Weight::from_parts(2_639_820, 0)
+            // Standard Error: 1_638
+            .saturating_add(Weight::from_parts(159_792, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64eq(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_279_000 picoseconds.
-        Weight::from_parts(2_315_000, 0)
-            // Standard Error: 11_776
-            .saturating_add(Weight::from_parts(1_779_477, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_128_000 picoseconds.
+        Weight::from_parts(2_166_000, 0)
+            // Standard Error: 11_777
+            .saturating_add(Weight::from_parts(1_709_510, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32eq(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_272_000 picoseconds.
-        Weight::from_parts(2_342_000, 0)
-            // Standard Error: 8_815
-            .saturating_add(Weight::from_parts(1_197_093, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_100_000 picoseconds.
+        Weight::from_parts(2_136_000, 0)
+            // Standard Error: 7_491
+            .saturating_add(Weight::from_parts(1_105_807, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64ne(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_190_000 picoseconds.
-        Weight::from_parts(2_258_000, 0)
-            // Standard Error: 9_983
-            .saturating_add(Weight::from_parts(1_838_257, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_088_000 picoseconds.
+        Weight::from_parts(2_171_000, 0)
+            // Standard Error: 11_841
+            .saturating_add(Weight::from_parts(1_785_140, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32ne(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_227_000 picoseconds.
-        Weight::from_parts(2_276_000, 0)
-            // Standard Error: 7_749
-            .saturating_add(Weight::from_parts(1_165_862, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_042_000 picoseconds.
+        Weight::from_parts(2_181_000, 0)
+            // Standard Error: 7_479
+            .saturating_add(Weight::from_parts(1_086_144, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64lts(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_172_000 picoseconds.
-        Weight::from_parts(2_246_000, 0)
-            // Standard Error: 11_426
-            .saturating_add(Weight::from_parts(1_828_814, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_109_000 picoseconds.
+        Weight::from_parts(2_151_000, 0)
+            // Standard Error: 13_111
+            .saturating_add(Weight::from_parts(1_829_000, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32lts(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_187_000 picoseconds.
-        Weight::from_parts(2_245_000, 0)
-            // Standard Error: 7_973
-            .saturating_add(Weight::from_parts(1_145_613, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_130_000 picoseconds.
+        Weight::from_parts(2_153_000, 0)
+            // Standard Error: 7_632
+            .saturating_add(Weight::from_parts(1_102_522, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64ltu(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_247_000 picoseconds.
-        Weight::from_parts(2_273_000, 0)
-            // Standard Error: 10_995
-            .saturating_add(Weight::from_parts(1_789_814, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_155_000 picoseconds.
+        Weight::from_parts(2_231_000, 0)
+            // Standard Error: 11_689
+            .saturating_add(Weight::from_parts(1_768_866, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32ltu(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_162_000 picoseconds.
-        Weight::from_parts(2_252_000, 0)
-            // Standard Error: 7_454
-            .saturating_add(Weight::from_parts(1_207_539, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_094_000 picoseconds.
+        Weight::from_parts(2_163_000, 0)
+            // Standard Error: 7_348
+            .saturating_add(Weight::from_parts(1_057_058, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64gts(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_219_000 picoseconds.
-        Weight::from_parts(2_279_000, 0)
-            // Standard Error: 10_576
-            .saturating_add(Weight::from_parts(1_855_075, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_095_000 picoseconds.
+        Weight::from_parts(2_142_000, 0)
+            // Standard Error: 12_173
+            .saturating_add(Weight::from_parts(1_786_184, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32gts(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_199_000 picoseconds.
-        Weight::from_parts(2_265_000, 0)
-            // Standard Error: 7_405
-            .saturating_add(Weight::from_parts(1_180_265, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_122_000 picoseconds.
+        Weight::from_parts(2_206_000, 0)
+            // Standard Error: 7_244
+            .saturating_add(Weight::from_parts(1_066_057, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64gtu(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_245_000 picoseconds.
-        Weight::from_parts(2_285_000, 0)
-            // Standard Error: 10_994
-            .saturating_add(Weight::from_parts(1_835_344, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_090_000 picoseconds.
+        Weight::from_parts(2_175_000, 0)
+            // Standard Error: 11_967
+            .saturating_add(Weight::from_parts(1_782_809, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32gtu(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_222_000 picoseconds.
-        Weight::from_parts(2_277_000, 0)
-            // Standard Error: 7_826
-            .saturating_add(Weight::from_parts(1_163_748, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_091_000 picoseconds.
+        Weight::from_parts(2_169_000, 0)
+            // Standard Error: 7_205
+            .saturating_add(Weight::from_parts(1_048_140, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64les(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_102_000 picoseconds.
-        Weight::from_parts(2_217_000, 0)
-            // Standard Error: 11_374
-            .saturating_add(Weight::from_parts(1_910_004, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_164_000 picoseconds.
+        Weight::from_parts(2_198_000, 0)
+            // Standard Error: 12_228
+            .saturating_add(Weight::from_parts(1_792_751, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32les(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_245_000 picoseconds.
-        Weight::from_parts(2_303_000, 0)
-            // Standard Error: 8_971
-            .saturating_add(Weight::from_parts(1_182_859, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_122_000 picoseconds.
+        Weight::from_parts(2_186_000, 0)
+            // Standard Error: 7_822
+            .saturating_add(Weight::from_parts(1_052_385, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64leu(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_230_000 picoseconds.
-        Weight::from_parts(2_284_000, 0)
-            // Standard Error: 12_177
-            .saturating_add(Weight::from_parts(1_866_465, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_055_000 picoseconds.
+        Weight::from_parts(2_135_000, 0)
+            // Standard Error: 12_011
+            .saturating_add(Weight::from_parts(1_789_504, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32leu(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_468_000 picoseconds.
-        Weight::from_parts(2_638_000, 0)
-            // Standard Error: 7_738
-            .saturating_add(Weight::from_parts(1_119_369, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_447_000 picoseconds.
+        Weight::from_parts(2_540_000, 0)
+            // Standard Error: 7_696
+            .saturating_add(Weight::from_parts(1_062_612, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64ges(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_191_000 picoseconds.
-        Weight::from_parts(2_286_000, 0)
-            // Standard Error: 10_340
-            .saturating_add(Weight::from_parts(1_831_738, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_077_000 picoseconds.
+        Weight::from_parts(2_107_000, 0)
+            // Standard Error: 12_070
+            .saturating_add(Weight::from_parts(1_771_498, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32ges(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_216_000 picoseconds.
-        Weight::from_parts(2_260_000, 0)
-            // Standard Error: 6_924
-            .saturating_add(Weight::from_parts(1_210_933, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_123_000 picoseconds.
+        Weight::from_parts(2_156_000, 0)
+            // Standard Error: 7_108
+            .saturating_add(Weight::from_parts(1_072_471, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64geu(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_202_000 picoseconds.
-        Weight::from_parts(2_325_000, 0)
-            // Standard Error: 9_907
-            .saturating_add(Weight::from_parts(1_822_715, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_038_000 picoseconds.
+        Weight::from_parts(2_145_000, 0)
+            // Standard Error: 11_990
+            .saturating_add(Weight::from_parts(1_786_273, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32geu(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_230_000 picoseconds.
-        Weight::from_parts(2_294_000, 0)
-            // Standard Error: 7_927
-            .saturating_add(Weight::from_parts(1_168_287, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_059_000 picoseconds.
+        Weight::from_parts(2_122_000, 0)
+            // Standard Error: 7_164
+            .saturating_add(Weight::from_parts(1_070_909, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64add(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_189_000 picoseconds.
-        Weight::from_parts(2_289_000, 0)
-            // Standard Error: 8_768
-            .saturating_add(Weight::from_parts(1_295_617, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_065_000 picoseconds.
+        Weight::from_parts(2_181_000, 0)
+            // Standard Error: 7_265
+            .saturating_add(Weight::from_parts(1_152_228, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32add(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_193_000 picoseconds.
-        Weight::from_parts(2_292_000, 0)
-            // Standard Error: 6_314
-            .saturating_add(Weight::from_parts(658_832, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_107_000 picoseconds.
+        Weight::from_parts(2_160_000, 0)
+            // Standard Error: 5_101
+            .saturating_add(Weight::from_parts(578_660, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64sub(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_258_000 picoseconds.
-        Weight::from_parts(2_312_000, 0)
-            // Standard Error: 9_261
-            .saturating_add(Weight::from_parts(1_348_699, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_130_000 picoseconds.
+        Weight::from_parts(2_184_000, 0)
+            // Standard Error: 9_299
+            .saturating_add(Weight::from_parts(1_257_633, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32sub(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_257_000 picoseconds.
-        Weight::from_parts(2_290_000, 0)
-            // Standard Error: 5_457
-            .saturating_add(Weight::from_parts(671_846, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_119_000 picoseconds.
+        Weight::from_parts(2_262_000, 0)
+            // Standard Error: 3_957
+            .saturating_add(Weight::from_parts(557_957, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64mul(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_180_000 picoseconds.
-        Weight::from_parts(2_241_000, 0)
-            // Standard Error: 11_567
-            .saturating_add(Weight::from_parts(1_835_171, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_045_000 picoseconds.
+        Weight::from_parts(2_157_000, 0)
+            // Standard Error: 10_839
+            .saturating_add(Weight::from_parts(1_686_809, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32mul(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_196_000 picoseconds.
-        Weight::from_parts(2_290_000, 0)
-            // Standard Error: 7_436
-            .saturating_add(Weight::from_parts(1_171_019, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_232_000 picoseconds.
+        Weight::from_parts(2_250_000, 0)
+            // Standard Error: 7_276
+            .saturating_add(Weight::from_parts(1_096_252, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64divs(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_195_000 picoseconds.
-        Weight::from_parts(6_299_544, 0)
-            // Standard Error: 28_028
-            .saturating_add(Weight::from_parts(2_500_140, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_107_000 picoseconds.
+        Weight::from_parts(1_434_170, 0)
+            // Standard Error: 21_965
+            .saturating_add(Weight::from_parts(2_633_663, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32divs(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_249_000 picoseconds.
-        Weight::from_parts(2_576_178, 0)
-            // Standard Error: 12_042
-            .saturating_add(Weight::from_parts(2_335_953, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_098_000 picoseconds.
+        Weight::from_parts(2_122_681, 0)
+            // Standard Error: 10_815
+            .saturating_add(Weight::from_parts(2_335_842, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64divu(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_223_000 picoseconds.
-        Weight::from_parts(8_638_891, 0)
-            // Standard Error: 32_649
-            .saturating_add(Weight::from_parts(2_462_794, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_153_000 picoseconds.
+        Weight::from_parts(145_632, 0)
+            // Standard Error: 12_320
+            .saturating_add(Weight::from_parts(2_992_427, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32divu(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_231_000 picoseconds.
-        Weight::from_parts(2_731_170, 0)
-            // Standard Error: 19_116
-            .saturating_add(Weight::from_parts(2_437_473, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_142_000 picoseconds.
+        Weight::from_parts(2_180_000, 0)
+            // Standard Error: 4_944
+            .saturating_add(Weight::from_parts(2_466_854, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64rems(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_261_000 picoseconds.
-        Weight::from_parts(1_535_146, 0)
-            // Standard Error: 30_575
-            .saturating_add(Weight::from_parts(9_634_377, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_143_000 picoseconds.
+        Weight::from_parts(2_204_000, 0)
+            // Standard Error: 14_500
+            .saturating_add(Weight::from_parts(9_530_241, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32rems(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_209_000 picoseconds.
-        Weight::from_parts(5_244_298, 0)
-            // Standard Error: 48_615
-            .saturating_add(Weight::from_parts(7_381_672, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_132_000 picoseconds.
+        Weight::from_parts(2_183_000, 0)
+            // Standard Error: 22_303
+            .saturating_add(Weight::from_parts(7_508_848, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64remu(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_260_000 picoseconds.
-        Weight::from_parts(8_453_159, 0)
-            // Standard Error: 30_530
-            .saturating_add(Weight::from_parts(2_541_459, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_133_000 picoseconds.
+        Weight::from_parts(2_183_000, 0)
+            // Standard Error: 5_407
+            .saturating_add(Weight::from_parts(2_948_013, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32remu(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_242_000 picoseconds.
-        Weight::from_parts(5_507_917, 0)
-            // Standard Error: 21_457
-            .saturating_add(Weight::from_parts(2_217_886, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_124_000 picoseconds.
+        Weight::from_parts(2_150_000, 0)
+            // Standard Error: 6_372
+            .saturating_add(Weight::from_parts(2_362_416, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64and(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_163_000 picoseconds.
-        Weight::from_parts(2_341_000, 0)
-            // Standard Error: 9_253
-            .saturating_add(Weight::from_parts(1_354_282, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_174_000 picoseconds.
+        Weight::from_parts(2_219_000, 0)
+            // Standard Error: 7_670
+            .saturating_add(Weight::from_parts(1_174_342, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32and(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_170_000 picoseconds.
-        Weight::from_parts(2_224_000, 0)
-            // Standard Error: 3_908
-            .saturating_add(Weight::from_parts(589_876, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_094_000 picoseconds.
+        Weight::from_parts(2_109_000, 0)
+            // Standard Error: 3_988
+            .saturating_add(Weight::from_parts(566_949, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64or(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_184_000 picoseconds.
-        Weight::from_parts(2_265_000, 0)
-            // Standard Error: 9_943
-            .saturating_add(Weight::from_parts(1_308_630, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_049_000 picoseconds.
+        Weight::from_parts(2_117_000, 0)
+            // Standard Error: 8_393
+            .saturating_add(Weight::from_parts(1_160_794, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32or(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_212_000 picoseconds.
-        Weight::from_parts(2_273_000, 0)
-            // Standard Error: 5_843
-            .saturating_add(Weight::from_parts(653_388, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_107_000 picoseconds.
+        Weight::from_parts(2_152_000, 0)
+            // Standard Error: 4_769
+            .saturating_add(Weight::from_parts(585_265, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64xor(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_228_000 picoseconds.
-        Weight::from_parts(2_293_000, 0)
-            // Standard Error: 9_157
-            .saturating_add(Weight::from_parts(1_290_731, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_115_000 picoseconds.
+        Weight::from_parts(2_170_000, 0)
+            // Standard Error: 7_943
+            .saturating_add(Weight::from_parts(1_185_174, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32xor(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_232_000 picoseconds.
-        Weight::from_parts(2_276_000, 0)
-            // Standard Error: 4_020
-            .saturating_add(Weight::from_parts(618_071, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_139_000 picoseconds.
+        Weight::from_parts(2_183_000, 0)
+            // Standard Error: 4_608
+            .saturating_add(Weight::from_parts(563_329, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64shl(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_239_000 picoseconds.
-        Weight::from_parts(2_292_000, 0)
-            // Standard Error: 7_192
-            .saturating_add(Weight::from_parts(1_061_312, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_144_000 picoseconds.
+        Weight::from_parts(2_178_000, 0)
+            // Standard Error: 6_727
+            .saturating_add(Weight::from_parts(1_000_757, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32shl(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_157_000 picoseconds.
-        Weight::from_parts(2_245_000, 0)
-            // Standard Error: 3_756
-            .saturating_add(Weight::from_parts(568_744, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_107_000 picoseconds.
+        Weight::from_parts(2_212_000, 0)
+            // Standard Error: 3_536
+            .saturating_add(Weight::from_parts(504_096, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64shrs(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_248_000 picoseconds.
-        Weight::from_parts(2_324_000, 0)
-            // Standard Error: 7_917
-            .saturating_add(Weight::from_parts(1_106_132, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_167_000 picoseconds.
+        Weight::from_parts(2_218_000, 0)
+            // Standard Error: 7_170
+            .saturating_add(Weight::from_parts(966_365, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32shrs(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_205_000 picoseconds.
-        Weight::from_parts(2_292_000, 0)
-            // Standard Error: 4_617
-            .saturating_add(Weight::from_parts(599_461, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_149_000 picoseconds.
+        Weight::from_parts(140_768, 0)
+            // Standard Error: 5_221
+            .saturating_add(Weight::from_parts(551_550, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64shru(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_215_000 picoseconds.
-        Weight::from_parts(2_346_000, 0)
-            // Standard Error: 7_501
-            .saturating_add(Weight::from_parts(1_125_645, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_122_000 picoseconds.
+        Weight::from_parts(2_159_000, 0)
+            // Standard Error: 7_621
+            .saturating_add(Weight::from_parts(997_420, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32shru(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_255_000 picoseconds.
-        Weight::from_parts(2_306_000, 0)
-            // Standard Error: 5_262
-            .saturating_add(Weight::from_parts(624_680, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_069_000 picoseconds.
+        Weight::from_parts(2_106_000, 0)
+            // Standard Error: 3_980
+            .saturating_add(Weight::from_parts(537_014, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64rotl(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_231_000 picoseconds.
-        Weight::from_parts(2_341_000, 0)
-            // Standard Error: 7_879
-            .saturating_add(Weight::from_parts(1_068_877, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_097_000 picoseconds.
+        Weight::from_parts(2_191_000, 0)
+            // Standard Error: 9_419
+            .saturating_add(Weight::from_parts(1_050_292, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32rotl(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_192_000 picoseconds.
-        Weight::from_parts(2_288_000, 0)
-            // Standard Error: 4_124
-            .saturating_add(Weight::from_parts(567_690, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_051_000 picoseconds.
+        Weight::from_parts(2_118_000, 0)
+            // Standard Error: 4_228
+            .saturating_add(Weight::from_parts(529_158, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64rotr(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_258_000 picoseconds.
-        Weight::from_parts(2_322_000, 0)
-            // Standard Error: 8_516
-            .saturating_add(Weight::from_parts(1_174_764, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_038_000 picoseconds.
+        Weight::from_parts(2_116_000, 0)
+            // Standard Error: 7_792
+            .saturating_add(Weight::from_parts(1_027_370, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32rotr(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_171_000 picoseconds.
-        Weight::from_parts(2_258_000, 0)
-            // Standard Error: 4_901
-            .saturating_add(Weight::from_parts(628_068, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_077_000 picoseconds.
+        Weight::from_parts(2_140_000, 0)
+            // Standard Error: 4_450
+            .saturating_add(Weight::from_parts(534_724, 0).saturating_mul(r.into()))
     }
 }
 
@@ -2115,10 +2115,10 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 965_000 picoseconds.
-        Weight::from_parts(1_020_000, 0)
-            // Standard Error: 753
-            .saturating_add(Weight::from_parts(247_354, 0).saturating_mul(c.into()))
+        // Minimum execution time: 954_000 picoseconds.
+        Weight::from_parts(1_004_000, 0)
+            // Standard Error: 802
+            .saturating_add(Weight::from_parts(249_956, 0).saturating_mul(c.into()))
             .saturating_add(RocksDbWeight::get().writes(1_u64))
     }
     /// The range of component `c` is `[0, 512]`.
@@ -2126,10 +2126,10 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `42 + c * (1024 ±0)`
         //  Estimated: `3506 + c * (1024 ±0)`
-        // Minimum execution time: 2_780_000 picoseconds.
-        Weight::from_parts(2_874_000, 3506)
-            // Standard Error: 924
-            .saturating_add(Weight::from_parts(674_078, 0).saturating_mul(c.into()))
+        // Minimum execution time: 2_808_000 picoseconds.
+        Weight::from_parts(2_895_000, 3506)
+            // Standard Error: 1_086
+            .saturating_add(Weight::from_parts(680_150, 0).saturating_mul(c.into()))
             .saturating_add(RocksDbWeight::get().reads(1_u64))
             .saturating_add(Weight::from_parts(0, 1024).saturating_mul(c.into()))
     }
@@ -2138,17 +2138,17 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 51_392_000 picoseconds.
-        Weight::from_parts(63_325_658, 0)
-            // Standard Error: 13_432
-            .saturating_add(Weight::from_parts(2_671_521, 0).saturating_mul(c.into()))
+        // Minimum execution time: 52_458_000 picoseconds.
+        Weight::from_parts(84_558_500, 0)
+            // Standard Error: 7_412
+            .saturating_add(Weight::from_parts(2_377_997, 0).saturating_mul(c.into()))
     }
     fn claim_value() -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `979`
         //  Estimated: `42236`
-        // Minimum execution time: 85_039_000 picoseconds.
-        Weight::from_parts(86_523_000, 42236)
+        // Minimum execution time: 81_302_000 picoseconds.
+        Weight::from_parts(83_307_000, 42236)
             .saturating_add(RocksDbWeight::get().reads(13_u64))
             .saturating_add(RocksDbWeight::get().writes(10_u64))
     }
@@ -2156,8 +2156,8 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `886`
         //  Estimated: `21261`
-        // Minimum execution time: 54_302_000 picoseconds.
-        Weight::from_parts(56_159_000, 21261)
+        // Minimum execution time: 52_219_000 picoseconds.
+        Weight::from_parts(53_704_000, 21261)
             .saturating_add(RocksDbWeight::get().reads(7_u64))
             .saturating_add(RocksDbWeight::get().writes(6_u64))
     }
@@ -2165,8 +2165,8 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `534`
         //  Estimated: `17070`
-        // Minimum execution time: 29_099_000 picoseconds.
-        Weight::from_parts(30_610_000, 17070)
+        // Minimum execution time: 28_408_000 picoseconds.
+        Weight::from_parts(29_714_000, 17070)
             .saturating_add(RocksDbWeight::get().reads(6_u64))
             .saturating_add(RocksDbWeight::get().writes(4_u64))
     }
@@ -2175,10 +2175,10 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `355`
         //  Estimated: `7640`
-        // Minimum execution time: 8_259_000 picoseconds.
-        Weight::from_parts(6_228_584, 7640)
-            // Standard Error: 37_556
-            .saturating_add(Weight::from_parts(16_519_610, 0).saturating_mul(c.into()))
+        // Minimum execution time: 7_918_000 picoseconds.
+        Weight::from_parts(6_745_647, 7640)
+            // Standard Error: 37_300
+            .saturating_add(Weight::from_parts(13_885_473, 0).saturating_mul(c.into()))
             .saturating_add(RocksDbWeight::get().reads(2_u64))
             .saturating_add(RocksDbWeight::get().writes(2_u64))
     }
@@ -2187,10 +2187,10 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `1297 + c * (16389 ±0)`
         //  Estimated: `40898 + c * (131112 ±0)`
-        // Minimum execution time: 70_699_000 picoseconds.
-        Weight::from_parts(71_447_000, 40898)
-            // Standard Error: 139_719
-            .saturating_add(Weight::from_parts(54_319_486, 0).saturating_mul(c.into()))
+        // Minimum execution time: 68_486_000 picoseconds.
+        Weight::from_parts(69_079_000, 40898)
+            // Standard Error: 164_982
+            .saturating_add(Weight::from_parts(55_774_264, 0).saturating_mul(c.into()))
             .saturating_add(RocksDbWeight::get().reads(11_u64))
             .saturating_add(RocksDbWeight::get().writes(9_u64))
             .saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(c.into())))
@@ -2201,10 +2201,10 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `10`
         //  Estimated: `4990`
-        // Minimum execution time: 60_906_000 picoseconds.
-        Weight::from_parts(18_999_485, 4990)
-            // Standard Error: 57_215
-            .saturating_add(Weight::from_parts(53_057_311, 0).saturating_mul(c.into()))
+        // Minimum execution time: 61_635_000 picoseconds.
+        Weight::from_parts(64_537_590, 4990)
+            // Standard Error: 40_298
+            .saturating_add(Weight::from_parts(52_820_238, 0).saturating_mul(c.into()))
             .saturating_add(RocksDbWeight::get().reads(2_u64))
             .saturating_add(RocksDbWeight::get().writes(4_u64))
     }
@@ -2213,10 +2213,10 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `671`
         //  Estimated: `38638`
-        // Minimum execution time: 65_623_000 picoseconds.
-        Weight::from_parts(88_392_610, 38638)
+        // Minimum execution time: 63_344_000 picoseconds.
+        Weight::from_parts(76_968_021, 38638)
             // Standard Error: 0
-            .saturating_add(Weight::from_parts(2_635, 0).saturating_mul(s.into()))
+            .saturating_add(Weight::from_parts(2_598, 0).saturating_mul(s.into()))
             .saturating_add(RocksDbWeight::get().reads(13_u64))
             .saturating_add(RocksDbWeight::get().writes(10_u64))
     }
@@ -2226,12 +2226,12 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `235`
         //  Estimated: `34312`
-        // Minimum execution time: 11_247_503_000 picoseconds.
-        Weight::from_parts(302_469_923, 34312)
-            // Standard Error: 147_459
-            .saturating_add(Weight::from_parts(54_400_528, 0).saturating_mul(c.into()))
-            // Standard Error: 8
-            .saturating_add(Weight::from_parts(2_571, 0).saturating_mul(s.into()))
+        // Minimum execution time: 10_980_969_000 picoseconds.
+        Weight::from_parts(301_891_685, 34312)
+            // Standard Error: 164_203
+            .saturating_add(Weight::from_parts(54_383_779, 0).saturating_mul(c.into()))
+            // Standard Error: 9
+            .saturating_add(Weight::from_parts(2_548, 0).saturating_mul(s.into()))
             .saturating_add(RocksDbWeight::get().reads(13_u64))
             .saturating_add(RocksDbWeight::get().writes(14_u64))
     }
@@ -2240,10 +2240,10 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `348`
         //  Estimated: `23853`
-        // Minimum execution time: 56_802_000 picoseconds.
-        Weight::from_parts(33_250_791, 23853)
-            // Standard Error: 1
-            .saturating_add(Weight::from_parts(1_182, 0).saturating_mul(p.into()))
+        // Minimum execution time: 53_732_000 picoseconds.
+        Weight::from_parts(35_204_611, 23853)
+            // Standard Error: 0
+            .saturating_add(Weight::from_parts(1_021, 0).saturating_mul(p.into()))
             .saturating_add(RocksDbWeight::get().reads(9_u64))
             .saturating_add(RocksDbWeight::get().writes(8_u64))
     }
@@ -2252,10 +2252,10 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `451`
         //  Estimated: `27177`
-        // Minimum execution time: 59_487_000 picoseconds.
-        Weight::from_parts(37_481_444, 27177)
-            // Standard Error: 1
-            .saturating_add(Weight::from_parts(1_182, 0).saturating_mul(p.into()))
+        // Minimum execution time: 57_078_000 picoseconds.
+        Weight::from_parts(37_366_780, 27177)
+            // Standard Error: 0
+            .saturating_add(Weight::from_parts(1_023, 0).saturating_mul(p.into()))
             .saturating_add(RocksDbWeight::get().reads(10_u64))
             .saturating_add(RocksDbWeight::get().writes(9_u64))
     }
@@ -2264,10 +2264,10 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `978`
         //  Estimated: `42227`
-        // Minimum execution time: 86_239_000 picoseconds.
-        Weight::from_parts(32_106_516, 42227)
-            // Standard Error: 3
-            .saturating_add(Weight::from_parts(1_249, 0).saturating_mul(p.into()))
+        // Minimum execution time: 82_297_000 picoseconds.
+        Weight::from_parts(62_302_593, 42227)
+            // Standard Error: 1
+            .saturating_add(Weight::from_parts(1_042, 0).saturating_mul(p.into()))
             .saturating_add(RocksDbWeight::get().reads(13_u64))
             .saturating_add(RocksDbWeight::get().writes(10_u64))
     }
@@ -2276,10 +2276,10 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `1081`
         //  Estimated: `45757`
-        // Minimum execution time: 98_413_000 picoseconds.
-        Weight::from_parts(52_381_439, 45757)
-            // Standard Error: 3
-            .saturating_add(Weight::from_parts(1_252, 0).saturating_mul(p.into()))
+        // Minimum execution time: 93_602_000 picoseconds.
+        Weight::from_parts(69_941_334, 45757)
+            // Standard Error: 1
+            .saturating_add(Weight::from_parts(1_057, 0).saturating_mul(p.into()))
             .saturating_add(RocksDbWeight::get().reads(14_u64))
             .saturating_add(RocksDbWeight::get().writes(11_u64))
     }
@@ -2288,8 +2288,8 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `760`
         //  Estimated: `74319`
-        // Minimum execution time: 302_634_000 picoseconds.
-        Weight::from_parts(320_223_637, 74319)
+        // Minimum execution time: 298_083_000 picoseconds.
+        Weight::from_parts(314_192_353, 74319)
             .saturating_add(RocksDbWeight::get().reads(27_u64))
             .saturating_add(RocksDbWeight::get().writes(22_u64))
     }
@@ -2298,10 +2298,10 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `760`
         //  Estimated: `74319`
-        // Minimum execution time: 315_859_000 picoseconds.
-        Weight::from_parts(328_138_594, 74319)
-            // Standard Error: 1_557
-            .saturating_add(Weight::from_parts(8_014, 0).saturating_mul(q.into()))
+        // Minimum execution time: 312_856_000 picoseconds.
+        Weight::from_parts(326_607_586, 74319)
+            // Standard Error: 1_507
+            .saturating_add(Weight::from_parts(723, 0).saturating_mul(q.into()))
             .saturating_add(RocksDbWeight::get().reads(27_u64))
             .saturating_add(RocksDbWeight::get().writes(22_u64))
     }
@@ -2310,10 +2310,10 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `211 + c * (1075 ±0)`
         //  Estimated: `3899 + c * (2150 ±0)`
-        // Minimum execution time: 45_804_000 picoseconds.
-        Weight::from_parts(46_226_000, 3899)
-            // Standard Error: 51_090
-            .saturating_add(Weight::from_parts(51_940_069, 0).saturating_mul(c.into()))
+        // Minimum execution time: 45_478_000 picoseconds.
+        Weight::from_parts(45_769_000, 3899)
+            // Standard Error: 42_221
+            .saturating_add(Weight::from_parts(51_492_007, 0).saturating_mul(c.into()))
             .saturating_add(RocksDbWeight::get().reads(1_u64))
             .saturating_add(RocksDbWeight::get().writes(2_u64))
             .saturating_add(Weight::from_parts(0, 2150).saturating_mul(c.into()))
@@ -2323,630 +2323,630 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 80_872_000 picoseconds.
-        Weight::from_parts(82_358_000, 0)
-            // Standard Error: 3_946_533
-            .saturating_add(Weight::from_parts(617_270_552, 0).saturating_mul(r.into()))
+        // Minimum execution time: 85_248_000 picoseconds.
+        Weight::from_parts(87_224_000, 0)
+            // Standard Error: 4_031_043
+            .saturating_add(Weight::from_parts(559_145_890, 0).saturating_mul(r.into()))
     }
     /// The range of component `p` is `[1, 512]`.
     fn alloc_per_page(p: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 365_182_000 picoseconds.
-        Weight::from_parts(292_523_651, 0)
-            // Standard Error: 7_087
-            .saturating_add(Weight::from_parts(31_059_002, 0).saturating_mul(p.into()))
+        // Minimum execution time: 304_310_000 picoseconds.
+        Weight::from_parts(240_640_662, 0)
+            // Standard Error: 7_875
+            .saturating_add(Weight::from_parts(30_931_778, 0).saturating_mul(p.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn free(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 196_771_000 picoseconds.
-        Weight::from_parts(219_836_156, 0)
-            // Standard Error: 406_704
-            .saturating_add(Weight::from_parts(120_742_843, 0).saturating_mul(r.into()))
+        // Minimum execution time: 144_728_000 picoseconds.
+        Weight::from_parts(127_694_995, 0)
+            // Standard Error: 344_021
+            .saturating_add(Weight::from_parts(63_008_235, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 256]`.
     fn gr_reserve_gas(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 86_043_000 picoseconds.
-        Weight::from_parts(92_117_781, 0)
-            // Standard Error: 7_334
-            .saturating_add(Weight::from_parts(3_640_301, 0).saturating_mul(r.into()))
+        // Minimum execution time: 85_763_000 picoseconds.
+        Weight::from_parts(93_302_515, 0)
+            // Standard Error: 3_873
+            .saturating_add(Weight::from_parts(2_723_217, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 256]`.
     fn gr_unreserve_gas(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 146_803_000 picoseconds.
-        Weight::from_parts(168_908_676, 0)
-            // Standard Error: 28_070
-            .saturating_add(Weight::from_parts(3_989_643, 0).saturating_mul(r.into()))
+        // Minimum execution time: 134_987_000 picoseconds.
+        Weight::from_parts(141_052_149, 0)
+            // Standard Error: 29_498
+            .saturating_add(Weight::from_parts(3_252_053, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_system_reserve_gas(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 82_421_000 picoseconds.
-        Weight::from_parts(109_902_108, 0)
-            // Standard Error: 458_197
-            .saturating_add(Weight::from_parts(186_560_355, 0).saturating_mul(r.into()))
+        // Minimum execution time: 82_532_000 picoseconds.
+        Weight::from_parts(111_956_884, 0)
+            // Standard Error: 420_651
+            .saturating_add(Weight::from_parts(124_761_103, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_message_id(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 85_173_000 picoseconds.
-        Weight::from_parts(81_703_608, 0)
-            // Standard Error: 318_823
-            .saturating_add(Weight::from_parts(183_602_076, 0).saturating_mul(r.into()))
+        // Minimum execution time: 82_442_000 picoseconds.
+        Weight::from_parts(76_262_730, 0)
+            // Standard Error: 310_067
+            .saturating_add(Weight::from_parts(115_334_131, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_program_id(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 85_999_000 picoseconds.
-        Weight::from_parts(81_002_605, 0)
-            // Standard Error: 269_075
-            .saturating_add(Weight::from_parts(183_154_106, 0).saturating_mul(r.into()))
+        // Minimum execution time: 82_322_000 picoseconds.
+        Weight::from_parts(71_153_919, 0)
+            // Standard Error: 293_317
+            .saturating_add(Weight::from_parts(115_508_333, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_source(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 82_306_000 picoseconds.
-        Weight::from_parts(79_166_166, 0)
-            // Standard Error: 332_502
-            .saturating_add(Weight::from_parts(182_666_522, 0).saturating_mul(r.into()))
+        // Minimum execution time: 82_586_000 picoseconds.
+        Weight::from_parts(73_401_225, 0)
+            // Standard Error: 306_089
+            .saturating_add(Weight::from_parts(115_530_298, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_value(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 82_459_000 picoseconds.
-        Weight::from_parts(80_301_392, 0)
-            // Standard Error: 340_598
-            .saturating_add(Weight::from_parts(184_099_120, 0).saturating_mul(r.into()))
+        // Minimum execution time: 86_537_000 picoseconds.
+        Weight::from_parts(80_327_682, 0)
+            // Standard Error: 275_679
+            .saturating_add(Weight::from_parts(114_024_859, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_value_available(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 81_140_000 picoseconds.
-        Weight::from_parts(72_987_262, 0)
-            // Standard Error: 388_909
-            .saturating_add(Weight::from_parts(186_920_851, 0).saturating_mul(r.into()))
+        // Minimum execution time: 84_226_000 picoseconds.
+        Weight::from_parts(74_308_323, 0)
+            // Standard Error: 291_460
+            .saturating_add(Weight::from_parts(115_396_428, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_gas_available(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 81_336_000 picoseconds.
-        Weight::from_parts(79_078_269, 0)
-            // Standard Error: 276_322
-            .saturating_add(Weight::from_parts(182_690_178, 0).saturating_mul(r.into()))
+        // Minimum execution time: 81_250_000 picoseconds.
+        Weight::from_parts(74_761_588, 0)
+            // Standard Error: 317_797
+            .saturating_add(Weight::from_parts(115_173_001, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_size(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 84_201_000 picoseconds.
-        Weight::from_parts(79_459_558, 0)
-            // Standard Error: 357_406
-            .saturating_add(Weight::from_parts(182_989_857, 0).saturating_mul(r.into()))
+        // Minimum execution time: 85_673_000 picoseconds.
+        Weight::from_parts(70_907_772, 0)
+            // Standard Error: 347_682
+            .saturating_add(Weight::from_parts(118_189_625, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_read(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 709_298_000 picoseconds.
-        Weight::from_parts(792_701_124, 0)
-            // Standard Error: 581_476
-            .saturating_add(Weight::from_parts(264_833_637, 0).saturating_mul(r.into()))
+        // Minimum execution time: 700_530_000 picoseconds.
+        Weight::from_parts(774_384_678, 0)
+            // Standard Error: 512_748
+            .saturating_add(Weight::from_parts(194_331_468, 0).saturating_mul(r.into()))
     }
     /// The range of component `n` is `[0, 2048]`.
     fn gr_read_per_kb(n: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 958_553_000 picoseconds.
-        Weight::from_parts(1_002_082_000, 0)
-            // Standard Error: 51_056
-            .saturating_add(Weight::from_parts(13_349_580, 0).saturating_mul(n.into()))
+        // Minimum execution time: 866_889_000 picoseconds.
+        Weight::from_parts(872_993_000, 0)
+            // Standard Error: 59_048
+            .saturating_add(Weight::from_parts(13_399_620, 0).saturating_mul(n.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_block_height(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 81_092_000 picoseconds.
-        Weight::from_parts(70_460_333, 0)
-            // Standard Error: 322_779
-            .saturating_add(Weight::from_parts(182_652_206, 0).saturating_mul(r.into()))
+        // Minimum execution time: 85_291_000 picoseconds.
+        Weight::from_parts(75_543_485, 0)
+            // Standard Error: 320_701
+            .saturating_add(Weight::from_parts(115_757_456, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_block_timestamp(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 82_315_000 picoseconds.
-        Weight::from_parts(77_285_940, 0)
-            // Standard Error: 310_862
-            .saturating_add(Weight::from_parts(183_154_588, 0).saturating_mul(r.into()))
+        // Minimum execution time: 83_780_000 picoseconds.
+        Weight::from_parts(68_090_338, 0)
+            // Standard Error: 330_050
+            .saturating_add(Weight::from_parts(117_803_137, 0).saturating_mul(r.into()))
     }
     /// The range of component `n` is `[0, 20]`.
     fn gr_random(n: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 82_813_000 picoseconds.
-        Weight::from_parts(83_631_977, 0)
-            // Standard Error: 426_894
-            .saturating_add(Weight::from_parts(250_044_040, 0).saturating_mul(n.into()))
+        // Minimum execution time: 84_394_000 picoseconds.
+        Weight::from_parts(88_472_912, 0)
+            // Standard Error: 340_524
+            .saturating_add(Weight::from_parts(190_044_477, 0).saturating_mul(n.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_reply_deposit(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 87_342_000 picoseconds.
-        Weight::from_parts(88_861_000, 0)
-            // Standard Error: 4_034_065
-            .saturating_add(Weight::from_parts(1_070_363_129, 0).saturating_mul(r.into()))
+        // Minimum execution time: 83_081_000 picoseconds.
+        Weight::from_parts(85_006_000, 0)
+            // Standard Error: 3_456_961
+            .saturating_add(Weight::from_parts(860_188_117, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_send(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 82_887_000 picoseconds.
-        Weight::from_parts(154_402_402, 0)
-            // Standard Error: 504_137
-            .saturating_add(Weight::from_parts(389_538_545, 0).saturating_mul(r.into()))
+        // Minimum execution time: 81_490_000 picoseconds.
+        Weight::from_parts(136_619_765, 0)
+            // Standard Error: 439_674
+            .saturating_add(Weight::from_parts(308_552_304, 0).saturating_mul(r.into()))
     }
     /// The range of component `n` is `[0, 2048]`.
     fn gr_send_per_kb(n: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 467_573_000 picoseconds.
-        Weight::from_parts(471_685_000, 0)
-            // Standard Error: 64_140
-            .saturating_add(Weight::from_parts(22_109_126, 0).saturating_mul(n.into()))
+        // Minimum execution time: 386_929_000 picoseconds.
+        Weight::from_parts(393_325_000, 0)
+            // Standard Error: 61_932
+            .saturating_add(Weight::from_parts(21_101_790, 0).saturating_mul(n.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_send_wgas(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 86_853_000 picoseconds.
-        Weight::from_parts(152_053_498, 0)
-            // Standard Error: 538_330
-            .saturating_add(Weight::from_parts(397_711_575, 0).saturating_mul(r.into()))
+        // Minimum execution time: 84_625_000 picoseconds.
+        Weight::from_parts(162_584_483, 0)
+            // Standard Error: 494_553
+            .saturating_add(Weight::from_parts(313_684_139, 0).saturating_mul(r.into()))
     }
     /// The range of component `n` is `[0, 2048]`.
     fn gr_send_wgas_per_kb(n: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 471_875_000 picoseconds.
-        Weight::from_parts(475_692_000, 0)
-            // Standard Error: 57_997
-            .saturating_add(Weight::from_parts(21_385_701, 0).saturating_mul(n.into()))
+        // Minimum execution time: 390_932_000 picoseconds.
+        Weight::from_parts(393_883_000, 0)
+            // Standard Error: 68_646
+            .saturating_add(Weight::from_parts(21_188_381, 0).saturating_mul(n.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_send_input(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 716_684_000 picoseconds.
-        Weight::from_parts(781_328_373, 0)
-            // Standard Error: 479_933
-            .saturating_add(Weight::from_parts(411_727_995, 0).saturating_mul(r.into()))
+        // Minimum execution time: 708_623_000 picoseconds.
+        Weight::from_parts(781_094_266, 0)
+            // Standard Error: 460_683
+            .saturating_add(Weight::from_parts(328_993_362, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_send_input_wgas(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 746_421_000 picoseconds.
-        Weight::from_parts(889_163_923, 0)
-            // Standard Error: 621_967
-            .saturating_add(Weight::from_parts(412_763_026, 0).saturating_mul(r.into()))
+        // Minimum execution time: 710_228_000 picoseconds.
+        Weight::from_parts(774_190_634, 0)
+            // Standard Error: 483_646
+            .saturating_add(Weight::from_parts(330_057_876, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_send_init(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 81_961_000 picoseconds.
-        Weight::from_parts(86_031_226, 0)
-            // Standard Error: 355_690
-            .saturating_add(Weight::from_parts(191_347_968, 0).saturating_mul(r.into()))
+        // Minimum execution time: 83_510_000 picoseconds.
+        Weight::from_parts(64_097_635, 0)
+            // Standard Error: 358_570
+            .saturating_add(Weight::from_parts(126_095_109, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_send_push(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 3_797_807_000 picoseconds.
-        Weight::from_parts(3_948_397_472, 0)
-            // Standard Error: 396_090
-            .saturating_add(Weight::from_parts(284_341_649, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_430_098_000 picoseconds.
+        Weight::from_parts(2_605_278_898, 0)
+            // Standard Error: 439_185
+            .saturating_add(Weight::from_parts(217_479_981, 0).saturating_mul(r.into()))
     }
     /// The range of component `n` is `[0, 2048]`.
     fn gr_send_push_per_kb(n: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 485_799_000 picoseconds.
-        Weight::from_parts(486_862_000, 0)
-            // Standard Error: 47_704
-            .saturating_add(Weight::from_parts(31_360_292, 0).saturating_mul(n.into()))
+        // Minimum execution time: 358_553_000 picoseconds.
+        Weight::from_parts(364_183_000, 0)
+            // Standard Error: 51_397
+            .saturating_add(Weight::from_parts(30_914_040, 0).saturating_mul(n.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_send_commit(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 3_842_120_000 picoseconds.
-        Weight::from_parts(3_943_431_716, 0)
-            // Standard Error: 766_406
-            .saturating_add(Weight::from_parts(339_379_953, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_464_581_000 picoseconds.
+        Weight::from_parts(2_580_044_243, 0)
+            // Standard Error: 461_216
+            .saturating_add(Weight::from_parts(272_575_116, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_send_commit_wgas(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 3_828_327_000 picoseconds.
-        Weight::from_parts(3_976_283_101, 0)
-            // Standard Error: 768_169
-            .saturating_add(Weight::from_parts(353_252_083, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_438_114_000 picoseconds.
+        Weight::from_parts(2_597_881_615, 0)
+            // Standard Error: 400_982
+            .saturating_add(Weight::from_parts(275_718_502, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_reservation_send(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 256_679_000 picoseconds.
-        Weight::from_parts(330_245_572, 0)
-            // Standard Error: 519_345
-            .saturating_add(Weight::from_parts(404_879_225, 0).saturating_mul(r.into()))
+        // Minimum execution time: 244_206_000 picoseconds.
+        Weight::from_parts(321_175_021, 0)
+            // Standard Error: 460_445
+            .saturating_add(Weight::from_parts(322_059_081, 0).saturating_mul(r.into()))
     }
     /// The range of component `n` is `[0, 2048]`.
     fn gr_reservation_send_per_kb(n: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 640_004_000 picoseconds.
-        Weight::from_parts(646_769_000, 0)
-            // Standard Error: 55_122
-            .saturating_add(Weight::from_parts(21_616_125, 0).saturating_mul(n.into()))
+        // Minimum execution time: 559_346_000 picoseconds.
+        Weight::from_parts(571_004_000, 0)
+            // Standard Error: 59_840
+            .saturating_add(Weight::from_parts(21_370_093, 0).saturating_mul(n.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_reservation_send_commit(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 3_981_155_000 picoseconds.
-        Weight::from_parts(4_086_072_221, 0)
-            // Standard Error: 1_076_069
-            .saturating_add(Weight::from_parts(362_989_310, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_620_633_000 picoseconds.
+        Weight::from_parts(2_741_869_292, 0)
+            // Standard Error: 620_120
+            .saturating_add(Weight::from_parts(289_781_719, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 1]`.
     fn gr_reply(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 84_145_000 picoseconds.
-        Weight::from_parts(88_260_563, 0)
-            // Standard Error: 277_576
-            .saturating_add(Weight::from_parts(20_209_036, 0).saturating_mul(r.into()))
+        // Minimum execution time: 83_438_000 picoseconds.
+        Weight::from_parts(86_817_816, 0)
+            // Standard Error: 234_731
+            .saturating_add(Weight::from_parts(19_849_283, 0).saturating_mul(r.into()))
     }
     /// The range of component `n` is `[0, 2048]`.
     fn gr_reply_per_kb(n: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 102_930_000 picoseconds.
-        Weight::from_parts(90_280_376, 0)
-            // Standard Error: 1_072
-            .saturating_add(Weight::from_parts(427_777, 0).saturating_mul(n.into()))
+        // Minimum execution time: 105_002_000 picoseconds.
+        Weight::from_parts(88_114_999, 0)
+            // Standard Error: 1_128
+            .saturating_add(Weight::from_parts(427_426, 0).saturating_mul(n.into()))
     }
     /// The range of component `r` is `[0, 1]`.
     fn gr_reply_wgas(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 84_156_000 picoseconds.
-        Weight::from_parts(89_778_763, 0)
-            // Standard Error: 365_767
-            .saturating_add(Weight::from_parts(24_157_936, 0).saturating_mul(r.into()))
+        // Minimum execution time: 82_436_000 picoseconds.
+        Weight::from_parts(88_440_285, 0)
+            // Standard Error: 277_544
+            .saturating_add(Weight::from_parts(17_399_914, 0).saturating_mul(r.into()))
     }
     /// The range of component `n` is `[0, 2048]`.
     fn gr_reply_wgas_per_kb(n: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 105_315_000 picoseconds.
-        Weight::from_parts(94_894_394, 0)
-            // Standard Error: 993
-            .saturating_add(Weight::from_parts(426_364, 0).saturating_mul(n.into()))
+        // Minimum execution time: 103_800_000 picoseconds.
+        Weight::from_parts(89_756_983, 0)
+            // Standard Error: 907
+            .saturating_add(Weight::from_parts(428_998, 0).saturating_mul(n.into()))
     }
     /// The range of component `r` is `[0, 1]`.
     fn gr_reply_commit(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 81_595_000 picoseconds.
-        Weight::from_parts(86_259_504, 0)
-            // Standard Error: 284_882
-            .saturating_add(Weight::from_parts(25_873_595, 0).saturating_mul(r.into()))
+        // Minimum execution time: 81_754_000 picoseconds.
+        Weight::from_parts(87_296_014, 0)
+            // Standard Error: 336_747
+            .saturating_add(Weight::from_parts(20_299_385, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 1]`.
     fn gr_reply_commit_wgas(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 80_771_000 picoseconds.
-        Weight::from_parts(85_313_802, 0)
-            // Standard Error: 265_474
-            .saturating_add(Weight::from_parts(25_863_597, 0).saturating_mul(r.into()))
+        // Minimum execution time: 81_952_000 picoseconds.
+        Weight::from_parts(86_840_575, 0)
+            // Standard Error: 272_708
+            .saturating_add(Weight::from_parts(19_217_524, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_reply_push(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 82_396_000 picoseconds.
-        Weight::from_parts(126_819_617, 0)
-            // Standard Error: 518_749
-            .saturating_add(Weight::from_parts(272_821_836, 0).saturating_mul(r.into()))
+        // Minimum execution time: 85_498_000 picoseconds.
+        Weight::from_parts(126_431_779, 0)
+            // Standard Error: 460_480
+            .saturating_add(Weight::from_parts(198_940_536, 0).saturating_mul(r.into()))
     }
     /// The range of component `n` is `[0, 8192]`.
     fn gr_reply_push_per_kb(n: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 98_266_000 picoseconds.
-        Weight::from_parts(100_843_000, 0)
-            // Standard Error: 2_828
-            .saturating_add(Weight::from_parts(662_117, 0).saturating_mul(n.into()))
+        // Minimum execution time: 96_862_000 picoseconds.
+        Weight::from_parts(98_611_000, 0)
+            // Standard Error: 2_677
+            .saturating_add(Weight::from_parts(662_266, 0).saturating_mul(n.into()))
     }
     /// The range of component `r` is `[0, 1]`.
     fn gr_reply_input(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 707_150_000 picoseconds.
-        Weight::from_parts(754_398_128, 0)
-            // Standard Error: 5_119_788
-            .saturating_add(Weight::from_parts(7_037_071, 0).saturating_mul(r.into()))
+        // Minimum execution time: 698_914_000 picoseconds.
+        Weight::from_parts(718_405_100, 0)
+            // Standard Error: 1_891_960
+            .saturating_add(Weight::from_parts(24_867_800, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 1]`.
     fn gr_reply_input_wgas(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 712_091_000 picoseconds.
-        Weight::from_parts(751_999_544, 0)
-            // Standard Error: 4_003_265
-            .saturating_add(Weight::from_parts(43_818_555, 0).saturating_mul(r.into()))
+        // Minimum execution time: 699_975_000 picoseconds.
+        Weight::from_parts(718_806_789, 0)
+            // Standard Error: 1_919_531
+            .saturating_add(Weight::from_parts(51_192_710, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 1]`.
     fn gr_reservation_reply(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 92_234_000 picoseconds.
-        Weight::from_parts(96_192_773, 0)
-            // Standard Error: 271_871
-            .saturating_add(Weight::from_parts(13_338_726, 0).saturating_mul(r.into()))
+        // Minimum execution time: 95_002_000 picoseconds.
+        Weight::from_parts(99_331_989, 0)
+            // Standard Error: 287_602
+            .saturating_add(Weight::from_parts(9_719_710, 0).saturating_mul(r.into()))
     }
     /// The range of component `n` is `[0, 2048]`.
     fn gr_reservation_reply_per_kb(n: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 108_190_000 picoseconds.
-        Weight::from_parts(92_525_926, 0)
-            // Standard Error: 1_134
-            .saturating_add(Weight::from_parts(433_806, 0).saturating_mul(n.into()))
+        // Minimum execution time: 102_501_000 picoseconds.
+        Weight::from_parts(87_026_327, 0)
+            // Standard Error: 1_214
+            .saturating_add(Weight::from_parts(429_134, 0).saturating_mul(n.into()))
     }
     /// The range of component `r` is `[0, 1]`.
     fn gr_reservation_reply_commit(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 92_297_000 picoseconds.
-        Weight::from_parts(98_054_616, 0)
-            // Standard Error: 394_791
-            .saturating_add(Weight::from_parts(7_680_683, 0).saturating_mul(r.into()))
+        // Minimum execution time: 93_228_000 picoseconds.
+        Weight::from_parts(97_923_691, 0)
+            // Standard Error: 288_469
+            .saturating_add(Weight::from_parts(9_669_908, 0).saturating_mul(r.into()))
     }
     /// The range of component `n` is `[0, 2048]`.
     fn gr_reservation_reply_commit_per_kb(n: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 106_932_000 picoseconds.
-        Weight::from_parts(91_150_785, 0)
-            // Standard Error: 1_067
-            .saturating_add(Weight::from_parts(424_570, 0).saturating_mul(n.into()))
+        // Minimum execution time: 100_908_000 picoseconds.
+        Weight::from_parts(87_613_705, 0)
+            // Standard Error: 1_237
+            .saturating_add(Weight::from_parts(431_412, 0).saturating_mul(n.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_reply_to(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 80_591_000 picoseconds.
-        Weight::from_parts(79_590_461, 0)
-            // Standard Error: 360_038
-            .saturating_add(Weight::from_parts(185_313_242, 0).saturating_mul(r.into()))
+        // Minimum execution time: 84_385_000 picoseconds.
+        Weight::from_parts(74_453_057, 0)
+            // Standard Error: 309_931
+            .saturating_add(Weight::from_parts(117_172_527, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_signal_from(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 83_379_000 picoseconds.
-        Weight::from_parts(82_304_672, 0)
-            // Standard Error: 371_508
-            .saturating_add(Weight::from_parts(184_895_719, 0).saturating_mul(r.into()))
+        // Minimum execution time: 82_437_000 picoseconds.
+        Weight::from_parts(78_951_443, 0)
+            // Standard Error: 294_227
+            .saturating_add(Weight::from_parts(116_066_384, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_reply_push_input(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 714_906_000 picoseconds.
-        Weight::from_parts(784_837_322, 0)
-            // Standard Error: 485_874
-            .saturating_add(Weight::from_parts(198_529_306, 0).saturating_mul(r.into()))
+        // Minimum execution time: 704_954_000 picoseconds.
+        Weight::from_parts(752_735_182, 0)
+            // Standard Error: 455_998
+            .saturating_add(Weight::from_parts(135_154_607, 0).saturating_mul(r.into()))
     }
     /// The range of component `n` is `[0, 2048]`.
     fn gr_reply_push_input_per_kb(n: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 735_164_000 picoseconds.
-        Weight::from_parts(760_829_418, 0)
-            // Standard Error: 2_049
-            .saturating_add(Weight::from_parts(164_862, 0).saturating_mul(n.into()))
+        // Minimum execution time: 724_451_000 picoseconds.
+        Weight::from_parts(738_722_668, 0)
+            // Standard Error: 1_014
+            .saturating_add(Weight::from_parts(154_329, 0).saturating_mul(n.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_send_push_input(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 4_467_125_000 picoseconds.
-        Weight::from_parts(4_668_343_697, 0)
-            // Standard Error: 529_569
-            .saturating_add(Weight::from_parts(214_709_155, 0).saturating_mul(r.into()))
+        // Minimum execution time: 3_092_586_000 picoseconds.
+        Weight::from_parts(3_231_311_035, 0)
+            // Standard Error: 506_742
+            .saturating_add(Weight::from_parts(159_545_582, 0).saturating_mul(r.into()))
     }
     /// The range of component `n` is `[0, 2048]`.
     fn gr_send_push_input_per_kb(n: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 4_716_693_000 picoseconds.
-        Weight::from_parts(4_810_590_943, 0)
-            // Standard Error: 12_440
-            .saturating_add(Weight::from_parts(13_814_475, 0).saturating_mul(n.into()))
+        // Minimum execution time: 3_299_872_000 picoseconds.
+        Weight::from_parts(3_317_022_894, 0)
+            // Standard Error: 8_542
+            .saturating_add(Weight::from_parts(13_645_472, 0).saturating_mul(n.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_debug(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 81_721_000 picoseconds.
-        Weight::from_parts(95_360_878, 0)
-            // Standard Error: 488_163
-            .saturating_add(Weight::from_parts(198_923_476, 0).saturating_mul(r.into()))
+        // Minimum execution time: 85_966_000 picoseconds.
+        Weight::from_parts(106_319_310, 0)
+            // Standard Error: 424_534
+            .saturating_add(Weight::from_parts(139_885_203, 0).saturating_mul(r.into()))
     }
     /// The range of component `n` is `[0, 2048]`.
     fn gr_debug_per_kb(n: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 189_069_000 picoseconds.
-        Weight::from_parts(191_834_000, 0)
-            // Standard Error: 53_942
-            .saturating_add(Weight::from_parts(26_059_121, 0).saturating_mul(n.into()))
+        // Minimum execution time: 142_910_000 picoseconds.
+        Weight::from_parts(144_843_000, 0)
+            // Standard Error: 54_401
+            .saturating_add(Weight::from_parts(25_535_472, 0).saturating_mul(n.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_reply_code(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 83_023_000 picoseconds.
-        Weight::from_parts(70_919_161, 0)
-            // Standard Error: 442_134
-            .saturating_add(Weight::from_parts(186_467_769, 0).saturating_mul(r.into()))
+        // Minimum execution time: 82_117_000 picoseconds.
+        Weight::from_parts(80_202_149, 0)
+            // Standard Error: 296_880
+            .saturating_add(Weight::from_parts(114_586_990, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 1]`.
     fn gr_exit(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 80_187_000 picoseconds.
-        Weight::from_parts(86_256_124, 0)
-            // Standard Error: 333_120
-            .saturating_add(Weight::from_parts(27_182_075, 0).saturating_mul(r.into()))
+        // Minimum execution time: 81_802_000 picoseconds.
+        Weight::from_parts(85_064_295, 0)
+            // Standard Error: 248_874
+            .saturating_add(Weight::from_parts(27_314_604, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 1]`.
     fn gr_leave(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 80_373_000 picoseconds.
-        Weight::from_parts(83_957_387, 0)
-            // Standard Error: 258_914
-            .saturating_add(Weight::from_parts(14_637_112, 0).saturating_mul(r.into()))
+        // Minimum execution time: 82_854_000 picoseconds.
+        Weight::from_parts(86_180_314, 0)
+            // Standard Error: 239_162
+            .saturating_add(Weight::from_parts(16_391_885, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 1]`.
     fn gr_wait(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 82_886_000 picoseconds.
-        Weight::from_parts(86_536_767, 0)
-            // Standard Error: 237_087
-            .saturating_add(Weight::from_parts(15_456_732, 0).saturating_mul(r.into()))
+        // Minimum execution time: 80_883_000 picoseconds.
+        Weight::from_parts(87_058_214, 0)
+            // Standard Error: 256_392
+            .saturating_add(Weight::from_parts(13_333_285, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 1]`.
     fn gr_wait_for(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 82_962_000 picoseconds.
-        Weight::from_parts(87_038_165, 0)
-            // Standard Error: 267_652
-            .saturating_add(Weight::from_parts(14_141_234, 0).saturating_mul(r.into()))
+        // Minimum execution time: 81_417_000 picoseconds.
+        Weight::from_parts(85_403_451, 0)
+            // Standard Error: 249_767
+            .saturating_add(Weight::from_parts(14_474_948, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 1]`.
     fn gr_wait_up_to(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 82_976_000 picoseconds.
-        Weight::from_parts(87_105_967, 0)
-            // Standard Error: 237_581
-            .saturating_add(Weight::from_parts(13_365_932, 0).saturating_mul(r.into()))
+        // Minimum execution time: 84_020_000 picoseconds.
+        Weight::from_parts(88_080_622, 0)
+            // Standard Error: 253_221
+            .saturating_add(Weight::from_parts(11_403_277, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_wake(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 139_585_000 picoseconds.
-        Weight::from_parts(203_512_831, 0)
-            // Standard Error: 393_346
-            .saturating_add(Weight::from_parts(283_538_921, 0).saturating_mul(r.into()))
+        // Minimum execution time: 138_317_000 picoseconds.
+        Weight::from_parts(187_894_162, 0)
+            // Standard Error: 376_519
+            .saturating_add(Weight::from_parts(209_723_429, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_create_program(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 98_330_000 picoseconds.
-        Weight::from_parts(158_669_516, 0)
-            // Standard Error: 440_421
-            .saturating_add(Weight::from_parts(473_163_025, 0).saturating_mul(r.into()))
+        // Minimum execution time: 93_047_000 picoseconds.
+        Weight::from_parts(151_715_771, 0)
+            // Standard Error: 425_606
+            .saturating_add(Weight::from_parts(396_733_544, 0).saturating_mul(r.into()))
     }
     /// The range of component `p` is `[0, 2048]`.
     /// The range of component `s` is `[1, 2048]`.
@@ -2954,22 +2954,22 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 43_492_772_000 picoseconds.
-        Weight::from_parts(43_692_998_000, 0)
-            // Standard Error: 263_249
-            .saturating_add(Weight::from_parts(8_169_821, 0).saturating_mul(p.into()))
-            // Standard Error: 263_236
-            .saturating_add(Weight::from_parts(180_732_778, 0).saturating_mul(s.into()))
+        // Minimum execution time: 45_923_081_000 picoseconds.
+        Weight::from_parts(45_981_736_000, 0)
+            // Standard Error: 274_662
+            .saturating_add(Weight::from_parts(6_858_186, 0).saturating_mul(p.into()))
+            // Standard Error: 274_649
+            .saturating_add(Weight::from_parts(177_291_831, 0).saturating_mul(s.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_create_program_wgas(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 97_189_000 picoseconds.
-        Weight::from_parts(158_677_248, 0)
-            // Standard Error: 452_648
-            .saturating_add(Weight::from_parts(478_043_506, 0).saturating_mul(r.into()))
+        // Minimum execution time: 95_680_000 picoseconds.
+        Weight::from_parts(157_350_147, 0)
+            // Standard Error: 440_994
+            .saturating_add(Weight::from_parts(402_511_567, 0).saturating_mul(r.into()))
     }
     /// The range of component `p` is `[0, 2048]`.
     /// The range of component `s` is `[1, 2048]`.
@@ -2977,32 +2977,32 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 43_613_488_000 picoseconds.
-        Weight::from_parts(43_758_304_000, 0)
-            // Standard Error: 268_412
-            .saturating_add(Weight::from_parts(7_987_894, 0).saturating_mul(p.into()))
-            // Standard Error: 268_399
-            .saturating_add(Weight::from_parts(180_769_004, 0).saturating_mul(s.into()))
+        // Minimum execution time: 42_842_395_000 picoseconds.
+        Weight::from_parts(42_890_931_000, 0)
+            // Standard Error: 264_187
+            .saturating_add(Weight::from_parts(7_896_879, 0).saturating_mul(p.into()))
+            // Standard Error: 264_174
+            .saturating_add(Weight::from_parts(178_082_248, 0).saturating_mul(s.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_pay_program_rent(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 84_210_000 picoseconds.
-        Weight::from_parts(99_996_695, 0)
-            // Standard Error: 31_808
-            .saturating_add(Weight::from_parts(3_523_987, 0).saturating_mul(r.into()))
+        // Minimum execution time: 82_272_000 picoseconds.
+        Weight::from_parts(100_008_395, 0)
+            // Standard Error: 36_430
+            .saturating_add(Weight::from_parts(2_544_223, 0).saturating_mul(r.into()))
     }
     /// The range of component `p` is `[0, 512]`.
     fn lazy_pages_signal_read(p: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `141`
         //  Estimated: `1131 + p * (9900 ±0)`
-        // Minimum execution time: 82_940_000 picoseconds.
-        Weight::from_parts(123_540_441, 1131)
-            // Standard Error: 7_143
-            .saturating_add(Weight::from_parts(11_789_871, 0).saturating_mul(p.into()))
+        // Minimum execution time: 83_139_000 picoseconds.
+        Weight::from_parts(122_967_835, 1131)
+            // Standard Error: 6_454
+            .saturating_add(Weight::from_parts(11_784_103, 0).saturating_mul(p.into()))
             .saturating_add(RocksDbWeight::get().reads((4_u64).saturating_mul(p.into())))
             .saturating_add(Weight::from_parts(0, 9900).saturating_mul(p.into()))
     }
@@ -3011,10 +3011,10 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `141`
         //  Estimated: `1131 + p * (9900 ±0)`
-        // Minimum execution time: 83_752_000 picoseconds.
-        Weight::from_parts(84_858_000, 1131)
-            // Standard Error: 48_161
-            .saturating_add(Weight::from_parts(36_181_117, 0).saturating_mul(p.into()))
+        // Minimum execution time: 83_229_000 picoseconds.
+        Weight::from_parts(83_885_000, 1131)
+            // Standard Error: 37_558
+            .saturating_add(Weight::from_parts(35_503_677, 0).saturating_mul(p.into()))
             .saturating_add(RocksDbWeight::get().reads((4_u64).saturating_mul(p.into())))
             .saturating_add(Weight::from_parts(0, 9900).saturating_mul(p.into()))
     }
@@ -3023,10 +3023,10 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `141`
         //  Estimated: `5069931`
-        // Minimum execution time: 6_125_138_000 picoseconds.
-        Weight::from_parts(5_869_525_563, 5069931)
-            // Standard Error: 46_521
-            .saturating_add(Weight::from_parts(36_899_111, 0).saturating_mul(p.into()))
+        // Minimum execution time: 6_139_187_000 picoseconds.
+        Weight::from_parts(5_806_599_304, 5069931)
+            // Standard Error: 75_881
+            .saturating_add(Weight::from_parts(36_513_688, 0).saturating_mul(p.into()))
             .saturating_add(RocksDbWeight::get().reads(2048_u64))
     }
     /// The range of component `p` is `[0, 512]`.
@@ -3034,10 +3034,10 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `1813 + p * (65580 ±0)`
         //  Estimated: `1939 + p * (75482 ±0)`
-        // Minimum execution time: 82_516_000 picoseconds.
-        Weight::from_parts(83_470_000, 1939)
-            // Standard Error: 29_769
-            .saturating_add(Weight::from_parts(46_665_657, 0).saturating_mul(p.into()))
+        // Minimum execution time: 82_177_000 picoseconds.
+        Weight::from_parts(83_595_000, 1939)
+            // Standard Error: 45_778
+            .saturating_add(Weight::from_parts(47_155_630, 0).saturating_mul(p.into()))
             .saturating_add(RocksDbWeight::get().reads((4_u64).saturating_mul(p.into())))
             .saturating_add(Weight::from_parts(0, 75482).saturating_mul(p.into()))
     }
@@ -3046,10 +3046,10 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `141`
         //  Estimated: `1131 + p * (9900 ±0)`
-        // Minimum execution time: 87_344_000 picoseconds.
-        Weight::from_parts(94_873_151, 1131)
-            // Standard Error: 55_429
-            .saturating_add(Weight::from_parts(35_724_871, 0).saturating_mul(p.into()))
+        // Minimum execution time: 90_231_000 picoseconds.
+        Weight::from_parts(95_944_378, 1131)
+            // Standard Error: 61_821
+            .saturating_add(Weight::from_parts(35_941_066, 0).saturating_mul(p.into()))
             .saturating_add(RocksDbWeight::get().reads((4_u64).saturating_mul(p.into())))
             .saturating_add(Weight::from_parts(0, 9900).saturating_mul(p.into()))
     }
@@ -3058,10 +3058,10 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `141`
         //  Estimated: `1496 + p * (9883 ±2)`
-        // Minimum execution time: 735_393_000 picoseconds.
-        Weight::from_parts(754_062_397, 1496)
-            // Standard Error: 166_437
-            .saturating_add(Weight::from_parts(43_966_900, 0).saturating_mul(p.into()))
+        // Minimum execution time: 734_006_000 picoseconds.
+        Weight::from_parts(717_384_508, 1496)
+            // Standard Error: 375_292
+            .saturating_add(Weight::from_parts(47_930_581, 0).saturating_mul(p.into()))
             .saturating_add(RocksDbWeight::get().reads((4_u64).saturating_mul(p.into())))
             .saturating_add(Weight::from_parts(0, 9883).saturating_mul(p.into()))
     }
@@ -3070,10 +3070,10 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `141`
         //  Estimated: `317931`
-        // Minimum execution time: 1_124_371_000 picoseconds.
-        Weight::from_parts(1_147_901_415, 317931)
-            // Standard Error: 145_342
-            .saturating_add(Weight::from_parts(43_795_511, 0).saturating_mul(p.into()))
+        // Minimum execution time: 1_121_849_000 picoseconds.
+        Weight::from_parts(1_147_558_033, 317931)
+            // Standard Error: 373_146
+            .saturating_add(Weight::from_parts(45_393_418, 0).saturating_mul(p.into()))
             .saturating_add(RocksDbWeight::get().reads(128_u64))
     }
     /// The range of component `r` is `[0, 20]`.
@@ -3081,884 +3081,884 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 1_510_000 picoseconds.
-        Weight::from_parts(1_448_006, 0)
-            // Standard Error: 9_868
-            .saturating_add(Weight::from_parts(24_061_691, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_162_000 picoseconds.
+        Weight::from_parts(2_220_392, 0)
+            // Standard Error: 8_848
+            .saturating_add(Weight::from_parts(24_205_605, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[50, 500]`.
     fn instr_i64load(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 4_337_991_000 picoseconds.
-        Weight::from_parts(4_151_991_287, 0)
-            // Standard Error: 60_683
-            .saturating_add(Weight::from_parts(4_818_799, 0).saturating_mul(r.into()))
+        // Minimum execution time: 4_352_664_000 picoseconds.
+        Weight::from_parts(4_153_366_897, 0)
+            // Standard Error: 60_193
+            .saturating_add(Weight::from_parts(4_722_164, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[50, 500]`.
     fn instr_i32load(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 4_341_162_000 picoseconds.
-        Weight::from_parts(4_200_807_294, 0)
-            // Standard Error: 51_442
-            .saturating_add(Weight::from_parts(4_527_839, 0).saturating_mul(r.into()))
+        // Minimum execution time: 4_357_649_000 picoseconds.
+        Weight::from_parts(4_256_499_798, 0)
+            // Standard Error: 57_942
+            .saturating_add(Weight::from_parts(4_200_870, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[50, 500]`.
     fn instr_i64store(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 10_322_767_000 picoseconds.
-        Weight::from_parts(11_038_976_057, 0)
-            // Standard Error: 150_113
-            .saturating_add(Weight::from_parts(10_655_640, 0).saturating_mul(r.into()))
+        // Minimum execution time: 10_269_998_000 picoseconds.
+        Weight::from_parts(11_525_100_351, 0)
+            // Standard Error: 204_230
+            .saturating_add(Weight::from_parts(8_423_588, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[50, 500]`.
     fn instr_i32store(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 10_367_826_000 picoseconds.
-        Weight::from_parts(11_310_983_745, 0)
-            // Standard Error: 145_202
-            .saturating_add(Weight::from_parts(7_541_832, 0).saturating_mul(r.into()))
+        // Minimum execution time: 10_204_810_000 picoseconds.
+        Weight::from_parts(10_982_673_143, 0)
+            // Standard Error: 145_327
+            .saturating_add(Weight::from_parts(9_198_033, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_select(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_251_000 picoseconds.
-        Weight::from_parts(2_304_000, 0)
-            // Standard Error: 8_520
-            .saturating_add(Weight::from_parts(3_798_413, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_074_000 picoseconds.
+        Weight::from_parts(2_108_000, 0)
+            // Standard Error: 9_031
+            .saturating_add(Weight::from_parts(3_829_182, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_if(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_168_000 picoseconds.
-        Weight::from_parts(573_722, 0)
-            // Standard Error: 11_642
-            .saturating_add(Weight::from_parts(3_174_691, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_020_000 picoseconds.
+        Weight::from_parts(2_118_000, 0)
+            // Standard Error: 5_295
+            .saturating_add(Weight::from_parts(2_980_329, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_br(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_227_000 picoseconds.
-        Weight::from_parts(3_155_512, 0)
-            // Standard Error: 1_212
-            .saturating_add(Weight::from_parts(1_586_585, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_032_000 picoseconds.
+        Weight::from_parts(3_411_359, 0)
+            // Standard Error: 1_146
+            .saturating_add(Weight::from_parts(1_563_906, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_br_if(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_160_000 picoseconds.
-        Weight::from_parts(2_219_000, 0)
-            // Standard Error: 8_627
-            .saturating_add(Weight::from_parts(2_929_529, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_096_000 picoseconds.
+        Weight::from_parts(2_140_000, 0)
+            // Standard Error: 8_349
+            .saturating_add(Weight::from_parts(2_904_673, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_br_table(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_227_000 picoseconds.
-        Weight::from_parts(1_609_241, 0)
-            // Standard Error: 19_812
-            .saturating_add(Weight::from_parts(5_162_833, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_128_000 picoseconds.
+        Weight::from_parts(2_159_000, 0)
+            // Standard Error: 8_100
+            .saturating_add(Weight::from_parts(5_229_400, 0).saturating_mul(r.into()))
     }
     /// The range of component `e` is `[1, 256]`.
     fn instr_br_table_per_entry(e: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 6_892_000 picoseconds.
-        Weight::from_parts(5_316_811, 0)
-            // Standard Error: 1_578
-            .saturating_add(Weight::from_parts(163_377, 0).saturating_mul(e.into()))
+        // Minimum execution time: 6_838_000 picoseconds.
+        Weight::from_parts(5_309_346, 0)
+            // Standard Error: 2_580
+            .saturating_add(Weight::from_parts(129_982, 0).saturating_mul(e.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_call_const(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_304_000 picoseconds.
-        Weight::from_parts(4_554_683, 0)
-            // Standard Error: 7_319
-            .saturating_add(Weight::from_parts(2_595_958, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_100_000 picoseconds.
+        Weight::from_parts(3_593_285, 0)
+            // Standard Error: 6_648
+            .saturating_add(Weight::from_parts(2_597_926, 0).saturating_mul(r.into()))
     }
     fn instr_i64const(r: u32, ) -> Weight {
         Weight::from_parts(0, 0)
-            .saturating_add(Weight::from_parts(2_595_958 -
-            2_422_191, 0).saturating_mul(r.into()))
+            .saturating_add(Weight::from_parts(2_597_926 -
+            2_429_048, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_call(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_273_000 picoseconds.
-        Weight::from_parts(5_046_075, 0)
-            // Standard Error: 13_702
-            .saturating_add(Weight::from_parts(2_422_191, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_086_000 picoseconds.
+        Weight::from_parts(3_972_773, 0)
+            // Standard Error: 12_538
+            .saturating_add(Weight::from_parts(2_429_048, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_call_indirect(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_684_000 picoseconds.
-        Weight::from_parts(17_324_871, 0)
-            // Standard Error: 38_532
-            .saturating_add(Weight::from_parts(10_260_872, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_591_000 picoseconds.
+        Weight::from_parts(12_798_134, 0)
+            // Standard Error: 23_023
+            .saturating_add(Weight::from_parts(9_786_464, 0).saturating_mul(r.into()))
     }
     /// The range of component `p` is `[0, 128]`.
     fn instr_call_indirect_per_param(p: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 12_206_000 picoseconds.
-        Weight::from_parts(2_634_425, 0)
-            // Standard Error: 5_954
-            .saturating_add(Weight::from_parts(1_275_538, 0).saturating_mul(p.into()))
+        // Minimum execution time: 12_274_000 picoseconds.
+        Weight::from_parts(1_706_188, 0)
+            // Standard Error: 6_199
+            .saturating_add(Weight::from_parts(1_212_443, 0).saturating_mul(p.into()))
     }
     /// The range of component `l` is `[0, 1024]`.
     fn instr_call_per_local(l: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 5_288_000 picoseconds.
-        Weight::from_parts(5_570_870, 0)
+        // Minimum execution time: 5_221_000 picoseconds.
+        Weight::from_parts(5_538_574, 0)
             // Standard Error: 12
-            .saturating_add(Weight::from_parts(61, 0).saturating_mul(l.into()))
+            .saturating_add(Weight::from_parts(12, 0).saturating_mul(l.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_local_get(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_203_000 picoseconds.
-        Weight::from_parts(1_788_159, 0)
-            // Standard Error: 3_152
-            .saturating_add(Weight::from_parts(267_842, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_100_000 picoseconds.
+        Weight::from_parts(1_785_103, 0)
+            // Standard Error: 2_948
+            .saturating_add(Weight::from_parts(249_981, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_local_set(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_164_000 picoseconds.
-        Weight::from_parts(2_223_000, 0)
-            // Standard Error: 4_611
-            .saturating_add(Weight::from_parts(721_127, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_123_000 picoseconds.
+        Weight::from_parts(2_187_000, 0)
+            // Standard Error: 5_664
+            .saturating_add(Weight::from_parts(719_187, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_local_tee(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_252_000 picoseconds.
-        Weight::from_parts(2_347_000, 0)
-            // Standard Error: 5_971
-            .saturating_add(Weight::from_parts(742_209, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_137_000 picoseconds.
+        Weight::from_parts(2_214_000, 0)
+            // Standard Error: 5_625
+            .saturating_add(Weight::from_parts(709_067, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_global_get(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 6_406_000 picoseconds.
-        Weight::from_parts(2_894_577, 0)
-            // Standard Error: 8_027
-            .saturating_add(Weight::from_parts(801_493, 0).saturating_mul(r.into()))
+        // Minimum execution time: 6_168_000 picoseconds.
+        Weight::from_parts(2_290_203, 0)
+            // Standard Error: 8_984
+            .saturating_add(Weight::from_parts(761_843, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_global_set(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 6_345_000 picoseconds.
-        Weight::from_parts(31_295, 0)
-            // Standard Error: 10_231
-            .saturating_add(Weight::from_parts(1_543_569, 0).saturating_mul(r.into()))
+        // Minimum execution time: 6_249_000 picoseconds.
+        Weight::from_parts(6_302_000, 0)
+            // Standard Error: 8_682
+            .saturating_add(Weight::from_parts(1_329_653, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_memory_current(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 3_937_000 picoseconds.
-        Weight::from_parts(62_049, 0)
-            // Standard Error: 12_087
-            .saturating_add(Weight::from_parts(7_172_920, 0).saturating_mul(r.into()))
+        // Minimum execution time: 3_791_000 picoseconds.
+        Weight::from_parts(3_929_000, 0)
+            // Standard Error: 9_270
+            .saturating_add(Weight::from_parts(6_742_685, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64clz(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_262_000 picoseconds.
-        Weight::from_parts(2_306_000, 0)
-            // Standard Error: 6_042
-            .saturating_add(Weight::from_parts(3_394_526, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_113_000 picoseconds.
+        Weight::from_parts(2_192_000, 0)
+            // Standard Error: 6_734
+            .saturating_add(Weight::from_parts(3_327_207, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32clz(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_151_000 picoseconds.
-        Weight::from_parts(2_260_000, 0)
-            // Standard Error: 5_891
-            .saturating_add(Weight::from_parts(3_138_523, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_095_000 picoseconds.
+        Weight::from_parts(2_141_000, 0)
+            // Standard Error: 6_506
+            .saturating_add(Weight::from_parts(3_061_891, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64ctz(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_218_000 picoseconds.
-        Weight::from_parts(2_277_000, 0)
-            // Standard Error: 8_196
-            .saturating_add(Weight::from_parts(3_167_033, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_108_000 picoseconds.
+        Weight::from_parts(2_141_000, 0)
+            // Standard Error: 6_738
+            .saturating_add(Weight::from_parts(3_101_844, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32ctz(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_246_000 picoseconds.
-        Weight::from_parts(2_289_000, 0)
-            // Standard Error: 5_536
-            .saturating_add(Weight::from_parts(2_668_164, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_138_000 picoseconds.
+        Weight::from_parts(2_155_000, 0)
+            // Standard Error: 4_379
+            .saturating_add(Weight::from_parts(2_613_794, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64popcnt(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_259_000 picoseconds.
-        Weight::from_parts(45_432, 0)
-            // Standard Error: 6_223
-            .saturating_add(Weight::from_parts(645_076, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_046_000 picoseconds.
+        Weight::from_parts(2_127_000, 0)
+            // Standard Error: 3_513
+            .saturating_add(Weight::from_parts(525_212, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32popcnt(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_168_000 picoseconds.
-        Weight::from_parts(1_301_007, 0)
-            // Standard Error: 4_929
-            .saturating_add(Weight::from_parts(446_280, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_127_000 picoseconds.
+        Weight::from_parts(1_669_179, 0)
+            // Standard Error: 2_817
+            .saturating_add(Weight::from_parts(367_599, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64eqz(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_130_000 picoseconds.
-        Weight::from_parts(2_205_000, 0)
-            // Standard Error: 10_412
-            .saturating_add(Weight::from_parts(1_894_722, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_131_000 picoseconds.
+        Weight::from_parts(2_169_000, 0)
+            // Standard Error: 11_816
+            .saturating_add(Weight::from_parts(1_810_781, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32eqz(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_170_000 picoseconds.
-        Weight::from_parts(2_257_000, 0)
-            // Standard Error: 7_708
-            .saturating_add(Weight::from_parts(1_162_246, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_087_000 picoseconds.
+        Weight::from_parts(2_194_000, 0)
+            // Standard Error: 7_361
+            .saturating_add(Weight::from_parts(1_130_773, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32extend8s(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_153_000 picoseconds.
-        Weight::from_parts(1_682_106, 0)
-            // Standard Error: 3_839
-            .saturating_add(Weight::from_parts(384_381, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_061_000 picoseconds.
+        Weight::from_parts(1_850_477, 0)
+            // Standard Error: 2_695
+            .saturating_add(Weight::from_parts(318_827, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32extend16s(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_162_000 picoseconds.
-        Weight::from_parts(1_669_708, 0)
-            // Standard Error: 3_126
-            .saturating_add(Weight::from_parts(384_474, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_115_000 picoseconds.
+        Weight::from_parts(1_764_589, 0)
+            // Standard Error: 2_923
+            .saturating_add(Weight::from_parts(329_840, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64extend8s(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_249_000 picoseconds.
-        Weight::from_parts(2_291_000, 0)
-            // Standard Error: 4_476
-            .saturating_add(Weight::from_parts(497_277, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_109_000 picoseconds.
+        Weight::from_parts(859_995, 0)
+            // Standard Error: 4_546
+            .saturating_add(Weight::from_parts(467_944, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64extend16s(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_217_000 picoseconds.
-        Weight::from_parts(2_287_000, 0)
-            // Standard Error: 4_107
-            .saturating_add(Weight::from_parts(524_095, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_010_000 picoseconds.
+        Weight::from_parts(2_081_000, 0)
+            // Standard Error: 3_959
+            .saturating_add(Weight::from_parts(472_947, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64extend32s(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_163_000 picoseconds.
-        Weight::from_parts(2_233_000, 0)
-            // Standard Error: 3_690
-            .saturating_add(Weight::from_parts(501_277, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_105_000 picoseconds.
+        Weight::from_parts(1_247_124, 0)
+            // Standard Error: 4_390
+            .saturating_add(Weight::from_parts(436_907, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64extendsi32(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_132_000 picoseconds.
-        Weight::from_parts(1_082_506, 0)
-            // Standard Error: 5_421
-            .saturating_add(Weight::from_parts(400_448, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_140_000 picoseconds.
+        Weight::from_parts(2_251_532, 0)
+            // Standard Error: 2_995
+            .saturating_add(Weight::from_parts(280_490, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64extendui32(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_211_000 picoseconds.
-        Weight::from_parts(3_085_764, 0)
-            // Standard Error: 1_912
-            .saturating_add(Weight::from_parts(162_384, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_119_000 picoseconds.
+        Weight::from_parts(2_808_547, 0)
+            // Standard Error: 1_453
+            .saturating_add(Weight::from_parts(143_409, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32wrapi64(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_161_000 picoseconds.
-        Weight::from_parts(2_849_158, 0)
-            // Standard Error: 1_635
-            .saturating_add(Weight::from_parts(153_763, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_043_000 picoseconds.
+        Weight::from_parts(2_639_820, 0)
+            // Standard Error: 1_638
+            .saturating_add(Weight::from_parts(159_792, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64eq(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_279_000 picoseconds.
-        Weight::from_parts(2_315_000, 0)
-            // Standard Error: 11_776
-            .saturating_add(Weight::from_parts(1_779_477, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_128_000 picoseconds.
+        Weight::from_parts(2_166_000, 0)
+            // Standard Error: 11_777
+            .saturating_add(Weight::from_parts(1_709_510, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32eq(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_272_000 picoseconds.
-        Weight::from_parts(2_342_000, 0)
-            // Standard Error: 8_815
-            .saturating_add(Weight::from_parts(1_197_093, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_100_000 picoseconds.
+        Weight::from_parts(2_136_000, 0)
+            // Standard Error: 7_491
+            .saturating_add(Weight::from_parts(1_105_807, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64ne(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_190_000 picoseconds.
-        Weight::from_parts(2_258_000, 0)
-            // Standard Error: 9_983
-            .saturating_add(Weight::from_parts(1_838_257, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_088_000 picoseconds.
+        Weight::from_parts(2_171_000, 0)
+            // Standard Error: 11_841
+            .saturating_add(Weight::from_parts(1_785_140, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32ne(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_227_000 picoseconds.
-        Weight::from_parts(2_276_000, 0)
-            // Standard Error: 7_749
-            .saturating_add(Weight::from_parts(1_165_862, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_042_000 picoseconds.
+        Weight::from_parts(2_181_000, 0)
+            // Standard Error: 7_479
+            .saturating_add(Weight::from_parts(1_086_144, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64lts(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_172_000 picoseconds.
-        Weight::from_parts(2_246_000, 0)
-            // Standard Error: 11_426
-            .saturating_add(Weight::from_parts(1_828_814, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_109_000 picoseconds.
+        Weight::from_parts(2_151_000, 0)
+            // Standard Error: 13_111
+            .saturating_add(Weight::from_parts(1_829_000, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32lts(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_187_000 picoseconds.
-        Weight::from_parts(2_245_000, 0)
-            // Standard Error: 7_973
-            .saturating_add(Weight::from_parts(1_145_613, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_130_000 picoseconds.
+        Weight::from_parts(2_153_000, 0)
+            // Standard Error: 7_632
+            .saturating_add(Weight::from_parts(1_102_522, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64ltu(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_247_000 picoseconds.
-        Weight::from_parts(2_273_000, 0)
-            // Standard Error: 10_995
-            .saturating_add(Weight::from_parts(1_789_814, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_155_000 picoseconds.
+        Weight::from_parts(2_231_000, 0)
+            // Standard Error: 11_689
+            .saturating_add(Weight::from_parts(1_768_866, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32ltu(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_162_000 picoseconds.
-        Weight::from_parts(2_252_000, 0)
-            // Standard Error: 7_454
-            .saturating_add(Weight::from_parts(1_207_539, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_094_000 picoseconds.
+        Weight::from_parts(2_163_000, 0)
+            // Standard Error: 7_348
+            .saturating_add(Weight::from_parts(1_057_058, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64gts(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_219_000 picoseconds.
-        Weight::from_parts(2_279_000, 0)
-            // Standard Error: 10_576
-            .saturating_add(Weight::from_parts(1_855_075, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_095_000 picoseconds.
+        Weight::from_parts(2_142_000, 0)
+            // Standard Error: 12_173
+            .saturating_add(Weight::from_parts(1_786_184, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32gts(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_199_000 picoseconds.
-        Weight::from_parts(2_265_000, 0)
-            // Standard Error: 7_405
-            .saturating_add(Weight::from_parts(1_180_265, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_122_000 picoseconds.
+        Weight::from_parts(2_206_000, 0)
+            // Standard Error: 7_244
+            .saturating_add(Weight::from_parts(1_066_057, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64gtu(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_245_000 picoseconds.
-        Weight::from_parts(2_285_000, 0)
-            // Standard Error: 10_994
-            .saturating_add(Weight::from_parts(1_835_344, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_090_000 picoseconds.
+        Weight::from_parts(2_175_000, 0)
+            // Standard Error: 11_967
+            .saturating_add(Weight::from_parts(1_782_809, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32gtu(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_222_000 picoseconds.
-        Weight::from_parts(2_277_000, 0)
-            // Standard Error: 7_826
-            .saturating_add(Weight::from_parts(1_163_748, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_091_000 picoseconds.
+        Weight::from_parts(2_169_000, 0)
+            // Standard Error: 7_205
+            .saturating_add(Weight::from_parts(1_048_140, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64les(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_102_000 picoseconds.
-        Weight::from_parts(2_217_000, 0)
-            // Standard Error: 11_374
-            .saturating_add(Weight::from_parts(1_910_004, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_164_000 picoseconds.
+        Weight::from_parts(2_198_000, 0)
+            // Standard Error: 12_228
+            .saturating_add(Weight::from_parts(1_792_751, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32les(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_245_000 picoseconds.
-        Weight::from_parts(2_303_000, 0)
-            // Standard Error: 8_971
-            .saturating_add(Weight::from_parts(1_182_859, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_122_000 picoseconds.
+        Weight::from_parts(2_186_000, 0)
+            // Standard Error: 7_822
+            .saturating_add(Weight::from_parts(1_052_385, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64leu(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_230_000 picoseconds.
-        Weight::from_parts(2_284_000, 0)
-            // Standard Error: 12_177
-            .saturating_add(Weight::from_parts(1_866_465, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_055_000 picoseconds.
+        Weight::from_parts(2_135_000, 0)
+            // Standard Error: 12_011
+            .saturating_add(Weight::from_parts(1_789_504, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32leu(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_468_000 picoseconds.
-        Weight::from_parts(2_638_000, 0)
-            // Standard Error: 7_738
-            .saturating_add(Weight::from_parts(1_119_369, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_447_000 picoseconds.
+        Weight::from_parts(2_540_000, 0)
+            // Standard Error: 7_696
+            .saturating_add(Weight::from_parts(1_062_612, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64ges(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_191_000 picoseconds.
-        Weight::from_parts(2_286_000, 0)
-            // Standard Error: 10_340
-            .saturating_add(Weight::from_parts(1_831_738, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_077_000 picoseconds.
+        Weight::from_parts(2_107_000, 0)
+            // Standard Error: 12_070
+            .saturating_add(Weight::from_parts(1_771_498, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32ges(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_216_000 picoseconds.
-        Weight::from_parts(2_260_000, 0)
-            // Standard Error: 6_924
-            .saturating_add(Weight::from_parts(1_210_933, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_123_000 picoseconds.
+        Weight::from_parts(2_156_000, 0)
+            // Standard Error: 7_108
+            .saturating_add(Weight::from_parts(1_072_471, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64geu(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_202_000 picoseconds.
-        Weight::from_parts(2_325_000, 0)
-            // Standard Error: 9_907
-            .saturating_add(Weight::from_parts(1_822_715, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_038_000 picoseconds.
+        Weight::from_parts(2_145_000, 0)
+            // Standard Error: 11_990
+            .saturating_add(Weight::from_parts(1_786_273, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32geu(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_230_000 picoseconds.
-        Weight::from_parts(2_294_000, 0)
-            // Standard Error: 7_927
-            .saturating_add(Weight::from_parts(1_168_287, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_059_000 picoseconds.
+        Weight::from_parts(2_122_000, 0)
+            // Standard Error: 7_164
+            .saturating_add(Weight::from_parts(1_070_909, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64add(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_189_000 picoseconds.
-        Weight::from_parts(2_289_000, 0)
-            // Standard Error: 8_768
-            .saturating_add(Weight::from_parts(1_295_617, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_065_000 picoseconds.
+        Weight::from_parts(2_181_000, 0)
+            // Standard Error: 7_265
+            .saturating_add(Weight::from_parts(1_152_228, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32add(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_193_000 picoseconds.
-        Weight::from_parts(2_292_000, 0)
-            // Standard Error: 6_314
-            .saturating_add(Weight::from_parts(658_832, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_107_000 picoseconds.
+        Weight::from_parts(2_160_000, 0)
+            // Standard Error: 5_101
+            .saturating_add(Weight::from_parts(578_660, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64sub(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_258_000 picoseconds.
-        Weight::from_parts(2_312_000, 0)
-            // Standard Error: 9_261
-            .saturating_add(Weight::from_parts(1_348_699, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_130_000 picoseconds.
+        Weight::from_parts(2_184_000, 0)
+            // Standard Error: 9_299
+            .saturating_add(Weight::from_parts(1_257_633, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32sub(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_257_000 picoseconds.
-        Weight::from_parts(2_290_000, 0)
-            // Standard Error: 5_457
-            .saturating_add(Weight::from_parts(671_846, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_119_000 picoseconds.
+        Weight::from_parts(2_262_000, 0)
+            // Standard Error: 3_957
+            .saturating_add(Weight::from_parts(557_957, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64mul(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_180_000 picoseconds.
-        Weight::from_parts(2_241_000, 0)
-            // Standard Error: 11_567
-            .saturating_add(Weight::from_parts(1_835_171, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_045_000 picoseconds.
+        Weight::from_parts(2_157_000, 0)
+            // Standard Error: 10_839
+            .saturating_add(Weight::from_parts(1_686_809, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32mul(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_196_000 picoseconds.
-        Weight::from_parts(2_290_000, 0)
-            // Standard Error: 7_436
-            .saturating_add(Weight::from_parts(1_171_019, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_232_000 picoseconds.
+        Weight::from_parts(2_250_000, 0)
+            // Standard Error: 7_276
+            .saturating_add(Weight::from_parts(1_096_252, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64divs(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_195_000 picoseconds.
-        Weight::from_parts(6_299_544, 0)
-            // Standard Error: 28_028
-            .saturating_add(Weight::from_parts(2_500_140, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_107_000 picoseconds.
+        Weight::from_parts(1_434_170, 0)
+            // Standard Error: 21_965
+            .saturating_add(Weight::from_parts(2_633_663, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32divs(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_249_000 picoseconds.
-        Weight::from_parts(2_576_178, 0)
-            // Standard Error: 12_042
-            .saturating_add(Weight::from_parts(2_335_953, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_098_000 picoseconds.
+        Weight::from_parts(2_122_681, 0)
+            // Standard Error: 10_815
+            .saturating_add(Weight::from_parts(2_335_842, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64divu(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_223_000 picoseconds.
-        Weight::from_parts(8_638_891, 0)
-            // Standard Error: 32_649
-            .saturating_add(Weight::from_parts(2_462_794, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_153_000 picoseconds.
+        Weight::from_parts(145_632, 0)
+            // Standard Error: 12_320
+            .saturating_add(Weight::from_parts(2_992_427, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32divu(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_231_000 picoseconds.
-        Weight::from_parts(2_731_170, 0)
-            // Standard Error: 19_116
-            .saturating_add(Weight::from_parts(2_437_473, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_142_000 picoseconds.
+        Weight::from_parts(2_180_000, 0)
+            // Standard Error: 4_944
+            .saturating_add(Weight::from_parts(2_466_854, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64rems(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_261_000 picoseconds.
-        Weight::from_parts(1_535_146, 0)
-            // Standard Error: 30_575
-            .saturating_add(Weight::from_parts(9_634_377, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_143_000 picoseconds.
+        Weight::from_parts(2_204_000, 0)
+            // Standard Error: 14_500
+            .saturating_add(Weight::from_parts(9_530_241, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32rems(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_209_000 picoseconds.
-        Weight::from_parts(5_244_298, 0)
-            // Standard Error: 48_615
-            .saturating_add(Weight::from_parts(7_381_672, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_132_000 picoseconds.
+        Weight::from_parts(2_183_000, 0)
+            // Standard Error: 22_303
+            .saturating_add(Weight::from_parts(7_508_848, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64remu(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_260_000 picoseconds.
-        Weight::from_parts(8_453_159, 0)
-            // Standard Error: 30_530
-            .saturating_add(Weight::from_parts(2_541_459, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_133_000 picoseconds.
+        Weight::from_parts(2_183_000, 0)
+            // Standard Error: 5_407
+            .saturating_add(Weight::from_parts(2_948_013, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32remu(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_242_000 picoseconds.
-        Weight::from_parts(5_507_917, 0)
-            // Standard Error: 21_457
-            .saturating_add(Weight::from_parts(2_217_886, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_124_000 picoseconds.
+        Weight::from_parts(2_150_000, 0)
+            // Standard Error: 6_372
+            .saturating_add(Weight::from_parts(2_362_416, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64and(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_163_000 picoseconds.
-        Weight::from_parts(2_341_000, 0)
-            // Standard Error: 9_253
-            .saturating_add(Weight::from_parts(1_354_282, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_174_000 picoseconds.
+        Weight::from_parts(2_219_000, 0)
+            // Standard Error: 7_670
+            .saturating_add(Weight::from_parts(1_174_342, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32and(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_170_000 picoseconds.
-        Weight::from_parts(2_224_000, 0)
-            // Standard Error: 3_908
-            .saturating_add(Weight::from_parts(589_876, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_094_000 picoseconds.
+        Weight::from_parts(2_109_000, 0)
+            // Standard Error: 3_988
+            .saturating_add(Weight::from_parts(566_949, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64or(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_184_000 picoseconds.
-        Weight::from_parts(2_265_000, 0)
-            // Standard Error: 9_943
-            .saturating_add(Weight::from_parts(1_308_630, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_049_000 picoseconds.
+        Weight::from_parts(2_117_000, 0)
+            // Standard Error: 8_393
+            .saturating_add(Weight::from_parts(1_160_794, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32or(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_212_000 picoseconds.
-        Weight::from_parts(2_273_000, 0)
-            // Standard Error: 5_843
-            .saturating_add(Weight::from_parts(653_388, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_107_000 picoseconds.
+        Weight::from_parts(2_152_000, 0)
+            // Standard Error: 4_769
+            .saturating_add(Weight::from_parts(585_265, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64xor(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_228_000 picoseconds.
-        Weight::from_parts(2_293_000, 0)
-            // Standard Error: 9_157
-            .saturating_add(Weight::from_parts(1_290_731, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_115_000 picoseconds.
+        Weight::from_parts(2_170_000, 0)
+            // Standard Error: 7_943
+            .saturating_add(Weight::from_parts(1_185_174, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32xor(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_232_000 picoseconds.
-        Weight::from_parts(2_276_000, 0)
-            // Standard Error: 4_020
-            .saturating_add(Weight::from_parts(618_071, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_139_000 picoseconds.
+        Weight::from_parts(2_183_000, 0)
+            // Standard Error: 4_608
+            .saturating_add(Weight::from_parts(563_329, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64shl(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_239_000 picoseconds.
-        Weight::from_parts(2_292_000, 0)
-            // Standard Error: 7_192
-            .saturating_add(Weight::from_parts(1_061_312, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_144_000 picoseconds.
+        Weight::from_parts(2_178_000, 0)
+            // Standard Error: 6_727
+            .saturating_add(Weight::from_parts(1_000_757, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32shl(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_157_000 picoseconds.
-        Weight::from_parts(2_245_000, 0)
-            // Standard Error: 3_756
-            .saturating_add(Weight::from_parts(568_744, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_107_000 picoseconds.
+        Weight::from_parts(2_212_000, 0)
+            // Standard Error: 3_536
+            .saturating_add(Weight::from_parts(504_096, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64shrs(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_248_000 picoseconds.
-        Weight::from_parts(2_324_000, 0)
-            // Standard Error: 7_917
-            .saturating_add(Weight::from_parts(1_106_132, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_167_000 picoseconds.
+        Weight::from_parts(2_218_000, 0)
+            // Standard Error: 7_170
+            .saturating_add(Weight::from_parts(966_365, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32shrs(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_205_000 picoseconds.
-        Weight::from_parts(2_292_000, 0)
-            // Standard Error: 4_617
-            .saturating_add(Weight::from_parts(599_461, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_149_000 picoseconds.
+        Weight::from_parts(140_768, 0)
+            // Standard Error: 5_221
+            .saturating_add(Weight::from_parts(551_550, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64shru(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_215_000 picoseconds.
-        Weight::from_parts(2_346_000, 0)
-            // Standard Error: 7_501
-            .saturating_add(Weight::from_parts(1_125_645, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_122_000 picoseconds.
+        Weight::from_parts(2_159_000, 0)
+            // Standard Error: 7_621
+            .saturating_add(Weight::from_parts(997_420, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32shru(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_255_000 picoseconds.
-        Weight::from_parts(2_306_000, 0)
-            // Standard Error: 5_262
-            .saturating_add(Weight::from_parts(624_680, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_069_000 picoseconds.
+        Weight::from_parts(2_106_000, 0)
+            // Standard Error: 3_980
+            .saturating_add(Weight::from_parts(537_014, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64rotl(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_231_000 picoseconds.
-        Weight::from_parts(2_341_000, 0)
-            // Standard Error: 7_879
-            .saturating_add(Weight::from_parts(1_068_877, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_097_000 picoseconds.
+        Weight::from_parts(2_191_000, 0)
+            // Standard Error: 9_419
+            .saturating_add(Weight::from_parts(1_050_292, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32rotl(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_192_000 picoseconds.
-        Weight::from_parts(2_288_000, 0)
-            // Standard Error: 4_124
-            .saturating_add(Weight::from_parts(567_690, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_051_000 picoseconds.
+        Weight::from_parts(2_118_000, 0)
+            // Standard Error: 4_228
+            .saturating_add(Weight::from_parts(529_158, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64rotr(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_258_000 picoseconds.
-        Weight::from_parts(2_322_000, 0)
-            // Standard Error: 8_516
-            .saturating_add(Weight::from_parts(1_174_764, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_038_000 picoseconds.
+        Weight::from_parts(2_116_000, 0)
+            // Standard Error: 7_792
+            .saturating_add(Weight::from_parts(1_027_370, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32rotr(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_171_000 picoseconds.
-        Weight::from_parts(2_258_000, 0)
-            // Standard Error: 4_901
-            .saturating_add(Weight::from_parts(628_068, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_077_000 picoseconds.
+        Weight::from_parts(2_140_000, 0)
+            // Standard Error: 4_450
+            .saturating_add(Weight::from_parts(534_724, 0).saturating_mul(r.into()))
     }
 }
diff --git a/runtime-interface/src/gear_sandbox/detail.rs b/runtime-interface/src/gear_sandbox/detail.rs
index 33cd6697b87..da4a7933a92 100644
--- a/runtime-interface/src/gear_sandbox/detail.rs
+++ b/runtime-interface/src/gear_sandbox/detail.rs
@@ -19,7 +19,7 @@
 use core::cell::RefCell;
 
 use codec::{Decode, Encode};
-use gear_sandbox_host::sandbox as sandbox_env;
+use gear_sandbox_host::sandbox::{self as sandbox_env, env::Instantiate};
 use sp_wasm_interface::{
     util,
     wasmtime::{AsContext, AsContextMut, Func, Val},
@@ -232,6 +232,7 @@ pub fn instantiate(
     wasm_code: &[u8],
     raw_env_def: &[u8],
     state_ptr: Pointer<u8>,
+    version: Instantiate,
 ) -> u32 {
     let mut method_result = u32::MAX;
 
@@ -271,6 +272,7 @@ pub fn instantiate(
         let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
             SANDBOXES.with(|sandboxes| {
                 sandboxes.borrow_mut().get(store_data_key).instantiate(
+                    version,
                     wasm_code,
                     guest_env,
                     &mut SandboxContext {
diff --git a/runtime-interface/src/gear_sandbox/mod.rs b/runtime-interface/src/gear_sandbox/mod.rs
index c4abfaf080b..4a4148061e7 100644
--- a/runtime-interface/src/gear_sandbox/mod.rs
+++ b/runtime-interface/src/gear_sandbox/mod.rs
@@ -18,6 +18,8 @@
 
 //! Runtime interface for gear node
 
+#[cfg(feature = "std")]
+use gear_sandbox_host::sandbox::env::Instantiate;
 use sp_runtime_interface::{runtime_interface, Pointer};
 use sp_wasm_interface::HostPointer;
 
@@ -38,7 +40,33 @@ pub trait Sandbox {
         raw_env_def: &[u8],
         state_ptr: Pointer<u8>,
     ) -> u32 {
-        detail::instantiate(*self, dispatch_thunk_id, wasm_code, raw_env_def, state_ptr)
+        detail::instantiate(
+            *self,
+            dispatch_thunk_id,
+            wasm_code,
+            raw_env_def,
+            state_ptr,
+            Instantiate::Version1,
+        )
+    }
+
+    /// Instantiate a new sandbox instance with the given `wasm_code`.
+    #[version(2)]
+    fn instantiate(
+        &mut self,
+        dispatch_thunk_id: u32,
+        wasm_code: &[u8],
+        raw_env_def: &[u8],
+        state_ptr: Pointer<u8>,
+    ) -> u32 {
+        detail::instantiate(
+            *self,
+            dispatch_thunk_id,
+            wasm_code,
+            raw_env_def,
+            state_ptr,
+            Instantiate::Version2,
+        )
     }
 
     /// Invoke `function` in the sandbox with `sandbox_idx`.
diff --git a/runtime/gear/src/weights/frame_system.rs b/runtime/gear/src/weights/frame_system.rs
index 57bbef7223e..7c2e30e83c0 100644
--- a/runtime/gear/src/weights/frame_system.rs
+++ b/runtime/gear/src/weights/frame_system.rs
@@ -19,7 +19,7 @@
 //! Autogenerated weights for frame_system
 //!
 //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
-//! DATE: 2023-08-01, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! DATE: 2023-08-07, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
 //! WORST CASE MAP SIZE: `1000000`
 //! CPU: `Intel(R) Xeon(R) Platinum 8375C CPU @ 2.90GHz`
 //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("gear-dev"), DB CACHE: 1024
@@ -53,8 +53,8 @@ impl<T: frame_system::Config> frame_system::WeightInfo for SubstrateWeight<T> {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 1_652_000 picoseconds.
-        Weight::from_parts(1_044_833, 0)
+        // Minimum execution time: 1_580_000 picoseconds.
+        Weight::from_parts(959_849, 0)
             // Standard Error: 0
             .saturating_add(Weight::from_parts(460, 0).saturating_mul(b.into()))
     }
@@ -63,17 +63,17 @@ impl<T: frame_system::Config> frame_system::WeightInfo for SubstrateWeight<T> {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 6_078_000 picoseconds.
-        Weight::from_parts(6_338_000, 0)
+        // Minimum execution time: 6_178_000 picoseconds.
+        Weight::from_parts(6_296_000, 0)
             // Standard Error: 0
-            .saturating_add(Weight::from_parts(1_433, 0).saturating_mul(b.into()))
+            .saturating_add(Weight::from_parts(1_429, 0).saturating_mul(b.into()))
     }
     fn set_heap_pages() -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `1485`
-        // Minimum execution time: 3_023_000 picoseconds.
-        Weight::from_parts(3_268_000, 1485)
+        // Minimum execution time: 3_133_000 picoseconds.
+        Weight::from_parts(3_263_000, 1485)
             .saturating_add(T::DbWeight::get().reads(1_u64))
             .saturating_add(T::DbWeight::get().writes(2_u64))
     }
@@ -82,10 +82,10 @@ impl<T: frame_system::Config> frame_system::WeightInfo for SubstrateWeight<T> {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 1_662_000 picoseconds.
-        Weight::from_parts(1_751_000, 0)
-            // Standard Error: 965
-            .saturating_add(Weight::from_parts(690_953, 0).saturating_mul(i.into()))
+        // Minimum execution time: 1_505_000 picoseconds.
+        Weight::from_parts(1_600_000, 0)
+            // Standard Error: 1_014
+            .saturating_add(Weight::from_parts(700_338, 0).saturating_mul(i.into()))
             .saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(i.into())))
     }
     /// The range of component `i` is `[0, 1000]`.
@@ -93,10 +93,10 @@ impl<T: frame_system::Config> frame_system::WeightInfo for SubstrateWeight<T> {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 1_656_000 picoseconds.
-        Weight::from_parts(1_676_000, 0)
-            // Standard Error: 886
-            .saturating_add(Weight::from_parts(524_369, 0).saturating_mul(i.into()))
+        // Minimum execution time: 1_547_000 picoseconds.
+        Weight::from_parts(1_605_000, 0)
+            // Standard Error: 807
+            .saturating_add(Weight::from_parts(534_871, 0).saturating_mul(i.into()))
             .saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(i.into())))
     }
     /// The range of component `p` is `[0, 1000]`.
@@ -104,10 +104,10 @@ impl<T: frame_system::Config> frame_system::WeightInfo for SubstrateWeight<T> {
         // Proof Size summary in bytes:
         //  Measured:  `64 + p * (69 ±0)`
         //  Estimated: `66 + p * (70 ±0)`
-        // Minimum execution time: 3_381_000 picoseconds.
-        Weight::from_parts(3_523_000, 66)
-            // Standard Error: 1_488
-            .saturating_add(Weight::from_parts(1_108_252, 0).saturating_mul(p.into()))
+        // Minimum execution time: 3_117_000 picoseconds.
+        Weight::from_parts(3_239_000, 66)
+            // Standard Error: 1_390
+            .saturating_add(Weight::from_parts(1_127_503, 0).saturating_mul(p.into()))
             .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(p.into())))
             .saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(p.into())))
             .saturating_add(Weight::from_parts(0, 70).saturating_mul(p.into()))
@@ -121,8 +121,8 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 1_652_000 picoseconds.
-        Weight::from_parts(1_044_833, 0)
+        // Minimum execution time: 1_580_000 picoseconds.
+        Weight::from_parts(959_849, 0)
             // Standard Error: 0
             .saturating_add(Weight::from_parts(460, 0).saturating_mul(b.into()))
     }
@@ -131,17 +131,17 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 6_078_000 picoseconds.
-        Weight::from_parts(6_338_000, 0)
+        // Minimum execution time: 6_178_000 picoseconds.
+        Weight::from_parts(6_296_000, 0)
             // Standard Error: 0
-            .saturating_add(Weight::from_parts(1_433, 0).saturating_mul(b.into()))
+            .saturating_add(Weight::from_parts(1_429, 0).saturating_mul(b.into()))
     }
     fn set_heap_pages() -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `1485`
-        // Minimum execution time: 3_023_000 picoseconds.
-        Weight::from_parts(3_268_000, 1485)
+        // Minimum execution time: 3_133_000 picoseconds.
+        Weight::from_parts(3_263_000, 1485)
             .saturating_add(RocksDbWeight::get().reads(1_u64))
             .saturating_add(RocksDbWeight::get().writes(2_u64))
     }
@@ -150,10 +150,10 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 1_662_000 picoseconds.
-        Weight::from_parts(1_751_000, 0)
-            // Standard Error: 965
-            .saturating_add(Weight::from_parts(690_953, 0).saturating_mul(i.into()))
+        // Minimum execution time: 1_505_000 picoseconds.
+        Weight::from_parts(1_600_000, 0)
+            // Standard Error: 1_014
+            .saturating_add(Weight::from_parts(700_338, 0).saturating_mul(i.into()))
             .saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(i.into())))
     }
     /// The range of component `i` is `[0, 1000]`.
@@ -161,10 +161,10 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 1_656_000 picoseconds.
-        Weight::from_parts(1_676_000, 0)
-            // Standard Error: 886
-            .saturating_add(Weight::from_parts(524_369, 0).saturating_mul(i.into()))
+        // Minimum execution time: 1_547_000 picoseconds.
+        Weight::from_parts(1_605_000, 0)
+            // Standard Error: 807
+            .saturating_add(Weight::from_parts(534_871, 0).saturating_mul(i.into()))
             .saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(i.into())))
     }
     /// The range of component `p` is `[0, 1000]`.
@@ -172,10 +172,10 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `64 + p * (69 ±0)`
         //  Estimated: `66 + p * (70 ±0)`
-        // Minimum execution time: 3_381_000 picoseconds.
-        Weight::from_parts(3_523_000, 66)
-            // Standard Error: 1_488
-            .saturating_add(Weight::from_parts(1_108_252, 0).saturating_mul(p.into()))
+        // Minimum execution time: 3_117_000 picoseconds.
+        Weight::from_parts(3_239_000, 66)
+            // Standard Error: 1_390
+            .saturating_add(Weight::from_parts(1_127_503, 0).saturating_mul(p.into()))
             .saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(p.into())))
             .saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(p.into())))
             .saturating_add(Weight::from_parts(0, 70).saturating_mul(p.into()))
diff --git a/runtime/gear/src/weights/pallet_balances.rs b/runtime/gear/src/weights/pallet_balances.rs
index 8c7c2852b75..7ac58bc3721 100644
--- a/runtime/gear/src/weights/pallet_balances.rs
+++ b/runtime/gear/src/weights/pallet_balances.rs
@@ -19,7 +19,7 @@
 //! Autogenerated weights for pallet_balances
 //!
 //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
-//! DATE: 2023-08-01, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! DATE: 2023-08-07, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
 //! WORST CASE MAP SIZE: `1000000`
 //! CPU: `Intel(R) Xeon(R) Platinum 8375C CPU @ 2.90GHz`
 //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("gear-dev"), DB CACHE: 1024
@@ -53,8 +53,8 @@ impl<T: frame_system::Config> pallet_balances::WeightInfo for SubstrateWeight<T>
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `3593`
-        // Minimum execution time: 31_661_000 picoseconds.
-        Weight::from_parts(32_358_000, 3593)
+        // Minimum execution time: 29_782_000 picoseconds.
+        Weight::from_parts(30_295_000, 3593)
             .saturating_add(T::DbWeight::get().reads(1_u64))
             .saturating_add(T::DbWeight::get().writes(1_u64))
     }
@@ -62,8 +62,8 @@ impl<T: frame_system::Config> pallet_balances::WeightInfo for SubstrateWeight<T>
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `3593`
-        // Minimum execution time: 23_643_000 picoseconds.
-        Weight::from_parts(23_917_000, 3593)
+        // Minimum execution time: 21_396_000 picoseconds.
+        Weight::from_parts(21_806_000, 3593)
             .saturating_add(T::DbWeight::get().reads(1_u64))
             .saturating_add(T::DbWeight::get().writes(1_u64))
     }
@@ -71,8 +71,8 @@ impl<T: frame_system::Config> pallet_balances::WeightInfo for SubstrateWeight<T>
         // Proof Size summary in bytes:
         //  Measured:  `103`
         //  Estimated: `3593`
-        // Minimum execution time: 13_269_000 picoseconds.
-        Weight::from_parts(13_533_000, 3593)
+        // Minimum execution time: 12_457_000 picoseconds.
+        Weight::from_parts(12_779_000, 3593)
             .saturating_add(T::DbWeight::get().reads(1_u64))
             .saturating_add(T::DbWeight::get().writes(1_u64))
     }
@@ -80,8 +80,8 @@ impl<T: frame_system::Config> pallet_balances::WeightInfo for SubstrateWeight<T>
         // Proof Size summary in bytes:
         //  Measured:  `103`
         //  Estimated: `3593`
-        // Minimum execution time: 15_877_000 picoseconds.
-        Weight::from_parts(16_512_000, 3593)
+        // Minimum execution time: 15_473_000 picoseconds.
+        Weight::from_parts(15_990_000, 3593)
             .saturating_add(T::DbWeight::get().reads(1_u64))
             .saturating_add(T::DbWeight::get().writes(1_u64))
     }
@@ -89,8 +89,8 @@ impl<T: frame_system::Config> pallet_balances::WeightInfo for SubstrateWeight<T>
         // Proof Size summary in bytes:
         //  Measured:  `103`
         //  Estimated: `6196`
-        // Minimum execution time: 33_754_000 picoseconds.
-        Weight::from_parts(34_473_000, 6196)
+        // Minimum execution time: 31_071_000 picoseconds.
+        Weight::from_parts(31_836_000, 6196)
             .saturating_add(T::DbWeight::get().reads(2_u64))
             .saturating_add(T::DbWeight::get().writes(2_u64))
     }
@@ -98,8 +98,8 @@ impl<T: frame_system::Config> pallet_balances::WeightInfo for SubstrateWeight<T>
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `3593`
-        // Minimum execution time: 29_975_000 picoseconds.
-        Weight::from_parts(30_556_000, 3593)
+        // Minimum execution time: 27_464_000 picoseconds.
+        Weight::from_parts(28_112_000, 3593)
             .saturating_add(T::DbWeight::get().reads(1_u64))
             .saturating_add(T::DbWeight::get().writes(1_u64))
     }
@@ -107,8 +107,8 @@ impl<T: frame_system::Config> pallet_balances::WeightInfo for SubstrateWeight<T>
         // Proof Size summary in bytes:
         //  Measured:  `103`
         //  Estimated: `3593`
-        // Minimum execution time: 12_611_000 picoseconds.
-        Weight::from_parts(13_043_000, 3593)
+        // Minimum execution time: 11_587_000 picoseconds.
+        Weight::from_parts(12_013_000, 3593)
             .saturating_add(T::DbWeight::get().reads(1_u64))
             .saturating_add(T::DbWeight::get().writes(1_u64))
     }
@@ -120,8 +120,8 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `3593`
-        // Minimum execution time: 31_661_000 picoseconds.
-        Weight::from_parts(32_358_000, 3593)
+        // Minimum execution time: 29_782_000 picoseconds.
+        Weight::from_parts(30_295_000, 3593)
             .saturating_add(RocksDbWeight::get().reads(1_u64))
             .saturating_add(RocksDbWeight::get().writes(1_u64))
     }
@@ -129,8 +129,8 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `3593`
-        // Minimum execution time: 23_643_000 picoseconds.
-        Weight::from_parts(23_917_000, 3593)
+        // Minimum execution time: 21_396_000 picoseconds.
+        Weight::from_parts(21_806_000, 3593)
             .saturating_add(RocksDbWeight::get().reads(1_u64))
             .saturating_add(RocksDbWeight::get().writes(1_u64))
     }
@@ -138,8 +138,8 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `103`
         //  Estimated: `3593`
-        // Minimum execution time: 13_269_000 picoseconds.
-        Weight::from_parts(13_533_000, 3593)
+        // Minimum execution time: 12_457_000 picoseconds.
+        Weight::from_parts(12_779_000, 3593)
             .saturating_add(RocksDbWeight::get().reads(1_u64))
             .saturating_add(RocksDbWeight::get().writes(1_u64))
     }
@@ -147,8 +147,8 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `103`
         //  Estimated: `3593`
-        // Minimum execution time: 15_877_000 picoseconds.
-        Weight::from_parts(16_512_000, 3593)
+        // Minimum execution time: 15_473_000 picoseconds.
+        Weight::from_parts(15_990_000, 3593)
             .saturating_add(RocksDbWeight::get().reads(1_u64))
             .saturating_add(RocksDbWeight::get().writes(1_u64))
     }
@@ -156,8 +156,8 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `103`
         //  Estimated: `6196`
-        // Minimum execution time: 33_754_000 picoseconds.
-        Weight::from_parts(34_473_000, 6196)
+        // Minimum execution time: 31_071_000 picoseconds.
+        Weight::from_parts(31_836_000, 6196)
             .saturating_add(RocksDbWeight::get().reads(2_u64))
             .saturating_add(RocksDbWeight::get().writes(2_u64))
     }
@@ -165,8 +165,8 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `3593`
-        // Minimum execution time: 29_975_000 picoseconds.
-        Weight::from_parts(30_556_000, 3593)
+        // Minimum execution time: 27_464_000 picoseconds.
+        Weight::from_parts(28_112_000, 3593)
             .saturating_add(RocksDbWeight::get().reads(1_u64))
             .saturating_add(RocksDbWeight::get().writes(1_u64))
     }
@@ -174,8 +174,8 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `103`
         //  Estimated: `3593`
-        // Minimum execution time: 12_611_000 picoseconds.
-        Weight::from_parts(13_043_000, 3593)
+        // Minimum execution time: 11_587_000 picoseconds.
+        Weight::from_parts(12_013_000, 3593)
             .saturating_add(RocksDbWeight::get().reads(1_u64))
             .saturating_add(RocksDbWeight::get().writes(1_u64))
     }
diff --git a/runtime/gear/src/weights/pallet_gear.rs b/runtime/gear/src/weights/pallet_gear.rs
index 210fc7cd252..f4429240be6 100644
--- a/runtime/gear/src/weights/pallet_gear.rs
+++ b/runtime/gear/src/weights/pallet_gear.rs
@@ -19,7 +19,7 @@
 //! Autogenerated weights for pallet_gear
 //!
 //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
-//! DATE: 2023-08-01, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! DATE: 2023-08-07, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
 //! WORST CASE MAP SIZE: `1000000`
 //! CPU: `Intel(R) Xeon(R) Platinum 8375C CPU @ 2.90GHz`
 //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("gear-dev"), DB CACHE: 1024
@@ -246,10 +246,10 @@ impl<T: frame_system::Config> pallet_gear::WeightInfo for SubstrateWeight<T> {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 965_000 picoseconds.
-        Weight::from_parts(1_020_000, 0)
-            // Standard Error: 753
-            .saturating_add(Weight::from_parts(247_354, 0).saturating_mul(c.into()))
+        // Minimum execution time: 954_000 picoseconds.
+        Weight::from_parts(1_004_000, 0)
+            // Standard Error: 802
+            .saturating_add(Weight::from_parts(249_956, 0).saturating_mul(c.into()))
             .saturating_add(T::DbWeight::get().writes(1_u64))
     }
     /// The range of component `c` is `[0, 512]`.
@@ -257,10 +257,10 @@ impl<T: frame_system::Config> pallet_gear::WeightInfo for SubstrateWeight<T> {
         // Proof Size summary in bytes:
         //  Measured:  `42 + c * (1024 ±0)`
         //  Estimated: `3506 + c * (1024 ±0)`
-        // Minimum execution time: 2_780_000 picoseconds.
-        Weight::from_parts(2_874_000, 3506)
-            // Standard Error: 924
-            .saturating_add(Weight::from_parts(674_078, 0).saturating_mul(c.into()))
+        // Minimum execution time: 2_808_000 picoseconds.
+        Weight::from_parts(2_895_000, 3506)
+            // Standard Error: 1_086
+            .saturating_add(Weight::from_parts(680_150, 0).saturating_mul(c.into()))
             .saturating_add(T::DbWeight::get().reads(1_u64))
             .saturating_add(Weight::from_parts(0, 1024).saturating_mul(c.into()))
     }
@@ -269,17 +269,17 @@ impl<T: frame_system::Config> pallet_gear::WeightInfo for SubstrateWeight<T> {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 51_392_000 picoseconds.
-        Weight::from_parts(63_325_658, 0)
-            // Standard Error: 13_432
-            .saturating_add(Weight::from_parts(2_671_521, 0).saturating_mul(c.into()))
+        // Minimum execution time: 52_458_000 picoseconds.
+        Weight::from_parts(84_558_500, 0)
+            // Standard Error: 7_412
+            .saturating_add(Weight::from_parts(2_377_997, 0).saturating_mul(c.into()))
     }
     fn claim_value() -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `979`
         //  Estimated: `42236`
-        // Minimum execution time: 85_039_000 picoseconds.
-        Weight::from_parts(86_523_000, 42236)
+        // Minimum execution time: 81_302_000 picoseconds.
+        Weight::from_parts(83_307_000, 42236)
             .saturating_add(T::DbWeight::get().reads(13_u64))
             .saturating_add(T::DbWeight::get().writes(10_u64))
     }
@@ -287,8 +287,8 @@ impl<T: frame_system::Config> pallet_gear::WeightInfo for SubstrateWeight<T> {
         // Proof Size summary in bytes:
         //  Measured:  `886`
         //  Estimated: `21261`
-        // Minimum execution time: 54_302_000 picoseconds.
-        Weight::from_parts(56_159_000, 21261)
+        // Minimum execution time: 52_219_000 picoseconds.
+        Weight::from_parts(53_704_000, 21261)
             .saturating_add(T::DbWeight::get().reads(7_u64))
             .saturating_add(T::DbWeight::get().writes(6_u64))
     }
@@ -296,8 +296,8 @@ impl<T: frame_system::Config> pallet_gear::WeightInfo for SubstrateWeight<T> {
         // Proof Size summary in bytes:
         //  Measured:  `534`
         //  Estimated: `17070`
-        // Minimum execution time: 29_099_000 picoseconds.
-        Weight::from_parts(30_610_000, 17070)
+        // Minimum execution time: 28_408_000 picoseconds.
+        Weight::from_parts(29_714_000, 17070)
             .saturating_add(T::DbWeight::get().reads(6_u64))
             .saturating_add(T::DbWeight::get().writes(4_u64))
     }
@@ -306,10 +306,10 @@ impl<T: frame_system::Config> pallet_gear::WeightInfo for SubstrateWeight<T> {
         // Proof Size summary in bytes:
         //  Measured:  `355`
         //  Estimated: `7640`
-        // Minimum execution time: 8_259_000 picoseconds.
-        Weight::from_parts(6_228_584, 7640)
-            // Standard Error: 37_556
-            .saturating_add(Weight::from_parts(16_519_610, 0).saturating_mul(c.into()))
+        // Minimum execution time: 7_918_000 picoseconds.
+        Weight::from_parts(6_745_647, 7640)
+            // Standard Error: 37_300
+            .saturating_add(Weight::from_parts(13_885_473, 0).saturating_mul(c.into()))
             .saturating_add(T::DbWeight::get().reads(2_u64))
             .saturating_add(T::DbWeight::get().writes(2_u64))
     }
@@ -318,10 +318,10 @@ impl<T: frame_system::Config> pallet_gear::WeightInfo for SubstrateWeight<T> {
         // Proof Size summary in bytes:
         //  Measured:  `1297 + c * (16389 ±0)`
         //  Estimated: `40898 + c * (131112 ±0)`
-        // Minimum execution time: 70_699_000 picoseconds.
-        Weight::from_parts(71_447_000, 40898)
-            // Standard Error: 139_719
-            .saturating_add(Weight::from_parts(54_319_486, 0).saturating_mul(c.into()))
+        // Minimum execution time: 68_486_000 picoseconds.
+        Weight::from_parts(69_079_000, 40898)
+            // Standard Error: 164_982
+            .saturating_add(Weight::from_parts(55_774_264, 0).saturating_mul(c.into()))
             .saturating_add(T::DbWeight::get().reads(11_u64))
             .saturating_add(T::DbWeight::get().writes(9_u64))
             .saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(c.into())))
@@ -332,10 +332,10 @@ impl<T: frame_system::Config> pallet_gear::WeightInfo for SubstrateWeight<T> {
         // Proof Size summary in bytes:
         //  Measured:  `10`
         //  Estimated: `4990`
-        // Minimum execution time: 60_906_000 picoseconds.
-        Weight::from_parts(18_999_485, 4990)
-            // Standard Error: 57_215
-            .saturating_add(Weight::from_parts(53_057_311, 0).saturating_mul(c.into()))
+        // Minimum execution time: 61_635_000 picoseconds.
+        Weight::from_parts(64_537_590, 4990)
+            // Standard Error: 40_298
+            .saturating_add(Weight::from_parts(52_820_238, 0).saturating_mul(c.into()))
             .saturating_add(T::DbWeight::get().reads(2_u64))
             .saturating_add(T::DbWeight::get().writes(4_u64))
     }
@@ -344,10 +344,10 @@ impl<T: frame_system::Config> pallet_gear::WeightInfo for SubstrateWeight<T> {
         // Proof Size summary in bytes:
         //  Measured:  `671`
         //  Estimated: `38638`
-        // Minimum execution time: 65_623_000 picoseconds.
-        Weight::from_parts(88_392_610, 38638)
+        // Minimum execution time: 63_344_000 picoseconds.
+        Weight::from_parts(76_968_021, 38638)
             // Standard Error: 0
-            .saturating_add(Weight::from_parts(2_635, 0).saturating_mul(s.into()))
+            .saturating_add(Weight::from_parts(2_598, 0).saturating_mul(s.into()))
             .saturating_add(T::DbWeight::get().reads(13_u64))
             .saturating_add(T::DbWeight::get().writes(10_u64))
     }
@@ -357,12 +357,12 @@ impl<T: frame_system::Config> pallet_gear::WeightInfo for SubstrateWeight<T> {
         // Proof Size summary in bytes:
         //  Measured:  `235`
         //  Estimated: `34312`
-        // Minimum execution time: 11_247_503_000 picoseconds.
-        Weight::from_parts(302_469_923, 34312)
-            // Standard Error: 147_459
-            .saturating_add(Weight::from_parts(54_400_528, 0).saturating_mul(c.into()))
-            // Standard Error: 8
-            .saturating_add(Weight::from_parts(2_571, 0).saturating_mul(s.into()))
+        // Minimum execution time: 10_980_969_000 picoseconds.
+        Weight::from_parts(301_891_685, 34312)
+            // Standard Error: 164_203
+            .saturating_add(Weight::from_parts(54_383_779, 0).saturating_mul(c.into()))
+            // Standard Error: 9
+            .saturating_add(Weight::from_parts(2_548, 0).saturating_mul(s.into()))
             .saturating_add(T::DbWeight::get().reads(13_u64))
             .saturating_add(T::DbWeight::get().writes(14_u64))
     }
@@ -371,10 +371,10 @@ impl<T: frame_system::Config> pallet_gear::WeightInfo for SubstrateWeight<T> {
         // Proof Size summary in bytes:
         //  Measured:  `348`
         //  Estimated: `23853`
-        // Minimum execution time: 56_802_000 picoseconds.
-        Weight::from_parts(33_250_791, 23853)
-            // Standard Error: 1
-            .saturating_add(Weight::from_parts(1_182, 0).saturating_mul(p.into()))
+        // Minimum execution time: 53_732_000 picoseconds.
+        Weight::from_parts(35_204_611, 23853)
+            // Standard Error: 0
+            .saturating_add(Weight::from_parts(1_021, 0).saturating_mul(p.into()))
             .saturating_add(T::DbWeight::get().reads(9_u64))
             .saturating_add(T::DbWeight::get().writes(8_u64))
     }
@@ -383,10 +383,10 @@ impl<T: frame_system::Config> pallet_gear::WeightInfo for SubstrateWeight<T> {
         // Proof Size summary in bytes:
         //  Measured:  `451`
         //  Estimated: `27177`
-        // Minimum execution time: 59_487_000 picoseconds.
-        Weight::from_parts(37_481_444, 27177)
-            // Standard Error: 1
-            .saturating_add(Weight::from_parts(1_182, 0).saturating_mul(p.into()))
+        // Minimum execution time: 57_078_000 picoseconds.
+        Weight::from_parts(37_366_780, 27177)
+            // Standard Error: 0
+            .saturating_add(Weight::from_parts(1_023, 0).saturating_mul(p.into()))
             .saturating_add(T::DbWeight::get().reads(10_u64))
             .saturating_add(T::DbWeight::get().writes(9_u64))
     }
@@ -395,10 +395,10 @@ impl<T: frame_system::Config> pallet_gear::WeightInfo for SubstrateWeight<T> {
         // Proof Size summary in bytes:
         //  Measured:  `978`
         //  Estimated: `42227`
-        // Minimum execution time: 86_239_000 picoseconds.
-        Weight::from_parts(32_106_516, 42227)
-            // Standard Error: 3
-            .saturating_add(Weight::from_parts(1_249, 0).saturating_mul(p.into()))
+        // Minimum execution time: 82_297_000 picoseconds.
+        Weight::from_parts(62_302_593, 42227)
+            // Standard Error: 1
+            .saturating_add(Weight::from_parts(1_042, 0).saturating_mul(p.into()))
             .saturating_add(T::DbWeight::get().reads(13_u64))
             .saturating_add(T::DbWeight::get().writes(10_u64))
     }
@@ -407,10 +407,10 @@ impl<T: frame_system::Config> pallet_gear::WeightInfo for SubstrateWeight<T> {
         // Proof Size summary in bytes:
         //  Measured:  `1081`
         //  Estimated: `45757`
-        // Minimum execution time: 98_413_000 picoseconds.
-        Weight::from_parts(52_381_439, 45757)
-            // Standard Error: 3
-            .saturating_add(Weight::from_parts(1_252, 0).saturating_mul(p.into()))
+        // Minimum execution time: 93_602_000 picoseconds.
+        Weight::from_parts(69_941_334, 45757)
+            // Standard Error: 1
+            .saturating_add(Weight::from_parts(1_057, 0).saturating_mul(p.into()))
             .saturating_add(T::DbWeight::get().reads(14_u64))
             .saturating_add(T::DbWeight::get().writes(11_u64))
     }
@@ -419,8 +419,8 @@ impl<T: frame_system::Config> pallet_gear::WeightInfo for SubstrateWeight<T> {
         // Proof Size summary in bytes:
         //  Measured:  `760`
         //  Estimated: `74319`
-        // Minimum execution time: 302_634_000 picoseconds.
-        Weight::from_parts(320_223_637, 74319)
+        // Minimum execution time: 298_083_000 picoseconds.
+        Weight::from_parts(314_192_353, 74319)
             .saturating_add(T::DbWeight::get().reads(27_u64))
             .saturating_add(T::DbWeight::get().writes(22_u64))
     }
@@ -429,10 +429,10 @@ impl<T: frame_system::Config> pallet_gear::WeightInfo for SubstrateWeight<T> {
         // Proof Size summary in bytes:
         //  Measured:  `760`
         //  Estimated: `74319`
-        // Minimum execution time: 315_859_000 picoseconds.
-        Weight::from_parts(328_138_594, 74319)
-            // Standard Error: 1_557
-            .saturating_add(Weight::from_parts(8_014, 0).saturating_mul(q.into()))
+        // Minimum execution time: 312_856_000 picoseconds.
+        Weight::from_parts(326_607_586, 74319)
+            // Standard Error: 1_507
+            .saturating_add(Weight::from_parts(723, 0).saturating_mul(q.into()))
             .saturating_add(T::DbWeight::get().reads(27_u64))
             .saturating_add(T::DbWeight::get().writes(22_u64))
     }
@@ -441,10 +441,10 @@ impl<T: frame_system::Config> pallet_gear::WeightInfo for SubstrateWeight<T> {
         // Proof Size summary in bytes:
         //  Measured:  `211 + c * (1075 ±0)`
         //  Estimated: `3899 + c * (2150 ±0)`
-        // Minimum execution time: 45_804_000 picoseconds.
-        Weight::from_parts(46_226_000, 3899)
-            // Standard Error: 51_090
-            .saturating_add(Weight::from_parts(51_940_069, 0).saturating_mul(c.into()))
+        // Minimum execution time: 45_478_000 picoseconds.
+        Weight::from_parts(45_769_000, 3899)
+            // Standard Error: 42_221
+            .saturating_add(Weight::from_parts(51_492_007, 0).saturating_mul(c.into()))
             .saturating_add(T::DbWeight::get().reads(1_u64))
             .saturating_add(T::DbWeight::get().writes(2_u64))
             .saturating_add(Weight::from_parts(0, 2150).saturating_mul(c.into()))
@@ -454,630 +454,630 @@ impl<T: frame_system::Config> pallet_gear::WeightInfo for SubstrateWeight<T> {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 80_872_000 picoseconds.
-        Weight::from_parts(82_358_000, 0)
-            // Standard Error: 3_946_533
-            .saturating_add(Weight::from_parts(617_270_552, 0).saturating_mul(r.into()))
+        // Minimum execution time: 85_248_000 picoseconds.
+        Weight::from_parts(87_224_000, 0)
+            // Standard Error: 4_031_043
+            .saturating_add(Weight::from_parts(559_145_890, 0).saturating_mul(r.into()))
     }
     /// The range of component `p` is `[1, 512]`.
     fn alloc_per_page(p: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 365_182_000 picoseconds.
-        Weight::from_parts(292_523_651, 0)
-            // Standard Error: 7_087
-            .saturating_add(Weight::from_parts(31_059_002, 0).saturating_mul(p.into()))
+        // Minimum execution time: 304_310_000 picoseconds.
+        Weight::from_parts(240_640_662, 0)
+            // Standard Error: 7_875
+            .saturating_add(Weight::from_parts(30_931_778, 0).saturating_mul(p.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn free(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 196_771_000 picoseconds.
-        Weight::from_parts(219_836_156, 0)
-            // Standard Error: 406_704
-            .saturating_add(Weight::from_parts(120_742_843, 0).saturating_mul(r.into()))
+        // Minimum execution time: 144_728_000 picoseconds.
+        Weight::from_parts(127_694_995, 0)
+            // Standard Error: 344_021
+            .saturating_add(Weight::from_parts(63_008_235, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 256]`.
     fn gr_reserve_gas(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 86_043_000 picoseconds.
-        Weight::from_parts(92_117_781, 0)
-            // Standard Error: 7_334
-            .saturating_add(Weight::from_parts(3_640_301, 0).saturating_mul(r.into()))
+        // Minimum execution time: 85_763_000 picoseconds.
+        Weight::from_parts(93_302_515, 0)
+            // Standard Error: 3_873
+            .saturating_add(Weight::from_parts(2_723_217, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 256]`.
     fn gr_unreserve_gas(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 146_803_000 picoseconds.
-        Weight::from_parts(168_908_676, 0)
-            // Standard Error: 28_070
-            .saturating_add(Weight::from_parts(3_989_643, 0).saturating_mul(r.into()))
+        // Minimum execution time: 134_987_000 picoseconds.
+        Weight::from_parts(141_052_149, 0)
+            // Standard Error: 29_498
+            .saturating_add(Weight::from_parts(3_252_053, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_system_reserve_gas(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 82_421_000 picoseconds.
-        Weight::from_parts(109_902_108, 0)
-            // Standard Error: 458_197
-            .saturating_add(Weight::from_parts(186_560_355, 0).saturating_mul(r.into()))
+        // Minimum execution time: 82_532_000 picoseconds.
+        Weight::from_parts(111_956_884, 0)
+            // Standard Error: 420_651
+            .saturating_add(Weight::from_parts(124_761_103, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_message_id(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 85_173_000 picoseconds.
-        Weight::from_parts(81_703_608, 0)
-            // Standard Error: 318_823
-            .saturating_add(Weight::from_parts(183_602_076, 0).saturating_mul(r.into()))
+        // Minimum execution time: 82_442_000 picoseconds.
+        Weight::from_parts(76_262_730, 0)
+            // Standard Error: 310_067
+            .saturating_add(Weight::from_parts(115_334_131, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_program_id(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 85_999_000 picoseconds.
-        Weight::from_parts(81_002_605, 0)
-            // Standard Error: 269_075
-            .saturating_add(Weight::from_parts(183_154_106, 0).saturating_mul(r.into()))
+        // Minimum execution time: 82_322_000 picoseconds.
+        Weight::from_parts(71_153_919, 0)
+            // Standard Error: 293_317
+            .saturating_add(Weight::from_parts(115_508_333, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_source(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 82_306_000 picoseconds.
-        Weight::from_parts(79_166_166, 0)
-            // Standard Error: 332_502
-            .saturating_add(Weight::from_parts(182_666_522, 0).saturating_mul(r.into()))
+        // Minimum execution time: 82_586_000 picoseconds.
+        Weight::from_parts(73_401_225, 0)
+            // Standard Error: 306_089
+            .saturating_add(Weight::from_parts(115_530_298, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_value(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 82_459_000 picoseconds.
-        Weight::from_parts(80_301_392, 0)
-            // Standard Error: 340_598
-            .saturating_add(Weight::from_parts(184_099_120, 0).saturating_mul(r.into()))
+        // Minimum execution time: 86_537_000 picoseconds.
+        Weight::from_parts(80_327_682, 0)
+            // Standard Error: 275_679
+            .saturating_add(Weight::from_parts(114_024_859, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_value_available(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 81_140_000 picoseconds.
-        Weight::from_parts(72_987_262, 0)
-            // Standard Error: 388_909
-            .saturating_add(Weight::from_parts(186_920_851, 0).saturating_mul(r.into()))
+        // Minimum execution time: 84_226_000 picoseconds.
+        Weight::from_parts(74_308_323, 0)
+            // Standard Error: 291_460
+            .saturating_add(Weight::from_parts(115_396_428, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_gas_available(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 81_336_000 picoseconds.
-        Weight::from_parts(79_078_269, 0)
-            // Standard Error: 276_322
-            .saturating_add(Weight::from_parts(182_690_178, 0).saturating_mul(r.into()))
+        // Minimum execution time: 81_250_000 picoseconds.
+        Weight::from_parts(74_761_588, 0)
+            // Standard Error: 317_797
+            .saturating_add(Weight::from_parts(115_173_001, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_size(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 84_201_000 picoseconds.
-        Weight::from_parts(79_459_558, 0)
-            // Standard Error: 357_406
-            .saturating_add(Weight::from_parts(182_989_857, 0).saturating_mul(r.into()))
+        // Minimum execution time: 85_673_000 picoseconds.
+        Weight::from_parts(70_907_772, 0)
+            // Standard Error: 347_682
+            .saturating_add(Weight::from_parts(118_189_625, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_read(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 709_298_000 picoseconds.
-        Weight::from_parts(792_701_124, 0)
-            // Standard Error: 581_476
-            .saturating_add(Weight::from_parts(264_833_637, 0).saturating_mul(r.into()))
+        // Minimum execution time: 700_530_000 picoseconds.
+        Weight::from_parts(774_384_678, 0)
+            // Standard Error: 512_748
+            .saturating_add(Weight::from_parts(194_331_468, 0).saturating_mul(r.into()))
     }
     /// The range of component `n` is `[0, 2048]`.
     fn gr_read_per_kb(n: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 958_553_000 picoseconds.
-        Weight::from_parts(1_002_082_000, 0)
-            // Standard Error: 51_056
-            .saturating_add(Weight::from_parts(13_349_580, 0).saturating_mul(n.into()))
+        // Minimum execution time: 866_889_000 picoseconds.
+        Weight::from_parts(872_993_000, 0)
+            // Standard Error: 59_048
+            .saturating_add(Weight::from_parts(13_399_620, 0).saturating_mul(n.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_block_height(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 81_092_000 picoseconds.
-        Weight::from_parts(70_460_333, 0)
-            // Standard Error: 322_779
-            .saturating_add(Weight::from_parts(182_652_206, 0).saturating_mul(r.into()))
+        // Minimum execution time: 85_291_000 picoseconds.
+        Weight::from_parts(75_543_485, 0)
+            // Standard Error: 320_701
+            .saturating_add(Weight::from_parts(115_757_456, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_block_timestamp(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 82_315_000 picoseconds.
-        Weight::from_parts(77_285_940, 0)
-            // Standard Error: 310_862
-            .saturating_add(Weight::from_parts(183_154_588, 0).saturating_mul(r.into()))
+        // Minimum execution time: 83_780_000 picoseconds.
+        Weight::from_parts(68_090_338, 0)
+            // Standard Error: 330_050
+            .saturating_add(Weight::from_parts(117_803_137, 0).saturating_mul(r.into()))
     }
     /// The range of component `n` is `[0, 20]`.
     fn gr_random(n: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 82_813_000 picoseconds.
-        Weight::from_parts(83_631_977, 0)
-            // Standard Error: 426_894
-            .saturating_add(Weight::from_parts(250_044_040, 0).saturating_mul(n.into()))
+        // Minimum execution time: 84_394_000 picoseconds.
+        Weight::from_parts(88_472_912, 0)
+            // Standard Error: 340_524
+            .saturating_add(Weight::from_parts(190_044_477, 0).saturating_mul(n.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_reply_deposit(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 87_342_000 picoseconds.
-        Weight::from_parts(88_861_000, 0)
-            // Standard Error: 4_034_065
-            .saturating_add(Weight::from_parts(1_070_363_129, 0).saturating_mul(r.into()))
+        // Minimum execution time: 83_081_000 picoseconds.
+        Weight::from_parts(85_006_000, 0)
+            // Standard Error: 3_456_961
+            .saturating_add(Weight::from_parts(860_188_117, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_send(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 82_887_000 picoseconds.
-        Weight::from_parts(154_402_402, 0)
-            // Standard Error: 504_137
-            .saturating_add(Weight::from_parts(389_538_545, 0).saturating_mul(r.into()))
+        // Minimum execution time: 81_490_000 picoseconds.
+        Weight::from_parts(136_619_765, 0)
+            // Standard Error: 439_674
+            .saturating_add(Weight::from_parts(308_552_304, 0).saturating_mul(r.into()))
     }
     /// The range of component `n` is `[0, 2048]`.
     fn gr_send_per_kb(n: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 467_573_000 picoseconds.
-        Weight::from_parts(471_685_000, 0)
-            // Standard Error: 64_140
-            .saturating_add(Weight::from_parts(22_109_126, 0).saturating_mul(n.into()))
+        // Minimum execution time: 386_929_000 picoseconds.
+        Weight::from_parts(393_325_000, 0)
+            // Standard Error: 61_932
+            .saturating_add(Weight::from_parts(21_101_790, 0).saturating_mul(n.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_send_wgas(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 86_853_000 picoseconds.
-        Weight::from_parts(152_053_498, 0)
-            // Standard Error: 538_330
-            .saturating_add(Weight::from_parts(397_711_575, 0).saturating_mul(r.into()))
+        // Minimum execution time: 84_625_000 picoseconds.
+        Weight::from_parts(162_584_483, 0)
+            // Standard Error: 494_553
+            .saturating_add(Weight::from_parts(313_684_139, 0).saturating_mul(r.into()))
     }
     /// The range of component `n` is `[0, 2048]`.
     fn gr_send_wgas_per_kb(n: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 471_875_000 picoseconds.
-        Weight::from_parts(475_692_000, 0)
-            // Standard Error: 57_997
-            .saturating_add(Weight::from_parts(21_385_701, 0).saturating_mul(n.into()))
+        // Minimum execution time: 390_932_000 picoseconds.
+        Weight::from_parts(393_883_000, 0)
+            // Standard Error: 68_646
+            .saturating_add(Weight::from_parts(21_188_381, 0).saturating_mul(n.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_send_input(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 716_684_000 picoseconds.
-        Weight::from_parts(781_328_373, 0)
-            // Standard Error: 479_933
-            .saturating_add(Weight::from_parts(411_727_995, 0).saturating_mul(r.into()))
+        // Minimum execution time: 708_623_000 picoseconds.
+        Weight::from_parts(781_094_266, 0)
+            // Standard Error: 460_683
+            .saturating_add(Weight::from_parts(328_993_362, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_send_input_wgas(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 746_421_000 picoseconds.
-        Weight::from_parts(889_163_923, 0)
-            // Standard Error: 621_967
-            .saturating_add(Weight::from_parts(412_763_026, 0).saturating_mul(r.into()))
+        // Minimum execution time: 710_228_000 picoseconds.
+        Weight::from_parts(774_190_634, 0)
+            // Standard Error: 483_646
+            .saturating_add(Weight::from_parts(330_057_876, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_send_init(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 81_961_000 picoseconds.
-        Weight::from_parts(86_031_226, 0)
-            // Standard Error: 355_690
-            .saturating_add(Weight::from_parts(191_347_968, 0).saturating_mul(r.into()))
+        // Minimum execution time: 83_510_000 picoseconds.
+        Weight::from_parts(64_097_635, 0)
+            // Standard Error: 358_570
+            .saturating_add(Weight::from_parts(126_095_109, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_send_push(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 3_797_807_000 picoseconds.
-        Weight::from_parts(3_948_397_472, 0)
-            // Standard Error: 396_090
-            .saturating_add(Weight::from_parts(284_341_649, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_430_098_000 picoseconds.
+        Weight::from_parts(2_605_278_898, 0)
+            // Standard Error: 439_185
+            .saturating_add(Weight::from_parts(217_479_981, 0).saturating_mul(r.into()))
     }
     /// The range of component `n` is `[0, 2048]`.
     fn gr_send_push_per_kb(n: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 485_799_000 picoseconds.
-        Weight::from_parts(486_862_000, 0)
-            // Standard Error: 47_704
-            .saturating_add(Weight::from_parts(31_360_292, 0).saturating_mul(n.into()))
+        // Minimum execution time: 358_553_000 picoseconds.
+        Weight::from_parts(364_183_000, 0)
+            // Standard Error: 51_397
+            .saturating_add(Weight::from_parts(30_914_040, 0).saturating_mul(n.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_send_commit(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 3_842_120_000 picoseconds.
-        Weight::from_parts(3_943_431_716, 0)
-            // Standard Error: 766_406
-            .saturating_add(Weight::from_parts(339_379_953, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_464_581_000 picoseconds.
+        Weight::from_parts(2_580_044_243, 0)
+            // Standard Error: 461_216
+            .saturating_add(Weight::from_parts(272_575_116, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_send_commit_wgas(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 3_828_327_000 picoseconds.
-        Weight::from_parts(3_976_283_101, 0)
-            // Standard Error: 768_169
-            .saturating_add(Weight::from_parts(353_252_083, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_438_114_000 picoseconds.
+        Weight::from_parts(2_597_881_615, 0)
+            // Standard Error: 400_982
+            .saturating_add(Weight::from_parts(275_718_502, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_reservation_send(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 256_679_000 picoseconds.
-        Weight::from_parts(330_245_572, 0)
-            // Standard Error: 519_345
-            .saturating_add(Weight::from_parts(404_879_225, 0).saturating_mul(r.into()))
+        // Minimum execution time: 244_206_000 picoseconds.
+        Weight::from_parts(321_175_021, 0)
+            // Standard Error: 460_445
+            .saturating_add(Weight::from_parts(322_059_081, 0).saturating_mul(r.into()))
     }
     /// The range of component `n` is `[0, 2048]`.
     fn gr_reservation_send_per_kb(n: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 640_004_000 picoseconds.
-        Weight::from_parts(646_769_000, 0)
-            // Standard Error: 55_122
-            .saturating_add(Weight::from_parts(21_616_125, 0).saturating_mul(n.into()))
+        // Minimum execution time: 559_346_000 picoseconds.
+        Weight::from_parts(571_004_000, 0)
+            // Standard Error: 59_840
+            .saturating_add(Weight::from_parts(21_370_093, 0).saturating_mul(n.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_reservation_send_commit(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 3_981_155_000 picoseconds.
-        Weight::from_parts(4_086_072_221, 0)
-            // Standard Error: 1_076_069
-            .saturating_add(Weight::from_parts(362_989_310, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_620_633_000 picoseconds.
+        Weight::from_parts(2_741_869_292, 0)
+            // Standard Error: 620_120
+            .saturating_add(Weight::from_parts(289_781_719, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 1]`.
     fn gr_reply(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 84_145_000 picoseconds.
-        Weight::from_parts(88_260_563, 0)
-            // Standard Error: 277_576
-            .saturating_add(Weight::from_parts(20_209_036, 0).saturating_mul(r.into()))
+        // Minimum execution time: 83_438_000 picoseconds.
+        Weight::from_parts(86_817_816, 0)
+            // Standard Error: 234_731
+            .saturating_add(Weight::from_parts(19_849_283, 0).saturating_mul(r.into()))
     }
     /// The range of component `n` is `[0, 2048]`.
     fn gr_reply_per_kb(n: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 102_930_000 picoseconds.
-        Weight::from_parts(90_280_376, 0)
-            // Standard Error: 1_072
-            .saturating_add(Weight::from_parts(427_777, 0).saturating_mul(n.into()))
+        // Minimum execution time: 105_002_000 picoseconds.
+        Weight::from_parts(88_114_999, 0)
+            // Standard Error: 1_128
+            .saturating_add(Weight::from_parts(427_426, 0).saturating_mul(n.into()))
     }
     /// The range of component `r` is `[0, 1]`.
     fn gr_reply_wgas(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 84_156_000 picoseconds.
-        Weight::from_parts(89_778_763, 0)
-            // Standard Error: 365_767
-            .saturating_add(Weight::from_parts(24_157_936, 0).saturating_mul(r.into()))
+        // Minimum execution time: 82_436_000 picoseconds.
+        Weight::from_parts(88_440_285, 0)
+            // Standard Error: 277_544
+            .saturating_add(Weight::from_parts(17_399_914, 0).saturating_mul(r.into()))
     }
     /// The range of component `n` is `[0, 2048]`.
     fn gr_reply_wgas_per_kb(n: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 105_315_000 picoseconds.
-        Weight::from_parts(94_894_394, 0)
-            // Standard Error: 993
-            .saturating_add(Weight::from_parts(426_364, 0).saturating_mul(n.into()))
+        // Minimum execution time: 103_800_000 picoseconds.
+        Weight::from_parts(89_756_983, 0)
+            // Standard Error: 907
+            .saturating_add(Weight::from_parts(428_998, 0).saturating_mul(n.into()))
     }
     /// The range of component `r` is `[0, 1]`.
     fn gr_reply_commit(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 81_595_000 picoseconds.
-        Weight::from_parts(86_259_504, 0)
-            // Standard Error: 284_882
-            .saturating_add(Weight::from_parts(25_873_595, 0).saturating_mul(r.into()))
+        // Minimum execution time: 81_754_000 picoseconds.
+        Weight::from_parts(87_296_014, 0)
+            // Standard Error: 336_747
+            .saturating_add(Weight::from_parts(20_299_385, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 1]`.
     fn gr_reply_commit_wgas(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 80_771_000 picoseconds.
-        Weight::from_parts(85_313_802, 0)
-            // Standard Error: 265_474
-            .saturating_add(Weight::from_parts(25_863_597, 0).saturating_mul(r.into()))
+        // Minimum execution time: 81_952_000 picoseconds.
+        Weight::from_parts(86_840_575, 0)
+            // Standard Error: 272_708
+            .saturating_add(Weight::from_parts(19_217_524, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_reply_push(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 82_396_000 picoseconds.
-        Weight::from_parts(126_819_617, 0)
-            // Standard Error: 518_749
-            .saturating_add(Weight::from_parts(272_821_836, 0).saturating_mul(r.into()))
+        // Minimum execution time: 85_498_000 picoseconds.
+        Weight::from_parts(126_431_779, 0)
+            // Standard Error: 460_480
+            .saturating_add(Weight::from_parts(198_940_536, 0).saturating_mul(r.into()))
     }
     /// The range of component `n` is `[0, 8192]`.
     fn gr_reply_push_per_kb(n: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 98_266_000 picoseconds.
-        Weight::from_parts(100_843_000, 0)
-            // Standard Error: 2_828
-            .saturating_add(Weight::from_parts(662_117, 0).saturating_mul(n.into()))
+        // Minimum execution time: 96_862_000 picoseconds.
+        Weight::from_parts(98_611_000, 0)
+            // Standard Error: 2_677
+            .saturating_add(Weight::from_parts(662_266, 0).saturating_mul(n.into()))
     }
     /// The range of component `r` is `[0, 1]`.
     fn gr_reply_input(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 707_150_000 picoseconds.
-        Weight::from_parts(754_398_128, 0)
-            // Standard Error: 5_119_788
-            .saturating_add(Weight::from_parts(7_037_071, 0).saturating_mul(r.into()))
+        // Minimum execution time: 698_914_000 picoseconds.
+        Weight::from_parts(718_405_100, 0)
+            // Standard Error: 1_891_960
+            .saturating_add(Weight::from_parts(24_867_800, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 1]`.
     fn gr_reply_input_wgas(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 712_091_000 picoseconds.
-        Weight::from_parts(751_999_544, 0)
-            // Standard Error: 4_003_265
-            .saturating_add(Weight::from_parts(43_818_555, 0).saturating_mul(r.into()))
+        // Minimum execution time: 699_975_000 picoseconds.
+        Weight::from_parts(718_806_789, 0)
+            // Standard Error: 1_919_531
+            .saturating_add(Weight::from_parts(51_192_710, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 1]`.
     fn gr_reservation_reply(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 92_234_000 picoseconds.
-        Weight::from_parts(96_192_773, 0)
-            // Standard Error: 271_871
-            .saturating_add(Weight::from_parts(13_338_726, 0).saturating_mul(r.into()))
+        // Minimum execution time: 95_002_000 picoseconds.
+        Weight::from_parts(99_331_989, 0)
+            // Standard Error: 287_602
+            .saturating_add(Weight::from_parts(9_719_710, 0).saturating_mul(r.into()))
     }
     /// The range of component `n` is `[0, 2048]`.
     fn gr_reservation_reply_per_kb(n: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 108_190_000 picoseconds.
-        Weight::from_parts(92_525_926, 0)
-            // Standard Error: 1_134
-            .saturating_add(Weight::from_parts(433_806, 0).saturating_mul(n.into()))
+        // Minimum execution time: 102_501_000 picoseconds.
+        Weight::from_parts(87_026_327, 0)
+            // Standard Error: 1_214
+            .saturating_add(Weight::from_parts(429_134, 0).saturating_mul(n.into()))
     }
     /// The range of component `r` is `[0, 1]`.
     fn gr_reservation_reply_commit(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 92_297_000 picoseconds.
-        Weight::from_parts(98_054_616, 0)
-            // Standard Error: 394_791
-            .saturating_add(Weight::from_parts(7_680_683, 0).saturating_mul(r.into()))
+        // Minimum execution time: 93_228_000 picoseconds.
+        Weight::from_parts(97_923_691, 0)
+            // Standard Error: 288_469
+            .saturating_add(Weight::from_parts(9_669_908, 0).saturating_mul(r.into()))
     }
     /// The range of component `n` is `[0, 2048]`.
     fn gr_reservation_reply_commit_per_kb(n: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 106_932_000 picoseconds.
-        Weight::from_parts(91_150_785, 0)
-            // Standard Error: 1_067
-            .saturating_add(Weight::from_parts(424_570, 0).saturating_mul(n.into()))
+        // Minimum execution time: 100_908_000 picoseconds.
+        Weight::from_parts(87_613_705, 0)
+            // Standard Error: 1_237
+            .saturating_add(Weight::from_parts(431_412, 0).saturating_mul(n.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_reply_to(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 80_591_000 picoseconds.
-        Weight::from_parts(79_590_461, 0)
-            // Standard Error: 360_038
-            .saturating_add(Weight::from_parts(185_313_242, 0).saturating_mul(r.into()))
+        // Minimum execution time: 84_385_000 picoseconds.
+        Weight::from_parts(74_453_057, 0)
+            // Standard Error: 309_931
+            .saturating_add(Weight::from_parts(117_172_527, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_signal_from(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 83_379_000 picoseconds.
-        Weight::from_parts(82_304_672, 0)
-            // Standard Error: 371_508
-            .saturating_add(Weight::from_parts(184_895_719, 0).saturating_mul(r.into()))
+        // Minimum execution time: 82_437_000 picoseconds.
+        Weight::from_parts(78_951_443, 0)
+            // Standard Error: 294_227
+            .saturating_add(Weight::from_parts(116_066_384, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_reply_push_input(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 714_906_000 picoseconds.
-        Weight::from_parts(784_837_322, 0)
-            // Standard Error: 485_874
-            .saturating_add(Weight::from_parts(198_529_306, 0).saturating_mul(r.into()))
+        // Minimum execution time: 704_954_000 picoseconds.
+        Weight::from_parts(752_735_182, 0)
+            // Standard Error: 455_998
+            .saturating_add(Weight::from_parts(135_154_607, 0).saturating_mul(r.into()))
     }
     /// The range of component `n` is `[0, 2048]`.
     fn gr_reply_push_input_per_kb(n: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 735_164_000 picoseconds.
-        Weight::from_parts(760_829_418, 0)
-            // Standard Error: 2_049
-            .saturating_add(Weight::from_parts(164_862, 0).saturating_mul(n.into()))
+        // Minimum execution time: 724_451_000 picoseconds.
+        Weight::from_parts(738_722_668, 0)
+            // Standard Error: 1_014
+            .saturating_add(Weight::from_parts(154_329, 0).saturating_mul(n.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_send_push_input(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 4_467_125_000 picoseconds.
-        Weight::from_parts(4_668_343_697, 0)
-            // Standard Error: 529_569
-            .saturating_add(Weight::from_parts(214_709_155, 0).saturating_mul(r.into()))
+        // Minimum execution time: 3_092_586_000 picoseconds.
+        Weight::from_parts(3_231_311_035, 0)
+            // Standard Error: 506_742
+            .saturating_add(Weight::from_parts(159_545_582, 0).saturating_mul(r.into()))
     }
     /// The range of component `n` is `[0, 2048]`.
     fn gr_send_push_input_per_kb(n: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 4_716_693_000 picoseconds.
-        Weight::from_parts(4_810_590_943, 0)
-            // Standard Error: 12_440
-            .saturating_add(Weight::from_parts(13_814_475, 0).saturating_mul(n.into()))
+        // Minimum execution time: 3_299_872_000 picoseconds.
+        Weight::from_parts(3_317_022_894, 0)
+            // Standard Error: 8_542
+            .saturating_add(Weight::from_parts(13_645_472, 0).saturating_mul(n.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_debug(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 81_721_000 picoseconds.
-        Weight::from_parts(95_360_878, 0)
-            // Standard Error: 488_163
-            .saturating_add(Weight::from_parts(198_923_476, 0).saturating_mul(r.into()))
+        // Minimum execution time: 85_966_000 picoseconds.
+        Weight::from_parts(106_319_310, 0)
+            // Standard Error: 424_534
+            .saturating_add(Weight::from_parts(139_885_203, 0).saturating_mul(r.into()))
     }
     /// The range of component `n` is `[0, 2048]`.
     fn gr_debug_per_kb(n: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 189_069_000 picoseconds.
-        Weight::from_parts(191_834_000, 0)
-            // Standard Error: 53_942
-            .saturating_add(Weight::from_parts(26_059_121, 0).saturating_mul(n.into()))
+        // Minimum execution time: 142_910_000 picoseconds.
+        Weight::from_parts(144_843_000, 0)
+            // Standard Error: 54_401
+            .saturating_add(Weight::from_parts(25_535_472, 0).saturating_mul(n.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_reply_code(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 83_023_000 picoseconds.
-        Weight::from_parts(70_919_161, 0)
-            // Standard Error: 442_134
-            .saturating_add(Weight::from_parts(186_467_769, 0).saturating_mul(r.into()))
+        // Minimum execution time: 82_117_000 picoseconds.
+        Weight::from_parts(80_202_149, 0)
+            // Standard Error: 296_880
+            .saturating_add(Weight::from_parts(114_586_990, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 1]`.
     fn gr_exit(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 80_187_000 picoseconds.
-        Weight::from_parts(86_256_124, 0)
-            // Standard Error: 333_120
-            .saturating_add(Weight::from_parts(27_182_075, 0).saturating_mul(r.into()))
+        // Minimum execution time: 81_802_000 picoseconds.
+        Weight::from_parts(85_064_295, 0)
+            // Standard Error: 248_874
+            .saturating_add(Weight::from_parts(27_314_604, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 1]`.
     fn gr_leave(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 80_373_000 picoseconds.
-        Weight::from_parts(83_957_387, 0)
-            // Standard Error: 258_914
-            .saturating_add(Weight::from_parts(14_637_112, 0).saturating_mul(r.into()))
+        // Minimum execution time: 82_854_000 picoseconds.
+        Weight::from_parts(86_180_314, 0)
+            // Standard Error: 239_162
+            .saturating_add(Weight::from_parts(16_391_885, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 1]`.
     fn gr_wait(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 82_886_000 picoseconds.
-        Weight::from_parts(86_536_767, 0)
-            // Standard Error: 237_087
-            .saturating_add(Weight::from_parts(15_456_732, 0).saturating_mul(r.into()))
+        // Minimum execution time: 80_883_000 picoseconds.
+        Weight::from_parts(87_058_214, 0)
+            // Standard Error: 256_392
+            .saturating_add(Weight::from_parts(13_333_285, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 1]`.
     fn gr_wait_for(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 82_962_000 picoseconds.
-        Weight::from_parts(87_038_165, 0)
-            // Standard Error: 267_652
-            .saturating_add(Weight::from_parts(14_141_234, 0).saturating_mul(r.into()))
+        // Minimum execution time: 81_417_000 picoseconds.
+        Weight::from_parts(85_403_451, 0)
+            // Standard Error: 249_767
+            .saturating_add(Weight::from_parts(14_474_948, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 1]`.
     fn gr_wait_up_to(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 82_976_000 picoseconds.
-        Weight::from_parts(87_105_967, 0)
-            // Standard Error: 237_581
-            .saturating_add(Weight::from_parts(13_365_932, 0).saturating_mul(r.into()))
+        // Minimum execution time: 84_020_000 picoseconds.
+        Weight::from_parts(88_080_622, 0)
+            // Standard Error: 253_221
+            .saturating_add(Weight::from_parts(11_403_277, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_wake(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 139_585_000 picoseconds.
-        Weight::from_parts(203_512_831, 0)
-            // Standard Error: 393_346
-            .saturating_add(Weight::from_parts(283_538_921, 0).saturating_mul(r.into()))
+        // Minimum execution time: 138_317_000 picoseconds.
+        Weight::from_parts(187_894_162, 0)
+            // Standard Error: 376_519
+            .saturating_add(Weight::from_parts(209_723_429, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_create_program(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 98_330_000 picoseconds.
-        Weight::from_parts(158_669_516, 0)
-            // Standard Error: 440_421
-            .saturating_add(Weight::from_parts(473_163_025, 0).saturating_mul(r.into()))
+        // Minimum execution time: 93_047_000 picoseconds.
+        Weight::from_parts(151_715_771, 0)
+            // Standard Error: 425_606
+            .saturating_add(Weight::from_parts(396_733_544, 0).saturating_mul(r.into()))
     }
     /// The range of component `p` is `[0, 2048]`.
     /// The range of component `s` is `[1, 2048]`.
@@ -1085,22 +1085,22 @@ impl<T: frame_system::Config> pallet_gear::WeightInfo for SubstrateWeight<T> {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 43_492_772_000 picoseconds.
-        Weight::from_parts(43_692_998_000, 0)
-            // Standard Error: 263_249
-            .saturating_add(Weight::from_parts(8_169_821, 0).saturating_mul(p.into()))
-            // Standard Error: 263_236
-            .saturating_add(Weight::from_parts(180_732_778, 0).saturating_mul(s.into()))
+        // Minimum execution time: 45_923_081_000 picoseconds.
+        Weight::from_parts(45_981_736_000, 0)
+            // Standard Error: 274_662
+            .saturating_add(Weight::from_parts(6_858_186, 0).saturating_mul(p.into()))
+            // Standard Error: 274_649
+            .saturating_add(Weight::from_parts(177_291_831, 0).saturating_mul(s.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_create_program_wgas(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 97_189_000 picoseconds.
-        Weight::from_parts(158_677_248, 0)
-            // Standard Error: 452_648
-            .saturating_add(Weight::from_parts(478_043_506, 0).saturating_mul(r.into()))
+        // Minimum execution time: 95_680_000 picoseconds.
+        Weight::from_parts(157_350_147, 0)
+            // Standard Error: 440_994
+            .saturating_add(Weight::from_parts(402_511_567, 0).saturating_mul(r.into()))
     }
     /// The range of component `p` is `[0, 2048]`.
     /// The range of component `s` is `[1, 2048]`.
@@ -1108,32 +1108,32 @@ impl<T: frame_system::Config> pallet_gear::WeightInfo for SubstrateWeight<T> {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 43_613_488_000 picoseconds.
-        Weight::from_parts(43_758_304_000, 0)
-            // Standard Error: 268_412
-            .saturating_add(Weight::from_parts(7_987_894, 0).saturating_mul(p.into()))
-            // Standard Error: 268_399
-            .saturating_add(Weight::from_parts(180_769_004, 0).saturating_mul(s.into()))
+        // Minimum execution time: 42_842_395_000 picoseconds.
+        Weight::from_parts(42_890_931_000, 0)
+            // Standard Error: 264_187
+            .saturating_add(Weight::from_parts(7_896_879, 0).saturating_mul(p.into()))
+            // Standard Error: 264_174
+            .saturating_add(Weight::from_parts(178_082_248, 0).saturating_mul(s.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_pay_program_rent(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 84_210_000 picoseconds.
-        Weight::from_parts(99_996_695, 0)
-            // Standard Error: 31_808
-            .saturating_add(Weight::from_parts(3_523_987, 0).saturating_mul(r.into()))
+        // Minimum execution time: 82_272_000 picoseconds.
+        Weight::from_parts(100_008_395, 0)
+            // Standard Error: 36_430
+            .saturating_add(Weight::from_parts(2_544_223, 0).saturating_mul(r.into()))
     }
     /// The range of component `p` is `[0, 512]`.
     fn lazy_pages_signal_read(p: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `141`
         //  Estimated: `1131 + p * (9900 ±0)`
-        // Minimum execution time: 82_940_000 picoseconds.
-        Weight::from_parts(123_540_441, 1131)
-            // Standard Error: 7_143
-            .saturating_add(Weight::from_parts(11_789_871, 0).saturating_mul(p.into()))
+        // Minimum execution time: 83_139_000 picoseconds.
+        Weight::from_parts(122_967_835, 1131)
+            // Standard Error: 6_454
+            .saturating_add(Weight::from_parts(11_784_103, 0).saturating_mul(p.into()))
             .saturating_add(T::DbWeight::get().reads((4_u64).saturating_mul(p.into())))
             .saturating_add(Weight::from_parts(0, 9900).saturating_mul(p.into()))
     }
@@ -1142,10 +1142,10 @@ impl<T: frame_system::Config> pallet_gear::WeightInfo for SubstrateWeight<T> {
         // Proof Size summary in bytes:
         //  Measured:  `141`
         //  Estimated: `1131 + p * (9900 ±0)`
-        // Minimum execution time: 83_752_000 picoseconds.
-        Weight::from_parts(84_858_000, 1131)
-            // Standard Error: 48_161
-            .saturating_add(Weight::from_parts(36_181_117, 0).saturating_mul(p.into()))
+        // Minimum execution time: 83_229_000 picoseconds.
+        Weight::from_parts(83_885_000, 1131)
+            // Standard Error: 37_558
+            .saturating_add(Weight::from_parts(35_503_677, 0).saturating_mul(p.into()))
             .saturating_add(T::DbWeight::get().reads((4_u64).saturating_mul(p.into())))
             .saturating_add(Weight::from_parts(0, 9900).saturating_mul(p.into()))
     }
@@ -1154,10 +1154,10 @@ impl<T: frame_system::Config> pallet_gear::WeightInfo for SubstrateWeight<T> {
         // Proof Size summary in bytes:
         //  Measured:  `141`
         //  Estimated: `5069931`
-        // Minimum execution time: 6_125_138_000 picoseconds.
-        Weight::from_parts(5_869_525_563, 5069931)
-            // Standard Error: 46_521
-            .saturating_add(Weight::from_parts(36_899_111, 0).saturating_mul(p.into()))
+        // Minimum execution time: 6_139_187_000 picoseconds.
+        Weight::from_parts(5_806_599_304, 5069931)
+            // Standard Error: 75_881
+            .saturating_add(Weight::from_parts(36_513_688, 0).saturating_mul(p.into()))
             .saturating_add(T::DbWeight::get().reads(2048_u64))
     }
     /// The range of component `p` is `[0, 512]`.
@@ -1165,10 +1165,10 @@ impl<T: frame_system::Config> pallet_gear::WeightInfo for SubstrateWeight<T> {
         // Proof Size summary in bytes:
         //  Measured:  `1813 + p * (65580 ±0)`
         //  Estimated: `1939 + p * (75482 ±0)`
-        // Minimum execution time: 82_516_000 picoseconds.
-        Weight::from_parts(83_470_000, 1939)
-            // Standard Error: 29_769
-            .saturating_add(Weight::from_parts(46_665_657, 0).saturating_mul(p.into()))
+        // Minimum execution time: 82_177_000 picoseconds.
+        Weight::from_parts(83_595_000, 1939)
+            // Standard Error: 45_778
+            .saturating_add(Weight::from_parts(47_155_630, 0).saturating_mul(p.into()))
             .saturating_add(T::DbWeight::get().reads((4_u64).saturating_mul(p.into())))
             .saturating_add(Weight::from_parts(0, 75482).saturating_mul(p.into()))
     }
@@ -1177,10 +1177,10 @@ impl<T: frame_system::Config> pallet_gear::WeightInfo for SubstrateWeight<T> {
         // Proof Size summary in bytes:
         //  Measured:  `141`
         //  Estimated: `1131 + p * (9900 ±0)`
-        // Minimum execution time: 87_344_000 picoseconds.
-        Weight::from_parts(94_873_151, 1131)
-            // Standard Error: 55_429
-            .saturating_add(Weight::from_parts(35_724_871, 0).saturating_mul(p.into()))
+        // Minimum execution time: 90_231_000 picoseconds.
+        Weight::from_parts(95_944_378, 1131)
+            // Standard Error: 61_821
+            .saturating_add(Weight::from_parts(35_941_066, 0).saturating_mul(p.into()))
             .saturating_add(T::DbWeight::get().reads((4_u64).saturating_mul(p.into())))
             .saturating_add(Weight::from_parts(0, 9900).saturating_mul(p.into()))
     }
@@ -1189,10 +1189,10 @@ impl<T: frame_system::Config> pallet_gear::WeightInfo for SubstrateWeight<T> {
         // Proof Size summary in bytes:
         //  Measured:  `141`
         //  Estimated: `1496 + p * (9883 ±2)`
-        // Minimum execution time: 735_393_000 picoseconds.
-        Weight::from_parts(754_062_397, 1496)
-            // Standard Error: 166_437
-            .saturating_add(Weight::from_parts(43_966_900, 0).saturating_mul(p.into()))
+        // Minimum execution time: 734_006_000 picoseconds.
+        Weight::from_parts(717_384_508, 1496)
+            // Standard Error: 375_292
+            .saturating_add(Weight::from_parts(47_930_581, 0).saturating_mul(p.into()))
             .saturating_add(T::DbWeight::get().reads((4_u64).saturating_mul(p.into())))
             .saturating_add(Weight::from_parts(0, 9883).saturating_mul(p.into()))
     }
@@ -1201,10 +1201,10 @@ impl<T: frame_system::Config> pallet_gear::WeightInfo for SubstrateWeight<T> {
         // Proof Size summary in bytes:
         //  Measured:  `141`
         //  Estimated: `317931`
-        // Minimum execution time: 1_124_371_000 picoseconds.
-        Weight::from_parts(1_147_901_415, 317931)
-            // Standard Error: 145_342
-            .saturating_add(Weight::from_parts(43_795_511, 0).saturating_mul(p.into()))
+        // Minimum execution time: 1_121_849_000 picoseconds.
+        Weight::from_parts(1_147_558_033, 317931)
+            // Standard Error: 373_146
+            .saturating_add(Weight::from_parts(45_393_418, 0).saturating_mul(p.into()))
             .saturating_add(T::DbWeight::get().reads(128_u64))
     }
     /// The range of component `r` is `[0, 20]`.
@@ -1212,885 +1212,885 @@ impl<T: frame_system::Config> pallet_gear::WeightInfo for SubstrateWeight<T> {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 1_510_000 picoseconds.
-        Weight::from_parts(1_448_006, 0)
-            // Standard Error: 9_868
-            .saturating_add(Weight::from_parts(24_061_691, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_162_000 picoseconds.
+        Weight::from_parts(2_220_392, 0)
+            // Standard Error: 8_848
+            .saturating_add(Weight::from_parts(24_205_605, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[50, 500]`.
     fn instr_i64load(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 4_337_991_000 picoseconds.
-        Weight::from_parts(4_151_991_287, 0)
-            // Standard Error: 60_683
-            .saturating_add(Weight::from_parts(4_818_799, 0).saturating_mul(r.into()))
+        // Minimum execution time: 4_352_664_000 picoseconds.
+        Weight::from_parts(4_153_366_897, 0)
+            // Standard Error: 60_193
+            .saturating_add(Weight::from_parts(4_722_164, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[50, 500]`.
     fn instr_i32load(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 4_341_162_000 picoseconds.
-        Weight::from_parts(4_200_807_294, 0)
-            // Standard Error: 51_442
-            .saturating_add(Weight::from_parts(4_527_839, 0).saturating_mul(r.into()))
+        // Minimum execution time: 4_357_649_000 picoseconds.
+        Weight::from_parts(4_256_499_798, 0)
+            // Standard Error: 57_942
+            .saturating_add(Weight::from_parts(4_200_870, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[50, 500]`.
     fn instr_i64store(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 10_322_767_000 picoseconds.
-        Weight::from_parts(11_038_976_057, 0)
-            // Standard Error: 150_113
-            .saturating_add(Weight::from_parts(10_655_640, 0).saturating_mul(r.into()))
+        // Minimum execution time: 10_269_998_000 picoseconds.
+        Weight::from_parts(11_525_100_351, 0)
+            // Standard Error: 204_230
+            .saturating_add(Weight::from_parts(8_423_588, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[50, 500]`.
     fn instr_i32store(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 10_367_826_000 picoseconds.
-        Weight::from_parts(11_310_983_745, 0)
-            // Standard Error: 145_202
-            .saturating_add(Weight::from_parts(7_541_832, 0).saturating_mul(r.into()))
+        // Minimum execution time: 10_204_810_000 picoseconds.
+        Weight::from_parts(10_982_673_143, 0)
+            // Standard Error: 145_327
+            .saturating_add(Weight::from_parts(9_198_033, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_select(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_251_000 picoseconds.
-        Weight::from_parts(2_304_000, 0)
-            // Standard Error: 8_520
-            .saturating_add(Weight::from_parts(3_798_413, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_074_000 picoseconds.
+        Weight::from_parts(2_108_000, 0)
+            // Standard Error: 9_031
+            .saturating_add(Weight::from_parts(3_829_182, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_if(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_168_000 picoseconds.
-        Weight::from_parts(573_722, 0)
-            // Standard Error: 11_642
-            .saturating_add(Weight::from_parts(3_174_691, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_020_000 picoseconds.
+        Weight::from_parts(2_118_000, 0)
+            // Standard Error: 5_295
+            .saturating_add(Weight::from_parts(2_980_329, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_br(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_227_000 picoseconds.
-        Weight::from_parts(3_155_512, 0)
-            // Standard Error: 1_212
-            .saturating_add(Weight::from_parts(1_586_585, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_032_000 picoseconds.
+        Weight::from_parts(3_411_359, 0)
+            // Standard Error: 1_146
+            .saturating_add(Weight::from_parts(1_563_906, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_br_if(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_160_000 picoseconds.
-        Weight::from_parts(2_219_000, 0)
-            // Standard Error: 8_627
-            .saturating_add(Weight::from_parts(2_929_529, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_096_000 picoseconds.
+        Weight::from_parts(2_140_000, 0)
+            // Standard Error: 8_349
+            .saturating_add(Weight::from_parts(2_904_673, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_br_table(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_227_000 picoseconds.
-        Weight::from_parts(1_609_241, 0)
-            // Standard Error: 19_812
-            .saturating_add(Weight::from_parts(5_162_833, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_128_000 picoseconds.
+        Weight::from_parts(2_159_000, 0)
+            // Standard Error: 8_100
+            .saturating_add(Weight::from_parts(5_229_400, 0).saturating_mul(r.into()))
     }
     /// The range of component `e` is `[1, 256]`.
     fn instr_br_table_per_entry(e: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 6_892_000 picoseconds.
-        Weight::from_parts(5_316_811, 0)
-            // Standard Error: 1_578
-            .saturating_add(Weight::from_parts(163_377, 0).saturating_mul(e.into()))
+        // Minimum execution time: 6_838_000 picoseconds.
+        Weight::from_parts(5_309_346, 0)
+            // Standard Error: 2_580
+            .saturating_add(Weight::from_parts(129_982, 0).saturating_mul(e.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_call_const(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_304_000 picoseconds.
-        Weight::from_parts(4_554_683, 0)
-            // Standard Error: 7_319
-            .saturating_add(Weight::from_parts(2_595_958, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_100_000 picoseconds.
+        Weight::from_parts(3_593_285, 0)
+            // Standard Error: 6_648
+            .saturating_add(Weight::from_parts(2_597_926, 0).saturating_mul(r.into()))
     }
     fn instr_i64const(r: u32, ) -> Weight {
         Weight::from_parts(0, 0)
-            .saturating_add(Weight::from_parts(2_595_958 -
-            2_422_191, 0).saturating_mul(r.into()))
+            .saturating_add(Weight::from_parts(2_597_926 -
+            2_429_048, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_call(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_273_000 picoseconds.
-        Weight::from_parts(5_046_075, 0)
-            // Standard Error: 13_702
-            .saturating_add(Weight::from_parts(2_422_191, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_086_000 picoseconds.
+        Weight::from_parts(3_972_773, 0)
+            // Standard Error: 12_538
+            .saturating_add(Weight::from_parts(2_429_048, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_call_indirect(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_684_000 picoseconds.
-        Weight::from_parts(17_324_871, 0)
-            // Standard Error: 38_532
-            .saturating_add(Weight::from_parts(10_260_872, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_591_000 picoseconds.
+        Weight::from_parts(12_798_134, 0)
+            // Standard Error: 23_023
+            .saturating_add(Weight::from_parts(9_786_464, 0).saturating_mul(r.into()))
     }
     /// The range of component `p` is `[0, 128]`.
     fn instr_call_indirect_per_param(p: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 12_206_000 picoseconds.
-        Weight::from_parts(2_634_425, 0)
-            // Standard Error: 5_954
-            .saturating_add(Weight::from_parts(1_275_538, 0).saturating_mul(p.into()))
+        // Minimum execution time: 12_274_000 picoseconds.
+        Weight::from_parts(1_706_188, 0)
+            // Standard Error: 6_199
+            .saturating_add(Weight::from_parts(1_212_443, 0).saturating_mul(p.into()))
     }
     /// The range of component `l` is `[0, 1024]`.
     fn instr_call_per_local(l: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 5_288_000 picoseconds.
-        Weight::from_parts(5_570_870, 0)
+        // Minimum execution time: 5_221_000 picoseconds.
+        Weight::from_parts(5_538_574, 0)
             // Standard Error: 12
-            .saturating_add(Weight::from_parts(61, 0).saturating_mul(l.into()))
+            .saturating_add(Weight::from_parts(12, 0).saturating_mul(l.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_local_get(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_203_000 picoseconds.
-        Weight::from_parts(1_788_159, 0)
-            // Standard Error: 3_152
-            .saturating_add(Weight::from_parts(267_842, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_100_000 picoseconds.
+        Weight::from_parts(1_785_103, 0)
+            // Standard Error: 2_948
+            .saturating_add(Weight::from_parts(249_981, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_local_set(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_164_000 picoseconds.
-        Weight::from_parts(2_223_000, 0)
-            // Standard Error: 4_611
-            .saturating_add(Weight::from_parts(721_127, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_123_000 picoseconds.
+        Weight::from_parts(2_187_000, 0)
+            // Standard Error: 5_664
+            .saturating_add(Weight::from_parts(719_187, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_local_tee(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_252_000 picoseconds.
-        Weight::from_parts(2_347_000, 0)
-            // Standard Error: 5_971
-            .saturating_add(Weight::from_parts(742_209, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_137_000 picoseconds.
+        Weight::from_parts(2_214_000, 0)
+            // Standard Error: 5_625
+            .saturating_add(Weight::from_parts(709_067, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_global_get(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 6_406_000 picoseconds.
-        Weight::from_parts(2_894_577, 0)
-            // Standard Error: 8_027
-            .saturating_add(Weight::from_parts(801_493, 0).saturating_mul(r.into()))
+        // Minimum execution time: 6_168_000 picoseconds.
+        Weight::from_parts(2_290_203, 0)
+            // Standard Error: 8_984
+            .saturating_add(Weight::from_parts(761_843, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_global_set(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 6_345_000 picoseconds.
-        Weight::from_parts(31_295, 0)
-            // Standard Error: 10_231
-            .saturating_add(Weight::from_parts(1_543_569, 0).saturating_mul(r.into()))
+        // Minimum execution time: 6_249_000 picoseconds.
+        Weight::from_parts(6_302_000, 0)
+            // Standard Error: 8_682
+            .saturating_add(Weight::from_parts(1_329_653, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_memory_current(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 3_937_000 picoseconds.
-        Weight::from_parts(62_049, 0)
-            // Standard Error: 12_087
-            .saturating_add(Weight::from_parts(7_172_920, 0).saturating_mul(r.into()))
+        // Minimum execution time: 3_791_000 picoseconds.
+        Weight::from_parts(3_929_000, 0)
+            // Standard Error: 9_270
+            .saturating_add(Weight::from_parts(6_742_685, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64clz(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_262_000 picoseconds.
-        Weight::from_parts(2_306_000, 0)
-            // Standard Error: 6_042
-            .saturating_add(Weight::from_parts(3_394_526, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_113_000 picoseconds.
+        Weight::from_parts(2_192_000, 0)
+            // Standard Error: 6_734
+            .saturating_add(Weight::from_parts(3_327_207, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32clz(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_151_000 picoseconds.
-        Weight::from_parts(2_260_000, 0)
-            // Standard Error: 5_891
-            .saturating_add(Weight::from_parts(3_138_523, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_095_000 picoseconds.
+        Weight::from_parts(2_141_000, 0)
+            // Standard Error: 6_506
+            .saturating_add(Weight::from_parts(3_061_891, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64ctz(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_218_000 picoseconds.
-        Weight::from_parts(2_277_000, 0)
-            // Standard Error: 8_196
-            .saturating_add(Weight::from_parts(3_167_033, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_108_000 picoseconds.
+        Weight::from_parts(2_141_000, 0)
+            // Standard Error: 6_738
+            .saturating_add(Weight::from_parts(3_101_844, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32ctz(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_246_000 picoseconds.
-        Weight::from_parts(2_289_000, 0)
-            // Standard Error: 5_536
-            .saturating_add(Weight::from_parts(2_668_164, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_138_000 picoseconds.
+        Weight::from_parts(2_155_000, 0)
+            // Standard Error: 4_379
+            .saturating_add(Weight::from_parts(2_613_794, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64popcnt(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_259_000 picoseconds.
-        Weight::from_parts(45_432, 0)
-            // Standard Error: 6_223
-            .saturating_add(Weight::from_parts(645_076, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_046_000 picoseconds.
+        Weight::from_parts(2_127_000, 0)
+            // Standard Error: 3_513
+            .saturating_add(Weight::from_parts(525_212, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32popcnt(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_168_000 picoseconds.
-        Weight::from_parts(1_301_007, 0)
-            // Standard Error: 4_929
-            .saturating_add(Weight::from_parts(446_280, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_127_000 picoseconds.
+        Weight::from_parts(1_669_179, 0)
+            // Standard Error: 2_817
+            .saturating_add(Weight::from_parts(367_599, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64eqz(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_130_000 picoseconds.
-        Weight::from_parts(2_205_000, 0)
-            // Standard Error: 10_412
-            .saturating_add(Weight::from_parts(1_894_722, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_131_000 picoseconds.
+        Weight::from_parts(2_169_000, 0)
+            // Standard Error: 11_816
+            .saturating_add(Weight::from_parts(1_810_781, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32eqz(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_170_000 picoseconds.
-        Weight::from_parts(2_257_000, 0)
-            // Standard Error: 7_708
-            .saturating_add(Weight::from_parts(1_162_246, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_087_000 picoseconds.
+        Weight::from_parts(2_194_000, 0)
+            // Standard Error: 7_361
+            .saturating_add(Weight::from_parts(1_130_773, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32extend8s(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_153_000 picoseconds.
-        Weight::from_parts(1_682_106, 0)
-            // Standard Error: 3_839
-            .saturating_add(Weight::from_parts(384_381, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_061_000 picoseconds.
+        Weight::from_parts(1_850_477, 0)
+            // Standard Error: 2_695
+            .saturating_add(Weight::from_parts(318_827, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32extend16s(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_162_000 picoseconds.
-        Weight::from_parts(1_669_708, 0)
-            // Standard Error: 3_126
-            .saturating_add(Weight::from_parts(384_474, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_115_000 picoseconds.
+        Weight::from_parts(1_764_589, 0)
+            // Standard Error: 2_923
+            .saturating_add(Weight::from_parts(329_840, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64extend8s(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_249_000 picoseconds.
-        Weight::from_parts(2_291_000, 0)
-            // Standard Error: 4_476
-            .saturating_add(Weight::from_parts(497_277, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_109_000 picoseconds.
+        Weight::from_parts(859_995, 0)
+            // Standard Error: 4_546
+            .saturating_add(Weight::from_parts(467_944, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64extend16s(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_217_000 picoseconds.
-        Weight::from_parts(2_287_000, 0)
-            // Standard Error: 4_107
-            .saturating_add(Weight::from_parts(524_095, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_010_000 picoseconds.
+        Weight::from_parts(2_081_000, 0)
+            // Standard Error: 3_959
+            .saturating_add(Weight::from_parts(472_947, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64extend32s(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_163_000 picoseconds.
-        Weight::from_parts(2_233_000, 0)
-            // Standard Error: 3_690
-            .saturating_add(Weight::from_parts(501_277, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_105_000 picoseconds.
+        Weight::from_parts(1_247_124, 0)
+            // Standard Error: 4_390
+            .saturating_add(Weight::from_parts(436_907, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64extendsi32(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_132_000 picoseconds.
-        Weight::from_parts(1_082_506, 0)
-            // Standard Error: 5_421
-            .saturating_add(Weight::from_parts(400_448, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_140_000 picoseconds.
+        Weight::from_parts(2_251_532, 0)
+            // Standard Error: 2_995
+            .saturating_add(Weight::from_parts(280_490, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64extendui32(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_211_000 picoseconds.
-        Weight::from_parts(3_085_764, 0)
-            // Standard Error: 1_912
-            .saturating_add(Weight::from_parts(162_384, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_119_000 picoseconds.
+        Weight::from_parts(2_808_547, 0)
+            // Standard Error: 1_453
+            .saturating_add(Weight::from_parts(143_409, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32wrapi64(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_161_000 picoseconds.
-        Weight::from_parts(2_849_158, 0)
-            // Standard Error: 1_635
-            .saturating_add(Weight::from_parts(153_763, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_043_000 picoseconds.
+        Weight::from_parts(2_639_820, 0)
+            // Standard Error: 1_638
+            .saturating_add(Weight::from_parts(159_792, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64eq(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_279_000 picoseconds.
-        Weight::from_parts(2_315_000, 0)
-            // Standard Error: 11_776
-            .saturating_add(Weight::from_parts(1_779_477, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_128_000 picoseconds.
+        Weight::from_parts(2_166_000, 0)
+            // Standard Error: 11_777
+            .saturating_add(Weight::from_parts(1_709_510, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32eq(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_272_000 picoseconds.
-        Weight::from_parts(2_342_000, 0)
-            // Standard Error: 8_815
-            .saturating_add(Weight::from_parts(1_197_093, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_100_000 picoseconds.
+        Weight::from_parts(2_136_000, 0)
+            // Standard Error: 7_491
+            .saturating_add(Weight::from_parts(1_105_807, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64ne(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_190_000 picoseconds.
-        Weight::from_parts(2_258_000, 0)
-            // Standard Error: 9_983
-            .saturating_add(Weight::from_parts(1_838_257, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_088_000 picoseconds.
+        Weight::from_parts(2_171_000, 0)
+            // Standard Error: 11_841
+            .saturating_add(Weight::from_parts(1_785_140, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32ne(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_227_000 picoseconds.
-        Weight::from_parts(2_276_000, 0)
-            // Standard Error: 7_749
-            .saturating_add(Weight::from_parts(1_165_862, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_042_000 picoseconds.
+        Weight::from_parts(2_181_000, 0)
+            // Standard Error: 7_479
+            .saturating_add(Weight::from_parts(1_086_144, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64lts(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_172_000 picoseconds.
-        Weight::from_parts(2_246_000, 0)
-            // Standard Error: 11_426
-            .saturating_add(Weight::from_parts(1_828_814, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_109_000 picoseconds.
+        Weight::from_parts(2_151_000, 0)
+            // Standard Error: 13_111
+            .saturating_add(Weight::from_parts(1_829_000, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32lts(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_187_000 picoseconds.
-        Weight::from_parts(2_245_000, 0)
-            // Standard Error: 7_973
-            .saturating_add(Weight::from_parts(1_145_613, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_130_000 picoseconds.
+        Weight::from_parts(2_153_000, 0)
+            // Standard Error: 7_632
+            .saturating_add(Weight::from_parts(1_102_522, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64ltu(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_247_000 picoseconds.
-        Weight::from_parts(2_273_000, 0)
-            // Standard Error: 10_995
-            .saturating_add(Weight::from_parts(1_789_814, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_155_000 picoseconds.
+        Weight::from_parts(2_231_000, 0)
+            // Standard Error: 11_689
+            .saturating_add(Weight::from_parts(1_768_866, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32ltu(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_162_000 picoseconds.
-        Weight::from_parts(2_252_000, 0)
-            // Standard Error: 7_454
-            .saturating_add(Weight::from_parts(1_207_539, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_094_000 picoseconds.
+        Weight::from_parts(2_163_000, 0)
+            // Standard Error: 7_348
+            .saturating_add(Weight::from_parts(1_057_058, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64gts(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_219_000 picoseconds.
-        Weight::from_parts(2_279_000, 0)
-            // Standard Error: 10_576
-            .saturating_add(Weight::from_parts(1_855_075, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_095_000 picoseconds.
+        Weight::from_parts(2_142_000, 0)
+            // Standard Error: 12_173
+            .saturating_add(Weight::from_parts(1_786_184, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32gts(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_199_000 picoseconds.
-        Weight::from_parts(2_265_000, 0)
-            // Standard Error: 7_405
-            .saturating_add(Weight::from_parts(1_180_265, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_122_000 picoseconds.
+        Weight::from_parts(2_206_000, 0)
+            // Standard Error: 7_244
+            .saturating_add(Weight::from_parts(1_066_057, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64gtu(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_245_000 picoseconds.
-        Weight::from_parts(2_285_000, 0)
-            // Standard Error: 10_994
-            .saturating_add(Weight::from_parts(1_835_344, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_090_000 picoseconds.
+        Weight::from_parts(2_175_000, 0)
+            // Standard Error: 11_967
+            .saturating_add(Weight::from_parts(1_782_809, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32gtu(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_222_000 picoseconds.
-        Weight::from_parts(2_277_000, 0)
-            // Standard Error: 7_826
-            .saturating_add(Weight::from_parts(1_163_748, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_091_000 picoseconds.
+        Weight::from_parts(2_169_000, 0)
+            // Standard Error: 7_205
+            .saturating_add(Weight::from_parts(1_048_140, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64les(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_102_000 picoseconds.
-        Weight::from_parts(2_217_000, 0)
-            // Standard Error: 11_374
-            .saturating_add(Weight::from_parts(1_910_004, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_164_000 picoseconds.
+        Weight::from_parts(2_198_000, 0)
+            // Standard Error: 12_228
+            .saturating_add(Weight::from_parts(1_792_751, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32les(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_245_000 picoseconds.
-        Weight::from_parts(2_303_000, 0)
-            // Standard Error: 8_971
-            .saturating_add(Weight::from_parts(1_182_859, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_122_000 picoseconds.
+        Weight::from_parts(2_186_000, 0)
+            // Standard Error: 7_822
+            .saturating_add(Weight::from_parts(1_052_385, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64leu(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_230_000 picoseconds.
-        Weight::from_parts(2_284_000, 0)
-            // Standard Error: 12_177
-            .saturating_add(Weight::from_parts(1_866_465, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_055_000 picoseconds.
+        Weight::from_parts(2_135_000, 0)
+            // Standard Error: 12_011
+            .saturating_add(Weight::from_parts(1_789_504, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32leu(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_468_000 picoseconds.
-        Weight::from_parts(2_638_000, 0)
-            // Standard Error: 7_738
-            .saturating_add(Weight::from_parts(1_119_369, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_447_000 picoseconds.
+        Weight::from_parts(2_540_000, 0)
+            // Standard Error: 7_696
+            .saturating_add(Weight::from_parts(1_062_612, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64ges(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_191_000 picoseconds.
-        Weight::from_parts(2_286_000, 0)
-            // Standard Error: 10_340
-            .saturating_add(Weight::from_parts(1_831_738, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_077_000 picoseconds.
+        Weight::from_parts(2_107_000, 0)
+            // Standard Error: 12_070
+            .saturating_add(Weight::from_parts(1_771_498, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32ges(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_216_000 picoseconds.
-        Weight::from_parts(2_260_000, 0)
-            // Standard Error: 6_924
-            .saturating_add(Weight::from_parts(1_210_933, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_123_000 picoseconds.
+        Weight::from_parts(2_156_000, 0)
+            // Standard Error: 7_108
+            .saturating_add(Weight::from_parts(1_072_471, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64geu(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_202_000 picoseconds.
-        Weight::from_parts(2_325_000, 0)
-            // Standard Error: 9_907
-            .saturating_add(Weight::from_parts(1_822_715, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_038_000 picoseconds.
+        Weight::from_parts(2_145_000, 0)
+            // Standard Error: 11_990
+            .saturating_add(Weight::from_parts(1_786_273, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32geu(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_230_000 picoseconds.
-        Weight::from_parts(2_294_000, 0)
-            // Standard Error: 7_927
-            .saturating_add(Weight::from_parts(1_168_287, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_059_000 picoseconds.
+        Weight::from_parts(2_122_000, 0)
+            // Standard Error: 7_164
+            .saturating_add(Weight::from_parts(1_070_909, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64add(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_189_000 picoseconds.
-        Weight::from_parts(2_289_000, 0)
-            // Standard Error: 8_768
-            .saturating_add(Weight::from_parts(1_295_617, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_065_000 picoseconds.
+        Weight::from_parts(2_181_000, 0)
+            // Standard Error: 7_265
+            .saturating_add(Weight::from_parts(1_152_228, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32add(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_193_000 picoseconds.
-        Weight::from_parts(2_292_000, 0)
-            // Standard Error: 6_314
-            .saturating_add(Weight::from_parts(658_832, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_107_000 picoseconds.
+        Weight::from_parts(2_160_000, 0)
+            // Standard Error: 5_101
+            .saturating_add(Weight::from_parts(578_660, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64sub(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_258_000 picoseconds.
-        Weight::from_parts(2_312_000, 0)
-            // Standard Error: 9_261
-            .saturating_add(Weight::from_parts(1_348_699, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_130_000 picoseconds.
+        Weight::from_parts(2_184_000, 0)
+            // Standard Error: 9_299
+            .saturating_add(Weight::from_parts(1_257_633, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32sub(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_257_000 picoseconds.
-        Weight::from_parts(2_290_000, 0)
-            // Standard Error: 5_457
-            .saturating_add(Weight::from_parts(671_846, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_119_000 picoseconds.
+        Weight::from_parts(2_262_000, 0)
+            // Standard Error: 3_957
+            .saturating_add(Weight::from_parts(557_957, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64mul(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_180_000 picoseconds.
-        Weight::from_parts(2_241_000, 0)
-            // Standard Error: 11_567
-            .saturating_add(Weight::from_parts(1_835_171, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_045_000 picoseconds.
+        Weight::from_parts(2_157_000, 0)
+            // Standard Error: 10_839
+            .saturating_add(Weight::from_parts(1_686_809, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32mul(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_196_000 picoseconds.
-        Weight::from_parts(2_290_000, 0)
-            // Standard Error: 7_436
-            .saturating_add(Weight::from_parts(1_171_019, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_232_000 picoseconds.
+        Weight::from_parts(2_250_000, 0)
+            // Standard Error: 7_276
+            .saturating_add(Weight::from_parts(1_096_252, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64divs(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_195_000 picoseconds.
-        Weight::from_parts(6_299_544, 0)
-            // Standard Error: 28_028
-            .saturating_add(Weight::from_parts(2_500_140, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_107_000 picoseconds.
+        Weight::from_parts(1_434_170, 0)
+            // Standard Error: 21_965
+            .saturating_add(Weight::from_parts(2_633_663, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32divs(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_249_000 picoseconds.
-        Weight::from_parts(2_576_178, 0)
-            // Standard Error: 12_042
-            .saturating_add(Weight::from_parts(2_335_953, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_098_000 picoseconds.
+        Weight::from_parts(2_122_681, 0)
+            // Standard Error: 10_815
+            .saturating_add(Weight::from_parts(2_335_842, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64divu(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_223_000 picoseconds.
-        Weight::from_parts(8_638_891, 0)
-            // Standard Error: 32_649
-            .saturating_add(Weight::from_parts(2_462_794, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_153_000 picoseconds.
+        Weight::from_parts(145_632, 0)
+            // Standard Error: 12_320
+            .saturating_add(Weight::from_parts(2_992_427, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32divu(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_231_000 picoseconds.
-        Weight::from_parts(2_731_170, 0)
-            // Standard Error: 19_116
-            .saturating_add(Weight::from_parts(2_437_473, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_142_000 picoseconds.
+        Weight::from_parts(2_180_000, 0)
+            // Standard Error: 4_944
+            .saturating_add(Weight::from_parts(2_466_854, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64rems(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_261_000 picoseconds.
-        Weight::from_parts(1_535_146, 0)
-            // Standard Error: 30_575
-            .saturating_add(Weight::from_parts(9_634_377, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_143_000 picoseconds.
+        Weight::from_parts(2_204_000, 0)
+            // Standard Error: 14_500
+            .saturating_add(Weight::from_parts(9_530_241, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32rems(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_209_000 picoseconds.
-        Weight::from_parts(5_244_298, 0)
-            // Standard Error: 48_615
-            .saturating_add(Weight::from_parts(7_381_672, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_132_000 picoseconds.
+        Weight::from_parts(2_183_000, 0)
+            // Standard Error: 22_303
+            .saturating_add(Weight::from_parts(7_508_848, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64remu(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_260_000 picoseconds.
-        Weight::from_parts(8_453_159, 0)
-            // Standard Error: 30_530
-            .saturating_add(Weight::from_parts(2_541_459, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_133_000 picoseconds.
+        Weight::from_parts(2_183_000, 0)
+            // Standard Error: 5_407
+            .saturating_add(Weight::from_parts(2_948_013, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32remu(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_242_000 picoseconds.
-        Weight::from_parts(5_507_917, 0)
-            // Standard Error: 21_457
-            .saturating_add(Weight::from_parts(2_217_886, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_124_000 picoseconds.
+        Weight::from_parts(2_150_000, 0)
+            // Standard Error: 6_372
+            .saturating_add(Weight::from_parts(2_362_416, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64and(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_163_000 picoseconds.
-        Weight::from_parts(2_341_000, 0)
-            // Standard Error: 9_253
-            .saturating_add(Weight::from_parts(1_354_282, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_174_000 picoseconds.
+        Weight::from_parts(2_219_000, 0)
+            // Standard Error: 7_670
+            .saturating_add(Weight::from_parts(1_174_342, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32and(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_170_000 picoseconds.
-        Weight::from_parts(2_224_000, 0)
-            // Standard Error: 3_908
-            .saturating_add(Weight::from_parts(589_876, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_094_000 picoseconds.
+        Weight::from_parts(2_109_000, 0)
+            // Standard Error: 3_988
+            .saturating_add(Weight::from_parts(566_949, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64or(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_184_000 picoseconds.
-        Weight::from_parts(2_265_000, 0)
-            // Standard Error: 9_943
-            .saturating_add(Weight::from_parts(1_308_630, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_049_000 picoseconds.
+        Weight::from_parts(2_117_000, 0)
+            // Standard Error: 8_393
+            .saturating_add(Weight::from_parts(1_160_794, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32or(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_212_000 picoseconds.
-        Weight::from_parts(2_273_000, 0)
-            // Standard Error: 5_843
-            .saturating_add(Weight::from_parts(653_388, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_107_000 picoseconds.
+        Weight::from_parts(2_152_000, 0)
+            // Standard Error: 4_769
+            .saturating_add(Weight::from_parts(585_265, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64xor(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_228_000 picoseconds.
-        Weight::from_parts(2_293_000, 0)
-            // Standard Error: 9_157
-            .saturating_add(Weight::from_parts(1_290_731, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_115_000 picoseconds.
+        Weight::from_parts(2_170_000, 0)
+            // Standard Error: 7_943
+            .saturating_add(Weight::from_parts(1_185_174, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32xor(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_232_000 picoseconds.
-        Weight::from_parts(2_276_000, 0)
-            // Standard Error: 4_020
-            .saturating_add(Weight::from_parts(618_071, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_139_000 picoseconds.
+        Weight::from_parts(2_183_000, 0)
+            // Standard Error: 4_608
+            .saturating_add(Weight::from_parts(563_329, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64shl(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_239_000 picoseconds.
-        Weight::from_parts(2_292_000, 0)
-            // Standard Error: 7_192
-            .saturating_add(Weight::from_parts(1_061_312, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_144_000 picoseconds.
+        Weight::from_parts(2_178_000, 0)
+            // Standard Error: 6_727
+            .saturating_add(Weight::from_parts(1_000_757, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32shl(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_157_000 picoseconds.
-        Weight::from_parts(2_245_000, 0)
-            // Standard Error: 3_756
-            .saturating_add(Weight::from_parts(568_744, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_107_000 picoseconds.
+        Weight::from_parts(2_212_000, 0)
+            // Standard Error: 3_536
+            .saturating_add(Weight::from_parts(504_096, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64shrs(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_248_000 picoseconds.
-        Weight::from_parts(2_324_000, 0)
-            // Standard Error: 7_917
-            .saturating_add(Weight::from_parts(1_106_132, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_167_000 picoseconds.
+        Weight::from_parts(2_218_000, 0)
+            // Standard Error: 7_170
+            .saturating_add(Weight::from_parts(966_365, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32shrs(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_205_000 picoseconds.
-        Weight::from_parts(2_292_000, 0)
-            // Standard Error: 4_617
-            .saturating_add(Weight::from_parts(599_461, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_149_000 picoseconds.
+        Weight::from_parts(140_768, 0)
+            // Standard Error: 5_221
+            .saturating_add(Weight::from_parts(551_550, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64shru(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_215_000 picoseconds.
-        Weight::from_parts(2_346_000, 0)
-            // Standard Error: 7_501
-            .saturating_add(Weight::from_parts(1_125_645, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_122_000 picoseconds.
+        Weight::from_parts(2_159_000, 0)
+            // Standard Error: 7_621
+            .saturating_add(Weight::from_parts(997_420, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32shru(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_255_000 picoseconds.
-        Weight::from_parts(2_306_000, 0)
-            // Standard Error: 5_262
-            .saturating_add(Weight::from_parts(624_680, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_069_000 picoseconds.
+        Weight::from_parts(2_106_000, 0)
+            // Standard Error: 3_980
+            .saturating_add(Weight::from_parts(537_014, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64rotl(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_231_000 picoseconds.
-        Weight::from_parts(2_341_000, 0)
-            // Standard Error: 7_879
-            .saturating_add(Weight::from_parts(1_068_877, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_097_000 picoseconds.
+        Weight::from_parts(2_191_000, 0)
+            // Standard Error: 9_419
+            .saturating_add(Weight::from_parts(1_050_292, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32rotl(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_192_000 picoseconds.
-        Weight::from_parts(2_288_000, 0)
-            // Standard Error: 4_124
-            .saturating_add(Weight::from_parts(567_690, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_051_000 picoseconds.
+        Weight::from_parts(2_118_000, 0)
+            // Standard Error: 4_228
+            .saturating_add(Weight::from_parts(529_158, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64rotr(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_258_000 picoseconds.
-        Weight::from_parts(2_322_000, 0)
-            // Standard Error: 8_516
-            .saturating_add(Weight::from_parts(1_174_764, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_038_000 picoseconds.
+        Weight::from_parts(2_116_000, 0)
+            // Standard Error: 7_792
+            .saturating_add(Weight::from_parts(1_027_370, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32rotr(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_171_000 picoseconds.
-        Weight::from_parts(2_258_000, 0)
-            // Standard Error: 4_901
-            .saturating_add(Weight::from_parts(628_068, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_077_000 picoseconds.
+        Weight::from_parts(2_140_000, 0)
+            // Standard Error: 4_450
+            .saturating_add(Weight::from_parts(534_724, 0).saturating_mul(r.into()))
     }
 }
 
@@ -2115,10 +2115,10 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 965_000 picoseconds.
-        Weight::from_parts(1_020_000, 0)
-            // Standard Error: 753
-            .saturating_add(Weight::from_parts(247_354, 0).saturating_mul(c.into()))
+        // Minimum execution time: 954_000 picoseconds.
+        Weight::from_parts(1_004_000, 0)
+            // Standard Error: 802
+            .saturating_add(Weight::from_parts(249_956, 0).saturating_mul(c.into()))
             .saturating_add(RocksDbWeight::get().writes(1_u64))
     }
     /// The range of component `c` is `[0, 512]`.
@@ -2126,10 +2126,10 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `42 + c * (1024 ±0)`
         //  Estimated: `3506 + c * (1024 ±0)`
-        // Minimum execution time: 2_780_000 picoseconds.
-        Weight::from_parts(2_874_000, 3506)
-            // Standard Error: 924
-            .saturating_add(Weight::from_parts(674_078, 0).saturating_mul(c.into()))
+        // Minimum execution time: 2_808_000 picoseconds.
+        Weight::from_parts(2_895_000, 3506)
+            // Standard Error: 1_086
+            .saturating_add(Weight::from_parts(680_150, 0).saturating_mul(c.into()))
             .saturating_add(RocksDbWeight::get().reads(1_u64))
             .saturating_add(Weight::from_parts(0, 1024).saturating_mul(c.into()))
     }
@@ -2138,17 +2138,17 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 51_392_000 picoseconds.
-        Weight::from_parts(63_325_658, 0)
-            // Standard Error: 13_432
-            .saturating_add(Weight::from_parts(2_671_521, 0).saturating_mul(c.into()))
+        // Minimum execution time: 52_458_000 picoseconds.
+        Weight::from_parts(84_558_500, 0)
+            // Standard Error: 7_412
+            .saturating_add(Weight::from_parts(2_377_997, 0).saturating_mul(c.into()))
     }
     fn claim_value() -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `979`
         //  Estimated: `42236`
-        // Minimum execution time: 85_039_000 picoseconds.
-        Weight::from_parts(86_523_000, 42236)
+        // Minimum execution time: 81_302_000 picoseconds.
+        Weight::from_parts(83_307_000, 42236)
             .saturating_add(RocksDbWeight::get().reads(13_u64))
             .saturating_add(RocksDbWeight::get().writes(10_u64))
     }
@@ -2156,8 +2156,8 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `886`
         //  Estimated: `21261`
-        // Minimum execution time: 54_302_000 picoseconds.
-        Weight::from_parts(56_159_000, 21261)
+        // Minimum execution time: 52_219_000 picoseconds.
+        Weight::from_parts(53_704_000, 21261)
             .saturating_add(RocksDbWeight::get().reads(7_u64))
             .saturating_add(RocksDbWeight::get().writes(6_u64))
     }
@@ -2165,8 +2165,8 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `534`
         //  Estimated: `17070`
-        // Minimum execution time: 29_099_000 picoseconds.
-        Weight::from_parts(30_610_000, 17070)
+        // Minimum execution time: 28_408_000 picoseconds.
+        Weight::from_parts(29_714_000, 17070)
             .saturating_add(RocksDbWeight::get().reads(6_u64))
             .saturating_add(RocksDbWeight::get().writes(4_u64))
     }
@@ -2175,10 +2175,10 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `355`
         //  Estimated: `7640`
-        // Minimum execution time: 8_259_000 picoseconds.
-        Weight::from_parts(6_228_584, 7640)
-            // Standard Error: 37_556
-            .saturating_add(Weight::from_parts(16_519_610, 0).saturating_mul(c.into()))
+        // Minimum execution time: 7_918_000 picoseconds.
+        Weight::from_parts(6_745_647, 7640)
+            // Standard Error: 37_300
+            .saturating_add(Weight::from_parts(13_885_473, 0).saturating_mul(c.into()))
             .saturating_add(RocksDbWeight::get().reads(2_u64))
             .saturating_add(RocksDbWeight::get().writes(2_u64))
     }
@@ -2187,10 +2187,10 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `1297 + c * (16389 ±0)`
         //  Estimated: `40898 + c * (131112 ±0)`
-        // Minimum execution time: 70_699_000 picoseconds.
-        Weight::from_parts(71_447_000, 40898)
-            // Standard Error: 139_719
-            .saturating_add(Weight::from_parts(54_319_486, 0).saturating_mul(c.into()))
+        // Minimum execution time: 68_486_000 picoseconds.
+        Weight::from_parts(69_079_000, 40898)
+            // Standard Error: 164_982
+            .saturating_add(Weight::from_parts(55_774_264, 0).saturating_mul(c.into()))
             .saturating_add(RocksDbWeight::get().reads(11_u64))
             .saturating_add(RocksDbWeight::get().writes(9_u64))
             .saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(c.into())))
@@ -2201,10 +2201,10 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `10`
         //  Estimated: `4990`
-        // Minimum execution time: 60_906_000 picoseconds.
-        Weight::from_parts(18_999_485, 4990)
-            // Standard Error: 57_215
-            .saturating_add(Weight::from_parts(53_057_311, 0).saturating_mul(c.into()))
+        // Minimum execution time: 61_635_000 picoseconds.
+        Weight::from_parts(64_537_590, 4990)
+            // Standard Error: 40_298
+            .saturating_add(Weight::from_parts(52_820_238, 0).saturating_mul(c.into()))
             .saturating_add(RocksDbWeight::get().reads(2_u64))
             .saturating_add(RocksDbWeight::get().writes(4_u64))
     }
@@ -2213,10 +2213,10 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `671`
         //  Estimated: `38638`
-        // Minimum execution time: 65_623_000 picoseconds.
-        Weight::from_parts(88_392_610, 38638)
+        // Minimum execution time: 63_344_000 picoseconds.
+        Weight::from_parts(76_968_021, 38638)
             // Standard Error: 0
-            .saturating_add(Weight::from_parts(2_635, 0).saturating_mul(s.into()))
+            .saturating_add(Weight::from_parts(2_598, 0).saturating_mul(s.into()))
             .saturating_add(RocksDbWeight::get().reads(13_u64))
             .saturating_add(RocksDbWeight::get().writes(10_u64))
     }
@@ -2226,12 +2226,12 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `235`
         //  Estimated: `34312`
-        // Minimum execution time: 11_247_503_000 picoseconds.
-        Weight::from_parts(302_469_923, 34312)
-            // Standard Error: 147_459
-            .saturating_add(Weight::from_parts(54_400_528, 0).saturating_mul(c.into()))
-            // Standard Error: 8
-            .saturating_add(Weight::from_parts(2_571, 0).saturating_mul(s.into()))
+        // Minimum execution time: 10_980_969_000 picoseconds.
+        Weight::from_parts(301_891_685, 34312)
+            // Standard Error: 164_203
+            .saturating_add(Weight::from_parts(54_383_779, 0).saturating_mul(c.into()))
+            // Standard Error: 9
+            .saturating_add(Weight::from_parts(2_548, 0).saturating_mul(s.into()))
             .saturating_add(RocksDbWeight::get().reads(13_u64))
             .saturating_add(RocksDbWeight::get().writes(14_u64))
     }
@@ -2240,10 +2240,10 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `348`
         //  Estimated: `23853`
-        // Minimum execution time: 56_802_000 picoseconds.
-        Weight::from_parts(33_250_791, 23853)
-            // Standard Error: 1
-            .saturating_add(Weight::from_parts(1_182, 0).saturating_mul(p.into()))
+        // Minimum execution time: 53_732_000 picoseconds.
+        Weight::from_parts(35_204_611, 23853)
+            // Standard Error: 0
+            .saturating_add(Weight::from_parts(1_021, 0).saturating_mul(p.into()))
             .saturating_add(RocksDbWeight::get().reads(9_u64))
             .saturating_add(RocksDbWeight::get().writes(8_u64))
     }
@@ -2252,10 +2252,10 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `451`
         //  Estimated: `27177`
-        // Minimum execution time: 59_487_000 picoseconds.
-        Weight::from_parts(37_481_444, 27177)
-            // Standard Error: 1
-            .saturating_add(Weight::from_parts(1_182, 0).saturating_mul(p.into()))
+        // Minimum execution time: 57_078_000 picoseconds.
+        Weight::from_parts(37_366_780, 27177)
+            // Standard Error: 0
+            .saturating_add(Weight::from_parts(1_023, 0).saturating_mul(p.into()))
             .saturating_add(RocksDbWeight::get().reads(10_u64))
             .saturating_add(RocksDbWeight::get().writes(9_u64))
     }
@@ -2264,10 +2264,10 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `978`
         //  Estimated: `42227`
-        // Minimum execution time: 86_239_000 picoseconds.
-        Weight::from_parts(32_106_516, 42227)
-            // Standard Error: 3
-            .saturating_add(Weight::from_parts(1_249, 0).saturating_mul(p.into()))
+        // Minimum execution time: 82_297_000 picoseconds.
+        Weight::from_parts(62_302_593, 42227)
+            // Standard Error: 1
+            .saturating_add(Weight::from_parts(1_042, 0).saturating_mul(p.into()))
             .saturating_add(RocksDbWeight::get().reads(13_u64))
             .saturating_add(RocksDbWeight::get().writes(10_u64))
     }
@@ -2276,10 +2276,10 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `1081`
         //  Estimated: `45757`
-        // Minimum execution time: 98_413_000 picoseconds.
-        Weight::from_parts(52_381_439, 45757)
-            // Standard Error: 3
-            .saturating_add(Weight::from_parts(1_252, 0).saturating_mul(p.into()))
+        // Minimum execution time: 93_602_000 picoseconds.
+        Weight::from_parts(69_941_334, 45757)
+            // Standard Error: 1
+            .saturating_add(Weight::from_parts(1_057, 0).saturating_mul(p.into()))
             .saturating_add(RocksDbWeight::get().reads(14_u64))
             .saturating_add(RocksDbWeight::get().writes(11_u64))
     }
@@ -2288,8 +2288,8 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `760`
         //  Estimated: `74319`
-        // Minimum execution time: 302_634_000 picoseconds.
-        Weight::from_parts(320_223_637, 74319)
+        // Minimum execution time: 298_083_000 picoseconds.
+        Weight::from_parts(314_192_353, 74319)
             .saturating_add(RocksDbWeight::get().reads(27_u64))
             .saturating_add(RocksDbWeight::get().writes(22_u64))
     }
@@ -2298,10 +2298,10 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `760`
         //  Estimated: `74319`
-        // Minimum execution time: 315_859_000 picoseconds.
-        Weight::from_parts(328_138_594, 74319)
-            // Standard Error: 1_557
-            .saturating_add(Weight::from_parts(8_014, 0).saturating_mul(q.into()))
+        // Minimum execution time: 312_856_000 picoseconds.
+        Weight::from_parts(326_607_586, 74319)
+            // Standard Error: 1_507
+            .saturating_add(Weight::from_parts(723, 0).saturating_mul(q.into()))
             .saturating_add(RocksDbWeight::get().reads(27_u64))
             .saturating_add(RocksDbWeight::get().writes(22_u64))
     }
@@ -2310,10 +2310,10 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `211 + c * (1075 ±0)`
         //  Estimated: `3899 + c * (2150 ±0)`
-        // Minimum execution time: 45_804_000 picoseconds.
-        Weight::from_parts(46_226_000, 3899)
-            // Standard Error: 51_090
-            .saturating_add(Weight::from_parts(51_940_069, 0).saturating_mul(c.into()))
+        // Minimum execution time: 45_478_000 picoseconds.
+        Weight::from_parts(45_769_000, 3899)
+            // Standard Error: 42_221
+            .saturating_add(Weight::from_parts(51_492_007, 0).saturating_mul(c.into()))
             .saturating_add(RocksDbWeight::get().reads(1_u64))
             .saturating_add(RocksDbWeight::get().writes(2_u64))
             .saturating_add(Weight::from_parts(0, 2150).saturating_mul(c.into()))
@@ -2323,630 +2323,630 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 80_872_000 picoseconds.
-        Weight::from_parts(82_358_000, 0)
-            // Standard Error: 3_946_533
-            .saturating_add(Weight::from_parts(617_270_552, 0).saturating_mul(r.into()))
+        // Minimum execution time: 85_248_000 picoseconds.
+        Weight::from_parts(87_224_000, 0)
+            // Standard Error: 4_031_043
+            .saturating_add(Weight::from_parts(559_145_890, 0).saturating_mul(r.into()))
     }
     /// The range of component `p` is `[1, 512]`.
     fn alloc_per_page(p: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 365_182_000 picoseconds.
-        Weight::from_parts(292_523_651, 0)
-            // Standard Error: 7_087
-            .saturating_add(Weight::from_parts(31_059_002, 0).saturating_mul(p.into()))
+        // Minimum execution time: 304_310_000 picoseconds.
+        Weight::from_parts(240_640_662, 0)
+            // Standard Error: 7_875
+            .saturating_add(Weight::from_parts(30_931_778, 0).saturating_mul(p.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn free(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 196_771_000 picoseconds.
-        Weight::from_parts(219_836_156, 0)
-            // Standard Error: 406_704
-            .saturating_add(Weight::from_parts(120_742_843, 0).saturating_mul(r.into()))
+        // Minimum execution time: 144_728_000 picoseconds.
+        Weight::from_parts(127_694_995, 0)
+            // Standard Error: 344_021
+            .saturating_add(Weight::from_parts(63_008_235, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 256]`.
     fn gr_reserve_gas(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 86_043_000 picoseconds.
-        Weight::from_parts(92_117_781, 0)
-            // Standard Error: 7_334
-            .saturating_add(Weight::from_parts(3_640_301, 0).saturating_mul(r.into()))
+        // Minimum execution time: 85_763_000 picoseconds.
+        Weight::from_parts(93_302_515, 0)
+            // Standard Error: 3_873
+            .saturating_add(Weight::from_parts(2_723_217, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 256]`.
     fn gr_unreserve_gas(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 146_803_000 picoseconds.
-        Weight::from_parts(168_908_676, 0)
-            // Standard Error: 28_070
-            .saturating_add(Weight::from_parts(3_989_643, 0).saturating_mul(r.into()))
+        // Minimum execution time: 134_987_000 picoseconds.
+        Weight::from_parts(141_052_149, 0)
+            // Standard Error: 29_498
+            .saturating_add(Weight::from_parts(3_252_053, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_system_reserve_gas(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 82_421_000 picoseconds.
-        Weight::from_parts(109_902_108, 0)
-            // Standard Error: 458_197
-            .saturating_add(Weight::from_parts(186_560_355, 0).saturating_mul(r.into()))
+        // Minimum execution time: 82_532_000 picoseconds.
+        Weight::from_parts(111_956_884, 0)
+            // Standard Error: 420_651
+            .saturating_add(Weight::from_parts(124_761_103, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_message_id(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 85_173_000 picoseconds.
-        Weight::from_parts(81_703_608, 0)
-            // Standard Error: 318_823
-            .saturating_add(Weight::from_parts(183_602_076, 0).saturating_mul(r.into()))
+        // Minimum execution time: 82_442_000 picoseconds.
+        Weight::from_parts(76_262_730, 0)
+            // Standard Error: 310_067
+            .saturating_add(Weight::from_parts(115_334_131, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_program_id(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 85_999_000 picoseconds.
-        Weight::from_parts(81_002_605, 0)
-            // Standard Error: 269_075
-            .saturating_add(Weight::from_parts(183_154_106, 0).saturating_mul(r.into()))
+        // Minimum execution time: 82_322_000 picoseconds.
+        Weight::from_parts(71_153_919, 0)
+            // Standard Error: 293_317
+            .saturating_add(Weight::from_parts(115_508_333, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_source(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 82_306_000 picoseconds.
-        Weight::from_parts(79_166_166, 0)
-            // Standard Error: 332_502
-            .saturating_add(Weight::from_parts(182_666_522, 0).saturating_mul(r.into()))
+        // Minimum execution time: 82_586_000 picoseconds.
+        Weight::from_parts(73_401_225, 0)
+            // Standard Error: 306_089
+            .saturating_add(Weight::from_parts(115_530_298, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_value(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 82_459_000 picoseconds.
-        Weight::from_parts(80_301_392, 0)
-            // Standard Error: 340_598
-            .saturating_add(Weight::from_parts(184_099_120, 0).saturating_mul(r.into()))
+        // Minimum execution time: 86_537_000 picoseconds.
+        Weight::from_parts(80_327_682, 0)
+            // Standard Error: 275_679
+            .saturating_add(Weight::from_parts(114_024_859, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_value_available(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 81_140_000 picoseconds.
-        Weight::from_parts(72_987_262, 0)
-            // Standard Error: 388_909
-            .saturating_add(Weight::from_parts(186_920_851, 0).saturating_mul(r.into()))
+        // Minimum execution time: 84_226_000 picoseconds.
+        Weight::from_parts(74_308_323, 0)
+            // Standard Error: 291_460
+            .saturating_add(Weight::from_parts(115_396_428, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_gas_available(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 81_336_000 picoseconds.
-        Weight::from_parts(79_078_269, 0)
-            // Standard Error: 276_322
-            .saturating_add(Weight::from_parts(182_690_178, 0).saturating_mul(r.into()))
+        // Minimum execution time: 81_250_000 picoseconds.
+        Weight::from_parts(74_761_588, 0)
+            // Standard Error: 317_797
+            .saturating_add(Weight::from_parts(115_173_001, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_size(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 84_201_000 picoseconds.
-        Weight::from_parts(79_459_558, 0)
-            // Standard Error: 357_406
-            .saturating_add(Weight::from_parts(182_989_857, 0).saturating_mul(r.into()))
+        // Minimum execution time: 85_673_000 picoseconds.
+        Weight::from_parts(70_907_772, 0)
+            // Standard Error: 347_682
+            .saturating_add(Weight::from_parts(118_189_625, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_read(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 709_298_000 picoseconds.
-        Weight::from_parts(792_701_124, 0)
-            // Standard Error: 581_476
-            .saturating_add(Weight::from_parts(264_833_637, 0).saturating_mul(r.into()))
+        // Minimum execution time: 700_530_000 picoseconds.
+        Weight::from_parts(774_384_678, 0)
+            // Standard Error: 512_748
+            .saturating_add(Weight::from_parts(194_331_468, 0).saturating_mul(r.into()))
     }
     /// The range of component `n` is `[0, 2048]`.
     fn gr_read_per_kb(n: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 958_553_000 picoseconds.
-        Weight::from_parts(1_002_082_000, 0)
-            // Standard Error: 51_056
-            .saturating_add(Weight::from_parts(13_349_580, 0).saturating_mul(n.into()))
+        // Minimum execution time: 866_889_000 picoseconds.
+        Weight::from_parts(872_993_000, 0)
+            // Standard Error: 59_048
+            .saturating_add(Weight::from_parts(13_399_620, 0).saturating_mul(n.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_block_height(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 81_092_000 picoseconds.
-        Weight::from_parts(70_460_333, 0)
-            // Standard Error: 322_779
-            .saturating_add(Weight::from_parts(182_652_206, 0).saturating_mul(r.into()))
+        // Minimum execution time: 85_291_000 picoseconds.
+        Weight::from_parts(75_543_485, 0)
+            // Standard Error: 320_701
+            .saturating_add(Weight::from_parts(115_757_456, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_block_timestamp(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 82_315_000 picoseconds.
-        Weight::from_parts(77_285_940, 0)
-            // Standard Error: 310_862
-            .saturating_add(Weight::from_parts(183_154_588, 0).saturating_mul(r.into()))
+        // Minimum execution time: 83_780_000 picoseconds.
+        Weight::from_parts(68_090_338, 0)
+            // Standard Error: 330_050
+            .saturating_add(Weight::from_parts(117_803_137, 0).saturating_mul(r.into()))
     }
     /// The range of component `n` is `[0, 20]`.
     fn gr_random(n: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 82_813_000 picoseconds.
-        Weight::from_parts(83_631_977, 0)
-            // Standard Error: 426_894
-            .saturating_add(Weight::from_parts(250_044_040, 0).saturating_mul(n.into()))
+        // Minimum execution time: 84_394_000 picoseconds.
+        Weight::from_parts(88_472_912, 0)
+            // Standard Error: 340_524
+            .saturating_add(Weight::from_parts(190_044_477, 0).saturating_mul(n.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_reply_deposit(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 87_342_000 picoseconds.
-        Weight::from_parts(88_861_000, 0)
-            // Standard Error: 4_034_065
-            .saturating_add(Weight::from_parts(1_070_363_129, 0).saturating_mul(r.into()))
+        // Minimum execution time: 83_081_000 picoseconds.
+        Weight::from_parts(85_006_000, 0)
+            // Standard Error: 3_456_961
+            .saturating_add(Weight::from_parts(860_188_117, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_send(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 82_887_000 picoseconds.
-        Weight::from_parts(154_402_402, 0)
-            // Standard Error: 504_137
-            .saturating_add(Weight::from_parts(389_538_545, 0).saturating_mul(r.into()))
+        // Minimum execution time: 81_490_000 picoseconds.
+        Weight::from_parts(136_619_765, 0)
+            // Standard Error: 439_674
+            .saturating_add(Weight::from_parts(308_552_304, 0).saturating_mul(r.into()))
     }
     /// The range of component `n` is `[0, 2048]`.
     fn gr_send_per_kb(n: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 467_573_000 picoseconds.
-        Weight::from_parts(471_685_000, 0)
-            // Standard Error: 64_140
-            .saturating_add(Weight::from_parts(22_109_126, 0).saturating_mul(n.into()))
+        // Minimum execution time: 386_929_000 picoseconds.
+        Weight::from_parts(393_325_000, 0)
+            // Standard Error: 61_932
+            .saturating_add(Weight::from_parts(21_101_790, 0).saturating_mul(n.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_send_wgas(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 86_853_000 picoseconds.
-        Weight::from_parts(152_053_498, 0)
-            // Standard Error: 538_330
-            .saturating_add(Weight::from_parts(397_711_575, 0).saturating_mul(r.into()))
+        // Minimum execution time: 84_625_000 picoseconds.
+        Weight::from_parts(162_584_483, 0)
+            // Standard Error: 494_553
+            .saturating_add(Weight::from_parts(313_684_139, 0).saturating_mul(r.into()))
     }
     /// The range of component `n` is `[0, 2048]`.
     fn gr_send_wgas_per_kb(n: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 471_875_000 picoseconds.
-        Weight::from_parts(475_692_000, 0)
-            // Standard Error: 57_997
-            .saturating_add(Weight::from_parts(21_385_701, 0).saturating_mul(n.into()))
+        // Minimum execution time: 390_932_000 picoseconds.
+        Weight::from_parts(393_883_000, 0)
+            // Standard Error: 68_646
+            .saturating_add(Weight::from_parts(21_188_381, 0).saturating_mul(n.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_send_input(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 716_684_000 picoseconds.
-        Weight::from_parts(781_328_373, 0)
-            // Standard Error: 479_933
-            .saturating_add(Weight::from_parts(411_727_995, 0).saturating_mul(r.into()))
+        // Minimum execution time: 708_623_000 picoseconds.
+        Weight::from_parts(781_094_266, 0)
+            // Standard Error: 460_683
+            .saturating_add(Weight::from_parts(328_993_362, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_send_input_wgas(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 746_421_000 picoseconds.
-        Weight::from_parts(889_163_923, 0)
-            // Standard Error: 621_967
-            .saturating_add(Weight::from_parts(412_763_026, 0).saturating_mul(r.into()))
+        // Minimum execution time: 710_228_000 picoseconds.
+        Weight::from_parts(774_190_634, 0)
+            // Standard Error: 483_646
+            .saturating_add(Weight::from_parts(330_057_876, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_send_init(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 81_961_000 picoseconds.
-        Weight::from_parts(86_031_226, 0)
-            // Standard Error: 355_690
-            .saturating_add(Weight::from_parts(191_347_968, 0).saturating_mul(r.into()))
+        // Minimum execution time: 83_510_000 picoseconds.
+        Weight::from_parts(64_097_635, 0)
+            // Standard Error: 358_570
+            .saturating_add(Weight::from_parts(126_095_109, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_send_push(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 3_797_807_000 picoseconds.
-        Weight::from_parts(3_948_397_472, 0)
-            // Standard Error: 396_090
-            .saturating_add(Weight::from_parts(284_341_649, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_430_098_000 picoseconds.
+        Weight::from_parts(2_605_278_898, 0)
+            // Standard Error: 439_185
+            .saturating_add(Weight::from_parts(217_479_981, 0).saturating_mul(r.into()))
     }
     /// The range of component `n` is `[0, 2048]`.
     fn gr_send_push_per_kb(n: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 485_799_000 picoseconds.
-        Weight::from_parts(486_862_000, 0)
-            // Standard Error: 47_704
-            .saturating_add(Weight::from_parts(31_360_292, 0).saturating_mul(n.into()))
+        // Minimum execution time: 358_553_000 picoseconds.
+        Weight::from_parts(364_183_000, 0)
+            // Standard Error: 51_397
+            .saturating_add(Weight::from_parts(30_914_040, 0).saturating_mul(n.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_send_commit(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 3_842_120_000 picoseconds.
-        Weight::from_parts(3_943_431_716, 0)
-            // Standard Error: 766_406
-            .saturating_add(Weight::from_parts(339_379_953, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_464_581_000 picoseconds.
+        Weight::from_parts(2_580_044_243, 0)
+            // Standard Error: 461_216
+            .saturating_add(Weight::from_parts(272_575_116, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_send_commit_wgas(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 3_828_327_000 picoseconds.
-        Weight::from_parts(3_976_283_101, 0)
-            // Standard Error: 768_169
-            .saturating_add(Weight::from_parts(353_252_083, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_438_114_000 picoseconds.
+        Weight::from_parts(2_597_881_615, 0)
+            // Standard Error: 400_982
+            .saturating_add(Weight::from_parts(275_718_502, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_reservation_send(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 256_679_000 picoseconds.
-        Weight::from_parts(330_245_572, 0)
-            // Standard Error: 519_345
-            .saturating_add(Weight::from_parts(404_879_225, 0).saturating_mul(r.into()))
+        // Minimum execution time: 244_206_000 picoseconds.
+        Weight::from_parts(321_175_021, 0)
+            // Standard Error: 460_445
+            .saturating_add(Weight::from_parts(322_059_081, 0).saturating_mul(r.into()))
     }
     /// The range of component `n` is `[0, 2048]`.
     fn gr_reservation_send_per_kb(n: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 640_004_000 picoseconds.
-        Weight::from_parts(646_769_000, 0)
-            // Standard Error: 55_122
-            .saturating_add(Weight::from_parts(21_616_125, 0).saturating_mul(n.into()))
+        // Minimum execution time: 559_346_000 picoseconds.
+        Weight::from_parts(571_004_000, 0)
+            // Standard Error: 59_840
+            .saturating_add(Weight::from_parts(21_370_093, 0).saturating_mul(n.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_reservation_send_commit(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 3_981_155_000 picoseconds.
-        Weight::from_parts(4_086_072_221, 0)
-            // Standard Error: 1_076_069
-            .saturating_add(Weight::from_parts(362_989_310, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_620_633_000 picoseconds.
+        Weight::from_parts(2_741_869_292, 0)
+            // Standard Error: 620_120
+            .saturating_add(Weight::from_parts(289_781_719, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 1]`.
     fn gr_reply(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 84_145_000 picoseconds.
-        Weight::from_parts(88_260_563, 0)
-            // Standard Error: 277_576
-            .saturating_add(Weight::from_parts(20_209_036, 0).saturating_mul(r.into()))
+        // Minimum execution time: 83_438_000 picoseconds.
+        Weight::from_parts(86_817_816, 0)
+            // Standard Error: 234_731
+            .saturating_add(Weight::from_parts(19_849_283, 0).saturating_mul(r.into()))
     }
     /// The range of component `n` is `[0, 2048]`.
     fn gr_reply_per_kb(n: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 102_930_000 picoseconds.
-        Weight::from_parts(90_280_376, 0)
-            // Standard Error: 1_072
-            .saturating_add(Weight::from_parts(427_777, 0).saturating_mul(n.into()))
+        // Minimum execution time: 105_002_000 picoseconds.
+        Weight::from_parts(88_114_999, 0)
+            // Standard Error: 1_128
+            .saturating_add(Weight::from_parts(427_426, 0).saturating_mul(n.into()))
     }
     /// The range of component `r` is `[0, 1]`.
     fn gr_reply_wgas(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 84_156_000 picoseconds.
-        Weight::from_parts(89_778_763, 0)
-            // Standard Error: 365_767
-            .saturating_add(Weight::from_parts(24_157_936, 0).saturating_mul(r.into()))
+        // Minimum execution time: 82_436_000 picoseconds.
+        Weight::from_parts(88_440_285, 0)
+            // Standard Error: 277_544
+            .saturating_add(Weight::from_parts(17_399_914, 0).saturating_mul(r.into()))
     }
     /// The range of component `n` is `[0, 2048]`.
     fn gr_reply_wgas_per_kb(n: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 105_315_000 picoseconds.
-        Weight::from_parts(94_894_394, 0)
-            // Standard Error: 993
-            .saturating_add(Weight::from_parts(426_364, 0).saturating_mul(n.into()))
+        // Minimum execution time: 103_800_000 picoseconds.
+        Weight::from_parts(89_756_983, 0)
+            // Standard Error: 907
+            .saturating_add(Weight::from_parts(428_998, 0).saturating_mul(n.into()))
     }
     /// The range of component `r` is `[0, 1]`.
     fn gr_reply_commit(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 81_595_000 picoseconds.
-        Weight::from_parts(86_259_504, 0)
-            // Standard Error: 284_882
-            .saturating_add(Weight::from_parts(25_873_595, 0).saturating_mul(r.into()))
+        // Minimum execution time: 81_754_000 picoseconds.
+        Weight::from_parts(87_296_014, 0)
+            // Standard Error: 336_747
+            .saturating_add(Weight::from_parts(20_299_385, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 1]`.
     fn gr_reply_commit_wgas(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 80_771_000 picoseconds.
-        Weight::from_parts(85_313_802, 0)
-            // Standard Error: 265_474
-            .saturating_add(Weight::from_parts(25_863_597, 0).saturating_mul(r.into()))
+        // Minimum execution time: 81_952_000 picoseconds.
+        Weight::from_parts(86_840_575, 0)
+            // Standard Error: 272_708
+            .saturating_add(Weight::from_parts(19_217_524, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_reply_push(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 82_396_000 picoseconds.
-        Weight::from_parts(126_819_617, 0)
-            // Standard Error: 518_749
-            .saturating_add(Weight::from_parts(272_821_836, 0).saturating_mul(r.into()))
+        // Minimum execution time: 85_498_000 picoseconds.
+        Weight::from_parts(126_431_779, 0)
+            // Standard Error: 460_480
+            .saturating_add(Weight::from_parts(198_940_536, 0).saturating_mul(r.into()))
     }
     /// The range of component `n` is `[0, 8192]`.
     fn gr_reply_push_per_kb(n: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 98_266_000 picoseconds.
-        Weight::from_parts(100_843_000, 0)
-            // Standard Error: 2_828
-            .saturating_add(Weight::from_parts(662_117, 0).saturating_mul(n.into()))
+        // Minimum execution time: 96_862_000 picoseconds.
+        Weight::from_parts(98_611_000, 0)
+            // Standard Error: 2_677
+            .saturating_add(Weight::from_parts(662_266, 0).saturating_mul(n.into()))
     }
     /// The range of component `r` is `[0, 1]`.
     fn gr_reply_input(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 707_150_000 picoseconds.
-        Weight::from_parts(754_398_128, 0)
-            // Standard Error: 5_119_788
-            .saturating_add(Weight::from_parts(7_037_071, 0).saturating_mul(r.into()))
+        // Minimum execution time: 698_914_000 picoseconds.
+        Weight::from_parts(718_405_100, 0)
+            // Standard Error: 1_891_960
+            .saturating_add(Weight::from_parts(24_867_800, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 1]`.
     fn gr_reply_input_wgas(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 712_091_000 picoseconds.
-        Weight::from_parts(751_999_544, 0)
-            // Standard Error: 4_003_265
-            .saturating_add(Weight::from_parts(43_818_555, 0).saturating_mul(r.into()))
+        // Minimum execution time: 699_975_000 picoseconds.
+        Weight::from_parts(718_806_789, 0)
+            // Standard Error: 1_919_531
+            .saturating_add(Weight::from_parts(51_192_710, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 1]`.
     fn gr_reservation_reply(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 92_234_000 picoseconds.
-        Weight::from_parts(96_192_773, 0)
-            // Standard Error: 271_871
-            .saturating_add(Weight::from_parts(13_338_726, 0).saturating_mul(r.into()))
+        // Minimum execution time: 95_002_000 picoseconds.
+        Weight::from_parts(99_331_989, 0)
+            // Standard Error: 287_602
+            .saturating_add(Weight::from_parts(9_719_710, 0).saturating_mul(r.into()))
     }
     /// The range of component `n` is `[0, 2048]`.
     fn gr_reservation_reply_per_kb(n: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 108_190_000 picoseconds.
-        Weight::from_parts(92_525_926, 0)
-            // Standard Error: 1_134
-            .saturating_add(Weight::from_parts(433_806, 0).saturating_mul(n.into()))
+        // Minimum execution time: 102_501_000 picoseconds.
+        Weight::from_parts(87_026_327, 0)
+            // Standard Error: 1_214
+            .saturating_add(Weight::from_parts(429_134, 0).saturating_mul(n.into()))
     }
     /// The range of component `r` is `[0, 1]`.
     fn gr_reservation_reply_commit(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 92_297_000 picoseconds.
-        Weight::from_parts(98_054_616, 0)
-            // Standard Error: 394_791
-            .saturating_add(Weight::from_parts(7_680_683, 0).saturating_mul(r.into()))
+        // Minimum execution time: 93_228_000 picoseconds.
+        Weight::from_parts(97_923_691, 0)
+            // Standard Error: 288_469
+            .saturating_add(Weight::from_parts(9_669_908, 0).saturating_mul(r.into()))
     }
     /// The range of component `n` is `[0, 2048]`.
     fn gr_reservation_reply_commit_per_kb(n: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 106_932_000 picoseconds.
-        Weight::from_parts(91_150_785, 0)
-            // Standard Error: 1_067
-            .saturating_add(Weight::from_parts(424_570, 0).saturating_mul(n.into()))
+        // Minimum execution time: 100_908_000 picoseconds.
+        Weight::from_parts(87_613_705, 0)
+            // Standard Error: 1_237
+            .saturating_add(Weight::from_parts(431_412, 0).saturating_mul(n.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_reply_to(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 80_591_000 picoseconds.
-        Weight::from_parts(79_590_461, 0)
-            // Standard Error: 360_038
-            .saturating_add(Weight::from_parts(185_313_242, 0).saturating_mul(r.into()))
+        // Minimum execution time: 84_385_000 picoseconds.
+        Weight::from_parts(74_453_057, 0)
+            // Standard Error: 309_931
+            .saturating_add(Weight::from_parts(117_172_527, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_signal_from(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 83_379_000 picoseconds.
-        Weight::from_parts(82_304_672, 0)
-            // Standard Error: 371_508
-            .saturating_add(Weight::from_parts(184_895_719, 0).saturating_mul(r.into()))
+        // Minimum execution time: 82_437_000 picoseconds.
+        Weight::from_parts(78_951_443, 0)
+            // Standard Error: 294_227
+            .saturating_add(Weight::from_parts(116_066_384, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_reply_push_input(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 714_906_000 picoseconds.
-        Weight::from_parts(784_837_322, 0)
-            // Standard Error: 485_874
-            .saturating_add(Weight::from_parts(198_529_306, 0).saturating_mul(r.into()))
+        // Minimum execution time: 704_954_000 picoseconds.
+        Weight::from_parts(752_735_182, 0)
+            // Standard Error: 455_998
+            .saturating_add(Weight::from_parts(135_154_607, 0).saturating_mul(r.into()))
     }
     /// The range of component `n` is `[0, 2048]`.
     fn gr_reply_push_input_per_kb(n: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 735_164_000 picoseconds.
-        Weight::from_parts(760_829_418, 0)
-            // Standard Error: 2_049
-            .saturating_add(Weight::from_parts(164_862, 0).saturating_mul(n.into()))
+        // Minimum execution time: 724_451_000 picoseconds.
+        Weight::from_parts(738_722_668, 0)
+            // Standard Error: 1_014
+            .saturating_add(Weight::from_parts(154_329, 0).saturating_mul(n.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_send_push_input(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 4_467_125_000 picoseconds.
-        Weight::from_parts(4_668_343_697, 0)
-            // Standard Error: 529_569
-            .saturating_add(Weight::from_parts(214_709_155, 0).saturating_mul(r.into()))
+        // Minimum execution time: 3_092_586_000 picoseconds.
+        Weight::from_parts(3_231_311_035, 0)
+            // Standard Error: 506_742
+            .saturating_add(Weight::from_parts(159_545_582, 0).saturating_mul(r.into()))
     }
     /// The range of component `n` is `[0, 2048]`.
     fn gr_send_push_input_per_kb(n: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 4_716_693_000 picoseconds.
-        Weight::from_parts(4_810_590_943, 0)
-            // Standard Error: 12_440
-            .saturating_add(Weight::from_parts(13_814_475, 0).saturating_mul(n.into()))
+        // Minimum execution time: 3_299_872_000 picoseconds.
+        Weight::from_parts(3_317_022_894, 0)
+            // Standard Error: 8_542
+            .saturating_add(Weight::from_parts(13_645_472, 0).saturating_mul(n.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_debug(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 81_721_000 picoseconds.
-        Weight::from_parts(95_360_878, 0)
-            // Standard Error: 488_163
-            .saturating_add(Weight::from_parts(198_923_476, 0).saturating_mul(r.into()))
+        // Minimum execution time: 85_966_000 picoseconds.
+        Weight::from_parts(106_319_310, 0)
+            // Standard Error: 424_534
+            .saturating_add(Weight::from_parts(139_885_203, 0).saturating_mul(r.into()))
     }
     /// The range of component `n` is `[0, 2048]`.
     fn gr_debug_per_kb(n: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 189_069_000 picoseconds.
-        Weight::from_parts(191_834_000, 0)
-            // Standard Error: 53_942
-            .saturating_add(Weight::from_parts(26_059_121, 0).saturating_mul(n.into()))
+        // Minimum execution time: 142_910_000 picoseconds.
+        Weight::from_parts(144_843_000, 0)
+            // Standard Error: 54_401
+            .saturating_add(Weight::from_parts(25_535_472, 0).saturating_mul(n.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_reply_code(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 83_023_000 picoseconds.
-        Weight::from_parts(70_919_161, 0)
-            // Standard Error: 442_134
-            .saturating_add(Weight::from_parts(186_467_769, 0).saturating_mul(r.into()))
+        // Minimum execution time: 82_117_000 picoseconds.
+        Weight::from_parts(80_202_149, 0)
+            // Standard Error: 296_880
+            .saturating_add(Weight::from_parts(114_586_990, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 1]`.
     fn gr_exit(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 80_187_000 picoseconds.
-        Weight::from_parts(86_256_124, 0)
-            // Standard Error: 333_120
-            .saturating_add(Weight::from_parts(27_182_075, 0).saturating_mul(r.into()))
+        // Minimum execution time: 81_802_000 picoseconds.
+        Weight::from_parts(85_064_295, 0)
+            // Standard Error: 248_874
+            .saturating_add(Weight::from_parts(27_314_604, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 1]`.
     fn gr_leave(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 80_373_000 picoseconds.
-        Weight::from_parts(83_957_387, 0)
-            // Standard Error: 258_914
-            .saturating_add(Weight::from_parts(14_637_112, 0).saturating_mul(r.into()))
+        // Minimum execution time: 82_854_000 picoseconds.
+        Weight::from_parts(86_180_314, 0)
+            // Standard Error: 239_162
+            .saturating_add(Weight::from_parts(16_391_885, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 1]`.
     fn gr_wait(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 82_886_000 picoseconds.
-        Weight::from_parts(86_536_767, 0)
-            // Standard Error: 237_087
-            .saturating_add(Weight::from_parts(15_456_732, 0).saturating_mul(r.into()))
+        // Minimum execution time: 80_883_000 picoseconds.
+        Weight::from_parts(87_058_214, 0)
+            // Standard Error: 256_392
+            .saturating_add(Weight::from_parts(13_333_285, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 1]`.
     fn gr_wait_for(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 82_962_000 picoseconds.
-        Weight::from_parts(87_038_165, 0)
-            // Standard Error: 267_652
-            .saturating_add(Weight::from_parts(14_141_234, 0).saturating_mul(r.into()))
+        // Minimum execution time: 81_417_000 picoseconds.
+        Weight::from_parts(85_403_451, 0)
+            // Standard Error: 249_767
+            .saturating_add(Weight::from_parts(14_474_948, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 1]`.
     fn gr_wait_up_to(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 82_976_000 picoseconds.
-        Weight::from_parts(87_105_967, 0)
-            // Standard Error: 237_581
-            .saturating_add(Weight::from_parts(13_365_932, 0).saturating_mul(r.into()))
+        // Minimum execution time: 84_020_000 picoseconds.
+        Weight::from_parts(88_080_622, 0)
+            // Standard Error: 253_221
+            .saturating_add(Weight::from_parts(11_403_277, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_wake(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 139_585_000 picoseconds.
-        Weight::from_parts(203_512_831, 0)
-            // Standard Error: 393_346
-            .saturating_add(Weight::from_parts(283_538_921, 0).saturating_mul(r.into()))
+        // Minimum execution time: 138_317_000 picoseconds.
+        Weight::from_parts(187_894_162, 0)
+            // Standard Error: 376_519
+            .saturating_add(Weight::from_parts(209_723_429, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_create_program(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 98_330_000 picoseconds.
-        Weight::from_parts(158_669_516, 0)
-            // Standard Error: 440_421
-            .saturating_add(Weight::from_parts(473_163_025, 0).saturating_mul(r.into()))
+        // Minimum execution time: 93_047_000 picoseconds.
+        Weight::from_parts(151_715_771, 0)
+            // Standard Error: 425_606
+            .saturating_add(Weight::from_parts(396_733_544, 0).saturating_mul(r.into()))
     }
     /// The range of component `p` is `[0, 2048]`.
     /// The range of component `s` is `[1, 2048]`.
@@ -2954,22 +2954,22 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 43_492_772_000 picoseconds.
-        Weight::from_parts(43_692_998_000, 0)
-            // Standard Error: 263_249
-            .saturating_add(Weight::from_parts(8_169_821, 0).saturating_mul(p.into()))
-            // Standard Error: 263_236
-            .saturating_add(Weight::from_parts(180_732_778, 0).saturating_mul(s.into()))
+        // Minimum execution time: 45_923_081_000 picoseconds.
+        Weight::from_parts(45_981_736_000, 0)
+            // Standard Error: 274_662
+            .saturating_add(Weight::from_parts(6_858_186, 0).saturating_mul(p.into()))
+            // Standard Error: 274_649
+            .saturating_add(Weight::from_parts(177_291_831, 0).saturating_mul(s.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_create_program_wgas(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 97_189_000 picoseconds.
-        Weight::from_parts(158_677_248, 0)
-            // Standard Error: 452_648
-            .saturating_add(Weight::from_parts(478_043_506, 0).saturating_mul(r.into()))
+        // Minimum execution time: 95_680_000 picoseconds.
+        Weight::from_parts(157_350_147, 0)
+            // Standard Error: 440_994
+            .saturating_add(Weight::from_parts(402_511_567, 0).saturating_mul(r.into()))
     }
     /// The range of component `p` is `[0, 2048]`.
     /// The range of component `s` is `[1, 2048]`.
@@ -2977,32 +2977,32 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 43_613_488_000 picoseconds.
-        Weight::from_parts(43_758_304_000, 0)
-            // Standard Error: 268_412
-            .saturating_add(Weight::from_parts(7_987_894, 0).saturating_mul(p.into()))
-            // Standard Error: 268_399
-            .saturating_add(Weight::from_parts(180_769_004, 0).saturating_mul(s.into()))
+        // Minimum execution time: 42_842_395_000 picoseconds.
+        Weight::from_parts(42_890_931_000, 0)
+            // Standard Error: 264_187
+            .saturating_add(Weight::from_parts(7_896_879, 0).saturating_mul(p.into()))
+            // Standard Error: 264_174
+            .saturating_add(Weight::from_parts(178_082_248, 0).saturating_mul(s.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_pay_program_rent(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 84_210_000 picoseconds.
-        Weight::from_parts(99_996_695, 0)
-            // Standard Error: 31_808
-            .saturating_add(Weight::from_parts(3_523_987, 0).saturating_mul(r.into()))
+        // Minimum execution time: 82_272_000 picoseconds.
+        Weight::from_parts(100_008_395, 0)
+            // Standard Error: 36_430
+            .saturating_add(Weight::from_parts(2_544_223, 0).saturating_mul(r.into()))
     }
     /// The range of component `p` is `[0, 512]`.
     fn lazy_pages_signal_read(p: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `141`
         //  Estimated: `1131 + p * (9900 ±0)`
-        // Minimum execution time: 82_940_000 picoseconds.
-        Weight::from_parts(123_540_441, 1131)
-            // Standard Error: 7_143
-            .saturating_add(Weight::from_parts(11_789_871, 0).saturating_mul(p.into()))
+        // Minimum execution time: 83_139_000 picoseconds.
+        Weight::from_parts(122_967_835, 1131)
+            // Standard Error: 6_454
+            .saturating_add(Weight::from_parts(11_784_103, 0).saturating_mul(p.into()))
             .saturating_add(RocksDbWeight::get().reads((4_u64).saturating_mul(p.into())))
             .saturating_add(Weight::from_parts(0, 9900).saturating_mul(p.into()))
     }
@@ -3011,10 +3011,10 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `141`
         //  Estimated: `1131 + p * (9900 ±0)`
-        // Minimum execution time: 83_752_000 picoseconds.
-        Weight::from_parts(84_858_000, 1131)
-            // Standard Error: 48_161
-            .saturating_add(Weight::from_parts(36_181_117, 0).saturating_mul(p.into()))
+        // Minimum execution time: 83_229_000 picoseconds.
+        Weight::from_parts(83_885_000, 1131)
+            // Standard Error: 37_558
+            .saturating_add(Weight::from_parts(35_503_677, 0).saturating_mul(p.into()))
             .saturating_add(RocksDbWeight::get().reads((4_u64).saturating_mul(p.into())))
             .saturating_add(Weight::from_parts(0, 9900).saturating_mul(p.into()))
     }
@@ -3023,10 +3023,10 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `141`
         //  Estimated: `5069931`
-        // Minimum execution time: 6_125_138_000 picoseconds.
-        Weight::from_parts(5_869_525_563, 5069931)
-            // Standard Error: 46_521
-            .saturating_add(Weight::from_parts(36_899_111, 0).saturating_mul(p.into()))
+        // Minimum execution time: 6_139_187_000 picoseconds.
+        Weight::from_parts(5_806_599_304, 5069931)
+            // Standard Error: 75_881
+            .saturating_add(Weight::from_parts(36_513_688, 0).saturating_mul(p.into()))
             .saturating_add(RocksDbWeight::get().reads(2048_u64))
     }
     /// The range of component `p` is `[0, 512]`.
@@ -3034,10 +3034,10 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `1813 + p * (65580 ±0)`
         //  Estimated: `1939 + p * (75482 ±0)`
-        // Minimum execution time: 82_516_000 picoseconds.
-        Weight::from_parts(83_470_000, 1939)
-            // Standard Error: 29_769
-            .saturating_add(Weight::from_parts(46_665_657, 0).saturating_mul(p.into()))
+        // Minimum execution time: 82_177_000 picoseconds.
+        Weight::from_parts(83_595_000, 1939)
+            // Standard Error: 45_778
+            .saturating_add(Weight::from_parts(47_155_630, 0).saturating_mul(p.into()))
             .saturating_add(RocksDbWeight::get().reads((4_u64).saturating_mul(p.into())))
             .saturating_add(Weight::from_parts(0, 75482).saturating_mul(p.into()))
     }
@@ -3046,10 +3046,10 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `141`
         //  Estimated: `1131 + p * (9900 ±0)`
-        // Minimum execution time: 87_344_000 picoseconds.
-        Weight::from_parts(94_873_151, 1131)
-            // Standard Error: 55_429
-            .saturating_add(Weight::from_parts(35_724_871, 0).saturating_mul(p.into()))
+        // Minimum execution time: 90_231_000 picoseconds.
+        Weight::from_parts(95_944_378, 1131)
+            // Standard Error: 61_821
+            .saturating_add(Weight::from_parts(35_941_066, 0).saturating_mul(p.into()))
             .saturating_add(RocksDbWeight::get().reads((4_u64).saturating_mul(p.into())))
             .saturating_add(Weight::from_parts(0, 9900).saturating_mul(p.into()))
     }
@@ -3058,10 +3058,10 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `141`
         //  Estimated: `1496 + p * (9883 ±2)`
-        // Minimum execution time: 735_393_000 picoseconds.
-        Weight::from_parts(754_062_397, 1496)
-            // Standard Error: 166_437
-            .saturating_add(Weight::from_parts(43_966_900, 0).saturating_mul(p.into()))
+        // Minimum execution time: 734_006_000 picoseconds.
+        Weight::from_parts(717_384_508, 1496)
+            // Standard Error: 375_292
+            .saturating_add(Weight::from_parts(47_930_581, 0).saturating_mul(p.into()))
             .saturating_add(RocksDbWeight::get().reads((4_u64).saturating_mul(p.into())))
             .saturating_add(Weight::from_parts(0, 9883).saturating_mul(p.into()))
     }
@@ -3070,10 +3070,10 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `141`
         //  Estimated: `317931`
-        // Minimum execution time: 1_124_371_000 picoseconds.
-        Weight::from_parts(1_147_901_415, 317931)
-            // Standard Error: 145_342
-            .saturating_add(Weight::from_parts(43_795_511, 0).saturating_mul(p.into()))
+        // Minimum execution time: 1_121_849_000 picoseconds.
+        Weight::from_parts(1_147_558_033, 317931)
+            // Standard Error: 373_146
+            .saturating_add(Weight::from_parts(45_393_418, 0).saturating_mul(p.into()))
             .saturating_add(RocksDbWeight::get().reads(128_u64))
     }
     /// The range of component `r` is `[0, 20]`.
@@ -3081,884 +3081,884 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 1_510_000 picoseconds.
-        Weight::from_parts(1_448_006, 0)
-            // Standard Error: 9_868
-            .saturating_add(Weight::from_parts(24_061_691, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_162_000 picoseconds.
+        Weight::from_parts(2_220_392, 0)
+            // Standard Error: 8_848
+            .saturating_add(Weight::from_parts(24_205_605, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[50, 500]`.
     fn instr_i64load(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 4_337_991_000 picoseconds.
-        Weight::from_parts(4_151_991_287, 0)
-            // Standard Error: 60_683
-            .saturating_add(Weight::from_parts(4_818_799, 0).saturating_mul(r.into()))
+        // Minimum execution time: 4_352_664_000 picoseconds.
+        Weight::from_parts(4_153_366_897, 0)
+            // Standard Error: 60_193
+            .saturating_add(Weight::from_parts(4_722_164, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[50, 500]`.
     fn instr_i32load(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 4_341_162_000 picoseconds.
-        Weight::from_parts(4_200_807_294, 0)
-            // Standard Error: 51_442
-            .saturating_add(Weight::from_parts(4_527_839, 0).saturating_mul(r.into()))
+        // Minimum execution time: 4_357_649_000 picoseconds.
+        Weight::from_parts(4_256_499_798, 0)
+            // Standard Error: 57_942
+            .saturating_add(Weight::from_parts(4_200_870, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[50, 500]`.
     fn instr_i64store(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 10_322_767_000 picoseconds.
-        Weight::from_parts(11_038_976_057, 0)
-            // Standard Error: 150_113
-            .saturating_add(Weight::from_parts(10_655_640, 0).saturating_mul(r.into()))
+        // Minimum execution time: 10_269_998_000 picoseconds.
+        Weight::from_parts(11_525_100_351, 0)
+            // Standard Error: 204_230
+            .saturating_add(Weight::from_parts(8_423_588, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[50, 500]`.
     fn instr_i32store(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 10_367_826_000 picoseconds.
-        Weight::from_parts(11_310_983_745, 0)
-            // Standard Error: 145_202
-            .saturating_add(Weight::from_parts(7_541_832, 0).saturating_mul(r.into()))
+        // Minimum execution time: 10_204_810_000 picoseconds.
+        Weight::from_parts(10_982_673_143, 0)
+            // Standard Error: 145_327
+            .saturating_add(Weight::from_parts(9_198_033, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_select(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_251_000 picoseconds.
-        Weight::from_parts(2_304_000, 0)
-            // Standard Error: 8_520
-            .saturating_add(Weight::from_parts(3_798_413, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_074_000 picoseconds.
+        Weight::from_parts(2_108_000, 0)
+            // Standard Error: 9_031
+            .saturating_add(Weight::from_parts(3_829_182, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_if(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_168_000 picoseconds.
-        Weight::from_parts(573_722, 0)
-            // Standard Error: 11_642
-            .saturating_add(Weight::from_parts(3_174_691, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_020_000 picoseconds.
+        Weight::from_parts(2_118_000, 0)
+            // Standard Error: 5_295
+            .saturating_add(Weight::from_parts(2_980_329, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_br(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_227_000 picoseconds.
-        Weight::from_parts(3_155_512, 0)
-            // Standard Error: 1_212
-            .saturating_add(Weight::from_parts(1_586_585, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_032_000 picoseconds.
+        Weight::from_parts(3_411_359, 0)
+            // Standard Error: 1_146
+            .saturating_add(Weight::from_parts(1_563_906, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_br_if(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_160_000 picoseconds.
-        Weight::from_parts(2_219_000, 0)
-            // Standard Error: 8_627
-            .saturating_add(Weight::from_parts(2_929_529, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_096_000 picoseconds.
+        Weight::from_parts(2_140_000, 0)
+            // Standard Error: 8_349
+            .saturating_add(Weight::from_parts(2_904_673, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_br_table(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_227_000 picoseconds.
-        Weight::from_parts(1_609_241, 0)
-            // Standard Error: 19_812
-            .saturating_add(Weight::from_parts(5_162_833, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_128_000 picoseconds.
+        Weight::from_parts(2_159_000, 0)
+            // Standard Error: 8_100
+            .saturating_add(Weight::from_parts(5_229_400, 0).saturating_mul(r.into()))
     }
     /// The range of component `e` is `[1, 256]`.
     fn instr_br_table_per_entry(e: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 6_892_000 picoseconds.
-        Weight::from_parts(5_316_811, 0)
-            // Standard Error: 1_578
-            .saturating_add(Weight::from_parts(163_377, 0).saturating_mul(e.into()))
+        // Minimum execution time: 6_838_000 picoseconds.
+        Weight::from_parts(5_309_346, 0)
+            // Standard Error: 2_580
+            .saturating_add(Weight::from_parts(129_982, 0).saturating_mul(e.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_call_const(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_304_000 picoseconds.
-        Weight::from_parts(4_554_683, 0)
-            // Standard Error: 7_319
-            .saturating_add(Weight::from_parts(2_595_958, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_100_000 picoseconds.
+        Weight::from_parts(3_593_285, 0)
+            // Standard Error: 6_648
+            .saturating_add(Weight::from_parts(2_597_926, 0).saturating_mul(r.into()))
     }
     fn instr_i64const(r: u32, ) -> Weight {
         Weight::from_parts(0, 0)
-            .saturating_add(Weight::from_parts(2_595_958 -
-            2_422_191, 0).saturating_mul(r.into()))
+            .saturating_add(Weight::from_parts(2_597_926 -
+            2_429_048, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_call(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_273_000 picoseconds.
-        Weight::from_parts(5_046_075, 0)
-            // Standard Error: 13_702
-            .saturating_add(Weight::from_parts(2_422_191, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_086_000 picoseconds.
+        Weight::from_parts(3_972_773, 0)
+            // Standard Error: 12_538
+            .saturating_add(Weight::from_parts(2_429_048, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_call_indirect(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_684_000 picoseconds.
-        Weight::from_parts(17_324_871, 0)
-            // Standard Error: 38_532
-            .saturating_add(Weight::from_parts(10_260_872, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_591_000 picoseconds.
+        Weight::from_parts(12_798_134, 0)
+            // Standard Error: 23_023
+            .saturating_add(Weight::from_parts(9_786_464, 0).saturating_mul(r.into()))
     }
     /// The range of component `p` is `[0, 128]`.
     fn instr_call_indirect_per_param(p: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 12_206_000 picoseconds.
-        Weight::from_parts(2_634_425, 0)
-            // Standard Error: 5_954
-            .saturating_add(Weight::from_parts(1_275_538, 0).saturating_mul(p.into()))
+        // Minimum execution time: 12_274_000 picoseconds.
+        Weight::from_parts(1_706_188, 0)
+            // Standard Error: 6_199
+            .saturating_add(Weight::from_parts(1_212_443, 0).saturating_mul(p.into()))
     }
     /// The range of component `l` is `[0, 1024]`.
     fn instr_call_per_local(l: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 5_288_000 picoseconds.
-        Weight::from_parts(5_570_870, 0)
+        // Minimum execution time: 5_221_000 picoseconds.
+        Weight::from_parts(5_538_574, 0)
             // Standard Error: 12
-            .saturating_add(Weight::from_parts(61, 0).saturating_mul(l.into()))
+            .saturating_add(Weight::from_parts(12, 0).saturating_mul(l.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_local_get(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_203_000 picoseconds.
-        Weight::from_parts(1_788_159, 0)
-            // Standard Error: 3_152
-            .saturating_add(Weight::from_parts(267_842, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_100_000 picoseconds.
+        Weight::from_parts(1_785_103, 0)
+            // Standard Error: 2_948
+            .saturating_add(Weight::from_parts(249_981, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_local_set(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_164_000 picoseconds.
-        Weight::from_parts(2_223_000, 0)
-            // Standard Error: 4_611
-            .saturating_add(Weight::from_parts(721_127, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_123_000 picoseconds.
+        Weight::from_parts(2_187_000, 0)
+            // Standard Error: 5_664
+            .saturating_add(Weight::from_parts(719_187, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_local_tee(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_252_000 picoseconds.
-        Weight::from_parts(2_347_000, 0)
-            // Standard Error: 5_971
-            .saturating_add(Weight::from_parts(742_209, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_137_000 picoseconds.
+        Weight::from_parts(2_214_000, 0)
+            // Standard Error: 5_625
+            .saturating_add(Weight::from_parts(709_067, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_global_get(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 6_406_000 picoseconds.
-        Weight::from_parts(2_894_577, 0)
-            // Standard Error: 8_027
-            .saturating_add(Weight::from_parts(801_493, 0).saturating_mul(r.into()))
+        // Minimum execution time: 6_168_000 picoseconds.
+        Weight::from_parts(2_290_203, 0)
+            // Standard Error: 8_984
+            .saturating_add(Weight::from_parts(761_843, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_global_set(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 6_345_000 picoseconds.
-        Weight::from_parts(31_295, 0)
-            // Standard Error: 10_231
-            .saturating_add(Weight::from_parts(1_543_569, 0).saturating_mul(r.into()))
+        // Minimum execution time: 6_249_000 picoseconds.
+        Weight::from_parts(6_302_000, 0)
+            // Standard Error: 8_682
+            .saturating_add(Weight::from_parts(1_329_653, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_memory_current(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 3_937_000 picoseconds.
-        Weight::from_parts(62_049, 0)
-            // Standard Error: 12_087
-            .saturating_add(Weight::from_parts(7_172_920, 0).saturating_mul(r.into()))
+        // Minimum execution time: 3_791_000 picoseconds.
+        Weight::from_parts(3_929_000, 0)
+            // Standard Error: 9_270
+            .saturating_add(Weight::from_parts(6_742_685, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64clz(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_262_000 picoseconds.
-        Weight::from_parts(2_306_000, 0)
-            // Standard Error: 6_042
-            .saturating_add(Weight::from_parts(3_394_526, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_113_000 picoseconds.
+        Weight::from_parts(2_192_000, 0)
+            // Standard Error: 6_734
+            .saturating_add(Weight::from_parts(3_327_207, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32clz(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_151_000 picoseconds.
-        Weight::from_parts(2_260_000, 0)
-            // Standard Error: 5_891
-            .saturating_add(Weight::from_parts(3_138_523, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_095_000 picoseconds.
+        Weight::from_parts(2_141_000, 0)
+            // Standard Error: 6_506
+            .saturating_add(Weight::from_parts(3_061_891, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64ctz(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_218_000 picoseconds.
-        Weight::from_parts(2_277_000, 0)
-            // Standard Error: 8_196
-            .saturating_add(Weight::from_parts(3_167_033, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_108_000 picoseconds.
+        Weight::from_parts(2_141_000, 0)
+            // Standard Error: 6_738
+            .saturating_add(Weight::from_parts(3_101_844, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32ctz(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_246_000 picoseconds.
-        Weight::from_parts(2_289_000, 0)
-            // Standard Error: 5_536
-            .saturating_add(Weight::from_parts(2_668_164, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_138_000 picoseconds.
+        Weight::from_parts(2_155_000, 0)
+            // Standard Error: 4_379
+            .saturating_add(Weight::from_parts(2_613_794, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64popcnt(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_259_000 picoseconds.
-        Weight::from_parts(45_432, 0)
-            // Standard Error: 6_223
-            .saturating_add(Weight::from_parts(645_076, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_046_000 picoseconds.
+        Weight::from_parts(2_127_000, 0)
+            // Standard Error: 3_513
+            .saturating_add(Weight::from_parts(525_212, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32popcnt(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_168_000 picoseconds.
-        Weight::from_parts(1_301_007, 0)
-            // Standard Error: 4_929
-            .saturating_add(Weight::from_parts(446_280, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_127_000 picoseconds.
+        Weight::from_parts(1_669_179, 0)
+            // Standard Error: 2_817
+            .saturating_add(Weight::from_parts(367_599, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64eqz(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_130_000 picoseconds.
-        Weight::from_parts(2_205_000, 0)
-            // Standard Error: 10_412
-            .saturating_add(Weight::from_parts(1_894_722, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_131_000 picoseconds.
+        Weight::from_parts(2_169_000, 0)
+            // Standard Error: 11_816
+            .saturating_add(Weight::from_parts(1_810_781, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32eqz(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_170_000 picoseconds.
-        Weight::from_parts(2_257_000, 0)
-            // Standard Error: 7_708
-            .saturating_add(Weight::from_parts(1_162_246, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_087_000 picoseconds.
+        Weight::from_parts(2_194_000, 0)
+            // Standard Error: 7_361
+            .saturating_add(Weight::from_parts(1_130_773, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32extend8s(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_153_000 picoseconds.
-        Weight::from_parts(1_682_106, 0)
-            // Standard Error: 3_839
-            .saturating_add(Weight::from_parts(384_381, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_061_000 picoseconds.
+        Weight::from_parts(1_850_477, 0)
+            // Standard Error: 2_695
+            .saturating_add(Weight::from_parts(318_827, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32extend16s(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_162_000 picoseconds.
-        Weight::from_parts(1_669_708, 0)
-            // Standard Error: 3_126
-            .saturating_add(Weight::from_parts(384_474, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_115_000 picoseconds.
+        Weight::from_parts(1_764_589, 0)
+            // Standard Error: 2_923
+            .saturating_add(Weight::from_parts(329_840, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64extend8s(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_249_000 picoseconds.
-        Weight::from_parts(2_291_000, 0)
-            // Standard Error: 4_476
-            .saturating_add(Weight::from_parts(497_277, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_109_000 picoseconds.
+        Weight::from_parts(859_995, 0)
+            // Standard Error: 4_546
+            .saturating_add(Weight::from_parts(467_944, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64extend16s(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_217_000 picoseconds.
-        Weight::from_parts(2_287_000, 0)
-            // Standard Error: 4_107
-            .saturating_add(Weight::from_parts(524_095, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_010_000 picoseconds.
+        Weight::from_parts(2_081_000, 0)
+            // Standard Error: 3_959
+            .saturating_add(Weight::from_parts(472_947, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64extend32s(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_163_000 picoseconds.
-        Weight::from_parts(2_233_000, 0)
-            // Standard Error: 3_690
-            .saturating_add(Weight::from_parts(501_277, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_105_000 picoseconds.
+        Weight::from_parts(1_247_124, 0)
+            // Standard Error: 4_390
+            .saturating_add(Weight::from_parts(436_907, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64extendsi32(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_132_000 picoseconds.
-        Weight::from_parts(1_082_506, 0)
-            // Standard Error: 5_421
-            .saturating_add(Weight::from_parts(400_448, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_140_000 picoseconds.
+        Weight::from_parts(2_251_532, 0)
+            // Standard Error: 2_995
+            .saturating_add(Weight::from_parts(280_490, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64extendui32(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_211_000 picoseconds.
-        Weight::from_parts(3_085_764, 0)
-            // Standard Error: 1_912
-            .saturating_add(Weight::from_parts(162_384, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_119_000 picoseconds.
+        Weight::from_parts(2_808_547, 0)
+            // Standard Error: 1_453
+            .saturating_add(Weight::from_parts(143_409, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32wrapi64(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_161_000 picoseconds.
-        Weight::from_parts(2_849_158, 0)
-            // Standard Error: 1_635
-            .saturating_add(Weight::from_parts(153_763, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_043_000 picoseconds.
+        Weight::from_parts(2_639_820, 0)
+            // Standard Error: 1_638
+            .saturating_add(Weight::from_parts(159_792, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64eq(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_279_000 picoseconds.
-        Weight::from_parts(2_315_000, 0)
-            // Standard Error: 11_776
-            .saturating_add(Weight::from_parts(1_779_477, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_128_000 picoseconds.
+        Weight::from_parts(2_166_000, 0)
+            // Standard Error: 11_777
+            .saturating_add(Weight::from_parts(1_709_510, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32eq(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_272_000 picoseconds.
-        Weight::from_parts(2_342_000, 0)
-            // Standard Error: 8_815
-            .saturating_add(Weight::from_parts(1_197_093, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_100_000 picoseconds.
+        Weight::from_parts(2_136_000, 0)
+            // Standard Error: 7_491
+            .saturating_add(Weight::from_parts(1_105_807, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64ne(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_190_000 picoseconds.
-        Weight::from_parts(2_258_000, 0)
-            // Standard Error: 9_983
-            .saturating_add(Weight::from_parts(1_838_257, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_088_000 picoseconds.
+        Weight::from_parts(2_171_000, 0)
+            // Standard Error: 11_841
+            .saturating_add(Weight::from_parts(1_785_140, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32ne(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_227_000 picoseconds.
-        Weight::from_parts(2_276_000, 0)
-            // Standard Error: 7_749
-            .saturating_add(Weight::from_parts(1_165_862, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_042_000 picoseconds.
+        Weight::from_parts(2_181_000, 0)
+            // Standard Error: 7_479
+            .saturating_add(Weight::from_parts(1_086_144, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64lts(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_172_000 picoseconds.
-        Weight::from_parts(2_246_000, 0)
-            // Standard Error: 11_426
-            .saturating_add(Weight::from_parts(1_828_814, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_109_000 picoseconds.
+        Weight::from_parts(2_151_000, 0)
+            // Standard Error: 13_111
+            .saturating_add(Weight::from_parts(1_829_000, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32lts(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_187_000 picoseconds.
-        Weight::from_parts(2_245_000, 0)
-            // Standard Error: 7_973
-            .saturating_add(Weight::from_parts(1_145_613, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_130_000 picoseconds.
+        Weight::from_parts(2_153_000, 0)
+            // Standard Error: 7_632
+            .saturating_add(Weight::from_parts(1_102_522, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64ltu(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_247_000 picoseconds.
-        Weight::from_parts(2_273_000, 0)
-            // Standard Error: 10_995
-            .saturating_add(Weight::from_parts(1_789_814, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_155_000 picoseconds.
+        Weight::from_parts(2_231_000, 0)
+            // Standard Error: 11_689
+            .saturating_add(Weight::from_parts(1_768_866, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32ltu(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_162_000 picoseconds.
-        Weight::from_parts(2_252_000, 0)
-            // Standard Error: 7_454
-            .saturating_add(Weight::from_parts(1_207_539, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_094_000 picoseconds.
+        Weight::from_parts(2_163_000, 0)
+            // Standard Error: 7_348
+            .saturating_add(Weight::from_parts(1_057_058, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64gts(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_219_000 picoseconds.
-        Weight::from_parts(2_279_000, 0)
-            // Standard Error: 10_576
-            .saturating_add(Weight::from_parts(1_855_075, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_095_000 picoseconds.
+        Weight::from_parts(2_142_000, 0)
+            // Standard Error: 12_173
+            .saturating_add(Weight::from_parts(1_786_184, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32gts(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_199_000 picoseconds.
-        Weight::from_parts(2_265_000, 0)
-            // Standard Error: 7_405
-            .saturating_add(Weight::from_parts(1_180_265, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_122_000 picoseconds.
+        Weight::from_parts(2_206_000, 0)
+            // Standard Error: 7_244
+            .saturating_add(Weight::from_parts(1_066_057, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64gtu(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_245_000 picoseconds.
-        Weight::from_parts(2_285_000, 0)
-            // Standard Error: 10_994
-            .saturating_add(Weight::from_parts(1_835_344, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_090_000 picoseconds.
+        Weight::from_parts(2_175_000, 0)
+            // Standard Error: 11_967
+            .saturating_add(Weight::from_parts(1_782_809, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32gtu(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_222_000 picoseconds.
-        Weight::from_parts(2_277_000, 0)
-            // Standard Error: 7_826
-            .saturating_add(Weight::from_parts(1_163_748, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_091_000 picoseconds.
+        Weight::from_parts(2_169_000, 0)
+            // Standard Error: 7_205
+            .saturating_add(Weight::from_parts(1_048_140, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64les(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_102_000 picoseconds.
-        Weight::from_parts(2_217_000, 0)
-            // Standard Error: 11_374
-            .saturating_add(Weight::from_parts(1_910_004, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_164_000 picoseconds.
+        Weight::from_parts(2_198_000, 0)
+            // Standard Error: 12_228
+            .saturating_add(Weight::from_parts(1_792_751, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32les(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_245_000 picoseconds.
-        Weight::from_parts(2_303_000, 0)
-            // Standard Error: 8_971
-            .saturating_add(Weight::from_parts(1_182_859, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_122_000 picoseconds.
+        Weight::from_parts(2_186_000, 0)
+            // Standard Error: 7_822
+            .saturating_add(Weight::from_parts(1_052_385, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64leu(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_230_000 picoseconds.
-        Weight::from_parts(2_284_000, 0)
-            // Standard Error: 12_177
-            .saturating_add(Weight::from_parts(1_866_465, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_055_000 picoseconds.
+        Weight::from_parts(2_135_000, 0)
+            // Standard Error: 12_011
+            .saturating_add(Weight::from_parts(1_789_504, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32leu(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_468_000 picoseconds.
-        Weight::from_parts(2_638_000, 0)
-            // Standard Error: 7_738
-            .saturating_add(Weight::from_parts(1_119_369, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_447_000 picoseconds.
+        Weight::from_parts(2_540_000, 0)
+            // Standard Error: 7_696
+            .saturating_add(Weight::from_parts(1_062_612, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64ges(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_191_000 picoseconds.
-        Weight::from_parts(2_286_000, 0)
-            // Standard Error: 10_340
-            .saturating_add(Weight::from_parts(1_831_738, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_077_000 picoseconds.
+        Weight::from_parts(2_107_000, 0)
+            // Standard Error: 12_070
+            .saturating_add(Weight::from_parts(1_771_498, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32ges(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_216_000 picoseconds.
-        Weight::from_parts(2_260_000, 0)
-            // Standard Error: 6_924
-            .saturating_add(Weight::from_parts(1_210_933, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_123_000 picoseconds.
+        Weight::from_parts(2_156_000, 0)
+            // Standard Error: 7_108
+            .saturating_add(Weight::from_parts(1_072_471, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64geu(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_202_000 picoseconds.
-        Weight::from_parts(2_325_000, 0)
-            // Standard Error: 9_907
-            .saturating_add(Weight::from_parts(1_822_715, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_038_000 picoseconds.
+        Weight::from_parts(2_145_000, 0)
+            // Standard Error: 11_990
+            .saturating_add(Weight::from_parts(1_786_273, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32geu(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_230_000 picoseconds.
-        Weight::from_parts(2_294_000, 0)
-            // Standard Error: 7_927
-            .saturating_add(Weight::from_parts(1_168_287, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_059_000 picoseconds.
+        Weight::from_parts(2_122_000, 0)
+            // Standard Error: 7_164
+            .saturating_add(Weight::from_parts(1_070_909, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64add(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_189_000 picoseconds.
-        Weight::from_parts(2_289_000, 0)
-            // Standard Error: 8_768
-            .saturating_add(Weight::from_parts(1_295_617, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_065_000 picoseconds.
+        Weight::from_parts(2_181_000, 0)
+            // Standard Error: 7_265
+            .saturating_add(Weight::from_parts(1_152_228, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32add(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_193_000 picoseconds.
-        Weight::from_parts(2_292_000, 0)
-            // Standard Error: 6_314
-            .saturating_add(Weight::from_parts(658_832, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_107_000 picoseconds.
+        Weight::from_parts(2_160_000, 0)
+            // Standard Error: 5_101
+            .saturating_add(Weight::from_parts(578_660, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64sub(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_258_000 picoseconds.
-        Weight::from_parts(2_312_000, 0)
-            // Standard Error: 9_261
-            .saturating_add(Weight::from_parts(1_348_699, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_130_000 picoseconds.
+        Weight::from_parts(2_184_000, 0)
+            // Standard Error: 9_299
+            .saturating_add(Weight::from_parts(1_257_633, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32sub(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_257_000 picoseconds.
-        Weight::from_parts(2_290_000, 0)
-            // Standard Error: 5_457
-            .saturating_add(Weight::from_parts(671_846, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_119_000 picoseconds.
+        Weight::from_parts(2_262_000, 0)
+            // Standard Error: 3_957
+            .saturating_add(Weight::from_parts(557_957, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64mul(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_180_000 picoseconds.
-        Weight::from_parts(2_241_000, 0)
-            // Standard Error: 11_567
-            .saturating_add(Weight::from_parts(1_835_171, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_045_000 picoseconds.
+        Weight::from_parts(2_157_000, 0)
+            // Standard Error: 10_839
+            .saturating_add(Weight::from_parts(1_686_809, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32mul(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_196_000 picoseconds.
-        Weight::from_parts(2_290_000, 0)
-            // Standard Error: 7_436
-            .saturating_add(Weight::from_parts(1_171_019, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_232_000 picoseconds.
+        Weight::from_parts(2_250_000, 0)
+            // Standard Error: 7_276
+            .saturating_add(Weight::from_parts(1_096_252, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64divs(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_195_000 picoseconds.
-        Weight::from_parts(6_299_544, 0)
-            // Standard Error: 28_028
-            .saturating_add(Weight::from_parts(2_500_140, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_107_000 picoseconds.
+        Weight::from_parts(1_434_170, 0)
+            // Standard Error: 21_965
+            .saturating_add(Weight::from_parts(2_633_663, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32divs(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_249_000 picoseconds.
-        Weight::from_parts(2_576_178, 0)
-            // Standard Error: 12_042
-            .saturating_add(Weight::from_parts(2_335_953, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_098_000 picoseconds.
+        Weight::from_parts(2_122_681, 0)
+            // Standard Error: 10_815
+            .saturating_add(Weight::from_parts(2_335_842, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64divu(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_223_000 picoseconds.
-        Weight::from_parts(8_638_891, 0)
-            // Standard Error: 32_649
-            .saturating_add(Weight::from_parts(2_462_794, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_153_000 picoseconds.
+        Weight::from_parts(145_632, 0)
+            // Standard Error: 12_320
+            .saturating_add(Weight::from_parts(2_992_427, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32divu(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_231_000 picoseconds.
-        Weight::from_parts(2_731_170, 0)
-            // Standard Error: 19_116
-            .saturating_add(Weight::from_parts(2_437_473, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_142_000 picoseconds.
+        Weight::from_parts(2_180_000, 0)
+            // Standard Error: 4_944
+            .saturating_add(Weight::from_parts(2_466_854, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64rems(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_261_000 picoseconds.
-        Weight::from_parts(1_535_146, 0)
-            // Standard Error: 30_575
-            .saturating_add(Weight::from_parts(9_634_377, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_143_000 picoseconds.
+        Weight::from_parts(2_204_000, 0)
+            // Standard Error: 14_500
+            .saturating_add(Weight::from_parts(9_530_241, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32rems(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_209_000 picoseconds.
-        Weight::from_parts(5_244_298, 0)
-            // Standard Error: 48_615
-            .saturating_add(Weight::from_parts(7_381_672, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_132_000 picoseconds.
+        Weight::from_parts(2_183_000, 0)
+            // Standard Error: 22_303
+            .saturating_add(Weight::from_parts(7_508_848, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64remu(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_260_000 picoseconds.
-        Weight::from_parts(8_453_159, 0)
-            // Standard Error: 30_530
-            .saturating_add(Weight::from_parts(2_541_459, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_133_000 picoseconds.
+        Weight::from_parts(2_183_000, 0)
+            // Standard Error: 5_407
+            .saturating_add(Weight::from_parts(2_948_013, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32remu(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_242_000 picoseconds.
-        Weight::from_parts(5_507_917, 0)
-            // Standard Error: 21_457
-            .saturating_add(Weight::from_parts(2_217_886, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_124_000 picoseconds.
+        Weight::from_parts(2_150_000, 0)
+            // Standard Error: 6_372
+            .saturating_add(Weight::from_parts(2_362_416, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64and(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_163_000 picoseconds.
-        Weight::from_parts(2_341_000, 0)
-            // Standard Error: 9_253
-            .saturating_add(Weight::from_parts(1_354_282, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_174_000 picoseconds.
+        Weight::from_parts(2_219_000, 0)
+            // Standard Error: 7_670
+            .saturating_add(Weight::from_parts(1_174_342, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32and(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_170_000 picoseconds.
-        Weight::from_parts(2_224_000, 0)
-            // Standard Error: 3_908
-            .saturating_add(Weight::from_parts(589_876, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_094_000 picoseconds.
+        Weight::from_parts(2_109_000, 0)
+            // Standard Error: 3_988
+            .saturating_add(Weight::from_parts(566_949, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64or(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_184_000 picoseconds.
-        Weight::from_parts(2_265_000, 0)
-            // Standard Error: 9_943
-            .saturating_add(Weight::from_parts(1_308_630, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_049_000 picoseconds.
+        Weight::from_parts(2_117_000, 0)
+            // Standard Error: 8_393
+            .saturating_add(Weight::from_parts(1_160_794, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32or(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_212_000 picoseconds.
-        Weight::from_parts(2_273_000, 0)
-            // Standard Error: 5_843
-            .saturating_add(Weight::from_parts(653_388, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_107_000 picoseconds.
+        Weight::from_parts(2_152_000, 0)
+            // Standard Error: 4_769
+            .saturating_add(Weight::from_parts(585_265, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64xor(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_228_000 picoseconds.
-        Weight::from_parts(2_293_000, 0)
-            // Standard Error: 9_157
-            .saturating_add(Weight::from_parts(1_290_731, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_115_000 picoseconds.
+        Weight::from_parts(2_170_000, 0)
+            // Standard Error: 7_943
+            .saturating_add(Weight::from_parts(1_185_174, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32xor(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_232_000 picoseconds.
-        Weight::from_parts(2_276_000, 0)
-            // Standard Error: 4_020
-            .saturating_add(Weight::from_parts(618_071, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_139_000 picoseconds.
+        Weight::from_parts(2_183_000, 0)
+            // Standard Error: 4_608
+            .saturating_add(Weight::from_parts(563_329, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64shl(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_239_000 picoseconds.
-        Weight::from_parts(2_292_000, 0)
-            // Standard Error: 7_192
-            .saturating_add(Weight::from_parts(1_061_312, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_144_000 picoseconds.
+        Weight::from_parts(2_178_000, 0)
+            // Standard Error: 6_727
+            .saturating_add(Weight::from_parts(1_000_757, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32shl(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_157_000 picoseconds.
-        Weight::from_parts(2_245_000, 0)
-            // Standard Error: 3_756
-            .saturating_add(Weight::from_parts(568_744, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_107_000 picoseconds.
+        Weight::from_parts(2_212_000, 0)
+            // Standard Error: 3_536
+            .saturating_add(Weight::from_parts(504_096, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64shrs(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_248_000 picoseconds.
-        Weight::from_parts(2_324_000, 0)
-            // Standard Error: 7_917
-            .saturating_add(Weight::from_parts(1_106_132, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_167_000 picoseconds.
+        Weight::from_parts(2_218_000, 0)
+            // Standard Error: 7_170
+            .saturating_add(Weight::from_parts(966_365, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32shrs(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_205_000 picoseconds.
-        Weight::from_parts(2_292_000, 0)
-            // Standard Error: 4_617
-            .saturating_add(Weight::from_parts(599_461, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_149_000 picoseconds.
+        Weight::from_parts(140_768, 0)
+            // Standard Error: 5_221
+            .saturating_add(Weight::from_parts(551_550, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64shru(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_215_000 picoseconds.
-        Weight::from_parts(2_346_000, 0)
-            // Standard Error: 7_501
-            .saturating_add(Weight::from_parts(1_125_645, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_122_000 picoseconds.
+        Weight::from_parts(2_159_000, 0)
+            // Standard Error: 7_621
+            .saturating_add(Weight::from_parts(997_420, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32shru(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_255_000 picoseconds.
-        Weight::from_parts(2_306_000, 0)
-            // Standard Error: 5_262
-            .saturating_add(Weight::from_parts(624_680, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_069_000 picoseconds.
+        Weight::from_parts(2_106_000, 0)
+            // Standard Error: 3_980
+            .saturating_add(Weight::from_parts(537_014, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64rotl(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_231_000 picoseconds.
-        Weight::from_parts(2_341_000, 0)
-            // Standard Error: 7_879
-            .saturating_add(Weight::from_parts(1_068_877, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_097_000 picoseconds.
+        Weight::from_parts(2_191_000, 0)
+            // Standard Error: 9_419
+            .saturating_add(Weight::from_parts(1_050_292, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32rotl(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_192_000 picoseconds.
-        Weight::from_parts(2_288_000, 0)
-            // Standard Error: 4_124
-            .saturating_add(Weight::from_parts(567_690, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_051_000 picoseconds.
+        Weight::from_parts(2_118_000, 0)
+            // Standard Error: 4_228
+            .saturating_add(Weight::from_parts(529_158, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64rotr(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_258_000 picoseconds.
-        Weight::from_parts(2_322_000, 0)
-            // Standard Error: 8_516
-            .saturating_add(Weight::from_parts(1_174_764, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_038_000 picoseconds.
+        Weight::from_parts(2_116_000, 0)
+            // Standard Error: 7_792
+            .saturating_add(Weight::from_parts(1_027_370, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32rotr(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_171_000 picoseconds.
-        Weight::from_parts(2_258_000, 0)
-            // Standard Error: 4_901
-            .saturating_add(Weight::from_parts(628_068, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_077_000 picoseconds.
+        Weight::from_parts(2_140_000, 0)
+            // Standard Error: 4_450
+            .saturating_add(Weight::from_parts(534_724, 0).saturating_mul(r.into()))
     }
 }
diff --git a/runtime/gear/src/weights/pallet_gear_voucher.rs b/runtime/gear/src/weights/pallet_gear_voucher.rs
index 9ce90d81e6b..d7bf678ab76 100644
--- a/runtime/gear/src/weights/pallet_gear_voucher.rs
+++ b/runtime/gear/src/weights/pallet_gear_voucher.rs
@@ -19,7 +19,7 @@
 //! Autogenerated weights for pallet_gear_voucher
 //!
 //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
-//! DATE: 2023-08-01, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! DATE: 2023-08-07, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
 //! WORST CASE MAP SIZE: `1000000`
 //! CPU: `Intel(R) Xeon(R) Platinum 8375C CPU @ 2.90GHz`
 //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("gear-dev"), DB CACHE: 1024
@@ -47,8 +47,8 @@ impl<T: frame_system::Config> pallet_gear_voucher::WeightInfo for SubstrateWeigh
         // Proof Size summary in bytes:
         //  Measured:  `101`
         //  Estimated: `6196`
-        // Minimum execution time: 28_703_000 picoseconds.
-        Weight::from_parts(29_520_000, 6196)
+        // Minimum execution time: 26_245_000 picoseconds.
+        Weight::from_parts(26_820_000, 6196)
             .saturating_add(T::DbWeight::get().reads(2_u64))
             .saturating_add(T::DbWeight::get().writes(2_u64))
     }
@@ -60,8 +60,8 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `101`
         //  Estimated: `6196`
-        // Minimum execution time: 28_703_000 picoseconds.
-        Weight::from_parts(29_520_000, 6196)
+        // Minimum execution time: 26_245_000 picoseconds.
+        Weight::from_parts(26_820_000, 6196)
             .saturating_add(RocksDbWeight::get().reads(2_u64))
             .saturating_add(RocksDbWeight::get().writes(2_u64))
     }
diff --git a/runtime/gear/src/weights/pallet_timestamp.rs b/runtime/gear/src/weights/pallet_timestamp.rs
index bddda071d0f..63568a7b1ca 100644
--- a/runtime/gear/src/weights/pallet_timestamp.rs
+++ b/runtime/gear/src/weights/pallet_timestamp.rs
@@ -19,7 +19,7 @@
 //! Autogenerated weights for pallet_timestamp
 //!
 //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
-//! DATE: 2023-08-01, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! DATE: 2023-08-07, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
 //! WORST CASE MAP SIZE: `1000000`
 //! CPU: `Intel(R) Xeon(R) Platinum 8375C CPU @ 2.90GHz`
 //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("gear-dev"), DB CACHE: 1024
@@ -48,8 +48,8 @@ impl<T: frame_system::Config> pallet_timestamp::WeightInfo for SubstrateWeight<T
         // Proof Size summary in bytes:
         //  Measured:  `175`
         //  Estimated: `2986`
-        // Minimum execution time: 7_977_000 picoseconds.
-        Weight::from_parts(8_436_000, 2986)
+        // Minimum execution time: 7_831_000 picoseconds.
+        Weight::from_parts(8_206_000, 2986)
             .saturating_add(T::DbWeight::get().reads(2_u64))
             .saturating_add(T::DbWeight::get().writes(1_u64))
     }
@@ -57,8 +57,8 @@ impl<T: frame_system::Config> pallet_timestamp::WeightInfo for SubstrateWeight<T
         // Proof Size summary in bytes:
         //  Measured:  `57`
         //  Estimated: `0`
-        // Minimum execution time: 3_140_000 picoseconds.
-        Weight::from_parts(3_231_000, 0)
+        // Minimum execution time: 3_204_000 picoseconds.
+        Weight::from_parts(3_350_000, 0)
     }
 }
 
@@ -68,8 +68,8 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `175`
         //  Estimated: `2986`
-        // Minimum execution time: 7_977_000 picoseconds.
-        Weight::from_parts(8_436_000, 2986)
+        // Minimum execution time: 7_831_000 picoseconds.
+        Weight::from_parts(8_206_000, 2986)
             .saturating_add(RocksDbWeight::get().reads(2_u64))
             .saturating_add(RocksDbWeight::get().writes(1_u64))
     }
@@ -77,7 +77,7 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `57`
         //  Estimated: `0`
-        // Minimum execution time: 3_140_000 picoseconds.
-        Weight::from_parts(3_231_000, 0)
+        // Minimum execution time: 3_204_000 picoseconds.
+        Weight::from_parts(3_350_000, 0)
     }
 }
diff --git a/runtime/gear/src/weights/pallet_utility.rs b/runtime/gear/src/weights/pallet_utility.rs
index 93f5f954b29..3f8a4d194c4 100644
--- a/runtime/gear/src/weights/pallet_utility.rs
+++ b/runtime/gear/src/weights/pallet_utility.rs
@@ -19,7 +19,7 @@
 //! Autogenerated weights for pallet_utility
 //!
 //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
-//! DATE: 2023-08-01, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! DATE: 2023-08-07, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
 //! WORST CASE MAP SIZE: `1000000`
 //! CPU: `Intel(R) Xeon(R) Platinum 8375C CPU @ 2.90GHz`
 //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("gear-dev"), DB CACHE: 1024
@@ -52,44 +52,44 @@ impl<T: frame_system::Config> pallet_utility::WeightInfo for SubstrateWeight<T>
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 5_618_000 picoseconds.
-        Weight::from_parts(13_560_220, 0)
-            // Standard Error: 5_243
-            .saturating_add(Weight::from_parts(3_938_406, 0).saturating_mul(c.into()))
+        // Minimum execution time: 5_492_000 picoseconds.
+        Weight::from_parts(16_501_612, 0)
+            // Standard Error: 5_305
+            .saturating_add(Weight::from_parts(3_940_106, 0).saturating_mul(c.into()))
     }
     fn as_derivative() -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 3_826_000 picoseconds.
-        Weight::from_parts(4_114_000, 0)
+        // Minimum execution time: 3_541_000 picoseconds.
+        Weight::from_parts(3_734_000, 0)
     }
     /// The range of component `c` is `[0, 1000]`.
     fn batch_all(c: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 5_376_000 picoseconds.
-        Weight::from_parts(4_303_245, 0)
-            // Standard Error: 7_216
-            .saturating_add(Weight::from_parts(4_194_979, 0).saturating_mul(c.into()))
+        // Minimum execution time: 5_273_000 picoseconds.
+        Weight::from_parts(19_870_279, 0)
+            // Standard Error: 3_599
+            .saturating_add(Weight::from_parts(4_086_216, 0).saturating_mul(c.into()))
     }
     fn dispatch_as() -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 7_307_000 picoseconds.
-        Weight::from_parts(7_643_000, 0)
+        // Minimum execution time: 6_999_000 picoseconds.
+        Weight::from_parts(7_200_000, 0)
     }
     /// The range of component `c` is `[0, 1000]`.
     fn force_batch(c: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 5_123_000 picoseconds.
-        Weight::from_parts(5_780_504, 0)
-            // Standard Error: 7_424
-            .saturating_add(Weight::from_parts(3_988_181, 0).saturating_mul(c.into()))
+        // Minimum execution time: 5_391_000 picoseconds.
+        Weight::from_parts(11_706_819, 0)
+            // Standard Error: 4_999
+            .saturating_add(Weight::from_parts(3_962_138, 0).saturating_mul(c.into()))
     }
 }
 
@@ -100,43 +100,43 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 5_618_000 picoseconds.
-        Weight::from_parts(13_560_220, 0)
-            // Standard Error: 5_243
-            .saturating_add(Weight::from_parts(3_938_406, 0).saturating_mul(c.into()))
+        // Minimum execution time: 5_492_000 picoseconds.
+        Weight::from_parts(16_501_612, 0)
+            // Standard Error: 5_305
+            .saturating_add(Weight::from_parts(3_940_106, 0).saturating_mul(c.into()))
     }
     fn as_derivative() -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 3_826_000 picoseconds.
-        Weight::from_parts(4_114_000, 0)
+        // Minimum execution time: 3_541_000 picoseconds.
+        Weight::from_parts(3_734_000, 0)
     }
     /// The range of component `c` is `[0, 1000]`.
     fn batch_all(c: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 5_376_000 picoseconds.
-        Weight::from_parts(4_303_245, 0)
-            // Standard Error: 7_216
-            .saturating_add(Weight::from_parts(4_194_979, 0).saturating_mul(c.into()))
+        // Minimum execution time: 5_273_000 picoseconds.
+        Weight::from_parts(19_870_279, 0)
+            // Standard Error: 3_599
+            .saturating_add(Weight::from_parts(4_086_216, 0).saturating_mul(c.into()))
     }
     fn dispatch_as() -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 7_307_000 picoseconds.
-        Weight::from_parts(7_643_000, 0)
+        // Minimum execution time: 6_999_000 picoseconds.
+        Weight::from_parts(7_200_000, 0)
     }
     /// The range of component `c` is `[0, 1000]`.
     fn force_batch(c: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 5_123_000 picoseconds.
-        Weight::from_parts(5_780_504, 0)
-            // Standard Error: 7_424
-            .saturating_add(Weight::from_parts(3_988_181, 0).saturating_mul(c.into()))
+        // Minimum execution time: 5_391_000 picoseconds.
+        Weight::from_parts(11_706_819, 0)
+            // Standard Error: 4_999
+            .saturating_add(Weight::from_parts(3_962_138, 0).saturating_mul(c.into()))
     }
 }
diff --git a/runtime/vara/src/tests.rs b/runtime/vara/src/tests.rs
index 1151b53d08e..e74dec9b53b 100644
--- a/runtime/vara/src/tests.rs
+++ b/runtime/vara/src/tests.rs
@@ -31,7 +31,7 @@ fn instruction_weights_heuristics_test() {
         version: 0,
         _phantom: core::marker::PhantomData,
 
-        i64const: 150,
+        i64const: 160,
         i64load: 7_000,
         i32load: 8_000,
         i64store: 29_000,
diff --git a/runtime/vara/src/weights/frame_system.rs b/runtime/vara/src/weights/frame_system.rs
index d2c4cc19e52..3592fb36d2d 100644
--- a/runtime/vara/src/weights/frame_system.rs
+++ b/runtime/vara/src/weights/frame_system.rs
@@ -19,7 +19,7 @@
 //! Autogenerated weights for frame_system
 //!
 //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
-//! DATE: 2023-08-01, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! DATE: 2023-08-07, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
 //! WORST CASE MAP SIZE: `1000000`
 //! CPU: `Intel(R) Xeon(R) Platinum 8375C CPU @ 2.90GHz`
 //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("vara-dev"), DB CACHE: 1024
@@ -53,8 +53,8 @@ impl<T: frame_system::Config> frame_system::WeightInfo for SubstrateWeight<T> {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 1_545_000 picoseconds.
-        Weight::from_parts(1_316_572, 0)
+        // Minimum execution time: 1_503_000 picoseconds.
+        Weight::from_parts(1_491_824, 0)
             // Standard Error: 0
             .saturating_add(Weight::from_parts(459, 0).saturating_mul(b.into()))
     }
@@ -63,17 +63,17 @@ impl<T: frame_system::Config> frame_system::WeightInfo for SubstrateWeight<T> {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 5_923_000 picoseconds.
-        Weight::from_parts(6_124_000, 0)
+        // Minimum execution time: 5_709_000 picoseconds.
+        Weight::from_parts(5_959_000, 0)
             // Standard Error: 0
-            .saturating_add(Weight::from_parts(1_437, 0).saturating_mul(b.into()))
+            .saturating_add(Weight::from_parts(1_440, 0).saturating_mul(b.into()))
     }
     fn set_heap_pages() -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `1485`
-        // Minimum execution time: 3_063_000 picoseconds.
-        Weight::from_parts(3_389_000, 1485)
+        // Minimum execution time: 2_908_000 picoseconds.
+        Weight::from_parts(3_176_000, 1485)
             .saturating_add(T::DbWeight::get().reads(1_u64))
             .saturating_add(T::DbWeight::get().writes(2_u64))
     }
@@ -82,10 +82,10 @@ impl<T: frame_system::Config> frame_system::WeightInfo for SubstrateWeight<T> {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 1_641_000 picoseconds.
-        Weight::from_parts(1_707_000, 0)
-            // Standard Error: 959
-            .saturating_add(Weight::from_parts(686_028, 0).saturating_mul(i.into()))
+        // Minimum execution time: 1_503_000 picoseconds.
+        Weight::from_parts(1_602_000, 0)
+            // Standard Error: 1_020
+            .saturating_add(Weight::from_parts(676_199, 0).saturating_mul(i.into()))
             .saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(i.into())))
     }
     /// The range of component `i` is `[0, 1000]`.
@@ -93,10 +93,10 @@ impl<T: frame_system::Config> frame_system::WeightInfo for SubstrateWeight<T> {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 1_644_000 picoseconds.
-        Weight::from_parts(1_678_000, 0)
-            // Standard Error: 747
-            .saturating_add(Weight::from_parts(524_085, 0).saturating_mul(i.into()))
+        // Minimum execution time: 1_477_000 picoseconds.
+        Weight::from_parts(1_606_000, 0)
+            // Standard Error: 751
+            .saturating_add(Weight::from_parts(523_999, 0).saturating_mul(i.into()))
             .saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(i.into())))
     }
     /// The range of component `p` is `[0, 1000]`.
@@ -104,10 +104,10 @@ impl<T: frame_system::Config> frame_system::WeightInfo for SubstrateWeight<T> {
         // Proof Size summary in bytes:
         //  Measured:  `82 + p * (69 ±0)`
         //  Estimated: `83 + p * (70 ±0)`
-        // Minimum execution time: 3_294_000 picoseconds.
-        Weight::from_parts(3_471_000, 83)
-            // Standard Error: 1_159
-            .saturating_add(Weight::from_parts(1_110_583, 0).saturating_mul(p.into()))
+        // Minimum execution time: 3_270_000 picoseconds.
+        Weight::from_parts(3_354_000, 83)
+            // Standard Error: 1_375
+            .saturating_add(Weight::from_parts(1_112_948, 0).saturating_mul(p.into()))
             .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(p.into())))
             .saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(p.into())))
             .saturating_add(Weight::from_parts(0, 70).saturating_mul(p.into()))
@@ -121,8 +121,8 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 1_545_000 picoseconds.
-        Weight::from_parts(1_316_572, 0)
+        // Minimum execution time: 1_503_000 picoseconds.
+        Weight::from_parts(1_491_824, 0)
             // Standard Error: 0
             .saturating_add(Weight::from_parts(459, 0).saturating_mul(b.into()))
     }
@@ -131,17 +131,17 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 5_923_000 picoseconds.
-        Weight::from_parts(6_124_000, 0)
+        // Minimum execution time: 5_709_000 picoseconds.
+        Weight::from_parts(5_959_000, 0)
             // Standard Error: 0
-            .saturating_add(Weight::from_parts(1_437, 0).saturating_mul(b.into()))
+            .saturating_add(Weight::from_parts(1_440, 0).saturating_mul(b.into()))
     }
     fn set_heap_pages() -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `1485`
-        // Minimum execution time: 3_063_000 picoseconds.
-        Weight::from_parts(3_389_000, 1485)
+        // Minimum execution time: 2_908_000 picoseconds.
+        Weight::from_parts(3_176_000, 1485)
             .saturating_add(RocksDbWeight::get().reads(1_u64))
             .saturating_add(RocksDbWeight::get().writes(2_u64))
     }
@@ -150,10 +150,10 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 1_641_000 picoseconds.
-        Weight::from_parts(1_707_000, 0)
-            // Standard Error: 959
-            .saturating_add(Weight::from_parts(686_028, 0).saturating_mul(i.into()))
+        // Minimum execution time: 1_503_000 picoseconds.
+        Weight::from_parts(1_602_000, 0)
+            // Standard Error: 1_020
+            .saturating_add(Weight::from_parts(676_199, 0).saturating_mul(i.into()))
             .saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(i.into())))
     }
     /// The range of component `i` is `[0, 1000]`.
@@ -161,10 +161,10 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 1_644_000 picoseconds.
-        Weight::from_parts(1_678_000, 0)
-            // Standard Error: 747
-            .saturating_add(Weight::from_parts(524_085, 0).saturating_mul(i.into()))
+        // Minimum execution time: 1_477_000 picoseconds.
+        Weight::from_parts(1_606_000, 0)
+            // Standard Error: 751
+            .saturating_add(Weight::from_parts(523_999, 0).saturating_mul(i.into()))
             .saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(i.into())))
     }
     /// The range of component `p` is `[0, 1000]`.
@@ -172,10 +172,10 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `82 + p * (69 ±0)`
         //  Estimated: `83 + p * (70 ±0)`
-        // Minimum execution time: 3_294_000 picoseconds.
-        Weight::from_parts(3_471_000, 83)
-            // Standard Error: 1_159
-            .saturating_add(Weight::from_parts(1_110_583, 0).saturating_mul(p.into()))
+        // Minimum execution time: 3_270_000 picoseconds.
+        Weight::from_parts(3_354_000, 83)
+            // Standard Error: 1_375
+            .saturating_add(Weight::from_parts(1_112_948, 0).saturating_mul(p.into()))
             .saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(p.into())))
             .saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(p.into())))
             .saturating_add(Weight::from_parts(0, 70).saturating_mul(p.into()))
diff --git a/runtime/vara/src/weights/pallet_airdrop.rs b/runtime/vara/src/weights/pallet_airdrop.rs
index 62ae1a74e8d..86ac421788d 100644
--- a/runtime/vara/src/weights/pallet_airdrop.rs
+++ b/runtime/vara/src/weights/pallet_airdrop.rs
@@ -19,13 +19,13 @@
 //! Autogenerated weights for pallet_airdrop
 //!
 //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
-//! DATE: 2023-07-26, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! DATE: 2023-08-07, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
 //! WORST CASE MAP SIZE: `1000000`
 //! CPU: `Intel(R) Xeon(R) Platinum 8375C CPU @ 2.90GHz`
 //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("vara-dev"), DB CACHE: 1024
 
 // Executed Command:
-// ./target/production/gear benchmark pallet --chain=vara-dev --steps=50 --repeat=20 --pallet=pallet_airdrop --extrinsic=* --execution=wasm --wasm-execution=compiled --heap-pages=4096 --output=pallet_airdrop.rs --template=.maintain/frame-weight-template.hbs
+// ./target/production/gear benchmark pallet --chain=vara-dev --steps=50 --repeat=20 --pallet=pallet_airdrop --extrinsic=* --execution=wasm --wasm-execution=compiled --heap-pages=4096 --output=./scripts/benchmarking/weights-output/pallet_airdrop.rs --template=.maintain/frame-weight-template.hbs
 
 #![cfg_attr(rustfmt, rustfmt_skip)]
 #![allow(unused_parens)]
@@ -49,20 +49,18 @@ impl<T: frame_system::Config> pallet_airdrop::WeightInfo for SubstrateWeight<T>
         // Proof Size summary in bytes:
         //  Measured:  `103`
         //  Estimated: `6196`
-        // Minimum execution time: 25_027_000 picoseconds.
-        Weight::from_parts(25_985_030, 6196)
+        // Minimum execution time: 24_965_000 picoseconds.
+        Weight::from_parts(26_088_278, 6196)
             .saturating_add(T::DbWeight::get().reads(2_u64))
             .saturating_add(T::DbWeight::get().writes(2_u64))
     }
     /// The range of component `q` is `[1, 256]`.
-    fn transfer_vested(q: u32, ) -> Weight {
+    fn transfer_vested(_q: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `550`
         //  Estimated: `15482`
-        // Minimum execution time: 65_271_000 picoseconds.
-        Weight::from_parts(67_109_074, 15482)
-            // Standard Error: 328
-            .saturating_add(Weight::from_parts(336, 0).saturating_mul(q.into()))
+        // Minimum execution time: 65_471_000 picoseconds.
+        Weight::from_parts(67_416_608, 15482)
             .saturating_add(T::DbWeight::get().reads(4_u64))
             .saturating_add(T::DbWeight::get().writes(4_u64))
     }
@@ -75,20 +73,18 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `103`
         //  Estimated: `6196`
-        // Minimum execution time: 25_027_000 picoseconds.
-        Weight::from_parts(25_985_030, 6196)
+        // Minimum execution time: 24_965_000 picoseconds.
+        Weight::from_parts(26_088_278, 6196)
             .saturating_add(RocksDbWeight::get().reads(2_u64))
             .saturating_add(RocksDbWeight::get().writes(2_u64))
     }
     /// The range of component `q` is `[1, 256]`.
-    fn transfer_vested(q: u32, ) -> Weight {
+    fn transfer_vested(_q: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `550`
         //  Estimated: `15482`
-        // Minimum execution time: 65_271_000 picoseconds.
-        Weight::from_parts(67_109_074, 15482)
-            // Standard Error: 328
-            .saturating_add(Weight::from_parts(336, 0).saturating_mul(q.into()))
+        // Minimum execution time: 65_471_000 picoseconds.
+        Weight::from_parts(67_416_608, 15482)
             .saturating_add(RocksDbWeight::get().reads(4_u64))
             .saturating_add(RocksDbWeight::get().writes(4_u64))
     }
diff --git a/runtime/vara/src/weights/pallet_balances.rs b/runtime/vara/src/weights/pallet_balances.rs
index 7c5d3c9d263..a9486cc0e2e 100644
--- a/runtime/vara/src/weights/pallet_balances.rs
+++ b/runtime/vara/src/weights/pallet_balances.rs
@@ -19,7 +19,7 @@
 //! Autogenerated weights for pallet_balances
 //!
 //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
-//! DATE: 2023-08-01, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! DATE: 2023-08-07, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
 //! WORST CASE MAP SIZE: `1000000`
 //! CPU: `Intel(R) Xeon(R) Platinum 8375C CPU @ 2.90GHz`
 //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("vara-dev"), DB CACHE: 1024
@@ -53,8 +53,8 @@ impl<T: frame_system::Config> pallet_balances::WeightInfo for SubstrateWeight<T>
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `3593`
-        // Minimum execution time: 31_720_000 picoseconds.
-        Weight::from_parts(32_331_000, 3593)
+        // Minimum execution time: 29_934_000 picoseconds.
+        Weight::from_parts(30_505_000, 3593)
             .saturating_add(T::DbWeight::get().reads(1_u64))
             .saturating_add(T::DbWeight::get().writes(1_u64))
     }
@@ -62,8 +62,8 @@ impl<T: frame_system::Config> pallet_balances::WeightInfo for SubstrateWeight<T>
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `3593`
-        // Minimum execution time: 23_027_000 picoseconds.
-        Weight::from_parts(23_472_000, 3593)
+        // Minimum execution time: 21_441_000 picoseconds.
+        Weight::from_parts(22_000_000, 3593)
             .saturating_add(T::DbWeight::get().reads(1_u64))
             .saturating_add(T::DbWeight::get().writes(1_u64))
     }
@@ -71,8 +71,8 @@ impl<T: frame_system::Config> pallet_balances::WeightInfo for SubstrateWeight<T>
         // Proof Size summary in bytes:
         //  Measured:  `103`
         //  Estimated: `3593`
-        // Minimum execution time: 12_856_000 picoseconds.
-        Weight::from_parts(13_281_000, 3593)
+        // Minimum execution time: 12_250_000 picoseconds.
+        Weight::from_parts(12_703_000, 3593)
             .saturating_add(T::DbWeight::get().reads(1_u64))
             .saturating_add(T::DbWeight::get().writes(1_u64))
     }
@@ -80,8 +80,8 @@ impl<T: frame_system::Config> pallet_balances::WeightInfo for SubstrateWeight<T>
         // Proof Size summary in bytes:
         //  Measured:  `103`
         //  Estimated: `3593`
-        // Minimum execution time: 15_656_000 picoseconds.
-        Weight::from_parts(16_124_000, 3593)
+        // Minimum execution time: 15_163_000 picoseconds.
+        Weight::from_parts(15_565_000, 3593)
             .saturating_add(T::DbWeight::get().reads(1_u64))
             .saturating_add(T::DbWeight::get().writes(1_u64))
     }
@@ -89,8 +89,8 @@ impl<T: frame_system::Config> pallet_balances::WeightInfo for SubstrateWeight<T>
         // Proof Size summary in bytes:
         //  Measured:  `103`
         //  Estimated: `6196`
-        // Minimum execution time: 33_238_000 picoseconds.
-        Weight::from_parts(33_914_000, 6196)
+        // Minimum execution time: 31_518_000 picoseconds.
+        Weight::from_parts(31_923_000, 6196)
             .saturating_add(T::DbWeight::get().reads(2_u64))
             .saturating_add(T::DbWeight::get().writes(2_u64))
     }
@@ -98,8 +98,8 @@ impl<T: frame_system::Config> pallet_balances::WeightInfo for SubstrateWeight<T>
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `3593`
-        // Minimum execution time: 29_167_000 picoseconds.
-        Weight::from_parts(29_692_000, 3593)
+        // Minimum execution time: 27_693_000 picoseconds.
+        Weight::from_parts(28_166_000, 3593)
             .saturating_add(T::DbWeight::get().reads(1_u64))
             .saturating_add(T::DbWeight::get().writes(1_u64))
     }
@@ -107,8 +107,8 @@ impl<T: frame_system::Config> pallet_balances::WeightInfo for SubstrateWeight<T>
         // Proof Size summary in bytes:
         //  Measured:  `103`
         //  Estimated: `3593`
-        // Minimum execution time: 12_557_000 picoseconds.
-        Weight::from_parts(12_942_000, 3593)
+        // Minimum execution time: 11_670_000 picoseconds.
+        Weight::from_parts(12_112_000, 3593)
             .saturating_add(T::DbWeight::get().reads(1_u64))
             .saturating_add(T::DbWeight::get().writes(1_u64))
     }
@@ -120,8 +120,8 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `3593`
-        // Minimum execution time: 31_720_000 picoseconds.
-        Weight::from_parts(32_331_000, 3593)
+        // Minimum execution time: 29_934_000 picoseconds.
+        Weight::from_parts(30_505_000, 3593)
             .saturating_add(RocksDbWeight::get().reads(1_u64))
             .saturating_add(RocksDbWeight::get().writes(1_u64))
     }
@@ -129,8 +129,8 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `3593`
-        // Minimum execution time: 23_027_000 picoseconds.
-        Weight::from_parts(23_472_000, 3593)
+        // Minimum execution time: 21_441_000 picoseconds.
+        Weight::from_parts(22_000_000, 3593)
             .saturating_add(RocksDbWeight::get().reads(1_u64))
             .saturating_add(RocksDbWeight::get().writes(1_u64))
     }
@@ -138,8 +138,8 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `103`
         //  Estimated: `3593`
-        // Minimum execution time: 12_856_000 picoseconds.
-        Weight::from_parts(13_281_000, 3593)
+        // Minimum execution time: 12_250_000 picoseconds.
+        Weight::from_parts(12_703_000, 3593)
             .saturating_add(RocksDbWeight::get().reads(1_u64))
             .saturating_add(RocksDbWeight::get().writes(1_u64))
     }
@@ -147,8 +147,8 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `103`
         //  Estimated: `3593`
-        // Minimum execution time: 15_656_000 picoseconds.
-        Weight::from_parts(16_124_000, 3593)
+        // Minimum execution time: 15_163_000 picoseconds.
+        Weight::from_parts(15_565_000, 3593)
             .saturating_add(RocksDbWeight::get().reads(1_u64))
             .saturating_add(RocksDbWeight::get().writes(1_u64))
     }
@@ -156,8 +156,8 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `103`
         //  Estimated: `6196`
-        // Minimum execution time: 33_238_000 picoseconds.
-        Weight::from_parts(33_914_000, 6196)
+        // Minimum execution time: 31_518_000 picoseconds.
+        Weight::from_parts(31_923_000, 6196)
             .saturating_add(RocksDbWeight::get().reads(2_u64))
             .saturating_add(RocksDbWeight::get().writes(2_u64))
     }
@@ -165,8 +165,8 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `3593`
-        // Minimum execution time: 29_167_000 picoseconds.
-        Weight::from_parts(29_692_000, 3593)
+        // Minimum execution time: 27_693_000 picoseconds.
+        Weight::from_parts(28_166_000, 3593)
             .saturating_add(RocksDbWeight::get().reads(1_u64))
             .saturating_add(RocksDbWeight::get().writes(1_u64))
     }
@@ -174,8 +174,8 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `103`
         //  Estimated: `3593`
-        // Minimum execution time: 12_557_000 picoseconds.
-        Weight::from_parts(12_942_000, 3593)
+        // Minimum execution time: 11_670_000 picoseconds.
+        Weight::from_parts(12_112_000, 3593)
             .saturating_add(RocksDbWeight::get().reads(1_u64))
             .saturating_add(RocksDbWeight::get().writes(1_u64))
     }
diff --git a/runtime/vara/src/weights/pallet_gear.rs b/runtime/vara/src/weights/pallet_gear.rs
index 89a72918825..5ad37564e7b 100644
--- a/runtime/vara/src/weights/pallet_gear.rs
+++ b/runtime/vara/src/weights/pallet_gear.rs
@@ -19,7 +19,7 @@
 //! Autogenerated weights for pallet_gear
 //!
 //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
-//! DATE: 2023-08-01, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! DATE: 2023-08-07, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
 //! WORST CASE MAP SIZE: `1000000`
 //! CPU: `Intel(R) Xeon(R) Platinum 8375C CPU @ 2.90GHz`
 //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("vara-dev"), DB CACHE: 1024
@@ -246,10 +246,10 @@ impl<T: frame_system::Config> pallet_gear::WeightInfo for SubstrateWeight<T> {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 1_003_000 picoseconds.
-        Weight::from_parts(1_051_000, 0)
-            // Standard Error: 968
-            .saturating_add(Weight::from_parts(212_482, 0).saturating_mul(c.into()))
+        // Minimum execution time: 1_017_000 picoseconds.
+        Weight::from_parts(1_119_000, 0)
+            // Standard Error: 761
+            .saturating_add(Weight::from_parts(209_074, 0).saturating_mul(c.into()))
             .saturating_add(T::DbWeight::get().writes(1_u64))
     }
     /// The range of component `c` is `[0, 512]`.
@@ -257,10 +257,10 @@ impl<T: frame_system::Config> pallet_gear::WeightInfo for SubstrateWeight<T> {
         // Proof Size summary in bytes:
         //  Measured:  `113 + c * (1024 ±0)`
         //  Estimated: `3577 + c * (1024 ±0)`
-        // Minimum execution time: 3_267_000 picoseconds.
-        Weight::from_parts(3_316_000, 3577)
-            // Standard Error: 1_072
-            .saturating_add(Weight::from_parts(688_242, 0).saturating_mul(c.into()))
+        // Minimum execution time: 3_299_000 picoseconds.
+        Weight::from_parts(3_409_000, 3577)
+            // Standard Error: 809
+            .saturating_add(Weight::from_parts(667_635, 0).saturating_mul(c.into()))
             .saturating_add(T::DbWeight::get().reads(1_u64))
             .saturating_add(Weight::from_parts(0, 1024).saturating_mul(c.into()))
     }
@@ -269,17 +269,17 @@ impl<T: frame_system::Config> pallet_gear::WeightInfo for SubstrateWeight<T> {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 53_248_000 picoseconds.
-        Weight::from_parts(71_345_881, 0)
-            // Standard Error: 10_707
-            .saturating_add(Weight::from_parts(2_548_249, 0).saturating_mul(c.into()))
+        // Minimum execution time: 50_278_000 picoseconds.
+        Weight::from_parts(73_427_731, 0)
+            // Standard Error: 6_473
+            .saturating_add(Weight::from_parts(2_331_768, 0).saturating_mul(c.into()))
     }
     fn claim_value() -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `1050`
         //  Estimated: `42875`
-        // Minimum execution time: 84_992_000 picoseconds.
-        Weight::from_parts(88_176_000, 42875)
+        // Minimum execution time: 81_857_000 picoseconds.
+        Weight::from_parts(83_494_000, 42875)
             .saturating_add(T::DbWeight::get().reads(13_u64))
             .saturating_add(T::DbWeight::get().writes(10_u64))
     }
@@ -287,8 +287,8 @@ impl<T: frame_system::Config> pallet_gear::WeightInfo for SubstrateWeight<T> {
         // Proof Size summary in bytes:
         //  Measured:  `958`
         //  Estimated: `21477`
-        // Minimum execution time: 56_951_000 picoseconds.
-        Weight::from_parts(58_755_000, 21477)
+        // Minimum execution time: 53_880_000 picoseconds.
+        Weight::from_parts(55_703_000, 21477)
             .saturating_add(T::DbWeight::get().reads(7_u64))
             .saturating_add(T::DbWeight::get().writes(6_u64))
     }
@@ -296,8 +296,8 @@ impl<T: frame_system::Config> pallet_gear::WeightInfo for SubstrateWeight<T> {
         // Proof Size summary in bytes:
         //  Measured:  `605`
         //  Estimated: `17354`
-        // Minimum execution time: 30_483_000 picoseconds.
-        Weight::from_parts(31_174_000, 17354)
+        // Minimum execution time: 28_976_000 picoseconds.
+        Weight::from_parts(30_055_000, 17354)
             .saturating_add(T::DbWeight::get().reads(6_u64))
             .saturating_add(T::DbWeight::get().writes(4_u64))
     }
@@ -306,10 +306,10 @@ impl<T: frame_system::Config> pallet_gear::WeightInfo for SubstrateWeight<T> {
         // Proof Size summary in bytes:
         //  Measured:  `355`
         //  Estimated: `7640`
-        // Minimum execution time: 8_269_000 picoseconds.
-        Weight::from_parts(7_343_300, 7640)
-            // Standard Error: 45_015
-            .saturating_add(Weight::from_parts(15_758_869, 0).saturating_mul(c.into()))
+        // Minimum execution time: 7_954_000 picoseconds.
+        Weight::from_parts(9_206_629, 7640)
+            // Standard Error: 40_915
+            .saturating_add(Weight::from_parts(13_218_946, 0).saturating_mul(c.into()))
             .saturating_add(T::DbWeight::get().reads(2_u64))
             .saturating_add(T::DbWeight::get().writes(2_u64))
     }
@@ -318,10 +318,10 @@ impl<T: frame_system::Config> pallet_gear::WeightInfo for SubstrateWeight<T> {
         // Proof Size summary in bytes:
         //  Measured:  `1439 + c * (16389 ±0)`
         //  Estimated: `42034 + c * (131112 ±0)`
-        // Minimum execution time: 70_643_000 picoseconds.
-        Weight::from_parts(71_487_000, 42034)
-            // Standard Error: 217_960
-            .saturating_add(Weight::from_parts(56_304_860, 0).saturating_mul(c.into()))
+        // Minimum execution time: 69_036_000 picoseconds.
+        Weight::from_parts(70_072_000, 42034)
+            // Standard Error: 149_794
+            .saturating_add(Weight::from_parts(52_674_750, 0).saturating_mul(c.into()))
             .saturating_add(T::DbWeight::get().reads(11_u64))
             .saturating_add(T::DbWeight::get().writes(9_u64))
             .saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(c.into())))
@@ -332,10 +332,10 @@ impl<T: frame_system::Config> pallet_gear::WeightInfo for SubstrateWeight<T> {
         // Proof Size summary in bytes:
         //  Measured:  `80`
         //  Estimated: `5270`
-        // Minimum execution time: 63_871_000 picoseconds.
-        Weight::from_parts(31_431_372, 5270)
-            // Standard Error: 58_224
-            .saturating_add(Weight::from_parts(52_560_364, 0).saturating_mul(c.into()))
+        // Minimum execution time: 61_042_000 picoseconds.
+        Weight::from_parts(42_647_149, 5270)
+            // Standard Error: 41_151
+            .saturating_add(Weight::from_parts(51_906_843, 0).saturating_mul(c.into()))
             .saturating_add(T::DbWeight::get().reads(2_u64))
             .saturating_add(T::DbWeight::get().writes(4_u64))
     }
@@ -344,10 +344,10 @@ impl<T: frame_system::Config> pallet_gear::WeightInfo for SubstrateWeight<T> {
         // Proof Size summary in bytes:
         //  Measured:  `742`
         //  Estimated: `39419`
-        // Minimum execution time: 65_988_000 picoseconds.
-        Weight::from_parts(102_441_114, 39419)
-            // Standard Error: 1
-            .saturating_add(Weight::from_parts(2_612, 0).saturating_mul(s.into()))
+        // Minimum execution time: 62_956_000 picoseconds.
+        Weight::from_parts(74_593_794, 39419)
+            // Standard Error: 0
+            .saturating_add(Weight::from_parts(2_594, 0).saturating_mul(s.into()))
             .saturating_add(T::DbWeight::get().reads(13_u64))
             .saturating_add(T::DbWeight::get().writes(10_u64))
     }
@@ -357,12 +357,12 @@ impl<T: frame_system::Config> pallet_gear::WeightInfo for SubstrateWeight<T> {
         // Proof Size summary in bytes:
         //  Measured:  `306`
         //  Estimated: `35235`
-        // Minimum execution time: 11_021_135_000 picoseconds.
-        Weight::from_parts(397_699_856, 35235)
-            // Standard Error: 169_994
-            .saturating_add(Weight::from_parts(52_665_060, 0).saturating_mul(c.into()))
-            // Standard Error: 10
-            .saturating_add(Weight::from_parts(2_533, 0).saturating_mul(s.into()))
+        // Minimum execution time: 10_939_548_000 picoseconds.
+        Weight::from_parts(505_483_291, 35235)
+            // Standard Error: 158_935
+            .saturating_add(Weight::from_parts(51_999_053, 0).saturating_mul(c.into()))
+            // Standard Error: 9
+            .saturating_add(Weight::from_parts(2_500, 0).saturating_mul(s.into()))
             .saturating_add(T::DbWeight::get().reads(13_u64))
             .saturating_add(T::DbWeight::get().writes(14_u64))
     }
@@ -371,10 +371,10 @@ impl<T: frame_system::Config> pallet_gear::WeightInfo for SubstrateWeight<T> {
         // Proof Size summary in bytes:
         //  Measured:  `349`
         //  Estimated: `23860`
-        // Minimum execution time: 57_013_000 picoseconds.
-        Weight::from_parts(35_413_717, 23860)
-            // Standard Error: 1
-            .saturating_add(Weight::from_parts(1_158, 0).saturating_mul(p.into()))
+        // Minimum execution time: 54_714_000 picoseconds.
+        Weight::from_parts(39_682_905, 23860)
+            // Standard Error: 0
+            .saturating_add(Weight::from_parts(1_012, 0).saturating_mul(p.into()))
             .saturating_add(T::DbWeight::get().reads(9_u64))
             .saturating_add(T::DbWeight::get().writes(8_u64))
     }
@@ -383,10 +383,10 @@ impl<T: frame_system::Config> pallet_gear::WeightInfo for SubstrateWeight<T> {
         // Proof Size summary in bytes:
         //  Measured:  `452`
         //  Estimated: `27184`
-        // Minimum execution time: 60_180_000 picoseconds.
-        Weight::from_parts(33_390_466, 27184)
-            // Standard Error: 2
-            .saturating_add(Weight::from_parts(1_167, 0).saturating_mul(p.into()))
+        // Minimum execution time: 56_333_000 picoseconds.
+        Weight::from_parts(38_749_450, 27184)
+            // Standard Error: 1
+            .saturating_add(Weight::from_parts(1_023, 0).saturating_mul(p.into()))
             .saturating_add(T::DbWeight::get().reads(10_u64))
             .saturating_add(T::DbWeight::get().writes(9_u64))
     }
@@ -395,10 +395,10 @@ impl<T: frame_system::Config> pallet_gear::WeightInfo for SubstrateWeight<T> {
         // Proof Size summary in bytes:
         //  Measured:  `1049`
         //  Estimated: `42866`
-        // Minimum execution time: 87_446_000 picoseconds.
-        Weight::from_parts(69_330_706, 42866)
-            // Standard Error: 2
-            .saturating_add(Weight::from_parts(1_174, 0).saturating_mul(p.into()))
+        // Minimum execution time: 82_073_000 picoseconds.
+        Weight::from_parts(66_860_069, 42866)
+            // Standard Error: 1
+            .saturating_add(Weight::from_parts(1_035, 0).saturating_mul(p.into()))
             .saturating_add(T::DbWeight::get().reads(13_u64))
             .saturating_add(T::DbWeight::get().writes(10_u64))
     }
@@ -407,20 +407,22 @@ impl<T: frame_system::Config> pallet_gear::WeightInfo for SubstrateWeight<T> {
         // Proof Size summary in bytes:
         //  Measured:  `1152`
         //  Estimated: `46396`
-        // Minimum execution time: 97_152_000 picoseconds.
-        Weight::from_parts(77_891_346, 46396)
-            // Standard Error: 2
-            .saturating_add(Weight::from_parts(1_170, 0).saturating_mul(p.into()))
+        // Minimum execution time: 92_361_000 picoseconds.
+        Weight::from_parts(69_850_521, 46396)
+            // Standard Error: 1
+            .saturating_add(Weight::from_parts(1_052, 0).saturating_mul(p.into()))
             .saturating_add(T::DbWeight::get().reads(14_u64))
             .saturating_add(T::DbWeight::get().writes(11_u64))
     }
     /// The range of component `q` is `[1, 512]`.
-    fn initial_allocation(_q: u32, ) -> Weight {
+    fn initial_allocation(q: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `1066`
         //  Estimated: `85981`
-        // Minimum execution time: 323_882_000 picoseconds.
-        Weight::from_parts(336_539_045, 85981)
+        // Minimum execution time: 316_122_000 picoseconds.
+        Weight::from_parts(330_387_653, 85981)
+            // Standard Error: 1_030
+            .saturating_add(Weight::from_parts(2_167, 0).saturating_mul(q.into()))
             .saturating_add(T::DbWeight::get().reads(29_u64))
             .saturating_add(T::DbWeight::get().writes(23_u64))
     }
@@ -429,8 +431,8 @@ impl<T: frame_system::Config> pallet_gear::WeightInfo for SubstrateWeight<T> {
         // Proof Size summary in bytes:
         //  Measured:  `1066`
         //  Estimated: `85905`
-        // Minimum execution time: 336_406_000 picoseconds.
-        Weight::from_parts(353_807_338, 85905)
+        // Minimum execution time: 327_296_000 picoseconds.
+        Weight::from_parts(344_778_587, 85905)
             .saturating_add(T::DbWeight::get().reads(29_u64))
             .saturating_add(T::DbWeight::get().writes(23_u64))
     }
@@ -439,10 +441,10 @@ impl<T: frame_system::Config> pallet_gear::WeightInfo for SubstrateWeight<T> {
         // Proof Size summary in bytes:
         //  Measured:  `211 + c * (1075 ±0)`
         //  Estimated: `3899 + c * (2150 ±0)`
-        // Minimum execution time: 45_464_000 picoseconds.
-        Weight::from_parts(45_831_000, 3899)
-            // Standard Error: 36_617
-            .saturating_add(Weight::from_parts(51_273_892, 0).saturating_mul(c.into()))
+        // Minimum execution time: 45_031_000 picoseconds.
+        Weight::from_parts(45_572_000, 3899)
+            // Standard Error: 24_669
+            .saturating_add(Weight::from_parts(50_090_777, 0).saturating_mul(c.into()))
             .saturating_add(T::DbWeight::get().reads(1_u64))
             .saturating_add(T::DbWeight::get().writes(2_u64))
             .saturating_add(Weight::from_parts(0, 2150).saturating_mul(c.into()))
@@ -452,630 +454,630 @@ impl<T: frame_system::Config> pallet_gear::WeightInfo for SubstrateWeight<T> {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 84_254_000 picoseconds.
-        Weight::from_parts(86_749_000, 0)
-            // Standard Error: 3_967_638
-            .saturating_add(Weight::from_parts(617_894_062, 0).saturating_mul(r.into()))
+        // Minimum execution time: 83_663_000 picoseconds.
+        Weight::from_parts(84_983_000, 0)
+            // Standard Error: 4_066_232
+            .saturating_add(Weight::from_parts(564_447_416, 0).saturating_mul(r.into()))
     }
     /// The range of component `p` is `[1, 512]`.
     fn alloc_per_page(p: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 366_392_000 picoseconds.
-        Weight::from_parts(294_624_660, 0)
-            // Standard Error: 10_067
-            .saturating_add(Weight::from_parts(30_802_641, 0).saturating_mul(p.into()))
+        // Minimum execution time: 311_448_000 picoseconds.
+        Weight::from_parts(245_631_815, 0)
+            // Standard Error: 7_937
+            .saturating_add(Weight::from_parts(30_896_737, 0).saturating_mul(p.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn free(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 199_070_000 picoseconds.
-        Weight::from_parts(213_938_845, 0)
-            // Standard Error: 343_895
-            .saturating_add(Weight::from_parts(120_152_478, 0).saturating_mul(r.into()))
+        // Minimum execution time: 149_067_000 picoseconds.
+        Weight::from_parts(130_181_921, 0)
+            // Standard Error: 294_281
+            .saturating_add(Weight::from_parts(60_998_326, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 256]`.
     fn gr_reserve_gas(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 85_714_000 picoseconds.
-        Weight::from_parts(96_261_609, 0)
-            // Standard Error: 3_991
-            .saturating_add(Weight::from_parts(3_567_375, 0).saturating_mul(r.into()))
+        // Minimum execution time: 87_222_000 picoseconds.
+        Weight::from_parts(94_195_714, 0)
+            // Standard Error: 3_616
+            .saturating_add(Weight::from_parts(2_672_494, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 256]`.
     fn gr_unreserve_gas(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 139_882_000 picoseconds.
-        Weight::from_parts(221_553_985, 0)
-            // Standard Error: 29_743
-            .saturating_add(Weight::from_parts(3_602_987, 0).saturating_mul(r.into()))
+        // Minimum execution time: 139_429_000 picoseconds.
+        Weight::from_parts(171_049_360, 0)
+            // Standard Error: 31_588
+            .saturating_add(Weight::from_parts(2_923_269, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_system_reserve_gas(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 87_497_000 picoseconds.
-        Weight::from_parts(118_603_695, 0)
-            // Standard Error: 431_810
-            .saturating_add(Weight::from_parts(177_456_338, 0).saturating_mul(r.into()))
+        // Minimum execution time: 86_992_000 picoseconds.
+        Weight::from_parts(115_936_976, 0)
+            // Standard Error: 414_340
+            .saturating_add(Weight::from_parts(116_785_346, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_message_id(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 88_831_000 picoseconds.
-        Weight::from_parts(88_005_607, 0)
-            // Standard Error: 244_708
-            .saturating_add(Weight::from_parts(175_744_834, 0).saturating_mul(r.into()))
+        // Minimum execution time: 87_790_000 picoseconds.
+        Weight::from_parts(90_746_200, 0)
+            // Standard Error: 270_835
+            .saturating_add(Weight::from_parts(107_416_174, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_program_id(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 84_145_000 picoseconds.
-        Weight::from_parts(86_969_872, 0)
-            // Standard Error: 302_008
-            .saturating_add(Weight::from_parts(180_744_297, 0).saturating_mul(r.into()))
+        // Minimum execution time: 84_210_000 picoseconds.
+        Weight::from_parts(91_082_335, 0)
+            // Standard Error: 211_867
+            .saturating_add(Weight::from_parts(104_318_383, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_source(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 84_337_000 picoseconds.
-        Weight::from_parts(80_268_581, 0)
-            // Standard Error: 290_578
-            .saturating_add(Weight::from_parts(180_541_423, 0).saturating_mul(r.into()))
+        // Minimum execution time: 84_806_000 picoseconds.
+        Weight::from_parts(85_438_969, 0)
+            // Standard Error: 248_652
+            .saturating_add(Weight::from_parts(105_330_427, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_value(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 85_327_000 picoseconds.
-        Weight::from_parts(84_307_332, 0)
-            // Standard Error: 316_639
-            .saturating_add(Weight::from_parts(179_561_839, 0).saturating_mul(r.into()))
+        // Minimum execution time: 84_654_000 picoseconds.
+        Weight::from_parts(82_257_210, 0)
+            // Standard Error: 336_548
+            .saturating_add(Weight::from_parts(106_454_200, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_value_available(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 85_300_000 picoseconds.
-        Weight::from_parts(70_645_226, 0)
-            // Standard Error: 320_673
-            .saturating_add(Weight::from_parts(182_342_085, 0).saturating_mul(r.into()))
+        // Minimum execution time: 84_452_000 picoseconds.
+        Weight::from_parts(82_661_045, 0)
+            // Standard Error: 286_452
+            .saturating_add(Weight::from_parts(105_467_642, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_gas_available(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 86_250_000 picoseconds.
-        Weight::from_parts(81_902_510, 0)
-            // Standard Error: 273_253
-            .saturating_add(Weight::from_parts(180_582_426, 0).saturating_mul(r.into()))
+        // Minimum execution time: 84_893_000 picoseconds.
+        Weight::from_parts(81_216_834, 0)
+            // Standard Error: 315_266
+            .saturating_add(Weight::from_parts(107_016_702, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_size(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 84_232_000 picoseconds.
-        Weight::from_parts(87_259_581, 0)
-            // Standard Error: 294_035
-            .saturating_add(Weight::from_parts(175_294_464, 0).saturating_mul(r.into()))
+        // Minimum execution time: 85_282_000 picoseconds.
+        Weight::from_parts(82_548_887, 0)
+            // Standard Error: 341_172
+            .saturating_add(Weight::from_parts(105_504_622, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_read(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 595_636_000 picoseconds.
-        Weight::from_parts(656_136_663, 0)
-            // Standard Error: 485_302
-            .saturating_add(Weight::from_parts(261_855_478, 0).saturating_mul(r.into()))
+        // Minimum execution time: 556_352_000 picoseconds.
+        Weight::from_parts(607_493_748, 0)
+            // Standard Error: 448_674
+            .saturating_add(Weight::from_parts(184_670_390, 0).saturating_mul(r.into()))
     }
     /// The range of component `n` is `[0, 2048]`.
     fn gr_read_per_kb(n: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 850_360_000 picoseconds.
-        Weight::from_parts(903_367_000, 0)
-            // Standard Error: 55_203
-            .saturating_add(Weight::from_parts(13_094_816, 0).saturating_mul(n.into()))
+        // Minimum execution time: 714_496_000 picoseconds.
+        Weight::from_parts(722_520_000, 0)
+            // Standard Error: 46_538
+            .saturating_add(Weight::from_parts(13_033_234, 0).saturating_mul(n.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_block_height(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 87_957_000 picoseconds.
-        Weight::from_parts(87_586_547, 0)
-            // Standard Error: 323_063
-            .saturating_add(Weight::from_parts(174_117_671, 0).saturating_mul(r.into()))
+        // Minimum execution time: 85_627_000 picoseconds.
+        Weight::from_parts(85_563_243, 0)
+            // Standard Error: 311_752
+            .saturating_add(Weight::from_parts(105_877_332, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_block_timestamp(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 87_008_000 picoseconds.
-        Weight::from_parts(78_303_076, 0)
-            // Standard Error: 299_495
-            .saturating_add(Weight::from_parts(175_222_715, 0).saturating_mul(r.into()))
+        // Minimum execution time: 86_852_000 picoseconds.
+        Weight::from_parts(84_860_381, 0)
+            // Standard Error: 321_988
+            .saturating_add(Weight::from_parts(105_008_310, 0).saturating_mul(r.into()))
     }
     /// The range of component `n` is `[0, 20]`.
     fn gr_random(n: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 84_234_000 picoseconds.
-        Weight::from_parts(103_801_859, 0)
-            // Standard Error: 382_198
-            .saturating_add(Weight::from_parts(245_171_881, 0).saturating_mul(n.into()))
+        // Minimum execution time: 84_396_000 picoseconds.
+        Weight::from_parts(89_972_413, 0)
+            // Standard Error: 338_324
+            .saturating_add(Weight::from_parts(184_316_536, 0).saturating_mul(n.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_reply_deposit(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 85_211_000 picoseconds.
-        Weight::from_parts(87_766_000, 0)
-            // Standard Error: 4_237_435
-            .saturating_add(Weight::from_parts(1_076_031_771, 0).saturating_mul(r.into()))
+        // Minimum execution time: 89_385_000 picoseconds.
+        Weight::from_parts(90_760_000, 0)
+            // Standard Error: 4_378_367
+            .saturating_add(Weight::from_parts(914_427_461, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_send(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 84_722_000 picoseconds.
-        Weight::from_parts(144_011_827, 0)
-            // Standard Error: 476_324
-            .saturating_add(Weight::from_parts(387_231_993, 0).saturating_mul(r.into()))
+        // Minimum execution time: 86_060_000 picoseconds.
+        Weight::from_parts(138_647_807, 0)
+            // Standard Error: 449_220
+            .saturating_add(Weight::from_parts(301_188_566, 0).saturating_mul(r.into()))
     }
     /// The range of component `n` is `[0, 2048]`.
     fn gr_send_per_kb(n: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 461_434_000 picoseconds.
-        Weight::from_parts(469_780_000, 0)
-            // Standard Error: 61_125
-            .saturating_add(Weight::from_parts(21_613_603, 0).saturating_mul(n.into()))
+        // Minimum execution time: 391_797_000 picoseconds.
+        Weight::from_parts(394_943_000, 0)
+            // Standard Error: 58_663
+            .saturating_add(Weight::from_parts(21_187_774, 0).saturating_mul(n.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_send_wgas(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 88_818_000 picoseconds.
-        Weight::from_parts(149_809_757, 0)
-            // Standard Error: 456_443
-            .saturating_add(Weight::from_parts(395_488_333, 0).saturating_mul(r.into()))
+        // Minimum execution time: 85_418_000 picoseconds.
+        Weight::from_parts(149_848_797, 0)
+            // Standard Error: 459_492
+            .saturating_add(Weight::from_parts(308_230_219, 0).saturating_mul(r.into()))
     }
     /// The range of component `n` is `[0, 2048]`.
     fn gr_send_wgas_per_kb(n: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 479_154_000 picoseconds.
-        Weight::from_parts(483_278_000, 0)
-            // Standard Error: 67_159
-            .saturating_add(Weight::from_parts(21_947_194, 0).saturating_mul(n.into()))
+        // Minimum execution time: 390_635_000 picoseconds.
+        Weight::from_parts(395_782_000, 0)
+            // Standard Error: 61_326
+            .saturating_add(Weight::from_parts(20_818_419, 0).saturating_mul(n.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_send_input(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 567_500_000 picoseconds.
-        Weight::from_parts(693_644_323, 0)
-            // Standard Error: 568_410
-            .saturating_add(Weight::from_parts(412_109_027, 0).saturating_mul(r.into()))
+        // Minimum execution time: 561_280_000 picoseconds.
+        Weight::from_parts(634_390_717, 0)
+            // Standard Error: 473_236
+            .saturating_add(Weight::from_parts(316_661_157, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_send_input_wgas(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 575_808_000 picoseconds.
-        Weight::from_parts(724_736_213, 0)
-            // Standard Error: 602_935
-            .saturating_add(Weight::from_parts(412_885_093, 0).saturating_mul(r.into()))
+        // Minimum execution time: 559_804_000 picoseconds.
+        Weight::from_parts(650_695_494, 0)
+            // Standard Error: 489_218
+            .saturating_add(Weight::from_parts(321_789_584, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_send_init(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 85_691_000 picoseconds.
-        Weight::from_parts(74_497_929, 0)
-            // Standard Error: 328_672
-            .saturating_add(Weight::from_parts(197_295_056, 0).saturating_mul(r.into()))
+        // Minimum execution time: 86_345_000 picoseconds.
+        Weight::from_parts(74_080_057, 0)
+            // Standard Error: 328_119
+            .saturating_add(Weight::from_parts(116_742_827, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_send_push(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 3_899_275_000 picoseconds.
-        Weight::from_parts(4_052_914_766, 0)
-            // Standard Error: 433_071
-            .saturating_add(Weight::from_parts(279_414_467, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_307_192_000 picoseconds.
+        Weight::from_parts(2_419_334_440, 0)
+            // Standard Error: 484_032
+            .saturating_add(Weight::from_parts(211_293_866, 0).saturating_mul(r.into()))
     }
     /// The range of component `n` is `[0, 2048]`.
     fn gr_send_push_per_kb(n: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 481_093_000 picoseconds.
-        Weight::from_parts(489_651_000, 0)
-            // Standard Error: 58_131
-            .saturating_add(Weight::from_parts(29_725_779, 0).saturating_mul(n.into()))
+        // Minimum execution time: 346_160_000 picoseconds.
+        Weight::from_parts(348_777_000, 0)
+            // Standard Error: 58_661
+            .saturating_add(Weight::from_parts(29_434_095, 0).saturating_mul(n.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_send_commit(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 3_898_930_000 picoseconds.
-        Weight::from_parts(4_051_051_643, 0)
-            // Standard Error: 422_685
-            .saturating_add(Weight::from_parts(335_909_883, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_292_607_000 picoseconds.
+        Weight::from_parts(2_434_102_108, 0)
+            // Standard Error: 502_502
+            .saturating_add(Weight::from_parts(264_859_383, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_send_commit_wgas(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 3_889_863_000 picoseconds.
-        Weight::from_parts(4_037_859_582, 0)
-            // Standard Error: 492_684
-            .saturating_add(Weight::from_parts(354_039_027, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_289_426_000 picoseconds.
+        Weight::from_parts(2_437_443_919, 0)
+            // Standard Error: 471_320
+            .saturating_add(Weight::from_parts(268_510_540, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_reservation_send(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 254_292_000 picoseconds.
-        Weight::from_parts(299_243_857, 0)
-            // Standard Error: 453_209
-            .saturating_add(Weight::from_parts(402_577_817, 0).saturating_mul(r.into()))
+        // Minimum execution time: 242_827_000 picoseconds.
+        Weight::from_parts(291_906_943, 0)
+            // Standard Error: 419_132
+            .saturating_add(Weight::from_parts(316_375_969, 0).saturating_mul(r.into()))
     }
     /// The range of component `n` is `[0, 2048]`.
     fn gr_reservation_send_per_kb(n: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 654_055_000 picoseconds.
-        Weight::from_parts(663_310_000, 0)
-            // Standard Error: 60_031
-            .saturating_add(Weight::from_parts(21_652_831, 0).saturating_mul(n.into()))
+        // Minimum execution time: 554_876_000 picoseconds.
+        Weight::from_parts(559_277_000, 0)
+            // Standard Error: 59_610
+            .saturating_add(Weight::from_parts(21_490_976, 0).saturating_mul(n.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_reservation_send_commit(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 4_054_583_000 picoseconds.
-        Weight::from_parts(4_192_801_478, 0)
-            // Standard Error: 494_878
-            .saturating_add(Weight::from_parts(356_698_705, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_443_317_000 picoseconds.
+        Weight::from_parts(2_625_227_536, 0)
+            // Standard Error: 511_289
+            .saturating_add(Weight::from_parts(283_117_268, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 1]`.
     fn gr_reply(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 84_037_000 picoseconds.
-        Weight::from_parts(88_828_036, 0)
-            // Standard Error: 335_490
-            .saturating_add(Weight::from_parts(26_597_063, 0).saturating_mul(r.into()))
+        // Minimum execution time: 85_099_000 picoseconds.
+        Weight::from_parts(88_574_604, 0)
+            // Standard Error: 274_173
+            .saturating_add(Weight::from_parts(20_834_495, 0).saturating_mul(r.into()))
     }
     /// The range of component `n` is `[0, 2048]`.
     fn gr_reply_per_kb(n: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 108_733_000 picoseconds.
-        Weight::from_parts(93_898_943, 0)
-            // Standard Error: 1_151
-            .saturating_add(Weight::from_parts(428_904, 0).saturating_mul(n.into()))
+        // Minimum execution time: 102_246_000 picoseconds.
+        Weight::from_parts(90_382_254, 0)
+            // Standard Error: 1_257
+            .saturating_add(Weight::from_parts(428_781, 0).saturating_mul(n.into()))
     }
     /// The range of component `r` is `[0, 1]`.
     fn gr_reply_wgas(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 82_569_000 picoseconds.
-        Weight::from_parts(89_213_638, 0)
-            // Standard Error: 317_917
-            .saturating_add(Weight::from_parts(22_797_961, 0).saturating_mul(r.into()))
+        // Minimum execution time: 86_454_000 picoseconds.
+        Weight::from_parts(90_235_951, 0)
+            // Standard Error: 256_364
+            .saturating_add(Weight::from_parts(14_555_548, 0).saturating_mul(r.into()))
     }
     /// The range of component `n` is `[0, 2048]`.
     fn gr_reply_wgas_per_kb(n: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 109_164_000 picoseconds.
-        Weight::from_parts(95_571_505, 0)
-            // Standard Error: 1_085
-            .saturating_add(Weight::from_parts(425_025, 0).saturating_mul(n.into()))
+        // Minimum execution time: 104_189_000 picoseconds.
+        Weight::from_parts(91_177_961, 0)
+            // Standard Error: 1_127
+            .saturating_add(Weight::from_parts(424_751, 0).saturating_mul(n.into()))
     }
     /// The range of component `r` is `[0, 1]`.
     fn gr_reply_commit(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 83_844_000 picoseconds.
-        Weight::from_parts(88_247_426, 0)
-            // Standard Error: 280_700
-            .saturating_add(Weight::from_parts(17_706_873, 0).saturating_mul(r.into()))
+        // Minimum execution time: 84_893_000 picoseconds.
+        Weight::from_parts(88_684_789, 0)
+            // Standard Error: 287_468
+            .saturating_add(Weight::from_parts(16_661_810, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 1]`.
     fn gr_reply_commit_wgas(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 82_987_000 picoseconds.
-        Weight::from_parts(87_544_514, 0)
-            // Standard Error: 269_120
-            .saturating_add(Weight::from_parts(21_098_185, 0).saturating_mul(r.into()))
+        // Minimum execution time: 84_534_000 picoseconds.
+        Weight::from_parts(88_923_020, 0)
+            // Standard Error: 249_896
+            .saturating_add(Weight::from_parts(19_208_979, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_reply_push(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 82_012_000 picoseconds.
-        Weight::from_parts(115_149_368, 0)
-            // Standard Error: 328_818
-            .saturating_add(Weight::from_parts(265_684_350, 0).saturating_mul(r.into()))
+        // Minimum execution time: 85_229_000 picoseconds.
+        Weight::from_parts(120_908_395, 0)
+            // Standard Error: 327_109
+            .saturating_add(Weight::from_parts(190_143_835, 0).saturating_mul(r.into()))
     }
     /// The range of component `n` is `[0, 8192]`.
     fn gr_reply_push_per_kb(n: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 100_890_000 picoseconds.
-        Weight::from_parts(102_844_000, 0)
-            // Standard Error: 2_931
-            .saturating_add(Weight::from_parts(635_797, 0).saturating_mul(n.into()))
+        // Minimum execution time: 98_549_000 picoseconds.
+        Weight::from_parts(100_553_000, 0)
+            // Standard Error: 2_727
+            .saturating_add(Weight::from_parts(616_949, 0).saturating_mul(n.into()))
     }
     /// The range of component `r` is `[0, 1]`.
     fn gr_reply_input(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 563_182_000 picoseconds.
-        Weight::from_parts(640_794_146, 0)
-            // Standard Error: 7_497_207
-            .saturating_add(Weight::from_parts(15_239_053, 0).saturating_mul(r.into()))
+        // Minimum execution time: 553_918_000 picoseconds.
+        Weight::from_parts(572_988_848, 0)
+            // Standard Error: 2_210_952
+            .saturating_add(Weight::from_parts(30_333_551, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 1]`.
     fn gr_reply_input_wgas(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 560_481_000 picoseconds.
-        Weight::from_parts(593_427_573, 0)
-            // Standard Error: 3_203_142
-            .saturating_add(Weight::from_parts(25_969_526, 0).saturating_mul(r.into()))
+        // Minimum execution time: 552_664_000 picoseconds.
+        Weight::from_parts(571_824_067, 0)
+            // Standard Error: 1_981_598
+            .saturating_add(Weight::from_parts(28_343_432, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 1]`.
     fn gr_reservation_reply(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 92_574_000 picoseconds.
-        Weight::from_parts(97_280_140, 0)
-            // Standard Error: 268_694
-            .saturating_add(Weight::from_parts(12_092_859, 0).saturating_mul(r.into()))
+        // Minimum execution time: 96_114_000 picoseconds.
+        Weight::from_parts(99_799_695, 0)
+            // Standard Error: 263_342
+            .saturating_add(Weight::from_parts(5_959_704, 0).saturating_mul(r.into()))
     }
     /// The range of component `n` is `[0, 2048]`.
     fn gr_reservation_reply_per_kb(n: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 109_631_000 picoseconds.
-        Weight::from_parts(94_175_255, 0)
-            // Standard Error: 1_213
-            .saturating_add(Weight::from_parts(427_553, 0).saturating_mul(n.into()))
+        // Minimum execution time: 104_595_000 picoseconds.
+        Weight::from_parts(94_900_895, 0)
+            // Standard Error: 1_221
+            .saturating_add(Weight::from_parts(425_729, 0).saturating_mul(n.into()))
     }
     /// The range of component `r` is `[0, 1]`.
     fn gr_reservation_reply_commit(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 95_505_000 picoseconds.
-        Weight::from_parts(100_109_459, 0)
-            // Standard Error: 279_145
-            .saturating_add(Weight::from_parts(8_335_840, 0).saturating_mul(r.into()))
+        // Minimum execution time: 94_123_000 picoseconds.
+        Weight::from_parts(99_068_002, 0)
+            // Standard Error: 278_340
+            .saturating_add(Weight::from_parts(6_056_397, 0).saturating_mul(r.into()))
     }
     /// The range of component `n` is `[0, 2048]`.
     fn gr_reservation_reply_commit_per_kb(n: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 105_015_000 picoseconds.
-        Weight::from_parts(96_000_128, 0)
-            // Standard Error: 1_363
-            .saturating_add(Weight::from_parts(423_685, 0).saturating_mul(n.into()))
+        // Minimum execution time: 106_148_000 picoseconds.
+        Weight::from_parts(93_583_351, 0)
+            // Standard Error: 1_048
+            .saturating_add(Weight::from_parts(420_112, 0).saturating_mul(n.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_reply_to(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 84_784_000 picoseconds.
-        Weight::from_parts(84_956_444, 0)
-            // Standard Error: 285_268
-            .saturating_add(Weight::from_parts(178_346_410, 0).saturating_mul(r.into()))
+        // Minimum execution time: 83_951_000 picoseconds.
+        Weight::from_parts(80_983_069, 0)
+            // Standard Error: 260_297
+            .saturating_add(Weight::from_parts(114_164_207, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_signal_from(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 85_915_000 picoseconds.
-        Weight::from_parts(78_586_027, 0)
-            // Standard Error: 254_710
-            .saturating_add(Weight::from_parts(178_243_954, 0).saturating_mul(r.into()))
+        // Minimum execution time: 88_991_000 picoseconds.
+        Weight::from_parts(83_808_552, 0)
+            // Standard Error: 291_596
+            .saturating_add(Weight::from_parts(107_977_269, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_reply_push_input(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 557_380_000 picoseconds.
-        Weight::from_parts(633_253_100, 0)
-            // Standard Error: 538_762
-            .saturating_add(Weight::from_parts(195_061_580, 0).saturating_mul(r.into()))
+        // Minimum execution time: 555_192_000 picoseconds.
+        Weight::from_parts(637_741_196, 0)
+            // Standard Error: 498_770
+            .saturating_add(Weight::from_parts(126_311_515, 0).saturating_mul(r.into()))
     }
     /// The range of component `n` is `[0, 2048]`.
     fn gr_reply_push_input_per_kb(n: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 597_682_000 picoseconds.
-        Weight::from_parts(661_897_574, 0)
-            // Standard Error: 3_826
-            .saturating_add(Weight::from_parts(136_457, 0).saturating_mul(n.into()))
+        // Minimum execution time: 567_642_000 picoseconds.
+        Weight::from_parts(587_862_774, 0)
+            // Standard Error: 1_100
+            .saturating_add(Weight::from_parts(120_318, 0).saturating_mul(n.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_send_push_input(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 4_454_821_000 picoseconds.
-        Weight::from_parts(4_682_125_339, 0)
-            // Standard Error: 520_741
-            .saturating_add(Weight::from_parts(206_155_172, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_764_152_000 picoseconds.
+        Weight::from_parts(2_885_803_691, 0)
+            // Standard Error: 562_616
+            .saturating_add(Weight::from_parts(154_883_526, 0).saturating_mul(r.into()))
     }
     /// The range of component `n` is `[0, 2048]`.
     fn gr_send_push_input_per_kb(n: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 4_637_831_000 picoseconds.
-        Weight::from_parts(4_748_853_254, 0)
-            // Standard Error: 16_010
-            .saturating_add(Weight::from_parts(12_276_105, 0).saturating_mul(n.into()))
+        // Minimum execution time: 2_942_765_000 picoseconds.
+        Weight::from_parts(2_852_597_513, 0)
+            // Standard Error: 14_069
+            .saturating_add(Weight::from_parts(12_388_759, 0).saturating_mul(n.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_debug(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 84_447_000 picoseconds.
-        Weight::from_parts(111_081_974, 0)
-            // Standard Error: 422_093
-            .saturating_add(Weight::from_parts(195_515_962, 0).saturating_mul(r.into()))
+        // Minimum execution time: 85_236_000 picoseconds.
+        Weight::from_parts(108_121_903, 0)
+            // Standard Error: 338_552
+            .saturating_add(Weight::from_parts(130_391_399, 0).saturating_mul(r.into()))
     }
     /// The range of component `n` is `[0, 2048]`.
     fn gr_debug_per_kb(n: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 188_901_000 picoseconds.
-        Weight::from_parts(192_422_000, 0)
-            // Standard Error: 54_402
-            .saturating_add(Weight::from_parts(25_703_289, 0).saturating_mul(n.into()))
+        // Minimum execution time: 143_555_000 picoseconds.
+        Weight::from_parts(145_256_000, 0)
+            // Standard Error: 61_456
+            .saturating_add(Weight::from_parts(25_766_308, 0).saturating_mul(n.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_reply_code(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 85_538_000 picoseconds.
-        Weight::from_parts(83_073_715, 0)
-            // Standard Error: 285_530
-            .saturating_add(Weight::from_parts(174_178_092, 0).saturating_mul(r.into()))
+        // Minimum execution time: 88_706_000 picoseconds.
+        Weight::from_parts(82_734_112, 0)
+            // Standard Error: 323_634
+            .saturating_add(Weight::from_parts(107_133_410, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 1]`.
     fn gr_exit(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 84_697_000 picoseconds.
-        Weight::from_parts(89_049_881, 0)
-            // Standard Error: 281_628
-            .saturating_add(Weight::from_parts(27_362_618, 0).saturating_mul(r.into()))
+        // Minimum execution time: 84_050_000 picoseconds.
+        Weight::from_parts(88_261_802, 0)
+            // Standard Error: 247_640
+            .saturating_add(Weight::from_parts(23_580_197, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 1]`.
     fn gr_leave(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 83_006_000 picoseconds.
-        Weight::from_parts(86_657_161, 0)
-            // Standard Error: 254_208
-            .saturating_add(Weight::from_parts(14_853_038, 0).saturating_mul(r.into()))
+        // Minimum execution time: 86_558_000 picoseconds.
+        Weight::from_parts(90_338_028, 0)
+            // Standard Error: 270_999
+            .saturating_add(Weight::from_parts(15_249_771, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 1]`.
     fn gr_wait(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 83_155_000 picoseconds.
-        Weight::from_parts(87_136_381, 0)
-            // Standard Error: 296_075
-            .saturating_add(Weight::from_parts(15_564_718, 0).saturating_mul(r.into()))
+        // Minimum execution time: 86_250_000 picoseconds.
+        Weight::from_parts(90_448_269, 0)
+            // Standard Error: 274_039
+            .saturating_add(Weight::from_parts(12_874_930, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 1]`.
     fn gr_wait_for(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 83_160_000 picoseconds.
-        Weight::from_parts(87_382_440, 0)
-            // Standard Error: 263_499
-            .saturating_add(Weight::from_parts(17_288_459, 0).saturating_mul(r.into()))
+        // Minimum execution time: 84_278_000 picoseconds.
+        Weight::from_parts(88_025_842, 0)
+            // Standard Error: 274_359
+            .saturating_add(Weight::from_parts(11_610_357, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 1]`.
     fn gr_wait_up_to(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 86_780_000 picoseconds.
-        Weight::from_parts(90_970_389, 0)
-            // Standard Error: 273_512
-            .saturating_add(Weight::from_parts(14_976_210, 0).saturating_mul(r.into()))
+        // Minimum execution time: 83_849_000 picoseconds.
+        Weight::from_parts(87_858_273, 0)
+            // Standard Error: 263_624
+            .saturating_add(Weight::from_parts(14_636_926, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_wake(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 141_871_000 picoseconds.
-        Weight::from_parts(203_107_595, 0)
-            // Standard Error: 322_999
-            .saturating_add(Weight::from_parts(280_023_774, 0).saturating_mul(r.into()))
+        // Minimum execution time: 134_444_000 picoseconds.
+        Weight::from_parts(198_654_906, 0)
+            // Standard Error: 409_120
+            .saturating_add(Weight::from_parts(200_669_427, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_create_program(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 99_132_000 picoseconds.
-        Weight::from_parts(166_620_417, 0)
-            // Standard Error: 428_363
-            .saturating_add(Weight::from_parts(469_520_431, 0).saturating_mul(r.into()))
+        // Minimum execution time: 97_737_000 picoseconds.
+        Weight::from_parts(162_389_592, 0)
+            // Standard Error: 437_002
+            .saturating_add(Weight::from_parts(385_229_944, 0).saturating_mul(r.into()))
     }
     /// The range of component `p` is `[0, 2048]`.
     /// The range of component `s` is `[1, 2048]`.
@@ -1083,22 +1085,22 @@ impl<T: frame_system::Config> pallet_gear::WeightInfo for SubstrateWeight<T> {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 46_670_030_000 picoseconds.
-        Weight::from_parts(46_979_707_000, 0)
-            // Standard Error: 290_199
-            .saturating_add(Weight::from_parts(7_295_075, 0).saturating_mul(p.into()))
-            // Standard Error: 290_185
-            .saturating_add(Weight::from_parts(178_049_340, 0).saturating_mul(s.into()))
+        // Minimum execution time: 44_710_614_000 picoseconds.
+        Weight::from_parts(44_848_530_000, 0)
+            // Standard Error: 271_081
+            .saturating_add(Weight::from_parts(7_518_236, 0).saturating_mul(p.into()))
+            // Standard Error: 271_067
+            .saturating_add(Weight::from_parts(176_484_363, 0).saturating_mul(s.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_create_program_wgas(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 95_401_000 picoseconds.
-        Weight::from_parts(162_215_381, 0)
-            // Standard Error: 435_866
-            .saturating_add(Weight::from_parts(479_266_464, 0).saturating_mul(r.into()))
+        // Minimum execution time: 93_935_000 picoseconds.
+        Weight::from_parts(155_283_975, 0)
+            // Standard Error: 398_331
+            .saturating_add(Weight::from_parts(394_750_144, 0).saturating_mul(r.into()))
     }
     /// The range of component `p` is `[0, 2048]`.
     /// The range of component `s` is `[1, 2048]`.
@@ -1106,32 +1108,32 @@ impl<T: frame_system::Config> pallet_gear::WeightInfo for SubstrateWeight<T> {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 44_093_174_000 picoseconds.
-        Weight::from_parts(44_268_099_000, 0)
-            // Standard Error: 249_484
-            .saturating_add(Weight::from_parts(7_595_737, 0).saturating_mul(p.into()))
-            // Standard Error: 249_471
-            .saturating_add(Weight::from_parts(179_055_114, 0).saturating_mul(s.into()))
+        // Minimum execution time: 43_166_105_000 picoseconds.
+        Weight::from_parts(43_210_411_000, 0)
+            // Standard Error: 273_792
+            .saturating_add(Weight::from_parts(7_685_961, 0).saturating_mul(p.into()))
+            // Standard Error: 273_779
+            .saturating_add(Weight::from_parts(177_206_473, 0).saturating_mul(s.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_pay_program_rent(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 84_188_000 picoseconds.
-        Weight::from_parts(101_583_480, 0)
-            // Standard Error: 35_878
-            .saturating_add(Weight::from_parts(3_611_568, 0).saturating_mul(r.into()))
+        // Minimum execution time: 86_385_000 picoseconds.
+        Weight::from_parts(100_368_488, 0)
+            // Standard Error: 25_882
+            .saturating_add(Weight::from_parts(2_517_495, 0).saturating_mul(r.into()))
     }
     /// The range of component `p` is `[0, 512]`.
     fn lazy_pages_signal_read(p: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `141`
         //  Estimated: `1131 + p * (9900 ±0)`
-        // Minimum execution time: 86_183_000 picoseconds.
-        Weight::from_parts(118_618_192, 1131)
-            // Standard Error: 6_832
-            .saturating_add(Weight::from_parts(11_877_671, 0).saturating_mul(p.into()))
+        // Minimum execution time: 86_723_000 picoseconds.
+        Weight::from_parts(112_959_650, 1131)
+            // Standard Error: 5_171
+            .saturating_add(Weight::from_parts(11_884_248, 0).saturating_mul(p.into()))
             .saturating_add(T::DbWeight::get().reads((4_u64).saturating_mul(p.into())))
             .saturating_add(Weight::from_parts(0, 9900).saturating_mul(p.into()))
     }
@@ -1140,10 +1142,10 @@ impl<T: frame_system::Config> pallet_gear::WeightInfo for SubstrateWeight<T> {
         // Proof Size summary in bytes:
         //  Measured:  `141`
         //  Estimated: `1131 + p * (9900 ±0)`
-        // Minimum execution time: 84_629_000 picoseconds.
-        Weight::from_parts(86_416_000, 1131)
-            // Standard Error: 28_253
-            .saturating_add(Weight::from_parts(36_463_142, 0).saturating_mul(p.into()))
+        // Minimum execution time: 85_367_000 picoseconds.
+        Weight::from_parts(86_968_000, 1131)
+            // Standard Error: 35_935
+            .saturating_add(Weight::from_parts(35_294_476, 0).saturating_mul(p.into()))
             .saturating_add(T::DbWeight::get().reads((4_u64).saturating_mul(p.into())))
             .saturating_add(Weight::from_parts(0, 9900).saturating_mul(p.into()))
     }
@@ -1152,10 +1154,10 @@ impl<T: frame_system::Config> pallet_gear::WeightInfo for SubstrateWeight<T> {
         // Proof Size summary in bytes:
         //  Measured:  `141`
         //  Estimated: `5069931`
-        // Minimum execution time: 6_148_282_000 picoseconds.
-        Weight::from_parts(5_977_321_351, 5069931)
-            // Standard Error: 52_501
-            .saturating_add(Weight::from_parts(36_684_019, 0).saturating_mul(p.into()))
+        // Minimum execution time: 6_166_740_000 picoseconds.
+        Weight::from_parts(5_878_966_706, 5069931)
+            // Standard Error: 72_748
+            .saturating_add(Weight::from_parts(35_598_278, 0).saturating_mul(p.into()))
             .saturating_add(T::DbWeight::get().reads(2048_u64))
     }
     /// The range of component `p` is `[0, 512]`.
@@ -1163,10 +1165,10 @@ impl<T: frame_system::Config> pallet_gear::WeightInfo for SubstrateWeight<T> {
         // Proof Size summary in bytes:
         //  Measured:  `1813 + p * (65580 ±0)`
         //  Estimated: `1939 + p * (75482 ±0)`
-        // Minimum execution time: 85_557_000 picoseconds.
-        Weight::from_parts(86_547_000, 1939)
-            // Standard Error: 32_777
-            .saturating_add(Weight::from_parts(46_224_064, 0).saturating_mul(p.into()))
+        // Minimum execution time: 84_509_000 picoseconds.
+        Weight::from_parts(86_396_000, 1939)
+            // Standard Error: 37_909
+            .saturating_add(Weight::from_parts(46_229_201, 0).saturating_mul(p.into()))
             .saturating_add(T::DbWeight::get().reads((4_u64).saturating_mul(p.into())))
             .saturating_add(Weight::from_parts(0, 75482).saturating_mul(p.into()))
     }
@@ -1175,10 +1177,10 @@ impl<T: frame_system::Config> pallet_gear::WeightInfo for SubstrateWeight<T> {
         // Proof Size summary in bytes:
         //  Measured:  `141`
         //  Estimated: `1131 + p * (9900 ±0)`
-        // Minimum execution time: 89_966_000 picoseconds.
-        Weight::from_parts(89_543_596, 1131)
-            // Standard Error: 68_448
-            .saturating_add(Weight::from_parts(36_359_585, 0).saturating_mul(p.into()))
+        // Minimum execution time: 89_570_000 picoseconds.
+        Weight::from_parts(91_679_907, 1131)
+            // Standard Error: 74_102
+            .saturating_add(Weight::from_parts(36_034_356, 0).saturating_mul(p.into()))
             .saturating_add(T::DbWeight::get().reads((4_u64).saturating_mul(p.into())))
             .saturating_add(Weight::from_parts(0, 9900).saturating_mul(p.into()))
     }
@@ -1187,10 +1189,10 @@ impl<T: frame_system::Config> pallet_gear::WeightInfo for SubstrateWeight<T> {
         // Proof Size summary in bytes:
         //  Measured:  `141`
         //  Estimated: `1496 + p * (9883 ±2)`
-        // Minimum execution time: 600_329_000 picoseconds.
-        Weight::from_parts(623_878_315, 1496)
-            // Standard Error: 267_055
-            .saturating_add(Weight::from_parts(46_147_238, 0).saturating_mul(p.into()))
+        // Minimum execution time: 581_516_000 picoseconds.
+        Weight::from_parts(574_828_964, 1496)
+            // Standard Error: 226_535
+            .saturating_add(Weight::from_parts(44_029_625, 0).saturating_mul(p.into()))
             .saturating_add(T::DbWeight::get().reads((4_u64).saturating_mul(p.into())))
             .saturating_add(Weight::from_parts(0, 9883).saturating_mul(p.into()))
     }
@@ -1199,10 +1201,10 @@ impl<T: frame_system::Config> pallet_gear::WeightInfo for SubstrateWeight<T> {
         // Proof Size summary in bytes:
         //  Measured:  `141`
         //  Estimated: `317931`
-        // Minimum execution time: 1_023_023_000 picoseconds.
-        Weight::from_parts(1_022_993_537, 317931)
-            // Standard Error: 203_791
-            .saturating_add(Weight::from_parts(43_538_291, 0).saturating_mul(p.into()))
+        // Minimum execution time: 984_554_000 picoseconds.
+        Weight::from_parts(1_010_300_775, 317931)
+            // Standard Error: 330_750
+            .saturating_add(Weight::from_parts(45_768_209, 0).saturating_mul(p.into()))
             .saturating_add(T::DbWeight::get().reads(128_u64))
     }
     /// The range of component `r` is `[0, 20]`.
@@ -1210,885 +1212,883 @@ impl<T: frame_system::Config> pallet_gear::WeightInfo for SubstrateWeight<T> {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_300_000 picoseconds.
-        Weight::from_parts(2_436_506, 0)
-            // Standard Error: 16_946
-            .saturating_add(Weight::from_parts(24_493_632, 0).saturating_mul(r.into()))
+        // Minimum execution time: 4_399_000 picoseconds.
+        Weight::from_parts(2_513_898, 0)
+            // Standard Error: 22_468
+            .saturating_add(Weight::from_parts(24_974_238, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[50, 500]`.
     fn instr_i64load(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 4_347_874_000 picoseconds.
-        Weight::from_parts(4_179_322_071, 0)
-            // Standard Error: 53_086
-            .saturating_add(Weight::from_parts(4_505_224, 0).saturating_mul(r.into()))
+        // Minimum execution time: 4_354_805_000 picoseconds.
+        Weight::from_parts(4_247_725_842, 0)
+            // Standard Error: 49_167
+            .saturating_add(Weight::from_parts(4_375_644, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[50, 500]`.
     fn instr_i32load(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 4_348_187_000 picoseconds.
-        Weight::from_parts(4_205_195_765, 0)
-            // Standard Error: 44_017
-            .saturating_add(Weight::from_parts(4_404_586, 0).saturating_mul(r.into()))
+        // Minimum execution time: 4_344_769_000 picoseconds.
+        Weight::from_parts(4_143_583_164, 0)
+            // Standard Error: 64_865
+            .saturating_add(Weight::from_parts(4_885_201, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[50, 500]`.
     fn instr_i64store(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 10_882_662_000 picoseconds.
-        Weight::from_parts(11_083_501_979, 0)
-            // Standard Error: 200_162
-            .saturating_add(Weight::from_parts(13_165_815, 0).saturating_mul(r.into()))
+        // Minimum execution time: 10_321_597_000 picoseconds.
+        Weight::from_parts(10_856_474_625, 0)
+            // Standard Error: 228_480
+            .saturating_add(Weight::from_parts(13_648_467, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[50, 500]`.
     fn instr_i32store(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 10_784_867_000 picoseconds.
-        Weight::from_parts(11_957_102_430, 0)
-            // Standard Error: 187_347
-            .saturating_add(Weight::from_parts(8_480_335, 0).saturating_mul(r.into()))
+        // Minimum execution time: 10_444_861_000 picoseconds.
+        Weight::from_parts(11_811_924_847, 0)
+            // Standard Error: 220_732
+            .saturating_add(Weight::from_parts(8_104_347, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_select(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_343_000 picoseconds.
-        Weight::from_parts(2_421_000, 0)
-            // Standard Error: 9_011
-            .saturating_add(Weight::from_parts(3_834_828, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_102_000 picoseconds.
+        Weight::from_parts(2_199_000, 0)
+            // Standard Error: 8_145
+            .saturating_add(Weight::from_parts(3_817_860, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_if(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_326_000 picoseconds.
-        Weight::from_parts(2_421_000, 0)
-            // Standard Error: 5_612
-            .saturating_add(Weight::from_parts(3_061_076, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_084_000 picoseconds.
+        Weight::from_parts(2_171_000, 0)
+            // Standard Error: 5_734
+            .saturating_add(Weight::from_parts(3_044_285, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_br(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_282_000 picoseconds.
-        Weight::from_parts(3_427_769, 0)
-            // Standard Error: 941
-            .saturating_add(Weight::from_parts(1_568_677, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_074_000 picoseconds.
+        Weight::from_parts(3_341_361, 0)
+            // Standard Error: 1_168
+            .saturating_add(Weight::from_parts(1_569_364, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_br_if(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_284_000 picoseconds.
-        Weight::from_parts(2_392_000, 0)
-            // Standard Error: 8_418
-            .saturating_add(Weight::from_parts(2_921_747, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_189_000 picoseconds.
+        Weight::from_parts(2_253_000, 0)
+            // Standard Error: 7_562
+            .saturating_add(Weight::from_parts(2_914_810, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_br_table(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_263_000 picoseconds.
-        Weight::from_parts(1_354_050, 0)
-            // Standard Error: 14_642
-            .saturating_add(Weight::from_parts(5_182_595, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_131_000 picoseconds.
+        Weight::from_parts(99_037, 0)
+            // Standard Error: 11_949
+            .saturating_add(Weight::from_parts(5_173_684, 0).saturating_mul(r.into()))
     }
     /// The range of component `e` is `[1, 256]`.
     fn instr_br_table_per_entry(e: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 7_011_000 picoseconds.
-        Weight::from_parts(5_823_252, 0)
-            // Standard Error: 2_035
-            .saturating_add(Weight::from_parts(162_988, 0).saturating_mul(e.into()))
+        // Minimum execution time: 6_992_000 picoseconds.
+        Weight::from_parts(6_256_207, 0)
+            // Standard Error: 1_332
+            .saturating_add(Weight::from_parts(161_069, 0).saturating_mul(e.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_call_const(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_405_000 picoseconds.
-        Weight::from_parts(5_172_082, 0)
-            // Standard Error: 7_906
-            .saturating_add(Weight::from_parts(2_576_107, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_106_000 picoseconds.
+        Weight::from_parts(4_233_365, 0)
+            // Standard Error: 7_839
+            .saturating_add(Weight::from_parts(2_631_387, 0).saturating_mul(r.into()))
     }
     fn instr_i64const(r: u32, ) -> Weight {
         Weight::from_parts(0, 0)
-            .saturating_add(Weight::from_parts(2_576_107 -
-            2_413_885, 0).saturating_mul(r.into()))
+            .saturating_add(Weight::from_parts(2_631_387 -
+            2_404_882, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_call(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_315_000 picoseconds.
-        Weight::from_parts(4_417_546, 0)
-            // Standard Error: 12_281
-            .saturating_add(Weight::from_parts(2_413_885, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_192_000 picoseconds.
+        Weight::from_parts(4_830_171, 0)
+            // Standard Error: 12_370
+            .saturating_add(Weight::from_parts(2_404_882, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_call_indirect(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_774_000 picoseconds.
-        Weight::from_parts(19_445_534, 0)
-            // Standard Error: 34_031
-            .saturating_add(Weight::from_parts(9_947_648, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_413_000 picoseconds.
+        Weight::from_parts(16_855_535, 0)
+            // Standard Error: 25_880
+            .saturating_add(Weight::from_parts(10_029_290, 0).saturating_mul(r.into()))
     }
     /// The range of component `p` is `[0, 128]`.
     fn instr_call_indirect_per_param(p: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 12_663_000 picoseconds.
-        Weight::from_parts(2_443_915, 0)
-            // Standard Error: 6_189
-            .saturating_add(Weight::from_parts(1_274_832, 0).saturating_mul(p.into()))
+        // Minimum execution time: 12_145_000 picoseconds.
+        Weight::from_parts(4_520_615, 0)
+            // Standard Error: 6_765
+            .saturating_add(Weight::from_parts(1_202_471, 0).saturating_mul(p.into()))
     }
     /// The range of component `l` is `[0, 1024]`.
-    fn instr_call_per_local(l: u32, ) -> Weight {
+    fn instr_call_per_local(_l: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 5_382_000 picoseconds.
-        Weight::from_parts(5_657_220, 0)
-            // Standard Error: 12
-            .saturating_add(Weight::from_parts(14, 0).saturating_mul(l.into()))
+        // Minimum execution time: 5_133_000 picoseconds.
+        Weight::from_parts(5_476_163, 0)
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_local_get(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_461_000 picoseconds.
-        Weight::from_parts(1_936_508, 0)
-            // Standard Error: 3_019
-            .saturating_add(Weight::from_parts(275_086, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_117_000 picoseconds.
+        Weight::from_parts(1_458_597, 0)
+            // Standard Error: 3_356
+            .saturating_add(Weight::from_parts(265_574, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_local_set(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_305_000 picoseconds.
-        Weight::from_parts(2_394_000, 0)
-            // Standard Error: 4_239
-            .saturating_add(Weight::from_parts(763_775, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_135_000 picoseconds.
+        Weight::from_parts(2_223_000, 0)
+            // Standard Error: 5_214
+            .saturating_add(Weight::from_parts(766_010, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_local_tee(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_367_000 picoseconds.
-        Weight::from_parts(2_411_000, 0)
-            // Standard Error: 5_426
-            .saturating_add(Weight::from_parts(771_295, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_078_000 picoseconds.
+        Weight::from_parts(2_218_000, 0)
+            // Standard Error: 5_801
+            .saturating_add(Weight::from_parts(743_573, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_global_get(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 6_346_000 picoseconds.
-        Weight::from_parts(2_691_888, 0)
-            // Standard Error: 7_020
-            .saturating_add(Weight::from_parts(804_877, 0).saturating_mul(r.into()))
+        // Minimum execution time: 6_226_000 picoseconds.
+        Weight::from_parts(2_093_625, 0)
+            // Standard Error: 7_678
+            .saturating_add(Weight::from_parts(824_956, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_global_set(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 6_476_000 picoseconds.
-        Weight::from_parts(6_582_000, 0)
-            // Standard Error: 8_493
-            .saturating_add(Weight::from_parts(1_358_866, 0).saturating_mul(r.into()))
+        // Minimum execution time: 6_201_000 picoseconds.
+        Weight::from_parts(154_770, 0)
+            // Standard Error: 9_398
+            .saturating_add(Weight::from_parts(1_480_245, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_memory_current(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 4_943_000 picoseconds.
-        Weight::from_parts(1_102_558, 0)
-            // Standard Error: 12_614
-            .saturating_add(Weight::from_parts(7_099_473, 0).saturating_mul(r.into()))
+        // Minimum execution time: 6_989_000 picoseconds.
+        Weight::from_parts(2_628_082, 0)
+            // Standard Error: 12_268
+            .saturating_add(Weight::from_parts(6_921_043, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64clz(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_298_000 picoseconds.
-        Weight::from_parts(2_357_000, 0)
-            // Standard Error: 7_419
-            .saturating_add(Weight::from_parts(3_438_043, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_086_000 picoseconds.
+        Weight::from_parts(2_156_000, 0)
+            // Standard Error: 5_477
+            .saturating_add(Weight::from_parts(3_348_027, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32clz(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_201_000 picoseconds.
-        Weight::from_parts(2_270_000, 0)
-            // Standard Error: 7_089
-            .saturating_add(Weight::from_parts(3_224_674, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_102_000 picoseconds.
+        Weight::from_parts(2_163_000, 0)
+            // Standard Error: 6_833
+            .saturating_add(Weight::from_parts(3_134_916, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64ctz(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_358_000 picoseconds.
-        Weight::from_parts(2_444_000, 0)
-            // Standard Error: 5_880
-            .saturating_add(Weight::from_parts(3_196_577, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_131_000 picoseconds.
+        Weight::from_parts(2_209_000, 0)
+            // Standard Error: 7_612
+            .saturating_add(Weight::from_parts(3_170_404, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32ctz(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_205_000 picoseconds.
-        Weight::from_parts(2_361_000, 0)
-            // Standard Error: 5_007
-            .saturating_add(Weight::from_parts(2_694_074, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_124_000 picoseconds.
+        Weight::from_parts(2_169_000, 0)
+            // Standard Error: 4_823
+            .saturating_add(Weight::from_parts(2_668_874, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64popcnt(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_217_000 picoseconds.
-        Weight::from_parts(2_339_000, 0)
-            // Standard Error: 4_242
-            .saturating_add(Weight::from_parts(562_083, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_159_000 picoseconds.
+        Weight::from_parts(2_240_000, 0)
+            // Standard Error: 3_992
+            .saturating_add(Weight::from_parts(559_604, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32popcnt(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_180_000 picoseconds.
-        Weight::from_parts(1_150_328, 0)
-            // Standard Error: 4_155
-            .saturating_add(Weight::from_parts(430_809, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_127_000 picoseconds.
+        Weight::from_parts(1_178_239, 0)
+            // Standard Error: 3_346
+            .saturating_add(Weight::from_parts(416_704, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64eqz(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_218_000 picoseconds.
-        Weight::from_parts(2_269_000, 0)
-            // Standard Error: 12_863
-            .saturating_add(Weight::from_parts(1_875_276, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_137_000 picoseconds.
+        Weight::from_parts(2_192_000, 0)
+            // Standard Error: 11_707
+            .saturating_add(Weight::from_parts(1_918_501, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32eqz(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_290_000 picoseconds.
-        Weight::from_parts(2_322_000, 0)
-            // Standard Error: 8_333
-            .saturating_add(Weight::from_parts(1_185_939, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_131_000 picoseconds.
+        Weight::from_parts(2_192_000, 0)
+            // Standard Error: 7_593
+            .saturating_add(Weight::from_parts(1_219_931, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32extend8s(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_384_000 picoseconds.
-        Weight::from_parts(1_572_617, 0)
-            // Standard Error: 3_727
-            .saturating_add(Weight::from_parts(382_695, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_124_000 picoseconds.
+        Weight::from_parts(726_401, 0)
+            // Standard Error: 4_086
+            .saturating_add(Weight::from_parts(424_161, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32extend16s(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_236_000 picoseconds.
-        Weight::from_parts(1_495_799, 0)
-            // Standard Error: 4_058
-            .saturating_add(Weight::from_parts(373_636, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_107_000 picoseconds.
+        Weight::from_parts(1_225_918, 0)
+            // Standard Error: 3_748
+            .saturating_add(Weight::from_parts(392_373, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64extend8s(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_341_000 picoseconds.
-        Weight::from_parts(465_059, 0)
-            // Standard Error: 4_917
-            .saturating_add(Weight::from_parts(551_259, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_168_000 picoseconds.
+        Weight::from_parts(11_174, 0)
+            // Standard Error: 5_816
+            .saturating_add(Weight::from_parts(594_467, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64extend16s(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_230_000 picoseconds.
-        Weight::from_parts(515_890, 0)
-            // Standard Error: 4_848
-            .saturating_add(Weight::from_parts(545_542, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_138_000 picoseconds.
+        Weight::from_parts(12_680, 0)
+            // Standard Error: 5_830
+            .saturating_add(Weight::from_parts(595_552, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64extend32s(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_272_000 picoseconds.
-        Weight::from_parts(739_709, 0)
-            // Standard Error: 4_827
-            .saturating_add(Weight::from_parts(496_885, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_163_000 picoseconds.
+        Weight::from_parts(172_344, 0)
+            // Standard Error: 5_372
+            .saturating_add(Weight::from_parts(537_510, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64extendsi32(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_322_000 picoseconds.
-        Weight::from_parts(1_492_190, 0)
-            // Standard Error: 3_923
-            .saturating_add(Weight::from_parts(340_665, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_171_000 picoseconds.
+        Weight::from_parts(459_682, 0)
+            // Standard Error: 5_533
+            .saturating_add(Weight::from_parts(421_155, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64extendui32(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_257_000 picoseconds.
-        Weight::from_parts(2_979_817, 0)
-            // Standard Error: 1_972
-            .saturating_add(Weight::from_parts(154_315, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_157_000 picoseconds.
+        Weight::from_parts(2_640_857, 0)
+            // Standard Error: 2_132
+            .saturating_add(Weight::from_parts(175_772, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32wrapi64(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_282_000 picoseconds.
-        Weight::from_parts(2_877_230, 0)
-            // Standard Error: 1_753
-            .saturating_add(Weight::from_parts(153_462, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_149_000 picoseconds.
+        Weight::from_parts(2_625_890, 0)
+            // Standard Error: 2_246
+            .saturating_add(Weight::from_parts(177_728, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64eq(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_193_000 picoseconds.
-        Weight::from_parts(2_289_000, 0)
-            // Standard Error: 11_649
-            .saturating_add(Weight::from_parts(1_795_062, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_082_000 picoseconds.
+        Weight::from_parts(2_193_000, 0)
+            // Standard Error: 9_664
+            .saturating_add(Weight::from_parts(1_832_396, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32eq(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_303_000 picoseconds.
-        Weight::from_parts(2_366_000, 0)
-            // Standard Error: 7_436
-            .saturating_add(Weight::from_parts(1_091_962, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_029_000 picoseconds.
+        Weight::from_parts(2_185_000, 0)
+            // Standard Error: 7_691
+            .saturating_add(Weight::from_parts(1_203_465, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64ne(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_346_000 picoseconds.
-        Weight::from_parts(2_409_000, 0)
-            // Standard Error: 11_197
-            .saturating_add(Weight::from_parts(1_828_518, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_146_000 picoseconds.
+        Weight::from_parts(2_198_000, 0)
+            // Standard Error: 10_390
+            .saturating_add(Weight::from_parts(1_868_795, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32ne(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_328_000 picoseconds.
-        Weight::from_parts(2_384_000, 0)
-            // Standard Error: 7_307
-            .saturating_add(Weight::from_parts(1_106_869, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_082_000 picoseconds.
+        Weight::from_parts(2_133_000, 0)
+            // Standard Error: 8_282
+            .saturating_add(Weight::from_parts(1_199_983, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64lts(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_286_000 picoseconds.
-        Weight::from_parts(2_343_000, 0)
-            // Standard Error: 10_932
-            .saturating_add(Weight::from_parts(1_789_419, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_145_000 picoseconds.
+        Weight::from_parts(2_178_000, 0)
+            // Standard Error: 10_175
+            .saturating_add(Weight::from_parts(1_943_386, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32lts(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_214_000 picoseconds.
-        Weight::from_parts(2_283_000, 0)
-            // Standard Error: 7_556
-            .saturating_add(Weight::from_parts(1_111_326, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_094_000 picoseconds.
+        Weight::from_parts(2_168_000, 0)
+            // Standard Error: 6_923
+            .saturating_add(Weight::from_parts(1_125_091, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64ltu(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_263_000 picoseconds.
-        Weight::from_parts(2_322_000, 0)
-            // Standard Error: 10_995
-            .saturating_add(Weight::from_parts(1_822_680, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_200_000 picoseconds.
+        Weight::from_parts(2_250_000, 0)
+            // Standard Error: 11_944
+            .saturating_add(Weight::from_parts(1_852_545, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32ltu(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_276_000 picoseconds.
-        Weight::from_parts(2_334_000, 0)
-            // Standard Error: 6_944
-            .saturating_add(Weight::from_parts(1_121_080, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_077_000 picoseconds.
+        Weight::from_parts(2_121_000, 0)
+            // Standard Error: 7_914
+            .saturating_add(Weight::from_parts(1_171_461, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64gts(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_227_000 picoseconds.
-        Weight::from_parts(2_292_000, 0)
-            // Standard Error: 11_873
-            .saturating_add(Weight::from_parts(1_840_273, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_171_000 picoseconds.
+        Weight::from_parts(2_278_000, 0)
+            // Standard Error: 10_701
+            .saturating_add(Weight::from_parts(1_859_283, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32gts(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_265_000 picoseconds.
-        Weight::from_parts(2_409_000, 0)
-            // Standard Error: 7_972
-            .saturating_add(Weight::from_parts(1_134_825, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_167_000 picoseconds.
+        Weight::from_parts(2_209_000, 0)
+            // Standard Error: 7_361
+            .saturating_add(Weight::from_parts(1_182_113, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64gtu(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_269_000 picoseconds.
-        Weight::from_parts(2_355_000, 0)
-            // Standard Error: 11_547
-            .saturating_add(Weight::from_parts(1_813_029, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_202_000 picoseconds.
+        Weight::from_parts(2_239_000, 0)
+            // Standard Error: 12_468
+            .saturating_add(Weight::from_parts(1_847_236, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32gtu(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_273_000 picoseconds.
-        Weight::from_parts(2_349_000, 0)
-            // Standard Error: 6_487
-            .saturating_add(Weight::from_parts(1_091_201, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_072_000 picoseconds.
+        Weight::from_parts(2_164_000, 0)
+            // Standard Error: 8_208
+            .saturating_add(Weight::from_parts(1_117_969, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64les(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_225_000 picoseconds.
-        Weight::from_parts(2_329_000, 0)
-            // Standard Error: 12_018
-            .saturating_add(Weight::from_parts(1_823_755, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_077_000 picoseconds.
+        Weight::from_parts(2_155_000, 0)
+            // Standard Error: 9_963
+            .saturating_add(Weight::from_parts(1_877_035, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32les(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_287_000 picoseconds.
-        Weight::from_parts(2_359_000, 0)
-            // Standard Error: 7_325
-            .saturating_add(Weight::from_parts(1_192_292, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_189_000 picoseconds.
+        Weight::from_parts(2_224_000, 0)
+            // Standard Error: 7_561
+            .saturating_add(Weight::from_parts(1_124_600, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64leu(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_352_000 picoseconds.
-        Weight::from_parts(2_386_000, 0)
-            // Standard Error: 10_009
-            .saturating_add(Weight::from_parts(1_870_539, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_157_000 picoseconds.
+        Weight::from_parts(2_210_000, 0)
+            // Standard Error: 11_998
+            .saturating_add(Weight::from_parts(1_829_852, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32leu(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_315_000 picoseconds.
-        Weight::from_parts(2_382_000, 0)
-            // Standard Error: 7_109
-            .saturating_add(Weight::from_parts(1_122_152, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_098_000 picoseconds.
+        Weight::from_parts(2_189_000, 0)
+            // Standard Error: 8_286
+            .saturating_add(Weight::from_parts(1_189_196, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64ges(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_254_000 picoseconds.
-        Weight::from_parts(2_337_000, 0)
-            // Standard Error: 11_700
-            .saturating_add(Weight::from_parts(1_825_021, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_125_000 picoseconds.
+        Weight::from_parts(2_198_000, 0)
+            // Standard Error: 10_056
+            .saturating_add(Weight::from_parts(1_829_185, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32ges(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_357_000 picoseconds.
-        Weight::from_parts(2_407_000, 0)
-            // Standard Error: 7_769
-            .saturating_add(Weight::from_parts(1_146_472, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_065_000 picoseconds.
+        Weight::from_parts(2_174_000, 0)
+            // Standard Error: 8_171
+            .saturating_add(Weight::from_parts(1_176_701, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64geu(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_196_000 picoseconds.
-        Weight::from_parts(2_292_000, 0)
-            // Standard Error: 9_908
-            .saturating_add(Weight::from_parts(1_845_094, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_141_000 picoseconds.
+        Weight::from_parts(2_220_000, 0)
+            // Standard Error: 9_910
+            .saturating_add(Weight::from_parts(1_871_442, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32geu(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_276_000 picoseconds.
-        Weight::from_parts(2_382_000, 0)
-            // Standard Error: 9_519
-            .saturating_add(Weight::from_parts(1_241_507, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_024_000 picoseconds.
+        Weight::from_parts(2_166_000, 0)
+            // Standard Error: 7_933
+            .saturating_add(Weight::from_parts(1_156_214, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64add(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_256_000 picoseconds.
-        Weight::from_parts(2_323_000, 0)
-            // Standard Error: 7_921
-            .saturating_add(Weight::from_parts(1_330_988, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_068_000 picoseconds.
+        Weight::from_parts(2_169_000, 0)
+            // Standard Error: 7_815
+            .saturating_add(Weight::from_parts(1_353_927, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32add(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_203_000 picoseconds.
-        Weight::from_parts(2_262_000, 0)
-            // Standard Error: 4_732
-            .saturating_add(Weight::from_parts(619_908, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_157_000 picoseconds.
+        Weight::from_parts(2_208_000, 0)
+            // Standard Error: 4_587
+            .saturating_add(Weight::from_parts(635_023, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64sub(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_273_000 picoseconds.
-        Weight::from_parts(2_318_000, 0)
-            // Standard Error: 8_121
-            .saturating_add(Weight::from_parts(1_255_733, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_080_000 picoseconds.
+        Weight::from_parts(2_140_000, 0)
+            // Standard Error: 8_399
+            .saturating_add(Weight::from_parts(1_278_782, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32sub(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_332_000 picoseconds.
-        Weight::from_parts(2_392_000, 0)
-            // Standard Error: 5_698
-            .saturating_add(Weight::from_parts(666_782, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_069_000 picoseconds.
+        Weight::from_parts(2_233_000, 0)
+            // Standard Error: 6_395
+            .saturating_add(Weight::from_parts(682_415, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64mul(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_269_000 picoseconds.
-        Weight::from_parts(2_342_000, 0)
-            // Standard Error: 10_724
-            .saturating_add(Weight::from_parts(1_779_885, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_206_000 picoseconds.
+        Weight::from_parts(2_224_000, 0)
+            // Standard Error: 9_477
+            .saturating_add(Weight::from_parts(1_819_764, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32mul(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_239_000 picoseconds.
-        Weight::from_parts(2_377_000, 0)
-            // Standard Error: 8_303
-            .saturating_add(Weight::from_parts(1_231_579, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_095_000 picoseconds.
+        Weight::from_parts(2_219_000, 0)
+            // Standard Error: 7_615
+            .saturating_add(Weight::from_parts(1_207_931, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64divs(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_247_000 picoseconds.
-        Weight::from_parts(3_881_473, 0)
-            // Standard Error: 22_336
-            .saturating_add(Weight::from_parts(2_602_873, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_108_000 picoseconds.
+        Weight::from_parts(1_363_438, 0)
+            // Standard Error: 18_139
+            .saturating_add(Weight::from_parts(2_743_512, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32divs(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_366_000 picoseconds.
-        Weight::from_parts(971_800, 0)
-            // Standard Error: 9_516
-            .saturating_add(Weight::from_parts(2_473_994, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_197_000 picoseconds.
+        Weight::from_parts(726_043, 0)
+            // Standard Error: 12_539
+            .saturating_add(Weight::from_parts(2_447_643, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64divu(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_333_000 picoseconds.
-        Weight::from_parts(3_150_808, 0)
-            // Standard Error: 24_239
-            .saturating_add(Weight::from_parts(2_853_024, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_118_000 picoseconds.
+        Weight::from_parts(1_113_814, 0)
+            // Standard Error: 15_837
+            .saturating_add(Weight::from_parts(2_939_546, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32divu(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_243_000 picoseconds.
-        Weight::from_parts(1_149_774, 0)
-            // Standard Error: 13_355
-            .saturating_add(Weight::from_parts(2_517_122, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_121_000 picoseconds.
+        Weight::from_parts(2_089_486, 0)
+            // Standard Error: 15_833
+            .saturating_add(Weight::from_parts(2_447_304, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64rems(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_243_000 picoseconds.
-        Weight::from_parts(1_527_824, 0)
-            // Standard Error: 31_972
-            .saturating_add(Weight::from_parts(9_267_865, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_200_000 picoseconds.
+        Weight::from_parts(2_235_000, 0)
+            // Standard Error: 16_089
+            .saturating_add(Weight::from_parts(9_370_736, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32rems(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_323_000 picoseconds.
-        Weight::from_parts(988_781, 0)
-            // Standard Error: 44_193
-            .saturating_add(Weight::from_parts(7_612_584, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_191_000 picoseconds.
+        Weight::from_parts(3_207_641, 0)
+            // Standard Error: 45_758
+            .saturating_add(Weight::from_parts(7_437_894, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64remu(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_294_000 picoseconds.
-        Weight::from_parts(2_334_729, 0)
-            // Standard Error: 15_965
-            .saturating_add(Weight::from_parts(2_951_129, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_118_000 picoseconds.
+        Weight::from_parts(588_160, 0)
+            // Standard Error: 17_384
+            .saturating_add(Weight::from_parts(2_989_240, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32remu(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_243_000 picoseconds.
-        Weight::from_parts(1_116_651, 0)
-            // Standard Error: 17_134
-            .saturating_add(Weight::from_parts(2_528_749, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_135_000 picoseconds.
+        Weight::from_parts(4_961_665, 0)
+            // Standard Error: 26_016
+            .saturating_add(Weight::from_parts(2_253_733, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64and(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_247_000 picoseconds.
-        Weight::from_parts(2_268_000, 0)
-            // Standard Error: 8_575
-            .saturating_add(Weight::from_parts(1_262_352, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_174_000 picoseconds.
+        Weight::from_parts(2_198_000, 0)
+            // Standard Error: 8_661
+            .saturating_add(Weight::from_parts(1_328_375, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32and(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_245_000 picoseconds.
-        Weight::from_parts(2_338_000, 0)
-            // Standard Error: 4_378
-            .saturating_add(Weight::from_parts(623_671, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_168_000 picoseconds.
+        Weight::from_parts(2_225_000, 0)
+            // Standard Error: 4_778
+            .saturating_add(Weight::from_parts(648_611, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64or(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_335_000 picoseconds.
-        Weight::from_parts(2_380_000, 0)
-            // Standard Error: 8_320
-            .saturating_add(Weight::from_parts(1_276_618, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_125_000 picoseconds.
+        Weight::from_parts(2_219_000, 0)
+            // Standard Error: 8_338
+            .saturating_add(Weight::from_parts(1_260_241, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32or(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_330_000 picoseconds.
-        Weight::from_parts(2_374_000, 0)
-            // Standard Error: 4_039
-            .saturating_add(Weight::from_parts(593_652, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_153_000 picoseconds.
+        Weight::from_parts(2_233_000, 0)
+            // Standard Error: 5_007
+            .saturating_add(Weight::from_parts(642_088, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64xor(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_220_000 picoseconds.
-        Weight::from_parts(2_325_000, 0)
-            // Standard Error: 8_112
-            .saturating_add(Weight::from_parts(1_247_970, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_230_000 picoseconds.
+        Weight::from_parts(2_267_000, 0)
+            // Standard Error: 8_196
+            .saturating_add(Weight::from_parts(1_328_828, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32xor(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_280_000 picoseconds.
-        Weight::from_parts(2_353_000, 0)
-            // Standard Error: 4_344
-            .saturating_add(Weight::from_parts(606_457, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_135_000 picoseconds.
+        Weight::from_parts(2_211_000, 0)
+            // Standard Error: 5_376
+            .saturating_add(Weight::from_parts(693_541, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64shl(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_234_000 picoseconds.
-        Weight::from_parts(2_286_000, 0)
-            // Standard Error: 7_296
-            .saturating_add(Weight::from_parts(1_053_977, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_208_000 picoseconds.
+        Weight::from_parts(2_224_000, 0)
+            // Standard Error: 7_393
+            .saturating_add(Weight::from_parts(1_144_418, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32shl(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_342_000 picoseconds.
-        Weight::from_parts(75_359, 0)
-            // Standard Error: 6_197
-            .saturating_add(Weight::from_parts(627_367, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_161_000 picoseconds.
+        Weight::from_parts(2_237_000, 0)
+            // Standard Error: 3_890
+            .saturating_add(Weight::from_parts(589_899, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64shrs(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_281_000 picoseconds.
-        Weight::from_parts(2_367_000, 0)
-            // Standard Error: 6_750
-            .saturating_add(Weight::from_parts(1_078_782, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_129_000 picoseconds.
+        Weight::from_parts(2_219_000, 0)
+            // Standard Error: 7_182
+            .saturating_add(Weight::from_parts(1_101_585, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32shrs(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_221_000 picoseconds.
-        Weight::from_parts(2_312_000, 0)
-            // Standard Error: 4_413
-            .saturating_add(Weight::from_parts(586_782, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_038_000 picoseconds.
+        Weight::from_parts(2_126_000, 0)
+            // Standard Error: 3_865
+            .saturating_add(Weight::from_parts(588_357, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64shru(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_353_000 picoseconds.
-        Weight::from_parts(2_385_000, 0)
-            // Standard Error: 9_421
-            .saturating_add(Weight::from_parts(1_130_965, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_129_000 picoseconds.
+        Weight::from_parts(2_215_000, 0)
+            // Standard Error: 8_265
+            .saturating_add(Weight::from_parts(1_152_496, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32shru(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_344_000 picoseconds.
-        Weight::from_parts(2_438_000, 0)
-            // Standard Error: 5_975
-            .saturating_add(Weight::from_parts(638_969, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_103_000 picoseconds.
+        Weight::from_parts(2_181_000, 0)
+            // Standard Error: 3_989
+            .saturating_add(Weight::from_parts(614_809, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64rotl(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_294_000 picoseconds.
-        Weight::from_parts(2_356_000, 0)
-            // Standard Error: 8_189
-            .saturating_add(Weight::from_parts(1_080_515, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_133_000 picoseconds.
+        Weight::from_parts(2_175_000, 0)
+            // Standard Error: 6_506
+            .saturating_add(Weight::from_parts(1_096_748, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32rotl(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_253_000 picoseconds.
-        Weight::from_parts(2_290_000, 0)
-            // Standard Error: 3_500
-            .saturating_add(Weight::from_parts(556_273, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_088_000 picoseconds.
+        Weight::from_parts(2_154_000, 0)
+            // Standard Error: 4_053
+            .saturating_add(Weight::from_parts(582_323, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64rotr(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_215_000 picoseconds.
-        Weight::from_parts(2_333_000, 0)
-            // Standard Error: 7_954
-            .saturating_add(Weight::from_parts(1_067_773, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_120_000 picoseconds.
+        Weight::from_parts(2_213_000, 0)
+            // Standard Error: 6_472
+            .saturating_add(Weight::from_parts(1_056_569, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32rotr(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_183_000 picoseconds.
-        Weight::from_parts(2_223_000, 0)
-            // Standard Error: 3_658
-            .saturating_add(Weight::from_parts(566_527, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_097_000 picoseconds.
+        Weight::from_parts(2_192_000, 0)
+            // Standard Error: 3_800
+            .saturating_add(Weight::from_parts(579_517, 0).saturating_mul(r.into()))
     }
 }
 
@@ -2113,10 +2113,10 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 1_003_000 picoseconds.
-        Weight::from_parts(1_051_000, 0)
-            // Standard Error: 968
-            .saturating_add(Weight::from_parts(212_482, 0).saturating_mul(c.into()))
+        // Minimum execution time: 1_017_000 picoseconds.
+        Weight::from_parts(1_119_000, 0)
+            // Standard Error: 761
+            .saturating_add(Weight::from_parts(209_074, 0).saturating_mul(c.into()))
             .saturating_add(RocksDbWeight::get().writes(1_u64))
     }
     /// The range of component `c` is `[0, 512]`.
@@ -2124,10 +2124,10 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `113 + c * (1024 ±0)`
         //  Estimated: `3577 + c * (1024 ±0)`
-        // Minimum execution time: 3_267_000 picoseconds.
-        Weight::from_parts(3_316_000, 3577)
-            // Standard Error: 1_072
-            .saturating_add(Weight::from_parts(688_242, 0).saturating_mul(c.into()))
+        // Minimum execution time: 3_299_000 picoseconds.
+        Weight::from_parts(3_409_000, 3577)
+            // Standard Error: 809
+            .saturating_add(Weight::from_parts(667_635, 0).saturating_mul(c.into()))
             .saturating_add(RocksDbWeight::get().reads(1_u64))
             .saturating_add(Weight::from_parts(0, 1024).saturating_mul(c.into()))
     }
@@ -2136,17 +2136,17 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 53_248_000 picoseconds.
-        Weight::from_parts(71_345_881, 0)
-            // Standard Error: 10_707
-            .saturating_add(Weight::from_parts(2_548_249, 0).saturating_mul(c.into()))
+        // Minimum execution time: 50_278_000 picoseconds.
+        Weight::from_parts(73_427_731, 0)
+            // Standard Error: 6_473
+            .saturating_add(Weight::from_parts(2_331_768, 0).saturating_mul(c.into()))
     }
     fn claim_value() -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `1050`
         //  Estimated: `42875`
-        // Minimum execution time: 84_992_000 picoseconds.
-        Weight::from_parts(88_176_000, 42875)
+        // Minimum execution time: 81_857_000 picoseconds.
+        Weight::from_parts(83_494_000, 42875)
             .saturating_add(RocksDbWeight::get().reads(13_u64))
             .saturating_add(RocksDbWeight::get().writes(10_u64))
     }
@@ -2154,8 +2154,8 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `958`
         //  Estimated: `21477`
-        // Minimum execution time: 56_951_000 picoseconds.
-        Weight::from_parts(58_755_000, 21477)
+        // Minimum execution time: 53_880_000 picoseconds.
+        Weight::from_parts(55_703_000, 21477)
             .saturating_add(RocksDbWeight::get().reads(7_u64))
             .saturating_add(RocksDbWeight::get().writes(6_u64))
     }
@@ -2163,8 +2163,8 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `605`
         //  Estimated: `17354`
-        // Minimum execution time: 30_483_000 picoseconds.
-        Weight::from_parts(31_174_000, 17354)
+        // Minimum execution time: 28_976_000 picoseconds.
+        Weight::from_parts(30_055_000, 17354)
             .saturating_add(RocksDbWeight::get().reads(6_u64))
             .saturating_add(RocksDbWeight::get().writes(4_u64))
     }
@@ -2173,10 +2173,10 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `355`
         //  Estimated: `7640`
-        // Minimum execution time: 8_269_000 picoseconds.
-        Weight::from_parts(7_343_300, 7640)
-            // Standard Error: 45_015
-            .saturating_add(Weight::from_parts(15_758_869, 0).saturating_mul(c.into()))
+        // Minimum execution time: 7_954_000 picoseconds.
+        Weight::from_parts(9_206_629, 7640)
+            // Standard Error: 40_915
+            .saturating_add(Weight::from_parts(13_218_946, 0).saturating_mul(c.into()))
             .saturating_add(RocksDbWeight::get().reads(2_u64))
             .saturating_add(RocksDbWeight::get().writes(2_u64))
     }
@@ -2185,10 +2185,10 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `1439 + c * (16389 ±0)`
         //  Estimated: `42034 + c * (131112 ±0)`
-        // Minimum execution time: 70_643_000 picoseconds.
-        Weight::from_parts(71_487_000, 42034)
-            // Standard Error: 217_960
-            .saturating_add(Weight::from_parts(56_304_860, 0).saturating_mul(c.into()))
+        // Minimum execution time: 69_036_000 picoseconds.
+        Weight::from_parts(70_072_000, 42034)
+            // Standard Error: 149_794
+            .saturating_add(Weight::from_parts(52_674_750, 0).saturating_mul(c.into()))
             .saturating_add(RocksDbWeight::get().reads(11_u64))
             .saturating_add(RocksDbWeight::get().writes(9_u64))
             .saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(c.into())))
@@ -2199,10 +2199,10 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `80`
         //  Estimated: `5270`
-        // Minimum execution time: 63_871_000 picoseconds.
-        Weight::from_parts(31_431_372, 5270)
-            // Standard Error: 58_224
-            .saturating_add(Weight::from_parts(52_560_364, 0).saturating_mul(c.into()))
+        // Minimum execution time: 61_042_000 picoseconds.
+        Weight::from_parts(42_647_149, 5270)
+            // Standard Error: 41_151
+            .saturating_add(Weight::from_parts(51_906_843, 0).saturating_mul(c.into()))
             .saturating_add(RocksDbWeight::get().reads(2_u64))
             .saturating_add(RocksDbWeight::get().writes(4_u64))
     }
@@ -2211,10 +2211,10 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `742`
         //  Estimated: `39419`
-        // Minimum execution time: 65_988_000 picoseconds.
-        Weight::from_parts(102_441_114, 39419)
-            // Standard Error: 1
-            .saturating_add(Weight::from_parts(2_612, 0).saturating_mul(s.into()))
+        // Minimum execution time: 62_956_000 picoseconds.
+        Weight::from_parts(74_593_794, 39419)
+            // Standard Error: 0
+            .saturating_add(Weight::from_parts(2_594, 0).saturating_mul(s.into()))
             .saturating_add(RocksDbWeight::get().reads(13_u64))
             .saturating_add(RocksDbWeight::get().writes(10_u64))
     }
@@ -2224,12 +2224,12 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `306`
         //  Estimated: `35235`
-        // Minimum execution time: 11_021_135_000 picoseconds.
-        Weight::from_parts(397_699_856, 35235)
-            // Standard Error: 169_994
-            .saturating_add(Weight::from_parts(52_665_060, 0).saturating_mul(c.into()))
-            // Standard Error: 10
-            .saturating_add(Weight::from_parts(2_533, 0).saturating_mul(s.into()))
+        // Minimum execution time: 10_939_548_000 picoseconds.
+        Weight::from_parts(505_483_291, 35235)
+            // Standard Error: 158_935
+            .saturating_add(Weight::from_parts(51_999_053, 0).saturating_mul(c.into()))
+            // Standard Error: 9
+            .saturating_add(Weight::from_parts(2_500, 0).saturating_mul(s.into()))
             .saturating_add(RocksDbWeight::get().reads(13_u64))
             .saturating_add(RocksDbWeight::get().writes(14_u64))
     }
@@ -2238,10 +2238,10 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `349`
         //  Estimated: `23860`
-        // Minimum execution time: 57_013_000 picoseconds.
-        Weight::from_parts(35_413_717, 23860)
-            // Standard Error: 1
-            .saturating_add(Weight::from_parts(1_158, 0).saturating_mul(p.into()))
+        // Minimum execution time: 54_714_000 picoseconds.
+        Weight::from_parts(39_682_905, 23860)
+            // Standard Error: 0
+            .saturating_add(Weight::from_parts(1_012, 0).saturating_mul(p.into()))
             .saturating_add(RocksDbWeight::get().reads(9_u64))
             .saturating_add(RocksDbWeight::get().writes(8_u64))
     }
@@ -2250,10 +2250,10 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `452`
         //  Estimated: `27184`
-        // Minimum execution time: 60_180_000 picoseconds.
-        Weight::from_parts(33_390_466, 27184)
-            // Standard Error: 2
-            .saturating_add(Weight::from_parts(1_167, 0).saturating_mul(p.into()))
+        // Minimum execution time: 56_333_000 picoseconds.
+        Weight::from_parts(38_749_450, 27184)
+            // Standard Error: 1
+            .saturating_add(Weight::from_parts(1_023, 0).saturating_mul(p.into()))
             .saturating_add(RocksDbWeight::get().reads(10_u64))
             .saturating_add(RocksDbWeight::get().writes(9_u64))
     }
@@ -2262,10 +2262,10 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `1049`
         //  Estimated: `42866`
-        // Minimum execution time: 87_446_000 picoseconds.
-        Weight::from_parts(69_330_706, 42866)
-            // Standard Error: 2
-            .saturating_add(Weight::from_parts(1_174, 0).saturating_mul(p.into()))
+        // Minimum execution time: 82_073_000 picoseconds.
+        Weight::from_parts(66_860_069, 42866)
+            // Standard Error: 1
+            .saturating_add(Weight::from_parts(1_035, 0).saturating_mul(p.into()))
             .saturating_add(RocksDbWeight::get().reads(13_u64))
             .saturating_add(RocksDbWeight::get().writes(10_u64))
     }
@@ -2274,20 +2274,22 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `1152`
         //  Estimated: `46396`
-        // Minimum execution time: 97_152_000 picoseconds.
-        Weight::from_parts(77_891_346, 46396)
-            // Standard Error: 2
-            .saturating_add(Weight::from_parts(1_170, 0).saturating_mul(p.into()))
+        // Minimum execution time: 92_361_000 picoseconds.
+        Weight::from_parts(69_850_521, 46396)
+            // Standard Error: 1
+            .saturating_add(Weight::from_parts(1_052, 0).saturating_mul(p.into()))
             .saturating_add(RocksDbWeight::get().reads(14_u64))
             .saturating_add(RocksDbWeight::get().writes(11_u64))
     }
     /// The range of component `q` is `[1, 512]`.
-    fn initial_allocation(_q: u32, ) -> Weight {
+    fn initial_allocation(q: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `1066`
         //  Estimated: `85981`
-        // Minimum execution time: 323_882_000 picoseconds.
-        Weight::from_parts(336_539_045, 85981)
+        // Minimum execution time: 316_122_000 picoseconds.
+        Weight::from_parts(330_387_653, 85981)
+            // Standard Error: 1_030
+            .saturating_add(Weight::from_parts(2_167, 0).saturating_mul(q.into()))
             .saturating_add(RocksDbWeight::get().reads(29_u64))
             .saturating_add(RocksDbWeight::get().writes(23_u64))
     }
@@ -2296,8 +2298,8 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `1066`
         //  Estimated: `85905`
-        // Minimum execution time: 336_406_000 picoseconds.
-        Weight::from_parts(353_807_338, 85905)
+        // Minimum execution time: 327_296_000 picoseconds.
+        Weight::from_parts(344_778_587, 85905)
             .saturating_add(RocksDbWeight::get().reads(29_u64))
             .saturating_add(RocksDbWeight::get().writes(23_u64))
     }
@@ -2306,10 +2308,10 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `211 + c * (1075 ±0)`
         //  Estimated: `3899 + c * (2150 ±0)`
-        // Minimum execution time: 45_464_000 picoseconds.
-        Weight::from_parts(45_831_000, 3899)
-            // Standard Error: 36_617
-            .saturating_add(Weight::from_parts(51_273_892, 0).saturating_mul(c.into()))
+        // Minimum execution time: 45_031_000 picoseconds.
+        Weight::from_parts(45_572_000, 3899)
+            // Standard Error: 24_669
+            .saturating_add(Weight::from_parts(50_090_777, 0).saturating_mul(c.into()))
             .saturating_add(RocksDbWeight::get().reads(1_u64))
             .saturating_add(RocksDbWeight::get().writes(2_u64))
             .saturating_add(Weight::from_parts(0, 2150).saturating_mul(c.into()))
@@ -2319,630 +2321,630 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 84_254_000 picoseconds.
-        Weight::from_parts(86_749_000, 0)
-            // Standard Error: 3_967_638
-            .saturating_add(Weight::from_parts(617_894_062, 0).saturating_mul(r.into()))
+        // Minimum execution time: 83_663_000 picoseconds.
+        Weight::from_parts(84_983_000, 0)
+            // Standard Error: 4_066_232
+            .saturating_add(Weight::from_parts(564_447_416, 0).saturating_mul(r.into()))
     }
     /// The range of component `p` is `[1, 512]`.
     fn alloc_per_page(p: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 366_392_000 picoseconds.
-        Weight::from_parts(294_624_660, 0)
-            // Standard Error: 10_067
-            .saturating_add(Weight::from_parts(30_802_641, 0).saturating_mul(p.into()))
+        // Minimum execution time: 311_448_000 picoseconds.
+        Weight::from_parts(245_631_815, 0)
+            // Standard Error: 7_937
+            .saturating_add(Weight::from_parts(30_896_737, 0).saturating_mul(p.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn free(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 199_070_000 picoseconds.
-        Weight::from_parts(213_938_845, 0)
-            // Standard Error: 343_895
-            .saturating_add(Weight::from_parts(120_152_478, 0).saturating_mul(r.into()))
+        // Minimum execution time: 149_067_000 picoseconds.
+        Weight::from_parts(130_181_921, 0)
+            // Standard Error: 294_281
+            .saturating_add(Weight::from_parts(60_998_326, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 256]`.
     fn gr_reserve_gas(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 85_714_000 picoseconds.
-        Weight::from_parts(96_261_609, 0)
-            // Standard Error: 3_991
-            .saturating_add(Weight::from_parts(3_567_375, 0).saturating_mul(r.into()))
+        // Minimum execution time: 87_222_000 picoseconds.
+        Weight::from_parts(94_195_714, 0)
+            // Standard Error: 3_616
+            .saturating_add(Weight::from_parts(2_672_494, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 256]`.
     fn gr_unreserve_gas(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 139_882_000 picoseconds.
-        Weight::from_parts(221_553_985, 0)
-            // Standard Error: 29_743
-            .saturating_add(Weight::from_parts(3_602_987, 0).saturating_mul(r.into()))
+        // Minimum execution time: 139_429_000 picoseconds.
+        Weight::from_parts(171_049_360, 0)
+            // Standard Error: 31_588
+            .saturating_add(Weight::from_parts(2_923_269, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_system_reserve_gas(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 87_497_000 picoseconds.
-        Weight::from_parts(118_603_695, 0)
-            // Standard Error: 431_810
-            .saturating_add(Weight::from_parts(177_456_338, 0).saturating_mul(r.into()))
+        // Minimum execution time: 86_992_000 picoseconds.
+        Weight::from_parts(115_936_976, 0)
+            // Standard Error: 414_340
+            .saturating_add(Weight::from_parts(116_785_346, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_message_id(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 88_831_000 picoseconds.
-        Weight::from_parts(88_005_607, 0)
-            // Standard Error: 244_708
-            .saturating_add(Weight::from_parts(175_744_834, 0).saturating_mul(r.into()))
+        // Minimum execution time: 87_790_000 picoseconds.
+        Weight::from_parts(90_746_200, 0)
+            // Standard Error: 270_835
+            .saturating_add(Weight::from_parts(107_416_174, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_program_id(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 84_145_000 picoseconds.
-        Weight::from_parts(86_969_872, 0)
-            // Standard Error: 302_008
-            .saturating_add(Weight::from_parts(180_744_297, 0).saturating_mul(r.into()))
+        // Minimum execution time: 84_210_000 picoseconds.
+        Weight::from_parts(91_082_335, 0)
+            // Standard Error: 211_867
+            .saturating_add(Weight::from_parts(104_318_383, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_source(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 84_337_000 picoseconds.
-        Weight::from_parts(80_268_581, 0)
-            // Standard Error: 290_578
-            .saturating_add(Weight::from_parts(180_541_423, 0).saturating_mul(r.into()))
+        // Minimum execution time: 84_806_000 picoseconds.
+        Weight::from_parts(85_438_969, 0)
+            // Standard Error: 248_652
+            .saturating_add(Weight::from_parts(105_330_427, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_value(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 85_327_000 picoseconds.
-        Weight::from_parts(84_307_332, 0)
-            // Standard Error: 316_639
-            .saturating_add(Weight::from_parts(179_561_839, 0).saturating_mul(r.into()))
+        // Minimum execution time: 84_654_000 picoseconds.
+        Weight::from_parts(82_257_210, 0)
+            // Standard Error: 336_548
+            .saturating_add(Weight::from_parts(106_454_200, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_value_available(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 85_300_000 picoseconds.
-        Weight::from_parts(70_645_226, 0)
-            // Standard Error: 320_673
-            .saturating_add(Weight::from_parts(182_342_085, 0).saturating_mul(r.into()))
+        // Minimum execution time: 84_452_000 picoseconds.
+        Weight::from_parts(82_661_045, 0)
+            // Standard Error: 286_452
+            .saturating_add(Weight::from_parts(105_467_642, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_gas_available(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 86_250_000 picoseconds.
-        Weight::from_parts(81_902_510, 0)
-            // Standard Error: 273_253
-            .saturating_add(Weight::from_parts(180_582_426, 0).saturating_mul(r.into()))
+        // Minimum execution time: 84_893_000 picoseconds.
+        Weight::from_parts(81_216_834, 0)
+            // Standard Error: 315_266
+            .saturating_add(Weight::from_parts(107_016_702, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_size(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 84_232_000 picoseconds.
-        Weight::from_parts(87_259_581, 0)
-            // Standard Error: 294_035
-            .saturating_add(Weight::from_parts(175_294_464, 0).saturating_mul(r.into()))
+        // Minimum execution time: 85_282_000 picoseconds.
+        Weight::from_parts(82_548_887, 0)
+            // Standard Error: 341_172
+            .saturating_add(Weight::from_parts(105_504_622, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_read(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 595_636_000 picoseconds.
-        Weight::from_parts(656_136_663, 0)
-            // Standard Error: 485_302
-            .saturating_add(Weight::from_parts(261_855_478, 0).saturating_mul(r.into()))
+        // Minimum execution time: 556_352_000 picoseconds.
+        Weight::from_parts(607_493_748, 0)
+            // Standard Error: 448_674
+            .saturating_add(Weight::from_parts(184_670_390, 0).saturating_mul(r.into()))
     }
     /// The range of component `n` is `[0, 2048]`.
     fn gr_read_per_kb(n: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 850_360_000 picoseconds.
-        Weight::from_parts(903_367_000, 0)
-            // Standard Error: 55_203
-            .saturating_add(Weight::from_parts(13_094_816, 0).saturating_mul(n.into()))
+        // Minimum execution time: 714_496_000 picoseconds.
+        Weight::from_parts(722_520_000, 0)
+            // Standard Error: 46_538
+            .saturating_add(Weight::from_parts(13_033_234, 0).saturating_mul(n.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_block_height(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 87_957_000 picoseconds.
-        Weight::from_parts(87_586_547, 0)
-            // Standard Error: 323_063
-            .saturating_add(Weight::from_parts(174_117_671, 0).saturating_mul(r.into()))
+        // Minimum execution time: 85_627_000 picoseconds.
+        Weight::from_parts(85_563_243, 0)
+            // Standard Error: 311_752
+            .saturating_add(Weight::from_parts(105_877_332, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_block_timestamp(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 87_008_000 picoseconds.
-        Weight::from_parts(78_303_076, 0)
-            // Standard Error: 299_495
-            .saturating_add(Weight::from_parts(175_222_715, 0).saturating_mul(r.into()))
+        // Minimum execution time: 86_852_000 picoseconds.
+        Weight::from_parts(84_860_381, 0)
+            // Standard Error: 321_988
+            .saturating_add(Weight::from_parts(105_008_310, 0).saturating_mul(r.into()))
     }
     /// The range of component `n` is `[0, 20]`.
     fn gr_random(n: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 84_234_000 picoseconds.
-        Weight::from_parts(103_801_859, 0)
-            // Standard Error: 382_198
-            .saturating_add(Weight::from_parts(245_171_881, 0).saturating_mul(n.into()))
+        // Minimum execution time: 84_396_000 picoseconds.
+        Weight::from_parts(89_972_413, 0)
+            // Standard Error: 338_324
+            .saturating_add(Weight::from_parts(184_316_536, 0).saturating_mul(n.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_reply_deposit(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 85_211_000 picoseconds.
-        Weight::from_parts(87_766_000, 0)
-            // Standard Error: 4_237_435
-            .saturating_add(Weight::from_parts(1_076_031_771, 0).saturating_mul(r.into()))
+        // Minimum execution time: 89_385_000 picoseconds.
+        Weight::from_parts(90_760_000, 0)
+            // Standard Error: 4_378_367
+            .saturating_add(Weight::from_parts(914_427_461, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_send(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 84_722_000 picoseconds.
-        Weight::from_parts(144_011_827, 0)
-            // Standard Error: 476_324
-            .saturating_add(Weight::from_parts(387_231_993, 0).saturating_mul(r.into()))
+        // Minimum execution time: 86_060_000 picoseconds.
+        Weight::from_parts(138_647_807, 0)
+            // Standard Error: 449_220
+            .saturating_add(Weight::from_parts(301_188_566, 0).saturating_mul(r.into()))
     }
     /// The range of component `n` is `[0, 2048]`.
     fn gr_send_per_kb(n: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 461_434_000 picoseconds.
-        Weight::from_parts(469_780_000, 0)
-            // Standard Error: 61_125
-            .saturating_add(Weight::from_parts(21_613_603, 0).saturating_mul(n.into()))
+        // Minimum execution time: 391_797_000 picoseconds.
+        Weight::from_parts(394_943_000, 0)
+            // Standard Error: 58_663
+            .saturating_add(Weight::from_parts(21_187_774, 0).saturating_mul(n.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_send_wgas(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 88_818_000 picoseconds.
-        Weight::from_parts(149_809_757, 0)
-            // Standard Error: 456_443
-            .saturating_add(Weight::from_parts(395_488_333, 0).saturating_mul(r.into()))
+        // Minimum execution time: 85_418_000 picoseconds.
+        Weight::from_parts(149_848_797, 0)
+            // Standard Error: 459_492
+            .saturating_add(Weight::from_parts(308_230_219, 0).saturating_mul(r.into()))
     }
     /// The range of component `n` is `[0, 2048]`.
     fn gr_send_wgas_per_kb(n: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 479_154_000 picoseconds.
-        Weight::from_parts(483_278_000, 0)
-            // Standard Error: 67_159
-            .saturating_add(Weight::from_parts(21_947_194, 0).saturating_mul(n.into()))
+        // Minimum execution time: 390_635_000 picoseconds.
+        Weight::from_parts(395_782_000, 0)
+            // Standard Error: 61_326
+            .saturating_add(Weight::from_parts(20_818_419, 0).saturating_mul(n.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_send_input(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 567_500_000 picoseconds.
-        Weight::from_parts(693_644_323, 0)
-            // Standard Error: 568_410
-            .saturating_add(Weight::from_parts(412_109_027, 0).saturating_mul(r.into()))
+        // Minimum execution time: 561_280_000 picoseconds.
+        Weight::from_parts(634_390_717, 0)
+            // Standard Error: 473_236
+            .saturating_add(Weight::from_parts(316_661_157, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_send_input_wgas(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 575_808_000 picoseconds.
-        Weight::from_parts(724_736_213, 0)
-            // Standard Error: 602_935
-            .saturating_add(Weight::from_parts(412_885_093, 0).saturating_mul(r.into()))
+        // Minimum execution time: 559_804_000 picoseconds.
+        Weight::from_parts(650_695_494, 0)
+            // Standard Error: 489_218
+            .saturating_add(Weight::from_parts(321_789_584, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_send_init(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 85_691_000 picoseconds.
-        Weight::from_parts(74_497_929, 0)
-            // Standard Error: 328_672
-            .saturating_add(Weight::from_parts(197_295_056, 0).saturating_mul(r.into()))
+        // Minimum execution time: 86_345_000 picoseconds.
+        Weight::from_parts(74_080_057, 0)
+            // Standard Error: 328_119
+            .saturating_add(Weight::from_parts(116_742_827, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_send_push(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 3_899_275_000 picoseconds.
-        Weight::from_parts(4_052_914_766, 0)
-            // Standard Error: 433_071
-            .saturating_add(Weight::from_parts(279_414_467, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_307_192_000 picoseconds.
+        Weight::from_parts(2_419_334_440, 0)
+            // Standard Error: 484_032
+            .saturating_add(Weight::from_parts(211_293_866, 0).saturating_mul(r.into()))
     }
     /// The range of component `n` is `[0, 2048]`.
     fn gr_send_push_per_kb(n: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 481_093_000 picoseconds.
-        Weight::from_parts(489_651_000, 0)
-            // Standard Error: 58_131
-            .saturating_add(Weight::from_parts(29_725_779, 0).saturating_mul(n.into()))
+        // Minimum execution time: 346_160_000 picoseconds.
+        Weight::from_parts(348_777_000, 0)
+            // Standard Error: 58_661
+            .saturating_add(Weight::from_parts(29_434_095, 0).saturating_mul(n.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_send_commit(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 3_898_930_000 picoseconds.
-        Weight::from_parts(4_051_051_643, 0)
-            // Standard Error: 422_685
-            .saturating_add(Weight::from_parts(335_909_883, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_292_607_000 picoseconds.
+        Weight::from_parts(2_434_102_108, 0)
+            // Standard Error: 502_502
+            .saturating_add(Weight::from_parts(264_859_383, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_send_commit_wgas(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 3_889_863_000 picoseconds.
-        Weight::from_parts(4_037_859_582, 0)
-            // Standard Error: 492_684
-            .saturating_add(Weight::from_parts(354_039_027, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_289_426_000 picoseconds.
+        Weight::from_parts(2_437_443_919, 0)
+            // Standard Error: 471_320
+            .saturating_add(Weight::from_parts(268_510_540, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_reservation_send(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 254_292_000 picoseconds.
-        Weight::from_parts(299_243_857, 0)
-            // Standard Error: 453_209
-            .saturating_add(Weight::from_parts(402_577_817, 0).saturating_mul(r.into()))
+        // Minimum execution time: 242_827_000 picoseconds.
+        Weight::from_parts(291_906_943, 0)
+            // Standard Error: 419_132
+            .saturating_add(Weight::from_parts(316_375_969, 0).saturating_mul(r.into()))
     }
     /// The range of component `n` is `[0, 2048]`.
     fn gr_reservation_send_per_kb(n: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 654_055_000 picoseconds.
-        Weight::from_parts(663_310_000, 0)
-            // Standard Error: 60_031
-            .saturating_add(Weight::from_parts(21_652_831, 0).saturating_mul(n.into()))
+        // Minimum execution time: 554_876_000 picoseconds.
+        Weight::from_parts(559_277_000, 0)
+            // Standard Error: 59_610
+            .saturating_add(Weight::from_parts(21_490_976, 0).saturating_mul(n.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_reservation_send_commit(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 4_054_583_000 picoseconds.
-        Weight::from_parts(4_192_801_478, 0)
-            // Standard Error: 494_878
-            .saturating_add(Weight::from_parts(356_698_705, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_443_317_000 picoseconds.
+        Weight::from_parts(2_625_227_536, 0)
+            // Standard Error: 511_289
+            .saturating_add(Weight::from_parts(283_117_268, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 1]`.
     fn gr_reply(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 84_037_000 picoseconds.
-        Weight::from_parts(88_828_036, 0)
-            // Standard Error: 335_490
-            .saturating_add(Weight::from_parts(26_597_063, 0).saturating_mul(r.into()))
+        // Minimum execution time: 85_099_000 picoseconds.
+        Weight::from_parts(88_574_604, 0)
+            // Standard Error: 274_173
+            .saturating_add(Weight::from_parts(20_834_495, 0).saturating_mul(r.into()))
     }
     /// The range of component `n` is `[0, 2048]`.
     fn gr_reply_per_kb(n: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 108_733_000 picoseconds.
-        Weight::from_parts(93_898_943, 0)
-            // Standard Error: 1_151
-            .saturating_add(Weight::from_parts(428_904, 0).saturating_mul(n.into()))
+        // Minimum execution time: 102_246_000 picoseconds.
+        Weight::from_parts(90_382_254, 0)
+            // Standard Error: 1_257
+            .saturating_add(Weight::from_parts(428_781, 0).saturating_mul(n.into()))
     }
     /// The range of component `r` is `[0, 1]`.
     fn gr_reply_wgas(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 82_569_000 picoseconds.
-        Weight::from_parts(89_213_638, 0)
-            // Standard Error: 317_917
-            .saturating_add(Weight::from_parts(22_797_961, 0).saturating_mul(r.into()))
+        // Minimum execution time: 86_454_000 picoseconds.
+        Weight::from_parts(90_235_951, 0)
+            // Standard Error: 256_364
+            .saturating_add(Weight::from_parts(14_555_548, 0).saturating_mul(r.into()))
     }
     /// The range of component `n` is `[0, 2048]`.
     fn gr_reply_wgas_per_kb(n: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 109_164_000 picoseconds.
-        Weight::from_parts(95_571_505, 0)
-            // Standard Error: 1_085
-            .saturating_add(Weight::from_parts(425_025, 0).saturating_mul(n.into()))
+        // Minimum execution time: 104_189_000 picoseconds.
+        Weight::from_parts(91_177_961, 0)
+            // Standard Error: 1_127
+            .saturating_add(Weight::from_parts(424_751, 0).saturating_mul(n.into()))
     }
     /// The range of component `r` is `[0, 1]`.
     fn gr_reply_commit(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 83_844_000 picoseconds.
-        Weight::from_parts(88_247_426, 0)
-            // Standard Error: 280_700
-            .saturating_add(Weight::from_parts(17_706_873, 0).saturating_mul(r.into()))
+        // Minimum execution time: 84_893_000 picoseconds.
+        Weight::from_parts(88_684_789, 0)
+            // Standard Error: 287_468
+            .saturating_add(Weight::from_parts(16_661_810, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 1]`.
     fn gr_reply_commit_wgas(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 82_987_000 picoseconds.
-        Weight::from_parts(87_544_514, 0)
-            // Standard Error: 269_120
-            .saturating_add(Weight::from_parts(21_098_185, 0).saturating_mul(r.into()))
+        // Minimum execution time: 84_534_000 picoseconds.
+        Weight::from_parts(88_923_020, 0)
+            // Standard Error: 249_896
+            .saturating_add(Weight::from_parts(19_208_979, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_reply_push(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 82_012_000 picoseconds.
-        Weight::from_parts(115_149_368, 0)
-            // Standard Error: 328_818
-            .saturating_add(Weight::from_parts(265_684_350, 0).saturating_mul(r.into()))
+        // Minimum execution time: 85_229_000 picoseconds.
+        Weight::from_parts(120_908_395, 0)
+            // Standard Error: 327_109
+            .saturating_add(Weight::from_parts(190_143_835, 0).saturating_mul(r.into()))
     }
     /// The range of component `n` is `[0, 8192]`.
     fn gr_reply_push_per_kb(n: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 100_890_000 picoseconds.
-        Weight::from_parts(102_844_000, 0)
-            // Standard Error: 2_931
-            .saturating_add(Weight::from_parts(635_797, 0).saturating_mul(n.into()))
+        // Minimum execution time: 98_549_000 picoseconds.
+        Weight::from_parts(100_553_000, 0)
+            // Standard Error: 2_727
+            .saturating_add(Weight::from_parts(616_949, 0).saturating_mul(n.into()))
     }
     /// The range of component `r` is `[0, 1]`.
     fn gr_reply_input(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 563_182_000 picoseconds.
-        Weight::from_parts(640_794_146, 0)
-            // Standard Error: 7_497_207
-            .saturating_add(Weight::from_parts(15_239_053, 0).saturating_mul(r.into()))
+        // Minimum execution time: 553_918_000 picoseconds.
+        Weight::from_parts(572_988_848, 0)
+            // Standard Error: 2_210_952
+            .saturating_add(Weight::from_parts(30_333_551, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 1]`.
     fn gr_reply_input_wgas(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 560_481_000 picoseconds.
-        Weight::from_parts(593_427_573, 0)
-            // Standard Error: 3_203_142
-            .saturating_add(Weight::from_parts(25_969_526, 0).saturating_mul(r.into()))
+        // Minimum execution time: 552_664_000 picoseconds.
+        Weight::from_parts(571_824_067, 0)
+            // Standard Error: 1_981_598
+            .saturating_add(Weight::from_parts(28_343_432, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 1]`.
     fn gr_reservation_reply(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 92_574_000 picoseconds.
-        Weight::from_parts(97_280_140, 0)
-            // Standard Error: 268_694
-            .saturating_add(Weight::from_parts(12_092_859, 0).saturating_mul(r.into()))
+        // Minimum execution time: 96_114_000 picoseconds.
+        Weight::from_parts(99_799_695, 0)
+            // Standard Error: 263_342
+            .saturating_add(Weight::from_parts(5_959_704, 0).saturating_mul(r.into()))
     }
     /// The range of component `n` is `[0, 2048]`.
     fn gr_reservation_reply_per_kb(n: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 109_631_000 picoseconds.
-        Weight::from_parts(94_175_255, 0)
-            // Standard Error: 1_213
-            .saturating_add(Weight::from_parts(427_553, 0).saturating_mul(n.into()))
+        // Minimum execution time: 104_595_000 picoseconds.
+        Weight::from_parts(94_900_895, 0)
+            // Standard Error: 1_221
+            .saturating_add(Weight::from_parts(425_729, 0).saturating_mul(n.into()))
     }
     /// The range of component `r` is `[0, 1]`.
     fn gr_reservation_reply_commit(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 95_505_000 picoseconds.
-        Weight::from_parts(100_109_459, 0)
-            // Standard Error: 279_145
-            .saturating_add(Weight::from_parts(8_335_840, 0).saturating_mul(r.into()))
+        // Minimum execution time: 94_123_000 picoseconds.
+        Weight::from_parts(99_068_002, 0)
+            // Standard Error: 278_340
+            .saturating_add(Weight::from_parts(6_056_397, 0).saturating_mul(r.into()))
     }
     /// The range of component `n` is `[0, 2048]`.
     fn gr_reservation_reply_commit_per_kb(n: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 105_015_000 picoseconds.
-        Weight::from_parts(96_000_128, 0)
-            // Standard Error: 1_363
-            .saturating_add(Weight::from_parts(423_685, 0).saturating_mul(n.into()))
+        // Minimum execution time: 106_148_000 picoseconds.
+        Weight::from_parts(93_583_351, 0)
+            // Standard Error: 1_048
+            .saturating_add(Weight::from_parts(420_112, 0).saturating_mul(n.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_reply_to(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 84_784_000 picoseconds.
-        Weight::from_parts(84_956_444, 0)
-            // Standard Error: 285_268
-            .saturating_add(Weight::from_parts(178_346_410, 0).saturating_mul(r.into()))
+        // Minimum execution time: 83_951_000 picoseconds.
+        Weight::from_parts(80_983_069, 0)
+            // Standard Error: 260_297
+            .saturating_add(Weight::from_parts(114_164_207, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_signal_from(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 85_915_000 picoseconds.
-        Weight::from_parts(78_586_027, 0)
-            // Standard Error: 254_710
-            .saturating_add(Weight::from_parts(178_243_954, 0).saturating_mul(r.into()))
+        // Minimum execution time: 88_991_000 picoseconds.
+        Weight::from_parts(83_808_552, 0)
+            // Standard Error: 291_596
+            .saturating_add(Weight::from_parts(107_977_269, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_reply_push_input(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 557_380_000 picoseconds.
-        Weight::from_parts(633_253_100, 0)
-            // Standard Error: 538_762
-            .saturating_add(Weight::from_parts(195_061_580, 0).saturating_mul(r.into()))
+        // Minimum execution time: 555_192_000 picoseconds.
+        Weight::from_parts(637_741_196, 0)
+            // Standard Error: 498_770
+            .saturating_add(Weight::from_parts(126_311_515, 0).saturating_mul(r.into()))
     }
     /// The range of component `n` is `[0, 2048]`.
     fn gr_reply_push_input_per_kb(n: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 597_682_000 picoseconds.
-        Weight::from_parts(661_897_574, 0)
-            // Standard Error: 3_826
-            .saturating_add(Weight::from_parts(136_457, 0).saturating_mul(n.into()))
+        // Minimum execution time: 567_642_000 picoseconds.
+        Weight::from_parts(587_862_774, 0)
+            // Standard Error: 1_100
+            .saturating_add(Weight::from_parts(120_318, 0).saturating_mul(n.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_send_push_input(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 4_454_821_000 picoseconds.
-        Weight::from_parts(4_682_125_339, 0)
-            // Standard Error: 520_741
-            .saturating_add(Weight::from_parts(206_155_172, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_764_152_000 picoseconds.
+        Weight::from_parts(2_885_803_691, 0)
+            // Standard Error: 562_616
+            .saturating_add(Weight::from_parts(154_883_526, 0).saturating_mul(r.into()))
     }
     /// The range of component `n` is `[0, 2048]`.
     fn gr_send_push_input_per_kb(n: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 4_637_831_000 picoseconds.
-        Weight::from_parts(4_748_853_254, 0)
-            // Standard Error: 16_010
-            .saturating_add(Weight::from_parts(12_276_105, 0).saturating_mul(n.into()))
+        // Minimum execution time: 2_942_765_000 picoseconds.
+        Weight::from_parts(2_852_597_513, 0)
+            // Standard Error: 14_069
+            .saturating_add(Weight::from_parts(12_388_759, 0).saturating_mul(n.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_debug(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 84_447_000 picoseconds.
-        Weight::from_parts(111_081_974, 0)
-            // Standard Error: 422_093
-            .saturating_add(Weight::from_parts(195_515_962, 0).saturating_mul(r.into()))
+        // Minimum execution time: 85_236_000 picoseconds.
+        Weight::from_parts(108_121_903, 0)
+            // Standard Error: 338_552
+            .saturating_add(Weight::from_parts(130_391_399, 0).saturating_mul(r.into()))
     }
     /// The range of component `n` is `[0, 2048]`.
     fn gr_debug_per_kb(n: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 188_901_000 picoseconds.
-        Weight::from_parts(192_422_000, 0)
-            // Standard Error: 54_402
-            .saturating_add(Weight::from_parts(25_703_289, 0).saturating_mul(n.into()))
+        // Minimum execution time: 143_555_000 picoseconds.
+        Weight::from_parts(145_256_000, 0)
+            // Standard Error: 61_456
+            .saturating_add(Weight::from_parts(25_766_308, 0).saturating_mul(n.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_reply_code(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 85_538_000 picoseconds.
-        Weight::from_parts(83_073_715, 0)
-            // Standard Error: 285_530
-            .saturating_add(Weight::from_parts(174_178_092, 0).saturating_mul(r.into()))
+        // Minimum execution time: 88_706_000 picoseconds.
+        Weight::from_parts(82_734_112, 0)
+            // Standard Error: 323_634
+            .saturating_add(Weight::from_parts(107_133_410, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 1]`.
     fn gr_exit(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 84_697_000 picoseconds.
-        Weight::from_parts(89_049_881, 0)
-            // Standard Error: 281_628
-            .saturating_add(Weight::from_parts(27_362_618, 0).saturating_mul(r.into()))
+        // Minimum execution time: 84_050_000 picoseconds.
+        Weight::from_parts(88_261_802, 0)
+            // Standard Error: 247_640
+            .saturating_add(Weight::from_parts(23_580_197, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 1]`.
     fn gr_leave(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 83_006_000 picoseconds.
-        Weight::from_parts(86_657_161, 0)
-            // Standard Error: 254_208
-            .saturating_add(Weight::from_parts(14_853_038, 0).saturating_mul(r.into()))
+        // Minimum execution time: 86_558_000 picoseconds.
+        Weight::from_parts(90_338_028, 0)
+            // Standard Error: 270_999
+            .saturating_add(Weight::from_parts(15_249_771, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 1]`.
     fn gr_wait(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 83_155_000 picoseconds.
-        Weight::from_parts(87_136_381, 0)
-            // Standard Error: 296_075
-            .saturating_add(Weight::from_parts(15_564_718, 0).saturating_mul(r.into()))
+        // Minimum execution time: 86_250_000 picoseconds.
+        Weight::from_parts(90_448_269, 0)
+            // Standard Error: 274_039
+            .saturating_add(Weight::from_parts(12_874_930, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 1]`.
     fn gr_wait_for(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 83_160_000 picoseconds.
-        Weight::from_parts(87_382_440, 0)
-            // Standard Error: 263_499
-            .saturating_add(Weight::from_parts(17_288_459, 0).saturating_mul(r.into()))
+        // Minimum execution time: 84_278_000 picoseconds.
+        Weight::from_parts(88_025_842, 0)
+            // Standard Error: 274_359
+            .saturating_add(Weight::from_parts(11_610_357, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 1]`.
     fn gr_wait_up_to(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 86_780_000 picoseconds.
-        Weight::from_parts(90_970_389, 0)
-            // Standard Error: 273_512
-            .saturating_add(Weight::from_parts(14_976_210, 0).saturating_mul(r.into()))
+        // Minimum execution time: 83_849_000 picoseconds.
+        Weight::from_parts(87_858_273, 0)
+            // Standard Error: 263_624
+            .saturating_add(Weight::from_parts(14_636_926, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_wake(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 141_871_000 picoseconds.
-        Weight::from_parts(203_107_595, 0)
-            // Standard Error: 322_999
-            .saturating_add(Weight::from_parts(280_023_774, 0).saturating_mul(r.into()))
+        // Minimum execution time: 134_444_000 picoseconds.
+        Weight::from_parts(198_654_906, 0)
+            // Standard Error: 409_120
+            .saturating_add(Weight::from_parts(200_669_427, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_create_program(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 99_132_000 picoseconds.
-        Weight::from_parts(166_620_417, 0)
-            // Standard Error: 428_363
-            .saturating_add(Weight::from_parts(469_520_431, 0).saturating_mul(r.into()))
+        // Minimum execution time: 97_737_000 picoseconds.
+        Weight::from_parts(162_389_592, 0)
+            // Standard Error: 437_002
+            .saturating_add(Weight::from_parts(385_229_944, 0).saturating_mul(r.into()))
     }
     /// The range of component `p` is `[0, 2048]`.
     /// The range of component `s` is `[1, 2048]`.
@@ -2950,22 +2952,22 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 46_670_030_000 picoseconds.
-        Weight::from_parts(46_979_707_000, 0)
-            // Standard Error: 290_199
-            .saturating_add(Weight::from_parts(7_295_075, 0).saturating_mul(p.into()))
-            // Standard Error: 290_185
-            .saturating_add(Weight::from_parts(178_049_340, 0).saturating_mul(s.into()))
+        // Minimum execution time: 44_710_614_000 picoseconds.
+        Weight::from_parts(44_848_530_000, 0)
+            // Standard Error: 271_081
+            .saturating_add(Weight::from_parts(7_518_236, 0).saturating_mul(p.into()))
+            // Standard Error: 271_067
+            .saturating_add(Weight::from_parts(176_484_363, 0).saturating_mul(s.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_create_program_wgas(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 95_401_000 picoseconds.
-        Weight::from_parts(162_215_381, 0)
-            // Standard Error: 435_866
-            .saturating_add(Weight::from_parts(479_266_464, 0).saturating_mul(r.into()))
+        // Minimum execution time: 93_935_000 picoseconds.
+        Weight::from_parts(155_283_975, 0)
+            // Standard Error: 398_331
+            .saturating_add(Weight::from_parts(394_750_144, 0).saturating_mul(r.into()))
     }
     /// The range of component `p` is `[0, 2048]`.
     /// The range of component `s` is `[1, 2048]`.
@@ -2973,32 +2975,32 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 44_093_174_000 picoseconds.
-        Weight::from_parts(44_268_099_000, 0)
-            // Standard Error: 249_484
-            .saturating_add(Weight::from_parts(7_595_737, 0).saturating_mul(p.into()))
-            // Standard Error: 249_471
-            .saturating_add(Weight::from_parts(179_055_114, 0).saturating_mul(s.into()))
+        // Minimum execution time: 43_166_105_000 picoseconds.
+        Weight::from_parts(43_210_411_000, 0)
+            // Standard Error: 273_792
+            .saturating_add(Weight::from_parts(7_685_961, 0).saturating_mul(p.into()))
+            // Standard Error: 273_779
+            .saturating_add(Weight::from_parts(177_206_473, 0).saturating_mul(s.into()))
     }
     /// The range of component `r` is `[0, 20]`.
     fn gr_pay_program_rent(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 84_188_000 picoseconds.
-        Weight::from_parts(101_583_480, 0)
-            // Standard Error: 35_878
-            .saturating_add(Weight::from_parts(3_611_568, 0).saturating_mul(r.into()))
+        // Minimum execution time: 86_385_000 picoseconds.
+        Weight::from_parts(100_368_488, 0)
+            // Standard Error: 25_882
+            .saturating_add(Weight::from_parts(2_517_495, 0).saturating_mul(r.into()))
     }
     /// The range of component `p` is `[0, 512]`.
     fn lazy_pages_signal_read(p: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `141`
         //  Estimated: `1131 + p * (9900 ±0)`
-        // Minimum execution time: 86_183_000 picoseconds.
-        Weight::from_parts(118_618_192, 1131)
-            // Standard Error: 6_832
-            .saturating_add(Weight::from_parts(11_877_671, 0).saturating_mul(p.into()))
+        // Minimum execution time: 86_723_000 picoseconds.
+        Weight::from_parts(112_959_650, 1131)
+            // Standard Error: 5_171
+            .saturating_add(Weight::from_parts(11_884_248, 0).saturating_mul(p.into()))
             .saturating_add(RocksDbWeight::get().reads((4_u64).saturating_mul(p.into())))
             .saturating_add(Weight::from_parts(0, 9900).saturating_mul(p.into()))
     }
@@ -3007,10 +3009,10 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `141`
         //  Estimated: `1131 + p * (9900 ±0)`
-        // Minimum execution time: 84_629_000 picoseconds.
-        Weight::from_parts(86_416_000, 1131)
-            // Standard Error: 28_253
-            .saturating_add(Weight::from_parts(36_463_142, 0).saturating_mul(p.into()))
+        // Minimum execution time: 85_367_000 picoseconds.
+        Weight::from_parts(86_968_000, 1131)
+            // Standard Error: 35_935
+            .saturating_add(Weight::from_parts(35_294_476, 0).saturating_mul(p.into()))
             .saturating_add(RocksDbWeight::get().reads((4_u64).saturating_mul(p.into())))
             .saturating_add(Weight::from_parts(0, 9900).saturating_mul(p.into()))
     }
@@ -3019,10 +3021,10 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `141`
         //  Estimated: `5069931`
-        // Minimum execution time: 6_148_282_000 picoseconds.
-        Weight::from_parts(5_977_321_351, 5069931)
-            // Standard Error: 52_501
-            .saturating_add(Weight::from_parts(36_684_019, 0).saturating_mul(p.into()))
+        // Minimum execution time: 6_166_740_000 picoseconds.
+        Weight::from_parts(5_878_966_706, 5069931)
+            // Standard Error: 72_748
+            .saturating_add(Weight::from_parts(35_598_278, 0).saturating_mul(p.into()))
             .saturating_add(RocksDbWeight::get().reads(2048_u64))
     }
     /// The range of component `p` is `[0, 512]`.
@@ -3030,10 +3032,10 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `1813 + p * (65580 ±0)`
         //  Estimated: `1939 + p * (75482 ±0)`
-        // Minimum execution time: 85_557_000 picoseconds.
-        Weight::from_parts(86_547_000, 1939)
-            // Standard Error: 32_777
-            .saturating_add(Weight::from_parts(46_224_064, 0).saturating_mul(p.into()))
+        // Minimum execution time: 84_509_000 picoseconds.
+        Weight::from_parts(86_396_000, 1939)
+            // Standard Error: 37_909
+            .saturating_add(Weight::from_parts(46_229_201, 0).saturating_mul(p.into()))
             .saturating_add(RocksDbWeight::get().reads((4_u64).saturating_mul(p.into())))
             .saturating_add(Weight::from_parts(0, 75482).saturating_mul(p.into()))
     }
@@ -3042,10 +3044,10 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `141`
         //  Estimated: `1131 + p * (9900 ±0)`
-        // Minimum execution time: 89_966_000 picoseconds.
-        Weight::from_parts(89_543_596, 1131)
-            // Standard Error: 68_448
-            .saturating_add(Weight::from_parts(36_359_585, 0).saturating_mul(p.into()))
+        // Minimum execution time: 89_570_000 picoseconds.
+        Weight::from_parts(91_679_907, 1131)
+            // Standard Error: 74_102
+            .saturating_add(Weight::from_parts(36_034_356, 0).saturating_mul(p.into()))
             .saturating_add(RocksDbWeight::get().reads((4_u64).saturating_mul(p.into())))
             .saturating_add(Weight::from_parts(0, 9900).saturating_mul(p.into()))
     }
@@ -3054,10 +3056,10 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `141`
         //  Estimated: `1496 + p * (9883 ±2)`
-        // Minimum execution time: 600_329_000 picoseconds.
-        Weight::from_parts(623_878_315, 1496)
-            // Standard Error: 267_055
-            .saturating_add(Weight::from_parts(46_147_238, 0).saturating_mul(p.into()))
+        // Minimum execution time: 581_516_000 picoseconds.
+        Weight::from_parts(574_828_964, 1496)
+            // Standard Error: 226_535
+            .saturating_add(Weight::from_parts(44_029_625, 0).saturating_mul(p.into()))
             .saturating_add(RocksDbWeight::get().reads((4_u64).saturating_mul(p.into())))
             .saturating_add(Weight::from_parts(0, 9883).saturating_mul(p.into()))
     }
@@ -3066,10 +3068,10 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `141`
         //  Estimated: `317931`
-        // Minimum execution time: 1_023_023_000 picoseconds.
-        Weight::from_parts(1_022_993_537, 317931)
-            // Standard Error: 203_791
-            .saturating_add(Weight::from_parts(43_538_291, 0).saturating_mul(p.into()))
+        // Minimum execution time: 984_554_000 picoseconds.
+        Weight::from_parts(1_010_300_775, 317931)
+            // Standard Error: 330_750
+            .saturating_add(Weight::from_parts(45_768_209, 0).saturating_mul(p.into()))
             .saturating_add(RocksDbWeight::get().reads(128_u64))
     }
     /// The range of component `r` is `[0, 20]`.
@@ -3077,884 +3079,882 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_300_000 picoseconds.
-        Weight::from_parts(2_436_506, 0)
-            // Standard Error: 16_946
-            .saturating_add(Weight::from_parts(24_493_632, 0).saturating_mul(r.into()))
+        // Minimum execution time: 4_399_000 picoseconds.
+        Weight::from_parts(2_513_898, 0)
+            // Standard Error: 22_468
+            .saturating_add(Weight::from_parts(24_974_238, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[50, 500]`.
     fn instr_i64load(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 4_347_874_000 picoseconds.
-        Weight::from_parts(4_179_322_071, 0)
-            // Standard Error: 53_086
-            .saturating_add(Weight::from_parts(4_505_224, 0).saturating_mul(r.into()))
+        // Minimum execution time: 4_354_805_000 picoseconds.
+        Weight::from_parts(4_247_725_842, 0)
+            // Standard Error: 49_167
+            .saturating_add(Weight::from_parts(4_375_644, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[50, 500]`.
     fn instr_i32load(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 4_348_187_000 picoseconds.
-        Weight::from_parts(4_205_195_765, 0)
-            // Standard Error: 44_017
-            .saturating_add(Weight::from_parts(4_404_586, 0).saturating_mul(r.into()))
+        // Minimum execution time: 4_344_769_000 picoseconds.
+        Weight::from_parts(4_143_583_164, 0)
+            // Standard Error: 64_865
+            .saturating_add(Weight::from_parts(4_885_201, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[50, 500]`.
     fn instr_i64store(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 10_882_662_000 picoseconds.
-        Weight::from_parts(11_083_501_979, 0)
-            // Standard Error: 200_162
-            .saturating_add(Weight::from_parts(13_165_815, 0).saturating_mul(r.into()))
+        // Minimum execution time: 10_321_597_000 picoseconds.
+        Weight::from_parts(10_856_474_625, 0)
+            // Standard Error: 228_480
+            .saturating_add(Weight::from_parts(13_648_467, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[50, 500]`.
     fn instr_i32store(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 10_784_867_000 picoseconds.
-        Weight::from_parts(11_957_102_430, 0)
-            // Standard Error: 187_347
-            .saturating_add(Weight::from_parts(8_480_335, 0).saturating_mul(r.into()))
+        // Minimum execution time: 10_444_861_000 picoseconds.
+        Weight::from_parts(11_811_924_847, 0)
+            // Standard Error: 220_732
+            .saturating_add(Weight::from_parts(8_104_347, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_select(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_343_000 picoseconds.
-        Weight::from_parts(2_421_000, 0)
-            // Standard Error: 9_011
-            .saturating_add(Weight::from_parts(3_834_828, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_102_000 picoseconds.
+        Weight::from_parts(2_199_000, 0)
+            // Standard Error: 8_145
+            .saturating_add(Weight::from_parts(3_817_860, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_if(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_326_000 picoseconds.
-        Weight::from_parts(2_421_000, 0)
-            // Standard Error: 5_612
-            .saturating_add(Weight::from_parts(3_061_076, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_084_000 picoseconds.
+        Weight::from_parts(2_171_000, 0)
+            // Standard Error: 5_734
+            .saturating_add(Weight::from_parts(3_044_285, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_br(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_282_000 picoseconds.
-        Weight::from_parts(3_427_769, 0)
-            // Standard Error: 941
-            .saturating_add(Weight::from_parts(1_568_677, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_074_000 picoseconds.
+        Weight::from_parts(3_341_361, 0)
+            // Standard Error: 1_168
+            .saturating_add(Weight::from_parts(1_569_364, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_br_if(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_284_000 picoseconds.
-        Weight::from_parts(2_392_000, 0)
-            // Standard Error: 8_418
-            .saturating_add(Weight::from_parts(2_921_747, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_189_000 picoseconds.
+        Weight::from_parts(2_253_000, 0)
+            // Standard Error: 7_562
+            .saturating_add(Weight::from_parts(2_914_810, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_br_table(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_263_000 picoseconds.
-        Weight::from_parts(1_354_050, 0)
-            // Standard Error: 14_642
-            .saturating_add(Weight::from_parts(5_182_595, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_131_000 picoseconds.
+        Weight::from_parts(99_037, 0)
+            // Standard Error: 11_949
+            .saturating_add(Weight::from_parts(5_173_684, 0).saturating_mul(r.into()))
     }
     /// The range of component `e` is `[1, 256]`.
     fn instr_br_table_per_entry(e: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 7_011_000 picoseconds.
-        Weight::from_parts(5_823_252, 0)
-            // Standard Error: 2_035
-            .saturating_add(Weight::from_parts(162_988, 0).saturating_mul(e.into()))
+        // Minimum execution time: 6_992_000 picoseconds.
+        Weight::from_parts(6_256_207, 0)
+            // Standard Error: 1_332
+            .saturating_add(Weight::from_parts(161_069, 0).saturating_mul(e.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_call_const(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_405_000 picoseconds.
-        Weight::from_parts(5_172_082, 0)
-            // Standard Error: 7_906
-            .saturating_add(Weight::from_parts(2_576_107, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_106_000 picoseconds.
+        Weight::from_parts(4_233_365, 0)
+            // Standard Error: 7_839
+            .saturating_add(Weight::from_parts(2_631_387, 0).saturating_mul(r.into()))
     }
     fn instr_i64const(r: u32, ) -> Weight {
         Weight::from_parts(0, 0)
-            .saturating_add(Weight::from_parts(2_576_107 -
-            2_413_885, 0).saturating_mul(r.into()))
+            .saturating_add(Weight::from_parts(2_631_387 -
+            2_404_882, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_call(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_315_000 picoseconds.
-        Weight::from_parts(4_417_546, 0)
-            // Standard Error: 12_281
-            .saturating_add(Weight::from_parts(2_413_885, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_192_000 picoseconds.
+        Weight::from_parts(4_830_171, 0)
+            // Standard Error: 12_370
+            .saturating_add(Weight::from_parts(2_404_882, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_call_indirect(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_774_000 picoseconds.
-        Weight::from_parts(19_445_534, 0)
-            // Standard Error: 34_031
-            .saturating_add(Weight::from_parts(9_947_648, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_413_000 picoseconds.
+        Weight::from_parts(16_855_535, 0)
+            // Standard Error: 25_880
+            .saturating_add(Weight::from_parts(10_029_290, 0).saturating_mul(r.into()))
     }
     /// The range of component `p` is `[0, 128]`.
     fn instr_call_indirect_per_param(p: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 12_663_000 picoseconds.
-        Weight::from_parts(2_443_915, 0)
-            // Standard Error: 6_189
-            .saturating_add(Weight::from_parts(1_274_832, 0).saturating_mul(p.into()))
+        // Minimum execution time: 12_145_000 picoseconds.
+        Weight::from_parts(4_520_615, 0)
+            // Standard Error: 6_765
+            .saturating_add(Weight::from_parts(1_202_471, 0).saturating_mul(p.into()))
     }
     /// The range of component `l` is `[0, 1024]`.
-    fn instr_call_per_local(l: u32, ) -> Weight {
+    fn instr_call_per_local(_l: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 5_382_000 picoseconds.
-        Weight::from_parts(5_657_220, 0)
-            // Standard Error: 12
-            .saturating_add(Weight::from_parts(14, 0).saturating_mul(l.into()))
+        // Minimum execution time: 5_133_000 picoseconds.
+        Weight::from_parts(5_476_163, 0)
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_local_get(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_461_000 picoseconds.
-        Weight::from_parts(1_936_508, 0)
-            // Standard Error: 3_019
-            .saturating_add(Weight::from_parts(275_086, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_117_000 picoseconds.
+        Weight::from_parts(1_458_597, 0)
+            // Standard Error: 3_356
+            .saturating_add(Weight::from_parts(265_574, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_local_set(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_305_000 picoseconds.
-        Weight::from_parts(2_394_000, 0)
-            // Standard Error: 4_239
-            .saturating_add(Weight::from_parts(763_775, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_135_000 picoseconds.
+        Weight::from_parts(2_223_000, 0)
+            // Standard Error: 5_214
+            .saturating_add(Weight::from_parts(766_010, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_local_tee(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_367_000 picoseconds.
-        Weight::from_parts(2_411_000, 0)
-            // Standard Error: 5_426
-            .saturating_add(Weight::from_parts(771_295, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_078_000 picoseconds.
+        Weight::from_parts(2_218_000, 0)
+            // Standard Error: 5_801
+            .saturating_add(Weight::from_parts(743_573, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_global_get(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 6_346_000 picoseconds.
-        Weight::from_parts(2_691_888, 0)
-            // Standard Error: 7_020
-            .saturating_add(Weight::from_parts(804_877, 0).saturating_mul(r.into()))
+        // Minimum execution time: 6_226_000 picoseconds.
+        Weight::from_parts(2_093_625, 0)
+            // Standard Error: 7_678
+            .saturating_add(Weight::from_parts(824_956, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_global_set(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 6_476_000 picoseconds.
-        Weight::from_parts(6_582_000, 0)
-            // Standard Error: 8_493
-            .saturating_add(Weight::from_parts(1_358_866, 0).saturating_mul(r.into()))
+        // Minimum execution time: 6_201_000 picoseconds.
+        Weight::from_parts(154_770, 0)
+            // Standard Error: 9_398
+            .saturating_add(Weight::from_parts(1_480_245, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_memory_current(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 4_943_000 picoseconds.
-        Weight::from_parts(1_102_558, 0)
-            // Standard Error: 12_614
-            .saturating_add(Weight::from_parts(7_099_473, 0).saturating_mul(r.into()))
+        // Minimum execution time: 6_989_000 picoseconds.
+        Weight::from_parts(2_628_082, 0)
+            // Standard Error: 12_268
+            .saturating_add(Weight::from_parts(6_921_043, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64clz(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_298_000 picoseconds.
-        Weight::from_parts(2_357_000, 0)
-            // Standard Error: 7_419
-            .saturating_add(Weight::from_parts(3_438_043, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_086_000 picoseconds.
+        Weight::from_parts(2_156_000, 0)
+            // Standard Error: 5_477
+            .saturating_add(Weight::from_parts(3_348_027, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32clz(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_201_000 picoseconds.
-        Weight::from_parts(2_270_000, 0)
-            // Standard Error: 7_089
-            .saturating_add(Weight::from_parts(3_224_674, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_102_000 picoseconds.
+        Weight::from_parts(2_163_000, 0)
+            // Standard Error: 6_833
+            .saturating_add(Weight::from_parts(3_134_916, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64ctz(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_358_000 picoseconds.
-        Weight::from_parts(2_444_000, 0)
-            // Standard Error: 5_880
-            .saturating_add(Weight::from_parts(3_196_577, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_131_000 picoseconds.
+        Weight::from_parts(2_209_000, 0)
+            // Standard Error: 7_612
+            .saturating_add(Weight::from_parts(3_170_404, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32ctz(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_205_000 picoseconds.
-        Weight::from_parts(2_361_000, 0)
-            // Standard Error: 5_007
-            .saturating_add(Weight::from_parts(2_694_074, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_124_000 picoseconds.
+        Weight::from_parts(2_169_000, 0)
+            // Standard Error: 4_823
+            .saturating_add(Weight::from_parts(2_668_874, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64popcnt(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_217_000 picoseconds.
-        Weight::from_parts(2_339_000, 0)
-            // Standard Error: 4_242
-            .saturating_add(Weight::from_parts(562_083, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_159_000 picoseconds.
+        Weight::from_parts(2_240_000, 0)
+            // Standard Error: 3_992
+            .saturating_add(Weight::from_parts(559_604, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32popcnt(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_180_000 picoseconds.
-        Weight::from_parts(1_150_328, 0)
-            // Standard Error: 4_155
-            .saturating_add(Weight::from_parts(430_809, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_127_000 picoseconds.
+        Weight::from_parts(1_178_239, 0)
+            // Standard Error: 3_346
+            .saturating_add(Weight::from_parts(416_704, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64eqz(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_218_000 picoseconds.
-        Weight::from_parts(2_269_000, 0)
-            // Standard Error: 12_863
-            .saturating_add(Weight::from_parts(1_875_276, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_137_000 picoseconds.
+        Weight::from_parts(2_192_000, 0)
+            // Standard Error: 11_707
+            .saturating_add(Weight::from_parts(1_918_501, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32eqz(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_290_000 picoseconds.
-        Weight::from_parts(2_322_000, 0)
-            // Standard Error: 8_333
-            .saturating_add(Weight::from_parts(1_185_939, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_131_000 picoseconds.
+        Weight::from_parts(2_192_000, 0)
+            // Standard Error: 7_593
+            .saturating_add(Weight::from_parts(1_219_931, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32extend8s(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_384_000 picoseconds.
-        Weight::from_parts(1_572_617, 0)
-            // Standard Error: 3_727
-            .saturating_add(Weight::from_parts(382_695, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_124_000 picoseconds.
+        Weight::from_parts(726_401, 0)
+            // Standard Error: 4_086
+            .saturating_add(Weight::from_parts(424_161, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32extend16s(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_236_000 picoseconds.
-        Weight::from_parts(1_495_799, 0)
-            // Standard Error: 4_058
-            .saturating_add(Weight::from_parts(373_636, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_107_000 picoseconds.
+        Weight::from_parts(1_225_918, 0)
+            // Standard Error: 3_748
+            .saturating_add(Weight::from_parts(392_373, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64extend8s(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_341_000 picoseconds.
-        Weight::from_parts(465_059, 0)
-            // Standard Error: 4_917
-            .saturating_add(Weight::from_parts(551_259, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_168_000 picoseconds.
+        Weight::from_parts(11_174, 0)
+            // Standard Error: 5_816
+            .saturating_add(Weight::from_parts(594_467, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64extend16s(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_230_000 picoseconds.
-        Weight::from_parts(515_890, 0)
-            // Standard Error: 4_848
-            .saturating_add(Weight::from_parts(545_542, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_138_000 picoseconds.
+        Weight::from_parts(12_680, 0)
+            // Standard Error: 5_830
+            .saturating_add(Weight::from_parts(595_552, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64extend32s(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_272_000 picoseconds.
-        Weight::from_parts(739_709, 0)
-            // Standard Error: 4_827
-            .saturating_add(Weight::from_parts(496_885, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_163_000 picoseconds.
+        Weight::from_parts(172_344, 0)
+            // Standard Error: 5_372
+            .saturating_add(Weight::from_parts(537_510, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64extendsi32(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_322_000 picoseconds.
-        Weight::from_parts(1_492_190, 0)
-            // Standard Error: 3_923
-            .saturating_add(Weight::from_parts(340_665, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_171_000 picoseconds.
+        Weight::from_parts(459_682, 0)
+            // Standard Error: 5_533
+            .saturating_add(Weight::from_parts(421_155, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64extendui32(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_257_000 picoseconds.
-        Weight::from_parts(2_979_817, 0)
-            // Standard Error: 1_972
-            .saturating_add(Weight::from_parts(154_315, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_157_000 picoseconds.
+        Weight::from_parts(2_640_857, 0)
+            // Standard Error: 2_132
+            .saturating_add(Weight::from_parts(175_772, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32wrapi64(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_282_000 picoseconds.
-        Weight::from_parts(2_877_230, 0)
-            // Standard Error: 1_753
-            .saturating_add(Weight::from_parts(153_462, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_149_000 picoseconds.
+        Weight::from_parts(2_625_890, 0)
+            // Standard Error: 2_246
+            .saturating_add(Weight::from_parts(177_728, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64eq(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_193_000 picoseconds.
-        Weight::from_parts(2_289_000, 0)
-            // Standard Error: 11_649
-            .saturating_add(Weight::from_parts(1_795_062, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_082_000 picoseconds.
+        Weight::from_parts(2_193_000, 0)
+            // Standard Error: 9_664
+            .saturating_add(Weight::from_parts(1_832_396, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32eq(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_303_000 picoseconds.
-        Weight::from_parts(2_366_000, 0)
-            // Standard Error: 7_436
-            .saturating_add(Weight::from_parts(1_091_962, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_029_000 picoseconds.
+        Weight::from_parts(2_185_000, 0)
+            // Standard Error: 7_691
+            .saturating_add(Weight::from_parts(1_203_465, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64ne(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_346_000 picoseconds.
-        Weight::from_parts(2_409_000, 0)
-            // Standard Error: 11_197
-            .saturating_add(Weight::from_parts(1_828_518, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_146_000 picoseconds.
+        Weight::from_parts(2_198_000, 0)
+            // Standard Error: 10_390
+            .saturating_add(Weight::from_parts(1_868_795, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32ne(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_328_000 picoseconds.
-        Weight::from_parts(2_384_000, 0)
-            // Standard Error: 7_307
-            .saturating_add(Weight::from_parts(1_106_869, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_082_000 picoseconds.
+        Weight::from_parts(2_133_000, 0)
+            // Standard Error: 8_282
+            .saturating_add(Weight::from_parts(1_199_983, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64lts(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_286_000 picoseconds.
-        Weight::from_parts(2_343_000, 0)
-            // Standard Error: 10_932
-            .saturating_add(Weight::from_parts(1_789_419, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_145_000 picoseconds.
+        Weight::from_parts(2_178_000, 0)
+            // Standard Error: 10_175
+            .saturating_add(Weight::from_parts(1_943_386, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32lts(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_214_000 picoseconds.
-        Weight::from_parts(2_283_000, 0)
-            // Standard Error: 7_556
-            .saturating_add(Weight::from_parts(1_111_326, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_094_000 picoseconds.
+        Weight::from_parts(2_168_000, 0)
+            // Standard Error: 6_923
+            .saturating_add(Weight::from_parts(1_125_091, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64ltu(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_263_000 picoseconds.
-        Weight::from_parts(2_322_000, 0)
-            // Standard Error: 10_995
-            .saturating_add(Weight::from_parts(1_822_680, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_200_000 picoseconds.
+        Weight::from_parts(2_250_000, 0)
+            // Standard Error: 11_944
+            .saturating_add(Weight::from_parts(1_852_545, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32ltu(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_276_000 picoseconds.
-        Weight::from_parts(2_334_000, 0)
-            // Standard Error: 6_944
-            .saturating_add(Weight::from_parts(1_121_080, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_077_000 picoseconds.
+        Weight::from_parts(2_121_000, 0)
+            // Standard Error: 7_914
+            .saturating_add(Weight::from_parts(1_171_461, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64gts(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_227_000 picoseconds.
-        Weight::from_parts(2_292_000, 0)
-            // Standard Error: 11_873
-            .saturating_add(Weight::from_parts(1_840_273, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_171_000 picoseconds.
+        Weight::from_parts(2_278_000, 0)
+            // Standard Error: 10_701
+            .saturating_add(Weight::from_parts(1_859_283, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32gts(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_265_000 picoseconds.
-        Weight::from_parts(2_409_000, 0)
-            // Standard Error: 7_972
-            .saturating_add(Weight::from_parts(1_134_825, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_167_000 picoseconds.
+        Weight::from_parts(2_209_000, 0)
+            // Standard Error: 7_361
+            .saturating_add(Weight::from_parts(1_182_113, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64gtu(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_269_000 picoseconds.
-        Weight::from_parts(2_355_000, 0)
-            // Standard Error: 11_547
-            .saturating_add(Weight::from_parts(1_813_029, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_202_000 picoseconds.
+        Weight::from_parts(2_239_000, 0)
+            // Standard Error: 12_468
+            .saturating_add(Weight::from_parts(1_847_236, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32gtu(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_273_000 picoseconds.
-        Weight::from_parts(2_349_000, 0)
-            // Standard Error: 6_487
-            .saturating_add(Weight::from_parts(1_091_201, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_072_000 picoseconds.
+        Weight::from_parts(2_164_000, 0)
+            // Standard Error: 8_208
+            .saturating_add(Weight::from_parts(1_117_969, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64les(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_225_000 picoseconds.
-        Weight::from_parts(2_329_000, 0)
-            // Standard Error: 12_018
-            .saturating_add(Weight::from_parts(1_823_755, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_077_000 picoseconds.
+        Weight::from_parts(2_155_000, 0)
+            // Standard Error: 9_963
+            .saturating_add(Weight::from_parts(1_877_035, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32les(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_287_000 picoseconds.
-        Weight::from_parts(2_359_000, 0)
-            // Standard Error: 7_325
-            .saturating_add(Weight::from_parts(1_192_292, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_189_000 picoseconds.
+        Weight::from_parts(2_224_000, 0)
+            // Standard Error: 7_561
+            .saturating_add(Weight::from_parts(1_124_600, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64leu(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_352_000 picoseconds.
-        Weight::from_parts(2_386_000, 0)
-            // Standard Error: 10_009
-            .saturating_add(Weight::from_parts(1_870_539, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_157_000 picoseconds.
+        Weight::from_parts(2_210_000, 0)
+            // Standard Error: 11_998
+            .saturating_add(Weight::from_parts(1_829_852, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32leu(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_315_000 picoseconds.
-        Weight::from_parts(2_382_000, 0)
-            // Standard Error: 7_109
-            .saturating_add(Weight::from_parts(1_122_152, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_098_000 picoseconds.
+        Weight::from_parts(2_189_000, 0)
+            // Standard Error: 8_286
+            .saturating_add(Weight::from_parts(1_189_196, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64ges(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_254_000 picoseconds.
-        Weight::from_parts(2_337_000, 0)
-            // Standard Error: 11_700
-            .saturating_add(Weight::from_parts(1_825_021, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_125_000 picoseconds.
+        Weight::from_parts(2_198_000, 0)
+            // Standard Error: 10_056
+            .saturating_add(Weight::from_parts(1_829_185, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32ges(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_357_000 picoseconds.
-        Weight::from_parts(2_407_000, 0)
-            // Standard Error: 7_769
-            .saturating_add(Weight::from_parts(1_146_472, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_065_000 picoseconds.
+        Weight::from_parts(2_174_000, 0)
+            // Standard Error: 8_171
+            .saturating_add(Weight::from_parts(1_176_701, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64geu(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_196_000 picoseconds.
-        Weight::from_parts(2_292_000, 0)
-            // Standard Error: 9_908
-            .saturating_add(Weight::from_parts(1_845_094, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_141_000 picoseconds.
+        Weight::from_parts(2_220_000, 0)
+            // Standard Error: 9_910
+            .saturating_add(Weight::from_parts(1_871_442, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32geu(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_276_000 picoseconds.
-        Weight::from_parts(2_382_000, 0)
-            // Standard Error: 9_519
-            .saturating_add(Weight::from_parts(1_241_507, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_024_000 picoseconds.
+        Weight::from_parts(2_166_000, 0)
+            // Standard Error: 7_933
+            .saturating_add(Weight::from_parts(1_156_214, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64add(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_256_000 picoseconds.
-        Weight::from_parts(2_323_000, 0)
-            // Standard Error: 7_921
-            .saturating_add(Weight::from_parts(1_330_988, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_068_000 picoseconds.
+        Weight::from_parts(2_169_000, 0)
+            // Standard Error: 7_815
+            .saturating_add(Weight::from_parts(1_353_927, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32add(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_203_000 picoseconds.
-        Weight::from_parts(2_262_000, 0)
-            // Standard Error: 4_732
-            .saturating_add(Weight::from_parts(619_908, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_157_000 picoseconds.
+        Weight::from_parts(2_208_000, 0)
+            // Standard Error: 4_587
+            .saturating_add(Weight::from_parts(635_023, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64sub(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_273_000 picoseconds.
-        Weight::from_parts(2_318_000, 0)
-            // Standard Error: 8_121
-            .saturating_add(Weight::from_parts(1_255_733, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_080_000 picoseconds.
+        Weight::from_parts(2_140_000, 0)
+            // Standard Error: 8_399
+            .saturating_add(Weight::from_parts(1_278_782, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32sub(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_332_000 picoseconds.
-        Weight::from_parts(2_392_000, 0)
-            // Standard Error: 5_698
-            .saturating_add(Weight::from_parts(666_782, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_069_000 picoseconds.
+        Weight::from_parts(2_233_000, 0)
+            // Standard Error: 6_395
+            .saturating_add(Weight::from_parts(682_415, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64mul(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_269_000 picoseconds.
-        Weight::from_parts(2_342_000, 0)
-            // Standard Error: 10_724
-            .saturating_add(Weight::from_parts(1_779_885, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_206_000 picoseconds.
+        Weight::from_parts(2_224_000, 0)
+            // Standard Error: 9_477
+            .saturating_add(Weight::from_parts(1_819_764, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32mul(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_239_000 picoseconds.
-        Weight::from_parts(2_377_000, 0)
-            // Standard Error: 8_303
-            .saturating_add(Weight::from_parts(1_231_579, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_095_000 picoseconds.
+        Weight::from_parts(2_219_000, 0)
+            // Standard Error: 7_615
+            .saturating_add(Weight::from_parts(1_207_931, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64divs(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_247_000 picoseconds.
-        Weight::from_parts(3_881_473, 0)
-            // Standard Error: 22_336
-            .saturating_add(Weight::from_parts(2_602_873, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_108_000 picoseconds.
+        Weight::from_parts(1_363_438, 0)
+            // Standard Error: 18_139
+            .saturating_add(Weight::from_parts(2_743_512, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32divs(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_366_000 picoseconds.
-        Weight::from_parts(971_800, 0)
-            // Standard Error: 9_516
-            .saturating_add(Weight::from_parts(2_473_994, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_197_000 picoseconds.
+        Weight::from_parts(726_043, 0)
+            // Standard Error: 12_539
+            .saturating_add(Weight::from_parts(2_447_643, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64divu(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_333_000 picoseconds.
-        Weight::from_parts(3_150_808, 0)
-            // Standard Error: 24_239
-            .saturating_add(Weight::from_parts(2_853_024, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_118_000 picoseconds.
+        Weight::from_parts(1_113_814, 0)
+            // Standard Error: 15_837
+            .saturating_add(Weight::from_parts(2_939_546, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32divu(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_243_000 picoseconds.
-        Weight::from_parts(1_149_774, 0)
-            // Standard Error: 13_355
-            .saturating_add(Weight::from_parts(2_517_122, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_121_000 picoseconds.
+        Weight::from_parts(2_089_486, 0)
+            // Standard Error: 15_833
+            .saturating_add(Weight::from_parts(2_447_304, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64rems(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_243_000 picoseconds.
-        Weight::from_parts(1_527_824, 0)
-            // Standard Error: 31_972
-            .saturating_add(Weight::from_parts(9_267_865, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_200_000 picoseconds.
+        Weight::from_parts(2_235_000, 0)
+            // Standard Error: 16_089
+            .saturating_add(Weight::from_parts(9_370_736, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32rems(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_323_000 picoseconds.
-        Weight::from_parts(988_781, 0)
-            // Standard Error: 44_193
-            .saturating_add(Weight::from_parts(7_612_584, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_191_000 picoseconds.
+        Weight::from_parts(3_207_641, 0)
+            // Standard Error: 45_758
+            .saturating_add(Weight::from_parts(7_437_894, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64remu(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_294_000 picoseconds.
-        Weight::from_parts(2_334_729, 0)
-            // Standard Error: 15_965
-            .saturating_add(Weight::from_parts(2_951_129, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_118_000 picoseconds.
+        Weight::from_parts(588_160, 0)
+            // Standard Error: 17_384
+            .saturating_add(Weight::from_parts(2_989_240, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32remu(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_243_000 picoseconds.
-        Weight::from_parts(1_116_651, 0)
-            // Standard Error: 17_134
-            .saturating_add(Weight::from_parts(2_528_749, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_135_000 picoseconds.
+        Weight::from_parts(4_961_665, 0)
+            // Standard Error: 26_016
+            .saturating_add(Weight::from_parts(2_253_733, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64and(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_247_000 picoseconds.
-        Weight::from_parts(2_268_000, 0)
-            // Standard Error: 8_575
-            .saturating_add(Weight::from_parts(1_262_352, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_174_000 picoseconds.
+        Weight::from_parts(2_198_000, 0)
+            // Standard Error: 8_661
+            .saturating_add(Weight::from_parts(1_328_375, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32and(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_245_000 picoseconds.
-        Weight::from_parts(2_338_000, 0)
-            // Standard Error: 4_378
-            .saturating_add(Weight::from_parts(623_671, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_168_000 picoseconds.
+        Weight::from_parts(2_225_000, 0)
+            // Standard Error: 4_778
+            .saturating_add(Weight::from_parts(648_611, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64or(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_335_000 picoseconds.
-        Weight::from_parts(2_380_000, 0)
-            // Standard Error: 8_320
-            .saturating_add(Weight::from_parts(1_276_618, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_125_000 picoseconds.
+        Weight::from_parts(2_219_000, 0)
+            // Standard Error: 8_338
+            .saturating_add(Weight::from_parts(1_260_241, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32or(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_330_000 picoseconds.
-        Weight::from_parts(2_374_000, 0)
-            // Standard Error: 4_039
-            .saturating_add(Weight::from_parts(593_652, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_153_000 picoseconds.
+        Weight::from_parts(2_233_000, 0)
+            // Standard Error: 5_007
+            .saturating_add(Weight::from_parts(642_088, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64xor(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_220_000 picoseconds.
-        Weight::from_parts(2_325_000, 0)
-            // Standard Error: 8_112
-            .saturating_add(Weight::from_parts(1_247_970, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_230_000 picoseconds.
+        Weight::from_parts(2_267_000, 0)
+            // Standard Error: 8_196
+            .saturating_add(Weight::from_parts(1_328_828, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32xor(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_280_000 picoseconds.
-        Weight::from_parts(2_353_000, 0)
-            // Standard Error: 4_344
-            .saturating_add(Weight::from_parts(606_457, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_135_000 picoseconds.
+        Weight::from_parts(2_211_000, 0)
+            // Standard Error: 5_376
+            .saturating_add(Weight::from_parts(693_541, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64shl(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_234_000 picoseconds.
-        Weight::from_parts(2_286_000, 0)
-            // Standard Error: 7_296
-            .saturating_add(Weight::from_parts(1_053_977, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_208_000 picoseconds.
+        Weight::from_parts(2_224_000, 0)
+            // Standard Error: 7_393
+            .saturating_add(Weight::from_parts(1_144_418, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32shl(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_342_000 picoseconds.
-        Weight::from_parts(75_359, 0)
-            // Standard Error: 6_197
-            .saturating_add(Weight::from_parts(627_367, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_161_000 picoseconds.
+        Weight::from_parts(2_237_000, 0)
+            // Standard Error: 3_890
+            .saturating_add(Weight::from_parts(589_899, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64shrs(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_281_000 picoseconds.
-        Weight::from_parts(2_367_000, 0)
-            // Standard Error: 6_750
-            .saturating_add(Weight::from_parts(1_078_782, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_129_000 picoseconds.
+        Weight::from_parts(2_219_000, 0)
+            // Standard Error: 7_182
+            .saturating_add(Weight::from_parts(1_101_585, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32shrs(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_221_000 picoseconds.
-        Weight::from_parts(2_312_000, 0)
-            // Standard Error: 4_413
-            .saturating_add(Weight::from_parts(586_782, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_038_000 picoseconds.
+        Weight::from_parts(2_126_000, 0)
+            // Standard Error: 3_865
+            .saturating_add(Weight::from_parts(588_357, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64shru(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_353_000 picoseconds.
-        Weight::from_parts(2_385_000, 0)
-            // Standard Error: 9_421
-            .saturating_add(Weight::from_parts(1_130_965, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_129_000 picoseconds.
+        Weight::from_parts(2_215_000, 0)
+            // Standard Error: 8_265
+            .saturating_add(Weight::from_parts(1_152_496, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32shru(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_344_000 picoseconds.
-        Weight::from_parts(2_438_000, 0)
-            // Standard Error: 5_975
-            .saturating_add(Weight::from_parts(638_969, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_103_000 picoseconds.
+        Weight::from_parts(2_181_000, 0)
+            // Standard Error: 3_989
+            .saturating_add(Weight::from_parts(614_809, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64rotl(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_294_000 picoseconds.
-        Weight::from_parts(2_356_000, 0)
-            // Standard Error: 8_189
-            .saturating_add(Weight::from_parts(1_080_515, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_133_000 picoseconds.
+        Weight::from_parts(2_175_000, 0)
+            // Standard Error: 6_506
+            .saturating_add(Weight::from_parts(1_096_748, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32rotl(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_253_000 picoseconds.
-        Weight::from_parts(2_290_000, 0)
-            // Standard Error: 3_500
-            .saturating_add(Weight::from_parts(556_273, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_088_000 picoseconds.
+        Weight::from_parts(2_154_000, 0)
+            // Standard Error: 4_053
+            .saturating_add(Weight::from_parts(582_323, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i64rotr(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_215_000 picoseconds.
-        Weight::from_parts(2_333_000, 0)
-            // Standard Error: 7_954
-            .saturating_add(Weight::from_parts(1_067_773, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_120_000 picoseconds.
+        Weight::from_parts(2_213_000, 0)
+            // Standard Error: 6_472
+            .saturating_add(Weight::from_parts(1_056_569, 0).saturating_mul(r.into()))
     }
     /// The range of component `r` is `[0, 50]`.
     fn instr_i32rotr(r: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 2_183_000 picoseconds.
-        Weight::from_parts(2_223_000, 0)
-            // Standard Error: 3_658
-            .saturating_add(Weight::from_parts(566_527, 0).saturating_mul(r.into()))
+        // Minimum execution time: 2_097_000 picoseconds.
+        Weight::from_parts(2_192_000, 0)
+            // Standard Error: 3_800
+            .saturating_add(Weight::from_parts(579_517, 0).saturating_mul(r.into()))
     }
 }
diff --git a/runtime/vara/src/weights/pallet_gear_voucher.rs b/runtime/vara/src/weights/pallet_gear_voucher.rs
index 9b536c8f873..2abb7e94df3 100644
--- a/runtime/vara/src/weights/pallet_gear_voucher.rs
+++ b/runtime/vara/src/weights/pallet_gear_voucher.rs
@@ -19,7 +19,7 @@
 //! Autogenerated weights for pallet_gear_voucher
 //!
 //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
-//! DATE: 2023-08-01, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! DATE: 2023-08-07, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
 //! WORST CASE MAP SIZE: `1000000`
 //! CPU: `Intel(R) Xeon(R) Platinum 8375C CPU @ 2.90GHz`
 //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("vara-dev"), DB CACHE: 1024
@@ -47,8 +47,8 @@ impl<T: frame_system::Config> pallet_gear_voucher::WeightInfo for SubstrateWeigh
         // Proof Size summary in bytes:
         //  Measured:  `101`
         //  Estimated: `6196`
-        // Minimum execution time: 30_067_000 picoseconds.
-        Weight::from_parts(30_908_000, 6196)
+        // Minimum execution time: 26_637_000 picoseconds.
+        Weight::from_parts(27_302_000, 6196)
             .saturating_add(T::DbWeight::get().reads(2_u64))
             .saturating_add(T::DbWeight::get().writes(2_u64))
     }
@@ -60,8 +60,8 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `101`
         //  Estimated: `6196`
-        // Minimum execution time: 30_067_000 picoseconds.
-        Weight::from_parts(30_908_000, 6196)
+        // Minimum execution time: 26_637_000 picoseconds.
+        Weight::from_parts(27_302_000, 6196)
             .saturating_add(RocksDbWeight::get().reads(2_u64))
             .saturating_add(RocksDbWeight::get().writes(2_u64))
     }
diff --git a/runtime/vara/src/weights/pallet_timestamp.rs b/runtime/vara/src/weights/pallet_timestamp.rs
index 47a61b07806..aa716bcc65c 100644
--- a/runtime/vara/src/weights/pallet_timestamp.rs
+++ b/runtime/vara/src/weights/pallet_timestamp.rs
@@ -19,7 +19,7 @@
 //! Autogenerated weights for pallet_timestamp
 //!
 //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
-//! DATE: 2023-08-01, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! DATE: 2023-08-07, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
 //! WORST CASE MAP SIZE: `1000000`
 //! CPU: `Intel(R) Xeon(R) Platinum 8375C CPU @ 2.90GHz`
 //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("vara-dev"), DB CACHE: 1024
@@ -48,8 +48,8 @@ impl<T: frame_system::Config> pallet_timestamp::WeightInfo for SubstrateWeight<T
         // Proof Size summary in bytes:
         //  Measured:  `175`
         //  Estimated: `2986`
-        // Minimum execution time: 8_009_000 picoseconds.
-        Weight::from_parts(8_413_000, 2986)
+        // Minimum execution time: 8_041_000 picoseconds.
+        Weight::from_parts(8_401_000, 2986)
             .saturating_add(T::DbWeight::get().reads(2_u64))
             .saturating_add(T::DbWeight::get().writes(1_u64))
     }
@@ -57,8 +57,8 @@ impl<T: frame_system::Config> pallet_timestamp::WeightInfo for SubstrateWeight<T
         // Proof Size summary in bytes:
         //  Measured:  `57`
         //  Estimated: `0`
-        // Minimum execution time: 3_111_000 picoseconds.
-        Weight::from_parts(3_251_000, 0)
+        // Minimum execution time: 3_188_000 picoseconds.
+        Weight::from_parts(3_357_000, 0)
     }
 }
 
@@ -68,8 +68,8 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `175`
         //  Estimated: `2986`
-        // Minimum execution time: 8_009_000 picoseconds.
-        Weight::from_parts(8_413_000, 2986)
+        // Minimum execution time: 8_041_000 picoseconds.
+        Weight::from_parts(8_401_000, 2986)
             .saturating_add(RocksDbWeight::get().reads(2_u64))
             .saturating_add(RocksDbWeight::get().writes(1_u64))
     }
@@ -77,7 +77,7 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `57`
         //  Estimated: `0`
-        // Minimum execution time: 3_111_000 picoseconds.
-        Weight::from_parts(3_251_000, 0)
+        // Minimum execution time: 3_188_000 picoseconds.
+        Weight::from_parts(3_357_000, 0)
     }
 }
diff --git a/runtime/vara/src/weights/pallet_utility.rs b/runtime/vara/src/weights/pallet_utility.rs
index 3f445f585ed..fe251a8c879 100644
--- a/runtime/vara/src/weights/pallet_utility.rs
+++ b/runtime/vara/src/weights/pallet_utility.rs
@@ -19,7 +19,7 @@
 //! Autogenerated weights for pallet_utility
 //!
 //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
-//! DATE: 2023-08-01, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! DATE: 2023-08-07, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
 //! WORST CASE MAP SIZE: `1000000`
 //! CPU: `Intel(R) Xeon(R) Platinum 8375C CPU @ 2.90GHz`
 //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("vara-dev"), DB CACHE: 1024
@@ -52,44 +52,44 @@ impl<T: frame_system::Config> pallet_utility::WeightInfo for SubstrateWeight<T>
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 5_350_000 picoseconds.
-        Weight::from_parts(8_163_155, 0)
-            // Standard Error: 2_074
-            .saturating_add(Weight::from_parts(4_084_858, 0).saturating_mul(c.into()))
+        // Minimum execution time: 5_390_000 picoseconds.
+        Weight::from_parts(15_138_158, 0)
+            // Standard Error: 2_071
+            .saturating_add(Weight::from_parts(3_958_890, 0).saturating_mul(c.into()))
     }
     fn as_derivative() -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 3_978_000 picoseconds.
-        Weight::from_parts(4_136_000, 0)
+        // Minimum execution time: 3_614_000 picoseconds.
+        Weight::from_parts(3_757_000, 0)
     }
     /// The range of component `c` is `[0, 1000]`.
     fn batch_all(c: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 5_406_000 picoseconds.
-        Weight::from_parts(9_180_867, 0)
-            // Standard Error: 2_030
-            .saturating_add(Weight::from_parts(4_259_130, 0).saturating_mul(c.into()))
+        // Minimum execution time: 5_187_000 picoseconds.
+        Weight::from_parts(12_724_758, 0)
+            // Standard Error: 1_830
+            .saturating_add(Weight::from_parts(4_146_725, 0).saturating_mul(c.into()))
     }
     fn dispatch_as() -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 7_029_000 picoseconds.
-        Weight::from_parts(7_246_000, 0)
+        // Minimum execution time: 6_937_000 picoseconds.
+        Weight::from_parts(7_217_000, 0)
     }
     /// The range of component `c` is `[0, 1000]`.
     fn force_batch(c: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 5_457_000 picoseconds.
-        Weight::from_parts(8_377_232, 0)
-            // Standard Error: 2_856
-            .saturating_add(Weight::from_parts(4_077_791, 0).saturating_mul(c.into()))
+        // Minimum execution time: 5_197_000 picoseconds.
+        Weight::from_parts(12_700_602, 0)
+            // Standard Error: 2_607
+            .saturating_add(Weight::from_parts(3_964_305, 0).saturating_mul(c.into()))
     }
 }
 
@@ -100,43 +100,43 @@ impl WeightInfo for () {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 5_350_000 picoseconds.
-        Weight::from_parts(8_163_155, 0)
-            // Standard Error: 2_074
-            .saturating_add(Weight::from_parts(4_084_858, 0).saturating_mul(c.into()))
+        // Minimum execution time: 5_390_000 picoseconds.
+        Weight::from_parts(15_138_158, 0)
+            // Standard Error: 2_071
+            .saturating_add(Weight::from_parts(3_958_890, 0).saturating_mul(c.into()))
     }
     fn as_derivative() -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 3_978_000 picoseconds.
-        Weight::from_parts(4_136_000, 0)
+        // Minimum execution time: 3_614_000 picoseconds.
+        Weight::from_parts(3_757_000, 0)
     }
     /// The range of component `c` is `[0, 1000]`.
     fn batch_all(c: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 5_406_000 picoseconds.
-        Weight::from_parts(9_180_867, 0)
-            // Standard Error: 2_030
-            .saturating_add(Weight::from_parts(4_259_130, 0).saturating_mul(c.into()))
+        // Minimum execution time: 5_187_000 picoseconds.
+        Weight::from_parts(12_724_758, 0)
+            // Standard Error: 1_830
+            .saturating_add(Weight::from_parts(4_146_725, 0).saturating_mul(c.into()))
     }
     fn dispatch_as() -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 7_029_000 picoseconds.
-        Weight::from_parts(7_246_000, 0)
+        // Minimum execution time: 6_937_000 picoseconds.
+        Weight::from_parts(7_217_000, 0)
     }
     /// The range of component `c` is `[0, 1000]`.
     fn force_batch(c: u32, ) -> Weight {
         // Proof Size summary in bytes:
         //  Measured:  `0`
         //  Estimated: `0`
-        // Minimum execution time: 5_457_000 picoseconds.
-        Weight::from_parts(8_377_232, 0)
-            // Standard Error: 2_856
-            .saturating_add(Weight::from_parts(4_077_791, 0).saturating_mul(c.into()))
+        // Minimum execution time: 5_197_000 picoseconds.
+        Weight::from_parts(12_700_602, 0)
+            // Standard Error: 2_607
+            .saturating_add(Weight::from_parts(3_964_305, 0).saturating_mul(c.into()))
     }
 }
diff --git a/sandbox/env/Cargo.toml b/sandbox/env/Cargo.toml
index 3d9138e7321..844eaa9bc90 100644
--- a/sandbox/env/Cargo.toml
+++ b/sandbox/env/Cargo.toml
@@ -15,6 +15,7 @@ targets = ["x86_64-unknown-linux-gnu"]
 codec.workspace = true
 sp-core.workspace = true
 sp-std.workspace = true
+sp-wasm-interface = { workspace = true, default-features = false }
 
 [features]
 default = ["std"]
@@ -22,4 +23,5 @@ std = [
 	"codec/std",
 	"sp-core/std",
 	"sp-std/std",
+	"sp-wasm-interface/std",
 ]
diff --git a/sandbox/env/src/lib.rs b/sandbox/env/src/lib.rs
index aacbcf9c3bd..7c344495963 100644
--- a/sandbox/env/src/lib.rs
+++ b/sandbox/env/src/lib.rs
@@ -21,9 +21,20 @@
 #![cfg_attr(not(feature = "std"), no_std)]
 
 use codec::{Decode, Encode};
-
 use sp_core::RuntimeDebug;
 use sp_std::vec::Vec;
+use sp_wasm_interface::ReturnValue;
+
+#[derive(Clone, Copy, Debug)]
+pub enum Instantiate {
+    /// The first version of instantiate method and syscalls.
+    Version1,
+    /// The second version of syscalls changes their signatures to
+    /// accept global gas value as its first argument and return the remaining
+    /// gas value as its first result tuple element. The approach eliminates
+    /// redundant host calls to get/set WASM-global value.
+    Version2,
+}
 
 /// Error error that can be returned from host function.
 #[derive(Encode, Decode, RuntimeDebug)]
@@ -108,6 +119,20 @@ pub const ERROR_GLOBALS_NOT_FOUND: u32 = u32::MAX;
 /// For FFI purposes.
 pub const ERROR_GLOBALS_OTHER: u32 = u32::MAX - 1;
 
+/// Typed value that can be returned from a wasm function
+/// through the dispatch thunk.
+/// Additionally contains globals values.
+#[derive(Clone, Copy, PartialEq, Encode, Decode, Debug)]
+#[codec(crate = codec)]
+pub struct WasmReturnValue {
+    pub gas: i64,
+    pub inner: ReturnValue,
+}
+
+impl WasmReturnValue {
+    pub const ENCODED_MAX_SIZE: usize = 8 + ReturnValue::ENCODED_MAX_SIZE;
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
diff --git a/sandbox/host/src/sandbox.rs b/sandbox/host/src/sandbox.rs
index 4cafa6502a6..5c67022d847 100644
--- a/sandbox/host/src/sandbox.rs
+++ b/sandbox/host/src/sandbox.rs
@@ -26,6 +26,7 @@ mod wasmi_backend;
 use std::{collections::HashMap, pin::Pin, rc::Rc};
 
 use codec::Decode;
+use env::Instantiate;
 use gear_sandbox_env as sandbox_env;
 use sp_wasm_interface::{Pointer, WordSize};
 
@@ -629,6 +630,7 @@ impl<DT: Clone> Store<DT> {
     /// Returns uninitialized sandboxed module instance or an instantiation error.
     pub fn instantiate(
         &mut self,
+        version: Instantiate,
         wasm: &[u8],
         guest_env: GuestEnvironment,
         sandbox_context: &mut dyn SandboxContext,
@@ -637,7 +639,7 @@ impl<DT: Clone> Store<DT> {
             BackendContext::Wasmi => wasmi_instantiate(wasm, guest_env, sandbox_context)?,
 
             BackendContext::Wasmer(ref context) => {
-                wasmer_instantiate(context, wasm, guest_env, sandbox_context)?
+                wasmer_instantiate(version, context, wasm, guest_env, sandbox_context)?
             }
         };
 
diff --git a/sandbox/host/src/sandbox/wasmer_backend.rs b/sandbox/host/src/sandbox/wasmer_backend.rs
index 3bea2d8505b..9d2531cea84 100644
--- a/sandbox/host/src/sandbox/wasmer_backend.rs
+++ b/sandbox/host/src/sandbox/wasmer_backend.rs
@@ -20,10 +20,10 @@
 
 use std::{cell::RefCell, collections::HashMap, rc::Rc};
 
-use wasmer::RuntimeError;
+use wasmer::{Exportable, RuntimeError};
 
 use codec::{Decode, Encode};
-use gear_sandbox_env::HostError;
+use gear_sandbox_env::{HostError, Instantiate, WasmReturnValue};
 use sp_wasm_interface::{util, Pointer, ReturnValue, Value, WordSize};
 
 use crate::{
@@ -69,6 +69,39 @@ impl Backend {
     }
 }
 
+#[derive(Default)]
+pub struct Env {
+    gas: Option<wasmer::Global>,
+}
+
+// WARNING: intentionally to avoid cyclic refs
+impl Clone for Env {
+    fn clone(&self) -> Self {
+        Self {
+            gas: self.gas.clone().map(|mut global| {
+                global.into_weak_instance_ref();
+
+                global
+            }),
+        }
+    }
+}
+
+// TODO #3057
+pub const GLOBAL_NAME_GAS: &str = "gear_gas";
+
+impl wasmer::WasmerEnv for Env {
+    fn init_with_instance(
+        &mut self,
+        instance: &wasmer::Instance,
+    ) -> std::result::Result<(), wasmer::HostEnvInitError> {
+        let gas: wasmer::Global = instance.exports.get_with_generics_weak(GLOBAL_NAME_GAS)?;
+        self.gas = Some(gas);
+
+        Ok(())
+    }
+}
+
 /// Invoke a function within a sandboxed module
 pub fn invoke(
     instance: &wasmer::Instance,
@@ -152,6 +185,7 @@ fn try_to_store_module_in_cache(mut fs_cache: FileSystemCache, code_hash: Hash,
 
 /// Instantiate a module within a sandbox context
 pub fn instantiate(
+    version: Instantiate,
     context: &Backend,
     wasm: &[u8],
     guest_env: GuestEnvironment,
@@ -240,7 +274,14 @@ pub fn instantiate(
                     .func_by_guest_index(guest_func_index)
                     .ok_or(InstantiationError::ModuleDecoding)?;
 
-                let function = dispatch_function(supervisor_func_index, &context.store, func_ty);
+                let function = match version {
+                    Instantiate::Version1 => {
+                        dispatch_function(supervisor_func_index, &context.store, func_ty)
+                    }
+                    Instantiate::Version2 => {
+                        dispatch_function_v2(supervisor_func_index, &context.store, func_ty)
+                    }
+                };
 
                 let exports = exports_map
                     .entry(import.module().to_string())
@@ -277,6 +318,7 @@ pub fn instantiate(
     })
 }
 
+// TODO #3067
 fn dispatch_function(
     supervisor_func_index: SupervisorFuncIndex,
     store: &wasmer::Store,
@@ -341,6 +383,7 @@ fn dispatch_function(
 
             let serialized_result = serialized_result?;
 
+            // TODO #3038
             // dispatch_thunk returns pointer to serialized arguments.
             // Unpack pointer and len of the serialized result data.
             let (serialized_result_val_ptr, serialized_result_val_len) = {
@@ -386,6 +429,125 @@ fn dispatch_function(
     })
 }
 
+// TODO #3067
+fn dispatch_function_v2(
+    supervisor_func_index: SupervisorFuncIndex,
+    store: &wasmer::Store,
+    func_ty: &wasmer::FunctionType,
+) -> wasmer::Function {
+    wasmer::Function::new_with_env(store, func_ty, Env::default(), move |env, params| {
+        SandboxContextStore::with(|sandbox_context| {
+            let gas = env
+                .gas
+                .as_ref()
+                .ok_or_else(|| RuntimeError::new("gas global should be set"))?;
+
+            // Serialize arguments into a byte vector.
+            let invoke_args_data = [gas.get()]
+                .iter()
+                .chain(params.iter())
+                .map(|val| match val {
+                    wasmer::Val::I32(val) => Ok(Value::I32(*val)),
+                    wasmer::Val::I64(val) => Ok(Value::I64(*val)),
+                    wasmer::Val::F32(val) => Ok(Value::F32(f32::to_bits(*val))),
+                    wasmer::Val::F64(val) => Ok(Value::F64(f64::to_bits(*val))),
+                    _ => Err(RuntimeError::new(format!(
+                        "Unsupported function argument: {:?}",
+                        val
+                    ))),
+                })
+                .collect::<std::result::Result<Vec<_>, _>>()?
+                .encode();
+
+            // Move serialized arguments inside the memory, invoke dispatch thunk and
+            // then free allocated memory.
+            let invoke_args_len = invoke_args_data.len() as WordSize;
+            let invoke_args_ptr =
+                sandbox_context
+                    .allocate_memory(invoke_args_len)
+                    .map_err(|_| {
+                        RuntimeError::new("Can't allocate memory in supervisor for the arguments")
+                    })?;
+
+            let deallocate = |fe: &mut dyn SandboxContext, ptr, fail_msg| {
+                fe.deallocate_memory(ptr)
+                    .map_err(|_| RuntimeError::new(fail_msg))
+            };
+
+            if sandbox_context
+                .write_memory(invoke_args_ptr, &invoke_args_data)
+                .is_err()
+            {
+                deallocate(
+                    sandbox_context,
+                    invoke_args_ptr,
+                    "Failed dealloction after failed write of invoke arguments",
+                )?;
+
+                return Err(RuntimeError::new("Can't write invoke args into memory"));
+            }
+
+            // Perform the actuall call
+            let serialized_result = sandbox_context
+                .invoke(invoke_args_ptr, invoke_args_len, supervisor_func_index)
+                .map_err(|e| RuntimeError::new(e.to_string()));
+
+            deallocate(
+                sandbox_context,
+                invoke_args_ptr,
+                "Failed dealloction after invoke",
+            )?;
+
+            let serialized_result = serialized_result?;
+
+            // TODO #3038
+            // dispatch_thunk returns pointer to serialized arguments.
+            // Unpack pointer and len of the serialized result data.
+            let (serialized_result_val_ptr, serialized_result_val_len) = {
+                // Cast to u64 to use zero-extension.
+                let v = serialized_result as u64;
+                let ptr = (v >> 32) as u32;
+                let len = (v & 0xFFFFFFFF) as u32;
+                (Pointer::new(ptr), len)
+            };
+
+            let serialized_result_val = sandbox_context
+                .read_memory(serialized_result_val_ptr, serialized_result_val_len)
+                .map_err(|_| {
+                    RuntimeError::new("Can't read the serialized result from dispatch thunk")
+                });
+
+            deallocate(
+                sandbox_context,
+                serialized_result_val_ptr,
+                "Can't deallocate memory for dispatch thunk's result",
+            )?;
+
+            let serialized_result_val = serialized_result_val?;
+
+            let deserialized_result = std::result::Result::<WasmReturnValue, HostError>::decode(
+                &mut serialized_result_val.as_slice(),
+            )
+            .map_err(|_| RuntimeError::new("Decoding Result<WasmReturnValue, HostError> failed!"))?
+            .map_err(|_| RuntimeError::new("Supervisor function returned sandbox::HostError"))?;
+
+            let result = match deserialized_result.inner {
+                ReturnValue::Value(Value::I32(val)) => vec![wasmer::Val::I32(val)],
+                ReturnValue::Value(Value::I64(val)) => vec![wasmer::Val::I64(val)],
+                ReturnValue::Value(Value::F32(val)) => vec![wasmer::Val::F32(f32::from_bits(val))],
+                ReturnValue::Value(Value::F64(val)) => vec![wasmer::Val::F64(f64::from_bits(val))],
+
+                ReturnValue::Unit => vec![],
+            };
+
+            gas.set(wasmer::Val::I64(deserialized_result.gas))?;
+
+            Ok(result)
+        })
+        .expect("SandboxContextStore is set when invoking sandboxed functions; qed")
+    })
+}
+
 /// Allocate new memory region
 pub fn new_memory(
     context: &Backend,
diff --git a/sandbox/sandbox/src/embedded_executor.rs b/sandbox/sandbox/src/embedded_executor.rs
index 76b48c1ea94..79d9ec396fb 100644
--- a/sandbox/sandbox/src/embedded_executor.rs
+++ b/sandbox/sandbox/src/embedded_executor.rs
@@ -137,7 +137,7 @@ impl<'a, T> Externals for GuestExternals<'a, T> {
 
         let result = (self.defined_host_functions.funcs[index])(self.state, &args);
         match result {
-            Ok(value) => Ok(match value {
+            Ok(value) => Ok(match value.inner {
                 ReturnValue::Value(v) => Some(to_wasmi(v)),
                 ReturnValue::Unit => None,
             }),
@@ -282,24 +282,9 @@ pub struct Instance<T> {
     _marker: PhantomData<T>,
 }
 
-/// Unit-type as InstanceGlobals for wasmi executor.
-#[derive(Clone, Default)]
-pub struct InstanceGlobals;
-
-impl super::InstanceGlobals for InstanceGlobals {
-    fn get_global_val(&self, _name: &str) -> Option<Value> {
-        None
-    }
-
-    fn set_global_val(&self, _name: &str, _value: Value) -> Result<(), super::GlobalsSetError> {
-        Err(super::GlobalsSetError::NotFound)
-    }
-}
-
 impl<T> super::SandboxInstance<T> for Instance<T> {
     type Memory = Memory;
     type EnvironmentBuilder = EnvironmentDefinitionBuilder<T>;
-    type InstanceGlobals = InstanceGlobals;
 
     fn new(
         code: &[u8],
@@ -350,8 +335,8 @@ impl<T> super::SandboxInstance<T> for Instance<T> {
         Some(to_interface(global))
     }
 
-    fn instance_globals(&self) -> Option<Self::InstanceGlobals> {
-        None
+    fn set_global_val(&self, _name: &str, _value: Value) -> Result<(), crate::GlobalsSetError> {
+        Err(crate::GlobalsSetError::NotFound)
     }
 
     fn get_instance_ptr(&self) -> HostPointer {
@@ -384,37 +369,50 @@ mod tests {
     use super::{EnvironmentDefinitionBuilder, Instance};
     use crate::{Error, HostError, ReturnValue, SandboxEnvironmentBuilder, SandboxInstance, Value};
     use assert_matches::assert_matches;
+    use gear_sandbox_env::WasmReturnValue;
 
     fn execute_sandboxed(code: &[u8], args: &[Value]) -> Result<ReturnValue, HostError> {
         struct State {
             counter: u32,
         }
 
-        fn env_assert(_e: &mut State, args: &[Value]) -> Result<ReturnValue, HostError> {
+        fn env_assert(_e: &mut State, args: &[Value]) -> Result<WasmReturnValue, HostError> {
             if args.len() != 1 {
                 return Err(HostError);
             }
             let condition = args[0].as_i32().ok_or(HostError)?;
             if condition != 0 {
-                Ok(ReturnValue::Unit)
+                Ok(WasmReturnValue {
+                    gas: 0,
+                    inner: ReturnValue::Unit,
+                })
             } else {
                 Err(HostError)
             }
         }
-        fn env_inc_counter(e: &mut State, args: &[Value]) -> Result<ReturnValue, HostError> {
+        fn env_inc_counter(e: &mut State, args: &[Value]) -> Result<WasmReturnValue, HostError> {
             if args.len() != 1 {
                 return Err(HostError);
             }
             let inc_by = args[0].as_i32().ok_or(HostError)?;
             e.counter += inc_by as u32;
-            Ok(ReturnValue::Value(Value::I32(e.counter as i32)))
+            Ok(WasmReturnValue {
+                gas: 0,
+                inner: ReturnValue::Value(Value::I32(e.counter as i32)),
+            })
         }
         /// Function that takes one argument of any type and returns that value.
-        fn env_polymorphic_id(_e: &mut State, args: &[Value]) -> Result<ReturnValue, HostError> {
+        fn env_polymorphic_id(
+            _e: &mut State,
+            args: &[Value],
+        ) -> Result<WasmReturnValue, HostError> {
             if args.len() != 1 {
                 return Err(HostError);
             }
-            Ok(ReturnValue::Value(args[0]))
+            Ok(WasmReturnValue {
+                gas: 0,
+                inner: ReturnValue::Value(args[0]),
+            })
         }
 
         let mut state = State { counter: 0 };
@@ -525,8 +523,11 @@ mod tests {
 
     #[test]
     fn cant_return_unmatching_type() {
-        fn env_returns_i32(_e: &mut (), _args: &[Value]) -> Result<ReturnValue, HostError> {
-            Ok(ReturnValue::Value(Value::I32(42)))
+        fn env_returns_i32(_e: &mut (), _args: &[Value]) -> Result<WasmReturnValue, HostError> {
+            Ok(WasmReturnValue {
+                gas: 0,
+                inner: ReturnValue::Value(Value::I32(42)),
+            })
         }
 
         let mut env_builder = EnvironmentDefinitionBuilder::new();
diff --git a/sandbox/sandbox/src/host_executor.rs b/sandbox/sandbox/src/host_executor.rs
index 34bc0f9b7c3..a73b6b17cc9 100644
--- a/sandbox/sandbox/src/host_executor.rs
+++ b/sandbox/sandbox/src/host_executor.rs
@@ -20,12 +20,12 @@
 
 use codec::{Decode, Encode};
 
+use crate::{env, Error, HostFuncType, ReturnValue, Value};
 use gear_runtime_interface::sandbox;
+use gear_sandbox_env::WasmReturnValue;
 use sp_std::{marker, mem, prelude::*, rc::Rc, slice, vec};
 use sp_wasm_interface::HostPointer;
 
-use crate::{env, Error, HostFuncType, ReturnValue, Value};
-
 mod ffi {
     use super::HostFuncType;
     use sp_std::mem;
@@ -190,29 +190,6 @@ pub struct Instance<T> {
     _marker: marker::PhantomData<T>,
 }
 
-#[derive(Clone, Default)]
-pub struct InstanceGlobals {
-    instance_idx: Option<u32>,
-}
-
-impl super::InstanceGlobals for InstanceGlobals {
-    fn get_global_val(&self, name: &str) -> Option<Value> {
-        self.instance_idx
-            .and_then(|i| sandbox::get_global_val(i, name))
-    }
-
-    fn set_global_val(&self, name: &str, value: Value) -> Result<(), super::GlobalsSetError> {
-        match self.instance_idx {
-            None => Err(super::GlobalsSetError::Other),
-            Some(i) => match sandbox::set_global_val(i, name, value) {
-                env::ERROR_GLOBALS_OK => Ok(()),
-                env::ERROR_GLOBALS_NOT_FOUND => Err(super::GlobalsSetError::NotFound),
-                _ => Err(super::GlobalsSetError::Other),
-            },
-        }
-    }
-}
-
 /// The primary responsibility of this thunk is to deserialize arguments and
 /// call the original function, specified by the index.
 extern "C" fn dispatch_thunk<T>(
@@ -243,8 +220,9 @@ extern "C" fn dispatch_thunk<T>(
         // This should be safe since mutable reference to T is passed upon the invocation.
         let state = &mut *(state as *mut T);
 
+        let mut result = Vec::with_capacity(WasmReturnValue::ENCODED_MAX_SIZE);
         // Pass control flow to the designated function.
-        let result = f(state, &args).encode();
+        f(state, &args).encode_to(&mut result);
 
         // Leak the result vector and return the pointer to return data.
         let result_ptr = result.as_ptr() as u64;
@@ -258,7 +236,6 @@ extern "C" fn dispatch_thunk<T>(
 impl<T> super::SandboxInstance<T> for Instance<T> {
     type Memory = Memory;
     type EnvironmentBuilder = EnvironmentDefinitionBuilder<T>;
-    type InstanceGlobals = InstanceGlobals;
 
     fn new(
         code: &[u8],
@@ -318,10 +295,12 @@ impl<T> super::SandboxInstance<T> for Instance<T> {
         sandbox::get_global_val(self.instance_idx, name)
     }
 
-    fn instance_globals(&self) -> Option<Self::InstanceGlobals> {
-        Some(InstanceGlobals {
-            instance_idx: Some(self.instance_idx),
-        })
+    fn set_global_val(&self, name: &str, value: Value) -> Result<(), super::GlobalsSetError> {
+        match sandbox::set_global_val(self.instance_idx, name, value) {
+            env::ERROR_GLOBALS_OK => Ok(()),
+            env::ERROR_GLOBALS_NOT_FOUND => Err(super::GlobalsSetError::NotFound),
+            _ => Err(super::GlobalsSetError::Other),
+        }
     }
 
     fn get_instance_ptr(&self) -> HostPointer {
diff --git a/sandbox/sandbox/src/lib.rs b/sandbox/sandbox/src/lib.rs
index ccbf1be9969..446a53bc089 100644
--- a/sandbox/sandbox/src/lib.rs
+++ b/sandbox/sandbox/src/lib.rs
@@ -50,7 +50,7 @@ use sp_core::RuntimeDebug;
 use sp_std::prelude::*;
 
 use sp_wasm_interface::HostPointer;
-pub use sp_wasm_interface::{ReturnValue, Value};
+pub use sp_wasm_interface::{IntoValue, ReturnValue, Value};
 
 #[cfg(feature = "std")]
 pub use self::embedded_executor as default_executor;
@@ -89,7 +89,7 @@ impl From<Error> for HostError {
 /// supervisor in [`EnvironmentDefinitionBuilder`].
 ///
 /// [`EnvironmentDefinitionBuilder`]: struct.EnvironmentDefinitionBuilder.html
-pub type HostFuncType<T> = fn(&mut T, &[Value]) -> Result<ReturnValue, HostError>;
+pub type HostFuncType<T> = fn(&mut T, &[Value]) -> Result<env::WasmReturnValue, HostError>;
 
 /// Reference to a sandboxed linear memory, that
 /// will be used by the guest module.
@@ -161,6 +161,16 @@ pub trait SandboxEnvironmentBuilder<State, Memory>: Sized {
         N2: Into<Vec<u8>>;
 }
 
+/// Error that can occur while using this crate.
+#[derive(RuntimeDebug)]
+pub enum GlobalsSetError {
+    /// A global variable is not found.
+    NotFound,
+
+    /// A global variable is immutable or has a different type.
+    Other,
+}
+
 /// Sandboxed instance of a wasm module.
 ///
 /// This instance can be used for invoking exported functions.
@@ -171,9 +181,6 @@ pub trait SandboxInstance<State>: Sized {
     /// The environment builder used to construct this sandbox.
     type EnvironmentBuilder: SandboxEnvironmentBuilder<State, Self::Memory>;
 
-    /// The globals type used for this sandbox to change globals.
-    type InstanceGlobals: InstanceGlobals;
-
     /// Instantiate a module with the given [`EnvironmentDefinitionBuilder`]. It will
     /// run the `start` function (if it is present in the module) with the given `state`.
     ///
@@ -211,32 +218,9 @@ pub trait SandboxInstance<State>: Sized {
     /// Returns `Some(_)` if the global could be found.
     fn get_global_val(&self, name: &str) -> Option<Value>;
 
-    /// Get the instance providing access to exported globals.
-    ///
-    /// Returns `None` if the executor doesn't support the interface.
-    fn instance_globals(&self) -> Option<Self::InstanceGlobals>;
+    /// Set the value of a global with the given `name`.
+    fn set_global_val(&self, name: &str, value: Value) -> Result<(), GlobalsSetError>;
 
     /// Get raw pointer to the executor host sandbox instance.
     fn get_instance_ptr(&self) -> HostPointer;
 }
-
-/// Error that can occur while using this crate.
-#[derive(RuntimeDebug)]
-pub enum GlobalsSetError {
-    /// A global variable is not found.
-    NotFound,
-
-    /// A global variable is immutable or has a different type.
-    Other,
-}
-
-/// This instance can be used for changing exported globals.
-pub trait InstanceGlobals: Sized + Clone {
-    /// Get the value from a global with the given `name`.
-    ///
-    /// Returns `Some(_)` if the global could be found.
-    fn get_global_val(&self, name: &str) -> Option<Value>;
-
-    /// Set the value of a global with the given `name`.
-    fn set_global_val(&self, name: &str, value: Value) -> Result<(), GlobalsSetError>;
-}
diff --git a/utils/wasm-instrument/src/lib.rs b/utils/wasm-instrument/src/lib.rs
index f3c04017d87..fe38b421e86 100644
--- a/utils/wasm-instrument/src/lib.rs
+++ b/utils/wasm-instrument/src/lib.rs
@@ -40,6 +40,7 @@ mod tests;
 pub mod rules;
 pub mod syscalls;
 
+// TODO #3057
 pub const GLOBAL_NAME_GAS: &str = "gear_gas";
 pub const GLOBAL_NAME_FLAGS: &str = "gear_flags";
 
diff --git a/utils/wasm-proc/src/main.rs b/utils/wasm-proc/src/main.rs
index 2a536a941f1..cac6e012ced 100644
--- a/utils/wasm-proc/src/main.rs
+++ b/utils/wasm-proc/src/main.rs
@@ -21,7 +21,7 @@ use gear_wasm_builder::optimize::{self, OptType, Optimizer};
 use parity_wasm::elements::External;
 use std::{collections::HashSet, fs, path::PathBuf};
 
-const RT_ALLOWED_IMPORTS: [&str; 63] = [
+const RT_ALLOWED_IMPORTS: [&str; 64] = [
     // From `Allocator` (substrate/primitives/io/src/lib.rs)
     "ext_allocator_free_version_1",
     "ext_allocator_malloc_version_1",
@@ -73,6 +73,7 @@ const RT_ALLOWED_IMPORTS: [&str; 63] = [
     "ext_sandbox_set_global_val_version_1",
     "ext_sandbox_instance_teardown_version_1",
     "ext_sandbox_instantiate_version_1",
+    "ext_sandbox_instantiate_version_2",
     "ext_sandbox_invoke_version_1",
     "ext_sandbox_memory_get_version_1",
     "ext_sandbox_memory_grow_version_1",