From 4ce0bffd4e8da4b813d2aa695a915b42bc7637ca Mon Sep 17 00:00:00 2001 From: Mihai Calin Luca Date: Mon, 4 Mar 2024 11:41:07 +0100 Subject: [PATCH 1/6] recommit --- .../abi_tester_expected_main.abi.json | 17 + .../abi_tester_expected_view.abi.json | 17 + .../abi-tester/src/abi_test_type.rs | 7 +- .../abi-tester/src/abi_tester.rs | 6 +- .../scenarios/managed_decimal.scen.json | 146 +++++++ .../basic-features/src/basic_features_main.rs | 4 + .../basic-features/src/egld_decimal.rs | 11 + .../src/managed_decimal_features.rs | 43 ++ .../tests/basic_features_egld_decimal_test.rs | 71 ++++ .../basic_features_managed_decimal_test.rs | 18 + .../basic-features/wasm/src/lib.rs | 10 +- .../tests/big_float_scenario_rs_test.rs | 47 ++- .../src/api/managed_types/const_handles.rs | 14 +- .../src/api/managed_types/static_var_api.rs | 4 + .../uncallable/static_var_api_uncallable.rs | 8 + .../wrappers/call_value_wrapper.rs | 12 +- .../base/src/types/managed/basic/big_float.rs | 6 +- .../wrapped/egld_or_esdt_token_identifier.rs | 3 +- .../types/managed/wrapped/managed_decimal.rs | 382 ++++++++++++++++++ .../base/src/types/managed/wrapped/mod.rs | 2 + .../types/managed/wrapped/token_identifier.rs | 3 +- .../src/api/local_api_vh/static_var_api_vh.rs | 10 + .../src/debug_executor/tx_static_vars.rs | 3 + .../scenario/tests/managed_decimal_test.rs | 129 ++++++ .../scenario/tests/managed_type_debug_test.rs | 16 +- framework/scenario/tests/test_print_api.rs | 6 +- framework/snippets/src/interactor_vm_query.rs | 1 + .../api/managed_types/static_var_api_node.rs | 12 + 28 files changed, 985 insertions(+), 23 deletions(-) create mode 100644 contracts/feature-tests/basic-features/scenarios/managed_decimal.scen.json create mode 100644 contracts/feature-tests/basic-features/src/egld_decimal.rs create mode 100644 contracts/feature-tests/basic-features/src/managed_decimal_features.rs create mode 100644 contracts/feature-tests/basic-features/tests/basic_features_egld_decimal_test.rs create mode 100644 contracts/feature-tests/basic-features/tests/basic_features_managed_decimal_test.rs create mode 100644 framework/base/src/types/managed/wrapped/managed_decimal.rs create mode 100644 framework/scenario/tests/managed_decimal_test.rs diff --git a/contracts/feature-tests/abi-tester/abi_tester_expected_main.abi.json b/contracts/feature-tests/abi-tester/abi_tester_expected_main.abi.json index 430deb54a5..69829a2e6a 100644 --- a/contracts/feature-tests/abi-tester/abi_tester_expected_main.abi.json +++ b/contracts/feature-tests/abi-tester/abi_tester_expected_main.abi.json @@ -454,6 +454,14 @@ { "ticker": "ExplicitDiscriminantMixed", "type": "ExplicitDiscriminantMixed" + }, + { + "ticker": "ManagedDecimalVar", + "type": "ManagedDecimal" + }, + { + "ticker": "ManagedDecimalConst", + "type": "ManagedDecimalWrapper" } ], "hasCallback": false, @@ -770,6 +778,15 @@ } ] }, + "ManagedDecimalWrapper": { + "type": "struct", + "fields": [ + { + "name": "field", + "type": "ManagedDecimal<2>" + } + ] + }, "OnlyShowsUpAsNested01": { "type": "struct", "docs": [ diff --git a/contracts/feature-tests/abi-tester/abi_tester_expected_view.abi.json b/contracts/feature-tests/abi-tester/abi_tester_expected_view.abi.json index fed675f693..7e9bcc8037 100644 --- a/contracts/feature-tests/abi-tester/abi_tester_expected_view.abi.json +++ b/contracts/feature-tests/abi-tester/abi_tester_expected_view.abi.json @@ -131,6 +131,14 @@ { "ticker": "ExplicitDiscriminantMixed", "type": "ExplicitDiscriminantMixed" + }, + { + "ticker": "ManagedDecimalVar", + "type": "ManagedDecimal" + }, + { + "ticker": "ManagedDecimalConst", + "type": "ManagedDecimalWrapper" } ], "hasCallback": false, @@ -447,6 +455,15 @@ } ] }, + "ManagedDecimalWrapper": { + "type": "struct", + "fields": [ + { + "name": "field", + "type": "ManagedDecimal<2>" + } + ] + }, "OnlyShowsUpAsNested01": { "type": "struct", "docs": [ diff --git a/contracts/feature-tests/abi-tester/src/abi_test_type.rs b/contracts/feature-tests/abi-tester/src/abi_test_type.rs index 2cc1fc4db4..6ff0fc3de9 100644 --- a/contracts/feature-tests/abi-tester/src/abi_test_type.rs +++ b/contracts/feature-tests/abi-tester/src/abi_test_type.rs @@ -1,7 +1,7 @@ use crate::only_nested::*; use multiversx_sc::{ api::ManagedTypeApi, - types::{BigUint, Box, ManagedBuffer}, + types::{BigUint, Box, ConstDecimals, ManagedBuffer, ManagedDecimal}, }; multiversx_sc::derive_imports!(); @@ -38,3 +38,8 @@ pub struct AbiManagedVecItem { pub struct OnlyShowsUpInEsdtAttr { pub field: OnlyShowsUpAsNested10, } + +#[derive(TypeAbi)] +pub struct ManagedDecimalWrapper { + pub field: ManagedDecimal>, +} diff --git a/contracts/feature-tests/abi-tester/src/abi_tester.rs b/contracts/feature-tests/abi-tester/src/abi_tester.rs index a68ea341a3..ce0b6f82b7 100644 --- a/contracts/feature-tests/abi-tester/src/abi_tester.rs +++ b/contracts/feature-tests/abi-tester/src/abi_tester.rs @@ -22,8 +22,10 @@ use only_nested::*; #[esdt_attribute("STRUCT1", AbiEnum)] #[esdt_attribute("STRUCT2", AbiManagedType)] #[esdt_attribute("OnlyInEsdt", OnlyShowsUpInEsdtAttr)] -#[esdt_attribute["ExplicitDiscriminant", ExplicitDiscriminant]] -#[esdt_attribute["ExplicitDiscriminantMixed", ExplicitDiscriminantMixed]] +#[esdt_attribute("ExplicitDiscriminant", ExplicitDiscriminant)] +#[esdt_attribute("ExplicitDiscriminantMixed", ExplicitDiscriminantMixed)] +#[esdt_attribute("ManagedDecimalVar", ManagedDecimal)] +#[esdt_attribute("ManagedDecimalConst", ManagedDecimalWrapper)] pub trait AbiTester { /// Contract constructor. #[init] diff --git a/contracts/feature-tests/basic-features/scenarios/managed_decimal.scen.json b/contracts/feature-tests/basic-features/scenarios/managed_decimal.scen.json new file mode 100644 index 0000000000..e19612ae29 --- /dev/null +++ b/contracts/feature-tests/basic-features/scenarios/managed_decimal.scen.json @@ -0,0 +1,146 @@ +{ + "steps": [ + { + "step": "setState", + "accounts": { + "sc:basic-features": { + "nonce": "0", + "balance": "0", + "code": "mxsc:../output/basic-features.mxsc.json" + }, + "address:an_account": { + "nonce": "0", + "balance": "0" + } + } + }, + { + "step": "scCall", + "id": "1", + "tx": { + "from": "address:an_account", + "to": "sc:basic-features", + "function": "managed_decimal_addition", + "arguments": [ + "4", + "5" + ], + "gasLimit": "1,000,000,000,000", + "gasPrice": "0" + }, + "expect": { + "out": [ + "9" + ] + } + }, + { + "step": "scCall", + "id": "1", + "tx": { + "from": "address:an_account", + "to": "sc:basic-features", + "function": "managed_decimal_subtraction", + "arguments": [ + "9", + "4" + ], + "gasLimit": "1,000,000,000,000", + "gasPrice": "0" + }, + "expect": { + "out": [ + "5" + ] + } + }, + { + "step": "scCall", + "id": "2", + "tx": { + "from": "address:an_account", + "to": "sc:basic-features", + "function": "managed_decimal_subtraction", + "arguments": [ + "2", + "8" + ], + "gasLimit": "1,000,000,000,000", + "gasPrice": "0" + }, + "expect": { + "out": [], + "status": "4", + "message": "str:cannot subtract because result would be negative", + "gas": "*", + "refund": "*" + } + }, + { + "step": "scCall", + "id": "3", + "tx": { + "from": "address:an_account", + "to": "sc:basic-features", + "function": "managed_decimal_eq", + "arguments": [ + "13", + "13" + ], + "gasLimit": "1,000,000,000,000", + "gasPrice": "0" + }, + "expect": { + "out": [ + "0x01" + ], + "status": "", + "message": "*", + "gas": "*", + "refund": "*" + } + }, + { + "step": "scCall", + "id": "4", + "tx": { + "from": "address:an_account", + "to": "sc:basic-features", + "function": "managed_decimal_trunc", + "arguments": [], + "gasLimit": "1,000,000,000,000", + "gasPrice": "0" + }, + "expect": { + "out": [ + "313" + ], + "status": "", + "message": "*", + "gas": "*", + "refund": "*" + } + }, + { + "step": "scCall", + "id": "5", + "tx": { + "from": "address:an_account", + "to": "sc:basic-features", + "function": "managed_decimal_into_raw_units", + "arguments": [], + "gasLimit": "1,000,000,000,000", + "gasPrice": "0" + }, + "expect": { + "out": [ + "12345" + ], + "status": "", + "message": "*", + "gas": "*", + "refund": "*" + } + } + ] +} \ No newline at end of file diff --git a/contracts/feature-tests/basic-features/src/basic_features_main.rs b/contracts/feature-tests/basic-features/src/basic_features_main.rs index 2be5e1a535..3ce78bc679 100644 --- a/contracts/feature-tests/basic-features/src/basic_features_main.rs +++ b/contracts/feature-tests/basic-features/src/basic_features_main.rs @@ -11,11 +11,13 @@ pub mod codec_err_test; pub mod crypto_features; pub mod echo; pub mod echo_managed; +pub mod egld_decimal; pub mod elliptic_curve_features; pub mod event_features; pub mod macro_features; pub mod managed_address_features; pub mod managed_buffer_features; +pub mod managed_decimal_features; pub mod managed_vec_features; pub mod non_zero_features; pub mod small_num_overflow_test_ops; @@ -76,8 +78,10 @@ pub trait BasicFeatures: + small_num_overflow_test_ops::SmallIntOverflow + token_identifier_features::TokenIdentifierFeatures + non_zero_features::TypeFeatures + + egld_decimal::EgldDecimal + multiversx_sc_modules::default_issue_callbacks::DefaultIssueCallbacksModule + storage_mapper_get_at_address::StorageMapperGetAtAddress + + managed_decimal_features::ManagedDecimalFeatures { #[init] fn init(&self) {} diff --git a/contracts/feature-tests/basic-features/src/egld_decimal.rs b/contracts/feature-tests/basic-features/src/egld_decimal.rs new file mode 100644 index 0000000000..0b27ed84c6 --- /dev/null +++ b/contracts/feature-tests/basic-features/src/egld_decimal.rs @@ -0,0 +1,11 @@ +multiversx_sc::imports!(); + +/// Used for testing the egld_decimal function return type +#[multiversx_sc::module] +pub trait EgldDecimal { + #[payable("EGLD")] + #[endpoint] + fn returns_egld_decimal(&self) -> ManagedDecimal> { + self.call_value().egld_decimal() + } +} diff --git a/contracts/feature-tests/basic-features/src/managed_decimal_features.rs b/contracts/feature-tests/basic-features/src/managed_decimal_features.rs new file mode 100644 index 0000000000..6952b9e6e1 --- /dev/null +++ b/contracts/feature-tests/basic-features/src/managed_decimal_features.rs @@ -0,0 +1,43 @@ +multiversx_sc::imports!(); + +#[multiversx_sc::module] +pub trait ManagedDecimalFeatures { + #[endpoint] + fn managed_decimal_addition( + &self, + first: ManagedDecimal>, + second: ManagedDecimal>, + ) -> ManagedDecimal> { + first + second + } + + #[endpoint] + fn managed_decimal_subtraction( + &self, + first: ManagedDecimal>, + second: ManagedDecimal>, + ) -> ManagedDecimal> { + first - second + } + + #[endpoint] + fn managed_decimal_eq( + &self, + first: ManagedDecimal>, + second: ManagedDecimal>, + ) -> bool { + first.eq(&second) + } + + #[endpoint] + fn managed_decimal_trunc(&self) -> BigUint { + let dec = ManagedDecimal::from_raw_units(BigUint::from(31332u64), 2usize); + dec.trunc() + } + + #[endpoint] + fn managed_decimal_into_raw_units(&self) -> BigUint { + let dec = ManagedDecimal::from_raw_units(BigUint::from(12345u64), 2usize); + dec.into_raw_units().clone() + } +} diff --git a/contracts/feature-tests/basic-features/tests/basic_features_egld_decimal_test.rs b/contracts/feature-tests/basic-features/tests/basic_features_egld_decimal_test.rs new file mode 100644 index 0000000000..96a01cfc00 --- /dev/null +++ b/contracts/feature-tests/basic-features/tests/basic_features_egld_decimal_test.rs @@ -0,0 +1,71 @@ +use multiversx_sc::types::{ + BigUint, ConstDecimals, ContractCallWithEgld, ManagedAddress, ManagedDecimal, +}; +use multiversx_sc_scenario::{api::StaticApi, scenario_model::*, *}; + +const BASIC_FEATURES_PATH_EXPR: &str = "file:../output/basic-features.wasm"; +const OWNER_ADDRESS_EXPR: &str = "address:owner"; +const BASIC_FEATURES_ADDRESS_EXPR: &str = "sc:basic-features"; + +type BasicFeatures = ContractInfo>; + +struct BasicFeaturesState { + world: ScenarioWorld, + basic_features: BasicFeatures, +} + +impl BasicFeaturesState { + fn new() -> Self { + let mut world = world(); + let basic_features_code = world.code_expression(BASIC_FEATURES_PATH_EXPR); + + world.set_state_step( + SetStateStep::new() + .put_account( + OWNER_ADDRESS_EXPR, + Account::new().nonce(1).balance(BigUintValue::from(100u64)), + ) + .put_account( + BASIC_FEATURES_ADDRESS_EXPR, + Account::new().nonce(1).code(basic_features_code), + ), + ); + + let basic_features = BasicFeatures::new(BASIC_FEATURES_ADDRESS_EXPR); + + Self { + world, + basic_features, + } + } +} +fn world() -> ScenarioWorld { + let mut blockchain = ScenarioWorld::new(); + blockchain.set_current_dir_from_workspace("contracts/feature-tests/basic-features"); + + blockchain.register_contract(BASIC_FEATURES_PATH_EXPR, basic_features::ContractBuilder); + blockchain +} + +#[test] +fn egld_decimal_blackbox_test() { + let mut state = BasicFeaturesState::new(); + + let sc_call = + ContractCallWithEgld::>>::new( + ManagedAddress::from(state.basic_features.to_address()), + "returns_egld_decimal", + BigUint::from(5u64), + ); + + let egld_decimal: ManagedDecimal> = state + .world + .sc_call_get_result(ScCallStep::new().call(sc_call).from("address:owner")); + + assert_eq!( + egld_decimal, + ManagedDecimal::>::const_decimals_from_raw(BigUint::from( + 5u64 + )) + ); +} diff --git a/contracts/feature-tests/basic-features/tests/basic_features_managed_decimal_test.rs b/contracts/feature-tests/basic-features/tests/basic_features_managed_decimal_test.rs new file mode 100644 index 0000000000..42473aec9b --- /dev/null +++ b/contracts/feature-tests/basic-features/tests/basic_features_managed_decimal_test.rs @@ -0,0 +1,18 @@ +use multiversx_sc_scenario::*; + +fn world() -> ScenarioWorld { + let mut blockchain = ScenarioWorld::new(); + blockchain.set_current_dir_from_workspace("contracts/feature-tests/basic-features"); + + blockchain.register_contract( + "mxsc:output/basic-features.mxsc.json", + basic_features::ContractBuilder, + ); + + blockchain +} + +#[test] +fn managed_decimal_test() { + world().run("scenarios/managed_decimal.scen.json"); +} diff --git a/contracts/feature-tests/basic-features/wasm/src/lib.rs b/contracts/feature-tests/basic-features/wasm/src/lib.rs index e87654cc7e..8a9a80bb04 100644 --- a/contracts/feature-tests/basic-features/wasm/src/lib.rs +++ b/contracts/feature-tests/basic-features/wasm/src/lib.rs @@ -5,9 +5,9 @@ //////////////////////////////////////////////////// // Init: 1 -// Endpoints: 384 +// Endpoints: 390 // Async Callback: 1 -// Total number of exported functions: 386 +// Total number of exported functions: 392 #![no_std] #![allow(internal_features)] @@ -395,6 +395,7 @@ multiversx_sc_wasm_adapter::endpoints! { token_identifier_is_valid_2 => token_identifier_is_valid_2 non_zero_usize_iter => non_zero_usize_iter non_zero_usize_macro => non_zero_usize_macro + returns_egld_decimal => returns_egld_decimal set_contract_address => set_contract_address is_empty_at_address => is_empty_at_address contains_at_address => contains_at_address @@ -404,6 +405,11 @@ multiversx_sc_wasm_adapter::endpoints! { front_at_address => front_at_address back_at_address => back_at_address fill_set_mapper => fill_set_mapper + managed_decimal_addition => managed_decimal_addition + managed_decimal_subtraction => managed_decimal_subtraction + managed_decimal_eq => managed_decimal_eq + managed_decimal_trunc => managed_decimal_trunc + managed_decimal_into_raw_units => managed_decimal_into_raw_units ) } diff --git a/contracts/feature-tests/big-float-features/tests/big_float_scenario_rs_test.rs b/contracts/feature-tests/big-float-features/tests/big_float_scenario_rs_test.rs index 0c5d6383fa..439c098def 100644 --- a/contracts/feature-tests/big-float-features/tests/big_float_scenario_rs_test.rs +++ b/contracts/feature-tests/big-float-features/tests/big_float_scenario_rs_test.rs @@ -1,4 +1,5 @@ -use multiversx_sc_scenario::*; +use multiversx_sc::types::{BigFloat, BigUint}; +use multiversx_sc_scenario::{api::StaticApi, *}; fn world() -> ScenarioWorld { let mut blockchain = ScenarioWorld::new(); @@ -12,6 +13,50 @@ fn world() -> ScenarioWorld { blockchain } +#[test] +fn big_float_overflow_test_rs() { + let exp = 1_080i32; + + let first = BigFloat::::from_sci(1_005, -3) + .pow(exp) + .to_fixed_point(&(100_000_000_000_000_000i64.into())) + .into_big_uint(); + + let second = BigFloat::::from_sci(1_005, -3) + .pow(exp) + .to_fixed_point(&(10_000_000_000_000_000i64.into())) + .into_big_uint(); + + let third_float = BigFloat::::from_sci(1_005, -3) + .pow(exp) + .to_managed_decimal(17usize); + let third = third_float.into_raw_units(); + + let forth_float = BigFloat::::from_sci(1_005, -3) + .pow(exp) + .to_managed_decimal(16usize); + let forth = forth_float.into_raw_units(); + + assert_eq!( + first.unwrap_or_sc_panic("unwrap failed"), + /* overflow */ + BigUint::from(9223372036854775807u64) + ); + + assert_eq!( + second.unwrap_or_sc_panic("unwrap failed"), + BigUint::from(2184473079534488064u64) + ); + + assert_eq!( + third, + /* overflow */ + &BigUint::from(9223372036854775807u64) + ); + + assert_eq!(forth, &BigUint::from(2184473079534488064u64)); +} + #[test] fn big_float_new_from_big_int_rs() { world().run("scenarios/big_float_new_from_big_int.scen.json"); diff --git a/framework/base/src/api/managed_types/const_handles.rs b/framework/base/src/api/managed_types/const_handles.rs index bd92bcc1db..837e002c53 100644 --- a/framework/base/src/api/managed_types/const_handles.rs +++ b/framework/base/src/api/managed_types/const_handles.rs @@ -1,3 +1,5 @@ +use num_traits::ToPrimitive; + use super::RawHandle; /// Used as a flag. Reading from this handle will always result in a crash. @@ -13,6 +15,7 @@ pub const CALL_VALUE_SINGLE_ESDT: RawHandle = -13; pub const BIG_INT_TEMPORARY_1: RawHandle = -14; pub const BIG_INT_TEMPORARY_2: RawHandle = -15; +pub const BIG_FLOAT_TEMPORARY: RawHandle = -16; /// WARNING! With the current VM this still needs to be initialized before use. pub const MBUF_CONST_EMPTY: RawHandle = -20; @@ -22,7 +25,16 @@ pub const CALLBACK_CLOSURE_ARGS_BUFFER: RawHandle = -23; pub const MBUF_TEMPORARY_1: RawHandle = -25; pub const MBUF_TEMPORARY_2: RawHandle = -26; -pub const NEW_HANDLE_START_FROM: RawHandle = -100; // > -100 reserved for APIs +pub const NEW_HANDLE_START_FROM: RawHandle = -200; // > -100 reserved for APIs + +// Vec of 64 entries of 1 bit +pub const SCALING_FACTOR_START: RawHandle = -100; +pub const SCALING_FACTOR_LENGTH: usize = 64; /// Used as a flag. Do not use as a regular handle. pub const MANAGED_OPTION_NONE: RawHandle = i32::MAX - 1; + +pub fn get_scaling_factor_handle(decimals: usize) -> i32 { + let decimals_i32 = decimals.to_i32().unwrap(); + SCALING_FACTOR_START - decimals_i32 +} diff --git a/framework/base/src/api/managed_types/static_var_api.rs b/framework/base/src/api/managed_types/static_var_api.rs index 59f65dc3b6..0002e01bff 100644 --- a/framework/base/src/api/managed_types/static_var_api.rs +++ b/framework/base/src/api/managed_types/static_var_api.rs @@ -31,4 +31,8 @@ pub trait StaticVarApiImpl { fn set_call_value_multi_esdt_handle(&self, handle: RawHandle); fn get_call_value_multi_esdt_handle(&self) -> RawHandle; + + fn get_scaling_factor_cached(&self, decimals: usize) -> bool; + + fn set_scaling_factor_cached(&self, decimals: usize); } diff --git a/framework/base/src/api/uncallable/static_var_api_uncallable.rs b/framework/base/src/api/uncallable/static_var_api_uncallable.rs index 3ed707e06b..88811401ab 100644 --- a/framework/base/src/api/uncallable/static_var_api_uncallable.rs +++ b/framework/base/src/api/uncallable/static_var_api_uncallable.rs @@ -56,4 +56,12 @@ impl StaticVarApiImpl for UncallableApi { fn get_call_value_multi_esdt_handle(&self) -> RawHandle { unreachable!() } + + fn get_scaling_factor_cached(&self, _decimals: usize) -> bool { + unreachable!() + } + + fn set_scaling_factor_cached(&self, _decimals: usize) { + unreachable!() + } } diff --git a/framework/base/src/contract_base/wrappers/call_value_wrapper.rs b/framework/base/src/contract_base/wrappers/call_value_wrapper.rs index 520ee4228e..3006805ef0 100644 --- a/framework/base/src/contract_base/wrappers/call_value_wrapper.rs +++ b/framework/base/src/contract_base/wrappers/call_value_wrapper.rs @@ -7,8 +7,9 @@ use crate::{ }, err_msg, types::{ - BigUint, EgldOrEsdtTokenIdentifier, EgldOrEsdtTokenPayment, EgldOrMultiEsdtPayment, - EsdtTokenPayment, ManagedRef, ManagedVec, TokenIdentifier, + BigUint, ConstDecimals, EgldOrEsdtTokenIdentifier, EgldOrEsdtTokenPayment, + EgldOrMultiEsdtPayment, EsdtTokenPayment, ManagedDecimal, ManagedRef, ManagedVec, + TokenIdentifier, }, }; @@ -43,6 +44,13 @@ where unsafe { ManagedRef::wrap_handle(call_value_handle) } } + /// Returns the EGLD call value from the VM as ManagedDecimal + pub fn egld_decimal(&self) -> ManagedDecimal> { + ManagedDecimal::>::const_decimals_from_raw( + self.egld_value().clone_value(), + ) + } + /// Returns all ESDT transfers that accompany this SC call. /// Will return 0 results if nothing was transfered, or just EGLD. /// Fully managed underlying types, very efficient. diff --git a/framework/base/src/types/managed/basic/big_float.rs b/framework/base/src/types/managed/basic/big_float.rs index 83ef5613e3..44abed8b86 100644 --- a/framework/base/src/types/managed/basic/big_float.rs +++ b/framework/base/src/types/managed/basic/big_float.rs @@ -4,7 +4,7 @@ use crate::{ api::{ use_raw_handle, BigFloatApiImpl, ManagedTypeApi, ManagedTypeApiImpl, Sign, StaticVarApiImpl, }, - types::{BigInt, BigUint, ManagedType}, + types::{BigInt, BigUint, Decimals, ManagedDecimal, ManagedType}, }; use alloc::string::String; @@ -169,6 +169,10 @@ impl BigFloat { pub fn to_fixed_point(&self, denominator: &BigFloat) -> BigInt { (self * denominator).trunc() } + + pub fn to_managed_decimal(self, decimals: T) -> ManagedDecimal { + ManagedDecimal::::from_big_float(self, decimals) + } } impl BigFloat { diff --git a/framework/base/src/types/managed/wrapped/egld_or_esdt_token_identifier.rs b/framework/base/src/types/managed/wrapped/egld_or_esdt_token_identifier.rs index 3e7ae8afb5..e885181eca 100644 --- a/framework/base/src/types/managed/wrapped/egld_or_esdt_token_identifier.rs +++ b/framework/base/src/types/managed/wrapped/egld_or_esdt_token_identifier.rs @@ -1,3 +1,5 @@ +use alloc::string::ToString; + use crate::{ abi::{TypeAbi, TypeName}, api::{HandleConstraints, ManagedTypeApi}, @@ -247,7 +249,6 @@ where M: ManagedTypeApi, { fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - use crate::alloc::string::ToString; if let Some(token_identifier) = self.data.as_option() { let token_id_str = token_identifier.to_string(); f.debug_tuple("EgldOrEsdtTokenIdentifier::Esdt") diff --git a/framework/base/src/types/managed/wrapped/managed_decimal.rs b/framework/base/src/types/managed/wrapped/managed_decimal.rs new file mode 100644 index 0000000000..3bf824101d --- /dev/null +++ b/framework/base/src/types/managed/wrapped/managed_decimal.rs @@ -0,0 +1,382 @@ +use crate::{ + abi::{TypeAbi, TypeName}, + api::{ + const_handles, use_raw_handle, BigFloatApiImpl, BigIntApiImpl, ManagedTypeApi, + StaticVarApiImpl, + }, + types::{BigFloat, BigUint}, +}; + +use multiversx_sc_codec::{ + DecodeError, DecodeErrorHandler, EncodeErrorHandler, NestedDecode, NestedDecodeInput, + NestedEncode, NestedEncodeOutput, TopDecode, TopDecodeInput, TopEncode, TopEncodeOutput, +}; + +use core::{ + cmp::Ordering, + ops::{Add, Deref, Div, Mul, Sub}, +}; + +use super::ManagedRef; + +fn scaling_factor( + num_decimals: NumDecimals, +) -> ManagedRef<'static, M, BigUint> { + let handle: M::BigIntHandle = + use_raw_handle(const_handles::get_scaling_factor_handle(num_decimals)); + + if !M::static_var_api_impl().get_scaling_factor_cached(num_decimals) { + cache_scaling_factor::(handle.clone(), num_decimals); + M::static_var_api_impl().set_scaling_factor_cached(num_decimals); + } + + unsafe { ManagedRef::<'static, M, BigUint>::wrap_handle(handle) } +} + +fn cache_scaling_factor(handle: M::BigIntHandle, num_decimals: NumDecimals) { + let temp1: M::BigIntHandle = use_raw_handle(const_handles::BIG_INT_TEMPORARY_1); + let temp2: M::BigIntHandle = use_raw_handle(const_handles::BIG_INT_TEMPORARY_2); + let api = M::managed_type_impl(); + api.bi_set_int64(temp1.clone(), 10); + api.bi_set_int64(temp2.clone(), num_decimals as i64); + api.bi_pow(handle, temp1, temp2); +} + +pub trait Decimals { + fn num_decimals(&self) -> NumDecimals; + + fn scaling_factor(&self) -> ManagedRef<'static, M, BigUint> { + scaling_factor(self.num_decimals()) + } +} + +impl Decimals for NumDecimals { + fn num_decimals(&self) -> NumDecimals { + *self + } +} + +pub type NumDecimals = usize; + +#[derive(Clone, Debug)] +pub struct ConstDecimals; + +impl Decimals for ConstDecimals { + fn num_decimals(&self) -> NumDecimals { + DECIMALS + } + + fn scaling_factor(&self) -> ManagedRef<'static, M, BigUint> { + scaling_factor(self.num_decimals()) + } +} + +#[derive(Debug, Clone)] +pub struct ManagedDecimal { + data: BigUint, + decimals: D, +} + +impl ManagedDecimal { + pub fn trunc(&self) -> BigUint { + &self.data / self.decimals.scaling_factor().deref() + } + + pub fn into_raw_units(&self) -> &BigUint { + &self.data + } + + pub fn from_raw_units(data: BigUint, decimals: D) -> Self { + ManagedDecimal { data, decimals } + } + + pub fn scale(&self) -> usize { + self.decimals.num_decimals() + } + + pub fn rescale(self, scale_to: T) -> ManagedDecimal + where + M: ManagedTypeApi, + { + let from_num_decimals = self.decimals.num_decimals(); + let scale_to_num_decimals = scale_to.num_decimals(); + + match from_num_decimals.cmp(&scale_to_num_decimals) { + Ordering::Less => { + let delta_decimals = scale_to_num_decimals - from_num_decimals; + let scaling_factor: &BigUint = &delta_decimals.scaling_factor(); + ManagedDecimal::from_raw_units(&self.data * scaling_factor, scale_to) + }, + Ordering::Equal => ManagedDecimal::from_raw_units(self.data, scale_to), + Ordering::Greater => { + let delta_decimals = from_num_decimals - scale_to_num_decimals; + let scaling_factor: &BigUint = &delta_decimals.scaling_factor(); + ManagedDecimal::from_raw_units(&self.data * scaling_factor, scale_to) + }, + } + } + + pub fn to_big_float(&self) -> BigFloat { + let result = BigFloat::from_big_uint(&self.data); + let temp_handle: M::BigFloatHandle = use_raw_handle(const_handles::BIG_FLOAT_TEMPORARY); + let denominator = self.decimals.scaling_factor::(); + M::managed_type_impl().bf_set_bi(temp_handle.clone(), denominator.handle); + M::managed_type_impl().bf_div(result.handle.clone(), result.handle.clone(), temp_handle); + result + } + + pub fn from_big_float( + big_float: BigFloat, + num_decimals: T, + ) -> ManagedDecimal { + let scaling_factor: &BigUint = &num_decimals.scaling_factor(); + let magnitude = big_float.magnitude(); + + let scaled = &BigFloat::from(scaling_factor) * &magnitude; + let fixed_big_int = scaled.trunc(); + + ManagedDecimal::from_raw_units( + fixed_big_int + .into_big_uint() + .unwrap_or_sc_panic("failed to cast BigInt to BigUint"), + num_decimals, + ) + } +} + +impl ManagedDecimal> { + pub fn const_decimals_from_raw(data: BigUint) -> Self { + ManagedDecimal { + data, + decimals: ConstDecimals, + } + } +} + +impl TopEncode + for ManagedDecimal> +{ + #[inline] + fn top_encode_or_handle_err(&self, output: O, h: H) -> Result<(), H::HandledErr> + where + O: TopEncodeOutput, + H: EncodeErrorHandler, + { + self.data.top_encode_or_handle_err(output, h) + } +} + +impl TopDecode + for ManagedDecimal> +{ + #[inline] + fn top_decode_or_handle_err(input: I, h: H) -> Result + where + I: TopDecodeInput, + H: DecodeErrorHandler, + { + Ok(ManagedDecimal::const_decimals_from_raw( + BigUint::top_decode_or_handle_err(input, h)?, + )) + } +} + +impl NestedEncode + for ManagedDecimal> +{ + #[inline] + fn dep_encode_or_handle_err(&self, dest: &mut O, h: H) -> Result<(), H::HandledErr> + where + O: NestedEncodeOutput, + H: EncodeErrorHandler, + { + NestedEncode::dep_encode_or_handle_err(&self.data, dest, h)?; + + Result::Ok(()) + } +} + +impl NestedDecode + for ManagedDecimal> +{ + #[inline] + fn dep_decode_or_handle_err(input: &mut I, h: H) -> Result + where + I: NestedDecodeInput, + H: DecodeErrorHandler, + { + Result::Ok(ManagedDecimal::const_decimals_from_raw( + as NestedDecode>::dep_decode_or_handle_err(input, h)?, + )) + } +} + +impl NestedEncode for ManagedDecimal { + fn dep_encode_or_handle_err(&self, dest: &mut O, h: H) -> Result<(), H::HandledErr> + where + O: NestedEncodeOutput, + H: EncodeErrorHandler, + { + NestedEncode::dep_encode_or_handle_err(&self.data, dest, h)?; + NestedEncode::dep_encode_or_handle_err(&self.decimals, dest, h)?; + + Result::Ok(()) + } +} + +impl TopEncode for ManagedDecimal { + #[inline] + fn top_encode_or_handle_err(&self, output: O, h: H) -> Result<(), H::HandledErr> + where + O: TopEncodeOutput, + H: EncodeErrorHandler, + { + let mut buffer = output.start_nested_encode(); + let dest = &mut buffer; + NestedEncode::dep_encode_or_handle_err(&self.data, dest, h)?; + NestedEncode::dep_encode_or_handle_err(&self.decimals, dest, h)?; + + output.finalize_nested_encode(buffer); + Result::Ok(()) + } +} + +impl NestedDecode for ManagedDecimal { + #[inline] + fn dep_decode_or_handle_err(input: &mut I, h: H) -> Result + where + I: NestedDecodeInput, + H: DecodeErrorHandler, + { + Result::Ok(ManagedDecimal::from_raw_units( + as NestedDecode>::dep_decode_or_handle_err(input, h)?, + ::dep_decode_or_handle_err(input, h)?, + )) + } +} + +impl TopDecode for ManagedDecimal { + #[inline] + fn top_decode_or_handle_err(top_input: I, h: H) -> Result + where + I: TopDecodeInput, + H: DecodeErrorHandler, + { + let mut nested_buffer = top_input.into_nested_buffer(); + let result = ManagedDecimal::from_raw_units( + as NestedDecode>::dep_decode_or_handle_err(&mut nested_buffer, h)?, + ::dep_decode_or_handle_err(&mut nested_buffer, h)?, + ); + if !NestedDecodeInput::is_depleted(&nested_buffer) { + return Result::Err(h.handle_error(DecodeError::INPUT_TOO_LONG)); + } + Result::Ok(result) + } +} + +impl From> + for ManagedDecimal> +{ + fn from(mut value: BigUint) -> Self { + let decimals = ConstDecimals; + value *= decimals.scaling_factor().deref(); + ManagedDecimal { + data: value, + decimals, + } + } +} + +impl Add>> + for ManagedDecimal> +{ + type Output = Self; + + fn add(self, other: ManagedDecimal>) -> Self::Output { + ManagedDecimal::const_decimals_from_raw(self.data + other.data) + } +} + +impl Sub>> + for ManagedDecimal> +{ + type Output = Self; + + fn sub(self, other: ManagedDecimal>) -> Self::Output { + ManagedDecimal::const_decimals_from_raw(self.data - other.data) + } +} + +#[allow(clippy::suspicious_arithmetic_impl)] +impl + Mul>> + for ManagedDecimal> +where + [(); DECIMALS + OTHER_DECIMALS]:, +{ + type Output = ManagedDecimal>; + + fn mul(self, other: ManagedDecimal>) -> Self::Output { + ManagedDecimal::const_decimals_from_raw(self.data * other.data) + } +} + +#[allow(clippy::suspicious_arithmetic_impl)] +impl + Div>> + for ManagedDecimal> +where + [(); DECIMALS - OTHER_DECIMALS]:, +{ + type Output = ManagedDecimal>; + + fn div(self, other: ManagedDecimal>) -> Self::Output { + ManagedDecimal::const_decimals_from_raw(self.data / other.data) + } +} + +impl PartialEq> + for ManagedDecimal +{ + fn eq(&self, other: &ManagedDecimal) -> bool { + match self + .decimals + .num_decimals() + .cmp(&other.decimals.num_decimals()) + { + Ordering::Less => { + let diff_decimals = other.decimals.num_decimals() - self.decimals.num_decimals(); + let scaling_factor: &BigUint = &diff_decimals.scaling_factor(); + &self.data * scaling_factor == other.data + }, + Ordering::Equal => self.data == other.data, + Ordering::Greater => { + let diff_decimals = self.decimals.num_decimals() - other.decimals.num_decimals(); + let scaling_factor: &BigUint = &diff_decimals.scaling_factor(); + &other.data * scaling_factor == self.data + }, + } + } +} + +impl TypeAbi for ManagedDecimal { + fn type_name() -> TypeName { + TypeName::from("ManagedDecimal") + } + + fn is_variadic() -> bool { + false + } +} + +impl TypeAbi + for ManagedDecimal> +{ + fn type_name() -> TypeName { + TypeName::from(alloc::format!("ManagedDecimal<{}>", DECIMALS)) + } + + fn is_variadic() -> bool { + false + } +} diff --git a/framework/base/src/types/managed/wrapped/mod.rs b/framework/base/src/types/managed/wrapped/mod.rs index 8ac485fa38..c9c70fea9b 100644 --- a/framework/base/src/types/managed/wrapped/mod.rs +++ b/framework/base/src/types/managed/wrapped/mod.rs @@ -7,6 +7,7 @@ mod esdt_token_payment; mod managed_address; mod managed_buffer_cached_builder; mod managed_byte_array; +mod managed_decimal; mod managed_option; mod managed_ref; mod managed_vec; @@ -28,6 +29,7 @@ pub use managed_address::ManagedAddress; pub use managed_buffer_cached_builder::ManagedBufferCachedBuilder; pub(crate) use managed_byte_array::ManagedBufferSizeContext; pub use managed_byte_array::ManagedByteArray; +pub use managed_decimal::{ConstDecimals, Decimals, ManagedDecimal, NumDecimals}; pub use managed_option::ManagedOption; pub use managed_ref::ManagedRef; pub use managed_vec::ManagedVec; diff --git a/framework/base/src/types/managed/wrapped/token_identifier.rs b/framework/base/src/types/managed/wrapped/token_identifier.rs index 329b3f2b3d..2e5a27020c 100644 --- a/framework/base/src/types/managed/wrapped/token_identifier.rs +++ b/framework/base/src/types/managed/wrapped/token_identifier.rs @@ -1,3 +1,5 @@ +use alloc::string::ToString; + use crate::{ abi::{TypeAbi, TypeName}, api::{ErrorApi, ErrorApiImpl, HandleConstraints, ManagedTypeApi, ManagedTypeApiImpl}, @@ -199,7 +201,6 @@ impl core::fmt::Display for TokenIdentifier { impl core::fmt::Debug for TokenIdentifier { fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - use crate::alloc::string::ToString; f.debug_tuple("TokenIdentifier") .field(&self.to_string()) .finish() diff --git a/framework/scenario/src/api/local_api_vh/static_var_api_vh.rs b/framework/scenario/src/api/local_api_vh/static_var_api_vh.rs index c736ea9c01..907fc19d06 100644 --- a/framework/scenario/src/api/local_api_vh/static_var_api_vh.rs +++ b/framework/scenario/src/api/local_api_vh/static_var_api_vh.rs @@ -80,4 +80,14 @@ impl StaticVarApiImpl for VMHooksApi { use_raw_handle(data.static_vars_cell.borrow().call_value_multi_esdt_handle) }) } + + fn get_scaling_factor_cached(&self, decimals: usize) -> bool { + self.with_static_data(|data| data.static_vars_cell.borrow().scaling_factor_init[decimals]) + } + + fn set_scaling_factor_cached(&self, decimals: usize) { + self.with_static_data(|data| { + data.static_vars_cell.borrow_mut().scaling_factor_init[decimals] = true + }) + } } diff --git a/framework/scenario/src/debug_executor/tx_static_vars.rs b/framework/scenario/src/debug_executor/tx_static_vars.rs index 4ca23f33cb..88277694c4 100644 --- a/framework/scenario/src/debug_executor/tx_static_vars.rs +++ b/framework/scenario/src/debug_executor/tx_static_vars.rs @@ -7,6 +7,8 @@ pub struct TxStaticVars { pub num_arguments: i32, pub call_value_egld_handle: RawHandle, pub call_value_multi_esdt_handle: RawHandle, + //vec of true/false, true if bit from handle = scaling_start + index is not empty + pub scaling_factor_init: [bool; const_handles::SCALING_FACTOR_LENGTH], } impl Default for TxStaticVars { @@ -17,6 +19,7 @@ impl Default for TxStaticVars { num_arguments: -1, call_value_egld_handle: const_handles::UNINITIALIZED_HANDLE, call_value_multi_esdt_handle: const_handles::UNINITIALIZED_HANDLE, + scaling_factor_init: [false; const_handles::SCALING_FACTOR_LENGTH], } } } diff --git a/framework/scenario/tests/managed_decimal_test.rs b/framework/scenario/tests/managed_decimal_test.rs new file mode 100644 index 0000000000..3b185a8a56 --- /dev/null +++ b/framework/scenario/tests/managed_decimal_test.rs @@ -0,0 +1,129 @@ +#![feature(generic_const_exprs)] +#![allow(incomplete_features)] + +use multiversx_sc::{ + codec::test_util::{check_dep_encode_decode, check_top_encode_decode}, + types::{BigFloat, BigUint, ConstDecimals, ManagedDecimal, NumDecimals}, +}; +use multiversx_sc_scenario::api::StaticApi; + +#[test] +pub fn test_managed_decimal() { + let fixed = ManagedDecimal::>::from(BigUint::from(1u64)); + let fixed_2 = ManagedDecimal::>::from(BigUint::from(5u64)); + let fixed_3 = ManagedDecimal::>::from(BigUint::from(8u64)); + + let addition = fixed.clone() + fixed_2.clone(); + assert_eq!( + addition, + ManagedDecimal::>::from(BigUint::from(6u64)) + ); + assert_eq!(addition.into_raw_units(), &BigUint::from(600u64)); + assert_eq!(addition.trunc(), BigUint::from(6u64)); + + let subtraction = addition - fixed; + assert_eq!( + subtraction, + ManagedDecimal::>::from(BigUint::from(5u64)) + ); + + let multiplication = fixed_3.clone() * fixed_2; + assert_eq!( + multiplication, + ManagedDecimal::>::from(BigUint::from(40u64)) + ); + + let division = multiplication / fixed_3; + assert_eq!( + division, + ManagedDecimal::>::from(BigUint::from(5u64)) + ); + + let fixed_4: ManagedDecimal = + ManagedDecimal::from_raw_units(BigUint::from(100u64), 2usize); + let fixed_5 = fixed_4.rescale(2usize); + assert_eq!( + fixed_5, + ManagedDecimal::from_raw_units(BigUint::from(100000000u64), 8usize) + ); + + let fixed_6: ManagedDecimal> = + ManagedDecimal::from(BigUint::from(1500u64)); + let fixed_7 = fixed_6.rescale(ConstDecimals::<8>); + assert_eq!( + fixed_7, + ManagedDecimal::>::from(BigUint::from(1500u64)) + ); + + let fixed_8: ManagedDecimal = + ManagedDecimal::from_raw_units(BigUint::from(5u64), 5usize); + let fixed_9 = fixed_8.rescale(ConstDecimals::<3>); + assert_eq!( + fixed_9, + ManagedDecimal::>::const_decimals_from_raw(BigUint::from( + 500u64 + )) + ); + + let float_1 = BigFloat::::from_frac(3i64, 2i64); + let fixed_float_1 = ManagedDecimal::>::from_big_float( + float_1.clone(), + ConstDecimals::<1>, + ); + let fixed_float_2 = ManagedDecimal::::from_big_float(float_1, 1usize); + + assert_eq!( + fixed_float_1, + ManagedDecimal::>::const_decimals_from_raw(BigUint::from( + 15u64 + )) + ); + assert_eq!( + fixed_float_2, + ManagedDecimal::::from_raw_units(BigUint::from(15u64), 1usize) + ); +} + +#[test] +fn test_managed_decimal_conversion() { + let fixed: ManagedDecimal = + ManagedDecimal::from_raw_units(BigUint::from(123456789123456789u64), 15usize); //123,45.... + + let float_coresp = fixed.to_big_float(); + + // hook not available yet, uncomment when available + // assert_eq!( + // float_coresp.to_buffer(), + // ManagedBuffer::from("123.456789123456789") + // ); + + assert_eq!( + float_coresp, + BigFloat::from_frac(123456789123456789i64, 1_000_000_000_000_000i64) + ); +} + +#[test] +fn test_encode_decode() { + let fixed_struct: ManagedDecimal = + ManagedDecimal::from_raw_units(BigUint::from(1u64), 1usize); + + #[rustfmt::skip] + let nested_bytes = &[ + /* BigUint */ 0, 0, 0, 0x01, 0x01, + /* usize */ 0, 0, 0, 0x01, + ]; + + check_dep_encode_decode(fixed_struct.clone(), nested_bytes); + check_top_encode_decode(fixed_struct, nested_bytes); + + let fixed_const: ManagedDecimal> = + ManagedDecimal::const_decimals_from_raw(BigUint::from(1u64)); + + #[rustfmt::skip] + let bytes = &[ + /* BigUint */ 0x01, + ]; + + check_top_encode_decode(fixed_const, bytes); +} diff --git a/framework/scenario/tests/managed_type_debug_test.rs b/framework/scenario/tests/managed_type_debug_test.rs index fbe031ab7e..1342395377 100644 --- a/framework/scenario/tests/managed_type_debug_test.rs +++ b/framework/scenario/tests/managed_type_debug_test.rs @@ -10,26 +10,26 @@ use multiversx_sc_scenario::api::StaticApi; #[test] fn test_big_uint_format() { let s = format!("{:?}", BigUint::::from(0x1234u32)); - assert_eq!("BigUint { handle: -100, hex-value-be: \"1234\" }", s); + assert_eq!("BigUint { handle: -200, hex-value-be: \"1234\" }", s); } #[test] fn test_big_int_format_1() { let s = format!("{:?}", BigInt::::from(0x1234)); - assert_eq!("BigInt { handle: -100, hex-value-be: \"1234\" }", s); + assert_eq!("BigInt { handle: -200, hex-value-be: \"1234\" }", s); } #[test] fn test_big_int_format_2() { let s = format!("{:?}", BigInt::::from(-0x1234)); - assert_eq!("BigInt { handle: -100, hex-value-be: \"edcc\" }", s); + assert_eq!("BigInt { handle: -200, hex-value-be: \"edcc\" }", s); } #[test] fn test_managed_buffer() { let _ = multiversx_sc::hex_literal::hex!("abcd"); let s = format!("{:?}", ManagedBuffer::::from(&[0x12, 0x34])); - assert_eq!("ManagedBuffer { handle: -100, hex-value: \"1234\" }", s); + assert_eq!("ManagedBuffer { handle: -200, hex-value: \"1234\" }", s); } #[test] @@ -37,7 +37,7 @@ fn test_managed_byte_array() { let addr = hex!("01020304050607"); let s = format!("{:?}", ManagedByteArray::::from(&addr)); assert_eq!( - "ManagedByteArray { handle: -100, size: 7, hex-value: \"01020304050607\" }", + "ManagedByteArray { handle: -200, size: 7, hex-value: \"01020304050607\" }", s ); } @@ -46,7 +46,7 @@ fn test_managed_byte_array() { fn test_managed_address() { let addr = hex!("000000000000000000010000000000000000000000000000000000000002ffff"); let s = format!("{:?}", ManagedAddress::::from(&addr)); - assert_eq!("ManagedAddress { handle: -100, hex-value: \"000000000000000000010000000000000000000000000000000000000002ffff\" }", s); + assert_eq!("ManagedAddress { handle: -200, hex-value: \"000000000000000000010000000000000000000000000000000000000002ffff\" }", s); } #[test] @@ -55,7 +55,7 @@ fn test_managed_address_pretty() { let s = format!("{:#?}", ManagedAddress::::from(&addr)); assert_eq!( "ManagedAddress { - handle: -100, + handle: -200, hex-value: \"000000000000000000010000000000000000000000000000000000000002ffff\", }", s @@ -68,7 +68,7 @@ fn test_managed_vec_format_biguint() { mv.push(BigUint::from(1u32)); mv.push(BigUint::from(2u32)); let s = format!("{:?}", &mv); - assert_eq!("[BigUint { handle: -101, hex-value-be: \"01\" }, BigUint { handle: -102, hex-value-be: \"02\" }]", s); + assert_eq!("[BigUint { handle: -201, hex-value-be: \"01\" }, BigUint { handle: -202, hex-value-be: \"02\" }]", s); } #[test] diff --git a/framework/scenario/tests/test_print_api.rs b/framework/scenario/tests/test_print_api.rs index f61cb78ea1..a15c91601d 100644 --- a/framework/scenario/tests/test_print_api.rs +++ b/framework/scenario/tests/test_print_api.rs @@ -6,13 +6,13 @@ fn test_print_api() { let zero = BigUint::::from(0u64); assert_eq!( format!("{:?}", BigUintPrinter { value: zero }), - "BigUint { handle: -100, hex: \"00\", dec: \"0\" }" + "BigUint { handle: -200, hex: \"00\", dec: \"0\" }" ); let regular = BigUint::::from(257u64); assert_eq!( format!("{:?}", BigUintPrinter { value: regular }), - "BigUint { handle: -101, hex: \"0101\", dec: \"257\" }" + "BigUint { handle: -201, hex: \"0101\", dec: \"257\" }" ); let huge_number = BigUint::::from_bytes_be(&[ @@ -21,6 +21,6 @@ fn test_print_api() { ]); assert_eq!( format!("{:?}", BigUintPrinter { value: huge_number }), - "BigUint { handle: -102, hex: \"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff\", dec: \"7588550360256754183279148073529370729071901715047420004889892225542594864082845695\" }" + "BigUint { handle: -202, hex: \"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff\", dec: \"7588550360256754183279148073529370729071901715047420004889892225542594864082845695\" }" ); } diff --git a/framework/snippets/src/interactor_vm_query.rs b/framework/snippets/src/interactor_vm_query.rs index 56a54961d2..d6a92aa450 100644 --- a/framework/snippets/src/interactor_vm_query.rs +++ b/framework/snippets/src/interactor_vm_query.rs @@ -40,6 +40,7 @@ impl Interactor { info!("{:#?}", result); let raw_results: Vec> = result.data.return_data.iter().map(base64_decode).collect(); + step.save_response(TxResponse::from_raw_results(raw_results)); self.pre_runners.run_sc_query_step(step); diff --git a/framework/wasm-adapter/src/api/managed_types/static_var_api_node.rs b/framework/wasm-adapter/src/api/managed_types/static_var_api_node.rs index 272bbba578..9e1aebb216 100644 --- a/framework/wasm-adapter/src/api/managed_types/static_var_api_node.rs +++ b/framework/wasm-adapter/src/api/managed_types/static_var_api_node.rs @@ -11,6 +11,8 @@ static mut NEXT_HANDLE: i32 = const_handles::NEW_HANDLE_START_FROM; static mut NUM_ARGUMENTS: i32 = 0; static mut CALL_VALUE_EGLD_HANDLE: i32 = const_handles::UNINITIALIZED_HANDLE; static mut CALL_VALUE_MULTI_ESDT_HANDLE: i32 = const_handles::UNINITIALIZED_HANDLE; +static mut SCALING_FACTOR_INIT: [bool; const_handles::SCALING_FACTOR_LENGTH] = + [false; const_handles::SCALING_FACTOR_LENGTH]; // The compiler seems to enjoy inlining this method no matter how many times it shows up. // Hence the rather drastic directive. @@ -78,4 +80,14 @@ impl StaticVarApiImpl for VmApiImpl { fn get_call_value_multi_esdt_handle(&self) -> RawHandle { unsafe { CALL_VALUE_MULTI_ESDT_HANDLE } } + + fn get_scaling_factor_cached(&self, decimals: usize) -> bool { + unsafe { SCALING_FACTOR_INIT[decimals] } + } + + fn set_scaling_factor_cached(&self, decimals: usize) { + { + unsafe { SCALING_FACTOR_INIT[decimals] = true } + } + } } From a2eaf7da04a29987122d5852bad16a3f17d5dba9 Mon Sep 17 00:00:00 2001 From: Mihai Calin Luca Date: Mon, 4 Mar 2024 11:58:04 +0100 Subject: [PATCH 2/6] fix after review --- framework/base/src/api/managed_types/const_handles.rs | 6 ++---- framework/base/src/api/managed_types/static_var_api.rs | 2 +- .../base/src/api/uncallable/static_var_api_uncallable.rs | 2 +- framework/base/src/types/managed/wrapped/managed_decimal.rs | 2 +- .../scenario/src/api/local_api_vh/static_var_api_vh.rs | 2 +- .../src/api/managed_types/static_var_api_node.rs | 2 +- 6 files changed, 7 insertions(+), 9 deletions(-) diff --git a/framework/base/src/api/managed_types/const_handles.rs b/framework/base/src/api/managed_types/const_handles.rs index 837e002c53..73f329452e 100644 --- a/framework/base/src/api/managed_types/const_handles.rs +++ b/framework/base/src/api/managed_types/const_handles.rs @@ -1,5 +1,3 @@ -use num_traits::ToPrimitive; - use super::RawHandle; /// Used as a flag. Reading from this handle will always result in a crash. @@ -34,7 +32,7 @@ pub const SCALING_FACTOR_LENGTH: usize = 64; /// Used as a flag. Do not use as a regular handle. pub const MANAGED_OPTION_NONE: RawHandle = i32::MAX - 1; -pub fn get_scaling_factor_handle(decimals: usize) -> i32 { - let decimals_i32 = decimals.to_i32().unwrap(); +pub const fn get_scaling_factor_handle(decimals: usize) -> i32 { + let decimals_i32 = decimals as i32; SCALING_FACTOR_START - decimals_i32 } diff --git a/framework/base/src/api/managed_types/static_var_api.rs b/framework/base/src/api/managed_types/static_var_api.rs index 0002e01bff..8eaf474ef3 100644 --- a/framework/base/src/api/managed_types/static_var_api.rs +++ b/framework/base/src/api/managed_types/static_var_api.rs @@ -32,7 +32,7 @@ pub trait StaticVarApiImpl { fn get_call_value_multi_esdt_handle(&self) -> RawHandle; - fn get_scaling_factor_cached(&self, decimals: usize) -> bool; + fn is_scaling_factor_cached(&self, decimals: usize) -> bool; fn set_scaling_factor_cached(&self, decimals: usize); } diff --git a/framework/base/src/api/uncallable/static_var_api_uncallable.rs b/framework/base/src/api/uncallable/static_var_api_uncallable.rs index 88811401ab..1da3c772cf 100644 --- a/framework/base/src/api/uncallable/static_var_api_uncallable.rs +++ b/framework/base/src/api/uncallable/static_var_api_uncallable.rs @@ -57,7 +57,7 @@ impl StaticVarApiImpl for UncallableApi { unreachable!() } - fn get_scaling_factor_cached(&self, _decimals: usize) -> bool { + fn is_scaling_factor_cached(&self, _decimals: usize) -> bool { unreachable!() } diff --git a/framework/base/src/types/managed/wrapped/managed_decimal.rs b/framework/base/src/types/managed/wrapped/managed_decimal.rs index 3bf824101d..7810a43500 100644 --- a/framework/base/src/types/managed/wrapped/managed_decimal.rs +++ b/framework/base/src/types/managed/wrapped/managed_decimal.rs @@ -25,7 +25,7 @@ fn scaling_factor( let handle: M::BigIntHandle = use_raw_handle(const_handles::get_scaling_factor_handle(num_decimals)); - if !M::static_var_api_impl().get_scaling_factor_cached(num_decimals) { + if !M::static_var_api_impl().is_scaling_factor_cached(num_decimals) { cache_scaling_factor::(handle.clone(), num_decimals); M::static_var_api_impl().set_scaling_factor_cached(num_decimals); } diff --git a/framework/scenario/src/api/local_api_vh/static_var_api_vh.rs b/framework/scenario/src/api/local_api_vh/static_var_api_vh.rs index 907fc19d06..e72ae45f74 100644 --- a/framework/scenario/src/api/local_api_vh/static_var_api_vh.rs +++ b/framework/scenario/src/api/local_api_vh/static_var_api_vh.rs @@ -81,7 +81,7 @@ impl StaticVarApiImpl for VMHooksApi { }) } - fn get_scaling_factor_cached(&self, decimals: usize) -> bool { + fn is_scaling_factor_cached(&self, decimals: usize) -> bool { self.with_static_data(|data| data.static_vars_cell.borrow().scaling_factor_init[decimals]) } diff --git a/framework/wasm-adapter/src/api/managed_types/static_var_api_node.rs b/framework/wasm-adapter/src/api/managed_types/static_var_api_node.rs index 9e1aebb216..1350697cf6 100644 --- a/framework/wasm-adapter/src/api/managed_types/static_var_api_node.rs +++ b/framework/wasm-adapter/src/api/managed_types/static_var_api_node.rs @@ -81,7 +81,7 @@ impl StaticVarApiImpl for VmApiImpl { unsafe { CALL_VALUE_MULTI_ESDT_HANDLE } } - fn get_scaling_factor_cached(&self, decimals: usize) -> bool { + fn is_scaling_factor_cached(&self, decimals: usize) -> bool { unsafe { SCALING_FACTOR_INIT[decimals] } } From 540b72aab295152e8bd666560954c12b5420b3af Mon Sep 17 00:00:00 2001 From: Mihai Calin Luca Date: Mon, 11 Mar 2024 10:09:06 +0100 Subject: [PATCH 3/6] managed decimal macros to replace unstable const generic arithmetic --- .../types/managed/wrapped/managed_decimal.rs | 36 +- .../managed/wrapped/managed_decimal_macros.rs | 4246 +++++++++++++++++ .../base/src/types/managed/wrapped/mod.rs | 1 + 3 files changed, 4267 insertions(+), 16 deletions(-) create mode 100644 framework/base/src/types/managed/wrapped/managed_decimal_macros.rs diff --git a/framework/base/src/types/managed/wrapped/managed_decimal.rs b/framework/base/src/types/managed/wrapped/managed_decimal.rs index 7810a43500..39a8263396 100644 --- a/framework/base/src/types/managed/wrapped/managed_decimal.rs +++ b/framework/base/src/types/managed/wrapped/managed_decimal.rs @@ -307,31 +307,35 @@ impl Sub - Mul>> - for ManagedDecimal> +impl Mul> + for ManagedDecimal where - [(); DECIMALS + OTHER_DECIMALS]:, + D1: Add, + >::Output: Decimals, { - type Output = ManagedDecimal>; + type Output = ManagedDecimal>::Output>; - fn mul(self, other: ManagedDecimal>) -> Self::Output { - ManagedDecimal::const_decimals_from_raw(self.data * other.data) + fn mul(self, other: ManagedDecimal) -> Self::Output { + ManagedDecimal { + data: self.data * other.data, + decimals: self.decimals + other.decimals, + } } } -#[allow(clippy::suspicious_arithmetic_impl)] -impl - Div>> - for ManagedDecimal> +impl Div> + for ManagedDecimal where - [(); DECIMALS - OTHER_DECIMALS]:, + D1: Sub, + >::Output: Decimals, { - type Output = ManagedDecimal>; + type Output = ManagedDecimal>::Output>; - fn div(self, other: ManagedDecimal>) -> Self::Output { - ManagedDecimal::const_decimals_from_raw(self.data / other.data) + fn div(self, other: ManagedDecimal) -> Self::Output { + ManagedDecimal { + data: self.data / other.data, + decimals: self.decimals - other.decimals, + } } } diff --git a/framework/base/src/types/managed/wrapped/managed_decimal_macros.rs b/framework/base/src/types/managed/wrapped/managed_decimal_macros.rs new file mode 100644 index 0000000000..ca6d8a3a3c --- /dev/null +++ b/framework/base/src/types/managed/wrapped/managed_decimal_macros.rs @@ -0,0 +1,4246 @@ +use crate::types::ConstDecimals; +use core::ops::{Add, Sub}; + +macro_rules! add_sub_const_decimals { + ($dec1:expr, $dec2:expr, $result_add:expr, $result_sub:expr) => { + impl Add> for ConstDecimals<$dec1> { + type Output = ConstDecimals<$result_add>; + fn add(self, _rhs: ConstDecimals<$dec2>) -> Self::Output { + ConstDecimals::<$result_add> + } + } + impl Sub> for ConstDecimals<$dec1> { + type Output = ConstDecimals<$result_sub>; + fn sub(self, _rhs: ConstDecimals<$dec2>) -> Self::Output { + ConstDecimals::<$result_sub> + } + } + }; +} + +// Add and subtract macros for const decimals +add_sub_const_decimals!(64usize, 64usize, 128usize, 0usize); +add_sub_const_decimals!(64usize, 63usize, 127usize, 1usize); +add_sub_const_decimals!(64usize, 62usize, 126usize, 2usize); +add_sub_const_decimals!(64usize, 61usize, 125usize, 3usize); +add_sub_const_decimals!(64usize, 60usize, 124usize, 4usize); +add_sub_const_decimals!(64usize, 59usize, 123usize, 5usize); +add_sub_const_decimals!(64usize, 58usize, 122usize, 6usize); +add_sub_const_decimals!(64usize, 57usize, 121usize, 7usize); +add_sub_const_decimals!(64usize, 56usize, 120usize, 8usize); +add_sub_const_decimals!(64usize, 55usize, 119usize, 9usize); +add_sub_const_decimals!(64usize, 54usize, 118usize, 10usize); +add_sub_const_decimals!(64usize, 53usize, 117usize, 11usize); +add_sub_const_decimals!(64usize, 52usize, 116usize, 12usize); +add_sub_const_decimals!(64usize, 51usize, 115usize, 13usize); +add_sub_const_decimals!(64usize, 50usize, 114usize, 14usize); +add_sub_const_decimals!(64usize, 49usize, 113usize, 15usize); +add_sub_const_decimals!(64usize, 48usize, 112usize, 16usize); +add_sub_const_decimals!(64usize, 47usize, 111usize, 17usize); +add_sub_const_decimals!(64usize, 46usize, 110usize, 18usize); +add_sub_const_decimals!(64usize, 45usize, 109usize, 19usize); +add_sub_const_decimals!(64usize, 44usize, 108usize, 20usize); +add_sub_const_decimals!(64usize, 43usize, 107usize, 21usize); +add_sub_const_decimals!(64usize, 42usize, 106usize, 22usize); +add_sub_const_decimals!(64usize, 41usize, 105usize, 23usize); +add_sub_const_decimals!(64usize, 40usize, 104usize, 24usize); +add_sub_const_decimals!(64usize, 39usize, 103usize, 25usize); +add_sub_const_decimals!(64usize, 38usize, 102usize, 26usize); +add_sub_const_decimals!(64usize, 37usize, 101usize, 27usize); +add_sub_const_decimals!(64usize, 36usize, 100usize, 28usize); +add_sub_const_decimals!(64usize, 35usize, 99usize, 29usize); +add_sub_const_decimals!(64usize, 34usize, 98usize, 30usize); +add_sub_const_decimals!(64usize, 33usize, 97usize, 31usize); +add_sub_const_decimals!(64usize, 32usize, 96usize, 32usize); +add_sub_const_decimals!(64usize, 31usize, 95usize, 33usize); +add_sub_const_decimals!(64usize, 30usize, 94usize, 34usize); +add_sub_const_decimals!(64usize, 29usize, 93usize, 35usize); +add_sub_const_decimals!(64usize, 28usize, 92usize, 36usize); +add_sub_const_decimals!(64usize, 27usize, 91usize, 37usize); +add_sub_const_decimals!(64usize, 26usize, 90usize, 38usize); +add_sub_const_decimals!(64usize, 25usize, 89usize, 39usize); +add_sub_const_decimals!(64usize, 24usize, 88usize, 40usize); +add_sub_const_decimals!(64usize, 23usize, 87usize, 41usize); +add_sub_const_decimals!(64usize, 22usize, 86usize, 42usize); +add_sub_const_decimals!(64usize, 21usize, 85usize, 43usize); +add_sub_const_decimals!(64usize, 20usize, 84usize, 44usize); +add_sub_const_decimals!(64usize, 19usize, 83usize, 45usize); +add_sub_const_decimals!(64usize, 18usize, 82usize, 46usize); +add_sub_const_decimals!(64usize, 17usize, 81usize, 47usize); +add_sub_const_decimals!(64usize, 16usize, 80usize, 48usize); +add_sub_const_decimals!(64usize, 15usize, 79usize, 49usize); +add_sub_const_decimals!(64usize, 14usize, 78usize, 50usize); +add_sub_const_decimals!(64usize, 13usize, 77usize, 51usize); +add_sub_const_decimals!(64usize, 12usize, 76usize, 52usize); +add_sub_const_decimals!(64usize, 11usize, 75usize, 53usize); +add_sub_const_decimals!(64usize, 10usize, 74usize, 54usize); +add_sub_const_decimals!(64usize, 9usize, 73usize, 55usize); +add_sub_const_decimals!(64usize, 8usize, 72usize, 56usize); +add_sub_const_decimals!(64usize, 7usize, 71usize, 57usize); +add_sub_const_decimals!(64usize, 6usize, 70usize, 58usize); +add_sub_const_decimals!(64usize, 5usize, 69usize, 59usize); +add_sub_const_decimals!(64usize, 4usize, 68usize, 60usize); +add_sub_const_decimals!(64usize, 3usize, 67usize, 61usize); +add_sub_const_decimals!(64usize, 2usize, 66usize, 62usize); +add_sub_const_decimals!(64usize, 1usize, 65usize, 63usize); +add_sub_const_decimals!(64usize, 0usize, 64usize, 64usize); +add_sub_const_decimals!(63usize, 64usize, 127usize, 0usize); +add_sub_const_decimals!(63usize, 63usize, 126usize, 0usize); +add_sub_const_decimals!(63usize, 62usize, 125usize, 1usize); +add_sub_const_decimals!(63usize, 61usize, 124usize, 2usize); +add_sub_const_decimals!(63usize, 60usize, 123usize, 3usize); +add_sub_const_decimals!(63usize, 59usize, 122usize, 4usize); +add_sub_const_decimals!(63usize, 58usize, 121usize, 5usize); +add_sub_const_decimals!(63usize, 57usize, 120usize, 6usize); +add_sub_const_decimals!(63usize, 56usize, 119usize, 7usize); +add_sub_const_decimals!(63usize, 55usize, 118usize, 8usize); +add_sub_const_decimals!(63usize, 54usize, 117usize, 9usize); +add_sub_const_decimals!(63usize, 53usize, 116usize, 10usize); +add_sub_const_decimals!(63usize, 52usize, 115usize, 11usize); +add_sub_const_decimals!(63usize, 51usize, 114usize, 12usize); +add_sub_const_decimals!(63usize, 50usize, 113usize, 13usize); +add_sub_const_decimals!(63usize, 49usize, 112usize, 14usize); +add_sub_const_decimals!(63usize, 48usize, 111usize, 15usize); +add_sub_const_decimals!(63usize, 47usize, 110usize, 16usize); +add_sub_const_decimals!(63usize, 46usize, 109usize, 17usize); +add_sub_const_decimals!(63usize, 45usize, 108usize, 18usize); +add_sub_const_decimals!(63usize, 44usize, 107usize, 19usize); +add_sub_const_decimals!(63usize, 43usize, 106usize, 20usize); +add_sub_const_decimals!(63usize, 42usize, 105usize, 21usize); +add_sub_const_decimals!(63usize, 41usize, 104usize, 22usize); +add_sub_const_decimals!(63usize, 40usize, 103usize, 23usize); +add_sub_const_decimals!(63usize, 39usize, 102usize, 24usize); +add_sub_const_decimals!(63usize, 38usize, 101usize, 25usize); +add_sub_const_decimals!(63usize, 37usize, 100usize, 26usize); +add_sub_const_decimals!(63usize, 36usize, 99usize, 27usize); +add_sub_const_decimals!(63usize, 35usize, 98usize, 28usize); +add_sub_const_decimals!(63usize, 34usize, 97usize, 29usize); +add_sub_const_decimals!(63usize, 33usize, 96usize, 30usize); +add_sub_const_decimals!(63usize, 32usize, 95usize, 31usize); +add_sub_const_decimals!(63usize, 31usize, 94usize, 32usize); +add_sub_const_decimals!(63usize, 30usize, 93usize, 33usize); +add_sub_const_decimals!(63usize, 29usize, 92usize, 34usize); +add_sub_const_decimals!(63usize, 28usize, 91usize, 35usize); +add_sub_const_decimals!(63usize, 27usize, 90usize, 36usize); +add_sub_const_decimals!(63usize, 26usize, 89usize, 37usize); +add_sub_const_decimals!(63usize, 25usize, 88usize, 38usize); +add_sub_const_decimals!(63usize, 24usize, 87usize, 39usize); +add_sub_const_decimals!(63usize, 23usize, 86usize, 40usize); +add_sub_const_decimals!(63usize, 22usize, 85usize, 41usize); +add_sub_const_decimals!(63usize, 21usize, 84usize, 42usize); +add_sub_const_decimals!(63usize, 20usize, 83usize, 43usize); +add_sub_const_decimals!(63usize, 19usize, 82usize, 44usize); +add_sub_const_decimals!(63usize, 18usize, 81usize, 45usize); +add_sub_const_decimals!(63usize, 17usize, 80usize, 46usize); +add_sub_const_decimals!(63usize, 16usize, 79usize, 47usize); +add_sub_const_decimals!(63usize, 15usize, 78usize, 48usize); +add_sub_const_decimals!(63usize, 14usize, 77usize, 49usize); +add_sub_const_decimals!(63usize, 13usize, 76usize, 50usize); +add_sub_const_decimals!(63usize, 12usize, 75usize, 51usize); +add_sub_const_decimals!(63usize, 11usize, 74usize, 52usize); +add_sub_const_decimals!(63usize, 10usize, 73usize, 53usize); +add_sub_const_decimals!(63usize, 9usize, 72usize, 54usize); +add_sub_const_decimals!(63usize, 8usize, 71usize, 55usize); +add_sub_const_decimals!(63usize, 7usize, 70usize, 56usize); +add_sub_const_decimals!(63usize, 6usize, 69usize, 57usize); +add_sub_const_decimals!(63usize, 5usize, 68usize, 58usize); +add_sub_const_decimals!(63usize, 4usize, 67usize, 59usize); +add_sub_const_decimals!(63usize, 3usize, 66usize, 60usize); +add_sub_const_decimals!(63usize, 2usize, 65usize, 61usize); +add_sub_const_decimals!(63usize, 1usize, 64usize, 62usize); +add_sub_const_decimals!(63usize, 0usize, 63usize, 63usize); +add_sub_const_decimals!(62usize, 64usize, 126usize, 0usize); +add_sub_const_decimals!(62usize, 63usize, 125usize, 0usize); +add_sub_const_decimals!(62usize, 62usize, 124usize, 0usize); +add_sub_const_decimals!(62usize, 61usize, 123usize, 1usize); +add_sub_const_decimals!(62usize, 60usize, 122usize, 2usize); +add_sub_const_decimals!(62usize, 59usize, 121usize, 3usize); +add_sub_const_decimals!(62usize, 58usize, 120usize, 4usize); +add_sub_const_decimals!(62usize, 57usize, 119usize, 5usize); +add_sub_const_decimals!(62usize, 56usize, 118usize, 6usize); +add_sub_const_decimals!(62usize, 55usize, 117usize, 7usize); +add_sub_const_decimals!(62usize, 54usize, 116usize, 8usize); +add_sub_const_decimals!(62usize, 53usize, 115usize, 9usize); +add_sub_const_decimals!(62usize, 52usize, 114usize, 10usize); +add_sub_const_decimals!(62usize, 51usize, 113usize, 11usize); +add_sub_const_decimals!(62usize, 50usize, 112usize, 12usize); +add_sub_const_decimals!(62usize, 49usize, 111usize, 13usize); +add_sub_const_decimals!(62usize, 48usize, 110usize, 14usize); +add_sub_const_decimals!(62usize, 47usize, 109usize, 15usize); +add_sub_const_decimals!(62usize, 46usize, 108usize, 16usize); +add_sub_const_decimals!(62usize, 45usize, 107usize, 17usize); +add_sub_const_decimals!(62usize, 44usize, 106usize, 18usize); +add_sub_const_decimals!(62usize, 43usize, 105usize, 19usize); +add_sub_const_decimals!(62usize, 42usize, 104usize, 20usize); +add_sub_const_decimals!(62usize, 41usize, 103usize, 21usize); +add_sub_const_decimals!(62usize, 40usize, 102usize, 22usize); +add_sub_const_decimals!(62usize, 39usize, 101usize, 23usize); +add_sub_const_decimals!(62usize, 38usize, 100usize, 24usize); +add_sub_const_decimals!(62usize, 37usize, 99usize, 25usize); +add_sub_const_decimals!(62usize, 36usize, 98usize, 26usize); +add_sub_const_decimals!(62usize, 35usize, 97usize, 27usize); +add_sub_const_decimals!(62usize, 34usize, 96usize, 28usize); +add_sub_const_decimals!(62usize, 33usize, 95usize, 29usize); +add_sub_const_decimals!(62usize, 32usize, 94usize, 30usize); +add_sub_const_decimals!(62usize, 31usize, 93usize, 31usize); +add_sub_const_decimals!(62usize, 30usize, 92usize, 32usize); +add_sub_const_decimals!(62usize, 29usize, 91usize, 33usize); +add_sub_const_decimals!(62usize, 28usize, 90usize, 34usize); +add_sub_const_decimals!(62usize, 27usize, 89usize, 35usize); +add_sub_const_decimals!(62usize, 26usize, 88usize, 36usize); +add_sub_const_decimals!(62usize, 25usize, 87usize, 37usize); +add_sub_const_decimals!(62usize, 24usize, 86usize, 38usize); +add_sub_const_decimals!(62usize, 23usize, 85usize, 39usize); +add_sub_const_decimals!(62usize, 22usize, 84usize, 40usize); +add_sub_const_decimals!(62usize, 21usize, 83usize, 41usize); +add_sub_const_decimals!(62usize, 20usize, 82usize, 42usize); +add_sub_const_decimals!(62usize, 19usize, 81usize, 43usize); +add_sub_const_decimals!(62usize, 18usize, 80usize, 44usize); +add_sub_const_decimals!(62usize, 17usize, 79usize, 45usize); +add_sub_const_decimals!(62usize, 16usize, 78usize, 46usize); +add_sub_const_decimals!(62usize, 15usize, 77usize, 47usize); +add_sub_const_decimals!(62usize, 14usize, 76usize, 48usize); +add_sub_const_decimals!(62usize, 13usize, 75usize, 49usize); +add_sub_const_decimals!(62usize, 12usize, 74usize, 50usize); +add_sub_const_decimals!(62usize, 11usize, 73usize, 51usize); +add_sub_const_decimals!(62usize, 10usize, 72usize, 52usize); +add_sub_const_decimals!(62usize, 9usize, 71usize, 53usize); +add_sub_const_decimals!(62usize, 8usize, 70usize, 54usize); +add_sub_const_decimals!(62usize, 7usize, 69usize, 55usize); +add_sub_const_decimals!(62usize, 6usize, 68usize, 56usize); +add_sub_const_decimals!(62usize, 5usize, 67usize, 57usize); +add_sub_const_decimals!(62usize, 4usize, 66usize, 58usize); +add_sub_const_decimals!(62usize, 3usize, 65usize, 59usize); +add_sub_const_decimals!(62usize, 2usize, 64usize, 60usize); +add_sub_const_decimals!(62usize, 1usize, 63usize, 61usize); +add_sub_const_decimals!(62usize, 0usize, 62usize, 62usize); +add_sub_const_decimals!(61usize, 64usize, 125usize, 0usize); +add_sub_const_decimals!(61usize, 63usize, 124usize, 0usize); +add_sub_const_decimals!(61usize, 62usize, 123usize, 0usize); +add_sub_const_decimals!(61usize, 61usize, 122usize, 0usize); +add_sub_const_decimals!(61usize, 60usize, 121usize, 1usize); +add_sub_const_decimals!(61usize, 59usize, 120usize, 2usize); +add_sub_const_decimals!(61usize, 58usize, 119usize, 3usize); +add_sub_const_decimals!(61usize, 57usize, 118usize, 4usize); +add_sub_const_decimals!(61usize, 56usize, 117usize, 5usize); +add_sub_const_decimals!(61usize, 55usize, 116usize, 6usize); +add_sub_const_decimals!(61usize, 54usize, 115usize, 7usize); +add_sub_const_decimals!(61usize, 53usize, 114usize, 8usize); +add_sub_const_decimals!(61usize, 52usize, 113usize, 9usize); +add_sub_const_decimals!(61usize, 51usize, 112usize, 10usize); +add_sub_const_decimals!(61usize, 50usize, 111usize, 11usize); +add_sub_const_decimals!(61usize, 49usize, 110usize, 12usize); +add_sub_const_decimals!(61usize, 48usize, 109usize, 13usize); +add_sub_const_decimals!(61usize, 47usize, 108usize, 14usize); +add_sub_const_decimals!(61usize, 46usize, 107usize, 15usize); +add_sub_const_decimals!(61usize, 45usize, 106usize, 16usize); +add_sub_const_decimals!(61usize, 44usize, 105usize, 17usize); +add_sub_const_decimals!(61usize, 43usize, 104usize, 18usize); +add_sub_const_decimals!(61usize, 42usize, 103usize, 19usize); +add_sub_const_decimals!(61usize, 41usize, 102usize, 20usize); +add_sub_const_decimals!(61usize, 40usize, 101usize, 21usize); +add_sub_const_decimals!(61usize, 39usize, 100usize, 22usize); +add_sub_const_decimals!(61usize, 38usize, 99usize, 23usize); +add_sub_const_decimals!(61usize, 37usize, 98usize, 24usize); +add_sub_const_decimals!(61usize, 36usize, 97usize, 25usize); +add_sub_const_decimals!(61usize, 35usize, 96usize, 26usize); +add_sub_const_decimals!(61usize, 34usize, 95usize, 27usize); +add_sub_const_decimals!(61usize, 33usize, 94usize, 28usize); +add_sub_const_decimals!(61usize, 32usize, 93usize, 29usize); +add_sub_const_decimals!(61usize, 31usize, 92usize, 30usize); +add_sub_const_decimals!(61usize, 30usize, 91usize, 31usize); +add_sub_const_decimals!(61usize, 29usize, 90usize, 32usize); +add_sub_const_decimals!(61usize, 28usize, 89usize, 33usize); +add_sub_const_decimals!(61usize, 27usize, 88usize, 34usize); +add_sub_const_decimals!(61usize, 26usize, 87usize, 35usize); +add_sub_const_decimals!(61usize, 25usize, 86usize, 36usize); +add_sub_const_decimals!(61usize, 24usize, 85usize, 37usize); +add_sub_const_decimals!(61usize, 23usize, 84usize, 38usize); +add_sub_const_decimals!(61usize, 22usize, 83usize, 39usize); +add_sub_const_decimals!(61usize, 21usize, 82usize, 40usize); +add_sub_const_decimals!(61usize, 20usize, 81usize, 41usize); +add_sub_const_decimals!(61usize, 19usize, 80usize, 42usize); +add_sub_const_decimals!(61usize, 18usize, 79usize, 43usize); +add_sub_const_decimals!(61usize, 17usize, 78usize, 44usize); +add_sub_const_decimals!(61usize, 16usize, 77usize, 45usize); +add_sub_const_decimals!(61usize, 15usize, 76usize, 46usize); +add_sub_const_decimals!(61usize, 14usize, 75usize, 47usize); +add_sub_const_decimals!(61usize, 13usize, 74usize, 48usize); +add_sub_const_decimals!(61usize, 12usize, 73usize, 49usize); +add_sub_const_decimals!(61usize, 11usize, 72usize, 50usize); +add_sub_const_decimals!(61usize, 10usize, 71usize, 51usize); +add_sub_const_decimals!(61usize, 9usize, 70usize, 52usize); +add_sub_const_decimals!(61usize, 8usize, 69usize, 53usize); +add_sub_const_decimals!(61usize, 7usize, 68usize, 54usize); +add_sub_const_decimals!(61usize, 6usize, 67usize, 55usize); +add_sub_const_decimals!(61usize, 5usize, 66usize, 56usize); +add_sub_const_decimals!(61usize, 4usize, 65usize, 57usize); +add_sub_const_decimals!(61usize, 3usize, 64usize, 58usize); +add_sub_const_decimals!(61usize, 2usize, 63usize, 59usize); +add_sub_const_decimals!(61usize, 1usize, 62usize, 60usize); +add_sub_const_decimals!(61usize, 0usize, 61usize, 61usize); +add_sub_const_decimals!(60usize, 64usize, 124usize, 0usize); +add_sub_const_decimals!(60usize, 63usize, 123usize, 0usize); +add_sub_const_decimals!(60usize, 62usize, 122usize, 0usize); +add_sub_const_decimals!(60usize, 61usize, 121usize, 0usize); +add_sub_const_decimals!(60usize, 60usize, 120usize, 0usize); +add_sub_const_decimals!(60usize, 59usize, 119usize, 1usize); +add_sub_const_decimals!(60usize, 58usize, 118usize, 2usize); +add_sub_const_decimals!(60usize, 57usize, 117usize, 3usize); +add_sub_const_decimals!(60usize, 56usize, 116usize, 4usize); +add_sub_const_decimals!(60usize, 55usize, 115usize, 5usize); +add_sub_const_decimals!(60usize, 54usize, 114usize, 6usize); +add_sub_const_decimals!(60usize, 53usize, 113usize, 7usize); +add_sub_const_decimals!(60usize, 52usize, 112usize, 8usize); +add_sub_const_decimals!(60usize, 51usize, 111usize, 9usize); +add_sub_const_decimals!(60usize, 50usize, 110usize, 10usize); +add_sub_const_decimals!(60usize, 49usize, 109usize, 11usize); +add_sub_const_decimals!(60usize, 48usize, 108usize, 12usize); +add_sub_const_decimals!(60usize, 47usize, 107usize, 13usize); +add_sub_const_decimals!(60usize, 46usize, 106usize, 14usize); +add_sub_const_decimals!(60usize, 45usize, 105usize, 15usize); +add_sub_const_decimals!(60usize, 44usize, 104usize, 16usize); +add_sub_const_decimals!(60usize, 43usize, 103usize, 17usize); +add_sub_const_decimals!(60usize, 42usize, 102usize, 18usize); +add_sub_const_decimals!(60usize, 41usize, 101usize, 19usize); +add_sub_const_decimals!(60usize, 40usize, 100usize, 20usize); +add_sub_const_decimals!(60usize, 39usize, 99usize, 21usize); +add_sub_const_decimals!(60usize, 38usize, 98usize, 22usize); +add_sub_const_decimals!(60usize, 37usize, 97usize, 23usize); +add_sub_const_decimals!(60usize, 36usize, 96usize, 24usize); +add_sub_const_decimals!(60usize, 35usize, 95usize, 25usize); +add_sub_const_decimals!(60usize, 34usize, 94usize, 26usize); +add_sub_const_decimals!(60usize, 33usize, 93usize, 27usize); +add_sub_const_decimals!(60usize, 32usize, 92usize, 28usize); +add_sub_const_decimals!(60usize, 31usize, 91usize, 29usize); +add_sub_const_decimals!(60usize, 30usize, 90usize, 30usize); +add_sub_const_decimals!(60usize, 29usize, 89usize, 31usize); +add_sub_const_decimals!(60usize, 28usize, 88usize, 32usize); +add_sub_const_decimals!(60usize, 27usize, 87usize, 33usize); +add_sub_const_decimals!(60usize, 26usize, 86usize, 34usize); +add_sub_const_decimals!(60usize, 25usize, 85usize, 35usize); +add_sub_const_decimals!(60usize, 24usize, 84usize, 36usize); +add_sub_const_decimals!(60usize, 23usize, 83usize, 37usize); +add_sub_const_decimals!(60usize, 22usize, 82usize, 38usize); +add_sub_const_decimals!(60usize, 21usize, 81usize, 39usize); +add_sub_const_decimals!(60usize, 20usize, 80usize, 40usize); +add_sub_const_decimals!(60usize, 19usize, 79usize, 41usize); +add_sub_const_decimals!(60usize, 18usize, 78usize, 42usize); +add_sub_const_decimals!(60usize, 17usize, 77usize, 43usize); +add_sub_const_decimals!(60usize, 16usize, 76usize, 44usize); +add_sub_const_decimals!(60usize, 15usize, 75usize, 45usize); +add_sub_const_decimals!(60usize, 14usize, 74usize, 46usize); +add_sub_const_decimals!(60usize, 13usize, 73usize, 47usize); +add_sub_const_decimals!(60usize, 12usize, 72usize, 48usize); +add_sub_const_decimals!(60usize, 11usize, 71usize, 49usize); +add_sub_const_decimals!(60usize, 10usize, 70usize, 50usize); +add_sub_const_decimals!(60usize, 9usize, 69usize, 51usize); +add_sub_const_decimals!(60usize, 8usize, 68usize, 52usize); +add_sub_const_decimals!(60usize, 7usize, 67usize, 53usize); +add_sub_const_decimals!(60usize, 6usize, 66usize, 54usize); +add_sub_const_decimals!(60usize, 5usize, 65usize, 55usize); +add_sub_const_decimals!(60usize, 4usize, 64usize, 56usize); +add_sub_const_decimals!(60usize, 3usize, 63usize, 57usize); +add_sub_const_decimals!(60usize, 2usize, 62usize, 58usize); +add_sub_const_decimals!(60usize, 1usize, 61usize, 59usize); +add_sub_const_decimals!(60usize, 0usize, 60usize, 60usize); +add_sub_const_decimals!(59usize, 64usize, 123usize, 0usize); +add_sub_const_decimals!(59usize, 63usize, 122usize, 0usize); +add_sub_const_decimals!(59usize, 62usize, 121usize, 0usize); +add_sub_const_decimals!(59usize, 61usize, 120usize, 0usize); +add_sub_const_decimals!(59usize, 60usize, 119usize, 0usize); +add_sub_const_decimals!(59usize, 59usize, 118usize, 0usize); +add_sub_const_decimals!(59usize, 58usize, 117usize, 1usize); +add_sub_const_decimals!(59usize, 57usize, 116usize, 2usize); +add_sub_const_decimals!(59usize, 56usize, 115usize, 3usize); +add_sub_const_decimals!(59usize, 55usize, 114usize, 4usize); +add_sub_const_decimals!(59usize, 54usize, 113usize, 5usize); +add_sub_const_decimals!(59usize, 53usize, 112usize, 6usize); +add_sub_const_decimals!(59usize, 52usize, 111usize, 7usize); +add_sub_const_decimals!(59usize, 51usize, 110usize, 8usize); +add_sub_const_decimals!(59usize, 50usize, 109usize, 9usize); +add_sub_const_decimals!(59usize, 49usize, 108usize, 10usize); +add_sub_const_decimals!(59usize, 48usize, 107usize, 11usize); +add_sub_const_decimals!(59usize, 47usize, 106usize, 12usize); +add_sub_const_decimals!(59usize, 46usize, 105usize, 13usize); +add_sub_const_decimals!(59usize, 45usize, 104usize, 14usize); +add_sub_const_decimals!(59usize, 44usize, 103usize, 15usize); +add_sub_const_decimals!(59usize, 43usize, 102usize, 16usize); +add_sub_const_decimals!(59usize, 42usize, 101usize, 17usize); +add_sub_const_decimals!(59usize, 41usize, 100usize, 18usize); +add_sub_const_decimals!(59usize, 40usize, 99usize, 19usize); +add_sub_const_decimals!(59usize, 39usize, 98usize, 20usize); +add_sub_const_decimals!(59usize, 38usize, 97usize, 21usize); +add_sub_const_decimals!(59usize, 37usize, 96usize, 22usize); +add_sub_const_decimals!(59usize, 36usize, 95usize, 23usize); +add_sub_const_decimals!(59usize, 35usize, 94usize, 24usize); +add_sub_const_decimals!(59usize, 34usize, 93usize, 25usize); +add_sub_const_decimals!(59usize, 33usize, 92usize, 26usize); +add_sub_const_decimals!(59usize, 32usize, 91usize, 27usize); +add_sub_const_decimals!(59usize, 31usize, 90usize, 28usize); +add_sub_const_decimals!(59usize, 30usize, 89usize, 29usize); +add_sub_const_decimals!(59usize, 29usize, 88usize, 30usize); +add_sub_const_decimals!(59usize, 28usize, 87usize, 31usize); +add_sub_const_decimals!(59usize, 27usize, 86usize, 32usize); +add_sub_const_decimals!(59usize, 26usize, 85usize, 33usize); +add_sub_const_decimals!(59usize, 25usize, 84usize, 34usize); +add_sub_const_decimals!(59usize, 24usize, 83usize, 35usize); +add_sub_const_decimals!(59usize, 23usize, 82usize, 36usize); +add_sub_const_decimals!(59usize, 22usize, 81usize, 37usize); +add_sub_const_decimals!(59usize, 21usize, 80usize, 38usize); +add_sub_const_decimals!(59usize, 20usize, 79usize, 39usize); +add_sub_const_decimals!(59usize, 19usize, 78usize, 40usize); +add_sub_const_decimals!(59usize, 18usize, 77usize, 41usize); +add_sub_const_decimals!(59usize, 17usize, 76usize, 42usize); +add_sub_const_decimals!(59usize, 16usize, 75usize, 43usize); +add_sub_const_decimals!(59usize, 15usize, 74usize, 44usize); +add_sub_const_decimals!(59usize, 14usize, 73usize, 45usize); +add_sub_const_decimals!(59usize, 13usize, 72usize, 46usize); +add_sub_const_decimals!(59usize, 12usize, 71usize, 47usize); +add_sub_const_decimals!(59usize, 11usize, 70usize, 48usize); +add_sub_const_decimals!(59usize, 10usize, 69usize, 49usize); +add_sub_const_decimals!(59usize, 9usize, 68usize, 50usize); +add_sub_const_decimals!(59usize, 8usize, 67usize, 51usize); +add_sub_const_decimals!(59usize, 7usize, 66usize, 52usize); +add_sub_const_decimals!(59usize, 6usize, 65usize, 53usize); +add_sub_const_decimals!(59usize, 5usize, 64usize, 54usize); +add_sub_const_decimals!(59usize, 4usize, 63usize, 55usize); +add_sub_const_decimals!(59usize, 3usize, 62usize, 56usize); +add_sub_const_decimals!(59usize, 2usize, 61usize, 57usize); +add_sub_const_decimals!(59usize, 1usize, 60usize, 58usize); +add_sub_const_decimals!(59usize, 0usize, 59usize, 59usize); +add_sub_const_decimals!(58usize, 64usize, 122usize, 0usize); +add_sub_const_decimals!(58usize, 63usize, 121usize, 0usize); +add_sub_const_decimals!(58usize, 62usize, 120usize, 0usize); +add_sub_const_decimals!(58usize, 61usize, 119usize, 0usize); +add_sub_const_decimals!(58usize, 60usize, 118usize, 0usize); +add_sub_const_decimals!(58usize, 59usize, 117usize, 0usize); +add_sub_const_decimals!(58usize, 58usize, 116usize, 0usize); +add_sub_const_decimals!(58usize, 57usize, 115usize, 1usize); +add_sub_const_decimals!(58usize, 56usize, 114usize, 2usize); +add_sub_const_decimals!(58usize, 55usize, 113usize, 3usize); +add_sub_const_decimals!(58usize, 54usize, 112usize, 4usize); +add_sub_const_decimals!(58usize, 53usize, 111usize, 5usize); +add_sub_const_decimals!(58usize, 52usize, 110usize, 6usize); +add_sub_const_decimals!(58usize, 51usize, 109usize, 7usize); +add_sub_const_decimals!(58usize, 50usize, 108usize, 8usize); +add_sub_const_decimals!(58usize, 49usize, 107usize, 9usize); +add_sub_const_decimals!(58usize, 48usize, 106usize, 10usize); +add_sub_const_decimals!(58usize, 47usize, 105usize, 11usize); +add_sub_const_decimals!(58usize, 46usize, 104usize, 12usize); +add_sub_const_decimals!(58usize, 45usize, 103usize, 13usize); +add_sub_const_decimals!(58usize, 44usize, 102usize, 14usize); +add_sub_const_decimals!(58usize, 43usize, 101usize, 15usize); +add_sub_const_decimals!(58usize, 42usize, 100usize, 16usize); +add_sub_const_decimals!(58usize, 41usize, 99usize, 17usize); +add_sub_const_decimals!(58usize, 40usize, 98usize, 18usize); +add_sub_const_decimals!(58usize, 39usize, 97usize, 19usize); +add_sub_const_decimals!(58usize, 38usize, 96usize, 20usize); +add_sub_const_decimals!(58usize, 37usize, 95usize, 21usize); +add_sub_const_decimals!(58usize, 36usize, 94usize, 22usize); +add_sub_const_decimals!(58usize, 35usize, 93usize, 23usize); +add_sub_const_decimals!(58usize, 34usize, 92usize, 24usize); +add_sub_const_decimals!(58usize, 33usize, 91usize, 25usize); +add_sub_const_decimals!(58usize, 32usize, 90usize, 26usize); +add_sub_const_decimals!(58usize, 31usize, 89usize, 27usize); +add_sub_const_decimals!(58usize, 30usize, 88usize, 28usize); +add_sub_const_decimals!(58usize, 29usize, 87usize, 29usize); +add_sub_const_decimals!(58usize, 28usize, 86usize, 30usize); +add_sub_const_decimals!(58usize, 27usize, 85usize, 31usize); +add_sub_const_decimals!(58usize, 26usize, 84usize, 32usize); +add_sub_const_decimals!(58usize, 25usize, 83usize, 33usize); +add_sub_const_decimals!(58usize, 24usize, 82usize, 34usize); +add_sub_const_decimals!(58usize, 23usize, 81usize, 35usize); +add_sub_const_decimals!(58usize, 22usize, 80usize, 36usize); +add_sub_const_decimals!(58usize, 21usize, 79usize, 37usize); +add_sub_const_decimals!(58usize, 20usize, 78usize, 38usize); +add_sub_const_decimals!(58usize, 19usize, 77usize, 39usize); +add_sub_const_decimals!(58usize, 18usize, 76usize, 40usize); +add_sub_const_decimals!(58usize, 17usize, 75usize, 41usize); +add_sub_const_decimals!(58usize, 16usize, 74usize, 42usize); +add_sub_const_decimals!(58usize, 15usize, 73usize, 43usize); +add_sub_const_decimals!(58usize, 14usize, 72usize, 44usize); +add_sub_const_decimals!(58usize, 13usize, 71usize, 45usize); +add_sub_const_decimals!(58usize, 12usize, 70usize, 46usize); +add_sub_const_decimals!(58usize, 11usize, 69usize, 47usize); +add_sub_const_decimals!(58usize, 10usize, 68usize, 48usize); +add_sub_const_decimals!(58usize, 9usize, 67usize, 49usize); +add_sub_const_decimals!(58usize, 8usize, 66usize, 50usize); +add_sub_const_decimals!(58usize, 7usize, 65usize, 51usize); +add_sub_const_decimals!(58usize, 6usize, 64usize, 52usize); +add_sub_const_decimals!(58usize, 5usize, 63usize, 53usize); +add_sub_const_decimals!(58usize, 4usize, 62usize, 54usize); +add_sub_const_decimals!(58usize, 3usize, 61usize, 55usize); +add_sub_const_decimals!(58usize, 2usize, 60usize, 56usize); +add_sub_const_decimals!(58usize, 1usize, 59usize, 57usize); +add_sub_const_decimals!(58usize, 0usize, 58usize, 58usize); +add_sub_const_decimals!(57usize, 64usize, 121usize, 0usize); +add_sub_const_decimals!(57usize, 63usize, 120usize, 0usize); +add_sub_const_decimals!(57usize, 62usize, 119usize, 0usize); +add_sub_const_decimals!(57usize, 61usize, 118usize, 0usize); +add_sub_const_decimals!(57usize, 60usize, 117usize, 0usize); +add_sub_const_decimals!(57usize, 59usize, 116usize, 0usize); +add_sub_const_decimals!(57usize, 58usize, 115usize, 0usize); +add_sub_const_decimals!(57usize, 57usize, 114usize, 0usize); +add_sub_const_decimals!(57usize, 56usize, 113usize, 1usize); +add_sub_const_decimals!(57usize, 55usize, 112usize, 2usize); +add_sub_const_decimals!(57usize, 54usize, 111usize, 3usize); +add_sub_const_decimals!(57usize, 53usize, 110usize, 4usize); +add_sub_const_decimals!(57usize, 52usize, 109usize, 5usize); +add_sub_const_decimals!(57usize, 51usize, 108usize, 6usize); +add_sub_const_decimals!(57usize, 50usize, 107usize, 7usize); +add_sub_const_decimals!(57usize, 49usize, 106usize, 8usize); +add_sub_const_decimals!(57usize, 48usize, 105usize, 9usize); +add_sub_const_decimals!(57usize, 47usize, 104usize, 10usize); +add_sub_const_decimals!(57usize, 46usize, 103usize, 11usize); +add_sub_const_decimals!(57usize, 45usize, 102usize, 12usize); +add_sub_const_decimals!(57usize, 44usize, 101usize, 13usize); +add_sub_const_decimals!(57usize, 43usize, 100usize, 14usize); +add_sub_const_decimals!(57usize, 42usize, 99usize, 15usize); +add_sub_const_decimals!(57usize, 41usize, 98usize, 16usize); +add_sub_const_decimals!(57usize, 40usize, 97usize, 17usize); +add_sub_const_decimals!(57usize, 39usize, 96usize, 18usize); +add_sub_const_decimals!(57usize, 38usize, 95usize, 19usize); +add_sub_const_decimals!(57usize, 37usize, 94usize, 20usize); +add_sub_const_decimals!(57usize, 36usize, 93usize, 21usize); +add_sub_const_decimals!(57usize, 35usize, 92usize, 22usize); +add_sub_const_decimals!(57usize, 34usize, 91usize, 23usize); +add_sub_const_decimals!(57usize, 33usize, 90usize, 24usize); +add_sub_const_decimals!(57usize, 32usize, 89usize, 25usize); +add_sub_const_decimals!(57usize, 31usize, 88usize, 26usize); +add_sub_const_decimals!(57usize, 30usize, 87usize, 27usize); +add_sub_const_decimals!(57usize, 29usize, 86usize, 28usize); +add_sub_const_decimals!(57usize, 28usize, 85usize, 29usize); +add_sub_const_decimals!(57usize, 27usize, 84usize, 30usize); +add_sub_const_decimals!(57usize, 26usize, 83usize, 31usize); +add_sub_const_decimals!(57usize, 25usize, 82usize, 32usize); +add_sub_const_decimals!(57usize, 24usize, 81usize, 33usize); +add_sub_const_decimals!(57usize, 23usize, 80usize, 34usize); +add_sub_const_decimals!(57usize, 22usize, 79usize, 35usize); +add_sub_const_decimals!(57usize, 21usize, 78usize, 36usize); +add_sub_const_decimals!(57usize, 20usize, 77usize, 37usize); +add_sub_const_decimals!(57usize, 19usize, 76usize, 38usize); +add_sub_const_decimals!(57usize, 18usize, 75usize, 39usize); +add_sub_const_decimals!(57usize, 17usize, 74usize, 40usize); +add_sub_const_decimals!(57usize, 16usize, 73usize, 41usize); +add_sub_const_decimals!(57usize, 15usize, 72usize, 42usize); +add_sub_const_decimals!(57usize, 14usize, 71usize, 43usize); +add_sub_const_decimals!(57usize, 13usize, 70usize, 44usize); +add_sub_const_decimals!(57usize, 12usize, 69usize, 45usize); +add_sub_const_decimals!(57usize, 11usize, 68usize, 46usize); +add_sub_const_decimals!(57usize, 10usize, 67usize, 47usize); +add_sub_const_decimals!(57usize, 9usize, 66usize, 48usize); +add_sub_const_decimals!(57usize, 8usize, 65usize, 49usize); +add_sub_const_decimals!(57usize, 7usize, 64usize, 50usize); +add_sub_const_decimals!(57usize, 6usize, 63usize, 51usize); +add_sub_const_decimals!(57usize, 5usize, 62usize, 52usize); +add_sub_const_decimals!(57usize, 4usize, 61usize, 53usize); +add_sub_const_decimals!(57usize, 3usize, 60usize, 54usize); +add_sub_const_decimals!(57usize, 2usize, 59usize, 55usize); +add_sub_const_decimals!(57usize, 1usize, 58usize, 56usize); +add_sub_const_decimals!(57usize, 0usize, 57usize, 57usize); +add_sub_const_decimals!(56usize, 64usize, 120usize, 0usize); +add_sub_const_decimals!(56usize, 63usize, 119usize, 0usize); +add_sub_const_decimals!(56usize, 62usize, 118usize, 0usize); +add_sub_const_decimals!(56usize, 61usize, 117usize, 0usize); +add_sub_const_decimals!(56usize, 60usize, 116usize, 0usize); +add_sub_const_decimals!(56usize, 59usize, 115usize, 0usize); +add_sub_const_decimals!(56usize, 58usize, 114usize, 0usize); +add_sub_const_decimals!(56usize, 57usize, 113usize, 0usize); +add_sub_const_decimals!(56usize, 56usize, 112usize, 0usize); +add_sub_const_decimals!(56usize, 55usize, 111usize, 1usize); +add_sub_const_decimals!(56usize, 54usize, 110usize, 2usize); +add_sub_const_decimals!(56usize, 53usize, 109usize, 3usize); +add_sub_const_decimals!(56usize, 52usize, 108usize, 4usize); +add_sub_const_decimals!(56usize, 51usize, 107usize, 5usize); +add_sub_const_decimals!(56usize, 50usize, 106usize, 6usize); +add_sub_const_decimals!(56usize, 49usize, 105usize, 7usize); +add_sub_const_decimals!(56usize, 48usize, 104usize, 8usize); +add_sub_const_decimals!(56usize, 47usize, 103usize, 9usize); +add_sub_const_decimals!(56usize, 46usize, 102usize, 10usize); +add_sub_const_decimals!(56usize, 45usize, 101usize, 11usize); +add_sub_const_decimals!(56usize, 44usize, 100usize, 12usize); +add_sub_const_decimals!(56usize, 43usize, 99usize, 13usize); +add_sub_const_decimals!(56usize, 42usize, 98usize, 14usize); +add_sub_const_decimals!(56usize, 41usize, 97usize, 15usize); +add_sub_const_decimals!(56usize, 40usize, 96usize, 16usize); +add_sub_const_decimals!(56usize, 39usize, 95usize, 17usize); +add_sub_const_decimals!(56usize, 38usize, 94usize, 18usize); +add_sub_const_decimals!(56usize, 37usize, 93usize, 19usize); +add_sub_const_decimals!(56usize, 36usize, 92usize, 20usize); +add_sub_const_decimals!(56usize, 35usize, 91usize, 21usize); +add_sub_const_decimals!(56usize, 34usize, 90usize, 22usize); +add_sub_const_decimals!(56usize, 33usize, 89usize, 23usize); +add_sub_const_decimals!(56usize, 32usize, 88usize, 24usize); +add_sub_const_decimals!(56usize, 31usize, 87usize, 25usize); +add_sub_const_decimals!(56usize, 30usize, 86usize, 26usize); +add_sub_const_decimals!(56usize, 29usize, 85usize, 27usize); +add_sub_const_decimals!(56usize, 28usize, 84usize, 28usize); +add_sub_const_decimals!(56usize, 27usize, 83usize, 29usize); +add_sub_const_decimals!(56usize, 26usize, 82usize, 30usize); +add_sub_const_decimals!(56usize, 25usize, 81usize, 31usize); +add_sub_const_decimals!(56usize, 24usize, 80usize, 32usize); +add_sub_const_decimals!(56usize, 23usize, 79usize, 33usize); +add_sub_const_decimals!(56usize, 22usize, 78usize, 34usize); +add_sub_const_decimals!(56usize, 21usize, 77usize, 35usize); +add_sub_const_decimals!(56usize, 20usize, 76usize, 36usize); +add_sub_const_decimals!(56usize, 19usize, 75usize, 37usize); +add_sub_const_decimals!(56usize, 18usize, 74usize, 38usize); +add_sub_const_decimals!(56usize, 17usize, 73usize, 39usize); +add_sub_const_decimals!(56usize, 16usize, 72usize, 40usize); +add_sub_const_decimals!(56usize, 15usize, 71usize, 41usize); +add_sub_const_decimals!(56usize, 14usize, 70usize, 42usize); +add_sub_const_decimals!(56usize, 13usize, 69usize, 43usize); +add_sub_const_decimals!(56usize, 12usize, 68usize, 44usize); +add_sub_const_decimals!(56usize, 11usize, 67usize, 45usize); +add_sub_const_decimals!(56usize, 10usize, 66usize, 46usize); +add_sub_const_decimals!(56usize, 9usize, 65usize, 47usize); +add_sub_const_decimals!(56usize, 8usize, 64usize, 48usize); +add_sub_const_decimals!(56usize, 7usize, 63usize, 49usize); +add_sub_const_decimals!(56usize, 6usize, 62usize, 50usize); +add_sub_const_decimals!(56usize, 5usize, 61usize, 51usize); +add_sub_const_decimals!(56usize, 4usize, 60usize, 52usize); +add_sub_const_decimals!(56usize, 3usize, 59usize, 53usize); +add_sub_const_decimals!(56usize, 2usize, 58usize, 54usize); +add_sub_const_decimals!(56usize, 1usize, 57usize, 55usize); +add_sub_const_decimals!(56usize, 0usize, 56usize, 56usize); +add_sub_const_decimals!(55usize, 64usize, 119usize, 0usize); +add_sub_const_decimals!(55usize, 63usize, 118usize, 0usize); +add_sub_const_decimals!(55usize, 62usize, 117usize, 0usize); +add_sub_const_decimals!(55usize, 61usize, 116usize, 0usize); +add_sub_const_decimals!(55usize, 60usize, 115usize, 0usize); +add_sub_const_decimals!(55usize, 59usize, 114usize, 0usize); +add_sub_const_decimals!(55usize, 58usize, 113usize, 0usize); +add_sub_const_decimals!(55usize, 57usize, 112usize, 0usize); +add_sub_const_decimals!(55usize, 56usize, 111usize, 0usize); +add_sub_const_decimals!(55usize, 55usize, 110usize, 0usize); +add_sub_const_decimals!(55usize, 54usize, 109usize, 1usize); +add_sub_const_decimals!(55usize, 53usize, 108usize, 2usize); +add_sub_const_decimals!(55usize, 52usize, 107usize, 3usize); +add_sub_const_decimals!(55usize, 51usize, 106usize, 4usize); +add_sub_const_decimals!(55usize, 50usize, 105usize, 5usize); +add_sub_const_decimals!(55usize, 49usize, 104usize, 6usize); +add_sub_const_decimals!(55usize, 48usize, 103usize, 7usize); +add_sub_const_decimals!(55usize, 47usize, 102usize, 8usize); +add_sub_const_decimals!(55usize, 46usize, 101usize, 9usize); +add_sub_const_decimals!(55usize, 45usize, 100usize, 10usize); +add_sub_const_decimals!(55usize, 44usize, 99usize, 11usize); +add_sub_const_decimals!(55usize, 43usize, 98usize, 12usize); +add_sub_const_decimals!(55usize, 42usize, 97usize, 13usize); +add_sub_const_decimals!(55usize, 41usize, 96usize, 14usize); +add_sub_const_decimals!(55usize, 40usize, 95usize, 15usize); +add_sub_const_decimals!(55usize, 39usize, 94usize, 16usize); +add_sub_const_decimals!(55usize, 38usize, 93usize, 17usize); +add_sub_const_decimals!(55usize, 37usize, 92usize, 18usize); +add_sub_const_decimals!(55usize, 36usize, 91usize, 19usize); +add_sub_const_decimals!(55usize, 35usize, 90usize, 20usize); +add_sub_const_decimals!(55usize, 34usize, 89usize, 21usize); +add_sub_const_decimals!(55usize, 33usize, 88usize, 22usize); +add_sub_const_decimals!(55usize, 32usize, 87usize, 23usize); +add_sub_const_decimals!(55usize, 31usize, 86usize, 24usize); +add_sub_const_decimals!(55usize, 30usize, 85usize, 25usize); +add_sub_const_decimals!(55usize, 29usize, 84usize, 26usize); +add_sub_const_decimals!(55usize, 28usize, 83usize, 27usize); +add_sub_const_decimals!(55usize, 27usize, 82usize, 28usize); +add_sub_const_decimals!(55usize, 26usize, 81usize, 29usize); +add_sub_const_decimals!(55usize, 25usize, 80usize, 30usize); +add_sub_const_decimals!(55usize, 24usize, 79usize, 31usize); +add_sub_const_decimals!(55usize, 23usize, 78usize, 32usize); +add_sub_const_decimals!(55usize, 22usize, 77usize, 33usize); +add_sub_const_decimals!(55usize, 21usize, 76usize, 34usize); +add_sub_const_decimals!(55usize, 20usize, 75usize, 35usize); +add_sub_const_decimals!(55usize, 19usize, 74usize, 36usize); +add_sub_const_decimals!(55usize, 18usize, 73usize, 37usize); +add_sub_const_decimals!(55usize, 17usize, 72usize, 38usize); +add_sub_const_decimals!(55usize, 16usize, 71usize, 39usize); +add_sub_const_decimals!(55usize, 15usize, 70usize, 40usize); +add_sub_const_decimals!(55usize, 14usize, 69usize, 41usize); +add_sub_const_decimals!(55usize, 13usize, 68usize, 42usize); +add_sub_const_decimals!(55usize, 12usize, 67usize, 43usize); +add_sub_const_decimals!(55usize, 11usize, 66usize, 44usize); +add_sub_const_decimals!(55usize, 10usize, 65usize, 45usize); +add_sub_const_decimals!(55usize, 9usize, 64usize, 46usize); +add_sub_const_decimals!(55usize, 8usize, 63usize, 47usize); +add_sub_const_decimals!(55usize, 7usize, 62usize, 48usize); +add_sub_const_decimals!(55usize, 6usize, 61usize, 49usize); +add_sub_const_decimals!(55usize, 5usize, 60usize, 50usize); +add_sub_const_decimals!(55usize, 4usize, 59usize, 51usize); +add_sub_const_decimals!(55usize, 3usize, 58usize, 52usize); +add_sub_const_decimals!(55usize, 2usize, 57usize, 53usize); +add_sub_const_decimals!(55usize, 1usize, 56usize, 54usize); +add_sub_const_decimals!(55usize, 0usize, 55usize, 55usize); +add_sub_const_decimals!(54usize, 64usize, 118usize, 0usize); +add_sub_const_decimals!(54usize, 63usize, 117usize, 0usize); +add_sub_const_decimals!(54usize, 62usize, 116usize, 0usize); +add_sub_const_decimals!(54usize, 61usize, 115usize, 0usize); +add_sub_const_decimals!(54usize, 60usize, 114usize, 0usize); +add_sub_const_decimals!(54usize, 59usize, 113usize, 0usize); +add_sub_const_decimals!(54usize, 58usize, 112usize, 0usize); +add_sub_const_decimals!(54usize, 57usize, 111usize, 0usize); +add_sub_const_decimals!(54usize, 56usize, 110usize, 0usize); +add_sub_const_decimals!(54usize, 55usize, 109usize, 0usize); +add_sub_const_decimals!(54usize, 54usize, 108usize, 0usize); +add_sub_const_decimals!(54usize, 53usize, 107usize, 1usize); +add_sub_const_decimals!(54usize, 52usize, 106usize, 2usize); +add_sub_const_decimals!(54usize, 51usize, 105usize, 3usize); +add_sub_const_decimals!(54usize, 50usize, 104usize, 4usize); +add_sub_const_decimals!(54usize, 49usize, 103usize, 5usize); +add_sub_const_decimals!(54usize, 48usize, 102usize, 6usize); +add_sub_const_decimals!(54usize, 47usize, 101usize, 7usize); +add_sub_const_decimals!(54usize, 46usize, 100usize, 8usize); +add_sub_const_decimals!(54usize, 45usize, 99usize, 9usize); +add_sub_const_decimals!(54usize, 44usize, 98usize, 10usize); +add_sub_const_decimals!(54usize, 43usize, 97usize, 11usize); +add_sub_const_decimals!(54usize, 42usize, 96usize, 12usize); +add_sub_const_decimals!(54usize, 41usize, 95usize, 13usize); +add_sub_const_decimals!(54usize, 40usize, 94usize, 14usize); +add_sub_const_decimals!(54usize, 39usize, 93usize, 15usize); +add_sub_const_decimals!(54usize, 38usize, 92usize, 16usize); +add_sub_const_decimals!(54usize, 37usize, 91usize, 17usize); +add_sub_const_decimals!(54usize, 36usize, 90usize, 18usize); +add_sub_const_decimals!(54usize, 35usize, 89usize, 19usize); +add_sub_const_decimals!(54usize, 34usize, 88usize, 20usize); +add_sub_const_decimals!(54usize, 33usize, 87usize, 21usize); +add_sub_const_decimals!(54usize, 32usize, 86usize, 22usize); +add_sub_const_decimals!(54usize, 31usize, 85usize, 23usize); +add_sub_const_decimals!(54usize, 30usize, 84usize, 24usize); +add_sub_const_decimals!(54usize, 29usize, 83usize, 25usize); +add_sub_const_decimals!(54usize, 28usize, 82usize, 26usize); +add_sub_const_decimals!(54usize, 27usize, 81usize, 27usize); +add_sub_const_decimals!(54usize, 26usize, 80usize, 28usize); +add_sub_const_decimals!(54usize, 25usize, 79usize, 29usize); +add_sub_const_decimals!(54usize, 24usize, 78usize, 30usize); +add_sub_const_decimals!(54usize, 23usize, 77usize, 31usize); +add_sub_const_decimals!(54usize, 22usize, 76usize, 32usize); +add_sub_const_decimals!(54usize, 21usize, 75usize, 33usize); +add_sub_const_decimals!(54usize, 20usize, 74usize, 34usize); +add_sub_const_decimals!(54usize, 19usize, 73usize, 35usize); +add_sub_const_decimals!(54usize, 18usize, 72usize, 36usize); +add_sub_const_decimals!(54usize, 17usize, 71usize, 37usize); +add_sub_const_decimals!(54usize, 16usize, 70usize, 38usize); +add_sub_const_decimals!(54usize, 15usize, 69usize, 39usize); +add_sub_const_decimals!(54usize, 14usize, 68usize, 40usize); +add_sub_const_decimals!(54usize, 13usize, 67usize, 41usize); +add_sub_const_decimals!(54usize, 12usize, 66usize, 42usize); +add_sub_const_decimals!(54usize, 11usize, 65usize, 43usize); +add_sub_const_decimals!(54usize, 10usize, 64usize, 44usize); +add_sub_const_decimals!(54usize, 9usize, 63usize, 45usize); +add_sub_const_decimals!(54usize, 8usize, 62usize, 46usize); +add_sub_const_decimals!(54usize, 7usize, 61usize, 47usize); +add_sub_const_decimals!(54usize, 6usize, 60usize, 48usize); +add_sub_const_decimals!(54usize, 5usize, 59usize, 49usize); +add_sub_const_decimals!(54usize, 4usize, 58usize, 50usize); +add_sub_const_decimals!(54usize, 3usize, 57usize, 51usize); +add_sub_const_decimals!(54usize, 2usize, 56usize, 52usize); +add_sub_const_decimals!(54usize, 1usize, 55usize, 53usize); +add_sub_const_decimals!(54usize, 0usize, 54usize, 54usize); +add_sub_const_decimals!(53usize, 64usize, 117usize, 0usize); +add_sub_const_decimals!(53usize, 63usize, 116usize, 0usize); +add_sub_const_decimals!(53usize, 62usize, 115usize, 0usize); +add_sub_const_decimals!(53usize, 61usize, 114usize, 0usize); +add_sub_const_decimals!(53usize, 60usize, 113usize, 0usize); +add_sub_const_decimals!(53usize, 59usize, 112usize, 0usize); +add_sub_const_decimals!(53usize, 58usize, 111usize, 0usize); +add_sub_const_decimals!(53usize, 57usize, 110usize, 0usize); +add_sub_const_decimals!(53usize, 56usize, 109usize, 0usize); +add_sub_const_decimals!(53usize, 55usize, 108usize, 0usize); +add_sub_const_decimals!(53usize, 54usize, 107usize, 0usize); +add_sub_const_decimals!(53usize, 53usize, 106usize, 0usize); +add_sub_const_decimals!(53usize, 52usize, 105usize, 1usize); +add_sub_const_decimals!(53usize, 51usize, 104usize, 2usize); +add_sub_const_decimals!(53usize, 50usize, 103usize, 3usize); +add_sub_const_decimals!(53usize, 49usize, 102usize, 4usize); +add_sub_const_decimals!(53usize, 48usize, 101usize, 5usize); +add_sub_const_decimals!(53usize, 47usize, 100usize, 6usize); +add_sub_const_decimals!(53usize, 46usize, 99usize, 7usize); +add_sub_const_decimals!(53usize, 45usize, 98usize, 8usize); +add_sub_const_decimals!(53usize, 44usize, 97usize, 9usize); +add_sub_const_decimals!(53usize, 43usize, 96usize, 10usize); +add_sub_const_decimals!(53usize, 42usize, 95usize, 11usize); +add_sub_const_decimals!(53usize, 41usize, 94usize, 12usize); +add_sub_const_decimals!(53usize, 40usize, 93usize, 13usize); +add_sub_const_decimals!(53usize, 39usize, 92usize, 14usize); +add_sub_const_decimals!(53usize, 38usize, 91usize, 15usize); +add_sub_const_decimals!(53usize, 37usize, 90usize, 16usize); +add_sub_const_decimals!(53usize, 36usize, 89usize, 17usize); +add_sub_const_decimals!(53usize, 35usize, 88usize, 18usize); +add_sub_const_decimals!(53usize, 34usize, 87usize, 19usize); +add_sub_const_decimals!(53usize, 33usize, 86usize, 20usize); +add_sub_const_decimals!(53usize, 32usize, 85usize, 21usize); +add_sub_const_decimals!(53usize, 31usize, 84usize, 22usize); +add_sub_const_decimals!(53usize, 30usize, 83usize, 23usize); +add_sub_const_decimals!(53usize, 29usize, 82usize, 24usize); +add_sub_const_decimals!(53usize, 28usize, 81usize, 25usize); +add_sub_const_decimals!(53usize, 27usize, 80usize, 26usize); +add_sub_const_decimals!(53usize, 26usize, 79usize, 27usize); +add_sub_const_decimals!(53usize, 25usize, 78usize, 28usize); +add_sub_const_decimals!(53usize, 24usize, 77usize, 29usize); +add_sub_const_decimals!(53usize, 23usize, 76usize, 30usize); +add_sub_const_decimals!(53usize, 22usize, 75usize, 31usize); +add_sub_const_decimals!(53usize, 21usize, 74usize, 32usize); +add_sub_const_decimals!(53usize, 20usize, 73usize, 33usize); +add_sub_const_decimals!(53usize, 19usize, 72usize, 34usize); +add_sub_const_decimals!(53usize, 18usize, 71usize, 35usize); +add_sub_const_decimals!(53usize, 17usize, 70usize, 36usize); +add_sub_const_decimals!(53usize, 16usize, 69usize, 37usize); +add_sub_const_decimals!(53usize, 15usize, 68usize, 38usize); +add_sub_const_decimals!(53usize, 14usize, 67usize, 39usize); +add_sub_const_decimals!(53usize, 13usize, 66usize, 40usize); +add_sub_const_decimals!(53usize, 12usize, 65usize, 41usize); +add_sub_const_decimals!(53usize, 11usize, 64usize, 42usize); +add_sub_const_decimals!(53usize, 10usize, 63usize, 43usize); +add_sub_const_decimals!(53usize, 9usize, 62usize, 44usize); +add_sub_const_decimals!(53usize, 8usize, 61usize, 45usize); +add_sub_const_decimals!(53usize, 7usize, 60usize, 46usize); +add_sub_const_decimals!(53usize, 6usize, 59usize, 47usize); +add_sub_const_decimals!(53usize, 5usize, 58usize, 48usize); +add_sub_const_decimals!(53usize, 4usize, 57usize, 49usize); +add_sub_const_decimals!(53usize, 3usize, 56usize, 50usize); +add_sub_const_decimals!(53usize, 2usize, 55usize, 51usize); +add_sub_const_decimals!(53usize, 1usize, 54usize, 52usize); +add_sub_const_decimals!(53usize, 0usize, 53usize, 53usize); +add_sub_const_decimals!(52usize, 64usize, 116usize, 0usize); +add_sub_const_decimals!(52usize, 63usize, 115usize, 0usize); +add_sub_const_decimals!(52usize, 62usize, 114usize, 0usize); +add_sub_const_decimals!(52usize, 61usize, 113usize, 0usize); +add_sub_const_decimals!(52usize, 60usize, 112usize, 0usize); +add_sub_const_decimals!(52usize, 59usize, 111usize, 0usize); +add_sub_const_decimals!(52usize, 58usize, 110usize, 0usize); +add_sub_const_decimals!(52usize, 57usize, 109usize, 0usize); +add_sub_const_decimals!(52usize, 56usize, 108usize, 0usize); +add_sub_const_decimals!(52usize, 55usize, 107usize, 0usize); +add_sub_const_decimals!(52usize, 54usize, 106usize, 0usize); +add_sub_const_decimals!(52usize, 53usize, 105usize, 0usize); +add_sub_const_decimals!(52usize, 52usize, 104usize, 0usize); +add_sub_const_decimals!(52usize, 51usize, 103usize, 1usize); +add_sub_const_decimals!(52usize, 50usize, 102usize, 2usize); +add_sub_const_decimals!(52usize, 49usize, 101usize, 3usize); +add_sub_const_decimals!(52usize, 48usize, 100usize, 4usize); +add_sub_const_decimals!(52usize, 47usize, 99usize, 5usize); +add_sub_const_decimals!(52usize, 46usize, 98usize, 6usize); +add_sub_const_decimals!(52usize, 45usize, 97usize, 7usize); +add_sub_const_decimals!(52usize, 44usize, 96usize, 8usize); +add_sub_const_decimals!(52usize, 43usize, 95usize, 9usize); +add_sub_const_decimals!(52usize, 42usize, 94usize, 10usize); +add_sub_const_decimals!(52usize, 41usize, 93usize, 11usize); +add_sub_const_decimals!(52usize, 40usize, 92usize, 12usize); +add_sub_const_decimals!(52usize, 39usize, 91usize, 13usize); +add_sub_const_decimals!(52usize, 38usize, 90usize, 14usize); +add_sub_const_decimals!(52usize, 37usize, 89usize, 15usize); +add_sub_const_decimals!(52usize, 36usize, 88usize, 16usize); +add_sub_const_decimals!(52usize, 35usize, 87usize, 17usize); +add_sub_const_decimals!(52usize, 34usize, 86usize, 18usize); +add_sub_const_decimals!(52usize, 33usize, 85usize, 19usize); +add_sub_const_decimals!(52usize, 32usize, 84usize, 20usize); +add_sub_const_decimals!(52usize, 31usize, 83usize, 21usize); +add_sub_const_decimals!(52usize, 30usize, 82usize, 22usize); +add_sub_const_decimals!(52usize, 29usize, 81usize, 23usize); +add_sub_const_decimals!(52usize, 28usize, 80usize, 24usize); +add_sub_const_decimals!(52usize, 27usize, 79usize, 25usize); +add_sub_const_decimals!(52usize, 26usize, 78usize, 26usize); +add_sub_const_decimals!(52usize, 25usize, 77usize, 27usize); +add_sub_const_decimals!(52usize, 24usize, 76usize, 28usize); +add_sub_const_decimals!(52usize, 23usize, 75usize, 29usize); +add_sub_const_decimals!(52usize, 22usize, 74usize, 30usize); +add_sub_const_decimals!(52usize, 21usize, 73usize, 31usize); +add_sub_const_decimals!(52usize, 20usize, 72usize, 32usize); +add_sub_const_decimals!(52usize, 19usize, 71usize, 33usize); +add_sub_const_decimals!(52usize, 18usize, 70usize, 34usize); +add_sub_const_decimals!(52usize, 17usize, 69usize, 35usize); +add_sub_const_decimals!(52usize, 16usize, 68usize, 36usize); +add_sub_const_decimals!(52usize, 15usize, 67usize, 37usize); +add_sub_const_decimals!(52usize, 14usize, 66usize, 38usize); +add_sub_const_decimals!(52usize, 13usize, 65usize, 39usize); +add_sub_const_decimals!(52usize, 12usize, 64usize, 40usize); +add_sub_const_decimals!(52usize, 11usize, 63usize, 41usize); +add_sub_const_decimals!(52usize, 10usize, 62usize, 42usize); +add_sub_const_decimals!(52usize, 9usize, 61usize, 43usize); +add_sub_const_decimals!(52usize, 8usize, 60usize, 44usize); +add_sub_const_decimals!(52usize, 7usize, 59usize, 45usize); +add_sub_const_decimals!(52usize, 6usize, 58usize, 46usize); +add_sub_const_decimals!(52usize, 5usize, 57usize, 47usize); +add_sub_const_decimals!(52usize, 4usize, 56usize, 48usize); +add_sub_const_decimals!(52usize, 3usize, 55usize, 49usize); +add_sub_const_decimals!(52usize, 2usize, 54usize, 50usize); +add_sub_const_decimals!(52usize, 1usize, 53usize, 51usize); +add_sub_const_decimals!(52usize, 0usize, 52usize, 52usize); +add_sub_const_decimals!(51usize, 64usize, 115usize, 0usize); +add_sub_const_decimals!(51usize, 63usize, 114usize, 0usize); +add_sub_const_decimals!(51usize, 62usize, 113usize, 0usize); +add_sub_const_decimals!(51usize, 61usize, 112usize, 0usize); +add_sub_const_decimals!(51usize, 60usize, 111usize, 0usize); +add_sub_const_decimals!(51usize, 59usize, 110usize, 0usize); +add_sub_const_decimals!(51usize, 58usize, 109usize, 0usize); +add_sub_const_decimals!(51usize, 57usize, 108usize, 0usize); +add_sub_const_decimals!(51usize, 56usize, 107usize, 0usize); +add_sub_const_decimals!(51usize, 55usize, 106usize, 0usize); +add_sub_const_decimals!(51usize, 54usize, 105usize, 0usize); +add_sub_const_decimals!(51usize, 53usize, 104usize, 0usize); +add_sub_const_decimals!(51usize, 52usize, 103usize, 0usize); +add_sub_const_decimals!(51usize, 51usize, 102usize, 0usize); +add_sub_const_decimals!(51usize, 50usize, 101usize, 1usize); +add_sub_const_decimals!(51usize, 49usize, 100usize, 2usize); +add_sub_const_decimals!(51usize, 48usize, 99usize, 3usize); +add_sub_const_decimals!(51usize, 47usize, 98usize, 4usize); +add_sub_const_decimals!(51usize, 46usize, 97usize, 5usize); +add_sub_const_decimals!(51usize, 45usize, 96usize, 6usize); +add_sub_const_decimals!(51usize, 44usize, 95usize, 7usize); +add_sub_const_decimals!(51usize, 43usize, 94usize, 8usize); +add_sub_const_decimals!(51usize, 42usize, 93usize, 9usize); +add_sub_const_decimals!(51usize, 41usize, 92usize, 10usize); +add_sub_const_decimals!(51usize, 40usize, 91usize, 11usize); +add_sub_const_decimals!(51usize, 39usize, 90usize, 12usize); +add_sub_const_decimals!(51usize, 38usize, 89usize, 13usize); +add_sub_const_decimals!(51usize, 37usize, 88usize, 14usize); +add_sub_const_decimals!(51usize, 36usize, 87usize, 15usize); +add_sub_const_decimals!(51usize, 35usize, 86usize, 16usize); +add_sub_const_decimals!(51usize, 34usize, 85usize, 17usize); +add_sub_const_decimals!(51usize, 33usize, 84usize, 18usize); +add_sub_const_decimals!(51usize, 32usize, 83usize, 19usize); +add_sub_const_decimals!(51usize, 31usize, 82usize, 20usize); +add_sub_const_decimals!(51usize, 30usize, 81usize, 21usize); +add_sub_const_decimals!(51usize, 29usize, 80usize, 22usize); +add_sub_const_decimals!(51usize, 28usize, 79usize, 23usize); +add_sub_const_decimals!(51usize, 27usize, 78usize, 24usize); +add_sub_const_decimals!(51usize, 26usize, 77usize, 25usize); +add_sub_const_decimals!(51usize, 25usize, 76usize, 26usize); +add_sub_const_decimals!(51usize, 24usize, 75usize, 27usize); +add_sub_const_decimals!(51usize, 23usize, 74usize, 28usize); +add_sub_const_decimals!(51usize, 22usize, 73usize, 29usize); +add_sub_const_decimals!(51usize, 21usize, 72usize, 30usize); +add_sub_const_decimals!(51usize, 20usize, 71usize, 31usize); +add_sub_const_decimals!(51usize, 19usize, 70usize, 32usize); +add_sub_const_decimals!(51usize, 18usize, 69usize, 33usize); +add_sub_const_decimals!(51usize, 17usize, 68usize, 34usize); +add_sub_const_decimals!(51usize, 16usize, 67usize, 35usize); +add_sub_const_decimals!(51usize, 15usize, 66usize, 36usize); +add_sub_const_decimals!(51usize, 14usize, 65usize, 37usize); +add_sub_const_decimals!(51usize, 13usize, 64usize, 38usize); +add_sub_const_decimals!(51usize, 12usize, 63usize, 39usize); +add_sub_const_decimals!(51usize, 11usize, 62usize, 40usize); +add_sub_const_decimals!(51usize, 10usize, 61usize, 41usize); +add_sub_const_decimals!(51usize, 9usize, 60usize, 42usize); +add_sub_const_decimals!(51usize, 8usize, 59usize, 43usize); +add_sub_const_decimals!(51usize, 7usize, 58usize, 44usize); +add_sub_const_decimals!(51usize, 6usize, 57usize, 45usize); +add_sub_const_decimals!(51usize, 5usize, 56usize, 46usize); +add_sub_const_decimals!(51usize, 4usize, 55usize, 47usize); +add_sub_const_decimals!(51usize, 3usize, 54usize, 48usize); +add_sub_const_decimals!(51usize, 2usize, 53usize, 49usize); +add_sub_const_decimals!(51usize, 1usize, 52usize, 50usize); +add_sub_const_decimals!(51usize, 0usize, 51usize, 51usize); +add_sub_const_decimals!(50usize, 64usize, 114usize, 0usize); +add_sub_const_decimals!(50usize, 63usize, 113usize, 0usize); +add_sub_const_decimals!(50usize, 62usize, 112usize, 0usize); +add_sub_const_decimals!(50usize, 61usize, 111usize, 0usize); +add_sub_const_decimals!(50usize, 60usize, 110usize, 0usize); +add_sub_const_decimals!(50usize, 59usize, 109usize, 0usize); +add_sub_const_decimals!(50usize, 58usize, 108usize, 0usize); +add_sub_const_decimals!(50usize, 57usize, 107usize, 0usize); +add_sub_const_decimals!(50usize, 56usize, 106usize, 0usize); +add_sub_const_decimals!(50usize, 55usize, 105usize, 0usize); +add_sub_const_decimals!(50usize, 54usize, 104usize, 0usize); +add_sub_const_decimals!(50usize, 53usize, 103usize, 0usize); +add_sub_const_decimals!(50usize, 52usize, 102usize, 0usize); +add_sub_const_decimals!(50usize, 51usize, 101usize, 0usize); +add_sub_const_decimals!(50usize, 50usize, 100usize, 0usize); +add_sub_const_decimals!(50usize, 49usize, 99usize, 1usize); +add_sub_const_decimals!(50usize, 48usize, 98usize, 2usize); +add_sub_const_decimals!(50usize, 47usize, 97usize, 3usize); +add_sub_const_decimals!(50usize, 46usize, 96usize, 4usize); +add_sub_const_decimals!(50usize, 45usize, 95usize, 5usize); +add_sub_const_decimals!(50usize, 44usize, 94usize, 6usize); +add_sub_const_decimals!(50usize, 43usize, 93usize, 7usize); +add_sub_const_decimals!(50usize, 42usize, 92usize, 8usize); +add_sub_const_decimals!(50usize, 41usize, 91usize, 9usize); +add_sub_const_decimals!(50usize, 40usize, 90usize, 10usize); +add_sub_const_decimals!(50usize, 39usize, 89usize, 11usize); +add_sub_const_decimals!(50usize, 38usize, 88usize, 12usize); +add_sub_const_decimals!(50usize, 37usize, 87usize, 13usize); +add_sub_const_decimals!(50usize, 36usize, 86usize, 14usize); +add_sub_const_decimals!(50usize, 35usize, 85usize, 15usize); +add_sub_const_decimals!(50usize, 34usize, 84usize, 16usize); +add_sub_const_decimals!(50usize, 33usize, 83usize, 17usize); +add_sub_const_decimals!(50usize, 32usize, 82usize, 18usize); +add_sub_const_decimals!(50usize, 31usize, 81usize, 19usize); +add_sub_const_decimals!(50usize, 30usize, 80usize, 20usize); +add_sub_const_decimals!(50usize, 29usize, 79usize, 21usize); +add_sub_const_decimals!(50usize, 28usize, 78usize, 22usize); +add_sub_const_decimals!(50usize, 27usize, 77usize, 23usize); +add_sub_const_decimals!(50usize, 26usize, 76usize, 24usize); +add_sub_const_decimals!(50usize, 25usize, 75usize, 25usize); +add_sub_const_decimals!(50usize, 24usize, 74usize, 26usize); +add_sub_const_decimals!(50usize, 23usize, 73usize, 27usize); +add_sub_const_decimals!(50usize, 22usize, 72usize, 28usize); +add_sub_const_decimals!(50usize, 21usize, 71usize, 29usize); +add_sub_const_decimals!(50usize, 20usize, 70usize, 30usize); +add_sub_const_decimals!(50usize, 19usize, 69usize, 31usize); +add_sub_const_decimals!(50usize, 18usize, 68usize, 32usize); +add_sub_const_decimals!(50usize, 17usize, 67usize, 33usize); +add_sub_const_decimals!(50usize, 16usize, 66usize, 34usize); +add_sub_const_decimals!(50usize, 15usize, 65usize, 35usize); +add_sub_const_decimals!(50usize, 14usize, 64usize, 36usize); +add_sub_const_decimals!(50usize, 13usize, 63usize, 37usize); +add_sub_const_decimals!(50usize, 12usize, 62usize, 38usize); +add_sub_const_decimals!(50usize, 11usize, 61usize, 39usize); +add_sub_const_decimals!(50usize, 10usize, 60usize, 40usize); +add_sub_const_decimals!(50usize, 9usize, 59usize, 41usize); +add_sub_const_decimals!(50usize, 8usize, 58usize, 42usize); +add_sub_const_decimals!(50usize, 7usize, 57usize, 43usize); +add_sub_const_decimals!(50usize, 6usize, 56usize, 44usize); +add_sub_const_decimals!(50usize, 5usize, 55usize, 45usize); +add_sub_const_decimals!(50usize, 4usize, 54usize, 46usize); +add_sub_const_decimals!(50usize, 3usize, 53usize, 47usize); +add_sub_const_decimals!(50usize, 2usize, 52usize, 48usize); +add_sub_const_decimals!(50usize, 1usize, 51usize, 49usize); +add_sub_const_decimals!(50usize, 0usize, 50usize, 50usize); +add_sub_const_decimals!(49usize, 64usize, 113usize, 0usize); +add_sub_const_decimals!(49usize, 63usize, 112usize, 0usize); +add_sub_const_decimals!(49usize, 62usize, 111usize, 0usize); +add_sub_const_decimals!(49usize, 61usize, 110usize, 0usize); +add_sub_const_decimals!(49usize, 60usize, 109usize, 0usize); +add_sub_const_decimals!(49usize, 59usize, 108usize, 0usize); +add_sub_const_decimals!(49usize, 58usize, 107usize, 0usize); +add_sub_const_decimals!(49usize, 57usize, 106usize, 0usize); +add_sub_const_decimals!(49usize, 56usize, 105usize, 0usize); +add_sub_const_decimals!(49usize, 55usize, 104usize, 0usize); +add_sub_const_decimals!(49usize, 54usize, 103usize, 0usize); +add_sub_const_decimals!(49usize, 53usize, 102usize, 0usize); +add_sub_const_decimals!(49usize, 52usize, 101usize, 0usize); +add_sub_const_decimals!(49usize, 51usize, 100usize, 0usize); +add_sub_const_decimals!(49usize, 50usize, 99usize, 0usize); +add_sub_const_decimals!(49usize, 49usize, 98usize, 0usize); +add_sub_const_decimals!(49usize, 48usize, 97usize, 1usize); +add_sub_const_decimals!(49usize, 47usize, 96usize, 2usize); +add_sub_const_decimals!(49usize, 46usize, 95usize, 3usize); +add_sub_const_decimals!(49usize, 45usize, 94usize, 4usize); +add_sub_const_decimals!(49usize, 44usize, 93usize, 5usize); +add_sub_const_decimals!(49usize, 43usize, 92usize, 6usize); +add_sub_const_decimals!(49usize, 42usize, 91usize, 7usize); +add_sub_const_decimals!(49usize, 41usize, 90usize, 8usize); +add_sub_const_decimals!(49usize, 40usize, 89usize, 9usize); +add_sub_const_decimals!(49usize, 39usize, 88usize, 10usize); +add_sub_const_decimals!(49usize, 38usize, 87usize, 11usize); +add_sub_const_decimals!(49usize, 37usize, 86usize, 12usize); +add_sub_const_decimals!(49usize, 36usize, 85usize, 13usize); +add_sub_const_decimals!(49usize, 35usize, 84usize, 14usize); +add_sub_const_decimals!(49usize, 34usize, 83usize, 15usize); +add_sub_const_decimals!(49usize, 33usize, 82usize, 16usize); +add_sub_const_decimals!(49usize, 32usize, 81usize, 17usize); +add_sub_const_decimals!(49usize, 31usize, 80usize, 18usize); +add_sub_const_decimals!(49usize, 30usize, 79usize, 19usize); +add_sub_const_decimals!(49usize, 29usize, 78usize, 20usize); +add_sub_const_decimals!(49usize, 28usize, 77usize, 21usize); +add_sub_const_decimals!(49usize, 27usize, 76usize, 22usize); +add_sub_const_decimals!(49usize, 26usize, 75usize, 23usize); +add_sub_const_decimals!(49usize, 25usize, 74usize, 24usize); +add_sub_const_decimals!(49usize, 24usize, 73usize, 25usize); +add_sub_const_decimals!(49usize, 23usize, 72usize, 26usize); +add_sub_const_decimals!(49usize, 22usize, 71usize, 27usize); +add_sub_const_decimals!(49usize, 21usize, 70usize, 28usize); +add_sub_const_decimals!(49usize, 20usize, 69usize, 29usize); +add_sub_const_decimals!(49usize, 19usize, 68usize, 30usize); +add_sub_const_decimals!(49usize, 18usize, 67usize, 31usize); +add_sub_const_decimals!(49usize, 17usize, 66usize, 32usize); +add_sub_const_decimals!(49usize, 16usize, 65usize, 33usize); +add_sub_const_decimals!(49usize, 15usize, 64usize, 34usize); +add_sub_const_decimals!(49usize, 14usize, 63usize, 35usize); +add_sub_const_decimals!(49usize, 13usize, 62usize, 36usize); +add_sub_const_decimals!(49usize, 12usize, 61usize, 37usize); +add_sub_const_decimals!(49usize, 11usize, 60usize, 38usize); +add_sub_const_decimals!(49usize, 10usize, 59usize, 39usize); +add_sub_const_decimals!(49usize, 9usize, 58usize, 40usize); +add_sub_const_decimals!(49usize, 8usize, 57usize, 41usize); +add_sub_const_decimals!(49usize, 7usize, 56usize, 42usize); +add_sub_const_decimals!(49usize, 6usize, 55usize, 43usize); +add_sub_const_decimals!(49usize, 5usize, 54usize, 44usize); +add_sub_const_decimals!(49usize, 4usize, 53usize, 45usize); +add_sub_const_decimals!(49usize, 3usize, 52usize, 46usize); +add_sub_const_decimals!(49usize, 2usize, 51usize, 47usize); +add_sub_const_decimals!(49usize, 1usize, 50usize, 48usize); +add_sub_const_decimals!(49usize, 0usize, 49usize, 49usize); +add_sub_const_decimals!(48usize, 64usize, 112usize, 0usize); +add_sub_const_decimals!(48usize, 63usize, 111usize, 0usize); +add_sub_const_decimals!(48usize, 62usize, 110usize, 0usize); +add_sub_const_decimals!(48usize, 61usize, 109usize, 0usize); +add_sub_const_decimals!(48usize, 60usize, 108usize, 0usize); +add_sub_const_decimals!(48usize, 59usize, 107usize, 0usize); +add_sub_const_decimals!(48usize, 58usize, 106usize, 0usize); +add_sub_const_decimals!(48usize, 57usize, 105usize, 0usize); +add_sub_const_decimals!(48usize, 56usize, 104usize, 0usize); +add_sub_const_decimals!(48usize, 55usize, 103usize, 0usize); +add_sub_const_decimals!(48usize, 54usize, 102usize, 0usize); +add_sub_const_decimals!(48usize, 53usize, 101usize, 0usize); +add_sub_const_decimals!(48usize, 52usize, 100usize, 0usize); +add_sub_const_decimals!(48usize, 51usize, 99usize, 0usize); +add_sub_const_decimals!(48usize, 50usize, 98usize, 0usize); +add_sub_const_decimals!(48usize, 49usize, 97usize, 0usize); +add_sub_const_decimals!(48usize, 48usize, 96usize, 0usize); +add_sub_const_decimals!(48usize, 47usize, 95usize, 1usize); +add_sub_const_decimals!(48usize, 46usize, 94usize, 2usize); +add_sub_const_decimals!(48usize, 45usize, 93usize, 3usize); +add_sub_const_decimals!(48usize, 44usize, 92usize, 4usize); +add_sub_const_decimals!(48usize, 43usize, 91usize, 5usize); +add_sub_const_decimals!(48usize, 42usize, 90usize, 6usize); +add_sub_const_decimals!(48usize, 41usize, 89usize, 7usize); +add_sub_const_decimals!(48usize, 40usize, 88usize, 8usize); +add_sub_const_decimals!(48usize, 39usize, 87usize, 9usize); +add_sub_const_decimals!(48usize, 38usize, 86usize, 10usize); +add_sub_const_decimals!(48usize, 37usize, 85usize, 11usize); +add_sub_const_decimals!(48usize, 36usize, 84usize, 12usize); +add_sub_const_decimals!(48usize, 35usize, 83usize, 13usize); +add_sub_const_decimals!(48usize, 34usize, 82usize, 14usize); +add_sub_const_decimals!(48usize, 33usize, 81usize, 15usize); +add_sub_const_decimals!(48usize, 32usize, 80usize, 16usize); +add_sub_const_decimals!(48usize, 31usize, 79usize, 17usize); +add_sub_const_decimals!(48usize, 30usize, 78usize, 18usize); +add_sub_const_decimals!(48usize, 29usize, 77usize, 19usize); +add_sub_const_decimals!(48usize, 28usize, 76usize, 20usize); +add_sub_const_decimals!(48usize, 27usize, 75usize, 21usize); +add_sub_const_decimals!(48usize, 26usize, 74usize, 22usize); +add_sub_const_decimals!(48usize, 25usize, 73usize, 23usize); +add_sub_const_decimals!(48usize, 24usize, 72usize, 24usize); +add_sub_const_decimals!(48usize, 23usize, 71usize, 25usize); +add_sub_const_decimals!(48usize, 22usize, 70usize, 26usize); +add_sub_const_decimals!(48usize, 21usize, 69usize, 27usize); +add_sub_const_decimals!(48usize, 20usize, 68usize, 28usize); +add_sub_const_decimals!(48usize, 19usize, 67usize, 29usize); +add_sub_const_decimals!(48usize, 18usize, 66usize, 30usize); +add_sub_const_decimals!(48usize, 17usize, 65usize, 31usize); +add_sub_const_decimals!(48usize, 16usize, 64usize, 32usize); +add_sub_const_decimals!(48usize, 15usize, 63usize, 33usize); +add_sub_const_decimals!(48usize, 14usize, 62usize, 34usize); +add_sub_const_decimals!(48usize, 13usize, 61usize, 35usize); +add_sub_const_decimals!(48usize, 12usize, 60usize, 36usize); +add_sub_const_decimals!(48usize, 11usize, 59usize, 37usize); +add_sub_const_decimals!(48usize, 10usize, 58usize, 38usize); +add_sub_const_decimals!(48usize, 9usize, 57usize, 39usize); +add_sub_const_decimals!(48usize, 8usize, 56usize, 40usize); +add_sub_const_decimals!(48usize, 7usize, 55usize, 41usize); +add_sub_const_decimals!(48usize, 6usize, 54usize, 42usize); +add_sub_const_decimals!(48usize, 5usize, 53usize, 43usize); +add_sub_const_decimals!(48usize, 4usize, 52usize, 44usize); +add_sub_const_decimals!(48usize, 3usize, 51usize, 45usize); +add_sub_const_decimals!(48usize, 2usize, 50usize, 46usize); +add_sub_const_decimals!(48usize, 1usize, 49usize, 47usize); +add_sub_const_decimals!(48usize, 0usize, 48usize, 48usize); +add_sub_const_decimals!(47usize, 64usize, 111usize, 0usize); +add_sub_const_decimals!(47usize, 63usize, 110usize, 0usize); +add_sub_const_decimals!(47usize, 62usize, 109usize, 0usize); +add_sub_const_decimals!(47usize, 61usize, 108usize, 0usize); +add_sub_const_decimals!(47usize, 60usize, 107usize, 0usize); +add_sub_const_decimals!(47usize, 59usize, 106usize, 0usize); +add_sub_const_decimals!(47usize, 58usize, 105usize, 0usize); +add_sub_const_decimals!(47usize, 57usize, 104usize, 0usize); +add_sub_const_decimals!(47usize, 56usize, 103usize, 0usize); +add_sub_const_decimals!(47usize, 55usize, 102usize, 0usize); +add_sub_const_decimals!(47usize, 54usize, 101usize, 0usize); +add_sub_const_decimals!(47usize, 53usize, 100usize, 0usize); +add_sub_const_decimals!(47usize, 52usize, 99usize, 0usize); +add_sub_const_decimals!(47usize, 51usize, 98usize, 0usize); +add_sub_const_decimals!(47usize, 50usize, 97usize, 0usize); +add_sub_const_decimals!(47usize, 49usize, 96usize, 0usize); +add_sub_const_decimals!(47usize, 48usize, 95usize, 0usize); +add_sub_const_decimals!(47usize, 47usize, 94usize, 0usize); +add_sub_const_decimals!(47usize, 46usize, 93usize, 1usize); +add_sub_const_decimals!(47usize, 45usize, 92usize, 2usize); +add_sub_const_decimals!(47usize, 44usize, 91usize, 3usize); +add_sub_const_decimals!(47usize, 43usize, 90usize, 4usize); +add_sub_const_decimals!(47usize, 42usize, 89usize, 5usize); +add_sub_const_decimals!(47usize, 41usize, 88usize, 6usize); +add_sub_const_decimals!(47usize, 40usize, 87usize, 7usize); +add_sub_const_decimals!(47usize, 39usize, 86usize, 8usize); +add_sub_const_decimals!(47usize, 38usize, 85usize, 9usize); +add_sub_const_decimals!(47usize, 37usize, 84usize, 10usize); +add_sub_const_decimals!(47usize, 36usize, 83usize, 11usize); +add_sub_const_decimals!(47usize, 35usize, 82usize, 12usize); +add_sub_const_decimals!(47usize, 34usize, 81usize, 13usize); +add_sub_const_decimals!(47usize, 33usize, 80usize, 14usize); +add_sub_const_decimals!(47usize, 32usize, 79usize, 15usize); +add_sub_const_decimals!(47usize, 31usize, 78usize, 16usize); +add_sub_const_decimals!(47usize, 30usize, 77usize, 17usize); +add_sub_const_decimals!(47usize, 29usize, 76usize, 18usize); +add_sub_const_decimals!(47usize, 28usize, 75usize, 19usize); +add_sub_const_decimals!(47usize, 27usize, 74usize, 20usize); +add_sub_const_decimals!(47usize, 26usize, 73usize, 21usize); +add_sub_const_decimals!(47usize, 25usize, 72usize, 22usize); +add_sub_const_decimals!(47usize, 24usize, 71usize, 23usize); +add_sub_const_decimals!(47usize, 23usize, 70usize, 24usize); +add_sub_const_decimals!(47usize, 22usize, 69usize, 25usize); +add_sub_const_decimals!(47usize, 21usize, 68usize, 26usize); +add_sub_const_decimals!(47usize, 20usize, 67usize, 27usize); +add_sub_const_decimals!(47usize, 19usize, 66usize, 28usize); +add_sub_const_decimals!(47usize, 18usize, 65usize, 29usize); +add_sub_const_decimals!(47usize, 17usize, 64usize, 30usize); +add_sub_const_decimals!(47usize, 16usize, 63usize, 31usize); +add_sub_const_decimals!(47usize, 15usize, 62usize, 32usize); +add_sub_const_decimals!(47usize, 14usize, 61usize, 33usize); +add_sub_const_decimals!(47usize, 13usize, 60usize, 34usize); +add_sub_const_decimals!(47usize, 12usize, 59usize, 35usize); +add_sub_const_decimals!(47usize, 11usize, 58usize, 36usize); +add_sub_const_decimals!(47usize, 10usize, 57usize, 37usize); +add_sub_const_decimals!(47usize, 9usize, 56usize, 38usize); +add_sub_const_decimals!(47usize, 8usize, 55usize, 39usize); +add_sub_const_decimals!(47usize, 7usize, 54usize, 40usize); +add_sub_const_decimals!(47usize, 6usize, 53usize, 41usize); +add_sub_const_decimals!(47usize, 5usize, 52usize, 42usize); +add_sub_const_decimals!(47usize, 4usize, 51usize, 43usize); +add_sub_const_decimals!(47usize, 3usize, 50usize, 44usize); +add_sub_const_decimals!(47usize, 2usize, 49usize, 45usize); +add_sub_const_decimals!(47usize, 1usize, 48usize, 46usize); +add_sub_const_decimals!(47usize, 0usize, 47usize, 47usize); +add_sub_const_decimals!(46usize, 64usize, 110usize, 0usize); +add_sub_const_decimals!(46usize, 63usize, 109usize, 0usize); +add_sub_const_decimals!(46usize, 62usize, 108usize, 0usize); +add_sub_const_decimals!(46usize, 61usize, 107usize, 0usize); +add_sub_const_decimals!(46usize, 60usize, 106usize, 0usize); +add_sub_const_decimals!(46usize, 59usize, 105usize, 0usize); +add_sub_const_decimals!(46usize, 58usize, 104usize, 0usize); +add_sub_const_decimals!(46usize, 57usize, 103usize, 0usize); +add_sub_const_decimals!(46usize, 56usize, 102usize, 0usize); +add_sub_const_decimals!(46usize, 55usize, 101usize, 0usize); +add_sub_const_decimals!(46usize, 54usize, 100usize, 0usize); +add_sub_const_decimals!(46usize, 53usize, 99usize, 0usize); +add_sub_const_decimals!(46usize, 52usize, 98usize, 0usize); +add_sub_const_decimals!(46usize, 51usize, 97usize, 0usize); +add_sub_const_decimals!(46usize, 50usize, 96usize, 0usize); +add_sub_const_decimals!(46usize, 49usize, 95usize, 0usize); +add_sub_const_decimals!(46usize, 48usize, 94usize, 0usize); +add_sub_const_decimals!(46usize, 47usize, 93usize, 0usize); +add_sub_const_decimals!(46usize, 46usize, 92usize, 0usize); +add_sub_const_decimals!(46usize, 45usize, 91usize, 1usize); +add_sub_const_decimals!(46usize, 44usize, 90usize, 2usize); +add_sub_const_decimals!(46usize, 43usize, 89usize, 3usize); +add_sub_const_decimals!(46usize, 42usize, 88usize, 4usize); +add_sub_const_decimals!(46usize, 41usize, 87usize, 5usize); +add_sub_const_decimals!(46usize, 40usize, 86usize, 6usize); +add_sub_const_decimals!(46usize, 39usize, 85usize, 7usize); +add_sub_const_decimals!(46usize, 38usize, 84usize, 8usize); +add_sub_const_decimals!(46usize, 37usize, 83usize, 9usize); +add_sub_const_decimals!(46usize, 36usize, 82usize, 10usize); +add_sub_const_decimals!(46usize, 35usize, 81usize, 11usize); +add_sub_const_decimals!(46usize, 34usize, 80usize, 12usize); +add_sub_const_decimals!(46usize, 33usize, 79usize, 13usize); +add_sub_const_decimals!(46usize, 32usize, 78usize, 14usize); +add_sub_const_decimals!(46usize, 31usize, 77usize, 15usize); +add_sub_const_decimals!(46usize, 30usize, 76usize, 16usize); +add_sub_const_decimals!(46usize, 29usize, 75usize, 17usize); +add_sub_const_decimals!(46usize, 28usize, 74usize, 18usize); +add_sub_const_decimals!(46usize, 27usize, 73usize, 19usize); +add_sub_const_decimals!(46usize, 26usize, 72usize, 20usize); +add_sub_const_decimals!(46usize, 25usize, 71usize, 21usize); +add_sub_const_decimals!(46usize, 24usize, 70usize, 22usize); +add_sub_const_decimals!(46usize, 23usize, 69usize, 23usize); +add_sub_const_decimals!(46usize, 22usize, 68usize, 24usize); +add_sub_const_decimals!(46usize, 21usize, 67usize, 25usize); +add_sub_const_decimals!(46usize, 20usize, 66usize, 26usize); +add_sub_const_decimals!(46usize, 19usize, 65usize, 27usize); +add_sub_const_decimals!(46usize, 18usize, 64usize, 28usize); +add_sub_const_decimals!(46usize, 17usize, 63usize, 29usize); +add_sub_const_decimals!(46usize, 16usize, 62usize, 30usize); +add_sub_const_decimals!(46usize, 15usize, 61usize, 31usize); +add_sub_const_decimals!(46usize, 14usize, 60usize, 32usize); +add_sub_const_decimals!(46usize, 13usize, 59usize, 33usize); +add_sub_const_decimals!(46usize, 12usize, 58usize, 34usize); +add_sub_const_decimals!(46usize, 11usize, 57usize, 35usize); +add_sub_const_decimals!(46usize, 10usize, 56usize, 36usize); +add_sub_const_decimals!(46usize, 9usize, 55usize, 37usize); +add_sub_const_decimals!(46usize, 8usize, 54usize, 38usize); +add_sub_const_decimals!(46usize, 7usize, 53usize, 39usize); +add_sub_const_decimals!(46usize, 6usize, 52usize, 40usize); +add_sub_const_decimals!(46usize, 5usize, 51usize, 41usize); +add_sub_const_decimals!(46usize, 4usize, 50usize, 42usize); +add_sub_const_decimals!(46usize, 3usize, 49usize, 43usize); +add_sub_const_decimals!(46usize, 2usize, 48usize, 44usize); +add_sub_const_decimals!(46usize, 1usize, 47usize, 45usize); +add_sub_const_decimals!(46usize, 0usize, 46usize, 46usize); +add_sub_const_decimals!(45usize, 64usize, 109usize, 0usize); +add_sub_const_decimals!(45usize, 63usize, 108usize, 0usize); +add_sub_const_decimals!(45usize, 62usize, 107usize, 0usize); +add_sub_const_decimals!(45usize, 61usize, 106usize, 0usize); +add_sub_const_decimals!(45usize, 60usize, 105usize, 0usize); +add_sub_const_decimals!(45usize, 59usize, 104usize, 0usize); +add_sub_const_decimals!(45usize, 58usize, 103usize, 0usize); +add_sub_const_decimals!(45usize, 57usize, 102usize, 0usize); +add_sub_const_decimals!(45usize, 56usize, 101usize, 0usize); +add_sub_const_decimals!(45usize, 55usize, 100usize, 0usize); +add_sub_const_decimals!(45usize, 54usize, 99usize, 0usize); +add_sub_const_decimals!(45usize, 53usize, 98usize, 0usize); +add_sub_const_decimals!(45usize, 52usize, 97usize, 0usize); +add_sub_const_decimals!(45usize, 51usize, 96usize, 0usize); +add_sub_const_decimals!(45usize, 50usize, 95usize, 0usize); +add_sub_const_decimals!(45usize, 49usize, 94usize, 0usize); +add_sub_const_decimals!(45usize, 48usize, 93usize, 0usize); +add_sub_const_decimals!(45usize, 47usize, 92usize, 0usize); +add_sub_const_decimals!(45usize, 46usize, 91usize, 0usize); +add_sub_const_decimals!(45usize, 45usize, 90usize, 0usize); +add_sub_const_decimals!(45usize, 44usize, 89usize, 1usize); +add_sub_const_decimals!(45usize, 43usize, 88usize, 2usize); +add_sub_const_decimals!(45usize, 42usize, 87usize, 3usize); +add_sub_const_decimals!(45usize, 41usize, 86usize, 4usize); +add_sub_const_decimals!(45usize, 40usize, 85usize, 5usize); +add_sub_const_decimals!(45usize, 39usize, 84usize, 6usize); +add_sub_const_decimals!(45usize, 38usize, 83usize, 7usize); +add_sub_const_decimals!(45usize, 37usize, 82usize, 8usize); +add_sub_const_decimals!(45usize, 36usize, 81usize, 9usize); +add_sub_const_decimals!(45usize, 35usize, 80usize, 10usize); +add_sub_const_decimals!(45usize, 34usize, 79usize, 11usize); +add_sub_const_decimals!(45usize, 33usize, 78usize, 12usize); +add_sub_const_decimals!(45usize, 32usize, 77usize, 13usize); +add_sub_const_decimals!(45usize, 31usize, 76usize, 14usize); +add_sub_const_decimals!(45usize, 30usize, 75usize, 15usize); +add_sub_const_decimals!(45usize, 29usize, 74usize, 16usize); +add_sub_const_decimals!(45usize, 28usize, 73usize, 17usize); +add_sub_const_decimals!(45usize, 27usize, 72usize, 18usize); +add_sub_const_decimals!(45usize, 26usize, 71usize, 19usize); +add_sub_const_decimals!(45usize, 25usize, 70usize, 20usize); +add_sub_const_decimals!(45usize, 24usize, 69usize, 21usize); +add_sub_const_decimals!(45usize, 23usize, 68usize, 22usize); +add_sub_const_decimals!(45usize, 22usize, 67usize, 23usize); +add_sub_const_decimals!(45usize, 21usize, 66usize, 24usize); +add_sub_const_decimals!(45usize, 20usize, 65usize, 25usize); +add_sub_const_decimals!(45usize, 19usize, 64usize, 26usize); +add_sub_const_decimals!(45usize, 18usize, 63usize, 27usize); +add_sub_const_decimals!(45usize, 17usize, 62usize, 28usize); +add_sub_const_decimals!(45usize, 16usize, 61usize, 29usize); +add_sub_const_decimals!(45usize, 15usize, 60usize, 30usize); +add_sub_const_decimals!(45usize, 14usize, 59usize, 31usize); +add_sub_const_decimals!(45usize, 13usize, 58usize, 32usize); +add_sub_const_decimals!(45usize, 12usize, 57usize, 33usize); +add_sub_const_decimals!(45usize, 11usize, 56usize, 34usize); +add_sub_const_decimals!(45usize, 10usize, 55usize, 35usize); +add_sub_const_decimals!(45usize, 9usize, 54usize, 36usize); +add_sub_const_decimals!(45usize, 8usize, 53usize, 37usize); +add_sub_const_decimals!(45usize, 7usize, 52usize, 38usize); +add_sub_const_decimals!(45usize, 6usize, 51usize, 39usize); +add_sub_const_decimals!(45usize, 5usize, 50usize, 40usize); +add_sub_const_decimals!(45usize, 4usize, 49usize, 41usize); +add_sub_const_decimals!(45usize, 3usize, 48usize, 42usize); +add_sub_const_decimals!(45usize, 2usize, 47usize, 43usize); +add_sub_const_decimals!(45usize, 1usize, 46usize, 44usize); +add_sub_const_decimals!(45usize, 0usize, 45usize, 45usize); +add_sub_const_decimals!(44usize, 64usize, 108usize, 0usize); +add_sub_const_decimals!(44usize, 63usize, 107usize, 0usize); +add_sub_const_decimals!(44usize, 62usize, 106usize, 0usize); +add_sub_const_decimals!(44usize, 61usize, 105usize, 0usize); +add_sub_const_decimals!(44usize, 60usize, 104usize, 0usize); +add_sub_const_decimals!(44usize, 59usize, 103usize, 0usize); +add_sub_const_decimals!(44usize, 58usize, 102usize, 0usize); +add_sub_const_decimals!(44usize, 57usize, 101usize, 0usize); +add_sub_const_decimals!(44usize, 56usize, 100usize, 0usize); +add_sub_const_decimals!(44usize, 55usize, 99usize, 0usize); +add_sub_const_decimals!(44usize, 54usize, 98usize, 0usize); +add_sub_const_decimals!(44usize, 53usize, 97usize, 0usize); +add_sub_const_decimals!(44usize, 52usize, 96usize, 0usize); +add_sub_const_decimals!(44usize, 51usize, 95usize, 0usize); +add_sub_const_decimals!(44usize, 50usize, 94usize, 0usize); +add_sub_const_decimals!(44usize, 49usize, 93usize, 0usize); +add_sub_const_decimals!(44usize, 48usize, 92usize, 0usize); +add_sub_const_decimals!(44usize, 47usize, 91usize, 0usize); +add_sub_const_decimals!(44usize, 46usize, 90usize, 0usize); +add_sub_const_decimals!(44usize, 45usize, 89usize, 0usize); +add_sub_const_decimals!(44usize, 44usize, 88usize, 0usize); +add_sub_const_decimals!(44usize, 43usize, 87usize, 1usize); +add_sub_const_decimals!(44usize, 42usize, 86usize, 2usize); +add_sub_const_decimals!(44usize, 41usize, 85usize, 3usize); +add_sub_const_decimals!(44usize, 40usize, 84usize, 4usize); +add_sub_const_decimals!(44usize, 39usize, 83usize, 5usize); +add_sub_const_decimals!(44usize, 38usize, 82usize, 6usize); +add_sub_const_decimals!(44usize, 37usize, 81usize, 7usize); +add_sub_const_decimals!(44usize, 36usize, 80usize, 8usize); +add_sub_const_decimals!(44usize, 35usize, 79usize, 9usize); +add_sub_const_decimals!(44usize, 34usize, 78usize, 10usize); +add_sub_const_decimals!(44usize, 33usize, 77usize, 11usize); +add_sub_const_decimals!(44usize, 32usize, 76usize, 12usize); +add_sub_const_decimals!(44usize, 31usize, 75usize, 13usize); +add_sub_const_decimals!(44usize, 30usize, 74usize, 14usize); +add_sub_const_decimals!(44usize, 29usize, 73usize, 15usize); +add_sub_const_decimals!(44usize, 28usize, 72usize, 16usize); +add_sub_const_decimals!(44usize, 27usize, 71usize, 17usize); +add_sub_const_decimals!(44usize, 26usize, 70usize, 18usize); +add_sub_const_decimals!(44usize, 25usize, 69usize, 19usize); +add_sub_const_decimals!(44usize, 24usize, 68usize, 20usize); +add_sub_const_decimals!(44usize, 23usize, 67usize, 21usize); +add_sub_const_decimals!(44usize, 22usize, 66usize, 22usize); +add_sub_const_decimals!(44usize, 21usize, 65usize, 23usize); +add_sub_const_decimals!(44usize, 20usize, 64usize, 24usize); +add_sub_const_decimals!(44usize, 19usize, 63usize, 25usize); +add_sub_const_decimals!(44usize, 18usize, 62usize, 26usize); +add_sub_const_decimals!(44usize, 17usize, 61usize, 27usize); +add_sub_const_decimals!(44usize, 16usize, 60usize, 28usize); +add_sub_const_decimals!(44usize, 15usize, 59usize, 29usize); +add_sub_const_decimals!(44usize, 14usize, 58usize, 30usize); +add_sub_const_decimals!(44usize, 13usize, 57usize, 31usize); +add_sub_const_decimals!(44usize, 12usize, 56usize, 32usize); +add_sub_const_decimals!(44usize, 11usize, 55usize, 33usize); +add_sub_const_decimals!(44usize, 10usize, 54usize, 34usize); +add_sub_const_decimals!(44usize, 9usize, 53usize, 35usize); +add_sub_const_decimals!(44usize, 8usize, 52usize, 36usize); +add_sub_const_decimals!(44usize, 7usize, 51usize, 37usize); +add_sub_const_decimals!(44usize, 6usize, 50usize, 38usize); +add_sub_const_decimals!(44usize, 5usize, 49usize, 39usize); +add_sub_const_decimals!(44usize, 4usize, 48usize, 40usize); +add_sub_const_decimals!(44usize, 3usize, 47usize, 41usize); +add_sub_const_decimals!(44usize, 2usize, 46usize, 42usize); +add_sub_const_decimals!(44usize, 1usize, 45usize, 43usize); +add_sub_const_decimals!(44usize, 0usize, 44usize, 44usize); +add_sub_const_decimals!(43usize, 64usize, 107usize, 0usize); +add_sub_const_decimals!(43usize, 63usize, 106usize, 0usize); +add_sub_const_decimals!(43usize, 62usize, 105usize, 0usize); +add_sub_const_decimals!(43usize, 61usize, 104usize, 0usize); +add_sub_const_decimals!(43usize, 60usize, 103usize, 0usize); +add_sub_const_decimals!(43usize, 59usize, 102usize, 0usize); +add_sub_const_decimals!(43usize, 58usize, 101usize, 0usize); +add_sub_const_decimals!(43usize, 57usize, 100usize, 0usize); +add_sub_const_decimals!(43usize, 56usize, 99usize, 0usize); +add_sub_const_decimals!(43usize, 55usize, 98usize, 0usize); +add_sub_const_decimals!(43usize, 54usize, 97usize, 0usize); +add_sub_const_decimals!(43usize, 53usize, 96usize, 0usize); +add_sub_const_decimals!(43usize, 52usize, 95usize, 0usize); +add_sub_const_decimals!(43usize, 51usize, 94usize, 0usize); +add_sub_const_decimals!(43usize, 50usize, 93usize, 0usize); +add_sub_const_decimals!(43usize, 49usize, 92usize, 0usize); +add_sub_const_decimals!(43usize, 48usize, 91usize, 0usize); +add_sub_const_decimals!(43usize, 47usize, 90usize, 0usize); +add_sub_const_decimals!(43usize, 46usize, 89usize, 0usize); +add_sub_const_decimals!(43usize, 45usize, 88usize, 0usize); +add_sub_const_decimals!(43usize, 44usize, 87usize, 0usize); +add_sub_const_decimals!(43usize, 43usize, 86usize, 0usize); +add_sub_const_decimals!(43usize, 42usize, 85usize, 1usize); +add_sub_const_decimals!(43usize, 41usize, 84usize, 2usize); +add_sub_const_decimals!(43usize, 40usize, 83usize, 3usize); +add_sub_const_decimals!(43usize, 39usize, 82usize, 4usize); +add_sub_const_decimals!(43usize, 38usize, 81usize, 5usize); +add_sub_const_decimals!(43usize, 37usize, 80usize, 6usize); +add_sub_const_decimals!(43usize, 36usize, 79usize, 7usize); +add_sub_const_decimals!(43usize, 35usize, 78usize, 8usize); +add_sub_const_decimals!(43usize, 34usize, 77usize, 9usize); +add_sub_const_decimals!(43usize, 33usize, 76usize, 10usize); +add_sub_const_decimals!(43usize, 32usize, 75usize, 11usize); +add_sub_const_decimals!(43usize, 31usize, 74usize, 12usize); +add_sub_const_decimals!(43usize, 30usize, 73usize, 13usize); +add_sub_const_decimals!(43usize, 29usize, 72usize, 14usize); +add_sub_const_decimals!(43usize, 28usize, 71usize, 15usize); +add_sub_const_decimals!(43usize, 27usize, 70usize, 16usize); +add_sub_const_decimals!(43usize, 26usize, 69usize, 17usize); +add_sub_const_decimals!(43usize, 25usize, 68usize, 18usize); +add_sub_const_decimals!(43usize, 24usize, 67usize, 19usize); +add_sub_const_decimals!(43usize, 23usize, 66usize, 20usize); +add_sub_const_decimals!(43usize, 22usize, 65usize, 21usize); +add_sub_const_decimals!(43usize, 21usize, 64usize, 22usize); +add_sub_const_decimals!(43usize, 20usize, 63usize, 23usize); +add_sub_const_decimals!(43usize, 19usize, 62usize, 24usize); +add_sub_const_decimals!(43usize, 18usize, 61usize, 25usize); +add_sub_const_decimals!(43usize, 17usize, 60usize, 26usize); +add_sub_const_decimals!(43usize, 16usize, 59usize, 27usize); +add_sub_const_decimals!(43usize, 15usize, 58usize, 28usize); +add_sub_const_decimals!(43usize, 14usize, 57usize, 29usize); +add_sub_const_decimals!(43usize, 13usize, 56usize, 30usize); +add_sub_const_decimals!(43usize, 12usize, 55usize, 31usize); +add_sub_const_decimals!(43usize, 11usize, 54usize, 32usize); +add_sub_const_decimals!(43usize, 10usize, 53usize, 33usize); +add_sub_const_decimals!(43usize, 9usize, 52usize, 34usize); +add_sub_const_decimals!(43usize, 8usize, 51usize, 35usize); +add_sub_const_decimals!(43usize, 7usize, 50usize, 36usize); +add_sub_const_decimals!(43usize, 6usize, 49usize, 37usize); +add_sub_const_decimals!(43usize, 5usize, 48usize, 38usize); +add_sub_const_decimals!(43usize, 4usize, 47usize, 39usize); +add_sub_const_decimals!(43usize, 3usize, 46usize, 40usize); +add_sub_const_decimals!(43usize, 2usize, 45usize, 41usize); +add_sub_const_decimals!(43usize, 1usize, 44usize, 42usize); +add_sub_const_decimals!(43usize, 0usize, 43usize, 43usize); +add_sub_const_decimals!(42usize, 64usize, 106usize, 0usize); +add_sub_const_decimals!(42usize, 63usize, 105usize, 0usize); +add_sub_const_decimals!(42usize, 62usize, 104usize, 0usize); +add_sub_const_decimals!(42usize, 61usize, 103usize, 0usize); +add_sub_const_decimals!(42usize, 60usize, 102usize, 0usize); +add_sub_const_decimals!(42usize, 59usize, 101usize, 0usize); +add_sub_const_decimals!(42usize, 58usize, 100usize, 0usize); +add_sub_const_decimals!(42usize, 57usize, 99usize, 0usize); +add_sub_const_decimals!(42usize, 56usize, 98usize, 0usize); +add_sub_const_decimals!(42usize, 55usize, 97usize, 0usize); +add_sub_const_decimals!(42usize, 54usize, 96usize, 0usize); +add_sub_const_decimals!(42usize, 53usize, 95usize, 0usize); +add_sub_const_decimals!(42usize, 52usize, 94usize, 0usize); +add_sub_const_decimals!(42usize, 51usize, 93usize, 0usize); +add_sub_const_decimals!(42usize, 50usize, 92usize, 0usize); +add_sub_const_decimals!(42usize, 49usize, 91usize, 0usize); +add_sub_const_decimals!(42usize, 48usize, 90usize, 0usize); +add_sub_const_decimals!(42usize, 47usize, 89usize, 0usize); +add_sub_const_decimals!(42usize, 46usize, 88usize, 0usize); +add_sub_const_decimals!(42usize, 45usize, 87usize, 0usize); +add_sub_const_decimals!(42usize, 44usize, 86usize, 0usize); +add_sub_const_decimals!(42usize, 43usize, 85usize, 0usize); +add_sub_const_decimals!(42usize, 42usize, 84usize, 0usize); +add_sub_const_decimals!(42usize, 41usize, 83usize, 1usize); +add_sub_const_decimals!(42usize, 40usize, 82usize, 2usize); +add_sub_const_decimals!(42usize, 39usize, 81usize, 3usize); +add_sub_const_decimals!(42usize, 38usize, 80usize, 4usize); +add_sub_const_decimals!(42usize, 37usize, 79usize, 5usize); +add_sub_const_decimals!(42usize, 36usize, 78usize, 6usize); +add_sub_const_decimals!(42usize, 35usize, 77usize, 7usize); +add_sub_const_decimals!(42usize, 34usize, 76usize, 8usize); +add_sub_const_decimals!(42usize, 33usize, 75usize, 9usize); +add_sub_const_decimals!(42usize, 32usize, 74usize, 10usize); +add_sub_const_decimals!(42usize, 31usize, 73usize, 11usize); +add_sub_const_decimals!(42usize, 30usize, 72usize, 12usize); +add_sub_const_decimals!(42usize, 29usize, 71usize, 13usize); +add_sub_const_decimals!(42usize, 28usize, 70usize, 14usize); +add_sub_const_decimals!(42usize, 27usize, 69usize, 15usize); +add_sub_const_decimals!(42usize, 26usize, 68usize, 16usize); +add_sub_const_decimals!(42usize, 25usize, 67usize, 17usize); +add_sub_const_decimals!(42usize, 24usize, 66usize, 18usize); +add_sub_const_decimals!(42usize, 23usize, 65usize, 19usize); +add_sub_const_decimals!(42usize, 22usize, 64usize, 20usize); +add_sub_const_decimals!(42usize, 21usize, 63usize, 21usize); +add_sub_const_decimals!(42usize, 20usize, 62usize, 22usize); +add_sub_const_decimals!(42usize, 19usize, 61usize, 23usize); +add_sub_const_decimals!(42usize, 18usize, 60usize, 24usize); +add_sub_const_decimals!(42usize, 17usize, 59usize, 25usize); +add_sub_const_decimals!(42usize, 16usize, 58usize, 26usize); +add_sub_const_decimals!(42usize, 15usize, 57usize, 27usize); +add_sub_const_decimals!(42usize, 14usize, 56usize, 28usize); +add_sub_const_decimals!(42usize, 13usize, 55usize, 29usize); +add_sub_const_decimals!(42usize, 12usize, 54usize, 30usize); +add_sub_const_decimals!(42usize, 11usize, 53usize, 31usize); +add_sub_const_decimals!(42usize, 10usize, 52usize, 32usize); +add_sub_const_decimals!(42usize, 9usize, 51usize, 33usize); +add_sub_const_decimals!(42usize, 8usize, 50usize, 34usize); +add_sub_const_decimals!(42usize, 7usize, 49usize, 35usize); +add_sub_const_decimals!(42usize, 6usize, 48usize, 36usize); +add_sub_const_decimals!(42usize, 5usize, 47usize, 37usize); +add_sub_const_decimals!(42usize, 4usize, 46usize, 38usize); +add_sub_const_decimals!(42usize, 3usize, 45usize, 39usize); +add_sub_const_decimals!(42usize, 2usize, 44usize, 40usize); +add_sub_const_decimals!(42usize, 1usize, 43usize, 41usize); +add_sub_const_decimals!(42usize, 0usize, 42usize, 42usize); +add_sub_const_decimals!(41usize, 64usize, 105usize, 0usize); +add_sub_const_decimals!(41usize, 63usize, 104usize, 0usize); +add_sub_const_decimals!(41usize, 62usize, 103usize, 0usize); +add_sub_const_decimals!(41usize, 61usize, 102usize, 0usize); +add_sub_const_decimals!(41usize, 60usize, 101usize, 0usize); +add_sub_const_decimals!(41usize, 59usize, 100usize, 0usize); +add_sub_const_decimals!(41usize, 58usize, 99usize, 0usize); +add_sub_const_decimals!(41usize, 57usize, 98usize, 0usize); +add_sub_const_decimals!(41usize, 56usize, 97usize, 0usize); +add_sub_const_decimals!(41usize, 55usize, 96usize, 0usize); +add_sub_const_decimals!(41usize, 54usize, 95usize, 0usize); +add_sub_const_decimals!(41usize, 53usize, 94usize, 0usize); +add_sub_const_decimals!(41usize, 52usize, 93usize, 0usize); +add_sub_const_decimals!(41usize, 51usize, 92usize, 0usize); +add_sub_const_decimals!(41usize, 50usize, 91usize, 0usize); +add_sub_const_decimals!(41usize, 49usize, 90usize, 0usize); +add_sub_const_decimals!(41usize, 48usize, 89usize, 0usize); +add_sub_const_decimals!(41usize, 47usize, 88usize, 0usize); +add_sub_const_decimals!(41usize, 46usize, 87usize, 0usize); +add_sub_const_decimals!(41usize, 45usize, 86usize, 0usize); +add_sub_const_decimals!(41usize, 44usize, 85usize, 0usize); +add_sub_const_decimals!(41usize, 43usize, 84usize, 0usize); +add_sub_const_decimals!(41usize, 42usize, 83usize, 0usize); +add_sub_const_decimals!(41usize, 41usize, 82usize, 0usize); +add_sub_const_decimals!(41usize, 40usize, 81usize, 1usize); +add_sub_const_decimals!(41usize, 39usize, 80usize, 2usize); +add_sub_const_decimals!(41usize, 38usize, 79usize, 3usize); +add_sub_const_decimals!(41usize, 37usize, 78usize, 4usize); +add_sub_const_decimals!(41usize, 36usize, 77usize, 5usize); +add_sub_const_decimals!(41usize, 35usize, 76usize, 6usize); +add_sub_const_decimals!(41usize, 34usize, 75usize, 7usize); +add_sub_const_decimals!(41usize, 33usize, 74usize, 8usize); +add_sub_const_decimals!(41usize, 32usize, 73usize, 9usize); +add_sub_const_decimals!(41usize, 31usize, 72usize, 10usize); +add_sub_const_decimals!(41usize, 30usize, 71usize, 11usize); +add_sub_const_decimals!(41usize, 29usize, 70usize, 12usize); +add_sub_const_decimals!(41usize, 28usize, 69usize, 13usize); +add_sub_const_decimals!(41usize, 27usize, 68usize, 14usize); +add_sub_const_decimals!(41usize, 26usize, 67usize, 15usize); +add_sub_const_decimals!(41usize, 25usize, 66usize, 16usize); +add_sub_const_decimals!(41usize, 24usize, 65usize, 17usize); +add_sub_const_decimals!(41usize, 23usize, 64usize, 18usize); +add_sub_const_decimals!(41usize, 22usize, 63usize, 19usize); +add_sub_const_decimals!(41usize, 21usize, 62usize, 20usize); +add_sub_const_decimals!(41usize, 20usize, 61usize, 21usize); +add_sub_const_decimals!(41usize, 19usize, 60usize, 22usize); +add_sub_const_decimals!(41usize, 18usize, 59usize, 23usize); +add_sub_const_decimals!(41usize, 17usize, 58usize, 24usize); +add_sub_const_decimals!(41usize, 16usize, 57usize, 25usize); +add_sub_const_decimals!(41usize, 15usize, 56usize, 26usize); +add_sub_const_decimals!(41usize, 14usize, 55usize, 27usize); +add_sub_const_decimals!(41usize, 13usize, 54usize, 28usize); +add_sub_const_decimals!(41usize, 12usize, 53usize, 29usize); +add_sub_const_decimals!(41usize, 11usize, 52usize, 30usize); +add_sub_const_decimals!(41usize, 10usize, 51usize, 31usize); +add_sub_const_decimals!(41usize, 9usize, 50usize, 32usize); +add_sub_const_decimals!(41usize, 8usize, 49usize, 33usize); +add_sub_const_decimals!(41usize, 7usize, 48usize, 34usize); +add_sub_const_decimals!(41usize, 6usize, 47usize, 35usize); +add_sub_const_decimals!(41usize, 5usize, 46usize, 36usize); +add_sub_const_decimals!(41usize, 4usize, 45usize, 37usize); +add_sub_const_decimals!(41usize, 3usize, 44usize, 38usize); +add_sub_const_decimals!(41usize, 2usize, 43usize, 39usize); +add_sub_const_decimals!(41usize, 1usize, 42usize, 40usize); +add_sub_const_decimals!(41usize, 0usize, 41usize, 41usize); +add_sub_const_decimals!(40usize, 64usize, 104usize, 0usize); +add_sub_const_decimals!(40usize, 63usize, 103usize, 0usize); +add_sub_const_decimals!(40usize, 62usize, 102usize, 0usize); +add_sub_const_decimals!(40usize, 61usize, 101usize, 0usize); +add_sub_const_decimals!(40usize, 60usize, 100usize, 0usize); +add_sub_const_decimals!(40usize, 59usize, 99usize, 0usize); +add_sub_const_decimals!(40usize, 58usize, 98usize, 0usize); +add_sub_const_decimals!(40usize, 57usize, 97usize, 0usize); +add_sub_const_decimals!(40usize, 56usize, 96usize, 0usize); +add_sub_const_decimals!(40usize, 55usize, 95usize, 0usize); +add_sub_const_decimals!(40usize, 54usize, 94usize, 0usize); +add_sub_const_decimals!(40usize, 53usize, 93usize, 0usize); +add_sub_const_decimals!(40usize, 52usize, 92usize, 0usize); +add_sub_const_decimals!(40usize, 51usize, 91usize, 0usize); +add_sub_const_decimals!(40usize, 50usize, 90usize, 0usize); +add_sub_const_decimals!(40usize, 49usize, 89usize, 0usize); +add_sub_const_decimals!(40usize, 48usize, 88usize, 0usize); +add_sub_const_decimals!(40usize, 47usize, 87usize, 0usize); +add_sub_const_decimals!(40usize, 46usize, 86usize, 0usize); +add_sub_const_decimals!(40usize, 45usize, 85usize, 0usize); +add_sub_const_decimals!(40usize, 44usize, 84usize, 0usize); +add_sub_const_decimals!(40usize, 43usize, 83usize, 0usize); +add_sub_const_decimals!(40usize, 42usize, 82usize, 0usize); +add_sub_const_decimals!(40usize, 41usize, 81usize, 0usize); +add_sub_const_decimals!(40usize, 40usize, 80usize, 0usize); +add_sub_const_decimals!(40usize, 39usize, 79usize, 1usize); +add_sub_const_decimals!(40usize, 38usize, 78usize, 2usize); +add_sub_const_decimals!(40usize, 37usize, 77usize, 3usize); +add_sub_const_decimals!(40usize, 36usize, 76usize, 4usize); +add_sub_const_decimals!(40usize, 35usize, 75usize, 5usize); +add_sub_const_decimals!(40usize, 34usize, 74usize, 6usize); +add_sub_const_decimals!(40usize, 33usize, 73usize, 7usize); +add_sub_const_decimals!(40usize, 32usize, 72usize, 8usize); +add_sub_const_decimals!(40usize, 31usize, 71usize, 9usize); +add_sub_const_decimals!(40usize, 30usize, 70usize, 10usize); +add_sub_const_decimals!(40usize, 29usize, 69usize, 11usize); +add_sub_const_decimals!(40usize, 28usize, 68usize, 12usize); +add_sub_const_decimals!(40usize, 27usize, 67usize, 13usize); +add_sub_const_decimals!(40usize, 26usize, 66usize, 14usize); +add_sub_const_decimals!(40usize, 25usize, 65usize, 15usize); +add_sub_const_decimals!(40usize, 24usize, 64usize, 16usize); +add_sub_const_decimals!(40usize, 23usize, 63usize, 17usize); +add_sub_const_decimals!(40usize, 22usize, 62usize, 18usize); +add_sub_const_decimals!(40usize, 21usize, 61usize, 19usize); +add_sub_const_decimals!(40usize, 20usize, 60usize, 20usize); +add_sub_const_decimals!(40usize, 19usize, 59usize, 21usize); +add_sub_const_decimals!(40usize, 18usize, 58usize, 22usize); +add_sub_const_decimals!(40usize, 17usize, 57usize, 23usize); +add_sub_const_decimals!(40usize, 16usize, 56usize, 24usize); +add_sub_const_decimals!(40usize, 15usize, 55usize, 25usize); +add_sub_const_decimals!(40usize, 14usize, 54usize, 26usize); +add_sub_const_decimals!(40usize, 13usize, 53usize, 27usize); +add_sub_const_decimals!(40usize, 12usize, 52usize, 28usize); +add_sub_const_decimals!(40usize, 11usize, 51usize, 29usize); +add_sub_const_decimals!(40usize, 10usize, 50usize, 30usize); +add_sub_const_decimals!(40usize, 9usize, 49usize, 31usize); +add_sub_const_decimals!(40usize, 8usize, 48usize, 32usize); +add_sub_const_decimals!(40usize, 7usize, 47usize, 33usize); +add_sub_const_decimals!(40usize, 6usize, 46usize, 34usize); +add_sub_const_decimals!(40usize, 5usize, 45usize, 35usize); +add_sub_const_decimals!(40usize, 4usize, 44usize, 36usize); +add_sub_const_decimals!(40usize, 3usize, 43usize, 37usize); +add_sub_const_decimals!(40usize, 2usize, 42usize, 38usize); +add_sub_const_decimals!(40usize, 1usize, 41usize, 39usize); +add_sub_const_decimals!(40usize, 0usize, 40usize, 40usize); +add_sub_const_decimals!(39usize, 64usize, 103usize, 0usize); +add_sub_const_decimals!(39usize, 63usize, 102usize, 0usize); +add_sub_const_decimals!(39usize, 62usize, 101usize, 0usize); +add_sub_const_decimals!(39usize, 61usize, 100usize, 0usize); +add_sub_const_decimals!(39usize, 60usize, 99usize, 0usize); +add_sub_const_decimals!(39usize, 59usize, 98usize, 0usize); +add_sub_const_decimals!(39usize, 58usize, 97usize, 0usize); +add_sub_const_decimals!(39usize, 57usize, 96usize, 0usize); +add_sub_const_decimals!(39usize, 56usize, 95usize, 0usize); +add_sub_const_decimals!(39usize, 55usize, 94usize, 0usize); +add_sub_const_decimals!(39usize, 54usize, 93usize, 0usize); +add_sub_const_decimals!(39usize, 53usize, 92usize, 0usize); +add_sub_const_decimals!(39usize, 52usize, 91usize, 0usize); +add_sub_const_decimals!(39usize, 51usize, 90usize, 0usize); +add_sub_const_decimals!(39usize, 50usize, 89usize, 0usize); +add_sub_const_decimals!(39usize, 49usize, 88usize, 0usize); +add_sub_const_decimals!(39usize, 48usize, 87usize, 0usize); +add_sub_const_decimals!(39usize, 47usize, 86usize, 0usize); +add_sub_const_decimals!(39usize, 46usize, 85usize, 0usize); +add_sub_const_decimals!(39usize, 45usize, 84usize, 0usize); +add_sub_const_decimals!(39usize, 44usize, 83usize, 0usize); +add_sub_const_decimals!(39usize, 43usize, 82usize, 0usize); +add_sub_const_decimals!(39usize, 42usize, 81usize, 0usize); +add_sub_const_decimals!(39usize, 41usize, 80usize, 0usize); +add_sub_const_decimals!(39usize, 40usize, 79usize, 0usize); +add_sub_const_decimals!(39usize, 39usize, 78usize, 0usize); +add_sub_const_decimals!(39usize, 38usize, 77usize, 1usize); +add_sub_const_decimals!(39usize, 37usize, 76usize, 2usize); +add_sub_const_decimals!(39usize, 36usize, 75usize, 3usize); +add_sub_const_decimals!(39usize, 35usize, 74usize, 4usize); +add_sub_const_decimals!(39usize, 34usize, 73usize, 5usize); +add_sub_const_decimals!(39usize, 33usize, 72usize, 6usize); +add_sub_const_decimals!(39usize, 32usize, 71usize, 7usize); +add_sub_const_decimals!(39usize, 31usize, 70usize, 8usize); +add_sub_const_decimals!(39usize, 30usize, 69usize, 9usize); +add_sub_const_decimals!(39usize, 29usize, 68usize, 10usize); +add_sub_const_decimals!(39usize, 28usize, 67usize, 11usize); +add_sub_const_decimals!(39usize, 27usize, 66usize, 12usize); +add_sub_const_decimals!(39usize, 26usize, 65usize, 13usize); +add_sub_const_decimals!(39usize, 25usize, 64usize, 14usize); +add_sub_const_decimals!(39usize, 24usize, 63usize, 15usize); +add_sub_const_decimals!(39usize, 23usize, 62usize, 16usize); +add_sub_const_decimals!(39usize, 22usize, 61usize, 17usize); +add_sub_const_decimals!(39usize, 21usize, 60usize, 18usize); +add_sub_const_decimals!(39usize, 20usize, 59usize, 19usize); +add_sub_const_decimals!(39usize, 19usize, 58usize, 20usize); +add_sub_const_decimals!(39usize, 18usize, 57usize, 21usize); +add_sub_const_decimals!(39usize, 17usize, 56usize, 22usize); +add_sub_const_decimals!(39usize, 16usize, 55usize, 23usize); +add_sub_const_decimals!(39usize, 15usize, 54usize, 24usize); +add_sub_const_decimals!(39usize, 14usize, 53usize, 25usize); +add_sub_const_decimals!(39usize, 13usize, 52usize, 26usize); +add_sub_const_decimals!(39usize, 12usize, 51usize, 27usize); +add_sub_const_decimals!(39usize, 11usize, 50usize, 28usize); +add_sub_const_decimals!(39usize, 10usize, 49usize, 29usize); +add_sub_const_decimals!(39usize, 9usize, 48usize, 30usize); +add_sub_const_decimals!(39usize, 8usize, 47usize, 31usize); +add_sub_const_decimals!(39usize, 7usize, 46usize, 32usize); +add_sub_const_decimals!(39usize, 6usize, 45usize, 33usize); +add_sub_const_decimals!(39usize, 5usize, 44usize, 34usize); +add_sub_const_decimals!(39usize, 4usize, 43usize, 35usize); +add_sub_const_decimals!(39usize, 3usize, 42usize, 36usize); +add_sub_const_decimals!(39usize, 2usize, 41usize, 37usize); +add_sub_const_decimals!(39usize, 1usize, 40usize, 38usize); +add_sub_const_decimals!(39usize, 0usize, 39usize, 39usize); +add_sub_const_decimals!(38usize, 64usize, 102usize, 0usize); +add_sub_const_decimals!(38usize, 63usize, 101usize, 0usize); +add_sub_const_decimals!(38usize, 62usize, 100usize, 0usize); +add_sub_const_decimals!(38usize, 61usize, 99usize, 0usize); +add_sub_const_decimals!(38usize, 60usize, 98usize, 0usize); +add_sub_const_decimals!(38usize, 59usize, 97usize, 0usize); +add_sub_const_decimals!(38usize, 58usize, 96usize, 0usize); +add_sub_const_decimals!(38usize, 57usize, 95usize, 0usize); +add_sub_const_decimals!(38usize, 56usize, 94usize, 0usize); +add_sub_const_decimals!(38usize, 55usize, 93usize, 0usize); +add_sub_const_decimals!(38usize, 54usize, 92usize, 0usize); +add_sub_const_decimals!(38usize, 53usize, 91usize, 0usize); +add_sub_const_decimals!(38usize, 52usize, 90usize, 0usize); +add_sub_const_decimals!(38usize, 51usize, 89usize, 0usize); +add_sub_const_decimals!(38usize, 50usize, 88usize, 0usize); +add_sub_const_decimals!(38usize, 49usize, 87usize, 0usize); +add_sub_const_decimals!(38usize, 48usize, 86usize, 0usize); +add_sub_const_decimals!(38usize, 47usize, 85usize, 0usize); +add_sub_const_decimals!(38usize, 46usize, 84usize, 0usize); +add_sub_const_decimals!(38usize, 45usize, 83usize, 0usize); +add_sub_const_decimals!(38usize, 44usize, 82usize, 0usize); +add_sub_const_decimals!(38usize, 43usize, 81usize, 0usize); +add_sub_const_decimals!(38usize, 42usize, 80usize, 0usize); +add_sub_const_decimals!(38usize, 41usize, 79usize, 0usize); +add_sub_const_decimals!(38usize, 40usize, 78usize, 0usize); +add_sub_const_decimals!(38usize, 39usize, 77usize, 0usize); +add_sub_const_decimals!(38usize, 38usize, 76usize, 0usize); +add_sub_const_decimals!(38usize, 37usize, 75usize, 1usize); +add_sub_const_decimals!(38usize, 36usize, 74usize, 2usize); +add_sub_const_decimals!(38usize, 35usize, 73usize, 3usize); +add_sub_const_decimals!(38usize, 34usize, 72usize, 4usize); +add_sub_const_decimals!(38usize, 33usize, 71usize, 5usize); +add_sub_const_decimals!(38usize, 32usize, 70usize, 6usize); +add_sub_const_decimals!(38usize, 31usize, 69usize, 7usize); +add_sub_const_decimals!(38usize, 30usize, 68usize, 8usize); +add_sub_const_decimals!(38usize, 29usize, 67usize, 9usize); +add_sub_const_decimals!(38usize, 28usize, 66usize, 10usize); +add_sub_const_decimals!(38usize, 27usize, 65usize, 11usize); +add_sub_const_decimals!(38usize, 26usize, 64usize, 12usize); +add_sub_const_decimals!(38usize, 25usize, 63usize, 13usize); +add_sub_const_decimals!(38usize, 24usize, 62usize, 14usize); +add_sub_const_decimals!(38usize, 23usize, 61usize, 15usize); +add_sub_const_decimals!(38usize, 22usize, 60usize, 16usize); +add_sub_const_decimals!(38usize, 21usize, 59usize, 17usize); +add_sub_const_decimals!(38usize, 20usize, 58usize, 18usize); +add_sub_const_decimals!(38usize, 19usize, 57usize, 19usize); +add_sub_const_decimals!(38usize, 18usize, 56usize, 20usize); +add_sub_const_decimals!(38usize, 17usize, 55usize, 21usize); +add_sub_const_decimals!(38usize, 16usize, 54usize, 22usize); +add_sub_const_decimals!(38usize, 15usize, 53usize, 23usize); +add_sub_const_decimals!(38usize, 14usize, 52usize, 24usize); +add_sub_const_decimals!(38usize, 13usize, 51usize, 25usize); +add_sub_const_decimals!(38usize, 12usize, 50usize, 26usize); +add_sub_const_decimals!(38usize, 11usize, 49usize, 27usize); +add_sub_const_decimals!(38usize, 10usize, 48usize, 28usize); +add_sub_const_decimals!(38usize, 9usize, 47usize, 29usize); +add_sub_const_decimals!(38usize, 8usize, 46usize, 30usize); +add_sub_const_decimals!(38usize, 7usize, 45usize, 31usize); +add_sub_const_decimals!(38usize, 6usize, 44usize, 32usize); +add_sub_const_decimals!(38usize, 5usize, 43usize, 33usize); +add_sub_const_decimals!(38usize, 4usize, 42usize, 34usize); +add_sub_const_decimals!(38usize, 3usize, 41usize, 35usize); +add_sub_const_decimals!(38usize, 2usize, 40usize, 36usize); +add_sub_const_decimals!(38usize, 1usize, 39usize, 37usize); +add_sub_const_decimals!(38usize, 0usize, 38usize, 38usize); +add_sub_const_decimals!(37usize, 64usize, 101usize, 0usize); +add_sub_const_decimals!(37usize, 63usize, 100usize, 0usize); +add_sub_const_decimals!(37usize, 62usize, 99usize, 0usize); +add_sub_const_decimals!(37usize, 61usize, 98usize, 0usize); +add_sub_const_decimals!(37usize, 60usize, 97usize, 0usize); +add_sub_const_decimals!(37usize, 59usize, 96usize, 0usize); +add_sub_const_decimals!(37usize, 58usize, 95usize, 0usize); +add_sub_const_decimals!(37usize, 57usize, 94usize, 0usize); +add_sub_const_decimals!(37usize, 56usize, 93usize, 0usize); +add_sub_const_decimals!(37usize, 55usize, 92usize, 0usize); +add_sub_const_decimals!(37usize, 54usize, 91usize, 0usize); +add_sub_const_decimals!(37usize, 53usize, 90usize, 0usize); +add_sub_const_decimals!(37usize, 52usize, 89usize, 0usize); +add_sub_const_decimals!(37usize, 51usize, 88usize, 0usize); +add_sub_const_decimals!(37usize, 50usize, 87usize, 0usize); +add_sub_const_decimals!(37usize, 49usize, 86usize, 0usize); +add_sub_const_decimals!(37usize, 48usize, 85usize, 0usize); +add_sub_const_decimals!(37usize, 47usize, 84usize, 0usize); +add_sub_const_decimals!(37usize, 46usize, 83usize, 0usize); +add_sub_const_decimals!(37usize, 45usize, 82usize, 0usize); +add_sub_const_decimals!(37usize, 44usize, 81usize, 0usize); +add_sub_const_decimals!(37usize, 43usize, 80usize, 0usize); +add_sub_const_decimals!(37usize, 42usize, 79usize, 0usize); +add_sub_const_decimals!(37usize, 41usize, 78usize, 0usize); +add_sub_const_decimals!(37usize, 40usize, 77usize, 0usize); +add_sub_const_decimals!(37usize, 39usize, 76usize, 0usize); +add_sub_const_decimals!(37usize, 38usize, 75usize, 0usize); +add_sub_const_decimals!(37usize, 37usize, 74usize, 0usize); +add_sub_const_decimals!(37usize, 36usize, 73usize, 1usize); +add_sub_const_decimals!(37usize, 35usize, 72usize, 2usize); +add_sub_const_decimals!(37usize, 34usize, 71usize, 3usize); +add_sub_const_decimals!(37usize, 33usize, 70usize, 4usize); +add_sub_const_decimals!(37usize, 32usize, 69usize, 5usize); +add_sub_const_decimals!(37usize, 31usize, 68usize, 6usize); +add_sub_const_decimals!(37usize, 30usize, 67usize, 7usize); +add_sub_const_decimals!(37usize, 29usize, 66usize, 8usize); +add_sub_const_decimals!(37usize, 28usize, 65usize, 9usize); +add_sub_const_decimals!(37usize, 27usize, 64usize, 10usize); +add_sub_const_decimals!(37usize, 26usize, 63usize, 11usize); +add_sub_const_decimals!(37usize, 25usize, 62usize, 12usize); +add_sub_const_decimals!(37usize, 24usize, 61usize, 13usize); +add_sub_const_decimals!(37usize, 23usize, 60usize, 14usize); +add_sub_const_decimals!(37usize, 22usize, 59usize, 15usize); +add_sub_const_decimals!(37usize, 21usize, 58usize, 16usize); +add_sub_const_decimals!(37usize, 20usize, 57usize, 17usize); +add_sub_const_decimals!(37usize, 19usize, 56usize, 18usize); +add_sub_const_decimals!(37usize, 18usize, 55usize, 19usize); +add_sub_const_decimals!(37usize, 17usize, 54usize, 20usize); +add_sub_const_decimals!(37usize, 16usize, 53usize, 21usize); +add_sub_const_decimals!(37usize, 15usize, 52usize, 22usize); +add_sub_const_decimals!(37usize, 14usize, 51usize, 23usize); +add_sub_const_decimals!(37usize, 13usize, 50usize, 24usize); +add_sub_const_decimals!(37usize, 12usize, 49usize, 25usize); +add_sub_const_decimals!(37usize, 11usize, 48usize, 26usize); +add_sub_const_decimals!(37usize, 10usize, 47usize, 27usize); +add_sub_const_decimals!(37usize, 9usize, 46usize, 28usize); +add_sub_const_decimals!(37usize, 8usize, 45usize, 29usize); +add_sub_const_decimals!(37usize, 7usize, 44usize, 30usize); +add_sub_const_decimals!(37usize, 6usize, 43usize, 31usize); +add_sub_const_decimals!(37usize, 5usize, 42usize, 32usize); +add_sub_const_decimals!(37usize, 4usize, 41usize, 33usize); +add_sub_const_decimals!(37usize, 3usize, 40usize, 34usize); +add_sub_const_decimals!(37usize, 2usize, 39usize, 35usize); +add_sub_const_decimals!(37usize, 1usize, 38usize, 36usize); +add_sub_const_decimals!(37usize, 0usize, 37usize, 37usize); +add_sub_const_decimals!(36usize, 64usize, 100usize, 0usize); +add_sub_const_decimals!(36usize, 63usize, 99usize, 0usize); +add_sub_const_decimals!(36usize, 62usize, 98usize, 0usize); +add_sub_const_decimals!(36usize, 61usize, 97usize, 0usize); +add_sub_const_decimals!(36usize, 60usize, 96usize, 0usize); +add_sub_const_decimals!(36usize, 59usize, 95usize, 0usize); +add_sub_const_decimals!(36usize, 58usize, 94usize, 0usize); +add_sub_const_decimals!(36usize, 57usize, 93usize, 0usize); +add_sub_const_decimals!(36usize, 56usize, 92usize, 0usize); +add_sub_const_decimals!(36usize, 55usize, 91usize, 0usize); +add_sub_const_decimals!(36usize, 54usize, 90usize, 0usize); +add_sub_const_decimals!(36usize, 53usize, 89usize, 0usize); +add_sub_const_decimals!(36usize, 52usize, 88usize, 0usize); +add_sub_const_decimals!(36usize, 51usize, 87usize, 0usize); +add_sub_const_decimals!(36usize, 50usize, 86usize, 0usize); +add_sub_const_decimals!(36usize, 49usize, 85usize, 0usize); +add_sub_const_decimals!(36usize, 48usize, 84usize, 0usize); +add_sub_const_decimals!(36usize, 47usize, 83usize, 0usize); +add_sub_const_decimals!(36usize, 46usize, 82usize, 0usize); +add_sub_const_decimals!(36usize, 45usize, 81usize, 0usize); +add_sub_const_decimals!(36usize, 44usize, 80usize, 0usize); +add_sub_const_decimals!(36usize, 43usize, 79usize, 0usize); +add_sub_const_decimals!(36usize, 42usize, 78usize, 0usize); +add_sub_const_decimals!(36usize, 41usize, 77usize, 0usize); +add_sub_const_decimals!(36usize, 40usize, 76usize, 0usize); +add_sub_const_decimals!(36usize, 39usize, 75usize, 0usize); +add_sub_const_decimals!(36usize, 38usize, 74usize, 0usize); +add_sub_const_decimals!(36usize, 37usize, 73usize, 0usize); +add_sub_const_decimals!(36usize, 36usize, 72usize, 0usize); +add_sub_const_decimals!(36usize, 35usize, 71usize, 1usize); +add_sub_const_decimals!(36usize, 34usize, 70usize, 2usize); +add_sub_const_decimals!(36usize, 33usize, 69usize, 3usize); +add_sub_const_decimals!(36usize, 32usize, 68usize, 4usize); +add_sub_const_decimals!(36usize, 31usize, 67usize, 5usize); +add_sub_const_decimals!(36usize, 30usize, 66usize, 6usize); +add_sub_const_decimals!(36usize, 29usize, 65usize, 7usize); +add_sub_const_decimals!(36usize, 28usize, 64usize, 8usize); +add_sub_const_decimals!(36usize, 27usize, 63usize, 9usize); +add_sub_const_decimals!(36usize, 26usize, 62usize, 10usize); +add_sub_const_decimals!(36usize, 25usize, 61usize, 11usize); +add_sub_const_decimals!(36usize, 24usize, 60usize, 12usize); +add_sub_const_decimals!(36usize, 23usize, 59usize, 13usize); +add_sub_const_decimals!(36usize, 22usize, 58usize, 14usize); +add_sub_const_decimals!(36usize, 21usize, 57usize, 15usize); +add_sub_const_decimals!(36usize, 20usize, 56usize, 16usize); +add_sub_const_decimals!(36usize, 19usize, 55usize, 17usize); +add_sub_const_decimals!(36usize, 18usize, 54usize, 18usize); +add_sub_const_decimals!(36usize, 17usize, 53usize, 19usize); +add_sub_const_decimals!(36usize, 16usize, 52usize, 20usize); +add_sub_const_decimals!(36usize, 15usize, 51usize, 21usize); +add_sub_const_decimals!(36usize, 14usize, 50usize, 22usize); +add_sub_const_decimals!(36usize, 13usize, 49usize, 23usize); +add_sub_const_decimals!(36usize, 12usize, 48usize, 24usize); +add_sub_const_decimals!(36usize, 11usize, 47usize, 25usize); +add_sub_const_decimals!(36usize, 10usize, 46usize, 26usize); +add_sub_const_decimals!(36usize, 9usize, 45usize, 27usize); +add_sub_const_decimals!(36usize, 8usize, 44usize, 28usize); +add_sub_const_decimals!(36usize, 7usize, 43usize, 29usize); +add_sub_const_decimals!(36usize, 6usize, 42usize, 30usize); +add_sub_const_decimals!(36usize, 5usize, 41usize, 31usize); +add_sub_const_decimals!(36usize, 4usize, 40usize, 32usize); +add_sub_const_decimals!(36usize, 3usize, 39usize, 33usize); +add_sub_const_decimals!(36usize, 2usize, 38usize, 34usize); +add_sub_const_decimals!(36usize, 1usize, 37usize, 35usize); +add_sub_const_decimals!(36usize, 0usize, 36usize, 36usize); +add_sub_const_decimals!(35usize, 64usize, 99usize, 0usize); +add_sub_const_decimals!(35usize, 63usize, 98usize, 0usize); +add_sub_const_decimals!(35usize, 62usize, 97usize, 0usize); +add_sub_const_decimals!(35usize, 61usize, 96usize, 0usize); +add_sub_const_decimals!(35usize, 60usize, 95usize, 0usize); +add_sub_const_decimals!(35usize, 59usize, 94usize, 0usize); +add_sub_const_decimals!(35usize, 58usize, 93usize, 0usize); +add_sub_const_decimals!(35usize, 57usize, 92usize, 0usize); +add_sub_const_decimals!(35usize, 56usize, 91usize, 0usize); +add_sub_const_decimals!(35usize, 55usize, 90usize, 0usize); +add_sub_const_decimals!(35usize, 54usize, 89usize, 0usize); +add_sub_const_decimals!(35usize, 53usize, 88usize, 0usize); +add_sub_const_decimals!(35usize, 52usize, 87usize, 0usize); +add_sub_const_decimals!(35usize, 51usize, 86usize, 0usize); +add_sub_const_decimals!(35usize, 50usize, 85usize, 0usize); +add_sub_const_decimals!(35usize, 49usize, 84usize, 0usize); +add_sub_const_decimals!(35usize, 48usize, 83usize, 0usize); +add_sub_const_decimals!(35usize, 47usize, 82usize, 0usize); +add_sub_const_decimals!(35usize, 46usize, 81usize, 0usize); +add_sub_const_decimals!(35usize, 45usize, 80usize, 0usize); +add_sub_const_decimals!(35usize, 44usize, 79usize, 0usize); +add_sub_const_decimals!(35usize, 43usize, 78usize, 0usize); +add_sub_const_decimals!(35usize, 42usize, 77usize, 0usize); +add_sub_const_decimals!(35usize, 41usize, 76usize, 0usize); +add_sub_const_decimals!(35usize, 40usize, 75usize, 0usize); +add_sub_const_decimals!(35usize, 39usize, 74usize, 0usize); +add_sub_const_decimals!(35usize, 38usize, 73usize, 0usize); +add_sub_const_decimals!(35usize, 37usize, 72usize, 0usize); +add_sub_const_decimals!(35usize, 36usize, 71usize, 0usize); +add_sub_const_decimals!(35usize, 35usize, 70usize, 0usize); +add_sub_const_decimals!(35usize, 34usize, 69usize, 1usize); +add_sub_const_decimals!(35usize, 33usize, 68usize, 2usize); +add_sub_const_decimals!(35usize, 32usize, 67usize, 3usize); +add_sub_const_decimals!(35usize, 31usize, 66usize, 4usize); +add_sub_const_decimals!(35usize, 30usize, 65usize, 5usize); +add_sub_const_decimals!(35usize, 29usize, 64usize, 6usize); +add_sub_const_decimals!(35usize, 28usize, 63usize, 7usize); +add_sub_const_decimals!(35usize, 27usize, 62usize, 8usize); +add_sub_const_decimals!(35usize, 26usize, 61usize, 9usize); +add_sub_const_decimals!(35usize, 25usize, 60usize, 10usize); +add_sub_const_decimals!(35usize, 24usize, 59usize, 11usize); +add_sub_const_decimals!(35usize, 23usize, 58usize, 12usize); +add_sub_const_decimals!(35usize, 22usize, 57usize, 13usize); +add_sub_const_decimals!(35usize, 21usize, 56usize, 14usize); +add_sub_const_decimals!(35usize, 20usize, 55usize, 15usize); +add_sub_const_decimals!(35usize, 19usize, 54usize, 16usize); +add_sub_const_decimals!(35usize, 18usize, 53usize, 17usize); +add_sub_const_decimals!(35usize, 17usize, 52usize, 18usize); +add_sub_const_decimals!(35usize, 16usize, 51usize, 19usize); +add_sub_const_decimals!(35usize, 15usize, 50usize, 20usize); +add_sub_const_decimals!(35usize, 14usize, 49usize, 21usize); +add_sub_const_decimals!(35usize, 13usize, 48usize, 22usize); +add_sub_const_decimals!(35usize, 12usize, 47usize, 23usize); +add_sub_const_decimals!(35usize, 11usize, 46usize, 24usize); +add_sub_const_decimals!(35usize, 10usize, 45usize, 25usize); +add_sub_const_decimals!(35usize, 9usize, 44usize, 26usize); +add_sub_const_decimals!(35usize, 8usize, 43usize, 27usize); +add_sub_const_decimals!(35usize, 7usize, 42usize, 28usize); +add_sub_const_decimals!(35usize, 6usize, 41usize, 29usize); +add_sub_const_decimals!(35usize, 5usize, 40usize, 30usize); +add_sub_const_decimals!(35usize, 4usize, 39usize, 31usize); +add_sub_const_decimals!(35usize, 3usize, 38usize, 32usize); +add_sub_const_decimals!(35usize, 2usize, 37usize, 33usize); +add_sub_const_decimals!(35usize, 1usize, 36usize, 34usize); +add_sub_const_decimals!(35usize, 0usize, 35usize, 35usize); +add_sub_const_decimals!(34usize, 64usize, 98usize, 0usize); +add_sub_const_decimals!(34usize, 63usize, 97usize, 0usize); +add_sub_const_decimals!(34usize, 62usize, 96usize, 0usize); +add_sub_const_decimals!(34usize, 61usize, 95usize, 0usize); +add_sub_const_decimals!(34usize, 60usize, 94usize, 0usize); +add_sub_const_decimals!(34usize, 59usize, 93usize, 0usize); +add_sub_const_decimals!(34usize, 58usize, 92usize, 0usize); +add_sub_const_decimals!(34usize, 57usize, 91usize, 0usize); +add_sub_const_decimals!(34usize, 56usize, 90usize, 0usize); +add_sub_const_decimals!(34usize, 55usize, 89usize, 0usize); +add_sub_const_decimals!(34usize, 54usize, 88usize, 0usize); +add_sub_const_decimals!(34usize, 53usize, 87usize, 0usize); +add_sub_const_decimals!(34usize, 52usize, 86usize, 0usize); +add_sub_const_decimals!(34usize, 51usize, 85usize, 0usize); +add_sub_const_decimals!(34usize, 50usize, 84usize, 0usize); +add_sub_const_decimals!(34usize, 49usize, 83usize, 0usize); +add_sub_const_decimals!(34usize, 48usize, 82usize, 0usize); +add_sub_const_decimals!(34usize, 47usize, 81usize, 0usize); +add_sub_const_decimals!(34usize, 46usize, 80usize, 0usize); +add_sub_const_decimals!(34usize, 45usize, 79usize, 0usize); +add_sub_const_decimals!(34usize, 44usize, 78usize, 0usize); +add_sub_const_decimals!(34usize, 43usize, 77usize, 0usize); +add_sub_const_decimals!(34usize, 42usize, 76usize, 0usize); +add_sub_const_decimals!(34usize, 41usize, 75usize, 0usize); +add_sub_const_decimals!(34usize, 40usize, 74usize, 0usize); +add_sub_const_decimals!(34usize, 39usize, 73usize, 0usize); +add_sub_const_decimals!(34usize, 38usize, 72usize, 0usize); +add_sub_const_decimals!(34usize, 37usize, 71usize, 0usize); +add_sub_const_decimals!(34usize, 36usize, 70usize, 0usize); +add_sub_const_decimals!(34usize, 35usize, 69usize, 0usize); +add_sub_const_decimals!(34usize, 34usize, 68usize, 0usize); +add_sub_const_decimals!(34usize, 33usize, 67usize, 1usize); +add_sub_const_decimals!(34usize, 32usize, 66usize, 2usize); +add_sub_const_decimals!(34usize, 31usize, 65usize, 3usize); +add_sub_const_decimals!(34usize, 30usize, 64usize, 4usize); +add_sub_const_decimals!(34usize, 29usize, 63usize, 5usize); +add_sub_const_decimals!(34usize, 28usize, 62usize, 6usize); +add_sub_const_decimals!(34usize, 27usize, 61usize, 7usize); +add_sub_const_decimals!(34usize, 26usize, 60usize, 8usize); +add_sub_const_decimals!(34usize, 25usize, 59usize, 9usize); +add_sub_const_decimals!(34usize, 24usize, 58usize, 10usize); +add_sub_const_decimals!(34usize, 23usize, 57usize, 11usize); +add_sub_const_decimals!(34usize, 22usize, 56usize, 12usize); +add_sub_const_decimals!(34usize, 21usize, 55usize, 13usize); +add_sub_const_decimals!(34usize, 20usize, 54usize, 14usize); +add_sub_const_decimals!(34usize, 19usize, 53usize, 15usize); +add_sub_const_decimals!(34usize, 18usize, 52usize, 16usize); +add_sub_const_decimals!(34usize, 17usize, 51usize, 17usize); +add_sub_const_decimals!(34usize, 16usize, 50usize, 18usize); +add_sub_const_decimals!(34usize, 15usize, 49usize, 19usize); +add_sub_const_decimals!(34usize, 14usize, 48usize, 20usize); +add_sub_const_decimals!(34usize, 13usize, 47usize, 21usize); +add_sub_const_decimals!(34usize, 12usize, 46usize, 22usize); +add_sub_const_decimals!(34usize, 11usize, 45usize, 23usize); +add_sub_const_decimals!(34usize, 10usize, 44usize, 24usize); +add_sub_const_decimals!(34usize, 9usize, 43usize, 25usize); +add_sub_const_decimals!(34usize, 8usize, 42usize, 26usize); +add_sub_const_decimals!(34usize, 7usize, 41usize, 27usize); +add_sub_const_decimals!(34usize, 6usize, 40usize, 28usize); +add_sub_const_decimals!(34usize, 5usize, 39usize, 29usize); +add_sub_const_decimals!(34usize, 4usize, 38usize, 30usize); +add_sub_const_decimals!(34usize, 3usize, 37usize, 31usize); +add_sub_const_decimals!(34usize, 2usize, 36usize, 32usize); +add_sub_const_decimals!(34usize, 1usize, 35usize, 33usize); +add_sub_const_decimals!(34usize, 0usize, 34usize, 34usize); +add_sub_const_decimals!(33usize, 64usize, 97usize, 0usize); +add_sub_const_decimals!(33usize, 63usize, 96usize, 0usize); +add_sub_const_decimals!(33usize, 62usize, 95usize, 0usize); +add_sub_const_decimals!(33usize, 61usize, 94usize, 0usize); +add_sub_const_decimals!(33usize, 60usize, 93usize, 0usize); +add_sub_const_decimals!(33usize, 59usize, 92usize, 0usize); +add_sub_const_decimals!(33usize, 58usize, 91usize, 0usize); +add_sub_const_decimals!(33usize, 57usize, 90usize, 0usize); +add_sub_const_decimals!(33usize, 56usize, 89usize, 0usize); +add_sub_const_decimals!(33usize, 55usize, 88usize, 0usize); +add_sub_const_decimals!(33usize, 54usize, 87usize, 0usize); +add_sub_const_decimals!(33usize, 53usize, 86usize, 0usize); +add_sub_const_decimals!(33usize, 52usize, 85usize, 0usize); +add_sub_const_decimals!(33usize, 51usize, 84usize, 0usize); +add_sub_const_decimals!(33usize, 50usize, 83usize, 0usize); +add_sub_const_decimals!(33usize, 49usize, 82usize, 0usize); +add_sub_const_decimals!(33usize, 48usize, 81usize, 0usize); +add_sub_const_decimals!(33usize, 47usize, 80usize, 0usize); +add_sub_const_decimals!(33usize, 46usize, 79usize, 0usize); +add_sub_const_decimals!(33usize, 45usize, 78usize, 0usize); +add_sub_const_decimals!(33usize, 44usize, 77usize, 0usize); +add_sub_const_decimals!(33usize, 43usize, 76usize, 0usize); +add_sub_const_decimals!(33usize, 42usize, 75usize, 0usize); +add_sub_const_decimals!(33usize, 41usize, 74usize, 0usize); +add_sub_const_decimals!(33usize, 40usize, 73usize, 0usize); +add_sub_const_decimals!(33usize, 39usize, 72usize, 0usize); +add_sub_const_decimals!(33usize, 38usize, 71usize, 0usize); +add_sub_const_decimals!(33usize, 37usize, 70usize, 0usize); +add_sub_const_decimals!(33usize, 36usize, 69usize, 0usize); +add_sub_const_decimals!(33usize, 35usize, 68usize, 0usize); +add_sub_const_decimals!(33usize, 34usize, 67usize, 0usize); +add_sub_const_decimals!(33usize, 33usize, 66usize, 0usize); +add_sub_const_decimals!(33usize, 32usize, 65usize, 1usize); +add_sub_const_decimals!(33usize, 31usize, 64usize, 2usize); +add_sub_const_decimals!(33usize, 30usize, 63usize, 3usize); +add_sub_const_decimals!(33usize, 29usize, 62usize, 4usize); +add_sub_const_decimals!(33usize, 28usize, 61usize, 5usize); +add_sub_const_decimals!(33usize, 27usize, 60usize, 6usize); +add_sub_const_decimals!(33usize, 26usize, 59usize, 7usize); +add_sub_const_decimals!(33usize, 25usize, 58usize, 8usize); +add_sub_const_decimals!(33usize, 24usize, 57usize, 9usize); +add_sub_const_decimals!(33usize, 23usize, 56usize, 10usize); +add_sub_const_decimals!(33usize, 22usize, 55usize, 11usize); +add_sub_const_decimals!(33usize, 21usize, 54usize, 12usize); +add_sub_const_decimals!(33usize, 20usize, 53usize, 13usize); +add_sub_const_decimals!(33usize, 19usize, 52usize, 14usize); +add_sub_const_decimals!(33usize, 18usize, 51usize, 15usize); +add_sub_const_decimals!(33usize, 17usize, 50usize, 16usize); +add_sub_const_decimals!(33usize, 16usize, 49usize, 17usize); +add_sub_const_decimals!(33usize, 15usize, 48usize, 18usize); +add_sub_const_decimals!(33usize, 14usize, 47usize, 19usize); +add_sub_const_decimals!(33usize, 13usize, 46usize, 20usize); +add_sub_const_decimals!(33usize, 12usize, 45usize, 21usize); +add_sub_const_decimals!(33usize, 11usize, 44usize, 22usize); +add_sub_const_decimals!(33usize, 10usize, 43usize, 23usize); +add_sub_const_decimals!(33usize, 9usize, 42usize, 24usize); +add_sub_const_decimals!(33usize, 8usize, 41usize, 25usize); +add_sub_const_decimals!(33usize, 7usize, 40usize, 26usize); +add_sub_const_decimals!(33usize, 6usize, 39usize, 27usize); +add_sub_const_decimals!(33usize, 5usize, 38usize, 28usize); +add_sub_const_decimals!(33usize, 4usize, 37usize, 29usize); +add_sub_const_decimals!(33usize, 3usize, 36usize, 30usize); +add_sub_const_decimals!(33usize, 2usize, 35usize, 31usize); +add_sub_const_decimals!(33usize, 1usize, 34usize, 32usize); +add_sub_const_decimals!(33usize, 0usize, 33usize, 33usize); +add_sub_const_decimals!(32usize, 64usize, 96usize, 0usize); +add_sub_const_decimals!(32usize, 63usize, 95usize, 0usize); +add_sub_const_decimals!(32usize, 62usize, 94usize, 0usize); +add_sub_const_decimals!(32usize, 61usize, 93usize, 0usize); +add_sub_const_decimals!(32usize, 60usize, 92usize, 0usize); +add_sub_const_decimals!(32usize, 59usize, 91usize, 0usize); +add_sub_const_decimals!(32usize, 58usize, 90usize, 0usize); +add_sub_const_decimals!(32usize, 57usize, 89usize, 0usize); +add_sub_const_decimals!(32usize, 56usize, 88usize, 0usize); +add_sub_const_decimals!(32usize, 55usize, 87usize, 0usize); +add_sub_const_decimals!(32usize, 54usize, 86usize, 0usize); +add_sub_const_decimals!(32usize, 53usize, 85usize, 0usize); +add_sub_const_decimals!(32usize, 52usize, 84usize, 0usize); +add_sub_const_decimals!(32usize, 51usize, 83usize, 0usize); +add_sub_const_decimals!(32usize, 50usize, 82usize, 0usize); +add_sub_const_decimals!(32usize, 49usize, 81usize, 0usize); +add_sub_const_decimals!(32usize, 48usize, 80usize, 0usize); +add_sub_const_decimals!(32usize, 47usize, 79usize, 0usize); +add_sub_const_decimals!(32usize, 46usize, 78usize, 0usize); +add_sub_const_decimals!(32usize, 45usize, 77usize, 0usize); +add_sub_const_decimals!(32usize, 44usize, 76usize, 0usize); +add_sub_const_decimals!(32usize, 43usize, 75usize, 0usize); +add_sub_const_decimals!(32usize, 42usize, 74usize, 0usize); +add_sub_const_decimals!(32usize, 41usize, 73usize, 0usize); +add_sub_const_decimals!(32usize, 40usize, 72usize, 0usize); +add_sub_const_decimals!(32usize, 39usize, 71usize, 0usize); +add_sub_const_decimals!(32usize, 38usize, 70usize, 0usize); +add_sub_const_decimals!(32usize, 37usize, 69usize, 0usize); +add_sub_const_decimals!(32usize, 36usize, 68usize, 0usize); +add_sub_const_decimals!(32usize, 35usize, 67usize, 0usize); +add_sub_const_decimals!(32usize, 34usize, 66usize, 0usize); +add_sub_const_decimals!(32usize, 33usize, 65usize, 0usize); +add_sub_const_decimals!(32usize, 32usize, 64usize, 0usize); +add_sub_const_decimals!(32usize, 31usize, 63usize, 1usize); +add_sub_const_decimals!(32usize, 30usize, 62usize, 2usize); +add_sub_const_decimals!(32usize, 29usize, 61usize, 3usize); +add_sub_const_decimals!(32usize, 28usize, 60usize, 4usize); +add_sub_const_decimals!(32usize, 27usize, 59usize, 5usize); +add_sub_const_decimals!(32usize, 26usize, 58usize, 6usize); +add_sub_const_decimals!(32usize, 25usize, 57usize, 7usize); +add_sub_const_decimals!(32usize, 24usize, 56usize, 8usize); +add_sub_const_decimals!(32usize, 23usize, 55usize, 9usize); +add_sub_const_decimals!(32usize, 22usize, 54usize, 10usize); +add_sub_const_decimals!(32usize, 21usize, 53usize, 11usize); +add_sub_const_decimals!(32usize, 20usize, 52usize, 12usize); +add_sub_const_decimals!(32usize, 19usize, 51usize, 13usize); +add_sub_const_decimals!(32usize, 18usize, 50usize, 14usize); +add_sub_const_decimals!(32usize, 17usize, 49usize, 15usize); +add_sub_const_decimals!(32usize, 16usize, 48usize, 16usize); +add_sub_const_decimals!(32usize, 15usize, 47usize, 17usize); +add_sub_const_decimals!(32usize, 14usize, 46usize, 18usize); +add_sub_const_decimals!(32usize, 13usize, 45usize, 19usize); +add_sub_const_decimals!(32usize, 12usize, 44usize, 20usize); +add_sub_const_decimals!(32usize, 11usize, 43usize, 21usize); +add_sub_const_decimals!(32usize, 10usize, 42usize, 22usize); +add_sub_const_decimals!(32usize, 9usize, 41usize, 23usize); +add_sub_const_decimals!(32usize, 8usize, 40usize, 24usize); +add_sub_const_decimals!(32usize, 7usize, 39usize, 25usize); +add_sub_const_decimals!(32usize, 6usize, 38usize, 26usize); +add_sub_const_decimals!(32usize, 5usize, 37usize, 27usize); +add_sub_const_decimals!(32usize, 4usize, 36usize, 28usize); +add_sub_const_decimals!(32usize, 3usize, 35usize, 29usize); +add_sub_const_decimals!(32usize, 2usize, 34usize, 30usize); +add_sub_const_decimals!(32usize, 1usize, 33usize, 31usize); +add_sub_const_decimals!(32usize, 0usize, 32usize, 32usize); +add_sub_const_decimals!(31usize, 64usize, 95usize, 0usize); +add_sub_const_decimals!(31usize, 63usize, 94usize, 0usize); +add_sub_const_decimals!(31usize, 62usize, 93usize, 0usize); +add_sub_const_decimals!(31usize, 61usize, 92usize, 0usize); +add_sub_const_decimals!(31usize, 60usize, 91usize, 0usize); +add_sub_const_decimals!(31usize, 59usize, 90usize, 0usize); +add_sub_const_decimals!(31usize, 58usize, 89usize, 0usize); +add_sub_const_decimals!(31usize, 57usize, 88usize, 0usize); +add_sub_const_decimals!(31usize, 56usize, 87usize, 0usize); +add_sub_const_decimals!(31usize, 55usize, 86usize, 0usize); +add_sub_const_decimals!(31usize, 54usize, 85usize, 0usize); +add_sub_const_decimals!(31usize, 53usize, 84usize, 0usize); +add_sub_const_decimals!(31usize, 52usize, 83usize, 0usize); +add_sub_const_decimals!(31usize, 51usize, 82usize, 0usize); +add_sub_const_decimals!(31usize, 50usize, 81usize, 0usize); +add_sub_const_decimals!(31usize, 49usize, 80usize, 0usize); +add_sub_const_decimals!(31usize, 48usize, 79usize, 0usize); +add_sub_const_decimals!(31usize, 47usize, 78usize, 0usize); +add_sub_const_decimals!(31usize, 46usize, 77usize, 0usize); +add_sub_const_decimals!(31usize, 45usize, 76usize, 0usize); +add_sub_const_decimals!(31usize, 44usize, 75usize, 0usize); +add_sub_const_decimals!(31usize, 43usize, 74usize, 0usize); +add_sub_const_decimals!(31usize, 42usize, 73usize, 0usize); +add_sub_const_decimals!(31usize, 41usize, 72usize, 0usize); +add_sub_const_decimals!(31usize, 40usize, 71usize, 0usize); +add_sub_const_decimals!(31usize, 39usize, 70usize, 0usize); +add_sub_const_decimals!(31usize, 38usize, 69usize, 0usize); +add_sub_const_decimals!(31usize, 37usize, 68usize, 0usize); +add_sub_const_decimals!(31usize, 36usize, 67usize, 0usize); +add_sub_const_decimals!(31usize, 35usize, 66usize, 0usize); +add_sub_const_decimals!(31usize, 34usize, 65usize, 0usize); +add_sub_const_decimals!(31usize, 33usize, 64usize, 0usize); +add_sub_const_decimals!(31usize, 32usize, 63usize, 0usize); +add_sub_const_decimals!(31usize, 31usize, 62usize, 0usize); +add_sub_const_decimals!(31usize, 30usize, 61usize, 1usize); +add_sub_const_decimals!(31usize, 29usize, 60usize, 2usize); +add_sub_const_decimals!(31usize, 28usize, 59usize, 3usize); +add_sub_const_decimals!(31usize, 27usize, 58usize, 4usize); +add_sub_const_decimals!(31usize, 26usize, 57usize, 5usize); +add_sub_const_decimals!(31usize, 25usize, 56usize, 6usize); +add_sub_const_decimals!(31usize, 24usize, 55usize, 7usize); +add_sub_const_decimals!(31usize, 23usize, 54usize, 8usize); +add_sub_const_decimals!(31usize, 22usize, 53usize, 9usize); +add_sub_const_decimals!(31usize, 21usize, 52usize, 10usize); +add_sub_const_decimals!(31usize, 20usize, 51usize, 11usize); +add_sub_const_decimals!(31usize, 19usize, 50usize, 12usize); +add_sub_const_decimals!(31usize, 18usize, 49usize, 13usize); +add_sub_const_decimals!(31usize, 17usize, 48usize, 14usize); +add_sub_const_decimals!(31usize, 16usize, 47usize, 15usize); +add_sub_const_decimals!(31usize, 15usize, 46usize, 16usize); +add_sub_const_decimals!(31usize, 14usize, 45usize, 17usize); +add_sub_const_decimals!(31usize, 13usize, 44usize, 18usize); +add_sub_const_decimals!(31usize, 12usize, 43usize, 19usize); +add_sub_const_decimals!(31usize, 11usize, 42usize, 20usize); +add_sub_const_decimals!(31usize, 10usize, 41usize, 21usize); +add_sub_const_decimals!(31usize, 9usize, 40usize, 22usize); +add_sub_const_decimals!(31usize, 8usize, 39usize, 23usize); +add_sub_const_decimals!(31usize, 7usize, 38usize, 24usize); +add_sub_const_decimals!(31usize, 6usize, 37usize, 25usize); +add_sub_const_decimals!(31usize, 5usize, 36usize, 26usize); +add_sub_const_decimals!(31usize, 4usize, 35usize, 27usize); +add_sub_const_decimals!(31usize, 3usize, 34usize, 28usize); +add_sub_const_decimals!(31usize, 2usize, 33usize, 29usize); +add_sub_const_decimals!(31usize, 1usize, 32usize, 30usize); +add_sub_const_decimals!(31usize, 0usize, 31usize, 31usize); +add_sub_const_decimals!(30usize, 64usize, 94usize, 0usize); +add_sub_const_decimals!(30usize, 63usize, 93usize, 0usize); +add_sub_const_decimals!(30usize, 62usize, 92usize, 0usize); +add_sub_const_decimals!(30usize, 61usize, 91usize, 0usize); +add_sub_const_decimals!(30usize, 60usize, 90usize, 0usize); +add_sub_const_decimals!(30usize, 59usize, 89usize, 0usize); +add_sub_const_decimals!(30usize, 58usize, 88usize, 0usize); +add_sub_const_decimals!(30usize, 57usize, 87usize, 0usize); +add_sub_const_decimals!(30usize, 56usize, 86usize, 0usize); +add_sub_const_decimals!(30usize, 55usize, 85usize, 0usize); +add_sub_const_decimals!(30usize, 54usize, 84usize, 0usize); +add_sub_const_decimals!(30usize, 53usize, 83usize, 0usize); +add_sub_const_decimals!(30usize, 52usize, 82usize, 0usize); +add_sub_const_decimals!(30usize, 51usize, 81usize, 0usize); +add_sub_const_decimals!(30usize, 50usize, 80usize, 0usize); +add_sub_const_decimals!(30usize, 49usize, 79usize, 0usize); +add_sub_const_decimals!(30usize, 48usize, 78usize, 0usize); +add_sub_const_decimals!(30usize, 47usize, 77usize, 0usize); +add_sub_const_decimals!(30usize, 46usize, 76usize, 0usize); +add_sub_const_decimals!(30usize, 45usize, 75usize, 0usize); +add_sub_const_decimals!(30usize, 44usize, 74usize, 0usize); +add_sub_const_decimals!(30usize, 43usize, 73usize, 0usize); +add_sub_const_decimals!(30usize, 42usize, 72usize, 0usize); +add_sub_const_decimals!(30usize, 41usize, 71usize, 0usize); +add_sub_const_decimals!(30usize, 40usize, 70usize, 0usize); +add_sub_const_decimals!(30usize, 39usize, 69usize, 0usize); +add_sub_const_decimals!(30usize, 38usize, 68usize, 0usize); +add_sub_const_decimals!(30usize, 37usize, 67usize, 0usize); +add_sub_const_decimals!(30usize, 36usize, 66usize, 0usize); +add_sub_const_decimals!(30usize, 35usize, 65usize, 0usize); +add_sub_const_decimals!(30usize, 34usize, 64usize, 0usize); +add_sub_const_decimals!(30usize, 33usize, 63usize, 0usize); +add_sub_const_decimals!(30usize, 32usize, 62usize, 0usize); +add_sub_const_decimals!(30usize, 31usize, 61usize, 0usize); +add_sub_const_decimals!(30usize, 30usize, 60usize, 0usize); +add_sub_const_decimals!(30usize, 29usize, 59usize, 1usize); +add_sub_const_decimals!(30usize, 28usize, 58usize, 2usize); +add_sub_const_decimals!(30usize, 27usize, 57usize, 3usize); +add_sub_const_decimals!(30usize, 26usize, 56usize, 4usize); +add_sub_const_decimals!(30usize, 25usize, 55usize, 5usize); +add_sub_const_decimals!(30usize, 24usize, 54usize, 6usize); +add_sub_const_decimals!(30usize, 23usize, 53usize, 7usize); +add_sub_const_decimals!(30usize, 22usize, 52usize, 8usize); +add_sub_const_decimals!(30usize, 21usize, 51usize, 9usize); +add_sub_const_decimals!(30usize, 20usize, 50usize, 10usize); +add_sub_const_decimals!(30usize, 19usize, 49usize, 11usize); +add_sub_const_decimals!(30usize, 18usize, 48usize, 12usize); +add_sub_const_decimals!(30usize, 17usize, 47usize, 13usize); +add_sub_const_decimals!(30usize, 16usize, 46usize, 14usize); +add_sub_const_decimals!(30usize, 15usize, 45usize, 15usize); +add_sub_const_decimals!(30usize, 14usize, 44usize, 16usize); +add_sub_const_decimals!(30usize, 13usize, 43usize, 17usize); +add_sub_const_decimals!(30usize, 12usize, 42usize, 18usize); +add_sub_const_decimals!(30usize, 11usize, 41usize, 19usize); +add_sub_const_decimals!(30usize, 10usize, 40usize, 20usize); +add_sub_const_decimals!(30usize, 9usize, 39usize, 21usize); +add_sub_const_decimals!(30usize, 8usize, 38usize, 22usize); +add_sub_const_decimals!(30usize, 7usize, 37usize, 23usize); +add_sub_const_decimals!(30usize, 6usize, 36usize, 24usize); +add_sub_const_decimals!(30usize, 5usize, 35usize, 25usize); +add_sub_const_decimals!(30usize, 4usize, 34usize, 26usize); +add_sub_const_decimals!(30usize, 3usize, 33usize, 27usize); +add_sub_const_decimals!(30usize, 2usize, 32usize, 28usize); +add_sub_const_decimals!(30usize, 1usize, 31usize, 29usize); +add_sub_const_decimals!(30usize, 0usize, 30usize, 30usize); +add_sub_const_decimals!(29usize, 64usize, 93usize, 0usize); +add_sub_const_decimals!(29usize, 63usize, 92usize, 0usize); +add_sub_const_decimals!(29usize, 62usize, 91usize, 0usize); +add_sub_const_decimals!(29usize, 61usize, 90usize, 0usize); +add_sub_const_decimals!(29usize, 60usize, 89usize, 0usize); +add_sub_const_decimals!(29usize, 59usize, 88usize, 0usize); +add_sub_const_decimals!(29usize, 58usize, 87usize, 0usize); +add_sub_const_decimals!(29usize, 57usize, 86usize, 0usize); +add_sub_const_decimals!(29usize, 56usize, 85usize, 0usize); +add_sub_const_decimals!(29usize, 55usize, 84usize, 0usize); +add_sub_const_decimals!(29usize, 54usize, 83usize, 0usize); +add_sub_const_decimals!(29usize, 53usize, 82usize, 0usize); +add_sub_const_decimals!(29usize, 52usize, 81usize, 0usize); +add_sub_const_decimals!(29usize, 51usize, 80usize, 0usize); +add_sub_const_decimals!(29usize, 50usize, 79usize, 0usize); +add_sub_const_decimals!(29usize, 49usize, 78usize, 0usize); +add_sub_const_decimals!(29usize, 48usize, 77usize, 0usize); +add_sub_const_decimals!(29usize, 47usize, 76usize, 0usize); +add_sub_const_decimals!(29usize, 46usize, 75usize, 0usize); +add_sub_const_decimals!(29usize, 45usize, 74usize, 0usize); +add_sub_const_decimals!(29usize, 44usize, 73usize, 0usize); +add_sub_const_decimals!(29usize, 43usize, 72usize, 0usize); +add_sub_const_decimals!(29usize, 42usize, 71usize, 0usize); +add_sub_const_decimals!(29usize, 41usize, 70usize, 0usize); +add_sub_const_decimals!(29usize, 40usize, 69usize, 0usize); +add_sub_const_decimals!(29usize, 39usize, 68usize, 0usize); +add_sub_const_decimals!(29usize, 38usize, 67usize, 0usize); +add_sub_const_decimals!(29usize, 37usize, 66usize, 0usize); +add_sub_const_decimals!(29usize, 36usize, 65usize, 0usize); +add_sub_const_decimals!(29usize, 35usize, 64usize, 0usize); +add_sub_const_decimals!(29usize, 34usize, 63usize, 0usize); +add_sub_const_decimals!(29usize, 33usize, 62usize, 0usize); +add_sub_const_decimals!(29usize, 32usize, 61usize, 0usize); +add_sub_const_decimals!(29usize, 31usize, 60usize, 0usize); +add_sub_const_decimals!(29usize, 30usize, 59usize, 0usize); +add_sub_const_decimals!(29usize, 29usize, 58usize, 0usize); +add_sub_const_decimals!(29usize, 28usize, 57usize, 1usize); +add_sub_const_decimals!(29usize, 27usize, 56usize, 2usize); +add_sub_const_decimals!(29usize, 26usize, 55usize, 3usize); +add_sub_const_decimals!(29usize, 25usize, 54usize, 4usize); +add_sub_const_decimals!(29usize, 24usize, 53usize, 5usize); +add_sub_const_decimals!(29usize, 23usize, 52usize, 6usize); +add_sub_const_decimals!(29usize, 22usize, 51usize, 7usize); +add_sub_const_decimals!(29usize, 21usize, 50usize, 8usize); +add_sub_const_decimals!(29usize, 20usize, 49usize, 9usize); +add_sub_const_decimals!(29usize, 19usize, 48usize, 10usize); +add_sub_const_decimals!(29usize, 18usize, 47usize, 11usize); +add_sub_const_decimals!(29usize, 17usize, 46usize, 12usize); +add_sub_const_decimals!(29usize, 16usize, 45usize, 13usize); +add_sub_const_decimals!(29usize, 15usize, 44usize, 14usize); +add_sub_const_decimals!(29usize, 14usize, 43usize, 15usize); +add_sub_const_decimals!(29usize, 13usize, 42usize, 16usize); +add_sub_const_decimals!(29usize, 12usize, 41usize, 17usize); +add_sub_const_decimals!(29usize, 11usize, 40usize, 18usize); +add_sub_const_decimals!(29usize, 10usize, 39usize, 19usize); +add_sub_const_decimals!(29usize, 9usize, 38usize, 20usize); +add_sub_const_decimals!(29usize, 8usize, 37usize, 21usize); +add_sub_const_decimals!(29usize, 7usize, 36usize, 22usize); +add_sub_const_decimals!(29usize, 6usize, 35usize, 23usize); +add_sub_const_decimals!(29usize, 5usize, 34usize, 24usize); +add_sub_const_decimals!(29usize, 4usize, 33usize, 25usize); +add_sub_const_decimals!(29usize, 3usize, 32usize, 26usize); +add_sub_const_decimals!(29usize, 2usize, 31usize, 27usize); +add_sub_const_decimals!(29usize, 1usize, 30usize, 28usize); +add_sub_const_decimals!(29usize, 0usize, 29usize, 29usize); +add_sub_const_decimals!(28usize, 64usize, 92usize, 0usize); +add_sub_const_decimals!(28usize, 63usize, 91usize, 0usize); +add_sub_const_decimals!(28usize, 62usize, 90usize, 0usize); +add_sub_const_decimals!(28usize, 61usize, 89usize, 0usize); +add_sub_const_decimals!(28usize, 60usize, 88usize, 0usize); +add_sub_const_decimals!(28usize, 59usize, 87usize, 0usize); +add_sub_const_decimals!(28usize, 58usize, 86usize, 0usize); +add_sub_const_decimals!(28usize, 57usize, 85usize, 0usize); +add_sub_const_decimals!(28usize, 56usize, 84usize, 0usize); +add_sub_const_decimals!(28usize, 55usize, 83usize, 0usize); +add_sub_const_decimals!(28usize, 54usize, 82usize, 0usize); +add_sub_const_decimals!(28usize, 53usize, 81usize, 0usize); +add_sub_const_decimals!(28usize, 52usize, 80usize, 0usize); +add_sub_const_decimals!(28usize, 51usize, 79usize, 0usize); +add_sub_const_decimals!(28usize, 50usize, 78usize, 0usize); +add_sub_const_decimals!(28usize, 49usize, 77usize, 0usize); +add_sub_const_decimals!(28usize, 48usize, 76usize, 0usize); +add_sub_const_decimals!(28usize, 47usize, 75usize, 0usize); +add_sub_const_decimals!(28usize, 46usize, 74usize, 0usize); +add_sub_const_decimals!(28usize, 45usize, 73usize, 0usize); +add_sub_const_decimals!(28usize, 44usize, 72usize, 0usize); +add_sub_const_decimals!(28usize, 43usize, 71usize, 0usize); +add_sub_const_decimals!(28usize, 42usize, 70usize, 0usize); +add_sub_const_decimals!(28usize, 41usize, 69usize, 0usize); +add_sub_const_decimals!(28usize, 40usize, 68usize, 0usize); +add_sub_const_decimals!(28usize, 39usize, 67usize, 0usize); +add_sub_const_decimals!(28usize, 38usize, 66usize, 0usize); +add_sub_const_decimals!(28usize, 37usize, 65usize, 0usize); +add_sub_const_decimals!(28usize, 36usize, 64usize, 0usize); +add_sub_const_decimals!(28usize, 35usize, 63usize, 0usize); +add_sub_const_decimals!(28usize, 34usize, 62usize, 0usize); +add_sub_const_decimals!(28usize, 33usize, 61usize, 0usize); +add_sub_const_decimals!(28usize, 32usize, 60usize, 0usize); +add_sub_const_decimals!(28usize, 31usize, 59usize, 0usize); +add_sub_const_decimals!(28usize, 30usize, 58usize, 0usize); +add_sub_const_decimals!(28usize, 29usize, 57usize, 0usize); +add_sub_const_decimals!(28usize, 28usize, 56usize, 0usize); +add_sub_const_decimals!(28usize, 27usize, 55usize, 1usize); +add_sub_const_decimals!(28usize, 26usize, 54usize, 2usize); +add_sub_const_decimals!(28usize, 25usize, 53usize, 3usize); +add_sub_const_decimals!(28usize, 24usize, 52usize, 4usize); +add_sub_const_decimals!(28usize, 23usize, 51usize, 5usize); +add_sub_const_decimals!(28usize, 22usize, 50usize, 6usize); +add_sub_const_decimals!(28usize, 21usize, 49usize, 7usize); +add_sub_const_decimals!(28usize, 20usize, 48usize, 8usize); +add_sub_const_decimals!(28usize, 19usize, 47usize, 9usize); +add_sub_const_decimals!(28usize, 18usize, 46usize, 10usize); +add_sub_const_decimals!(28usize, 17usize, 45usize, 11usize); +add_sub_const_decimals!(28usize, 16usize, 44usize, 12usize); +add_sub_const_decimals!(28usize, 15usize, 43usize, 13usize); +add_sub_const_decimals!(28usize, 14usize, 42usize, 14usize); +add_sub_const_decimals!(28usize, 13usize, 41usize, 15usize); +add_sub_const_decimals!(28usize, 12usize, 40usize, 16usize); +add_sub_const_decimals!(28usize, 11usize, 39usize, 17usize); +add_sub_const_decimals!(28usize, 10usize, 38usize, 18usize); +add_sub_const_decimals!(28usize, 9usize, 37usize, 19usize); +add_sub_const_decimals!(28usize, 8usize, 36usize, 20usize); +add_sub_const_decimals!(28usize, 7usize, 35usize, 21usize); +add_sub_const_decimals!(28usize, 6usize, 34usize, 22usize); +add_sub_const_decimals!(28usize, 5usize, 33usize, 23usize); +add_sub_const_decimals!(28usize, 4usize, 32usize, 24usize); +add_sub_const_decimals!(28usize, 3usize, 31usize, 25usize); +add_sub_const_decimals!(28usize, 2usize, 30usize, 26usize); +add_sub_const_decimals!(28usize, 1usize, 29usize, 27usize); +add_sub_const_decimals!(28usize, 0usize, 28usize, 28usize); +add_sub_const_decimals!(27usize, 64usize, 91usize, 0usize); +add_sub_const_decimals!(27usize, 63usize, 90usize, 0usize); +add_sub_const_decimals!(27usize, 62usize, 89usize, 0usize); +add_sub_const_decimals!(27usize, 61usize, 88usize, 0usize); +add_sub_const_decimals!(27usize, 60usize, 87usize, 0usize); +add_sub_const_decimals!(27usize, 59usize, 86usize, 0usize); +add_sub_const_decimals!(27usize, 58usize, 85usize, 0usize); +add_sub_const_decimals!(27usize, 57usize, 84usize, 0usize); +add_sub_const_decimals!(27usize, 56usize, 83usize, 0usize); +add_sub_const_decimals!(27usize, 55usize, 82usize, 0usize); +add_sub_const_decimals!(27usize, 54usize, 81usize, 0usize); +add_sub_const_decimals!(27usize, 53usize, 80usize, 0usize); +add_sub_const_decimals!(27usize, 52usize, 79usize, 0usize); +add_sub_const_decimals!(27usize, 51usize, 78usize, 0usize); +add_sub_const_decimals!(27usize, 50usize, 77usize, 0usize); +add_sub_const_decimals!(27usize, 49usize, 76usize, 0usize); +add_sub_const_decimals!(27usize, 48usize, 75usize, 0usize); +add_sub_const_decimals!(27usize, 47usize, 74usize, 0usize); +add_sub_const_decimals!(27usize, 46usize, 73usize, 0usize); +add_sub_const_decimals!(27usize, 45usize, 72usize, 0usize); +add_sub_const_decimals!(27usize, 44usize, 71usize, 0usize); +add_sub_const_decimals!(27usize, 43usize, 70usize, 0usize); +add_sub_const_decimals!(27usize, 42usize, 69usize, 0usize); +add_sub_const_decimals!(27usize, 41usize, 68usize, 0usize); +add_sub_const_decimals!(27usize, 40usize, 67usize, 0usize); +add_sub_const_decimals!(27usize, 39usize, 66usize, 0usize); +add_sub_const_decimals!(27usize, 38usize, 65usize, 0usize); +add_sub_const_decimals!(27usize, 37usize, 64usize, 0usize); +add_sub_const_decimals!(27usize, 36usize, 63usize, 0usize); +add_sub_const_decimals!(27usize, 35usize, 62usize, 0usize); +add_sub_const_decimals!(27usize, 34usize, 61usize, 0usize); +add_sub_const_decimals!(27usize, 33usize, 60usize, 0usize); +add_sub_const_decimals!(27usize, 32usize, 59usize, 0usize); +add_sub_const_decimals!(27usize, 31usize, 58usize, 0usize); +add_sub_const_decimals!(27usize, 30usize, 57usize, 0usize); +add_sub_const_decimals!(27usize, 29usize, 56usize, 0usize); +add_sub_const_decimals!(27usize, 28usize, 55usize, 0usize); +add_sub_const_decimals!(27usize, 27usize, 54usize, 0usize); +add_sub_const_decimals!(27usize, 26usize, 53usize, 1usize); +add_sub_const_decimals!(27usize, 25usize, 52usize, 2usize); +add_sub_const_decimals!(27usize, 24usize, 51usize, 3usize); +add_sub_const_decimals!(27usize, 23usize, 50usize, 4usize); +add_sub_const_decimals!(27usize, 22usize, 49usize, 5usize); +add_sub_const_decimals!(27usize, 21usize, 48usize, 6usize); +add_sub_const_decimals!(27usize, 20usize, 47usize, 7usize); +add_sub_const_decimals!(27usize, 19usize, 46usize, 8usize); +add_sub_const_decimals!(27usize, 18usize, 45usize, 9usize); +add_sub_const_decimals!(27usize, 17usize, 44usize, 10usize); +add_sub_const_decimals!(27usize, 16usize, 43usize, 11usize); +add_sub_const_decimals!(27usize, 15usize, 42usize, 12usize); +add_sub_const_decimals!(27usize, 14usize, 41usize, 13usize); +add_sub_const_decimals!(27usize, 13usize, 40usize, 14usize); +add_sub_const_decimals!(27usize, 12usize, 39usize, 15usize); +add_sub_const_decimals!(27usize, 11usize, 38usize, 16usize); +add_sub_const_decimals!(27usize, 10usize, 37usize, 17usize); +add_sub_const_decimals!(27usize, 9usize, 36usize, 18usize); +add_sub_const_decimals!(27usize, 8usize, 35usize, 19usize); +add_sub_const_decimals!(27usize, 7usize, 34usize, 20usize); +add_sub_const_decimals!(27usize, 6usize, 33usize, 21usize); +add_sub_const_decimals!(27usize, 5usize, 32usize, 22usize); +add_sub_const_decimals!(27usize, 4usize, 31usize, 23usize); +add_sub_const_decimals!(27usize, 3usize, 30usize, 24usize); +add_sub_const_decimals!(27usize, 2usize, 29usize, 25usize); +add_sub_const_decimals!(27usize, 1usize, 28usize, 26usize); +add_sub_const_decimals!(27usize, 0usize, 27usize, 27usize); +add_sub_const_decimals!(26usize, 64usize, 90usize, 0usize); +add_sub_const_decimals!(26usize, 63usize, 89usize, 0usize); +add_sub_const_decimals!(26usize, 62usize, 88usize, 0usize); +add_sub_const_decimals!(26usize, 61usize, 87usize, 0usize); +add_sub_const_decimals!(26usize, 60usize, 86usize, 0usize); +add_sub_const_decimals!(26usize, 59usize, 85usize, 0usize); +add_sub_const_decimals!(26usize, 58usize, 84usize, 0usize); +add_sub_const_decimals!(26usize, 57usize, 83usize, 0usize); +add_sub_const_decimals!(26usize, 56usize, 82usize, 0usize); +add_sub_const_decimals!(26usize, 55usize, 81usize, 0usize); +add_sub_const_decimals!(26usize, 54usize, 80usize, 0usize); +add_sub_const_decimals!(26usize, 53usize, 79usize, 0usize); +add_sub_const_decimals!(26usize, 52usize, 78usize, 0usize); +add_sub_const_decimals!(26usize, 51usize, 77usize, 0usize); +add_sub_const_decimals!(26usize, 50usize, 76usize, 0usize); +add_sub_const_decimals!(26usize, 49usize, 75usize, 0usize); +add_sub_const_decimals!(26usize, 48usize, 74usize, 0usize); +add_sub_const_decimals!(26usize, 47usize, 73usize, 0usize); +add_sub_const_decimals!(26usize, 46usize, 72usize, 0usize); +add_sub_const_decimals!(26usize, 45usize, 71usize, 0usize); +add_sub_const_decimals!(26usize, 44usize, 70usize, 0usize); +add_sub_const_decimals!(26usize, 43usize, 69usize, 0usize); +add_sub_const_decimals!(26usize, 42usize, 68usize, 0usize); +add_sub_const_decimals!(26usize, 41usize, 67usize, 0usize); +add_sub_const_decimals!(26usize, 40usize, 66usize, 0usize); +add_sub_const_decimals!(26usize, 39usize, 65usize, 0usize); +add_sub_const_decimals!(26usize, 38usize, 64usize, 0usize); +add_sub_const_decimals!(26usize, 37usize, 63usize, 0usize); +add_sub_const_decimals!(26usize, 36usize, 62usize, 0usize); +add_sub_const_decimals!(26usize, 35usize, 61usize, 0usize); +add_sub_const_decimals!(26usize, 34usize, 60usize, 0usize); +add_sub_const_decimals!(26usize, 33usize, 59usize, 0usize); +add_sub_const_decimals!(26usize, 32usize, 58usize, 0usize); +add_sub_const_decimals!(26usize, 31usize, 57usize, 0usize); +add_sub_const_decimals!(26usize, 30usize, 56usize, 0usize); +add_sub_const_decimals!(26usize, 29usize, 55usize, 0usize); +add_sub_const_decimals!(26usize, 28usize, 54usize, 0usize); +add_sub_const_decimals!(26usize, 27usize, 53usize, 0usize); +add_sub_const_decimals!(26usize, 26usize, 52usize, 0usize); +add_sub_const_decimals!(26usize, 25usize, 51usize, 1usize); +add_sub_const_decimals!(26usize, 24usize, 50usize, 2usize); +add_sub_const_decimals!(26usize, 23usize, 49usize, 3usize); +add_sub_const_decimals!(26usize, 22usize, 48usize, 4usize); +add_sub_const_decimals!(26usize, 21usize, 47usize, 5usize); +add_sub_const_decimals!(26usize, 20usize, 46usize, 6usize); +add_sub_const_decimals!(26usize, 19usize, 45usize, 7usize); +add_sub_const_decimals!(26usize, 18usize, 44usize, 8usize); +add_sub_const_decimals!(26usize, 17usize, 43usize, 9usize); +add_sub_const_decimals!(26usize, 16usize, 42usize, 10usize); +add_sub_const_decimals!(26usize, 15usize, 41usize, 11usize); +add_sub_const_decimals!(26usize, 14usize, 40usize, 12usize); +add_sub_const_decimals!(26usize, 13usize, 39usize, 13usize); +add_sub_const_decimals!(26usize, 12usize, 38usize, 14usize); +add_sub_const_decimals!(26usize, 11usize, 37usize, 15usize); +add_sub_const_decimals!(26usize, 10usize, 36usize, 16usize); +add_sub_const_decimals!(26usize, 9usize, 35usize, 17usize); +add_sub_const_decimals!(26usize, 8usize, 34usize, 18usize); +add_sub_const_decimals!(26usize, 7usize, 33usize, 19usize); +add_sub_const_decimals!(26usize, 6usize, 32usize, 20usize); +add_sub_const_decimals!(26usize, 5usize, 31usize, 21usize); +add_sub_const_decimals!(26usize, 4usize, 30usize, 22usize); +add_sub_const_decimals!(26usize, 3usize, 29usize, 23usize); +add_sub_const_decimals!(26usize, 2usize, 28usize, 24usize); +add_sub_const_decimals!(26usize, 1usize, 27usize, 25usize); +add_sub_const_decimals!(26usize, 0usize, 26usize, 26usize); +add_sub_const_decimals!(25usize, 64usize, 89usize, 0usize); +add_sub_const_decimals!(25usize, 63usize, 88usize, 0usize); +add_sub_const_decimals!(25usize, 62usize, 87usize, 0usize); +add_sub_const_decimals!(25usize, 61usize, 86usize, 0usize); +add_sub_const_decimals!(25usize, 60usize, 85usize, 0usize); +add_sub_const_decimals!(25usize, 59usize, 84usize, 0usize); +add_sub_const_decimals!(25usize, 58usize, 83usize, 0usize); +add_sub_const_decimals!(25usize, 57usize, 82usize, 0usize); +add_sub_const_decimals!(25usize, 56usize, 81usize, 0usize); +add_sub_const_decimals!(25usize, 55usize, 80usize, 0usize); +add_sub_const_decimals!(25usize, 54usize, 79usize, 0usize); +add_sub_const_decimals!(25usize, 53usize, 78usize, 0usize); +add_sub_const_decimals!(25usize, 52usize, 77usize, 0usize); +add_sub_const_decimals!(25usize, 51usize, 76usize, 0usize); +add_sub_const_decimals!(25usize, 50usize, 75usize, 0usize); +add_sub_const_decimals!(25usize, 49usize, 74usize, 0usize); +add_sub_const_decimals!(25usize, 48usize, 73usize, 0usize); +add_sub_const_decimals!(25usize, 47usize, 72usize, 0usize); +add_sub_const_decimals!(25usize, 46usize, 71usize, 0usize); +add_sub_const_decimals!(25usize, 45usize, 70usize, 0usize); +add_sub_const_decimals!(25usize, 44usize, 69usize, 0usize); +add_sub_const_decimals!(25usize, 43usize, 68usize, 0usize); +add_sub_const_decimals!(25usize, 42usize, 67usize, 0usize); +add_sub_const_decimals!(25usize, 41usize, 66usize, 0usize); +add_sub_const_decimals!(25usize, 40usize, 65usize, 0usize); +add_sub_const_decimals!(25usize, 39usize, 64usize, 0usize); +add_sub_const_decimals!(25usize, 38usize, 63usize, 0usize); +add_sub_const_decimals!(25usize, 37usize, 62usize, 0usize); +add_sub_const_decimals!(25usize, 36usize, 61usize, 0usize); +add_sub_const_decimals!(25usize, 35usize, 60usize, 0usize); +add_sub_const_decimals!(25usize, 34usize, 59usize, 0usize); +add_sub_const_decimals!(25usize, 33usize, 58usize, 0usize); +add_sub_const_decimals!(25usize, 32usize, 57usize, 0usize); +add_sub_const_decimals!(25usize, 31usize, 56usize, 0usize); +add_sub_const_decimals!(25usize, 30usize, 55usize, 0usize); +add_sub_const_decimals!(25usize, 29usize, 54usize, 0usize); +add_sub_const_decimals!(25usize, 28usize, 53usize, 0usize); +add_sub_const_decimals!(25usize, 27usize, 52usize, 0usize); +add_sub_const_decimals!(25usize, 26usize, 51usize, 0usize); +add_sub_const_decimals!(25usize, 25usize, 50usize, 0usize); +add_sub_const_decimals!(25usize, 24usize, 49usize, 1usize); +add_sub_const_decimals!(25usize, 23usize, 48usize, 2usize); +add_sub_const_decimals!(25usize, 22usize, 47usize, 3usize); +add_sub_const_decimals!(25usize, 21usize, 46usize, 4usize); +add_sub_const_decimals!(25usize, 20usize, 45usize, 5usize); +add_sub_const_decimals!(25usize, 19usize, 44usize, 6usize); +add_sub_const_decimals!(25usize, 18usize, 43usize, 7usize); +add_sub_const_decimals!(25usize, 17usize, 42usize, 8usize); +add_sub_const_decimals!(25usize, 16usize, 41usize, 9usize); +add_sub_const_decimals!(25usize, 15usize, 40usize, 10usize); +add_sub_const_decimals!(25usize, 14usize, 39usize, 11usize); +add_sub_const_decimals!(25usize, 13usize, 38usize, 12usize); +add_sub_const_decimals!(25usize, 12usize, 37usize, 13usize); +add_sub_const_decimals!(25usize, 11usize, 36usize, 14usize); +add_sub_const_decimals!(25usize, 10usize, 35usize, 15usize); +add_sub_const_decimals!(25usize, 9usize, 34usize, 16usize); +add_sub_const_decimals!(25usize, 8usize, 33usize, 17usize); +add_sub_const_decimals!(25usize, 7usize, 32usize, 18usize); +add_sub_const_decimals!(25usize, 6usize, 31usize, 19usize); +add_sub_const_decimals!(25usize, 5usize, 30usize, 20usize); +add_sub_const_decimals!(25usize, 4usize, 29usize, 21usize); +add_sub_const_decimals!(25usize, 3usize, 28usize, 22usize); +add_sub_const_decimals!(25usize, 2usize, 27usize, 23usize); +add_sub_const_decimals!(25usize, 1usize, 26usize, 24usize); +add_sub_const_decimals!(25usize, 0usize, 25usize, 25usize); +add_sub_const_decimals!(24usize, 64usize, 88usize, 0usize); +add_sub_const_decimals!(24usize, 63usize, 87usize, 0usize); +add_sub_const_decimals!(24usize, 62usize, 86usize, 0usize); +add_sub_const_decimals!(24usize, 61usize, 85usize, 0usize); +add_sub_const_decimals!(24usize, 60usize, 84usize, 0usize); +add_sub_const_decimals!(24usize, 59usize, 83usize, 0usize); +add_sub_const_decimals!(24usize, 58usize, 82usize, 0usize); +add_sub_const_decimals!(24usize, 57usize, 81usize, 0usize); +add_sub_const_decimals!(24usize, 56usize, 80usize, 0usize); +add_sub_const_decimals!(24usize, 55usize, 79usize, 0usize); +add_sub_const_decimals!(24usize, 54usize, 78usize, 0usize); +add_sub_const_decimals!(24usize, 53usize, 77usize, 0usize); +add_sub_const_decimals!(24usize, 52usize, 76usize, 0usize); +add_sub_const_decimals!(24usize, 51usize, 75usize, 0usize); +add_sub_const_decimals!(24usize, 50usize, 74usize, 0usize); +add_sub_const_decimals!(24usize, 49usize, 73usize, 0usize); +add_sub_const_decimals!(24usize, 48usize, 72usize, 0usize); +add_sub_const_decimals!(24usize, 47usize, 71usize, 0usize); +add_sub_const_decimals!(24usize, 46usize, 70usize, 0usize); +add_sub_const_decimals!(24usize, 45usize, 69usize, 0usize); +add_sub_const_decimals!(24usize, 44usize, 68usize, 0usize); +add_sub_const_decimals!(24usize, 43usize, 67usize, 0usize); +add_sub_const_decimals!(24usize, 42usize, 66usize, 0usize); +add_sub_const_decimals!(24usize, 41usize, 65usize, 0usize); +add_sub_const_decimals!(24usize, 40usize, 64usize, 0usize); +add_sub_const_decimals!(24usize, 39usize, 63usize, 0usize); +add_sub_const_decimals!(24usize, 38usize, 62usize, 0usize); +add_sub_const_decimals!(24usize, 37usize, 61usize, 0usize); +add_sub_const_decimals!(24usize, 36usize, 60usize, 0usize); +add_sub_const_decimals!(24usize, 35usize, 59usize, 0usize); +add_sub_const_decimals!(24usize, 34usize, 58usize, 0usize); +add_sub_const_decimals!(24usize, 33usize, 57usize, 0usize); +add_sub_const_decimals!(24usize, 32usize, 56usize, 0usize); +add_sub_const_decimals!(24usize, 31usize, 55usize, 0usize); +add_sub_const_decimals!(24usize, 30usize, 54usize, 0usize); +add_sub_const_decimals!(24usize, 29usize, 53usize, 0usize); +add_sub_const_decimals!(24usize, 28usize, 52usize, 0usize); +add_sub_const_decimals!(24usize, 27usize, 51usize, 0usize); +add_sub_const_decimals!(24usize, 26usize, 50usize, 0usize); +add_sub_const_decimals!(24usize, 25usize, 49usize, 0usize); +add_sub_const_decimals!(24usize, 24usize, 48usize, 0usize); +add_sub_const_decimals!(24usize, 23usize, 47usize, 1usize); +add_sub_const_decimals!(24usize, 22usize, 46usize, 2usize); +add_sub_const_decimals!(24usize, 21usize, 45usize, 3usize); +add_sub_const_decimals!(24usize, 20usize, 44usize, 4usize); +add_sub_const_decimals!(24usize, 19usize, 43usize, 5usize); +add_sub_const_decimals!(24usize, 18usize, 42usize, 6usize); +add_sub_const_decimals!(24usize, 17usize, 41usize, 7usize); +add_sub_const_decimals!(24usize, 16usize, 40usize, 8usize); +add_sub_const_decimals!(24usize, 15usize, 39usize, 9usize); +add_sub_const_decimals!(24usize, 14usize, 38usize, 10usize); +add_sub_const_decimals!(24usize, 13usize, 37usize, 11usize); +add_sub_const_decimals!(24usize, 12usize, 36usize, 12usize); +add_sub_const_decimals!(24usize, 11usize, 35usize, 13usize); +add_sub_const_decimals!(24usize, 10usize, 34usize, 14usize); +add_sub_const_decimals!(24usize, 9usize, 33usize, 15usize); +add_sub_const_decimals!(24usize, 8usize, 32usize, 16usize); +add_sub_const_decimals!(24usize, 7usize, 31usize, 17usize); +add_sub_const_decimals!(24usize, 6usize, 30usize, 18usize); +add_sub_const_decimals!(24usize, 5usize, 29usize, 19usize); +add_sub_const_decimals!(24usize, 4usize, 28usize, 20usize); +add_sub_const_decimals!(24usize, 3usize, 27usize, 21usize); +add_sub_const_decimals!(24usize, 2usize, 26usize, 22usize); +add_sub_const_decimals!(24usize, 1usize, 25usize, 23usize); +add_sub_const_decimals!(24usize, 0usize, 24usize, 24usize); +add_sub_const_decimals!(23usize, 64usize, 87usize, 0usize); +add_sub_const_decimals!(23usize, 63usize, 86usize, 0usize); +add_sub_const_decimals!(23usize, 62usize, 85usize, 0usize); +add_sub_const_decimals!(23usize, 61usize, 84usize, 0usize); +add_sub_const_decimals!(23usize, 60usize, 83usize, 0usize); +add_sub_const_decimals!(23usize, 59usize, 82usize, 0usize); +add_sub_const_decimals!(23usize, 58usize, 81usize, 0usize); +add_sub_const_decimals!(23usize, 57usize, 80usize, 0usize); +add_sub_const_decimals!(23usize, 56usize, 79usize, 0usize); +add_sub_const_decimals!(23usize, 55usize, 78usize, 0usize); +add_sub_const_decimals!(23usize, 54usize, 77usize, 0usize); +add_sub_const_decimals!(23usize, 53usize, 76usize, 0usize); +add_sub_const_decimals!(23usize, 52usize, 75usize, 0usize); +add_sub_const_decimals!(23usize, 51usize, 74usize, 0usize); +add_sub_const_decimals!(23usize, 50usize, 73usize, 0usize); +add_sub_const_decimals!(23usize, 49usize, 72usize, 0usize); +add_sub_const_decimals!(23usize, 48usize, 71usize, 0usize); +add_sub_const_decimals!(23usize, 47usize, 70usize, 0usize); +add_sub_const_decimals!(23usize, 46usize, 69usize, 0usize); +add_sub_const_decimals!(23usize, 45usize, 68usize, 0usize); +add_sub_const_decimals!(23usize, 44usize, 67usize, 0usize); +add_sub_const_decimals!(23usize, 43usize, 66usize, 0usize); +add_sub_const_decimals!(23usize, 42usize, 65usize, 0usize); +add_sub_const_decimals!(23usize, 41usize, 64usize, 0usize); +add_sub_const_decimals!(23usize, 40usize, 63usize, 0usize); +add_sub_const_decimals!(23usize, 39usize, 62usize, 0usize); +add_sub_const_decimals!(23usize, 38usize, 61usize, 0usize); +add_sub_const_decimals!(23usize, 37usize, 60usize, 0usize); +add_sub_const_decimals!(23usize, 36usize, 59usize, 0usize); +add_sub_const_decimals!(23usize, 35usize, 58usize, 0usize); +add_sub_const_decimals!(23usize, 34usize, 57usize, 0usize); +add_sub_const_decimals!(23usize, 33usize, 56usize, 0usize); +add_sub_const_decimals!(23usize, 32usize, 55usize, 0usize); +add_sub_const_decimals!(23usize, 31usize, 54usize, 0usize); +add_sub_const_decimals!(23usize, 30usize, 53usize, 0usize); +add_sub_const_decimals!(23usize, 29usize, 52usize, 0usize); +add_sub_const_decimals!(23usize, 28usize, 51usize, 0usize); +add_sub_const_decimals!(23usize, 27usize, 50usize, 0usize); +add_sub_const_decimals!(23usize, 26usize, 49usize, 0usize); +add_sub_const_decimals!(23usize, 25usize, 48usize, 0usize); +add_sub_const_decimals!(23usize, 24usize, 47usize, 0usize); +add_sub_const_decimals!(23usize, 23usize, 46usize, 0usize); +add_sub_const_decimals!(23usize, 22usize, 45usize, 1usize); +add_sub_const_decimals!(23usize, 21usize, 44usize, 2usize); +add_sub_const_decimals!(23usize, 20usize, 43usize, 3usize); +add_sub_const_decimals!(23usize, 19usize, 42usize, 4usize); +add_sub_const_decimals!(23usize, 18usize, 41usize, 5usize); +add_sub_const_decimals!(23usize, 17usize, 40usize, 6usize); +add_sub_const_decimals!(23usize, 16usize, 39usize, 7usize); +add_sub_const_decimals!(23usize, 15usize, 38usize, 8usize); +add_sub_const_decimals!(23usize, 14usize, 37usize, 9usize); +add_sub_const_decimals!(23usize, 13usize, 36usize, 10usize); +add_sub_const_decimals!(23usize, 12usize, 35usize, 11usize); +add_sub_const_decimals!(23usize, 11usize, 34usize, 12usize); +add_sub_const_decimals!(23usize, 10usize, 33usize, 13usize); +add_sub_const_decimals!(23usize, 9usize, 32usize, 14usize); +add_sub_const_decimals!(23usize, 8usize, 31usize, 15usize); +add_sub_const_decimals!(23usize, 7usize, 30usize, 16usize); +add_sub_const_decimals!(23usize, 6usize, 29usize, 17usize); +add_sub_const_decimals!(23usize, 5usize, 28usize, 18usize); +add_sub_const_decimals!(23usize, 4usize, 27usize, 19usize); +add_sub_const_decimals!(23usize, 3usize, 26usize, 20usize); +add_sub_const_decimals!(23usize, 2usize, 25usize, 21usize); +add_sub_const_decimals!(23usize, 1usize, 24usize, 22usize); +add_sub_const_decimals!(23usize, 0usize, 23usize, 23usize); +add_sub_const_decimals!(22usize, 64usize, 86usize, 0usize); +add_sub_const_decimals!(22usize, 63usize, 85usize, 0usize); +add_sub_const_decimals!(22usize, 62usize, 84usize, 0usize); +add_sub_const_decimals!(22usize, 61usize, 83usize, 0usize); +add_sub_const_decimals!(22usize, 60usize, 82usize, 0usize); +add_sub_const_decimals!(22usize, 59usize, 81usize, 0usize); +add_sub_const_decimals!(22usize, 58usize, 80usize, 0usize); +add_sub_const_decimals!(22usize, 57usize, 79usize, 0usize); +add_sub_const_decimals!(22usize, 56usize, 78usize, 0usize); +add_sub_const_decimals!(22usize, 55usize, 77usize, 0usize); +add_sub_const_decimals!(22usize, 54usize, 76usize, 0usize); +add_sub_const_decimals!(22usize, 53usize, 75usize, 0usize); +add_sub_const_decimals!(22usize, 52usize, 74usize, 0usize); +add_sub_const_decimals!(22usize, 51usize, 73usize, 0usize); +add_sub_const_decimals!(22usize, 50usize, 72usize, 0usize); +add_sub_const_decimals!(22usize, 49usize, 71usize, 0usize); +add_sub_const_decimals!(22usize, 48usize, 70usize, 0usize); +add_sub_const_decimals!(22usize, 47usize, 69usize, 0usize); +add_sub_const_decimals!(22usize, 46usize, 68usize, 0usize); +add_sub_const_decimals!(22usize, 45usize, 67usize, 0usize); +add_sub_const_decimals!(22usize, 44usize, 66usize, 0usize); +add_sub_const_decimals!(22usize, 43usize, 65usize, 0usize); +add_sub_const_decimals!(22usize, 42usize, 64usize, 0usize); +add_sub_const_decimals!(22usize, 41usize, 63usize, 0usize); +add_sub_const_decimals!(22usize, 40usize, 62usize, 0usize); +add_sub_const_decimals!(22usize, 39usize, 61usize, 0usize); +add_sub_const_decimals!(22usize, 38usize, 60usize, 0usize); +add_sub_const_decimals!(22usize, 37usize, 59usize, 0usize); +add_sub_const_decimals!(22usize, 36usize, 58usize, 0usize); +add_sub_const_decimals!(22usize, 35usize, 57usize, 0usize); +add_sub_const_decimals!(22usize, 34usize, 56usize, 0usize); +add_sub_const_decimals!(22usize, 33usize, 55usize, 0usize); +add_sub_const_decimals!(22usize, 32usize, 54usize, 0usize); +add_sub_const_decimals!(22usize, 31usize, 53usize, 0usize); +add_sub_const_decimals!(22usize, 30usize, 52usize, 0usize); +add_sub_const_decimals!(22usize, 29usize, 51usize, 0usize); +add_sub_const_decimals!(22usize, 28usize, 50usize, 0usize); +add_sub_const_decimals!(22usize, 27usize, 49usize, 0usize); +add_sub_const_decimals!(22usize, 26usize, 48usize, 0usize); +add_sub_const_decimals!(22usize, 25usize, 47usize, 0usize); +add_sub_const_decimals!(22usize, 24usize, 46usize, 0usize); +add_sub_const_decimals!(22usize, 23usize, 45usize, 0usize); +add_sub_const_decimals!(22usize, 22usize, 44usize, 0usize); +add_sub_const_decimals!(22usize, 21usize, 43usize, 1usize); +add_sub_const_decimals!(22usize, 20usize, 42usize, 2usize); +add_sub_const_decimals!(22usize, 19usize, 41usize, 3usize); +add_sub_const_decimals!(22usize, 18usize, 40usize, 4usize); +add_sub_const_decimals!(22usize, 17usize, 39usize, 5usize); +add_sub_const_decimals!(22usize, 16usize, 38usize, 6usize); +add_sub_const_decimals!(22usize, 15usize, 37usize, 7usize); +add_sub_const_decimals!(22usize, 14usize, 36usize, 8usize); +add_sub_const_decimals!(22usize, 13usize, 35usize, 9usize); +add_sub_const_decimals!(22usize, 12usize, 34usize, 10usize); +add_sub_const_decimals!(22usize, 11usize, 33usize, 11usize); +add_sub_const_decimals!(22usize, 10usize, 32usize, 12usize); +add_sub_const_decimals!(22usize, 9usize, 31usize, 13usize); +add_sub_const_decimals!(22usize, 8usize, 30usize, 14usize); +add_sub_const_decimals!(22usize, 7usize, 29usize, 15usize); +add_sub_const_decimals!(22usize, 6usize, 28usize, 16usize); +add_sub_const_decimals!(22usize, 5usize, 27usize, 17usize); +add_sub_const_decimals!(22usize, 4usize, 26usize, 18usize); +add_sub_const_decimals!(22usize, 3usize, 25usize, 19usize); +add_sub_const_decimals!(22usize, 2usize, 24usize, 20usize); +add_sub_const_decimals!(22usize, 1usize, 23usize, 21usize); +add_sub_const_decimals!(22usize, 0usize, 22usize, 22usize); +add_sub_const_decimals!(21usize, 64usize, 85usize, 0usize); +add_sub_const_decimals!(21usize, 63usize, 84usize, 0usize); +add_sub_const_decimals!(21usize, 62usize, 83usize, 0usize); +add_sub_const_decimals!(21usize, 61usize, 82usize, 0usize); +add_sub_const_decimals!(21usize, 60usize, 81usize, 0usize); +add_sub_const_decimals!(21usize, 59usize, 80usize, 0usize); +add_sub_const_decimals!(21usize, 58usize, 79usize, 0usize); +add_sub_const_decimals!(21usize, 57usize, 78usize, 0usize); +add_sub_const_decimals!(21usize, 56usize, 77usize, 0usize); +add_sub_const_decimals!(21usize, 55usize, 76usize, 0usize); +add_sub_const_decimals!(21usize, 54usize, 75usize, 0usize); +add_sub_const_decimals!(21usize, 53usize, 74usize, 0usize); +add_sub_const_decimals!(21usize, 52usize, 73usize, 0usize); +add_sub_const_decimals!(21usize, 51usize, 72usize, 0usize); +add_sub_const_decimals!(21usize, 50usize, 71usize, 0usize); +add_sub_const_decimals!(21usize, 49usize, 70usize, 0usize); +add_sub_const_decimals!(21usize, 48usize, 69usize, 0usize); +add_sub_const_decimals!(21usize, 47usize, 68usize, 0usize); +add_sub_const_decimals!(21usize, 46usize, 67usize, 0usize); +add_sub_const_decimals!(21usize, 45usize, 66usize, 0usize); +add_sub_const_decimals!(21usize, 44usize, 65usize, 0usize); +add_sub_const_decimals!(21usize, 43usize, 64usize, 0usize); +add_sub_const_decimals!(21usize, 42usize, 63usize, 0usize); +add_sub_const_decimals!(21usize, 41usize, 62usize, 0usize); +add_sub_const_decimals!(21usize, 40usize, 61usize, 0usize); +add_sub_const_decimals!(21usize, 39usize, 60usize, 0usize); +add_sub_const_decimals!(21usize, 38usize, 59usize, 0usize); +add_sub_const_decimals!(21usize, 37usize, 58usize, 0usize); +add_sub_const_decimals!(21usize, 36usize, 57usize, 0usize); +add_sub_const_decimals!(21usize, 35usize, 56usize, 0usize); +add_sub_const_decimals!(21usize, 34usize, 55usize, 0usize); +add_sub_const_decimals!(21usize, 33usize, 54usize, 0usize); +add_sub_const_decimals!(21usize, 32usize, 53usize, 0usize); +add_sub_const_decimals!(21usize, 31usize, 52usize, 0usize); +add_sub_const_decimals!(21usize, 30usize, 51usize, 0usize); +add_sub_const_decimals!(21usize, 29usize, 50usize, 0usize); +add_sub_const_decimals!(21usize, 28usize, 49usize, 0usize); +add_sub_const_decimals!(21usize, 27usize, 48usize, 0usize); +add_sub_const_decimals!(21usize, 26usize, 47usize, 0usize); +add_sub_const_decimals!(21usize, 25usize, 46usize, 0usize); +add_sub_const_decimals!(21usize, 24usize, 45usize, 0usize); +add_sub_const_decimals!(21usize, 23usize, 44usize, 0usize); +add_sub_const_decimals!(21usize, 22usize, 43usize, 0usize); +add_sub_const_decimals!(21usize, 21usize, 42usize, 0usize); +add_sub_const_decimals!(21usize, 20usize, 41usize, 1usize); +add_sub_const_decimals!(21usize, 19usize, 40usize, 2usize); +add_sub_const_decimals!(21usize, 18usize, 39usize, 3usize); +add_sub_const_decimals!(21usize, 17usize, 38usize, 4usize); +add_sub_const_decimals!(21usize, 16usize, 37usize, 5usize); +add_sub_const_decimals!(21usize, 15usize, 36usize, 6usize); +add_sub_const_decimals!(21usize, 14usize, 35usize, 7usize); +add_sub_const_decimals!(21usize, 13usize, 34usize, 8usize); +add_sub_const_decimals!(21usize, 12usize, 33usize, 9usize); +add_sub_const_decimals!(21usize, 11usize, 32usize, 10usize); +add_sub_const_decimals!(21usize, 10usize, 31usize, 11usize); +add_sub_const_decimals!(21usize, 9usize, 30usize, 12usize); +add_sub_const_decimals!(21usize, 8usize, 29usize, 13usize); +add_sub_const_decimals!(21usize, 7usize, 28usize, 14usize); +add_sub_const_decimals!(21usize, 6usize, 27usize, 15usize); +add_sub_const_decimals!(21usize, 5usize, 26usize, 16usize); +add_sub_const_decimals!(21usize, 4usize, 25usize, 17usize); +add_sub_const_decimals!(21usize, 3usize, 24usize, 18usize); +add_sub_const_decimals!(21usize, 2usize, 23usize, 19usize); +add_sub_const_decimals!(21usize, 1usize, 22usize, 20usize); +add_sub_const_decimals!(21usize, 0usize, 21usize, 21usize); +add_sub_const_decimals!(20usize, 64usize, 84usize, 0usize); +add_sub_const_decimals!(20usize, 63usize, 83usize, 0usize); +add_sub_const_decimals!(20usize, 62usize, 82usize, 0usize); +add_sub_const_decimals!(20usize, 61usize, 81usize, 0usize); +add_sub_const_decimals!(20usize, 60usize, 80usize, 0usize); +add_sub_const_decimals!(20usize, 59usize, 79usize, 0usize); +add_sub_const_decimals!(20usize, 58usize, 78usize, 0usize); +add_sub_const_decimals!(20usize, 57usize, 77usize, 0usize); +add_sub_const_decimals!(20usize, 56usize, 76usize, 0usize); +add_sub_const_decimals!(20usize, 55usize, 75usize, 0usize); +add_sub_const_decimals!(20usize, 54usize, 74usize, 0usize); +add_sub_const_decimals!(20usize, 53usize, 73usize, 0usize); +add_sub_const_decimals!(20usize, 52usize, 72usize, 0usize); +add_sub_const_decimals!(20usize, 51usize, 71usize, 0usize); +add_sub_const_decimals!(20usize, 50usize, 70usize, 0usize); +add_sub_const_decimals!(20usize, 49usize, 69usize, 0usize); +add_sub_const_decimals!(20usize, 48usize, 68usize, 0usize); +add_sub_const_decimals!(20usize, 47usize, 67usize, 0usize); +add_sub_const_decimals!(20usize, 46usize, 66usize, 0usize); +add_sub_const_decimals!(20usize, 45usize, 65usize, 0usize); +add_sub_const_decimals!(20usize, 44usize, 64usize, 0usize); +add_sub_const_decimals!(20usize, 43usize, 63usize, 0usize); +add_sub_const_decimals!(20usize, 42usize, 62usize, 0usize); +add_sub_const_decimals!(20usize, 41usize, 61usize, 0usize); +add_sub_const_decimals!(20usize, 40usize, 60usize, 0usize); +add_sub_const_decimals!(20usize, 39usize, 59usize, 0usize); +add_sub_const_decimals!(20usize, 38usize, 58usize, 0usize); +add_sub_const_decimals!(20usize, 37usize, 57usize, 0usize); +add_sub_const_decimals!(20usize, 36usize, 56usize, 0usize); +add_sub_const_decimals!(20usize, 35usize, 55usize, 0usize); +add_sub_const_decimals!(20usize, 34usize, 54usize, 0usize); +add_sub_const_decimals!(20usize, 33usize, 53usize, 0usize); +add_sub_const_decimals!(20usize, 32usize, 52usize, 0usize); +add_sub_const_decimals!(20usize, 31usize, 51usize, 0usize); +add_sub_const_decimals!(20usize, 30usize, 50usize, 0usize); +add_sub_const_decimals!(20usize, 29usize, 49usize, 0usize); +add_sub_const_decimals!(20usize, 28usize, 48usize, 0usize); +add_sub_const_decimals!(20usize, 27usize, 47usize, 0usize); +add_sub_const_decimals!(20usize, 26usize, 46usize, 0usize); +add_sub_const_decimals!(20usize, 25usize, 45usize, 0usize); +add_sub_const_decimals!(20usize, 24usize, 44usize, 0usize); +add_sub_const_decimals!(20usize, 23usize, 43usize, 0usize); +add_sub_const_decimals!(20usize, 22usize, 42usize, 0usize); +add_sub_const_decimals!(20usize, 21usize, 41usize, 0usize); +add_sub_const_decimals!(20usize, 20usize, 40usize, 0usize); +add_sub_const_decimals!(20usize, 19usize, 39usize, 1usize); +add_sub_const_decimals!(20usize, 18usize, 38usize, 2usize); +add_sub_const_decimals!(20usize, 17usize, 37usize, 3usize); +add_sub_const_decimals!(20usize, 16usize, 36usize, 4usize); +add_sub_const_decimals!(20usize, 15usize, 35usize, 5usize); +add_sub_const_decimals!(20usize, 14usize, 34usize, 6usize); +add_sub_const_decimals!(20usize, 13usize, 33usize, 7usize); +add_sub_const_decimals!(20usize, 12usize, 32usize, 8usize); +add_sub_const_decimals!(20usize, 11usize, 31usize, 9usize); +add_sub_const_decimals!(20usize, 10usize, 30usize, 10usize); +add_sub_const_decimals!(20usize, 9usize, 29usize, 11usize); +add_sub_const_decimals!(20usize, 8usize, 28usize, 12usize); +add_sub_const_decimals!(20usize, 7usize, 27usize, 13usize); +add_sub_const_decimals!(20usize, 6usize, 26usize, 14usize); +add_sub_const_decimals!(20usize, 5usize, 25usize, 15usize); +add_sub_const_decimals!(20usize, 4usize, 24usize, 16usize); +add_sub_const_decimals!(20usize, 3usize, 23usize, 17usize); +add_sub_const_decimals!(20usize, 2usize, 22usize, 18usize); +add_sub_const_decimals!(20usize, 1usize, 21usize, 19usize); +add_sub_const_decimals!(20usize, 0usize, 20usize, 20usize); +add_sub_const_decimals!(19usize, 64usize, 83usize, 0usize); +add_sub_const_decimals!(19usize, 63usize, 82usize, 0usize); +add_sub_const_decimals!(19usize, 62usize, 81usize, 0usize); +add_sub_const_decimals!(19usize, 61usize, 80usize, 0usize); +add_sub_const_decimals!(19usize, 60usize, 79usize, 0usize); +add_sub_const_decimals!(19usize, 59usize, 78usize, 0usize); +add_sub_const_decimals!(19usize, 58usize, 77usize, 0usize); +add_sub_const_decimals!(19usize, 57usize, 76usize, 0usize); +add_sub_const_decimals!(19usize, 56usize, 75usize, 0usize); +add_sub_const_decimals!(19usize, 55usize, 74usize, 0usize); +add_sub_const_decimals!(19usize, 54usize, 73usize, 0usize); +add_sub_const_decimals!(19usize, 53usize, 72usize, 0usize); +add_sub_const_decimals!(19usize, 52usize, 71usize, 0usize); +add_sub_const_decimals!(19usize, 51usize, 70usize, 0usize); +add_sub_const_decimals!(19usize, 50usize, 69usize, 0usize); +add_sub_const_decimals!(19usize, 49usize, 68usize, 0usize); +add_sub_const_decimals!(19usize, 48usize, 67usize, 0usize); +add_sub_const_decimals!(19usize, 47usize, 66usize, 0usize); +add_sub_const_decimals!(19usize, 46usize, 65usize, 0usize); +add_sub_const_decimals!(19usize, 45usize, 64usize, 0usize); +add_sub_const_decimals!(19usize, 44usize, 63usize, 0usize); +add_sub_const_decimals!(19usize, 43usize, 62usize, 0usize); +add_sub_const_decimals!(19usize, 42usize, 61usize, 0usize); +add_sub_const_decimals!(19usize, 41usize, 60usize, 0usize); +add_sub_const_decimals!(19usize, 40usize, 59usize, 0usize); +add_sub_const_decimals!(19usize, 39usize, 58usize, 0usize); +add_sub_const_decimals!(19usize, 38usize, 57usize, 0usize); +add_sub_const_decimals!(19usize, 37usize, 56usize, 0usize); +add_sub_const_decimals!(19usize, 36usize, 55usize, 0usize); +add_sub_const_decimals!(19usize, 35usize, 54usize, 0usize); +add_sub_const_decimals!(19usize, 34usize, 53usize, 0usize); +add_sub_const_decimals!(19usize, 33usize, 52usize, 0usize); +add_sub_const_decimals!(19usize, 32usize, 51usize, 0usize); +add_sub_const_decimals!(19usize, 31usize, 50usize, 0usize); +add_sub_const_decimals!(19usize, 30usize, 49usize, 0usize); +add_sub_const_decimals!(19usize, 29usize, 48usize, 0usize); +add_sub_const_decimals!(19usize, 28usize, 47usize, 0usize); +add_sub_const_decimals!(19usize, 27usize, 46usize, 0usize); +add_sub_const_decimals!(19usize, 26usize, 45usize, 0usize); +add_sub_const_decimals!(19usize, 25usize, 44usize, 0usize); +add_sub_const_decimals!(19usize, 24usize, 43usize, 0usize); +add_sub_const_decimals!(19usize, 23usize, 42usize, 0usize); +add_sub_const_decimals!(19usize, 22usize, 41usize, 0usize); +add_sub_const_decimals!(19usize, 21usize, 40usize, 0usize); +add_sub_const_decimals!(19usize, 20usize, 39usize, 0usize); +add_sub_const_decimals!(19usize, 19usize, 38usize, 0usize); +add_sub_const_decimals!(19usize, 18usize, 37usize, 1usize); +add_sub_const_decimals!(19usize, 17usize, 36usize, 2usize); +add_sub_const_decimals!(19usize, 16usize, 35usize, 3usize); +add_sub_const_decimals!(19usize, 15usize, 34usize, 4usize); +add_sub_const_decimals!(19usize, 14usize, 33usize, 5usize); +add_sub_const_decimals!(19usize, 13usize, 32usize, 6usize); +add_sub_const_decimals!(19usize, 12usize, 31usize, 7usize); +add_sub_const_decimals!(19usize, 11usize, 30usize, 8usize); +add_sub_const_decimals!(19usize, 10usize, 29usize, 9usize); +add_sub_const_decimals!(19usize, 9usize, 28usize, 10usize); +add_sub_const_decimals!(19usize, 8usize, 27usize, 11usize); +add_sub_const_decimals!(19usize, 7usize, 26usize, 12usize); +add_sub_const_decimals!(19usize, 6usize, 25usize, 13usize); +add_sub_const_decimals!(19usize, 5usize, 24usize, 14usize); +add_sub_const_decimals!(19usize, 4usize, 23usize, 15usize); +add_sub_const_decimals!(19usize, 3usize, 22usize, 16usize); +add_sub_const_decimals!(19usize, 2usize, 21usize, 17usize); +add_sub_const_decimals!(19usize, 1usize, 20usize, 18usize); +add_sub_const_decimals!(19usize, 0usize, 19usize, 19usize); +add_sub_const_decimals!(18usize, 64usize, 82usize, 0usize); +add_sub_const_decimals!(18usize, 63usize, 81usize, 0usize); +add_sub_const_decimals!(18usize, 62usize, 80usize, 0usize); +add_sub_const_decimals!(18usize, 61usize, 79usize, 0usize); +add_sub_const_decimals!(18usize, 60usize, 78usize, 0usize); +add_sub_const_decimals!(18usize, 59usize, 77usize, 0usize); +add_sub_const_decimals!(18usize, 58usize, 76usize, 0usize); +add_sub_const_decimals!(18usize, 57usize, 75usize, 0usize); +add_sub_const_decimals!(18usize, 56usize, 74usize, 0usize); +add_sub_const_decimals!(18usize, 55usize, 73usize, 0usize); +add_sub_const_decimals!(18usize, 54usize, 72usize, 0usize); +add_sub_const_decimals!(18usize, 53usize, 71usize, 0usize); +add_sub_const_decimals!(18usize, 52usize, 70usize, 0usize); +add_sub_const_decimals!(18usize, 51usize, 69usize, 0usize); +add_sub_const_decimals!(18usize, 50usize, 68usize, 0usize); +add_sub_const_decimals!(18usize, 49usize, 67usize, 0usize); +add_sub_const_decimals!(18usize, 48usize, 66usize, 0usize); +add_sub_const_decimals!(18usize, 47usize, 65usize, 0usize); +add_sub_const_decimals!(18usize, 46usize, 64usize, 0usize); +add_sub_const_decimals!(18usize, 45usize, 63usize, 0usize); +add_sub_const_decimals!(18usize, 44usize, 62usize, 0usize); +add_sub_const_decimals!(18usize, 43usize, 61usize, 0usize); +add_sub_const_decimals!(18usize, 42usize, 60usize, 0usize); +add_sub_const_decimals!(18usize, 41usize, 59usize, 0usize); +add_sub_const_decimals!(18usize, 40usize, 58usize, 0usize); +add_sub_const_decimals!(18usize, 39usize, 57usize, 0usize); +add_sub_const_decimals!(18usize, 38usize, 56usize, 0usize); +add_sub_const_decimals!(18usize, 37usize, 55usize, 0usize); +add_sub_const_decimals!(18usize, 36usize, 54usize, 0usize); +add_sub_const_decimals!(18usize, 35usize, 53usize, 0usize); +add_sub_const_decimals!(18usize, 34usize, 52usize, 0usize); +add_sub_const_decimals!(18usize, 33usize, 51usize, 0usize); +add_sub_const_decimals!(18usize, 32usize, 50usize, 0usize); +add_sub_const_decimals!(18usize, 31usize, 49usize, 0usize); +add_sub_const_decimals!(18usize, 30usize, 48usize, 0usize); +add_sub_const_decimals!(18usize, 29usize, 47usize, 0usize); +add_sub_const_decimals!(18usize, 28usize, 46usize, 0usize); +add_sub_const_decimals!(18usize, 27usize, 45usize, 0usize); +add_sub_const_decimals!(18usize, 26usize, 44usize, 0usize); +add_sub_const_decimals!(18usize, 25usize, 43usize, 0usize); +add_sub_const_decimals!(18usize, 24usize, 42usize, 0usize); +add_sub_const_decimals!(18usize, 23usize, 41usize, 0usize); +add_sub_const_decimals!(18usize, 22usize, 40usize, 0usize); +add_sub_const_decimals!(18usize, 21usize, 39usize, 0usize); +add_sub_const_decimals!(18usize, 20usize, 38usize, 0usize); +add_sub_const_decimals!(18usize, 19usize, 37usize, 0usize); +add_sub_const_decimals!(18usize, 18usize, 36usize, 0usize); +add_sub_const_decimals!(18usize, 17usize, 35usize, 1usize); +add_sub_const_decimals!(18usize, 16usize, 34usize, 2usize); +add_sub_const_decimals!(18usize, 15usize, 33usize, 3usize); +add_sub_const_decimals!(18usize, 14usize, 32usize, 4usize); +add_sub_const_decimals!(18usize, 13usize, 31usize, 5usize); +add_sub_const_decimals!(18usize, 12usize, 30usize, 6usize); +add_sub_const_decimals!(18usize, 11usize, 29usize, 7usize); +add_sub_const_decimals!(18usize, 10usize, 28usize, 8usize); +add_sub_const_decimals!(18usize, 9usize, 27usize, 9usize); +add_sub_const_decimals!(18usize, 8usize, 26usize, 10usize); +add_sub_const_decimals!(18usize, 7usize, 25usize, 11usize); +add_sub_const_decimals!(18usize, 6usize, 24usize, 12usize); +add_sub_const_decimals!(18usize, 5usize, 23usize, 13usize); +add_sub_const_decimals!(18usize, 4usize, 22usize, 14usize); +add_sub_const_decimals!(18usize, 3usize, 21usize, 15usize); +add_sub_const_decimals!(18usize, 2usize, 20usize, 16usize); +add_sub_const_decimals!(18usize, 1usize, 19usize, 17usize); +add_sub_const_decimals!(18usize, 0usize, 18usize, 18usize); +add_sub_const_decimals!(17usize, 64usize, 81usize, 0usize); +add_sub_const_decimals!(17usize, 63usize, 80usize, 0usize); +add_sub_const_decimals!(17usize, 62usize, 79usize, 0usize); +add_sub_const_decimals!(17usize, 61usize, 78usize, 0usize); +add_sub_const_decimals!(17usize, 60usize, 77usize, 0usize); +add_sub_const_decimals!(17usize, 59usize, 76usize, 0usize); +add_sub_const_decimals!(17usize, 58usize, 75usize, 0usize); +add_sub_const_decimals!(17usize, 57usize, 74usize, 0usize); +add_sub_const_decimals!(17usize, 56usize, 73usize, 0usize); +add_sub_const_decimals!(17usize, 55usize, 72usize, 0usize); +add_sub_const_decimals!(17usize, 54usize, 71usize, 0usize); +add_sub_const_decimals!(17usize, 53usize, 70usize, 0usize); +add_sub_const_decimals!(17usize, 52usize, 69usize, 0usize); +add_sub_const_decimals!(17usize, 51usize, 68usize, 0usize); +add_sub_const_decimals!(17usize, 50usize, 67usize, 0usize); +add_sub_const_decimals!(17usize, 49usize, 66usize, 0usize); +add_sub_const_decimals!(17usize, 48usize, 65usize, 0usize); +add_sub_const_decimals!(17usize, 47usize, 64usize, 0usize); +add_sub_const_decimals!(17usize, 46usize, 63usize, 0usize); +add_sub_const_decimals!(17usize, 45usize, 62usize, 0usize); +add_sub_const_decimals!(17usize, 44usize, 61usize, 0usize); +add_sub_const_decimals!(17usize, 43usize, 60usize, 0usize); +add_sub_const_decimals!(17usize, 42usize, 59usize, 0usize); +add_sub_const_decimals!(17usize, 41usize, 58usize, 0usize); +add_sub_const_decimals!(17usize, 40usize, 57usize, 0usize); +add_sub_const_decimals!(17usize, 39usize, 56usize, 0usize); +add_sub_const_decimals!(17usize, 38usize, 55usize, 0usize); +add_sub_const_decimals!(17usize, 37usize, 54usize, 0usize); +add_sub_const_decimals!(17usize, 36usize, 53usize, 0usize); +add_sub_const_decimals!(17usize, 35usize, 52usize, 0usize); +add_sub_const_decimals!(17usize, 34usize, 51usize, 0usize); +add_sub_const_decimals!(17usize, 33usize, 50usize, 0usize); +add_sub_const_decimals!(17usize, 32usize, 49usize, 0usize); +add_sub_const_decimals!(17usize, 31usize, 48usize, 0usize); +add_sub_const_decimals!(17usize, 30usize, 47usize, 0usize); +add_sub_const_decimals!(17usize, 29usize, 46usize, 0usize); +add_sub_const_decimals!(17usize, 28usize, 45usize, 0usize); +add_sub_const_decimals!(17usize, 27usize, 44usize, 0usize); +add_sub_const_decimals!(17usize, 26usize, 43usize, 0usize); +add_sub_const_decimals!(17usize, 25usize, 42usize, 0usize); +add_sub_const_decimals!(17usize, 24usize, 41usize, 0usize); +add_sub_const_decimals!(17usize, 23usize, 40usize, 0usize); +add_sub_const_decimals!(17usize, 22usize, 39usize, 0usize); +add_sub_const_decimals!(17usize, 21usize, 38usize, 0usize); +add_sub_const_decimals!(17usize, 20usize, 37usize, 0usize); +add_sub_const_decimals!(17usize, 19usize, 36usize, 0usize); +add_sub_const_decimals!(17usize, 18usize, 35usize, 0usize); +add_sub_const_decimals!(17usize, 17usize, 34usize, 0usize); +add_sub_const_decimals!(17usize, 16usize, 33usize, 1usize); +add_sub_const_decimals!(17usize, 15usize, 32usize, 2usize); +add_sub_const_decimals!(17usize, 14usize, 31usize, 3usize); +add_sub_const_decimals!(17usize, 13usize, 30usize, 4usize); +add_sub_const_decimals!(17usize, 12usize, 29usize, 5usize); +add_sub_const_decimals!(17usize, 11usize, 28usize, 6usize); +add_sub_const_decimals!(17usize, 10usize, 27usize, 7usize); +add_sub_const_decimals!(17usize, 9usize, 26usize, 8usize); +add_sub_const_decimals!(17usize, 8usize, 25usize, 9usize); +add_sub_const_decimals!(17usize, 7usize, 24usize, 10usize); +add_sub_const_decimals!(17usize, 6usize, 23usize, 11usize); +add_sub_const_decimals!(17usize, 5usize, 22usize, 12usize); +add_sub_const_decimals!(17usize, 4usize, 21usize, 13usize); +add_sub_const_decimals!(17usize, 3usize, 20usize, 14usize); +add_sub_const_decimals!(17usize, 2usize, 19usize, 15usize); +add_sub_const_decimals!(17usize, 1usize, 18usize, 16usize); +add_sub_const_decimals!(17usize, 0usize, 17usize, 17usize); +add_sub_const_decimals!(16usize, 64usize, 80usize, 0usize); +add_sub_const_decimals!(16usize, 63usize, 79usize, 0usize); +add_sub_const_decimals!(16usize, 62usize, 78usize, 0usize); +add_sub_const_decimals!(16usize, 61usize, 77usize, 0usize); +add_sub_const_decimals!(16usize, 60usize, 76usize, 0usize); +add_sub_const_decimals!(16usize, 59usize, 75usize, 0usize); +add_sub_const_decimals!(16usize, 58usize, 74usize, 0usize); +add_sub_const_decimals!(16usize, 57usize, 73usize, 0usize); +add_sub_const_decimals!(16usize, 56usize, 72usize, 0usize); +add_sub_const_decimals!(16usize, 55usize, 71usize, 0usize); +add_sub_const_decimals!(16usize, 54usize, 70usize, 0usize); +add_sub_const_decimals!(16usize, 53usize, 69usize, 0usize); +add_sub_const_decimals!(16usize, 52usize, 68usize, 0usize); +add_sub_const_decimals!(16usize, 51usize, 67usize, 0usize); +add_sub_const_decimals!(16usize, 50usize, 66usize, 0usize); +add_sub_const_decimals!(16usize, 49usize, 65usize, 0usize); +add_sub_const_decimals!(16usize, 48usize, 64usize, 0usize); +add_sub_const_decimals!(16usize, 47usize, 63usize, 0usize); +add_sub_const_decimals!(16usize, 46usize, 62usize, 0usize); +add_sub_const_decimals!(16usize, 45usize, 61usize, 0usize); +add_sub_const_decimals!(16usize, 44usize, 60usize, 0usize); +add_sub_const_decimals!(16usize, 43usize, 59usize, 0usize); +add_sub_const_decimals!(16usize, 42usize, 58usize, 0usize); +add_sub_const_decimals!(16usize, 41usize, 57usize, 0usize); +add_sub_const_decimals!(16usize, 40usize, 56usize, 0usize); +add_sub_const_decimals!(16usize, 39usize, 55usize, 0usize); +add_sub_const_decimals!(16usize, 38usize, 54usize, 0usize); +add_sub_const_decimals!(16usize, 37usize, 53usize, 0usize); +add_sub_const_decimals!(16usize, 36usize, 52usize, 0usize); +add_sub_const_decimals!(16usize, 35usize, 51usize, 0usize); +add_sub_const_decimals!(16usize, 34usize, 50usize, 0usize); +add_sub_const_decimals!(16usize, 33usize, 49usize, 0usize); +add_sub_const_decimals!(16usize, 32usize, 48usize, 0usize); +add_sub_const_decimals!(16usize, 31usize, 47usize, 0usize); +add_sub_const_decimals!(16usize, 30usize, 46usize, 0usize); +add_sub_const_decimals!(16usize, 29usize, 45usize, 0usize); +add_sub_const_decimals!(16usize, 28usize, 44usize, 0usize); +add_sub_const_decimals!(16usize, 27usize, 43usize, 0usize); +add_sub_const_decimals!(16usize, 26usize, 42usize, 0usize); +add_sub_const_decimals!(16usize, 25usize, 41usize, 0usize); +add_sub_const_decimals!(16usize, 24usize, 40usize, 0usize); +add_sub_const_decimals!(16usize, 23usize, 39usize, 0usize); +add_sub_const_decimals!(16usize, 22usize, 38usize, 0usize); +add_sub_const_decimals!(16usize, 21usize, 37usize, 0usize); +add_sub_const_decimals!(16usize, 20usize, 36usize, 0usize); +add_sub_const_decimals!(16usize, 19usize, 35usize, 0usize); +add_sub_const_decimals!(16usize, 18usize, 34usize, 0usize); +add_sub_const_decimals!(16usize, 17usize, 33usize, 0usize); +add_sub_const_decimals!(16usize, 16usize, 32usize, 0usize); +add_sub_const_decimals!(16usize, 15usize, 31usize, 1usize); +add_sub_const_decimals!(16usize, 14usize, 30usize, 2usize); +add_sub_const_decimals!(16usize, 13usize, 29usize, 3usize); +add_sub_const_decimals!(16usize, 12usize, 28usize, 4usize); +add_sub_const_decimals!(16usize, 11usize, 27usize, 5usize); +add_sub_const_decimals!(16usize, 10usize, 26usize, 6usize); +add_sub_const_decimals!(16usize, 9usize, 25usize, 7usize); +add_sub_const_decimals!(16usize, 8usize, 24usize, 8usize); +add_sub_const_decimals!(16usize, 7usize, 23usize, 9usize); +add_sub_const_decimals!(16usize, 6usize, 22usize, 10usize); +add_sub_const_decimals!(16usize, 5usize, 21usize, 11usize); +add_sub_const_decimals!(16usize, 4usize, 20usize, 12usize); +add_sub_const_decimals!(16usize, 3usize, 19usize, 13usize); +add_sub_const_decimals!(16usize, 2usize, 18usize, 14usize); +add_sub_const_decimals!(16usize, 1usize, 17usize, 15usize); +add_sub_const_decimals!(16usize, 0usize, 16usize, 16usize); +add_sub_const_decimals!(15usize, 64usize, 79usize, 0usize); +add_sub_const_decimals!(15usize, 63usize, 78usize, 0usize); +add_sub_const_decimals!(15usize, 62usize, 77usize, 0usize); +add_sub_const_decimals!(15usize, 61usize, 76usize, 0usize); +add_sub_const_decimals!(15usize, 60usize, 75usize, 0usize); +add_sub_const_decimals!(15usize, 59usize, 74usize, 0usize); +add_sub_const_decimals!(15usize, 58usize, 73usize, 0usize); +add_sub_const_decimals!(15usize, 57usize, 72usize, 0usize); +add_sub_const_decimals!(15usize, 56usize, 71usize, 0usize); +add_sub_const_decimals!(15usize, 55usize, 70usize, 0usize); +add_sub_const_decimals!(15usize, 54usize, 69usize, 0usize); +add_sub_const_decimals!(15usize, 53usize, 68usize, 0usize); +add_sub_const_decimals!(15usize, 52usize, 67usize, 0usize); +add_sub_const_decimals!(15usize, 51usize, 66usize, 0usize); +add_sub_const_decimals!(15usize, 50usize, 65usize, 0usize); +add_sub_const_decimals!(15usize, 49usize, 64usize, 0usize); +add_sub_const_decimals!(15usize, 48usize, 63usize, 0usize); +add_sub_const_decimals!(15usize, 47usize, 62usize, 0usize); +add_sub_const_decimals!(15usize, 46usize, 61usize, 0usize); +add_sub_const_decimals!(15usize, 45usize, 60usize, 0usize); +add_sub_const_decimals!(15usize, 44usize, 59usize, 0usize); +add_sub_const_decimals!(15usize, 43usize, 58usize, 0usize); +add_sub_const_decimals!(15usize, 42usize, 57usize, 0usize); +add_sub_const_decimals!(15usize, 41usize, 56usize, 0usize); +add_sub_const_decimals!(15usize, 40usize, 55usize, 0usize); +add_sub_const_decimals!(15usize, 39usize, 54usize, 0usize); +add_sub_const_decimals!(15usize, 38usize, 53usize, 0usize); +add_sub_const_decimals!(15usize, 37usize, 52usize, 0usize); +add_sub_const_decimals!(15usize, 36usize, 51usize, 0usize); +add_sub_const_decimals!(15usize, 35usize, 50usize, 0usize); +add_sub_const_decimals!(15usize, 34usize, 49usize, 0usize); +add_sub_const_decimals!(15usize, 33usize, 48usize, 0usize); +add_sub_const_decimals!(15usize, 32usize, 47usize, 0usize); +add_sub_const_decimals!(15usize, 31usize, 46usize, 0usize); +add_sub_const_decimals!(15usize, 30usize, 45usize, 0usize); +add_sub_const_decimals!(15usize, 29usize, 44usize, 0usize); +add_sub_const_decimals!(15usize, 28usize, 43usize, 0usize); +add_sub_const_decimals!(15usize, 27usize, 42usize, 0usize); +add_sub_const_decimals!(15usize, 26usize, 41usize, 0usize); +add_sub_const_decimals!(15usize, 25usize, 40usize, 0usize); +add_sub_const_decimals!(15usize, 24usize, 39usize, 0usize); +add_sub_const_decimals!(15usize, 23usize, 38usize, 0usize); +add_sub_const_decimals!(15usize, 22usize, 37usize, 0usize); +add_sub_const_decimals!(15usize, 21usize, 36usize, 0usize); +add_sub_const_decimals!(15usize, 20usize, 35usize, 0usize); +add_sub_const_decimals!(15usize, 19usize, 34usize, 0usize); +add_sub_const_decimals!(15usize, 18usize, 33usize, 0usize); +add_sub_const_decimals!(15usize, 17usize, 32usize, 0usize); +add_sub_const_decimals!(15usize, 16usize, 31usize, 0usize); +add_sub_const_decimals!(15usize, 15usize, 30usize, 0usize); +add_sub_const_decimals!(15usize, 14usize, 29usize, 1usize); +add_sub_const_decimals!(15usize, 13usize, 28usize, 2usize); +add_sub_const_decimals!(15usize, 12usize, 27usize, 3usize); +add_sub_const_decimals!(15usize, 11usize, 26usize, 4usize); +add_sub_const_decimals!(15usize, 10usize, 25usize, 5usize); +add_sub_const_decimals!(15usize, 9usize, 24usize, 6usize); +add_sub_const_decimals!(15usize, 8usize, 23usize, 7usize); +add_sub_const_decimals!(15usize, 7usize, 22usize, 8usize); +add_sub_const_decimals!(15usize, 6usize, 21usize, 9usize); +add_sub_const_decimals!(15usize, 5usize, 20usize, 10usize); +add_sub_const_decimals!(15usize, 4usize, 19usize, 11usize); +add_sub_const_decimals!(15usize, 3usize, 18usize, 12usize); +add_sub_const_decimals!(15usize, 2usize, 17usize, 13usize); +add_sub_const_decimals!(15usize, 1usize, 16usize, 14usize); +add_sub_const_decimals!(15usize, 0usize, 15usize, 15usize); +add_sub_const_decimals!(14usize, 64usize, 78usize, 0usize); +add_sub_const_decimals!(14usize, 63usize, 77usize, 0usize); +add_sub_const_decimals!(14usize, 62usize, 76usize, 0usize); +add_sub_const_decimals!(14usize, 61usize, 75usize, 0usize); +add_sub_const_decimals!(14usize, 60usize, 74usize, 0usize); +add_sub_const_decimals!(14usize, 59usize, 73usize, 0usize); +add_sub_const_decimals!(14usize, 58usize, 72usize, 0usize); +add_sub_const_decimals!(14usize, 57usize, 71usize, 0usize); +add_sub_const_decimals!(14usize, 56usize, 70usize, 0usize); +add_sub_const_decimals!(14usize, 55usize, 69usize, 0usize); +add_sub_const_decimals!(14usize, 54usize, 68usize, 0usize); +add_sub_const_decimals!(14usize, 53usize, 67usize, 0usize); +add_sub_const_decimals!(14usize, 52usize, 66usize, 0usize); +add_sub_const_decimals!(14usize, 51usize, 65usize, 0usize); +add_sub_const_decimals!(14usize, 50usize, 64usize, 0usize); +add_sub_const_decimals!(14usize, 49usize, 63usize, 0usize); +add_sub_const_decimals!(14usize, 48usize, 62usize, 0usize); +add_sub_const_decimals!(14usize, 47usize, 61usize, 0usize); +add_sub_const_decimals!(14usize, 46usize, 60usize, 0usize); +add_sub_const_decimals!(14usize, 45usize, 59usize, 0usize); +add_sub_const_decimals!(14usize, 44usize, 58usize, 0usize); +add_sub_const_decimals!(14usize, 43usize, 57usize, 0usize); +add_sub_const_decimals!(14usize, 42usize, 56usize, 0usize); +add_sub_const_decimals!(14usize, 41usize, 55usize, 0usize); +add_sub_const_decimals!(14usize, 40usize, 54usize, 0usize); +add_sub_const_decimals!(14usize, 39usize, 53usize, 0usize); +add_sub_const_decimals!(14usize, 38usize, 52usize, 0usize); +add_sub_const_decimals!(14usize, 37usize, 51usize, 0usize); +add_sub_const_decimals!(14usize, 36usize, 50usize, 0usize); +add_sub_const_decimals!(14usize, 35usize, 49usize, 0usize); +add_sub_const_decimals!(14usize, 34usize, 48usize, 0usize); +add_sub_const_decimals!(14usize, 33usize, 47usize, 0usize); +add_sub_const_decimals!(14usize, 32usize, 46usize, 0usize); +add_sub_const_decimals!(14usize, 31usize, 45usize, 0usize); +add_sub_const_decimals!(14usize, 30usize, 44usize, 0usize); +add_sub_const_decimals!(14usize, 29usize, 43usize, 0usize); +add_sub_const_decimals!(14usize, 28usize, 42usize, 0usize); +add_sub_const_decimals!(14usize, 27usize, 41usize, 0usize); +add_sub_const_decimals!(14usize, 26usize, 40usize, 0usize); +add_sub_const_decimals!(14usize, 25usize, 39usize, 0usize); +add_sub_const_decimals!(14usize, 24usize, 38usize, 0usize); +add_sub_const_decimals!(14usize, 23usize, 37usize, 0usize); +add_sub_const_decimals!(14usize, 22usize, 36usize, 0usize); +add_sub_const_decimals!(14usize, 21usize, 35usize, 0usize); +add_sub_const_decimals!(14usize, 20usize, 34usize, 0usize); +add_sub_const_decimals!(14usize, 19usize, 33usize, 0usize); +add_sub_const_decimals!(14usize, 18usize, 32usize, 0usize); +add_sub_const_decimals!(14usize, 17usize, 31usize, 0usize); +add_sub_const_decimals!(14usize, 16usize, 30usize, 0usize); +add_sub_const_decimals!(14usize, 15usize, 29usize, 0usize); +add_sub_const_decimals!(14usize, 14usize, 28usize, 0usize); +add_sub_const_decimals!(14usize, 13usize, 27usize, 1usize); +add_sub_const_decimals!(14usize, 12usize, 26usize, 2usize); +add_sub_const_decimals!(14usize, 11usize, 25usize, 3usize); +add_sub_const_decimals!(14usize, 10usize, 24usize, 4usize); +add_sub_const_decimals!(14usize, 9usize, 23usize, 5usize); +add_sub_const_decimals!(14usize, 8usize, 22usize, 6usize); +add_sub_const_decimals!(14usize, 7usize, 21usize, 7usize); +add_sub_const_decimals!(14usize, 6usize, 20usize, 8usize); +add_sub_const_decimals!(14usize, 5usize, 19usize, 9usize); +add_sub_const_decimals!(14usize, 4usize, 18usize, 10usize); +add_sub_const_decimals!(14usize, 3usize, 17usize, 11usize); +add_sub_const_decimals!(14usize, 2usize, 16usize, 12usize); +add_sub_const_decimals!(14usize, 1usize, 15usize, 13usize); +add_sub_const_decimals!(14usize, 0usize, 14usize, 14usize); +add_sub_const_decimals!(13usize, 64usize, 77usize, 0usize); +add_sub_const_decimals!(13usize, 63usize, 76usize, 0usize); +add_sub_const_decimals!(13usize, 62usize, 75usize, 0usize); +add_sub_const_decimals!(13usize, 61usize, 74usize, 0usize); +add_sub_const_decimals!(13usize, 60usize, 73usize, 0usize); +add_sub_const_decimals!(13usize, 59usize, 72usize, 0usize); +add_sub_const_decimals!(13usize, 58usize, 71usize, 0usize); +add_sub_const_decimals!(13usize, 57usize, 70usize, 0usize); +add_sub_const_decimals!(13usize, 56usize, 69usize, 0usize); +add_sub_const_decimals!(13usize, 55usize, 68usize, 0usize); +add_sub_const_decimals!(13usize, 54usize, 67usize, 0usize); +add_sub_const_decimals!(13usize, 53usize, 66usize, 0usize); +add_sub_const_decimals!(13usize, 52usize, 65usize, 0usize); +add_sub_const_decimals!(13usize, 51usize, 64usize, 0usize); +add_sub_const_decimals!(13usize, 50usize, 63usize, 0usize); +add_sub_const_decimals!(13usize, 49usize, 62usize, 0usize); +add_sub_const_decimals!(13usize, 48usize, 61usize, 0usize); +add_sub_const_decimals!(13usize, 47usize, 60usize, 0usize); +add_sub_const_decimals!(13usize, 46usize, 59usize, 0usize); +add_sub_const_decimals!(13usize, 45usize, 58usize, 0usize); +add_sub_const_decimals!(13usize, 44usize, 57usize, 0usize); +add_sub_const_decimals!(13usize, 43usize, 56usize, 0usize); +add_sub_const_decimals!(13usize, 42usize, 55usize, 0usize); +add_sub_const_decimals!(13usize, 41usize, 54usize, 0usize); +add_sub_const_decimals!(13usize, 40usize, 53usize, 0usize); +add_sub_const_decimals!(13usize, 39usize, 52usize, 0usize); +add_sub_const_decimals!(13usize, 38usize, 51usize, 0usize); +add_sub_const_decimals!(13usize, 37usize, 50usize, 0usize); +add_sub_const_decimals!(13usize, 36usize, 49usize, 0usize); +add_sub_const_decimals!(13usize, 35usize, 48usize, 0usize); +add_sub_const_decimals!(13usize, 34usize, 47usize, 0usize); +add_sub_const_decimals!(13usize, 33usize, 46usize, 0usize); +add_sub_const_decimals!(13usize, 32usize, 45usize, 0usize); +add_sub_const_decimals!(13usize, 31usize, 44usize, 0usize); +add_sub_const_decimals!(13usize, 30usize, 43usize, 0usize); +add_sub_const_decimals!(13usize, 29usize, 42usize, 0usize); +add_sub_const_decimals!(13usize, 28usize, 41usize, 0usize); +add_sub_const_decimals!(13usize, 27usize, 40usize, 0usize); +add_sub_const_decimals!(13usize, 26usize, 39usize, 0usize); +add_sub_const_decimals!(13usize, 25usize, 38usize, 0usize); +add_sub_const_decimals!(13usize, 24usize, 37usize, 0usize); +add_sub_const_decimals!(13usize, 23usize, 36usize, 0usize); +add_sub_const_decimals!(13usize, 22usize, 35usize, 0usize); +add_sub_const_decimals!(13usize, 21usize, 34usize, 0usize); +add_sub_const_decimals!(13usize, 20usize, 33usize, 0usize); +add_sub_const_decimals!(13usize, 19usize, 32usize, 0usize); +add_sub_const_decimals!(13usize, 18usize, 31usize, 0usize); +add_sub_const_decimals!(13usize, 17usize, 30usize, 0usize); +add_sub_const_decimals!(13usize, 16usize, 29usize, 0usize); +add_sub_const_decimals!(13usize, 15usize, 28usize, 0usize); +add_sub_const_decimals!(13usize, 14usize, 27usize, 0usize); +add_sub_const_decimals!(13usize, 13usize, 26usize, 0usize); +add_sub_const_decimals!(13usize, 12usize, 25usize, 1usize); +add_sub_const_decimals!(13usize, 11usize, 24usize, 2usize); +add_sub_const_decimals!(13usize, 10usize, 23usize, 3usize); +add_sub_const_decimals!(13usize, 9usize, 22usize, 4usize); +add_sub_const_decimals!(13usize, 8usize, 21usize, 5usize); +add_sub_const_decimals!(13usize, 7usize, 20usize, 6usize); +add_sub_const_decimals!(13usize, 6usize, 19usize, 7usize); +add_sub_const_decimals!(13usize, 5usize, 18usize, 8usize); +add_sub_const_decimals!(13usize, 4usize, 17usize, 9usize); +add_sub_const_decimals!(13usize, 3usize, 16usize, 10usize); +add_sub_const_decimals!(13usize, 2usize, 15usize, 11usize); +add_sub_const_decimals!(13usize, 1usize, 14usize, 12usize); +add_sub_const_decimals!(13usize, 0usize, 13usize, 13usize); +add_sub_const_decimals!(12usize, 64usize, 76usize, 0usize); +add_sub_const_decimals!(12usize, 63usize, 75usize, 0usize); +add_sub_const_decimals!(12usize, 62usize, 74usize, 0usize); +add_sub_const_decimals!(12usize, 61usize, 73usize, 0usize); +add_sub_const_decimals!(12usize, 60usize, 72usize, 0usize); +add_sub_const_decimals!(12usize, 59usize, 71usize, 0usize); +add_sub_const_decimals!(12usize, 58usize, 70usize, 0usize); +add_sub_const_decimals!(12usize, 57usize, 69usize, 0usize); +add_sub_const_decimals!(12usize, 56usize, 68usize, 0usize); +add_sub_const_decimals!(12usize, 55usize, 67usize, 0usize); +add_sub_const_decimals!(12usize, 54usize, 66usize, 0usize); +add_sub_const_decimals!(12usize, 53usize, 65usize, 0usize); +add_sub_const_decimals!(12usize, 52usize, 64usize, 0usize); +add_sub_const_decimals!(12usize, 51usize, 63usize, 0usize); +add_sub_const_decimals!(12usize, 50usize, 62usize, 0usize); +add_sub_const_decimals!(12usize, 49usize, 61usize, 0usize); +add_sub_const_decimals!(12usize, 48usize, 60usize, 0usize); +add_sub_const_decimals!(12usize, 47usize, 59usize, 0usize); +add_sub_const_decimals!(12usize, 46usize, 58usize, 0usize); +add_sub_const_decimals!(12usize, 45usize, 57usize, 0usize); +add_sub_const_decimals!(12usize, 44usize, 56usize, 0usize); +add_sub_const_decimals!(12usize, 43usize, 55usize, 0usize); +add_sub_const_decimals!(12usize, 42usize, 54usize, 0usize); +add_sub_const_decimals!(12usize, 41usize, 53usize, 0usize); +add_sub_const_decimals!(12usize, 40usize, 52usize, 0usize); +add_sub_const_decimals!(12usize, 39usize, 51usize, 0usize); +add_sub_const_decimals!(12usize, 38usize, 50usize, 0usize); +add_sub_const_decimals!(12usize, 37usize, 49usize, 0usize); +add_sub_const_decimals!(12usize, 36usize, 48usize, 0usize); +add_sub_const_decimals!(12usize, 35usize, 47usize, 0usize); +add_sub_const_decimals!(12usize, 34usize, 46usize, 0usize); +add_sub_const_decimals!(12usize, 33usize, 45usize, 0usize); +add_sub_const_decimals!(12usize, 32usize, 44usize, 0usize); +add_sub_const_decimals!(12usize, 31usize, 43usize, 0usize); +add_sub_const_decimals!(12usize, 30usize, 42usize, 0usize); +add_sub_const_decimals!(12usize, 29usize, 41usize, 0usize); +add_sub_const_decimals!(12usize, 28usize, 40usize, 0usize); +add_sub_const_decimals!(12usize, 27usize, 39usize, 0usize); +add_sub_const_decimals!(12usize, 26usize, 38usize, 0usize); +add_sub_const_decimals!(12usize, 25usize, 37usize, 0usize); +add_sub_const_decimals!(12usize, 24usize, 36usize, 0usize); +add_sub_const_decimals!(12usize, 23usize, 35usize, 0usize); +add_sub_const_decimals!(12usize, 22usize, 34usize, 0usize); +add_sub_const_decimals!(12usize, 21usize, 33usize, 0usize); +add_sub_const_decimals!(12usize, 20usize, 32usize, 0usize); +add_sub_const_decimals!(12usize, 19usize, 31usize, 0usize); +add_sub_const_decimals!(12usize, 18usize, 30usize, 0usize); +add_sub_const_decimals!(12usize, 17usize, 29usize, 0usize); +add_sub_const_decimals!(12usize, 16usize, 28usize, 0usize); +add_sub_const_decimals!(12usize, 15usize, 27usize, 0usize); +add_sub_const_decimals!(12usize, 14usize, 26usize, 0usize); +add_sub_const_decimals!(12usize, 13usize, 25usize, 0usize); +add_sub_const_decimals!(12usize, 12usize, 24usize, 0usize); +add_sub_const_decimals!(12usize, 11usize, 23usize, 1usize); +add_sub_const_decimals!(12usize, 10usize, 22usize, 2usize); +add_sub_const_decimals!(12usize, 9usize, 21usize, 3usize); +add_sub_const_decimals!(12usize, 8usize, 20usize, 4usize); +add_sub_const_decimals!(12usize, 7usize, 19usize, 5usize); +add_sub_const_decimals!(12usize, 6usize, 18usize, 6usize); +add_sub_const_decimals!(12usize, 5usize, 17usize, 7usize); +add_sub_const_decimals!(12usize, 4usize, 16usize, 8usize); +add_sub_const_decimals!(12usize, 3usize, 15usize, 9usize); +add_sub_const_decimals!(12usize, 2usize, 14usize, 10usize); +add_sub_const_decimals!(12usize, 1usize, 13usize, 11usize); +add_sub_const_decimals!(12usize, 0usize, 12usize, 12usize); +add_sub_const_decimals!(11usize, 64usize, 75usize, 0usize); +add_sub_const_decimals!(11usize, 63usize, 74usize, 0usize); +add_sub_const_decimals!(11usize, 62usize, 73usize, 0usize); +add_sub_const_decimals!(11usize, 61usize, 72usize, 0usize); +add_sub_const_decimals!(11usize, 60usize, 71usize, 0usize); +add_sub_const_decimals!(11usize, 59usize, 70usize, 0usize); +add_sub_const_decimals!(11usize, 58usize, 69usize, 0usize); +add_sub_const_decimals!(11usize, 57usize, 68usize, 0usize); +add_sub_const_decimals!(11usize, 56usize, 67usize, 0usize); +add_sub_const_decimals!(11usize, 55usize, 66usize, 0usize); +add_sub_const_decimals!(11usize, 54usize, 65usize, 0usize); +add_sub_const_decimals!(11usize, 53usize, 64usize, 0usize); +add_sub_const_decimals!(11usize, 52usize, 63usize, 0usize); +add_sub_const_decimals!(11usize, 51usize, 62usize, 0usize); +add_sub_const_decimals!(11usize, 50usize, 61usize, 0usize); +add_sub_const_decimals!(11usize, 49usize, 60usize, 0usize); +add_sub_const_decimals!(11usize, 48usize, 59usize, 0usize); +add_sub_const_decimals!(11usize, 47usize, 58usize, 0usize); +add_sub_const_decimals!(11usize, 46usize, 57usize, 0usize); +add_sub_const_decimals!(11usize, 45usize, 56usize, 0usize); +add_sub_const_decimals!(11usize, 44usize, 55usize, 0usize); +add_sub_const_decimals!(11usize, 43usize, 54usize, 0usize); +add_sub_const_decimals!(11usize, 42usize, 53usize, 0usize); +add_sub_const_decimals!(11usize, 41usize, 52usize, 0usize); +add_sub_const_decimals!(11usize, 40usize, 51usize, 0usize); +add_sub_const_decimals!(11usize, 39usize, 50usize, 0usize); +add_sub_const_decimals!(11usize, 38usize, 49usize, 0usize); +add_sub_const_decimals!(11usize, 37usize, 48usize, 0usize); +add_sub_const_decimals!(11usize, 36usize, 47usize, 0usize); +add_sub_const_decimals!(11usize, 35usize, 46usize, 0usize); +add_sub_const_decimals!(11usize, 34usize, 45usize, 0usize); +add_sub_const_decimals!(11usize, 33usize, 44usize, 0usize); +add_sub_const_decimals!(11usize, 32usize, 43usize, 0usize); +add_sub_const_decimals!(11usize, 31usize, 42usize, 0usize); +add_sub_const_decimals!(11usize, 30usize, 41usize, 0usize); +add_sub_const_decimals!(11usize, 29usize, 40usize, 0usize); +add_sub_const_decimals!(11usize, 28usize, 39usize, 0usize); +add_sub_const_decimals!(11usize, 27usize, 38usize, 0usize); +add_sub_const_decimals!(11usize, 26usize, 37usize, 0usize); +add_sub_const_decimals!(11usize, 25usize, 36usize, 0usize); +add_sub_const_decimals!(11usize, 24usize, 35usize, 0usize); +add_sub_const_decimals!(11usize, 23usize, 34usize, 0usize); +add_sub_const_decimals!(11usize, 22usize, 33usize, 0usize); +add_sub_const_decimals!(11usize, 21usize, 32usize, 0usize); +add_sub_const_decimals!(11usize, 20usize, 31usize, 0usize); +add_sub_const_decimals!(11usize, 19usize, 30usize, 0usize); +add_sub_const_decimals!(11usize, 18usize, 29usize, 0usize); +add_sub_const_decimals!(11usize, 17usize, 28usize, 0usize); +add_sub_const_decimals!(11usize, 16usize, 27usize, 0usize); +add_sub_const_decimals!(11usize, 15usize, 26usize, 0usize); +add_sub_const_decimals!(11usize, 14usize, 25usize, 0usize); +add_sub_const_decimals!(11usize, 13usize, 24usize, 0usize); +add_sub_const_decimals!(11usize, 12usize, 23usize, 0usize); +add_sub_const_decimals!(11usize, 11usize, 22usize, 0usize); +add_sub_const_decimals!(11usize, 10usize, 21usize, 1usize); +add_sub_const_decimals!(11usize, 9usize, 20usize, 2usize); +add_sub_const_decimals!(11usize, 8usize, 19usize, 3usize); +add_sub_const_decimals!(11usize, 7usize, 18usize, 4usize); +add_sub_const_decimals!(11usize, 6usize, 17usize, 5usize); +add_sub_const_decimals!(11usize, 5usize, 16usize, 6usize); +add_sub_const_decimals!(11usize, 4usize, 15usize, 7usize); +add_sub_const_decimals!(11usize, 3usize, 14usize, 8usize); +add_sub_const_decimals!(11usize, 2usize, 13usize, 9usize); +add_sub_const_decimals!(11usize, 1usize, 12usize, 10usize); +add_sub_const_decimals!(11usize, 0usize, 11usize, 11usize); +add_sub_const_decimals!(10usize, 64usize, 74usize, 0usize); +add_sub_const_decimals!(10usize, 63usize, 73usize, 0usize); +add_sub_const_decimals!(10usize, 62usize, 72usize, 0usize); +add_sub_const_decimals!(10usize, 61usize, 71usize, 0usize); +add_sub_const_decimals!(10usize, 60usize, 70usize, 0usize); +add_sub_const_decimals!(10usize, 59usize, 69usize, 0usize); +add_sub_const_decimals!(10usize, 58usize, 68usize, 0usize); +add_sub_const_decimals!(10usize, 57usize, 67usize, 0usize); +add_sub_const_decimals!(10usize, 56usize, 66usize, 0usize); +add_sub_const_decimals!(10usize, 55usize, 65usize, 0usize); +add_sub_const_decimals!(10usize, 54usize, 64usize, 0usize); +add_sub_const_decimals!(10usize, 53usize, 63usize, 0usize); +add_sub_const_decimals!(10usize, 52usize, 62usize, 0usize); +add_sub_const_decimals!(10usize, 51usize, 61usize, 0usize); +add_sub_const_decimals!(10usize, 50usize, 60usize, 0usize); +add_sub_const_decimals!(10usize, 49usize, 59usize, 0usize); +add_sub_const_decimals!(10usize, 48usize, 58usize, 0usize); +add_sub_const_decimals!(10usize, 47usize, 57usize, 0usize); +add_sub_const_decimals!(10usize, 46usize, 56usize, 0usize); +add_sub_const_decimals!(10usize, 45usize, 55usize, 0usize); +add_sub_const_decimals!(10usize, 44usize, 54usize, 0usize); +add_sub_const_decimals!(10usize, 43usize, 53usize, 0usize); +add_sub_const_decimals!(10usize, 42usize, 52usize, 0usize); +add_sub_const_decimals!(10usize, 41usize, 51usize, 0usize); +add_sub_const_decimals!(10usize, 40usize, 50usize, 0usize); +add_sub_const_decimals!(10usize, 39usize, 49usize, 0usize); +add_sub_const_decimals!(10usize, 38usize, 48usize, 0usize); +add_sub_const_decimals!(10usize, 37usize, 47usize, 0usize); +add_sub_const_decimals!(10usize, 36usize, 46usize, 0usize); +add_sub_const_decimals!(10usize, 35usize, 45usize, 0usize); +add_sub_const_decimals!(10usize, 34usize, 44usize, 0usize); +add_sub_const_decimals!(10usize, 33usize, 43usize, 0usize); +add_sub_const_decimals!(10usize, 32usize, 42usize, 0usize); +add_sub_const_decimals!(10usize, 31usize, 41usize, 0usize); +add_sub_const_decimals!(10usize, 30usize, 40usize, 0usize); +add_sub_const_decimals!(10usize, 29usize, 39usize, 0usize); +add_sub_const_decimals!(10usize, 28usize, 38usize, 0usize); +add_sub_const_decimals!(10usize, 27usize, 37usize, 0usize); +add_sub_const_decimals!(10usize, 26usize, 36usize, 0usize); +add_sub_const_decimals!(10usize, 25usize, 35usize, 0usize); +add_sub_const_decimals!(10usize, 24usize, 34usize, 0usize); +add_sub_const_decimals!(10usize, 23usize, 33usize, 0usize); +add_sub_const_decimals!(10usize, 22usize, 32usize, 0usize); +add_sub_const_decimals!(10usize, 21usize, 31usize, 0usize); +add_sub_const_decimals!(10usize, 20usize, 30usize, 0usize); +add_sub_const_decimals!(10usize, 19usize, 29usize, 0usize); +add_sub_const_decimals!(10usize, 18usize, 28usize, 0usize); +add_sub_const_decimals!(10usize, 17usize, 27usize, 0usize); +add_sub_const_decimals!(10usize, 16usize, 26usize, 0usize); +add_sub_const_decimals!(10usize, 15usize, 25usize, 0usize); +add_sub_const_decimals!(10usize, 14usize, 24usize, 0usize); +add_sub_const_decimals!(10usize, 13usize, 23usize, 0usize); +add_sub_const_decimals!(10usize, 12usize, 22usize, 0usize); +add_sub_const_decimals!(10usize, 11usize, 21usize, 0usize); +add_sub_const_decimals!(10usize, 10usize, 20usize, 0usize); +add_sub_const_decimals!(10usize, 9usize, 19usize, 1usize); +add_sub_const_decimals!(10usize, 8usize, 18usize, 2usize); +add_sub_const_decimals!(10usize, 7usize, 17usize, 3usize); +add_sub_const_decimals!(10usize, 6usize, 16usize, 4usize); +add_sub_const_decimals!(10usize, 5usize, 15usize, 5usize); +add_sub_const_decimals!(10usize, 4usize, 14usize, 6usize); +add_sub_const_decimals!(10usize, 3usize, 13usize, 7usize); +add_sub_const_decimals!(10usize, 2usize, 12usize, 8usize); +add_sub_const_decimals!(10usize, 1usize, 11usize, 9usize); +add_sub_const_decimals!(10usize, 0usize, 10usize, 10usize); +add_sub_const_decimals!(9usize, 64usize, 73usize, 0usize); +add_sub_const_decimals!(9usize, 63usize, 72usize, 0usize); +add_sub_const_decimals!(9usize, 62usize, 71usize, 0usize); +add_sub_const_decimals!(9usize, 61usize, 70usize, 0usize); +add_sub_const_decimals!(9usize, 60usize, 69usize, 0usize); +add_sub_const_decimals!(9usize, 59usize, 68usize, 0usize); +add_sub_const_decimals!(9usize, 58usize, 67usize, 0usize); +add_sub_const_decimals!(9usize, 57usize, 66usize, 0usize); +add_sub_const_decimals!(9usize, 56usize, 65usize, 0usize); +add_sub_const_decimals!(9usize, 55usize, 64usize, 0usize); +add_sub_const_decimals!(9usize, 54usize, 63usize, 0usize); +add_sub_const_decimals!(9usize, 53usize, 62usize, 0usize); +add_sub_const_decimals!(9usize, 52usize, 61usize, 0usize); +add_sub_const_decimals!(9usize, 51usize, 60usize, 0usize); +add_sub_const_decimals!(9usize, 50usize, 59usize, 0usize); +add_sub_const_decimals!(9usize, 49usize, 58usize, 0usize); +add_sub_const_decimals!(9usize, 48usize, 57usize, 0usize); +add_sub_const_decimals!(9usize, 47usize, 56usize, 0usize); +add_sub_const_decimals!(9usize, 46usize, 55usize, 0usize); +add_sub_const_decimals!(9usize, 45usize, 54usize, 0usize); +add_sub_const_decimals!(9usize, 44usize, 53usize, 0usize); +add_sub_const_decimals!(9usize, 43usize, 52usize, 0usize); +add_sub_const_decimals!(9usize, 42usize, 51usize, 0usize); +add_sub_const_decimals!(9usize, 41usize, 50usize, 0usize); +add_sub_const_decimals!(9usize, 40usize, 49usize, 0usize); +add_sub_const_decimals!(9usize, 39usize, 48usize, 0usize); +add_sub_const_decimals!(9usize, 38usize, 47usize, 0usize); +add_sub_const_decimals!(9usize, 37usize, 46usize, 0usize); +add_sub_const_decimals!(9usize, 36usize, 45usize, 0usize); +add_sub_const_decimals!(9usize, 35usize, 44usize, 0usize); +add_sub_const_decimals!(9usize, 34usize, 43usize, 0usize); +add_sub_const_decimals!(9usize, 33usize, 42usize, 0usize); +add_sub_const_decimals!(9usize, 32usize, 41usize, 0usize); +add_sub_const_decimals!(9usize, 31usize, 40usize, 0usize); +add_sub_const_decimals!(9usize, 30usize, 39usize, 0usize); +add_sub_const_decimals!(9usize, 29usize, 38usize, 0usize); +add_sub_const_decimals!(9usize, 28usize, 37usize, 0usize); +add_sub_const_decimals!(9usize, 27usize, 36usize, 0usize); +add_sub_const_decimals!(9usize, 26usize, 35usize, 0usize); +add_sub_const_decimals!(9usize, 25usize, 34usize, 0usize); +add_sub_const_decimals!(9usize, 24usize, 33usize, 0usize); +add_sub_const_decimals!(9usize, 23usize, 32usize, 0usize); +add_sub_const_decimals!(9usize, 22usize, 31usize, 0usize); +add_sub_const_decimals!(9usize, 21usize, 30usize, 0usize); +add_sub_const_decimals!(9usize, 20usize, 29usize, 0usize); +add_sub_const_decimals!(9usize, 19usize, 28usize, 0usize); +add_sub_const_decimals!(9usize, 18usize, 27usize, 0usize); +add_sub_const_decimals!(9usize, 17usize, 26usize, 0usize); +add_sub_const_decimals!(9usize, 16usize, 25usize, 0usize); +add_sub_const_decimals!(9usize, 15usize, 24usize, 0usize); +add_sub_const_decimals!(9usize, 14usize, 23usize, 0usize); +add_sub_const_decimals!(9usize, 13usize, 22usize, 0usize); +add_sub_const_decimals!(9usize, 12usize, 21usize, 0usize); +add_sub_const_decimals!(9usize, 11usize, 20usize, 0usize); +add_sub_const_decimals!(9usize, 10usize, 19usize, 0usize); +add_sub_const_decimals!(9usize, 9usize, 18usize, 0usize); +add_sub_const_decimals!(9usize, 8usize, 17usize, 1usize); +add_sub_const_decimals!(9usize, 7usize, 16usize, 2usize); +add_sub_const_decimals!(9usize, 6usize, 15usize, 3usize); +add_sub_const_decimals!(9usize, 5usize, 14usize, 4usize); +add_sub_const_decimals!(9usize, 4usize, 13usize, 5usize); +add_sub_const_decimals!(9usize, 3usize, 12usize, 6usize); +add_sub_const_decimals!(9usize, 2usize, 11usize, 7usize); +add_sub_const_decimals!(9usize, 1usize, 10usize, 8usize); +add_sub_const_decimals!(9usize, 0usize, 9usize, 9usize); +add_sub_const_decimals!(8usize, 64usize, 72usize, 0usize); +add_sub_const_decimals!(8usize, 63usize, 71usize, 0usize); +add_sub_const_decimals!(8usize, 62usize, 70usize, 0usize); +add_sub_const_decimals!(8usize, 61usize, 69usize, 0usize); +add_sub_const_decimals!(8usize, 60usize, 68usize, 0usize); +add_sub_const_decimals!(8usize, 59usize, 67usize, 0usize); +add_sub_const_decimals!(8usize, 58usize, 66usize, 0usize); +add_sub_const_decimals!(8usize, 57usize, 65usize, 0usize); +add_sub_const_decimals!(8usize, 56usize, 64usize, 0usize); +add_sub_const_decimals!(8usize, 55usize, 63usize, 0usize); +add_sub_const_decimals!(8usize, 54usize, 62usize, 0usize); +add_sub_const_decimals!(8usize, 53usize, 61usize, 0usize); +add_sub_const_decimals!(8usize, 52usize, 60usize, 0usize); +add_sub_const_decimals!(8usize, 51usize, 59usize, 0usize); +add_sub_const_decimals!(8usize, 50usize, 58usize, 0usize); +add_sub_const_decimals!(8usize, 49usize, 57usize, 0usize); +add_sub_const_decimals!(8usize, 48usize, 56usize, 0usize); +add_sub_const_decimals!(8usize, 47usize, 55usize, 0usize); +add_sub_const_decimals!(8usize, 46usize, 54usize, 0usize); +add_sub_const_decimals!(8usize, 45usize, 53usize, 0usize); +add_sub_const_decimals!(8usize, 44usize, 52usize, 0usize); +add_sub_const_decimals!(8usize, 43usize, 51usize, 0usize); +add_sub_const_decimals!(8usize, 42usize, 50usize, 0usize); +add_sub_const_decimals!(8usize, 41usize, 49usize, 0usize); +add_sub_const_decimals!(8usize, 40usize, 48usize, 0usize); +add_sub_const_decimals!(8usize, 39usize, 47usize, 0usize); +add_sub_const_decimals!(8usize, 38usize, 46usize, 0usize); +add_sub_const_decimals!(8usize, 37usize, 45usize, 0usize); +add_sub_const_decimals!(8usize, 36usize, 44usize, 0usize); +add_sub_const_decimals!(8usize, 35usize, 43usize, 0usize); +add_sub_const_decimals!(8usize, 34usize, 42usize, 0usize); +add_sub_const_decimals!(8usize, 33usize, 41usize, 0usize); +add_sub_const_decimals!(8usize, 32usize, 40usize, 0usize); +add_sub_const_decimals!(8usize, 31usize, 39usize, 0usize); +add_sub_const_decimals!(8usize, 30usize, 38usize, 0usize); +add_sub_const_decimals!(8usize, 29usize, 37usize, 0usize); +add_sub_const_decimals!(8usize, 28usize, 36usize, 0usize); +add_sub_const_decimals!(8usize, 27usize, 35usize, 0usize); +add_sub_const_decimals!(8usize, 26usize, 34usize, 0usize); +add_sub_const_decimals!(8usize, 25usize, 33usize, 0usize); +add_sub_const_decimals!(8usize, 24usize, 32usize, 0usize); +add_sub_const_decimals!(8usize, 23usize, 31usize, 0usize); +add_sub_const_decimals!(8usize, 22usize, 30usize, 0usize); +add_sub_const_decimals!(8usize, 21usize, 29usize, 0usize); +add_sub_const_decimals!(8usize, 20usize, 28usize, 0usize); +add_sub_const_decimals!(8usize, 19usize, 27usize, 0usize); +add_sub_const_decimals!(8usize, 18usize, 26usize, 0usize); +add_sub_const_decimals!(8usize, 17usize, 25usize, 0usize); +add_sub_const_decimals!(8usize, 16usize, 24usize, 0usize); +add_sub_const_decimals!(8usize, 15usize, 23usize, 0usize); +add_sub_const_decimals!(8usize, 14usize, 22usize, 0usize); +add_sub_const_decimals!(8usize, 13usize, 21usize, 0usize); +add_sub_const_decimals!(8usize, 12usize, 20usize, 0usize); +add_sub_const_decimals!(8usize, 11usize, 19usize, 0usize); +add_sub_const_decimals!(8usize, 10usize, 18usize, 0usize); +add_sub_const_decimals!(8usize, 9usize, 17usize, 0usize); +add_sub_const_decimals!(8usize, 8usize, 16usize, 0usize); +add_sub_const_decimals!(8usize, 7usize, 15usize, 1usize); +add_sub_const_decimals!(8usize, 6usize, 14usize, 2usize); +add_sub_const_decimals!(8usize, 5usize, 13usize, 3usize); +add_sub_const_decimals!(8usize, 4usize, 12usize, 4usize); +add_sub_const_decimals!(8usize, 3usize, 11usize, 5usize); +add_sub_const_decimals!(8usize, 2usize, 10usize, 6usize); +add_sub_const_decimals!(8usize, 1usize, 9usize, 7usize); +add_sub_const_decimals!(8usize, 0usize, 8usize, 8usize); +add_sub_const_decimals!(7usize, 64usize, 71usize, 0usize); +add_sub_const_decimals!(7usize, 63usize, 70usize, 0usize); +add_sub_const_decimals!(7usize, 62usize, 69usize, 0usize); +add_sub_const_decimals!(7usize, 61usize, 68usize, 0usize); +add_sub_const_decimals!(7usize, 60usize, 67usize, 0usize); +add_sub_const_decimals!(7usize, 59usize, 66usize, 0usize); +add_sub_const_decimals!(7usize, 58usize, 65usize, 0usize); +add_sub_const_decimals!(7usize, 57usize, 64usize, 0usize); +add_sub_const_decimals!(7usize, 56usize, 63usize, 0usize); +add_sub_const_decimals!(7usize, 55usize, 62usize, 0usize); +add_sub_const_decimals!(7usize, 54usize, 61usize, 0usize); +add_sub_const_decimals!(7usize, 53usize, 60usize, 0usize); +add_sub_const_decimals!(7usize, 52usize, 59usize, 0usize); +add_sub_const_decimals!(7usize, 51usize, 58usize, 0usize); +add_sub_const_decimals!(7usize, 50usize, 57usize, 0usize); +add_sub_const_decimals!(7usize, 49usize, 56usize, 0usize); +add_sub_const_decimals!(7usize, 48usize, 55usize, 0usize); +add_sub_const_decimals!(7usize, 47usize, 54usize, 0usize); +add_sub_const_decimals!(7usize, 46usize, 53usize, 0usize); +add_sub_const_decimals!(7usize, 45usize, 52usize, 0usize); +add_sub_const_decimals!(7usize, 44usize, 51usize, 0usize); +add_sub_const_decimals!(7usize, 43usize, 50usize, 0usize); +add_sub_const_decimals!(7usize, 42usize, 49usize, 0usize); +add_sub_const_decimals!(7usize, 41usize, 48usize, 0usize); +add_sub_const_decimals!(7usize, 40usize, 47usize, 0usize); +add_sub_const_decimals!(7usize, 39usize, 46usize, 0usize); +add_sub_const_decimals!(7usize, 38usize, 45usize, 0usize); +add_sub_const_decimals!(7usize, 37usize, 44usize, 0usize); +add_sub_const_decimals!(7usize, 36usize, 43usize, 0usize); +add_sub_const_decimals!(7usize, 35usize, 42usize, 0usize); +add_sub_const_decimals!(7usize, 34usize, 41usize, 0usize); +add_sub_const_decimals!(7usize, 33usize, 40usize, 0usize); +add_sub_const_decimals!(7usize, 32usize, 39usize, 0usize); +add_sub_const_decimals!(7usize, 31usize, 38usize, 0usize); +add_sub_const_decimals!(7usize, 30usize, 37usize, 0usize); +add_sub_const_decimals!(7usize, 29usize, 36usize, 0usize); +add_sub_const_decimals!(7usize, 28usize, 35usize, 0usize); +add_sub_const_decimals!(7usize, 27usize, 34usize, 0usize); +add_sub_const_decimals!(7usize, 26usize, 33usize, 0usize); +add_sub_const_decimals!(7usize, 25usize, 32usize, 0usize); +add_sub_const_decimals!(7usize, 24usize, 31usize, 0usize); +add_sub_const_decimals!(7usize, 23usize, 30usize, 0usize); +add_sub_const_decimals!(7usize, 22usize, 29usize, 0usize); +add_sub_const_decimals!(7usize, 21usize, 28usize, 0usize); +add_sub_const_decimals!(7usize, 20usize, 27usize, 0usize); +add_sub_const_decimals!(7usize, 19usize, 26usize, 0usize); +add_sub_const_decimals!(7usize, 18usize, 25usize, 0usize); +add_sub_const_decimals!(7usize, 17usize, 24usize, 0usize); +add_sub_const_decimals!(7usize, 16usize, 23usize, 0usize); +add_sub_const_decimals!(7usize, 15usize, 22usize, 0usize); +add_sub_const_decimals!(7usize, 14usize, 21usize, 0usize); +add_sub_const_decimals!(7usize, 13usize, 20usize, 0usize); +add_sub_const_decimals!(7usize, 12usize, 19usize, 0usize); +add_sub_const_decimals!(7usize, 11usize, 18usize, 0usize); +add_sub_const_decimals!(7usize, 10usize, 17usize, 0usize); +add_sub_const_decimals!(7usize, 9usize, 16usize, 0usize); +add_sub_const_decimals!(7usize, 8usize, 15usize, 0usize); +add_sub_const_decimals!(7usize, 7usize, 14usize, 0usize); +add_sub_const_decimals!(7usize, 6usize, 13usize, 1usize); +add_sub_const_decimals!(7usize, 5usize, 12usize, 2usize); +add_sub_const_decimals!(7usize, 4usize, 11usize, 3usize); +add_sub_const_decimals!(7usize, 3usize, 10usize, 4usize); +add_sub_const_decimals!(7usize, 2usize, 9usize, 5usize); +add_sub_const_decimals!(7usize, 1usize, 8usize, 6usize); +add_sub_const_decimals!(7usize, 0usize, 7usize, 7usize); +add_sub_const_decimals!(6usize, 64usize, 70usize, 0usize); +add_sub_const_decimals!(6usize, 63usize, 69usize, 0usize); +add_sub_const_decimals!(6usize, 62usize, 68usize, 0usize); +add_sub_const_decimals!(6usize, 61usize, 67usize, 0usize); +add_sub_const_decimals!(6usize, 60usize, 66usize, 0usize); +add_sub_const_decimals!(6usize, 59usize, 65usize, 0usize); +add_sub_const_decimals!(6usize, 58usize, 64usize, 0usize); +add_sub_const_decimals!(6usize, 57usize, 63usize, 0usize); +add_sub_const_decimals!(6usize, 56usize, 62usize, 0usize); +add_sub_const_decimals!(6usize, 55usize, 61usize, 0usize); +add_sub_const_decimals!(6usize, 54usize, 60usize, 0usize); +add_sub_const_decimals!(6usize, 53usize, 59usize, 0usize); +add_sub_const_decimals!(6usize, 52usize, 58usize, 0usize); +add_sub_const_decimals!(6usize, 51usize, 57usize, 0usize); +add_sub_const_decimals!(6usize, 50usize, 56usize, 0usize); +add_sub_const_decimals!(6usize, 49usize, 55usize, 0usize); +add_sub_const_decimals!(6usize, 48usize, 54usize, 0usize); +add_sub_const_decimals!(6usize, 47usize, 53usize, 0usize); +add_sub_const_decimals!(6usize, 46usize, 52usize, 0usize); +add_sub_const_decimals!(6usize, 45usize, 51usize, 0usize); +add_sub_const_decimals!(6usize, 44usize, 50usize, 0usize); +add_sub_const_decimals!(6usize, 43usize, 49usize, 0usize); +add_sub_const_decimals!(6usize, 42usize, 48usize, 0usize); +add_sub_const_decimals!(6usize, 41usize, 47usize, 0usize); +add_sub_const_decimals!(6usize, 40usize, 46usize, 0usize); +add_sub_const_decimals!(6usize, 39usize, 45usize, 0usize); +add_sub_const_decimals!(6usize, 38usize, 44usize, 0usize); +add_sub_const_decimals!(6usize, 37usize, 43usize, 0usize); +add_sub_const_decimals!(6usize, 36usize, 42usize, 0usize); +add_sub_const_decimals!(6usize, 35usize, 41usize, 0usize); +add_sub_const_decimals!(6usize, 34usize, 40usize, 0usize); +add_sub_const_decimals!(6usize, 33usize, 39usize, 0usize); +add_sub_const_decimals!(6usize, 32usize, 38usize, 0usize); +add_sub_const_decimals!(6usize, 31usize, 37usize, 0usize); +add_sub_const_decimals!(6usize, 30usize, 36usize, 0usize); +add_sub_const_decimals!(6usize, 29usize, 35usize, 0usize); +add_sub_const_decimals!(6usize, 28usize, 34usize, 0usize); +add_sub_const_decimals!(6usize, 27usize, 33usize, 0usize); +add_sub_const_decimals!(6usize, 26usize, 32usize, 0usize); +add_sub_const_decimals!(6usize, 25usize, 31usize, 0usize); +add_sub_const_decimals!(6usize, 24usize, 30usize, 0usize); +add_sub_const_decimals!(6usize, 23usize, 29usize, 0usize); +add_sub_const_decimals!(6usize, 22usize, 28usize, 0usize); +add_sub_const_decimals!(6usize, 21usize, 27usize, 0usize); +add_sub_const_decimals!(6usize, 20usize, 26usize, 0usize); +add_sub_const_decimals!(6usize, 19usize, 25usize, 0usize); +add_sub_const_decimals!(6usize, 18usize, 24usize, 0usize); +add_sub_const_decimals!(6usize, 17usize, 23usize, 0usize); +add_sub_const_decimals!(6usize, 16usize, 22usize, 0usize); +add_sub_const_decimals!(6usize, 15usize, 21usize, 0usize); +add_sub_const_decimals!(6usize, 14usize, 20usize, 0usize); +add_sub_const_decimals!(6usize, 13usize, 19usize, 0usize); +add_sub_const_decimals!(6usize, 12usize, 18usize, 0usize); +add_sub_const_decimals!(6usize, 11usize, 17usize, 0usize); +add_sub_const_decimals!(6usize, 10usize, 16usize, 0usize); +add_sub_const_decimals!(6usize, 9usize, 15usize, 0usize); +add_sub_const_decimals!(6usize, 8usize, 14usize, 0usize); +add_sub_const_decimals!(6usize, 7usize, 13usize, 0usize); +add_sub_const_decimals!(6usize, 6usize, 12usize, 0usize); +add_sub_const_decimals!(6usize, 5usize, 11usize, 1usize); +add_sub_const_decimals!(6usize, 4usize, 10usize, 2usize); +add_sub_const_decimals!(6usize, 3usize, 9usize, 3usize); +add_sub_const_decimals!(6usize, 2usize, 8usize, 4usize); +add_sub_const_decimals!(6usize, 1usize, 7usize, 5usize); +add_sub_const_decimals!(6usize, 0usize, 6usize, 6usize); +add_sub_const_decimals!(5usize, 64usize, 69usize, 0usize); +add_sub_const_decimals!(5usize, 63usize, 68usize, 0usize); +add_sub_const_decimals!(5usize, 62usize, 67usize, 0usize); +add_sub_const_decimals!(5usize, 61usize, 66usize, 0usize); +add_sub_const_decimals!(5usize, 60usize, 65usize, 0usize); +add_sub_const_decimals!(5usize, 59usize, 64usize, 0usize); +add_sub_const_decimals!(5usize, 58usize, 63usize, 0usize); +add_sub_const_decimals!(5usize, 57usize, 62usize, 0usize); +add_sub_const_decimals!(5usize, 56usize, 61usize, 0usize); +add_sub_const_decimals!(5usize, 55usize, 60usize, 0usize); +add_sub_const_decimals!(5usize, 54usize, 59usize, 0usize); +add_sub_const_decimals!(5usize, 53usize, 58usize, 0usize); +add_sub_const_decimals!(5usize, 52usize, 57usize, 0usize); +add_sub_const_decimals!(5usize, 51usize, 56usize, 0usize); +add_sub_const_decimals!(5usize, 50usize, 55usize, 0usize); +add_sub_const_decimals!(5usize, 49usize, 54usize, 0usize); +add_sub_const_decimals!(5usize, 48usize, 53usize, 0usize); +add_sub_const_decimals!(5usize, 47usize, 52usize, 0usize); +add_sub_const_decimals!(5usize, 46usize, 51usize, 0usize); +add_sub_const_decimals!(5usize, 45usize, 50usize, 0usize); +add_sub_const_decimals!(5usize, 44usize, 49usize, 0usize); +add_sub_const_decimals!(5usize, 43usize, 48usize, 0usize); +add_sub_const_decimals!(5usize, 42usize, 47usize, 0usize); +add_sub_const_decimals!(5usize, 41usize, 46usize, 0usize); +add_sub_const_decimals!(5usize, 40usize, 45usize, 0usize); +add_sub_const_decimals!(5usize, 39usize, 44usize, 0usize); +add_sub_const_decimals!(5usize, 38usize, 43usize, 0usize); +add_sub_const_decimals!(5usize, 37usize, 42usize, 0usize); +add_sub_const_decimals!(5usize, 36usize, 41usize, 0usize); +add_sub_const_decimals!(5usize, 35usize, 40usize, 0usize); +add_sub_const_decimals!(5usize, 34usize, 39usize, 0usize); +add_sub_const_decimals!(5usize, 33usize, 38usize, 0usize); +add_sub_const_decimals!(5usize, 32usize, 37usize, 0usize); +add_sub_const_decimals!(5usize, 31usize, 36usize, 0usize); +add_sub_const_decimals!(5usize, 30usize, 35usize, 0usize); +add_sub_const_decimals!(5usize, 29usize, 34usize, 0usize); +add_sub_const_decimals!(5usize, 28usize, 33usize, 0usize); +add_sub_const_decimals!(5usize, 27usize, 32usize, 0usize); +add_sub_const_decimals!(5usize, 26usize, 31usize, 0usize); +add_sub_const_decimals!(5usize, 25usize, 30usize, 0usize); +add_sub_const_decimals!(5usize, 24usize, 29usize, 0usize); +add_sub_const_decimals!(5usize, 23usize, 28usize, 0usize); +add_sub_const_decimals!(5usize, 22usize, 27usize, 0usize); +add_sub_const_decimals!(5usize, 21usize, 26usize, 0usize); +add_sub_const_decimals!(5usize, 20usize, 25usize, 0usize); +add_sub_const_decimals!(5usize, 19usize, 24usize, 0usize); +add_sub_const_decimals!(5usize, 18usize, 23usize, 0usize); +add_sub_const_decimals!(5usize, 17usize, 22usize, 0usize); +add_sub_const_decimals!(5usize, 16usize, 21usize, 0usize); +add_sub_const_decimals!(5usize, 15usize, 20usize, 0usize); +add_sub_const_decimals!(5usize, 14usize, 19usize, 0usize); +add_sub_const_decimals!(5usize, 13usize, 18usize, 0usize); +add_sub_const_decimals!(5usize, 12usize, 17usize, 0usize); +add_sub_const_decimals!(5usize, 11usize, 16usize, 0usize); +add_sub_const_decimals!(5usize, 10usize, 15usize, 0usize); +add_sub_const_decimals!(5usize, 9usize, 14usize, 0usize); +add_sub_const_decimals!(5usize, 8usize, 13usize, 0usize); +add_sub_const_decimals!(5usize, 7usize, 12usize, 0usize); +add_sub_const_decimals!(5usize, 6usize, 11usize, 0usize); +add_sub_const_decimals!(5usize, 5usize, 10usize, 0usize); +add_sub_const_decimals!(5usize, 4usize, 9usize, 1usize); +add_sub_const_decimals!(5usize, 3usize, 8usize, 2usize); +add_sub_const_decimals!(5usize, 2usize, 7usize, 3usize); +add_sub_const_decimals!(5usize, 1usize, 6usize, 4usize); +add_sub_const_decimals!(5usize, 0usize, 5usize, 5usize); +add_sub_const_decimals!(4usize, 64usize, 68usize, 0usize); +add_sub_const_decimals!(4usize, 63usize, 67usize, 0usize); +add_sub_const_decimals!(4usize, 62usize, 66usize, 0usize); +add_sub_const_decimals!(4usize, 61usize, 65usize, 0usize); +add_sub_const_decimals!(4usize, 60usize, 64usize, 0usize); +add_sub_const_decimals!(4usize, 59usize, 63usize, 0usize); +add_sub_const_decimals!(4usize, 58usize, 62usize, 0usize); +add_sub_const_decimals!(4usize, 57usize, 61usize, 0usize); +add_sub_const_decimals!(4usize, 56usize, 60usize, 0usize); +add_sub_const_decimals!(4usize, 55usize, 59usize, 0usize); +add_sub_const_decimals!(4usize, 54usize, 58usize, 0usize); +add_sub_const_decimals!(4usize, 53usize, 57usize, 0usize); +add_sub_const_decimals!(4usize, 52usize, 56usize, 0usize); +add_sub_const_decimals!(4usize, 51usize, 55usize, 0usize); +add_sub_const_decimals!(4usize, 50usize, 54usize, 0usize); +add_sub_const_decimals!(4usize, 49usize, 53usize, 0usize); +add_sub_const_decimals!(4usize, 48usize, 52usize, 0usize); +add_sub_const_decimals!(4usize, 47usize, 51usize, 0usize); +add_sub_const_decimals!(4usize, 46usize, 50usize, 0usize); +add_sub_const_decimals!(4usize, 45usize, 49usize, 0usize); +add_sub_const_decimals!(4usize, 44usize, 48usize, 0usize); +add_sub_const_decimals!(4usize, 43usize, 47usize, 0usize); +add_sub_const_decimals!(4usize, 42usize, 46usize, 0usize); +add_sub_const_decimals!(4usize, 41usize, 45usize, 0usize); +add_sub_const_decimals!(4usize, 40usize, 44usize, 0usize); +add_sub_const_decimals!(4usize, 39usize, 43usize, 0usize); +add_sub_const_decimals!(4usize, 38usize, 42usize, 0usize); +add_sub_const_decimals!(4usize, 37usize, 41usize, 0usize); +add_sub_const_decimals!(4usize, 36usize, 40usize, 0usize); +add_sub_const_decimals!(4usize, 35usize, 39usize, 0usize); +add_sub_const_decimals!(4usize, 34usize, 38usize, 0usize); +add_sub_const_decimals!(4usize, 33usize, 37usize, 0usize); +add_sub_const_decimals!(4usize, 32usize, 36usize, 0usize); +add_sub_const_decimals!(4usize, 31usize, 35usize, 0usize); +add_sub_const_decimals!(4usize, 30usize, 34usize, 0usize); +add_sub_const_decimals!(4usize, 29usize, 33usize, 0usize); +add_sub_const_decimals!(4usize, 28usize, 32usize, 0usize); +add_sub_const_decimals!(4usize, 27usize, 31usize, 0usize); +add_sub_const_decimals!(4usize, 26usize, 30usize, 0usize); +add_sub_const_decimals!(4usize, 25usize, 29usize, 0usize); +add_sub_const_decimals!(4usize, 24usize, 28usize, 0usize); +add_sub_const_decimals!(4usize, 23usize, 27usize, 0usize); +add_sub_const_decimals!(4usize, 22usize, 26usize, 0usize); +add_sub_const_decimals!(4usize, 21usize, 25usize, 0usize); +add_sub_const_decimals!(4usize, 20usize, 24usize, 0usize); +add_sub_const_decimals!(4usize, 19usize, 23usize, 0usize); +add_sub_const_decimals!(4usize, 18usize, 22usize, 0usize); +add_sub_const_decimals!(4usize, 17usize, 21usize, 0usize); +add_sub_const_decimals!(4usize, 16usize, 20usize, 0usize); +add_sub_const_decimals!(4usize, 15usize, 19usize, 0usize); +add_sub_const_decimals!(4usize, 14usize, 18usize, 0usize); +add_sub_const_decimals!(4usize, 13usize, 17usize, 0usize); +add_sub_const_decimals!(4usize, 12usize, 16usize, 0usize); +add_sub_const_decimals!(4usize, 11usize, 15usize, 0usize); +add_sub_const_decimals!(4usize, 10usize, 14usize, 0usize); +add_sub_const_decimals!(4usize, 9usize, 13usize, 0usize); +add_sub_const_decimals!(4usize, 8usize, 12usize, 0usize); +add_sub_const_decimals!(4usize, 7usize, 11usize, 0usize); +add_sub_const_decimals!(4usize, 6usize, 10usize, 0usize); +add_sub_const_decimals!(4usize, 5usize, 9usize, 0usize); +add_sub_const_decimals!(4usize, 4usize, 8usize, 0usize); +add_sub_const_decimals!(4usize, 3usize, 7usize, 1usize); +add_sub_const_decimals!(4usize, 2usize, 6usize, 2usize); +add_sub_const_decimals!(4usize, 1usize, 5usize, 3usize); +add_sub_const_decimals!(4usize, 0usize, 4usize, 4usize); +add_sub_const_decimals!(3usize, 64usize, 67usize, 0usize); +add_sub_const_decimals!(3usize, 63usize, 66usize, 0usize); +add_sub_const_decimals!(3usize, 62usize, 65usize, 0usize); +add_sub_const_decimals!(3usize, 61usize, 64usize, 0usize); +add_sub_const_decimals!(3usize, 60usize, 63usize, 0usize); +add_sub_const_decimals!(3usize, 59usize, 62usize, 0usize); +add_sub_const_decimals!(3usize, 58usize, 61usize, 0usize); +add_sub_const_decimals!(3usize, 57usize, 60usize, 0usize); +add_sub_const_decimals!(3usize, 56usize, 59usize, 0usize); +add_sub_const_decimals!(3usize, 55usize, 58usize, 0usize); +add_sub_const_decimals!(3usize, 54usize, 57usize, 0usize); +add_sub_const_decimals!(3usize, 53usize, 56usize, 0usize); +add_sub_const_decimals!(3usize, 52usize, 55usize, 0usize); +add_sub_const_decimals!(3usize, 51usize, 54usize, 0usize); +add_sub_const_decimals!(3usize, 50usize, 53usize, 0usize); +add_sub_const_decimals!(3usize, 49usize, 52usize, 0usize); +add_sub_const_decimals!(3usize, 48usize, 51usize, 0usize); +add_sub_const_decimals!(3usize, 47usize, 50usize, 0usize); +add_sub_const_decimals!(3usize, 46usize, 49usize, 0usize); +add_sub_const_decimals!(3usize, 45usize, 48usize, 0usize); +add_sub_const_decimals!(3usize, 44usize, 47usize, 0usize); +add_sub_const_decimals!(3usize, 43usize, 46usize, 0usize); +add_sub_const_decimals!(3usize, 42usize, 45usize, 0usize); +add_sub_const_decimals!(3usize, 41usize, 44usize, 0usize); +add_sub_const_decimals!(3usize, 40usize, 43usize, 0usize); +add_sub_const_decimals!(3usize, 39usize, 42usize, 0usize); +add_sub_const_decimals!(3usize, 38usize, 41usize, 0usize); +add_sub_const_decimals!(3usize, 37usize, 40usize, 0usize); +add_sub_const_decimals!(3usize, 36usize, 39usize, 0usize); +add_sub_const_decimals!(3usize, 35usize, 38usize, 0usize); +add_sub_const_decimals!(3usize, 34usize, 37usize, 0usize); +add_sub_const_decimals!(3usize, 33usize, 36usize, 0usize); +add_sub_const_decimals!(3usize, 32usize, 35usize, 0usize); +add_sub_const_decimals!(3usize, 31usize, 34usize, 0usize); +add_sub_const_decimals!(3usize, 30usize, 33usize, 0usize); +add_sub_const_decimals!(3usize, 29usize, 32usize, 0usize); +add_sub_const_decimals!(3usize, 28usize, 31usize, 0usize); +add_sub_const_decimals!(3usize, 27usize, 30usize, 0usize); +add_sub_const_decimals!(3usize, 26usize, 29usize, 0usize); +add_sub_const_decimals!(3usize, 25usize, 28usize, 0usize); +add_sub_const_decimals!(3usize, 24usize, 27usize, 0usize); +add_sub_const_decimals!(3usize, 23usize, 26usize, 0usize); +add_sub_const_decimals!(3usize, 22usize, 25usize, 0usize); +add_sub_const_decimals!(3usize, 21usize, 24usize, 0usize); +add_sub_const_decimals!(3usize, 20usize, 23usize, 0usize); +add_sub_const_decimals!(3usize, 19usize, 22usize, 0usize); +add_sub_const_decimals!(3usize, 18usize, 21usize, 0usize); +add_sub_const_decimals!(3usize, 17usize, 20usize, 0usize); +add_sub_const_decimals!(3usize, 16usize, 19usize, 0usize); +add_sub_const_decimals!(3usize, 15usize, 18usize, 0usize); +add_sub_const_decimals!(3usize, 14usize, 17usize, 0usize); +add_sub_const_decimals!(3usize, 13usize, 16usize, 0usize); +add_sub_const_decimals!(3usize, 12usize, 15usize, 0usize); +add_sub_const_decimals!(3usize, 11usize, 14usize, 0usize); +add_sub_const_decimals!(3usize, 10usize, 13usize, 0usize); +add_sub_const_decimals!(3usize, 9usize, 12usize, 0usize); +add_sub_const_decimals!(3usize, 8usize, 11usize, 0usize); +add_sub_const_decimals!(3usize, 7usize, 10usize, 0usize); +add_sub_const_decimals!(3usize, 6usize, 9usize, 0usize); +add_sub_const_decimals!(3usize, 5usize, 8usize, 0usize); +add_sub_const_decimals!(3usize, 4usize, 7usize, 0usize); +add_sub_const_decimals!(3usize, 3usize, 6usize, 0usize); +add_sub_const_decimals!(3usize, 2usize, 5usize, 1usize); +add_sub_const_decimals!(3usize, 1usize, 4usize, 2usize); +add_sub_const_decimals!(3usize, 0usize, 3usize, 3usize); +add_sub_const_decimals!(2usize, 64usize, 66usize, 0usize); +add_sub_const_decimals!(2usize, 63usize, 65usize, 0usize); +add_sub_const_decimals!(2usize, 62usize, 64usize, 0usize); +add_sub_const_decimals!(2usize, 61usize, 63usize, 0usize); +add_sub_const_decimals!(2usize, 60usize, 62usize, 0usize); +add_sub_const_decimals!(2usize, 59usize, 61usize, 0usize); +add_sub_const_decimals!(2usize, 58usize, 60usize, 0usize); +add_sub_const_decimals!(2usize, 57usize, 59usize, 0usize); +add_sub_const_decimals!(2usize, 56usize, 58usize, 0usize); +add_sub_const_decimals!(2usize, 55usize, 57usize, 0usize); +add_sub_const_decimals!(2usize, 54usize, 56usize, 0usize); +add_sub_const_decimals!(2usize, 53usize, 55usize, 0usize); +add_sub_const_decimals!(2usize, 52usize, 54usize, 0usize); +add_sub_const_decimals!(2usize, 51usize, 53usize, 0usize); +add_sub_const_decimals!(2usize, 50usize, 52usize, 0usize); +add_sub_const_decimals!(2usize, 49usize, 51usize, 0usize); +add_sub_const_decimals!(2usize, 48usize, 50usize, 0usize); +add_sub_const_decimals!(2usize, 47usize, 49usize, 0usize); +add_sub_const_decimals!(2usize, 46usize, 48usize, 0usize); +add_sub_const_decimals!(2usize, 45usize, 47usize, 0usize); +add_sub_const_decimals!(2usize, 44usize, 46usize, 0usize); +add_sub_const_decimals!(2usize, 43usize, 45usize, 0usize); +add_sub_const_decimals!(2usize, 42usize, 44usize, 0usize); +add_sub_const_decimals!(2usize, 41usize, 43usize, 0usize); +add_sub_const_decimals!(2usize, 40usize, 42usize, 0usize); +add_sub_const_decimals!(2usize, 39usize, 41usize, 0usize); +add_sub_const_decimals!(2usize, 38usize, 40usize, 0usize); +add_sub_const_decimals!(2usize, 37usize, 39usize, 0usize); +add_sub_const_decimals!(2usize, 36usize, 38usize, 0usize); +add_sub_const_decimals!(2usize, 35usize, 37usize, 0usize); +add_sub_const_decimals!(2usize, 34usize, 36usize, 0usize); +add_sub_const_decimals!(2usize, 33usize, 35usize, 0usize); +add_sub_const_decimals!(2usize, 32usize, 34usize, 0usize); +add_sub_const_decimals!(2usize, 31usize, 33usize, 0usize); +add_sub_const_decimals!(2usize, 30usize, 32usize, 0usize); +add_sub_const_decimals!(2usize, 29usize, 31usize, 0usize); +add_sub_const_decimals!(2usize, 28usize, 30usize, 0usize); +add_sub_const_decimals!(2usize, 27usize, 29usize, 0usize); +add_sub_const_decimals!(2usize, 26usize, 28usize, 0usize); +add_sub_const_decimals!(2usize, 25usize, 27usize, 0usize); +add_sub_const_decimals!(2usize, 24usize, 26usize, 0usize); +add_sub_const_decimals!(2usize, 23usize, 25usize, 0usize); +add_sub_const_decimals!(2usize, 22usize, 24usize, 0usize); +add_sub_const_decimals!(2usize, 21usize, 23usize, 0usize); +add_sub_const_decimals!(2usize, 20usize, 22usize, 0usize); +add_sub_const_decimals!(2usize, 19usize, 21usize, 0usize); +add_sub_const_decimals!(2usize, 18usize, 20usize, 0usize); +add_sub_const_decimals!(2usize, 17usize, 19usize, 0usize); +add_sub_const_decimals!(2usize, 16usize, 18usize, 0usize); +add_sub_const_decimals!(2usize, 15usize, 17usize, 0usize); +add_sub_const_decimals!(2usize, 14usize, 16usize, 0usize); +add_sub_const_decimals!(2usize, 13usize, 15usize, 0usize); +add_sub_const_decimals!(2usize, 12usize, 14usize, 0usize); +add_sub_const_decimals!(2usize, 11usize, 13usize, 0usize); +add_sub_const_decimals!(2usize, 10usize, 12usize, 0usize); +add_sub_const_decimals!(2usize, 9usize, 11usize, 0usize); +add_sub_const_decimals!(2usize, 8usize, 10usize, 0usize); +add_sub_const_decimals!(2usize, 7usize, 9usize, 0usize); +add_sub_const_decimals!(2usize, 6usize, 8usize, 0usize); +add_sub_const_decimals!(2usize, 5usize, 7usize, 0usize); +add_sub_const_decimals!(2usize, 4usize, 6usize, 0usize); +add_sub_const_decimals!(2usize, 3usize, 5usize, 0usize); +add_sub_const_decimals!(2usize, 2usize, 4usize, 0usize); +add_sub_const_decimals!(2usize, 1usize, 3usize, 1usize); +add_sub_const_decimals!(2usize, 0usize, 2usize, 2usize); +add_sub_const_decimals!(1usize, 64usize, 65usize, 0usize); +add_sub_const_decimals!(1usize, 63usize, 64usize, 0usize); +add_sub_const_decimals!(1usize, 62usize, 63usize, 0usize); +add_sub_const_decimals!(1usize, 61usize, 62usize, 0usize); +add_sub_const_decimals!(1usize, 60usize, 61usize, 0usize); +add_sub_const_decimals!(1usize, 59usize, 60usize, 0usize); +add_sub_const_decimals!(1usize, 58usize, 59usize, 0usize); +add_sub_const_decimals!(1usize, 57usize, 58usize, 0usize); +add_sub_const_decimals!(1usize, 56usize, 57usize, 0usize); +add_sub_const_decimals!(1usize, 55usize, 56usize, 0usize); +add_sub_const_decimals!(1usize, 54usize, 55usize, 0usize); +add_sub_const_decimals!(1usize, 53usize, 54usize, 0usize); +add_sub_const_decimals!(1usize, 52usize, 53usize, 0usize); +add_sub_const_decimals!(1usize, 51usize, 52usize, 0usize); +add_sub_const_decimals!(1usize, 50usize, 51usize, 0usize); +add_sub_const_decimals!(1usize, 49usize, 50usize, 0usize); +add_sub_const_decimals!(1usize, 48usize, 49usize, 0usize); +add_sub_const_decimals!(1usize, 47usize, 48usize, 0usize); +add_sub_const_decimals!(1usize, 46usize, 47usize, 0usize); +add_sub_const_decimals!(1usize, 45usize, 46usize, 0usize); +add_sub_const_decimals!(1usize, 44usize, 45usize, 0usize); +add_sub_const_decimals!(1usize, 43usize, 44usize, 0usize); +add_sub_const_decimals!(1usize, 42usize, 43usize, 0usize); +add_sub_const_decimals!(1usize, 41usize, 42usize, 0usize); +add_sub_const_decimals!(1usize, 40usize, 41usize, 0usize); +add_sub_const_decimals!(1usize, 39usize, 40usize, 0usize); +add_sub_const_decimals!(1usize, 38usize, 39usize, 0usize); +add_sub_const_decimals!(1usize, 37usize, 38usize, 0usize); +add_sub_const_decimals!(1usize, 36usize, 37usize, 0usize); +add_sub_const_decimals!(1usize, 35usize, 36usize, 0usize); +add_sub_const_decimals!(1usize, 34usize, 35usize, 0usize); +add_sub_const_decimals!(1usize, 33usize, 34usize, 0usize); +add_sub_const_decimals!(1usize, 32usize, 33usize, 0usize); +add_sub_const_decimals!(1usize, 31usize, 32usize, 0usize); +add_sub_const_decimals!(1usize, 30usize, 31usize, 0usize); +add_sub_const_decimals!(1usize, 29usize, 30usize, 0usize); +add_sub_const_decimals!(1usize, 28usize, 29usize, 0usize); +add_sub_const_decimals!(1usize, 27usize, 28usize, 0usize); +add_sub_const_decimals!(1usize, 26usize, 27usize, 0usize); +add_sub_const_decimals!(1usize, 25usize, 26usize, 0usize); +add_sub_const_decimals!(1usize, 24usize, 25usize, 0usize); +add_sub_const_decimals!(1usize, 23usize, 24usize, 0usize); +add_sub_const_decimals!(1usize, 22usize, 23usize, 0usize); +add_sub_const_decimals!(1usize, 21usize, 22usize, 0usize); +add_sub_const_decimals!(1usize, 20usize, 21usize, 0usize); +add_sub_const_decimals!(1usize, 19usize, 20usize, 0usize); +add_sub_const_decimals!(1usize, 18usize, 19usize, 0usize); +add_sub_const_decimals!(1usize, 17usize, 18usize, 0usize); +add_sub_const_decimals!(1usize, 16usize, 17usize, 0usize); +add_sub_const_decimals!(1usize, 15usize, 16usize, 0usize); +add_sub_const_decimals!(1usize, 14usize, 15usize, 0usize); +add_sub_const_decimals!(1usize, 13usize, 14usize, 0usize); +add_sub_const_decimals!(1usize, 12usize, 13usize, 0usize); +add_sub_const_decimals!(1usize, 11usize, 12usize, 0usize); +add_sub_const_decimals!(1usize, 10usize, 11usize, 0usize); +add_sub_const_decimals!(1usize, 9usize, 10usize, 0usize); +add_sub_const_decimals!(1usize, 8usize, 9usize, 0usize); +add_sub_const_decimals!(1usize, 7usize, 8usize, 0usize); +add_sub_const_decimals!(1usize, 6usize, 7usize, 0usize); +add_sub_const_decimals!(1usize, 5usize, 6usize, 0usize); +add_sub_const_decimals!(1usize, 4usize, 5usize, 0usize); +add_sub_const_decimals!(1usize, 3usize, 4usize, 0usize); +add_sub_const_decimals!(1usize, 2usize, 3usize, 0usize); +add_sub_const_decimals!(1usize, 1usize, 2usize, 0usize); +add_sub_const_decimals!(1usize, 0usize, 1usize, 1usize); +add_sub_const_decimals!(0usize, 64usize, 64usize, 0usize); +add_sub_const_decimals!(0usize, 63usize, 63usize, 0usize); +add_sub_const_decimals!(0usize, 62usize, 62usize, 0usize); +add_sub_const_decimals!(0usize, 61usize, 61usize, 0usize); +add_sub_const_decimals!(0usize, 60usize, 60usize, 0usize); +add_sub_const_decimals!(0usize, 59usize, 59usize, 0usize); +add_sub_const_decimals!(0usize, 58usize, 58usize, 0usize); +add_sub_const_decimals!(0usize, 57usize, 57usize, 0usize); +add_sub_const_decimals!(0usize, 56usize, 56usize, 0usize); +add_sub_const_decimals!(0usize, 55usize, 55usize, 0usize); +add_sub_const_decimals!(0usize, 54usize, 54usize, 0usize); +add_sub_const_decimals!(0usize, 53usize, 53usize, 0usize); +add_sub_const_decimals!(0usize, 52usize, 52usize, 0usize); +add_sub_const_decimals!(0usize, 51usize, 51usize, 0usize); +add_sub_const_decimals!(0usize, 50usize, 50usize, 0usize); +add_sub_const_decimals!(0usize, 49usize, 49usize, 0usize); +add_sub_const_decimals!(0usize, 48usize, 48usize, 0usize); +add_sub_const_decimals!(0usize, 47usize, 47usize, 0usize); +add_sub_const_decimals!(0usize, 46usize, 46usize, 0usize); +add_sub_const_decimals!(0usize, 45usize, 45usize, 0usize); +add_sub_const_decimals!(0usize, 44usize, 44usize, 0usize); +add_sub_const_decimals!(0usize, 43usize, 43usize, 0usize); +add_sub_const_decimals!(0usize, 42usize, 42usize, 0usize); +add_sub_const_decimals!(0usize, 41usize, 41usize, 0usize); +add_sub_const_decimals!(0usize, 40usize, 40usize, 0usize); +add_sub_const_decimals!(0usize, 39usize, 39usize, 0usize); +add_sub_const_decimals!(0usize, 38usize, 38usize, 0usize); +add_sub_const_decimals!(0usize, 37usize, 37usize, 0usize); +add_sub_const_decimals!(0usize, 36usize, 36usize, 0usize); +add_sub_const_decimals!(0usize, 35usize, 35usize, 0usize); +add_sub_const_decimals!(0usize, 34usize, 34usize, 0usize); +add_sub_const_decimals!(0usize, 33usize, 33usize, 0usize); +add_sub_const_decimals!(0usize, 32usize, 32usize, 0usize); +add_sub_const_decimals!(0usize, 31usize, 31usize, 0usize); +add_sub_const_decimals!(0usize, 30usize, 30usize, 0usize); +add_sub_const_decimals!(0usize, 29usize, 29usize, 0usize); +add_sub_const_decimals!(0usize, 28usize, 28usize, 0usize); +add_sub_const_decimals!(0usize, 27usize, 27usize, 0usize); +add_sub_const_decimals!(0usize, 26usize, 26usize, 0usize); +add_sub_const_decimals!(0usize, 25usize, 25usize, 0usize); +add_sub_const_decimals!(0usize, 24usize, 24usize, 0usize); +add_sub_const_decimals!(0usize, 23usize, 23usize, 0usize); +add_sub_const_decimals!(0usize, 22usize, 22usize, 0usize); +add_sub_const_decimals!(0usize, 21usize, 21usize, 0usize); +add_sub_const_decimals!(0usize, 20usize, 20usize, 0usize); +add_sub_const_decimals!(0usize, 19usize, 19usize, 0usize); +add_sub_const_decimals!(0usize, 18usize, 18usize, 0usize); +add_sub_const_decimals!(0usize, 17usize, 17usize, 0usize); +add_sub_const_decimals!(0usize, 16usize, 16usize, 0usize); +add_sub_const_decimals!(0usize, 15usize, 15usize, 0usize); +add_sub_const_decimals!(0usize, 14usize, 14usize, 0usize); +add_sub_const_decimals!(0usize, 13usize, 13usize, 0usize); +add_sub_const_decimals!(0usize, 12usize, 12usize, 0usize); +add_sub_const_decimals!(0usize, 11usize, 11usize, 0usize); +add_sub_const_decimals!(0usize, 10usize, 10usize, 0usize); +add_sub_const_decimals!(0usize, 9usize, 9usize, 0usize); +add_sub_const_decimals!(0usize, 8usize, 8usize, 0usize); +add_sub_const_decimals!(0usize, 7usize, 7usize, 0usize); +add_sub_const_decimals!(0usize, 6usize, 6usize, 0usize); +add_sub_const_decimals!(0usize, 5usize, 5usize, 0usize); +add_sub_const_decimals!(0usize, 4usize, 4usize, 0usize); +add_sub_const_decimals!(0usize, 3usize, 3usize, 0usize); +add_sub_const_decimals!(0usize, 2usize, 2usize, 0usize); +add_sub_const_decimals!(0usize, 1usize, 1usize, 0usize); +add_sub_const_decimals!(0usize, 0usize, 0usize, 0usize); diff --git a/framework/base/src/types/managed/wrapped/mod.rs b/framework/base/src/types/managed/wrapped/mod.rs index c9c70fea9b..e05c3a3a43 100644 --- a/framework/base/src/types/managed/wrapped/mod.rs +++ b/framework/base/src/types/managed/wrapped/mod.rs @@ -8,6 +8,7 @@ mod managed_address; mod managed_buffer_cached_builder; mod managed_byte_array; mod managed_decimal; +mod managed_decimal_macros; mod managed_option; mod managed_ref; mod managed_vec; From 391cce6b80d4ecc5ad4a39c7711c0f046916766d Mon Sep 17 00:00:00 2001 From: Andrei Marinica Date: Thu, 30 May 2024 10:31:43 +0300 Subject: [PATCH 4/6] fix after merge --- .../tests/basic_features_managed_decimal_test.rs | 3 --- .../src/types/managed/wrapped/managed_decimal.rs | 13 ++++++++++++- framework/scenario/tests/managed_decimal_test.rs | 3 --- 3 files changed, 12 insertions(+), 7 deletions(-) diff --git a/contracts/feature-tests/basic-features/tests/basic_features_managed_decimal_test.rs b/contracts/feature-tests/basic-features/tests/basic_features_managed_decimal_test.rs index 42473aec9b..d4257fe078 100644 --- a/contracts/feature-tests/basic-features/tests/basic_features_managed_decimal_test.rs +++ b/contracts/feature-tests/basic-features/tests/basic_features_managed_decimal_test.rs @@ -2,13 +2,10 @@ use multiversx_sc_scenario::*; fn world() -> ScenarioWorld { let mut blockchain = ScenarioWorld::new(); - blockchain.set_current_dir_from_workspace("contracts/feature-tests/basic-features"); - blockchain.register_contract( "mxsc:output/basic-features.mxsc.json", basic_features::ContractBuilder, ); - blockchain } diff --git a/framework/base/src/types/managed/wrapped/managed_decimal.rs b/framework/base/src/types/managed/wrapped/managed_decimal.rs index 39a8263396..bc9b282a55 100644 --- a/framework/base/src/types/managed/wrapped/managed_decimal.rs +++ b/framework/base/src/types/managed/wrapped/managed_decimal.rs @@ -1,5 +1,5 @@ use crate::{ - abi::{TypeAbi, TypeName}, + abi::{TypeAbi, TypeAbiFrom, TypeName}, api::{ const_handles, use_raw_handle, BigFloatApiImpl, BigIntApiImpl, ManagedTypeApi, StaticVarApiImpl, @@ -363,7 +363,11 @@ impl PartialEq TypeAbiFrom for ManagedDecimal {} + impl TypeAbi for ManagedDecimal { + type Unmanaged = Self; + fn type_name() -> TypeName { TypeName::from("ManagedDecimal") } @@ -373,9 +377,16 @@ impl TypeAbi for ManagedDecimal { } } +impl TypeAbiFrom + for ManagedDecimal> +{ +} + impl TypeAbi for ManagedDecimal> { + type Unmanaged = Self; + fn type_name() -> TypeName { TypeName::from(alloc::format!("ManagedDecimal<{}>", DECIMALS)) } diff --git a/framework/scenario/tests/managed_decimal_test.rs b/framework/scenario/tests/managed_decimal_test.rs index 3b185a8a56..cbe701c9cf 100644 --- a/framework/scenario/tests/managed_decimal_test.rs +++ b/framework/scenario/tests/managed_decimal_test.rs @@ -1,6 +1,3 @@ -#![feature(generic_const_exprs)] -#![allow(incomplete_features)] - use multiversx_sc::{ codec::test_util::{check_dep_encode_decode, check_top_encode_decode}, types::{BigFloat, BigUint, ConstDecimals, ManagedDecimal, NumDecimals}, From 910077470f1b89696846117742b202f0819b0c2a Mon Sep 17 00:00:00 2001 From: Andrei Marinica Date: Thu, 30 May 2024 11:02:17 +0300 Subject: [PATCH 5/6] managed decimal test fix after merge --- .../src/basic_features_proxy.rs | 8 +++ .../tests/basic_features_egld_decimal_test.rs | 65 +++++++------------ .../basic-features/wasm/src/lib.rs | 8 +-- 3 files changed, 37 insertions(+), 44 deletions(-) diff --git a/contracts/feature-tests/basic-features/src/basic_features_proxy.rs b/contracts/feature-tests/basic-features/src/basic_features_proxy.rs index 5fce393783..7131607d8c 100644 --- a/contracts/feature-tests/basic-features/src/basic_features_proxy.rs +++ b/contracts/feature-tests/basic-features/src/basic_features_proxy.rs @@ -74,6 +74,14 @@ where .argument(&bi) .original_result() } + + pub fn returns_egld_decimal( + self, + ) -> TxTypedCall>> { + self.wrapped_tx + .raw_call("returns_egld_decimal") + .original_result() + } } #[type_abi] diff --git a/contracts/feature-tests/basic-features/tests/basic_features_egld_decimal_test.rs b/contracts/feature-tests/basic-features/tests/basic_features_egld_decimal_test.rs index 96a01cfc00..3f9589e01f 100644 --- a/contracts/feature-tests/basic-features/tests/basic_features_egld_decimal_test.rs +++ b/contracts/feature-tests/basic-features/tests/basic_features_egld_decimal_test.rs @@ -1,49 +1,34 @@ -use multiversx_sc::types::{ - BigUint, ConstDecimals, ContractCallWithEgld, ManagedAddress, ManagedDecimal, -}; -use multiversx_sc_scenario::{api::StaticApi, scenario_model::*, *}; +use imports::{MxscPath, ReturnsResult, TestAddress, TestSCAddress}; +use multiversx_sc::types::{BigUint, ConstDecimals, ManagedDecimal}; +use multiversx_sc_scenario::{api::StaticApi, imports, ScenarioTxRun, ScenarioWorld}; -const BASIC_FEATURES_PATH_EXPR: &str = "file:../output/basic-features.wasm"; -const OWNER_ADDRESS_EXPR: &str = "address:owner"; -const BASIC_FEATURES_ADDRESS_EXPR: &str = "sc:basic-features"; - -type BasicFeatures = ContractInfo>; +const OWNER_ADDRESS: TestAddress = TestAddress::new("owner"); +const BASIC_FEATURES_ADDRESS: TestSCAddress = TestSCAddress::new("basic-features"); +const BASIC_FEATURES_PATH: MxscPath = MxscPath::new("output/basic-features.mxsc.json"); struct BasicFeaturesState { world: ScenarioWorld, - basic_features: BasicFeatures, } impl BasicFeaturesState { fn new() -> Self { let mut world = world(); - let basic_features_code = world.code_expression(BASIC_FEATURES_PATH_EXPR); - - world.set_state_step( - SetStateStep::new() - .put_account( - OWNER_ADDRESS_EXPR, - Account::new().nonce(1).balance(BigUintValue::from(100u64)), - ) - .put_account( - BASIC_FEATURES_ADDRESS_EXPR, - Account::new().nonce(1).code(basic_features_code), - ), - ); + let basic_features_code = + world.code_expression(BASIC_FEATURES_PATH.eval_to_expr().as_str()); - let basic_features = BasicFeatures::new(BASIC_FEATURES_ADDRESS_EXPR); + world.account(OWNER_ADDRESS).nonce(1).balance(100); + world + .account(BASIC_FEATURES_ADDRESS) + .nonce(1) + .code(basic_features_code); - Self { - world, - basic_features, - } + Self { world } } } fn world() -> ScenarioWorld { let mut blockchain = ScenarioWorld::new(); - blockchain.set_current_dir_from_workspace("contracts/feature-tests/basic-features"); - blockchain.register_contract(BASIC_FEATURES_PATH_EXPR, basic_features::ContractBuilder); + blockchain.register_contract(BASIC_FEATURES_PATH, basic_features::ContractBuilder); blockchain } @@ -51,19 +36,19 @@ fn world() -> ScenarioWorld { fn egld_decimal_blackbox_test() { let mut state = BasicFeaturesState::new(); - let sc_call = - ContractCallWithEgld::>>::new( - ManagedAddress::from(state.basic_features.to_address()), - "returns_egld_decimal", - BigUint::from(5u64), - ); - - let egld_decimal: ManagedDecimal> = state + let egld_decimal_result = state .world - .sc_call_get_result(ScCallStep::new().call(sc_call).from("address:owner")); + .tx() + .from(OWNER_ADDRESS) + .to(BASIC_FEATURES_ADDRESS) + .typed(basic_features::basic_features_proxy::BasicFeaturesProxy) + .returns_egld_decimal() + .egld(5) + .returns(ReturnsResult) + .run(); assert_eq!( - egld_decimal, + egld_decimal_result, ManagedDecimal::>::const_decimals_from_raw(BigUint::from( 5u64 )) diff --git a/contracts/feature-tests/basic-features/wasm/src/lib.rs b/contracts/feature-tests/basic-features/wasm/src/lib.rs index b746a95e81..07b590d9f6 100644 --- a/contracts/feature-tests/basic-features/wasm/src/lib.rs +++ b/contracts/feature-tests/basic-features/wasm/src/lib.rs @@ -5,9 +5,9 @@ //////////////////////////////////////////////////// // Init: 1 -// Endpoints: 389 +// Endpoints: 395 // Async Callback: 1 -// Total number of exported functions: 391 +// Total number of exported functions: 397 #![no_std] @@ -406,13 +406,13 @@ multiversx_sc_wasm_adapter::endpoints! { contains_unordered_at_address => contains_unordered_at_address get_by_index => get_by_index fill_set_mapper => fill_set_mapper + fill_map_mapper => fill_map_mapper + fill_unordered_set_mapper => fill_unordered_set_mapper managed_decimal_addition => managed_decimal_addition managed_decimal_subtraction => managed_decimal_subtraction managed_decimal_eq => managed_decimal_eq managed_decimal_trunc => managed_decimal_trunc managed_decimal_into_raw_units => managed_decimal_into_raw_units - fill_map_mapper => fill_map_mapper - fill_unordered_set_mapper => fill_unordered_set_mapper ) } From 0ffc965216698386b649bdc7e76f31bb57f6e2e7 Mon Sep 17 00:00:00 2001 From: Andrei Marinica Date: Thu, 30 May 2024 11:31:37 +0300 Subject: [PATCH 6/6] ManagedDecimal type abi fix, proxy update --- contracts/feature-tests/abi-tester/src/abi_proxy.rs | 9 +++++++++ .../base/src/types/managed/wrapped/managed_decimal.rs | 7 +++++++ 2 files changed, 16 insertions(+) diff --git a/contracts/feature-tests/abi-tester/src/abi_proxy.rs b/contracts/feature-tests/abi-tester/src/abi_proxy.rs index 55f3a6e6ef..2011970429 100644 --- a/contracts/feature-tests/abi-tester/src/abi_proxy.rs +++ b/contracts/feature-tests/abi-tester/src/abi_proxy.rs @@ -578,3 +578,12 @@ pub enum ExplicitDiscriminantMixed { b: u16, }, } + +#[type_abi] +#[derive(TopEncode, TopDecode)] +pub struct ManagedDecimalWrapper +where + Api: ManagedTypeApi, +{ + pub field: ManagedDecimal>, +} diff --git a/framework/base/src/types/managed/wrapped/managed_decimal.rs b/framework/base/src/types/managed/wrapped/managed_decimal.rs index bc9b282a55..89a7c47ca9 100644 --- a/framework/base/src/types/managed/wrapped/managed_decimal.rs +++ b/framework/base/src/types/managed/wrapped/managed_decimal.rs @@ -391,6 +391,13 @@ impl TypeAbi TypeName::from(alloc::format!("ManagedDecimal<{}>", DECIMALS)) } + fn type_name_rust() -> TypeName { + TypeName::from(alloc::format!( + "ManagedDecimal<$API, ConstDecimals<{}>>", + DECIMALS + )) + } + fn is_variadic() -> bool { false }