From 7e9f45fa65f831199a483fc2bda66d8b20bec039 Mon Sep 17 00:00:00 2001 From: zhong solar Date: Fri, 9 Nov 2018 15:54:35 +0800 Subject: [PATCH] code --- README.md | 5 +- dice/.DS_Store | Bin 0 -> 8196 bytes dice/config.hpp | 28 + dice/dice.abi | 560 + dice/dice.cpp | 1405 + dice/dice.wasm | Bin 0 -> 147975 bytes dice/eosio.token.hpp | 85 + jackpot/jackpot.abi | 156 + jackpot/jackpot.cpp | 315 + jackpot/jackpot.wasm | Bin 0 -> 53065 bytes lottery/config.hpp | 28 + lottery/lottery.abi | 482 + lottery/lottery.cpp | 663 + lottery/lottery.hpp | 232 + lottery/lottery.wasm | Bin 0 -> 98629 bytes lottery/lottery.wast | 66380 +++++++++++++++++++++++++++++++++++++++++ lottery/token.abi | 171 + lottery/token.cpp | 166 + lottery/token.hpp | 136 + lottery/token.wasm | Bin 0 -> 22951 bytes lottery/token.wast | 14960 ++++++++++ 21 files changed, 85770 insertions(+), 2 deletions(-) create mode 100644 dice/.DS_Store create mode 100644 dice/config.hpp create mode 100644 dice/dice.abi create mode 100644 dice/dice.cpp create mode 100644 dice/dice.wasm create mode 100644 dice/eosio.token.hpp create mode 100644 jackpot/jackpot.abi create mode 100644 jackpot/jackpot.cpp create mode 100644 jackpot/jackpot.wasm create mode 100644 lottery/config.hpp create mode 100644 lottery/lottery.abi create mode 100644 lottery/lottery.cpp create mode 100644 lottery/lottery.hpp create mode 100644 lottery/lottery.wasm create mode 100644 lottery/lottery.wast create mode 100644 lottery/token.abi create mode 100644 lottery/token.cpp create mode 100644 lottery/token.hpp create mode 100644 lottery/token.wasm create mode 100644 lottery/token.wast diff --git a/README.md b/README.md index 2cdbced..93e9ca0 100644 --- a/README.md +++ b/README.md @@ -1,7 +1,8 @@ # EOS.Win - 纯链上去中心化游戏平台 我们很高兴开源所有的合约代码，包括骰子、彩票、21点以及jackpot，为EOS的生态贡献自己的力量。 -正如我们之前一直强调的，EOS.Win没有服务器，所有的随机数都是在链上生成的。 + +#### 正如我们之前一直强调的，EOS.Win没有服务器，所有的随机数都是在链上生成的。 对于将来的每一次合约更新，我们将在更新合约之后： 1. 同步更新eospark的代码验证。 @@ -24,8 +25,8 @@ $ bc2d73d0eb6f22d8a5bf3bde6464e245df5f4977c07822bf1a189bc204549b33 dice.wasm ```sh $ cleos push action eosluckydice verify '["your_receipt_seed"]' -p youraccount ``` - #### 骰子幸运抽奖随机数验证： ```sh $ cleos push action eosluckydice luckreceipt '["your_receipt_seed"]' -p youraccount ``` +当然这些操作也可以在bloks(https://bloks.io/account/eosluckydice)上完成 \ No newline at end of file diff --git a/dice/.DS_Store b/dice/.DS_Store new file mode 100644 index 0000000000000000000000000000000000000000..8b7b2dbc91eb0b2d719a5e4356adce71b448bfcf GIT binary patch literal 8196 zcmeHMTWl0n7(U;&zzm~hwj#8!8y5-`NrjejjRH%zC6pH0u!WZEGP^U@f+A#X5mIr+=1qlE~8 z2!RNJ2!RNJ2!U$>0eWZiCQb0(7uu+g5Qq@?Un0Pt4=K91Oowtr$l%dIT~Gp$k-jG_^y!!BAS(0k&H*DQoyzl6-C!Tx$g%?kq78oFWj6u)W)+HLY^=Aeta(US7hK1(x*gB-O~>BR=NkunuH%8msQPw#j_YTFV0|XV7gp7L zkFG)P>}@w(kEATWQZ@6Yc?)k@y7IR58%C$8@oHtdGNZR-dS>1-whi%nwnOs@hOL|S z{+)CeY~Q@yG+a3zdsFVQwE<(ax~6v4>_jp--nty6ub4OQESmm7wN8@69&?g)vU)<= zty6}Z9i2zi15I*HvR;yQ@%4;rP_K_xtMO?!FG?ys9_6ZPk{qloUZN;HcMuy?PZlf9 z%ar6cOUoOUs>@Pfv}(1I>@A5@)sAp+%~~bdS8xUfC>1Y`23qEMCo{=5N&Q&b%lGco zJilwuuxa~QHMQ0BSG7yh4z5|R>xM4Xl_^n|UMPkE6m{uFF;n>~E6EyJ3){r@($P7{ zj<84BarPEF!QN)4*r)7Ec9#9Xeqq0|-`MZ$0)Q!qqZV^95A(4AOVEg=Xhs_C*n|%B zVjm3bM?Xxs7{Wmu!Z7Z~19%V*;V2%%aXgJ@@GM@%3A}@MaT2F-1|Q-he1-4uJY;51SsiXCpW%}7Few%NYe&dXp zsrieREL*)cbCCw)Zu+JC3uq^J74WUhr{IQXm3^4 zNJMgVau8}=T2WNS52+l?Tk8{w3Q7K3>Ry$&pRh03IrcMA_5%9@lQ0!Ck-|bO#wx7E zI_HA1@+iQ<02~Ywb%${m?#4a1m#BLrpzgzX9LMk^o+1jrgqQIe zUdJ0m;gfg|@8bia@aGsEN7&A>gvGbx30um#w&mFSX}wJHu`bc +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "config.hpp" + +#define GLOBAL_ID_BET 101 +#define GLOBAL_ID_HISTORY_INDEX 104 +#define GLOBAL_ID_LARGE_HISTORY_INDEX 105 +#define GLOBAL_ID_HIGH_ODDS_HISTORY_INDEX 106 +#define GLOBAL_ID_ACTIVE 109 + +#define GLOBAL_ID_ACCU_START_TIME 102 +#define GLOBAL_ID_ACCU_STOP_TIME 103 +#define GLOBAL_ID_STATIC_TOTAL 107 +#define GLOBAL_ID_STATIC_DAILY 108 +#define GLOBAL_ID_LUCKNUM_START_TIME 110 +#define GLOBAL_ID_LUCKNUM_STOP_TIME 111 +#define GLOBAL_ID_LUCKNUM_START_BETNUMS 112 +#define GLOBAL_ID_LUCKNUM_STOP_BETNUMS 113 +#define GLOBAL_ID_LUCK_DRAW_TOTAL 114 +#define GLOBAL_ID_LUCK_DRAW_ACTIVE 115 +#define GLOBAL_ID_LUCK_DRAW_LUCKY 116 +#define GLOBAL_ID_TOKEN_MULTIPLE 118 +#define GLOBAL_ID_MIN_JACKPOT_BET 119 +#define GLOBAL_ID_JACKPOT_ACTIVE 120 +#define GLOBAL_ID_DIVIDEND_PERCENT 121 + +#define BET_HISTORY_LEN 40 +#define WONDER_HIGH_ODDS 20 +#define FEE 2 +#define SINGLE_BET_MAX_PERCENT 1.5 +#define BETTOR_TOKEN_FEE 8 +#define INVITER_TOKEN_FEE 1 +#define ROLL_BORDER_MIN 2 +#define ROLL_BORDER_MAX 97 +#define ROLL_TYPE_SMALL 1 +#define ROLL_TYPE_BIG 2 +#define BET_MAX_NUM 100 +#define INVITE_BONUS 0.005 +#define JACKPOT_BONUS 0.005 +#define TOP_NOTICE 1 +#define DAY_SECONDS 86400 +#define HOUR_SECONDS 3600 +#define LUCK_DRAW_MAX 10001 + +using namespace std; + +/********* random ***********/ +namespace eoswin { + class random { + public: + template + struct data { + T content; + int block; + int prefix; + uint64_t time; + + data(T t) { + content = t; + block = tapos_block_num(); + prefix = tapos_block_prefix(); + time = current_time(); + } + }; + + struct st_seeds { + checksum256 seed1; + checksum256 seed2; + }; + + public: + random(); + ~random(); + + template + checksum256 create_sys_seed(T mixed) const; + + void seed(checksum256 sseed, checksum256 useed); + + void mixseed(checksum256& sseed, checksum256& useed, checksum256& result) const; + + // generator number ranged [0, max-1] + uint64_t generator(uint64_t max = 101); + + uint64_t gen(checksum256& seed, uint64_t max = 101) const; + + checksum256 get_sys_seed() const; + checksum256 get_user_seed() const; + checksum256 get_mixed() const; + checksum256 get_seed() const; + private: + checksum256 _sseed; + checksum256 _useed; + checksum256 _mixed; + checksum256 _seed; + }; + + random::random() {} + random::~random() {} + + template + checksum256 random::create_sys_seed(T mixed) const { + checksum256 result; + data mixed_block(mixed); + const char *mixed_char = reinterpret_cast(&mixed_block); + sha256((char *)mixed_char, sizeof(mixed_block), &result); + return result; + } + + void random::seed(checksum256 sseed, checksum256 useed) { + _sseed = sseed; + _useed = useed; + mixseed(_sseed, _useed, _mixed); + _seed = _mixed; + } + + void random::mixseed(checksum256& sseed, checksum256& useed, checksum256& result) const { + st_seeds seeds; + seeds.seed1 = sseed; + seeds.seed2 = useed; + sha256( (char *)&seeds.seed1, sizeof(seeds.seed1) * 2, &result); + } + + uint64_t random::generator(uint64_t max) { + mixseed(_mixed, _seed, _seed); + + uint64_t r = gen(_seed, max); + + return r; + } + + uint64_t random::gen(checksum256& seed, uint64_t max) const { + if (max <= 0) { + return 0; + } + const uint64_t *p64 = reinterpret_cast(&seed); + uint64_t r = p64[1] % max; + return r; + } + + checksum256 random::get_sys_seed() const { + return _sseed; + } + + checksum256 random::get_user_seed() const { + return _useed; + } + + checksum256 random::get_mixed() const { + return _mixed; + } + + checksum256 random::get_seed() const { + return _seed; + } +} +/********************************* bet *********************************/ + +class dice : public eosio::contract { + public: + const uint64_t to_bonus_bucket_interval = 1*3600*uint64_t(1000000); + const uint64_t luck_draw_interval = 1*3600*uint64_t(1000000); + + eosio::token _eosio_token; + eosio::token _game_token; + using contract::contract; + + account_name _code; + void setCode(account_name code) { + _code = code; + } + + //@abi table activebets + //@abi table highbets + //@abi table largebets + struct bet + { + uint64_t id; + uint64_t bet_id; + account_name contract; + account_name bettor; + account_name inviter; + uint64_t bet_amt; + vector payout; + uint8_t roll_type; + uint64_t roll_border; + uint64_t roll_value; + checksum256 seed; + eosio::time_point_sec time; + uint64_t primary_key() const { return id; }; + EOSLIB_SERIALIZE(bet, (id)(bet_id)(contract)(bettor)(inviter)(bet_amt)(payout)(roll_type)(roll_border)(roll_value)(seed)(time)); + }; + typedef eosio::multi_index bet_index; + bet_index _bets; + + typedef eosio::multi_index high_odds_index; + high_odds_index _high_odds_bets; + + typedef eosio::multi_index large_eos_index; + large_eos_index _large_eos_bets; + + //@abi table globalvars + struct globalvar + { + uint64_t id; + uint64_t val; + uint64_t primary_key() const { return id; }; + EOSLIB_SERIALIZE(globalvar, (id)(val)); + }; + typedef eosio::multi_index global_index; + global_index _globals; + + //@abi table tradetokens + struct tradetoken + { + eosio::symbol_name name; + account_name contract; + uint64_t in; + uint64_t out; + uint64_t protect; + uint64_t times; + uint64_t divi_time; + uint64_t divi_balance; + uint64_t min_bet; + uint64_t large_bet; + uint64_t primary_key() const { return name; }; + EOSLIB_SERIALIZE(tradetoken, (name)(contract)(in)(out)(protect)(times)(divi_time)(divi_balance)(min_bet)(large_bet)); + }; + typedef eosio::multi_index _tradetoken_index; + _tradetoken_index _trades; + + //@abi table notices + struct notice + { + uint64_t id; + string val; + uint64_t primary_key() const { return id; }; + EOSLIB_SERIALIZE(notice, (id)(val)); + }; + typedef eosio::multi_index _notice_index; + _notice_index _notices; + + struct assetitem + { + string symbol; + uint64_t accu_in; + uint64_t accu_out; + }; + + //@abi table players + //@abi table ranks + //@abi table dailys + struct player + { + account_name account; + eosio::time_point_sec last_bettime; + eosio::asset last_betin; + eosio::asset last_payout; + vector asset_items; + uint64_t primary_key() const { return account; }; + double byeosin() const { + for(auto it = asset_items.begin(); it != asset_items.end(); ++it) { + if (it->symbol == "EOS") { + return -it->accu_in; + } + } + return 0; + } + EOSLIB_SERIALIZE(player, (account)(last_bettime)(last_betin)(last_payout)(asset_items)); + }; + + typedef eosio::multi_index _player_index; + _player_index _playerlists; + + typedef eosio::multi_index _rank_index; + _rank_index _ranklists; + + typedef eosio::multi_index _daily_index; + _daily_index _dailylists; + + ///@abi table luckers i64 + struct lucker { + account_name account; + uint64_t last_bet_time_sec; + uint64_t draw_time; + uint64_t roll_value; + + uint64_t primary_key() const {return account;} + EOSLIB_SERIALIZE(lucker, (account)(last_bet_time_sec)(draw_time)(roll_value)) + }; + typedef eosio::multi_index luckers_table; + luckers_table _luckers; + + //@abi table luckys + struct luckyreward + { + uint64_t id; + uint64_t number; + eosio::asset reward; + uint64_t primary_key() const { return id; }; + EOSLIB_SERIALIZE(luckyreward, (id)(number)(reward)); + }; + typedef eosio::multi_index _luckyreward_index; + _luckyreward_index _luckyrewards; + + eoswin::random _random; + checksum256 _seed; + + dice(account_name self) : contract(self), + _bets(self, self), + _globals(self, self), + _high_odds_bets(self, self), + _large_eos_bets(self, self), + _eosio_token(TOKEN_CONTRACT), + _game_token(GAME_TOKEN_CONTRACT), + _trades(self, _self), + _notices(self, _self), + _playerlists(self, _self), + _ranklists(self, _self), + _dailylists(self, _self), + _luckers(self, self), + _luckyrewards(self, _self) + + { + + } + + /// @abi action + void setactive(bool active) { + require_auth(_self); + + auto pos = _globals.find(GLOBAL_ID_ACTIVE); + if (pos == _globals.end()) { + _globals.emplace(_self, [&](auto& a) { + a.id = GLOBAL_ID_ACTIVE; + a.val = active; + }); + } else { + _globals.modify(pos, 0, [&](auto& a) { + a.val = active; + }); + } + } + + /// @abi action + void init() + { + require_auth(_self); + + _globals.emplace(_self, [&](auto &a) { + a.id = GLOBAL_ID_BET; + a.val = 0; + }); + + _globals.emplace(_self, [&](auto &a) { + a.id = GLOBAL_ID_HISTORY_INDEX; + a.val = 0; + }); + + _globals.emplace(_self, [&](auto &a) { + a.id = GLOBAL_ID_LARGE_HISTORY_INDEX; + a.val = 0; + }); + + _globals.emplace(_self, [&](auto &a) { + a.id = GLOBAL_ID_HIGH_ODDS_HISTORY_INDEX; + a.val = 0; + }); + + _globals.emplace(_self, [&](auto &a) { + a.id = GLOBAL_ID_STATIC_TOTAL; + a.val = 0; + }); + + _globals.emplace(_self, [&](auto &a) { + a.id = GLOBAL_ID_STATIC_DAILY; + a.val = 0; + }); + + _globals.emplace(_self, [&](auto &a) { + a.id = GLOBAL_ID_MIN_JACKPOT_BET; + a.val = 2500; + }); + + _globals.emplace(_self, [&](auto &a) { + a.id = GLOBAL_ID_JACKPOT_ACTIVE; + a.val = 1; + }); + + _globals.emplace(_self, [&](auto &a) { + a.id = GLOBAL_ID_DIVIDEND_PERCENT; + a.val = 25; + }); + + _notices.emplace(_self, [&](auto &a) { + a.id = TOP_NOTICE; + a.val = ""; + }); + + init_all_trade(); + } + + void init_all_trade() { + init_trade_token(EOS_SYMBOL, TOKEN_CONTRACT); + init_trade_token(GAME_SYMBOL, GAME_TOKEN_CONTRACT); + init_trade_token(ADD_SYMBOL, ADD_CONTRACT); + init_trade_token(ATD_SYMBOL, ATD_CONTRACT); + init_trade_token(DAC_SYMBOL, DAC_CONTRACT); + init_trade_token(HORUS_SYMBOL, HORUS_CONTRACT); + init_trade_token(IQ_SYMBOL, IQ_CONTRACT); + init_trade_token(KARMA_SYMBOL, KARMA_CONTRACT); + init_trade_token(TP_SYMBOL, TP_CONTRACT); + init_trade_token(MEET_SYMBOL, MEET_CONTRACT); + init_trade_token(BLACK_SYMBOL, BLACK_CONTRACT); + } + + void init_trade_token(eosio::symbol_name sym, account_name contract) + { + _trades.emplace(_self, [&](auto &a) { + a.name = eosio::symbol_type(sym).name(); + a.contract = contract; + a.in = 0; + a.out = 0; + a.protect = 0; + a.times = 0; + a.divi_time = current_time(); + a.divi_balance = 0; + }); + } + + /// @abi action + void setnotice(string notice) + { + require_auth(_self); + auto iter = _notices.find(TOP_NOTICE); + if (iter != _notices.end()) { + _notices.modify(iter, 0, [&](auto &a) { + a.val = notice; + }); + } + } + + /// @abi action + void setluckrwd(uint64_t id, uint64_t number, eosio::asset reward) + { + require_auth(_self); + auto iter = _luckyrewards.find(id); + if (iter == _luckyrewards.end()) { + _luckyrewards.emplace(_self, [&](auto &a) { + a.id = id; + a.number = number; + a.reward = reward; + }); + } else { + _luckyrewards.modify(iter, 0, [&](auto &a) { + a.number = number; + a.reward = reward; + }); + } + } + + /// @abi action + void setglobal(uint64_t id, uint64_t value) + { + require_auth(_self); + auto iter = _globals.find(id); + if (iter == _globals.end()) { + _globals.emplace(_self, [&](auto &a) { + a.id = id; + a.val = value; + }); + } else { + _globals.modify(iter, 0, [&](auto &a) { + a.val = value; + }); + } + } + + void to_bonus_bucket(eosio::symbol_type sym) + { + eosio::symbol_name sym_name = eosio::symbol_type(sym).name(); + auto trade_iter = _trades.find(sym_name); + + auto divi_time = trade_iter->divi_time; + auto ct = current_time(); + + if (ct < (divi_time + to_bonus_bucket_interval)) { + return; + } + + uint64_t last_divi_balance = trade_iter->divi_balance; + eosio::token bet_token(trade_iter->contract); + auto balance = bet_token.get_balance(_self, sym_name); + uint64_t dividends = 0; + + if (last_divi_balance < balance.amount) { + auto iter = _globals.find(GLOBAL_ID_DIVIDEND_PERCENT); + + uint64_t dividend_pecent = iter->val; + if (dividend_pecent >= 75) { + dividend_pecent = 75; + } + dividends = (balance.amount - last_divi_balance) * dividend_pecent / 100; + } + + if (dividends <= 10000) { + return; + } + + _trades.modify(trade_iter, 0, [&](auto &a) { + a.divi_balance = balance.amount - dividends; + a.divi_time = ct; + }); + INLINE_ACTION_SENDER(eosio::token, transfer)(trade_iter->contract, {_self,N(active)}, {_self, DIVI_ACCOUNT, eosio::asset(dividends, sym), "To EOS.Win Bonus Pool [https://eos.win/dice]"} ); + } + + void reward_game_token(account_name bettor, account_name inviter, eosio::asset quantity) { + auto pos = _globals.find(GLOBAL_ID_TOKEN_MULTIPLE); + uint64_t multiple = 1; + if (pos != _globals.end()) { + multiple = pos->val; + } + + auto num = quantity.amount / 2 * multiple; + num = quantity.amount % 2 == 0 ? num : num + 1; + if (num <= 0) { + return; + } + auto reward = eosio::asset(num, GAME_SYMBOL); + + auto balance = _game_token.get_balance(GAME_TOKEN_CONTRACT, eosio::symbol_type(GAME_SYMBOL).name()); + reward = reward > balance ? balance : reward; + + auto to_better = reward * BETTOR_TOKEN_FEE / 10; + auto to_team = reward - to_better; + if (inviter != TEAM_ACCOUNT) { + auto to_inviter = reward * INVITER_TOKEN_FEE / 10; + if (to_inviter.amount > 0) { + to_team.set_amount(to_team.amount - to_inviter.amount); + + if (is_account(inviter)) { + INLINE_ACTION_SENDER(eosio::token, transfer)(GAME_TOKEN_CONTRACT, {GAME_TOKEN_CONTRACT,N(active)}, {GAME_TOKEN_CONTRACT, inviter, to_inviter, "LUCKY token for inviter [https://eos.win]"} ); + } + } + } + + if (to_better.amount > 0) { + INLINE_ACTION_SENDER(eosio::token, transfer)(GAME_TOKEN_CONTRACT, {GAME_TOKEN_CONTRACT,N(active)}, {GAME_TOKEN_CONTRACT, bettor, to_better, "LUCKY token for player [https://eos.win]"} ); + } + + if (to_team.amount > 0) { + INLINE_ACTION_SENDER(eosio::token, transfer)(GAME_TOKEN_CONTRACT, {GAME_TOKEN_CONTRACT,N(active)}, {GAME_TOKEN_CONTRACT, TEAM_ACCOUNT, to_team, "LUCKY token for team [https://eos.win]"} ); + } + } + + void transfer(account_name from, account_name to, eosio::asset quantity, string memo) + { + eosio::currency::transfer t = {from, to, quantity, memo}; + if (t.from == _self || t.to != _self) + { + return; + } + + if (t.from == N(eosio.stake) || t.from == N(tptvotepools)) + { + return; + } + + check_symbol_code(t.quantity); + eosio_assert(t.quantity.is_valid(), "Invalid transfer amount."); + + int64_t amt = t.quantity.amount; + eosio_assert(amt > 0, "Transfer amount not positive"); + + eosio::symbol_name sym_name = eosio::symbol_type(t.quantity.symbol).name(); + auto trade_iter = _trades.find(sym_name); + eosio::token bet_token(trade_iter->contract); + eosio::asset balance = bet_token.get_balance(_self, sym_name); + + if (t.memo == "deposit") { + if (trade_iter != _trades.end()) { + _trades.modify(trade_iter, 0, [&](auto& info) { + info.divi_balance += t.quantity.amount; + }); + } + } else { + auto active_pos = _globals.find(GLOBAL_ID_ACTIVE); + eosio_assert(active_pos != _globals.end() && active_pos->val, "Maintaining ..."); + + int64_t max = (balance.amount * SINGLE_BET_MAX_PERCENT / 100); + eosio_assert(amt <= max, "Bet amount exceeds max amount."); + + auto trade_iter = _trades.find(sym_name); + eosio_assert(balance.amount >= trade_iter->protect, "Game under maintain, stay tuned."); + + eosio_assert(t.memo.empty() == false, "Memo is for dice info, cannot be empty."); + + vector pieces; + boost::split(pieces, t.memo, boost::is_any_of(",")); + + eosio_assert(pieces[0].empty() == false, "Roll type cannot be empty!"); + eosio_assert(pieces[1].empty() == false, "Roll prediction cannot be empty!"); + + uint8_t roll_type = atoi( pieces[0].c_str() ); + uint64_t roll_border = atoi( pieces[1].c_str() ); + + account_name inviter; + if (pieces[2].empty() == true) { + inviter = TEAM_ACCOUNT; + } else { + inviter = eosio::string_to_name(pieces[2].c_str()); + } + eosio_assert(t.from != inviter, "Inviter can't be self"); + + int64_t max_reward = get_bet_reward(roll_type, roll_border, amt); + float max_bet_token = (amt * (balance.amount / 10) / max_reward) / 10000.0; + float min_bet_token = (trade_iter->min_bet) / 10000.0; + char str[128]; + sprintf(str, "Bet amount must between %f and %f", min_bet_token, max_bet_token); + eosio_assert(amt >= trade_iter->min_bet && max_reward <= (balance.amount / 10), str); + + eosio_assert(roll_border >= ROLL_BORDER_MIN && roll_border <= ROLL_BORDER_MAX, "Bet border must between 2 to 97"); + + eosio::transaction r_out; + auto t_data = make_tuple(t.from, t.quantity, roll_type, roll_border, inviter); + r_out.actions.emplace_back(eosio::permission_level{_self, N(active)}, _self, N(start), t_data); + r_out.delay_sec = 1; + r_out.send(t.from, _self); + } + } + + int64_t get_bet_reward(uint8_t roll_type, uint64_t roll_border, int64_t amount) + { + uint8_t fit_num; + if (roll_type == ROLL_TYPE_SMALL) + { + fit_num = roll_border; + } + else if (roll_type == ROLL_TYPE_BIG) + { + fit_num = BET_MAX_NUM - 1 - roll_border; + } + + int64_t reward_amt = amount * (100 - FEE) / fit_num; + + return reward_amt; + } + + uint64_t get_random(uint64_t max) + { + auto g = _globals.get(GLOBAL_ID_BET, "global is missing"); + auto sseed = _random.create_sys_seed(g); + + auto s = read_transaction(nullptr, 0); + char *tx = (char *)malloc(s); + read_transaction(tx, s); + checksum256 txid; + sha256(tx, s, &txid); + printhex(&txid, sizeof(txid)); + + _random.seed(sseed, txid); + uint64_t roll_value = _random.generator(max); + _seed = _random.get_seed(); + + return roll_value; + } + + uint64_t get_bet_nums() + { + uint64_t total = 0; + for(auto iter = _trades.begin(); iter != _trades.end(); ) + { + total += iter->times; + iter++; + } + return total; + } + + + bool is_lucknum_open() + { + auto start_itr = _globals.find(GLOBAL_ID_LUCKNUM_START_TIME); + uint64_t start_time = 0; + if (start_itr != _globals.end()) { + start_time = start_itr->val; + } + + auto stop_itr = _globals.find(GLOBAL_ID_LUCKNUM_STOP_TIME); + uint64_t stop_time = 0; + if (stop_itr != _globals.end()) { + stop_time = stop_itr->val; + } + + eosio::time_point_sec cur_time = eosio::time_point_sec( now() ); + + if (eosio::time_point_sec(start_time) <= cur_time && cur_time <= eosio::time_point_sec(stop_time)) { + return true; + } + + uint64_t total_bet_nums = get_bet_nums(); + auto start_betnums_itr = _globals.find(GLOBAL_ID_LUCKNUM_START_BETNUMS); + uint64_t start_betnums = 0; + if (start_betnums_itr != _globals.end()) { + start_betnums = start_betnums_itr->val; + } + + auto stop_betnums_itr = _globals.find(GLOBAL_ID_LUCKNUM_STOP_BETNUMS); + uint64_t stop_betnums = 0; + if (stop_betnums_itr != _globals.end()) { + stop_betnums = stop_betnums_itr->val; + } + + if (start_betnums <= total_bet_nums && total_bet_nums <= stop_betnums) { + return true; + } + return false; + } + + /// @abi action + void start(account_name bettor, eosio::asset bet_asset, + uint8_t roll_type, uint64_t roll_border, account_name inviter) + { + require_auth(_self); + eosio::transaction r_out; + auto t_data = make_tuple(bettor, bet_asset, roll_type, roll_border, inviter); + r_out.actions.emplace_back(eosio::permission_level{_self, N(active)}, _self, N(resolved), t_data); + r_out.delay_sec = 0; + r_out.send(bettor, _self); + } + + /// @abi action + void resolved(account_name bettor, eosio::asset bet_asset, + uint8_t roll_type, uint64_t roll_border, account_name inviter) + { + require_auth(_self); + eosio::symbol_name sym_name = eosio::symbol_type(bet_asset.symbol).name(); + auto trade_iter = _trades.find(sym_name); + + uint64_t roll_value = get_random(BET_MAX_NUM); + auto global_itr = _globals.find(GLOBAL_ID_BET); + eosio_assert(global_itr != _globals.end(), "Unknown global id"); + uint64_t last_bet_id = global_itr->val; + uint64_t cur_bet_id = last_bet_id + 1; + + _globals.modify(global_itr, 0, [&](auto& a) { + a.val = cur_bet_id; + }); + + vector payout_list; + eosio::asset payout; + + uint32_t _now = now(); + + if ( (roll_type == ROLL_TYPE_SMALL && roll_value < roll_border) || (roll_type == ROLL_TYPE_BIG && roll_value > roll_border) ) + { + int64_t reward_amt = get_bet_reward(roll_type, roll_border, bet_asset.amount); + payout = eosio::asset(reward_amt, bet_asset.symbol); + + char str[128]; + sprintf(str, "Bet id: %lld. You win! Remember to claim your dividens with your LUCKY token! https://eos.win", cur_bet_id); + INLINE_ACTION_SENDER(eosio::token, transfer)(trade_iter->contract, {_self, N(active)}, {_self, bettor, payout, string(str)} ); + + _trades.modify(trade_iter, 0, [&](auto& a) { + a.out += reward_amt; + }); + } + else + { + payout = eosio::asset(0, bet_asset.symbol); + } + + payout_list.push_back(payout); + + to_jackpot(bettor, bet_asset); + if (bet_asset.symbol == EOS_SYMBOL && is_lucknum_open()) + { + for(auto lucky_iter = _luckyrewards.begin(); lucky_iter != _luckyrewards.end(); ) + { + if ( (roll_value == lucky_iter->number) && lucky_iter->reward.amount > 0) + { + eosio::symbol_name lucky_sym_name = eosio::symbol_type(lucky_iter->reward.symbol).name(); + auto lucky_trade_iter = _trades.find(lucky_sym_name); + + char str[128]; + sprintf(str, "Hit magic number! You got extra bonus! https://eos.win"); + eosio::print(string(str).c_str()); + INLINE_ACTION_SENDER(eosio::token, transfer)(lucky_trade_iter->contract, {_self, N(active)}, {_self, bettor, lucky_iter->reward, string(str)} ); + + payout_list.push_back(lucky_iter->reward); + } + lucky_iter++; + } + } + + if (bet_asset.symbol == EOS_SYMBOL) { + auto lucker_pos = _luckers.find(bettor); + if (lucker_pos == _luckers.end()) { + lucker_pos = _luckers.emplace(_self, [&](auto& info) { + info.account = bettor; + info.last_bet_time_sec = _now; + info.draw_time = 0; + info.roll_value = 0; + }); + } else { + _luckers.modify(lucker_pos, 0, [&](auto& info) { + info.last_bet_time_sec = _now; + }); + } + } + + eosio::time_point_sec time = eosio::time_point_sec( _now ); + + save_rank_list(bettor, bet_asset, payout, _now); + save_daily_list(bettor, bet_asset, payout, _now); + + save_bet(cur_bet_id, bettor, inviter, bet_asset, payout_list, roll_type, roll_border, roll_value, _seed, time); + save_highodds_bet(cur_bet_id, bettor, inviter, bet_asset, payout_list, roll_type, roll_border, roll_value, _seed, time); + save_large_bet(cur_bet_id, bettor, inviter, bet_asset, payout_list, roll_type, roll_border, roll_value, _seed, time); + + _trades.modify(trade_iter, 0, [&](auto& a) { + a.in += bet_asset.amount; + a.times += 1; + }); + + INLINE_ACTION_SENDER(dice, receipt)(_self, {_self, N(active)}, {cur_bet_id, bettor, bet_asset, payout_list, _seed, roll_type, roll_border, roll_value}); + + if (inviter != TEAM_ACCOUNT && is_account(inviter)) { + eosio::asset inviter_reward = eosio::asset(bet_asset.amount * INVITE_BONUS, bet_asset.symbol); + + char str[128]; + sprintf(str, "Referral reward from EOS.Win! Player: %s, Bet ID: %lld", eosio::name{bettor}.to_string().c_str(), cur_bet_id); + INLINE_ACTION_SENDER(eosio::token, transfer)(trade_iter->contract, {_self, N(active)}, {_self, inviter, inviter_reward, string(str)} ); + } + + if (bet_asset.symbol == EOS_SYMBOL) { + reward_game_token(bettor, inviter, bet_asset); + } + + to_bonus_bucket(bet_asset.symbol); + } + + /// @abi action + void receipt(uint64_t bet_id, account_name bettor, eosio::asset bet_amt, vector payout_list, + checksum256 seed, uint8_t roll_type, uint64_t roll_border, uint64_t roll_value) + { + require_auth(_self); + require_recipient( bettor ); + } + + void to_jackpot(account_name bettor, eosio::asset bet_asset) + { + auto pos = _globals.find(GLOBAL_ID_JACKPOT_ACTIVE); + + if (pos != _globals.end() && pos->val == 0) { + return; + } + + if (bet_asset.symbol == EOS_SYMBOL) { + auto jackpot_itr = _globals.find(GLOBAL_ID_MIN_JACKPOT_BET); + if (jackpot_itr != _globals.end() && bet_asset.amount >= jackpot_itr->val) { + eosio::asset jackpot_reward = eosio::asset(bet_asset.amount * JACKPOT_BONUS, bet_asset.symbol); + eosio::transaction r_out; + auto t_data = make_tuple(_self, JACKPOT_ACCOUNT, jackpot_reward, eosio::name{bettor}.to_string()); + r_out.actions.emplace_back(eosio::permission_level{_self, N(active)}, N(eosio.token), N(transfer), t_data); + r_out.delay_sec = 1; + r_out.send(bettor, _self); + } + } + } + + string symbol_to_string(uint64_t v) const + { + v >>= 8; + string result; + while (v > 0) { + char c = static_cast(v & 0xFF); + result += c; + v >>= 8; + } + return result; + } + + void init_player(player &a, account_name bettor, eosio::asset betin, eosio::asset payout, eosio::time_point_sec cur_time) + { + string symbol = symbol_to_string(betin.symbol.value); + + a.account = bettor; + a.last_betin = betin; + a.last_bettime = cur_time; + a.last_payout = payout; + + uint8_t count = a.asset_items.size(); + bool finded = false; + for (uint8_t i=0; i < count; i++) + { + if (a.asset_items[i].symbol == symbol) + { + a.asset_items[i].accu_in += betin.amount; + a.asset_items[i].accu_out += payout.amount; + finded = true; + } + } + + if (finded == false) + { + assetitem item; + item.symbol = symbol; + item.accu_in = betin.amount; + item.accu_out = payout.amount; + a.asset_items.push_back(item); + } + } + + void clear_player_accu(player &a) + { + uint8_t count = a.asset_items.size(); + for (uint8_t i=0; i < count; i++) + { + a.asset_items[i].accu_in = 0; + a.asset_items[i].accu_out = 0; + } + } + + void save_player_list(account_name bettor, eosio::asset betin, eosio::asset payout, uint32_t now) + { + eosio::time_point_sec cur_time = eosio::time_point_sec( now ); + auto player_itr = _playerlists.find(bettor); + + string symbol = symbol_to_string(betin.symbol.value); + if (player_itr == _playerlists.end()) { + _playerlists.emplace(_self, [&](auto &a) { + init_player(a, bettor, betin, payout, cur_time); + }); + } + else + { + _playerlists.modify(player_itr, 0, [&](auto& a) { + init_player(a, bettor, betin, payout, cur_time); + }); + } + } + + void save_rank_list(account_name bettor, eosio::asset betin, eosio::asset payout, uint32_t now) + { + auto start_itr = _globals.find(GLOBAL_ID_ACCU_START_TIME); + auto start_time = 0; + if (start_itr != _globals.end()) { + start_time = start_itr->val; + } + + auto stop_itr = _globals.find(GLOBAL_ID_ACCU_STOP_TIME); + auto stop_time = 0; + if (stop_itr != _globals.end()) { + stop_time = stop_itr->val; + } + + eosio::time_point_sec cur_time = eosio::time_point_sec( now ); + + if (eosio::time_point_sec(start_time) > cur_time || cur_time > eosio::time_point_sec(stop_time)) { + return; + } + auto player_itr = _ranklists.find(bettor); + string symbol = symbol_to_string(betin.symbol.value); + if (player_itr == _ranklists.end()) { + _ranklists.emplace(_self, [&](auto &a) { + init_player(a, bettor, betin, payout, cur_time); + }); + } + else + { + if (eosio::time_point_sec(start_time) > player_itr->last_bettime) { + _ranklists.modify(player_itr, 0, [&](auto& a) { + clear_player_accu(a); + }); + } + + _ranklists.modify(player_itr, 0, [&](auto& a) { + init_player(a, bettor, betin, payout, cur_time); + }); + } + } + + void save_daily_list(account_name bettor, eosio::asset betin, eosio::asset payout, uint32_t now) + { + uint64_t cur_day = now / DAY_SECONDS; + eosio::time_point_sec start_time = eosio::time_point_sec( cur_day * DAY_SECONDS ); + eosio::time_point_sec stop_time = eosio::time_point_sec( (cur_day + 1) * DAY_SECONDS); + eosio::time_point_sec cur_time = eosio::time_point_sec( now ); + + auto player_itr = _dailylists.find(bettor); + string symbol = symbol_to_string(betin.symbol.value); + if (player_itr == _dailylists.end()) { + _dailylists.emplace(_self, [&](auto &a) { + init_player(a, bettor, betin, payout, cur_time); + }); + } + else + { + if (eosio::time_point_sec(start_time) > player_itr->last_bettime) { + _dailylists.modify(player_itr, 0, [&](auto& a) { + clear_player_accu(a); + }); + } + + _dailylists.modify(player_itr, 0, [&](auto& a) { + init_player(a, bettor, betin, payout, cur_time); + }); + } + } + + void init_bet(bet& a, uint64_t id, uint64_t bet_id, account_name contract, account_name bettor, account_name inviter, + uint64_t bet_amt, vector payout, uint8_t roll_type, uint64_t roll_border, + uint64_t roll_value, checksum256 seed, eosio::time_point_sec time) + { + a.id = id; + a.bet_id = bet_id; + a.contract = contract; + a.bettor = bettor; + a.inviter = inviter; + + a.bet_amt = bet_amt; + a.payout = payout; + a.roll_type = roll_type; + a.roll_border = roll_border; + a.roll_value = roll_value; + a.seed = seed; + a.time = time; + } + + void save_bet( + uint64_t bet_id, account_name bettor, account_name inviter, + eosio::asset bet_quantity, vector payout_list, uint8_t roll_type, uint64_t roll_border, uint64_t roll_value, + checksum256 seed, eosio::time_point_sec time + ) + { + uint64_t bet_amt = bet_quantity.amount; + eosio::symbol_name sym_name = eosio::symbol_type(bet_quantity.symbol).name(); + auto trade_iter = _trades.find(sym_name); + + auto global_itr = _globals.find(GLOBAL_ID_HISTORY_INDEX); + + uint64_t history_index = global_itr->val % BET_HISTORY_LEN + 1; + + auto bet_itr = _bets.find(history_index); + + if (bet_itr != _bets.end()) + { + // auto lambda_func = [&](auto& a) {}; + _bets.modify(bet_itr, 0, [&](auto& a) { + init_bet(a, a.id, bet_id, trade_iter->contract, bettor, + inviter, bet_amt, payout_list, roll_type, + roll_border, roll_value, seed, time); + }); + } + else + { + _bets.emplace(_self, [&](auto &a) { + init_bet(a, history_index, bet_id, trade_iter->contract, bettor, + inviter, bet_amt, payout_list, roll_type, + roll_border, roll_value, seed, time); + }); + } + + _globals.modify(global_itr, 0, [&](auto& a) { + a.val = history_index; + }); + } + + void save_highodds_bet( + uint64_t bet_id, account_name bettor, account_name inviter, + eosio::asset bet_quantity, vector payout_list, uint8_t roll_type, uint64_t roll_border, uint64_t roll_value, + checksum256 seed, eosio::time_point_sec time + ) + { + if ((roll_type == ROLL_TYPE_SMALL && roll_value < roll_border && roll_border < WONDER_HIGH_ODDS) + || (roll_type == ROLL_TYPE_BIG && roll_value > roll_border && roll_border > (BET_MAX_NUM - WONDER_HIGH_ODDS)) + ) + { + uint64_t bet_amt = bet_quantity.amount; + eosio::symbol_name sym_name = eosio::symbol_type(bet_quantity.symbol).name(); + auto trade_iter = _trades.find(sym_name); + + auto global_itr = _globals.find(GLOBAL_ID_HIGH_ODDS_HISTORY_INDEX); + + uint64_t history_index = global_itr->val % BET_HISTORY_LEN + 1; + + auto bet_itr = _high_odds_bets.find(history_index); + + if (bet_itr != _high_odds_bets.end()) + { + _high_odds_bets.modify(bet_itr, 0, [&](auto& a) { + init_bet(a, a.id, bet_id, trade_iter->contract, bettor, + inviter, bet_amt, payout_list, roll_type, + roll_border, roll_value, seed, time); + }); + } + else + { + _high_odds_bets.emplace(_self, [&](auto &a) { + init_bet(a, history_index, bet_id, trade_iter->contract, bettor, + inviter, bet_amt, payout_list, roll_type, + roll_border, roll_value, seed, time); + }); + } + + _globals.modify(global_itr, 0, [&](auto& a) { + a.val = history_index; + }); + } + } + + void save_large_bet( + uint64_t bet_id, account_name bettor, account_name inviter, + eosio::asset bet_quantity, vector payout_list, uint8_t roll_type, uint64_t roll_border, uint64_t roll_value, + checksum256 seed, eosio::time_point_sec time + ) + { + uint64_t bet_amt = bet_quantity.amount; + eosio::symbol_name sym_name = eosio::symbol_type(bet_quantity.symbol).name(); + auto trade_iter = _trades.find(sym_name); + + if (bet_amt >= trade_iter->large_bet) + { + auto global_itr = _globals.find(GLOBAL_ID_LARGE_HISTORY_INDEX); + + uint64_t history_index = global_itr->val % BET_HISTORY_LEN + 1; + + auto bet_itr = _large_eos_bets.find(history_index); + + if (bet_itr != _large_eos_bets.end()) + { + _large_eos_bets.modify(bet_itr, 0, [&](auto& a) { + init_bet(a, a.id, bet_id, trade_iter->contract, bettor, + inviter, bet_amt, payout_list, roll_type, + roll_border, roll_value, seed, time); + }); + } + else + { + _large_eos_bets.emplace(_self, [&](auto &a) { + init_bet(a, history_index, bet_id, trade_iter->contract, bettor, + inviter, bet_amt, payout_list, roll_type, + roll_border, roll_value, seed, time); + }); + } + + _globals.modify(global_itr, 0, [&](auto& a) { + a.val = history_index; + }); + } + } + + /// @abi action + void verify(checksum256 seed) { + uint64_t r = _random.gen(seed, BET_MAX_NUM); + string str = string("Random value ") + to_string(r); + eosio_assert(false, str.c_str()); + } + + void check_symbol(eosio::asset quantity) { + eosio_assert( + quantity.symbol == EOS_SYMBOL || + quantity.symbol == GAME_SYMBOL || + quantity.symbol == ADD_SYMBOL || + quantity.symbol == ATD_SYMBOL || + quantity.symbol == DAC_SYMBOL || + quantity.symbol == HORUS_SYMBOL || + quantity.symbol == IQ_SYMBOL || + quantity.symbol == KARMA_SYMBOL || + quantity.symbol == TP_SYMBOL || + quantity.symbol == MEET_SYMBOL || + quantity.symbol == BLACK_SYMBOL, + "Accept EOS/LUCKY/ADD/ATD/EOSDAC/HORUS/IQ/KARMA/TPT/MEETONE/BLACK only!"); + } + + void check_symbol_code(const eosio::asset& quantity) { + eosio_assert( + (_code == TOKEN_CONTRACT && quantity.symbol == EOS_SYMBOL) || + (_code == GAME_TOKEN_CONTRACT && quantity.symbol == GAME_SYMBOL) || + (_code == ADD_CONTRACT && quantity.symbol == ADD_SYMBOL) || + (_code == ATD_CONTRACT && quantity.symbol == ATD_SYMBOL) || + (_code == DAC_CONTRACT && quantity.symbol == DAC_SYMBOL) || + (_code == HORUS_CONTRACT && quantity.symbol == HORUS_SYMBOL) || + (_code == IQ_CONTRACT && quantity.symbol == IQ_SYMBOL) || + (_code == KARMA_CONTRACT && quantity.symbol == KARMA_SYMBOL) || + (_code == TP_CONTRACT && quantity.symbol == TP_SYMBOL) || + (_code == MEET_CONTRACT && quantity.symbol == MEET_SYMBOL) || + (_code == BLACK_CONTRACT && quantity.symbol == BLACK_SYMBOL), + "Token do not be supported, or symbol not match with the code!"); + } + + /// @abi action + void setriskline(eosio::asset quantity) { + require_auth(_self); + check_symbol(quantity); + eosio::symbol_name sym_name = eosio::symbol_type(quantity.symbol).name(); + auto trade_iter = _trades.find(sym_name); + if (trade_iter != _trades.end()) { + _trades.modify(trade_iter, 0, [&](auto& info) { + info.protect = quantity.amount; + }); + } + } + + /// @abi action + void setdivi(eosio::asset quantity) + { + require_auth(_self); + check_symbol(quantity); + eosio::symbol_name sym_name = eosio::symbol_type(quantity.symbol).name(); + auto trade_iter = _trades.find(sym_name); + if (trade_iter != _trades.end()) { + _trades.modify(trade_iter, 0, [&](auto& info) { + info.divi_balance = quantity.amount; + }); + } + } + + /// @abi action + void setminbet(eosio::asset quantity) { + require_auth(_self); + check_symbol(quantity); + eosio::symbol_name sym_name = eosio::symbol_type(quantity.symbol).name(); + auto trade_iter = _trades.find(sym_name); + if (trade_iter != _trades.end()) { + _trades.modify(trade_iter, 0, [&](auto& info) { + info.min_bet = quantity.amount; + info.large_bet = 10 * info.min_bet; + }); + } + } + + /// @abi action + void luck(account_name actor, uint64_t sub) { + require_auth(actor); + + auto g_pos = _globals.find(GLOBAL_ID_LUCK_DRAW_ACTIVE); + eosio_assert(g_pos->val > 0, "luck is not actived"); + + auto ct = current_time(); + + auto nt = ct/1e6; + auto st = sub ^ 217824523; + eosio_assert(abs(st - nt) < 300, "wrong sub!"); + + auto luck_pos = _luckers.find(actor); + if (luck_pos == _luckers.end()) { + luck_pos = _luckers.emplace(_self, [&](auto& info) { + info.account = actor; + info.last_bet_time_sec = 0; + info.draw_time = 0; + info.roll_value = 0; + }); + } + eosio_assert(luck_pos->last_bet_time_sec + HOUR_SECONDS > nt, "do not be active player"); + eosio_assert(luck_pos->draw_time + luck_draw_interval < ct, "draw time has not cool down yet"); + + eosio::transaction r_out; + r_out.actions.emplace_back(eosio::permission_level{_self, N(active)}, _self, N(lucking), actor); + r_out.delay_sec = 1; + r_out.send(actor, _self); + } + + /// @abi action + void lucking(account_name actor) { + require_auth(_self); + eosio::transaction r_out; + r_out.actions.emplace_back(eosio::permission_level{_self, N(active)}, _self, N(lucked), actor); + r_out.delay_sec = 0; + r_out.send(actor, _self); + } + + /// @abi action + void lucked(account_name actor) { + require_auth(_self); + + auto ct = current_time(); + + uint64_t roll_value = get_random(LUCK_DRAW_MAX); + + vector rewards; + eosio::asset reward = get_luck_reward(roll_value); + rewards.push_back(reward); + + auto total_pos = _globals.find(GLOBAL_ID_LUCK_DRAW_TOTAL); + if (total_pos == _globals.end()) { + total_pos = _globals.emplace(_self, [&](auto& info) { + info.id = GLOBAL_ID_LUCK_DRAW_TOTAL; + info.val = reward.amount; + }); + } else { + _globals.modify(total_pos, 0, [&](auto& info) { + info.val += reward.amount; + }); + } + + auto luck_pos = _luckers.find(actor); + _luckers.modify(luck_pos, 0, [&](auto& info) { + info.draw_time = ct; + info.roll_value = roll_value; + }); + + eosio::transaction r_out; + r_out.actions.emplace_back(eosio::permission_level{_self, N(active)}, N(eosio.token), N(transfer), eosio::currency::transfer{_self, actor, reward, "EOS.Win lucky draw rewards!"}); + + if (roll_value == 10000) { + auto lucky_reward = eosio::asset(6660000, GAME_SYMBOL); + rewards.push_back(lucky_reward); + r_out.actions.emplace_back(eosio::permission_level{_self, N(active)}, GAME_TOKEN_CONTRACT, N(transfer), eosio::currency::transfer{_self, actor, lucky_reward, "EOS.Win lucky draw rewards!"}); + + auto lucky_pos = _globals.find(GLOBAL_ID_LUCK_DRAW_LUCKY); + if (lucky_pos == _globals.end()) { + lucky_pos = _globals.emplace(_self, [&](auto& info) { + info.id = GLOBAL_ID_LUCK_DRAW_LUCKY; + info.val = lucky_reward.amount; + }); + } else { + _globals.modify(lucky_pos, 0, [&](auto& info) { + info.val += lucky_reward.amount; + }); + } + } + + r_out.actions.emplace_back(eosio::permission_level{_self, N(active)}, _self, N(luckreceipt), make_tuple(actor, _seed, roll_value, rewards, luck_pos->draw_time)); + r_out.delay_sec = 0; + r_out.send(actor, _self); + } + + eosio::asset get_luck_reward(uint64_t roll_number) { + if (roll_number <= 9885) { + return eosio::asset(6, EOS_SYMBOL); + } else if (9886 <= roll_number && roll_number <= 9985) { + return eosio::asset(60, EOS_SYMBOL); + } else if (9986 <= roll_number && roll_number <= 9993) { + return eosio::asset(600, EOS_SYMBOL); + } else if (9994 <= roll_number && roll_number <= 9997) { + return eosio::asset(6000, EOS_SYMBOL); + } else if (9998 <= roll_number && roll_number <= 9999) { + return eosio::asset(60000, EOS_SYMBOL); + } else if (roll_number == 10000) { + return eosio::asset(160000, EOS_SYMBOL); + } else { + return eosio::asset(0, EOS_SYMBOL); + } + } + + /// @abi action + void luckreceipt(account_name name, checksum256 seed, uint64_t roll_value, vector rewards, uint64_t draw_time) { + require_auth(_self); + require_recipient(name); + } + + /// @abi action + void luckverify(checksum256 seed) { + uint64_t r = _random.gen(seed, LUCK_DRAW_MAX); + string str = string("Random value ") + to_string(r); + eosio_assert(false, str.c_str()); + } +}; + +#define EOSIO_ABI_EX(TYPE, MEMBERS) \ + extern "C" \ + { \ + void apply(uint64_t receiver, uint64_t code, uint64_t action) \ + { \ + if (code == N(eosio) && action == N(onerror)) \ + { \ + /* onerror is only valid if it is for the "eosio" code account and \ + * authorized by "EOS"'s "active permission */ \ + eosio_assert(code == N(eosio), "onerror action's are only valid from " \ + "the \"EOS\" system account"); \ + } \ + TYPE thiscontract(receiver); \ + if (( code == TOKEN_CONTRACT || code == GAME_TOKEN_CONTRACT || code == ADD_CONTRACT || code == ATD_CONTRACT || \ + code == DAC_CONTRACT || code == HORUS_CONTRACT || code == IQ_CONTRACT || code == KARMA_CONTRACT || code == TP_CONTRACT || code == MEET_CONTRACT || code == BLACK_CONTRACT) \ + && (action == N(transfer))) { \ + thiscontract.setCode(code);\ + execute_action(&thiscontract, &dice::transfer); \ + return; \ + } \ + if (code != receiver) return; \ + switch (action) { \ + EOSIO_API(TYPE, MEMBERS) \ + }; \ + eosio_exit(0); \ + } \ + } + +EOSIO_ABI_EX(dice, (init)(setactive)(setglobal)(setnotice)(setluckrwd)(setriskline)(setdivi)(setminbet)(receipt)(verify)(start)(resolved)(luck)(lucking)(lucked)(luckreceipt)(luckverify)) diff --git a/dice/dice.wasm b/dice/dice.wasm new file mode 100644 index 0000000000000000000000000000000000000000..5e90d12f099e83aa47613ba6bc9c742ef9927364 GIT binary patch literal 147975 zcmeFa3xFNRS?Al2^FC*0dSuDSl8O2p4`IyOS;aV#FlM8k&BNIQVml6av)n5=wv08h z9+pOq1CBLu6cCUNf*V)|lB~!BI}gJEPSy#5Oo$=ot_gx9#IS~)3nnNKKqQ9sy_enW z@BdYGpFU@1q_JZ=GDuFQ`&8HCtE#WQSAF$WaNU93VGso2N1}_ihlhgg(INiChwiu| z*k0i;KWc~WIAp)0LnP`K{{`Ed`pQ4$tlGQEsdPoj!S=xY4i9Y)!aKG{$`|m12KXED zt8xebc&D^4$CDP6>@&Hq{1#xh^T!H=ssU)ImKN<{S@gr27uZ!n!IQoyJB{VPg6(bK zRhurY#*1Y&z{yL3{_)muZz@^$uX)XU4Q~%`k3L!b)_BLBTN~T9U3bF`GdF&F@J;$z z-?nYXEi*S>60Fj%5q{k^vt!Qv)TlAJ{Qt2_2OhC*kJ3uiLTzwR;biGpgtw#>jFeRzE2R zX7=viVM%M0G(ytBeSqiER$I0mdk^f~yY0FI2X@d88>E&?+Hu>?nIKS}*3JXluDkwv zTAT^aRYGm|j@{SqdwpOa)%me|@2xxBFMT?&W5)ex?AyO{&&*9bZgUma?B@YjX|jLE zbvICLF=T;(?UHBqU$^Ig`{t56`*+-Oa3`I)?%>Q#!MOFNoODSrs4Z%6e+qSfwdv4yjXNQOHz)ja(@`6o4Q=i9XuG_cwz_!=ky!ZND z+x8sX?Iv?oId$Lu9iSi|-W$C;N|IzOShud(T7Q1Xzi)0NK@uhr|Bv~97}oh)Nh(n_ zsn(Kk9sfd-*FPsrHf%^Xgh{$#Lzsr^s7C)ftt4r6x+xzv^fp|uj!fsAGchr-p%=#0 z?gnL`5mGmVtuSeZiGR(L?D;JT4TaRi=R9jG4U-lP>EDJ8%?$|L5Doa zdFREQ4v;46I-PZ$b?r(u+!vmEZZ!^ru>Kdd=LuEz?tgt0oV)EcJ8rr9<NnB>Er9pw`K!-esly{`+tZR57re9sFEi=Tf=Wp7#WB=}*2f+J1+iu=*>yDdW9Q>;_6xl?P*X`W13FNzB@9uwl$%}6d zE?S)aBBfvat&8$sdSJ(n8(zGq6VLnCd?AU)D%lXBx4>mq`agEuzRE1wR#4 zZrs0PNAS~;hWJ%8-@a|z^S@(eFEk69@dI@87sznkYYzk;j2Z{_80EMz_)yfmwfJ#w zl)xAE@87c*l6d`fA|$~tMU7i;^qJ=($hDU5jXQ7N5&TL7hd8*W`2DMqILPbv@0@`= z-A5ZU`>AX1{@^1~o%cOA@7NRkm#Fr->u2`ver<5S>N>FV2ll*n=giH)M@ z8M3+a#@F8*d@QQbncMc=9Q;~Tf8F)_t<1+Gqmwu74}M*3-F&@Kwct0R(c;Ipox3UX zi3m=$TfNx3>)^g%KB@u0^}F{4pH#V-y#{3Po51CJ_9=RqzdsOFz>A&1Z@Jbe_1jin z@P9gLreTl;?QQ>UQBaqr;C(ix>q43>8CWNdsR{z{gf@!y)cc+r8Z9YYNV7( zO-}dfr1VRrk+qSg4GN~QZ?Hj`w37cwtM=AN8`dMi*vPg_7XUZ1jnio@&z((9r}g}Y z3Z$E3RX?wu%?H!T1kcBVY5qPO^r1g#DaT7GCoJW`eu^sFx;fsSseNi<*xGN0{0{U0?_nop#5eT zMgyS50xcG3<*vtqEy(&kk9|L>ko3I&4N3x?4V{NQ7I;C%$Q22|7i0`v&rPdUabdh& zGY|{JAY0H3L|db+X?W#GU>!)qJG*eN_EgXf+w?#=)q^x_uL;N)DI){cNTWN)$ko1_ zii!~wx|YW}7#iz<@$CdP~rE=T*T6LEB?f?AQU-?{p(UX!t6>}pfr*{x}%mI*?BJ?2^s76h11=*6KV7tAC8C9 zHW{yU*{d&G-&Oj(Q(Jy`YRivw8|}0)wc$-^b?R&U8++3aE2WZATZL-E+q*T^YyEJy zPL3bCy;q(3!K+7tHq%*8L*5F2(TBJ#jc5o&u}04Y%A2KIf=h9Y*DI@r5E|_Gth0MDeQPCsq9Me(~8# z0sN6l0sLF~uSbhl6~C)O@ne;u@AveJ&lMT7`}(i<7q2Qlui_8(iy!Y7f4In)J<@+& zC|*_kgo>Z+7k|88e70Huf4Kj8qEsF6CeG;YpxnWrFK7OAN||Mf~!Xo;Gi#W zQ(vM@(NW)rqx1oR!}S4uI=O6JCuv(l|MM%q_~B1I_|`+OE*k#Amp*B~i%AdQOcTd=YP^nxo1@!`wos0fE7x_#Tw_N*@$>Kf^dC*Vy6Dv-8iKs) zWB0xFXMg37rmh|tbu}MWFR;hV`d-Y^i?v0~Yp0Wcv#vAhD*oE1Kljc*c=%)V!a@DN ze6RAVXJ^0iSMPuDV?aIP>i(Rdu5OBsd#H~C^%X_kDE!G4>pCN#KV7^PfHX55H-HDO?f~ zs;)Xn=04LJhCZT@R=9Lyrsyz#d?pL=+=w!jpAT5sYc9y`+ z!`(3|#i9{*YfAvA-A;}f#YLFYVJ z0;C(JqYkV{293xYG#prIkXDm7MHyxx4ZOy-H-i1qx+nw53vZwLUwZ0aAYMG4&0*uP z?SiSsk#0!QINBQ1kGr$AGnw-J&~!$bFND|}sWc=TgYmWSO;a$PKsg6eVgt4pXZ0&E z0JSruxpE2<1!{IR5!vx1S(6I9UVSQfb#_ue4f6!CfT6h{`*J9p>y5}d?Ov0Y0Qg9D z6El?sX|k)^1`44c<)mz48tsnI=uPZ=FqxIKJ)Pb3Qb9upKw|9(Q2J{lkSDYLgsGyy;F?x3+ zLwYc2JUfa>Hua{7@pKdmO30#N5kYvyWqvxQC)NeXh2_S!eX^DOly)1sO~4(Wgp%|| zUhJ)90Tnp<8*`((HN-98VDP6tz^noD8X9%Ik1~S(J)Z|JvNdUkHNzc*@lx8 zdWpSF`7}EEFFQJ(d^+lhK720HB=90^NvAJ1Yjk+4X7-l#)S1?>Y9FEiExj*#F#-}T z2iXJtxtl-z+)e$BM62`^lLy$sZ2dPpeRMlXD{lJIc*GDHWMdk&6+%HbjdOk)XCMFY zKc0BUeUAn-%0!N6B12GRB-ySJEUIGdF_ECU8PKz1notps`hx}6_8_vi^hW3oFSojJjkEJrQVTI1(VBw9yJ}ey z$66j7RBbd(+C8qDda<*wxw5bHLV?F_eZj(0a@XB$JgI zXA$IU>d%9;^@jdVCV0tu*!nTIwvT*j>w7-(Yu^DI7-tuzb*LAm^*hq~)Sm@+04JRA zP%k{>DMFsN;qWz^J0~4aJ{7G?!!-InD2J+j%`G08fobZF+ou+SYqA9(Oh&t+{a+4p zHlh7lEg~%&9^bFWWx;m$>jw9@37|sfH;`S97J8*ip5cK4mY4pg{wo#Ds+q&uBXo5i z>Azk&omR_oAlt-Mv_{axWlg8~N>WJ>tlGy(;IQ%5hVgjXxGdPhqqP}~8c)YI$5+tg zV}USBY`VZBBtF)iLnh(1`;Q(~C7morCTR2`iO*XKmX)V+)Plk+EAe^J%1eBb|9Ycd zv@-D5(u>aKH~~^8sLrll5^US8J#)Zbh~Sgs<|e>n0lGQPqEAqPZ5F@-3FpWuOgjZS*IhrOlX;bR7&kFWbXD3x- zrTyVJmKN35pcZh!ab6>M)UZM>PjRfV<*?Dc@$u3Ol;QtDv^DAUkd1hue^K_via1r2 z{8ZEpOyGpiMcLSNw(pi*Jt{*+*5_|t*Jiz~ot`@UW552hRc#faEp5i5!XExtLT4AE zWX;rXz3X=w4z<9-ikp~gfKP=1er4)vcVR172F{EX{oAk8AU`pvb z@W04Cw(5~;0I%S!>KsI_)axc}166tQ@K^ZpMr4IzT!Q4MnJE?6NKw^QHTp(%sscUd zPGzrN9Hbsi1Vw++s&ZFh5VNrTCt=B(CfU`)I)>8}R4Cbiif6)MFSG<&$3phkA<5;0 zFApdD&2Yls4k!HGZ~}_`V5NUQobZ+5gs&;QjBz31wgOF5{hU2VNq$xMtb5R@*tP+MCyH*A67hV>O`H`o(LO-bS>h*(2x?N4W zopo`SsDbr`>6&u-LC7wB=#)E2?Cfe6%ANEB`t1HgL@a6p;9f;yedslWij$L0uNhRF zWXIX zjIpZW3d9&_#L9CCAesbdNSM=*(9@7mG(-}n$}u*chRA8mrpG3d@kFwPMzDa!WbFx) zwIIO7!C1G(WaM?lw(f*onso+KZ$^fNQ4n6?71f5!l3bC3m!_5RP}7eClV5PZQFc>I zy_aG`mZG&#V`D3B`IV8N-baF1NKh9NpjN_OOfId_u#_89@N4)c2}{8E8e%7-+X*C-z`?v--;&ngCwb5RQb|ZMS3%k38xc)Pqmc_O*mMwL#P|-%kiqL-Jmk zd>A6t4UsVKqMWdb>*FjV4P1^xvt=C0DM$%x-ew#cGh-l)Qgd4@c3VG@BOMY>MLG;? z3|SoI0A~g$2Sir>NcxX~DXLPvEc(@Hb(n5YK-d^$vyn3lu}?Gi=8wMpork7m8S-R< zW|BV(2dWU=K+Y;KhAd!=QH4Jrpb8(43aYU2lvII5%KSSj5BRaC3ZnC-(g<@%^;Chj zZTUL#4sHt-b6G-=O|YPNqS{bo?A)& zZD2WIq%^!`cEwJGSh#r0vdCF;EKB~$9yxQ$R;9BB^G2X0d0A$LWns7xf zB_pkACUaMH@?98jlrFw3V{fW(myJAwUWM~oK+B%#9WAB0H`TXQsp`2UNfZP4v^gFJ z;6p20$i?rkMp1Z2|JVX+(VbeLUIcLQJatcUi#Q9Z(s9h}9q|=5gTcXa728vm3M>){ zG#VyTq~ffT(Zr_6c&v>J>)EPE{s>w_&DvFv)==y!Na#4>EYpRYu$0gd$uNBip##IK zFx}Y4Vv*y@#UjV@mf8sJQIa?gN#ZCfki-FPUYjrRT-;zs{7<|Hu@Qu;w0~71M0iKO zP>)MdwT_v(T3)E0>lKnE^B~RC%MjXGV?DVCQ(Op_sz^n8D}xIK(w?Fj-Pr={ci)9dUnvCkwO3Cfk8*Mak4Z9rf&NKl_9&< zv2f6?b-QFiBewh88>@c?vLFVJ>;{AX=Wf@^9)hD9v#IJ_RsQ-w|5Ys4XSlq0+fuw; zn!ibeLAF+2jD#}iV+>Ow#xOm$Gs1j3EL#E3S$mrO?1)~g8JAKG0DTkMN%3N6=b2As|j2BiX87loKs4qzxO+6aiDV~c}R$GH%wvTN<&nd&Ktvx|-D+^~X z3lfUMAj18!VmY~32k)?l_TuF2Y=4n6=CcGy=EKY@el-^~t*hCb9^MpPNt^Q)IISzT2>{{o&qF z^GMJDQrlvU#C;f6U=WXJ&uLX25~SE$*4x%`Sq&O8Xc}k7olYG|-Wdh$KZ)%)D6nT* zu~k!5+;o(TfL<M_Zdm>;DL z-h`lR8h<8+p~%Go86DArjd4>YN~Rb3ToTnXyLplhgidPv2s;{E)Z*cF$(8_9$O|q( zvs*58#pd`XS8A(P)v}Ur%|r=&$Ld-U>ZFWxu8F)p`vPF>{Mnb{T&zKL)8?49X|LNi z$E?`8peuk8-sOiXEz>NPFvd_FI>IX=9Y1PL9H}#veyRQc)k^NVl`prWOmmBg@zk3g z!v>=EBMgTjrb*rTD=DwwqY)S$rmW~86{S(yF_d;f@(n!jqsvPdyO8#AA0OGh%Rd%7 zi!G6gsJ~&@(uB*1?w5{fHpuT$f5WgPJ759~k>y#-TYOnC$)h5PuO)S23(c_~g*GHE z#qmfEi{Wn7&}N}_o}2MjM?y^CuDZ>_NbX^$IwJ}FSos-A3AfsO?jI~81*^uisGR(; zz|pjMxZ5O0>0lWOkR}v$kSQ*}o*!EhZ1aXbbHEnj0=bkou?Eduu~S&(=jRFp&^lKq z4UhBO^R`3C{7EUD4OuHZVLH(+zdh)av0hV@O&EO>gQ04b-7R10me`mm&jYeH#OAe_ zD={ZgVwzplk<^SiWhDkAHDRP~RBmZgSlwA0uzutuPP-B^$2n_58{F-0vax3k`j8SQMO(g=%d`<;raiR&c8<1j|z1mdHdGKV*Yhh4Wgdy{8pK zg7kcQ6ChVAbvr;=lFaIKUHcF$M(}RDf>=TslXoPoeE2)-@_(&kw;D5S$_eRl4qs1* zkWL7Rk2pf3{Xltpox=BUOqM+JJxpn7Y*%*!Ba_k%Aa-WK6c>k7X2Dh6G+mW$D47Kd zD*>DGMMaeDVOK1a0K-yIzSDSf(Y|~SYiWw_VYvc!o)Ef{|3e-|)UwzIuV}ivxDQi* zVLo`L=!EvzRvFzL>I9>Zq^q1=({&=Hd9rJ0f^2S)=iOfvo_7HQCC|HZ6>UZ_cqyKF z^9}Z_CelKRk|pFEGWCD<+czf9j{H5+vF4U|))u5bpflzVEfzk_{`b$G!8bU{A)7Zfc&(<7gq zs71;GA8&mC6wiKo#m2E^S+bTv32SQXfHLCkh(ArYX>Bi`8WR_ zp5}C$JQLZ`IzBQ?MLKbDFjx25rg)Fv6{9!v^4+zpnaIp@(q z)Do7~Q7x_Y$@zlA{}O&EgJ~;9OUBa;BJ#OE=owGsC3rBbA|bLI@hWr`DJ_luBD#;) zhRw%fy5EL+dV((|??}FlyrX4)xTp5(KwmDoS*~)#FvNkt zk--ipt7vnOta>g?dXU}cTq*SK&!$gS^wIH6oxLjrlUdMsK`=_jEa5U;xiCJ7ZSHuO zI;Ki#myP+y?n!m7*^$1alM&FzK~exP#J?ASBNrWx^KPA!BsRYUYzs6$ua@SPfbBRR z=W^I6?Xsm~$&aeUd=5yC`NeQbke5v8ZL{+LVWh%8@AJ?5E8sBTJ%;o@8J(={0$(Zz z?I50XPyU6kL@|R+6OU+>@gCAEGfX~nCy{rKn)FnS{d#(1yHIXJ>F}%4G1Ol??Ix6g zY$FuD57QI~1NiXwRUj`hjPm)iWGI$a6iAaNONP-*9aV!k4p-b4Vl^REEirQQtcv30ju=@g4{)JO}EiJ-e)!Ds3#a+ta|>=F$D7FGo6T;NRuB6-RR9#daJ}m z^MP1p^oo}A>G6u8p<|9JLo+n1ey}76U1iV5{PS@+7nVkL$r(~!g}YjEhE$_wNHwlt zhRCKFdW@rAESI>LAtF*SrA6#b_l;>{b|J3CEV)rVt~N(lB$ocL;KOXSXywf^()-j5 z-v*{g2~1J3zBDZl$J$1;89L6ZOmF!FQMX!P1o8=@0w(Ck{REwiOA|x~^9e%U)j}RK znv{28nF&IEc1y@V@AJ?5m!6;vLWm9d64K<}-=CljgG-2-Yzgr!P0)F}dK>a3bY8ll zzl37!ZY&|2priQ&4NQ$vnVJntP0dlYR!q%Z>IJ4#P0he)&ojgz9wyVlnc+7Rlgk1& z8+Va)(oM`!UenUVP&0MRl_nPlarn%}R_2&v5Ma+12}WSaM@YU$bQy{< zujeu9n_$M303ov9lVEoKd!B=-h3q6W6Rl50>(4X!KSxxNJMuCUG7h-9h>m~fxsn%ZSLxw=Ma{t5$SnCSe%{cUV5JRh3JXE#KWL>9vE06B}xWWXr)X`EcX^^ zqy@T)#(D~)kzjA_q@IwG$Mq!G+$?cpmo#iRam6G-bW8ReaIO+G~W<3_>T+NB;K4uKv zLSl2hOy25OU5p223Z~I7sI|)~y+8+Zy`hk# zE=;WyOk%O2P$Q>c602lcS=KaY!6cmVSHUE@!}h?gvj<)vd*B7m9!SHzw5mWI)#RH5 zaBj54&yqp?=!<@6^)J5k|M|h07ruKA2Y}p^OlXPx^=r9V*=?m{OsK?lh~+b8R@bD9 z0?0V$=Ma4_`3dBgNe~(gD`*E+7?!K$!dg)1{AhZKoB3?6#S5FEoa1F|CQ3$uiR>;r z$j~`x(?xxVo*v4-eXU&K!9f#kTla0;cD6|YoGxMz3 zY*}$;v&B}MTZBxPNAWQd2Z@wr)@-(rNfA;>?@E%9)&gXhHLjOBi|tcsq!n5%X`%(= zwElW2OOL%4+s2Xw5QK##46BezBQrLcoM+~;npbm)ZH!xMElY1ObL+s375p>+^sv@OS#J|3) zS!3Jwb~&0Ua8VXGXEQkf5Cf``c4U^h7T7j0I>i3Gkaxf`;3Hi0nSWhcm* ze4*DTN0ND?@p@zB*gVDY`0KirHKjcb4JmpHpcPCtCQBoyL~Ja7&{lL<+W)at&6R z(eH-LUPq^X#W*{X9qK7*$s5wnWOTkxAi%jBQ%BFg{bOnMhU}zyj_$fdG-0E<8G|=oNe{JU=_8 zg!xu3CybCIJ@QTx|88lcugQn%d~A4{r3;jepnOMj!r*#YSJ-k0>PBRwDpjB-2k2#3^w-HOiKk;h4nD!UCb%c7$dg zH>AznKglJE#1Y<4-Zf2Q>%vjzoYe7-CGGdgGcO)+C^6?G(I$%^d94AKY%nx!7HHZm z(3Eu|H02>QwO<#x$41pKfTs5Ka=sR5+RO?xwU1Zuu|QLzg6HVmK8chA5x`}E-x~Udc?w>P+G7$LL|BsllXtA&E+yFpw1sRT zPVZ$4JIpD`0g7)YL*sa>Tpdle_=?FEEy!@o$rdfx8>XfK*#c)8_a8G@)FxI=Ex644 z?Tc2veQ^pGs;|g}3NW;PfxjifM!AYMeYf7h81wB5a!uj5mb|uL$b=5ebIoeBAfx=o zB%EBQZJlEKMnm95jsoZcH1F+x(=#Z4BVL}REb-m525msdx)zWkN1Y*>tC_w|$R@4vnm@>p{;TTahy(QD?c zJ2D_vbevexI-OWCnsy3$eOj@CP?HvMt6k7*Qd*+dEvgA`$IoFj9XX8WLtFH^?ddi4 z?alFRj02j~J|OKF*xXRC6xbHZb7f%rP@Z2G*a8$W$b+p;^g2G2r-6MkEC4}d=rSX8X7ejJz!^ah)*gOGR7V{e;zXZM|eIa(RwU3#>59q65BX|b4Bo2aDtKZDRN?=6)8gI zJ!?z^Z2nwG=ZtkTv2;RCPyP8^YPK0P6DB@q8~8cbM{JT?nu*JjkR2U+c937@TMcDG^g-^JTmcOY9`#4F5j&794b#J(b#>bAhBiQnmbvYNyPQa zg1ACvL4+qvTOmKJ#WHQZ_6(%0MkICWP1IvK+DgPVqp>ITgt|U1(aq@blP0fAsTB=T ztwOD6xbQ_S@QOj4dhC>Hh2xj7lA;cZ4QK*6dp@PP^05^t6Q)@P!^*_YA!WjHi5WRv zf?-Z>dY01FMPlv3($e@DC)R?b7fqu-y~R{%N3D>*%#SFiRuaR4jC<0Ggj5N*6cq_b zl|lAT#g4m4mF8MhzJ!{-s>`Ra4t9ZvKqsHhQP$eyQD{}88e=Lr*7$i`M!Ipwq8sKLbvbEX;V~1 z_T348L>E$RT_B5%p%;1=ohx$j(_|zkJdx96Q2nyVJSK)Zs%YW@qFyeFN-D+DAh@3q zQPgD2ij9T9Y-#|vsK*f_h!C1>?6#JcK*^QE?lTRrHRnXx?Fkn+8rKTXm@@iU2X!Z45P;23ooA;Jkzs9n+Nn|mkkX;9b z$l;-%om`G)0x**p`QmF=x!v0RCCBklbALD0)+$*=L|!_Zv0VHic2~R$}3=F8gp=#etbW)(}mo)(!H^i zu3=O|JK-A8zDd79=EBGZrC@J5#V{1?EwD&`5i-68NAt~DSN}$6S@))gA~y7YZ6u>D z)2LX&QGW?r&MO3+tdREDu1Bhgy@|I-HqcGcKD};=ZsYgkEYV1cSMu)}%N%$YNly7; z!mh4JhuWpdSRI@behv8}hEphR=QRY0n8?>rl(Vj#{Q82!|Q zsd#IHK!!Hm5BnXdx!RU#4`e%< zW!wja2$m}aMI&%=K*&g&pa@RI_!wmx9upS}a~T*75X_(&?-C#!OVXc%%JpG7eU z4s;%RVtImW)`Ztd={bEmvPOhjEPFge;~##KSXTVwjTgCGB;YK`54dk-2vSG zP%Vn@Xclf)iY_;cHB-9+1g)<;)y;ve@VTgW7`$ZD=cYJ*iJ@Z60 z${D_m#KQ=k-CK7k=*L=@XN&!?TX48Z!D5SaBk2~jLA@M7)I-ktJSO#hqjs75|54TD zs!A5PN`J4(2Jc?NwPn=Ga~JR`t_LT*WxA6Dv@ZUPa^z7B$}Exa;8nT z9?0(O^DW?%xw<1uKKr5iqyKXuBye5Ob-W)4W{C> ziZzSr?nvk$z%V$=tA=}@d(61UZ8VER%`SjJZ?9>HYxxj!35iMmffRS87h~+Ik-jrS z>9!wL`li8jql!_Cr7$D#JpsPDZk0rdOcXjexvPp|e`;^$+s<4s1pggUto3Viq{q zjWP#ouxkwJA_~FFxE>LgHtvGLqyS?A53opRlf$;gD%sb9TNonUQdFC{H?1CKVrv;k zz-yQ&>bJ6Sbq>{b;pCE@z!=F-)|^ki_YvbJuW-ay<7B_@3LWp z;#=@QO^GhX(2g7)2)Z{)aGQM4tsye0Gd%%Ky#>jmASsT5RQx-%Kns3RR?07*TQ?y9 zrtV_WEq(2Otk@kAxPO+{vIrr$4Do@YaxmrS9RMjM=ryeSj0JEOm}fT_S`=#f)sPja za!}V9zVPJ~)VRkWD>cL~TQ8)Qu#wXR#g?ti*gmH2|FmgrFcLNAgDV>Yu7BWPz7r-N z7wv?hwYXrwWUel=6IRtuShc(pHkcCAI2~c)@ounKD)>nCQ-*iK@Qow(aiCGO(GRmj z$k-!6r)oQ9NKi;MkfFdZHfh^5+d71yG45{qyXsz}-#vFFK;Au8+c&Oz^bE(Tyjyrb z_R-VLK4*36yNvjGL!TXoGKR{)bP4YVvI{Xeov4TK*-3YfR74%wuY#&--vH zf-Vc2+ zPU1ckoW#0+n~uTR8(ZyaRTffTZK(>%b0wt>(qQ>3wCb!pqd{M7FsOrTql@-6K2!iZ z$&)njIM_W%clFAe)yUW|Qx;^(Gg=a5ho)uHZsoMHsZBzV9T9CTS_pKGwNw!Xa_kI@ z&4n?y{sJhV+V$8mCrv>gGFQ`4-)fK@<9ELYxIFQjgGd(wu@%;FU+5kQ^OoQy4bTY# zRe&xW80xm`*9mnSv*SsR3A!i|*z@p|AU41I;3U}*eiOhjui5k5SxvPXnb+dsq;Ibc zMiAh{fF*8735CKhyp?@f%;)|MA+LaeT>_@f zy5cf|)37lAy($M_zDsP#hZRevrIq21k_j=CG`te(uZ(GUrv=oSG64xx?;|qar;Mks zHm^)8iFCi>0S8Rr5Lmv5!2^EfsA$_Hnza*s99ZD>Bra$|KQk7mVf#-TA=kYC*Gm3N zqp5fOZoqAecs2TvW+)U>3c%wDwYvi>g5(EKlV}MBg#RJcz<{_}u^**yFh#C+Frc8% zfP}e43b$O#1^v#?016bb49ewC1eD4OK!Lya8#Z1z2#Vuzob`>(E5t6G|FI&)6_HN}CNrOD7ZL*@MT}-lQ2Ts~U%`sb^$$jjl1$56D z0;J`&e>FCRBfoMhRixPlWEyo|NE0~ggi}7&+Er70)E!f(5O{)1Ly~(st;&Ll?5Q&i z+R5P74Gq+EIjojxSlS=H$qkP-FhUc(63$+1xHSt85M<5YLCnzFwS5e-q%!)RBpz1lAyasi zj9it?F^-G~bHADgy~0J55s(+;S~o)A90?rn{XvFR8B;yfVJcE?RN2+K=F@dphALga zWZMb-4r6Ulhb=C>yinJ+1+A>znj+7(!;2K=)f z&)gnS#|%f__AiBOa`sP0a=ast{f@l%5=0Sqa?TBdeuNqojx+*1-6NDL8Wk_BNbZ^^ zgC4pul{I8&Q2fps`)w^cciXl^M>zT4=t1d zMFHyt@CODL88h|`T4c51MOO3M=rwJlSHMf4ZnA*=Hae4!1;8XuEk5vCMnQX|dZY>w zHOW}y_1Ni_Y@_U5wgAbc8LuU`Dc}QBtkO%bt%;|1ZN2_9Ys*lJwe@F%$OS>nktZA!KC!HST>~!>OnYTHl>QUDPc$w zKa601ED?->fpH59b;_b)HHrm0(wN(A97mVk#+|!$Mn}w3(@;e&EkYm6-H=4N4lk1%W&V&i>oR>dABZYo}VG4?9xe;TkDUpn!a!6SET{!AFtFfz*%^Iu24o;j;6DgJE&E;nv zDw%EPq?L<<6qM({1AjR15Rw}^cX%%rI!PDw1-YmRpX`QUI+^sjF~!jboqYEeZ0FM< z9NZy46J$cSf8p*UHZwW~OS>olM>IJQNxO%|>*9fmTyL9jad&B_A-m=*bW^9m*%>{S zuoz~569Gq)?OuSH$#wc>cCCKj-2aWZ#%Z95%Q?&a*-Mx)7|H#Ef?V0Df+z(njILtReE1Z9hC$CJsD zj38=KVj5^LV2BAxjG4v_rUC5}9@vBHK(ygw7nz7-VxN#I+A`k3RUt@{x+W!=b~EPK z<0<(_Ylx4uhWJQJYQLxcoSqyY`!E6R(}^UvPR~bLFsr;K?ZsKCMSP@R;Y#>OQ4f3s zbXqwdK|*>0e57T3q*dl4qWvXa0Uv2G6mCXw_Ah^9aNr}Y<@pH44O^)13d8I{6 zbf*H1Su@Zq+yR4X0^>5CfKeJ?dOxhw48C%=KgJW_xVstD^f@yS1RLrF+jL0LC4yG%vY03w5UU>qbCos#Ww)newmUW`?WP)t-q)kKTkwLC-! z`v|hB`EB@q%al3U?-b^Yevv3IxJRUPwqdV4TAdxsa?Y}J0ey|M;hLkMG;ehBF zg=Ex5r!zC@Lxfo>QpZgYiO?ghs55dbS=cN`OBDvT)j4e3=~#k|@HI2AMF-oM*-FcR z2?SumF1Td1z?A8`QGcfClg>A6fJfQw=O%tiba9IVa}D^wa?@BC`@&3AVeG1RqZeaV z*4S|*-H#ntp4r%W`0$0w2hQMYECHX9B#jwJsdm9BZwqk2^2{)$76n01j%w!U<>$k9 z+hlD&59D%nE|b;E)kSU-A8crn13b>3PWGd$E{4 z#Q-*Mm|hw}iIhV_=*CWXH#BxR-Yp(GvzRSA!HWh^+~2fr+Ya(GN3&*gV@irOC0w=` zzZJKtT*P09fEyC_%WNzpGxX3&Z2PD@7JYPjB#f&trGZsHgiiN@FJ)X}jZ?okds@F+ zW*820gG-nbuI|NyxNco9;gT3V6OrRO_YISv^=Cs7=j%_oWG!`r;gAcjsp|K5%V5!c z1RN0+AMm)U?hnlL-BGN|`UV!uQZsF2ix_5Z$Rm1Ixtle^wwHQFJfEv!*R0~WSS5ze z!xX~islSwCo4A6!)JjW5MkF`WlGfaS#x&bsD%728rf&M3Qt9htsW_6Qp;{uVUn)bn zwV#L`*^V0wQkAm*vSD3*pniRD6T>SA2r9M@D0@X0iy^1$*{D(~wR){u7}E{& z4F@eE(Z1rhHpB!#Zhg?c+SKgq;~)OV6Yse1QB(@}Dm7_m3^88nKynT{kkDRs5&UkM zm=n8Yv3ASi(r%g89pE0n7_+~bTM`WG5kz-oYj^k9v7__Z2S5LT&nqHM_5r<=?b0q= zE&JRDKL2g9OUs8Cs{>n~X|-gRUVAFLw1$IK=8c+iKVFNKn)6ShTj=0^sBEtX?I;Fb~ z0U$}jxh(1ytRsfrn8Jn)5`)`d6;Ui1L=kTSCI>;lfv2r`Gtg2k=6d(FzX_|JnyWHp z3ir`=`$wWvlIM#Ft;lx5tw`ON&7V<14V(pi9sr{kt?!u|1d~mGK0|6oT?BnG0S9-% zyENjy^kG6i$g@8l4sR2A=L1%oSoomLZfN5t&&u+8BDqmhpFrK1eU`{=LhjjR_bgj> zE2Q#YIYX)ZN5cGgw6g`6{I=Ff<<7YXDJga#tR+T@uY^~XeT>)&mgC9vppTI$_}<4z z@~1h4%*V+ZXWN1vdk!_gxpW~GJAaC)2-hH>WVxh{L0T4M^Ll{Ym@ zO#hA1*Xe|2UP7=|b37ARadHQe$kL8z6Hl)r8s0(B8e@Y_PGUaOTn0)R#J&s!D&~%8 ze;wMXnZ8=ec9|KB40EMc+RB7%VUCy6nI1R^>9JNcfnA$Iv_{5QBx=ixVJMYxTI3fb zw?a~L?++7EMcj(p{zQI^eDcS{@>F8^1pPt^^L=$O`MVYTv@>YDMC644??^#vE;)Dr+0w~5Ay2o(EFIQ(3oB0E+=FMEL+89v5%0r@ zXs7(lctfZ-?PJ*kw^k$g^xA5|whbRMcWQ;QGD9#K*>SQd)wXm)ArG30FNS>v7ZZhA zO06x&UD)0QP24A2Dy%fjR7`JSNhiQ-}IqF=iCuxiyRNOaQ3AMtu(KJUmnDKAykg~ zTnxCZfACtfgMt6}2M_sfB4k!wh^A}xsv)z-l`ff0(YHYu!2fF)cja8MKjuPU+oc~G zsbcWBBN~Y7uJ8kj>&}1{aT8m-&bvS_7K^-vm}6JHuxBMxCj+b{JoUK0>V?zf5`=2F zP9ZAif-;qGlCvK$K#pa|4(vYPWRe24;9}>)u{T!`j{R{(P-MX>FaREKNYCXem>bMQ zSIQ$0X2V3fQ&S-9lj++3IAzyN+WvaG^FL109f{uDL8@NK{d;8KX0Up39oVurgAqo+ z-Lu1tjVy6aEo59qbWUxgd`@jJMUIBp!kYbaYUYBOr}%@?+TXOpVT5_-%HZtFxcwN} zvAA&gD=7q0RtW0tdMFZ^J%~;R9Q_dQiVn-y86E^Q%S#g$Hh<;gtfGV-MrPz)q2Z4B z*C_(I6CQmun;Yvw({))4e?@~w`tf<~)|FcMvKTBf7N6II;F^!mTPw%swJr|E=OxmF z21n5{6uf6Ei>NwYwUoS7Bqkmw0M!PcxRDR;OaMk?>oc+sk2Kvv58sGn@ zO%;T5FQVEnI~w_AIeAoj0#EZ#x8RX7I54AbU^?EyX(EeWtiwO<*)KC1oK1+YiJ zWye`gy?qSi72}^UFZsRD>=d?Y9|ec(c#MUs*VKTziZ2S%@)s0SY)9cSYkV>~8sdt| z^KCHaU0IOygorL#JlTTz>YHcE7M%3rAn>tM48g%|ef5>^=1>*ovSStwr2P{OxYh6- zW$ZCHPr*L3!l08gE9vm4O)x9eW>e)Mecq@u^|waRmpeJ;nH4lq|4A^*>jFq;r3pQ& zs*PZ?N5nD936hbx9BY%8IeRJXRM03a3t+^uz}DR0O(PF`TSK6PyJ7s@X z+>eUuhxTAj(T~4dNk1y|gPt@Je_=_U;2rn<_Fp&{)(?1yXNvv+>! zL+|_IcTWY$xEm}D=5hEAM}Lw-J&wmsB7TI~Y)hsw2|#U$VXJ&*Cb^Um^O(y>W!9t|w647cTNJBU?xRxFYVF^w*#1w15+@aI<1**lY$t5+5UGxen&2vTJJz#1 zL~3?j$*tP#9zH~hMNI@iB`M%s{#o|Wxda35&>_;QKi^gzINw%Xe7>!^^!YYz)=z>v zc|HF2Cb)k$cE{W*c?bZGd760#BwxT#?4l8{hvv2eSqb%JB)z&MJ*38dM1sMTnAUCA zvj~Z!gEK|Su%yR;A(y1iWKl_e7tI8{9n)`)0Vv8~>qaA7eOm45Jk_cRDONWoap@uusnO53&J`Lu? zhuFk?HrW$DKd8B4P0SV7bUDRUHk%hj&br8~KEWfcx$)7QT^E@ZHLqo}BA8khT4{g&@|68q zaX*@_AI(#9u)kD4Sc;N+Sd&ZlgP46Cofp{1^xz6EM+%PHzsxJ_k4D9GEx6ahdXU>9 zO4F5J#k%Zlac#Ue>MhpWFXu!=*5A8R-^lJ{y5sg@X71V9Pkr{Ihp@x=OW`0a1UCF_ zb zk)6e3#S7lzUR%NkMXn?~!+WaxG;wG!^7ZX6*DC(g{pC6||L)dd4)7H>1D<65>o&Tj zibM}=^6JC$Pj)x|kC*2E%b)(t@4$-s^IvEFKjP=#SHbxhH~$DPOU{3L#q-a07;pUHktflmy!D zBSCur3EHyf3JLy`;*{q|aMW8JQ4?F6q9a&DgbcHK66isV(nxQ*;b9PZqJo9UGNFwo_gS@*Y2hR(L{G9uVZt040aY zm#a`GhyvD_n!HmM6y{EC2D(Z&pC=c~x;HW~Pa{uko;Lbv@;xf*@>7K?yq_xcc6b*6 zZ1j_~MNcUE{eSq@5C7WRFY$9^JWKlIFNT`xqP)6e1d^M;B>7@~%VuS&;Ia!|>58OQ zy<)Z0`qL}H`y`F(75j;f_UZNS^g3a$3wp)gN2=Y}aS^X zExbaj9B6ZpBjvSK-$+OCXmMPN%Pn*8e;G}REJvN8=l7o?!XN|y!D^Y;+;HvH;e!SS zHoUS|U*o198SYvZetqiq15#|Efdz{En^P0G1W4kkiR>aLO4LNe!mLZ4nt&l z3^7NdCM|3p@US6j;+%9UsV!esWXnKwpjJ?m){3Y}-B^%O6B@!q(ps_>#yF=YP^kfG zqJDWPxBzE~eog(AHxw+}G020bCPN)7lLEILcp7T*SB0TK)I_$jauq|=1cu+5vb(O# zd1G+l0-pBi*gm}7qLngNf%s4qSmApyBkD$i=?F|GB2=ECk6U06_xq9Da3=c z5HBd=x^yJ(((GqG|DIp|!jB#rmN0(q%#|?S(WeJznuPJrL3)6mm24&?WpOxbBQ2RWh+%D)ZyQBGh#iMQwRP@ytv+4HiIWF4N0^5__W+(IcaW@(W$ zvT+>^LQ^4HznxN+>F4p$sj;aIeeylj3;o(mmqEd?0cGF4Qp9^O=v|8Twe8 z){5P+PBI4u5WcC09LX_4M*#%$Z+Ya=LCuU6L#bUZMS+r$AEP zk<)JY{iFCcpvd-%Nd-CH__nVGTNGTIYS{3jHd}($w8aGNOmP#?$Q{^F!#CaD8&@Fl zHU0b1?+Md2>A1y+A3v4<)6_#B_>X`5wsuz@P}Tqw{^UKN+DtwDDea4uQik`%rgF!S z*|4h}%~5ke8e{584oK~bIIA|`fFtbI1>q}jK|A4k<>zK;<3X_d$&-=#p-Z=XjN3E@WLJhXy~E*~wP&Qz64pgbZHe zW6B>5>D-#h=s}blvs>$D_Kw!rK@;KF zF@e!@sgL%AQHwEm%C4MaL%Qa|_^$A(?06ggyGBkU4rE|=Khtq#IU2rteGaw6c<{-? zeT<&!)_~slRQ$ue)!xECJ3Aj-la5cl@JC4H`CUg2t$xm}-^)-R zdbR#swLY8UBl5s;_gHX`*%3;NQ>JyO*LXuODO%b3>TFKm`YH3ltFq%HnIF_K`h5mq z4>L5HMpv;4#|y{>rwv3uNu62Ldy2FUv1!KRRaAhFwfZj~G5uT0YcWc`2?P>a+8CT6 zD`*&=@n?2Lk00)i53Fbp&zM~Ngd?kD2+9A;UHleP7_m7=Va&y^^F&8iusRph|MZ_K&)4G-Ko&+NdRbGUoXz`#KkFn?+*0U{vhQAi(DWsPz1XrUCqT6S_I`E&#w+4ss3)6!WO?X0a(+?GRwF=K*?=rNSc z*&5}$LI|K<6$y$|mldaq{i0@TWZrdz&7euy6hm5Q(H4|$?K(y0#Db^*v`z$Ti}gVT z(^c}4fQ)U57DTw!igwga*pE%oqk2NxwmWK0Ll~xVx-IfAvaU^c_o28L#tLz9%zU0@ zQkSkMbU8%ZAoe$c;JjsB@mxhinZK%~N&jn9B;)?izxnsR_}yyC=rS!QZ#0H+ad15J z5}%lY_Y#DUEWl+X?pX)vi&1^opcA_6qXw^E4EhR<8AiBoH18dT=Pc#GIrv#hIpmJ* zDaYr6f^ygfwo#6a;H!4HKvdSsl{`@QARNa=3&IgQBHbq(QV3T_IFz+dIIuY9gacp- z!f_1$-=~6ba1WxyK>DBnpfYATv9V7#NFO8{TUSap=txd006l-DzNd+5&|aBpFmj%1 zAbEvnX~rNEA4|_l8{i~7@0HWKA~GYGiv{n?bn@eriq|4(qaglXlwbYKNl3ha#q^7ueeyL~P%jR? z3w6wL2?_nMd1IH-a+D^2! zUHCy(QRzz2FsS1=B5!1f(Q;ugRS{(sVerZ{D)0E5dh;s5Ze+fXveY%%$0}FA&X=wq z?xf?%Xb(Ha71kog4jC>Qx9fx)8Mcr?`}kNv1UsgYal1g#KbBD}z#{N)%{l#YUXbzguv|2hjA897 zmty=4^tAH^U5VJhmhxZO-RI9W>+j&lqrt3>vUR53`{wV`6q4IK)iA->lt`4)o4K%D z%SOE4>w&uB?TNb8ziKN$#J6!<^|3l#Lw5=GGQjZWl^&2S7)&qwTH^ z?2Q?lz-XzazgH8^s~sd8090@|K(Uc63!1U5(E=VUY5rWEhlf4X!(EJqf@jp9%LCCi zGBM6dv!tB{qpD#GD3&a9*dUQhE5@GwVS~Yx#m7puOfVU`gQni7s?oJ$rOdH>#Koh= zIp*l}_VIK~ybI%qnAW%!S;{ZXy~_yuqIg^KHy2L4awKP8O{chz!{5}X>Fqk{fQIf* zAR+!gz{}oLgs@&Jq$Nl}I`wVs`WeeQ= zEf==yB^7-!aC%{Yds4-C_C;+ClP|=g8TY z{bC>&@0(~Q_){>9Ld&o3mgHxKd!uid zXPH*P7M*R`%&`{)?M=}>{DyeUfB@)dwd8$yK)l<)4?NM9xHI{-r#B$pu_YNeO9alw zbtTePIgy0&(n}rMICWo6D0mNajs6`3a}W2h^5$aUS8ya$gQ4Su--*3>$ z-WMp~=o@temr>`g-q_YS)~e#JUQQNr@1aF(L$uUELn*i1YRWppXA|1@ZUrgRPP_0B z7fotXWcIw?n5(r#u~-JDxz{-NiTm)^duHF^S?usEc6esL_5mFt%?txURGT>Y&&!|W zzwPOb3@ZFWjx<^&keC~V29;pRLP!}eT^FTCe$^GT1-@BUySW~IXxnj*F_vThcwT|{*_F| z;c7zpibr|f0B;_6YMS-T)g1e7*(KLkP~HfSPPy?@ypDkVhVoE&hw|>6H!cskvp*2` z!=d783Pm6s>TSaPVvV`AK(wL3@Thg{g>;~Q$9K*N|L?PR7O);9I()r%7TCqlb=_x3 zZK_h@jT2M0fO$MIYyEJQ3YYU|B1oZ@hlB-r$JHf_kg!O_&9F(5ldzt&fiVXuv5*K3^*c z3wB}z#62e5V^XMZ=#QEON<*lLmZA8jX4Y$FAn|PY%8{7t7&|-S(xX@`D>GocJo!d- zOw=B!>9?Zvs)b9P3Hm^6(-5~oET7T@$(ADc5n^%zg%Xg)w9_%##S{pXlLFq}CiK=) zT8b5sO{N5?yT|U%WONag7N*YxQcYAuEeJ};wkmDhTT2`I;gc!25tzDUkWffv#5Tx_ zD200Pg3D7<#uiiU7HZHaYgZzaXBgO_v*;}Iv|^_~WCtK}XIk4Fr##qEWjsO1jRGq{ zU=e2>q1R){d%`pk8D}FPOk45}VI%Fb;Bp@9L|wsy&l|PJ5oV7B)B1I}!)|$a@N0|v zB_|JlUFv?Z+eAC=6tzoX56Q;g{UVMV-ybjr>{1XnQ;@^097$IDfOu3wi=WF;&pQ&y zz~CQ~qn=ox)3;R48Vi>+x!Ig2Gd&Oun-eQ(SC%Uj`o-tVy*>ePAwjm5QyE9+bEUv% zKaDMQu_17<_FOOWut>QXya0GG`_Qd(C&@l|?VORN_Mb;YQ7-5Qs_L#@EXrXtr@<1V zIW`V=kw(-C(9G$OBCHi`|34Q&0mvlH&(P5+zevjk(aE&+1eK#KwzGrT|6&vB<)Esf zbTzX0Ajf`8K#lkv<)!Q{Zbe|WJsWp%5o)W!Ok1{Nt+jwS>_XD8sLezR(eK%K^G(!k zOtNWc^MxL(%Nl8pVstTn`Fi?Chim#}GC%4q;_Z3(YLbTtcVuqt;>LCh?<|HQ*2@|%Smu{-6KMxIqm(@5jW za-*a@f!u7FK7rin6UvQPv_#!TZX8?q4}G@q(rjK=x`-XPLVaSe1Wzc226nJi8-r9k zH>igeFL()%2D5J{YKI-T+E2+7itMlhmwhRoaMo^h#@ekuc&6B`?mcU_vdcEnCl%jY zTs#@MDx0f887z9_>U?XFO9aun6t8W?cB>D3!|YbVFC-^V_#|PSwOcJ|xBAeTZ@0>W z*1$#1+O1fGXXag-XYE!}45eS6wOg6->#W^M7Cz)zm{8enbykU%>U>s-M)5jhZL4QB zr!!V_`qeW;cdvZM|GqO`bIRifpH-X^yd2IdPK04U zyWxL!!~fa3;eS?fI;%LH=}sy4R$@8QR=gwaGwLc`kpokx=+fK;_6)g7KWNv4SCZe* zIVLvpH|fF|Jaq6r_+)kai`3SPB|#V1Vc#MY!&O#_ZI`7{K68Z1UxzXQ5q5W&sCNp-2dE34kBI4#yW zITrE%W-O=8Mpm7{;SXPLeD&->AOksIH7!5qP4IEokvHc>uR41=t73SC8)H^IcyG6r zUDRz*oew75l0$K;a46=$wet++a5S#)3|Ws5wztw<-K7o)@-W2LsZK>pR{}(-9o+WL zq4cofJ%bx^MOI7*jSi{a6L4_25lUBW8QYhAvN=R?yB3QOB{oFC)&E{Y-X$tw7(f*2=_5+)5hWI)G#sKRWU)sSoi9@WL7tbo zhmEHBxNV_(8+A&pge#oLGhE55ZLAnqTG_mr-rJw9#%<4%9jZWQ6}8xfm{mL>rd*gw zpkF(EtLVNAn&J$l<93AA-G?@=W2=N^k>kD`XLBc9!vn&wXXk@ReH;p5PW&#=M~CP5 z?eRwJ3!22VvZ;=jVSz17tj89udUxlCBQV@L;t7oCfFm&G?I%cy0s#`*8_}(Ct|rC= zF*x}@i=56W3`2FMH#XfnM`Ym~%{E8&ZpGD@$1T0~dc1^*ayXH$xj0DellxFz&*aL> zS2$Q*j}zZH!X_3lwOT;L5rwR#)<(+RUh8pb97%pV;%*xeFBdY1o{MUVXyzsw`S`z{-TF zmFZa7QbOfz!Fv)_7r$>nwkFlGO2ydcty@C#;_KeAy0peIg8~dSJ{!iLKG%v?grX^O zmU&8nT1skJix>b;`KOFZ+n&GcIaVxSZc0#U5o@cIRu{MWvi&(ay*EwEVLP(p}l-aG_ z%P1Z6?emKpaUfeQG9!tVgErV?X+)K-$E5Wl>72q<@2K5=t`el2}wGu-}!vs>+}&mDf92B0nwCD+3QHgBnSuFS*~?GMM7BXL1AOx#`CXEpzx9<*e#NBcCw1XXIuoC+ zSS|hXC%^I*CqD7%7IN{a!$7ph)8;A3%$i%L#!7TEti8+>v9t)=3oSaO1ToxUA0yF_ zam&QysJM-2RHO8sq-rM3z1TF>7_@4Rs&;6gv<%)ulu1RzrAez$;!rZt>Xq2M=(Uev zSL8O)r`p}}96K>3sWqz-jpteWNFN<|HLZPAx|OuHfd?hEl2Kpc;XK9@1r097W5I=zf(uk->cWBxwuF*_l`pI`3*A=UuVcVvdF;kH=QV^%Sy7E< zc&B`R11>Mk@V3(DHL~*3Xxdj$8vp1Ol-{v!>4E|GZ^HOj+)fj2QwSRFG=3y0{o z=`0Mj5`u(uWypSSdfIdqmo3R2SXwL7GyAJ7yA2LiB&KWO`K0m;HFc#`i6Ax?I%4J- ztWtTdW!7PtC0u5#IoqeIF+IV|7jHup1y0 zZ zfHi1*UdXy)ZeH$?2@KzP;)y>y=G5R#>m97Op*)_3G?t40j}6r3oqE4mD@i ztG8njO=2K9bVhzwcR-pHFJMg;J8mlNFcGy(4l4~N1FvU+Dw8bW|Mjt@d&@yn`n~{vS z>^u(U6F`{T)DupVjZTYZ^RV$r(q)b+U?Eb}mJgt4#g@dMxJiB|BanmTnSp?TDQ3)- z_1ggShl8yKI)_%k8#*$!a#;V21xwoq~K*VDfmaoFHFYGh$S-_zo#Yz|Lu2eQc!3&Lz%%+*hol%8>yH? zcf2_%C{_06q@ef1-<%YDb5c+nU%XC}f^SCd-Y}87r9b$Ozh~y-n~^)_Ti%S^eK#U^ ze;t-WatJ!7P~(OYU&Y09kq`MUK7h|<8OJ7cj%k=g-yfmZeSp*7XW}|NTV|HUd_+8k z{C8TLGq=$qH=Vmg@$zZd&Rya*ir~5^4=pKwfl$fP+28uYm;ULhA)`ID69v0RFtzY+ zRtC3A3T~GQ!EFl5lZ!tauAXzwVujZ6^M)+50F!x=3J_gn>DMA;X)$H1rCYK?89o7fm!U&LAQU`zSImXZAvoc^~?Iy(0638dgN+EwqQju5JX2W0-YA%8V?YgrvXhIHY+d?F##? zKmMh6XlDAGeEaR8AvQBxR;Zr-i*Nq%7EP^aiVOlW0hV+X2)M(hR?a~{=B?5lOs3R5 ztvb_l)UPm(lJ_)y>LNQ#rfEw;Vl||!5F{c$#7G?}#VqV(21N?3XjB;414GMA z3|tgiS9RqKSsiv*(>87pr}P26dVX+9nJWbxhzTVGt4Q|agJi#u(vn3?z8P=P7o~xb zsHB8S71HD4Y@A`*_JR!A@Vaf;2nq^PdsBgL#c%k7g54IAa$ho42?jE=sS{|(VRQMu zb>?#6|87vk2l2Vnp`)Y=xnx1k&W6#7h5}*)Y;^@WBW9GmSgogz==W6TH&Z_nvWBHu zO|!Y^8ihVcz{aDt&Knk45;m1tK$u>g(N8}v>ok(pq@bTwNEL+&6-mx3d{S`anS!bl zI;9lrcY#pu@iPpA*xpb-wg9@&K+x> zbI*G?Tk)@a^Li7*wBH2V0s}#}?jHN<=Q^)m;GHZhCU4GV8d)PzCo6{EiqK_>GA}LQ z)B?}Q1UtGl{*%%hQ`xObu*x(vy?P}|ddDj&z4H~7zV#KAUJhPSaWub*$40GKSV zW^(?!Y6AT0=zOxqvo^c8=jP;!;jBrs^<<5I&xzBuudb3Cd1)-sb2PM4GWnhKYz>ON zVA+5kvchQ%Jj=yj-Uy@gq8jPU*eXZr9Ph-R?IIbaFj=O|{8i=?Nhg{4R9$I4F(->Y zG4sh4s^#XBGT||wIL;`kVm@V=Db9S-1SwX5n=9?uznaIA`DD2?n7Ya!cG*o-* zpq!acWF)@E=2I;pfjgDAZYYe#Mz1`!JsbVvzyu8tBga~CBp z`v&V#_6-SGHu=Z^lS##vKhDyTF^E>h()r2-EFGq&GE1kn%F?N=vUDuT#alWx=4`Qf z*RynLMN5atzjZ8~+FDDeCS$2kVZqX=X}-8%>8Q?gS~>z6BhychE?^BtqB`Ht1RrCr`*$zml$_}%q6 z2HR@Z*WOMw3>=NRDvr9_!kSl-ZaD$GkaQoE|Gw9$2dRi2{(6;Y5wmiGj~@Pd*>+#~ zuxJ9MpJ2{;pU>_ha*)C4a_6r4OJ?g%!^N$xFvnJ2S9(n8G}o0LQOxCrU=MP+FXik| z3FT~^mAe54kOpfSsW0i{1mjyu&+2FZE~$8lOFNty-z(d+-<~~oOKDcxQU9C8DYviO z3es@VGH1BmMDD{A;bEn(SQ3C8WUVy8K0Bxv0b9?jFTyZ;OX;*4hJMTb`%C`&1y$Oe z^iI+g$x$`cUCZbd@y?exAk`M)>V8fyUy~N)z7X<$kEao^i!_c#czFc+UNHDh8m=IE zhPDj8R8Js;_)7@QGu{m?&vF3nCjeFGTjKhpz?M8&h2_&cOLzo1;=E=^(VhKJ1)rc$ z&DC|1OOS{Z%focG5SgErdwzRmHr|4_CYhfn$Xiwn@oGZ7O z(aAtF%ZyYND8ot3pU}bO)`VUDdB^ExghARC)&Uw0igUJ?7Y`*R8|xOaRao91wdIpw z#17u?&0ozeMeTEJFPfzGFBVM2{Eed7r*Ua7nV0QfawpOmgnS@248kn<8c3elJ?CG8 z8G&mr#lISIsv|+|P-`bNbZRZ1djB3!$>m4C^080<<|hB+L;vj8%Gu?A$S;59b07QS zCr&s0gAHfx*@n<}ULCUBr(;3okym;Spj#asm*NVosI2VInaTs^^ zQ+BEa_nHKL-O^eX$GFY;9)XjnaLzer zE(Fdi!Z!fMzxCl1V|h}fHM>#qsM(cwFkLl` zQ0gpCVh@PU9V``dY?VfNvg9W0bey}(ux|XB(y4G-xM53jS}X}}=$du3$|mj+ba3Z3 zmz}GmL=+>^N!f+W5J=UL(J7bGr9tsaJ`kd)gqq|^p<&s9JWuq2x~vlJZTx$A*(!@f zDx_1bI+u;b(@xoCTOIsYH_kJ{U;)y&MM0Ab2-AECNx7A+mK9v&)fN^ntr$MpJSAG% z#%BI|-8oJj5J^Gr?sUr1bq?s1az$^A$TdXOYWIK(i(*QeBqj${leeXuAMRzqo?rNF0^}4ehD~I*9>St#ncj=`+SZ5+v7`W((+zbgn{axIc z#@zl;O!xY1OrzDdJ75VG3Y3-QTV@RxhOn)nX7Y-#zzDM|U=5LCu?}Wh6@JpB7{;-7 zxYtprUf^n;))>y6nyVwl6gHxE&g<5)3m96_AKvy~@JqI-4ND0&ueYfU+}auWtVGpt zV&R8IzRyA}yTzbzU}xm7x2ervF!C*bRZ%CPM>JyhYCzl&5TY~3L!Kv0Z8NQFkNf;= z#O@i9-#tS{RfE&f?6^-m{g-jZ`PRGBr3&&+1H;Y(&<{7f#pX8d)q>W~BR?pWpZjT3 zV{*W>u92xoKA4IW_LRN;e6uR+K{JmCE3LC;uFM^UNFTCo9*Vn1AR<@p9zl3cGLkRb zHbT#{1?zH}jdnbwLCH2YKF|VddbJtpLE%@qpM=7C)EEEZn>ht=9isB$SNpx*6ACbn z*v&J)lt{+>=Sw#DPI!qXipdjHx~b*Hw~!2WV1|qVsmRP2z--$1`fj*%M7976Z&um@ zf(uF|!j3%S%<;`^fj7`OtjjW6I>}eatB&QP#Xs_iZ3-T=OO4anjvD7-&3a z2k~pnY=8AV!fbB~peI5dy5^pHMmd6fD=3MXSje3d2W&Lgy>XG|qCe?9{@i()O{~@o z*_Pn{>~LD(!TkRtr!Ar2-%w)hH6Cd%ztKk8Yux|ue2@44@4m}MTM zZ&lP+u1UuoE*0G2)#2c0H;`{%E_hZ%Mim3v#g;3(-igJ1mIymPZ0iQavMrun+134i z#jmdq0y4}$e*B=OV^fmsnOjVMgTPKm*qpaW|JoJ5r#E7&Hy)g3-dLW}!>%}sC^RV^ zKELbMkLFn0;sUMrui#~|%SNw)Mx>EF z!vrMZG>gaCRuJ+PIFXwGkesg`yHYG&scV72AQf9Db`#C}Z=_XOPsx5@4%GFO&oU?k zc6w3XqUTCX!F zE}zb5()d!ka`H0j3X|TK(v?$}Pgne;{iXC~`SR(FOFFoe&YZq{Iz!ULrS#;?<SjIeYnZMoBA|(v>CBCoU8Hk|*6 z-db__NKfRp%XohE7=WH3kE?81NjBleQr|QG@k9UlQ@`=e2MKekS?1zp^C(w|2=!js zFp8WOBh)fHuxx(f{eu9E^`r~}>h`b8eBydXw0BkVf)W{5Cok9(rcYk5iO9#YWVcQPo_!F~ZJ28Cdup@d56VFuyW^GpTSxIHJ`Wa>IFD76$52;zn&RqYg5C7gT z{ZFeFZQE90A|@M>)85J*O3BAxxrn<<#O=z6Ys~GYEKi*`q8;q|8yCvnwMDV^%OZ$< zA&9^2A+}`E%L3xxz5tH@+C%)p6>k_MzvMyY>kYyd|K$w_@n5~+ApXy9IEY_-!$JI) zmmS343cm}>GEJ+S>7mS1jIBbJmh!LdmeZ{H5~NF6#zS(KHp-6*#|q{7=9TpN73*{= z7>+VAusbkz08+{yd&`#TB)Velq1_&_l!B&Z3&=9jJTp&Oa_){2VdV=c%+79973|=i z$R=F7(1hG|7Mc)yl8F<_O7bZ$wjd>6XkvNo4z`Nc)#Q82Tiq;hQI7jE)}$cuK&*yf zk4vM_(hDWZt8_R}BOIoKTki19vg7PMev<+2lALSFXWZTF(@yhb_+RTUDS@N>loHBz zG^1UG0As+9bpwon0*s}V0mhPr-AZc%j4T(h0Ar~bVAL{#^9C3LS$tUT=L|4f{Ewtl zVsmLI)GIs0LXPiYYjz-4oYbO+z8lsB8HYj8lDt-|eO>Y3@lLdTn<*J+L2Go`Szs)JQVwwT55 zWl`6!CEZ>KQRA2C9Hxs^)%Zx%jI4ZCZC;+;@s%fBR(UI7 z(B_X>PnkbXX#mqw26`0#R(D~`krR>MpdYrW5lrK&tYz75Gk42KKBf6{BMz|tE~f)v z4YRIS#%wFJLxXgEBnbzZN;b5!#7MNOrl&C1Xwq*-M+^-bf+cFSAP^f%fJSaZL~DWr zTtBNkXssKj8COH&ry}x!Wr`a(FUpdZNo}Xa@E%avy%GS?sy1e$47?rL~T0{#64fR%^P9A>!R{4(MxRbC;qbEjay3JR{wc*^UcwcP7~mA+s)B4c6mdP z+!j150%;!$eK{Z^*QleYAZlsl8p+*&p&4koA0k>c{ay0|9My>1o(kRS=g_#In*KlR zE?~Zj_5Cr2f)Bc{C*9X9U*T=RlF&ubXZ`oD`|p$b=J_Z1*1CEYu7A`&+5uLDP1=1i zbg)7Ow>ZalBts;1uziFf)b~vY<;7=1@&~Ys?Kud|Fbk^XVyQ_mdP{V@+7eP-0ly^u z*8GNd$^gcf@LMe0ncqkb+7Sx(@LW{`x8=!05dX`ezM4L3q^FpH8|L(PU>b}nlJ5y; zF#aqsA_&yF9(wq+I?&zl@NtBNzv1EAmf!I3B|O(^aUq0L6`p0{#i5w&3&$f2AIGT1 zn2z28mPCgL9tn*{Tqli3c0@bQ|Ef`D?b|yLBjR|iGtktB=;0SEa^KRT%_Wyuu#_1J zN(w}-Jku$7@wSl;9dN6bxM0OozOS9)_8hDdmhR94$V1O0bQH~}L0izI5-kS&!F0iP z(-S0)Wq?5b6vGvnz)RjYHKsa$haH92_W0S*BMf#vFS1`W7Fk=ti*|TfH9ZlTungk= ztC*fdx{Xa;7;Q9jKwnsCh}bu==T(;G3=p9ur)^lPCaH(2vyccLsCLst-#DR14G29J zaKSGuiVhk-6LBUAKWtGwGYNrE62yn-P$wYE1Kq%&<#3_6VB2oegZQ}(d5K$YVnM7fU6>$`Z7gZmC0O8Y zoqDE*X&}*dr2Ig6B6G}I@c?m?K#Cn-C^>8tS9O7Qcc}7$*f5Cy?@HL0ul!`?2)n3o zTO*!yAfYu#3S3|xx z=>h#oZ&N29#k7_5^Ko}?CFxffqd#FY6)sw_ZRVJC8}?jqiVAFZBNnF66+WoDQDgo871^fX=xqc9AK&9zpBAW5MtD4mtJ58JG?Ny^rVyDzP9yHhwxv z8UW%&k6t&qqur%MZu%~QxB5j-9YSh|28*T_jO}$MBQWU=(U+fPcD-SsHj-YoYG0yc zzs7`h@0t#rgWh>lK1kKec(Db0dRg?!NV=Uh) z(%KZ7G)`ywJN{Ty$Y(`itn_if8KOM%alD<(5m8C#ww0AJocTG1U+nUgVHQ86U_`M#`JQe0N3M2H7lZ?Rc^R}G`uR@ zfOu>rha1(E;U;}{qrFD6KZ_ouK2_qHav0$CM!}V{5(NaA_OM;=yr)NvU@05~3w&#$ z0&K;zukC{K}><4w+ob=95oCIZXs4F z@oCH#cX;4uLRr4L9i*SJyXDw9;!)$DMaXvKA$-U)d556qogs)#|Bz*i=^tU_L_FCo zD#i^2jNw<-RpUeyf3_0Vi$)EMT29zoO?c>Wj4x~3*b_l2!u2$1quDLSCns8XMFqQB zo7##E{b4yOJ&rUsi$QDN;KL(#wIu$e^oYqB?4q7#cZ9gIJ;_QM4AhcFhgvb)oKYgF zKIBvu<`NH%v-8(v6C}i~8p$=1blpisMoqUBexR38;t-kWJYduz&}z(K-y->;f^WBS z>FsKd$-G^LexY4jEkP6Y%yEyw;Pzc}(GkO}LyyqigG#gtO#A6&{)s z6PQ|dWu%iqld{7ibfIA7Rbmkw(wE5hN1=u$=Umb-P!=2Ry3~fves#pV z4-^y{Hde=#v9STCrLZ8fL!#(&Wx{sC;ClZ+V+no*A5mX9AmK|kzlj#VJ*?w$5G?U7 z0fLBwH|cJZQ3%#6CtaAg)9VF zK@&`h8YVPh1ogzwC^ZLEaIGwNeU&akD)sv^s|A+ZlS%W$4l$5NX?1WrC%>|9Ux^3! zABpgbIbp{G%8E-atBw3mlN|fbVAFMhm*)0A%WEj zt*C9ps46?9tVl0)b094eDro#dq@!uU(BHDC1m{`j!UpM==qA$L^%oZoG<+#-m72Za zoC?j*4%27p09@dJcNWG7W|g$+p8^t<;t|`I=T1d>S41| zIFRBV8>V0qwDC$WhBHXyU}SciRQYZdp>rVAy-2{%LN^4c;Z)pd_>aGP2k~kgTGV49 zF|p%1@s^3@$R2m^J4&iO^n{vIeZ5Il^}#eDK4*}`Gz~Ke-KINs54PkO@yi`CpM>x_ zi-A@$WxFPuFBY1k+e(=RdEc^3z6kkdcxABDb2(54~ z3^C(J2T)p;1)SXwIcCwGEc597rBw{qSWqHIp}(DlB24128x5aHvrO7 z0aBKNEy$V@q>wQz_)#skqGHP zO(LZ)Q(%f9eStxs_?xG`NjJ$3d6{nXI&Tu9t5vXO+*C6uZt|LVkVAN@r1(za%ZFxv2&Rlns?*xzefdDDtbpU>7r8b6Ufq(ay9Lad?mpJplbHT!cpsHhXv+ zq%T&*%?cj`X>_CoI6eI1i*7Xj#|Wd8iJOv4p}>!w9)7g&(Dc$(&q_Y6|0 zN`-XPgh7cCb-!34sh6O1rBIaka9$MBWOZZms|ubrW8oo?VO~i&?U_L9fGGr8O>r%UN3fs$b9nTaH$I`P;}egm0v_#=$D`rSvb#?UWp$y7U;hMakIEtAeEa zy9PXIGp5bytMXQlc*@?k%J~5OZZK`-QD-P!h|%0Yk|faha#k3iTKkTBlMGbrkd^UW z=m6qzO3(mewiYedo@ z){a%sBekOV3x}Tfn7dB(It$&h?_y_$h^blxr~~AUx@_ch-IP;I4ah=^uIp7=6#>la z1SNXcDw9jg+Xe*yLs+$ARIJe#!{x)UaFEm-HAPg%z77@4o>JaDWz%#FM-4w3mRvEG zs3#mWA5eMS!66}La1@|O)Nc<*ouUOO#LG4t4Bljbu7Cton)Ka0$oR^er=n(E?bqET zgBP3f;ahM9VP{A69@ho;o{dB^k1ITn8Xt`y8S!cHL1@3Bf82|NWD`D_-1W(aL?kQx z&pBs9omZ?RsW%x=AUwXSw-SpT2{1C?U2RsEin~I3@KTAOsE-9?!T{hyfr}c~mx%*5 ze{?)(1B?6#NP*g@BZ&}ib>tJzWrOC@_xLD__~UR^R-JYzudDI8hKfk;{#hsjkR33hxN9Br+ri>`WN=suSSt=jdt8LCw4&D~ zl`{AUhFK*Nb)eAhyGrWVE5b`1(u*nVD{^0@gYlQEp_|RffIas&*bdkoF0H`#P=W|p zQts=z;))QOmA*DU3R^f>R$fqJ0Lv!u^v0MW zNT*lWs=#U%^5l_8yZZ)U0fl{|hkAQ?udGfxQP|Va{F`h}4Qf89ERY;mO=cHul~b-? zgo_L!t1^ek&`hjHMvX_ORbri}$;IK3+(Rn1cGV8no{LUpJcmRQ7ng--!Y z#mSR$ARD<%7jzKP<9n1Bch&UBly!(&*)|5eD#Io%z>KS*wn3pskF^WNRMfzPq#35c zq`;>EH@#7_$r!K(pt2hn)cUJR14PJXQ4aKXMpi{Ep?^qBs>fpx%B_zzXSpa!N$+K0 zJIkehHb_aSfaO%Qr0IUjE!jVf$I+RMax;K4&4j^9l~mS z>Q<+KDs`exSDpJ#g$m8|nsMKG;`v4eByB;9u?78wHJMwDZ(~JC1Qk;H$WfK7t!xES zdeASB$MX^%kA+nS;(%!rJ;o20;*P5f8fKN_{y-II9yVah-`L$}$LmVah=cgU5qW8u zsGvvYV_GmKgcx$C+&P)8GLaw#n$bz&8xFGSwipM_Km6k-f&ocCo;oZBfe-L`6W)Y> zDd6_S2O27}Er@$@snhSUFG_fX2_YnJSyE4Jgao-1q*R!utT`tj(`%EwAmM-&*7!It z$R(smO)uDtD=HGXuw^SkK>O0)VM`x@1%F_NoGWkTm|A(0s{sT1`Z_e$gE( zUlUNK60Eg)oX%KOI848Z`&yMC<**jvN5_8wsJYomjZ?s)G^RdAip}(E8lfAqD6HmY zFm;rc@=~Pb?7Ss7l^I!Pn%q4M+ewX2(qKeHd)mdRAu3g&pf47t-EzX~Hd{(D#e4(V zE*2Irfr?aDZ&iaKrau-3{6%Dn1K3Gi2q3B;GomsoEwRXmTJc1UOdD#%3Z0b>`84Vs zv8ba=9r)1tyI)7F8VYRZ@>yezvU&?BfNYp9r`?#G3;<_DLQcbTBsnE{qL{g`7P{9g zVt5ylgr7O6_C8`>q|%FSVqMGu$zj)!-Eyq4)v#AgVhMKhS|yBH%-;vVFFq@hCd-zx z;iRYp%%hn#;aV^{bc-orRO2%&HDUQrLK$OW;}4-c_^Cu5aE%MAtT=Gsd)?2*i-4v) zu$*hup!C#hg@#MytYm}$3U0})%tlSfsObzE9@?N`9@h^V?p*w!`9CyhJh9I$1w?9~ zSBF4pKHgU$9gCNN=R(WIqLX57`EO$R4D1XO!kASUx{jA6JaSn80;mqvL8nM^RiDJv z9_0=WYIXE++Dc+TZ~5LM5kBc8f@?8<8LNo|T(A}xjuGe@9Byc|@Qsw#14g7y!y^=i zt4$jMEMoyGq(S4?p@5f1D(-3E_{SJZEb9|(sAd6;g%oogHP4B7F7@0N(D}sjT>hPx zUNh&DUQREoZo)w`%{u5V7VQchveN=~`4^0Cmg9)*po7`X&n!8jL3@=;B~w5lsBmdYcG*XfJo4|>2K zduMeS-Snyr4~J93uDwbrOt<@66}o8@rQ^~qjsJ}q1l=GAo*svPD0T0kgY8=-q@~D+ zxJXx|CX%G8G_VHb*AeAN`;g>Pigq`)ZZ$xvtp97dagc6=N2=+@+X9kZ*@V}1tD1I` zmWa=j4!TiD%ar%q!&|lF)FC@ccc37&lY{FZEJ&YK^Pm|`>DjO1iZwn(T0m++a;)hG zWzo21z~chIIRpYL?JMoZU~_Gu?OP=Y8#_z`ASU74=d{Z$#VmJ2sL!9%RS&PlvQV$| zDl6&Ivbs72Y?nCq6idZ=04{PML}m5jFoAm)Qa2!^0UZ#GSX%GOS}zq_2M20hgPK#~ zZ7PT77OJrzGRUPb0oP^=YDOpBM?bYBQ(@xJUO zLt`dZ)PM%F%t{kKXeh)RV&35bBzW`h_tncR#Z&kY$AAa`ko^Z03|eyZEm;hx-E64> z@QhX!V<7O7YzJMVYy}DrN~z*AK;me^l~fdB(B(dA%ROa2mQAfw3{mGz6|YaFUCoTM zwFOOIm|C}D;T2zir4nO`6Q!La=+ za;^qjQ2T^(5`y#u?1akFsVV$^8O?G(-^Xu`9xxvLxDH;s-Y!q*lD%`l6g58}D!VZz z&0T7oiY)c5@xMgrAKBEe!Fkdh+*XM{FS79}17oiapDZ(z#x?2KN^M4e$Z6uf(es$UWPf7Ed7zlR9(%MjtdTx_+X7@-5I7<#XxG8;KMFnSAJZzO@_a?a` zuhYauK%SH!y56N$S&BCVK+wirLHf0qg81X5!jhho@RUnam+Ae>Q3@Ea#aWHGbce<% zOBiK^~>aVV_t4;5)raTek^Is)A}eK_Lq#)Gu+dtwU3iJ6%yiB40+9>lLukuj~0* zA85QoOUMkwfhS6?&L0SK{G@3 zA^xu6FVXNg-@now$xw35!R9qd*cwIFwua=$k2+CK|Av$ZqMLzArlZPUk}zqRV76!G z>4(iB33n`WAf3gp#4)3s=!;h=0TN-0`3kcQ0!DWevsU#Eno zOCPYQ`Tq3yeZ3V~_W_FtGSI1ZNYzH%rRwGY;2&@H)44GH<6ruh-_-Q7x}SDW!N5ZY z1(#txoV;&P>k9gLjaI>;+Oz7q)f*D!nHDQEbDJc+R~SIe0a1v_dz(L}J7tMM8V0Kx zAO@jwB$EC~K;#h8Wddh?@-P4l7Ew|Dl*0j+9&e6h*mB>=fJlF%PzEqzYeeV+I>Nj; z`XUu734M(ABKigtoMwp9nP?U2nj?zi4A^SIhFyw}z?NzqHlhHK!yF({LjiLG!rVYI zd@vdIm>Ur0MieV+s9yk~A>pw%oC=sh4wIwE>f5$)S0Umz%|@(orxsNC=ZT3Ar9W_guMRge_y^M4rXXp$^rwM_98b})H6tE_79Q|u9ZCm< z(?Ln~u!s2ipk%t(Z&2))3<;cTLEWJEjcR<-^QTJO9m>qDPq<%}!Ekf*>-LK-+#H=$ za7;Nehyh8+SJ%kdX#i6wSa9Y|u$mPIbYr99=EfNqF4f;#@mkjmY8i2MS2#_S%e-&NyWWSLA zp`M4_sMU$JC9E0Yxy|$;yQDE2y(w~@Q*=wstMz@d)VvCmfy^yh1_V4e3(jFnIsS*MsyYzaH=#X}xifhoIbQZC$xzqfBv;VD0d~d4mLL@u7Sos?A_FJl^Ahj`n0Nd&V=CjS5X?uyh1@?C2)tUmnsJv zzaMdNid!_a9JQ<)Uy52Pa8)Cq6Wl*#_f-lW($0rh?ZQ-Um}7fwaxJmr3ba$F<79i9 z%(bpe|4i9d$rWk+U~+}-9d3;Z%#n2K{k=&#n2b!`)tm6MjatcY^OMU#v$ZQ|HcPac zp2nzbCj9n~mwDWfvgCmSquCO0Y*f*NSs1!#mN?nW07`GTyLXt9*oo>!R{zq{@eixY zMxAFTT=jYVEJgRWh6ZKDnJqE`Y7h)VOjixug^C-N_yX&6$bxyU3f?sRY4146 z0!I7v!a%z8lr-ndAtQqkO0&o}B7Va?tlkTb}+*KJ0K^5Is4jKpCY_4btm`v>8V5U9EU13?1DH}q_d@i1t-@xMmEDIMc1 zrj&5}4WdS0EqKdYufO5On|6X@>qK&mQ<+0O--kQg9Ho?DrFHcllTf4dXOvOV8f9!& zpWe0e85-uY^eltfPT`xtW>vtpGD1T2m{R zjh+GDan#CLM9u<@CwHDn}`qN)hPXulC^=yV_h-^LeWtJXt2 za6l1G1LYAZ(2}24SxJT(S((^RZQ^-gwM;K)3Np79u*3e+m z7)(o@Dm75chc#NIPi?en)L-OimF8i@qWNE&5i7CaMl9W52L}RBe^@I+J#PU+yCCIH zw65mp_Y$m}F;A`nY_`iIJ?TRp-qjoTTyNxisnTTJb!jXOHn-8`vjn&6v>)6v*xJ+_ zG0Dr~X^DqMxi!>~OS0sCi)1IHEqLxlr35LCrk)_8tfUv4PHO+<$3F88vcWnK>94Jcp+L;Uh5cv8eZHE$DFFYjbmM=&-wAKV0Wu=c(T=(VUkMIqX(7x zvq{$UQXO59)(?prTAR~nmOgl}i4$TB&;1!5%J6~T&<>-MO#m?%)HFnPy2jXZSa1#| zeY4U^fHMqTTU(PM$+}VKZ6hq90PKiR%}ku%#r#4wVdV@vt_LWM9T{@N3=IT{871rw zRAy!<67DuK#F8u2 z7Dilv{pZ_~@rJ?27|#BaAr0NqGYB9Iv0W6#b{nQ+SX-m!3SCz^BU^$JPAr*4Zf5JS zU}RKKj7CRXPbE(_LkTc1NhoP$AtaSZ2B5AN5q1+bZDS6qxaIbeN-zUH($9l6v&Kx` zVS&5~HgZ%GvoJcb1cu;Dtmfvh6OVv51S^?z>N8;m(IuTw2xvPudl=|a1W&fzm28v9 z9C-jk6F~3bYrAB~c4Qm*PgK0kEP@v0`+BZ)wn?+mvr!dpP5(^(okuRxJHC2{MdL~=FE#fuovCUQf1;ccX$w0kz)X;zBDATo*5?rG{6 zaIeZRN&gbNVjj* z#bnlC{%N>dT!Y(IvtcP2;yoOA3Sd&Jz3rlQf&yx7^Ty8B$@}nNwhFIUFDs@uqB(6C8^oC*o;oYNtI z!}Kb&lSDU%04{V6L4)|pCNnQK$pG&Y?VO3FHC;X?XR|$KU~Q&H`E5F}q?NfVyRZ|E zqzhZs1$|tw3tL}nOH*&sDrd;yKXEy zkJ`LwV`*pnElbMs%uCtK$3B(aah~%jJZCCVxPTDSa5}t*n~)66w+24dY%vgryyZuj zSCNX=b1jTv#npI(r07x9v(=F_5?ly~mf3m|I0JgR)M_?c!b_YqsX)??cP-kk5L=At zQxr8;h2qY#q$F_|K&C{il$KlS41Joy5#5Os731tjbNKuNDfk;iiuPMh1wbpZICLb9 z4ySL`E#5T;51A!XR+cn#1J)IS7%az;ja_ODG~{S6yWbL3d-%!Yf{DG;ENu0HVk->n zr6nI0Q6M05_C`&NUYqYl?6AMn1fT^<6axU1$yBT45wwu$M)`+B3UcD-4M=upAp_*E z*0~meUvgZK1An#y{E|3<=LP7`@RV-N@_>RD4?gd?!Vdn&UOoI(+3eyLqykh!>4`9e z2dZ&e7uzL+QVG(dGM&&Sfq0G)-95`?H@22zL7__b87kO&qq9=DQV?btJ9`ebf(JTh z*1aZi8i*q1KQv1s1PAv?No-4ouufPESa|8=VWV8Vn81&#K3xT z46SuRF>oO{HfUmCP@=XV#|ArcOcP1KEx&A3_#&8-MQlbCvB6d{KZ;-tsO{($7t|Ta zB;TmqjZsB$Wd20LUCrQ{0r zY{~|Q5OQsrWCOd;1~z+UF_bg_5_{Mg7`jLJMU$B30r!2^T9wQ$KCRd2TWg!>hJ4}nOH4Qc+UGm$x0k$GUwNq$bVco0=C`*%eLR5`Q z#_bC0rqG1~ti^GTaw*!8+mo#V*Wx*jHFla=W*_Tt#dj6@LC9DnKqirh=oiKE1tR(@ zyKw1I{S^|aK!6NZv4s9iA|c^nI*Di5Eeb$i&^^mtGFeOK@X3aeHRh8IdwE@j4bxB) zVS2+Xn;|ojkRwAxC`{?Lh8f+XX+)$*ZVH16|8G>r)0SjAR)++Tz0c4oSWi^3MZvJn zaC5SXA+}Y~tc~u;{C&OM++qvCt!7G_9IAtftq=4nI+@8K7;wAfkUmy$+^Bg2jFl>r z5z$#y(|HZ_ zn1!GP+pB6~l45mDq_`DyRpwzJ2s%SEkDp837NiT<%9vZyp7VhyjvMeY0?}cJQcZUi?G%z%o*%GpY7^Is> zl2x(IGDY*U=^5rQ!mQ{v$xt$T5<-m;fOKa-$_&HT33Mk1u;}TSi-Te2TpT*9+?}jT zmY%SFpH>6Djp#Ig=zk|8`Ee9f@zs3~`hN%$+xMprtBwT(3VovnyReci@H{x!#IDdD zUIQkgEWk;(i$rtN5K)y?#Pc@{Y(sa%FXrvH5% zOxbm)*Inm#V*7cgUS(SE`DCUJ#^ zG)8THU?hivJ{cpJ@MZT+n|pdgP*x#k3wh;q6~h=oZJ3>N5WY&%hMu%GB376}=QEIv zZS%RtOE;2bi8~|NgcKjfOt7UN&mDfH@at=xbn$ z76MfTQ^*IZ3_w98Q%GZmpfE``L}t-(8rI}E^(6^DE0OIX9lu%D5)G}B!rcii(@A%0 zx~ruSICP!6J-SPlFTs_ehT83LchdZ8HkM*D=+|xl{Srk6H$8vC1|H< z%W}9&Mt7^~*E^62qwcz-U`s&MqI1^6-*1zVdU~)~qPCi96vQNXD?q`*6)kJ)l1|VO z2^B6R1GHLDOJ!9p^F4HitbSKL>EmSKaXURe-&76uycqzXZ5hofK*k6!Dx+NYctIPp z0)nQWSdpwX^2VL7jTwllEzFrn8zdz*WPG3}n6vnLR7 z?b{w&H17r8#ty$g2^99)`aKO0OlzO{wn_e5w`Q_s-&zV9aI9=2HVRcr9wdP{{!}{| zp#D`mGZ)6t(hf(wCV4P=QAew}w@Q3zr1}LQ@$s+(uV$-nEE6J1&wkxy5~1V6^nVW+ z4w1%6#5DuR~6mQ7vLAg=Li*X_?f7eB}-ix4n=0nF`B zyDo5J=d;h@E|OJQ(ibKmvX4bD^rV!6s3drXlq{Cz+2tNBoiE3K5gHou<$2l&n)V}A z#@ZIEuHvhUZ15%(Km*b&ITFd^f4V8_<=zJCuv1HLv=?^gErs zom62I_~btP*2D29@?YD)UarJA6Up3e-SR+1SuNNEM9^ z-gQbeVcC;*Fwg>QE@4NvT1?lGuhLq8l|>emSy{;ob}#+O4?R7C_O$; zyD$IUe?NKKwco$v~~04H5@M)Ok2BD~@sV=Ow-?8$n! z`Wt~~&}#}#G+>c89}9rgbI@{t>QD#l0S^m3!=$cjObWJiR=bsEok3m|ff9E3I4D~N z>rtE>A8dSq?WSdVmUZGqHwAmSug&;?@SavY*s5yR2R4XGxTesN7THHDo39m{XS<|M z^K$GprN$N!dXt5b1*kDA4eARM5k01kX#ddG1&Jjru;%q)h6+np^PZRKY@z36>p6?Z z*z;;-&sjUJp0gNPSg`%ExHkA%z;{VqU`Mi7(gk6U{m_b>qHD0p*%EM!BYt;=MzQ?) zM?=O)yIb`^$1K7RTjC0;ix^D_uR#mrD~)6^kUp?>g<7e_-j$r~V2>YXm1x2$t)R1{ z*%mv^-I*15o|uC&QSEtF@(6$`+<_9jxzOhNlG8UG`*2ec>CeONLt%ilpC z+!w+6>LRu&V$-cWM$G8u^*S^Fmsa~}=xiR^VHG0^k7R2@b;uMgsxdttzfJm&ZhOOA zt8LMntgY;^_oBuNQ8NN7@(%SZiU(){1*I9Y5Rc{gDE@;GwV;s*E?OnG77efnj7i2~ z`;?oiAfaE0E~B&p7vyRc$@Nw}3YGE}r6D@smRMoMl?}VH=kP%=4Ir#NilRHH&^9pB z+NYA%KFKPON})^yFcDMKNoi6bTpvK94Amv~f~^fhyQF|KiA;{~byi=6nngu3`&@^N zYAq6hLO`Siu<58KP1a%yY10H+k}g$Mi9aB|@b)7`r4T_`ZV=kaGhv0jpdg$mt;{(G zGoeuL9H6lvc2Q$djaN)uSr1hS81n2AOva^v`cA!NADS&L&mIW^wx*7|+B5SLGh8Nd zZDzVXH#alKkDc+m{EuX8|H8z~^tJQJ*jziAnVve992uLM7*7t&%^XS=o@ghnyB>aD zE15qwztBEJ>HRZ{(+gB_Hi&zy?i&|oCfn28SqkG`?o2K2pUiHZaJR2EDe zj87~cGSE)BTjPMDs^%%R%&jM8<`(Dej+HvCQb*cz6SM8{iLr^plsdyLK%8rjO-+u? z9U9}-Sy$J@%))F2#8PB%P0So>w-@L(r8w3=pzfO*1J?G~A#RL>Ha!j!z{g@c;odU4J<--Um#3q+{CHbKacLW|E18_T1RQ%-o~8o=>J{7Lti+YM)w|cywZVy!|9EE|ue}_m55MnO;oV z)8qMjs^iei_{4!@6g*Xqt0MamYpxt`gTgodF!hOa$CB~6v7^ac`{>x*_@B zLzw;6a3y}{;_Ubs*hqW@`$6jC?PPXt;?UUKv1GD+EIIl_8{AlLC#D}yK)S15UGK_U z-VZ4kXvk1~;g-ANt8DaunXz$In~{WCPgLU#k5A3)8=F#>4^7O^Q$Vd%?c|9u z#}4~vV4?AuqtnSTwzD7_x(RYF~)8) zd17HW*)DZ=0b!2TdF=JBj95y_xJWbkghj z>l0z%-a8!zg#PaMip6PTL;8Mz@g=t6!HL+!2Hi4viL#_8;`9HfLZh%W|KzdPUjIbJP0n!_9%8IJO6;SlXR~DZY;6K|Nzoo!Y z$$^3BwI#2e+*R3w^#>%?IPxr;wt}ZSWux{aR_r>L#DnjhnVL!#j?K1L7c@n-A#PfM**Q!I zvwPMncH)Y76ZkTQL-bs03VgmjbwItmB5oCW>DBwf(KZ@ql!1(>7*)A5tYlQVeKT_m zz03@7<=(C_^aHo3pBv*YdOjztKD#llZG_XVu`BBNT_T29Cl$)4; zbZq+AqcaC~|Dc+ASHi#BZkyh5UGk%X=k;hngLr9E{I0!HAgHiR@69jH&d$s&w8yVc z;DO9YLS-BpTiE}E(?2p$_s@*CMPAMqiQj)nVsihZvR?Us1(TyF$nmz9ZeZSQT=-`{ zC3!q{K!WAbC)#7PR#cLCs=d(05VoqY5u_;D3M{UmAr}Sgp9b;i(w3k**s^7d$W_rt z5Y+V%>qGx-2?n}(Uh1v};b1-9%=0cD#zB|f@o!p5|IwHIpypmZ?+t<|sOxq;;4^=o zmCL_-@~a@YLf7_DcenX0J}(sIvQhZi&vjWJLEYWvv-rGFl*rln&kcF&m&@;Jd}RM!r3?G0yW4ygpJ(OV_ol*68)5cQcenY}h0;yq#!eIR zH{WvW52U-^edk@f8Oz-6zTvG&lI(nBrwnbD0LRrG(~DD6*NGdx9>iDNu=A0(?tFv- zH|%`!tvjDgtQ<>l<1%84LafA%%lAICo6BWgPLEA<$&%f;{80K3m!!JH(T!X%*APFl zx7pf40&!{J{%t*ta=d-R(6vuU)$B_uUHw;VymD)8Q+3D4Rh#SGeS^cJS3muspSb2N zZ~ei4@UGk6efND2KJp{~@JIjAKmM^t9~(18B|U|TI`)Ad|Dc-uMiBpO-@UN@<5))f zj$r}Mw+}D2r}wvmJ7*-26Xztpw>^({VPkQwjli78B#}uJJj4hbOBNQ61$)|aX6vHc zu?Qy^ClAlcO_8!U4Wj3m4dc9n(ZHBJFd@@k0v%@pcjj3BWOi<5zf8B?D$#y&Vt!#h zc)vMb3o|px)Yu$0zNvz-1sX@d+ncjvD2A!_fdxi2FdRWo1P?Fr>p+6>s`}{$Rx73U zEzTbc?ww|^&n?aZQ|8f140KA##+jMJGGq8-0vZdTH1&eHFZWW_p^g3q`^y8sb7G#>cPMzDImYNcAvu|vnVB{IkfYowv={z3gw9H4W>Fu)zd3WB2K3ZOf(F=6=m4Gr z)|{-n#t3wX<2sMUSNorsm>S2WbS$Yt8G3fBaL$oI-nIao*Q-Kbv4x!f#$ge|?a`S< zDxcZEe{n8&A8Nhr$Jl<^z(&G7b8zwuegrf|H;u0xS(qgI+i0#}_u{l;B#pHRX)WQ> zQR@(6X^bJmK#=Z(hHlW@%RpV2I50uA_)@eu9^7fe#()^Z4ug{psUtYqV+Bn4QsPZ< zrXOUk_`F!zM%jGufG8!Obe~M3c?E1}W6#{o!pwf0A}3pfQ4gUT@E!DvZ};(722Uny z=D{gG?VauUg^6h=UOYWI9QvT|aECT|o6fa1qfipW*OosP_BtG~;&yI<1n)BtoMovO zI!`nfI=}MQ4~!j>3|Uz=8=LDrG(q6eln>&SuszgXI65 +#include + +#include + +namespace eosiosystem { + class system_contract; +} + +namespace eosio { + + using std::string; + + class token : public contract { + public: + token( account_name self ):contract(self){} + + void create( account_name issuer, + asset maximum_supply); + + void issue( account_name to, asset quantity, string memo ); + + void transfer( account_name from, + account_name to, + asset quantity, + string memo ); + + + inline asset get_supply( symbol_name sym )const; + + inline asset get_balance( account_name owner, symbol_name sym )const; + + private: + struct account { + asset balance; + + uint64_t primary_key()const { return balance.symbol.name(); } + }; + + struct currency_stat { + asset supply; + asset max_supply; + account_name issuer; + + uint64_t primary_key()const { return supply.symbol.name(); } + }; + + + typedef eosio::multi_index accounts; + + typedef eosio::multi_index stats; + + void sub_balance( account_name owner, asset value ); + void add_balance( account_name owner, asset value, account_name ram_payer ); + + public: + struct transfer_args { + account_name from; + account_name to; + asset quantity; + string memo; + }; + }; + + asset token::get_supply( symbol_name sym )const + { + stats statstable( _self, sym ); + const auto& st = statstable.get( sym ); + return st.supply; + } + + asset token::get_balance( account_name owner, symbol_name sym )const + { + accounts accountstable( _self, owner ); + const auto& ac = accountstable.get( sym ); + return ac.balance; + } + +} /// namespace eosio diff --git a/jackpot/jackpot.abi b/jackpot/jackpot.abi new file mode 100644 index 0000000..0d2db4c --- /dev/null +++ b/jackpot/jackpot.abi @@ -0,0 +1,156 @@ +{ + "____comment": "This file was generated by eosio-abigen. DO NOT EDIT - 2018-11-09T07:40:57", + "version": "eosio::abi/1.0", + "types": [], + "structs": [{ + "name": "player", + "base": "", + "fields": [{ + "name": "name", + "type": "name" + },{ + "name": "total_num", + "type": "uint64" + },{ + "name": "start", + "type": "uint64" + },{ + "name": "end", + "type": "uint64" + },{ + "name": "time", + "type": "time_point_sec" + } + ] + },{ + "name": "round", + "base": "", + "fields": [{ + "name": "id", + "type": "uint64" + },{ + "name": "total_num", + "type": "uint64" + },{ + "name": "winner", + "type": "name" + },{ + "name": "winner_num", + "type": "uint64" + },{ + "name": "winner_score", + "type": "uint64" + },{ + "name": "profit", + "type": "asset" + },{ + "name": "start_time", + "type": "time_point_sec" + },{ + "name": "end_time", + "type": "time_point_sec" + } + ] + },{ + "name": "globalvar", + "base": "", + "fields": [{ + "name": "id", + "type": "uint64" + },{ + "name": "val", + "type": "uint64" + } + ] + },{ + "name": "number", + "base": "", + "fields": [{ + "name": "id", + "type": "uint64" + },{ + "name": "owner", + "type": "name" + } + ] + },{ + "name": "init", + "base": "", + "fields": [] + },{ + "name": "draw", + "base": "", + "fields": [] + },{ + "name": "setglobal", + "base": "", + "fields": [{ + "name": "id", + "type": "uint64" + },{ + "name": "value", + "type": "uint64" + } + ] + } + ], + "actions": [{ + "name": "init", + "type": "init", + "ricardian_contract": "" + },{ + "name": "draw", + "type": "draw", + "ricardian_contract": "" + },{ + "name": "setglobal", + "type": "setglobal", + "ricardian_contract": "" + } + ], + "tables": [{ + "name": "players", + "index_type": "i64", + "key_names": [ + "name" + ], + "key_types": [ + "name" + ], + "type": "player" + },{ + "name": "rounds", + "index_type": "i64", + "key_names": [ + "id" + ], + "key_types": [ + "uint64" + ], + "type": "round" + },{ + "name": "globalvars", + "index_type": "i64", + "key_names": [ + "id" + ], + "key_types": [ + "uint64" + ], + "type": "globalvar" + },{ + "name": "numbers", + "index_type": "i64", + "key_names": [ + "id" + ], + "key_types": [ + "uint64" + ], + "type": "number" + } + ], + "ricardian_clauses": [], + "error_messages": [], + "abi_extensions": [] +} \ No newline at end of file diff --git a/jackpot/jackpot.cpp b/jackpot/jackpot.cpp new file mode 100644 index 0000000..3c5a434 --- /dev/null +++ b/jackpot/jackpot.cpp @@ -0,0 +1,315 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +using namespace std; + +#define GLOBAL_ID_CUR_ROUND_ID 1 +#define GLOBAL_ID_AMOUNT_PER_NUM 2 +#define GLOBAL_ID_MAX_AMOUNT_PER_ROUND 3 +#define AUTH_ACCOUNT N(eosluckydice) + +class jackpot : public eosio::contract +{ +public: + const uint64_t max_number_count = 200; + + struct st_seeds { + checksum256 seed1; + checksum256 seed2; + }; + + //@abi table players + struct player + { + account_name name; + uint64_t total_num; + uint64_t start; + uint64_t end; + eosio::time_point_sec time; + uint64_t primary_key() const { return name; }; + EOSLIB_SERIALIZE(player, (name)(total_num)(start)(end)(time)); + }; + typedef eosio::multi_index player_index; + player_index _players; + + //@abi table rounds + struct round + { + uint64_t id; + uint64_t total_num; + account_name winner; + uint64_t winner_num; + uint64_t winner_score; + eosio::asset profit; + eosio::time_point_sec start_time; + eosio::time_point_sec end_time; + uint64_t primary_key() const { return id; }; + EOSLIB_SERIALIZE(round, (id)(total_num)(winner)(winner_num)(winner_score)(profit)(start_time)(end_time)); + }; + typedef eosio::multi_index round_index; + round_index _rounds; + round _cur_round; + + //@abi table globalvars + struct globalvar + { + uint64_t id; + uint64_t val; + uint64_t primary_key() const { return id; }; + EOSLIB_SERIALIZE(globalvar, (id)(val)); + }; + typedef eosio::multi_index global_index; + global_index _globals; + + //@abi table numbers + struct number + { + uint64_t id; + account_name owner; + uint64_t primary_key() const { return id; }; + EOSLIB_SERIALIZE(number, (id)(owner)); + }; + typedef eosio::multi_index number_index; + number_index _numbers; + + jackpot(account_name self) : contract(self), + _players(self, self), + _globals(self, self), + _numbers(self, self), + _rounds(self, self) + { + auto cur_round_iter = _globals.find(GLOBAL_ID_CUR_ROUND_ID); + + uint64_t cur_round_id; + if (cur_round_iter != _globals.end()) { + cur_round_id = cur_round_iter->val; + _cur_round = _rounds.get(cur_round_id, "construct get cur"); + } + } + + ~jackpot() + { + auto round_iter = _rounds.find(_cur_round.id); + if (round_iter != _rounds.end()) + { + _rounds.modify(round_iter, 0, [&](auto& a) { + a.total_num = _cur_round.total_num; + a.winner = _cur_round.winner; + a.winner_num = _cur_round.winner_num; + a.winner_score = _cur_round.winner_score; + a.profit = _cur_round.profit; + a.end_time = _cur_round.end_time; + }); + } + } + + /// @abi action + void init() + { + require_auth(AUTH_ACCOUNT); + _rounds.emplace(_self, [&](auto& a) { + a.id = 1; + a.total_num = 0; + a.start_time = eosio::time_point_sec( now() ); + }); + + _globals.emplace(_self, [&](auto& a) { + a.id = GLOBAL_ID_CUR_ROUND_ID; + a.val = 1; + }); + } + + void transfer(account_name from, account_name to, eosio::asset quantity, string memo) + { + eosio::currency::transfer t = {from, to, quantity, memo}; + if (from == _self || to != _self || from != AUTH_ACCOUNT) + { + return; + } + + vector pieces; + boost::split(pieces, memo, boost::is_any_of("-")); + + account_name account = eosio::string_to_name(pieces[0].c_str()); + + auto amount_iter = _globals.find(GLOBAL_ID_AMOUNT_PER_NUM); + uint64_t amount_per_num = 0; + if (amount_iter != _globals.end()) { + amount_per_num = amount_iter->val; + } + uint64_t total_num = quantity.amount * 10 / amount_per_num; + if (quantity.amount == 12) { + total_num = 1; + } + + if (total_num >= max_number_count) { + total_num = max_number_count; + } + auto player_iter = _players.find(account); + if (player_iter == _players.end()) { + _players.emplace(_self, [&](auto &a) { + a.name = account; + a.total_num = total_num; + a.time = eosio::time_point_sec( now() ); + }); + } else { + if (player_iter->time <= _cur_round.start_time) { + _players.modify(player_iter, 0, [&](auto& a) { + a.total_num = 0; + a.start = 0; + a.end = 0; + }); + } + + _players.modify(player_iter, 0, [&](auto& a) { + a.total_num = a.total_num + total_num; + a.time = eosio::time_point_sec( now() ); + }); + } + + uint64_t start = _cur_round.total_num; + uint64_t end = start + total_num - 1; + + for (uint64_t i = start; i <= end; i++) { + auto number_iter = _numbers.find(i); + if (number_iter != _numbers.end()) { + _numbers.modify(number_iter, 0, [&](auto& a) { + a.owner = account; + }); + } else { + _numbers.emplace(_self, [&](auto& a) { + a.id = i; + a.owner = account; + }); + } + } + + _cur_round.total_num += total_num; + _cur_round.profit += quantity; + + auto max_iter = _globals.find(GLOBAL_ID_MAX_AMOUNT_PER_ROUND); + + uint64_t max_profit = max_iter->val * amount_per_num / 10; + if (_cur_round.profit.amount >= max_profit) { + draw(); + } + } + + /// @abi action + void draw() + { + require_auth(AUTH_ACCOUNT); + + uint64_t total_number = _cur_round.total_num; + + auto s = read_transaction(nullptr, 0); + char *tx = (char *)malloc(s); + read_transaction(tx, s); + checksum256 tx_hash; + sha256(tx, s, &tx_hash); + + auto global_iter = _globals.find(GLOBAL_ID_CUR_ROUND_ID); + checksum256 system_seed; + sha256( (char *)&global_iter, sizeof(global_iter), &system_seed); + + st_seeds seeds; + seeds.seed1 = system_seed; + seeds.seed2 = tx_hash; + + checksum256 seed_hash; + sha256( (char *)&seeds.seed1, sizeof(seeds.seed1) * 2, &seed_hash); + + const uint64_t *p64 = reinterpret_cast(&seed_hash); + uint64_t hash_added = p64[1]; + uint64_t random_roll = (hash_added % total_number); + + auto number_iter = _numbers.find(random_roll); + _cur_round.winner = number_iter->owner; + _cur_round.winner_num = random_roll; + + auto player_iter = _players.find(_cur_round.winner); + if (player_iter != _players.end()) { + _cur_round.winner_score = player_iter->total_num; + } + + uint64_t _now = now(); + _cur_round.end_time = eosio::time_point_sec( _now ); + + eosio::action( + eosio::permission_level{_self, N(active)}, + N(eosio.token), + N(transfer), + std::make_tuple( + _self, + _cur_round.winner, + _cur_round.profit, + std::string("Jackpot round ") + std::to_string(_cur_round.id) + std::string(" bonus") + ) + ).send(); + + newround(); + } + + void newround() + { + require_auth(AUTH_ACCOUNT); + + _rounds.emplace(_self, [&](auto& a) { + a.id = _cur_round.id + 1; + a.total_num = 0; + a.start_time = eosio::time_point_sec( now() ); + }); + + auto global_round_iter = _globals.find(GLOBAL_ID_CUR_ROUND_ID); + _globals.modify(global_round_iter, 0, [&](auto& a) { + a.val = _cur_round.id + 1; + }); + } + + /// @abi action + void setglobal(uint64_t id, uint64_t value) + { + require_auth(AUTH_ACCOUNT); + auto iter = _globals.find(id); + if (iter == _globals.end()) { + _globals.emplace(_self, [&](auto &a) { + a.id = id; + a.val = value; + }); + } else { + _globals.modify(iter, 0, [&](auto &a) { + a.val = value; + }); + } + } +}; + +#define EOSIO_ABI_EX(TYPE, MEMBERS) \ + extern "C" \ + { \ + void apply(uint64_t receiver, uint64_t code, uint64_t action) { \ + if (action == N(onerror)) { \ + return; \ + } \ + TYPE thiscontract(receiver); \ + if (code == N(eosio.token) && action == N(transfer)) { \ + execute_action(&thiscontract, &jackpot::transfer); \ + } \ + if (code != receiver) return; \ + switch (action) { \ + EOSIO_API(TYPE, MEMBERS); \ + } \ + } \ + } + +EOSIO_ABI_EX(jackpot, (init)(draw)(setglobal)) diff --git a/jackpot/jackpot.wasm b/jackpot/jackpot.wasm new file mode 100644 index 0000000000000000000000000000000000000000..e9dd323851443ebb91e22245c68e30bd9fc2e26c GIT binary patch literal 53065 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 1000000 && bucket.amount <= 3000000) { + lucky_fee = 72; + team_fee = 7; + } else { + lucky_fee = 60; + team_fee = 10; + } + } + + void lottery::active(account_name actor) { + eosio_assert(_global_state.active == false, "lottery can't be actived twice!"); + require_auth(actor); + + SEND_INLINE_ACTION(*this, setactived, {_self,N(active)}, {true} ); + + newround(actor); + } + + void lottery::setactived(bool actived) { + require_auth(_self); + _global_state.active = actived; + } + + void lottery::setstatus(uint64_t id, uint64_t val) { + require_auth(_self); + auto pos = _status.find(id); + if (pos == _status.end()) { + _status.emplace(_self, [&](auto& info) { + info.id = id; + info.val = val; + }); + } else { + _status.modify(pos, 0, [&](auto& info) { + info.val = val; + }); + } + } + + void lottery::newround(account_name actor) { + uint64_t next = _global_state.cur_round + 1; + eosio_assert(next > _global_state.cur_round, "new round number is smaller than or equal with the old!"); + + asset next_bucket = asset(0, EOS_SYMBOL); + auto rnd_pos = _rounds.find( _global_state.cur_round); + auto fee_pos = _roundfee.find(_global_state.cur_round); + if (rnd_pos != _rounds.end() && fee_pos != _roundfee.end() && rnd_pos->lucky_player <= 0) { + next_bucket = fee_pos->to_lucky; + } + + _rounds.emplace(actor, [&](round_item& info) { + info.round = next; + info.bills_num = 0; + info.last_key = 0; + info.reward_bucket = next_bucket; + info.start_time = current_time(); + info.draw_time = 0; + }); + + _global_state.cur_round = next; + } + + void lottery::endround() { + round_item rnd = _rounds.get( _global_state.cur_round ); + + uint8_t lucky_fee, team_fee; + get_stage_fees(rnd.reward_bucket, lucky_fee, team_fee); + + auto to_drawer_max = rnd.reward_bucket * _global_state.drawer_fee / 100; + to_drawer_max = to_drawer_max > _global_state.drawer_fee_max ? _global_state.drawer_fee_max : to_drawer_max; + + bills_table bills(_self, _global_state.cur_round); + auto idx = bills.template get_index(); + auto itr = idx.lower_bound( rnd.draw_account ); + eosio_assert(itr != idx.end(), "join game first"); + uint64_t keynum = 0; + for(; itr != idx.end(); itr++) { + if (itr->referal == ACTIVITY_ACCOUNT) { + continue; + } + if (itr->player == rnd.draw_account ) { + keynum += itr->high - itr->low + 1; + } else { + break; + } + } + auto to_drawer = _global_state.key_price * keynum / 2; + to_drawer = to_drawer > to_drawer_max ? to_drawer_max : to_drawer; + + auto to_lucky = rnd.reward_bucket * lucky_fee / 100; + auto to_team = rnd.reward_bucket * team_fee / 100; + auto to_tokener = rnd.reward_bucket - to_team - to_lucky - to_drawer; + + INLINE_ACTION_SENDER(eosio::token, transfer)( N(eosio.token), {_self,N(active)}, {_self, DIVI_ACCOUNT, to_tokener, "[eos.win] To EOS.Win Bonus Pool [https://eos.win/lottery]"} ); + + INLINE_ACTION_SENDER(eosio::token, transfer)( N(eosio.token), {_self,N(active)}, {_self, _global_state.team_account, to_team, "[eos.win] Team fee"} ); + + transaction to_drawer_tx; + to_drawer_tx.actions.emplace_back(eosio::permission_level{_self, N(active)}, N(eosio.token), N(transfer), currency::transfer{_self, rnd.draw_account, to_drawer, "[eos.win] Round drawer reward"}); + to_drawer_tx.delay_sec = 1; + to_drawer_tx.send(rnd.draw_account, _self); + + if ( rnd.lucky_player > 0 ) { + char buffer[256]; + sprintf(buffer,"[eosluckygame@eos.win][round: %lld][lucky key: %lld] winner reward", _global_state.cur_round, rnd.lucky_key); + string notify = buffer; + INLINE_ACTION_SENDER(eosio::token, transfer)( N(eosio.token), {_self,N(active)}, {_self, rnd.lucky_player, to_lucky, notify} ); + } + + _roundfee.emplace(_self, [&](auto& info) { + info.round = _global_state.cur_round; + info.to_team = to_team; + info.to_bonus = to_tokener; + info.to_drawer = to_drawer; + info.to_lucky = to_lucky; + }); + } + + void lottery::transfer(account_name from, account_name to) { + const auto params = eosio::unpack_action_data(); + + if (params.from == _self || params.to != _self) { + return; + } + + if (params.memo == "deposit") { + return; + } else if (params.memo == "activity") { + bills_table bills(_self, _global_state.cur_round); + bills.emplace(_self, [&](bill_item& info) { + info.id = bills.available_primary_key(); + info.player = from; + info.low = params.quantity.amount; + info.high = 0; + info.mine_token = asset(0, GAME_SYMBOL); + info.referal = ACTIVITY_ACCOUNT; + info.time = current_time(); + }); + + auto pos = _rounds.find(_global_state.cur_round); + _rounds.modify(pos, 0, [&](round_item& info) { + info.reward_bucket += params.quantity; + }); + return; + } + + eosio_assert(_global_state.active == true, "lottery not activated yet!"); + + eosio_assert(params.quantity.symbol == EOS_SYMBOL, "accept EOS only"); + eosio_assert(params.quantity.is_valid(), "transfer invalid quantity"); + eosio_assert(params.quantity.amount >= _global_state.key_price.amount, "amount can't be smaller than the key price"); + + bill_item bill = buykeys(params.from, params.quantity, params.memo); + + auto pos = _rounds.find(_global_state.cur_round); + eosio_assert(pos != _rounds.end(), "round number not found"); + + _rounds.modify(pos, 0, [&](round_item& info) { + info.reward_bucket += params.quantity; + info.bills_num += 1; + }); + } + + bill_item lottery::buykeys(account_name buyer, asset quantity, string memo) { + string referal_name = memo; + bool has_referal = referal_name == "" ? false : true; + account_name referal = has_referal ? eosio::string_to_name(referal_name.c_str()) : 0; + + bill_item bill; + bill.player = buyer; + bill.referal = referal; + + auto rnd = _rounds.find(_global_state.cur_round); + eosio_assert(rnd != _rounds.end(), "round number can't be found in rounds table error!"); + + uint64_t num = static_cast(quantity.amount / _global_state.key_price.amount); + eosio_assert(num * _global_state.key_price.amount == quantity.amount, "transfer number must be integer multiples of key price"); + + bill.low = rnd->last_key + 1 + num; + eosio_assert(bill.low > rnd->last_key, "low key is out of range while buy keys"); + + bill.high = bill.low + num - 1; + eosio_assert(bill.high > rnd->last_key, "high key is out of range while buy keys"); + + asset surprise = asset(mine(num), GAME_SYMBOL); + + asset to_referal_token = asset(0, GAME_SYMBOL); + if (referal > 0) { + eosio_assert(buyer != referal, "referal can't be self!"); + to_referal_token = surprise * _global_state.mine_referral_fee / 100; + } + bill.mine_token = surprise * (100 - _global_state.mine_referral_fee - _global_state.mine_team_fee) / 100; + asset to_team_token = surprise - to_referal_token - bill.mine_token; + + issue_game_token(_global_state.team_account, to_team_token, "[lottery@eos.win] LUCKY token for dev team"); + issue_game_token(referal, to_referal_token, "[lottery@eos.win] LUCKY token for referal"); + issue_game_token(buyer, bill.mine_token, "[lottery@eos.win] LUCKY token for player"); + + bill.time = current_time(); + + bills_table bills(_self, _global_state.cur_round); + bill.id = bills.available_primary_key(); + bills.emplace(_self, [&](bill_item& info) { + info = bill; + }); + + players_table players(_self, _global_state.cur_round); + auto pos = players.find(buyer); + if (pos != players.end()) { + players.modify(pos, 0, [&](player_item& info) { + info.bills_num += 1; + eosio_assert(info.bills_num <= max_player_bills_per_round, "max 500 bills for one player per round"); + }); + } else { + players.emplace(_self, [&](player_item& info) { + info.player = buyer; + info.bills_num = 1; + }); + } + + _rounds.modify(rnd, 0, [&](round_item& info) { + info.last_key = bill.high; + }); + + _global_state.total_users += 1; + + return bill; + } + + uint64_t lottery::mine(uint64_t keynum) { + eosio_assert(_global_state.active == true, "lottery game has not began!"); + + uint64_t mine_token = keynum*7500; + + auto left_token = _game_token.get_balance(TOKEN_ACCOUNT, _game_token_symbol); + mine_token = mine_token > left_token.amount ? left_token.amount : mine_token; + + return mine_token; + } + + uint64_t lottery::randomkey(uint64_t max) { + checksum256 result; + static uint64_t seed = static_cast((int)&result); + auto rnd = _rounds.find(_global_state.cur_round); + auto mixedBlock = tapos_block_prefix() + tapos_block_num() + rnd->reward_bucket.amount + seed + current_time(); + + seed += (mixedBlock >> 33); + + const char *mixedChar = reinterpret_cast(&mixedBlock); + sha256((char *)mixedChar, sizeof(mixedChar), &result); + const uint64_t *p64 = reinterpret_cast(&result); + + eosio_assert(max > 0, "random max must > 0"); + return (p64[1] % max) + 1; + } + + void lottery::delaydraw(account_name drawer) { + require_auth(drawer); + + eosio_assert(_global_state.active == true, "lottery has not been actived!"); + + auto pos = _rounds.find(_global_state.cur_round); + eosio_assert(pos != _rounds.end(), "round is missing!"); + eosio_assert(pos->last_key > 0, "none buy keys"); + + auto ct = current_time(); + eosio_assert(ct > (pos->start_time + useconds_draw_interval), "draw time has not cool down!"); + + players_table players(_self, _global_state.cur_round); + players.get(drawer, "join game first!"); + + transaction dr; + dr.actions.emplace_back( permission_level{ _self, N(active) }, _self, N(drawing), drawer); + dr.delay_sec = 1; + dr.send( _self, _self); + } + + void lottery::drawing(account_name drawer) { + require_auth(_self); + + transaction dr; + dr.actions.emplace_back( permission_level{ _self, N(active) }, _self, N(draw), drawer); + dr.delay_sec = 1; + dr.send( _self, _self); + } + + void lottery::draw(account_name drawer) { + require_auth(_self); + + auto pos = _rounds.find(_global_state.cur_round); + + auto ct = current_time(); + + uint64_t lucky_key = randomkey(pos->last_key); + + bills_table bills(_self, _global_state.cur_round); + auto it = bills.begin(); + for (; it!=bills.end(); it++) { + if (it->referal == ACTIVITY_ACCOUNT) { + continue; + } + if (lucky_key >= it->low && lucky_key <= it->high) { + break; + } + } + + _rounds.modify(pos, 0, [&](round_item& info) { + info.draw_account = drawer; + info.draw_time = ct; + info.lucky_key = lucky_key; + + if (it == bills.end()) { + info.lucky_player = 0; + } else { + info.lucky_player = it->player; + } + + }); + + endround(); + newround(_self); + + erasehistory(_global_state.cur_round - HISTORY_NUM, 1); + + } + + void lottery::claimbonus(account_name actor, account_name owner) { + require_auth(actor); + + auto b_pos = _status.find(STATUS_ID_BONUS_ACTIVE); + eosio_assert(b_pos->val == true, "bonus has been locked!"); + auto ct = current_time(); + + auto dividend_base_time = _status.get(STATUS_ID_CLAIM_PEROID_BASE_TIME, "can not find claim base time"); + auto devidend_acc_interval = _status.get(STATUS_ID_CLAIM_PEROID_ACC_INTERVAL, "can not find accumulate interval"); + auto devidend_claim_interval = _status.get(STATUS_ID_CLAIM_PEROID_CLAIM_INTERVAL, "can not find claim interval"); + uint64_t period = devidend_acc_interval.val + devidend_claim_interval.val; + uint64_t n = 0; + uint64_t ct_sec = ct / uint64_t(1e6); + if (ct_sec > dividend_base_time.val) { + n = (ct_sec - dividend_base_time.val) / period; + } + auto acc_start = dividend_base_time.val + n * period; + auto claim_start = acc_start + devidend_acc_interval.val; + auto claim_end = claim_start + devidend_claim_interval.val; + + char buffer[128]; + sprintf(buffer, "%lld is not in claim time [%lld, %lld], base time: %lld", ct_sec, claim_start, claim_end, dividend_base_time.val); + eosio_assert(ct_sec >= claim_start && ct_sec <= claim_end, buffer); + + auto last_claimed_time = _game_token.get_age(owner, _game_token_symbol); + eosio_assert(ct > last_claimed_time + useconds_claim_token_bonus_interval, "claim token bonus time has not cool down yet!"); + + auto snapshot_pos = _status.find(STATUS_ID_TOKEN_SNAPSHOT_TIME); + if (snapshot_pos == _status.end()) { + snapshot_pos = _status.emplace(_self, [&](auto& info) { + info.id = STATUS_ID_TOKEN_SNAPSHOT_TIME; + info.val = 0; + }); + } + if (snapshot_pos->val < claim_start) { + snapshot_token_balance(); + + _status.modify(snapshot_pos, 0, [&](auto& info) { + info.val = claim_start; + }); + } + + asset balance = _game_token.get_balance(TOKEN_ACCOUNT, _game_token_symbol); + asset max_supply = _game_token.get_max_supply(_game_token_symbol); + eosio_assert(balance.amount < max_supply.amount, "has no game token issued!"); + + asset b = _game_token.get_balance(owner, _game_token_symbol); + eosio_assert(b.amount > 0, "has no game token!"); + + asset supply = max_supply - balance; + double percent = (double)b.amount / supply.amount; + + auto to_bonus = divide_token(owner, TOKEN_CONTRACT, EOS_SYMBOL, percent); + auto to_lucky_bonus = divide_token(owner, GAME_TOKEN_CONTRACT, GAME_SYMBOL, percent); + auto to_add_bonus = divide_token(owner, ADD_CONTRACT, ADD_SYMBOL, percent); + auto to_atd_bonus = divide_token(owner, ATD_CONTRACT, ATD_SYMBOL, percent); + auto to_dac_bonus = divide_token(owner, DAC_CONTRACT, DAC_SYMBOL, percent); + auto to_horus_bonus = divide_token(owner, HORUS_CONTRACT, HORUS_SYMBOL, percent); + auto to_iq_bonus = divide_token(owner, IQ_CONTRACT, IQ_SYMBOL, percent); + auto to_karma_bonus = divide_token(owner, KARMA_CONTRACT, KARMA_SYMBOL, percent); + auto to_meet_bonus = divide_token(owner, MEET_CONTRACT, MEET_SYMBOL, percent); + auto to_black_bonus = divide_token(owner, BLACK_CONTRACT, BLACK_SYMBOL, percent); + + asset fee = asset(b.amount*0.005, GAME_SYMBOL); + + INLINE_ACTION_SENDER(eosio::token, updateage)( _global_state.token_account, {_global_state.token_account, N(active)}, {owner, asset(0, GAME_SYMBOL), ct} ); + + _global_state.total_claimed_token_bonus += to_bonus; + + auto count_pos = _status.find(STATUS_ID_CLAIM_BONUS_COUNT); + uint64_t claim_count = 1; + if (count_pos == _status.end()) { + _status.emplace(_self, [&](auto& info) { + info.id = STATUS_ID_CLAIM_BONUS_COUNT; + info.val = claim_count; + }); + count_pos = _status.find(STATUS_ID_CLAIM_BONUS_COUNT); + } else { + claim_count = count_pos->val + 1; + _status.modify(count_pos, 0, [&](auto& info) { + info.val = claim_count; + }); + } + + if (claim_count > CLAIM_BONUS_HISTORY_NUM) { + _dividends.erase(_dividends.begin()); + } + + _dividends.emplace(_self, [&](auto& info) { + info.id = claim_count; + info.player = owner; + info.time = ct; + + if (to_bonus.amount > 0) { + info.bonus.push_back(to_bonus); + } + if (to_lucky_bonus.amount > 0) { + info.bonus.push_back(to_lucky_bonus); + } + if (to_add_bonus.amount > 0) { + info.bonus.push_back(to_add_bonus); + } + if (to_atd_bonus.amount > 0) { + info.bonus.push_back(to_atd_bonus); + } + if (to_dac_bonus.amount > 0) { + info.bonus.push_back(to_dac_bonus); + } + if (to_horus_bonus.amount > 0) { + info.bonus.push_back(to_horus_bonus); + } + if (to_iq_bonus.amount > 0) { + info.bonus.push_back(to_iq_bonus); + } + if (to_karma_bonus.amount > 0) { + info.bonus.push_back(to_karma_bonus); + } + if (to_meet_bonus.amount > 0) { + info.bonus.push_back(to_meet_bonus); + } + if (to_black_bonus.amount > 0) { + info.bonus.push_back(to_black_bonus); + } + }); + } + + void lottery::eraseclaims() { + require_auth(_self); + claims_table claims(_self, _self); + for(auto itr=claims.begin(); itr != claims.end(); ) { + _dividends.emplace(_self, [&](auto& info) { + info.id = itr->id; + info.player = itr->player; + info.time = itr->time; + info.bonus.push_back(itr->bonus); + }); + + itr = claims.erase(itr); + } + } + + asset lottery::divide_token(account_name to, account_name token_account, symbol_name sym, const double percent) { + auto pos = _status.find(STATUS_ID_CLAIM_SUB_TOKEN_ACTIVE); + if (sym != EOS_SYMBOL && (pos == _status.end() || pos->val != true )) { + return asset(0, sym); + } + + symbol_name sname = symbol_type(sym).name(); + auto token_pos = _tokens.find(sname); + if (token_pos == _tokens.end()) { + return asset(0, sym);; + } + + asset to_dividend = asset(token_pos->balance.amount * percent, sym); + if (to_dividend.amount <= 0) { + return to_dividend; + } + + INLINE_ACTION_SENDER(eosio::token, transfer)( token_account, {DIVI_ACCOUNT, N(active)}, {DIVI_ACCOUNT, to, to_dividend, "[eos.win] Claim token dividend."} ); + + return to_dividend; + } + + void lottery::snapshot_token_balance() { + uint64_t data[10][2] = { + {TOKEN_CONTRACT, EOS_SYMBOL}, {GAME_TOKEN_CONTRACT, GAME_SYMBOL}, + {ADD_CONTRACT, ADD_SYMBOL}, {ATD_CONTRACT, ATD_SYMBOL}, + {DAC_CONTRACT, DAC_SYMBOL}, {HORUS_CONTRACT, HORUS_SYMBOL}, + {IQ_CONTRACT, IQ_SYMBOL}, {KARMA_CONTRACT, KARMA_SYMBOL}, + {BLACK_CONTRACT, BLACK_SYMBOL}, {MEET_CONTRACT, MEET_SYMBOL} + }; + for (int i=0; i<10; i++) { + eosio::token tokener(data[i][0]); + symbol_name sname = symbol_type(data[i][1]).name(); + uint64_t b_amount = tokener.get_balance_amount(DIVI_ACCOUNT, sname); + auto token_pos = _tokens.find(sname); + if (token_pos == _tokens.end()) { + _tokens.emplace(_self, [&](auto& info) { + info.balance = asset(b_amount, data[i][1]); + }); + } else { + _tokens.modify(token_pos, 0, [&](auto& info) { + info.balance = asset(b_amount, data[i][1]); + }); + } + } + } + + void lottery::activesub(bool active) { + require_auth(_self); + auto pos = _status.find(STATUS_ID_CLAIM_SUB_TOKEN_ACTIVE); + if(pos == _status.end()) { + _status.emplace(_self, [&](auto& info) { + info.id = STATUS_ID_CLAIM_SUB_TOKEN_ACTIVE; + info.val = active; + }); + } else { + _status.modify(pos, 0, [&](auto& info) { + info.val = active; + }); + } + } + + void lottery::activebonus(bool active) { + require_auth(_self); + auto pos = _status.find(STATUS_ID_BONUS_ACTIVE); + if(pos == _status.end()) { + _status.emplace(_self, [&](auto& info) { + info.id = STATUS_ID_BONUS_ACTIVE; + info.val = active; + }); + } else { + _status.modify(pos, 0, [&](auto& info) { + info.val = active; + }); + } + } + + void lottery::erasehistory(uint64_t offset, uint64_t limit) { + if (_global_state.cur_round <= HISTORY_NUM) { + return; + } + + auto max_round = _global_state.cur_round - HISTORY_NUM; + for (auto itr = _rounds.begin(); itr->round <= max_round; ) { + itr = _rounds.erase(itr); + } + + for (auto fee_itr = _roundfee.begin(); fee_itr != _roundfee.end() && fee_itr->round <= max_round; ) { + fee_itr = _roundfee.erase(fee_itr); + } + + eosio_assert(offset > 0 && limit > 0, "offset > 0 && limit > 0."); + auto temp_round = offset + limit - 1; + temp_round = temp_round < max_round ? temp_round : max_round; + while(temp_round >= offset) { + bills_table bills(_self, temp_round); + + for(auto bill_itr = bills.begin(); bill_itr != bills.end();) { + bill_itr = bills.erase(bill_itr); + } + + players_table players(_self, temp_round); + for(auto player_itr = players.begin(); player_itr != players.end();) { + player_itr = players.erase(player_itr); + } + + temp_round -= 1; + } + + } +}; + + +#define eosio_ABI_EX(TYPE, MEMBERS) \ + extern "C" \ + { \ + void apply(uint64_t receiver, uint64_t code, uint64_t action) \ + { \ + if (action == N(onerror)) \ + { \ + /* onerror is only valid if it is for the "eosio" code account and \ + * authorized by "EOS"'s "active permission */ \ + eosio_assert(code == N(eosio), "onerror action's are only valid from " \ + "the \"EOS\" system account"); \ + } \ + auto self = receiver; \ + if (code == N(eosio.token) && action == N(transfer)) { \ + TYPE thiscontract(self); \ + eosio::execute_action( &thiscontract, &eoswin::lottery::transfer ); \ + } \ + \ + if (code == self || action == N(onerror)) \ + { \ + TYPE thiscontract(self); \ + switch (action) \ + { \ + EOSIO_API(TYPE, MEMBERS) \ + } \ + /* does not allow destructor of thiscontract to run: enu_exit(0); */ \ + } \ + } \ + } + +eosio_ABI_EX( eoswin::lottery, (delaydraw)(drawing)(draw)(active)(setactived)(claimbonus)(activesub)(activebonus)(eraseclaims)(setstatus)) diff --git a/lottery/lottery.hpp b/lottery/lottery.hpp new file mode 100644 index 0000000..b8ea8c5 --- /dev/null +++ b/lottery/lottery.hpp @@ -0,0 +1,232 @@ +/** + * @file + * @copyright defined in eos/LICENSE.txt + */ +#include +#include +#include +#include +#include +#include +#include +#include +#include "config.hpp" +#include "token.hpp" + +namespace eoswin { + using namespace eosio; + + #define ACTIVITY_ACCOUNT N(activity) + #define TOKEN_ACCOUNT GAME_TOKEN_CONTRACT + #define HISTORY_NUM 5 + #define CLAIM_BONUS_HISTORY_NUM 100 + + #define STATUS_ID_BONUS_ACTIVE 101 + #define STATUS_ID_CLAIM_BONUS_COUNT 102 + #define STATUS_ID_CLAIM_SUB_TOKEN_ACTIVE 103 + #define STATUS_ID_CLAIM_PEROID_BASE_TIME 104 + #define STATUS_ID_CLAIM_PEROID_ACC_INTERVAL 105 + #define STATUS_ID_CLAIM_PEROID_CLAIM_INTERVAL 106 + #define STATUS_ID_TOKEN_SNAPSHOT_TIME 107 + + const uint64_t useconds_draw_interval = 2*3600*uint64_t(1000000); + const uint64_t useconds_claim_token_bonus_interval = 24*3600*uint64_t(1000000); + const uint16_t max_player_bills_per_round = 50; + + //@abi table global i64 + struct global_item { + asset key_price; + uint64_t cur_round; + account_name token_account; + account_name team_account; + uint8_t token_bonus; + uint8_t team_fee; + uint8_t drawer_fee; + asset drawer_fee_max; + uint8_t mine_probability; + uint8_t mine_team_fee; + uint8_t mine_referral_fee; + asset total_claimed_token_bonus; + uint32_t total_users; + bool active; + + EOSLIB_SERIALIZE( global_item, (key_price)(cur_round)(token_account)(team_account)(token_bonus)(team_fee)(drawer_fee)(drawer_fee_max)(mine_probability)(mine_team_fee)(mine_referral_fee)(total_claimed_token_bonus)(total_users)(active) ) + }; + typedef eosio::singleton global_singleton; + + //@abi table rounds i64 + struct round_item { + uint64_t round; + uint64_t bills_num; + uint64_t last_key; + asset reward_bucket; + account_name draw_account; + uint64_t start_time; + uint64_t draw_time; + uint64_t lucky_key; + account_name lucky_player; + uint64_t primary_key()const {return round;} + + EOSLIB_SERIALIZE( round_item, (round)(bills_num)(last_key)(reward_bucket)(draw_account)(start_time)(draw_time)(lucky_key)(lucky_player) ) + }; + typedef eosio::multi_index rounds_table; + + //@abi table roundfee i64 + struct roundfee_item { + uint64_t round; + asset to_team; + asset to_bonus; + asset to_drawer; + asset to_lucky; + uint64_t primary_key()const {return round;} + EOSLIB_SERIALIZE( roundfee_item, (round)(to_team)(to_bonus)(to_drawer)(to_lucky) ) + }; + typedef eosio::multi_index roundfee_table; + + //@abi table bills i64 + struct bill_item { + uint64_t id; + account_name player; + uint64_t low; + uint64_t high; + asset mine_token; + account_name referal; + uint64_t time; + + uint64_t primary_key()const {return id;} + account_name byplayer()const { return player; } + + EOSLIB_SERIALIZE( bill_item, (id)(player)(low)(high)(mine_token)(referal)(time)) + }; + typedef eosio::multi_index > + > bills_table; + + //@abi table players i64 + struct player_item { + account_name player; + uint16_t bills_num; + + uint64_t primary_key()const {return player;} + + EOSLIB_SERIALIZE( player_item, (player)(bills_num)) + }; + typedef eosio::multi_index players_table; + + //@abi table status i64 + struct status { + uint64_t id; + uint64_t val; + + uint64_t primary_key()const {return id;} + EOSLIB_SERIALIZE( status, (id)(val)) + }; + typedef eosio::multi_index status_table; + + //@abi table claims i64 + struct claim_item { + uint64_t id; + account_name player; + asset bonus; + uint64_t time; + + uint64_t primary_key()const {return id;} + EOSLIB_SERIALIZE(claim_item, (id)(player)(bonus)(time)) + }; + typedef eosio::multi_index claims_table; + + //@abi table dividends i64 + struct dividend_item { + uint64_t id; + account_name player; + vector bonus; + uint64_t time; + + uint64_t primary_key()const {return id;} + EOSLIB_SERIALIZE(dividend_item, (id)(player)(bonus)(time)) + }; + typedef eosio::multi_index dividends_table; + + //@abi table tokens i64 + struct token_item { + asset balance; + + uint64_t primary_key()const {return balance.symbol.name();} + EOSLIB_SERIALIZE(token_item, (balance)) + }; + typedef eosio::multi_index tokens_table; + + class lottery : public eosio::contract { + public: + lottery(account_name name); + + ~lottery(); + + global_item get_default_parameters(); + + void issue_game_token(account_name to, asset quantity, string memo); + + void get_stage_fees(const asset& bucket, uint8_t& lucky_fee, uint8_t& team_fee); + + /// @abi action + void active(account_name actor); + + ///@abi action + void setactived(bool actived); + + // @abi action + void setstatus(uint64_t id, uint64_t val); + + void newround(account_name actor); + + void endround(); + + void transfer(account_name from, account_name to); + + bill_item buykeys(account_name buyer, asset quantity, string memo); + + uint64_t mine(uint64_t keynum); + + uint64_t randomkey(uint64_t max); + + /// @abi action + void delaydraw(account_name drawer); + + /// @abi action + void drawing(account_name drawer); + + /// @abi action + void draw(account_name drawer); + + /// @abi action + void claimbonus(account_name actor, account_name owner); + + asset divide_token(account_name to, account_name token_account, symbol_name sym, const double percent); + + void snapshot_token_balance(); + + /// @abi action + void activesub(bool active); + + /// @abi action + void activebonus(bool active); + + /// @abi action + void eraseclaims(); + + void erasehistory(uint64_t offset = 1, uint64_t limit = 1); + + private: + global_singleton _global; + global_item _global_state; + rounds_table _rounds; + roundfee_table _roundfee; + + token _game_token; + symbol_name _game_token_symbol; + + status_table _status; + dividends_table _dividends; + tokens_table _tokens; + }; +} \ No newline at end of file diff --git a/lottery/lottery.wasm b/lottery/lottery.wasm new file mode 100644 index 0000000000000000000000000000000000000000..6017ec4c66b75333375d9277f98eb762415ebf98 GIT binary patch literal 98629 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 z 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 SDoQMd@gLKBb%YiUg8u{2xDP@A literal 0 HcmV?d00001 diff --git a/lottery/lottery.wast b/lottery/lottery.wast new file mode 100644 index 0000000..f576bbc --- /dev/null +++ b/lottery/lottery.wast @@ -0,0 +1,66380 @@ +(module + (type $FUNCSIG$vijj (func (param i32 i64 i64))) + (type $FUNCSIG$vij (func (param i32 i64))) + (type $FUNCSIG$vii (func (param i32 i32))) + (type $FUNCSIG$vi (func (param i32))) + (type $FUNCSIG$v (func)) + (type $FUNCSIG$iiii (func (param i32 i32 i32) (result i32))) + (type $FUNCSIG$j (func (result i64))) + (type $FUNCSIG$vjj (func (param i64 i64))) + (type $FUNCSIG$ijjjj (func (param i64 i64 i64 i64) (result i32))) + (type $FUNCSIG$ijjjjii (func (param i64 i64 i64 i64 i32 i32) (result i32))) + (type $FUNCSIG$vijii (func (param i32 i64 i32 i32))) + (type $FUNCSIG$vj (func (param i64))) + (type $FUNCSIG$vijiii (func (param i32 i64 i32 i32 i32))) + (type $FUNCSIG$ijjjij (func (param i64 i64 i64 i32 i64) (result i32))) + (type $FUNCSIG$iii (func (param i32 i32) (result i32))) + (type $FUNCSIG$ijjjii (func (param i64 i64 i64 i32 i32) (result i32))) + (type $FUNCSIG$ijjjji (func (param i64 i64 i64 i64 i32) (result i32))) + (type $FUNCSIG$ijjj (func (param i64 i64 i64) (result i32))) + (type $FUNCSIG$i (func (result i32))) + (type $FUNCSIG$viii (func (param i32 i32 i32))) + (type $FUNCSIG$vijjjj (func (param i32 i64 i64 i64 i64))) + (type $FUNCSIG$vid (func (param i32 f64))) + (type $FUNCSIG$ijj (func (param i64 i64) (result i32))) + (import "env" "__addtf3" (func $__addtf3 (param i32 i64 i64 i64 i64))) + (import "env" "__eqtf2" (func $__eqtf2 (param i64 i64 i64 i64) (result i32))) + (import "env" "__extenddftf2" (func $__extenddftf2 (param i32 f64))) + (import "env" "__fixtfsi" (func $__fixtfsi (param i64 i64) (result i32))) + (import "env" "__fixunstfsi" (func $__fixunstfsi (param i64 i64) (result i32))) + (import "env" "__floatsitf" (func $__floatsitf (param i32 i32))) + (import "env" "__floatunsitf" (func $__floatunsitf (param i32 i32))) + (import "env" "__multf3" (func $__multf3 (param i32 i64 i64 i64 i64))) + (import "env" "__multi3" (func $__multi3 (param i32 i64 i64 i64 i64))) + (import "env" "__netf2" (func $__netf2 (param i64 i64 i64 i64) (result i32))) + (import "env" "__subtf3" (func $__subtf3 (param i32 i64 i64 i64 i64))) + (import "env" "__unordtf2" (func $__unordtf2 (param i64 i64 i64 i64) (result i32))) + (import "env" "abort" (func $abort)) + (import "env" "action_data_size" (func $action_data_size (result i32))) + (import "env" "current_receiver" (func $current_receiver (result i64))) + (import "env" "current_time" (func $current_time (result i64))) + (import "env" "db_end_i64" (func $db_end_i64 (param i64 i64 i64) (result i32))) + (import "env" "db_find_i64" (func $db_find_i64 (param i64 i64 i64 i64) (result i32))) + (import "env" "db_get_i64" (func $db_get_i64 (param i32 i32 i32) (result i32))) + (import "env" "db_idx64_find_primary" (func $db_idx64_find_primary (param i64 i64 i64 i32 i64) (result i32))) + (import "env" "db_idx64_lowerbound" (func $db_idx64_lowerbound (param i64 i64 i64 i32 i32) (result i32))) + (import "env" "db_idx64_next" (func $db_idx64_next (param i32 i32) (result i32))) + (import "env" "db_idx64_remove" (func $db_idx64_remove (param i32))) + (import "env" "db_idx64_store" (func $db_idx64_store (param i64 i64 i64 i64 i32) (result i32))) + (import "env" "db_lowerbound_i64" (func $db_lowerbound_i64 (param i64 i64 i64 i64) (result i32))) + (import "env" "db_next_i64" (func $db_next_i64 (param i32 i32) (result i32))) + (import "env" "db_previous_i64" (func $db_previous_i64 (param i32 i32) (result i32))) + (import "env" "db_remove_i64" (func $db_remove_i64 (param i32))) + (import "env" "db_store_i64" (func $db_store_i64 (param i64 i64 i64 i64 i32 i32) (result i32))) + (import "env" "db_update_i64" (func $db_update_i64 (param i32 i64 i32 i32))) + (import "env" "eosio_assert" (func $eosio_assert (param i32 i32))) + (import "env" "memcpy" (func $memcpy (param i32 i32 i32) (result i32))) + (import "env" "memset" (func $memset (param i32 i32 i32) (result i32))) + (import "env" "read_action_data" (func $read_action_data (param i32 i32) (result i32))) + (import "env" "require_auth" (func $require_auth (param i64))) + (import "env" "require_auth2" (func $require_auth2 (param i64 i64))) + (import "env" "send_deferred" (func $send_deferred (param i32 i64 i32 i32 i32))) + (import "env" "send_inline" (func $send_inline (param i32 i32))) + (import "env" "sha256" (func $sha256 (param i32 i32 i32))) + (import "env" "tapos_block_num" (func $tapos_block_num (result i32))) + (import "env" "tapos_block_prefix" (func $tapos_block_prefix (result i32))) + (table 13 13 anyfunc) + (elem (i32.const 0) $__wasm_nullptr $_ZN6eoswin7lottery8transferEyy $_ZN6eoswin7lottery9activesubEb $_ZN6eoswin7lottery11eraseclaimsEv $_ZN6eoswin7lottery9setstatusEyy $_ZN6eoswin7lottery9delaydrawEy $_ZN6eoswin7lottery6activeEy $_ZN6eoswin7lottery11activebonusEb $_ZN6eoswin7lottery4drawEy $_ZN6eoswin7lottery7drawingEy $_ZN6eoswin7lottery10setactivedEb $_ZN6eoswin7lottery10claimbonusEyy $sn_write) + (memory $0 1) + (data (i32.const 4) "\00y\00\00") + (data (i32.const 16) "eoslucktoken\00") + (data (i32.const 32) "object passed to iterator_to is not in multi_index\00") + (data (i32.const 96) "singleton does not exist\00") + (data (i32.const 128) "invalid symbol name\00") + (data (i32.const 160) "luckyaddress\00") + (data (i32.const 176) "magnitude of asset amount must be less than 2^62\00") + (data (i32.const 240) "error reading iterator\00") + (data (i32.const 272) "read\00") + (data (i32.const 288) "cannot pass end iterator to modify\00") + (data (i32.const 336) "cannot create objects in table of another contract\00") + (data (i32.const 400) "write\00") + (data (i32.const 416) "object passed to modify is not in multi_index\00") + (data (i32.const 464) "cannot modify objects in table of another contract\00") + (data (i32.const 528) "updater cannot change primary key when modifying an object\00") + (data (i32.const 592) "active\00") + (data (i32.const 608) "only issue for game token\00") + (data (i32.const 640) "lottery can\'t be actived twice!\00") + (data (i32.const 672) "new round number is smaller than or equal with the old!\00") + (data (i32.const 736) "unable to find key\00") + (data (i32.const 768) "multiplication overflow\00") + (data (i32.const 800) "multiplication underflow\00") + (data (i32.const 832) "divide by zero\00") + (data (i32.const 848) "signed division overflow\00") + (data (i32.const 880) "comparison of assets with different symbols is not allowed\00") + (data (i32.const 944) "join game first\00") + (data (i32.const 960) "activity\00") + (data (i32.const 976) "attempt to subtract asset with different symbol\00") + (data (i32.const 1024) "subtraction underflow\00") + (data (i32.const 1056) "subtraction overflow\00") + (data (i32.const 1088) "eosio.token\00") + (data (i32.const 1104) "eoswinbonus1\00") + (data (i32.const 1120) "[eos.win] To EOS.Win Bonus Pool [https://eos.win/lottery]\00") + (data (i32.const 1184) "[eos.win] Team fee\00") + (data (i32.const 1216) "transfer\00") + (data (i32.const 1232) "[eos.win] Round drawer reward\00") + (data (i32.const 1264) "[eosluckygame@eos.win][round: %lld][lucky key: %lld] winner reward\00") + (data (i32.const 1344) "cannot increment end iterator\00") + (data (i32.const 1376) "deposit\00") + (data (i32.const 1392) "attempt to add asset with different symbol\00") + (data (i32.const 1440) "addition underflow\00") + (data (i32.const 1472) "addition overflow\00") + (data (i32.const 1504) "lottery not activated yet!\00") + (data (i32.const 1536) "transfer invalid quantity\00") + (data (i32.const 1568) "amount can\'t be smaller than the key price\00") + (data (i32.const 1616) "round number not found\00") + (data (i32.const 1648) "accept EOS only\00") + (data (i32.const 1680) "round number can\'t be found in rounds table error!\00") + (data (i32.const 1744) "transfer number must be integer multiples of key price\00") + (data (i32.const 1808) "low key is out of range while buy keys\00") + (data (i32.const 1856) "high key is out of range while buy keys\00") + (data (i32.const 1904) "referal can\'t be self!\00") + (data (i32.const 1936) "[lottery@eos.win] LUCKY token for dev team\00") + (data (i32.const 1984) "[lottery@eos.win] LUCKY token for referal\00") + (data (i32.const 2032) "[lottery@eos.win] LUCKY token for player\00") + (data (i32.const 2080) "next primary key in table is at autoincrement limit\00") + (data (i32.const 2144) "max 500 bills for one player per round\00") + (data (i32.const 2192) "cannot decrement end iterator when the table is empty\00") + (data (i32.const 2256) "cannot decrement iterator at beginning of table\00") + (data (i32.const 2304) "lottery game has not began!\00") + (data (i32.const 2336) "get\00") + (data (i32.const 2352) "random max must > 0\00") + (data (i32.const 2384) "lottery has not been actived!\00") + (data (i32.const 2416) "round is missing!\00") + (data (i32.const 2448) "none buy keys\00") + (data (i32.const 2464) "draw time has not cool down!\00") + (data (i32.const 2496) "join game first!\00") + (data (i32.const 2528) "drawing\00") + (data (i32.const 2544) "draw\00") + (data (i32.const 2560) "cannot pass end iterator to erase\00") + (data (i32.const 2608) "offset > 0 && limit > 0.\00") + (data (i32.const 2640) "object passed to erase is not in multi_index\00") + (data (i32.const 2688) "cannot erase objects in table of another contract\00") + (data (i32.const 2752) "attempt to remove object that was not in multi_index\00") + (data (i32.const 2816) "bonus has been locked!\00") + (data (i32.const 2848) "can not find claim base time\00") + (data (i32.const 2880) "can not find accumulate interval\00") + (data (i32.const 2928) "can not find claim interval\00") + (data (i32.const 2960) "%lld is not in claim time [%lld, %lld], base time: %lld\00") + (data (i32.const 3024) "claim token bonus time has not cool down yet!\00") + (data (i32.const 3072) "has no game token issued!\00") + (data (i32.const 3104) "has no game token!\00") + (data (i32.const 3136) "eosadddddddd\00") + (data (i32.const 3152) "eosatidiumio\00") + (data (i32.const 3168) "eosdactokens\00") + (data (i32.const 3184) "horustokenio\00") + (data (i32.const 3200) "everipediaiq\00") + (data (i32.const 3216) "therealkarma\00") + (data (i32.const 3232) "eosiomeetone\00") + (data (i32.const 3248) "eosblackteam\00") + (data (i32.const 3264) "[eos.win] Claim token dividend.\00") + (data (i32.const 3296) "\00\a6\824\03\ea0U\04EOS\00\00\00\000\15\a4\19\"\1d1U\04LUCKY\00\00\90RJ)\a5d0U\04ADD\00\00\00\00@\9d\d4.\b9l0U\04ATD\00\00\00\00\80\a7\824#\930U\04EOSDAC\00@\ddT\90f\ac/m\04HORUS\00\00`\9dqIUw\d5V\04IQ\00\00\00\00\00`\e450\1auU\cb\04KARMA\00\00 \8d\ca\10\99x0U\04BLACK\00\00\a0&\cdJI\ea0U\04MEETONE") + (data (i32.const 3456) "onerror\00") + (data (i32.const 3472) "eosio\00") + (data (i32.const 3488) "onerror action\'s are only valid from the \"EOS\" system account\00") + (data (i32.const 11952) "malloc_from_freed was designed to only be called after _heap was completely allocated\00") + (data (i32.const 12048) "\19\00\n\00\19\19\19\00\00\00\00\05\00\00\00\00\00\00\t\00\00\00\00\0b\00\00\00\00\00\00\00\00\19\00\11\n\19\19\19\03\n\07\00\01\1b\t\0b\18\00\00\t\06\0b\00\00\0b\00\06\19\00\00\00\19\19\19\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\0e\00\00\00\00\00\00\00\00\19\00\n\0d\19\19\19\00\0d\00\00\02\00\t\0e\00\00\00\t\00\0e\00\00\0e\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\0c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\00\13\00\00\00\00\t\0c\00\00\00\00\00\0c\00\00\0c\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\10\00\00\00\00\00\00\00\00\00\00\00\0f\00\00\00\04\0f\00\00\00\00\t\10\00\00\00\00\00\10\00\00\10\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\12\00\00\00\00\00\00\00\00\00\00\00\11\00\00\00\00\11\00\00\00\00\t\12\00\00\00\00\00\12\00\00\12\00\00\1a\00\00\00\1a\1a\1a\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\1a\1a\1a\00\00\00\00\00\00\t\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\00\00\00\00\00\00\00\00\17\00\00\00\00\17\00\00\00\00\t\14\00\00\00\00\00\14\00\00\14\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\16\00\00\00\00\00\00\00\00\00\00\00\15\00\00\00\00\15\00\00\00\00\t\16\00\00\00\00\00\16\00\00\16\00\00") + (data (i32.const 12512) "0123456789ABCDEF") + (data (i32.const 12528) "-+ 0X0x\00") + (data (i32.const 12544) "(null)\00") + (data (i32.const 12560) "-0X+0X 0X-0x+0x 0x\00") + (data (i32.const 12592) "inf\00") + (data (i32.const 12608) "INF\00") + (data (i32.const 12624) "nan\00") + (data (i32.const 12640) "NAN\00") + (data (i32.const 12656) ".\00") + (data (i32.const 12672) "T!\"\19\0d\01\02\03\11K\1c\0c\10\04\0b\1d\12\1e\'hnopqb \05\06\0f\13\14\15\1a\08\16\07($\17\18\t\n\0e\1b\1f%#\83\82}&*+<=>?CGJMXYZ[\\]^_`acdefgijklrstyz{|\00") + (data (i32.const 12768) "Illegal byte sequence\00Domain error\00Result not representable\00Not a tty\00Permission denied\00Operation not permitted\00No such file or directory\00No such process\00File exists\00Value too large for data type\00No space left on device\00Out of memory\00Resource busy\00Interrupted system call\00Resource temporarily unavailable\00Invalid seek\00Cross-device link\00Read-only file system\00Directory not empty\00Connection reset by peer\00Operation timed out\00Connection refused\00Host is down\00Host is unreachable\00Address in use\00Broken pipe\00I/O error\00No such device or address\00Block device required\00No such device\00Not a directory\00Is a directory\00Text file busy\00Exec format error\00Invalid argument\00Argument list too long\00Symbolic link loop\00Filename too long\00Too many open files in system\00No file descriptors available\00Bad file descriptor\00No child process\00Bad address\00File too large\00Too many links\00No locks available\00Resource deadlock would occur\00State not recoverable\00Previous owner died\00Operation canceled\00Function not implemented\00No message of desired type\00Identifier removed\00Device not a stream\00No data available\00Device timeout\00Out of streams resources\00Link has been severed\00Protocol error\00Bad message\00File descriptor in bad state\00Not a socket\00Destination address required\00Message too large\00Protocol wrong type for socket\00Protocol not available\00Protocol not supported\00Socket type not supported\00Not supported\00Protocol family not supported\00Address family not supported by protocol\00Address not available\00Network is down\00Network unreachable\00Connection reset by network\00Connection aborted\00No buffer space available\00Socket is connected\00Socket not connected\00Cannot send after socket shutdown\00Operation already in progress\00Operation in progress\00Stale file handle\00Remote I/O error\00Quota exceeded\00No medium found\00Wrong medium type\00No error information\00\00") + (export "memory" (memory $0)) + (export "_ZeqRK11checksum256S1_" (func $_ZeqRK11checksum256S1_)) + (export "_ZeqRK11checksum160S1_" (func $_ZeqRK11checksum160S1_)) + (export "_ZneRK11checksum160S1_" (func $_ZneRK11checksum160S1_)) + (export "now" (func $now)) + (export "_ZN5eosio12require_authERKNS_16permission_levelE" (func $_ZN5eosio12require_authERKNS_16permission_levelE)) + (export "_ZN6eoswin7lotteryC2Ey" (func $_ZN6eoswin7lotteryC2Ey)) + (export "_ZN6eoswin7lottery22get_default_parametersEv" (func $_ZN6eoswin7lottery22get_default_parametersEv)) + (export "_ZN6eoswin7lotteryD2Ev" (func $_ZN6eoswin7lotteryD2Ev)) + (export "_ZN6eoswin7lottery16issue_game_tokenEyN5eosio5assetENSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE" (func $_ZN6eoswin7lottery16issue_game_tokenEyN5eosio5assetENSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE)) + (export "_ZN6eoswin7lottery14get_stage_feesERKN5eosio5assetERhS5_" (func $_ZN6eoswin7lottery14get_stage_feesERKN5eosio5assetERhS5_)) + (export "_ZN6eoswin7lottery6activeEy" (func $_ZN6eoswin7lottery6activeEy)) + (export "_ZN6eoswin7lottery8newroundEy" (func $_ZN6eoswin7lottery8newroundEy)) + (export "_ZN6eoswin7lottery10setactivedEb" (func $_ZN6eoswin7lottery10setactivedEb)) + (export "_ZN6eoswin7lottery9setstatusEyy" (func $_ZN6eoswin7lottery9setstatusEyy)) + (export "_ZN6eoswin7lottery8endroundEv" (func $_ZN6eoswin7lottery8endroundEv)) + (export "_ZN6eoswin7lottery8transferEyy" (func $_ZN6eoswin7lottery8transferEyy)) + (export "_ZN6eoswin7lottery7buykeysEyN5eosio5assetENSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE" (func $_ZN6eoswin7lottery7buykeysEyN5eosio5assetENSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE)) + (export "_ZN6eoswin7lottery4mineEy" (func $_ZN6eoswin7lottery4mineEy)) + (export "_ZN6eoswin7lottery9randomkeyEy" (func $_ZN6eoswin7lottery9randomkeyEy)) + (export "_ZN6eoswin7lottery9delaydrawEy" (func $_ZN6eoswin7lottery9delaydrawEy)) + (export "_ZN6eoswin7lottery7drawingEy" (func $_ZN6eoswin7lottery7drawingEy)) + (export "_ZN6eoswin7lottery4drawEy" (func $_ZN6eoswin7lottery4drawEy)) + (export "_ZN6eoswin7lottery12erasehistoryEyy" (func $_ZN6eoswin7lottery12erasehistoryEyy)) + (export "_ZN6eoswin7lottery10claimbonusEyy" (func $_ZN6eoswin7lottery10claimbonusEyy)) + (export "_ZN6eoswin7lottery22snapshot_token_balanceEv" (func $_ZN6eoswin7lottery22snapshot_token_balanceEv)) + (export "_ZN6eoswin7lottery12divide_tokenEyyyd" (func $_ZN6eoswin7lottery12divide_tokenEyyyd)) + (export "_ZN6eoswin7lottery11eraseclaimsEv" (func $_ZN6eoswin7lottery11eraseclaimsEv)) + (export "_ZN6eoswin7lottery9activesubEb" (func $_ZN6eoswin7lottery9activesubEb)) + (export "_ZN6eoswin7lottery11activebonusEb" (func $_ZN6eoswin7lottery11activebonusEb)) + (export "apply" (func $apply)) + (export "malloc" (func $malloc)) + (export "free" (func $free)) + (export "sprintf" (func $sprintf)) + (export "vsprintf" (func $vsprintf)) + (export "vsnprintf" (func $vsnprintf)) + (export "__errno_location" (func $__errno_location)) + (export "vfprintf" (func $vfprintf)) + (export "__lockfile" (func $__lockfile)) + (export "__unlockfile" (func $__unlockfile)) + (export "__fwritex" (func $__fwritex)) + (export "strerror" (func $strerror)) + (export "strnlen" (func $strnlen)) + (export "wctomb" (func $wctomb)) + (export "__signbitl" (func $__signbitl)) + (export "__fpclassifyl" (func $__fpclassifyl)) + (export "frexpl" (func $frexpl)) + (export "wcrtomb" (func $wcrtomb)) + (export "memchr" (func $memchr)) + (export "__lctrans" (func $__lctrans)) + (export "__lctrans_impl" (func $__lctrans_impl)) + (export "__mo_lookup" (func $__mo_lookup)) + (export "strcmp" (func $strcmp)) + (export "__towrite" (func $__towrite)) + (export "memcmp" (func $memcmp)) + (export "strlen" (func $strlen)) + (func $_ZeqRK11checksum256S1_ (param $0 i32) (param $1 i32) (result i32) + (i32.eqz + (call $memcmp + (get_local $0) + (get_local $1) + (i32.const 32) + ) + ) + ) + (func $_ZeqRK11checksum160S1_ (param $0 i32) (param $1 i32) (result i32) + (i32.eqz + (call $memcmp + (get_local $0) + (get_local $1) + (i32.const 32) + ) + ) + ) + (func $_ZneRK11checksum160S1_ (param $0 i32) (param $1 i32) (result i32) + (i32.ne + (call $memcmp + (get_local $0) + (get_local $1) + (i32.const 32) + ) + (i32.const 0) + ) + ) + (func $now (result i32) + (i32.wrap/i64 + (i64.div_u + (call $current_time) + (i64.const 1000000) + ) + ) + ) + (func $_ZN5eosio12require_authERKNS_16permission_levelE (param $0 i32) + (call $require_auth2 + (i64.load + (get_local $0) + ) + (i64.load offset=8 + (get_local $0) + ) + ) + ) + (func $_ZN6eoswin7lotteryC2Ey (param $0 i32) (param $1 i64) (result i32) + (local $2 i32) + (local $3 i32) + (local $4 i64) + (local $5 i32) + (local $6 i32) + (local $7 i64) + (local $8 i64) + (local $9 i64) + (local $10 i32) + (i32.store offset=4 + (i32.const 0) + (tee_local $10 + (i32.sub + (i32.load offset=4 + (i32.const 0) + ) + (i32.const 96) + ) + ) + ) + (i64.store offset=8 + (get_local $0) + (get_local $1) + ) + (i64.store + (get_local $0) + (get_local $1) + ) + (i64.store + (i32.add + (get_local $0) + (i32.const 16) + ) + (get_local $1) + ) + (i64.store + (i32.add + (get_local $0) + (i32.const 24) + ) + (i64.const -1) + ) + (set_local $1 + (i64.const 0) + ) + (i64.store align=4 + (i32.add + (get_local $0) + (i32.const 32) + ) + (i64.const 0) + ) + (i32.store + (i32.add + (get_local $0) + (i32.const 40) + ) + (i32.const 0) + ) + (set_local $3 + (call $_ZN6eoswin11global_itemC2Ev + (i32.add + (get_local $0) + (i32.const 48) + ) + ) + ) + (i64.store + (i32.add + (get_local $0) + (i32.const 160) + ) + (i64.const -1) + ) + (i64.store align=4 + (i32.add + (get_local $0) + (i32.const 168) + ) + (i64.const 0) + ) + (i32.store + (i32.add + (get_local $0) + (i32.const 176) + ) + (i32.const 0) + ) + (i64.store offset=144 + (get_local $0) + (tee_local $4 + (i64.load + (get_local $0) + ) + ) + ) + (i64.store + (i32.add + (get_local $0) + (i32.const 152) + ) + (get_local $4) + ) + (i64.store offset=184 + (get_local $0) + (get_local $4) + ) + (i64.store + (i32.add + (get_local $0) + (i32.const 192) + ) + (get_local $4) + ) + (i64.store + (i32.add + (get_local $0) + (i32.const 200) + ) + (i64.const -1) + ) + (i32.store + (i32.add + (get_local $0) + (i32.const 208) + ) + (i32.const 0) + ) + (i32.store + (i32.add + (get_local $0) + (i32.const 212) + ) + (i32.const 0) + ) + (i32.store + (i32.add + (get_local $0) + (i32.const 216) + ) + (i32.const 0) + ) + (set_local $2 + (i32.add + (get_local $0) + (i32.const 8) + ) + ) + (set_local $7 + (i64.const 59) + ) + (set_local $6 + (i32.const 16) + ) + (set_local $8 + (i64.const 0) + ) + (loop $label$0 + (set_local $9 + (i64.const 0) + ) + (block $label$1 + (br_if $label$1 + (i64.gt_u + (get_local $1) + (i64.const 11) + ) + ) + (block $label$2 + (block $label$3 + (br_if $label$3 + (i32.gt_u + (i32.and + (i32.add + (tee_local $5 + (i32.load8_s + (get_local $6) + ) + ) + (i32.const -97) + ) + (i32.const 255) + ) + (i32.const 25) + ) + ) + (set_local $5 + (i32.add + (get_local $5) + (i32.const 165) + ) + ) + (br $label$2) + ) + (set_local $5 + (select + (i32.add + (get_local $5) + (i32.const 208) + ) + (i32.const 0) + (i32.lt_u + (i32.and + (i32.add + (get_local $5) + (i32.const -49) + ) + (i32.const 255) + ) + (i32.const 5) + ) + ) + ) + ) + (set_local $9 + (i64.shl + (i64.extend_u/i32 + (i32.and + (get_local $5) + (i32.const 31) + ) + ) + (i64.and + (get_local $7) + (i64.const 4294967295) + ) + ) + ) + ) + (set_local $6 + (i32.add + (get_local $6) + (i32.const 1) + ) + ) + (set_local $1 + (i64.add + (get_local $1) + (i64.const 1) + ) + ) + (set_local $8 + (i64.or + (get_local $9) + (get_local $8) + ) + ) + (br_if $label$0 + (i64.ne + (tee_local $7 + (i64.add + (get_local $7) + (i64.const -5) + ) + ) + (i64.const -6) + ) + ) + ) + (i64.store offset=224 + (get_local $0) + (get_local $8) + ) + (i64.store offset=248 + (get_local $0) + (get_local $4) + ) + (i64.store + (i32.add + (get_local $0) + (i32.const 232) + ) + (i64.const 86400000000) + ) + (i64.store + (i32.add + (get_local $0) + (i32.const 256) + ) + (get_local $4) + ) + (i64.store + (i32.add + (get_local $0) + (i32.const 264) + ) + (i64.const -1) + ) + (i64.store align=4 + (i32.add + (get_local $0) + (i32.const 272) + ) + (i64.const 0) + ) + (i32.store + (i32.add + (get_local $0) + (i32.const 280) + ) + (i32.const 0) + ) + (i64.store offset=288 + (get_local $0) + (get_local $4) + ) + (i64.store + (i32.add + (get_local $0) + (i32.const 296) + ) + (get_local $4) + ) + (i64.store + (i32.add + (get_local $0) + (i32.const 304) + ) + (i64.const -1) + ) + (i32.store + (i32.add + (get_local $0) + (i32.const 312) + ) + (i32.const 0) + ) + (i32.store + (i32.add + (get_local $0) + (i32.const 316) + ) + (i32.const 0) + ) + (i32.store + (i32.add + (get_local $0) + (i32.const 320) + ) + (i32.const 0) + ) + (i64.store offset=328 + (get_local $0) + (get_local $4) + ) + (i64.store + (i32.add + (get_local $0) + (i32.const 336) + ) + (get_local $4) + ) + (i64.store + (i32.add + (get_local $0) + (i32.const 344) + ) + (i64.const -1) + ) + (i32.store + (i32.add + (get_local $0) + (i32.const 352) + ) + (i32.const 0) + ) + (i32.store + (i32.add + (get_local $0) + (i32.const 356) + ) + (i32.const 0) + ) + (i32.store + (i32.add + (get_local $0) + (i32.const 360) + ) + (i32.const 0) + ) + (block $label$4 + (block $label$5 + (block $label$6 + (block $label$7 + (block $label$8 + (block $label$9 + (br_if $label$9 + (i32.eq + (tee_local $6 + (i32.load + (i32.add + (get_local $0) + (i32.const 36) + ) + ) + ) + (i32.load + (i32.add + (get_local $0) + (i32.const 32) + ) + ) + ) + ) + (call $eosio_assert + (i32.eq + (i32.load offset=96 + (tee_local $6 + (i32.load + (i32.add + (get_local $6) + (i32.const -24) + ) + ) + ) + ) + (get_local $2) + ) + (i32.const 32) + ) + (br_if $label$8 + (get_local $6) + ) + (br $label$7) + ) + (br_if $label$7 + (i32.lt_s + (tee_local $6 + (call $db_find_i64 + (i64.load + (i32.add + (get_local $0) + (i32.const 8) + ) + ) + (i64.load + (i32.add + (get_local $0) + (i32.const 16) + ) + ) + (i64.const 7235159537265672192) + (i64.const 7235159537265672192) + ) + ) + (i32.const 0) + ) + ) + (call $eosio_assert + (i32.eq + (i32.load offset=96 + (call $_ZNK5eosio11multi_indexILy7235159537265672192ENS_9singletonILy7235159537265672192EN6eoswin11global_itemEE3rowEJEE31load_object_by_primary_iteratorEl + (get_local $2) + (get_local $6) + ) + ) + (get_local $2) + ) + (i32.const 32) + ) + ) + (br_if $label$6 + (i32.eq + (tee_local $6 + (i32.load + (i32.add + (get_local $0) + (i32.const 36) + ) + ) + ) + (i32.load + (i32.add + (get_local $0) + (i32.const 32) + ) + ) + ) + ) + (call $eosio_assert + (i32.eq + (i32.load offset=96 + (tee_local $6 + (i32.load + (i32.add + (get_local $6) + (i32.const -24) + ) + ) + ) + ) + (get_local $2) + ) + (i32.const 32) + ) + (br $label$5) + ) + (call $_ZN6eoswin7lottery22get_default_parametersEv + (get_local $10) + (get_local $6) + ) + (br $label$4) + ) + (set_local $6 + (i32.const 0) + ) + (br_if $label$5 + (i32.lt_s + (tee_local $5 + (call $db_find_i64 + (i64.load + (i32.add + (get_local $0) + (i32.const 8) + ) + ) + (i64.load + (i32.add + (get_local $0) + (i32.const 16) + ) + ) + (i64.const 7235159537265672192) + (i64.const 7235159537265672192) + ) + ) + (i32.const 0) + ) + ) + (call $eosio_assert + (i32.eq + (i32.load offset=96 + (tee_local $6 + (call $_ZNK5eosio11multi_indexILy7235159537265672192ENS_9singletonILy7235159537265672192EN6eoswin11global_itemEE3rowEJEE31load_object_by_primary_iteratorEl + (get_local $2) + (get_local $5) + ) + ) + ) + (get_local $2) + ) + (i32.const 32) + ) + ) + (call $eosio_assert + (i32.ne + (get_local $6) + (i32.const 0) + ) + (i32.const 96) + ) + (drop + (call $memcpy + (get_local $10) + (get_local $6) + (i32.const 96) + ) + ) + ) + (drop + (call $memcpy + (get_local $3) + (get_local $10) + (i32.const 93) + ) + ) + (i64.store offset=240 + (get_local $0) + (i64.const 383514793292) + ) + (i32.store offset=4 + (i32.const 0) + (i32.add + (get_local $10) + (i32.const 96) + ) + ) + (get_local $0) + ) + (func $_ZN6eoswin11global_itemC2Ev (param $0 i32) (result i32) + (local $1 i64) + (local $2 i32) + (local $3 i32) + (i64.store offset=8 + (get_local $0) + (i64.const 1397703940) + ) + (i64.store + (get_local $0) + (i64.const 0) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 176) + ) + (set_local $1 + (i64.shr_u + (i64.load offset=8 + (get_local $0) + ) + (i64.const 8) + ) + ) + (set_local $2 + (i32.const 0) + ) + (block $label$0 + (block $label$1 + (loop $label$2 + (br_if $label$1 + (i32.gt_u + (i32.add + (i32.shl + (i32.wrap/i64 + (get_local $1) + ) + (i32.const 24) + ) + (i32.const -1073741825) + ) + (i32.const 452984830) + ) + ) + (block $label$3 + (br_if $label$3 + (i64.ne + (i64.and + (tee_local $1 + (i64.shr_u + (get_local $1) + (i64.const 8) + ) + ) + (i64.const 255) + ) + (i64.const 0) + ) + ) + (loop $label$4 + (br_if $label$1 + (i64.ne + (i64.and + (tee_local $1 + (i64.shr_u + (get_local $1) + (i64.const 8) + ) + ) + (i64.const 255) + ) + (i64.const 0) + ) + ) + (br_if $label$4 + (i32.lt_s + (tee_local $2 + (i32.add + (get_local $2) + (i32.const 1) + ) + ) + (i32.const 7) + ) + ) + ) + ) + (set_local $3 + (i32.const 1) + ) + (br_if $label$2 + (i32.lt_s + (tee_local $2 + (i32.add + (get_local $2) + (i32.const 1) + ) + ) + (i32.const 7) + ) + ) + (br $label$0) + ) + ) + (set_local $3 + (i32.const 0) + ) + ) + (call $eosio_assert + (get_local $3) + (i32.const 128) + ) + (i64.store + (tee_local $2 + (i32.add + (get_local $0) + (i32.const 56) + ) + ) + (i64.const 1397703940) + ) + (i64.store offset=48 + (get_local $0) + (i64.const 0) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 176) + ) + (set_local $1 + (i64.shr_u + (i64.load + (get_local $2) + ) + (i64.const 8) + ) + ) + (set_local $2 + (i32.const 0) + ) + (block $label$5 + (block $label$6 + (loop $label$7 + (br_if $label$6 + (i32.gt_u + (i32.add + (i32.shl + (i32.wrap/i64 + (get_local $1) + ) + (i32.const 24) + ) + (i32.const -1073741825) + ) + (i32.const 452984830) + ) + ) + (block $label$8 + (br_if $label$8 + (i64.ne + (i64.and + (tee_local $1 + (i64.shr_u + (get_local $1) + (i64.const 8) + ) + ) + (i64.const 255) + ) + (i64.const 0) + ) + ) + (loop $label$9 + (br_if $label$6 + (i64.ne + (i64.and + (tee_local $1 + (i64.shr_u + (get_local $1) + (i64.const 8) + ) + ) + (i64.const 255) + ) + (i64.const 0) + ) + ) + (br_if $label$9 + (i32.lt_s + (tee_local $2 + (i32.add + (get_local $2) + (i32.const 1) + ) + ) + (i32.const 7) + ) + ) + ) + ) + (set_local $3 + (i32.const 1) + ) + (br_if $label$7 + (i32.lt_s + (tee_local $2 + (i32.add + (get_local $2) + (i32.const 1) + ) + ) + (i32.const 7) + ) + ) + (br $label$5) + ) + ) + (set_local $3 + (i32.const 0) + ) + ) + (call $eosio_assert + (get_local $3) + (i32.const 128) + ) + (i64.store + (tee_local $2 + (i32.add + (get_local $0) + (i32.const 80) + ) + ) + (i64.const 1397703940) + ) + (i64.store offset=72 + (get_local $0) + (i64.const 0) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 176) + ) + (set_local $1 + (i64.shr_u + (i64.load + (get_local $2) + ) + (i64.const 8) + ) + ) + (set_local $2 + (i32.const 0) + ) + (block $label$10 + (block $label$11 + (loop $label$12 + (br_if $label$11 + (i32.gt_u + (i32.add + (i32.shl + (i32.wrap/i64 + (get_local $1) + ) + (i32.const 24) + ) + (i32.const -1073741825) + ) + (i32.const 452984830) + ) + ) + (block $label$13 + (br_if $label$13 + (i64.ne + (i64.and + (tee_local $1 + (i64.shr_u + (get_local $1) + (i64.const 8) + ) + ) + (i64.const 255) + ) + (i64.const 0) + ) + ) + (loop $label$14 + (br_if $label$11 + (i64.ne + (i64.and + (tee_local $1 + (i64.shr_u + (get_local $1) + (i64.const 8) + ) + ) + (i64.const 255) + ) + (i64.const 0) + ) + ) + (br_if $label$14 + (i32.lt_s + (tee_local $2 + (i32.add + (get_local $2) + (i32.const 1) + ) + ) + (i32.const 7) + ) + ) + ) + ) + (set_local $3 + (i32.const 1) + ) + (br_if $label$12 + (i32.lt_s + (tee_local $2 + (i32.add + (get_local $2) + (i32.const 1) + ) + ) + (i32.const 7) + ) + ) + (br $label$10) + ) + ) + (set_local $3 + (i32.const 0) + ) + ) + (call $eosio_assert + (get_local $3) + (i32.const 128) + ) + (get_local $0) + ) + (func $_ZNK5eosio11multi_indexILy7235159537265672192ENS_9singletonILy7235159537265672192EN6eoswin11global_itemEE3rowEJEE31load_object_by_primary_iteratorEl (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (local $8 i32) + (set_local $7 + (tee_local $8 + (i32.sub + (i32.load offset=4 + (i32.const 0) + ) + (i32.const 48) + ) + ) + ) + (i32.store offset=4 + (i32.const 0) + (get_local $8) + ) + (block $label$0 + (br_if $label$0 + (i32.eq + (tee_local $6 + (i32.load + (i32.add + (get_local $0) + (i32.const 28) + ) + ) + ) + (tee_local $2 + (i32.load offset=24 + (get_local $0) + ) + ) + ) + ) + (set_local $3 + (i32.sub + (i32.const 0) + (get_local $2) + ) + ) + (set_local $5 + (i32.add + (get_local $6) + (i32.const -24) + ) + ) + (loop $label$1 + (br_if $label$0 + (i32.eq + (i32.load + (i32.add + (get_local $5) + (i32.const 16) + ) + ) + (get_local $1) + ) + ) + (set_local $6 + (get_local $5) + ) + (set_local $5 + (tee_local $4 + (i32.add + (get_local $5) + (i32.const -24) + ) + ) + ) + (br_if $label$1 + (i32.ne + (i32.add + (get_local $4) + (get_local $3) + ) + (i32.const -24) + ) + ) + ) + ) + (block $label$2 + (block $label$3 + (br_if $label$3 + (i32.eq + (get_local $6) + (get_local $2) + ) + ) + (set_local $5 + (i32.load + (i32.add + (get_local $6) + (i32.const -24) + ) + ) + ) + (br $label$2) + ) + (call $eosio_assert + (i32.xor + (i32.shr_u + (tee_local $5 + (call $db_get_i64 + (get_local $1) + (i32.const 0) + (i32.const 0) + ) + ) + (i32.const 31) + ) + (i32.const 1) + ) + (i32.const 240) + ) + (block $label$4 + (block $label$5 + (br_if $label$5 + (i32.lt_u + (get_local $5) + (i32.const 513) + ) + ) + (set_local $4 + (call $malloc + (get_local $5) + ) + ) + (br $label$4) + ) + (i32.store offset=4 + (i32.const 0) + (tee_local $4 + (i32.sub + (get_local $8) + (i32.and + (i32.add + (get_local $5) + (i32.const 15) + ) + (i32.const -16) + ) + ) + ) + ) + ) + (drop + (call $db_get_i64 + (get_local $1) + (get_local $4) + (get_local $5) + ) + ) + (i32.store offset=36 + (get_local $7) + (get_local $4) + ) + (i32.store offset=32 + (get_local $7) + (get_local $4) + ) + (i32.store offset=40 + (get_local $7) + (i32.add + (get_local $4) + (get_local $5) + ) + ) + (block $label$6 + (br_if $label$6 + (i32.lt_u + (get_local $5) + (i32.const 513) + ) + ) + (call $free + (get_local $4) + ) + ) + (set_local $4 + (call $_ZN6eoswin11global_itemC2Ev + (tee_local $5 + (call $_Znwj + (i32.const 112) + ) + ) + ) + ) + (i32.store offset=96 + (get_local $5) + (get_local $0) + ) + (drop + (call $_ZN6eoswinrsIN5eosio10datastreamIPKcEEEERT_S7_RNS_11global_itemE + (i32.add + (get_local $7) + (i32.const 32) + ) + (get_local $4) + ) + ) + (i32.store offset=100 + (get_local $5) + (get_local $1) + ) + (i32.store offset=24 + (get_local $7) + (get_local $5) + ) + (i64.store offset=16 + (get_local $7) + (i64.const 7235159537265672192) + ) + (i32.store offset=12 + (get_local $7) + (tee_local $6 + (i32.load offset=100 + (get_local $5) + ) + ) + ) + (block $label$7 + (block $label$8 + (br_if $label$8 + (i32.ge_u + (tee_local $4 + (i32.load + (tee_local $1 + (i32.add + (get_local $0) + (i32.const 28) + ) + ) + ) + ) + (i32.load + (i32.add + (get_local $0) + (i32.const 32) + ) + ) + ) + ) + (i64.store offset=8 + (get_local $4) + (i64.const 7235159537265672192) + ) + (i32.store offset=16 + (get_local $4) + (get_local $6) + ) + (i32.store offset=24 + (get_local $7) + (i32.const 0) + ) + (i32.store + (get_local $4) + (get_local $5) + ) + (i32.store + (get_local $1) + (i32.add + (get_local $4) + (i32.const 24) + ) + ) + (br $label$7) + ) + (call $_ZNSt3__16vectorIN5eosio11multi_indexILy7235159537265672192ENS1_9singletonILy7235159537265672192EN6eoswin11global_itemEE3rowEJEE8item_ptrENS_9allocatorIS9_EEE24__emplace_back_slow_pathIJNS_10unique_ptrINS8_4itemENS_14default_deleteISF_EEEERyRlEEEvDpOT_ + (i32.add + (get_local $0) + (i32.const 24) + ) + (i32.add + (get_local $7) + (i32.const 24) + ) + (i32.add + (get_local $7) + (i32.const 16) + ) + (i32.add + (get_local $7) + (i32.const 12) + ) + ) + ) + (set_local $4 + (i32.load offset=24 + (get_local $7) + ) + ) + (i32.store offset=24 + (get_local $7) + (i32.const 0) + ) + (br_if $label$2 + (i32.eqz + (get_local $4) + ) + ) + (call $_ZdlPv + (get_local $4) + ) + ) + (i32.store offset=4 + (i32.const 0) + (i32.add + (get_local $7) + (i32.const 48) + ) + ) + (get_local $5) + ) + (func $_ZN6eoswin7lottery22get_default_parametersEv (param $0 i32) (param $1 i32) + (local $2 i32) + (local $3 i32) + (local $4 i64) + (local $5 i64) + (local $6 i64) + (local $7 i64) + (set_local $2 + (call $_ZN6eoswin11global_itemC2Ev + (get_local $0) + ) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 176) + ) + (set_local $0 + (i32.const 0) + ) + (set_local $5 + (i64.const 5459781) + ) + (block $label$0 + (block $label$1 + (loop $label$2 + (br_if $label$1 + (i32.gt_u + (i32.add + (i32.shl + (i32.wrap/i64 + (get_local $5) + ) + (i32.const 24) + ) + (i32.const -1073741825) + ) + (i32.const 452984830) + ) + ) + (block $label$3 + (br_if $label$3 + (i64.ne + (i64.and + (tee_local $5 + (i64.shr_u + (get_local $5) + (i64.const 8) + ) + ) + (i64.const 255) + ) + (i64.const 0) + ) + ) + (loop $label$4 + (br_if $label$1 + (i64.ne + (i64.and + (tee_local $5 + (i64.shr_u + (get_local $5) + (i64.const 8) + ) + ) + (i64.const 255) + ) + (i64.const 0) + ) + ) + (br_if $label$4 + (i32.lt_s + (tee_local $0 + (i32.add + (get_local $0) + (i32.const 1) + ) + ) + (i32.const 7) + ) + ) + ) + ) + (set_local $3 + (i32.const 1) + ) + (br_if $label$2 + (i32.lt_s + (tee_local $0 + (i32.add + (get_local $0) + (i32.const 1) + ) + ) + (i32.const 7) + ) + ) + (br $label$0) + ) + ) + (set_local $3 + (i32.const 0) + ) + ) + (call $eosio_assert + (get_local $3) + (i32.const 128) + ) + (i64.store offset=8 + (get_local $2) + (i64.const 1397703940) + ) + (i64.store + (get_local $2) + (i64.const 1000) + ) + (set_local $5 + (i64.const 0) + ) + (i64.store offset=16 + (get_local $2) + (i64.const 0) + ) + (set_local $4 + (i64.const 59) + ) + (set_local $0 + (i32.const 16) + ) + (set_local $6 + (i64.const 0) + ) + (loop $label$5 + (set_local $7 + (i64.const 0) + ) + (block $label$6 + (br_if $label$6 + (i64.gt_u + (get_local $5) + (i64.const 11) + ) + ) + (block $label$7 + (block $label$8 + (br_if $label$8 + (i32.gt_u + (i32.and + (i32.add + (tee_local $3 + (i32.load8_s + (get_local $0) + ) + ) + (i32.const -97) + ) + (i32.const 255) + ) + (i32.const 25) + ) + ) + (set_local $3 + (i32.add + (get_local $3) + (i32.const 165) + ) + ) + (br $label$7) + ) + (set_local $3 + (select + (i32.add + (get_local $3) + (i32.const 208) + ) + (i32.const 0) + (i32.lt_u + (i32.and + (i32.add + (get_local $3) + (i32.const -49) + ) + (i32.const 255) + ) + (i32.const 5) + ) + ) + ) + ) + (set_local $7 + (i64.shl + (i64.extend_u/i32 + (i32.and + (get_local $3) + (i32.const 31) + ) + ) + (i64.and + (get_local $4) + (i64.const 4294967295) + ) + ) + ) + ) + (set_local $0 + (i32.add + (get_local $0) + (i32.const 1) + ) + ) + (set_local $5 + (i64.add + (get_local $5) + (i64.const 1) + ) + ) + (set_local $6 + (i64.or + (get_local $7) + (get_local $6) + ) + ) + (br_if $label$5 + (i64.ne + (tee_local $4 + (i64.add + (get_local $4) + (i64.const -5) + ) + ) + (i64.const -6) + ) + ) + ) + (i64.store offset=24 + (get_local $2) + (get_local $6) + ) + (set_local $5 + (i64.const 0) + ) + (set_local $4 + (i64.const 59) + ) + (set_local $0 + (i32.const 160) + ) + (set_local $6 + (i64.const 0) + ) + (loop $label$9 + (set_local $7 + (i64.const 0) + ) + (block $label$10 + (br_if $label$10 + (i64.gt_u + (get_local $5) + (i64.const 11) + ) + ) + (block $label$11 + (block $label$12 + (br_if $label$12 + (i32.gt_u + (i32.and + (i32.add + (tee_local $3 + (i32.load8_s + (get_local $0) + ) + ) + (i32.const -97) + ) + (i32.const 255) + ) + (i32.const 25) + ) + ) + (set_local $3 + (i32.add + (get_local $3) + (i32.const 165) + ) + ) + (br $label$11) + ) + (set_local $3 + (select + (i32.add + (get_local $3) + (i32.const 208) + ) + (i32.const 0) + (i32.lt_u + (i32.and + (i32.add + (get_local $3) + (i32.const -49) + ) + (i32.const 255) + ) + (i32.const 5) + ) + ) + ) + ) + (set_local $7 + (i64.shl + (i64.extend_u/i32 + (i32.and + (get_local $3) + (i32.const 31) + ) + ) + (i64.and + (get_local $4) + (i64.const 4294967295) + ) + ) + ) + ) + (set_local $0 + (i32.add + (get_local $0) + (i32.const 1) + ) + ) + (set_local $5 + (i64.add + (get_local $5) + (i64.const 1) + ) + ) + (set_local $6 + (i64.or + (get_local $7) + (get_local $6) + ) + ) + (br_if $label$9 + (i64.ne + (tee_local $4 + (i64.add + (get_local $4) + (i64.const -5) + ) + ) + (i64.const -6) + ) + ) + ) + (i64.store offset=32 + (get_local $2) + (get_local $6) + ) + (i32.store16 offset=40 + (get_local $2) + (i32.const 1294) + ) + (i32.store8 offset=42 + (get_local $2) + (i32.const 1) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 176) + ) + (set_local $5 + (i64.const 5459781) + ) + (set_local $0 + (i32.const 0) + ) + (block $label$13 + (block $label$14 + (loop $label$15 + (br_if $label$14 + (i32.gt_u + (i32.add + (i32.shl + (i32.wrap/i64 + (get_local $5) + ) + (i32.const 24) + ) + (i32.const -1073741825) + ) + (i32.const 452984830) + ) + ) + (block $label$16 + (br_if $label$16 + (i64.ne + (i64.and + (tee_local $5 + (i64.shr_u + (get_local $5) + (i64.const 8) + ) + ) + (i64.const 255) + ) + (i64.const 0) + ) + ) + (loop $label$17 + (br_if $label$14 + (i64.ne + (i64.and + (tee_local $5 + (i64.shr_u + (get_local $5) + (i64.const 8) + ) + ) + (i64.const 255) + ) + (i64.const 0) + ) + ) + (br_if $label$17 + (i32.lt_s + (tee_local $0 + (i32.add + (get_local $0) + (i32.const 1) + ) + ) + (i32.const 7) + ) + ) + ) + ) + (set_local $3 + (i32.const 1) + ) + (br_if $label$15 + (i32.lt_s + (tee_local $0 + (i32.add + (get_local $0) + (i32.const 1) + ) + ) + (i32.const 7) + ) + ) + (br $label$13) + ) + ) + (set_local $3 + (i32.const 0) + ) + ) + (call $eosio_assert + (get_local $3) + (i32.const 128) + ) + (i64.store + (i32.add + (get_local $2) + (i32.const 56) + ) + (i64.const 1397703940) + ) + (i64.store offset=48 + (get_local $2) + (i64.const 100000) + ) + (i32.store8 offset=92 + (get_local $2) + (i32.const 0) + ) + (i32.store16 offset=64 + (get_local $2) + (i32.const 2610) + ) + (i32.store8 offset=66 + (get_local $2) + (i32.const 10) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 176) + ) + (set_local $5 + (i64.const 5459781) + ) + (set_local $0 + (i32.const 0) + ) + (block $label$18 + (block $label$19 + (loop $label$20 + (br_if $label$19 + (i32.gt_u + (i32.add + (i32.shl + (i32.wrap/i64 + (get_local $5) + ) + (i32.const 24) + ) + (i32.const -1073741825) + ) + (i32.const 452984830) + ) + ) + (block $label$21 + (br_if $label$21 + (i64.ne + (i64.and + (tee_local $5 + (i64.shr_u + (get_local $5) + (i64.const 8) + ) + ) + (i64.const 255) + ) + (i64.const 0) + ) + ) + (loop $label$22 + (br_if $label$19 + (i64.ne + (i64.and + (tee_local $5 + (i64.shr_u + (get_local $5) + (i64.const 8) + ) + ) + (i64.const 255) + ) + (i64.const 0) + ) + ) + (br_if $label$22 + (i32.lt_s + (tee_local $0 + (i32.add + (get_local $0) + (i32.const 1) + ) + ) + (i32.const 7) + ) + ) + ) + ) + (set_local $3 + (i32.const 1) + ) + (br_if $label$20 + (i32.lt_s + (tee_local $0 + (i32.add + (get_local $0) + (i32.const 1) + ) + ) + (i32.const 7) + ) + ) + (br $label$18) + ) + ) + (set_local $3 + (i32.const 0) + ) + ) + (call $eosio_assert + (get_local $3) + (i32.const 128) + ) + (i64.store + (i32.add + (get_local $2) + (i32.const 80) + ) + (i64.const 1397703940) + ) + (i64.store offset=72 + (get_local $2) + (i64.const 0) + ) + (i32.store offset=88 + (get_local $2) + (i32.const 0) + ) + ) + (func $_ZN6eoswinrsIN5eosio10datastreamIPKcEEEERT_S7_RNS_11global_itemE (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + (local $3 i32) + (i32.store offset=4 + (i32.const 0) + (tee_local $3 + (i32.sub + (i32.load offset=4 + (i32.const 0) + ) + (i32.const 16) + ) + ) + ) + (call $eosio_assert + (i32.gt_u + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (i32.load offset=4 + (get_local $0) + ) + ) + (i32.const 7) + ) + (i32.const 272) + ) + (drop + (call $memcpy + (get_local $1) + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $0) + (tee_local $2 + (i32.add + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + ) + (call $eosio_assert + (i32.gt_u + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (get_local $2) + ) + (i32.const 7) + ) + (i32.const 272) + ) + (drop + (call $memcpy + (i32.add + (get_local $1) + (i32.const 8) + ) + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $0) + (tee_local $2 + (i32.add + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + ) + (call $eosio_assert + (i32.gt_u + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (get_local $2) + ) + (i32.const 7) + ) + (i32.const 272) + ) + (drop + (call $memcpy + (i32.add + (get_local $1) + (i32.const 16) + ) + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $0) + (tee_local $2 + (i32.add + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + ) + (call $eosio_assert + (i32.gt_u + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (get_local $2) + ) + (i32.const 7) + ) + (i32.const 272) + ) + (drop + (call $memcpy + (i32.add + (get_local $1) + (i32.const 24) + ) + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $0) + (tee_local $2 + (i32.add + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + ) + (call $eosio_assert + (i32.gt_u + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (get_local $2) + ) + (i32.const 7) + ) + (i32.const 272) + ) + (drop + (call $memcpy + (i32.add + (get_local $1) + (i32.const 32) + ) + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $0) + (tee_local $2 + (i32.add + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + ) + (call $eosio_assert + (i32.ne + (i32.load offset=8 + (get_local $0) + ) + (get_local $2) + ) + (i32.const 272) + ) + (drop + (call $memcpy + (i32.add + (get_local $1) + (i32.const 40) + ) + (i32.load offset=4 + (get_local $0) + ) + (i32.const 1) + ) + ) + (i32.store offset=4 + (get_local $0) + (tee_local $2 + (i32.add + (i32.load offset=4 + (get_local $0) + ) + (i32.const 1) + ) + ) + ) + (call $eosio_assert + (i32.ne + (i32.load offset=8 + (get_local $0) + ) + (get_local $2) + ) + (i32.const 272) + ) + (drop + (call $memcpy + (i32.add + (get_local $1) + (i32.const 41) + ) + (i32.load offset=4 + (get_local $0) + ) + (i32.const 1) + ) + ) + (i32.store offset=4 + (get_local $0) + (tee_local $2 + (i32.add + (i32.load offset=4 + (get_local $0) + ) + (i32.const 1) + ) + ) + ) + (call $eosio_assert + (i32.ne + (i32.load offset=8 + (get_local $0) + ) + (get_local $2) + ) + (i32.const 272) + ) + (drop + (call $memcpy + (i32.add + (get_local $1) + (i32.const 42) + ) + (i32.load offset=4 + (get_local $0) + ) + (i32.const 1) + ) + ) + (i32.store offset=4 + (get_local $0) + (tee_local $2 + (i32.add + (i32.load offset=4 + (get_local $0) + ) + (i32.const 1) + ) + ) + ) + (call $eosio_assert + (i32.gt_u + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (get_local $2) + ) + (i32.const 7) + ) + (i32.const 272) + ) + (drop + (call $memcpy + (i32.add + (get_local $1) + (i32.const 48) + ) + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $0) + (tee_local $2 + (i32.add + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + ) + (call $eosio_assert + (i32.gt_u + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (get_local $2) + ) + (i32.const 7) + ) + (i32.const 272) + ) + (drop + (call $memcpy + (i32.add + (get_local $1) + (i32.const 56) + ) + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $0) + (tee_local $2 + (i32.add + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + ) + (call $eosio_assert + (i32.ne + (i32.load offset=8 + (get_local $0) + ) + (get_local $2) + ) + (i32.const 272) + ) + (drop + (call $memcpy + (i32.add + (get_local $1) + (i32.const 64) + ) + (i32.load offset=4 + (get_local $0) + ) + (i32.const 1) + ) + ) + (i32.store offset=4 + (get_local $0) + (tee_local $2 + (i32.add + (i32.load offset=4 + (get_local $0) + ) + (i32.const 1) + ) + ) + ) + (call $eosio_assert + (i32.ne + (i32.load offset=8 + (get_local $0) + ) + (get_local $2) + ) + (i32.const 272) + ) + (drop + (call $memcpy + (i32.add + (get_local $1) + (i32.const 65) + ) + (i32.load offset=4 + (get_local $0) + ) + (i32.const 1) + ) + ) + (i32.store offset=4 + (get_local $0) + (tee_local $2 + (i32.add + (i32.load offset=4 + (get_local $0) + ) + (i32.const 1) + ) + ) + ) + (call $eosio_assert + (i32.ne + (i32.load offset=8 + (get_local $0) + ) + (get_local $2) + ) + (i32.const 272) + ) + (drop + (call $memcpy + (i32.add + (get_local $1) + (i32.const 66) + ) + (i32.load offset=4 + (get_local $0) + ) + (i32.const 1) + ) + ) + (i32.store offset=4 + (get_local $0) + (tee_local $2 + (i32.add + (i32.load offset=4 + (get_local $0) + ) + (i32.const 1) + ) + ) + ) + (call $eosio_assert + (i32.gt_u + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (get_local $2) + ) + (i32.const 7) + ) + (i32.const 272) + ) + (drop + (call $memcpy + (i32.add + (get_local $1) + (i32.const 72) + ) + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $0) + (tee_local $2 + (i32.add + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + ) + (call $eosio_assert + (i32.gt_u + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (get_local $2) + ) + (i32.const 7) + ) + (i32.const 272) + ) + (drop + (call $memcpy + (i32.add + (get_local $1) + (i32.const 80) + ) + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $0) + (tee_local $2 + (i32.add + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + ) + (call $eosio_assert + (i32.gt_u + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (get_local $2) + ) + (i32.const 3) + ) + (i32.const 272) + ) + (drop + (call $memcpy + (i32.add + (get_local $1) + (i32.const 88) + ) + (i32.load offset=4 + (get_local $0) + ) + (i32.const 4) + ) + ) + (i32.store offset=4 + (get_local $0) + (tee_local $2 + (i32.add + (i32.load offset=4 + (get_local $0) + ) + (i32.const 4) + ) + ) + ) + (call $eosio_assert + (i32.ne + (i32.load offset=8 + (get_local $0) + ) + (get_local $2) + ) + (i32.const 272) + ) + (drop + (call $memcpy + (i32.add + (get_local $3) + (i32.const 15) + ) + (i32.load offset=4 + (get_local $0) + ) + (i32.const 1) + ) + ) + (i32.store offset=4 + (get_local $0) + (i32.add + (i32.load offset=4 + (get_local $0) + ) + (i32.const 1) + ) + ) + (i32.store8 offset=92 + (get_local $1) + (i32.ne + (i32.load8_u offset=15 + (get_local $3) + ) + (i32.const 0) + ) + ) + (i32.store offset=4 + (i32.const 0) + (i32.add + (get_local $3) + (i32.const 16) + ) + ) + (get_local $0) + ) + (func $_ZNSt3__16vectorIN5eosio11multi_indexILy7235159537265672192ENS1_9singletonILy7235159537265672192EN6eoswin11global_itemEE3rowEJEE8item_ptrENS_9allocatorIS9_EEE24__emplace_back_slow_pathIJNS_10unique_ptrINS8_4itemENS_14default_deleteISF_EEEERyRlEEEvDpOT_ (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (block $label$0 + (block $label$1 + (br_if $label$1 + (i32.ge_u + (tee_local $5 + (i32.add + (tee_local $4 + (i32.div_s + (i32.sub + (i32.load offset=4 + (get_local $0) + ) + (tee_local $6 + (i32.load + (get_local $0) + ) + ) + ) + (i32.const 24) + ) + ) + (i32.const 1) + ) + ) + (i32.const 178956971) + ) + ) + (set_local $7 + (i32.const 178956970) + ) + (block $label$2 + (block $label$3 + (br_if $label$3 + (i32.gt_u + (tee_local $6 + (i32.div_s + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (get_local $6) + ) + (i32.const 24) + ) + ) + (i32.const 89478484) + ) + ) + (br_if $label$2 + (i32.eqz + (tee_local $7 + (select + (get_local $5) + (tee_local $7 + (i32.shl + (get_local $6) + (i32.const 1) + ) + ) + (i32.lt_u + (get_local $7) + (get_local $5) + ) + ) + ) + ) + ) + ) + (set_local $6 + (call $_Znwj + (i32.mul + (get_local $7) + (i32.const 24) + ) + ) + ) + (br $label$0) + ) + (set_local $7 + (i32.const 0) + ) + (set_local $6 + (i32.const 0) + ) + (br $label$0) + ) + (call $_ZNKSt3__120__vector_base_commonILb1EE20__throw_length_errorEv + (get_local $0) + ) + (unreachable) + ) + (set_local $5 + (i32.load + (get_local $1) + ) + ) + (i32.store + (get_local $1) + (i32.const 0) + ) + (i32.store + (tee_local $1 + (i32.add + (get_local $6) + (i32.mul + (get_local $4) + (i32.const 24) + ) + ) + ) + (get_local $5) + ) + (i64.store offset=8 + (get_local $1) + (i64.load + (get_local $2) + ) + ) + (i32.store offset=16 + (get_local $1) + (i32.load + (get_local $3) + ) + ) + (set_local $4 + (i32.add + (get_local $6) + (i32.mul + (get_local $7) + (i32.const 24) + ) + ) + ) + (set_local $5 + (i32.add + (get_local $1) + (i32.const 24) + ) + ) + (block $label$4 + (block $label$5 + (br_if $label$5 + (i32.eq + (tee_local $6 + (i32.load + (i32.add + (get_local $0) + (i32.const 4) + ) + ) + ) + (tee_local $7 + (i32.load + (get_local $0) + ) + ) + ) + ) + (loop $label$6 + (set_local $3 + (i32.load + (tee_local $2 + (i32.add + (get_local $6) + (i32.const -24) + ) + ) + ) + ) + (i32.store + (get_local $2) + (i32.const 0) + ) + (i32.store + (i32.add + (get_local $1) + (i32.const -24) + ) + (get_local $3) + ) + (i32.store + (i32.add + (get_local $1) + (i32.const -8) + ) + (i32.load + (i32.add + (get_local $6) + (i32.const -8) + ) + ) + ) + (i32.store + (i32.add + (get_local $1) + (i32.const -12) + ) + (i32.load + (i32.add + (get_local $6) + (i32.const -12) + ) + ) + ) + (i32.store + (i32.add + (get_local $1) + (i32.const -16) + ) + (i32.load + (i32.add + (get_local $6) + (i32.const -16) + ) + ) + ) + (set_local $1 + (i32.add + (get_local $1) + (i32.const -24) + ) + ) + (set_local $6 + (get_local $2) + ) + (br_if $label$6 + (i32.ne + (get_local $7) + (get_local $2) + ) + ) + ) + (set_local $7 + (i32.load + (i32.add + (get_local $0) + (i32.const 4) + ) + ) + ) + (set_local $6 + (i32.load + (get_local $0) + ) + ) + (br $label$4) + ) + (set_local $6 + (get_local $7) + ) + ) + (i32.store + (get_local $0) + (get_local $1) + ) + (i32.store + (i32.add + (get_local $0) + (i32.const 4) + ) + (get_local $5) + ) + (i32.store + (i32.add + (get_local $0) + (i32.const 8) + ) + (get_local $4) + ) + (block $label$7 + (br_if $label$7 + (i32.eq + (get_local $7) + (get_local $6) + ) + ) + (loop $label$8 + (set_local $1 + (i32.load + (tee_local $7 + (i32.add + (get_local $7) + (i32.const -24) + ) + ) + ) + ) + (i32.store + (get_local $7) + (i32.const 0) + ) + (block $label$9 + (br_if $label$9 + (i32.eqz + (get_local $1) + ) + ) + (call $_ZdlPv + (get_local $1) + ) + ) + (br_if $label$8 + (i32.ne + (get_local $6) + (get_local $7) + ) + ) + ) + ) + (block $label$10 + (br_if $label$10 + (i32.eqz + (get_local $6) + ) + ) + (call $_ZdlPv + (get_local $6) + ) + ) + ) + (func $_ZN6eoswin7lotteryD2Ev (param $0 i32) (result i32) + (local $1 i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (call $_ZN5eosio9singletonILy7235159537265672192EN6eoswin11global_itemEE3setERKS2_y + (i32.add + (get_local $0) + (i32.const 8) + ) + (i32.add + (get_local $0) + (i32.const 48) + ) + (i64.load + (get_local $0) + ) + ) + (block $label$0 + (br_if $label$0 + (i32.eqz + (tee_local $3 + (i32.load + (i32.add + (get_local $0) + (i32.const 352) + ) + ) + ) + ) + ) + (block $label$1 + (block $label$2 + (br_if $label$2 + (i32.eq + (tee_local $5 + (i32.load + (tee_local $1 + (i32.add + (get_local $0) + (i32.const 356) + ) + ) + ) + ) + (get_local $3) + ) + ) + (loop $label$3 + (set_local $2 + (i32.load + (tee_local $5 + (i32.add + (get_local $5) + (i32.const -24) + ) + ) + ) + ) + (i32.store + (get_local $5) + (i32.const 0) + ) + (block $label$4 + (br_if $label$4 + (i32.eqz + (get_local $2) + ) + ) + (call $_ZdlPv + (get_local $2) + ) + ) + (br_if $label$3 + (i32.ne + (get_local $3) + (get_local $5) + ) + ) + ) + (set_local $5 + (i32.load + (i32.add + (get_local $0) + (i32.const 352) + ) + ) + ) + (br $label$1) + ) + (set_local $5 + (get_local $3) + ) + ) + (i32.store + (get_local $1) + (get_local $3) + ) + (call $_ZdlPv + (get_local $5) + ) + ) + (block $label$5 + (br_if $label$5 + (i32.eqz + (tee_local $1 + (i32.load + (i32.add + (get_local $0) + (i32.const 312) + ) + ) + ) + ) + ) + (block $label$6 + (block $label$7 + (br_if $label$7 + (i32.eq + (tee_local $5 + (i32.load + (tee_local $4 + (i32.add + (get_local $0) + (i32.const 316) + ) + ) + ) + ) + (get_local $1) + ) + ) + (loop $label$8 + (set_local $2 + (i32.load + (tee_local $5 + (i32.add + (get_local $5) + (i32.const -24) + ) + ) + ) + ) + (i32.store + (get_local $5) + (i32.const 0) + ) + (block $label$9 + (br_if $label$9 + (i32.eqz + (get_local $2) + ) + ) + (block $label$10 + (br_if $label$10 + (i32.eqz + (tee_local $3 + (i32.load offset=16 + (get_local $2) + ) + ) + ) + ) + (i32.store + (i32.add + (get_local $2) + (i32.const 20) + ) + (get_local $3) + ) + (call $_ZdlPv + (get_local $3) + ) + ) + (call $_ZdlPv + (get_local $2) + ) + ) + (br_if $label$8 + (i32.ne + (get_local $1) + (get_local $5) + ) + ) + ) + (set_local $5 + (i32.load + (i32.add + (get_local $0) + (i32.const 312) + ) + ) + ) + (br $label$6) + ) + (set_local $5 + (get_local $1) + ) + ) + (i32.store + (get_local $4) + (get_local $1) + ) + (call $_ZdlPv + (get_local $5) + ) + ) + (block $label$11 + (br_if $label$11 + (i32.eqz + (tee_local $3 + (i32.load + (i32.add + (get_local $0) + (i32.const 272) + ) + ) + ) + ) + ) + (block $label$12 + (block $label$13 + (br_if $label$13 + (i32.eq + (tee_local $5 + (i32.load + (tee_local $1 + (i32.add + (get_local $0) + (i32.const 276) + ) + ) + ) + ) + (get_local $3) + ) + ) + (loop $label$14 + (set_local $2 + (i32.load + (tee_local $5 + (i32.add + (get_local $5) + (i32.const -24) + ) + ) + ) + ) + (i32.store + (get_local $5) + (i32.const 0) + ) + (block $label$15 + (br_if $label$15 + (i32.eqz + (get_local $2) + ) + ) + (call $_ZdlPv + (get_local $2) + ) + ) + (br_if $label$14 + (i32.ne + (get_local $3) + (get_local $5) + ) + ) + ) + (set_local $5 + (i32.load + (i32.add + (get_local $0) + (i32.const 272) + ) + ) + ) + (br $label$12) + ) + (set_local $5 + (get_local $3) + ) + ) + (i32.store + (get_local $1) + (get_local $3) + ) + (call $_ZdlPv + (get_local $5) + ) + ) + (block $label$16 + (br_if $label$16 + (i32.eqz + (tee_local $3 + (i32.load + (i32.add + (get_local $0) + (i32.const 208) + ) + ) + ) + ) + ) + (block $label$17 + (block $label$18 + (br_if $label$18 + (i32.eq + (tee_local $5 + (i32.load + (tee_local $1 + (i32.add + (get_local $0) + (i32.const 212) + ) + ) + ) + ) + (get_local $3) + ) + ) + (loop $label$19 + (set_local $2 + (i32.load + (tee_local $5 + (i32.add + (get_local $5) + (i32.const -24) + ) + ) + ) + ) + (i32.store + (get_local $5) + (i32.const 0) + ) + (block $label$20 + (br_if $label$20 + (i32.eqz + (get_local $2) + ) + ) + (call $_ZdlPv + (get_local $2) + ) + ) + (br_if $label$19 + (i32.ne + (get_local $3) + (get_local $5) + ) + ) + ) + (set_local $5 + (i32.load + (i32.add + (get_local $0) + (i32.const 208) + ) + ) + ) + (br $label$17) + ) + (set_local $5 + (get_local $3) + ) + ) + (i32.store + (get_local $1) + (get_local $3) + ) + (call $_ZdlPv + (get_local $5) + ) + ) + (block $label$21 + (br_if $label$21 + (i32.eqz + (tee_local $3 + (i32.load + (i32.add + (get_local $0) + (i32.const 168) + ) + ) + ) + ) + ) + (block $label$22 + (block $label$23 + (br_if $label$23 + (i32.eq + (tee_local $5 + (i32.load + (tee_local $1 + (i32.add + (get_local $0) + (i32.const 172) + ) + ) + ) + ) + (get_local $3) + ) + ) + (loop $label$24 + (set_local $2 + (i32.load + (tee_local $5 + (i32.add + (get_local $5) + (i32.const -24) + ) + ) + ) + ) + (i32.store + (get_local $5) + (i32.const 0) + ) + (block $label$25 + (br_if $label$25 + (i32.eqz + (get_local $2) + ) + ) + (call $_ZdlPv + (get_local $2) + ) + ) + (br_if $label$24 + (i32.ne + (get_local $3) + (get_local $5) + ) + ) + ) + (set_local $5 + (i32.load + (i32.add + (get_local $0) + (i32.const 168) + ) + ) + ) + (br $label$22) + ) + (set_local $5 + (get_local $3) + ) + ) + (i32.store + (get_local $1) + (get_local $3) + ) + (call $_ZdlPv + (get_local $5) + ) + ) + (block $label$26 + (br_if $label$26 + (i32.eqz + (tee_local $3 + (i32.load + (i32.add + (get_local $0) + (i32.const 32) + ) + ) + ) + ) + ) + (block $label$27 + (block $label$28 + (br_if $label$28 + (i32.eq + (tee_local $5 + (i32.load + (tee_local $1 + (i32.add + (get_local $0) + (i32.const 36) + ) + ) + ) + ) + (get_local $3) + ) + ) + (loop $label$29 + (set_local $2 + (i32.load + (tee_local $5 + (i32.add + (get_local $5) + (i32.const -24) + ) + ) + ) + ) + (i32.store + (get_local $5) + (i32.const 0) + ) + (block $label$30 + (br_if $label$30 + (i32.eqz + (get_local $2) + ) + ) + (call $_ZdlPv + (get_local $2) + ) + ) + (br_if $label$29 + (i32.ne + (get_local $3) + (get_local $5) + ) + ) + ) + (set_local $5 + (i32.load + (i32.add + (get_local $0) + (i32.const 32) + ) + ) + ) + (br $label$27) + ) + (set_local $5 + (get_local $3) + ) + ) + (i32.store + (get_local $1) + (get_local $3) + ) + (call $_ZdlPv + (get_local $5) + ) + ) + (get_local $0) + ) + (func $_ZN5eosio9singletonILy7235159537265672192EN6eoswin11global_itemEE3setERKS2_y (param $0 i32) (param $1 i32) (param $2 i64) + (local $3 i32) + (local $4 i32) + (i32.store offset=4 + (i32.const 0) + (tee_local $4 + (i32.sub + (i32.load offset=4 + (i32.const 0) + ) + (i32.const 16) + ) + ) + ) + (block $label$0 + (block $label$1 + (block $label$2 + (block $label$3 + (br_if $label$3 + (i32.eq + (tee_local $3 + (i32.load + (i32.add + (get_local $0) + (i32.const 28) + ) + ) + ) + (i32.load offset=24 + (get_local $0) + ) + ) + ) + (call $eosio_assert + (i32.eq + (i32.load offset=96 + (tee_local $3 + (i32.load + (i32.add + (get_local $3) + (i32.const -24) + ) + ) + ) + ) + (get_local $0) + ) + (i32.const 32) + ) + (br_if $label$2 + (get_local $3) + ) + (br $label$1) + ) + (br_if $label$1 + (i32.lt_s + (tee_local $3 + (call $db_find_i64 + (i64.load + (get_local $0) + ) + (i64.load offset=8 + (get_local $0) + ) + (i64.const 7235159537265672192) + (i64.const 7235159537265672192) + ) + ) + (i32.const 0) + ) + ) + (call $eosio_assert + (i32.eq + (i32.load offset=96 + (tee_local $3 + (call $_ZNK5eosio11multi_indexILy7235159537265672192ENS_9singletonILy7235159537265672192EN6eoswin11global_itemEE3rowEJEE31load_object_by_primary_iteratorEl + (get_local $0) + (get_local $3) + ) + ) + ) + (get_local $0) + ) + (i32.const 32) + ) + ) + (i32.store + (get_local $4) + (get_local $1) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 288) + ) + (call $_ZN5eosio11multi_indexILy7235159537265672192ENS_9singletonILy7235159537265672192EN6eoswin11global_itemEE3rowEJEE6modifyIZNS4_3setERKS3_yEUlRS5_E_EEvRKS5_yOT_ + (get_local $0) + (get_local $3) + (get_local $2) + (get_local $4) + ) + (br $label$0) + ) + (i32.store offset=8 + (get_local $4) + (get_local $1) + ) + (call $_ZN5eosio11multi_indexILy7235159537265672192ENS_9singletonILy7235159537265672192EN6eoswin11global_itemEE3rowEJEE7emplaceIZNS4_3setERKS3_yEUlRS5_E0_EENS6_14const_iteratorEyOT_ + (get_local $4) + (get_local $0) + (get_local $2) + (i32.add + (get_local $4) + (i32.const 8) + ) + ) + ) + (i32.store offset=4 + (i32.const 0) + (i32.add + (get_local $4) + (i32.const 16) + ) + ) + ) + (func $_ZN5eosio11multi_indexILy7235159537265672192ENS_9singletonILy7235159537265672192EN6eoswin11global_itemEE3rowEJEE6modifyIZNS4_3setERKS3_yEUlRS5_E_EEvRKS5_yOT_ (param $0 i32) (param $1 i32) (param $2 i64) (param $3 i32) + (local $4 i32) + (i32.store offset=4 + (i32.const 0) + (tee_local $4 + (i32.sub + (i32.load offset=4 + (i32.const 0) + ) + (i32.const 112) + ) + ) + ) + (call $eosio_assert + (i32.eq + (i32.load offset=96 + (get_local $1) + ) + (get_local $0) + ) + (i32.const 416) + ) + (call $eosio_assert + (i64.eq + (i64.load + (get_local $0) + ) + (call $current_receiver) + ) + (i32.const 464) + ) + (drop + (call $memcpy + (get_local $1) + (i32.load + (get_local $3) + ) + (i32.const 93) + ) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 528) + ) + (i32.store offset=104 + (get_local $4) + (i32.add + (get_local $4) + (i32.const 83) + ) + ) + (i32.store offset=100 + (get_local $4) + (get_local $4) + ) + (i32.store offset=96 + (get_local $4) + (get_local $4) + ) + (drop + (call $_ZN6eoswinlsIN5eosio10datastreamIPcEEEERT_S6_RKNS_11global_itemE + (i32.add + (get_local $4) + (i32.const 96) + ) + (get_local $1) + ) + ) + (call $db_update_i64 + (i32.load offset=100 + (get_local $1) + ) + (get_local $2) + (get_local $4) + (i32.const 83) + ) + (block $label$0 + (br_if $label$0 + (i64.gt_u + (i64.load offset=16 + (get_local $0) + ) + (i64.const 7235159537265672192) + ) + ) + (i64.store + (i32.add + (get_local $0) + (i32.const 16) + ) + (i64.const 7235159537265672193) + ) + ) + (i32.store offset=4 + (i32.const 0) + (i32.add + (get_local $4) + (i32.const 112) + ) + ) + ) + (func $_ZN5eosio11multi_indexILy7235159537265672192ENS_9singletonILy7235159537265672192EN6eoswin11global_itemEE3rowEJEE7emplaceIZNS4_3setERKS3_yEUlRS5_E0_EENS6_14const_iteratorEyOT_ (param $0 i32) (param $1 i32) (param $2 i64) (param $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (i32.store offset=4 + (i32.const 0) + (tee_local $7 + (i32.sub + (i32.load offset=4 + (i32.const 0) + ) + (i32.const 128) + ) + ) + ) + (call $eosio_assert + (i64.eq + (i64.load + (get_local $1) + ) + (call $current_receiver) + ) + (i32.const 336) + ) + (set_local $5 + (call $_ZN6eoswin11global_itemC2Ev + (tee_local $4 + (call $_Znwj + (i32.const 112) + ) + ) + ) + ) + (i32.store offset=96 + (get_local $4) + (get_local $1) + ) + (drop + (call $memcpy + (get_local $4) + (i32.load + (get_local $3) + ) + (i32.const 93) + ) + ) + (i32.store offset=120 + (get_local $7) + (i32.add + (i32.add + (get_local $7) + (i32.const 16) + ) + (i32.const 83) + ) + ) + (i32.store offset=116 + (get_local $7) + (i32.add + (get_local $7) + (i32.const 16) + ) + ) + (i32.store offset=112 + (get_local $7) + (i32.add + (get_local $7) + (i32.const 16) + ) + ) + (drop + (call $_ZN6eoswinlsIN5eosio10datastreamIPcEEEERT_S6_RKNS_11global_itemE + (i32.add + (get_local $7) + (i32.const 112) + ) + (get_local $5) + ) + ) + (i32.store offset=100 + (get_local $4) + (call $db_store_i64 + (i64.load offset=8 + (get_local $1) + ) + (i64.const 7235159537265672192) + (get_local $2) + (i64.const 7235159537265672192) + (i32.add + (get_local $7) + (i32.const 16) + ) + (i32.const 83) + ) + ) + (block $label$0 + (br_if $label$0 + (i64.gt_u + (i64.load offset=16 + (get_local $1) + ) + (i64.const 7235159537265672192) + ) + ) + (i64.store + (i32.add + (get_local $1) + (i32.const 16) + ) + (i64.const 7235159537265672193) + ) + ) + (i32.store offset=112 + (get_local $7) + (get_local $4) + ) + (i64.store offset=16 + (get_local $7) + (i64.const 7235159537265672192) + ) + (i32.store offset=12 + (get_local $7) + (tee_local $5 + (i32.load offset=100 + (get_local $4) + ) + ) + ) + (block $label$1 + (block $label$2 + (br_if $label$2 + (i32.ge_u + (tee_local $3 + (i32.load + (tee_local $6 + (i32.add + (get_local $1) + (i32.const 28) + ) + ) + ) + ) + (i32.load + (i32.add + (get_local $1) + (i32.const 32) + ) + ) + ) + ) + (i64.store offset=8 + (get_local $3) + (i64.const 7235159537265672192) + ) + (i32.store offset=16 + (get_local $3) + (get_local $5) + ) + (i32.store offset=112 + (get_local $7) + (i32.const 0) + ) + (i32.store + (get_local $3) + (get_local $4) + ) + (i32.store + (get_local $6) + (i32.add + (get_local $3) + (i32.const 24) + ) + ) + (br $label$1) + ) + (call $_ZNSt3__16vectorIN5eosio11multi_indexILy7235159537265672192ENS1_9singletonILy7235159537265672192EN6eoswin11global_itemEE3rowEJEE8item_ptrENS_9allocatorIS9_EEE24__emplace_back_slow_pathIJNS_10unique_ptrINS8_4itemENS_14default_deleteISF_EEEERyRlEEEvDpOT_ + (i32.add + (get_local $1) + (i32.const 24) + ) + (i32.add + (get_local $7) + (i32.const 112) + ) + (i32.add + (get_local $7) + (i32.const 16) + ) + (i32.add + (get_local $7) + (i32.const 12) + ) + ) + ) + (i32.store offset=4 + (get_local $0) + (get_local $4) + ) + (i32.store + (get_local $0) + (get_local $1) + ) + (set_local $1 + (i32.load offset=112 + (get_local $7) + ) + ) + (i32.store offset=112 + (get_local $7) + (i32.const 0) + ) + (block $label$3 + (br_if $label$3 + (i32.eqz + (get_local $1) + ) + ) + (call $_ZdlPv + (get_local $1) + ) + ) + (i32.store offset=4 + (i32.const 0) + (i32.add + (get_local $7) + (i32.const 128) + ) + ) + ) + (func $_ZN6eoswinlsIN5eosio10datastreamIPcEEEERT_S6_RKNS_11global_itemE (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + (local $3 i32) + (i32.store offset=4 + (i32.const 0) + (tee_local $3 + (i32.sub + (i32.load offset=4 + (i32.const 0) + ) + (i32.const 16) + ) + ) + ) + (call $eosio_assert + (i32.gt_s + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (i32.load offset=4 + (get_local $0) + ) + ) + (i32.const 7) + ) + (i32.const 400) + ) + (drop + (call $memcpy + (i32.load offset=4 + (get_local $0) + ) + (get_local $1) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $0) + (tee_local $2 + (i32.add + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + ) + (call $eosio_assert + (i32.gt_s + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (get_local $2) + ) + (i32.const 7) + ) + (i32.const 400) + ) + (drop + (call $memcpy + (i32.load offset=4 + (get_local $0) + ) + (i32.add + (get_local $1) + (i32.const 8) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $0) + (tee_local $2 + (i32.add + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + ) + (call $eosio_assert + (i32.gt_s + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (get_local $2) + ) + (i32.const 7) + ) + (i32.const 400) + ) + (drop + (call $memcpy + (i32.load offset=4 + (get_local $0) + ) + (i32.add + (get_local $1) + (i32.const 16) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $0) + (tee_local $2 + (i32.add + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + ) + (call $eosio_assert + (i32.gt_s + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (get_local $2) + ) + (i32.const 7) + ) + (i32.const 400) + ) + (drop + (call $memcpy + (i32.load offset=4 + (get_local $0) + ) + (i32.add + (get_local $1) + (i32.const 24) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $0) + (tee_local $2 + (i32.add + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + ) + (call $eosio_assert + (i32.gt_s + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (get_local $2) + ) + (i32.const 7) + ) + (i32.const 400) + ) + (drop + (call $memcpy + (i32.load offset=4 + (get_local $0) + ) + (i32.add + (get_local $1) + (i32.const 32) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $0) + (tee_local $2 + (i32.add + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + ) + (call $eosio_assert + (i32.gt_s + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (get_local $2) + ) + (i32.const 0) + ) + (i32.const 400) + ) + (drop + (call $memcpy + (i32.load offset=4 + (get_local $0) + ) + (i32.add + (get_local $1) + (i32.const 40) + ) + (i32.const 1) + ) + ) + (i32.store offset=4 + (get_local $0) + (tee_local $2 + (i32.add + (i32.load offset=4 + (get_local $0) + ) + (i32.const 1) + ) + ) + ) + (call $eosio_assert + (i32.gt_s + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (get_local $2) + ) + (i32.const 0) + ) + (i32.const 400) + ) + (drop + (call $memcpy + (i32.load offset=4 + (get_local $0) + ) + (i32.add + (get_local $1) + (i32.const 41) + ) + (i32.const 1) + ) + ) + (i32.store offset=4 + (get_local $0) + (tee_local $2 + (i32.add + (i32.load offset=4 + (get_local $0) + ) + (i32.const 1) + ) + ) + ) + (call $eosio_assert + (i32.gt_s + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (get_local $2) + ) + (i32.const 0) + ) + (i32.const 400) + ) + (drop + (call $memcpy + (i32.load offset=4 + (get_local $0) + ) + (i32.add + (get_local $1) + (i32.const 42) + ) + (i32.const 1) + ) + ) + (i32.store offset=4 + (get_local $0) + (tee_local $2 + (i32.add + (i32.load offset=4 + (get_local $0) + ) + (i32.const 1) + ) + ) + ) + (call $eosio_assert + (i32.gt_s + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (get_local $2) + ) + (i32.const 7) + ) + (i32.const 400) + ) + (drop + (call $memcpy + (i32.load offset=4 + (get_local $0) + ) + (i32.add + (get_local $1) + (i32.const 48) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $0) + (tee_local $2 + (i32.add + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + ) + (call $eosio_assert + (i32.gt_s + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (get_local $2) + ) + (i32.const 7) + ) + (i32.const 400) + ) + (drop + (call $memcpy + (i32.load offset=4 + (get_local $0) + ) + (i32.add + (get_local $1) + (i32.const 56) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $0) + (tee_local $2 + (i32.add + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + ) + (call $eosio_assert + (i32.gt_s + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (get_local $2) + ) + (i32.const 0) + ) + (i32.const 400) + ) + (drop + (call $memcpy + (i32.load offset=4 + (get_local $0) + ) + (i32.add + (get_local $1) + (i32.const 64) + ) + (i32.const 1) + ) + ) + (i32.store offset=4 + (get_local $0) + (tee_local $2 + (i32.add + (i32.load offset=4 + (get_local $0) + ) + (i32.const 1) + ) + ) + ) + (call $eosio_assert + (i32.gt_s + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (get_local $2) + ) + (i32.const 0) + ) + (i32.const 400) + ) + (drop + (call $memcpy + (i32.load offset=4 + (get_local $0) + ) + (i32.add + (get_local $1) + (i32.const 65) + ) + (i32.const 1) + ) + ) + (i32.store offset=4 + (get_local $0) + (tee_local $2 + (i32.add + (i32.load offset=4 + (get_local $0) + ) + (i32.const 1) + ) + ) + ) + (call $eosio_assert + (i32.gt_s + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (get_local $2) + ) + (i32.const 0) + ) + (i32.const 400) + ) + (drop + (call $memcpy + (i32.load offset=4 + (get_local $0) + ) + (i32.add + (get_local $1) + (i32.const 66) + ) + (i32.const 1) + ) + ) + (i32.store offset=4 + (get_local $0) + (tee_local $2 + (i32.add + (i32.load offset=4 + (get_local $0) + ) + (i32.const 1) + ) + ) + ) + (call $eosio_assert + (i32.gt_s + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (get_local $2) + ) + (i32.const 7) + ) + (i32.const 400) + ) + (drop + (call $memcpy + (i32.load offset=4 + (get_local $0) + ) + (i32.add + (get_local $1) + (i32.const 72) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $0) + (tee_local $2 + (i32.add + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + ) + (call $eosio_assert + (i32.gt_s + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (get_local $2) + ) + (i32.const 7) + ) + (i32.const 400) + ) + (drop + (call $memcpy + (i32.load offset=4 + (get_local $0) + ) + (i32.add + (get_local $1) + (i32.const 80) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $0) + (tee_local $2 + (i32.add + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + ) + (call $eosio_assert + (i32.gt_s + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (get_local $2) + ) + (i32.const 3) + ) + (i32.const 400) + ) + (drop + (call $memcpy + (i32.load offset=4 + (get_local $0) + ) + (i32.add + (get_local $1) + (i32.const 88) + ) + (i32.const 4) + ) + ) + (i32.store offset=4 + (get_local $0) + (tee_local $2 + (i32.add + (i32.load offset=4 + (get_local $0) + ) + (i32.const 4) + ) + ) + ) + (i32.store8 offset=15 + (get_local $3) + (i32.load8_u offset=92 + (get_local $1) + ) + ) + (call $eosio_assert + (i32.gt_s + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (get_local $2) + ) + (i32.const 0) + ) + (i32.const 400) + ) + (drop + (call $memcpy + (i32.load offset=4 + (get_local $0) + ) + (i32.add + (get_local $3) + (i32.const 15) + ) + (i32.const 1) + ) + ) + (i32.store offset=4 + (get_local $0) + (i32.add + (i32.load offset=4 + (get_local $0) + ) + (i32.const 1) + ) + ) + (i32.store offset=4 + (i32.const 0) + (i32.add + (get_local $3) + (i32.const 16) + ) + ) + (get_local $0) + ) + (func $_ZN6eoswin7lottery16issue_game_tokenEyN5eosio5assetENSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE (param $0 i32) (param $1 i64) (param $2 i32) (param $3 i32) + (local $4 i32) + (local $5 i64) + (local $6 i64) + (local $7 i64) + (local $8 i64) + (local $9 i64) + (local $10 i32) + (i32.store offset=4 + (i32.const 0) + (tee_local $10 + (i32.sub + (i32.load offset=4 + (i32.const 0) + ) + (i32.const 112) + ) + ) + ) + (block $label$0 + (br_if $label$0 + (i64.lt_s + (i64.load + (get_local $2) + ) + (i64.const 1) + ) + ) + (call $eosio_assert + (i64.eq + (i64.load offset=8 + (get_local $2) + ) + (i64.const 98179787082756) + ) + (i32.const 608) + ) + (set_local $5 + (i64.load + (i32.add + (get_local $0) + (i32.const 72) + ) + ) + ) + (set_local $7 + (i64.const 0) + ) + (set_local $6 + (i64.const 59) + ) + (set_local $0 + (i32.const 592) + ) + (set_local $8 + (i64.const 0) + ) + (loop $label$1 + (block $label$2 + (block $label$3 + (block $label$4 + (block $label$5 + (block $label$6 + (br_if $label$6 + (i64.gt_u + (get_local $7) + (i64.const 5) + ) + ) + (br_if $label$5 + (i32.gt_u + (i32.and + (i32.add + (tee_local $4 + (i32.load8_s + (get_local $0) + ) + ) + (i32.const -97) + ) + (i32.const 255) + ) + (i32.const 25) + ) + ) + (set_local $4 + (i32.add + (get_local $4) + (i32.const 165) + ) + ) + (br $label$4) + ) + (set_local $9 + (i64.const 0) + ) + (br_if $label$3 + (i64.le_u + (get_local $7) + (i64.const 11) + ) + ) + (br $label$2) + ) + (set_local $4 + (select + (i32.add + (get_local $4) + (i32.const 208) + ) + (i32.const 0) + (i32.lt_u + (i32.and + (i32.add + (get_local $4) + (i32.const -49) + ) + (i32.const 255) + ) + (i32.const 5) + ) + ) + ) + ) + (set_local $9 + (i64.shr_s + (i64.shl + (i64.extend_u/i32 + (get_local $4) + ) + (i64.const 56) + ) + (i64.const 56) + ) + ) + ) + (set_local $9 + (i64.shl + (i64.and + (get_local $9) + (i64.const 31) + ) + (i64.and + (get_local $6) + (i64.const 4294967295) + ) + ) + ) + ) + (set_local $0 + (i32.add + (get_local $0) + (i32.const 1) + ) + ) + (set_local $7 + (i64.add + (get_local $7) + (i64.const 1) + ) + ) + (set_local $8 + (i64.or + (get_local $9) + (get_local $8) + ) + ) + (br_if $label$1 + (i64.ne + (tee_local $6 + (i64.add + (get_local $6) + (i64.const -5) + ) + ) + (i64.const -6) + ) + ) + ) + (i32.store + (i32.add + (get_local $10) + (i32.const 28) + ) + (i32.load + (i32.add + (get_local $2) + (i32.const 12) + ) + ) + ) + (i32.store + (tee_local $4 + (i32.add + (get_local $10) + (i32.const 24) + ) + ) + (i32.load + (i32.add + (get_local $2) + (i32.const 8) + ) + ) + ) + (i32.store + (i32.add + (get_local $10) + (i32.const 20) + ) + (i32.load + (i32.add + (get_local $2) + (i32.const 4) + ) + ) + ) + (i64.store offset=8 + (get_local $10) + (get_local $1) + ) + (i64.store + (get_local $10) + (get_local $5) + ) + (i32.store offset=16 + (get_local $10) + (i32.load + (get_local $2) + ) + ) + (drop + (call $_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEC2ERKS5_ + (i32.add + (get_local $10) + (i32.const 32) + ) + (get_local $3) + ) + ) + (i64.store + (tee_local $0 + (call $_Znwj + (i32.const 16) + ) + ) + (get_local $5) + ) + (i64.store offset=8 + (get_local $0) + (get_local $8) + ) + (i32.store offset=96 + (get_local $10) + (get_local $0) + ) + (i32.store offset=104 + (get_local $10) + (tee_local $0 + (i32.add + (get_local $0) + (i32.const 16) + ) + ) + ) + (i32.store offset=100 + (get_local $10) + (get_local $0) + ) + (i64.store offset=48 + (get_local $10) + (i64.load + (get_local $10) + ) + ) + (i64.store offset=56 + (get_local $10) + (i64.load offset=8 + (get_local $10) + ) + ) + (i64.store + (i32.add + (i32.add + (get_local $10) + (i32.const 48) + ) + (i32.const 24) + ) + (i64.load + (get_local $4) + ) + ) + (i64.store offset=64 + (get_local $10) + (i64.load offset=16 + (get_local $10) + ) + ) + (i32.store + (tee_local $4 + (i32.add + (i32.add + (get_local $10) + (i32.const 48) + ) + (i32.const 40) + ) + ) + (i32.load + (tee_local $0 + (i32.add + (get_local $10) + (i32.const 40) + ) + ) + ) + ) + (i64.store offset=80 + (get_local $10) + (i64.load offset=32 + (get_local $10) + ) + ) + (i32.store offset=32 + (get_local $10) + (i32.const 0) + ) + (i32.store + (i32.add + (get_local $10) + (i32.const 36) + ) + (i32.const 0) + ) + (i32.store + (get_local $0) + (i32.const 0) + ) + (call $_ZN5eosio15dispatch_inlineIJyyNS_5assetENSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEvyyNS2_6vectorINS_16permission_levelENS6_ISA_EEEENS2_5tupleIJDpT_EEE + (get_local $5) + (i64.const -3617168760277827584) + (i32.add + (get_local $10) + (i32.const 96) + ) + (i32.add + (get_local $10) + (i32.const 48) + ) + ) + (block $label$7 + (br_if $label$7 + (i32.eqz + (i32.and + (i32.load8_u offset=80 + (get_local $10) + ) + (i32.const 1) + ) + ) + ) + (call $_ZdlPv + (i32.load + (get_local $4) + ) + ) + ) + (block $label$8 + (br_if $label$8 + (i32.eqz + (tee_local $0 + (i32.load offset=96 + (get_local $10) + ) + ) + ) + ) + (i32.store offset=100 + (get_local $10) + (get_local $0) + ) + (call $_ZdlPv + (get_local $0) + ) + ) + (br_if $label$0 + (i32.eqz + (i32.and + (i32.load8_u + (i32.add + (get_local $10) + (i32.const 32) + ) + ) + (i32.const 1) + ) + ) + ) + (call $_ZdlPv + (i32.load + (i32.add + (get_local $10) + (i32.const 40) + ) + ) + ) + ) + (i32.store offset=4 + (i32.const 0) + (i32.add + (get_local $10) + (i32.const 112) + ) + ) + ) + (func $_ZN5eosio15dispatch_inlineIJyyNS_5assetENSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEvyyNS2_6vectorINS_16permission_levelENS6_ISA_EEEENS2_5tupleIJDpT_EEE (param $0 i64) (param $1 i64) (param $2 i32) (param $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (local $8 i32) + (local $9 i32) + (i32.store offset=4 + (i32.const 0) + (tee_local $9 + (i32.sub + (i32.load offset=4 + (i32.const 0) + ) + (i32.const 96) + ) + ) + ) + (i32.store offset=16 + (get_local $9) + (i32.const 0) + ) + (i64.store offset=8 + (get_local $9) + (i64.const 0) + ) + (set_local $6 + (i32.const 0) + ) + (set_local $7 + (i32.const 0) + ) + (set_local $8 + (i32.const 0) + ) + (block $label$0 + (block $label$1 + (br_if $label$1 + (i32.eqz + (tee_local $5 + (i32.shr_s + (tee_local $4 + (i32.sub + (i32.load offset=4 + (get_local $2) + ) + (i32.load + (get_local $2) + ) + ) + ) + (i32.const 4) + ) + ) + ) + ) + (br_if $label$0 + (i32.ge_u + (get_local $5) + (i32.const 268435456) + ) + ) + (i32.store + (i32.add + (get_local $9) + (i32.const 16) + ) + (tee_local $6 + (i32.add + (tee_local $8 + (call $_Znwj + (get_local $4) + ) + ) + (i32.shl + (get_local $5) + (i32.const 4) + ) + ) + ) + ) + (i32.store offset=8 + (get_local $9) + (get_local $8) + ) + (i32.store offset=12 + (get_local $9) + (get_local $8) + ) + (block $label$2 + (br_if $label$2 + (i32.lt_s + (tee_local $2 + (i32.sub + (i32.load + (i32.add + (get_local $2) + (i32.const 4) + ) + ) + (tee_local $7 + (i32.load + (get_local $2) + ) + ) + ) + ) + (i32.const 1) + ) + ) + (drop + (call $memcpy + (get_local $8) + (get_local $7) + (get_local $2) + ) + ) + (i32.store offset=12 + (get_local $9) + (tee_local $7 + (i32.add + (get_local $8) + (get_local $2) + ) + ) + ) + (br $label$1) + ) + (set_local $7 + (get_local $8) + ) + ) + (i32.store + (i32.add + (get_local $9) + (i32.const 44) + ) + (get_local $7) + ) + (i64.store offset=32 + (get_local $9) + (get_local $1) + ) + (i32.store + (i32.add + (get_local $9) + (i32.const 16) + ) + (i32.const 0) + ) + (i32.store + (i32.add + (get_local $9) + (i32.const 48) + ) + (get_local $6) + ) + (i64.store offset=24 + (get_local $9) + (get_local $0) + ) + (i32.store offset=40 + (get_local $9) + (get_local $8) + ) + (i64.store offset=8 + (get_local $9) + (i64.const 0) + ) + (i32.store offset=52 + (get_local $9) + (i32.const 0) + ) + (i32.store + (i32.add + (i32.add + (get_local $9) + (i32.const 24) + ) + (i32.const 32) + ) + (i32.const 0) + ) + (i32.store + (i32.add + (i32.add + (get_local $9) + (i32.const 24) + ) + (i32.const 36) + ) + (i32.const 0) + ) + (set_local $8 + (i32.add + (tee_local $2 + (select + (i32.load + (i32.add + (get_local $3) + (i32.const 36) + ) + ) + (i32.shr_u + (tee_local $8 + (i32.load8_u offset=32 + (get_local $3) + ) + ) + (i32.const 1) + ) + (i32.and + (get_local $8) + (i32.const 1) + ) + ) + ) + (i32.const 32) + ) + ) + (set_local $0 + (i64.extend_u/i32 + (get_local $2) + ) + ) + (set_local $2 + (i32.add + (get_local $9) + (i32.const 52) + ) + ) + (loop $label$3 + (set_local $8 + (i32.add + (get_local $8) + (i32.const 1) + ) + ) + (br_if $label$3 + (i64.ne + (tee_local $0 + (i64.shr_u + (get_local $0) + (i64.const 7) + ) + ) + (i64.const 0) + ) + ) + ) + (block $label$4 + (block $label$5 + (br_if $label$5 + (i32.eqz + (get_local $8) + ) + ) + (call $_ZNSt3__16vectorIcNS_9allocatorIcEEE8__appendEj + (get_local $2) + (get_local $8) + ) + (set_local $2 + (i32.load + (i32.add + (get_local $9) + (i32.const 56) + ) + ) + ) + (set_local $8 + (i32.load + (i32.add + (get_local $9) + (i32.const 52) + ) + ) + ) + (br $label$4) + ) + (set_local $2 + (i32.const 0) + ) + (set_local $8 + (i32.const 0) + ) + ) + (i32.store offset=84 + (get_local $9) + (get_local $8) + ) + (i32.store offset=80 + (get_local $9) + (get_local $8) + ) + (i32.store offset=88 + (get_local $9) + (get_local $2) + ) + (i32.store offset=64 + (get_local $9) + (i32.add + (get_local $9) + (i32.const 80) + ) + ) + (i32.store offset=72 + (get_local $9) + (get_local $3) + ) + (call $_ZN5boost6fusion6detail17for_each_unrolledILi4EE4callINS0_18std_tuple_iteratorIKNSt3__15tupleIJyyN5eosio5assetENS6_12basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEEEELi0EEEZNS8_lsINS8_10datastreamIPcEEJyyS9_SF_EEERT_SO_RKNS7_IJDpT0_EEEEUlRKSN_E_EEvSV_RKT0_ + (i32.add + (get_local $9) + (i32.const 72) + ) + (i32.add + (get_local $9) + (i32.const 64) + ) + ) + (call $_ZN5eosio4packINS_6actionEEENSt3__16vectorIcNS2_9allocatorIcEEEERKT_ + (i32.add + (get_local $9) + (i32.const 80) + ) + (i32.add + (get_local $9) + (i32.const 24) + ) + ) + (call $send_inline + (tee_local $8 + (i32.load offset=80 + (get_local $9) + ) + ) + (i32.sub + (i32.load offset=84 + (get_local $9) + ) + (get_local $8) + ) + ) + (block $label$6 + (br_if $label$6 + (i32.eqz + (tee_local $8 + (i32.load offset=80 + (get_local $9) + ) + ) + ) + ) + (i32.store offset=84 + (get_local $9) + (get_local $8) + ) + (call $_ZdlPv + (get_local $8) + ) + ) + (block $label$7 + (br_if $label$7 + (i32.eqz + (tee_local $8 + (i32.load offset=52 + (get_local $9) + ) + ) + ) + ) + (i32.store + (i32.add + (get_local $9) + (i32.const 56) + ) + (get_local $8) + ) + (call $_ZdlPv + (get_local $8) + ) + ) + (block $label$8 + (br_if $label$8 + (i32.eqz + (tee_local $8 + (i32.load offset=40 + (get_local $9) + ) + ) + ) + ) + (i32.store + (i32.add + (get_local $9) + (i32.const 44) + ) + (get_local $8) + ) + (call $_ZdlPv + (get_local $8) + ) + ) + (block $label$9 + (br_if $label$9 + (i32.eqz + (tee_local $8 + (i32.load offset=8 + (get_local $9) + ) + ) + ) + ) + (i32.store offset=12 + (get_local $9) + (get_local $8) + ) + (call $_ZdlPv + (get_local $8) + ) + ) + (i32.store offset=4 + (i32.const 0) + (i32.add + (get_local $9) + (i32.const 96) + ) + ) + (return) + ) + (call $_ZNKSt3__120__vector_base_commonILb1EE20__throw_length_errorEv + (i32.add + (get_local $9) + (i32.const 8) + ) + ) + (unreachable) + ) + (func $_ZNSt3__16vectorIcNS_9allocatorIcEEE8__appendEj (param $0 i32) (param $1 i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (block $label$0 + (block $label$1 + (block $label$2 + (block $label$3 + (block $label$4 + (br_if $label$4 + (i32.ge_u + (i32.sub + (tee_local $2 + (i32.load offset=8 + (get_local $0) + ) + ) + (tee_local $6 + (i32.load offset=4 + (get_local $0) + ) + ) + ) + (get_local $1) + ) + ) + (br_if $label$2 + (i32.le_s + (tee_local $4 + (i32.add + (tee_local $3 + (i32.sub + (get_local $6) + (tee_local $5 + (i32.load + (get_local $0) + ) + ) + ) + ) + (get_local $1) + ) + ) + (i32.const -1) + ) + ) + (set_local $6 + (i32.const 2147483647) + ) + (block $label$5 + (br_if $label$5 + (i32.gt_u + (tee_local $2 + (i32.sub + (get_local $2) + (get_local $5) + ) + ) + (i32.const 1073741822) + ) + ) + (br_if $label$3 + (i32.eqz + (tee_local $6 + (select + (get_local $4) + (tee_local $6 + (i32.shl + (get_local $2) + (i32.const 1) + ) + ) + (i32.lt_u + (get_local $6) + (get_local $4) + ) + ) + ) + ) + ) + ) + (set_local $2 + (call $_Znwj + (get_local $6) + ) + ) + (br $label$1) + ) + (set_local $0 + (i32.add + (get_local $0) + (i32.const 4) + ) + ) + (loop $label$6 + (i32.store8 + (get_local $6) + (i32.const 0) + ) + (i32.store + (get_local $0) + (tee_local $6 + (i32.add + (i32.load + (get_local $0) + ) + (i32.const 1) + ) + ) + ) + (br_if $label$6 + (tee_local $1 + (i32.add + (get_local $1) + (i32.const -1) + ) + ) + ) + (br $label$0) + ) + ) + (set_local $6 + (i32.const 0) + ) + (set_local $2 + (i32.const 0) + ) + (br $label$1) + ) + (call $_ZNKSt3__120__vector_base_commonILb1EE20__throw_length_errorEv + (get_local $0) + ) + (unreachable) + ) + (set_local $4 + (i32.add + (get_local $2) + (get_local $6) + ) + ) + (set_local $6 + (tee_local $5 + (i32.add + (get_local $2) + (get_local $3) + ) + ) + ) + (loop $label$7 + (i32.store8 + (get_local $6) + (i32.const 0) + ) + (set_local $6 + (i32.add + (get_local $6) + (i32.const 1) + ) + ) + (br_if $label$7 + (tee_local $1 + (i32.add + (get_local $1) + (i32.const -1) + ) + ) + ) + ) + (set_local $5 + (i32.sub + (get_local $5) + (tee_local $2 + (i32.sub + (i32.load + (tee_local $3 + (i32.add + (get_local $0) + (i32.const 4) + ) + ) + ) + (tee_local $1 + (i32.load + (get_local $0) + ) + ) + ) + ) + ) + ) + (block $label$8 + (br_if $label$8 + (i32.lt_s + (get_local $2) + (i32.const 1) + ) + ) + (drop + (call $memcpy + (get_local $5) + (get_local $1) + (get_local $2) + ) + ) + (set_local $1 + (i32.load + (get_local $0) + ) + ) + ) + (i32.store + (get_local $0) + (get_local $5) + ) + (i32.store + (get_local $3) + (get_local $6) + ) + (i32.store + (i32.add + (get_local $0) + (i32.const 8) + ) + (get_local $4) + ) + (br_if $label$0 + (i32.eqz + (get_local $1) + ) + ) + (call $_ZdlPv + (get_local $1) + ) + (return) + ) + ) + (func $_ZN5boost6fusion6detail17for_each_unrolledILi4EE4callINS0_18std_tuple_iteratorIKNSt3__15tupleIJyyN5eosio5assetENS6_12basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEEEELi0EEEZNS8_lsINS8_10datastreamIPcEEJyyS9_SF_EEERT_SO_RKNS7_IJDpT0_EEEEUlRKSN_E_EEvSV_RKT0_ (param $0 i32) (param $1 i32) + (local $2 i32) + (local $3 i32) + (set_local $2 + (i32.load + (get_local $0) + ) + ) + (call $eosio_assert + (i32.gt_s + (i32.sub + (i32.load offset=8 + (tee_local $3 + (i32.load + (get_local $1) + ) + ) + ) + (i32.load offset=4 + (get_local $3) + ) + ) + (i32.const 7) + ) + (i32.const 400) + ) + (drop + (call $memcpy + (i32.load offset=4 + (get_local $3) + ) + (get_local $2) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $3) + (i32.add + (i32.load offset=4 + (get_local $3) + ) + (i32.const 8) + ) + ) + (set_local $0 + (i32.load + (get_local $0) + ) + ) + (call $eosio_assert + (i32.gt_s + (i32.sub + (i32.load offset=8 + (tee_local $3 + (i32.load + (get_local $1) + ) + ) + ) + (i32.load offset=4 + (get_local $3) + ) + ) + (i32.const 7) + ) + (i32.const 400) + ) + (drop + (call $memcpy + (i32.load offset=4 + (get_local $3) + ) + (i32.add + (get_local $0) + (i32.const 8) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $3) + (i32.add + (i32.load offset=4 + (get_local $3) + ) + (i32.const 8) + ) + ) + (call $eosio_assert + (i32.gt_s + (i32.sub + (i32.load offset=8 + (tee_local $3 + (i32.load + (get_local $1) + ) + ) + ) + (i32.load offset=4 + (get_local $3) + ) + ) + (i32.const 7) + ) + (i32.const 400) + ) + (drop + (call $memcpy + (i32.load offset=4 + (get_local $3) + ) + (i32.add + (get_local $0) + (i32.const 16) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $3) + (tee_local $2 + (i32.add + (i32.load offset=4 + (get_local $3) + ) + (i32.const 8) + ) + ) + ) + (call $eosio_assert + (i32.gt_s + (i32.sub + (i32.load offset=8 + (get_local $3) + ) + (get_local $2) + ) + (i32.const 7) + ) + (i32.const 400) + ) + (drop + (call $memcpy + (i32.load offset=4 + (get_local $3) + ) + (i32.add + (get_local $0) + (i32.const 24) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $3) + (i32.add + (i32.load offset=4 + (get_local $3) + ) + (i32.const 8) + ) + ) + (drop + (call $_ZN5eosiolsINS_10datastreamIPcEEEERT_S5_RKNSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEE + (i32.load + (get_local $1) + ) + (i32.add + (get_local $0) + (i32.const 32) + ) + ) + ) + ) + (func $_ZN5eosio4packINS_6actionEEENSt3__16vectorIcNS2_9allocatorIcEEEERKT_ (param $0 i32) (param $1 i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i64) + (local $7 i32) + (local $8 i32) + (i32.store offset=4 + (i32.const 0) + (tee_local $8 + (i32.sub + (i32.load offset=4 + (i32.const 0) + ) + (i32.const 16) + ) + ) + ) + (i32.store offset=8 + (get_local $0) + (i32.const 0) + ) + (i64.store align=4 + (get_local $0) + (i64.const 0) + ) + (set_local $5 + (i32.const 16) + ) + (set_local $2 + (i32.add + (get_local $1) + (i32.const 16) + ) + ) + (set_local $6 + (i64.extend_u/i32 + (i32.shr_s + (tee_local $4 + (i32.sub + (tee_local $7 + (i32.load + (i32.add + (get_local $1) + (i32.const 20) + ) + ) + ) + (tee_local $3 + (i32.load offset=16 + (get_local $1) + ) + ) + ) + ) + (i32.const 4) + ) + ) + ) + (loop $label$0 + (set_local $5 + (i32.add + (get_local $5) + (i32.const 1) + ) + ) + (br_if $label$0 + (i64.ne + (tee_local $6 + (i64.shr_u + (get_local $6) + (i64.const 7) + ) + ) + (i64.const 0) + ) + ) + ) + (block $label$1 + (br_if $label$1 + (i32.eq + (get_local $3) + (get_local $7) + ) + ) + (set_local $5 + (i32.add + (i32.and + (get_local $4) + (i32.const -16) + ) + (get_local $5) + ) + ) + ) + (set_local $5 + (i32.sub + (i32.sub + (tee_local $7 + (i32.load offset=28 + (get_local $1) + ) + ) + (get_local $5) + ) + (tee_local $3 + (i32.load + (i32.add + (get_local $1) + (i32.const 32) + ) + ) + ) + ) + ) + (set_local $4 + (i32.add + (get_local $1) + (i32.const 28) + ) + ) + (set_local $6 + (i64.extend_u/i32 + (i32.sub + (get_local $3) + (get_local $7) + ) + ) + ) + (loop $label$2 + (set_local $5 + (i32.add + (get_local $5) + (i32.const -1) + ) + ) + (br_if $label$2 + (i64.ne + (tee_local $6 + (i64.shr_u + (get_local $6) + (i64.const 7) + ) + ) + (i64.const 0) + ) + ) + ) + (set_local $7 + (i32.const 0) + ) + (block $label$3 + (block $label$4 + (br_if $label$4 + (i32.eqz + (get_local $5) + ) + ) + (call $_ZNSt3__16vectorIcNS_9allocatorIcEEE8__appendEj + (get_local $0) + (i32.sub + (i32.const 0) + (get_local $5) + ) + ) + (set_local $7 + (i32.load + (i32.add + (get_local $0) + (i32.const 4) + ) + ) + ) + (set_local $5 + (i32.load + (get_local $0) + ) + ) + (br $label$3) + ) + (set_local $5 + (i32.const 0) + ) + ) + (i32.store + (get_local $8) + (get_local $5) + ) + (i32.store offset=8 + (get_local $8) + (get_local $7) + ) + (call $eosio_assert + (i32.gt_s + (i32.sub + (get_local $7) + (get_local $5) + ) + (i32.const 7) + ) + (i32.const 400) + ) + (drop + (call $memcpy + (get_local $5) + (get_local $1) + (i32.const 8) + ) + ) + (call $eosio_assert + (i32.gt_s + (i32.sub + (get_local $7) + (tee_local $0 + (i32.add + (get_local $5) + (i32.const 8) + ) + ) + ) + (i32.const 7) + ) + (i32.const 400) + ) + (drop + (call $memcpy + (get_local $0) + (i32.add + (get_local $1) + (i32.const 8) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $8) + (i32.add + (get_local $5) + (i32.const 16) + ) + ) + (drop + (call $_ZN5eosiolsINS_10datastreamIPcEEEERT_S5_RKNSt3__16vectorIcNS6_9allocatorIcEEEE + (call $_ZN5eosiolsINS_10datastreamIPcEENS_16permission_levelEEERT_S6_RKNSt3__16vectorIT0_NS7_9allocatorIS9_EEEE + (get_local $8) + (get_local $2) + ) + (get_local $4) + ) + ) + (i32.store offset=4 + (i32.const 0) + (i32.add + (get_local $8) + (i32.const 16) + ) + ) + ) + (func $_ZN5eosiolsINS_10datastreamIPcEENS_16permission_levelEEERT_S6_RKNSt3__16vectorIT0_NS7_9allocatorIS9_EEEE (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + (local $3 i32) + (local $4 i64) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (i32.store offset=4 + (i32.const 0) + (tee_local $7 + (i32.sub + (i32.load offset=4 + (i32.const 0) + ) + (i32.const 16) + ) + ) + ) + (set_local $4 + (i64.extend_u/i32 + (i32.shr_s + (i32.sub + (i32.load offset=4 + (get_local $1) + ) + (i32.load + (get_local $1) + ) + ) + (i32.const 4) + ) + ) + ) + (set_local $5 + (i32.load offset=4 + (get_local $0) + ) + ) + (set_local $2 + (i32.add + (get_local $0) + (i32.const 8) + ) + ) + (loop $label$0 + (set_local $3 + (i32.wrap/i64 + (get_local $4) + ) + ) + (i32.store8 offset=15 + (get_local $7) + (i32.or + (i32.shl + (tee_local $6 + (i64.ne + (tee_local $4 + (i64.shr_u + (get_local $4) + (i64.const 7) + ) + ) + (i64.const 0) + ) + ) + (i32.const 7) + ) + (i32.and + (get_local $3) + (i32.const 127) + ) + ) + ) + (call $eosio_assert + (i32.gt_s + (i32.sub + (i32.load + (get_local $2) + ) + (get_local $5) + ) + (i32.const 0) + ) + (i32.const 400) + ) + (drop + (call $memcpy + (i32.load + (tee_local $3 + (i32.add + (get_local $0) + (i32.const 4) + ) + ) + ) + (i32.add + (get_local $7) + (i32.const 15) + ) + (i32.const 1) + ) + ) + (i32.store + (get_local $3) + (tee_local $5 + (i32.add + (i32.load + (get_local $3) + ) + (i32.const 1) + ) + ) + ) + (br_if $label$0 + (get_local $6) + ) + ) + (block $label$1 + (br_if $label$1 + (i32.eq + (tee_local $6 + (i32.load + (get_local $1) + ) + ) + (tee_local $1 + (i32.load + (i32.add + (get_local $1) + (i32.const 4) + ) + ) + ) + ) + ) + (set_local $3 + (i32.add + (get_local $0) + (i32.const 4) + ) + ) + (loop $label$2 + (call $eosio_assert + (i32.gt_s + (i32.sub + (i32.load + (tee_local $2 + (i32.add + (get_local $0) + (i32.const 8) + ) + ) + ) + (get_local $5) + ) + (i32.const 7) + ) + (i32.const 400) + ) + (drop + (call $memcpy + (i32.load + (get_local $3) + ) + (get_local $6) + (i32.const 8) + ) + ) + (i32.store + (get_local $3) + (tee_local $5 + (i32.add + (i32.load + (get_local $3) + ) + (i32.const 8) + ) + ) + ) + (call $eosio_assert + (i32.gt_s + (i32.sub + (i32.load + (get_local $2) + ) + (get_local $5) + ) + (i32.const 7) + ) + (i32.const 400) + ) + (drop + (call $memcpy + (i32.load + (get_local $3) + ) + (i32.add + (get_local $6) + (i32.const 8) + ) + (i32.const 8) + ) + ) + (i32.store + (get_local $3) + (tee_local $5 + (i32.add + (i32.load + (get_local $3) + ) + (i32.const 8) + ) + ) + ) + (br_if $label$2 + (i32.ne + (tee_local $6 + (i32.add + (get_local $6) + (i32.const 16) + ) + ) + (get_local $1) + ) + ) + ) + ) + (i32.store offset=4 + (i32.const 0) + (i32.add + (get_local $7) + (i32.const 16) + ) + ) + (get_local $0) + ) + (func $_ZN5eosiolsINS_10datastreamIPcEEEERT_S5_RKNSt3__16vectorIcNS6_9allocatorIcEEEE (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i64) + (local $8 i32) + (i32.store offset=4 + (i32.const 0) + (tee_local $8 + (i32.sub + (i32.load offset=4 + (i32.const 0) + ) + (i32.const 16) + ) + ) + ) + (set_local $7 + (i64.extend_u/i32 + (i32.sub + (i32.load offset=4 + (get_local $1) + ) + (i32.load + (get_local $1) + ) + ) + ) + ) + (set_local $6 + (i32.load offset=4 + (get_local $0) + ) + ) + (set_local $4 + (i32.add + (get_local $0) + (i32.const 8) + ) + ) + (set_local $5 + (i32.add + (get_local $0) + (i32.const 4) + ) + ) + (loop $label$0 + (set_local $2 + (i32.wrap/i64 + (get_local $7) + ) + ) + (i32.store8 offset=15 + (get_local $8) + (i32.or + (i32.shl + (tee_local $3 + (i64.ne + (tee_local $7 + (i64.shr_u + (get_local $7) + (i64.const 7) + ) + ) + (i64.const 0) + ) + ) + (i32.const 7) + ) + (i32.and + (get_local $2) + (i32.const 127) + ) + ) + ) + (call $eosio_assert + (i32.gt_s + (i32.sub + (i32.load + (get_local $4) + ) + (get_local $6) + ) + (i32.const 0) + ) + (i32.const 400) + ) + (drop + (call $memcpy + (i32.load + (get_local $5) + ) + (i32.add + (get_local $8) + (i32.const 15) + ) + (i32.const 1) + ) + ) + (i32.store + (get_local $5) + (tee_local $6 + (i32.add + (i32.load + (get_local $5) + ) + (i32.const 1) + ) + ) + ) + (br_if $label$0 + (get_local $3) + ) + ) + (call $eosio_assert + (i32.ge_s + (i32.sub + (i32.load + (i32.add + (get_local $0) + (i32.const 8) + ) + ) + (get_local $6) + ) + (tee_local $5 + (i32.sub + (i32.load + (i32.add + (get_local $1) + (i32.const 4) + ) + ) + (tee_local $2 + (i32.load + (get_local $1) + ) + ) + ) + ) + ) + (i32.const 400) + ) + (drop + (call $memcpy + (i32.load + (tee_local $6 + (i32.add + (get_local $0) + (i32.const 4) + ) + ) + ) + (get_local $2) + (get_local $5) + ) + ) + (i32.store + (get_local $6) + (i32.add + (i32.load + (get_local $6) + ) + (get_local $5) + ) + ) + (i32.store offset=4 + (i32.const 0) + (i32.add + (get_local $8) + (i32.const 16) + ) + ) + (get_local $0) + ) + (func $_ZN5eosiolsINS_10datastreamIPcEEEERT_S5_RKNSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEE (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i64) + (local $8 i32) + (i32.store offset=4 + (i32.const 0) + (tee_local $8 + (i32.sub + (i32.load offset=4 + (i32.const 0) + ) + (i32.const 16) + ) + ) + ) + (set_local $7 + (i64.extend_u/i32 + (select + (i32.load offset=4 + (get_local $1) + ) + (i32.shr_u + (tee_local $5 + (i32.load8_u + (get_local $1) + ) + ) + (i32.const 1) + ) + (i32.and + (get_local $5) + (i32.const 1) + ) + ) + ) + ) + (set_local $6 + (i32.load offset=4 + (get_local $0) + ) + ) + (set_local $4 + (i32.add + (get_local $0) + (i32.const 8) + ) + ) + (set_local $5 + (i32.add + (get_local $0) + (i32.const 4) + ) + ) + (loop $label$0 + (set_local $2 + (i32.wrap/i64 + (get_local $7) + ) + ) + (i32.store8 offset=15 + (get_local $8) + (i32.or + (i32.shl + (tee_local $3 + (i64.ne + (tee_local $7 + (i64.shr_u + (get_local $7) + (i64.const 7) + ) + ) + (i64.const 0) + ) + ) + (i32.const 7) + ) + (i32.and + (get_local $2) + (i32.const 127) + ) + ) + ) + (call $eosio_assert + (i32.gt_s + (i32.sub + (i32.load + (get_local $4) + ) + (get_local $6) + ) + (i32.const 0) + ) + (i32.const 400) + ) + (drop + (call $memcpy + (i32.load + (get_local $5) + ) + (i32.add + (get_local $8) + (i32.const 15) + ) + (i32.const 1) + ) + ) + (i32.store + (get_local $5) + (tee_local $6 + (i32.add + (i32.load + (get_local $5) + ) + (i32.const 1) + ) + ) + ) + (br_if $label$0 + (get_local $3) + ) + ) + (block $label$1 + (br_if $label$1 + (i32.eqz + (tee_local $5 + (select + (i32.load + (i32.add + (get_local $1) + (i32.const 4) + ) + ) + (i32.shr_u + (tee_local $5 + (i32.load8_u + (get_local $1) + ) + ) + (i32.const 1) + ) + (tee_local $2 + (i32.and + (get_local $5) + (i32.const 1) + ) + ) + ) + ) + ) + ) + (set_local $3 + (i32.load offset=8 + (get_local $1) + ) + ) + (call $eosio_assert + (i32.ge_s + (i32.sub + (i32.load + (i32.add + (get_local $0) + (i32.const 8) + ) + ) + (get_local $6) + ) + (get_local $5) + ) + (i32.const 400) + ) + (drop + (call $memcpy + (i32.load + (tee_local $6 + (i32.add + (get_local $0) + (i32.const 4) + ) + ) + ) + (select + (get_local $3) + (i32.add + (get_local $1) + (i32.const 1) + ) + (get_local $2) + ) + (get_local $5) + ) + ) + (i32.store + (get_local $6) + (i32.add + (i32.load + (get_local $6) + ) + (get_local $5) + ) + ) + ) + (i32.store offset=4 + (i32.const 0) + (i32.add + (get_local $8) + (i32.const 16) + ) + ) + (get_local $0) + ) + (func $_ZN6eoswin7lottery14get_stage_feesERKN5eosio5assetERhS5_ (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) + (local $4 i64) + (block $label$0 + (br_if $label$0 + (i64.gt_s + (tee_local $4 + (i64.load + (get_local $1) + ) + ) + (i64.const 1000000) + ) + ) + (i32.store8 + (get_local $2) + (i32.sub + (i32.sub + (i32.sub + (i32.const 100) + (i32.load8_u + (i32.add + (get_local $0) + (i32.const 90) + ) + ) + ) + (i32.load8_u + (i32.add + (get_local $0) + (i32.const 88) + ) + ) + ) + (i32.load8_u + (tee_local $0 + (i32.add + (get_local $0) + (i32.const 89) + ) + ) + ) + ) + ) + (i32.store8 + (get_local $3) + (i32.load8_u + (get_local $0) + ) + ) + (return) + ) + (block $label$1 + (br_if $label$1 + (i64.gt_s + (get_local $4) + (i64.const 3000000) + ) + ) + (i32.store8 + (get_local $2) + (i32.const 72) + ) + (i32.store8 + (get_local $3) + (i32.const 7) + ) + (return) + ) + (i32.store8 + (get_local $2) + (i32.const 60) + ) + (i32.store8 + (get_local $3) + (i32.const 10) + ) + ) + (func $_ZN6eoswin7lottery6activeEy (type $FUNCSIG$vij) (param $0 i32) (param $1 i64) + (local $2 i64) + (local $3 i32) + (local $4 i32) + (local $5 i64) + (local $6 i64) + (local $7 i64) + (local $8 i64) + (local $9 i32) + (i32.store offset=4 + (i32.const 0) + (tee_local $9 + (i32.sub + (i32.load offset=4 + (i32.const 0) + ) + (i32.const 16) + ) + ) + ) + (call $eosio_assert + (i32.xor + (i32.load8_u + (i32.add + (get_local $0) + (i32.const 140) + ) + ) + (i32.const 1) + ) + (i32.const 640) + ) + (call $require_auth + (get_local $1) + ) + (set_local $2 + (i64.load + (get_local $0) + ) + ) + (set_local $6 + (i64.const 0) + ) + (set_local $5 + (i64.const 59) + ) + (set_local $4 + (i32.const 592) + ) + (set_local $7 + (i64.const 0) + ) + (loop $label$0 + (block $label$1 + (block $label$2 + (block $label$3 + (block $label$4 + (block $label$5 + (br_if $label$5 + (i64.gt_u + (get_local $6) + (i64.const 5) + ) + ) + (br_if $label$4 + (i32.gt_u + (i32.and + (i32.add + (tee_local $3 + (i32.load8_s + (get_local $4) + ) + ) + (i32.const -97) + ) + (i32.const 255) + ) + (i32.const 25) + ) + ) + (set_local $3 + (i32.add + (get_local $3) + (i32.const 165) + ) + ) + (br $label$3) + ) + (set_local $8 + (i64.const 0) + ) + (br_if $label$2 + (i64.le_u + (get_local $6) + (i64.const 11) + ) + ) + (br $label$1) + ) + (set_local $3 + (select + (i32.add + (get_local $3) + (i32.const 208) + ) + (i32.const 0) + (i32.lt_u + (i32.and + (i32.add + (get_local $3) + (i32.const -49) + ) + (i32.const 255) + ) + (i32.const 5) + ) + ) + ) + ) + (set_local $8 + (i64.shr_s + (i64.shl + (i64.extend_u/i32 + (get_local $3) + ) + (i64.const 56) + ) + (i64.const 56) + ) + ) + ) + (set_local $8 + (i64.shl + (i64.and + (get_local $8) + (i64.const 31) + ) + (i64.and + (get_local $5) + (i64.const 4294967295) + ) + ) + ) + ) + (set_local $4 + (i32.add + (get_local $4) + (i32.const 1) + ) + ) + (set_local $6 + (i64.add + (get_local $6) + (i64.const 1) + ) + ) + (set_local $7 + (i64.or + (get_local $8) + (get_local $7) + ) + ) + (br_if $label$0 + (i64.ne + (tee_local $5 + (i64.add + (get_local $5) + (i64.const -5) + ) + ) + (i64.const -6) + ) + ) + ) + (i64.store + (tee_local $4 + (call $_Znwj + (i32.const 16) + ) + ) + (get_local $2) + ) + (i64.store offset=8 + (get_local $4) + (get_local $7) + ) + (i32.store + (get_local $9) + (get_local $4) + ) + (i32.store offset=8 + (get_local $9) + (tee_local $4 + (i32.add + (get_local $4) + (i32.const 16) + ) + ) + ) + (i32.store offset=4 + (get_local $9) + (get_local $4) + ) + (call $_ZN5eosio15dispatch_inlineIJbEEEvyyNSt3__16vectorINS_16permission_levelENS1_9allocatorIS3_EEEENS1_5tupleIJDpT_EEE + (get_local $2) + (i64.const -4417357895862960128) + (get_local $9) + (i32.const 1) + ) + (block $label$6 + (br_if $label$6 + (i32.eqz + (tee_local $4 + (i32.load + (get_local $9) + ) + ) + ) + ) + (i32.store offset=4 + (get_local $9) + (get_local $4) + ) + (call $_ZdlPv + (get_local $4) + ) + ) + (call $_ZN6eoswin7lottery8newroundEy + (get_local $0) + (get_local $1) + ) + (i32.store offset=4 + (i32.const 0) + (i32.add + (get_local $9) + (i32.const 16) + ) + ) + ) + (func $_ZN5eosio15dispatch_inlineIJbEEEvyyNSt3__16vectorINS_16permission_levelENS1_9allocatorIS3_EEEENS1_5tupleIJDpT_EEE (param $0 i64) (param $1 i64) (param $2 i32) (param $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (local $8 i32) + (local $9 i32) + (i32.store offset=4 + (i32.const 0) + (tee_local $9 + (i32.sub + (i32.load offset=4 + (i32.const 0) + ) + (i32.const 80) + ) + ) + ) + (i32.store offset=16 + (get_local $9) + (i32.const 0) + ) + (i64.store offset=8 + (get_local $9) + (i64.const 0) + ) + (set_local $6 + (i32.const 0) + ) + (set_local $7 + (i32.const 0) + ) + (set_local $8 + (i32.const 0) + ) + (block $label$0 + (block $label$1 + (br_if $label$1 + (i32.eqz + (tee_local $5 + (i32.shr_s + (tee_local $4 + (i32.sub + (i32.load offset=4 + (get_local $2) + ) + (i32.load + (get_local $2) + ) + ) + ) + (i32.const 4) + ) + ) + ) + ) + (br_if $label$0 + (i32.ge_u + (get_local $5) + (i32.const 268435456) + ) + ) + (i32.store + (i32.add + (get_local $9) + (i32.const 16) + ) + (tee_local $6 + (i32.add + (tee_local $8 + (call $_Znwj + (get_local $4) + ) + ) + (i32.shl + (get_local $5) + (i32.const 4) + ) + ) + ) + ) + (i32.store offset=8 + (get_local $9) + (get_local $8) + ) + (i32.store offset=12 + (get_local $9) + (get_local $8) + ) + (block $label$2 + (br_if $label$2 + (i32.lt_s + (tee_local $2 + (i32.sub + (i32.load + (i32.add + (get_local $2) + (i32.const 4) + ) + ) + (tee_local $7 + (i32.load + (get_local $2) + ) + ) + ) + ) + (i32.const 1) + ) + ) + (drop + (call $memcpy + (get_local $8) + (get_local $7) + (get_local $2) + ) + ) + (i32.store offset=12 + (get_local $9) + (tee_local $7 + (i32.add + (get_local $8) + (get_local $2) + ) + ) + ) + (br $label$1) + ) + (set_local $7 + (get_local $8) + ) + ) + (i32.store + (i32.add + (get_local $9) + (i32.const 44) + ) + (get_local $7) + ) + (i64.store offset=32 + (get_local $9) + (get_local $1) + ) + (i32.store + (i32.add + (get_local $9) + (i32.const 16) + ) + (i32.const 0) + ) + (i32.store + (i32.add + (get_local $9) + (i32.const 48) + ) + (get_local $6) + ) + (i64.store offset=24 + (get_local $9) + (get_local $0) + ) + (i32.store offset=40 + (get_local $9) + (get_local $8) + ) + (i64.store offset=8 + (get_local $9) + (i64.const 0) + ) + (i32.store offset=52 + (get_local $9) + (i32.const 0) + ) + (i32.store + (tee_local $8 + (i32.add + (get_local $9) + (i32.const 56) + ) + ) + (i32.const 0) + ) + (i32.store + (i32.add + (get_local $9) + (i32.const 60) + ) + (i32.const 0) + ) + (call $_ZNSt3__16vectorIcNS_9allocatorIcEEE8__appendEj + (i32.add + (get_local $9) + (i32.const 52) + ) + (i32.const 1) + ) + (set_local $2 + (i32.load + (get_local $8) + ) + ) + (set_local $8 + (i32.load offset=52 + (get_local $9) + ) + ) + (i32.store8 offset=64 + (get_local $9) + (i32.and + (get_local $3) + (i32.const 1) + ) + ) + (call $eosio_assert + (i32.gt_s + (i32.sub + (get_local $2) + (get_local $8) + ) + (i32.const 0) + ) + (i32.const 400) + ) + (drop + (call $memcpy + (get_local $8) + (i32.add + (get_local $9) + (i32.const 64) + ) + (i32.const 1) + ) + ) + (call $_ZN5eosio4packINS_6actionEEENSt3__16vectorIcNS2_9allocatorIcEEEERKT_ + (i32.add + (get_local $9) + (i32.const 64) + ) + (i32.add + (get_local $9) + (i32.const 24) + ) + ) + (call $send_inline + (tee_local $8 + (i32.load offset=64 + (get_local $9) + ) + ) + (i32.sub + (i32.load offset=68 + (get_local $9) + ) + (get_local $8) + ) + ) + (block $label$3 + (br_if $label$3 + (i32.eqz + (tee_local $8 + (i32.load offset=64 + (get_local $9) + ) + ) + ) + ) + (i32.store offset=68 + (get_local $9) + (get_local $8) + ) + (call $_ZdlPv + (get_local $8) + ) + ) + (block $label$4 + (br_if $label$4 + (i32.eqz + (tee_local $8 + (i32.load offset=52 + (get_local $9) + ) + ) + ) + ) + (i32.store + (i32.add + (get_local $9) + (i32.const 56) + ) + (get_local $8) + ) + (call $_ZdlPv + (get_local $8) + ) + ) + (block $label$5 + (br_if $label$5 + (i32.eqz + (tee_local $8 + (i32.load offset=40 + (get_local $9) + ) + ) + ) + ) + (i32.store + (i32.add + (get_local $9) + (i32.const 44) + ) + (get_local $8) + ) + (call $_ZdlPv + (get_local $8) + ) + ) + (block $label$6 + (br_if $label$6 + (i32.eqz + (tee_local $8 + (i32.load offset=8 + (get_local $9) + ) + ) + ) + ) + (i32.store offset=12 + (get_local $9) + (get_local $8) + ) + (call $_ZdlPv + (get_local $8) + ) + ) + (i32.store offset=4 + (i32.const 0) + (i32.add + (get_local $9) + (i32.const 80) + ) + ) + (return) + ) + (call $_ZNKSt3__120__vector_base_commonILb1EE20__throw_length_errorEv + (i32.add + (get_local $9) + (i32.const 8) + ) + ) + (unreachable) + ) + (func $_ZN6eoswin7lottery8newroundEy (param $0 i32) (param $1 i64) + (local $2 i64) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (local $8 i64) + (local $9 i32) + (local $10 i32) + (local $11 i64) + (local $12 i64) + (local $13 i32) + (i32.store offset=4 + (i32.const 0) + (tee_local $13 + (i32.sub + (i32.load offset=4 + (i32.const 0) + ) + (i32.const 112) + ) + ) + ) + (call $eosio_assert + (i64.ne + (tee_local $8 + (i64.load + (i32.add + (get_local $0) + (i32.const 64) + ) + ) + ) + (i64.const -1) + ) + (i32.const 672) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 176) + ) + (set_local $2 + (i64.add + (get_local $8) + (i64.const 1) + ) + ) + (set_local $9 + (i32.const 0) + ) + (set_local $8 + (i64.const 5459781) + ) + (set_local $11 + (i64.const 1397703940) + ) + (block $label$0 + (block $label$1 + (loop $label$2 + (br_if $label$1 + (i32.gt_u + (i32.add + (i32.shl + (i32.wrap/i64 + (get_local $8) + ) + (i32.const 24) + ) + (i32.const -1073741825) + ) + (i32.const 452984830) + ) + ) + (block $label$3 + (br_if $label$3 + (i64.ne + (i64.and + (tee_local $8 + (i64.shr_u + (get_local $8) + (i64.const 8) + ) + ) + (i64.const 255) + ) + (i64.const 0) + ) + ) + (loop $label$4 + (br_if $label$1 + (i64.ne + (i64.and + (tee_local $8 + (i64.shr_u + (get_local $8) + (i64.const 8) + ) + ) + (i64.const 255) + ) + (i64.const 0) + ) + ) + (br_if $label$4 + (i32.lt_s + (tee_local $9 + (i32.add + (get_local $9) + (i32.const 1) + ) + ) + (i32.const 7) + ) + ) + ) + ) + (set_local $6 + (i32.const 1) + ) + (br_if $label$2 + (i32.lt_s + (tee_local $9 + (i32.add + (get_local $9) + (i32.const 1) + ) + ) + (i32.const 7) + ) + ) + (br $label$0) + ) + ) + (set_local $6 + (i32.const 0) + ) + ) + (call $eosio_assert + (get_local $6) + (i32.const 128) + ) + (set_local $8 + (i64.load + (i32.add + (get_local $0) + (i32.const 64) + ) + ) + ) + (block $label$5 + (br_if $label$5 + (i32.eq + (tee_local $10 + (i32.load + (i32.add + (get_local $0) + (i32.const 172) + ) + ) + ) + (tee_local $4 + (i32.load + (i32.add + (get_local $0) + (i32.const 168) + ) + ) + ) + ) + ) + (set_local $9 + (i32.add + (get_local $10) + (i32.const -24) + ) + ) + (set_local $5 + (i32.sub + (i32.const 0) + (get_local $4) + ) + ) + (loop $label$6 + (br_if $label$5 + (i64.eq + (i64.load + (i32.load + (get_local $9) + ) + ) + (get_local $8) + ) + ) + (set_local $10 + (get_local $9) + ) + (set_local $9 + (tee_local $6 + (i32.add + (get_local $9) + (i32.const -24) + ) + ) + ) + (br_if $label$6 + (i32.ne + (i32.add + (get_local $6) + (get_local $5) + ) + (i32.const -24) + ) + ) + ) + ) + (set_local $3 + (i32.add + (get_local $0) + (i32.const 144) + ) + ) + (block $label$7 + (block $label$8 + (br_if $label$8 + (i32.eq + (get_local $10) + (get_local $4) + ) + ) + (call $eosio_assert + (i32.eq + (i32.load offset=80 + (tee_local $7 + (i32.load + (i32.add + (get_local $10) + (i32.const -24) + ) + ) + ) + ) + (get_local $3) + ) + (i32.const 32) + ) + (br $label$7) + ) + (set_local $7 + (i32.const 0) + ) + (br_if $label$7 + (i32.lt_s + (tee_local $9 + (call $db_find_i64 + (i64.load + (i32.add + (get_local $0) + (i32.const 144) + ) + ) + (i64.load + (i32.add + (get_local $0) + (i32.const 152) + ) + ) + (i64.const -4812882490098188288) + (get_local $8) + ) + ) + (i32.const 0) + ) + ) + (call $eosio_assert + (i32.eq + (i32.load offset=80 + (tee_local $7 + (call $_ZNK5eosio11multi_indexILy13633861583611363328EN6eoswin10round_itemEJEE31load_object_by_primary_iteratorEl + (get_local $3) + (get_local $9) + ) + ) + ) + (get_local $3) + ) + (i32.const 32) + ) + ) + (set_local $8 + (i64.load + (i32.add + (get_local $0) + (i32.const 64) + ) + ) + ) + (block $label$9 + (br_if $label$9 + (i32.eq + (tee_local $10 + (i32.load + (i32.add + (get_local $0) + (i32.const 212) + ) + ) + ) + (tee_local $4 + (i32.load + (i32.add + (get_local $0) + (i32.const 208) + ) + ) + ) + ) + ) + (set_local $9 + (i32.add + (get_local $10) + (i32.const -24) + ) + ) + (set_local $5 + (i32.sub + (i32.const 0) + (get_local $4) + ) + ) + (loop $label$10 + (br_if $label$9 + (i64.eq + (i64.load + (i32.load + (get_local $9) + ) + ) + (get_local $8) + ) + ) + (set_local $10 + (get_local $9) + ) + (set_local $9 + (tee_local $6 + (i32.add + (get_local $9) + (i32.const -24) + ) + ) + ) + (br_if $label$10 + (i32.ne + (i32.add + (get_local $6) + (get_local $5) + ) + (i32.const -24) + ) + ) + ) + ) + (set_local $9 + (i32.add + (get_local $0) + (i32.const 184) + ) + ) + (block $label$11 + (block $label$12 + (block $label$13 + (block $label$14 + (br_if $label$14 + (i32.eq + (get_local $10) + (get_local $4) + ) + ) + (call $eosio_assert + (i32.eq + (i32.load offset=72 + (tee_local $6 + (i32.load + (i32.add + (get_local $10) + (i32.const -24) + ) + ) + ) + ) + (get_local $9) + ) + (i32.const 32) + ) + (set_local $12 + (i64.const 0) + ) + (br_if $label$13 + (get_local $7) + ) + (br $label$11) + ) + (br_if $label$12 + (i32.lt_s + (tee_local $6 + (call $db_find_i64 + (i64.load + (i32.add + (get_local $0) + (i32.const 184) + ) + ) + (i64.load + (i32.add + (get_local $0) + (i32.const 192) + ) + ) + (i64.const -4812882707900006400) + (get_local $8) + ) + ) + (i32.const 0) + ) + ) + (call $eosio_assert + (i32.eq + (i32.load offset=72 + (tee_local $6 + (call $_ZNK5eosio11multi_indexILy13633861365809545216EN6eoswin13roundfee_itemEJEE31load_object_by_primary_iteratorEl + (get_local $9) + (get_local $6) + ) + ) + ) + (get_local $9) + ) + (i32.const 32) + ) + (set_local $12 + (i64.const 0) + ) + (br_if $label$11 + (i32.eqz + (get_local $7) + ) + ) + ) + (br_if $label$11 + (i32.eqz + (get_local $6) + ) + ) + (set_local $12 + (i64.const 0) + ) + (br_if $label$11 + (i64.ne + (i64.load offset=72 + (get_local $7) + ) + (i64.const 0) + ) + ) + (set_local $11 + (i64.load + (i32.add + (get_local $6) + (i32.const 64) + ) + ) + ) + (set_local $12 + (i64.load offset=56 + (get_local $6) + ) + ) + (br $label$11) + ) + (set_local $12 + (i64.const 0) + ) + ) + (call $eosio_assert + (i64.eq + (i64.load + (get_local $3) + ) + (call $current_receiver) + ) + (i32.const 336) + ) + (i64.store offset=32 + (tee_local $6 + (call $_Znwj + (i32.const 96) + ) + ) + (i64.const 1397703940) + ) + (i64.store offset=24 + (get_local $6) + (i64.const 0) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 176) + ) + (set_local $8 + (i64.const 5459781) + ) + (set_local $9 + (i32.const 0) + ) + (block $label$15 + (block $label$16 + (loop $label$17 + (br_if $label$16 + (i32.gt_u + (i32.add + (i32.shl + (i32.wrap/i64 + (get_local $8) + ) + (i32.const 24) + ) + (i32.const -1073741825) + ) + (i32.const 452984830) + ) + ) + (block $label$18 + (br_if $label$18 + (i64.ne + (i64.and + (tee_local $8 + (i64.shr_u + (get_local $8) + (i64.const 8) + ) + ) + (i64.const 255) + ) + (i64.const 0) + ) + ) + (loop $label$19 + (br_if $label$16 + (i64.ne + (i64.and + (tee_local $8 + (i64.shr_u + (get_local $8) + (i64.const 8) + ) + ) + (i64.const 255) + ) + (i64.const 0) + ) + ) + (br_if $label$19 + (i32.lt_s + (tee_local $9 + (i32.add + (get_local $9) + (i32.const 1) + ) + ) + (i32.const 7) + ) + ) + ) + ) + (set_local $10 + (i32.const 1) + ) + (br_if $label$17 + (i32.lt_s + (tee_local $9 + (i32.add + (get_local $9) + (i32.const 1) + ) + ) + (i32.const 7) + ) + ) + (br $label$15) + ) + ) + (set_local $10 + (i32.const 0) + ) + ) + (call $eosio_assert + (get_local $10) + (i32.const 128) + ) + (i32.store offset=80 + (get_local $6) + (get_local $3) + ) + (i64.store offset=8 + (get_local $6) + (i64.const 0) + ) + (i64.store + (get_local $6) + (get_local $2) + ) + (i64.store offset=16 + (get_local $6) + (i64.const 0) + ) + (i64.store + (i32.add + (get_local $6) + (i32.const 24) + ) + (get_local $12) + ) + (i64.store + (i32.add + (get_local $6) + (i32.const 32) + ) + (get_local $11) + ) + (set_local $8 + (call $current_time) + ) + (i64.store offset=56 + (get_local $6) + (i64.const 0) + ) + (i64.store offset=48 + (get_local $6) + (get_local $8) + ) + (i32.store offset=104 + (get_local $13) + (i32.add + (i32.add + (get_local $13) + (i32.const 16) + ) + (i32.const 80) + ) + ) + (i32.store offset=100 + (get_local $13) + (i32.add + (get_local $13) + (i32.const 16) + ) + ) + (i32.store offset=96 + (get_local $13) + (i32.add + (get_local $13) + (i32.const 16) + ) + ) + (drop + (call $_ZN6eoswinlsIN5eosio10datastreamIPcEEEERT_S6_RKNS_10round_itemE + (i32.add + (get_local $13) + (i32.const 96) + ) + (get_local $6) + ) + ) + (i32.store offset=84 + (get_local $6) + (tee_local $10 + (call $db_store_i64 + (i64.load + (i32.add + (get_local $0) + (i32.const 152) + ) + ) + (i64.const -4812882490098188288) + (get_local $1) + (tee_local $8 + (i64.load + (get_local $6) + ) + ) + (i32.add + (get_local $13) + (i32.const 16) + ) + (i32.const 80) + ) + ) + ) + (block $label$20 + (br_if $label$20 + (i64.lt_u + (get_local $8) + (i64.load + (tee_local $9 + (i32.add + (get_local $0) + (i32.const 160) + ) + ) + ) + ) + ) + (i64.store + (get_local $9) + (select + (i64.const -2) + (i64.add + (get_local $8) + (i64.const 1) + ) + (i64.gt_u + (get_local $8) + (i64.const -3) + ) + ) + ) + ) + (i32.store offset=96 + (get_local $13) + (get_local $6) + ) + (i64.store offset=16 + (get_local $13) + (tee_local $8 + (i64.load + (get_local $6) + ) + ) + ) + (i32.store offset=12 + (get_local $13) + (get_local $10) + ) + (block $label$21 + (block $label$22 + (br_if $label$22 + (i32.ge_u + (tee_local $9 + (i32.load + (tee_local $5 + (i32.add + (get_local $0) + (i32.const 172) + ) + ) + ) + ) + (i32.load + (i32.add + (get_local $0) + (i32.const 176) + ) + ) + ) + ) + (i64.store offset=8 + (get_local $9) + (get_local $8) + ) + (i32.store offset=16 + (get_local $9) + (get_local $10) + ) + (i32.store offset=96 + (get_local $13) + (i32.const 0) + ) + (i32.store + (get_local $9) + (get_local $6) + ) + (i32.store + (get_local $5) + (i32.add + (get_local $9) + (i32.const 24) + ) + ) + (br $label$21) + ) + (call $_ZNSt3__16vectorIN5eosio11multi_indexILy13633861583611363328EN6eoswin10round_itemEJEE8item_ptrENS_9allocatorIS6_EEE24__emplace_back_slow_pathIJNS_10unique_ptrINS5_4itemENS_14default_deleteISC_EEEERyRlEEEvDpOT_ + (i32.add + (get_local $0) + (i32.const 168) + ) + (i32.add + (get_local $13) + (i32.const 96) + ) + (i32.add + (get_local $13) + (i32.const 16) + ) + (i32.add + (get_local $13) + (i32.const 12) + ) + ) + ) + (set_local $9 + (i32.load offset=96 + (get_local $13) + ) + ) + (i32.store offset=96 + (get_local $13) + (i32.const 0) + ) + (block $label$23 + (br_if $label$23 + (i32.eqz + (get_local $9) + ) + ) + (call $_ZdlPv + (get_local $9) + ) + ) + (i64.store + (i32.add + (get_local $0) + (i32.const 64) + ) + (get_local $2) + ) + (i32.store offset=4 + (i32.const 0) + (i32.add + (get_local $13) + (i32.const 112) + ) + ) + ) + (func $_ZNK5eosio11multi_indexILy13633861583611363328EN6eoswin10round_itemEJEE31load_object_by_primary_iteratorEl (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i64) + (local $8 i32) + (local $9 i32) + (set_local $8 + (tee_local $9 + (i32.sub + (i32.load offset=4 + (i32.const 0) + ) + (i32.const 48) + ) + ) + ) + (i32.store offset=4 + (i32.const 0) + (get_local $9) + ) + (block $label$0 + (br_if $label$0 + (i32.eq + (tee_local $6 + (i32.load + (i32.add + (get_local $0) + (i32.const 28) + ) + ) + ) + (tee_local $2 + (i32.load offset=24 + (get_local $0) + ) + ) + ) + ) + (set_local $3 + (i32.sub + (i32.const 0) + (get_local $2) + ) + ) + (set_local $5 + (i32.add + (get_local $6) + (i32.const -24) + ) + ) + (loop $label$1 + (br_if $label$0 + (i32.eq + (i32.load + (i32.add + (get_local $5) + (i32.const 16) + ) + ) + (get_local $1) + ) + ) + (set_local $6 + (get_local $5) + ) + (set_local $5 + (tee_local $4 + (i32.add + (get_local $5) + (i32.const -24) + ) + ) + ) + (br_if $label$1 + (i32.ne + (i32.add + (get_local $4) + (get_local $3) + ) + (i32.const -24) + ) + ) + ) + ) + (block $label$2 + (block $label$3 + (br_if $label$3 + (i32.eq + (get_local $6) + (get_local $2) + ) + ) + (set_local $4 + (i32.load + (i32.add + (get_local $6) + (i32.const -24) + ) + ) + ) + (br $label$2) + ) + (call $eosio_assert + (i32.xor + (i32.shr_u + (tee_local $5 + (call $db_get_i64 + (get_local $1) + (i32.const 0) + (i32.const 0) + ) + ) + (i32.const 31) + ) + (i32.const 1) + ) + (i32.const 240) + ) + (block $label$4 + (block $label$5 + (br_if $label$5 + (i32.lt_u + (get_local $5) + (i32.const 513) + ) + ) + (set_local $4 + (call $malloc + (get_local $5) + ) + ) + (br $label$4) + ) + (i32.store offset=4 + (i32.const 0) + (tee_local $4 + (i32.sub + (get_local $9) + (i32.and + (i32.add + (get_local $5) + (i32.const 15) + ) + (i32.const -16) + ) + ) + ) + ) + ) + (drop + (call $db_get_i64 + (get_local $1) + (get_local $4) + (get_local $5) + ) + ) + (i32.store offset=36 + (get_local $8) + (get_local $4) + ) + (i32.store offset=32 + (get_local $8) + (get_local $4) + ) + (i32.store offset=40 + (get_local $8) + (i32.add + (get_local $4) + (get_local $5) + ) + ) + (block $label$6 + (br_if $label$6 + (i32.lt_u + (get_local $5) + (i32.const 513) + ) + ) + (call $free + (get_local $4) + ) + ) + (set_local $3 + (i32.add + (get_local $0) + (i32.const 24) + ) + ) + (i64.store offset=32 + (tee_local $4 + (call $_Znwj + (i32.const 96) + ) + ) + (i64.const 1397703940) + ) + (i64.store offset=24 + (get_local $4) + (i64.const 0) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 176) + ) + (set_local $7 + (i64.const 5459781) + ) + (set_local $5 + (i32.const 0) + ) + (block $label$7 + (block $label$8 + (loop $label$9 + (br_if $label$8 + (i32.gt_u + (i32.add + (i32.shl + (i32.wrap/i64 + (get_local $7) + ) + (i32.const 24) + ) + (i32.const -1073741825) + ) + (i32.const 452984830) + ) + ) + (block $label$10 + (br_if $label$10 + (i64.ne + (i64.and + (tee_local $7 + (i64.shr_u + (get_local $7) + (i64.const 8) + ) + ) + (i64.const 255) + ) + (i64.const 0) + ) + ) + (loop $label$11 + (br_if $label$8 + (i64.ne + (i64.and + (tee_local $7 + (i64.shr_u + (get_local $7) + (i64.const 8) + ) + ) + (i64.const 255) + ) + (i64.const 0) + ) + ) + (br_if $label$11 + (i32.lt_s + (tee_local $5 + (i32.add + (get_local $5) + (i32.const 1) + ) + ) + (i32.const 7) + ) + ) + ) + ) + (set_local $6 + (i32.const 1) + ) + (br_if $label$9 + (i32.lt_s + (tee_local $5 + (i32.add + (get_local $5) + (i32.const 1) + ) + ) + (i32.const 7) + ) + ) + (br $label$7) + ) + ) + (set_local $6 + (i32.const 0) + ) + ) + (call $eosio_assert + (get_local $6) + (i32.const 128) + ) + (i32.store offset=80 + (get_local $4) + (get_local $0) + ) + (drop + (call $_ZN6eoswinrsIN5eosio10datastreamIPKcEEEERT_S7_RNS_10round_itemE + (i32.add + (get_local $8) + (i32.const 32) + ) + (get_local $4) + ) + ) + (i32.store offset=84 + (get_local $4) + (get_local $1) + ) + (i32.store offset=24 + (get_local $8) + (get_local $4) + ) + (i64.store offset=16 + (get_local $8) + (tee_local $7 + (i64.load + (get_local $4) + ) + ) + ) + (i32.store offset=12 + (get_local $8) + (tee_local $6 + (i32.load offset=84 + (get_local $4) + ) + ) + ) + (block $label$12 + (block $label$13 + (br_if $label$13 + (i32.ge_u + (tee_local $5 + (i32.load + (tee_local $1 + (i32.add + (get_local $0) + (i32.const 28) + ) + ) + ) + ) + (i32.load + (i32.add + (get_local $0) + (i32.const 32) + ) + ) + ) + ) + (i64.store offset=8 + (get_local $5) + (get_local $7) + ) + (i32.store offset=16 + (get_local $5) + (get_local $6) + ) + (i32.store offset=24 + (get_local $8) + (i32.const 0) + ) + (i32.store + (get_local $5) + (get_local $4) + ) + (i32.store + (get_local $1) + (i32.add + (get_local $5) + (i32.const 24) + ) + ) + (br $label$12) + ) + (call $_ZNSt3__16vectorIN5eosio11multi_indexILy13633861583611363328EN6eoswin10round_itemEJEE8item_ptrENS_9allocatorIS6_EEE24__emplace_back_slow_pathIJNS_10unique_ptrINS5_4itemENS_14default_deleteISC_EEEERyRlEEEvDpOT_ + (get_local $3) + (i32.add + (get_local $8) + (i32.const 24) + ) + (i32.add + (get_local $8) + (i32.const 16) + ) + (i32.add + (get_local $8) + (i32.const 12) + ) + ) + ) + (set_local $5 + (i32.load offset=24 + (get_local $8) + ) + ) + (i32.store offset=24 + (get_local $8) + (i32.const 0) + ) + (br_if $label$2 + (i32.eqz + (get_local $5) + ) + ) + (call $_ZdlPv + (get_local $5) + ) + ) + (i32.store offset=4 + (i32.const 0) + (i32.add + (get_local $8) + (i32.const 48) + ) + ) + (get_local $4) + ) + (func $_ZNK5eosio11multi_indexILy13633861365809545216EN6eoswin13roundfee_itemEJEE31load_object_by_primary_iteratorEl (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 i64) + (local $6 i32) + (local $7 i32) + (local $8 i32) + (local $9 i32) + (set_local $8 + (tee_local $9 + (i32.sub + (i32.load offset=4 + (i32.const 0) + ) + (i32.const 48) + ) + ) + ) + (i32.store offset=4 + (i32.const 0) + (get_local $9) + ) + (block $label$0 + (br_if $label$0 + (i32.eq + (tee_local $7 + (i32.load + (i32.add + (get_local $0) + (i32.const 28) + ) + ) + ) + (tee_local $2 + (i32.load offset=24 + (get_local $0) + ) + ) + ) + ) + (set_local $3 + (i32.sub + (i32.const 0) + (get_local $2) + ) + ) + (set_local $6 + (i32.add + (get_local $7) + (i32.const -24) + ) + ) + (loop $label$1 + (br_if $label$0 + (i32.eq + (i32.load + (i32.add + (get_local $6) + (i32.const 16) + ) + ) + (get_local $1) + ) + ) + (set_local $7 + (get_local $6) + ) + (set_local $6 + (tee_local $4 + (i32.add + (get_local $6) + (i32.const -24) + ) + ) + ) + (br_if $label$1 + (i32.ne + (i32.add + (get_local $4) + (get_local $3) + ) + (i32.const -24) + ) + ) + ) + ) + (block $label$2 + (block $label$3 + (br_if $label$3 + (i32.eq + (get_local $7) + (get_local $2) + ) + ) + (set_local $6 + (i32.load + (i32.add + (get_local $7) + (i32.const -24) + ) + ) + ) + (br $label$2) + ) + (call $eosio_assert + (i32.xor + (i32.shr_u + (tee_local $6 + (call $db_get_i64 + (get_local $1) + (i32.const 0) + (i32.const 0) + ) + ) + (i32.const 31) + ) + (i32.const 1) + ) + (i32.const 240) + ) + (block $label$4 + (block $label$5 + (br_if $label$5 + (i32.lt_u + (get_local $6) + (i32.const 513) + ) + ) + (set_local $4 + (call $malloc + (get_local $6) + ) + ) + (br $label$4) + ) + (i32.store offset=4 + (i32.const 0) + (tee_local $4 + (i32.sub + (get_local $9) + (i32.and + (i32.add + (get_local $6) + (i32.const 15) + ) + (i32.const -16) + ) + ) + ) + ) + ) + (drop + (call $db_get_i64 + (get_local $1) + (get_local $4) + (get_local $6) + ) + ) + (i32.store offset=36 + (get_local $8) + (get_local $4) + ) + (i32.store offset=32 + (get_local $8) + (get_local $4) + ) + (i32.store offset=40 + (get_local $8) + (i32.add + (get_local $4) + (get_local $6) + ) + ) + (block $label$6 + (br_if $label$6 + (i32.lt_u + (get_local $6) + (i32.const 513) + ) + ) + (call $free + (get_local $4) + ) + ) + (set_local $4 + (call $_ZN6eoswin13roundfee_itemC2Ev + (tee_local $6 + (call $_Znwj + (i32.const 88) + ) + ) + ) + ) + (i32.store offset=72 + (get_local $6) + (get_local $0) + ) + (drop + (call $_ZN6eoswinrsIN5eosio10datastreamIPKcEEEERT_S7_RNS_13roundfee_itemE + (i32.add + (get_local $8) + (i32.const 32) + ) + (get_local $4) + ) + ) + (i32.store offset=76 + (get_local $6) + (get_local $1) + ) + (i32.store offset=24 + (get_local $8) + (get_local $6) + ) + (i64.store offset=16 + (get_local $8) + (tee_local $5 + (i64.load + (get_local $6) + ) + ) + ) + (i32.store offset=12 + (get_local $8) + (tee_local $7 + (i32.load offset=76 + (get_local $6) + ) + ) + ) + (block $label$7 + (block $label$8 + (br_if $label$8 + (i32.ge_u + (tee_local $4 + (i32.load + (tee_local $1 + (i32.add + (get_local $0) + (i32.const 28) + ) + ) + ) + ) + (i32.load + (i32.add + (get_local $0) + (i32.const 32) + ) + ) + ) + ) + (i64.store offset=8 + (get_local $4) + (get_local $5) + ) + (i32.store offset=16 + (get_local $4) + (get_local $7) + ) + (i32.store offset=24 + (get_local $8) + (i32.const 0) + ) + (i32.store + (get_local $4) + (get_local $6) + ) + (i32.store + (get_local $1) + (i32.add + (get_local $4) + (i32.const 24) + ) + ) + (br $label$7) + ) + (call $_ZNSt3__16vectorIN5eosio11multi_indexILy13633861365809545216EN6eoswin13roundfee_itemEJEE8item_ptrENS_9allocatorIS6_EEE24__emplace_back_slow_pathIJNS_10unique_ptrINS5_4itemENS_14default_deleteISC_EEEERyRlEEEvDpOT_ + (i32.add + (get_local $0) + (i32.const 24) + ) + (i32.add + (get_local $8) + (i32.const 24) + ) + (i32.add + (get_local $8) + (i32.const 16) + ) + (i32.add + (get_local $8) + (i32.const 12) + ) + ) + ) + (set_local $4 + (i32.load offset=24 + (get_local $8) + ) + ) + (i32.store offset=24 + (get_local $8) + (i32.const 0) + ) + (br_if $label$2 + (i32.eqz + (get_local $4) + ) + ) + (call $_ZdlPv + (get_local $4) + ) + ) + (i32.store offset=4 + (i32.const 0) + (i32.add + (get_local $8) + (i32.const 48) + ) + ) + (get_local $6) + ) + (func $_ZN6eoswinlsIN5eosio10datastreamIPcEEEERT_S6_RKNS_10round_itemE (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + (call $eosio_assert + (i32.gt_s + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (i32.load offset=4 + (get_local $0) + ) + ) + (i32.const 7) + ) + (i32.const 400) + ) + (drop + (call $memcpy + (i32.load offset=4 + (get_local $0) + ) + (get_local $1) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $0) + (tee_local $2 + (i32.add + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + ) + (call $eosio_assert + (i32.gt_s + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (get_local $2) + ) + (i32.const 7) + ) + (i32.const 400) + ) + (drop + (call $memcpy + (i32.load offset=4 + (get_local $0) + ) + (i32.add + (get_local $1) + (i32.const 8) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $0) + (tee_local $2 + (i32.add + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + ) + (call $eosio_assert + (i32.gt_s + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (get_local $2) + ) + (i32.const 7) + ) + (i32.const 400) + ) + (drop + (call $memcpy + (i32.load offset=4 + (get_local $0) + ) + (i32.add + (get_local $1) + (i32.const 16) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $0) + (tee_local $2 + (i32.add + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + ) + (call $eosio_assert + (i32.gt_s + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (get_local $2) + ) + (i32.const 7) + ) + (i32.const 400) + ) + (drop + (call $memcpy + (i32.load offset=4 + (get_local $0) + ) + (i32.add + (get_local $1) + (i32.const 24) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $0) + (tee_local $2 + (i32.add + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + ) + (call $eosio_assert + (i32.gt_s + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (get_local $2) + ) + (i32.const 7) + ) + (i32.const 400) + ) + (drop + (call $memcpy + (i32.load offset=4 + (get_local $0) + ) + (i32.add + (get_local $1) + (i32.const 32) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $0) + (tee_local $2 + (i32.add + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + ) + (call $eosio_assert + (i32.gt_s + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (get_local $2) + ) + (i32.const 7) + ) + (i32.const 400) + ) + (drop + (call $memcpy + (i32.load offset=4 + (get_local $0) + ) + (i32.add + (get_local $1) + (i32.const 40) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $0) + (tee_local $2 + (i32.add + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + ) + (call $eosio_assert + (i32.gt_s + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (get_local $2) + ) + (i32.const 7) + ) + (i32.const 400) + ) + (drop + (call $memcpy + (i32.load offset=4 + (get_local $0) + ) + (i32.add + (get_local $1) + (i32.const 48) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $0) + (tee_local $2 + (i32.add + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + ) + (call $eosio_assert + (i32.gt_s + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (get_local $2) + ) + (i32.const 7) + ) + (i32.const 400) + ) + (drop + (call $memcpy + (i32.load offset=4 + (get_local $0) + ) + (i32.add + (get_local $1) + (i32.const 56) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $0) + (tee_local $2 + (i32.add + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + ) + (call $eosio_assert + (i32.gt_s + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (get_local $2) + ) + (i32.const 7) + ) + (i32.const 400) + ) + (drop + (call $memcpy + (i32.load offset=4 + (get_local $0) + ) + (i32.add + (get_local $1) + (i32.const 64) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $0) + (tee_local $2 + (i32.add + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + ) + (call $eosio_assert + (i32.gt_s + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (get_local $2) + ) + (i32.const 7) + ) + (i32.const 400) + ) + (drop + (call $memcpy + (i32.load offset=4 + (get_local $0) + ) + (i32.add + (get_local $1) + (i32.const 72) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $0) + (i32.add + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + (get_local $0) + ) + (func $_ZNSt3__16vectorIN5eosio11multi_indexILy13633861583611363328EN6eoswin10round_itemEJEE8item_ptrENS_9allocatorIS6_EEE24__emplace_back_slow_pathIJNS_10unique_ptrINS5_4itemENS_14default_deleteISC_EEEERyRlEEEvDpOT_ (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (block $label$0 + (block $label$1 + (br_if $label$1 + (i32.ge_u + (tee_local $5 + (i32.add + (tee_local $4 + (i32.div_s + (i32.sub + (i32.load offset=4 + (get_local $0) + ) + (tee_local $6 + (i32.load + (get_local $0) + ) + ) + ) + (i32.const 24) + ) + ) + (i32.const 1) + ) + ) + (i32.const 178956971) + ) + ) + (set_local $7 + (i32.const 178956970) + ) + (block $label$2 + (block $label$3 + (br_if $label$3 + (i32.gt_u + (tee_local $6 + (i32.div_s + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (get_local $6) + ) + (i32.const 24) + ) + ) + (i32.const 89478484) + ) + ) + (br_if $label$2 + (i32.eqz + (tee_local $7 + (select + (get_local $5) + (tee_local $7 + (i32.shl + (get_local $6) + (i32.const 1) + ) + ) + (i32.lt_u + (get_local $7) + (get_local $5) + ) + ) + ) + ) + ) + ) + (set_local $6 + (call $_Znwj + (i32.mul + (get_local $7) + (i32.const 24) + ) + ) + ) + (br $label$0) + ) + (set_local $7 + (i32.const 0) + ) + (set_local $6 + (i32.const 0) + ) + (br $label$0) + ) + (call $_ZNKSt3__120__vector_base_commonILb1EE20__throw_length_errorEv + (get_local $0) + ) + (unreachable) + ) + (set_local $5 + (i32.load + (get_local $1) + ) + ) + (i32.store + (get_local $1) + (i32.const 0) + ) + (i32.store + (tee_local $1 + (i32.add + (get_local $6) + (i32.mul + (get_local $4) + (i32.const 24) + ) + ) + ) + (get_local $5) + ) + (i64.store offset=8 + (get_local $1) + (i64.load + (get_local $2) + ) + ) + (i32.store offset=16 + (get_local $1) + (i32.load + (get_local $3) + ) + ) + (set_local $4 + (i32.add + (get_local $6) + (i32.mul + (get_local $7) + (i32.const 24) + ) + ) + ) + (set_local $5 + (i32.add + (get_local $1) + (i32.const 24) + ) + ) + (block $label$4 + (block $label$5 + (br_if $label$5 + (i32.eq + (tee_local $6 + (i32.load + (i32.add + (get_local $0) + (i32.const 4) + ) + ) + ) + (tee_local $7 + (i32.load + (get_local $0) + ) + ) + ) + ) + (loop $label$6 + (set_local $3 + (i32.load + (tee_local $2 + (i32.add + (get_local $6) + (i32.const -24) + ) + ) + ) + ) + (i32.store + (get_local $2) + (i32.const 0) + ) + (i32.store + (i32.add + (get_local $1) + (i32.const -24) + ) + (get_local $3) + ) + (i32.store + (i32.add + (get_local $1) + (i32.const -8) + ) + (i32.load + (i32.add + (get_local $6) + (i32.const -8) + ) + ) + ) + (i32.store + (i32.add + (get_local $1) + (i32.const -12) + ) + (i32.load + (i32.add + (get_local $6) + (i32.const -12) + ) + ) + ) + (i32.store + (i32.add + (get_local $1) + (i32.const -16) + ) + (i32.load + (i32.add + (get_local $6) + (i32.const -16) + ) + ) + ) + (set_local $1 + (i32.add + (get_local $1) + (i32.const -24) + ) + ) + (set_local $6 + (get_local $2) + ) + (br_if $label$6 + (i32.ne + (get_local $7) + (get_local $2) + ) + ) + ) + (set_local $7 + (i32.load + (i32.add + (get_local $0) + (i32.const 4) + ) + ) + ) + (set_local $6 + (i32.load + (get_local $0) + ) + ) + (br $label$4) + ) + (set_local $6 + (get_local $7) + ) + ) + (i32.store + (get_local $0) + (get_local $1) + ) + (i32.store + (i32.add + (get_local $0) + (i32.const 4) + ) + (get_local $5) + ) + (i32.store + (i32.add + (get_local $0) + (i32.const 8) + ) + (get_local $4) + ) + (block $label$7 + (br_if $label$7 + (i32.eq + (get_local $7) + (get_local $6) + ) + ) + (loop $label$8 + (set_local $1 + (i32.load + (tee_local $7 + (i32.add + (get_local $7) + (i32.const -24) + ) + ) + ) + ) + (i32.store + (get_local $7) + (i32.const 0) + ) + (block $label$9 + (br_if $label$9 + (i32.eqz + (get_local $1) + ) + ) + (call $_ZdlPv + (get_local $1) + ) + ) + (br_if $label$8 + (i32.ne + (get_local $6) + (get_local $7) + ) + ) + ) + ) + (block $label$10 + (br_if $label$10 + (i32.eqz + (get_local $6) + ) + ) + (call $_ZdlPv + (get_local $6) + ) + ) + ) + (func $_ZN6eoswin13roundfee_itemC2Ev (param $0 i32) (result i32) + (local $1 i64) + (local $2 i32) + (local $3 i32) + (i64.store offset=8 + (get_local $0) + (i64.const 0) + ) + (i64.store + (tee_local $2 + (i32.add + (get_local $0) + (i32.const 16) + ) + ) + (i64.const 1397703940) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 176) + ) + (set_local $1 + (i64.shr_u + (i64.load + (get_local $2) + ) + (i64.const 8) + ) + ) + (set_local $2 + (i32.const 0) + ) + (block $label$0 + (block $label$1 + (loop $label$2 + (br_if $label$1 + (i32.gt_u + (i32.add + (i32.shl + (i32.wrap/i64 + (get_local $1) + ) + (i32.const 24) + ) + (i32.const -1073741825) + ) + (i32.const 452984830) + ) + ) + (block $label$3 + (br_if $label$3 + (i64.ne + (i64.and + (tee_local $1 + (i64.shr_u + (get_local $1) + (i64.const 8) + ) + ) + (i64.const 255) + ) + (i64.const 0) + ) + ) + (loop $label$4 + (br_if $label$1 + (i64.ne + (i64.and + (tee_local $1 + (i64.shr_u + (get_local $1) + (i64.const 8) + ) + ) + (i64.const 255) + ) + (i64.const 0) + ) + ) + (br_if $label$4 + (i32.lt_s + (tee_local $2 + (i32.add + (get_local $2) + (i32.const 1) + ) + ) + (i32.const 7) + ) + ) + ) + ) + (set_local $3 + (i32.const 1) + ) + (br_if $label$2 + (i32.lt_s + (tee_local $2 + (i32.add + (get_local $2) + (i32.const 1) + ) + ) + (i32.const 7) + ) + ) + (br $label$0) + ) + ) + (set_local $3 + (i32.const 0) + ) + ) + (call $eosio_assert + (get_local $3) + (i32.const 128) + ) + (i64.store + (tee_local $2 + (i32.add + (get_local $0) + (i32.const 32) + ) + ) + (i64.const 1397703940) + ) + (i64.store offset=24 + (get_local $0) + (i64.const 0) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 176) + ) + (set_local $1 + (i64.shr_u + (i64.load + (get_local $2) + ) + (i64.const 8) + ) + ) + (set_local $2 + (i32.const 0) + ) + (block $label$5 + (block $label$6 + (loop $label$7 + (br_if $label$6 + (i32.gt_u + (i32.add + (i32.shl + (i32.wrap/i64 + (get_local $1) + ) + (i32.const 24) + ) + (i32.const -1073741825) + ) + (i32.const 452984830) + ) + ) + (block $label$8 + (br_if $label$8 + (i64.ne + (i64.and + (tee_local $1 + (i64.shr_u + (get_local $1) + (i64.const 8) + ) + ) + (i64.const 255) + ) + (i64.const 0) + ) + ) + (loop $label$9 + (br_if $label$6 + (i64.ne + (i64.and + (tee_local $1 + (i64.shr_u + (get_local $1) + (i64.const 8) + ) + ) + (i64.const 255) + ) + (i64.const 0) + ) + ) + (br_if $label$9 + (i32.lt_s + (tee_local $2 + (i32.add + (get_local $2) + (i32.const 1) + ) + ) + (i32.const 7) + ) + ) + ) + ) + (set_local $3 + (i32.const 1) + ) + (br_if $label$7 + (i32.lt_s + (tee_local $2 + (i32.add + (get_local $2) + (i32.const 1) + ) + ) + (i32.const 7) + ) + ) + (br $label$5) + ) + ) + (set_local $3 + (i32.const 0) + ) + ) + (call $eosio_assert + (get_local $3) + (i32.const 128) + ) + (i64.store + (tee_local $2 + (i32.add + (get_local $0) + (i32.const 48) + ) + ) + (i64.const 1397703940) + ) + (i64.store offset=40 + (get_local $0) + (i64.const 0) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 176) + ) + (set_local $1 + (i64.shr_u + (i64.load + (get_local $2) + ) + (i64.const 8) + ) + ) + (set_local $2 + (i32.const 0) + ) + (block $label$10 + (block $label$11 + (loop $label$12 + (br_if $label$11 + (i32.gt_u + (i32.add + (i32.shl + (i32.wrap/i64 + (get_local $1) + ) + (i32.const 24) + ) + (i32.const -1073741825) + ) + (i32.const 452984830) + ) + ) + (block $label$13 + (br_if $label$13 + (i64.ne + (i64.and + (tee_local $1 + (i64.shr_u + (get_local $1) + (i64.const 8) + ) + ) + (i64.const 255) + ) + (i64.const 0) + ) + ) + (loop $label$14 + (br_if $label$11 + (i64.ne + (i64.and + (tee_local $1 + (i64.shr_u + (get_local $1) + (i64.const 8) + ) + ) + (i64.const 255) + ) + (i64.const 0) + ) + ) + (br_if $label$14 + (i32.lt_s + (tee_local $2 + (i32.add + (get_local $2) + (i32.const 1) + ) + ) + (i32.const 7) + ) + ) + ) + ) + (set_local $3 + (i32.const 1) + ) + (br_if $label$12 + (i32.lt_s + (tee_local $2 + (i32.add + (get_local $2) + (i32.const 1) + ) + ) + (i32.const 7) + ) + ) + (br $label$10) + ) + ) + (set_local $3 + (i32.const 0) + ) + ) + (call $eosio_assert + (get_local $3) + (i32.const 128) + ) + (i64.store + (tee_local $2 + (i32.add + (get_local $0) + (i32.const 64) + ) + ) + (i64.const 1397703940) + ) + (i64.store offset=56 + (get_local $0) + (i64.const 0) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 176) + ) + (set_local $1 + (i64.shr_u + (i64.load + (get_local $2) + ) + (i64.const 8) + ) + ) + (set_local $2 + (i32.const 0) + ) + (block $label$15 + (block $label$16 + (loop $label$17 + (br_if $label$16 + (i32.gt_u + (i32.add + (i32.shl + (i32.wrap/i64 + (get_local $1) + ) + (i32.const 24) + ) + (i32.const -1073741825) + ) + (i32.const 452984830) + ) + ) + (block $label$18 + (br_if $label$18 + (i64.ne + (i64.and + (tee_local $1 + (i64.shr_u + (get_local $1) + (i64.const 8) + ) + ) + (i64.const 255) + ) + (i64.const 0) + ) + ) + (loop $label$19 + (br_if $label$16 + (i64.ne + (i64.and + (tee_local $1 + (i64.shr_u + (get_local $1) + (i64.const 8) + ) + ) + (i64.const 255) + ) + (i64.const 0) + ) + ) + (br_if $label$19 + (i32.lt_s + (tee_local $2 + (i32.add + (get_local $2) + (i32.const 1) + ) + ) + (i32.const 7) + ) + ) + ) + ) + (set_local $3 + (i32.const 1) + ) + (br_if $label$17 + (i32.lt_s + (tee_local $2 + (i32.add + (get_local $2) + (i32.const 1) + ) + ) + (i32.const 7) + ) + ) + (br $label$15) + ) + ) + (set_local $3 + (i32.const 0) + ) + ) + (call $eosio_assert + (get_local $3) + (i32.const 128) + ) + (get_local $0) + ) + (func $_ZN6eoswinrsIN5eosio10datastreamIPKcEEEERT_S7_RNS_13roundfee_itemE (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + (call $eosio_assert + (i32.gt_u + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (i32.load offset=4 + (get_local $0) + ) + ) + (i32.const 7) + ) + (i32.const 272) + ) + (drop + (call $memcpy + (get_local $1) + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $0) + (tee_local $2 + (i32.add + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + ) + (call $eosio_assert + (i32.gt_u + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (get_local $2) + ) + (i32.const 7) + ) + (i32.const 272) + ) + (drop + (call $memcpy + (i32.add + (get_local $1) + (i32.const 8) + ) + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $0) + (tee_local $2 + (i32.add + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + ) + (call $eosio_assert + (i32.gt_u + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (get_local $2) + ) + (i32.const 7) + ) + (i32.const 272) + ) + (drop + (call $memcpy + (i32.add + (get_local $1) + (i32.const 16) + ) + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $0) + (tee_local $2 + (i32.add + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + ) + (call $eosio_assert + (i32.gt_u + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (get_local $2) + ) + (i32.const 7) + ) + (i32.const 272) + ) + (drop + (call $memcpy + (i32.add + (get_local $1) + (i32.const 24) + ) + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $0) + (tee_local $2 + (i32.add + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + ) + (call $eosio_assert + (i32.gt_u + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (get_local $2) + ) + (i32.const 7) + ) + (i32.const 272) + ) + (drop + (call $memcpy + (i32.add + (get_local $1) + (i32.const 32) + ) + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $0) + (tee_local $2 + (i32.add + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + ) + (call $eosio_assert + (i32.gt_u + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (get_local $2) + ) + (i32.const 7) + ) + (i32.const 272) + ) + (drop + (call $memcpy + (i32.add + (get_local $1) + (i32.const 40) + ) + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $0) + (tee_local $2 + (i32.add + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + ) + (call $eosio_assert + (i32.gt_u + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (get_local $2) + ) + (i32.const 7) + ) + (i32.const 272) + ) + (drop + (call $memcpy + (i32.add + (get_local $1) + (i32.const 48) + ) + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $0) + (tee_local $2 + (i32.add + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + ) + (call $eosio_assert + (i32.gt_u + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (get_local $2) + ) + (i32.const 7) + ) + (i32.const 272) + ) + (drop + (call $memcpy + (i32.add + (get_local $1) + (i32.const 56) + ) + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $0) + (tee_local $2 + (i32.add + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + ) + (call $eosio_assert + (i32.gt_u + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (get_local $2) + ) + (i32.const 7) + ) + (i32.const 272) + ) + (drop + (call $memcpy + (i32.add + (get_local $1) + (i32.const 64) + ) + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $0) + (i32.add + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + (get_local $0) + ) + (func $_ZNSt3__16vectorIN5eosio11multi_indexILy13633861365809545216EN6eoswin13roundfee_itemEJEE8item_ptrENS_9allocatorIS6_EEE24__emplace_back_slow_pathIJNS_10unique_ptrINS5_4itemENS_14default_deleteISC_EEEERyRlEEEvDpOT_ (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (block $label$0 + (block $label$1 + (br_if $label$1 + (i32.ge_u + (tee_local $5 + (i32.add + (tee_local $4 + (i32.div_s + (i32.sub + (i32.load offset=4 + (get_local $0) + ) + (tee_local $6 + (i32.load + (get_local $0) + ) + ) + ) + (i32.const 24) + ) + ) + (i32.const 1) + ) + ) + (i32.const 178956971) + ) + ) + (set_local $7 + (i32.const 178956970) + ) + (block $label$2 + (block $label$3 + (br_if $label$3 + (i32.gt_u + (tee_local $6 + (i32.div_s + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (get_local $6) + ) + (i32.const 24) + ) + ) + (i32.const 89478484) + ) + ) + (br_if $label$2 + (i32.eqz + (tee_local $7 + (select + (get_local $5) + (tee_local $7 + (i32.shl + (get_local $6) + (i32.const 1) + ) + ) + (i32.lt_u + (get_local $7) + (get_local $5) + ) + ) + ) + ) + ) + ) + (set_local $6 + (call $_Znwj + (i32.mul + (get_local $7) + (i32.const 24) + ) + ) + ) + (br $label$0) + ) + (set_local $7 + (i32.const 0) + ) + (set_local $6 + (i32.const 0) + ) + (br $label$0) + ) + (call $_ZNKSt3__120__vector_base_commonILb1EE20__throw_length_errorEv + (get_local $0) + ) + (unreachable) + ) + (set_local $5 + (i32.load + (get_local $1) + ) + ) + (i32.store + (get_local $1) + (i32.const 0) + ) + (i32.store + (tee_local $1 + (i32.add + (get_local $6) + (i32.mul + (get_local $4) + (i32.const 24) + ) + ) + ) + (get_local $5) + ) + (i64.store offset=8 + (get_local $1) + (i64.load + (get_local $2) + ) + ) + (i32.store offset=16 + (get_local $1) + (i32.load + (get_local $3) + ) + ) + (set_local $4 + (i32.add + (get_local $6) + (i32.mul + (get_local $7) + (i32.const 24) + ) + ) + ) + (set_local $5 + (i32.add + (get_local $1) + (i32.const 24) + ) + ) + (block $label$4 + (block $label$5 + (br_if $label$5 + (i32.eq + (tee_local $6 + (i32.load + (i32.add + (get_local $0) + (i32.const 4) + ) + ) + ) + (tee_local $7 + (i32.load + (get_local $0) + ) + ) + ) + ) + (loop $label$6 + (set_local $3 + (i32.load + (tee_local $2 + (i32.add + (get_local $6) + (i32.const -24) + ) + ) + ) + ) + (i32.store + (get_local $2) + (i32.const 0) + ) + (i32.store + (i32.add + (get_local $1) + (i32.const -24) + ) + (get_local $3) + ) + (i32.store + (i32.add + (get_local $1) + (i32.const -8) + ) + (i32.load + (i32.add + (get_local $6) + (i32.const -8) + ) + ) + ) + (i32.store + (i32.add + (get_local $1) + (i32.const -12) + ) + (i32.load + (i32.add + (get_local $6) + (i32.const -12) + ) + ) + ) + (i32.store + (i32.add + (get_local $1) + (i32.const -16) + ) + (i32.load + (i32.add + (get_local $6) + (i32.const -16) + ) + ) + ) + (set_local $1 + (i32.add + (get_local $1) + (i32.const -24) + ) + ) + (set_local $6 + (get_local $2) + ) + (br_if $label$6 + (i32.ne + (get_local $7) + (get_local $2) + ) + ) + ) + (set_local $7 + (i32.load + (i32.add + (get_local $0) + (i32.const 4) + ) + ) + ) + (set_local $6 + (i32.load + (get_local $0) + ) + ) + (br $label$4) + ) + (set_local $6 + (get_local $7) + ) + ) + (i32.store + (get_local $0) + (get_local $1) + ) + (i32.store + (i32.add + (get_local $0) + (i32.const 4) + ) + (get_local $5) + ) + (i32.store + (i32.add + (get_local $0) + (i32.const 8) + ) + (get_local $4) + ) + (block $label$7 + (br_if $label$7 + (i32.eq + (get_local $7) + (get_local $6) + ) + ) + (loop $label$8 + (set_local $1 + (i32.load + (tee_local $7 + (i32.add + (get_local $7) + (i32.const -24) + ) + ) + ) + ) + (i32.store + (get_local $7) + (i32.const 0) + ) + (block $label$9 + (br_if $label$9 + (i32.eqz + (get_local $1) + ) + ) + (call $_ZdlPv + (get_local $1) + ) + ) + (br_if $label$8 + (i32.ne + (get_local $6) + (get_local $7) + ) + ) + ) + ) + (block $label$10 + (br_if $label$10 + (i32.eqz + (get_local $6) + ) + ) + (call $_ZdlPv + (get_local $6) + ) + ) + ) + (func $_ZN6eoswinrsIN5eosio10datastreamIPKcEEEERT_S7_RNS_10round_itemE (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + (call $eosio_assert + (i32.gt_u + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (i32.load offset=4 + (get_local $0) + ) + ) + (i32.const 7) + ) + (i32.const 272) + ) + (drop + (call $memcpy + (get_local $1) + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $0) + (tee_local $2 + (i32.add + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + ) + (call $eosio_assert + (i32.gt_u + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (get_local $2) + ) + (i32.const 7) + ) + (i32.const 272) + ) + (drop + (call $memcpy + (i32.add + (get_local $1) + (i32.const 8) + ) + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $0) + (tee_local $2 + (i32.add + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + ) + (call $eosio_assert + (i32.gt_u + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (get_local $2) + ) + (i32.const 7) + ) + (i32.const 272) + ) + (drop + (call $memcpy + (i32.add + (get_local $1) + (i32.const 16) + ) + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $0) + (tee_local $2 + (i32.add + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + ) + (call $eosio_assert + (i32.gt_u + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (get_local $2) + ) + (i32.const 7) + ) + (i32.const 272) + ) + (drop + (call $memcpy + (i32.add + (get_local $1) + (i32.const 24) + ) + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $0) + (tee_local $2 + (i32.add + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + ) + (call $eosio_assert + (i32.gt_u + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (get_local $2) + ) + (i32.const 7) + ) + (i32.const 272) + ) + (drop + (call $memcpy + (i32.add + (get_local $1) + (i32.const 32) + ) + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $0) + (tee_local $2 + (i32.add + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + ) + (call $eosio_assert + (i32.gt_u + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (get_local $2) + ) + (i32.const 7) + ) + (i32.const 272) + ) + (drop + (call $memcpy + (i32.add + (get_local $1) + (i32.const 40) + ) + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $0) + (tee_local $2 + (i32.add + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + ) + (call $eosio_assert + (i32.gt_u + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (get_local $2) + ) + (i32.const 7) + ) + (i32.const 272) + ) + (drop + (call $memcpy + (i32.add + (get_local $1) + (i32.const 48) + ) + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $0) + (tee_local $2 + (i32.add + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + ) + (call $eosio_assert + (i32.gt_u + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (get_local $2) + ) + (i32.const 7) + ) + (i32.const 272) + ) + (drop + (call $memcpy + (i32.add + (get_local $1) + (i32.const 56) + ) + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $0) + (tee_local $2 + (i32.add + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + ) + (call $eosio_assert + (i32.gt_u + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (get_local $2) + ) + (i32.const 7) + ) + (i32.const 272) + ) + (drop + (call $memcpy + (i32.add + (get_local $1) + (i32.const 64) + ) + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $0) + (tee_local $2 + (i32.add + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + ) + (call $eosio_assert + (i32.gt_u + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (get_local $2) + ) + (i32.const 7) + ) + (i32.const 272) + ) + (drop + (call $memcpy + (i32.add + (get_local $1) + (i32.const 72) + ) + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $0) + (i32.add + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + (get_local $0) + ) + (func $_ZN6eoswin7lottery10setactivedEb (type $FUNCSIG$vii) (param $0 i32) (param $1 i32) + (call $require_auth + (i64.load + (get_local $0) + ) + ) + (i32.store8 + (i32.add + (get_local $0) + (i32.const 140) + ) + (get_local $1) + ) + ) + (func $_ZN6eoswin7lottery9setstatusEyy (type $FUNCSIG$vijj) (param $0 i32) (param $1 i64) (param $2 i64) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i64) + (local $7 i32) + (local $8 i32) + (local $9 i32) + (i32.store offset=4 + (i32.const 0) + (tee_local $9 + (i32.sub + (i32.load offset=4 + (i32.const 0) + ) + (i32.const 32) + ) + ) + ) + (call $require_auth + (i64.load + (get_local $0) + ) + ) + (block $label$0 + (br_if $label$0 + (i32.eq + (tee_local $8 + (i32.load + (i32.add + (get_local $0) + (i32.const 276) + ) + ) + ) + (tee_local $3 + (i32.load + (i32.add + (get_local $0) + (i32.const 272) + ) + ) + ) + ) + ) + (set_local $7 + (i32.add + (get_local $8) + (i32.const -24) + ) + ) + (set_local $4 + (i32.sub + (i32.const 0) + (get_local $3) + ) + ) + (loop $label$1 + (br_if $label$0 + (i64.eq + (i64.load + (i32.load + (get_local $7) + ) + ) + (get_local $1) + ) + ) + (set_local $8 + (get_local $7) + ) + (set_local $7 + (tee_local $5 + (i32.add + (get_local $7) + (i32.const -24) + ) + ) + ) + (br_if $label$1 + (i32.ne + (i32.add + (get_local $5) + (get_local $4) + ) + (i32.const -24) + ) + ) + ) + ) + (set_local $5 + (i32.add + (get_local $0) + (i32.const 248) + ) + ) + (block $label$2 + (block $label$3 + (block $label$4 + (block $label$5 + (br_if $label$5 + (i32.eq + (get_local $8) + (get_local $3) + ) + ) + (call $eosio_assert + (i32.eq + (i32.load offset=16 + (tee_local $7 + (i32.load + (i32.add + (get_local $8) + (i32.const -24) + ) + ) + ) + ) + (get_local $5) + ) + (i32.const 32) + ) + (br_if $label$4 + (get_local $7) + ) + (br $label$3) + ) + (br_if $label$3 + (i32.lt_s + (tee_local $7 + (call $db_find_i64 + (i64.load + (i32.add + (get_local $0) + (i32.const 248) + ) + ) + (i64.load + (i32.add + (get_local $0) + (i32.const 256) + ) + ) + (i64.const -4157493845350678528) + (get_local $1) + ) + ) + (i32.const 0) + ) + ) + (call $eosio_assert + (i32.eq + (i32.load offset=16 + (tee_local $7 + (call $_ZNK5eosio11multi_indexILy14289250228358873088EN6eoswin6statusEJEE31load_object_by_primary_iteratorEl + (get_local $5) + (get_local $7) + ) + ) + ) + (get_local $5) + ) + (i32.const 32) + ) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 288) + ) + (call $eosio_assert + (i32.eq + (i32.load offset=16 + (get_local $7) + ) + (get_local $5) + ) + (i32.const 416) + ) + (call $eosio_assert + (i64.eq + (i64.load + (i32.add + (get_local $0) + (i32.const 248) + ) + ) + (call $current_receiver) + ) + (i32.const 464) + ) + (i64.store offset=8 + (get_local $7) + (get_local $2) + ) + (set_local $1 + (i64.load + (get_local $7) + ) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 528) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 400) + ) + (drop + (call $memcpy + (i32.add + (get_local $9) + (i32.const 16) + ) + (get_local $7) + (i32.const 8) + ) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 400) + ) + (drop + (call $memcpy + (i32.or + (i32.add + (get_local $9) + (i32.const 16) + ) + (i32.const 8) + ) + (i32.add + (get_local $7) + (i32.const 8) + ) + (i32.const 8) + ) + ) + (call $db_update_i64 + (i32.load offset=20 + (get_local $7) + ) + (i64.const 0) + (i32.add + (get_local $9) + (i32.const 16) + ) + (i32.const 16) + ) + (br_if $label$2 + (i64.lt_u + (get_local $1) + (i64.load + (tee_local $7 + (i32.add + (get_local $0) + (i32.const 264) + ) + ) + ) + ) + ) + (i64.store + (get_local $7) + (select + (i64.const -2) + (i64.add + (get_local $1) + (i64.const 1) + ) + (i64.gt_u + (get_local $1) + (i64.const -3) + ) + ) + ) + (br $label$2) + ) + (set_local $6 + (i64.load + (get_local $0) + ) + ) + (call $eosio_assert + (i64.eq + (i64.load + (i32.add + (get_local $0) + (i32.const 248) + ) + ) + (call $current_receiver) + ) + (i32.const 336) + ) + (i32.store offset=16 + (tee_local $7 + (call $_Znwj + (i32.const 32) + ) + ) + (get_local $5) + ) + (i64.store offset=8 + (get_local $7) + (get_local $2) + ) + (i64.store + (get_local $7) + (get_local $1) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 400) + ) + (drop + (call $memcpy + (i32.add + (get_local $9) + (i32.const 16) + ) + (get_local $7) + (i32.const 8) + ) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 400) + ) + (drop + (call $memcpy + (i32.or + (i32.add + (get_local $9) + (i32.const 16) + ) + (i32.const 8) + ) + (i32.add + (get_local $7) + (i32.const 8) + ) + (i32.const 8) + ) + ) + (i32.store offset=20 + (get_local $7) + (tee_local $8 + (call $db_store_i64 + (i64.load + (i32.add + (get_local $0) + (i32.const 256) + ) + ) + (i64.const -4157493845350678528) + (get_local $6) + (tee_local $1 + (i64.load + (get_local $7) + ) + ) + (i32.add + (get_local $9) + (i32.const 16) + ) + (i32.const 16) + ) + ) + ) + (block $label$6 + (br_if $label$6 + (i64.lt_u + (get_local $1) + (i64.load + (tee_local $5 + (i32.add + (get_local $0) + (i32.const 264) + ) + ) + ) + ) + ) + (i64.store + (get_local $5) + (select + (i64.const -2) + (i64.add + (get_local $1) + (i64.const 1) + ) + (i64.gt_u + (get_local $1) + (i64.const -3) + ) + ) + ) + ) + (i32.store offset=8 + (get_local $9) + (get_local $7) + ) + (i64.store offset=16 + (get_local $9) + (tee_local $1 + (i64.load + (get_local $7) + ) + ) + ) + (i32.store offset=4 + (get_local $9) + (get_local $8) + ) + (block $label$7 + (block $label$8 + (br_if $label$8 + (i32.ge_u + (tee_local $5 + (i32.load + (tee_local $4 + (i32.add + (get_local $0) + (i32.const 276) + ) + ) + ) + ) + (i32.load + (i32.add + (get_local $0) + (i32.const 280) + ) + ) + ) + ) + (i64.store offset=8 + (get_local $5) + (get_local $1) + ) + (i32.store offset=16 + (get_local $5) + (get_local $8) + ) + (i32.store offset=8 + (get_local $9) + (i32.const 0) + ) + (i32.store + (get_local $5) + (get_local $7) + ) + (i32.store + (get_local $4) + (i32.add + (get_local $5) + (i32.const 24) + ) + ) + (br $label$7) + ) + (call $_ZNSt3__16vectorIN5eosio11multi_indexILy14289250228358873088EN6eoswin6statusEJEE8item_ptrENS_9allocatorIS6_EEE24__emplace_back_slow_pathIJNS_10unique_ptrINS5_4itemENS_14default_deleteISC_EEEERyRlEEEvDpOT_ + (i32.add + (get_local $0) + (i32.const 272) + ) + (i32.add + (get_local $9) + (i32.const 8) + ) + (i32.add + (get_local $9) + (i32.const 16) + ) + (i32.add + (get_local $9) + (i32.const 4) + ) + ) + ) + (set_local $7 + (i32.load offset=8 + (get_local $9) + ) + ) + (i32.store offset=8 + (get_local $9) + (i32.const 0) + ) + (br_if $label$2 + (i32.eqz + (get_local $7) + ) + ) + (call $_ZdlPv + (get_local $7) + ) + ) + (i32.store offset=4 + (i32.const 0) + (i32.add + (get_local $9) + (i32.const 32) + ) + ) + ) + (func $_ZNK5eosio11multi_indexILy14289250228358873088EN6eoswin6statusEJEE31load_object_by_primary_iteratorEl (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 i64) + (local $6 i32) + (local $7 i32) + (local $8 i32) + (local $9 i32) + (set_local $8 + (tee_local $9 + (i32.sub + (i32.load offset=4 + (i32.const 0) + ) + (i32.const 32) + ) + ) + ) + (i32.store offset=4 + (i32.const 0) + (get_local $9) + ) + (block $label$0 + (br_if $label$0 + (i32.eq + (tee_local $7 + (i32.load + (i32.add + (get_local $0) + (i32.const 28) + ) + ) + ) + (tee_local $2 + (i32.load offset=24 + (get_local $0) + ) + ) + ) + ) + (set_local $3 + (i32.sub + (i32.const 0) + (get_local $2) + ) + ) + (set_local $6 + (i32.add + (get_local $7) + (i32.const -24) + ) + ) + (loop $label$1 + (br_if $label$0 + (i32.eq + (i32.load + (i32.add + (get_local $6) + (i32.const 16) + ) + ) + (get_local $1) + ) + ) + (set_local $7 + (get_local $6) + ) + (set_local $6 + (tee_local $4 + (i32.add + (get_local $6) + (i32.const -24) + ) + ) + ) + (br_if $label$1 + (i32.ne + (i32.add + (get_local $4) + (get_local $3) + ) + (i32.const -24) + ) + ) + ) + ) + (block $label$2 + (block $label$3 + (br_if $label$3 + (i32.eq + (get_local $7) + (get_local $2) + ) + ) + (set_local $6 + (i32.load + (i32.add + (get_local $7) + (i32.const -24) + ) + ) + ) + (br $label$2) + ) + (call $eosio_assert + (i32.xor + (i32.shr_u + (tee_local $4 + (call $db_get_i64 + (get_local $1) + (i32.const 0) + (i32.const 0) + ) + ) + (i32.const 31) + ) + (i32.const 1) + ) + (i32.const 240) + ) + (block $label$4 + (block $label$5 + (br_if $label$5 + (i32.le_u + (get_local $4) + (i32.const 512) + ) + ) + (drop + (call $db_get_i64 + (get_local $1) + (tee_local $7 + (call $malloc + (get_local $4) + ) + ) + (get_local $4) + ) + ) + (call $free + (get_local $7) + ) + (br $label$4) + ) + (i32.store offset=4 + (i32.const 0) + (tee_local $7 + (i32.sub + (get_local $9) + (i32.and + (i32.add + (get_local $4) + (i32.const 15) + ) + (i32.const -16) + ) + ) + ) + ) + (drop + (call $db_get_i64 + (get_local $1) + (get_local $7) + (get_local $4) + ) + ) + ) + (i32.store offset=16 + (tee_local $6 + (call $_Znwj + (i32.const 32) + ) + ) + (get_local $0) + ) + (call $eosio_assert + (i32.gt_u + (get_local $4) + (i32.const 7) + ) + (i32.const 272) + ) + (drop + (call $memcpy + (get_local $6) + (get_local $7) + (i32.const 8) + ) + ) + (call $eosio_assert + (i32.ne + (i32.and + (get_local $4) + (i32.const -8) + ) + (i32.const 8) + ) + (i32.const 272) + ) + (drop + (call $memcpy + (i32.add + (get_local $6) + (i32.const 8) + ) + (i32.add + (get_local $7) + (i32.const 8) + ) + (i32.const 8) + ) + ) + (i32.store offset=20 + (get_local $6) + (get_local $1) + ) + (i32.store offset=24 + (get_local $8) + (get_local $6) + ) + (i64.store offset=16 + (get_local $8) + (tee_local $5 + (i64.load + (get_local $6) + ) + ) + ) + (i32.store offset=12 + (get_local $8) + (tee_local $7 + (i32.load offset=20 + (get_local $6) + ) + ) + ) + (block $label$6 + (block $label$7 + (br_if $label$7 + (i32.ge_u + (tee_local $4 + (i32.load + (tee_local $1 + (i32.add + (get_local $0) + (i32.const 28) + ) + ) + ) + ) + (i32.load + (i32.add + (get_local $0) + (i32.const 32) + ) + ) + ) + ) + (i64.store offset=8 + (get_local $4) + (get_local $5) + ) + (i32.store offset=16 + (get_local $4) + (get_local $7) + ) + (i32.store offset=24 + (get_local $8) + (i32.const 0) + ) + (i32.store + (get_local $4) + (get_local $6) + ) + (i32.store + (get_local $1) + (i32.add + (get_local $4) + (i32.const 24) + ) + ) + (br $label$6) + ) + (call $_ZNSt3__16vectorIN5eosio11multi_indexILy14289250228358873088EN6eoswin6statusEJEE8item_ptrENS_9allocatorIS6_EEE24__emplace_back_slow_pathIJNS_10unique_ptrINS5_4itemENS_14default_deleteISC_EEEERyRlEEEvDpOT_ + (i32.add + (get_local $0) + (i32.const 24) + ) + (i32.add + (get_local $8) + (i32.const 24) + ) + (i32.add + (get_local $8) + (i32.const 16) + ) + (i32.add + (get_local $8) + (i32.const 12) + ) + ) + ) + (set_local $4 + (i32.load offset=24 + (get_local $8) + ) + ) + (i32.store offset=24 + (get_local $8) + (i32.const 0) + ) + (br_if $label$2 + (i32.eqz + (get_local $4) + ) + ) + (call $_ZdlPv + (get_local $4) + ) + ) + (i32.store offset=4 + (i32.const 0) + (i32.add + (get_local $8) + (i32.const 32) + ) + ) + (get_local $6) + ) + (func $_ZNSt3__16vectorIN5eosio11multi_indexILy14289250228358873088EN6eoswin6statusEJEE8item_ptrENS_9allocatorIS6_EEE24__emplace_back_slow_pathIJNS_10unique_ptrINS5_4itemENS_14default_deleteISC_EEEERyRlEEEvDpOT_ (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (block $label$0 + (block $label$1 + (br_if $label$1 + (i32.ge_u + (tee_local $5 + (i32.add + (tee_local $4 + (i32.div_s + (i32.sub + (i32.load offset=4 + (get_local $0) + ) + (tee_local $6 + (i32.load + (get_local $0) + ) + ) + ) + (i32.const 24) + ) + ) + (i32.const 1) + ) + ) + (i32.const 178956971) + ) + ) + (set_local $7 + (i32.const 178956970) + ) + (block $label$2 + (block $label$3 + (br_if $label$3 + (i32.gt_u + (tee_local $6 + (i32.div_s + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (get_local $6) + ) + (i32.const 24) + ) + ) + (i32.const 89478484) + ) + ) + (br_if $label$2 + (i32.eqz + (tee_local $7 + (select + (get_local $5) + (tee_local $7 + (i32.shl + (get_local $6) + (i32.const 1) + ) + ) + (i32.lt_u + (get_local $7) + (get_local $5) + ) + ) + ) + ) + ) + ) + (set_local $6 + (call $_Znwj + (i32.mul + (get_local $7) + (i32.const 24) + ) + ) + ) + (br $label$0) + ) + (set_local $7 + (i32.const 0) + ) + (set_local $6 + (i32.const 0) + ) + (br $label$0) + ) + (call $_ZNKSt3__120__vector_base_commonILb1EE20__throw_length_errorEv + (get_local $0) + ) + (unreachable) + ) + (set_local $5 + (i32.load + (get_local $1) + ) + ) + (i32.store + (get_local $1) + (i32.const 0) + ) + (i32.store + (tee_local $1 + (i32.add + (get_local $6) + (i32.mul + (get_local $4) + (i32.const 24) + ) + ) + ) + (get_local $5) + ) + (i64.store offset=8 + (get_local $1) + (i64.load + (get_local $2) + ) + ) + (i32.store offset=16 + (get_local $1) + (i32.load + (get_local $3) + ) + ) + (set_local $4 + (i32.add + (get_local $6) + (i32.mul + (get_local $7) + (i32.const 24) + ) + ) + ) + (set_local $5 + (i32.add + (get_local $1) + (i32.const 24) + ) + ) + (block $label$4 + (block $label$5 + (br_if $label$5 + (i32.eq + (tee_local $6 + (i32.load + (i32.add + (get_local $0) + (i32.const 4) + ) + ) + ) + (tee_local $7 + (i32.load + (get_local $0) + ) + ) + ) + ) + (loop $label$6 + (set_local $3 + (i32.load + (tee_local $2 + (i32.add + (get_local $6) + (i32.const -24) + ) + ) + ) + ) + (i32.store + (get_local $2) + (i32.const 0) + ) + (i32.store + (i32.add + (get_local $1) + (i32.const -24) + ) + (get_local $3) + ) + (i32.store + (i32.add + (get_local $1) + (i32.const -8) + ) + (i32.load + (i32.add + (get_local $6) + (i32.const -8) + ) + ) + ) + (i32.store + (i32.add + (get_local $1) + (i32.const -12) + ) + (i32.load + (i32.add + (get_local $6) + (i32.const -12) + ) + ) + ) + (i32.store + (i32.add + (get_local $1) + (i32.const -16) + ) + (i32.load + (i32.add + (get_local $6) + (i32.const -16) + ) + ) + ) + (set_local $1 + (i32.add + (get_local $1) + (i32.const -24) + ) + ) + (set_local $6 + (get_local $2) + ) + (br_if $label$6 + (i32.ne + (get_local $7) + (get_local $2) + ) + ) + ) + (set_local $7 + (i32.load + (i32.add + (get_local $0) + (i32.const 4) + ) + ) + ) + (set_local $6 + (i32.load + (get_local $0) + ) + ) + (br $label$4) + ) + (set_local $6 + (get_local $7) + ) + ) + (i32.store + (get_local $0) + (get_local $1) + ) + (i32.store + (i32.add + (get_local $0) + (i32.const 4) + ) + (get_local $5) + ) + (i32.store + (i32.add + (get_local $0) + (i32.const 8) + ) + (get_local $4) + ) + (block $label$7 + (br_if $label$7 + (i32.eq + (get_local $7) + (get_local $6) + ) + ) + (loop $label$8 + (set_local $1 + (i32.load + (tee_local $7 + (i32.add + (get_local $7) + (i32.const -24) + ) + ) + ) + ) + (i32.store + (get_local $7) + (i32.const 0) + ) + (block $label$9 + (br_if $label$9 + (i32.eqz + (get_local $1) + ) + ) + (call $_ZdlPv + (get_local $1) + ) + ) + (br_if $label$8 + (i32.ne + (get_local $6) + (get_local $7) + ) + ) + ) + ) + (block $label$10 + (br_if $label$10 + (i32.eqz + (get_local $6) + ) + ) + (call $_ZdlPv + (get_local $6) + ) + ) + ) + (func $_ZN6eoswin7lottery8endroundEv (param $0 i32) + (local $1 i32) + (local $2 i32) + (local $3 i64) + (local $4 i64) + (local $5 i64) + (local $6 i64) + (local $7 i64) + (local $8 i64) + (local $9 i32) + (local $10 i32) + (local $11 i32) + (local $12 i64) + (local $13 i32) + (local $14 i64) + (local $15 i64) + (local $16 i64) + (local $17 i64) + (local $18 i64) + (local $19 i64) + (local $20 i32) + (i32.store offset=4 + (i32.const 0) + (tee_local $20 + (i32.sub + (i32.load offset=4 + (i32.const 0) + ) + (i32.const 800) + ) + ) + ) + (drop + (call $memcpy + (i32.add + (get_local $20) + (i32.const 656) + ) + (call $_ZNK5eosio11multi_indexILy13633861583611363328EN6eoswin10round_itemEJEE3getEyPKc + (i32.add + (get_local $0) + (i32.const 144) + ) + (i64.load + (i32.add + (get_local $0) + (i32.const 64) + ) + ) + (i32.const 736) + ) + (i32.const 80) + ) + ) + (block $label$0 + (block $label$1 + (br_if $label$1 + (i64.gt_s + (tee_local $15 + (i64.load offset=680 + (get_local $20) + ) + ) + (i64.const 1000000) + ) + ) + (set_local $7 + (i64.and + (i64.sub + (i64.sub + (i64.sub + (i64.const 100) + (i64.and + (i64.extend_u/i32 + (tee_local $13 + (i32.load8_u + (i32.add + (get_local $0) + (i32.const 90) + ) + ) + ) + ) + (i64.const 255) + ) + ) + (i64.load8_u + (i32.add + (get_local $0) + (i32.const 88) + ) + ) + ) + (i64.and + (i64.extend_u/i32 + (tee_local $11 + (i32.load8_u + (i32.add + (get_local $0) + (i32.const 89) + ) + ) + ) + ) + (i64.const 255) + ) + ) + (i64.const 4294967295) + ) + ) + (br $label$0) + ) + (set_local $11 + (select + (i32.const 7) + (i32.const 10) + (tee_local $13 + (i64.lt_s + (get_local $15) + (i64.const 3000001) + ) + ) + ) + ) + (set_local $7 + (select + (i64.const 72) + (i64.const 60) + (get_local $13) + ) + ) + (set_local $13 + (i32.load8_u + (i32.add + (get_local $0) + (i32.const 90) + ) + ) + ) + ) + (set_local $18 + (i64.const 0) + ) + (call $__multi3 + (i32.add + (get_local $20) + (i32.const 64) + ) + (get_local $15) + (i64.shr_s + (get_local $15) + (i64.const 63) + ) + (i64.extend_u/i32 + (i32.and + (get_local $13) + (i32.const 255) + ) + ) + (i64.const 0) + ) + (set_local $17 + (i64.load + (tee_local $9 + (i32.add + (i32.add + (get_local $20) + (i32.const 656) + ) + (i32.const 32) + ) + ) + ) + ) + (call $eosio_assert + (select + (i64.lt_u + (tee_local $14 + (i64.load offset=64 + (get_local $20) + ) + ) + (i64.const 4611686018427387904) + ) + (i64.lt_s + (tee_local $15 + (i64.load + (i32.add + (i32.add + (get_local $20) + (i32.const 64) + ) + (i32.const 8) + ) + ) + ) + (i64.const 0) + ) + (i64.eqz + (get_local $15) + ) + ) + (i32.const 768) + ) + (call $eosio_assert + (select + (i64.gt_u + (get_local $14) + (i64.const -4611686018427387904) + ) + (i64.gt_s + (get_local $15) + (i64.const -1) + ) + (i64.eq + (get_local $15) + (i64.const -1) + ) + ) + (i32.const 800) + ) + (i64.store offset=648 + (get_local $20) + (get_local $17) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 832) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 848) + ) + (i64.store offset=640 + (get_local $20) + (tee_local $15 + (i64.div_s + (get_local $14) + (i64.const 100) + ) + ) + ) + (call $eosio_assert + (i64.eq + (get_local $17) + (i64.load + (i32.add + (get_local $0) + (i32.const 104) + ) + ) + ) + (i32.const 880) + ) + (i32.store + (i32.add + (i32.add + (get_local $20) + (i32.const 640) + ) + (i32.const 12) + ) + (i32.load + (i32.add + (tee_local $13 + (select + (tee_local $13 + (i32.add + (get_local $0) + (i32.const 96) + ) + ) + (i32.add + (get_local $20) + (i32.const 640) + ) + (i64.gt_s + (get_local $15) + (i64.load + (get_local $13) + ) + ) + ) + ) + (i32.const 12) + ) + ) + ) + (i32.store offset=640 + (get_local $20) + (i32.load + (get_local $13) + ) + ) + (i32.store offset=648 + (get_local $20) + (i32.load + (i32.add + (get_local $13) + (i32.const 8) + ) + ) + ) + (i32.store offset=644 + (get_local $20) + (i32.load + (i32.add + (get_local $13) + (i32.const 4) + ) + ) + ) + (i64.store offset=616 + (get_local $20) + (i64.const -1) + ) + (i32.store offset=624 + (get_local $20) + (i32.const 0) + ) + (i64.store offset=600 + (get_local $20) + (i64.load + (get_local $0) + ) + ) + (i64.store offset=608 + (get_local $20) + (i64.load + (i32.add + (get_local $0) + (i32.const 64) + ) + ) + ) + (i32.store + (i32.add + (get_local $20) + (i32.const 628) + ) + (i32.const 0) + ) + (i32.store + (i32.add + (i32.add + (get_local $20) + (i32.const 600) + ) + (i32.const 32) + ) + (i32.const 0) + ) + (i32.store8 offset=636 + (get_local $20) + (i32.const 0) + ) + (i32.store offset=592 + (get_local $20) + (i32.add + (get_local $20) + (i32.const 600) + ) + ) + (call $_ZNK5eosio11multi_indexILy4297309255767162880EN6eoswin9bill_itemEJNS_10indexed_byILy4587782057278570496EN5boost11multi_index13const_mem_funIS2_yXadL_ZNKS2_8byplayerEvEEEEEEEE5indexILy4587782057278570496ES7_Ly0ELb0EE11lower_boundERKy + (i32.add + (get_local $20) + (i32.const 584) + ) + (i32.add + (get_local $20) + (i32.const 592) + ) + (tee_local $10 + (i32.add + (get_local $20) + (i32.const 696) + ) + ) + ) + (call $eosio_assert + (i32.ne + (i32.load offset=588 + (get_local $20) + ) + (i32.const 0) + ) + (i32.const 944) + ) + (set_local $12 + (i64.const 0) + ) + (block $label$2 + (br_if $label$2 + (i32.eqz + (tee_local $1 + (i32.load offset=588 + (get_local $20) + ) + ) + ) + ) + (set_local $12 + (i64.const 0) + ) + (loop $label$3 + (set_local $19 + (i64.load offset=48 + (get_local $1) + ) + ) + (set_local $14 + (i64.const 59) + ) + (set_local $13 + (i32.const 960) + ) + (set_local $15 + (i64.const 0) + ) + (set_local $16 + (i64.const 0) + ) + (loop $label$4 + (block $label$5 + (block $label$6 + (block $label$7 + (block $label$8 + (block $label$9 + (br_if $label$9 + (i64.gt_u + (get_local $15) + (i64.const 7) + ) + ) + (br_if $label$8 + (i32.gt_u + (i32.and + (i32.add + (tee_local $2 + (i32.load8_s + (get_local $13) + ) + ) + (i32.const -97) + ) + (i32.const 255) + ) + (i32.const 25) + ) + ) + (set_local $2 + (i32.add + (get_local $2) + (i32.const 165) + ) + ) + (br $label$7) + ) + (set_local $17 + (i64.const 0) + ) + (br_if $label$6 + (i64.le_u + (get_local $15) + (i64.const 11) + ) + ) + (br $label$5) + ) + (set_local $2 + (select + (i32.add + (get_local $2) + (i32.const 208) + ) + (i32.const 0) + (i32.lt_u + (i32.and + (i32.add + (get_local $2) + (i32.const -49) + ) + (i32.const 255) + ) + (i32.const 5) + ) + ) + ) + ) + (set_local $17 + (i64.shr_s + (i64.shl + (i64.extend_u/i32 + (get_local $2) + ) + (i64.const 56) + ) + (i64.const 56) + ) + ) + ) + (set_local $17 + (i64.shl + (i64.and + (get_local $17) + (i64.const 31) + ) + (i64.and + (get_local $14) + (i64.const 4294967295) + ) + ) + ) + ) + (set_local $13 + (i32.add + (get_local $13) + (i32.const 1) + ) + ) + (set_local $15 + (i64.add + (get_local $15) + (i64.const 1) + ) + ) + (set_local $16 + (i64.or + (get_local $17) + (get_local $16) + ) + ) + (br_if $label$4 + (i64.ne + (tee_local $14 + (i64.add + (get_local $14) + (i64.const -5) + ) + ) + (i64.const -6) + ) + ) + ) + (block $label$10 + (br_if $label$10 + (i64.eq + (get_local $19) + (get_local $16) + ) + ) + (br_if $label$2 + (i64.ne + (i64.load offset=8 + (get_local $1) + ) + (i64.load + (get_local $10) + ) + ) + ) + (set_local $12 + (i64.sub + (i64.add + (i64.add + (get_local $12) + (i64.load offset=24 + (get_local $1) + ) + ) + (i64.const 1) + ) + (i64.load offset=16 + (get_local $1) + ) + ) + ) + ) + (drop + (call $_ZN5eosio11multi_indexILy4297309255767162880EN6eoswin9bill_itemEJNS_10indexed_byILy4587782057278570496EN5boost11multi_index13const_mem_funIS2_yXadL_ZNKS2_8byplayerEvEEEEEEEE5indexILy4587782057278570496ES7_Ly0ELb0EE14const_iteratorppEv + (i32.add + (get_local $20) + (i32.const 584) + ) + ) + ) + (br_if $label$3 + (tee_local $1 + (i32.load offset=588 + (get_local $20) + ) + ) + ) + ) + ) + (call $__multi3 + (i32.add + (get_local $20) + (i32.const 48) + ) + (tee_local $15 + (i64.load offset=48 + (get_local $0) + ) + ) + (i64.shr_s + (get_local $15) + (i64.const 63) + ) + (get_local $12) + (i64.shr_s + (get_local $12) + (i64.const 63) + ) + ) + (set_local $17 + (i64.load + (i32.add + (get_local $0) + (i32.const 56) + ) + ) + ) + (call $eosio_assert + (select + (i64.lt_u + (tee_local $14 + (i64.load offset=48 + (get_local $20) + ) + ) + (i64.const 4611686018427387904) + ) + (i64.lt_s + (tee_local $15 + (i64.load + (i32.add + (i32.add + (get_local $20) + (i32.const 48) + ) + (i32.const 8) + ) + ) + ) + (i64.const 0) + ) + (i64.eqz + (get_local $15) + ) + ) + (i32.const 768) + ) + (call $eosio_assert + (select + (i64.gt_u + (get_local $14) + (i64.const -4611686018427387904) + ) + (i64.gt_s + (get_local $15) + (i64.const -1) + ) + (i64.eq + (get_local $15) + (i64.const -1) + ) + ) + (i32.const 800) + ) + (i64.store offset=576 + (get_local $20) + (get_local $17) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 832) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 848) + ) + (i64.store offset=568 + (get_local $20) + (tee_local $15 + (i64.div_s + (get_local $14) + (i64.const 2) + ) + ) + ) + (call $eosio_assert + (i64.eq + (get_local $17) + (i64.load + (i32.add + (i32.add + (get_local $20) + (i32.const 640) + ) + (i32.const 8) + ) + ) + ) + (i32.const 880) + ) + (call $__multi3 + (i32.add + (get_local $20) + (i32.const 32) + ) + (tee_local $17 + (i64.load + (tee_local $13 + (i32.add + (get_local $20) + (i32.const 680) + ) + ) + ) + ) + (i64.shr_s + (get_local $17) + (i64.const 63) + ) + (i64.and + (get_local $7) + (i64.const 255) + ) + (i64.const 0) + ) + (i64.store offset=568 + (get_local $20) + (i64.load + (tee_local $2 + (select + (i32.add + (get_local $20) + (i32.const 640) + ) + (i32.add + (get_local $20) + (i32.const 568) + ) + (i64.gt_s + (get_local $15) + (i64.load offset=640 + (get_local $20) + ) + ) + ) + ) + ) + ) + (i64.store offset=576 + (get_local $20) + (i64.load + (i32.add + (get_local $2) + (i32.const 8) + ) + ) + ) + (set_local $3 + (i64.load + (get_local $9) + ) + ) + (call $eosio_assert + (select + (i64.lt_u + (tee_local $17 + (i64.load offset=32 + (get_local $20) + ) + ) + (i64.const 4611686018427387904) + ) + (i64.lt_s + (tee_local $15 + (i64.load + (i32.add + (i32.add + (get_local $20) + (i32.const 32) + ) + (i32.const 8) + ) + ) + ) + (i64.const 0) + ) + (i64.eqz + (get_local $15) + ) + ) + (i32.const 768) + ) + (call $eosio_assert + (select + (i64.gt_u + (get_local $17) + (i64.const -4611686018427387904) + ) + (i64.gt_s + (get_local $15) + (i64.const -1) + ) + (i64.eq + (get_local $15) + (i64.const -1) + ) + ) + (i32.const 800) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 832) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 848) + ) + (call $__multi3 + (i32.add + (get_local $20) + (i32.const 16) + ) + (tee_local $15 + (i64.load + (get_local $13) + ) + ) + (i64.shr_s + (get_local $15) + (i64.const 63) + ) + (i64.extend_u/i32 + (i32.and + (get_local $11) + (i32.const 255) + ) + ) + (i64.const 0) + ) + (set_local $5 + (i64.load + (get_local $9) + ) + ) + (call $eosio_assert + (select + (i64.lt_u + (tee_local $14 + (i64.load offset=16 + (get_local $20) + ) + ) + (i64.const 4611686018427387904) + ) + (i64.lt_s + (tee_local $15 + (i64.load + (i32.add + (i32.add + (get_local $20) + (i32.const 16) + ) + (i32.const 8) + ) + ) + ) + (i64.const 0) + ) + (i64.eqz + (get_local $15) + ) + ) + (i32.const 768) + ) + (call $eosio_assert + (select + (i64.gt_u + (get_local $14) + (i64.const -4611686018427387904) + ) + (i64.gt_s + (get_local $15) + (i64.const -1) + ) + (i64.eq + (get_local $15) + (i64.const -1) + ) + ) + (i32.const 800) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 832) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 848) + ) + (set_local $15 + (i64.load + (get_local $13) + ) + ) + (call $eosio_assert + (i64.eq + (get_local $5) + (tee_local $12 + (i64.load + (get_local $9) + ) + ) + ) + (i32.const 976) + ) + (call $eosio_assert + (i64.gt_s + (tee_local $15 + (i64.sub + (get_local $15) + (tee_local $6 + (i64.div_s + (get_local $14) + (i64.const 100) + ) + ) + ) + ) + (i64.const -4611686018427387904) + ) + (i32.const 1024) + ) + (call $eosio_assert + (i64.lt_s + (get_local $15) + (i64.const 4611686018427387904) + ) + (i32.const 1056) + ) + (call $eosio_assert + (i64.eq + (get_local $3) + (get_local $12) + ) + (i32.const 976) + ) + (call $eosio_assert + (i64.gt_s + (tee_local $15 + (i64.sub + (get_local $15) + (tee_local $4 + (i64.div_s + (get_local $17) + (i64.const 100) + ) + ) + ) + ) + (i64.const -4611686018427387904) + ) + (i32.const 1024) + ) + (call $eosio_assert + (i64.lt_s + (get_local $15) + (i64.const 4611686018427387904) + ) + (i32.const 1056) + ) + (call $eosio_assert + (i64.eq + (get_local $12) + (i64.load offset=576 + (get_local $20) + ) + ) + (i32.const 976) + ) + (call $eosio_assert + (i64.gt_s + (tee_local $7 + (i64.sub + (get_local $15) + (i64.load offset=568 + (get_local $20) + ) + ) + ) + (i64.const -4611686018427387904) + ) + (i32.const 1024) + ) + (call $eosio_assert + (i64.lt_s + (get_local $7) + (i64.const 4611686018427387904) + ) + (i32.const 1056) + ) + (set_local $17 + (i64.const 59) + ) + (set_local $13 + (i32.const 1088) + ) + (set_local $16 + (i64.const 0) + ) + (loop $label$11 + (block $label$12 + (block $label$13 + (block $label$14 + (block $label$15 + (block $label$16 + (br_if $label$16 + (i64.gt_u + (get_local $18) + (i64.const 10) + ) + ) + (br_if $label$15 + (i32.gt_u + (i32.and + (i32.add + (tee_local $2 + (i32.load8_s + (get_local $13) + ) + ) + (i32.const -97) + ) + (i32.const 255) + ) + (i32.const 25) + ) + ) + (set_local $2 + (i32.add + (get_local $2) + (i32.const 165) + ) + ) + (br $label$14) + ) + (set_local $15 + (i64.const 0) + ) + (br_if $label$13 + (i64.eq + (get_local $18) + (i64.const 11) + ) + ) + (br $label$12) + ) + (set_local $2 + (select + (i32.add + (get_local $2) + (i32.const 208) + ) + (i32.const 0) + (i32.lt_u + (i32.and + (i32.add + (get_local $2) + (i32.const -49) + ) + (i32.const 255) + ) + (i32.const 5) + ) + ) + ) + ) + (set_local $15 + (i64.shr_s + (i64.shl + (i64.extend_u/i32 + (get_local $2) + ) + (i64.const 56) + ) + (i64.const 56) + ) + ) + ) + (set_local $15 + (i64.shl + (i64.and + (get_local $15) + (i64.const 31) + ) + (i64.and + (get_local $17) + (i64.const 4294967295) + ) + ) + ) + ) + (set_local $13 + (i32.add + (get_local $13) + (i32.const 1) + ) + ) + (set_local $17 + (i64.add + (get_local $17) + (i64.const -5) + ) + ) + (set_local $16 + (i64.or + (get_local $15) + (get_local $16) + ) + ) + (br_if $label$11 + (i64.ne + (tee_local $18 + (i64.add + (get_local $18) + (i64.const 1) + ) + ) + (i64.const 13) + ) + ) + ) + (set_local $8 + (i64.load + (get_local $0) + ) + ) + (set_local $15 + (i64.const 0) + ) + (set_local $14 + (i64.const 59) + ) + (set_local $13 + (i32.const 592) + ) + (set_local $18 + (i64.const 0) + ) + (loop $label$17 + (block $label$18 + (block $label$19 + (block $label$20 + (block $label$21 + (block $label$22 + (br_if $label$22 + (i64.gt_u + (get_local $15) + (i64.const 5) + ) + ) + (br_if $label$21 + (i32.gt_u + (i32.and + (i32.add + (tee_local $2 + (i32.load8_s + (get_local $13) + ) + ) + (i32.const -97) + ) + (i32.const 255) + ) + (i32.const 25) + ) + ) + (set_local $2 + (i32.add + (get_local $2) + (i32.const 165) + ) + ) + (br $label$20) + ) + (set_local $17 + (i64.const 0) + ) + (br_if $label$19 + (i64.le_u + (get_local $15) + (i64.const 11) + ) + ) + (br $label$18) + ) + (set_local $2 + (select + (i32.add + (get_local $2) + (i32.const 208) + ) + (i32.const 0) + (i32.lt_u + (i32.and + (i32.add + (get_local $2) + (i32.const -49) + ) + (i32.const 255) + ) + (i32.const 5) + ) + ) + ) + ) + (set_local $17 + (i64.shr_s + (i64.shl + (i64.extend_u/i32 + (get_local $2) + ) + (i64.const 56) + ) + (i64.const 56) + ) + ) + ) + (set_local $17 + (i64.shl + (i64.and + (get_local $17) + (i64.const 31) + ) + (i64.and + (get_local $14) + (i64.const 4294967295) + ) + ) + ) + ) + (set_local $13 + (i32.add + (get_local $13) + (i32.const 1) + ) + ) + (set_local $15 + (i64.add + (get_local $15) + (i64.const 1) + ) + ) + (set_local $18 + (i64.or + (get_local $17) + (get_local $18) + ) + ) + (br_if $label$17 + (i64.ne + (tee_local $14 + (i64.add + (get_local $14) + (i64.const -5) + ) + ) + (i64.const -6) + ) + ) + ) + (set_local $15 + (i64.const 0) + ) + (set_local $17 + (i64.const 59) + ) + (set_local $13 + (i32.const 1104) + ) + (set_local $19 + (i64.const 0) + ) + (loop $label$23 + (set_local $14 + (i64.const 0) + ) + (block $label$24 + (br_if $label$24 + (i64.gt_u + (get_local $15) + (i64.const 11) + ) + ) + (block $label$25 + (block $label$26 + (br_if $label$26 + (i32.gt_u + (i32.and + (i32.add + (tee_local $2 + (i32.load8_s + (get_local $13) + ) + ) + (i32.const -97) + ) + (i32.const 255) + ) + (i32.const 25) + ) + ) + (set_local $2 + (i32.add + (get_local $2) + (i32.const 165) + ) + ) + (br $label$25) + ) + (set_local $2 + (select + (i32.add + (get_local $2) + (i32.const 208) + ) + (i32.const 0) + (i32.lt_u + (i32.and + (i32.add + (get_local $2) + (i32.const -49) + ) + (i32.const 255) + ) + (i32.const 5) + ) + ) + ) + ) + (set_local $14 + (i64.shl + (i64.extend_u/i32 + (i32.and + (get_local $2) + (i32.const 31) + ) + ) + (i64.and + (get_local $17) + (i64.const 4294967295) + ) + ) + ) + ) + (set_local $13 + (i32.add + (get_local $13) + (i32.const 1) + ) + ) + (set_local $15 + (i64.add + (get_local $15) + (i64.const 1) + ) + ) + (set_local $19 + (i64.or + (get_local $14) + (get_local $19) + ) + ) + (br_if $label$23 + (i64.ne + (tee_local $17 + (i64.add + (get_local $17) + (i64.const -5) + ) + ) + (i64.const -6) + ) + ) + ) + (i64.store + (i32.add + (get_local $20) + (i32.const 544) + ) + (get_local $12) + ) + (i64.store align=4 + (i32.add + (get_local $20) + (i32.const 556) + ) + (i64.const 0) + ) + (i64.store offset=528 + (get_local $20) + (get_local $19) + ) + (i64.store offset=520 + (get_local $20) + (get_local $8) + ) + (i64.store offset=536 + (get_local $20) + (get_local $7) + ) + (i32.store offset=552 + (get_local $20) + (i32.const 0) + ) + (set_local $2 + (i32.add + (get_local $20) + (i32.const 552) + ) + ) + (block $label$27 + (block $label$28 + (block $label$29 + (block $label$30 + (br_if $label$30 + (i32.ge_u + (tee_local $13 + (call $strlen + (i32.const 1120) + ) + ) + (i32.const -16) + ) + ) + (block $label$31 + (block $label$32 + (block $label$33 + (br_if $label$33 + (i32.ge_u + (get_local $13) + (i32.const 11) + ) + ) + (i32.store8 + (i32.add + (get_local $20) + (i32.const 552) + ) + (i32.shl + (get_local $13) + (i32.const 1) + ) + ) + (set_local $1 + (i32.add + (get_local $2) + (i32.const 1) + ) + ) + (br_if $label$32 + (get_local $13) + ) + (br $label$31) + ) + (set_local $1 + (call $_Znwj + (tee_local $10 + (i32.and + (i32.add + (get_local $13) + (i32.const 16) + ) + (i32.const -16) + ) + ) + ) + ) + (i32.store + (i32.add + (get_local $20) + (i32.const 552) + ) + (i32.or + (get_local $10) + (i32.const 1) + ) + ) + (i32.store + (i32.add + (get_local $20) + (i32.const 560) + ) + (get_local $1) + ) + (i32.store + (i32.add + (get_local $20) + (i32.const 556) + ) + (get_local $13) + ) + ) + (drop + (call $memcpy + (get_local $1) + (i32.const 1120) + (get_local $13) + ) + ) + ) + (i32.store8 + (i32.add + (get_local $1) + (get_local $13) + ) + (i32.const 0) + ) + (i64.store + (tee_local $13 + (call $_Znwj + (i32.const 16) + ) + ) + (get_local $8) + ) + (i64.store offset=8 + (get_local $13) + (get_local $18) + ) + (i32.store offset=408 + (get_local $20) + (get_local $13) + ) + (i32.store offset=416 + (get_local $20) + (tee_local $13 + (i32.add + (get_local $13) + (i32.const 16) + ) + ) + ) + (i32.store offset=412 + (get_local $20) + (get_local $13) + ) + (i64.store offset=144 + (get_local $20) + (i64.load offset=520 + (get_local $20) + ) + ) + (i64.store offset=152 + (get_local $20) + (i64.load + (i32.add + (i32.add + (get_local $20) + (i32.const 520) + ) + (i32.const 8) + ) + ) + ) + (i64.store + (i32.add + (i32.add + (get_local $20) + (i32.const 144) + ) + (i32.const 24) + ) + (i64.load + (i32.add + (i32.add + (get_local $20) + (i32.const 520) + ) + (i32.const 24) + ) + ) + ) + (i64.store offset=160 + (get_local $20) + (i64.load offset=536 + (get_local $20) + ) + ) + (i32.store + (tee_local $13 + (i32.add + (i32.add + (get_local $20) + (i32.const 144) + ) + (i32.const 40) + ) + ) + (i32.load + (i32.add + (get_local $2) + (i32.const 8) + ) + ) + ) + (i64.store offset=176 + (get_local $20) + (i64.load + (get_local $2) + ) + ) + (i32.store + (i32.add + (get_local $20) + (i32.const 552) + ) + (i32.const 0) + ) + (i32.store + (i32.add + (get_local $20) + (i32.const 556) + ) + (i32.const 0) + ) + (i32.store + (i32.add + (i32.add + (get_local $20) + (i32.const 520) + ) + (i32.const 40) + ) + (i32.const 0) + ) + (call $_ZN5eosio15dispatch_inlineIJyyNS_5assetENSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEvyyNS2_6vectorINS_16permission_levelENS6_ISA_EEEENS2_5tupleIJDpT_EEE + (get_local $16) + (i64.const -3617168760277827584) + (i32.add + (get_local $20) + (i32.const 408) + ) + (i32.add + (get_local $20) + (i32.const 144) + ) + ) + (block $label$34 + (br_if $label$34 + (i32.eqz + (i32.and + (i32.load8_u offset=176 + (get_local $20) + ) + (i32.const 1) + ) + ) + ) + (call $_ZdlPv + (i32.load + (get_local $13) + ) + ) + ) + (block $label$35 + (br_if $label$35 + (i32.eqz + (tee_local $13 + (i32.load offset=408 + (get_local $20) + ) + ) + ) + ) + (i32.store offset=412 + (get_local $20) + (get_local $13) + ) + (call $_ZdlPv + (get_local $13) + ) + ) + (block $label$36 + (br_if $label$36 + (i32.eqz + (i32.and + (i32.load8_u + (i32.add + (get_local $20) + (i32.const 552) + ) + ) + (i32.const 1) + ) + ) + ) + (call $_ZdlPv + (i32.load + (i32.add + (get_local $20) + (i32.const 560) + ) + ) + ) + ) + (set_local $15 + (i64.const 0) + ) + (set_local $14 + (i64.const 59) + ) + (set_local $13 + (i32.const 1088) + ) + (set_local $16 + (i64.const 0) + ) + (loop $label$37 + (block $label$38 + (block $label$39 + (block $label$40 + (block $label$41 + (block $label$42 + (br_if $label$42 + (i64.gt_u + (get_local $15) + (i64.const 10) + ) + ) + (br_if $label$41 + (i32.gt_u + (i32.and + (i32.add + (tee_local $2 + (i32.load8_s + (get_local $13) + ) + ) + (i32.const -97) + ) + (i32.const 255) + ) + (i32.const 25) + ) + ) + (set_local $2 + (i32.add + (get_local $2) + (i32.const 165) + ) + ) + (br $label$40) + ) + (set_local $17 + (i64.const 0) + ) + (br_if $label$39 + (i64.eq + (get_local $15) + (i64.const 11) + ) + ) + (br $label$38) + ) + (set_local $2 + (select + (i32.add + (get_local $2) + (i32.const 208) + ) + (i32.const 0) + (i32.lt_u + (i32.and + (i32.add + (get_local $2) + (i32.const -49) + ) + (i32.const 255) + ) + (i32.const 5) + ) + ) + ) + ) + (set_local $17 + (i64.shr_s + (i64.shl + (i64.extend_u/i32 + (get_local $2) + ) + (i64.const 56) + ) + (i64.const 56) + ) + ) + ) + (set_local $17 + (i64.shl + (i64.and + (get_local $17) + (i64.const 31) + ) + (i64.and + (get_local $14) + (i64.const 4294967295) + ) + ) + ) + ) + (set_local $13 + (i32.add + (get_local $13) + (i32.const 1) + ) + ) + (set_local $14 + (i64.add + (get_local $14) + (i64.const -5) + ) + ) + (set_local $16 + (i64.or + (get_local $17) + (get_local $16) + ) + ) + (br_if $label$37 + (i64.ne + (tee_local $15 + (i64.add + (get_local $15) + (i64.const 1) + ) + ) + (i64.const 13) + ) + ) + ) + (set_local $19 + (i64.load + (get_local $0) + ) + ) + (set_local $15 + (i64.const 0) + ) + (set_local $14 + (i64.const 59) + ) + (set_local $13 + (i32.const 592) + ) + (set_local $18 + (i64.const 0) + ) + (loop $label$43 + (block $label$44 + (block $label$45 + (block $label$46 + (block $label$47 + (block $label$48 + (br_if $label$48 + (i64.gt_u + (get_local $15) + (i64.const 5) + ) + ) + (br_if $label$47 + (i32.gt_u + (i32.and + (i32.add + (tee_local $2 + (i32.load8_s + (get_local $13) + ) + ) + (i32.const -97) + ) + (i32.const 255) + ) + (i32.const 25) + ) + ) + (set_local $2 + (i32.add + (get_local $2) + (i32.const 165) + ) + ) + (br $label$46) + ) + (set_local $17 + (i64.const 0) + ) + (br_if $label$45 + (i64.le_u + (get_local $15) + (i64.const 11) + ) + ) + (br $label$44) + ) + (set_local $2 + (select + (i32.add + (get_local $2) + (i32.const 208) + ) + (i32.const 0) + (i32.lt_u + (i32.and + (i32.add + (get_local $2) + (i32.const -49) + ) + (i32.const 255) + ) + (i32.const 5) + ) + ) + ) + ) + (set_local $17 + (i64.shr_s + (i64.shl + (i64.extend_u/i32 + (get_local $2) + ) + (i64.const 56) + ) + (i64.const 56) + ) + ) + ) + (set_local $17 + (i64.shl + (i64.and + (get_local $17) + (i64.const 31) + ) + (i64.and + (get_local $14) + (i64.const 4294967295) + ) + ) + ) + ) + (set_local $13 + (i32.add + (get_local $13) + (i32.const 1) + ) + ) + (set_local $15 + (i64.add + (get_local $15) + (i64.const 1) + ) + ) + (set_local $18 + (i64.or + (get_local $17) + (get_local $18) + ) + ) + (br_if $label$43 + (i64.ne + (tee_local $14 + (i64.add + (get_local $14) + (i64.const -5) + ) + ) + (i64.const -6) + ) + ) + ) + (i64.store + (i32.add + (get_local $20) + (i32.const 496) + ) + (get_local $5) + ) + (i64.store align=4 + (i32.add + (get_local $20) + (i32.const 508) + ) + (i64.const 0) + ) + (i64.store offset=472 + (get_local $20) + (get_local $19) + ) + (i64.store offset=488 + (get_local $20) + (get_local $6) + ) + (i32.store offset=504 + (get_local $20) + (i32.const 0) + ) + (i64.store offset=480 + (get_local $20) + (i64.load + (i32.add + (get_local $0) + (i32.const 80) + ) + ) + ) + (set_local $2 + (i32.add + (get_local $20) + (i32.const 504) + ) + ) + (br_if $label$29 + (i32.ge_u + (tee_local $13 + (call $strlen + (i32.const 1184) + ) + ) + (i32.const -16) + ) + ) + (block $label$49 + (block $label$50 + (block $label$51 + (br_if $label$51 + (i32.ge_u + (get_local $13) + (i32.const 11) + ) + ) + (i32.store8 + (i32.add + (get_local $20) + (i32.const 504) + ) + (i32.shl + (get_local $13) + (i32.const 1) + ) + ) + (set_local $1 + (i32.add + (get_local $2) + (i32.const 1) + ) + ) + (br_if $label$50 + (get_local $13) + ) + (br $label$49) + ) + (set_local $1 + (call $_Znwj + (tee_local $10 + (i32.and + (i32.add + (get_local $13) + (i32.const 16) + ) + (i32.const -16) + ) + ) + ) + ) + (i32.store + (i32.add + (get_local $20) + (i32.const 504) + ) + (i32.or + (get_local $10) + (i32.const 1) + ) + ) + (i32.store + (i32.add + (get_local $20) + (i32.const 512) + ) + (get_local $1) + ) + (i32.store + (i32.add + (get_local $20) + (i32.const 508) + ) + (get_local $13) + ) + ) + (drop + (call $memcpy + (get_local $1) + (i32.const 1184) + (get_local $13) + ) + ) + ) + (i32.store8 + (i32.add + (get_local $1) + (get_local $13) + ) + (i32.const 0) + ) + (i64.store + (tee_local $13 + (call $_Znwj + (i32.const 16) + ) + ) + (get_local $19) + ) + (i64.store offset=8 + (get_local $13) + (get_local $18) + ) + (i32.store offset=408 + (get_local $20) + (get_local $13) + ) + (i32.store offset=416 + (get_local $20) + (tee_local $13 + (i32.add + (get_local $13) + (i32.const 16) + ) + ) + ) + (i32.store offset=412 + (get_local $20) + (get_local $13) + ) + (i64.store offset=144 + (get_local $20) + (i64.load offset=472 + (get_local $20) + ) + ) + (i64.store offset=152 + (get_local $20) + (i64.load + (i32.add + (i32.add + (get_local $20) + (i32.const 472) + ) + (i32.const 8) + ) + ) + ) + (i64.store + (i32.add + (i32.add + (get_local $20) + (i32.const 144) + ) + (i32.const 24) + ) + (i64.load + (i32.add + (i32.add + (get_local $20) + (i32.const 472) + ) + (i32.const 24) + ) + ) + ) + (i64.store offset=160 + (get_local $20) + (i64.load offset=488 + (get_local $20) + ) + ) + (i32.store + (tee_local $13 + (i32.add + (i32.add + (get_local $20) + (i32.const 144) + ) + (i32.const 40) + ) + ) + (i32.load + (i32.add + (get_local $2) + (i32.const 8) + ) + ) + ) + (i64.store offset=176 + (get_local $20) + (i64.load + (get_local $2) + ) + ) + (i32.store + (i32.add + (get_local $20) + (i32.const 504) + ) + (i32.const 0) + ) + (i32.store + (i32.add + (get_local $20) + (i32.const 508) + ) + (i32.const 0) + ) + (i32.store + (i32.add + (i32.add + (get_local $20) + (i32.const 472) + ) + (i32.const 40) + ) + (i32.const 0) + ) + (call $_ZN5eosio15dispatch_inlineIJyyNS_5assetENSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEvyyNS2_6vectorINS_16permission_levelENS6_ISA_EEEENS2_5tupleIJDpT_EEE + (get_local $16) + (i64.const -3617168760277827584) + (i32.add + (get_local $20) + (i32.const 408) + ) + (i32.add + (get_local $20) + (i32.const 144) + ) + ) + (block $label$52 + (br_if $label$52 + (i32.eqz + (i32.and + (i32.load8_u offset=176 + (get_local $20) + ) + (i32.const 1) + ) + ) + ) + (call $_ZdlPv + (i32.load + (get_local $13) + ) + ) + ) + (block $label$53 + (br_if $label$53 + (i32.eqz + (tee_local $13 + (i32.load offset=408 + (get_local $20) + ) + ) + ) + ) + (i32.store offset=412 + (get_local $20) + (get_local $13) + ) + (call $_ZdlPv + (get_local $13) + ) + ) + (block $label$54 + (br_if $label$54 + (i32.eqz + (i32.and + (i32.load8_u + (i32.add + (i32.add + (get_local $20) + (i32.const 472) + ) + (i32.const 32) + ) + ) + (i32.const 1) + ) + ) + ) + (call $_ZdlPv + (i32.load + (i32.add + (get_local $20) + (i32.const 512) + ) + ) + ) + ) + (set_local $15 + (call $current_time) + ) + (i32.store + (i32.add + (get_local $20) + (i32.const 436) + ) + (i32.const 0) + ) + (i32.store + (i32.add + (i32.add + (get_local $20) + (i32.const 408) + ) + (i32.const 32) + ) + (i32.const 0) + ) + (i32.store offset=420 + (get_local $20) + (i32.const 0) + ) + (i32.store8 offset=424 + (get_local $20) + (i32.const 0) + ) + (i32.store offset=428 + (get_local $20) + (i32.const 0) + ) + (i32.store offset=432 + (get_local $20) + (i32.const 0) + ) + (i32.store offset=408 + (get_local $20) + (i32.add + (i32.wrap/i64 + (i64.div_u + (get_local $15) + (i64.const 1000000) + ) + ) + (i32.const 60) + ) + ) + (i32.store offset=444 + (get_local $20) + (i32.const 0) + ) + (i32.store + (i32.add + (get_local $20) + (i32.const 448) + ) + (i32.const 0) + ) + (i32.store + (i32.add + (get_local $20) + (i32.const 452) + ) + (i32.const 0) + ) + (i32.store offset=456 + (get_local $20) + (i32.const 0) + ) + (i32.store + (i32.add + (get_local $20) + (i32.const 460) + ) + (i32.const 0) + ) + (i32.store + (i32.add + (get_local $20) + (i32.const 464) + ) + (i32.const 0) + ) + (set_local $1 + (i32.add + (get_local $20) + (i32.const 444) + ) + ) + (set_local $18 + (i64.load + (get_local $0) + ) + ) + (set_local $15 + (i64.const 0) + ) + (set_local $14 + (i64.const 59) + ) + (set_local $13 + (i32.const 592) + ) + (set_local $16 + (i64.const 0) + ) + (loop $label$55 + (block $label$56 + (block $label$57 + (block $label$58 + (block $label$59 + (block $label$60 + (br_if $label$60 + (i64.gt_u + (get_local $15) + (i64.const 5) + ) + ) + (br_if $label$59 + (i32.gt_u + (i32.and + (i32.add + (tee_local $2 + (i32.load8_s + (get_local $13) + ) + ) + (i32.const -97) + ) + (i32.const 255) + ) + (i32.const 25) + ) + ) + (set_local $2 + (i32.add + (get_local $2) + (i32.const 165) + ) + ) + (br $label$58) + ) + (set_local $17 + (i64.const 0) + ) + (br_if $label$57 + (i64.le_u + (get_local $15) + (i64.const 11) + ) + ) + (br $label$56) + ) + (set_local $2 + (select + (i32.add + (get_local $2) + (i32.const 208) + ) + (i32.const 0) + (i32.lt_u + (i32.and + (i32.add + (get_local $2) + (i32.const -49) + ) + (i32.const 255) + ) + (i32.const 5) + ) + ) + ) + ) + (set_local $17 + (i64.shr_s + (i64.shl + (i64.extend_u/i32 + (get_local $2) + ) + (i64.const 56) + ) + (i64.const 56) + ) + ) + ) + (set_local $17 + (i64.shl + (i64.and + (get_local $17) + (i64.const 31) + ) + (i64.and + (get_local $14) + (i64.const 4294967295) + ) + ) + ) + ) + (set_local $13 + (i32.add + (get_local $13) + (i32.const 1) + ) + ) + (set_local $15 + (i64.add + (get_local $15) + (i64.const 1) + ) + ) + (set_local $16 + (i64.or + (get_local $17) + (get_local $16) + ) + ) + (br_if $label$55 + (i64.ne + (tee_local $14 + (i64.add + (get_local $14) + (i64.const -5) + ) + ) + (i64.const -6) + ) + ) + ) + (i64.store offset=744 + (get_local $20) + (get_local $16) + ) + (i64.store offset=736 + (get_local $20) + (get_local $18) + ) + (set_local $15 + (i64.const 0) + ) + (set_local $14 + (i64.const 59) + ) + (set_local $13 + (i32.const 1088) + ) + (set_local $16 + (i64.const 0) + ) + (loop $label$61 + (block $label$62 + (block $label$63 + (block $label$64 + (block $label$65 + (block $label$66 + (br_if $label$66 + (i64.gt_u + (get_local $15) + (i64.const 10) + ) + ) + (br_if $label$65 + (i32.gt_u + (i32.and + (i32.add + (tee_local $2 + (i32.load8_s + (get_local $13) + ) + ) + (i32.const -97) + ) + (i32.const 255) + ) + (i32.const 25) + ) + ) + (set_local $2 + (i32.add + (get_local $2) + (i32.const 165) + ) + ) + (br $label$64) + ) + (set_local $17 + (i64.const 0) + ) + (br_if $label$63 + (i64.eq + (get_local $15) + (i64.const 11) + ) + ) + (br $label$62) + ) + (set_local $2 + (select + (i32.add + (get_local $2) + (i32.const 208) + ) + (i32.const 0) + (i32.lt_u + (i32.and + (i32.add + (get_local $2) + (i32.const -49) + ) + (i32.const 255) + ) + (i32.const 5) + ) + ) + ) + ) + (set_local $17 + (i64.shr_s + (i64.shl + (i64.extend_u/i32 + (get_local $2) + ) + (i64.const 56) + ) + (i64.const 56) + ) + ) + ) + (set_local $17 + (i64.shl + (i64.and + (get_local $17) + (i64.const 31) + ) + (i64.and + (get_local $14) + (i64.const 4294967295) + ) + ) + ) + ) + (set_local $13 + (i32.add + (get_local $13) + (i32.const 1) + ) + ) + (set_local $14 + (i64.add + (get_local $14) + (i64.const -5) + ) + ) + (set_local $16 + (i64.or + (get_local $17) + (get_local $16) + ) + ) + (br_if $label$61 + (i64.ne + (tee_local $15 + (i64.add + (get_local $15) + (i64.const 1) + ) + ) + (i64.const 13) + ) + ) + ) + (i64.store offset=128 + (get_local $20) + (get_local $16) + ) + (set_local $15 + (i64.const 0) + ) + (set_local $14 + (i64.const 59) + ) + (set_local $13 + (i32.const 1216) + ) + (set_local $16 + (i64.const 0) + ) + (loop $label$67 + (block $label$68 + (block $label$69 + (block $label$70 + (block $label$71 + (block $label$72 + (br_if $label$72 + (i64.gt_u + (get_local $15) + (i64.const 7) + ) + ) + (br_if $label$71 + (i32.gt_u + (i32.and + (i32.add + (tee_local $2 + (i32.load8_s + (get_local $13) + ) + ) + (i32.const -97) + ) + (i32.const 255) + ) + (i32.const 25) + ) + ) + (set_local $2 + (i32.add + (get_local $2) + (i32.const 165) + ) + ) + (br $label$70) + ) + (set_local $17 + (i64.const 0) + ) + (br_if $label$69 + (i64.le_u + (get_local $15) + (i64.const 11) + ) + ) + (br $label$68) + ) + (set_local $2 + (select + (i32.add + (get_local $2) + (i32.const 208) + ) + (i32.const 0) + (i32.lt_u + (i32.and + (i32.add + (get_local $2) + (i32.const -49) + ) + (i32.const 255) + ) + (i32.const 5) + ) + ) + ) + ) + (set_local $17 + (i64.shr_s + (i64.shl + (i64.extend_u/i32 + (get_local $2) + ) + (i64.const 56) + ) + (i64.const 56) + ) + ) + ) + (set_local $17 + (i64.shl + (i64.and + (get_local $17) + (i64.const 31) + ) + (i64.and + (get_local $14) + (i64.const 4294967295) + ) + ) + ) + ) + (set_local $13 + (i32.add + (get_local $13) + (i32.const 1) + ) + ) + (set_local $15 + (i64.add + (get_local $15) + (i64.const 1) + ) + ) + (set_local $16 + (i64.or + (get_local $17) + (get_local $16) + ) + ) + (br_if $label$67 + (i64.ne + (tee_local $14 + (i64.add + (get_local $14) + (i64.const -5) + ) + ) + (i64.const -6) + ) + ) + ) + (i64.store offset=400 + (get_local $20) + (get_local $16) + ) + (i32.store + (i32.add + (get_local $20) + (i32.const 164) + ) + (i32.load offset=572 + (get_local $20) + ) + ) + (i64.store offset=152 + (get_local $20) + (i64.load + (i32.add + (i32.add + (get_local $20) + (i32.const 656) + ) + (i32.const 40) + ) + ) + ) + (i32.store + (i32.add + (get_local $20) + (i32.const 172) + ) + (i32.load + (i32.add + (get_local $20) + (i32.const 580) + ) + ) + ) + (i32.store + (i32.add + (get_local $20) + (i32.const 168) + ) + (i32.load + (i32.add + (get_local $20) + (i32.const 576) + ) + ) + ) + (i64.store offset=144 + (get_local $20) + (get_local $18) + ) + (i32.store offset=160 + (get_local $20) + (i32.load offset=568 + (get_local $20) + ) + ) + (i32.store + (i32.add + (i32.add + (get_local $20) + (i32.const 144) + ) + (i32.const 40) + ) + (i32.const 0) + ) + (i64.store offset=176 + (get_local $20) + (i64.const 0) + ) + (set_local $2 + (i32.add + (get_local $20) + (i32.const 176) + ) + ) + (br_if $label$28 + (i32.ge_u + (tee_local $13 + (call $strlen + (i32.const 1232) + ) + ) + (i32.const -16) + ) + ) + (block $label$73 + (block $label$74 + (block $label$75 + (br_if $label$75 + (i32.ge_u + (get_local $13) + (i32.const 11) + ) + ) + (i32.store8 + (i32.add + (get_local $20) + (i32.const 176) + ) + (i32.shl + (get_local $13) + (i32.const 1) + ) + ) + (set_local $2 + (i32.add + (get_local $2) + (i32.const 1) + ) + ) + (br_if $label$74 + (get_local $13) + ) + (br $label$73) + ) + (set_local $2 + (call $_Znwj + (tee_local $10 + (i32.and + (i32.add + (get_local $13) + (i32.const 16) + ) + (i32.const -16) + ) + ) + ) + ) + (i32.store + (i32.add + (get_local $20) + (i32.const 176) + ) + (i32.or + (get_local $10) + (i32.const 1) + ) + ) + (i32.store + (i32.add + (get_local $20) + (i32.const 184) + ) + (get_local $2) + ) + (i32.store + (i32.add + (get_local $20) + (i32.const 180) + ) + (get_local $13) + ) + ) + (drop + (call $memcpy + (get_local $2) + (i32.const 1232) + (get_local $13) + ) + ) + ) + (i32.store8 + (i32.add + (get_local $2) + (get_local $13) + ) + (i32.const 0) + ) + (block $label$76 + (block $label$77 + (block $label$78 + (block $label$79 + (br_if $label$79 + (i32.ge_u + (tee_local $2 + (i32.load + (i32.add + (get_local $20) + (i32.const 448) + ) + ) + ) + (i32.load + (i32.add + (get_local $20) + (i32.const 452) + ) + ) + ) + ) + (i64.store offset=8 + (get_local $2) + (i64.load offset=400 + (get_local $20) + ) + ) + (i64.store + (get_local $2) + (i64.load offset=128 + (get_local $20) + ) + ) + (i64.store offset=16 align=4 + (get_local $2) + (i64.const 0) + ) + (i32.store + (tee_local $1 + (i32.add + (get_local $2) + (i32.const 24) + ) + ) + (i32.const 0) + ) + (i32.store offset=16 + (get_local $2) + (tee_local $13 + (call $_Znwj + (i32.const 16) + ) + ) + ) + (i32.store + (get_local $1) + (tee_local $10 + (i32.add + (get_local $13) + (i32.const 16) + ) + ) + ) + (i64.store + (i32.add + (get_local $13) + (i32.const 8) + ) + (i64.load + (i32.add + (i32.add + (get_local $20) + (i32.const 736) + ) + (i32.const 8) + ) + ) + ) + (i64.store + (get_local $13) + (i64.load offset=736 + (get_local $20) + ) + ) + (i32.store + (i32.add + (get_local $2) + (i32.const 20) + ) + (get_local $10) + ) + (i32.store offset=28 + (get_local $2) + (i32.const 0) + ) + (i32.store + (i32.add + (get_local $2) + (i32.const 32) + ) + (i32.const 0) + ) + (i32.store + (i32.add + (get_local $2) + (i32.const 36) + ) + (i32.const 0) + ) + (set_local $13 + (i32.add + (tee_local $1 + (select + (i32.load + (i32.add + (i32.add + (get_local $20) + (i32.const 144) + ) + (i32.const 36) + ) + ) + (i32.shr_u + (tee_local $13 + (i32.load8_u + (i32.add + (i32.add + (get_local $20) + (i32.const 144) + ) + (i32.const 32) + ) + ) + ) + (i32.const 1) + ) + (i32.and + (get_local $13) + (i32.const 1) + ) + ) + ) + (i32.const 32) + ) + ) + (set_local $15 + (i64.extend_u/i32 + (get_local $1) + ) + ) + (set_local $1 + (i32.add + (get_local $2) + (i32.const 28) + ) + ) + (loop $label$80 + (set_local $13 + (i32.add + (get_local $13) + (i32.const 1) + ) + ) + (br_if $label$80 + (i64.ne + (tee_local $15 + (i64.shr_u + (get_local $15) + (i64.const 7) + ) + ) + (i64.const 0) + ) + ) + ) + (br_if $label$78 + (i32.eqz + (get_local $13) + ) + ) + (call $_ZNSt3__16vectorIcNS_9allocatorIcEEE8__appendEj + (get_local $1) + (get_local $13) + ) + (set_local $1 + (i32.load + (i32.add + (get_local $2) + (i32.const 32) + ) + ) + ) + (set_local $13 + (i32.load + (i32.add + (get_local $2) + (i32.const 28) + ) + ) + ) + (br $label$77) + ) + (call $_ZNSt3__16vectorIN5eosio6actionENS_9allocatorIS2_EEE24__emplace_back_slow_pathIJNS1_16permission_levelEyyNS1_8currency8transferEEEEvDpOT_ + (get_local $1) + (i32.add + (get_local $20) + (i32.const 736) + ) + (i32.add + (get_local $20) + (i32.const 128) + ) + (i32.add + (get_local $20) + (i32.const 400) + ) + (i32.add + (get_local $20) + (i32.const 144) + ) + ) + (br $label$76) + ) + (set_local $1 + (i32.const 0) + ) + (set_local $13 + (i32.const 0) + ) + ) + (i32.store offset=788 + (get_local $20) + (get_local $13) + ) + (i32.store offset=784 + (get_local $20) + (get_local $13) + ) + (i32.store offset=792 + (get_local $20) + (get_local $1) + ) + (drop + (call $_ZN5eosiolsINS_10datastreamIPcEEEERT_S5_RKNS_8currency8transferE + (i32.add + (get_local $20) + (i32.const 784) + ) + (i32.add + (get_local $20) + (i32.const 144) + ) + ) + ) + (i32.store + (tee_local $13 + (i32.add + (i32.add + (get_local $20) + (i32.const 408) + ) + (i32.const 40) + ) + ) + (i32.add + (i32.load + (get_local $13) + ) + (i32.const 40) + ) + ) + ) + (block $label$81 + (br_if $label$81 + (i32.eqz + (i32.and + (i32.load8_u + (i32.add + (get_local $20) + (i32.const 176) + ) + ) + (i32.const 1) + ) + ) + ) + (call $_ZdlPv + (i32.load + (i32.add + (get_local $20) + (i32.const 184) + ) + ) + ) + ) + (i32.store + (i32.add + (get_local $20) + (i32.const 428) + ) + (i32.const 1) + ) + (i64.store offset=152 + (get_local $20) + (i64.const 0) + ) + (i64.store offset=144 + (get_local $20) + (i64.load + (i32.add + (get_local $20) + (i32.const 696) + ) + ) + ) + (set_local $15 + (i64.load + (get_local $0) + ) + ) + (call $_ZN5eosio4packINS_11transactionEEENSt3__16vectorIcNS2_9allocatorIcEEEERKT_ + (i32.add + (get_local $20) + (i32.const 736) + ) + (i32.add + (get_local $20) + (i32.const 408) + ) + ) + (call $send_deferred + (i32.add + (get_local $20) + (i32.const 144) + ) + (get_local $15) + (tee_local $13 + (i32.load offset=736 + (get_local $20) + ) + ) + (i32.sub + (i32.load offset=740 + (get_local $20) + ) + (get_local $13) + ) + (i32.const 0) + ) + (block $label$82 + (br_if $label$82 + (i32.eqz + (tee_local $13 + (i32.load offset=736 + (get_local $20) + ) + ) + ) + ) + (i32.store offset=740 + (get_local $20) + (get_local $13) + ) + (call $_ZdlPv + (get_local $13) + ) + ) + (block $label$83 + (br_if $label$83 + (i64.eqz + (i64.load offset=728 + (get_local $20) + ) + ) + ) + (set_local $15 + (i64.load + (i32.add + (get_local $0) + (i32.const 64) + ) + ) + ) + (i64.store offset=8 + (get_local $20) + (i64.load offset=720 + (get_local $20) + ) + ) + (i64.store + (get_local $20) + (get_local $15) + ) + (drop + (call $sprintf + (i32.add + (get_local $20) + (i32.const 144) + ) + (i32.const 1264) + (get_local $20) + ) + ) + (i32.store + (i32.add + (get_local $20) + (i32.const 136) + ) + (i32.const 0) + ) + (i64.store offset=128 + (get_local $20) + (i64.const 0) + ) + (br_if $label$27 + (i32.ge_u + (tee_local $13 + (call $strlen + (i32.add + (get_local $20) + (i32.const 144) + ) + ) + ) + (i32.const -16) + ) + ) + (block $label$84 + (block $label$85 + (block $label$86 + (br_if $label$86 + (i32.ge_u + (get_local $13) + (i32.const 11) + ) + ) + (i32.store8 offset=128 + (get_local $20) + (i32.shl + (get_local $13) + (i32.const 1) + ) + ) + (set_local $2 + (i32.or + (i32.add + (get_local $20) + (i32.const 128) + ) + (i32.const 1) + ) + ) + (br_if $label$85 + (get_local $13) + ) + (br $label$84) + ) + (set_local $2 + (call $_Znwj + (tee_local $1 + (i32.and + (i32.add + (get_local $13) + (i32.const 16) + ) + (i32.const -16) + ) + ) + ) + ) + (i32.store offset=128 + (get_local $20) + (i32.or + (get_local $1) + (i32.const 1) + ) + ) + (i32.store offset=136 + (get_local $20) + (get_local $2) + ) + (i32.store offset=132 + (get_local $20) + (get_local $13) + ) + ) + (drop + (call $memcpy + (get_local $2) + (i32.add + (get_local $20) + (i32.const 144) + ) + (get_local $13) + ) + ) + ) + (i32.store8 + (i32.add + (get_local $2) + (get_local $13) + ) + (i32.const 0) + ) + (set_local $15 + (i64.const 0) + ) + (set_local $14 + (i64.const 59) + ) + (set_local $13 + (i32.const 1088) + ) + (set_local $16 + (i64.const 0) + ) + (loop $label$87 + (block $label$88 + (block $label$89 + (block $label$90 + (block $label$91 + (block $label$92 + (br_if $label$92 + (i64.gt_u + (get_local $15) + (i64.const 10) + ) + ) + (br_if $label$91 + (i32.gt_u + (i32.and + (i32.add + (tee_local $2 + (i32.load8_s + (get_local $13) + ) + ) + (i32.const -97) + ) + (i32.const 255) + ) + (i32.const 25) + ) + ) + (set_local $2 + (i32.add + (get_local $2) + (i32.const 165) + ) + ) + (br $label$90) + ) + (set_local $17 + (i64.const 0) + ) + (br_if $label$89 + (i64.eq + (get_local $15) + (i64.const 11) + ) + ) + (br $label$88) + ) + (set_local $2 + (select + (i32.add + (get_local $2) + (i32.const 208) + ) + (i32.const 0) + (i32.lt_u + (i32.and + (i32.add + (get_local $2) + (i32.const -49) + ) + (i32.const 255) + ) + (i32.const 5) + ) + ) + ) + ) + (set_local $17 + (i64.shr_s + (i64.shl + (i64.extend_u/i32 + (get_local $2) + ) + (i64.const 56) + ) + (i64.const 56) + ) + ) + ) + (set_local $17 + (i64.shl + (i64.and + (get_local $17) + (i64.const 31) + ) + (i64.and + (get_local $14) + (i64.const 4294967295) + ) + ) + ) + ) + (set_local $13 + (i32.add + (get_local $13) + (i32.const 1) + ) + ) + (set_local $14 + (i64.add + (get_local $14) + (i64.const -5) + ) + ) + (set_local $16 + (i64.or + (get_local $17) + (get_local $16) + ) + ) + (br_if $label$87 + (i64.ne + (tee_local $15 + (i64.add + (get_local $15) + (i64.const 1) + ) + ) + (i64.const 13) + ) + ) + ) + (set_local $19 + (i64.load + (get_local $0) + ) + ) + (set_local $15 + (i64.const 0) + ) + (set_local $14 + (i64.const 59) + ) + (set_local $13 + (i32.const 592) + ) + (set_local $18 + (i64.const 0) + ) + (loop $label$93 + (block $label$94 + (block $label$95 + (block $label$96 + (block $label$97 + (block $label$98 + (br_if $label$98 + (i64.gt_u + (get_local $15) + (i64.const 5) + ) + ) + (br_if $label$97 + (i32.gt_u + (i32.and + (i32.add + (tee_local $2 + (i32.load8_s + (get_local $13) + ) + ) + (i32.const -97) + ) + (i32.const 255) + ) + (i32.const 25) + ) + ) + (set_local $2 + (i32.add + (get_local $2) + (i32.const 165) + ) + ) + (br $label$96) + ) + (set_local $17 + (i64.const 0) + ) + (br_if $label$95 + (i64.le_u + (get_local $15) + (i64.const 11) + ) + ) + (br $label$94) + ) + (set_local $2 + (select + (i32.add + (get_local $2) + (i32.const 208) + ) + (i32.const 0) + (i32.lt_u + (i32.and + (i32.add + (get_local $2) + (i32.const -49) + ) + (i32.const 255) + ) + (i32.const 5) + ) + ) + ) + ) + (set_local $17 + (i64.shr_s + (i64.shl + (i64.extend_u/i32 + (get_local $2) + ) + (i64.const 56) + ) + (i64.const 56) + ) + ) + ) + (set_local $17 + (i64.shl + (i64.and + (get_local $17) + (i64.const 31) + ) + (i64.and + (get_local $14) + (i64.const 4294967295) + ) + ) + ) + ) + (set_local $13 + (i32.add + (get_local $13) + (i32.const 1) + ) + ) + (set_local $15 + (i64.add + (get_local $15) + (i64.const 1) + ) + ) + (set_local $18 + (i64.or + (get_local $17) + (get_local $18) + ) + ) + (br_if $label$93 + (i64.ne + (tee_local $14 + (i64.add + (get_local $14) + (i64.const -5) + ) + ) + (i64.const -6) + ) + ) + ) + (i64.store + (tee_local $2 + (i32.add + (i32.add + (get_local $20) + (i32.const 80) + ) + (i32.const 24) + ) + ) + (get_local $3) + ) + (i64.store offset=80 + (get_local $20) + (get_local $19) + ) + (i64.store offset=96 + (get_local $20) + (get_local $4) + ) + (i64.store offset=88 + (get_local $20) + (i64.load + (i32.add + (get_local $20) + (i32.const 728) + ) + ) + ) + (drop + (call $_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEC2ERKS5_ + (i32.add + (get_local $20) + (i32.const 112) + ) + (i32.add + (get_local $20) + (i32.const 128) + ) + ) + ) + (i64.store + (tee_local $13 + (call $_Znwj + (i32.const 16) + ) + ) + (get_local $19) + ) + (i64.store offset=8 + (get_local $13) + (get_local $18) + ) + (i32.store offset=784 + (get_local $20) + (get_local $13) + ) + (i32.store offset=792 + (get_local $20) + (tee_local $13 + (i32.add + (get_local $13) + (i32.const 16) + ) + ) + ) + (i32.store offset=788 + (get_local $20) + (get_local $13) + ) + (i64.store offset=736 + (get_local $20) + (i64.load offset=80 + (get_local $20) + ) + ) + (i64.store offset=744 + (get_local $20) + (i64.load offset=88 + (get_local $20) + ) + ) + (i64.store + (i32.add + (i32.add + (get_local $20) + (i32.const 736) + ) + (i32.const 24) + ) + (i64.load + (get_local $2) + ) + ) + (i64.store offset=752 + (get_local $20) + (i64.load offset=96 + (get_local $20) + ) + ) + (i32.store + (tee_local $2 + (i32.add + (i32.add + (get_local $20) + (i32.const 736) + ) + (i32.const 40) + ) + ) + (i32.load + (tee_local $13 + (i32.add + (i32.add + (get_local $20) + (i32.const 80) + ) + (i32.const 40) + ) + ) + ) + ) + (i64.store offset=768 + (get_local $20) + (i64.load offset=112 + (get_local $20) + ) + ) + (i32.store offset=112 + (get_local $20) + (i32.const 0) + ) + (i32.store + (i32.add + (get_local $20) + (i32.const 116) + ) + (i32.const 0) + ) + (i32.store + (get_local $13) + (i32.const 0) + ) + (call $_ZN5eosio15dispatch_inlineIJyyNS_5assetENSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEvyyNS2_6vectorINS_16permission_levelENS6_ISA_EEEENS2_5tupleIJDpT_EEE + (get_local $16) + (i64.const -3617168760277827584) + (i32.add + (get_local $20) + (i32.const 784) + ) + (i32.add + (get_local $20) + (i32.const 736) + ) + ) + (block $label$99 + (br_if $label$99 + (i32.eqz + (i32.and + (i32.load8_u offset=768 + (get_local $20) + ) + (i32.const 1) + ) + ) + ) + (call $_ZdlPv + (i32.load + (get_local $2) + ) + ) + ) + (block $label$100 + (br_if $label$100 + (i32.eqz + (tee_local $13 + (i32.load offset=784 + (get_local $20) + ) + ) + ) + ) + (i32.store offset=788 + (get_local $20) + (get_local $13) + ) + (call $_ZdlPv + (get_local $13) + ) + ) + (block $label$101 + (br_if $label$101 + (i32.eqz + (i32.and + (i32.load8_u + (i32.add + (get_local $20) + (i32.const 112) + ) + ) + (i32.const 1) + ) + ) + ) + (call $_ZdlPv + (i32.load + (i32.add + (get_local $20) + (i32.const 120) + ) + ) + ) + ) + (br_if $label$83 + (i32.eqz + (i32.and + (i32.load8_u offset=128 + (get_local $20) + ) + (i32.const 1) + ) + ) + ) + (call $_ZdlPv + (i32.load offset=136 + (get_local $20) + ) + ) + ) + (set_local $17 + (i64.load + (get_local $0) + ) + ) + (call $eosio_assert + (i64.eq + (i64.load offset=184 + (get_local $0) + ) + (call $current_receiver) + ) + (i32.const 336) + ) + (set_local $2 + (call $_ZN6eoswin13roundfee_itemC2Ev + (tee_local $13 + (call $_Znwj + (i32.const 88) + ) + ) + ) + ) + (i32.store offset=72 + (get_local $13) + (i32.add + (get_local $0) + (i32.const 184) + ) + ) + (i64.store offset=8 + (get_local $13) + (get_local $6) + ) + (i64.store offset=16 + (get_local $13) + (get_local $5) + ) + (i64.store offset=24 + (get_local $13) + (get_local $7) + ) + (i64.store offset=32 + (get_local $13) + (get_local $12) + ) + (i64.store + (get_local $13) + (i64.load + (i32.add + (get_local $0) + (i32.const 64) + ) + ) + ) + (i32.store + (i32.add + (get_local $13) + (i32.const 52) + ) + (i32.load + (i32.add + (get_local $20) + (i32.const 580) + ) + ) + ) + (i32.store + (i32.add + (get_local $13) + (i32.const 48) + ) + (i32.load + (i32.add + (get_local $20) + (i32.const 576) + ) + ) + ) + (i64.store offset=40 + (get_local $13) + (i64.load offset=568 + (get_local $20) + ) + ) + (i64.store offset=56 + (get_local $13) + (get_local $4) + ) + (i64.store offset=64 + (get_local $13) + (get_local $3) + ) + (i32.store offset=744 + (get_local $20) + (i32.add + (i32.add + (get_local $20) + (i32.const 144) + ) + (i32.const 72) + ) + ) + (i32.store offset=740 + (get_local $20) + (i32.add + (get_local $20) + (i32.const 144) + ) + ) + (i32.store offset=736 + (get_local $20) + (i32.add + (get_local $20) + (i32.const 144) + ) + ) + (drop + (call $_ZN6eoswinlsIN5eosio10datastreamIPcEEEERT_S6_RKNS_13roundfee_itemE + (i32.add + (get_local $20) + (i32.const 736) + ) + (get_local $2) + ) + ) + (i32.store offset=76 + (get_local $13) + (tee_local $1 + (call $db_store_i64 + (i64.load + (i32.add + (get_local $0) + (i32.const 192) + ) + ) + (i64.const -4812882707900006400) + (get_local $17) + (tee_local $15 + (i64.load + (get_local $13) + ) + ) + (i32.add + (get_local $20) + (i32.const 144) + ) + (i32.const 72) + ) + ) + ) + (block $label$102 + (br_if $label$102 + (i64.lt_u + (get_local $15) + (i64.load + (tee_local $2 + (i32.add + (get_local $0) + (i32.const 200) + ) + ) + ) + ) + ) + (i64.store + (get_local $2) + (select + (i64.const -2) + (i64.add + (get_local $15) + (i64.const 1) + ) + (i64.gt_u + (get_local $15) + (i64.const -3) + ) + ) + ) + ) + (i32.store offset=736 + (get_local $20) + (get_local $13) + ) + (i64.store offset=144 + (get_local $20) + (tee_local $15 + (i64.load + (get_local $13) + ) + ) + ) + (i32.store offset=784 + (get_local $20) + (get_local $1) + ) + (block $label$103 + (block $label$104 + (br_if $label$104 + (i32.ge_u + (tee_local $2 + (i32.load + (tee_local $10 + (i32.add + (get_local $0) + (i32.const 212) + ) + ) + ) + ) + (i32.load + (i32.add + (get_local $0) + (i32.const 216) + ) + ) + ) + ) + (i64.store offset=8 + (get_local $2) + (get_local $15) + ) + (i32.store offset=16 + (get_local $2) + (get_local $1) + ) + (i32.store offset=736 + (get_local $20) + (i32.const 0) + ) + (i32.store + (get_local $2) + (get_local $13) + ) + (i32.store + (get_local $10) + (i32.add + (get_local $2) + (i32.const 24) + ) + ) + (br $label$103) + ) + (call $_ZNSt3__16vectorIN5eosio11multi_indexILy13633861365809545216EN6eoswin13roundfee_itemEJEE8item_ptrENS_9allocatorIS6_EEE24__emplace_back_slow_pathIJNS_10unique_ptrINS5_4itemENS_14default_deleteISC_EEEERyRlEEEvDpOT_ + (i32.add + (get_local $0) + (i32.const 208) + ) + (i32.add + (get_local $20) + (i32.const 736) + ) + (i32.add + (get_local $20) + (i32.const 144) + ) + (i32.add + (get_local $20) + (i32.const 784) + ) + ) + ) + (set_local $13 + (i32.load offset=736 + (get_local $20) + ) + ) + (i32.store offset=736 + (get_local $20) + (i32.const 0) + ) + (block $label$105 + (br_if $label$105 + (i32.eqz + (get_local $13) + ) + ) + (call $_ZdlPv + (get_local $13) + ) + ) + (drop + (call $_ZN5eosio11transactionD2Ev + (i32.add + (get_local $20) + (i32.const 408) + ) + ) + ) + (block $label$106 + (br_if $label$106 + (i32.eqz + (tee_local $1 + (i32.load offset=624 + (get_local $20) + ) + ) + ) + ) + (block $label$107 + (block $label$108 + (br_if $label$108 + (i32.eq + (tee_local $13 + (i32.load + (tee_local $0 + (i32.add + (get_local $20) + (i32.const 628) + ) + ) + ) + ) + (get_local $1) + ) + ) + (loop $label$109 + (set_local $2 + (i32.load + (tee_local $13 + (i32.add + (get_local $13) + (i32.const -24) + ) + ) + ) + ) + (i32.store + (get_local $13) + (i32.const 0) + ) + (block $label$110 + (br_if $label$110 + (i32.eqz + (get_local $2) + ) + ) + (call $_ZdlPv + (get_local $2) + ) + ) + (br_if $label$109 + (i32.ne + (get_local $1) + (get_local $13) + ) + ) + ) + (set_local $13 + (i32.load + (i32.add + (get_local $20) + (i32.const 624) + ) + ) + ) + (br $label$107) + ) + (set_local $13 + (get_local $1) + ) + ) + (i32.store + (get_local $0) + (get_local $1) + ) + (call $_ZdlPv + (get_local $13) + ) + ) + (i32.store offset=4 + (i32.const 0) + (i32.add + (get_local $20) + (i32.const 800) + ) + ) + (return) + ) + (call $_ZNKSt3__121__basic_string_commonILb1EE20__throw_length_errorEv + (get_local $2) + ) + (unreachable) + ) + (call $_ZNKSt3__121__basic_string_commonILb1EE20__throw_length_errorEv + (get_local $2) + ) + (unreachable) + ) + (call $_ZNKSt3__121__basic_string_commonILb1EE20__throw_length_errorEv + (get_local $2) + ) + (unreachable) + ) + (call $_ZNKSt3__121__basic_string_commonILb1EE20__throw_length_errorEv + (i32.add + (get_local $20) + (i32.const 128) + ) + ) + (unreachable) + ) + (func $_ZNK5eosio11multi_indexILy13633861583611363328EN6eoswin10round_itemEJEE3getEyPKc (param $0 i32) (param $1 i64) (param $2 i32) (result i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (block $label$0 + (br_if $label$0 + (i32.eq + (tee_local $7 + (i32.load + (i32.add + (get_local $0) + (i32.const 28) + ) + ) + ) + (tee_local $3 + (i32.load offset=24 + (get_local $0) + ) + ) + ) + ) + (set_local $6 + (i32.add + (get_local $7) + (i32.const -24) + ) + ) + (set_local $4 + (i32.sub + (i32.const 0) + (get_local $3) + ) + ) + (loop $label$1 + (br_if $label$0 + (i64.eq + (i64.load + (i32.load + (get_local $6) + ) + ) + (get_local $1) + ) + ) + (set_local $7 + (get_local $6) + ) + (set_local $6 + (tee_local $5 + (i32.add + (get_local $6) + (i32.const -24) + ) + ) + ) + (br_if $label$1 + (i32.ne + (i32.add + (get_local $5) + (get_local $4) + ) + (i32.const -24) + ) + ) + ) + ) + (block $label$2 + (block $label$3 + (br_if $label$3 + (i32.eq + (get_local $7) + (get_local $3) + ) + ) + (call $eosio_assert + (i32.eq + (i32.load offset=80 + (tee_local $6 + (i32.load + (i32.add + (get_local $7) + (i32.const -24) + ) + ) + ) + ) + (get_local $0) + ) + (i32.const 32) + ) + (br $label$2) + ) + (set_local $6 + (i32.const 0) + ) + (br_if $label$2 + (i32.lt_s + (tee_local $5 + (call $db_find_i64 + (i64.load + (get_local $0) + ) + (i64.load offset=8 + (get_local $0) + ) + (i64.const -4812882490098188288) + (get_local $1) + ) + ) + (i32.const 0) + ) + ) + (call $eosio_assert + (i32.eq + (i32.load offset=80 + (tee_local $6 + (call $_ZNK5eosio11multi_indexILy13633861583611363328EN6eoswin10round_itemEJEE31load_object_by_primary_iteratorEl + (get_local $0) + (get_local $5) + ) + ) + ) + (get_local $0) + ) + (i32.const 32) + ) + ) + (call $eosio_assert + (i32.ne + (get_local $6) + (i32.const 0) + ) + (get_local $2) + ) + (get_local $6) + ) + (func $_ZNK5eosio11multi_indexILy4297309255767162880EN6eoswin9bill_itemEJNS_10indexed_byILy4587782057278570496EN5boost11multi_index13const_mem_funIS2_yXadL_ZNKS2_8byplayerEvEEEEEEEE5indexILy4587782057278570496ES7_Ly0ELb0EE11lower_boundERKy (param $0 i32) (param $1 i32) (param $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 i64) + (local $6 i32) + (local $7 i32) + (local $8 i32) + (local $9 i32) + (local $10 i32) + (i32.store offset=4 + (i32.const 0) + (tee_local $10 + (i32.sub + (i32.load offset=4 + (i32.const 0) + ) + (i32.const 16) + ) + ) + ) + (i64.store offset=8 + (get_local $10) + (i64.const 0) + ) + (i64.store + (get_local $10) + (i64.load + (get_local $2) + ) + ) + (set_local $2 + (i32.const 0) + ) + (block $label$0 + (br_if $label$0 + (i32.lt_s + (tee_local $3 + (call $db_idx64_lowerbound + (i64.load + (tee_local $8 + (i32.load + (get_local $1) + ) + ) + ) + (i64.load offset=8 + (get_local $8) + ) + (i64.const 4297309255767162880) + (get_local $10) + (i32.add + (get_local $10) + (i32.const 8) + ) + ) + ) + (i32.const 0) + ) + ) + (set_local $5 + (i64.load offset=8 + (get_local $10) + ) + ) + (block $label$1 + (br_if $label$1 + (i32.eq + (tee_local $9 + (i32.load + (i32.add + (tee_local $4 + (i32.load + (get_local $1) + ) + ) + (i32.const 28) + ) + ) + ) + (tee_local $6 + (i32.load offset=24 + (get_local $4) + ) + ) + ) + ) + (set_local $2 + (i32.add + (get_local $9) + (i32.const -24) + ) + ) + (set_local $7 + (i32.sub + (i32.const 0) + (get_local $6) + ) + ) + (loop $label$2 + (br_if $label$1 + (i64.eq + (i64.load + (i32.load + (get_local $2) + ) + ) + (get_local $5) + ) + ) + (set_local $9 + (get_local $2) + ) + (set_local $2 + (tee_local $8 + (i32.add + (get_local $2) + (i32.const -24) + ) + ) + ) + (br_if $label$2 + (i32.ne + (i32.add + (get_local $8) + (get_local $7) + ) + (i32.const -24) + ) + ) + ) + ) + (block $label$3 + (block $label$4 + (br_if $label$4 + (i32.eq + (get_local $9) + (get_local $6) + ) + ) + (call $eosio_assert + (i32.eq + (i32.load offset=64 + (tee_local $2 + (i32.load + (i32.add + (get_local $9) + (i32.const -24) + ) + ) + ) + ) + (get_local $4) + ) + (i32.const 32) + ) + (br $label$3) + ) + (call $eosio_assert + (i32.eq + (i32.load offset=64 + (tee_local $2 + (call $_ZNK5eosio11multi_indexILy4297309255767162880EN6eoswin9bill_itemEJNS_10indexed_byILy4587782057278570496EN5boost11multi_index13const_mem_funIS2_yXadL_ZNKS2_8byplayerEvEEEEEEEE31load_object_by_primary_iteratorEl + (get_local $4) + (call $db_find_i64 + (i64.load + (get_local $4) + ) + (i64.load offset=8 + (get_local $4) + ) + (i64.const 4297309255767162880) + (get_local $5) + ) + ) + ) + ) + (get_local $4) + ) + (i32.const 32) + ) + ) + (i32.store + (i32.add + (get_local $2) + (i32.const 72) + ) + (get_local $3) + ) + ) + (i32.store offset=4 + (get_local $0) + (get_local $2) + ) + (i32.store + (get_local $0) + (get_local $1) + ) + (i32.store offset=4 + (i32.const 0) + (i32.add + (get_local $10) + (i32.const 16) + ) + ) + ) + (func $_ZN5eosio11multi_indexILy4297309255767162880EN6eoswin9bill_itemEJNS_10indexed_byILy4587782057278570496EN5boost11multi_index13const_mem_funIS2_yXadL_ZNKS2_8byplayerEvEEEEEEEE5indexILy4587782057278570496ES7_Ly0ELb0EE14const_iteratorppEv (param $0 i32) (result i32) + (local $1 i32) + (local $2 i32) + (local $3 i64) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (local $8 i32) + (local $9 i32) + (i32.store offset=4 + (i32.const 0) + (tee_local $9 + (i32.sub + (i32.load offset=4 + (i32.const 0) + ) + (i32.const 16) + ) + ) + ) + (call $eosio_assert + (i32.ne + (i32.load offset=4 + (get_local $0) + ) + (i32.const 0) + ) + (i32.const 1344) + ) + (block $label$0 + (br_if $label$0 + (i32.ne + (tee_local $7 + (i32.load offset=72 + (tee_local $6 + (i32.load offset=4 + (get_local $0) + ) + ) + ) + ) + (i32.const -1) + ) + ) + (set_local $7 + (call $db_idx64_find_primary + (i64.load + (tee_local $7 + (i32.load + (i32.load + (get_local $0) + ) + ) + ) + ) + (i64.load offset=8 + (get_local $7) + ) + (i64.const 4297309255767162880) + (i32.add + (get_local $9) + (i32.const 8) + ) + (i64.load + (get_local $6) + ) + ) + ) + (i32.store offset=72 + (i32.load + (i32.add + (get_local $0) + (i32.const 4) + ) + ) + (get_local $7) + ) + ) + (i64.store offset=8 + (get_local $9) + (i64.const 0) + ) + (block $label$1 + (block $label$2 + (block $label$3 + (block $label$4 + (br_if $label$4 + (i32.le_s + (tee_local $1 + (call $db_idx64_next + (get_local $7) + (i32.add + (get_local $9) + (i32.const 8) + ) + ) + ) + (i32.const -1) + ) + ) + (set_local $3 + (i64.load offset=8 + (get_local $9) + ) + ) + (block $label$5 + (br_if $label$5 + (i32.eq + (tee_local $8 + (i32.load + (i32.add + (tee_local $2 + (i32.load + (i32.load + (get_local $0) + ) + ) + ) + (i32.const 28) + ) + ) + ) + (tee_local $4 + (i32.load offset=24 + (get_local $2) + ) + ) + ) + ) + (set_local $7 + (i32.add + (get_local $8) + (i32.const -24) + ) + ) + (set_local $5 + (i32.sub + (i32.const 0) + (get_local $4) + ) + ) + (loop $label$6 + (br_if $label$5 + (i64.eq + (i64.load + (i32.load + (get_local $7) + ) + ) + (get_local $3) + ) + ) + (set_local $8 + (get_local $7) + ) + (set_local $7 + (tee_local $6 + (i32.add + (get_local $7) + (i32.const -24) + ) + ) + ) + (br_if $label$6 + (i32.ne + (i32.add + (get_local $6) + (get_local $5) + ) + (i32.const -24) + ) + ) + ) + ) + (br_if $label$3 + (i32.eq + (get_local $8) + (get_local $4) + ) + ) + (call $eosio_assert + (i32.eq + (i32.load offset=64 + (tee_local $7 + (i32.load + (i32.add + (get_local $8) + (i32.const -24) + ) + ) + ) + ) + (get_local $2) + ) + (i32.const 32) + ) + (br $label$2) + ) + (i32.store + (i32.add + (get_local $0) + (i32.const 4) + ) + (i32.const 0) + ) + (br $label$1) + ) + (call $eosio_assert + (i32.eq + (i32.load offset=64 + (tee_local $7 + (call $_ZNK5eosio11multi_indexILy4297309255767162880EN6eoswin9bill_itemEJNS_10indexed_byILy4587782057278570496EN5boost11multi_index13const_mem_funIS2_yXadL_ZNKS2_8byplayerEvEEEEEEEE31load_object_by_primary_iteratorEl + (get_local $2) + (call $db_find_i64 + (i64.load + (get_local $2) + ) + (i64.load offset=8 + (get_local $2) + ) + (i64.const 4297309255767162880) + (get_local $3) + ) + ) + ) + ) + (get_local $2) + ) + (i32.const 32) + ) + ) + (i32.store + (i32.add + (get_local $0) + (i32.const 4) + ) + (get_local $7) + ) + (i32.store + (i32.add + (get_local $7) + (i32.const 72) + ) + (get_local $1) + ) + ) + (i32.store offset=4 + (i32.const 0) + (i32.add + (get_local $9) + (i32.const 16) + ) + ) + (get_local $0) + ) + (func $_ZN5eosiolsINS_10datastreamIPcEEEERT_S5_RKNS_8currency8transferE (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + (call $eosio_assert + (i32.gt_s + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (i32.load offset=4 + (get_local $0) + ) + ) + (i32.const 7) + ) + (i32.const 400) + ) + (drop + (call $memcpy + (i32.load offset=4 + (get_local $0) + ) + (get_local $1) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $0) + (tee_local $2 + (i32.add + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + ) + (call $eosio_assert + (i32.gt_s + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (get_local $2) + ) + (i32.const 7) + ) + (i32.const 400) + ) + (drop + (call $memcpy + (i32.load offset=4 + (get_local $0) + ) + (i32.add + (get_local $1) + (i32.const 8) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $0) + (tee_local $2 + (i32.add + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + ) + (call $eosio_assert + (i32.gt_s + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (get_local $2) + ) + (i32.const 7) + ) + (i32.const 400) + ) + (drop + (call $memcpy + (i32.load offset=4 + (get_local $0) + ) + (i32.add + (get_local $1) + (i32.const 16) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $0) + (tee_local $2 + (i32.add + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + ) + (call $eosio_assert + (i32.gt_s + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (get_local $2) + ) + (i32.const 7) + ) + (i32.const 400) + ) + (drop + (call $memcpy + (i32.load offset=4 + (get_local $0) + ) + (i32.add + (get_local $1) + (i32.const 24) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $0) + (i32.add + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + (call $_ZN5eosiolsINS_10datastreamIPcEEEERT_S5_RKNSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEE + (get_local $0) + (i32.add + (get_local $1) + (i32.const 32) + ) + ) + ) + (func $_ZNSt3__16vectorIN5eosio6actionENS_9allocatorIS2_EEE24__emplace_back_slow_pathIJNS1_16permission_levelEyyNS1_8currency8transferEEEEvDpOT_ (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) (param $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (local $8 i64) + (local $9 i32) + (local $10 i32) + (i32.store offset=4 + (i32.const 0) + (tee_local $10 + (i32.sub + (i32.load offset=4 + (i32.const 0) + ) + (i32.const 16) + ) + ) + ) + (block $label$0 + (block $label$1 + (br_if $label$1 + (i32.ge_u + (tee_local $6 + (i32.add + (tee_local $5 + (i32.div_s + (i32.sub + (i32.load offset=4 + (get_local $0) + ) + (tee_local $9 + (i32.load + (get_local $0) + ) + ) + ) + (i32.const 40) + ) + ) + (i32.const 1) + ) + ) + (i32.const 107374183) + ) + ) + (set_local $7 + (i32.const 107374182) + ) + (block $label$2 + (block $label$3 + (br_if $label$3 + (i32.gt_u + (tee_local $9 + (i32.div_s + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (get_local $9) + ) + (i32.const 40) + ) + ) + (i32.const 53687090) + ) + ) + (br_if $label$2 + (i32.eqz + (tee_local $7 + (select + (get_local $6) + (tee_local $9 + (i32.shl + (get_local $9) + (i32.const 1) + ) + ) + (i32.lt_u + (get_local $9) + (get_local $6) + ) + ) + ) + ) + ) + ) + (set_local $6 + (call $_Znwj + (i32.mul + (get_local $7) + (i32.const 40) + ) + ) + ) + (br $label$0) + ) + (set_local $7 + (i32.const 0) + ) + (set_local $6 + (i32.const 0) + ) + (br $label$0) + ) + (call $_ZNKSt3__120__vector_base_commonILb1EE20__throw_length_errorEv + (get_local $0) + ) + (unreachable) + ) + (i64.store + (tee_local $9 + (i32.add + (get_local $6) + (i32.mul + (get_local $5) + (i32.const 40) + ) + ) + ) + (i64.load + (get_local $2) + ) + ) + (i64.store offset=8 + (get_local $9) + (i64.load + (get_local $3) + ) + ) + (i64.store offset=16 align=4 + (get_local $9) + (i64.const 0) + ) + (i32.store + (tee_local $3 + (i32.add + (get_local $9) + (i32.const 24) + ) + ) + (i32.const 0) + ) + (i32.store offset=16 + (get_local $9) + (tee_local $2 + (call $_Znwj + (i32.const 16) + ) + ) + ) + (i32.store + (get_local $3) + (tee_local $5 + (i32.add + (get_local $2) + (i32.const 16) + ) + ) + ) + (i32.store + (i32.add + (get_local $2) + (i32.const 12) + ) + (i32.load + (i32.add + (get_local $1) + (i32.const 12) + ) + ) + ) + (i32.store + (i32.add + (get_local $2) + (i32.const 8) + ) + (i32.load + (i32.add + (get_local $1) + (i32.const 8) + ) + ) + ) + (i32.store + (i32.add + (get_local $2) + (i32.const 4) + ) + (i32.load + (i32.add + (get_local $1) + (i32.const 4) + ) + ) + ) + (i32.store + (get_local $2) + (i32.load + (get_local $1) + ) + ) + (i32.store + (i32.add + (get_local $9) + (i32.const 20) + ) + (get_local $5) + ) + (i32.store offset=28 + (get_local $9) + (i32.const 0) + ) + (i32.store + (tee_local $5 + (i32.add + (get_local $9) + (i32.const 32) + ) + ) + (i32.const 0) + ) + (i32.store + (i32.add + (get_local $9) + (i32.const 36) + ) + (i32.const 0) + ) + (set_local $2 + (i32.add + (tee_local $1 + (select + (i32.load + (i32.add + (get_local $4) + (i32.const 36) + ) + ) + (i32.shr_u + (tee_local $2 + (i32.load8_u offset=32 + (get_local $4) + ) + ) + (i32.const 1) + ) + (i32.and + (get_local $2) + (i32.const 1) + ) + ) + ) + (i32.const 32) + ) + ) + (set_local $8 + (i64.extend_u/i32 + (get_local $1) + ) + ) + (set_local $3 + (i32.add + (get_local $6) + (i32.mul + (get_local $7) + (i32.const 40) + ) + ) + ) + (set_local $1 + (i32.add + (get_local $9) + (i32.const 28) + ) + ) + (loop $label$4 + (set_local $2 + (i32.add + (get_local $2) + (i32.const 1) + ) + ) + (br_if $label$4 + (i64.ne + (tee_local $8 + (i64.shr_u + (get_local $8) + (i64.const 7) + ) + ) + (i64.const 0) + ) + ) + ) + (block $label$5 + (block $label$6 + (br_if $label$6 + (i32.eqz + (get_local $2) + ) + ) + (call $_ZNSt3__16vectorIcNS_9allocatorIcEEE8__appendEj + (get_local $1) + (get_local $2) + ) + (set_local $7 + (i32.load + (get_local $5) + ) + ) + (set_local $2 + (i32.load + (get_local $1) + ) + ) + (br $label$5) + ) + (set_local $7 + (i32.const 0) + ) + (set_local $2 + (i32.const 0) + ) + ) + (i32.store offset=4 + (get_local $10) + (get_local $2) + ) + (i32.store + (get_local $10) + (get_local $2) + ) + (i32.store offset=8 + (get_local $10) + (get_local $7) + ) + (drop + (call $_ZN5eosiolsINS_10datastreamIPcEEEERT_S5_RKNS_8currency8transferE + (get_local $10) + (get_local $4) + ) + ) + (set_local $5 + (i32.add + (get_local $9) + (i32.const 40) + ) + ) + (block $label$7 + (block $label$8 + (br_if $label$8 + (i32.eq + (tee_local $1 + (i32.load + (i32.add + (get_local $0) + (i32.const 4) + ) + ) + ) + (tee_local $2 + (i32.load + (get_local $0) + ) + ) + ) + ) + (set_local $6 + (i32.sub + (i32.const 0) + (get_local $2) + ) + ) + (set_local $2 + (i32.add + (get_local $1) + (i32.const -20) + ) + ) + (loop $label$9 + (i64.store + (i32.add + (get_local $9) + (i32.const -32) + ) + (i64.load + (i32.add + (get_local $2) + (i32.const -12) + ) + ) + ) + (i64.store + (i32.add + (get_local $9) + (i32.const -40) + ) + (i64.load + (i32.add + (get_local $2) + (i32.const -20) + ) + ) + ) + (i64.store align=4 + (tee_local $1 + (i32.add + (get_local $9) + (i32.const -24) + ) + ) + (i64.const 0) + ) + (i32.store + (tee_local $4 + (i32.add + (get_local $9) + (i32.const -16) + ) + ) + (i32.const 0) + ) + (i32.store + (get_local $1) + (i32.load + (tee_local $7 + (i32.add + (get_local $2) + (i32.const -4) + ) + ) + ) + ) + (i32.store + (i32.add + (get_local $9) + (i32.const -20) + ) + (i32.load + (get_local $2) + ) + ) + (i32.store + (get_local $4) + (i32.load + (tee_local $1 + (i32.add + (get_local $2) + (i32.const 4) + ) + ) + ) + ) + (i32.store + (get_local $1) + (i32.const 0) + ) + (i64.store align=4 + (tee_local $1 + (i32.add + (get_local $9) + (i32.const -12) + ) + ) + (i64.const 0) + ) + (i64.store align=4 + (get_local $7) + (i64.const 0) + ) + (i32.store + (tee_local $4 + (i32.add + (get_local $9) + (i32.const -4) + ) + ) + (i32.const 0) + ) + (i32.store + (get_local $1) + (i32.load + (tee_local $7 + (i32.add + (get_local $2) + (i32.const 8) + ) + ) + ) + ) + (i32.store + (i32.add + (get_local $9) + (i32.const -8) + ) + (i32.load + (i32.add + (get_local $2) + (i32.const 12) + ) + ) + ) + (i32.store + (get_local $4) + (i32.load + (tee_local $1 + (i32.add + (get_local $2) + (i32.const 16) + ) + ) + ) + ) + (i32.store + (get_local $1) + (i32.const 0) + ) + (i64.store align=4 + (get_local $7) + (i64.const 0) + ) + (set_local $9 + (i32.add + (get_local $9) + (i32.const -40) + ) + ) + (br_if $label$9 + (i32.ne + (i32.add + (tee_local $2 + (i32.add + (get_local $2) + (i32.const -40) + ) + ) + (get_local $6) + ) + (i32.const -20) + ) + ) + ) + (set_local $2 + (i32.load + (i32.add + (get_local $0) + (i32.const 4) + ) + ) + ) + (set_local $4 + (i32.load + (get_local $0) + ) + ) + (br $label$7) + ) + (set_local $4 + (get_local $2) + ) + ) + (i32.store + (get_local $0) + (get_local $9) + ) + (i32.store + (i32.add + (get_local $0) + (i32.const 4) + ) + (get_local $5) + ) + (i32.store + (i32.add + (get_local $0) + (i32.const 8) + ) + (get_local $3) + ) + (block $label$10 + (br_if $label$10 + (i32.eq + (get_local $2) + (get_local $4) + ) + ) + (set_local $1 + (i32.sub + (i32.const 0) + (get_local $4) + ) + ) + (set_local $9 + (i32.add + (get_local $2) + (i32.const -24) + ) + ) + (loop $label$11 + (block $label$12 + (br_if $label$12 + (i32.eqz + (tee_local $2 + (i32.load + (i32.add + (get_local $9) + (i32.const 12) + ) + ) + ) + ) + ) + (i32.store + (i32.add + (get_local $9) + (i32.const 16) + ) + (get_local $2) + ) + (call $_ZdlPv + (get_local $2) + ) + ) + (block $label$13 + (br_if $label$13 + (i32.eqz + (tee_local $2 + (i32.load + (get_local $9) + ) + ) + ) + ) + (i32.store + (i32.add + (get_local $9) + (i32.const 4) + ) + (get_local $2) + ) + (call $_ZdlPv + (get_local $2) + ) + ) + (br_if $label$11 + (i32.ne + (i32.add + (tee_local $9 + (i32.add + (get_local $9) + (i32.const -40) + ) + ) + (get_local $1) + ) + (i32.const -24) + ) + ) + ) + ) + (block $label$14 + (br_if $label$14 + (i32.eqz + (get_local $4) + ) + ) + (call $_ZdlPv + (get_local $4) + ) + ) + (i32.store offset=4 + (i32.const 0) + (i32.add + (get_local $10) + (i32.const 16) + ) + ) + ) + (func $_ZN5eosio4packINS_11transactionEEENSt3__16vectorIcNS2_9allocatorIcEEEERKT_ (param $0 i32) (param $1 i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (i32.store offset=4 + (i32.const 0) + (tee_local $4 + (i32.sub + (i32.load offset=4 + (i32.const 0) + ) + (i32.const 16) + ) + ) + ) + (set_local $3 + (i32.const 0) + ) + (i32.store offset=8 + (get_local $0) + (i32.const 0) + ) + (i64.store align=4 + (get_local $0) + (i64.const 0) + ) + (i32.store + (get_local $4) + (i32.const 0) + ) + (drop + (call $_ZN5eosiolsINS_10datastreamIjEEEERT_S4_RKNS_11transactionE + (get_local $4) + (get_local $1) + ) + ) + (block $label$0 + (block $label$1 + (br_if $label$1 + (i32.eqz + (tee_local $2 + (i32.load + (get_local $4) + ) + ) + ) + ) + (call $_ZNSt3__16vectorIcNS_9allocatorIcEEE8__appendEj + (get_local $0) + (get_local $2) + ) + (set_local $3 + (i32.load + (i32.add + (get_local $0) + (i32.const 4) + ) + ) + ) + (set_local $0 + (i32.load + (get_local $0) + ) + ) + (br $label$0) + ) + (set_local $0 + (i32.const 0) + ) + ) + (i32.store offset=4 + (get_local $4) + (get_local $0) + ) + (i32.store + (get_local $4) + (get_local $0) + ) + (i32.store offset=8 + (get_local $4) + (get_local $3) + ) + (drop + (call $_ZN5eosiolsINS_10datastreamIPcEEEERT_S5_RKNS_18transaction_headerE + (get_local $4) + (get_local $1) + ) + ) + (drop + (call $_ZN5eosiolsINS_10datastreamIPcEENSt3__15tupleIJtNS4_6vectorIcNS4_9allocatorIcEEEEEEEEERT_SC_RKNS6_IT0_NS7_ISD_EEEE + (call $_ZN5eosiolsINS_10datastreamIPcEENS_6actionEEERT_S6_RKNSt3__16vectorIT0_NS7_9allocatorIS9_EEEE + (call $_ZN5eosiolsINS_10datastreamIPcEENS_6actionEEERT_S6_RKNSt3__16vectorIT0_NS7_9allocatorIS9_EEEE + (get_local $4) + (i32.add + (get_local $1) + (i32.const 24) + ) + ) + (i32.add + (get_local $1) + (i32.const 36) + ) + ) + (i32.add + (get_local $1) + (i32.const 48) + ) + ) + ) + (i32.store offset=4 + (i32.const 0) + (i32.add + (get_local $4) + (i32.const 16) + ) + ) + ) + (func $_ZN6eoswinlsIN5eosio10datastreamIPcEEEERT_S6_RKNS_13roundfee_itemE (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + (call $eosio_assert + (i32.gt_s + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (i32.load offset=4 + (get_local $0) + ) + ) + (i32.const 7) + ) + (i32.const 400) + ) + (drop + (call $memcpy + (i32.load offset=4 + (get_local $0) + ) + (get_local $1) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $0) + (tee_local $2 + (i32.add + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + ) + (call $eosio_assert + (i32.gt_s + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (get_local $2) + ) + (i32.const 7) + ) + (i32.const 400) + ) + (drop + (call $memcpy + (i32.load offset=4 + (get_local $0) + ) + (i32.add + (get_local $1) + (i32.const 8) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $0) + (tee_local $2 + (i32.add + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + ) + (call $eosio_assert + (i32.gt_s + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (get_local $2) + ) + (i32.const 7) + ) + (i32.const 400) + ) + (drop + (call $memcpy + (i32.load offset=4 + (get_local $0) + ) + (i32.add + (get_local $1) + (i32.const 16) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $0) + (tee_local $2 + (i32.add + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + ) + (call $eosio_assert + (i32.gt_s + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (get_local $2) + ) + (i32.const 7) + ) + (i32.const 400) + ) + (drop + (call $memcpy + (i32.load offset=4 + (get_local $0) + ) + (i32.add + (get_local $1) + (i32.const 24) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $0) + (tee_local $2 + (i32.add + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + ) + (call $eosio_assert + (i32.gt_s + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (get_local $2) + ) + (i32.const 7) + ) + (i32.const 400) + ) + (drop + (call $memcpy + (i32.load offset=4 + (get_local $0) + ) + (i32.add + (get_local $1) + (i32.const 32) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $0) + (tee_local $2 + (i32.add + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + ) + (call $eosio_assert + (i32.gt_s + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (get_local $2) + ) + (i32.const 7) + ) + (i32.const 400) + ) + (drop + (call $memcpy + (i32.load offset=4 + (get_local $0) + ) + (i32.add + (get_local $1) + (i32.const 40) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $0) + (tee_local $2 + (i32.add + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + ) + (call $eosio_assert + (i32.gt_s + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (get_local $2) + ) + (i32.const 7) + ) + (i32.const 400) + ) + (drop + (call $memcpy + (i32.load offset=4 + (get_local $0) + ) + (i32.add + (get_local $1) + (i32.const 48) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $0) + (tee_local $2 + (i32.add + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + ) + (call $eosio_assert + (i32.gt_s + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (get_local $2) + ) + (i32.const 7) + ) + (i32.const 400) + ) + (drop + (call $memcpy + (i32.load offset=4 + (get_local $0) + ) + (i32.add + (get_local $1) + (i32.const 56) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $0) + (tee_local $2 + (i32.add + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + ) + (call $eosio_assert + (i32.gt_s + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (get_local $2) + ) + (i32.const 7) + ) + (i32.const 400) + ) + (drop + (call $memcpy + (i32.load offset=4 + (get_local $0) + ) + (i32.add + (get_local $1) + (i32.const 64) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $0) + (i32.add + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + (get_local $0) + ) + (func $_ZN5eosio11transactionD2Ev (param $0 i32) (result i32) + (local $1 i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (block $label$0 + (br_if $label$0 + (i32.eqz + (tee_local $1 + (i32.load offset=48 + (get_local $0) + ) + ) + ) + ) + (block $label$1 + (block $label$2 + (br_if $label$2 + (i32.eq + (tee_local $5 + (i32.load + (tee_local $4 + (i32.add + (get_local $0) + (i32.const 52) + ) + ) + ) + ) + (get_local $1) + ) + ) + (set_local $2 + (i32.sub + (i32.const 0) + (get_local $1) + ) + ) + (set_local $5 + (i32.add + (get_local $5) + (i32.const -12) + ) + ) + (loop $label$3 + (block $label$4 + (br_if $label$4 + (i32.eqz + (tee_local $3 + (i32.load + (get_local $5) + ) + ) + ) + ) + (i32.store + (i32.add + (get_local $5) + (i32.const 4) + ) + (get_local $3) + ) + (call $_ZdlPv + (get_local $3) + ) + ) + (br_if $label$3 + (i32.ne + (i32.add + (tee_local $5 + (i32.add + (get_local $5) + (i32.const -16) + ) + ) + (get_local $2) + ) + (i32.const -12) + ) + ) + ) + (set_local $5 + (i32.load + (i32.add + (get_local $0) + (i32.const 48) + ) + ) + ) + (br $label$1) + ) + (set_local $5 + (get_local $1) + ) + ) + (i32.store + (get_local $4) + (get_local $1) + ) + (call $_ZdlPv + (get_local $5) + ) + ) + (block $label$5 + (br_if $label$5 + (i32.eqz + (tee_local $1 + (i32.load offset=36 + (get_local $0) + ) + ) + ) + ) + (block $label$6 + (block $label$7 + (br_if $label$7 + (i32.eq + (tee_local $5 + (i32.load + (tee_local $4 + (i32.add + (get_local $0) + (i32.const 40) + ) + ) + ) + ) + (get_local $1) + ) + ) + (set_local $2 + (i32.sub + (i32.const 0) + (get_local $1) + ) + ) + (set_local $5 + (i32.add + (get_local $5) + (i32.const -24) + ) + ) + (loop $label$8 + (block $label$9 + (br_if $label$9 + (i32.eqz + (tee_local $3 + (i32.load + (i32.add + (get_local $5) + (i32.const 12) + ) + ) + ) + ) + ) + (i32.store + (i32.add + (get_local $5) + (i32.const 16) + ) + (get_local $3) + ) + (call $_ZdlPv + (get_local $3) + ) + ) + (block $label$10 + (br_if $label$10 + (i32.eqz + (tee_local $3 + (i32.load + (get_local $5) + ) + ) + ) + ) + (i32.store + (i32.add + (get_local $5) + (i32.const 4) + ) + (get_local $3) + ) + (call $_ZdlPv + (get_local $3) + ) + ) + (br_if $label$8 + (i32.ne + (i32.add + (tee_local $5 + (i32.add + (get_local $5) + (i32.const -40) + ) + ) + (get_local $2) + ) + (i32.const -24) + ) + ) + ) + (set_local $5 + (i32.load + (i32.add + (get_local $0) + (i32.const 36) + ) + ) + ) + (br $label$6) + ) + (set_local $5 + (get_local $1) + ) + ) + (i32.store + (get_local $4) + (get_local $1) + ) + (call $_ZdlPv + (get_local $5) + ) + ) + (block $label$11 + (br_if $label$11 + (i32.eqz + (tee_local $1 + (i32.load offset=24 + (get_local $0) + ) + ) + ) + ) + (block $label$12 + (block $label$13 + (br_if $label$13 + (i32.eq + (tee_local $5 + (i32.load + (tee_local $4 + (i32.add + (get_local $0) + (i32.const 28) + ) + ) + ) + ) + (get_local $1) + ) + ) + (set_local $2 + (i32.sub + (i32.const 0) + (get_local $1) + ) + ) + (set_local $5 + (i32.add + (get_local $5) + (i32.const -24) + ) + ) + (loop $label$14 + (block $label$15 + (br_if $label$15 + (i32.eqz + (tee_local $3 + (i32.load + (i32.add + (get_local $5) + (i32.const 12) + ) + ) + ) + ) + ) + (i32.store + (i32.add + (get_local $5) + (i32.const 16) + ) + (get_local $3) + ) + (call $_ZdlPv + (get_local $3) + ) + ) + (block $label$16 + (br_if $label$16 + (i32.eqz + (tee_local $3 + (i32.load + (get_local $5) + ) + ) + ) + ) + (i32.store + (i32.add + (get_local $5) + (i32.const 4) + ) + (get_local $3) + ) + (call $_ZdlPv + (get_local $3) + ) + ) + (br_if $label$14 + (i32.ne + (i32.add + (tee_local $5 + (i32.add + (get_local $5) + (i32.const -40) + ) + ) + (get_local $2) + ) + (i32.const -24) + ) + ) + ) + (set_local $5 + (i32.load + (i32.add + (get_local $0) + (i32.const 24) + ) + ) + ) + (br $label$12) + ) + (set_local $5 + (get_local $1) + ) + ) + (i32.store + (get_local $4) + (get_local $1) + ) + (call $_ZdlPv + (get_local $5) + ) + ) + (get_local $0) + ) + (func $_ZN5eosiolsINS_10datastreamIjEEEERT_S4_RKNS_11transactionE (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (local $8 i64) + (i32.store + (get_local $0) + (i32.add + (tee_local $6 + (i32.load + (get_local $0) + ) + ) + (i32.const 10) + ) + ) + (set_local $6 + (i32.add + (get_local $6) + (i32.const 11) + ) + ) + (set_local $8 + (i64.load32_u offset=12 + (get_local $1) + ) + ) + (loop $label$0 + (set_local $6 + (i32.add + (get_local $6) + (i32.const 1) + ) + ) + (br_if $label$0 + (i64.ne + (tee_local $8 + (i64.shr_u + (get_local $8) + (i64.const 7) + ) + ) + (i64.const 0) + ) + ) + ) + (i32.store + (get_local $0) + (get_local $6) + ) + (set_local $8 + (i64.load32_u offset=20 + (get_local $1) + ) + ) + (loop $label$1 + (set_local $6 + (i32.add + (get_local $6) + (i32.const 1) + ) + ) + (br_if $label$1 + (i64.ne + (tee_local $8 + (i64.shr_u + (get_local $8) + (i64.const 7) + ) + ) + (i64.const 0) + ) + ) + ) + (i32.store + (get_local $0) + (get_local $6) + ) + (set_local $8 + (i64.extend_u/i32 + (i32.div_s + (i32.sub + (tee_local $2 + (i32.load + (i32.add + (get_local $1) + (i32.const 28) + ) + ) + ) + (tee_local $7 + (i32.load offset=24 + (get_local $1) + ) + ) + ) + (i32.const 40) + ) + ) + ) + (loop $label$2 + (set_local $6 + (i32.add + (get_local $6) + (i32.const 1) + ) + ) + (br_if $label$2 + (i64.ne + (tee_local $8 + (i64.shr_u + (get_local $8) + (i64.const 7) + ) + ) + (i64.const 0) + ) + ) + ) + (i32.store + (get_local $0) + (get_local $6) + ) + (block $label$3 + (br_if $label$3 + (i32.eq + (get_local $7) + (get_local $2) + ) + ) + (loop $label$4 + (set_local $6 + (i32.add + (get_local $6) + (i32.const 16) + ) + ) + (set_local $8 + (i64.extend_u/i32 + (i32.shr_s + (tee_local $5 + (i32.sub + (tee_local $3 + (i32.load + (i32.add + (get_local $7) + (i32.const 20) + ) + ) + ) + (tee_local $4 + (i32.load offset=16 + (get_local $7) + ) + ) + ) + ) + (i32.const 4) + ) + ) + ) + (loop $label$5 + (set_local $6 + (i32.add + (get_local $6) + (i32.const 1) + ) + ) + (br_if $label$5 + (i64.ne + (tee_local $8 + (i64.shr_u + (get_local $8) + (i64.const 7) + ) + ) + (i64.const 0) + ) + ) + ) + (block $label$6 + (br_if $label$6 + (i32.eq + (get_local $4) + (get_local $3) + ) + ) + (set_local $6 + (i32.add + (i32.and + (get_local $5) + (i32.const -16) + ) + (get_local $6) + ) + ) + ) + (set_local $6 + (i32.sub + (i32.add + (get_local $6) + (tee_local $3 + (i32.load + (i32.add + (get_local $7) + (i32.const 32) + ) + ) + ) + ) + (tee_local $4 + (i32.load offset=28 + (get_local $7) + ) + ) + ) + ) + (set_local $8 + (i64.extend_u/i32 + (i32.sub + (get_local $3) + (get_local $4) + ) + ) + ) + (loop $label$7 + (set_local $6 + (i32.add + (get_local $6) + (i32.const 1) + ) + ) + (br_if $label$7 + (i64.ne + (tee_local $8 + (i64.shr_u + (get_local $8) + (i64.const 7) + ) + ) + (i64.const 0) + ) + ) + ) + (br_if $label$4 + (i32.ne + (tee_local $7 + (i32.add + (get_local $7) + (i32.const 40) + ) + ) + (get_local $2) + ) + ) + ) + (i32.store + (get_local $0) + (get_local $6) + ) + ) + (set_local $8 + (i64.extend_u/i32 + (i32.div_s + (i32.sub + (tee_local $2 + (i32.load + (i32.add + (get_local $1) + (i32.const 40) + ) + ) + ) + (tee_local $7 + (i32.load offset=36 + (get_local $1) + ) + ) + ) + (i32.const 40) + ) + ) + ) + (loop $label$8 + (set_local $6 + (i32.add + (get_local $6) + (i32.const 1) + ) + ) + (br_if $label$8 + (i64.ne + (tee_local $8 + (i64.shr_u + (get_local $8) + (i64.const 7) + ) + ) + (i64.const 0) + ) + ) + ) + (i32.store + (get_local $0) + (get_local $6) + ) + (block $label$9 + (br_if $label$9 + (i32.eq + (get_local $7) + (get_local $2) + ) + ) + (loop $label$10 + (set_local $6 + (i32.add + (get_local $6) + (i32.const 16) + ) + ) + (set_local $8 + (i64.extend_u/i32 + (i32.shr_s + (tee_local $5 + (i32.sub + (tee_local $3 + (i32.load + (i32.add + (get_local $7) + (i32.const 20) + ) + ) + ) + (tee_local $4 + (i32.load offset=16 + (get_local $7) + ) + ) + ) + ) + (i32.const 4) + ) + ) + ) + (loop $label$11 + (set_local $6 + (i32.add + (get_local $6) + (i32.const 1) + ) + ) + (br_if $label$11 + (i64.ne + (tee_local $8 + (i64.shr_u + (get_local $8) + (i64.const 7) + ) + ) + (i64.const 0) + ) + ) + ) + (block $label$12 + (br_if $label$12 + (i32.eq + (get_local $4) + (get_local $3) + ) + ) + (set_local $6 + (i32.add + (i32.and + (get_local $5) + (i32.const -16) + ) + (get_local $6) + ) + ) + ) + (set_local $6 + (i32.sub + (i32.add + (get_local $6) + (tee_local $3 + (i32.load + (i32.add + (get_local $7) + (i32.const 32) + ) + ) + ) + ) + (tee_local $4 + (i32.load offset=28 + (get_local $7) + ) + ) + ) + ) + (set_local $8 + (i64.extend_u/i32 + (i32.sub + (get_local $3) + (get_local $4) + ) + ) + ) + (loop $label$13 + (set_local $6 + (i32.add + (get_local $6) + (i32.const 1) + ) + ) + (br_if $label$13 + (i64.ne + (tee_local $8 + (i64.shr_u + (get_local $8) + (i64.const 7) + ) + ) + (i64.const 0) + ) + ) + ) + (br_if $label$10 + (i32.ne + (tee_local $7 + (i32.add + (get_local $7) + (i32.const 40) + ) + ) + (get_local $2) + ) + ) + ) + (i32.store + (get_local $0) + (get_local $6) + ) + ) + (set_local $8 + (i64.extend_u/i32 + (i32.shr_s + (i32.sub + (tee_local $5 + (i32.load + (i32.add + (get_local $1) + (i32.const 52) + ) + ) + ) + (tee_local $7 + (i32.load offset=48 + (get_local $1) + ) + ) + ) + (i32.const 4) + ) + ) + ) + (loop $label$14 + (set_local $6 + (i32.add + (get_local $6) + (i32.const 1) + ) + ) + (br_if $label$14 + (i64.ne + (tee_local $8 + (i64.shr_u + (get_local $8) + (i64.const 7) + ) + ) + (i64.const 0) + ) + ) + ) + (i32.store + (get_local $0) + (get_local $6) + ) + (block $label$15 + (br_if $label$15 + (i32.eq + (get_local $7) + (get_local $5) + ) + ) + (loop $label$16 + (set_local $6 + (i32.sub + (i32.add + (i32.add + (get_local $6) + (tee_local $3 + (i32.load + (i32.add + (get_local $7) + (i32.const 8) + ) + ) + ) + ) + (i32.const 2) + ) + (tee_local $4 + (i32.load offset=4 + (get_local $7) + ) + ) + ) + ) + (set_local $8 + (i64.extend_u/i32 + (i32.sub + (get_local $3) + (get_local $4) + ) + ) + ) + (loop $label$17 + (set_local $6 + (i32.add + (get_local $6) + (i32.const 1) + ) + ) + (br_if $label$17 + (i64.ne + (tee_local $8 + (i64.shr_u + (get_local $8) + (i64.const 7) + ) + ) + (i64.const 0) + ) + ) + ) + (br_if $label$16 + (i32.ne + (tee_local $7 + (i32.add + (get_local $7) + (i32.const 16) + ) + ) + (get_local $5) + ) + ) + ) + (i32.store + (get_local $0) + (get_local $6) + ) + ) + (get_local $0) + ) + (func $_ZN5eosiolsINS_10datastreamIPcEEEERT_S5_RKNS_18transaction_headerE (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i64) + (local $7 i32) + (i32.store offset=4 + (i32.const 0) + (tee_local $7 + (i32.sub + (i32.load offset=4 + (i32.const 0) + ) + (i32.const 16) + ) + ) + ) + (call $eosio_assert + (i32.gt_s + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (i32.load offset=4 + (get_local $0) + ) + ) + (i32.const 3) + ) + (i32.const 400) + ) + (drop + (call $memcpy + (i32.load offset=4 + (get_local $0) + ) + (get_local $1) + (i32.const 4) + ) + ) + (i32.store offset=4 + (get_local $0) + (tee_local $4 + (i32.add + (i32.load offset=4 + (get_local $0) + ) + (i32.const 4) + ) + ) + ) + (call $eosio_assert + (i32.gt_s + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (get_local $4) + ) + (i32.const 1) + ) + (i32.const 400) + ) + (drop + (call $memcpy + (i32.load offset=4 + (get_local $0) + ) + (i32.add + (get_local $1) + (i32.const 4) + ) + (i32.const 2) + ) + ) + (i32.store offset=4 + (get_local $0) + (tee_local $4 + (i32.add + (i32.load offset=4 + (get_local $0) + ) + (i32.const 2) + ) + ) + ) + (call $eosio_assert + (i32.gt_s + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (get_local $4) + ) + (i32.const 3) + ) + (i32.const 400) + ) + (drop + (call $memcpy + (i32.load offset=4 + (get_local $0) + ) + (i32.add + (get_local $1) + (i32.const 8) + ) + (i32.const 4) + ) + ) + (i32.store offset=4 + (get_local $0) + (tee_local $5 + (i32.add + (i32.load offset=4 + (get_local $0) + ) + (i32.const 4) + ) + ) + ) + (set_local $6 + (i64.load32_u offset=12 + (get_local $1) + ) + ) + (loop $label$0 + (set_local $4 + (i32.wrap/i64 + (get_local $6) + ) + ) + (i32.store8 offset=14 + (get_local $7) + (i32.or + (i32.shl + (tee_local $2 + (i64.ne + (tee_local $6 + (i64.shr_u + (get_local $6) + (i64.const 7) + ) + ) + (i64.const 0) + ) + ) + (i32.const 7) + ) + (i32.and + (get_local $4) + (i32.const 127) + ) + ) + ) + (call $eosio_assert + (i32.gt_s + (i32.sub + (i32.load + (i32.add + (get_local $0) + (i32.const 8) + ) + ) + (get_local $5) + ) + (i32.const 0) + ) + (i32.const 400) + ) + (drop + (call $memcpy + (i32.load + (tee_local $4 + (i32.add + (get_local $0) + (i32.const 4) + ) + ) + ) + (i32.add + (get_local $7) + (i32.const 14) + ) + (i32.const 1) + ) + ) + (i32.store + (get_local $4) + (tee_local $5 + (i32.add + (i32.load + (get_local $4) + ) + (i32.const 1) + ) + ) + ) + (br_if $label$0 + (get_local $2) + ) + ) + (call $eosio_assert + (i32.gt_s + (i32.sub + (i32.load + (tee_local $3 + (i32.add + (get_local $0) + (i32.const 8) + ) + ) + ) + (get_local $5) + ) + (i32.const 0) + ) + (i32.const 400) + ) + (drop + (call $memcpy + (i32.load + (tee_local $4 + (i32.add + (get_local $0) + (i32.const 4) + ) + ) + ) + (i32.add + (get_local $1) + (i32.const 16) + ) + (i32.const 1) + ) + ) + (i32.store + (get_local $4) + (tee_local $5 + (i32.add + (i32.load + (get_local $4) + ) + (i32.const 1) + ) + ) + ) + (set_local $6 + (i64.load32_u offset=20 + (get_local $1) + ) + ) + (loop $label$1 + (set_local $2 + (i32.wrap/i64 + (get_local $6) + ) + ) + (i32.store8 offset=15 + (get_local $7) + (i32.or + (i32.shl + (tee_local $1 + (i64.ne + (tee_local $6 + (i64.shr_u + (get_local $6) + (i64.const 7) + ) + ) + (i64.const 0) + ) + ) + (i32.const 7) + ) + (i32.and + (get_local $2) + (i32.const 127) + ) + ) + ) + (call $eosio_assert + (i32.gt_s + (i32.sub + (i32.load + (get_local $3) + ) + (get_local $5) + ) + (i32.const 0) + ) + (i32.const 400) + ) + (drop + (call $memcpy + (i32.load + (get_local $4) + ) + (i32.add + (get_local $7) + (i32.const 15) + ) + (i32.const 1) + ) + ) + (i32.store + (get_local $4) + (tee_local $5 + (i32.add + (i32.load + (get_local $4) + ) + (i32.const 1) + ) + ) + ) + (br_if $label$1 + (get_local $1) + ) + ) + (i32.store offset=4 + (i32.const 0) + (i32.add + (get_local $7) + (i32.const 16) + ) + ) + (get_local $0) + ) + (func $_ZN5eosiolsINS_10datastreamIPcEENS_6actionEEERT_S6_RKNSt3__16vectorIT0_NS7_9allocatorIS9_EEEE (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 i64) + (local $6 i32) + (local $7 i32) + (local $8 i32) + (i32.store offset=4 + (i32.const 0) + (tee_local $8 + (i32.sub + (i32.load offset=4 + (i32.const 0) + ) + (i32.const 16) + ) + ) + ) + (set_local $5 + (i64.extend_u/i32 + (i32.div_s + (i32.sub + (i32.load offset=4 + (get_local $1) + ) + (i32.load + (get_local $1) + ) + ) + (i32.const 40) + ) + ) + ) + (set_local $6 + (i32.load offset=4 + (get_local $0) + ) + ) + (set_local $3 + (i32.add + (get_local $0) + (i32.const 8) + ) + ) + (set_local $4 + (i32.add + (get_local $0) + (i32.const 4) + ) + ) + (loop $label$0 + (set_local $7 + (i32.wrap/i64 + (get_local $5) + ) + ) + (i32.store8 offset=15 + (get_local $8) + (i32.or + (i32.shl + (tee_local $2 + (i64.ne + (tee_local $5 + (i64.shr_u + (get_local $5) + (i64.const 7) + ) + ) + (i64.const 0) + ) + ) + (i32.const 7) + ) + (i32.and + (get_local $7) + (i32.const 127) + ) + ) + ) + (call $eosio_assert + (i32.gt_s + (i32.sub + (i32.load + (get_local $3) + ) + (get_local $6) + ) + (i32.const 0) + ) + (i32.const 400) + ) + (drop + (call $memcpy + (i32.load + (get_local $4) + ) + (i32.add + (get_local $8) + (i32.const 15) + ) + (i32.const 1) + ) + ) + (i32.store + (get_local $4) + (tee_local $6 + (i32.add + (i32.load + (get_local $4) + ) + (i32.const 1) + ) + ) + ) + (br_if $label$0 + (get_local $2) + ) + ) + (block $label$1 + (br_if $label$1 + (i32.eq + (tee_local $7 + (i32.load + (get_local $1) + ) + ) + (tee_local $3 + (i32.load + (i32.add + (get_local $1) + (i32.const 4) + ) + ) + ) + ) + ) + (set_local $4 + (i32.add + (get_local $0) + (i32.const 4) + ) + ) + (loop $label$2 + (call $eosio_assert + (i32.gt_s + (i32.sub + (i32.load + (tee_local $2 + (i32.add + (get_local $0) + (i32.const 8) + ) + ) + ) + (get_local $6) + ) + (i32.const 7) + ) + (i32.const 400) + ) + (drop + (call $memcpy + (i32.load + (get_local $4) + ) + (get_local $7) + (i32.const 8) + ) + ) + (i32.store + (get_local $4) + (tee_local $6 + (i32.add + (i32.load + (get_local $4) + ) + (i32.const 8) + ) + ) + ) + (call $eosio_assert + (i32.gt_s + (i32.sub + (i32.load + (get_local $2) + ) + (get_local $6) + ) + (i32.const 7) + ) + (i32.const 400) + ) + (drop + (call $memcpy + (i32.load + (get_local $4) + ) + (i32.add + (get_local $7) + (i32.const 8) + ) + (i32.const 8) + ) + ) + (i32.store + (get_local $4) + (i32.add + (i32.load + (get_local $4) + ) + (i32.const 8) + ) + ) + (drop + (call $_ZN5eosiolsINS_10datastreamIPcEEEERT_S5_RKNSt3__16vectorIcNS6_9allocatorIcEEEE + (call $_ZN5eosiolsINS_10datastreamIPcEENS_16permission_levelEEERT_S6_RKNSt3__16vectorIT0_NS7_9allocatorIS9_EEEE + (get_local $0) + (i32.add + (get_local $7) + (i32.const 16) + ) + ) + (i32.add + (get_local $7) + (i32.const 28) + ) + ) + ) + (br_if $label$1 + (i32.eq + (tee_local $7 + (i32.add + (get_local $7) + (i32.const 40) + ) + ) + (get_local $3) + ) + ) + (set_local $6 + (i32.load + (get_local $4) + ) + ) + (br $label$2) + ) + ) + (i32.store offset=4 + (i32.const 0) + (i32.add + (get_local $8) + (i32.const 16) + ) + ) + (get_local $0) + ) + (func $_ZN5eosiolsINS_10datastreamIPcEENSt3__15tupleIJtNS4_6vectorIcNS4_9allocatorIcEEEEEEEEERT_SC_RKNS6_IT0_NS7_ISD_EEEE (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 i64) + (local $6 i32) + (local $7 i32) + (i32.store offset=4 + (i32.const 0) + (tee_local $7 + (i32.sub + (i32.load offset=4 + (i32.const 0) + ) + (i32.const 16) + ) + ) + ) + (set_local $5 + (i64.extend_u/i32 + (i32.shr_s + (i32.sub + (i32.load offset=4 + (get_local $1) + ) + (i32.load + (get_local $1) + ) + ) + (i32.const 4) + ) + ) + ) + (set_local $6 + (i32.load offset=4 + (get_local $0) + ) + ) + (set_local $3 + (i32.add + (get_local $0) + (i32.const 8) + ) + ) + (loop $label$0 + (set_local $4 + (i32.wrap/i64 + (get_local $5) + ) + ) + (i32.store8 offset=15 + (get_local $7) + (i32.or + (i32.shl + (tee_local $2 + (i64.ne + (tee_local $5 + (i64.shr_u + (get_local $5) + (i64.const 7) + ) + ) + (i64.const 0) + ) + ) + (i32.const 7) + ) + (i32.and + (get_local $4) + (i32.const 127) + ) + ) + ) + (call $eosio_assert + (i32.gt_s + (i32.sub + (i32.load + (get_local $3) + ) + (get_local $6) + ) + (i32.const 0) + ) + (i32.const 400) + ) + (drop + (call $memcpy + (i32.load + (tee_local $4 + (i32.add + (get_local $0) + (i32.const 4) + ) + ) + ) + (i32.add + (get_local $7) + (i32.const 15) + ) + (i32.const 1) + ) + ) + (i32.store + (get_local $4) + (tee_local $6 + (i32.add + (i32.load + (get_local $4) + ) + (i32.const 1) + ) + ) + ) + (br_if $label$0 + (get_local $2) + ) + ) + (block $label$1 + (br_if $label$1 + (i32.eq + (tee_local $4 + (i32.load + (get_local $1) + ) + ) + (tee_local $2 + (i32.load + (i32.add + (get_local $1) + (i32.const 4) + ) + ) + ) + ) + ) + (set_local $3 + (i32.add + (get_local $0) + (i32.const 8) + ) + ) + (loop $label$2 + (call $eosio_assert + (i32.gt_s + (i32.sub + (i32.load + (get_local $3) + ) + (get_local $6) + ) + (i32.const 1) + ) + (i32.const 400) + ) + (drop + (call $memcpy + (i32.load + (tee_local $6 + (i32.add + (get_local $0) + (i32.const 4) + ) + ) + ) + (get_local $4) + (i32.const 2) + ) + ) + (i32.store + (get_local $6) + (i32.add + (i32.load + (get_local $6) + ) + (i32.const 2) + ) + ) + (drop + (call $_ZN5eosiolsINS_10datastreamIPcEEEERT_S5_RKNSt3__16vectorIcNS6_9allocatorIcEEEE + (get_local $0) + (i32.add + (get_local $4) + (i32.const 4) + ) + ) + ) + (br_if $label$1 + (i32.eq + (tee_local $4 + (i32.add + (get_local $4) + (i32.const 16) + ) + ) + (get_local $2) + ) + ) + (set_local $6 + (i32.load + (get_local $6) + ) + ) + (br $label$2) + ) + ) + (i32.store offset=4 + (i32.const 0) + (i32.add + (get_local $7) + (i32.const 16) + ) + ) + (get_local $0) + ) + (func $_ZNK5eosio11multi_indexILy4297309255767162880EN6eoswin9bill_itemEJNS_10indexed_byILy4587782057278570496EN5boost11multi_index13const_mem_funIS2_yXadL_ZNKS2_8byplayerEvEEEEEEEE31load_object_by_primary_iteratorEl (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i64) + (local $8 i32) + (local $9 i32) + (set_local $8 + (tee_local $9 + (i32.sub + (i32.load offset=4 + (i32.const 0) + ) + (i32.const 48) + ) + ) + ) + (i32.store offset=4 + (i32.const 0) + (get_local $9) + ) + (block $label$0 + (br_if $label$0 + (i32.eq + (tee_local $6 + (i32.load + (i32.add + (get_local $0) + (i32.const 28) + ) + ) + ) + (tee_local $2 + (i32.load offset=24 + (get_local $0) + ) + ) + ) + ) + (set_local $3 + (i32.sub + (i32.const 0) + (get_local $2) + ) + ) + (set_local $5 + (i32.add + (get_local $6) + (i32.const -24) + ) + ) + (loop $label$1 + (br_if $label$0 + (i32.eq + (i32.load + (i32.add + (get_local $5) + (i32.const 16) + ) + ) + (get_local $1) + ) + ) + (set_local $6 + (get_local $5) + ) + (set_local $5 + (tee_local $4 + (i32.add + (get_local $5) + (i32.const -24) + ) + ) + ) + (br_if $label$1 + (i32.ne + (i32.add + (get_local $4) + (get_local $3) + ) + (i32.const -24) + ) + ) + ) + ) + (block $label$2 + (block $label$3 + (br_if $label$3 + (i32.eq + (get_local $6) + (get_local $2) + ) + ) + (set_local $4 + (i32.load + (i32.add + (get_local $6) + (i32.const -24) + ) + ) + ) + (br $label$2) + ) + (call $eosio_assert + (i32.xor + (i32.shr_u + (tee_local $5 + (call $db_get_i64 + (get_local $1) + (i32.const 0) + (i32.const 0) + ) + ) + (i32.const 31) + ) + (i32.const 1) + ) + (i32.const 240) + ) + (block $label$4 + (block $label$5 + (br_if $label$5 + (i32.lt_u + (get_local $5) + (i32.const 513) + ) + ) + (set_local $4 + (call $malloc + (get_local $5) + ) + ) + (br $label$4) + ) + (i32.store offset=4 + (i32.const 0) + (tee_local $4 + (i32.sub + (get_local $9) + (i32.and + (i32.add + (get_local $5) + (i32.const 15) + ) + (i32.const -16) + ) + ) + ) + ) + ) + (drop + (call $db_get_i64 + (get_local $1) + (get_local $4) + (get_local $5) + ) + ) + (i32.store offset=36 + (get_local $8) + (get_local $4) + ) + (i32.store offset=32 + (get_local $8) + (get_local $4) + ) + (i32.store offset=40 + (get_local $8) + (i32.add + (get_local $4) + (get_local $5) + ) + ) + (block $label$6 + (br_if $label$6 + (i32.lt_u + (get_local $5) + (i32.const 513) + ) + ) + (call $free + (get_local $4) + ) + ) + (set_local $3 + (i32.add + (get_local $0) + (i32.const 24) + ) + ) + (i64.store offset=40 + (tee_local $4 + (call $_Znwj + (i32.const 80) + ) + ) + (i64.const 1397703940) + ) + (i64.store offset=32 + (get_local $4) + (i64.const 0) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 176) + ) + (set_local $7 + (i64.const 5459781) + ) + (set_local $5 + (i32.const 0) + ) + (block $label$7 + (block $label$8 + (loop $label$9 + (br_if $label$8 + (i32.gt_u + (i32.add + (i32.shl + (i32.wrap/i64 + (get_local $7) + ) + (i32.const 24) + ) + (i32.const -1073741825) + ) + (i32.const 452984830) + ) + ) + (block $label$10 + (br_if $label$10 + (i64.ne + (i64.and + (tee_local $7 + (i64.shr_u + (get_local $7) + (i64.const 8) + ) + ) + (i64.const 255) + ) + (i64.const 0) + ) + ) + (loop $label$11 + (br_if $label$8 + (i64.ne + (i64.and + (tee_local $7 + (i64.shr_u + (get_local $7) + (i64.const 8) + ) + ) + (i64.const 255) + ) + (i64.const 0) + ) + ) + (br_if $label$11 + (i32.lt_s + (tee_local $5 + (i32.add + (get_local $5) + (i32.const 1) + ) + ) + (i32.const 7) + ) + ) + ) + ) + (set_local $6 + (i32.const 1) + ) + (br_if $label$9 + (i32.lt_s + (tee_local $5 + (i32.add + (get_local $5) + (i32.const 1) + ) + ) + (i32.const 7) + ) + ) + (br $label$7) + ) + ) + (set_local $6 + (i32.const 0) + ) + ) + (call $eosio_assert + (get_local $6) + (i32.const 128) + ) + (i32.store offset=64 + (get_local $4) + (get_local $0) + ) + (drop + (call $_ZN6eoswinrsIN5eosio10datastreamIPKcEEEERT_S7_RNS_9bill_itemE + (i32.add + (get_local $8) + (i32.const 32) + ) + (get_local $4) + ) + ) + (i32.store offset=72 + (get_local $4) + (i32.const -1) + ) + (i32.store offset=68 + (get_local $4) + (get_local $1) + ) + (i32.store offset=24 + (get_local $8) + (get_local $4) + ) + (i64.store offset=16 + (get_local $8) + (tee_local $7 + (i64.load + (get_local $4) + ) + ) + ) + (i32.store offset=12 + (get_local $8) + (tee_local $6 + (i32.load offset=68 + (get_local $4) + ) + ) + ) + (block $label$12 + (block $label$13 + (br_if $label$13 + (i32.ge_u + (tee_local $5 + (i32.load + (tee_local $1 + (i32.add + (get_local $0) + (i32.const 28) + ) + ) + ) + ) + (i32.load + (i32.add + (get_local $0) + (i32.const 32) + ) + ) + ) + ) + (i64.store offset=8 + (get_local $5) + (get_local $7) + ) + (i32.store offset=16 + (get_local $5) + (get_local $6) + ) + (i32.store offset=24 + (get_local $8) + (i32.const 0) + ) + (i32.store + (get_local $5) + (get_local $4) + ) + (i32.store + (get_local $1) + (i32.add + (get_local $5) + (i32.const 24) + ) + ) + (br $label$12) + ) + (call $_ZNSt3__16vectorIN5eosio11multi_indexILy4297309255767162880EN6eoswin9bill_itemEJNS1_10indexed_byILy4587782057278570496EN5boost11multi_index13const_mem_funIS4_yXadL_ZNKS4_8byplayerEvEEEEEEEE8item_ptrENS_9allocatorISC_EEE24__emplace_back_slow_pathIJNS_10unique_ptrINSB_4itemENS_14default_deleteISI_EEEERyRlEEEvDpOT_ + (get_local $3) + (i32.add + (get_local $8) + (i32.const 24) + ) + (i32.add + (get_local $8) + (i32.const 16) + ) + (i32.add + (get_local $8) + (i32.const 12) + ) + ) + ) + (set_local $5 + (i32.load offset=24 + (get_local $8) + ) + ) + (i32.store offset=24 + (get_local $8) + (i32.const 0) + ) + (br_if $label$2 + (i32.eqz + (get_local $5) + ) + ) + (call $_ZdlPv + (get_local $5) + ) + ) + (i32.store offset=4 + (i32.const 0) + (i32.add + (get_local $8) + (i32.const 48) + ) + ) + (get_local $4) + ) + (func $_ZN6eoswinrsIN5eosio10datastreamIPKcEEEERT_S7_RNS_9bill_itemE (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + (call $eosio_assert + (i32.gt_u + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (i32.load offset=4 + (get_local $0) + ) + ) + (i32.const 7) + ) + (i32.const 272) + ) + (drop + (call $memcpy + (get_local $1) + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $0) + (tee_local $2 + (i32.add + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + ) + (call $eosio_assert + (i32.gt_u + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (get_local $2) + ) + (i32.const 7) + ) + (i32.const 272) + ) + (drop + (call $memcpy + (i32.add + (get_local $1) + (i32.const 8) + ) + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $0) + (tee_local $2 + (i32.add + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + ) + (call $eosio_assert + (i32.gt_u + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (get_local $2) + ) + (i32.const 7) + ) + (i32.const 272) + ) + (drop + (call $memcpy + (i32.add + (get_local $1) + (i32.const 16) + ) + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $0) + (tee_local $2 + (i32.add + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + ) + (call $eosio_assert + (i32.gt_u + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (get_local $2) + ) + (i32.const 7) + ) + (i32.const 272) + ) + (drop + (call $memcpy + (i32.add + (get_local $1) + (i32.const 24) + ) + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $0) + (tee_local $2 + (i32.add + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + ) + (call $eosio_assert + (i32.gt_u + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (get_local $2) + ) + (i32.const 7) + ) + (i32.const 272) + ) + (drop + (call $memcpy + (i32.add + (get_local $1) + (i32.const 32) + ) + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $0) + (tee_local $2 + (i32.add + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + ) + (call $eosio_assert + (i32.gt_u + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (get_local $2) + ) + (i32.const 7) + ) + (i32.const 272) + ) + (drop + (call $memcpy + (i32.add + (get_local $1) + (i32.const 40) + ) + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $0) + (tee_local $2 + (i32.add + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + ) + (call $eosio_assert + (i32.gt_u + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (get_local $2) + ) + (i32.const 7) + ) + (i32.const 272) + ) + (drop + (call $memcpy + (i32.add + (get_local $1) + (i32.const 48) + ) + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $0) + (tee_local $2 + (i32.add + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + ) + (call $eosio_assert + (i32.gt_u + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (get_local $2) + ) + (i32.const 7) + ) + (i32.const 272) + ) + (drop + (call $memcpy + (i32.add + (get_local $1) + (i32.const 56) + ) + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $0) + (i32.add + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + (get_local $0) + ) + (func $_ZNSt3__16vectorIN5eosio11multi_indexILy4297309255767162880EN6eoswin9bill_itemEJNS1_10indexed_byILy4587782057278570496EN5boost11multi_index13const_mem_funIS4_yXadL_ZNKS4_8byplayerEvEEEEEEEE8item_ptrENS_9allocatorISC_EEE24__emplace_back_slow_pathIJNS_10unique_ptrINSB_4itemENS_14default_deleteISI_EEEERyRlEEEvDpOT_ (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (block $label$0 + (block $label$1 + (br_if $label$1 + (i32.ge_u + (tee_local $5 + (i32.add + (tee_local $4 + (i32.div_s + (i32.sub + (i32.load offset=4 + (get_local $0) + ) + (tee_local $6 + (i32.load + (get_local $0) + ) + ) + ) + (i32.const 24) + ) + ) + (i32.const 1) + ) + ) + (i32.const 178956971) + ) + ) + (set_local $7 + (i32.const 178956970) + ) + (block $label$2 + (block $label$3 + (br_if $label$3 + (i32.gt_u + (tee_local $6 + (i32.div_s + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (get_local $6) + ) + (i32.const 24) + ) + ) + (i32.const 89478484) + ) + ) + (br_if $label$2 + (i32.eqz + (tee_local $7 + (select + (get_local $5) + (tee_local $7 + (i32.shl + (get_local $6) + (i32.const 1) + ) + ) + (i32.lt_u + (get_local $7) + (get_local $5) + ) + ) + ) + ) + ) + ) + (set_local $6 + (call $_Znwj + (i32.mul + (get_local $7) + (i32.const 24) + ) + ) + ) + (br $label$0) + ) + (set_local $7 + (i32.const 0) + ) + (set_local $6 + (i32.const 0) + ) + (br $label$0) + ) + (call $_ZNKSt3__120__vector_base_commonILb1EE20__throw_length_errorEv + (get_local $0) + ) + (unreachable) + ) + (set_local $5 + (i32.load + (get_local $1) + ) + ) + (i32.store + (get_local $1) + (i32.const 0) + ) + (i32.store + (tee_local $1 + (i32.add + (get_local $6) + (i32.mul + (get_local $4) + (i32.const 24) + ) + ) + ) + (get_local $5) + ) + (i64.store offset=8 + (get_local $1) + (i64.load + (get_local $2) + ) + ) + (i32.store offset=16 + (get_local $1) + (i32.load + (get_local $3) + ) + ) + (set_local $4 + (i32.add + (get_local $6) + (i32.mul + (get_local $7) + (i32.const 24) + ) + ) + ) + (set_local $5 + (i32.add + (get_local $1) + (i32.const 24) + ) + ) + (block $label$4 + (block $label$5 + (br_if $label$5 + (i32.eq + (tee_local $6 + (i32.load + (i32.add + (get_local $0) + (i32.const 4) + ) + ) + ) + (tee_local $7 + (i32.load + (get_local $0) + ) + ) + ) + ) + (loop $label$6 + (set_local $3 + (i32.load + (tee_local $2 + (i32.add + (get_local $6) + (i32.const -24) + ) + ) + ) + ) + (i32.store + (get_local $2) + (i32.const 0) + ) + (i32.store + (i32.add + (get_local $1) + (i32.const -24) + ) + (get_local $3) + ) + (i32.store + (i32.add + (get_local $1) + (i32.const -8) + ) + (i32.load + (i32.add + (get_local $6) + (i32.const -8) + ) + ) + ) + (i32.store + (i32.add + (get_local $1) + (i32.const -12) + ) + (i32.load + (i32.add + (get_local $6) + (i32.const -12) + ) + ) + ) + (i32.store + (i32.add + (get_local $1) + (i32.const -16) + ) + (i32.load + (i32.add + (get_local $6) + (i32.const -16) + ) + ) + ) + (set_local $1 + (i32.add + (get_local $1) + (i32.const -24) + ) + ) + (set_local $6 + (get_local $2) + ) + (br_if $label$6 + (i32.ne + (get_local $7) + (get_local $2) + ) + ) + ) + (set_local $7 + (i32.load + (i32.add + (get_local $0) + (i32.const 4) + ) + ) + ) + (set_local $6 + (i32.load + (get_local $0) + ) + ) + (br $label$4) + ) + (set_local $6 + (get_local $7) + ) + ) + (i32.store + (get_local $0) + (get_local $1) + ) + (i32.store + (i32.add + (get_local $0) + (i32.const 4) + ) + (get_local $5) + ) + (i32.store + (i32.add + (get_local $0) + (i32.const 8) + ) + (get_local $4) + ) + (block $label$7 + (br_if $label$7 + (i32.eq + (get_local $7) + (get_local $6) + ) + ) + (loop $label$8 + (set_local $1 + (i32.load + (tee_local $7 + (i32.add + (get_local $7) + (i32.const -24) + ) + ) + ) + ) + (i32.store + (get_local $7) + (i32.const 0) + ) + (block $label$9 + (br_if $label$9 + (i32.eqz + (get_local $1) + ) + ) + (call $_ZdlPv + (get_local $1) + ) + ) + (br_if $label$8 + (i32.ne + (get_local $6) + (get_local $7) + ) + ) + ) + ) + (block $label$10 + (br_if $label$10 + (i32.eqz + (get_local $6) + ) + ) + (call $_ZdlPv + (get_local $6) + ) + ) + ) + (func $_ZN6eoswin7lottery8transferEyy (type $FUNCSIG$vijj) (param $0 i32) (param $1 i64) (param $2 i64) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i64) + (local $7 i32) + (local $8 i32) + (local $9 i32) + (i32.store offset=4 + (i32.const 0) + (tee_local $9 + (i32.sub + (i32.load offset=4 + (i32.const 0) + ) + (i32.const 288) + ) + ) + ) + (i64.store offset=160 + (get_local $9) + (get_local $1) + ) + (call $_ZN5eosio18unpack_action_dataINS_8currency8transferEEET_v + (i32.add + (get_local $9) + (i32.const 112) + ) + ) + (block $label$0 + (br_if $label$0 + (i64.eq + (i64.load offset=112 + (get_local $9) + ) + (tee_local $1 + (i64.load + (get_local $0) + ) + ) + ) + ) + (br_if $label$0 + (i64.ne + (i64.load offset=120 + (get_local $9) + ) + (get_local $1) + ) + ) + (set_local $5 + (i32.add + (get_local $9) + (i32.const 144) + ) + ) + (block $label$1 + (br_if $label$1 + (i32.ne + (tee_local $4 + (call $strlen + (i32.const 1376) + ) + ) + (select + (i32.load + (tee_local $8 + (i32.add + (get_local $9) + (i32.const 148) + ) + ) + ) + (i32.shr_u + (tee_local $7 + (i32.load8_u offset=144 + (get_local $9) + ) + ) + (i32.const 1) + ) + (i32.and + (get_local $7) + (i32.const 1) + ) + ) + ) + ) + (br_if $label$0 + (i32.eqz + (call $_ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7compareEjjPKcj + (get_local $5) + (i32.const 0) + (i32.const -1) + (i32.const 1376) + (get_local $4) + ) + ) + ) + ) + (block $label$2 + (block $label$3 + (br_if $label$3 + (i32.ne + (tee_local $4 + (call $strlen + (i32.const 960) + ) + ) + (select + (i32.load + (get_local $8) + ) + (i32.shr_u + (tee_local $7 + (i32.load8_u + (get_local $5) + ) + ) + (i32.const 1) + ) + (i32.and + (get_local $7) + (i32.const 1) + ) + ) + ) + ) + (set_local $7 + (i32.const 0) + ) + (br_if $label$2 + (i32.eqz + (call $_ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7compareEjjPKcj + (get_local $5) + (i32.const 0) + (i32.const -1) + (i32.const 960) + (get_local $4) + ) + ) + ) + ) + (call $eosio_assert + (i32.load8_u + (i32.add + (get_local $0) + (i32.const 140) + ) + ) + (i32.const 1504) + ) + (call $eosio_assert + (i64.eq + (i64.load + (tee_local $7 + (i32.add + (i32.add + (get_local $9) + (i32.const 112) + ) + (i32.const 24) + ) + ) + ) + (i64.const 1397703940) + ) + (i32.const 1648) + ) + (set_local $8 + (i32.const 0) + ) + (block $label$4 + (br_if $label$4 + (i64.ge_u + (i64.add + (i64.load + (tee_local $4 + (i32.add + (get_local $9) + (i32.const 128) + ) + ) + ) + (i64.const 4611686018427387903) + ) + (i64.const 9223372036854775807) + ) + ) + (set_local $1 + (i64.shr_u + (i64.load + (get_local $7) + ) + (i64.const 8) + ) + ) + (set_local $7 + (i32.const 0) + ) + (block $label$5 + (loop $label$6 + (br_if $label$5 + (i32.gt_u + (i32.add + (i32.shl + (i32.wrap/i64 + (get_local $1) + ) + (i32.const 24) + ) + (i32.const -1073741825) + ) + (i32.const 452984830) + ) + ) + (block $label$7 + (br_if $label$7 + (i64.ne + (i64.and + (tee_local $1 + (i64.shr_u + (get_local $1) + (i64.const 8) + ) + ) + (i64.const 255) + ) + (i64.const 0) + ) + ) + (loop $label$8 + (br_if $label$5 + (i64.ne + (i64.and + (tee_local $1 + (i64.shr_u + (get_local $1) + (i64.const 8) + ) + ) + (i64.const 255) + ) + (i64.const 0) + ) + ) + (br_if $label$8 + (i32.lt_s + (tee_local $7 + (i32.add + (get_local $7) + (i32.const 1) + ) + ) + (i32.const 7) + ) + ) + ) + ) + (set_local $8 + (i32.const 1) + ) + (br_if $label$6 + (i32.lt_s + (tee_local $7 + (i32.add + (get_local $7) + (i32.const 1) + ) + ) + (i32.const 7) + ) + ) + (br $label$4) + ) + ) + (set_local $8 + (i32.const 0) + ) + ) + (call $eosio_assert + (get_local $8) + (i32.const 1536) + ) + (call $eosio_assert + (i64.ge_s + (i64.load + (get_local $4) + ) + (i64.load offset=48 + (get_local $0) + ) + ) + (i32.const 1568) + ) + (i64.store + (tee_local $7 + (i32.add + (i32.add + (get_local $9) + (i32.const 32) + ) + (i32.const 8) + ) + ) + (i64.load + (i32.add + (get_local $4) + (i32.const 8) + ) + ) + ) + (set_local $1 + (i64.load offset=112 + (get_local $9) + ) + ) + (i64.store offset=32 + (get_local $9) + (i64.load + (get_local $4) + ) + ) + (drop + (call $_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEC2ERKS5_ + (i32.add + (get_local $9) + (i32.const 16) + ) + (get_local $5) + ) + ) + (i64.store + (i32.add + (get_local $9) + (i32.const 8) + ) + (i64.load + (get_local $7) + ) + ) + (i64.store + (get_local $9) + (i64.load offset=32 + (get_local $9) + ) + ) + (call $_ZN6eoswin7lottery7buykeysEyN5eosio5assetENSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE + (i32.add + (get_local $9) + (i32.const 48) + ) + (get_local $0) + (get_local $1) + (get_local $9) + (i32.add + (get_local $9) + (i32.const 16) + ) + ) + (block $label$9 + (br_if $label$9 + (i32.eqz + (i32.and + (i32.load8_u offset=16 + (get_local $9) + ) + (i32.const 1) + ) + ) + ) + (call $_ZdlPv + (i32.load offset=24 + (get_local $9) + ) + ) + ) + (set_local $1 + (i64.load + (i32.add + (get_local $0) + (i32.const 64) + ) + ) + ) + (block $label$10 + (br_if $label$10 + (i32.eq + (tee_local $8 + (i32.load + (i32.add + (get_local $0) + (i32.const 172) + ) + ) + ) + (tee_local $3 + (i32.load + (i32.add + (get_local $0) + (i32.const 168) + ) + ) + ) + ) + ) + (set_local $7 + (i32.add + (get_local $8) + (i32.const -24) + ) + ) + (set_local $4 + (i32.sub + (i32.const 0) + (get_local $3) + ) + ) + (loop $label$11 + (br_if $label$10 + (i64.eq + (i64.load + (i32.load + (get_local $7) + ) + ) + (get_local $1) + ) + ) + (set_local $8 + (get_local $7) + ) + (set_local $7 + (tee_local $5 + (i32.add + (get_local $7) + (i32.const -24) + ) + ) + ) + (br_if $label$11 + (i32.ne + (i32.add + (get_local $5) + (get_local $4) + ) + (i32.const -24) + ) + ) + ) + ) + (set_local $5 + (i32.add + (get_local $0) + (i32.const 144) + ) + ) + (block $label$12 + (block $label$13 + (br_if $label$13 + (i32.eq + (get_local $8) + (get_local $3) + ) + ) + (call $eosio_assert + (i32.eq + (i32.load offset=80 + (tee_local $7 + (i32.load + (i32.add + (get_local $8) + (i32.const -24) + ) + ) + ) + ) + (get_local $5) + ) + (i32.const 32) + ) + (br $label$12) + ) + (set_local $7 + (i32.const 0) + ) + (br_if $label$12 + (i32.lt_s + (tee_local $8 + (call $db_find_i64 + (i64.load + (i32.add + (get_local $0) + (i32.const 144) + ) + ) + (i64.load + (i32.add + (get_local $0) + (i32.const 152) + ) + ) + (i64.const -4812882490098188288) + (get_local $1) + ) + ) + (i32.const 0) + ) + ) + (call $eosio_assert + (i32.eq + (i32.load offset=80 + (tee_local $7 + (call $_ZNK5eosio11multi_indexILy13633861583611363328EN6eoswin10round_itemEJEE31load_object_by_primary_iteratorEl + (get_local $5) + (get_local $8) + ) + ) + ) + (get_local $5) + ) + (i32.const 32) + ) + ) + (call $eosio_assert + (tee_local $8 + (i32.ne + (get_local $7) + (i32.const 0) + ) + ) + (i32.const 1616) + ) + (call $eosio_assert + (get_local $8) + (i32.const 288) + ) + (call $eosio_assert + (i32.eq + (i32.load offset=80 + (get_local $7) + ) + (get_local $5) + ) + (i32.const 416) + ) + (call $eosio_assert + (i64.eq + (i64.load + (i32.add + (get_local $0) + (i32.const 144) + ) + ) + (call $current_receiver) + ) + (i32.const 464) + ) + (set_local $1 + (i64.load + (get_local $7) + ) + ) + (call $eosio_assert + (i64.eq + (i64.load + (i32.add + (get_local $9) + (i32.const 136) + ) + ) + (i64.load + (i32.add + (get_local $7) + (i32.const 32) + ) + ) + ) + (i32.const 1392) + ) + (i64.store offset=24 + (get_local $7) + (tee_local $6 + (i64.add + (i64.load offset=24 + (get_local $7) + ) + (i64.load offset=128 + (get_local $9) + ) + ) + ) + ) + (call $eosio_assert + (i64.gt_s + (get_local $6) + (i64.const -4611686018427387904) + ) + (i32.const 1440) + ) + (call $eosio_assert + (i64.lt_s + (i64.load offset=24 + (get_local $7) + ) + (i64.const 4611686018427387904) + ) + (i32.const 1472) + ) + (i64.store offset=8 + (get_local $7) + (i64.add + (i64.load offset=8 + (get_local $7) + ) + (i64.const 1) + ) + ) + (call $eosio_assert + (i64.eq + (get_local $1) + (i64.load + (get_local $7) + ) + ) + (i32.const 528) + ) + (i32.store offset=280 + (get_local $9) + (i32.add + (i32.add + (get_local $9) + (i32.const 192) + ) + (i32.const 80) + ) + ) + (i32.store offset=276 + (get_local $9) + (i32.add + (get_local $9) + (i32.const 192) + ) + ) + (i32.store offset=272 + (get_local $9) + (i32.add + (get_local $9) + (i32.const 192) + ) + ) + (drop + (call $_ZN6eoswinlsIN5eosio10datastreamIPcEEEERT_S6_RKNS_10round_itemE + (i32.add + (get_local $9) + (i32.const 272) + ) + (get_local $7) + ) + ) + (call $db_update_i64 + (i32.load offset=84 + (get_local $7) + ) + (i64.const 0) + (i32.add + (get_local $9) + (i32.const 192) + ) + (i32.const 80) + ) + (br_if $label$0 + (i64.lt_u + (get_local $1) + (i64.load + (tee_local $7 + (i32.add + (get_local $0) + (i32.const 160) + ) + ) + ) + ) + ) + (i64.store + (get_local $7) + (select + (i64.const -2) + (i64.add + (get_local $1) + (i64.const 1) + ) + (i64.gt_u + (get_local $1) + (i64.const -3) + ) + ) + ) + (br $label$0) + ) + (i64.store offset=64 + (get_local $9) + (i64.const -1) + ) + (i32.store offset=72 + (get_local $9) + (i32.const 0) + ) + (i64.store offset=48 + (get_local $9) + (tee_local $1 + (i64.load + (get_local $0) + ) + ) + ) + (i64.store offset=56 + (get_local $9) + (i64.load + (i32.add + (get_local $0) + (i32.const 64) + ) + ) + ) + (i32.store + (i32.add + (get_local $9) + (i32.const 76) + ) + (i32.const 0) + ) + (i32.store + (i32.add + (get_local $9) + (i32.const 80) + ) + (i32.const 0) + ) + (i32.store8 offset=84 + (get_local $9) + (i32.const 0) + ) + (i32.store offset=276 + (get_local $9) + (i32.add + (get_local $9) + (i32.const 160) + ) + ) + (i32.store offset=272 + (get_local $9) + (i32.add + (get_local $9) + (i32.const 48) + ) + ) + (i32.store offset=280 + (get_local $9) + (i32.add + (get_local $9) + (i32.const 112) + ) + ) + (i64.store offset=184 + (get_local $9) + (get_local $1) + ) + (call $eosio_assert + (i64.eq + (get_local $1) + (call $current_receiver) + ) + (i32.const 336) + ) + (i32.store offset=196 + (get_local $9) + (i32.add + (get_local $9) + (i32.const 272) + ) + ) + (i32.store offset=192 + (get_local $9) + (i32.add + (get_local $9) + (i32.const 48) + ) + ) + (i32.store offset=200 + (get_local $9) + (i32.add + (get_local $9) + (i32.const 184) + ) + ) + (i64.store offset=40 + (tee_local $8 + (call $_Znwj + (i32.const 80) + ) + ) + (i64.const 1397703940) + ) + (i64.store offset=32 + (get_local $8) + (i64.const 0) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 176) + ) + (set_local $1 + (i64.const 5459781) + ) + (block $label$14 + (loop $label$15 + (set_local $5 + (i32.const 0) + ) + (br_if $label$14 + (i32.gt_u + (i32.add + (i32.shl + (i32.wrap/i64 + (get_local $1) + ) + (i32.const 24) + ) + (i32.const -1073741825) + ) + (i32.const 452984830) + ) + ) + (block $label$16 + (br_if $label$16 + (i64.ne + (i64.and + (tee_local $1 + (i64.shr_u + (get_local $1) + (i64.const 8) + ) + ) + (i64.const 255) + ) + (i64.const 0) + ) + ) + (loop $label$17 + (br_if $label$14 + (i64.ne + (i64.and + (tee_local $1 + (i64.shr_u + (get_local $1) + (i64.const 8) + ) + ) + (i64.const 255) + ) + (i64.const 0) + ) + ) + (br_if $label$17 + (i32.lt_s + (tee_local $7 + (i32.add + (get_local $7) + (i32.const 1) + ) + ) + (i32.const 7) + ) + ) + ) + ) + (set_local $5 + (i32.const 1) + ) + (br_if $label$15 + (i32.lt_s + (tee_local $7 + (i32.add + (get_local $7) + (i32.const 1) + ) + ) + (i32.const 7) + ) + ) + ) + ) + (call $eosio_assert + (get_local $5) + (i32.const 128) + ) + (i32.store offset=64 + (get_local $8) + (i32.add + (get_local $9) + (i32.const 48) + ) + ) + (call $_ZZN5eosio11multi_indexILy4297309255767162880EN6eoswin9bill_itemEJNS_10indexed_byILy4587782057278570496EN5boost11multi_index13const_mem_funIS2_yXadL_ZNKS2_8byplayerEvEEEEEEEE7emplaceIZNS1_7lottery8transferEyyE3$_4EENS9_14const_iteratorEyOT_ENKUlRSE_E_clINS9_4itemEEEDaSG_ + (i32.add + (get_local $9) + (i32.const 192) + ) + (get_local $8) + ) + (i32.store offset=176 + (get_local $9) + (get_local $8) + ) + (i64.store offset=192 + (get_local $9) + (tee_local $1 + (i64.load + (get_local $8) + ) + ) + ) + (i32.store offset=172 + (get_local $9) + (tee_local $5 + (i32.load offset=68 + (get_local $8) + ) + ) + ) + (block $label$18 + (block $label$19 + (br_if $label$19 + (i32.ge_u + (tee_local $7 + (i32.load + (tee_local $4 + (i32.add + (get_local $9) + (i32.const 76) + ) + ) + ) + ) + (i32.load + (i32.add + (get_local $9) + (i32.const 80) + ) + ) + ) + ) + (i64.store offset=8 + (get_local $7) + (get_local $1) + ) + (i32.store offset=16 + (get_local $7) + (get_local $5) + ) + (i32.store offset=176 + (get_local $9) + (i32.const 0) + ) + (i32.store + (get_local $7) + (get_local $8) + ) + (i32.store + (get_local $4) + (i32.add + (get_local $7) + (i32.const 24) + ) + ) + (br $label$18) + ) + (call $_ZNSt3__16vectorIN5eosio11multi_indexILy4297309255767162880EN6eoswin9bill_itemEJNS1_10indexed_byILy4587782057278570496EN5boost11multi_index13const_mem_funIS4_yXadL_ZNKS4_8byplayerEvEEEEEEEE8item_ptrENS_9allocatorISC_EEE24__emplace_back_slow_pathIJNS_10unique_ptrINSB_4itemENS_14default_deleteISI_EEEERyRlEEEvDpOT_ + (i32.add + (get_local $9) + (i32.const 72) + ) + (i32.add + (get_local $9) + (i32.const 176) + ) + (i32.add + (get_local $9) + (i32.const 192) + ) + (i32.add + (get_local $9) + (i32.const 172) + ) + ) + ) + (set_local $7 + (i32.load offset=176 + (get_local $9) + ) + ) + (i32.store offset=176 + (get_local $9) + (i32.const 0) + ) + (block $label$20 + (br_if $label$20 + (i32.eqz + (get_local $7) + ) + ) + (call $_ZdlPv + (get_local $7) + ) + ) + (set_local $1 + (i64.load + (i32.add + (get_local $0) + (i32.const 64) + ) + ) + ) + (block $label$21 + (br_if $label$21 + (i32.eq + (tee_local $8 + (i32.load + (i32.add + (get_local $0) + (i32.const 172) + ) + ) + ) + (tee_local $3 + (i32.load + (i32.add + (get_local $0) + (i32.const 168) + ) + ) + ) + ) + ) + (set_local $7 + (i32.add + (get_local $8) + (i32.const -24) + ) + ) + (set_local $4 + (i32.sub + (i32.const 0) + (get_local $3) + ) + ) + (loop $label$22 + (br_if $label$21 + (i64.eq + (i64.load + (i32.load + (get_local $7) + ) + ) + (get_local $1) + ) + ) + (set_local $8 + (get_local $7) + ) + (set_local $7 + (tee_local $5 + (i32.add + (get_local $7) + (i32.const -24) + ) + ) + ) + (br_if $label$22 + (i32.ne + (i32.add + (get_local $5) + (get_local $4) + ) + (i32.const -24) + ) + ) + ) + ) + (set_local $5 + (i32.add + (get_local $0) + (i32.const 144) + ) + ) + (block $label$23 + (block $label$24 + (br_if $label$24 + (i32.eq + (get_local $8) + (get_local $3) + ) + ) + (call $eosio_assert + (i32.eq + (i32.load offset=80 + (tee_local $7 + (i32.load + (i32.add + (get_local $8) + (i32.const -24) + ) + ) + ) + ) + (get_local $5) + ) + (i32.const 32) + ) + (br $label$23) + ) + (set_local $7 + (i32.const 0) + ) + (br_if $label$23 + (i32.lt_s + (tee_local $8 + (call $db_find_i64 + (i64.load + (i32.add + (get_local $0) + (i32.const 144) + ) + ) + (i64.load + (i32.add + (get_local $0) + (i32.const 152) + ) + ) + (i64.const -4812882490098188288) + (get_local $1) + ) + ) + (i32.const 0) + ) + ) + (call $eosio_assert + (i32.eq + (i32.load offset=80 + (tee_local $7 + (call $_ZNK5eosio11multi_indexILy13633861583611363328EN6eoswin10round_itemEJEE31load_object_by_primary_iteratorEl + (get_local $5) + (get_local $8) + ) + ) + ) + (get_local $5) + ) + (i32.const 32) + ) + ) + (call $eosio_assert + (i32.ne + (get_local $7) + (i32.const 0) + ) + (i32.const 288) + ) + (call $eosio_assert + (i32.eq + (i32.load offset=80 + (get_local $7) + ) + (get_local $5) + ) + (i32.const 416) + ) + (call $eosio_assert + (i64.eq + (i64.load + (i32.add + (get_local $0) + (i32.const 144) + ) + ) + (call $current_receiver) + ) + (i32.const 464) + ) + (set_local $1 + (i64.load + (get_local $7) + ) + ) + (call $eosio_assert + (i64.eq + (i64.load + (i32.add + (get_local $9) + (i32.const 136) + ) + ) + (i64.load + (i32.add + (get_local $7) + (i32.const 32) + ) + ) + ) + (i32.const 1392) + ) + (i64.store offset=24 + (get_local $7) + (tee_local $6 + (i64.add + (i64.load offset=24 + (get_local $7) + ) + (i64.load offset=128 + (get_local $9) + ) + ) + ) + ) + (call $eosio_assert + (i64.gt_s + (get_local $6) + (i64.const -4611686018427387904) + ) + (i32.const 1440) + ) + (call $eosio_assert + (i64.lt_s + (i64.load offset=24 + (get_local $7) + ) + (i64.const 4611686018427387904) + ) + (i32.const 1472) + ) + (call $eosio_assert + (i64.eq + (get_local $1) + (i64.load + (get_local $7) + ) + ) + (i32.const 528) + ) + (i32.store offset=280 + (get_local $9) + (i32.add + (i32.add + (get_local $9) + (i32.const 192) + ) + (i32.const 80) + ) + ) + (i32.store offset=276 + (get_local $9) + (i32.add + (get_local $9) + (i32.const 192) + ) + ) + (i32.store offset=272 + (get_local $9) + (i32.add + (get_local $9) + (i32.const 192) + ) + ) + (drop + (call $_ZN6eoswinlsIN5eosio10datastreamIPcEEEERT_S6_RKNS_10round_itemE + (i32.add + (get_local $9) + (i32.const 272) + ) + (get_local $7) + ) + ) + (call $db_update_i64 + (i32.load offset=84 + (get_local $7) + ) + (i64.const 0) + (i32.add + (get_local $9) + (i32.const 192) + ) + (i32.const 80) + ) + (block $label$25 + (br_if $label$25 + (i64.lt_u + (get_local $1) + (i64.load + (tee_local $7 + (i32.add + (get_local $0) + (i32.const 160) + ) + ) + ) + ) + ) + (i64.store + (get_local $7) + (select + (i64.const -2) + (i64.add + (get_local $1) + (i64.const 1) + ) + (i64.gt_u + (get_local $1) + (i64.const -3) + ) + ) + ) + ) + (br_if $label$0 + (i32.eqz + (tee_local $5 + (i32.load offset=72 + (get_local $9) + ) + ) + ) + ) + (block $label$26 + (block $label$27 + (br_if $label$27 + (i32.eq + (tee_local $7 + (i32.load + (tee_local $8 + (i32.add + (get_local $9) + (i32.const 76) + ) + ) + ) + ) + (get_local $5) + ) + ) + (loop $label$28 + (set_local $0 + (i32.load + (tee_local $7 + (i32.add + (get_local $7) + (i32.const -24) + ) + ) + ) + ) + (i32.store + (get_local $7) + (i32.const 0) + ) + (block $label$29 + (br_if $label$29 + (i32.eqz + (get_local $0) + ) + ) + (call $_ZdlPv + (get_local $0) + ) + ) + (br_if $label$28 + (i32.ne + (get_local $5) + (get_local $7) + ) + ) + ) + (set_local $7 + (i32.load + (i32.add + (get_local $9) + (i32.const 72) + ) + ) + ) + (br $label$26) + ) + (set_local $7 + (get_local $5) + ) + ) + (i32.store + (get_local $8) + (get_local $5) + ) + (call $_ZdlPv + (get_local $7) + ) + ) + (block $label$30 + (br_if $label$30 + (i32.eqz + (i32.and + (i32.load8_u offset=144 + (get_local $9) + ) + (i32.const 1) + ) + ) + ) + (call $_ZdlPv + (i32.load + (i32.add + (get_local $9) + (i32.const 152) + ) + ) + ) + ) + (i32.store offset=4 + (i32.const 0) + (i32.add + (get_local $9) + (i32.const 288) + ) + ) + ) + (func $_ZN5eosio18unpack_action_dataINS_8currency8transferEEET_v (param $0 i32) + (local $1 i32) + (local $2 i32) + (local $3 i64) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (set_local $6 + (tee_local $4 + (i32.sub + (i32.load offset=4 + (i32.const 0) + ) + (i32.const 16) + ) + ) + ) + (i32.store offset=4 + (i32.const 0) + (get_local $4) + ) + (block $label$0 + (block $label$1 + (br_if $label$1 + (i32.lt_u + (tee_local $1 + (call $action_data_size) + ) + (i32.const 513) + ) + ) + (set_local $2 + (call $malloc + (get_local $1) + ) + ) + (br $label$0) + ) + (i32.store offset=4 + (i32.const 0) + (tee_local $2 + (i32.sub + (get_local $4) + (i32.and + (i32.add + (get_local $1) + (i32.const 15) + ) + (i32.const -16) + ) + ) + ) + ) + ) + (drop + (call $read_action_data + (get_local $2) + (get_local $1) + ) + ) + (i64.store + (i32.add + (get_local $0) + (i32.const 24) + ) + (i64.const 1397703940) + ) + (i64.store offset=16 + (get_local $0) + (i64.const 0) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 176) + ) + (set_local $3 + (i64.const 5459781) + ) + (set_local $4 + (i32.const 0) + ) + (block $label$2 + (block $label$3 + (loop $label$4 + (br_if $label$3 + (i32.gt_u + (i32.add + (i32.shl + (i32.wrap/i64 + (get_local $3) + ) + (i32.const 24) + ) + (i32.const -1073741825) + ) + (i32.const 452984830) + ) + ) + (block $label$5 + (br_if $label$5 + (i64.ne + (i64.and + (tee_local $3 + (i64.shr_u + (get_local $3) + (i64.const 8) + ) + ) + (i64.const 255) + ) + (i64.const 0) + ) + ) + (loop $label$6 + (br_if $label$3 + (i64.ne + (i64.and + (tee_local $3 + (i64.shr_u + (get_local $3) + (i64.const 8) + ) + ) + (i64.const 255) + ) + (i64.const 0) + ) + ) + (br_if $label$6 + (i32.lt_s + (tee_local $4 + (i32.add + (get_local $4) + (i32.const 1) + ) + ) + (i32.const 7) + ) + ) + ) + ) + (set_local $5 + (i32.const 1) + ) + (br_if $label$4 + (i32.lt_s + (tee_local $4 + (i32.add + (get_local $4) + (i32.const 1) + ) + ) + (i32.const 7) + ) + ) + (br $label$2) + ) + ) + (set_local $5 + (i32.const 0) + ) + ) + (call $eosio_assert + (get_local $5) + (i32.const 128) + ) + (i32.store + (i32.add + (get_local $0) + (i32.const 40) + ) + (i32.const 0) + ) + (i64.store offset=32 align=4 + (get_local $0) + (i64.const 0) + ) + (i32.store offset=4 + (get_local $6) + (get_local $2) + ) + (i32.store + (get_local $6) + (get_local $2) + ) + (i32.store offset=8 + (get_local $6) + (i32.add + (get_local $2) + (get_local $1) + ) + ) + (drop + (call $_ZN5eosiorsINS_10datastreamIPKcEEEERT_S6_RNS_8currency8transferE + (get_local $6) + (get_local $0) + ) + ) + (block $label$7 + (br_if $label$7 + (i32.lt_u + (get_local $1) + (i32.const 513) + ) + ) + (call $free + (get_local $2) + ) + ) + (i32.store offset=4 + (i32.const 0) + (i32.add + (get_local $6) + (i32.const 16) + ) + ) + ) + (func $_ZZN5eosio11multi_indexILy4297309255767162880EN6eoswin9bill_itemEJNS_10indexed_byILy4587782057278570496EN5boost11multi_index13const_mem_funIS2_yXadL_ZNKS2_8byplayerEvEEEEEEEE7emplaceIZNS1_7lottery8transferEyyE3$_4EENS9_14const_iteratorEyOT_ENKUlRSE_E_clINS9_4itemEEEDaSG_ (param $0 i32) (param $1 i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i64) + (local $7 i64) + (local $8 i64) + (local $9 i64) + (local $10 i32) + (local $11 i32) + (set_local $10 + (tee_local $11 + (i32.sub + (i32.load offset=4 + (i32.const 0) + ) + (i32.const 32) + ) + ) + ) + (i32.store offset=4 + (i32.const 0) + (get_local $11) + ) + (set_local $2 + (i32.load + (get_local $0) + ) + ) + (block $label$0 + (br_if $label$0 + (i64.ne + (tee_local $7 + (i64.load offset=16 + (tee_local $5 + (i32.load + (tee_local $4 + (i32.load offset=4 + (get_local $0) + ) + ) + ) + ) + ) + ) + (i64.const -1) + ) + ) + (set_local $7 + (i64.const 0) + ) + (block $label$1 + (br_if $label$1 + (i32.lt_s + (tee_local $3 + (call $db_lowerbound_i64 + (i64.load + (get_local $5) + ) + (i64.load offset=8 + (get_local $5) + ) + (i64.const 4297309255767162880) + (i64.const 0) + ) + ) + (i32.const 0) + ) + ) + (drop + (call $_ZNK5eosio11multi_indexILy4297309255767162880EN6eoswin9bill_itemEJNS_10indexed_byILy4587782057278570496EN5boost11multi_index13const_mem_funIS2_yXadL_ZNKS2_8byplayerEvEEEEEEEE31load_object_by_primary_iteratorEl + (get_local $5) + (get_local $3) + ) + ) + (i32.store offset=12 + (get_local $10) + (i32.const 0) + ) + (i32.store offset=8 + (get_local $10) + (get_local $5) + ) + (set_local $7 + (select + (i64.const -2) + (i64.add + (tee_local $7 + (i64.load + (i32.load offset=4 + (call $_ZN5eosio11multi_indexILy4297309255767162880EN6eoswin9bill_itemEJNS_10indexed_byILy4587782057278570496EN5boost11multi_index13const_mem_funIS2_yXadL_ZNKS2_8byplayerEvEEEEEEEE14const_iteratormmEv + (i32.add + (get_local $10) + (i32.const 8) + ) + ) + ) + ) + ) + (i64.const 1) + ) + (i64.gt_u + (get_local $7) + (i64.const -3) + ) + ) + ) + ) + (i64.store + (i32.add + (get_local $5) + (i32.const 16) + ) + (get_local $7) + ) + ) + (call $eosio_assert + (i64.lt_u + (get_local $7) + (i64.const -2) + ) + (i32.const 2080) + ) + (i64.store + (get_local $1) + (i64.load + (i32.add + (get_local $5) + (i32.const 16) + ) + ) + ) + (i64.store offset=8 + (get_local $1) + (i64.load + (i32.load offset=4 + (get_local $4) + ) + ) + ) + (set_local $5 + (i32.load offset=8 + (get_local $4) + ) + ) + (i64.store offset=24 + (get_local $1) + (i64.const 0) + ) + (i64.store offset=16 + (get_local $1) + (i64.load offset=16 + (get_local $5) + ) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 176) + ) + (set_local $7 + (i64.const 383514793292) + ) + (set_local $5 + (i32.const 0) + ) + (block $label$2 + (block $label$3 + (loop $label$4 + (br_if $label$3 + (i32.gt_u + (i32.add + (i32.shl + (i32.wrap/i64 + (get_local $7) + ) + (i32.const 24) + ) + (i32.const -1073741825) + ) + (i32.const 452984830) + ) + ) + (block $label$5 + (br_if $label$5 + (i64.ne + (i64.and + (tee_local $7 + (i64.shr_u + (get_local $7) + (i64.const 8) + ) + ) + (i64.const 255) + ) + (i64.const 0) + ) + ) + (loop $label$6 + (br_if $label$3 + (i64.ne + (i64.and + (tee_local $7 + (i64.shr_u + (get_local $7) + (i64.const 8) + ) + ) + (i64.const 255) + ) + (i64.const 0) + ) + ) + (br_if $label$6 + (i32.lt_s + (tee_local $5 + (i32.add + (get_local $5) + (i32.const 1) + ) + ) + (i32.const 7) + ) + ) + ) + ) + (set_local $4 + (i32.const 1) + ) + (br_if $label$4 + (i32.lt_s + (tee_local $5 + (i32.add + (get_local $5) + (i32.const 1) + ) + ) + (i32.const 7) + ) + ) + (br $label$2) + ) + ) + (set_local $4 + (i32.const 0) + ) + ) + (call $eosio_assert + (get_local $4) + (i32.const 128) + ) + (i64.store + (i32.add + (get_local $1) + (i32.const 40) + ) + (i64.const 98179787082756) + ) + (set_local $7 + (i64.const 0) + ) + (i64.store offset=32 + (get_local $1) + (i64.const 0) + ) + (set_local $6 + (i64.const 59) + ) + (set_local $5 + (i32.const 960) + ) + (set_local $8 + (i64.const 0) + ) + (loop $label$7 + (block $label$8 + (block $label$9 + (block $label$10 + (block $label$11 + (block $label$12 + (br_if $label$12 + (i64.gt_u + (get_local $7) + (i64.const 7) + ) + ) + (br_if $label$11 + (i32.gt_u + (i32.and + (i32.add + (tee_local $4 + (i32.load8_s + (get_local $5) + ) + ) + (i32.const -97) + ) + (i32.const 255) + ) + (i32.const 25) + ) + ) + (set_local $4 + (i32.add + (get_local $4) + (i32.const 165) + ) + ) + (br $label$10) + ) + (set_local $9 + (i64.const 0) + ) + (br_if $label$9 + (i64.le_u + (get_local $7) + (i64.const 11) + ) + ) + (br $label$8) + ) + (set_local $4 + (select + (i32.add + (get_local $4) + (i32.const 208) + ) + (i32.const 0) + (i32.lt_u + (i32.and + (i32.add + (get_local $4) + (i32.const -49) + ) + (i32.const 255) + ) + (i32.const 5) + ) + ) + ) + ) + (set_local $9 + (i64.shr_s + (i64.shl + (i64.extend_u/i32 + (get_local $4) + ) + (i64.const 56) + ) + (i64.const 56) + ) + ) + ) + (set_local $9 + (i64.shl + (i64.and + (get_local $9) + (i64.const 31) + ) + (i64.and + (get_local $6) + (i64.const 4294967295) + ) + ) + ) + ) + (set_local $5 + (i32.add + (get_local $5) + (i32.const 1) + ) + ) + (set_local $7 + (i64.add + (get_local $7) + (i64.const 1) + ) + ) + (set_local $8 + (i64.or + (get_local $9) + (get_local $8) + ) + ) + (br_if $label$7 + (i64.ne + (tee_local $6 + (i64.add + (get_local $6) + (i64.const -5) + ) + ) + (i64.const -6) + ) + ) + ) + (i64.store offset=48 + (get_local $1) + (get_local $8) + ) + (i64.store offset=56 + (get_local $1) + (call $current_time) + ) + (i32.store offset=4 + (i32.const 0) + (tee_local $5 + (i32.add + (tee_local $4 + (get_local $11) + ) + (i32.const -64) + ) + ) + ) + (i32.store offset=12 + (get_local $10) + (get_local $5) + ) + (i32.store offset=8 + (get_local $10) + (get_local $5) + ) + (i32.store offset=16 + (get_local $10) + (get_local $4) + ) + (drop + (call $_ZN6eoswinlsIN5eosio10datastreamIPcEEEERT_S6_RKNS_9bill_itemE + (i32.add + (get_local $10) + (i32.const 8) + ) + (get_local $1) + ) + ) + (i32.store offset=68 + (get_local $1) + (call $db_store_i64 + (i64.load offset=8 + (get_local $2) + ) + (i64.const 4297309255767162880) + (i64.load + (i32.load offset=8 + (get_local $0) + ) + ) + (tee_local $7 + (i64.load + (get_local $1) + ) + ) + (get_local $5) + (i32.const 64) + ) + ) + (block $label$13 + (br_if $label$13 + (i64.lt_u + (get_local $7) + (i64.load offset=16 + (get_local $2) + ) + ) + ) + (i64.store + (i32.add + (get_local $2) + (i32.const 16) + ) + (select + (i64.const -2) + (i64.add + (get_local $7) + (i64.const 1) + ) + (i64.gt_u + (get_local $7) + (i64.const -3) + ) + ) + ) + ) + (set_local $7 + (i64.load + (i32.add + (get_local $2) + (i32.const 8) + ) + ) + ) + (set_local $9 + (i64.load + (i32.load + (i32.add + (get_local $0) + (i32.const 8) + ) + ) + ) + ) + (set_local $6 + (i64.load + (get_local $1) + ) + ) + (i64.store offset=24 + (get_local $10) + (i64.load + (i32.add + (get_local $1) + (i32.const 8) + ) + ) + ) + (i32.store offset=72 + (get_local $1) + (call $db_idx64_store + (get_local $7) + (i64.const 4297309255767162880) + (get_local $9) + (get_local $6) + (i32.add + (get_local $10) + (i32.const 24) + ) + ) + ) + (i32.store offset=4 + (i32.const 0) + (i32.add + (get_local $10) + (i32.const 32) + ) + ) + ) + (func $_ZN6eoswin7lottery7buykeysEyN5eosio5assetENSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE (param $0 i32) (param $1 i32) (param $2 i64) (param $3 i32) (param $4 i32) + (local $5 i32) + (local $6 i64) + (local $7 i32) + (local $8 i32) + (local $9 i32) + (local $10 i32) + (local $11 i64) + (local $12 i64) + (local $13 i64) + (local $14 i64) + (local $15 i32) + (i32.store offset=4 + (i32.const 0) + (tee_local $15 + (i32.sub + (i32.load offset=4 + (i32.const 0) + ) + (i32.const 368) + ) + ) + ) + (drop + (call $_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEC2ERKS5_ + (i32.add + (get_local $15) + (i32.const 256) + ) + (get_local $4) + ) + ) + (block $label$0 + (block $label$1 + (block $label$2 + (br_if $label$2 + (i32.ne + (tee_local $10 + (call $strlen + (i32.const 1664) + ) + ) + (select + (i32.load offset=260 + (get_local $15) + ) + (i32.shr_u + (tee_local $4 + (i32.load8_u offset=256 + (get_local $15) + ) + ) + (i32.const 1) + ) + (i32.and + (get_local $4) + (i32.const 1) + ) + ) + ) + ) + (br_if $label$1 + (i32.eqz + (call $_ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7compareEjjPKcj + (i32.add + (get_local $15) + (i32.const 256) + ) + (i32.const 0) + (i32.const -1) + (i32.const 1664) + (get_local $10) + ) + ) + ) + (set_local $4 + (i32.load8_u offset=256 + (get_local $15) + ) + ) + ) + (set_local $4 + (select + (i32.load offset=264 + (get_local $15) + ) + (i32.or + (i32.add + (get_local $15) + (i32.const 256) + ) + (i32.const 1) + ) + (i32.and + (get_local $4) + (i32.const 1) + ) + ) + ) + (set_local $10 + (i32.const -1) + ) + (loop $label$3 + (set_local $9 + (i32.add + (get_local $4) + (get_local $10) + ) + ) + (set_local $10 + (tee_local $5 + (i32.add + (get_local $10) + (i32.const 1) + ) + ) + ) + (br_if $label$3 + (i32.load8_u + (i32.add + (get_local $9) + (i32.const 1) + ) + ) + ) + ) + (set_local $6 + (i64.extend_u/i32 + (get_local $5) + ) + ) + (set_local $12 + (i64.const 0) + ) + (set_local $11 + (i64.const 59) + ) + (set_local $14 + (i64.const 0) + ) + (loop $label$4 + (set_local $13 + (i64.const 0) + ) + (block $label$5 + (br_if $label$5 + (i64.ge_u + (get_local $12) + (get_local $6) + ) + ) + (block $label$6 + (block $label$7 + (br_if $label$7 + (i32.gt_u + (i32.and + (i32.add + (tee_local $10 + (i32.load8_s + (get_local $4) + ) + ) + (i32.const -97) + ) + (i32.const 255) + ) + (i32.const 25) + ) + ) + (set_local $10 + (i32.add + (get_local $10) + (i32.const 165) + ) + ) + (br $label$6) + ) + (set_local $10 + (select + (i32.add + (get_local $10) + (i32.const 208) + ) + (i32.const 0) + (i32.lt_u + (i32.and + (i32.add + (get_local $10) + (i32.const -49) + ) + (i32.const 255) + ) + (i32.const 5) + ) + ) + ) + ) + (set_local $13 + (i64.shr_s + (i64.shl + (i64.extend_u/i32 + (get_local $10) + ) + (i64.const 56) + ) + (i64.const 56) + ) + ) + ) + (block $label$8 + (block $label$9 + (br_if $label$9 + (i64.gt_u + (get_local $12) + (i64.const 11) + ) + ) + (set_local $13 + (i64.shl + (i64.and + (get_local $13) + (i64.const 31) + ) + (i64.and + (get_local $11) + (i64.const 4294967295) + ) + ) + ) + (br $label$8) + ) + (set_local $13 + (i64.and + (get_local $13) + (i64.const 15) + ) + ) + ) + (set_local $4 + (i32.add + (get_local $4) + (i32.const 1) + ) + ) + (set_local $12 + (i64.add + (get_local $12) + (i64.const 1) + ) + ) + (set_local $14 + (i64.or + (get_local $13) + (get_local $14) + ) + ) + (br_if $label$4 + (i64.ne + (tee_local $11 + (i64.add + (get_local $11) + (i64.const -5) + ) + ) + (i64.const -6) + ) + ) + (br $label$0) + ) + ) + (set_local $14 + (i64.const 0) + ) + ) + (i64.store offset=32 + (get_local $0) + (i64.const 0) + ) + (i64.store + (i32.add + (get_local $0) + (i32.const 40) + ) + (i64.const 1397703940) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 176) + ) + (set_local $12 + (i64.const 5459781) + ) + (set_local $4 + (i32.const 0) + ) + (block $label$10 + (block $label$11 + (loop $label$12 + (br_if $label$11 + (i32.gt_u + (i32.add + (i32.shl + (i32.wrap/i64 + (get_local $12) + ) + (i32.const 24) + ) + (i32.const -1073741825) + ) + (i32.const 452984830) + ) + ) + (block $label$13 + (br_if $label$13 + (i64.ne + (i64.and + (tee_local $12 + (i64.shr_u + (get_local $12) + (i64.const 8) + ) + ) + (i64.const 255) + ) + (i64.const 0) + ) + ) + (loop $label$14 + (br_if $label$11 + (i64.ne + (i64.and + (tee_local $12 + (i64.shr_u + (get_local $12) + (i64.const 8) + ) + ) + (i64.const 255) + ) + (i64.const 0) + ) + ) + (br_if $label$14 + (i32.lt_s + (tee_local $4 + (i32.add + (get_local $4) + (i32.const 1) + ) + ) + (i32.const 7) + ) + ) + ) + ) + (set_local $10 + (i32.const 1) + ) + (br_if $label$12 + (i32.lt_s + (tee_local $4 + (i32.add + (get_local $4) + (i32.const 1) + ) + ) + (i32.const 7) + ) + ) + (br $label$10) + ) + ) + (set_local $10 + (i32.const 0) + ) + ) + (call $eosio_assert + (get_local $10) + (i32.const 128) + ) + (i64.store offset=48 + (get_local $0) + (get_local $14) + ) + (i64.store offset=8 + (get_local $0) + (get_local $2) + ) + (set_local $12 + (i64.load + (i32.add + (get_local $1) + (i32.const 64) + ) + ) + ) + (block $label$15 + (br_if $label$15 + (i32.eq + (tee_local $9 + (i32.load + (i32.add + (get_local $1) + (i32.const 172) + ) + ) + ) + (tee_local $8 + (i32.load + (i32.add + (get_local $1) + (i32.const 168) + ) + ) + ) + ) + ) + (set_local $4 + (i32.add + (get_local $9) + (i32.const -24) + ) + ) + (set_local $5 + (i32.sub + (i32.const 0) + (get_local $8) + ) + ) + (loop $label$16 + (br_if $label$15 + (i64.eq + (i64.load + (i32.load + (get_local $4) + ) + ) + (get_local $12) + ) + ) + (set_local $9 + (get_local $4) + ) + (set_local $4 + (tee_local $10 + (i32.add + (get_local $4) + (i32.const -24) + ) + ) + ) + (br_if $label$16 + (i32.ne + (i32.add + (get_local $10) + (get_local $5) + ) + (i32.const -24) + ) + ) + ) + ) + (set_local $7 + (i32.add + (get_local $1) + (i32.const 144) + ) + ) + (block $label$17 + (block $label$18 + (br_if $label$18 + (i32.eq + (get_local $9) + (get_local $8) + ) + ) + (call $eosio_assert + (i32.eq + (i32.load offset=80 + (tee_local $10 + (i32.load + (i32.add + (get_local $9) + (i32.const -24) + ) + ) + ) + ) + (get_local $7) + ) + (i32.const 32) + ) + (br $label$17) + ) + (set_local $10 + (i32.const 0) + ) + (br_if $label$17 + (i32.lt_s + (tee_local $4 + (call $db_find_i64 + (i64.load + (i32.add + (get_local $1) + (i32.const 144) + ) + ) + (i64.load + (i32.add + (get_local $1) + (i32.const 152) + ) + ) + (i64.const -4812882490098188288) + (get_local $12) + ) + ) + (i32.const 0) + ) + ) + (call $eosio_assert + (i32.eq + (i32.load offset=80 + (tee_local $10 + (call $_ZNK5eosio11multi_indexILy13633861583611363328EN6eoswin10round_itemEJEE31load_object_by_primary_iteratorEl + (get_local $7) + (get_local $4) + ) + ) + ) + (get_local $7) + ) + (i32.const 32) + ) + ) + (call $eosio_assert + (tee_local $8 + (i32.ne + (get_local $10) + (i32.const 0) + ) + ) + (i32.const 1680) + ) + (call $eosio_assert + (i64.eq + (i64.mul + (tee_local $12 + (i64.div_s + (tee_local $11 + (i64.load + (get_local $3) + ) + ) + (tee_local $13 + (i64.load offset=48 + (get_local $1) + ) + ) + ) + ) + (get_local $13) + ) + (get_local $11) + ) + (i32.const 1744) + ) + (i64.store offset=16 + (get_local $0) + (tee_local $11 + (i64.add + (i64.add + (get_local $12) + (tee_local $13 + (i64.load offset=16 + (get_local $10) + ) + ) + ) + (i64.const 1) + ) + ) + ) + (call $eosio_assert + (i64.gt_u + (get_local $11) + (get_local $13) + ) + (i32.const 1808) + ) + (i64.store + (i32.add + (get_local $0) + (i32.const 24) + ) + (tee_local $11 + (i64.add + (i64.add + (get_local $12) + (get_local $11) + ) + (i64.const -1) + ) + ) + ) + (call $eosio_assert + (i64.gt_u + (get_local $11) + (i64.load offset=16 + (get_local $10) + ) + ) + (i32.const 1856) + ) + (call $eosio_assert + (i64.lt_u + (i64.add + (tee_local $11 + (call $_ZN6eoswin7lottery4mineEy + (get_local $1) + (get_local $12) + ) + ) + (i64.const 4611686018427387903) + ) + (i64.const 9223372036854775807) + ) + (i32.const 176) + ) + (set_local $12 + (i64.const 383514793292) + ) + (set_local $4 + (i32.const 0) + ) + (block $label$19 + (block $label$20 + (loop $label$21 + (br_if $label$20 + (i32.gt_u + (i32.add + (i32.shl + (i32.wrap/i64 + (get_local $12) + ) + (i32.const 24) + ) + (i32.const -1073741825) + ) + (i32.const 452984830) + ) + ) + (block $label$22 + (br_if $label$22 + (i64.ne + (i64.and + (tee_local $12 + (i64.shr_u + (get_local $12) + (i64.const 8) + ) + ) + (i64.const 255) + ) + (i64.const 0) + ) + ) + (loop $label$23 + (br_if $label$20 + (i64.ne + (i64.and + (tee_local $12 + (i64.shr_u + (get_local $12) + (i64.const 8) + ) + ) + (i64.const 255) + ) + (i64.const 0) + ) + ) + (br_if $label$23 + (i32.lt_s + (tee_local $4 + (i32.add + (get_local $4) + (i32.const 1) + ) + ) + (i32.const 7) + ) + ) + ) + ) + (set_local $9 + (i32.const 1) + ) + (br_if $label$21 + (i32.lt_s + (tee_local $4 + (i32.add + (get_local $4) + (i32.const 1) + ) + ) + (i32.const 7) + ) + ) + (br $label$19) + ) + ) + (set_local $9 + (i32.const 0) + ) + ) + (call $eosio_assert + (get_local $9) + (i32.const 128) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 176) + ) + (set_local $12 + (i64.const 383514793292) + ) + (set_local $4 + (i32.const 0) + ) + (block $label$24 + (block $label$25 + (loop $label$26 + (br_if $label$25 + (i32.gt_u + (i32.add + (i32.shl + (i32.wrap/i64 + (get_local $12) + ) + (i32.const 24) + ) + (i32.const -1073741825) + ) + (i32.const 452984830) + ) + ) + (block $label$27 + (br_if $label$27 + (i64.ne + (i64.and + (tee_local $12 + (i64.shr_u + (get_local $12) + (i64.const 8) + ) + ) + (i64.const 255) + ) + (i64.const 0) + ) + ) + (loop $label$28 + (br_if $label$25 + (i64.ne + (i64.and + (tee_local $12 + (i64.shr_u + (get_local $12) + (i64.const 8) + ) + ) + (i64.const 255) + ) + (i64.const 0) + ) + ) + (br_if $label$28 + (i32.lt_s + (tee_local $4 + (i32.add + (get_local $4) + (i32.const 1) + ) + ) + (i32.const 7) + ) + ) + ) + ) + (set_local $9 + (i32.const 1) + ) + (br_if $label$26 + (i32.lt_s + (tee_local $4 + (i32.add + (get_local $4) + (i32.const 1) + ) + ) + (i32.const 7) + ) + ) + (br $label$24) + ) + ) + (set_local $9 + (i32.const 0) + ) + ) + (call $eosio_assert + (get_local $9) + (i32.const 128) + ) + (set_local $13 + (i64.const 0) + ) + (block $label$29 + (block $label$30 + (br_if $label$30 + (i64.eq + (get_local $14) + (i64.const 0) + ) + ) + (call $eosio_assert + (i64.ne + (get_local $14) + (get_local $2) + ) + (i32.const 1904) + ) + (call $__multi3 + (i32.add + (get_local $15) + (i32.const 64) + ) + (i64.load8_u + (i32.add + (get_local $1) + (i32.const 114) + ) + ) + (i64.const 0) + (get_local $11) + (tee_local $6 + (i64.shr_s + (get_local $11) + (i64.const 63) + ) + ) + ) + (call $eosio_assert + (select + (i64.lt_u + (tee_local $13 + (i64.load offset=64 + (get_local $15) + ) + ) + (i64.const 4611686018427387904) + ) + (i64.lt_s + (tee_local $12 + (i64.load + (i32.add + (get_local $15) + (i32.const 72) + ) + ) + ) + (i64.const 0) + ) + (i64.eqz + (get_local $12) + ) + ) + (i32.const 768) + ) + (call $eosio_assert + (select + (i64.gt_u + (get_local $13) + (i64.const -4611686018427387904) + ) + (i64.gt_s + (get_local $12) + (i64.const -1) + ) + (i64.eq + (get_local $12) + (i64.const -1) + ) + ) + (i32.const 800) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 832) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 848) + ) + (set_local $13 + (i64.div_s + (get_local $13) + (i64.const 100) + ) + ) + (br $label$29) + ) + (set_local $6 + (i64.shr_s + (get_local $11) + (i64.const 63) + ) + ) + ) + (call $__multi3 + (i32.add + (get_local $15) + (i32.const 48) + ) + (tee_local $12 + (i64.sub + (i64.sub + (i64.const 100) + (i64.load8_u + (i32.add + (get_local $1) + (i32.const 114) + ) + ) + ) + (i64.load8_u + (i32.add + (get_local $1) + (i32.const 113) + ) + ) + ) + ) + (i64.shr_s + (get_local $12) + (i64.const 63) + ) + (get_local $11) + (get_local $6) + ) + (call $eosio_assert + (select + (i64.lt_u + (tee_local $6 + (i64.load offset=48 + (get_local $15) + ) + ) + (i64.const 4611686018427387904) + ) + (i64.lt_s + (tee_local $12 + (i64.load + (i32.add + (i32.add + (get_local $15) + (i32.const 48) + ) + (i32.const 8) + ) + ) + ) + (i64.const 0) + ) + (i64.eqz + (get_local $12) + ) + ) + (i32.const 768) + ) + (call $eosio_assert + (select + (i64.gt_u + (get_local $6) + (i64.const -4611686018427387904) + ) + (i64.gt_s + (get_local $12) + (i64.const -1) + ) + (i64.eq + (get_local $12) + (i64.const -1) + ) + ) + (i32.const 800) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 832) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 848) + ) + (i64.store + (i32.add + (get_local $0) + (i32.const 40) + ) + (i64.const 98179787082756) + ) + (i64.store + (tee_local $5 + (i32.add + (get_local $0) + (i32.const 32) + ) + ) + (tee_local $6 + (i64.div_s + (get_local $6) + (i64.const 100) + ) + ) + ) + (call $eosio_assert + (i64.eq + (i64.const 98179787082756) + (i64.const 98179787082756) + ) + (i32.const 976) + ) + (call $eosio_assert + (i64.gt_s + (tee_local $12 + (i64.sub + (get_local $11) + (get_local $13) + ) + ) + (i64.const -4611686018427387904) + ) + (i32.const 1024) + ) + (call $eosio_assert + (i64.lt_s + (get_local $12) + (i64.const 4611686018427387904) + ) + (i32.const 1056) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 976) + ) + (call $eosio_assert + (i64.gt_s + (tee_local $12 + (i64.sub + (get_local $12) + (get_local $6) + ) + ) + (i64.const -4611686018427387904) + ) + (i32.const 1024) + ) + (call $eosio_assert + (i64.lt_s + (get_local $12) + (i64.const 4611686018427387904) + ) + (i32.const 1056) + ) + (i64.store offset=248 + (get_local $15) + (i64.const 98179787082756) + ) + (i32.store + (i32.add + (i32.add + (get_local $15) + (i32.const 224) + ) + (i32.const 8) + ) + (i32.const 0) + ) + (i64.store offset=240 + (get_local $15) + (get_local $12) + ) + (i64.store offset=224 + (get_local $15) + (i64.const 0) + ) + (set_local $12 + (i64.load + (i32.add + (get_local $1) + (i32.const 80) + ) + ) + ) + (block $label$31 + (block $label$32 + (block $label$33 + (br_if $label$33 + (i32.ge_u + (tee_local $4 + (call $strlen + (i32.const 1936) + ) + ) + (i32.const -16) + ) + ) + (block $label$34 + (block $label$35 + (block $label$36 + (br_if $label$36 + (i32.ge_u + (get_local $4) + (i32.const 11) + ) + ) + (i32.store8 offset=224 + (get_local $15) + (i32.shl + (get_local $4) + (i32.const 1) + ) + ) + (set_local $9 + (i32.or + (i32.add + (get_local $15) + (i32.const 224) + ) + (i32.const 1) + ) + ) + (br_if $label$35 + (get_local $4) + ) + (br $label$34) + ) + (set_local $9 + (call $_Znwj + (tee_local $3 + (i32.and + (i32.add + (get_local $4) + (i32.const 16) + ) + (i32.const -16) + ) + ) + ) + ) + (i32.store offset=224 + (get_local $15) + (i32.or + (get_local $3) + (i32.const 1) + ) + ) + (i32.store offset=232 + (get_local $15) + (get_local $9) + ) + (i32.store offset=228 + (get_local $15) + (get_local $4) + ) + ) + (drop + (call $memcpy + (get_local $9) + (i32.const 1936) + (get_local $4) + ) + ) + ) + (i32.store8 + (i32.add + (get_local $9) + (get_local $4) + ) + (i32.const 0) + ) + (i64.store + (i32.add + (i32.add + (get_local $15) + (i32.const 32) + ) + (i32.const 8) + ) + (i64.load + (i32.add + (i32.add + (get_local $15) + (i32.const 240) + ) + (i32.const 8) + ) + ) + ) + (i64.store offset=32 + (get_local $15) + (i64.load offset=240 + (get_local $15) + ) + ) + (call $_ZN6eoswin7lottery16issue_game_tokenEyN5eosio5assetENSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE + (get_local $1) + (get_local $12) + (i32.add + (get_local $15) + (i32.const 32) + ) + (i32.add + (get_local $15) + (i32.const 224) + ) + ) + (block $label$37 + (br_if $label$37 + (i32.eqz + (i32.and + (i32.load8_u offset=224 + (get_local $15) + ) + (i32.const 1) + ) + ) + ) + (call $_ZdlPv + (i32.load offset=232 + (get_local $15) + ) + ) + ) + (i64.store offset=216 + (get_local $15) + (i64.const 98179787082756) + ) + (i32.store + (i32.add + (i32.add + (get_local $15) + (i32.const 192) + ) + (i32.const 8) + ) + (i32.const 0) + ) + (i64.store offset=208 + (get_local $15) + (get_local $13) + ) + (i64.store offset=192 + (get_local $15) + (i64.const 0) + ) + (br_if $label$32 + (i32.ge_u + (tee_local $4 + (call $strlen + (i32.const 1984) + ) + ) + (i32.const -16) + ) + ) + (block $label$38 + (block $label$39 + (block $label$40 + (br_if $label$40 + (i32.ge_u + (get_local $4) + (i32.const 11) + ) + ) + (i32.store8 offset=192 + (get_local $15) + (i32.shl + (get_local $4) + (i32.const 1) + ) + ) + (set_local $9 + (i32.or + (i32.add + (get_local $15) + (i32.const 192) + ) + (i32.const 1) + ) + ) + (br_if $label$39 + (get_local $4) + ) + (br $label$38) + ) + (set_local $9 + (call $_Znwj + (tee_local $3 + (i32.and + (i32.add + (get_local $4) + (i32.const 16) + ) + (i32.const -16) + ) + ) + ) + ) + (i32.store offset=192 + (get_local $15) + (i32.or + (get_local $3) + (i32.const 1) + ) + ) + (i32.store offset=200 + (get_local $15) + (get_local $9) + ) + (i32.store offset=196 + (get_local $15) + (get_local $4) + ) + ) + (drop + (call $memcpy + (get_local $9) + (i32.const 1984) + (get_local $4) + ) + ) + ) + (i32.store8 + (i32.add + (get_local $9) + (get_local $4) + ) + (i32.const 0) + ) + (i64.store + (i32.add + (i32.add + (get_local $15) + (i32.const 16) + ) + (i32.const 8) + ) + (i64.load + (i32.add + (i32.add + (get_local $15) + (i32.const 208) + ) + (i32.const 8) + ) + ) + ) + (i64.store offset=16 + (get_local $15) + (i64.load offset=208 + (get_local $15) + ) + ) + (call $_ZN6eoswin7lottery16issue_game_tokenEyN5eosio5assetENSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE + (get_local $1) + (get_local $14) + (i32.add + (get_local $15) + (i32.const 16) + ) + (i32.add + (get_local $15) + (i32.const 192) + ) + ) + (block $label$41 + (br_if $label$41 + (i32.eqz + (i32.and + (i32.load8_u offset=192 + (get_local $15) + ) + (i32.const 1) + ) + ) + ) + (call $_ZdlPv + (i32.load offset=200 + (get_local $15) + ) + ) + ) + (i64.store + (i32.add + (i32.add + (get_local $15) + (i32.const 176) + ) + (i32.const 8) + ) + (i64.load + (i32.add + (get_local $5) + (i32.const 8) + ) + ) + ) + (i32.store + (i32.add + (i32.add + (get_local $15) + (i32.const 160) + ) + (i32.const 8) + ) + (i32.const 0) + ) + (i64.store offset=176 + (get_local $15) + (i64.load + (get_local $5) + ) + ) + (i64.store offset=160 + (get_local $15) + (i64.const 0) + ) + (br_if $label$31 + (i32.ge_u + (tee_local $4 + (call $strlen + (i32.const 2032) + ) + ) + (i32.const -16) + ) + ) + (block $label$42 + (block $label$43 + (block $label$44 + (br_if $label$44 + (i32.ge_u + (get_local $4) + (i32.const 11) + ) + ) + (i32.store8 offset=160 + (get_local $15) + (i32.shl + (get_local $4) + (i32.const 1) + ) + ) + (set_local $9 + (i32.or + (i32.add + (get_local $15) + (i32.const 160) + ) + (i32.const 1) + ) + ) + (br_if $label$43 + (get_local $4) + ) + (br $label$42) + ) + (set_local $9 + (call $_Znwj + (tee_local $5 + (i32.and + (i32.add + (get_local $4) + (i32.const 16) + ) + (i32.const -16) + ) + ) + ) + ) + (i32.store offset=160 + (get_local $15) + (i32.or + (get_local $5) + (i32.const 1) + ) + ) + (i32.store offset=168 + (get_local $15) + (get_local $9) + ) + (i32.store offset=164 + (get_local $15) + (get_local $4) + ) + ) + (drop + (call $memcpy + (get_local $9) + (i32.const 2032) + (get_local $4) + ) + ) + ) + (i32.store8 + (i32.add + (get_local $9) + (get_local $4) + ) + (i32.const 0) + ) + (i64.store + (i32.add + (get_local $15) + (i32.const 8) + ) + (i64.load + (i32.add + (i32.add + (get_local $15) + (i32.const 176) + ) + (i32.const 8) + ) + ) + ) + (i64.store + (get_local $15) + (i64.load offset=176 + (get_local $15) + ) + ) + (call $_ZN6eoswin7lottery16issue_game_tokenEyN5eosio5assetENSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE + (get_local $1) + (get_local $2) + (get_local $15) + (i32.add + (get_local $15) + (i32.const 160) + ) + ) + (block $label$45 + (br_if $label$45 + (i32.eqz + (i32.and + (i32.load8_u offset=160 + (get_local $15) + ) + (i32.const 1) + ) + ) + ) + (call $_ZdlPv + (i32.load offset=168 + (get_local $15) + ) + ) + ) + (i64.store offset=56 + (get_local $0) + (call $current_time) + ) + (i64.store offset=136 + (get_local $15) + (i64.const -1) + ) + (i32.store offset=144 + (get_local $15) + (i32.const 0) + ) + (i64.store offset=120 + (get_local $15) + (tee_local $11 + (i64.load + (get_local $1) + ) + ) + ) + (i64.store offset=128 + (get_local $15) + (tee_local $13 + (i64.load + (i32.add + (get_local $1) + (i32.const 64) + ) + ) + ) + ) + (i32.store + (i32.add + (get_local $15) + (i32.const 148) + ) + (i32.const 0) + ) + (i32.store + (i32.add + (get_local $15) + (i32.const 152) + ) + (i32.const 0) + ) + (i32.store8 offset=156 + (get_local $15) + (i32.const 0) + ) + (set_local $12 + (i64.const 0) + ) + (block $label$46 + (br_if $label$46 + (i32.lt_s + (tee_local $4 + (call $db_lowerbound_i64 + (get_local $11) + (get_local $13) + (i64.const 4297309255767162880) + (i64.const 0) + ) + ) + (i32.const 0) + ) + ) + (drop + (call $_ZNK5eosio11multi_indexILy4297309255767162880EN6eoswin9bill_itemEJNS_10indexed_byILy4587782057278570496EN5boost11multi_index13const_mem_funIS2_yXadL_ZNKS2_8byplayerEvEEEEEEEE31load_object_by_primary_iteratorEl + (i32.add + (get_local $15) + (i32.const 120) + ) + (get_local $4) + ) + ) + (i32.store offset=276 + (get_local $15) + (i32.const 0) + ) + (i32.store offset=272 + (get_local $15) + (i32.add + (get_local $15) + (i32.const 120) + ) + ) + (set_local $12 + (select + (i64.const -2) + (i64.add + (tee_local $12 + (i64.load + (i32.load offset=4 + (call $_ZN5eosio11multi_indexILy4297309255767162880EN6eoswin9bill_itemEJNS_10indexed_byILy4587782057278570496EN5boost11multi_index13const_mem_funIS2_yXadL_ZNKS2_8byplayerEvEEEEEEEE14const_iteratormmEv + (i32.add + (get_local $15) + (i32.const 272) + ) + ) + ) + ) + ) + (i64.const 1) + ) + (i64.gt_u + (get_local $12) + (i64.const -3) + ) + ) + ) + ) + (i64.store + (tee_local $4 + (i32.add + (get_local $15) + (i32.const 136) + ) + ) + (get_local $12) + ) + (call $eosio_assert + (i64.lt_u + (get_local $12) + (i64.const -2) + ) + (i32.const 2080) + ) + (i64.store + (get_local $0) + (i64.load + (get_local $4) + ) + ) + (set_local $11 + (i64.load + (get_local $1) + ) + ) + (call $eosio_assert + (i64.eq + (i64.load offset=120 + (get_local $15) + ) + (call $current_receiver) + ) + (i32.const 336) + ) + (i64.store offset=40 + (tee_local $5 + (call $_Znwj + (i32.const 80) + ) + ) + (i64.const 1397703940) + ) + (i64.store offset=32 + (get_local $5) + (i64.const 0) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 176) + ) + (set_local $12 + (i64.const 5459781) + ) + (set_local $4 + (i32.const 0) + ) + (block $label$47 + (block $label$48 + (loop $label$49 + (br_if $label$48 + (i32.gt_u + (i32.add + (i32.shl + (i32.wrap/i64 + (get_local $12) + ) + (i32.const 24) + ) + (i32.const -1073741825) + ) + (i32.const 452984830) + ) + ) + (block $label$50 + (br_if $label$50 + (i64.ne + (i64.and + (tee_local $12 + (i64.shr_u + (get_local $12) + (i64.const 8) + ) + ) + (i64.const 255) + ) + (i64.const 0) + ) + ) + (loop $label$51 + (br_if $label$48 + (i64.ne + (i64.and + (tee_local $12 + (i64.shr_u + (get_local $12) + (i64.const 8) + ) + ) + (i64.const 255) + ) + (i64.const 0) + ) + ) + (br_if $label$51 + (i32.lt_s + (tee_local $4 + (i32.add + (get_local $4) + (i32.const 1) + ) + ) + (i32.const 7) + ) + ) + ) + ) + (set_local $9 + (i32.const 1) + ) + (br_if $label$49 + (i32.lt_s + (tee_local $4 + (i32.add + (get_local $4) + (i32.const 1) + ) + ) + (i32.const 7) + ) + ) + (br $label$47) + ) + ) + (set_local $9 + (i32.const 0) + ) + ) + (call $eosio_assert + (get_local $9) + (i32.const 128) + ) + (i32.store offset=64 + (get_local $5) + (i32.add + (get_local $15) + (i32.const 120) + ) + ) + (set_local $4 + (call $memcpy + (get_local $5) + (get_local $0) + (i32.const 64) + ) + ) + (i32.store offset=88 + (get_local $15) + (i32.add + (i32.add + (get_local $15) + (i32.const 272) + ) + (i32.const 64) + ) + ) + (i32.store offset=84 + (get_local $15) + (i32.add + (get_local $15) + (i32.const 272) + ) + ) + (i32.store offset=80 + (get_local $15) + (i32.add + (get_local $15) + (i32.const 272) + ) + ) + (drop + (call $_ZN6eoswinlsIN5eosio10datastreamIPcEEEERT_S6_RKNS_9bill_itemE + (i32.add + (get_local $15) + (i32.const 80) + ) + (get_local $4) + ) + ) + (i32.store offset=68 + (get_local $4) + (call $db_store_i64 + (i64.load + (tee_local $9 + (i32.add + (get_local $15) + (i32.const 128) + ) + ) + ) + (i64.const 4297309255767162880) + (get_local $11) + (tee_local $12 + (i64.load + (get_local $4) + ) + ) + (i32.add + (get_local $15) + (i32.const 272) + ) + (i32.const 64) + ) + ) + (block $label$52 + (br_if $label$52 + (i64.lt_u + (get_local $12) + (i64.load + (tee_local $5 + (i32.add + (get_local $15) + (i32.const 136) + ) + ) + ) + ) + ) + (i64.store + (get_local $5) + (select + (i64.const -2) + (i64.add + (get_local $12) + (i64.const 1) + ) + (i64.gt_u + (get_local $12) + (i64.const -3) + ) + ) + ) + ) + (set_local $12 + (i64.load + (get_local $4) + ) + ) + (set_local $13 + (i64.load + (get_local $9) + ) + ) + (i64.store offset=352 + (get_local $15) + (i64.load offset=8 + (get_local $4) + ) + ) + (i32.store offset=72 + (get_local $4) + (call $db_idx64_store + (get_local $13) + (i64.const 4297309255767162880) + (get_local $11) + (get_local $12) + (i32.add + (get_local $15) + (i32.const 352) + ) + ) + ) + (i32.store offset=80 + (get_local $15) + (get_local $4) + ) + (i64.store offset=272 + (get_local $15) + (tee_local $12 + (i64.load + (get_local $4) + ) + ) + ) + (i32.store offset=352 + (get_local $15) + (tee_local $5 + (i32.load + (i32.add + (get_local $4) + (i32.const 68) + ) + ) + ) + ) + (block $label$53 + (block $label$54 + (br_if $label$54 + (i32.ge_u + (tee_local $9 + (i32.load + (tee_local $3 + (i32.add + (get_local $15) + (i32.const 148) + ) + ) + ) + ) + (i32.load + (i32.add + (get_local $15) + (i32.const 152) + ) + ) + ) + ) + (i64.store offset=8 + (get_local $9) + (get_local $12) + ) + (i32.store offset=16 + (get_local $9) + (get_local $5) + ) + (i32.store offset=80 + (get_local $15) + (i32.const 0) + ) + (i32.store + (get_local $9) + (get_local $4) + ) + (i32.store + (get_local $3) + (i32.add + (get_local $9) + (i32.const 24) + ) + ) + (br $label$53) + ) + (call $_ZNSt3__16vectorIN5eosio11multi_indexILy4297309255767162880EN6eoswin9bill_itemEJNS1_10indexed_byILy4587782057278570496EN5boost11multi_index13const_mem_funIS4_yXadL_ZNKS4_8byplayerEvEEEEEEEE8item_ptrENS_9allocatorISC_EEE24__emplace_back_slow_pathIJNS_10unique_ptrINSB_4itemENS_14default_deleteISI_EEEERyRlEEEvDpOT_ + (i32.add + (get_local $15) + (i32.const 144) + ) + (i32.add + (get_local $15) + (i32.const 80) + ) + (i32.add + (get_local $15) + (i32.const 272) + ) + (i32.add + (get_local $15) + (i32.const 352) + ) + ) + ) + (set_local $4 + (i32.load offset=80 + (get_local $15) + ) + ) + (i32.store offset=80 + (get_local $15) + (i32.const 0) + ) + (block $label$55 + (br_if $label$55 + (i32.eqz + (get_local $4) + ) + ) + (call $_ZdlPv + (get_local $4) + ) + ) + (i64.store offset=96 + (get_local $15) + (i64.const -1) + ) + (i32.store offset=104 + (get_local $15) + (i32.const 0) + ) + (i64.store offset=80 + (get_local $15) + (tee_local $12 + (i64.load + (get_local $1) + ) + ) + ) + (i64.store offset=88 + (get_local $15) + (tee_local $11 + (i64.load + (i32.add + (get_local $1) + (i32.const 64) + ) + ) + ) + ) + (i32.store + (i32.add + (get_local $15) + (i32.const 108) + ) + (i32.const 0) + ) + (i32.store + (i32.add + (i32.add + (get_local $15) + (i32.const 80) + ) + (i32.const 32) + ) + (i32.const 0) + ) + (block $label$56 + (block $label$57 + (br_if $label$57 + (i32.lt_s + (tee_local $4 + (call $db_find_i64 + (get_local $12) + (get_local $11) + (i64.const -6030912129794572288) + (get_local $2) + ) + ) + (i32.const 0) + ) + ) + (call $eosio_assert + (i32.eq + (i32.load offset=16 + (tee_local $4 + (call $_ZNK5eosio11multi_indexILy12415831943914979328EN6eoswin11player_itemEJEE31load_object_by_primary_iteratorEl + (i32.add + (get_local $15) + (i32.const 80) + ) + (get_local $4) + ) + ) + ) + (i32.add + (get_local $15) + (i32.const 80) + ) + ) + (i32.const 32) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 288) + ) + (call $eosio_assert + (i32.eq + (i32.load offset=16 + (get_local $4) + ) + (i32.add + (get_local $15) + (i32.const 80) + ) + ) + (i32.const 416) + ) + (call $eosio_assert + (i64.eq + (i64.load offset=80 + (get_local $15) + ) + (call $current_receiver) + ) + (i32.const 464) + ) + (i32.store16 offset=8 + (get_local $4) + (tee_local $9 + (i32.add + (i32.load16_u offset=8 + (get_local $4) + ) + (i32.const 1) + ) + ) + ) + (set_local $12 + (i64.load + (get_local $4) + ) + ) + (call $eosio_assert + (i32.lt_u + (i32.and + (get_local $9) + (i32.const 65535) + ) + (i32.const 51) + ) + (i32.const 2144) + ) + (call $eosio_assert + (i64.eq + (get_local $12) + (i64.load + (get_local $4) + ) + ) + (i32.const 528) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 400) + ) + (drop + (call $memcpy + (i32.add + (get_local $15) + (i32.const 272) + ) + (get_local $4) + (i32.const 8) + ) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 400) + ) + (drop + (call $memcpy + (i32.or + (i32.add + (get_local $15) + (i32.const 272) + ) + (i32.const 8) + ) + (i32.add + (get_local $4) + (i32.const 8) + ) + (i32.const 2) + ) + ) + (call $db_update_i64 + (i32.load offset=20 + (get_local $4) + ) + (i64.const 0) + (i32.add + (get_local $15) + (i32.const 272) + ) + (i32.const 10) + ) + (br_if $label$56 + (i64.lt_u + (get_local $12) + (i64.load + (tee_local $4 + (i32.add + (get_local $15) + (i32.const 96) + ) + ) + ) + ) + ) + (i64.store + (get_local $4) + (select + (i64.const -2) + (i64.add + (get_local $12) + (i64.const 1) + ) + (i64.gt_u + (get_local $12) + (i64.const -3) + ) + ) + ) + (br $label$56) + ) + (set_local $11 + (i64.load + (get_local $1) + ) + ) + (call $eosio_assert + (i64.eq + (i64.load offset=80 + (get_local $15) + ) + (call $current_receiver) + ) + (i32.const 336) + ) + (i32.store offset=16 + (tee_local $4 + (call $_Znwj + (i32.const 32) + ) + ) + (i32.add + (get_local $15) + (i32.const 80) + ) + ) + (i32.store16 offset=8 + (get_local $4) + (i32.const 1) + ) + (i64.store + (get_local $4) + (get_local $2) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 400) + ) + (drop + (call $memcpy + (i32.add + (get_local $15) + (i32.const 272) + ) + (get_local $4) + (i32.const 8) + ) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 400) + ) + (drop + (call $memcpy + (i32.or + (i32.add + (get_local $15) + (i32.const 272) + ) + (i32.const 8) + ) + (i32.add + (get_local $4) + (i32.const 8) + ) + (i32.const 2) + ) + ) + (i32.store offset=20 + (get_local $4) + (tee_local $5 + (call $db_store_i64 + (i64.load + (i32.add + (i32.add + (get_local $15) + (i32.const 80) + ) + (i32.const 8) + ) + ) + (i64.const -6030912129794572288) + (get_local $11) + (tee_local $12 + (i64.load + (get_local $4) + ) + ) + (i32.add + (get_local $15) + (i32.const 272) + ) + (i32.const 10) + ) + ) + ) + (block $label$58 + (br_if $label$58 + (i64.lt_u + (get_local $12) + (i64.load + (tee_local $9 + (i32.add + (get_local $15) + (i32.const 96) + ) + ) + ) + ) + ) + (i64.store + (get_local $9) + (select + (i64.const -2) + (i64.add + (get_local $12) + (i64.const 1) + ) + (i64.gt_u + (get_local $12) + (i64.const -3) + ) + ) + ) + ) + (i32.store offset=352 + (get_local $15) + (get_local $4) + ) + (i64.store offset=272 + (get_local $15) + (tee_local $12 + (i64.load + (get_local $4) + ) + ) + ) + (i32.store offset=268 + (get_local $15) + (get_local $5) + ) + (block $label$59 + (block $label$60 + (br_if $label$60 + (i32.ge_u + (tee_local $9 + (i32.load + (tee_local $3 + (i32.add + (get_local $15) + (i32.const 108) + ) + ) + ) + ) + (i32.load + (i32.add + (get_local $15) + (i32.const 112) + ) + ) + ) + ) + (i64.store offset=8 + (get_local $9) + (get_local $12) + ) + (i32.store offset=16 + (get_local $9) + (get_local $5) + ) + (i32.store offset=352 + (get_local $15) + (i32.const 0) + ) + (i32.store + (get_local $9) + (get_local $4) + ) + (i32.store + (get_local $3) + (i32.add + (get_local $9) + (i32.const 24) + ) + ) + (br $label$59) + ) + (call $_ZNSt3__16vectorIN5eosio11multi_indexILy12415831943914979328EN6eoswin11player_itemEJEE8item_ptrENS_9allocatorIS6_EEE24__emplace_back_slow_pathIJNS_10unique_ptrINS5_4itemENS_14default_deleteISC_EEEERyRlEEEvDpOT_ + (i32.add + (get_local $15) + (i32.const 104) + ) + (i32.add + (get_local $15) + (i32.const 352) + ) + (i32.add + (get_local $15) + (i32.const 272) + ) + (i32.add + (get_local $15) + (i32.const 268) + ) + ) + ) + (set_local $4 + (i32.load offset=352 + (get_local $15) + ) + ) + (i32.store offset=352 + (get_local $15) + (i32.const 0) + ) + (br_if $label$56 + (i32.eqz + (get_local $4) + ) + ) + (call $_ZdlPv + (get_local $4) + ) + ) + (call $eosio_assert + (get_local $8) + (i32.const 288) + ) + (call $eosio_assert + (i32.eq + (i32.load offset=80 + (get_local $10) + ) + (get_local $7) + ) + (i32.const 416) + ) + (call $eosio_assert + (i64.eq + (i64.load + (i32.add + (get_local $1) + (i32.const 144) + ) + ) + (call $current_receiver) + ) + (i32.const 464) + ) + (i64.store offset=16 + (get_local $10) + (i64.load + (i32.add + (get_local $0) + (i32.const 24) + ) + ) + ) + (set_local $12 + (i64.load + (get_local $10) + ) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 528) + ) + (i32.store offset=360 + (get_local $15) + (i32.add + (i32.add + (get_local $15) + (i32.const 272) + ) + (i32.const 80) + ) + ) + (i32.store offset=356 + (get_local $15) + (i32.add + (get_local $15) + (i32.const 272) + ) + ) + (i32.store offset=352 + (get_local $15) + (i32.add + (get_local $15) + (i32.const 272) + ) + ) + (drop + (call $_ZN6eoswinlsIN5eosio10datastreamIPcEEEERT_S6_RKNS_10round_itemE + (i32.add + (get_local $15) + (i32.const 352) + ) + (get_local $10) + ) + ) + (call $db_update_i64 + (i32.load offset=84 + (get_local $10) + ) + (i64.const 0) + (i32.add + (get_local $15) + (i32.const 272) + ) + (i32.const 80) + ) + (block $label$61 + (br_if $label$61 + (i64.lt_u + (get_local $12) + (i64.load + (tee_local $4 + (i32.add + (get_local $1) + (i32.const 160) + ) + ) + ) + ) + ) + (i64.store + (get_local $4) + (select + (i64.const -2) + (i64.add + (get_local $12) + (i64.const 1) + ) + (i64.gt_u + (get_local $12) + (i64.const -3) + ) + ) + ) + ) + (i32.store + (tee_local $4 + (i32.add + (get_local $1) + (i32.const 136) + ) + ) + (i32.add + (i32.load + (get_local $4) + ) + (i32.const 1) + ) + ) + (block $label$62 + (br_if $label$62 + (i32.eqz + (tee_local $9 + (i32.load offset=104 + (get_local $15) + ) + ) + ) + ) + (block $label$63 + (block $label$64 + (br_if $label$64 + (i32.eq + (tee_local $4 + (i32.load + (tee_local $5 + (i32.add + (get_local $15) + (i32.const 108) + ) + ) + ) + ) + (get_local $9) + ) + ) + (loop $label$65 + (set_local $10 + (i32.load + (tee_local $4 + (i32.add + (get_local $4) + (i32.const -24) + ) + ) + ) + ) + (i32.store + (get_local $4) + (i32.const 0) + ) + (block $label$66 + (br_if $label$66 + (i32.eqz + (get_local $10) + ) + ) + (call $_ZdlPv + (get_local $10) + ) + ) + (br_if $label$65 + (i32.ne + (get_local $9) + (get_local $4) + ) + ) + ) + (set_local $4 + (i32.load + (i32.add + (get_local $15) + (i32.const 104) + ) + ) + ) + (br $label$63) + ) + (set_local $4 + (get_local $9) + ) + ) + (i32.store + (get_local $5) + (get_local $9) + ) + (call $_ZdlPv + (get_local $4) + ) + ) + (block $label$67 + (br_if $label$67 + (i32.eqz + (tee_local $9 + (i32.load offset=144 + (get_local $15) + ) + ) + ) + ) + (block $label$68 + (block $label$69 + (br_if $label$69 + (i32.eq + (tee_local $4 + (i32.load + (tee_local $5 + (i32.add + (get_local $15) + (i32.const 148) + ) + ) + ) + ) + (get_local $9) + ) + ) + (loop $label$70 + (set_local $10 + (i32.load + (tee_local $4 + (i32.add + (get_local $4) + (i32.const -24) + ) + ) + ) + ) + (i32.store + (get_local $4) + (i32.const 0) + ) + (block $label$71 + (br_if $label$71 + (i32.eqz + (get_local $10) + ) + ) + (call $_ZdlPv + (get_local $10) + ) + ) + (br_if $label$70 + (i32.ne + (get_local $9) + (get_local $4) + ) + ) + ) + (set_local $4 + (i32.load + (i32.add + (get_local $15) + (i32.const 144) + ) + ) + ) + (br $label$68) + ) + (set_local $4 + (get_local $9) + ) + ) + (i32.store + (get_local $5) + (get_local $9) + ) + (call $_ZdlPv + (get_local $4) + ) + ) + (block $label$72 + (br_if $label$72 + (i32.eqz + (i32.and + (i32.load8_u offset=256 + (get_local $15) + ) + (i32.const 1) + ) + ) + ) + (call $_ZdlPv + (i32.load offset=264 + (get_local $15) + ) + ) + ) + (i32.store offset=4 + (i32.const 0) + (i32.add + (get_local $15) + (i32.const 368) + ) + ) + (return) + ) + (call $_ZNKSt3__121__basic_string_commonILb1EE20__throw_length_errorEv + (i32.add + (get_local $15) + (i32.const 224) + ) + ) + (unreachable) + ) + (call $_ZNKSt3__121__basic_string_commonILb1EE20__throw_length_errorEv + (i32.add + (get_local $15) + (i32.const 192) + ) + ) + (unreachable) + ) + (call $_ZNKSt3__121__basic_string_commonILb1EE20__throw_length_errorEv + (i32.add + (get_local $15) + (i32.const 160) + ) + ) + (unreachable) + ) + (func $_ZN6eoswin7lottery4mineEy (param $0 i32) (param $1 i64) (result i64) + (local $2 i64) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i64) + (local $7 i64) + (local $8 i64) + (local $9 i32) + (i32.store offset=4 + (i32.const 0) + (tee_local $9 + (i32.sub + (i32.load offset=4 + (i32.const 0) + ) + (i32.const 48) + ) + ) + ) + (call $eosio_assert + (i32.load8_u + (i32.add + (get_local $0) + (i32.const 140) + ) + ) + (i32.const 2304) + ) + (set_local $2 + (i64.mul + (get_local $1) + (i64.const 7500) + ) + ) + (set_local $1 + (i64.const 0) + ) + (set_local $6 + (i64.const 59) + ) + (set_local $5 + (i32.const 16) + ) + (set_local $7 + (i64.const 0) + ) + (loop $label$0 + (set_local $8 + (i64.const 0) + ) + (block $label$1 + (br_if $label$1 + (i64.gt_u + (get_local $1) + (i64.const 11) + ) + ) + (block $label$2 + (block $label$3 + (br_if $label$3 + (i32.gt_u + (i32.and + (i32.add + (tee_local $3 + (i32.load8_s + (get_local $5) + ) + ) + (i32.const -97) + ) + (i32.const 255) + ) + (i32.const 25) + ) + ) + (set_local $3 + (i32.add + (get_local $3) + (i32.const 165) + ) + ) + (br $label$2) + ) + (set_local $3 + (select + (i32.add + (get_local $3) + (i32.const 208) + ) + (i32.const 0) + (i32.lt_u + (i32.and + (i32.add + (get_local $3) + (i32.const -49) + ) + (i32.const 255) + ) + (i32.const 5) + ) + ) + ) + ) + (set_local $8 + (i64.shl + (i64.extend_u/i32 + (i32.and + (get_local $3) + (i32.const 31) + ) + ) + (i64.and + (get_local $6) + (i64.const 4294967295) + ) + ) + ) + ) + (set_local $5 + (i32.add + (get_local $5) + (i32.const 1) + ) + ) + (set_local $1 + (i64.add + (get_local $1) + (i64.const 1) + ) + ) + (set_local $7 + (i64.or + (get_local $8) + (get_local $7) + ) + ) + (br_if $label$0 + (i64.ne + (tee_local $6 + (i64.add + (get_local $6) + (i64.const -5) + ) + ) + (i64.const -6) + ) + ) + ) + (set_local $1 + (i64.load offset=240 + (get_local $0) + ) + ) + (i32.store + (i32.add + (get_local $9) + (i32.const 40) + ) + (i32.const 0) + ) + (i64.store offset=16 + (get_local $9) + (get_local $7) + ) + (i64.store offset=24 + (get_local $9) + (i64.const -1) + ) + (i64.store offset=32 + (get_local $9) + (i64.const 0) + ) + (i64.store offset=8 + (get_local $9) + (i64.load offset=224 + (get_local $0) + ) + ) + (set_local $1 + (i64.load + (call $_ZNK5eosio11multi_indexILy3607749779137757184ENS_5token7accountEJEE3getEyPKc + (i32.add + (get_local $9) + (i32.const 8) + ) + (get_local $1) + (i32.const 736) + ) + ) + ) + (block $label$4 + (br_if $label$4 + (i32.eqz + (tee_local $0 + (i32.load offset=32 + (get_local $9) + ) + ) + ) + ) + (block $label$5 + (block $label$6 + (br_if $label$6 + (i32.eq + (tee_local $5 + (i32.load + (tee_local $4 + (i32.add + (get_local $9) + (i32.const 36) + ) + ) + ) + ) + (get_local $0) + ) + ) + (loop $label$7 + (set_local $3 + (i32.load + (tee_local $5 + (i32.add + (get_local $5) + (i32.const -24) + ) + ) + ) + ) + (i32.store + (get_local $5) + (i32.const 0) + ) + (block $label$8 + (br_if $label$8 + (i32.eqz + (get_local $3) + ) + ) + (call $_ZdlPv + (get_local $3) + ) + ) + (br_if $label$7 + (i32.ne + (get_local $0) + (get_local $5) + ) + ) + ) + (set_local $5 + (i32.load + (i32.add + (get_local $9) + (i32.const 32) + ) + ) + ) + (br $label$5) + ) + (set_local $5 + (get_local $0) + ) + ) + (i32.store + (get_local $4) + (get_local $0) + ) + (call $_ZdlPv + (get_local $5) + ) + ) + (i32.store offset=4 + (i32.const 0) + (i32.add + (get_local $9) + (i32.const 48) + ) + ) + (select + (get_local $1) + (get_local $2) + (i64.gt_u + (get_local $2) + (get_local $1) + ) + ) + ) + (func $_ZN5eosio11multi_indexILy4297309255767162880EN6eoswin9bill_itemEJNS_10indexed_byILy4587782057278570496EN5boost11multi_index13const_mem_funIS2_yXadL_ZNKS2_8byplayerEvEEEEEEEE14const_iteratormmEv (param $0 i32) (result i32) + (local $1 i32) + (local $2 i32) + (i32.store offset=4 + (i32.const 0) + (tee_local $2 + (i32.sub + (i32.load offset=4 + (i32.const 0) + ) + (i32.const 16) + ) + ) + ) + (block $label$0 + (block $label$1 + (br_if $label$1 + (i32.eqz + (tee_local $1 + (i32.load offset=4 + (get_local $0) + ) + ) + ) + ) + (call $eosio_assert + (i32.xor + (i32.shr_u + (tee_local $1 + (call $db_previous_i64 + (i32.load offset=68 + (get_local $1) + ) + (i32.add + (get_local $2) + (i32.const 8) + ) + ) + ) + (i32.const 31) + ) + (i32.const 1) + ) + (i32.const 2256) + ) + (br $label$0) + ) + (call $eosio_assert + (i32.ne + (tee_local $1 + (call $db_end_i64 + (i64.load + (tee_local $1 + (i32.load + (get_local $0) + ) + ) + ) + (i64.load offset=8 + (get_local $1) + ) + (i64.const 4297309255767162880) + ) + ) + (i32.const -1) + ) + (i32.const 2192) + ) + (call $eosio_assert + (i32.xor + (i32.shr_u + (tee_local $1 + (call $db_previous_i64 + (get_local $1) + (i32.add + (get_local $2) + (i32.const 8) + ) + ) + ) + (i32.const 31) + ) + (i32.const 1) + ) + (i32.const 2192) + ) + ) + (i32.store + (i32.add + (get_local $0) + (i32.const 4) + ) + (call $_ZNK5eosio11multi_indexILy4297309255767162880EN6eoswin9bill_itemEJNS_10indexed_byILy4587782057278570496EN5boost11multi_index13const_mem_funIS2_yXadL_ZNKS2_8byplayerEvEEEEEEEE31load_object_by_primary_iteratorEl + (i32.load + (get_local $0) + ) + (get_local $1) + ) + ) + (i32.store offset=4 + (i32.const 0) + (i32.add + (get_local $2) + (i32.const 16) + ) + ) + (get_local $0) + ) + (func $_ZN6eoswinlsIN5eosio10datastreamIPcEEEERT_S6_RKNS_9bill_itemE (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + (call $eosio_assert + (i32.gt_s + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (i32.load offset=4 + (get_local $0) + ) + ) + (i32.const 7) + ) + (i32.const 400) + ) + (drop + (call $memcpy + (i32.load offset=4 + (get_local $0) + ) + (get_local $1) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $0) + (tee_local $2 + (i32.add + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + ) + (call $eosio_assert + (i32.gt_s + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (get_local $2) + ) + (i32.const 7) + ) + (i32.const 400) + ) + (drop + (call $memcpy + (i32.load offset=4 + (get_local $0) + ) + (i32.add + (get_local $1) + (i32.const 8) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $0) + (tee_local $2 + (i32.add + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + ) + (call $eosio_assert + (i32.gt_s + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (get_local $2) + ) + (i32.const 7) + ) + (i32.const 400) + ) + (drop + (call $memcpy + (i32.load offset=4 + (get_local $0) + ) + (i32.add + (get_local $1) + (i32.const 16) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $0) + (tee_local $2 + (i32.add + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + ) + (call $eosio_assert + (i32.gt_s + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (get_local $2) + ) + (i32.const 7) + ) + (i32.const 400) + ) + (drop + (call $memcpy + (i32.load offset=4 + (get_local $0) + ) + (i32.add + (get_local $1) + (i32.const 24) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $0) + (tee_local $2 + (i32.add + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + ) + (call $eosio_assert + (i32.gt_s + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (get_local $2) + ) + (i32.const 7) + ) + (i32.const 400) + ) + (drop + (call $memcpy + (i32.load offset=4 + (get_local $0) + ) + (i32.add + (get_local $1) + (i32.const 32) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $0) + (tee_local $2 + (i32.add + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + ) + (call $eosio_assert + (i32.gt_s + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (get_local $2) + ) + (i32.const 7) + ) + (i32.const 400) + ) + (drop + (call $memcpy + (i32.load offset=4 + (get_local $0) + ) + (i32.add + (get_local $1) + (i32.const 40) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $0) + (tee_local $2 + (i32.add + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + ) + (call $eosio_assert + (i32.gt_s + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (get_local $2) + ) + (i32.const 7) + ) + (i32.const 400) + ) + (drop + (call $memcpy + (i32.load offset=4 + (get_local $0) + ) + (i32.add + (get_local $1) + (i32.const 48) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $0) + (tee_local $2 + (i32.add + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + ) + (call $eosio_assert + (i32.gt_s + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (get_local $2) + ) + (i32.const 7) + ) + (i32.const 400) + ) + (drop + (call $memcpy + (i32.load offset=4 + (get_local $0) + ) + (i32.add + (get_local $1) + (i32.const 56) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $0) + (i32.add + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + (get_local $0) + ) + (func $_ZNK5eosio11multi_indexILy12415831943914979328EN6eoswin11player_itemEJEE31load_object_by_primary_iteratorEl (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 i64) + (local $6 i32) + (local $7 i32) + (local $8 i32) + (local $9 i32) + (set_local $8 + (tee_local $9 + (i32.sub + (i32.load offset=4 + (i32.const 0) + ) + (i32.const 32) + ) + ) + ) + (i32.store offset=4 + (i32.const 0) + (get_local $9) + ) + (block $label$0 + (br_if $label$0 + (i32.eq + (tee_local $7 + (i32.load + (i32.add + (get_local $0) + (i32.const 28) + ) + ) + ) + (tee_local $2 + (i32.load offset=24 + (get_local $0) + ) + ) + ) + ) + (set_local $3 + (i32.sub + (i32.const 0) + (get_local $2) + ) + ) + (set_local $6 + (i32.add + (get_local $7) + (i32.const -24) + ) + ) + (loop $label$1 + (br_if $label$0 + (i32.eq + (i32.load + (i32.add + (get_local $6) + (i32.const 16) + ) + ) + (get_local $1) + ) + ) + (set_local $7 + (get_local $6) + ) + (set_local $6 + (tee_local $4 + (i32.add + (get_local $6) + (i32.const -24) + ) + ) + ) + (br_if $label$1 + (i32.ne + (i32.add + (get_local $4) + (get_local $3) + ) + (i32.const -24) + ) + ) + ) + ) + (block $label$2 + (block $label$3 + (br_if $label$3 + (i32.eq + (get_local $7) + (get_local $2) + ) + ) + (set_local $6 + (i32.load + (i32.add + (get_local $7) + (i32.const -24) + ) + ) + ) + (br $label$2) + ) + (call $eosio_assert + (i32.xor + (i32.shr_u + (tee_local $4 + (call $db_get_i64 + (get_local $1) + (i32.const 0) + (i32.const 0) + ) + ) + (i32.const 31) + ) + (i32.const 1) + ) + (i32.const 240) + ) + (block $label$4 + (block $label$5 + (br_if $label$5 + (i32.le_u + (get_local $4) + (i32.const 512) + ) + ) + (drop + (call $db_get_i64 + (get_local $1) + (tee_local $7 + (call $malloc + (get_local $4) + ) + ) + (get_local $4) + ) + ) + (call $free + (get_local $7) + ) + (br $label$4) + ) + (i32.store offset=4 + (i32.const 0) + (tee_local $7 + (i32.sub + (get_local $9) + (i32.and + (i32.add + (get_local $4) + (i32.const 15) + ) + (i32.const -16) + ) + ) + ) + ) + (drop + (call $db_get_i64 + (get_local $1) + (get_local $7) + (get_local $4) + ) + ) + ) + (i32.store offset=16 + (tee_local $6 + (call $_Znwj + (i32.const 32) + ) + ) + (get_local $0) + ) + (call $eosio_assert + (i32.gt_u + (get_local $4) + (i32.const 7) + ) + (i32.const 272) + ) + (drop + (call $memcpy + (get_local $6) + (get_local $7) + (i32.const 8) + ) + ) + (call $eosio_assert + (i32.ne + (i32.and + (get_local $4) + (i32.const -2) + ) + (i32.const 8) + ) + (i32.const 272) + ) + (drop + (call $memcpy + (i32.add + (get_local $6) + (i32.const 8) + ) + (i32.add + (get_local $7) + (i32.const 8) + ) + (i32.const 2) + ) + ) + (i32.store offset=20 + (get_local $6) + (get_local $1) + ) + (i32.store offset=24 + (get_local $8) + (get_local $6) + ) + (i64.store offset=16 + (get_local $8) + (tee_local $5 + (i64.load + (get_local $6) + ) + ) + ) + (i32.store offset=12 + (get_local $8) + (tee_local $7 + (i32.load offset=20 + (get_local $6) + ) + ) + ) + (block $label$6 + (block $label$7 + (br_if $label$7 + (i32.ge_u + (tee_local $4 + (i32.load + (tee_local $1 + (i32.add + (get_local $0) + (i32.const 28) + ) + ) + ) + ) + (i32.load + (i32.add + (get_local $0) + (i32.const 32) + ) + ) + ) + ) + (i64.store offset=8 + (get_local $4) + (get_local $5) + ) + (i32.store offset=16 + (get_local $4) + (get_local $7) + ) + (i32.store offset=24 + (get_local $8) + (i32.const 0) + ) + (i32.store + (get_local $4) + (get_local $6) + ) + (i32.store + (get_local $1) + (i32.add + (get_local $4) + (i32.const 24) + ) + ) + (br $label$6) + ) + (call $_ZNSt3__16vectorIN5eosio11multi_indexILy12415831943914979328EN6eoswin11player_itemEJEE8item_ptrENS_9allocatorIS6_EEE24__emplace_back_slow_pathIJNS_10unique_ptrINS5_4itemENS_14default_deleteISC_EEEERyRlEEEvDpOT_ + (i32.add + (get_local $0) + (i32.const 24) + ) + (i32.add + (get_local $8) + (i32.const 24) + ) + (i32.add + (get_local $8) + (i32.const 16) + ) + (i32.add + (get_local $8) + (i32.const 12) + ) + ) + ) + (set_local $4 + (i32.load offset=24 + (get_local $8) + ) + ) + (i32.store offset=24 + (get_local $8) + (i32.const 0) + ) + (br_if $label$2 + (i32.eqz + (get_local $4) + ) + ) + (call $_ZdlPv + (get_local $4) + ) + ) + (i32.store offset=4 + (i32.const 0) + (i32.add + (get_local $8) + (i32.const 32) + ) + ) + (get_local $6) + ) + (func $_ZNSt3__16vectorIN5eosio11multi_indexILy12415831943914979328EN6eoswin11player_itemEJEE8item_ptrENS_9allocatorIS6_EEE24__emplace_back_slow_pathIJNS_10unique_ptrINS5_4itemENS_14default_deleteISC_EEEERyRlEEEvDpOT_ (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (block $label$0 + (block $label$1 + (br_if $label$1 + (i32.ge_u + (tee_local $5 + (i32.add + (tee_local $4 + (i32.div_s + (i32.sub + (i32.load offset=4 + (get_local $0) + ) + (tee_local $6 + (i32.load + (get_local $0) + ) + ) + ) + (i32.const 24) + ) + ) + (i32.const 1) + ) + ) + (i32.const 178956971) + ) + ) + (set_local $7 + (i32.const 178956970) + ) + (block $label$2 + (block $label$3 + (br_if $label$3 + (i32.gt_u + (tee_local $6 + (i32.div_s + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (get_local $6) + ) + (i32.const 24) + ) + ) + (i32.const 89478484) + ) + ) + (br_if $label$2 + (i32.eqz + (tee_local $7 + (select + (get_local $5) + (tee_local $7 + (i32.shl + (get_local $6) + (i32.const 1) + ) + ) + (i32.lt_u + (get_local $7) + (get_local $5) + ) + ) + ) + ) + ) + ) + (set_local $6 + (call $_Znwj + (i32.mul + (get_local $7) + (i32.const 24) + ) + ) + ) + (br $label$0) + ) + (set_local $7 + (i32.const 0) + ) + (set_local $6 + (i32.const 0) + ) + (br $label$0) + ) + (call $_ZNKSt3__120__vector_base_commonILb1EE20__throw_length_errorEv + (get_local $0) + ) + (unreachable) + ) + (set_local $5 + (i32.load + (get_local $1) + ) + ) + (i32.store + (get_local $1) + (i32.const 0) + ) + (i32.store + (tee_local $1 + (i32.add + (get_local $6) + (i32.mul + (get_local $4) + (i32.const 24) + ) + ) + ) + (get_local $5) + ) + (i64.store offset=8 + (get_local $1) + (i64.load + (get_local $2) + ) + ) + (i32.store offset=16 + (get_local $1) + (i32.load + (get_local $3) + ) + ) + (set_local $4 + (i32.add + (get_local $6) + (i32.mul + (get_local $7) + (i32.const 24) + ) + ) + ) + (set_local $5 + (i32.add + (get_local $1) + (i32.const 24) + ) + ) + (block $label$4 + (block $label$5 + (br_if $label$5 + (i32.eq + (tee_local $6 + (i32.load + (i32.add + (get_local $0) + (i32.const 4) + ) + ) + ) + (tee_local $7 + (i32.load + (get_local $0) + ) + ) + ) + ) + (loop $label$6 + (set_local $3 + (i32.load + (tee_local $2 + (i32.add + (get_local $6) + (i32.const -24) + ) + ) + ) + ) + (i32.store + (get_local $2) + (i32.const 0) + ) + (i32.store + (i32.add + (get_local $1) + (i32.const -24) + ) + (get_local $3) + ) + (i32.store + (i32.add + (get_local $1) + (i32.const -8) + ) + (i32.load + (i32.add + (get_local $6) + (i32.const -8) + ) + ) + ) + (i32.store + (i32.add + (get_local $1) + (i32.const -12) + ) + (i32.load + (i32.add + (get_local $6) + (i32.const -12) + ) + ) + ) + (i32.store + (i32.add + (get_local $1) + (i32.const -16) + ) + (i32.load + (i32.add + (get_local $6) + (i32.const -16) + ) + ) + ) + (set_local $1 + (i32.add + (get_local $1) + (i32.const -24) + ) + ) + (set_local $6 + (get_local $2) + ) + (br_if $label$6 + (i32.ne + (get_local $7) + (get_local $2) + ) + ) + ) + (set_local $7 + (i32.load + (i32.add + (get_local $0) + (i32.const 4) + ) + ) + ) + (set_local $6 + (i32.load + (get_local $0) + ) + ) + (br $label$4) + ) + (set_local $6 + (get_local $7) + ) + ) + (i32.store + (get_local $0) + (get_local $1) + ) + (i32.store + (i32.add + (get_local $0) + (i32.const 4) + ) + (get_local $5) + ) + (i32.store + (i32.add + (get_local $0) + (i32.const 8) + ) + (get_local $4) + ) + (block $label$7 + (br_if $label$7 + (i32.eq + (get_local $7) + (get_local $6) + ) + ) + (loop $label$8 + (set_local $1 + (i32.load + (tee_local $7 + (i32.add + (get_local $7) + (i32.const -24) + ) + ) + ) + ) + (i32.store + (get_local $7) + (i32.const 0) + ) + (block $label$9 + (br_if $label$9 + (i32.eqz + (get_local $1) + ) + ) + (call $_ZdlPv + (get_local $1) + ) + ) + (br_if $label$8 + (i32.ne + (get_local $6) + (get_local $7) + ) + ) + ) + ) + (block $label$10 + (br_if $label$10 + (i32.eqz + (get_local $6) + ) + ) + (call $_ZdlPv + (get_local $6) + ) + ) + ) + (func $_ZNK5eosio11multi_indexILy3607749779137757184ENS_5token7accountEJEE3getEyPKc (param $0 i32) (param $1 i64) (param $2 i32) (result i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (block $label$0 + (br_if $label$0 + (i32.eq + (tee_local $7 + (i32.load + (i32.add + (get_local $0) + (i32.const 28) + ) + ) + ) + (tee_local $3 + (i32.load offset=24 + (get_local $0) + ) + ) + ) + ) + (set_local $6 + (i32.add + (get_local $7) + (i32.const -24) + ) + ) + (set_local $4 + (i32.sub + (i32.const 0) + (get_local $3) + ) + ) + (loop $label$1 + (br_if $label$0 + (i64.eq + (i64.shr_u + (i64.load offset=8 + (i32.load + (get_local $6) + ) + ) + (i64.const 8) + ) + (get_local $1) + ) + ) + (set_local $7 + (get_local $6) + ) + (set_local $6 + (tee_local $5 + (i32.add + (get_local $6) + (i32.const -24) + ) + ) + ) + (br_if $label$1 + (i32.ne + (i32.add + (get_local $5) + (get_local $4) + ) + (i32.const -24) + ) + ) + ) + ) + (block $label$2 + (block $label$3 + (br_if $label$3 + (i32.eq + (get_local $7) + (get_local $3) + ) + ) + (call $eosio_assert + (i32.eq + (i32.load offset=16 + (tee_local $6 + (i32.load + (i32.add + (get_local $7) + (i32.const -24) + ) + ) + ) + ) + (get_local $0) + ) + (i32.const 32) + ) + (br $label$2) + ) + (set_local $6 + (i32.const 0) + ) + (br_if $label$2 + (i32.lt_s + (tee_local $5 + (call $db_find_i64 + (i64.load + (get_local $0) + ) + (i64.load offset=8 + (get_local $0) + ) + (i64.const 3607749779137757184) + (get_local $1) + ) + ) + (i32.const 0) + ) + ) + (call $eosio_assert + (i32.eq + (i32.load offset=16 + (tee_local $6 + (call $_ZNK5eosio11multi_indexILy3607749779137757184ENS_5token7accountEJEE31load_object_by_primary_iteratorEl + (get_local $0) + (get_local $5) + ) + ) + ) + (get_local $0) + ) + (i32.const 32) + ) + ) + (call $eosio_assert + (i32.ne + (get_local $6) + (i32.const 0) + ) + (get_local $2) + ) + (get_local $6) + ) + (func $_ZNK5eosio11multi_indexILy3607749779137757184ENS_5token7accountEJEE31load_object_by_primary_iteratorEl (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 i64) + (local $6 i32) + (local $7 i32) + (local $8 i32) + (local $9 i32) + (i32.store offset=4 + (i32.const 0) + (tee_local $9 + (i32.sub + (i32.load offset=4 + (i32.const 0) + ) + (i32.const 48) + ) + ) + ) + (i32.store offset=44 + (tee_local $8 + (get_local $9) + ) + (get_local $1) + ) + (block $label$0 + (br_if $label$0 + (i32.eq + (tee_local $7 + (i32.load + (i32.add + (get_local $0) + (i32.const 28) + ) + ) + ) + (tee_local $2 + (i32.load offset=24 + (get_local $0) + ) + ) + ) + ) + (set_local $3 + (i32.sub + (i32.const 0) + (get_local $2) + ) + ) + (set_local $6 + (i32.add + (get_local $7) + (i32.const -24) + ) + ) + (loop $label$1 + (br_if $label$0 + (i32.eq + (i32.load + (i32.add + (get_local $6) + (i32.const 16) + ) + ) + (get_local $1) + ) + ) + (set_local $7 + (get_local $6) + ) + (set_local $6 + (tee_local $4 + (i32.add + (get_local $6) + (i32.const -24) + ) + ) + ) + (br_if $label$1 + (i32.ne + (i32.add + (get_local $4) + (get_local $3) + ) + (i32.const -24) + ) + ) + ) + ) + (block $label$2 + (block $label$3 + (br_if $label$3 + (i32.eq + (get_local $7) + (get_local $2) + ) + ) + (set_local $6 + (i32.load + (i32.add + (get_local $7) + (i32.const -24) + ) + ) + ) + (br $label$2) + ) + (call $eosio_assert + (i32.xor + (i32.shr_u + (tee_local $6 + (call $db_get_i64 + (get_local $1) + (i32.const 0) + (i32.const 0) + ) + ) + (i32.const 31) + ) + (i32.const 1) + ) + (i32.const 240) + ) + (block $label$4 + (block $label$5 + (br_if $label$5 + (i32.lt_u + (get_local $6) + (i32.const 513) + ) + ) + (set_local $4 + (call $malloc + (get_local $6) + ) + ) + (br $label$4) + ) + (i32.store offset=4 + (i32.const 0) + (tee_local $4 + (i32.sub + (get_local $9) + (i32.and + (i32.add + (get_local $6) + (i32.const 15) + ) + (i32.const -16) + ) + ) + ) + ) + ) + (drop + (call $db_get_i64 + (get_local $1) + (get_local $4) + (get_local $6) + ) + ) + (i32.store offset=36 + (get_local $8) + (get_local $4) + ) + (i32.store offset=32 + (get_local $8) + (get_local $4) + ) + (i32.store offset=40 + (get_local $8) + (i32.add + (get_local $4) + (get_local $6) + ) + ) + (block $label$6 + (br_if $label$6 + (i32.lt_u + (get_local $6) + (i32.const 513) + ) + ) + (call $free + (get_local $4) + ) + ) + (i32.store offset=12 + (get_local $8) + (i32.add + (get_local $8) + (i32.const 32) + ) + ) + (i32.store offset=16 + (get_local $8) + (i32.add + (get_local $8) + (i32.const 44) + ) + ) + (i32.store offset=8 + (get_local $8) + (get_local $0) + ) + (set_local $6 + (call $_ZN5eosio11multi_indexILy3607749779137757184ENS_5token7accountEJEE4itemC2IZNKS3_31load_object_by_primary_iteratorElEUlRT_E_EEPKS3_OS6_ + (tee_local $4 + (call $_Znwj + (i32.const 32) + ) + ) + (get_local $0) + (i32.add + (get_local $8) + (i32.const 8) + ) + ) + ) + (i32.store offset=24 + (get_local $8) + (get_local $4) + ) + (i64.store offset=8 + (get_local $8) + (tee_local $5 + (i64.shr_u + (i64.load offset=8 + (get_local $4) + ) + (i64.const 8) + ) + ) + ) + (i32.store offset=4 + (get_local $8) + (tee_local $1 + (i32.load offset=20 + (get_local $4) + ) + ) + ) + (block $label$7 + (block $label$8 + (br_if $label$8 + (i32.ge_u + (tee_local $7 + (i32.load + (tee_local $3 + (i32.add + (get_local $0) + (i32.const 28) + ) + ) + ) + ) + (i32.load + (i32.add + (get_local $0) + (i32.const 32) + ) + ) + ) + ) + (i64.store offset=8 + (get_local $7) + (get_local $5) + ) + (i32.store offset=16 + (get_local $7) + (get_local $1) + ) + (i32.store offset=24 + (get_local $8) + (i32.const 0) + ) + (i32.store + (get_local $7) + (get_local $4) + ) + (i32.store + (get_local $3) + (i32.add + (get_local $7) + (i32.const 24) + ) + ) + (br $label$7) + ) + (call $_ZNSt3__16vectorIN5eosio11multi_indexILy3607749779137757184ENS1_5token7accountEJEE8item_ptrENS_9allocatorIS6_EEE24__emplace_back_slow_pathIJNS_10unique_ptrINS5_4itemENS_14default_deleteISC_EEEERyRlEEEvDpOT_ + (i32.add + (get_local $0) + (i32.const 24) + ) + (i32.add + (get_local $8) + (i32.const 24) + ) + (i32.add + (get_local $8) + (i32.const 8) + ) + (i32.add + (get_local $8) + (i32.const 4) + ) + ) + ) + (set_local $4 + (i32.load offset=24 + (get_local $8) + ) + ) + (i32.store offset=24 + (get_local $8) + (i32.const 0) + ) + (br_if $label$2 + (i32.eqz + (get_local $4) + ) + ) + (call $_ZdlPv + (get_local $4) + ) + ) + (i32.store offset=4 + (i32.const 0) + (i32.add + (get_local $8) + (i32.const 48) + ) + ) + (get_local $6) + ) + (func $_ZN5eosio11multi_indexILy3607749779137757184ENS_5token7accountEJEE4itemC2IZNKS3_31load_object_by_primary_iteratorElEUlRT_E_EEPKS3_OS6_ (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i32) + (local $5 i32) + (i64.store offset=8 + (get_local $0) + (i64.const 1397703940) + ) + (i64.store + (get_local $0) + (i64.const 0) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 176) + ) + (set_local $3 + (i64.shr_u + (i64.load offset=8 + (get_local $0) + ) + (i64.const 8) + ) + ) + (set_local $4 + (i32.const 0) + ) + (block $label$0 + (block $label$1 + (loop $label$2 + (br_if $label$1 + (i32.gt_u + (i32.add + (i32.shl + (i32.wrap/i64 + (get_local $3) + ) + (i32.const 24) + ) + (i32.const -1073741825) + ) + (i32.const 452984830) + ) + ) + (block $label$3 + (br_if $label$3 + (i64.ne + (i64.and + (tee_local $3 + (i64.shr_u + (get_local $3) + (i64.const 8) + ) + ) + (i64.const 255) + ) + (i64.const 0) + ) + ) + (loop $label$4 + (br_if $label$1 + (i64.ne + (i64.and + (tee_local $3 + (i64.shr_u + (get_local $3) + (i64.const 8) + ) + ) + (i64.const 255) + ) + (i64.const 0) + ) + ) + (br_if $label$4 + (i32.lt_s + (tee_local $4 + (i32.add + (get_local $4) + (i32.const 1) + ) + ) + (i32.const 7) + ) + ) + ) + ) + (set_local $5 + (i32.const 1) + ) + (br_if $label$2 + (i32.lt_s + (tee_local $4 + (i32.add + (get_local $4) + (i32.const 1) + ) + ) + (i32.const 7) + ) + ) + (br $label$0) + ) + ) + (set_local $5 + (i32.const 0) + ) + ) + (call $eosio_assert + (get_local $5) + (i32.const 128) + ) + (i32.store offset=16 + (get_local $0) + (get_local $1) + ) + (call $eosio_assert + (i32.gt_u + (i32.sub + (i32.load offset=8 + (tee_local $4 + (i32.load offset=4 + (get_local $2) + ) + ) + ) + (i32.load offset=4 + (get_local $4) + ) + ) + (i32.const 7) + ) + (i32.const 272) + ) + (drop + (call $memcpy + (get_local $0) + (i32.load offset=4 + (get_local $4) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $4) + (tee_local $5 + (i32.add + (i32.load offset=4 + (get_local $4) + ) + (i32.const 8) + ) + ) + ) + (call $eosio_assert + (i32.gt_u + (i32.sub + (i32.load offset=8 + (get_local $4) + ) + (get_local $5) + ) + (i32.const 7) + ) + (i32.const 272) + ) + (drop + (call $memcpy + (i32.add + (get_local $0) + (i32.const 8) + ) + (i32.load offset=4 + (get_local $4) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $4) + (i32.add + (i32.load offset=4 + (get_local $4) + ) + (i32.const 8) + ) + ) + (i32.store offset=20 + (get_local $0) + (i32.load + (i32.load offset=8 + (get_local $2) + ) + ) + ) + (get_local $0) + ) + (func $_ZNSt3__16vectorIN5eosio11multi_indexILy3607749779137757184ENS1_5token7accountEJEE8item_ptrENS_9allocatorIS6_EEE24__emplace_back_slow_pathIJNS_10unique_ptrINS5_4itemENS_14default_deleteISC_EEEERyRlEEEvDpOT_ (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (block $label$0 + (block $label$1 + (br_if $label$1 + (i32.ge_u + (tee_local $5 + (i32.add + (tee_local $4 + (i32.div_s + (i32.sub + (i32.load offset=4 + (get_local $0) + ) + (tee_local $6 + (i32.load + (get_local $0) + ) + ) + ) + (i32.const 24) + ) + ) + (i32.const 1) + ) + ) + (i32.const 178956971) + ) + ) + (set_local $7 + (i32.const 178956970) + ) + (block $label$2 + (block $label$3 + (br_if $label$3 + (i32.gt_u + (tee_local $6 + (i32.div_s + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (get_local $6) + ) + (i32.const 24) + ) + ) + (i32.const 89478484) + ) + ) + (br_if $label$2 + (i32.eqz + (tee_local $7 + (select + (get_local $5) + (tee_local $7 + (i32.shl + (get_local $6) + (i32.const 1) + ) + ) + (i32.lt_u + (get_local $7) + (get_local $5) + ) + ) + ) + ) + ) + ) + (set_local $6 + (call $_Znwj + (i32.mul + (get_local $7) + (i32.const 24) + ) + ) + ) + (br $label$0) + ) + (set_local $7 + (i32.const 0) + ) + (set_local $6 + (i32.const 0) + ) + (br $label$0) + ) + (call $_ZNKSt3__120__vector_base_commonILb1EE20__throw_length_errorEv + (get_local $0) + ) + (unreachable) + ) + (set_local $5 + (i32.load + (get_local $1) + ) + ) + (i32.store + (get_local $1) + (i32.const 0) + ) + (i32.store + (tee_local $1 + (i32.add + (get_local $6) + (i32.mul + (get_local $4) + (i32.const 24) + ) + ) + ) + (get_local $5) + ) + (i64.store offset=8 + (get_local $1) + (i64.load + (get_local $2) + ) + ) + (i32.store offset=16 + (get_local $1) + (i32.load + (get_local $3) + ) + ) + (set_local $4 + (i32.add + (get_local $6) + (i32.mul + (get_local $7) + (i32.const 24) + ) + ) + ) + (set_local $5 + (i32.add + (get_local $1) + (i32.const 24) + ) + ) + (block $label$4 + (block $label$5 + (br_if $label$5 + (i32.eq + (tee_local $6 + (i32.load + (i32.add + (get_local $0) + (i32.const 4) + ) + ) + ) + (tee_local $7 + (i32.load + (get_local $0) + ) + ) + ) + ) + (loop $label$6 + (set_local $3 + (i32.load + (tee_local $2 + (i32.add + (get_local $6) + (i32.const -24) + ) + ) + ) + ) + (i32.store + (get_local $2) + (i32.const 0) + ) + (i32.store + (i32.add + (get_local $1) + (i32.const -24) + ) + (get_local $3) + ) + (i32.store + (i32.add + (get_local $1) + (i32.const -8) + ) + (i32.load + (i32.add + (get_local $6) + (i32.const -8) + ) + ) + ) + (i32.store + (i32.add + (get_local $1) + (i32.const -12) + ) + (i32.load + (i32.add + (get_local $6) + (i32.const -12) + ) + ) + ) + (i32.store + (i32.add + (get_local $1) + (i32.const -16) + ) + (i32.load + (i32.add + (get_local $6) + (i32.const -16) + ) + ) + ) + (set_local $1 + (i32.add + (get_local $1) + (i32.const -24) + ) + ) + (set_local $6 + (get_local $2) + ) + (br_if $label$6 + (i32.ne + (get_local $7) + (get_local $2) + ) + ) + ) + (set_local $7 + (i32.load + (i32.add + (get_local $0) + (i32.const 4) + ) + ) + ) + (set_local $6 + (i32.load + (get_local $0) + ) + ) + (br $label$4) + ) + (set_local $6 + (get_local $7) + ) + ) + (i32.store + (get_local $0) + (get_local $1) + ) + (i32.store + (i32.add + (get_local $0) + (i32.const 4) + ) + (get_local $5) + ) + (i32.store + (i32.add + (get_local $0) + (i32.const 8) + ) + (get_local $4) + ) + (block $label$7 + (br_if $label$7 + (i32.eq + (get_local $7) + (get_local $6) + ) + ) + (loop $label$8 + (set_local $1 + (i32.load + (tee_local $7 + (i32.add + (get_local $7) + (i32.const -24) + ) + ) + ) + ) + (i32.store + (get_local $7) + (i32.const 0) + ) + (block $label$9 + (br_if $label$9 + (i32.eqz + (get_local $1) + ) + ) + (call $_ZdlPv + (get_local $1) + ) + ) + (br_if $label$8 + (i32.ne + (get_local $6) + (get_local $7) + ) + ) + ) + ) + (block $label$10 + (br_if $label$10 + (i32.eqz + (get_local $6) + ) + ) + (call $_ZdlPv + (get_local $6) + ) + ) + ) + (func $_ZN5eosiorsINS_10datastreamIPKcEEEERT_S6_RNS_8currency8transferE (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + (call $eosio_assert + (i32.gt_u + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (i32.load offset=4 + (get_local $0) + ) + ) + (i32.const 7) + ) + (i32.const 272) + ) + (drop + (call $memcpy + (get_local $1) + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $0) + (tee_local $2 + (i32.add + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + ) + (call $eosio_assert + (i32.gt_u + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (get_local $2) + ) + (i32.const 7) + ) + (i32.const 272) + ) + (drop + (call $memcpy + (i32.add + (get_local $1) + (i32.const 8) + ) + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $0) + (tee_local $2 + (i32.add + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + ) + (call $eosio_assert + (i32.gt_u + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (get_local $2) + ) + (i32.const 7) + ) + (i32.const 272) + ) + (drop + (call $memcpy + (i32.add + (get_local $1) + (i32.const 16) + ) + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $0) + (tee_local $2 + (i32.add + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + ) + (call $eosio_assert + (i32.gt_u + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (get_local $2) + ) + (i32.const 7) + ) + (i32.const 272) + ) + (drop + (call $memcpy + (i32.add + (get_local $1) + (i32.const 24) + ) + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $0) + (i32.add + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + (call $_ZN5eosiorsINS_10datastreamIPKcEEEERT_S6_RNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEE + (get_local $0) + (i32.add + (get_local $1) + (i32.const 32) + ) + ) + ) + (func $_ZN5eosiorsINS_10datastreamIPKcEEEERT_S6_RNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEE (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (i32.store offset=4 + (i32.const 0) + (tee_local $7 + (i32.sub + (i32.load offset=4 + (i32.const 0) + ) + (i32.const 32) + ) + ) + ) + (i32.store offset=24 + (get_local $7) + (i32.const 0) + ) + (i64.store offset=16 + (get_local $7) + (i64.const 0) + ) + (drop + (call $_ZN5eosiorsINS_10datastreamIPKcEEEERT_S6_RNSt3__16vectorIcNS7_9allocatorIcEEEE + (get_local $0) + (i32.add + (get_local $7) + (i32.const 16) + ) + ) + ) + (block $label$0 + (block $label$1 + (block $label$2 + (block $label$3 + (block $label$4 + (block $label$5 + (block $label$6 + (block $label$7 + (block $label$8 + (br_if $label$8 + (i32.ne + (tee_local $5 + (i32.load offset=20 + (get_local $7) + ) + ) + (tee_local $4 + (i32.load offset=16 + (get_local $7) + ) + ) + ) + ) + (br_if $label$7 + (i32.and + (i32.load8_u + (get_local $1) + ) + (i32.const 1) + ) + ) + (i32.store16 + (get_local $1) + (i32.const 0) + ) + (set_local $4 + (i32.add + (get_local $1) + (i32.const 8) + ) + ) + (br $label$6) + ) + (i32.store + (i32.add + (get_local $7) + (i32.const 8) + ) + (i32.const 0) + ) + (i64.store + (get_local $7) + (i64.const 0) + ) + (br_if $label$0 + (i32.ge_u + (tee_local $2 + (i32.sub + (get_local $5) + (get_local $4) + ) + ) + (i32.const -16) + ) + ) + (br_if $label$5 + (i32.ge_u + (get_local $2) + (i32.const 11) + ) + ) + (i32.store8 + (get_local $7) + (i32.shl + (get_local $2) + (i32.const 1) + ) + ) + (set_local $6 + (i32.or + (get_local $7) + (i32.const 1) + ) + ) + (br_if $label$4 + (get_local $2) + ) + (br $label$3) + ) + (i32.store8 + (i32.load offset=8 + (get_local $1) + ) + (i32.const 0) + ) + (i32.store offset=4 + (get_local $1) + (i32.const 0) + ) + (set_local $4 + (i32.add + (get_local $1) + (i32.const 8) + ) + ) + ) + (call $_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7reserveEj + (get_local $1) + (i32.const 0) + ) + (i32.store + (get_local $4) + (i32.const 0) + ) + (i64.store align=4 + (get_local $1) + (i64.const 0) + ) + (br_if $label$2 + (tee_local $4 + (i32.load offset=16 + (get_local $7) + ) + ) + ) + (br $label$1) + ) + (set_local $6 + (call $_Znwj + (tee_local $5 + (i32.and + (i32.add + (get_local $2) + (i32.const 16) + ) + (i32.const -16) + ) + ) + ) + ) + (i32.store + (get_local $7) + (i32.or + (get_local $5) + (i32.const 1) + ) + ) + (i32.store offset=8 + (get_local $7) + (get_local $6) + ) + (i32.store offset=4 + (get_local $7) + (get_local $2) + ) + ) + (set_local $3 + (get_local $2) + ) + (set_local $5 + (get_local $6) + ) + (loop $label$9 + (i32.store8 + (get_local $5) + (i32.load8_u + (get_local $4) + ) + ) + (set_local $5 + (i32.add + (get_local $5) + (i32.const 1) + ) + ) + (set_local $4 + (i32.add + (get_local $4) + (i32.const 1) + ) + ) + (br_if $label$9 + (tee_local $3 + (i32.add + (get_local $3) + (i32.const -1) + ) + ) + ) + ) + (set_local $6 + (i32.add + (get_local $6) + (get_local $2) + ) + ) + ) + (i32.store8 + (get_local $6) + (i32.const 0) + ) + (block $label$10 + (block $label$11 + (br_if $label$11 + (i32.and + (i32.load8_u + (get_local $1) + ) + (i32.const 1) + ) + ) + (i32.store16 + (get_local $1) + (i32.const 0) + ) + (br $label$10) + ) + (i32.store8 + (i32.load offset=8 + (get_local $1) + ) + (i32.const 0) + ) + (i32.store offset=4 + (get_local $1) + (i32.const 0) + ) + ) + (call $_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7reserveEj + (get_local $1) + (i32.const 0) + ) + (i32.store + (i32.add + (get_local $1) + (i32.const 8) + ) + (i32.load + (i32.add + (get_local $7) + (i32.const 8) + ) + ) + ) + (i64.store align=4 + (get_local $1) + (i64.load + (get_local $7) + ) + ) + (br_if $label$1 + (i32.eqz + (tee_local $4 + (i32.load offset=16 + (get_local $7) + ) + ) + ) + ) + ) + (i32.store offset=20 + (get_local $7) + (get_local $4) + ) + (call $_ZdlPv + (get_local $4) + ) + ) + (i32.store offset=4 + (i32.const 0) + (i32.add + (get_local $7) + (i32.const 32) + ) + ) + (return + (get_local $0) + ) + ) + (call $_ZNKSt3__121__basic_string_commonILb1EE20__throw_length_errorEv + (get_local $7) + ) + (unreachable) + ) + (func $_ZN5eosiorsINS_10datastreamIPKcEEEERT_S6_RNSt3__16vectorIcNS7_9allocatorIcEEEE (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i64) + (local $7 i32) + (set_local $5 + (i32.load offset=4 + (get_local $0) + ) + ) + (set_local $7 + (i32.const 0) + ) + (set_local $6 + (i64.const 0) + ) + (set_local $2 + (i32.add + (get_local $0) + (i32.const 8) + ) + ) + (set_local $3 + (i32.add + (get_local $0) + (i32.const 4) + ) + ) + (loop $label$0 + (call $eosio_assert + (i32.lt_u + (get_local $5) + (i32.load + (get_local $2) + ) + ) + (i32.const 2336) + ) + (set_local $4 + (i32.load8_u + (tee_local $5 + (i32.load + (get_local $3) + ) + ) + ) + ) + (i32.store + (get_local $3) + (tee_local $5 + (i32.add + (get_local $5) + (i32.const 1) + ) + ) + ) + (set_local $6 + (i64.or + (i64.extend_u/i32 + (i32.shl + (i32.and + (get_local $4) + (i32.const 127) + ) + (tee_local $7 + (i32.and + (get_local $7) + (i32.const 255) + ) + ) + ) + ) + (get_local $6) + ) + ) + (set_local $7 + (i32.add + (get_local $7) + (i32.const 7) + ) + ) + (br_if $label$0 + (i32.shr_u + (get_local $4) + (i32.const 7) + ) + ) + ) + (block $label$1 + (block $label$2 + (br_if $label$2 + (i32.le_u + (tee_local $3 + (i32.wrap/i64 + (get_local $6) + ) + ) + (tee_local $2 + (i32.sub + (tee_local $7 + (i32.load offset=4 + (get_local $1) + ) + ) + (tee_local $4 + (i32.load + (get_local $1) + ) + ) + ) + ) + ) + ) + (call $_ZNSt3__16vectorIcNS_9allocatorIcEEE8__appendEj + (get_local $1) + (i32.sub + (get_local $3) + (get_local $2) + ) + ) + (set_local $5 + (i32.load + (i32.add + (get_local $0) + (i32.const 4) + ) + ) + ) + (set_local $7 + (i32.load + (i32.add + (get_local $1) + (i32.const 4) + ) + ) + ) + (set_local $4 + (i32.load + (get_local $1) + ) + ) + (br $label$1) + ) + (br_if $label$1 + (i32.ge_u + (get_local $3) + (get_local $2) + ) + ) + (i32.store + (i32.add + (get_local $1) + (i32.const 4) + ) + (tee_local $7 + (i32.add + (get_local $4) + (get_local $3) + ) + ) + ) + ) + (call $eosio_assert + (i32.ge_u + (i32.sub + (i32.load + (i32.add + (get_local $0) + (i32.const 8) + ) + ) + (get_local $5) + ) + (tee_local $5 + (i32.sub + (get_local $7) + (get_local $4) + ) + ) + ) + (i32.const 272) + ) + (drop + (call $memcpy + (get_local $4) + (i32.load + (tee_local $7 + (i32.add + (get_local $0) + (i32.const 4) + ) + ) + ) + (get_local $5) + ) + ) + (i32.store + (get_local $7) + (i32.add + (i32.load + (get_local $7) + ) + (get_local $5) + ) + ) + (get_local $0) + ) + (func $_ZN6eoswin7lottery9randomkeyEy (param $0 i32) (param $1 i64) (result i64) + (local $2 i64) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (local $8 i32) + (i32.store offset=4 + (i32.const 0) + (tee_local $8 + (i32.sub + (i32.load offset=4 + (i32.const 0) + ) + (i32.const 48) + ) + ) + ) + (block $label$0 + (br_if $label$0 + (i32.load8_u offset=2340 + (i32.const 0) + ) + ) + (i32.store8 offset=2340 + (i32.const 0) + (i32.const 1) + ) + (i64.store offset=2344 + (i32.const 0) + (i64.extend_s/i32 + (i32.add + (get_local $8) + (i32.const 16) + ) + ) + ) + ) + (set_local $2 + (i64.load + (i32.add + (get_local $0) + (i32.const 64) + ) + ) + ) + (block $label$1 + (br_if $label$1 + (i32.eq + (tee_local $7 + (i32.load + (i32.add + (get_local $0) + (i32.const 172) + ) + ) + ) + (tee_local $3 + (i32.load + (i32.add + (get_local $0) + (i32.const 168) + ) + ) + ) + ) + ) + (set_local $6 + (i32.add + (get_local $7) + (i32.const -24) + ) + ) + (set_local $4 + (i32.sub + (i32.const 0) + (get_local $3) + ) + ) + (loop $label$2 + (br_if $label$1 + (i64.eq + (i64.load + (i32.load + (get_local $6) + ) + ) + (get_local $2) + ) + ) + (set_local $7 + (get_local $6) + ) + (set_local $6 + (tee_local $5 + (i32.add + (get_local $6) + (i32.const -24) + ) + ) + ) + (br_if $label$2 + (i32.ne + (i32.add + (get_local $5) + (get_local $4) + ) + (i32.const -24) + ) + ) + ) + ) + (set_local $5 + (i32.add + (get_local $0) + (i32.const 144) + ) + ) + (block $label$3 + (block $label$4 + (br_if $label$4 + (i32.eq + (get_local $7) + (get_local $3) + ) + ) + (call $eosio_assert + (i32.eq + (i32.load offset=80 + (tee_local $6 + (i32.load + (i32.add + (get_local $7) + (i32.const -24) + ) + ) + ) + ) + (get_local $5) + ) + (i32.const 32) + ) + (br $label$3) + ) + (set_local $6 + (i32.const 0) + ) + (br_if $label$3 + (i32.lt_s + (tee_local $7 + (call $db_find_i64 + (i64.load + (i32.add + (get_local $0) + (i32.const 144) + ) + ) + (i64.load + (i32.add + (get_local $0) + (i32.const 152) + ) + ) + (i64.const -4812882490098188288) + (get_local $2) + ) + ) + (i32.const 0) + ) + ) + (call $eosio_assert + (i32.eq + (i32.load offset=80 + (tee_local $6 + (call $_ZNK5eosio11multi_indexILy13633861583611363328EN6eoswin10round_itemEJEE31load_object_by_primary_iteratorEl + (get_local $5) + (get_local $7) + ) + ) + ) + (get_local $5) + ) + (i32.const 32) + ) + ) + (i64.store offset=8 + (get_local $8) + (tee_local $2 + (i64.add + (i64.add + (i64.add + (i64.extend_s/i32 + (i32.add + (call $tapos_block_prefix) + (call $tapos_block_num) + ) + ) + (i64.load offset=24 + (get_local $6) + ) + ) + (i64.load offset=2344 + (i32.const 0) + ) + ) + (call $current_time) + ) + ) + ) + (i64.store offset=2344 + (i32.const 0) + (i64.add + (i64.shr_u + (get_local $2) + (i64.const 33) + ) + (i64.load offset=2344 + (i32.const 0) + ) + ) + ) + (call $sha256 + (i32.add + (get_local $8) + (i32.const 8) + ) + (i32.const 4) + (i32.add + (get_local $8) + (i32.const 16) + ) + ) + (call $eosio_assert + (i64.ne + (get_local $1) + (i64.const 0) + ) + (i32.const 2352) + ) + (set_local $2 + (i64.load offset=24 + (get_local $8) + ) + ) + (i32.store offset=4 + (i32.const 0) + (i32.add + (get_local $8) + (i32.const 48) + ) + ) + (i64.add + (i64.rem_u + (get_local $2) + (get_local $1) + ) + (i64.const 1) + ) + ) + (func $_ZN6eoswin7lottery9delaydrawEy (type $FUNCSIG$vij) (param $0 i32) (param $1 i64) + (local $2 i32) + (local $3 i32) + (local $4 i64) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (local $8 i64) + (local $9 i64) + (local $10 i64) + (local $11 i32) + (i32.store offset=4 + (i32.const 0) + (tee_local $11 + (i32.sub + (i32.load offset=4 + (i32.const 0) + ) + (i32.const 144) + ) + ) + ) + (i64.store offset=120 + (get_local $11) + (get_local $1) + ) + (call $require_auth + (get_local $1) + ) + (call $eosio_assert + (i32.load8_u + (i32.add + (get_local $0) + (i32.const 140) + ) + ) + (i32.const 2384) + ) + (set_local $9 + (i64.load + (i32.add + (get_local $0) + (i32.const 64) + ) + ) + ) + (block $label$0 + (br_if $label$0 + (i32.eq + (tee_local $6 + (i32.load + (i32.add + (get_local $0) + (i32.const 172) + ) + ) + ) + (tee_local $2 + (i32.load + (i32.add + (get_local $0) + (i32.const 168) + ) + ) + ) + ) + ) + (set_local $7 + (i32.add + (get_local $6) + (i32.const -24) + ) + ) + (set_local $3 + (i32.sub + (i32.const 0) + (get_local $2) + ) + ) + (loop $label$1 + (br_if $label$0 + (i64.eq + (i64.load + (i32.load + (get_local $7) + ) + ) + (get_local $9) + ) + ) + (set_local $6 + (get_local $7) + ) + (set_local $7 + (tee_local $5 + (i32.add + (get_local $7) + (i32.const -24) + ) + ) + ) + (br_if $label$1 + (i32.ne + (i32.add + (get_local $5) + (get_local $3) + ) + (i32.const -24) + ) + ) + ) + ) + (set_local $5 + (i32.add + (get_local $0) + (i32.const 144) + ) + ) + (block $label$2 + (block $label$3 + (br_if $label$3 + (i32.eq + (get_local $6) + (get_local $2) + ) + ) + (call $eosio_assert + (i32.eq + (i32.load offset=80 + (tee_local $7 + (i32.load + (i32.add + (get_local $6) + (i32.const -24) + ) + ) + ) + ) + (get_local $5) + ) + (i32.const 32) + ) + (br $label$2) + ) + (set_local $7 + (i32.const 0) + ) + (br_if $label$2 + (i32.lt_s + (tee_local $6 + (call $db_find_i64 + (i64.load + (i32.add + (get_local $0) + (i32.const 144) + ) + ) + (i64.load + (i32.add + (get_local $0) + (i32.const 152) + ) + ) + (i64.const -4812882490098188288) + (get_local $9) + ) + ) + (i32.const 0) + ) + ) + (call $eosio_assert + (i32.eq + (i32.load offset=80 + (tee_local $7 + (call $_ZNK5eosio11multi_indexILy13633861583611363328EN6eoswin10round_itemEJEE31load_object_by_primary_iteratorEl + (get_local $5) + (get_local $6) + ) + ) + ) + (get_local $5) + ) + (i32.const 32) + ) + ) + (call $eosio_assert + (i32.ne + (get_local $7) + (i32.const 0) + ) + (i32.const 2416) + ) + (set_local $9 + (i64.const 0) + ) + (call $eosio_assert + (i64.ne + (i64.load offset=16 + (get_local $7) + ) + (i64.const 0) + ) + (i32.const 2448) + ) + (call $eosio_assert + (i64.gt_u + (call $current_time) + (i64.add + (i64.load offset=48 + (get_local $7) + ) + (i64.const 7200000000) + ) + ) + (i32.const 2464) + ) + (i64.store offset=96 + (get_local $11) + (i64.const -1) + ) + (i32.store offset=104 + (get_local $11) + (i32.const 0) + ) + (i64.store offset=80 + (get_local $11) + (i64.load + (get_local $0) + ) + ) + (i64.store offset=88 + (get_local $11) + (i64.load + (i32.add + (get_local $0) + (i32.const 64) + ) + ) + ) + (i32.store + (i32.add + (i32.add + (get_local $11) + (i32.const 80) + ) + (i32.const 28) + ) + (i32.const 0) + ) + (i32.store + (i32.add + (i32.add + (get_local $11) + (i32.const 80) + ) + (i32.const 32) + ) + (i32.const 0) + ) + (drop + (call $_ZNK5eosio11multi_indexILy12415831943914979328EN6eoswin11player_itemEJEE3getEyPKc + (i32.add + (get_local $11) + (i32.const 80) + ) + (get_local $1) + (i32.const 2496) + ) + ) + (set_local $1 + (call $current_time) + ) + (i32.store + (i32.add + (i32.add + (get_local $11) + (i32.const 16) + ) + (i32.const 28) + ) + (i32.const 0) + ) + (i32.store + (i32.add + (i32.add + (get_local $11) + (i32.const 16) + ) + (i32.const 32) + ) + (i32.const 0) + ) + (i32.store offset=28 + (get_local $11) + (i32.const 0) + ) + (i32.store8 offset=32 + (get_local $11) + (i32.const 0) + ) + (i32.store offset=36 + (get_local $11) + (i32.const 0) + ) + (i32.store offset=40 + (get_local $11) + (i32.const 0) + ) + (i32.store offset=16 + (get_local $11) + (i32.add + (i32.wrap/i64 + (i64.div_u + (get_local $1) + (i64.const 1000000) + ) + ) + (i32.const 60) + ) + ) + (i32.store offset=52 + (get_local $11) + (i32.const 0) + ) + (i32.store + (i32.add + (get_local $11) + (i32.const 56) + ) + (i32.const 0) + ) + (i32.store + (i32.add + (get_local $11) + (i32.const 60) + ) + (i32.const 0) + ) + (i32.store offset=64 + (get_local $11) + (i32.const 0) + ) + (i32.store + (i32.add + (get_local $11) + (i32.const 68) + ) + (i32.const 0) + ) + (i32.store + (i32.add + (get_local $11) + (i32.const 72) + ) + (i32.const 0) + ) + (set_local $6 + (i32.add + (get_local $11) + (i32.const 52) + ) + ) + (set_local $4 + (i64.load + (get_local $0) + ) + ) + (set_local $8 + (i64.const 59) + ) + (set_local $7 + (i32.const 592) + ) + (set_local $10 + (i64.const 0) + ) + (loop $label$4 + (block $label$5 + (block $label$6 + (block $label$7 + (block $label$8 + (block $label$9 + (br_if $label$9 + (i64.gt_u + (get_local $9) + (i64.const 5) + ) + ) + (br_if $label$8 + (i32.gt_u + (i32.and + (i32.add + (tee_local $5 + (i32.load8_s + (get_local $7) + ) + ) + (i32.const -97) + ) + (i32.const 255) + ) + (i32.const 25) + ) + ) + (set_local $5 + (i32.add + (get_local $5) + (i32.const 165) + ) + ) + (br $label$7) + ) + (set_local $1 + (i64.const 0) + ) + (br_if $label$6 + (i64.le_u + (get_local $9) + (i64.const 11) + ) + ) + (br $label$5) + ) + (set_local $5 + (select + (i32.add + (get_local $5) + (i32.const 208) + ) + (i32.const 0) + (i32.lt_u + (i32.and + (i32.add + (get_local $5) + (i32.const -49) + ) + (i32.const 255) + ) + (i32.const 5) + ) + ) + ) + ) + (set_local $1 + (i64.shr_s + (i64.shl + (i64.extend_u/i32 + (get_local $5) + ) + (i64.const 56) + ) + (i64.const 56) + ) + ) + ) + (set_local $1 + (i64.shl + (i64.and + (get_local $1) + (i64.const 31) + ) + (i64.and + (get_local $8) + (i64.const 4294967295) + ) + ) + ) + ) + (set_local $7 + (i32.add + (get_local $7) + (i32.const 1) + ) + ) + (set_local $9 + (i64.add + (get_local $9) + (i64.const 1) + ) + ) + (set_local $10 + (i64.or + (get_local $1) + (get_local $10) + ) + ) + (br_if $label$4 + (i64.ne + (tee_local $8 + (i64.add + (get_local $8) + (i64.const -5) + ) + ) + (i64.const -6) + ) + ) + ) + (i64.store offset=8 + (get_local $11) + (get_local $10) + ) + (i64.store + (get_local $11) + (get_local $4) + ) + (set_local $9 + (i64.const 0) + ) + (set_local $8 + (i64.const 59) + ) + (set_local $7 + (i32.const 2528) + ) + (set_local $10 + (i64.const 0) + ) + (loop $label$10 + (block $label$11 + (block $label$12 + (block $label$13 + (block $label$14 + (block $label$15 + (br_if $label$15 + (i64.gt_u + (get_local $9) + (i64.const 6) + ) + ) + (br_if $label$14 + (i32.gt_u + (i32.and + (i32.add + (tee_local $5 + (i32.load8_s + (get_local $7) + ) + ) + (i32.const -97) + ) + (i32.const 255) + ) + (i32.const 25) + ) + ) + (set_local $5 + (i32.add + (get_local $5) + (i32.const 165) + ) + ) + (br $label$13) + ) + (set_local $1 + (i64.const 0) + ) + (br_if $label$12 + (i64.le_u + (get_local $9) + (i64.const 11) + ) + ) + (br $label$11) + ) + (set_local $5 + (select + (i32.add + (get_local $5) + (i32.const 208) + ) + (i32.const 0) + (i32.lt_u + (i32.and + (i32.add + (get_local $5) + (i32.const -49) + ) + (i32.const 255) + ) + (i32.const 5) + ) + ) + ) + ) + (set_local $1 + (i64.shr_s + (i64.shl + (i64.extend_u/i32 + (get_local $5) + ) + (i64.const 56) + ) + (i64.const 56) + ) + ) + ) + (set_local $1 + (i64.shl + (i64.and + (get_local $1) + (i64.const 31) + ) + (i64.and + (get_local $8) + (i64.const 4294967295) + ) + ) + ) + ) + (set_local $7 + (i32.add + (get_local $7) + (i32.const 1) + ) + ) + (set_local $9 + (i64.add + (get_local $9) + (i64.const 1) + ) + ) + (set_local $10 + (i64.or + (get_local $1) + (get_local $10) + ) + ) + (br_if $label$10 + (i64.ne + (tee_local $8 + (i64.add + (get_local $8) + (i64.const -5) + ) + ) + (i64.const -6) + ) + ) + ) + (i64.store offset=128 + (get_local $11) + (get_local $10) + ) + (call $_ZNSt3__16vectorIN5eosio6actionENS_9allocatorIS2_EEE24__emplace_back_slow_pathIJNS1_16permission_levelERyyS8_EEEvDpOT_ + (get_local $6) + (get_local $11) + (get_local $0) + (i32.add + (get_local $11) + (i32.const 128) + ) + (i32.add + (get_local $11) + (i32.const 120) + ) + ) + (set_local $9 + (i64.load + (get_local $0) + ) + ) + (i32.store + (i32.add + (get_local $11) + (i32.const 36) + ) + (i32.const 1) + ) + (i64.store offset=8 + (get_local $11) + (i64.const 0) + ) + (i64.store + (get_local $11) + (get_local $9) + ) + (call $_ZN5eosio4packINS_11transactionEEENSt3__16vectorIcNS2_9allocatorIcEEEERKT_ + (i32.add + (get_local $11) + (i32.const 128) + ) + (i32.add + (get_local $11) + (i32.const 16) + ) + ) + (call $send_deferred + (get_local $11) + (get_local $9) + (tee_local $7 + (i32.load offset=128 + (get_local $11) + ) + ) + (i32.sub + (i32.load offset=132 + (get_local $11) + ) + (get_local $7) + ) + (i32.const 0) + ) + (block $label$16 + (br_if $label$16 + (i32.eqz + (tee_local $7 + (i32.load offset=128 + (get_local $11) + ) + ) + ) + ) + (i32.store offset=132 + (get_local $11) + (get_local $7) + ) + (call $_ZdlPv + (get_local $7) + ) + ) + (drop + (call $_ZN5eosio11transactionD2Ev + (i32.add + (get_local $11) + (i32.const 16) + ) + ) + ) + (block $label$17 + (br_if $label$17 + (i32.eqz + (tee_local $6 + (i32.load offset=104 + (get_local $11) + ) + ) + ) + ) + (block $label$18 + (block $label$19 + (br_if $label$19 + (i32.eq + (tee_local $7 + (i32.load + (tee_local $0 + (i32.add + (get_local $11) + (i32.const 108) + ) + ) + ) + ) + (get_local $6) + ) + ) + (loop $label$20 + (set_local $5 + (i32.load + (tee_local $7 + (i32.add + (get_local $7) + (i32.const -24) + ) + ) + ) + ) + (i32.store + (get_local $7) + (i32.const 0) + ) + (block $label$21 + (br_if $label$21 + (i32.eqz + (get_local $5) + ) + ) + (call $_ZdlPv + (get_local $5) + ) + ) + (br_if $label$20 + (i32.ne + (get_local $6) + (get_local $7) + ) + ) + ) + (set_local $7 + (i32.load + (i32.add + (get_local $11) + (i32.const 104) + ) + ) + ) + (br $label$18) + ) + (set_local $7 + (get_local $6) + ) + ) + (i32.store + (get_local $0) + (get_local $6) + ) + (call $_ZdlPv + (get_local $7) + ) + ) + (i32.store offset=4 + (i32.const 0) + (i32.add + (get_local $11) + (i32.const 144) + ) + ) + ) + (func $_ZNK5eosio11multi_indexILy12415831943914979328EN6eoswin11player_itemEJEE3getEyPKc (param $0 i32) (param $1 i64) (param $2 i32) (result i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (block $label$0 + (br_if $label$0 + (i32.eq + (tee_local $7 + (i32.load + (i32.add + (get_local $0) + (i32.const 28) + ) + ) + ) + (tee_local $3 + (i32.load offset=24 + (get_local $0) + ) + ) + ) + ) + (set_local $6 + (i32.add + (get_local $7) + (i32.const -24) + ) + ) + (set_local $4 + (i32.sub + (i32.const 0) + (get_local $3) + ) + ) + (loop $label$1 + (br_if $label$0 + (i64.eq + (i64.load + (i32.load + (get_local $6) + ) + ) + (get_local $1) + ) + ) + (set_local $7 + (get_local $6) + ) + (set_local $6 + (tee_local $5 + (i32.add + (get_local $6) + (i32.const -24) + ) + ) + ) + (br_if $label$1 + (i32.ne + (i32.add + (get_local $5) + (get_local $4) + ) + (i32.const -24) + ) + ) + ) + ) + (block $label$2 + (block $label$3 + (br_if $label$3 + (i32.eq + (get_local $7) + (get_local $3) + ) + ) + (call $eosio_assert + (i32.eq + (i32.load offset=16 + (tee_local $6 + (i32.load + (i32.add + (get_local $7) + (i32.const -24) + ) + ) + ) + ) + (get_local $0) + ) + (i32.const 32) + ) + (br $label$2) + ) + (set_local $6 + (i32.const 0) + ) + (br_if $label$2 + (i32.lt_s + (tee_local $5 + (call $db_find_i64 + (i64.load + (get_local $0) + ) + (i64.load offset=8 + (get_local $0) + ) + (i64.const -6030912129794572288) + (get_local $1) + ) + ) + (i32.const 0) + ) + ) + (call $eosio_assert + (i32.eq + (i32.load offset=16 + (tee_local $6 + (call $_ZNK5eosio11multi_indexILy12415831943914979328EN6eoswin11player_itemEJEE31load_object_by_primary_iteratorEl + (get_local $0) + (get_local $5) + ) + ) + ) + (get_local $0) + ) + (i32.const 32) + ) + ) + (call $eosio_assert + (i32.ne + (get_local $6) + (i32.const 0) + ) + (get_local $2) + ) + (get_local $6) + ) + (func $_ZNSt3__16vectorIN5eosio6actionENS_9allocatorIS2_EEE24__emplace_back_slow_pathIJNS1_16permission_levelERyyS8_EEEvDpOT_ (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) (param $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (local $8 i32) + (block $label$0 + (block $label$1 + (br_if $label$1 + (i32.ge_u + (tee_local $7 + (i32.add + (tee_local $5 + (i32.div_s + (i32.sub + (i32.load offset=4 + (get_local $0) + ) + (tee_local $8 + (i32.load + (get_local $0) + ) + ) + ) + (i32.const 40) + ) + ) + (i32.const 1) + ) + ) + (i32.const 107374183) + ) + ) + (set_local $6 + (i32.const 107374182) + ) + (block $label$2 + (block $label$3 + (br_if $label$3 + (i32.gt_u + (tee_local $8 + (i32.div_s + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (get_local $8) + ) + (i32.const 40) + ) + ) + (i32.const 53687090) + ) + ) + (br_if $label$2 + (i32.eqz + (tee_local $6 + (select + (get_local $7) + (tee_local $8 + (i32.shl + (get_local $8) + (i32.const 1) + ) + ) + (i32.lt_u + (get_local $8) + (get_local $7) + ) + ) + ) + ) + ) + ) + (set_local $7 + (call $_Znwj + (i32.mul + (get_local $6) + (i32.const 40) + ) + ) + ) + (br $label$0) + ) + (set_local $6 + (i32.const 0) + ) + (set_local $7 + (i32.const 0) + ) + (br $label$0) + ) + (call $_ZNKSt3__120__vector_base_commonILb1EE20__throw_length_errorEv + (get_local $0) + ) + (unreachable) + ) + (i64.store + (tee_local $8 + (i32.add + (get_local $7) + (i32.mul + (get_local $5) + (i32.const 40) + ) + ) + ) + (i64.load + (get_local $2) + ) + ) + (i64.store offset=8 + (get_local $8) + (i64.load + (get_local $3) + ) + ) + (i64.store offset=16 align=4 + (get_local $8) + (i64.const 0) + ) + (i32.store + (tee_local $3 + (i32.add + (get_local $8) + (i32.const 24) + ) + ) + (i32.const 0) + ) + (i32.store offset=16 + (get_local $8) + (tee_local $2 + (call $_Znwj + (i32.const 16) + ) + ) + ) + (i32.store + (get_local $3) + (tee_local $5 + (i32.add + (get_local $2) + (i32.const 16) + ) + ) + ) + (i32.store + (i32.add + (get_local $2) + (i32.const 12) + ) + (i32.load + (i32.add + (get_local $1) + (i32.const 12) + ) + ) + ) + (i32.store + (i32.add + (get_local $2) + (i32.const 8) + ) + (i32.load + (i32.add + (get_local $1) + (i32.const 8) + ) + ) + ) + (i32.store + (i32.add + (get_local $2) + (i32.const 4) + ) + (i32.load + (i32.add + (get_local $1) + (i32.const 4) + ) + ) + ) + (i32.store + (get_local $2) + (i32.load + (get_local $1) + ) + ) + (i32.store + (i32.add + (get_local $8) + (i32.const 20) + ) + (get_local $5) + ) + (i32.store offset=28 + (get_local $8) + (i32.const 0) + ) + (i32.store + (tee_local $2 + (i32.add + (get_local $8) + (i32.const 32) + ) + ) + (i32.const 0) + ) + (i32.store + (i32.add + (get_local $8) + (i32.const 36) + ) + (i32.const 0) + ) + (call $_ZNSt3__16vectorIcNS_9allocatorIcEEE8__appendEj + (i32.add + (get_local $8) + (i32.const 28) + ) + (i32.const 8) + ) + (call $eosio_assert + (i32.gt_s + (i32.sub + (i32.load + (get_local $2) + ) + (tee_local $2 + (i32.load offset=28 + (get_local $8) + ) + ) + ) + (i32.const 7) + ) + (i32.const 400) + ) + (drop + (call $memcpy + (get_local $2) + (get_local $4) + (i32.const 8) + ) + ) + (set_local $4 + (i32.add + (get_local $7) + (i32.mul + (get_local $6) + (i32.const 40) + ) + ) + ) + (set_local $5 + (i32.add + (get_local $8) + (i32.const 40) + ) + ) + (block $label$4 + (block $label$5 + (br_if $label$5 + (i32.eq + (tee_local $1 + (i32.load + (i32.add + (get_local $0) + (i32.const 4) + ) + ) + ) + (tee_local $2 + (i32.load + (get_local $0) + ) + ) + ) + ) + (set_local $3 + (i32.sub + (i32.const 0) + (get_local $2) + ) + ) + (set_local $2 + (i32.add + (get_local $1) + (i32.const -20) + ) + ) + (loop $label$6 + (i64.store + (i32.add + (get_local $8) + (i32.const -32) + ) + (i64.load + (i32.add + (get_local $2) + (i32.const -12) + ) + ) + ) + (i64.store + (i32.add + (get_local $8) + (i32.const -40) + ) + (i64.load + (i32.add + (get_local $2) + (i32.const -20) + ) + ) + ) + (i64.store align=4 + (tee_local $1 + (i32.add + (get_local $8) + (i32.const -24) + ) + ) + (i64.const 0) + ) + (i32.store + (tee_local $6 + (i32.add + (get_local $8) + (i32.const -16) + ) + ) + (i32.const 0) + ) + (i32.store + (get_local $1) + (i32.load + (tee_local $7 + (i32.add + (get_local $2) + (i32.const -4) + ) + ) + ) + ) + (i32.store + (i32.add + (get_local $8) + (i32.const -20) + ) + (i32.load + (get_local $2) + ) + ) + (i32.store + (get_local $6) + (i32.load + (tee_local $1 + (i32.add + (get_local $2) + (i32.const 4) + ) + ) + ) + ) + (i32.store + (get_local $1) + (i32.const 0) + ) + (i64.store align=4 + (tee_local $1 + (i32.add + (get_local $8) + (i32.const -12) + ) + ) + (i64.const 0) + ) + (i64.store align=4 + (get_local $7) + (i64.const 0) + ) + (i32.store + (tee_local $6 + (i32.add + (get_local $8) + (i32.const -4) + ) + ) + (i32.const 0) + ) + (i32.store + (get_local $1) + (i32.load + (tee_local $7 + (i32.add + (get_local $2) + (i32.const 8) + ) + ) + ) + ) + (i32.store + (i32.add + (get_local $8) + (i32.const -8) + ) + (i32.load + (i32.add + (get_local $2) + (i32.const 12) + ) + ) + ) + (i32.store + (get_local $6) + (i32.load + (tee_local $1 + (i32.add + (get_local $2) + (i32.const 16) + ) + ) + ) + ) + (i32.store + (get_local $1) + (i32.const 0) + ) + (i64.store align=4 + (get_local $7) + (i64.const 0) + ) + (set_local $8 + (i32.add + (get_local $8) + (i32.const -40) + ) + ) + (br_if $label$6 + (i32.ne + (i32.add + (tee_local $2 + (i32.add + (get_local $2) + (i32.const -40) + ) + ) + (get_local $3) + ) + (i32.const -20) + ) + ) + ) + (set_local $2 + (i32.load + (i32.add + (get_local $0) + (i32.const 4) + ) + ) + ) + (set_local $6 + (i32.load + (get_local $0) + ) + ) + (br $label$4) + ) + (set_local $6 + (get_local $2) + ) + ) + (i32.store + (get_local $0) + (get_local $8) + ) + (i32.store + (i32.add + (get_local $0) + (i32.const 4) + ) + (get_local $5) + ) + (i32.store + (i32.add + (get_local $0) + (i32.const 8) + ) + (get_local $4) + ) + (block $label$7 + (br_if $label$7 + (i32.eq + (get_local $2) + (get_local $6) + ) + ) + (set_local $1 + (i32.sub + (i32.const 0) + (get_local $6) + ) + ) + (set_local $8 + (i32.add + (get_local $2) + (i32.const -24) + ) + ) + (loop $label$8 + (block $label$9 + (br_if $label$9 + (i32.eqz + (tee_local $2 + (i32.load + (i32.add + (get_local $8) + (i32.const 12) + ) + ) + ) + ) + ) + (i32.store + (i32.add + (get_local $8) + (i32.const 16) + ) + (get_local $2) + ) + (call $_ZdlPv + (get_local $2) + ) + ) + (block $label$10 + (br_if $label$10 + (i32.eqz + (tee_local $2 + (i32.load + (get_local $8) + ) + ) + ) + ) + (i32.store + (i32.add + (get_local $8) + (i32.const 4) + ) + (get_local $2) + ) + (call $_ZdlPv + (get_local $2) + ) + ) + (br_if $label$8 + (i32.ne + (i32.add + (tee_local $8 + (i32.add + (get_local $8) + (i32.const -40) + ) + ) + (get_local $1) + ) + (i32.const -24) + ) + ) + ) + ) + (block $label$11 + (br_if $label$11 + (i32.eqz + (get_local $6) + ) + ) + (call $_ZdlPv + (get_local $6) + ) + ) + ) + (func $_ZN6eoswin7lottery7drawingEy (type $FUNCSIG$vij) (param $0 i32) (param $1 i64) + (local $2 i64) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i64) + (local $7 i64) + (local $8 i64) + (local $9 i32) + (i32.store offset=4 + (i32.const 0) + (tee_local $9 + (i32.sub + (i32.load offset=4 + (i32.const 0) + ) + (i32.const 112) + ) + ) + ) + (i64.store offset=88 + (get_local $9) + (get_local $1) + ) + (call $require_auth + (i64.load + (get_local $0) + ) + ) + (set_local $1 + (call $current_time) + ) + (i32.store + (i32.add + (get_local $9) + (i32.const 52) + ) + (i32.const 0) + ) + (i32.store + (i32.add + (get_local $9) + (i32.const 56) + ) + (i32.const 0) + ) + (i32.store offset=36 + (get_local $9) + (i32.const 0) + ) + (i32.store8 offset=40 + (get_local $9) + (i32.const 0) + ) + (i32.store offset=44 + (get_local $9) + (i32.const 0) + ) + (i32.store offset=48 + (get_local $9) + (i32.const 0) + ) + (i32.store offset=24 + (get_local $9) + (i32.add + (i32.wrap/i64 + (i64.div_u + (get_local $1) + (i64.const 1000000) + ) + ) + (i32.const 60) + ) + ) + (i32.store offset=60 + (get_local $9) + (i32.const 0) + ) + (i32.store + (i32.add + (get_local $9) + (i32.const 64) + ) + (i32.const 0) + ) + (i32.store + (i32.add + (get_local $9) + (i32.const 68) + ) + (i32.const 0) + ) + (i32.store offset=72 + (get_local $9) + (i32.const 0) + ) + (i32.store + (i32.add + (get_local $9) + (i32.const 76) + ) + (i32.const 0) + ) + (i32.store + (i32.add + (get_local $9) + (i32.const 80) + ) + (i32.const 0) + ) + (set_local $3 + (i32.add + (get_local $9) + (i32.const 60) + ) + ) + (set_local $2 + (i64.load + (get_local $0) + ) + ) + (set_local $1 + (i64.const 0) + ) + (set_local $6 + (i64.const 59) + ) + (set_local $5 + (i32.const 592) + ) + (set_local $7 + (i64.const 0) + ) + (loop $label$0 + (block $label$1 + (block $label$2 + (block $label$3 + (block $label$4 + (block $label$5 + (br_if $label$5 + (i64.gt_u + (get_local $1) + (i64.const 5) + ) + ) + (br_if $label$4 + (i32.gt_u + (i32.and + (i32.add + (tee_local $4 + (i32.load8_s + (get_local $5) + ) + ) + (i32.const -97) + ) + (i32.const 255) + ) + (i32.const 25) + ) + ) + (set_local $4 + (i32.add + (get_local $4) + (i32.const 165) + ) + ) + (br $label$3) + ) + (set_local $8 + (i64.const 0) + ) + (br_if $label$2 + (i64.le_u + (get_local $1) + (i64.const 11) + ) + ) + (br $label$1) + ) + (set_local $4 + (select + (i32.add + (get_local $4) + (i32.const 208) + ) + (i32.const 0) + (i32.lt_u + (i32.and + (i32.add + (get_local $4) + (i32.const -49) + ) + (i32.const 255) + ) + (i32.const 5) + ) + ) + ) + ) + (set_local $8 + (i64.shr_s + (i64.shl + (i64.extend_u/i32 + (get_local $4) + ) + (i64.const 56) + ) + (i64.const 56) + ) + ) + ) + (set_local $8 + (i64.shl + (i64.and + (get_local $8) + (i64.const 31) + ) + (i64.and + (get_local $6) + (i64.const 4294967295) + ) + ) + ) + ) + (set_local $5 + (i32.add + (get_local $5) + (i32.const 1) + ) + ) + (set_local $1 + (i64.add + (get_local $1) + (i64.const 1) + ) + ) + (set_local $7 + (i64.or + (get_local $8) + (get_local $7) + ) + ) + (br_if $label$0 + (i64.ne + (tee_local $6 + (i64.add + (get_local $6) + (i64.const -5) + ) + ) + (i64.const -6) + ) + ) + ) + (i64.store offset=8 + (get_local $9) + (get_local $7) + ) + (i64.store + (get_local $9) + (get_local $2) + ) + (set_local $1 + (i64.const 0) + ) + (set_local $6 + (i64.const 59) + ) + (set_local $5 + (i32.const 2544) + ) + (set_local $7 + (i64.const 0) + ) + (loop $label$6 + (block $label$7 + (block $label$8 + (block $label$9 + (block $label$10 + (block $label$11 + (br_if $label$11 + (i64.gt_u + (get_local $1) + (i64.const 3) + ) + ) + (br_if $label$10 + (i32.gt_u + (i32.and + (i32.add + (tee_local $4 + (i32.load8_s + (get_local $5) + ) + ) + (i32.const -97) + ) + (i32.const 255) + ) + (i32.const 25) + ) + ) + (set_local $4 + (i32.add + (get_local $4) + (i32.const 165) + ) + ) + (br $label$9) + ) + (set_local $8 + (i64.const 0) + ) + (br_if $label$8 + (i64.le_u + (get_local $1) + (i64.const 11) + ) + ) + (br $label$7) + ) + (set_local $4 + (select + (i32.add + (get_local $4) + (i32.const 208) + ) + (i32.const 0) + (i32.lt_u + (i32.and + (i32.add + (get_local $4) + (i32.const -49) + ) + (i32.const 255) + ) + (i32.const 5) + ) + ) + ) + ) + (set_local $8 + (i64.shr_s + (i64.shl + (i64.extend_u/i32 + (get_local $4) + ) + (i64.const 56) + ) + (i64.const 56) + ) + ) + ) + (set_local $8 + (i64.shl + (i64.and + (get_local $8) + (i64.const 31) + ) + (i64.and + (get_local $6) + (i64.const 4294967295) + ) + ) + ) + ) + (set_local $5 + (i32.add + (get_local $5) + (i32.const 1) + ) + ) + (set_local $1 + (i64.add + (get_local $1) + (i64.const 1) + ) + ) + (set_local $7 + (i64.or + (get_local $8) + (get_local $7) + ) + ) + (br_if $label$6 + (i64.ne + (tee_local $6 + (i64.add + (get_local $6) + (i64.const -5) + ) + ) + (i64.const -6) + ) + ) + ) + (i64.store offset=96 + (get_local $9) + (get_local $7) + ) + (call $_ZNSt3__16vectorIN5eosio6actionENS_9allocatorIS2_EEE24__emplace_back_slow_pathIJNS1_16permission_levelERyyS8_EEEvDpOT_ + (get_local $3) + (get_local $9) + (get_local $0) + (i32.add + (get_local $9) + (i32.const 96) + ) + (i32.add + (get_local $9) + (i32.const 88) + ) + ) + (set_local $1 + (i64.load + (get_local $0) + ) + ) + (i32.store + (i32.add + (get_local $9) + (i32.const 44) + ) + (i32.const 1) + ) + (i64.store offset=8 + (get_local $9) + (i64.const 0) + ) + (i64.store + (get_local $9) + (get_local $1) + ) + (call $_ZN5eosio4packINS_11transactionEEENSt3__16vectorIcNS2_9allocatorIcEEEERKT_ + (i32.add + (get_local $9) + (i32.const 96) + ) + (i32.add + (get_local $9) + (i32.const 24) + ) + ) + (call $send_deferred + (get_local $9) + (get_local $1) + (tee_local $5 + (i32.load offset=96 + (get_local $9) + ) + ) + (i32.sub + (i32.load offset=100 + (get_local $9) + ) + (get_local $5) + ) + (i32.const 0) + ) + (block $label$12 + (br_if $label$12 + (i32.eqz + (tee_local $5 + (i32.load offset=96 + (get_local $9) + ) + ) + ) + ) + (i32.store offset=100 + (get_local $9) + (get_local $5) + ) + (call $_ZdlPv + (get_local $5) + ) + ) + (drop + (call $_ZN5eosio11transactionD2Ev + (i32.add + (get_local $9) + (i32.const 24) + ) + ) + ) + (i32.store offset=4 + (i32.const 0) + (i32.add + (get_local $9) + (i32.const 112) + ) + ) + ) + (func $_ZN6eoswin7lottery4drawEy (type $FUNCSIG$vij) (param $0 i32) (param $1 i64) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 i64) + (local $6 i32) + (local $7 i32) + (local $8 i32) + (local $9 i64) + (local $10 i64) + (local $11 i64) + (local $12 i32) + (i32.store offset=4 + (i32.const 0) + (tee_local $12 + (i32.sub + (i32.load offset=4 + (i32.const 0) + ) + (i32.const 96) + ) + ) + ) + (i64.store offset=88 + (get_local $12) + (get_local $1) + ) + (call $require_auth + (i64.load + (get_local $0) + ) + ) + (set_local $1 + (i64.load + (i32.add + (get_local $0) + (i32.const 64) + ) + ) + ) + (block $label$0 + (br_if $label$0 + (i32.eq + (tee_local $7 + (i32.load + (i32.add + (get_local $0) + (i32.const 172) + ) + ) + ) + (tee_local $3 + (i32.load + (i32.add + (get_local $0) + (i32.const 168) + ) + ) + ) + ) + ) + (set_local $8 + (i32.add + (get_local $7) + (i32.const -24) + ) + ) + (set_local $4 + (i32.sub + (i32.const 0) + (get_local $3) + ) + ) + (loop $label$1 + (br_if $label$0 + (i64.eq + (i64.load + (i32.load + (get_local $8) + ) + ) + (get_local $1) + ) + ) + (set_local $7 + (get_local $8) + ) + (set_local $8 + (tee_local $6 + (i32.add + (get_local $8) + (i32.const -24) + ) + ) + ) + (br_if $label$1 + (i32.ne + (i32.add + (get_local $6) + (get_local $4) + ) + (i32.const -24) + ) + ) + ) + ) + (set_local $2 + (i32.add + (get_local $0) + (i32.const 144) + ) + ) + (block $label$2 + (block $label$3 + (br_if $label$3 + (i32.eq + (get_local $7) + (get_local $3) + ) + ) + (call $eosio_assert + (i32.eq + (i32.load offset=80 + (tee_local $4 + (i32.load + (i32.add + (get_local $7) + (i32.const -24) + ) + ) + ) + ) + (get_local $2) + ) + (i32.const 32) + ) + (br $label$2) + ) + (set_local $4 + (i32.const 0) + ) + (br_if $label$2 + (i32.lt_s + (tee_local $8 + (call $db_find_i64 + (i64.load + (i32.add + (get_local $0) + (i32.const 144) + ) + ) + (i64.load + (i32.add + (get_local $0) + (i32.const 152) + ) + ) + (i64.const -4812882490098188288) + (get_local $1) + ) + ) + (i32.const 0) + ) + ) + (call $eosio_assert + (i32.eq + (i32.load offset=80 + (tee_local $4 + (call $_ZNK5eosio11multi_indexILy13633861583611363328EN6eoswin10round_itemEJEE31load_object_by_primary_iteratorEl + (get_local $2) + (get_local $8) + ) + ) + ) + (get_local $2) + ) + (i32.const 32) + ) + ) + (i64.store offset=80 + (get_local $12) + (call $current_time) + ) + (i64.store offset=72 + (get_local $12) + (call $_ZN6eoswin7lottery9randomkeyEy + (get_local $0) + (i64.load offset=16 + (get_local $4) + ) + ) + ) + (i64.store offset=48 + (get_local $12) + (i64.const -1) + ) + (i32.store offset=56 + (get_local $12) + (i32.const 0) + ) + (i64.store offset=32 + (get_local $12) + (tee_local $1 + (i64.load + (get_local $0) + ) + ) + ) + (i64.store offset=40 + (get_local $12) + (tee_local $11 + (i64.load + (i32.add + (get_local $0) + (i32.const 64) + ) + ) + ) + ) + (i32.store + (i32.add + (get_local $12) + (i32.const 60) + ) + (i32.const 0) + ) + (i32.store + (i32.add + (get_local $12) + (i32.const 64) + ) + (i32.const 0) + ) + (i32.store8 offset=68 + (get_local $12) + (i32.const 0) + ) + (block $label$4 + (block $label$5 + (br_if $label$5 + (i32.le_s + (tee_local $8 + (call $db_lowerbound_i64 + (get_local $1) + (get_local $11) + (i64.const 4297309255767162880) + (i64.const 0) + ) + ) + (i32.const -1) + ) + ) + (i32.store offset=28 + (get_local $12) + (tee_local $7 + (call $_ZNK5eosio11multi_indexILy4297309255767162880EN6eoswin9bill_itemEJNS_10indexed_byILy4587782057278570496EN5boost11multi_index13const_mem_funIS2_yXadL_ZNKS2_8byplayerEvEEEEEEEE31load_object_by_primary_iteratorEl + (i32.add + (get_local $12) + (i32.const 32) + ) + (get_local $8) + ) + ) + ) + (i32.store offset=24 + (get_local $12) + (i32.add + (get_local $12) + (i32.const 32) + ) + ) + (loop $label$6 + (set_local $5 + (i64.load offset=48 + (get_local $7) + ) + ) + (set_local $1 + (i64.const 0) + ) + (set_local $9 + (i64.const 59) + ) + (set_local $8 + (i32.const 960) + ) + (set_local $10 + (i64.const 0) + ) + (loop $label$7 + (block $label$8 + (block $label$9 + (block $label$10 + (block $label$11 + (block $label$12 + (br_if $label$12 + (i64.gt_u + (get_local $1) + (i64.const 7) + ) + ) + (br_if $label$11 + (i32.gt_u + (i32.and + (i32.add + (tee_local $6 + (i32.load8_s + (get_local $8) + ) + ) + (i32.const -97) + ) + (i32.const 255) + ) + (i32.const 25) + ) + ) + (set_local $6 + (i32.add + (get_local $6) + (i32.const 165) + ) + ) + (br $label$10) + ) + (set_local $11 + (i64.const 0) + ) + (br_if $label$9 + (i64.le_u + (get_local $1) + (i64.const 11) + ) + ) + (br $label$8) + ) + (set_local $6 + (select + (i32.add + (get_local $6) + (i32.const 208) + ) + (i32.const 0) + (i32.lt_u + (i32.and + (i32.add + (get_local $6) + (i32.const -49) + ) + (i32.const 255) + ) + (i32.const 5) + ) + ) + ) + ) + (set_local $11 + (i64.shr_s + (i64.shl + (i64.extend_u/i32 + (get_local $6) + ) + (i64.const 56) + ) + (i64.const 56) + ) + ) + ) + (set_local $11 + (i64.shl + (i64.and + (get_local $11) + (i64.const 31) + ) + (i64.and + (get_local $9) + (i64.const 4294967295) + ) + ) + ) + ) + (set_local $8 + (i32.add + (get_local $8) + (i32.const 1) + ) + ) + (set_local $1 + (i64.add + (get_local $1) + (i64.const 1) + ) + ) + (set_local $10 + (i64.or + (get_local $11) + (get_local $10) + ) + ) + (br_if $label$7 + (i64.ne + (tee_local $9 + (i64.add + (get_local $9) + (i64.const -5) + ) + ) + (i64.const -6) + ) + ) + ) + (block $label$13 + (br_if $label$13 + (i64.eq + (get_local $5) + (get_local $10) + ) + ) + (br_if $label$13 + (i64.lt_u + (tee_local $1 + (i64.load offset=72 + (get_local $12) + ) + ) + (i64.load offset=16 + (get_local $7) + ) + ) + ) + (br_if $label$4 + (i64.le_u + (get_local $1) + (i64.load offset=24 + (get_local $7) + ) + ) + ) + ) + (block $label$14 + (call $eosio_assert + (i32.const 1) + (i32.const 1344) + ) + (br_if $label$14 + (i32.le_s + (tee_local $8 + (call $db_next_i64 + (i32.load offset=68 + (i32.load offset=28 + (get_local $12) + ) + ) + (get_local $12) + ) + ) + (i32.const -1) + ) + ) + (i32.store offset=28 + (get_local $12) + (tee_local $7 + (call $_ZNK5eosio11multi_indexILy4297309255767162880EN6eoswin9bill_itemEJNS_10indexed_byILy4587782057278570496EN5boost11multi_index13const_mem_funIS2_yXadL_ZNKS2_8byplayerEvEEEEEEEE31load_object_by_primary_iteratorEl + (i32.load offset=24 + (get_local $12) + ) + (get_local $8) + ) + ) + ) + (br $label$6) + ) + ) + (i32.store offset=28 + (get_local $12) + (i32.const 0) + ) + (br $label$4) + ) + (i32.store offset=28 + (get_local $12) + (i32.const 0) + ) + (i32.store offset=24 + (get_local $12) + (i32.add + (get_local $12) + (i32.const 32) + ) + ) + ) + (i32.store offset=4 + (get_local $12) + (i32.add + (get_local $12) + (i32.const 80) + ) + ) + (i32.store + (get_local $12) + (i32.add + (get_local $12) + (i32.const 88) + ) + ) + (i32.store offset=8 + (get_local $12) + (i32.add + (get_local $12) + (i32.const 72) + ) + ) + (i32.store offset=12 + (get_local $12) + (i32.add + (get_local $12) + (i32.const 24) + ) + ) + (i32.store offset=16 + (get_local $12) + (i32.add + (get_local $12) + (i32.const 32) + ) + ) + (call $eosio_assert + (i32.ne + (get_local $4) + (i32.const 0) + ) + (i32.const 288) + ) + (call $_ZN5eosio11multi_indexILy13633861583611363328EN6eoswin10round_itemEJEE6modifyIZNS1_7lottery4drawEyE4$_11EEvRKS2_yOT_ + (get_local $2) + (get_local $4) + (get_local $12) + ) + (call $_ZN6eoswin7lottery8endroundEv + (get_local $0) + ) + (call $_ZN6eoswin7lottery8newroundEy + (get_local $0) + (i64.load + (get_local $0) + ) + ) + (call $_ZN6eoswin7lottery12erasehistoryEyy + (get_local $0) + (i64.add + (i64.load + (i32.add + (get_local $0) + (i32.const 64) + ) + ) + (i64.const -5) + ) + (i64.const 1) + ) + (block $label$15 + (br_if $label$15 + (i32.eqz + (tee_local $7 + (i32.load offset=56 + (get_local $12) + ) + ) + ) + ) + (block $label$16 + (block $label$17 + (br_if $label$17 + (i32.eq + (tee_local $8 + (i32.load + (tee_local $0 + (i32.add + (get_local $12) + (i32.const 60) + ) + ) + ) + ) + (get_local $7) + ) + ) + (loop $label$18 + (set_local $6 + (i32.load + (tee_local $8 + (i32.add + (get_local $8) + (i32.const -24) + ) + ) + ) + ) + (i32.store + (get_local $8) + (i32.const 0) + ) + (block $label$19 + (br_if $label$19 + (i32.eqz + (get_local $6) + ) + ) + (call $_ZdlPv + (get_local $6) + ) + ) + (br_if $label$18 + (i32.ne + (get_local $7) + (get_local $8) + ) + ) + ) + (set_local $8 + (i32.load + (i32.add + (get_local $12) + (i32.const 56) + ) + ) + ) + (br $label$16) + ) + (set_local $8 + (get_local $7) + ) + ) + (i32.store + (get_local $0) + (get_local $7) + ) + (call $_ZdlPv + (get_local $8) + ) + ) + (i32.store offset=4 + (i32.const 0) + (i32.add + (get_local $12) + (i32.const 96) + ) + ) + ) + (func $_ZN5eosio11multi_indexILy13633861583611363328EN6eoswin10round_itemEJEE6modifyIZNS1_7lottery4drawEyE4$_11EEvRKS2_yOT_ (param $0 i32) (param $1 i32) (param $2 i32) + (local $3 i64) + (local $4 i64) + (local $5 i32) + (local $6 i32) + (set_local $5 + (tee_local $6 + (i32.sub + (i32.load offset=4 + (i32.const 0) + ) + (i32.const 16) + ) + ) + ) + (i32.store offset=4 + (i32.const 0) + (get_local $6) + ) + (call $eosio_assert + (i32.eq + (i32.load offset=80 + (get_local $1) + ) + (get_local $0) + ) + (i32.const 416) + ) + (call $eosio_assert + (i64.eq + (i64.load + (get_local $0) + ) + (call $current_receiver) + ) + (i32.const 464) + ) + (i64.store offset=40 + (get_local $1) + (i64.load + (i32.load + (get_local $2) + ) + ) + ) + (i64.store offset=56 + (get_local $1) + (i64.load + (i32.load offset=4 + (get_local $2) + ) + ) + ) + (set_local $3 + (i64.load + (get_local $1) + ) + ) + (i64.store offset=64 + (get_local $1) + (i64.load + (i32.load offset=8 + (get_local $2) + ) + ) + ) + (set_local $4 + (i64.const 0) + ) + (block $label$0 + (br_if $label$0 + (i32.eqz + (tee_local $2 + (i32.load offset=4 + (i32.load offset=12 + (get_local $2) + ) + ) + ) + ) + ) + (set_local $4 + (i64.load offset=8 + (get_local $2) + ) + ) + ) + (i64.store offset=72 + (get_local $1) + (get_local $4) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 528) + ) + (i32.store offset=4 + (i32.const 0) + (tee_local $2 + (i32.add + (tee_local $6 + (get_local $6) + ) + (i32.const -80) + ) + ) + ) + (i32.store offset=4 + (get_local $5) + (get_local $2) + ) + (i32.store + (get_local $5) + (get_local $2) + ) + (i32.store offset=8 + (get_local $5) + (get_local $6) + ) + (drop + (call $_ZN6eoswinlsIN5eosio10datastreamIPcEEEERT_S6_RKNS_10round_itemE + (get_local $5) + (get_local $1) + ) + ) + (call $db_update_i64 + (i32.load offset=84 + (get_local $1) + ) + (i64.const 0) + (get_local $2) + (i32.const 80) + ) + (block $label$1 + (br_if $label$1 + (i64.lt_u + (get_local $3) + (i64.load offset=16 + (get_local $0) + ) + ) + ) + (i64.store + (i32.add + (get_local $0) + (i32.const 16) + ) + (select + (i64.const -2) + (i64.add + (get_local $3) + (i64.const 1) + ) + (i64.gt_u + (get_local $3) + (i64.const -3) + ) + ) + ) + ) + (i32.store offset=4 + (i32.const 0) + (i32.add + (get_local $5) + (i32.const 16) + ) + ) + ) + (func $_ZN6eoswin7lottery12erasehistoryEyy (param $0 i32) (param $1 i64) (param $2 i64) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (local $8 i32) + (local $9 i32) + (local $10 i32) + (local $11 i32) + (local $12 i64) + (local $13 i32) + (local $14 i32) + (local $15 i32) + (i32.store offset=4 + (i32.const 0) + (tee_local $15 + (i32.sub + (i32.load offset=4 + (i32.const 0) + ) + (i32.const 96) + ) + ) + ) + (block $label$0 + (br_if $label$0 + (i64.lt_u + (tee_local $12 + (i64.load + (i32.add + (get_local $0) + (i32.const 64) + ) + ) + ) + (i64.const 6) + ) + ) + (set_local $6 + (i32.add + (get_local $0) + (i32.const 144) + ) + ) + (set_local $12 + (i64.add + (get_local $12) + (i64.const -5) + ) + ) + (set_local $14 + (i32.const 0) + ) + (block $label$1 + (br_if $label$1 + (i32.lt_s + (tee_local $13 + (call $db_lowerbound_i64 + (i64.load offset=144 + (get_local $0) + ) + (i64.load + (i32.add + (get_local $0) + (i32.const 152) + ) + ) + (i64.const -4812882490098188288) + (i64.const 0) + ) + ) + (i32.const 0) + ) + ) + (set_local $14 + (call $_ZNK5eosio11multi_indexILy13633861583611363328EN6eoswin10round_itemEJEE31load_object_by_primary_iteratorEl + (get_local $6) + (get_local $13) + ) + ) + ) + (block $label$2 + (br_if $label$2 + (i64.gt_u + (i64.load + (get_local $14) + ) + (get_local $12) + ) + ) + (loop $label$3 + (set_local $13 + (i32.const 0) + ) + (call $eosio_assert + (tee_local $3 + (i32.ne + (get_local $14) + (i32.const 0) + ) + ) + (i32.const 2560) + ) + (call $eosio_assert + (get_local $3) + (i32.const 1344) + ) + (block $label$4 + (br_if $label$4 + (i32.lt_s + (tee_local $3 + (call $db_next_i64 + (i32.load offset=84 + (get_local $14) + ) + (i32.add + (get_local $15) + (i32.const 48) + ) + ) + ) + (i32.const 0) + ) + ) + (set_local $13 + (call $_ZNK5eosio11multi_indexILy13633861583611363328EN6eoswin10round_itemEJEE31load_object_by_primary_iteratorEl + (get_local $6) + (get_local $3) + ) + ) + ) + (call $_ZN5eosio11multi_indexILy13633861583611363328EN6eoswin10round_itemEJEE5eraseERKS2_ + (get_local $6) + (get_local $14) + ) + (set_local $14 + (get_local $13) + ) + (br_if $label$3 + (i64.le_u + (i64.load + (get_local $13) + ) + (get_local $12) + ) + ) + ) + ) + (block $label$5 + (br_if $label$5 + (i32.lt_s + (tee_local $14 + (call $db_lowerbound_i64 + (i64.load offset=184 + (get_local $0) + ) + (i64.load + (i32.add + (get_local $0) + (i32.const 192) + ) + ) + (i64.const -4812882707900006400) + (i64.const 0) + ) + ) + (i32.const 0) + ) + ) + (set_local $14 + (call $_ZNK5eosio11multi_indexILy13633861365809545216EN6eoswin13roundfee_itemEJEE31load_object_by_primary_iteratorEl + (tee_local $3 + (i32.add + (get_local $0) + (i32.const 184) + ) + ) + (get_local $14) + ) + ) + (loop $label$6 + (br_if $label$5 + (i64.gt_u + (i64.load + (get_local $14) + ) + (get_local $12) + ) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 2560) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 1344) + ) + (set_local $13 + (i32.const 0) + ) + (block $label$7 + (br_if $label$7 + (i32.lt_s + (tee_local $6 + (call $db_next_i64 + (i32.load offset=76 + (get_local $14) + ) + (i32.add + (get_local $15) + (i32.const 48) + ) + ) + ) + (i32.const 0) + ) + ) + (set_local $13 + (call $_ZNK5eosio11multi_indexILy13633861365809545216EN6eoswin13roundfee_itemEJEE31load_object_by_primary_iteratorEl + (get_local $3) + (get_local $6) + ) + ) + ) + (call $_ZN5eosio11multi_indexILy13633861365809545216EN6eoswin13roundfee_itemEJEE5eraseERKS2_ + (get_local $3) + (get_local $14) + ) + (set_local $14 + (get_local $13) + ) + (br_if $label$6 + (get_local $13) + ) + ) + ) + (call $eosio_assert + (i32.and + (i64.ne + (get_local $1) + (i64.const 0) + ) + (i64.ne + (get_local $2) + (i64.const 0) + ) + ) + (i32.const 2608) + ) + (br_if $label$0 + (i64.lt_u + (tee_local $12 + (select + (tee_local $2 + (i64.add + (i64.add + (get_local $1) + (get_local $2) + ) + (i64.const -1) + ) + ) + (get_local $12) + (i64.lt_u + (get_local $2) + (get_local $12) + ) + ) + ) + (get_local $1) + ) + ) + (set_local $4 + (i32.add + (i32.add + (get_local $15) + (i32.const 48) + ) + (i32.const 8) + ) + ) + (set_local $5 + (i32.add + (i32.add + (get_local $15) + (i32.const 48) + ) + (i32.const 16) + ) + ) + (set_local $6 + (i32.add + (i32.add + (get_local $15) + (i32.const 48) + ) + (i32.const 24) + ) + ) + (set_local $7 + (i32.add + (i32.add + (get_local $15) + (i32.const 48) + ) + (i32.const 32) + ) + ) + (set_local $8 + (i32.add + (get_local $15) + (i32.const 84) + ) + ) + (set_local $11 + (i32.add + (i32.add + (get_local $15) + (i32.const 48) + ) + (i32.const 28) + ) + ) + (loop $label$8 + (i64.store + (get_local $4) + (get_local $12) + ) + (i64.store + (get_local $5) + (i64.const -1) + ) + (i64.store + (get_local $6) + (i64.const 0) + ) + (i32.store + (get_local $7) + (i32.const 0) + ) + (i64.store offset=48 + (get_local $15) + (tee_local $2 + (i64.load + (get_local $0) + ) + ) + ) + (i32.store8 + (get_local $8) + (i32.const 0) + ) + (block $label$9 + (br_if $label$9 + (i32.lt_s + (tee_local $14 + (call $db_lowerbound_i64 + (get_local $2) + (get_local $12) + (i64.const 4297309255767162880) + (i64.const 0) + ) + ) + (i32.const 0) + ) + ) + (set_local $13 + (call $_ZNK5eosio11multi_indexILy4297309255767162880EN6eoswin9bill_itemEJNS_10indexed_byILy4587782057278570496EN5boost11multi_index13const_mem_funIS2_yXadL_ZNKS2_8byplayerEvEEEEEEEE31load_object_by_primary_iteratorEl + (i32.add + (get_local $15) + (i32.const 48) + ) + (get_local $14) + ) + ) + (loop $label$10 + (call $eosio_assert + (i32.const 1) + (i32.const 2560) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 1344) + ) + (set_local $14 + (i32.const 0) + ) + (block $label$11 + (br_if $label$11 + (i32.lt_s + (tee_local $3 + (call $db_next_i64 + (i32.load offset=68 + (get_local $13) + ) + (i32.add + (get_local $15) + (i32.const 8) + ) + ) + ) + (i32.const 0) + ) + ) + (set_local $14 + (call $_ZNK5eosio11multi_indexILy4297309255767162880EN6eoswin9bill_itemEJNS_10indexed_byILy4587782057278570496EN5boost11multi_index13const_mem_funIS2_yXadL_ZNKS2_8byplayerEvEEEEEEEE31load_object_by_primary_iteratorEl + (i32.add + (get_local $15) + (i32.const 48) + ) + (get_local $3) + ) + ) + ) + (call $_ZN5eosio11multi_indexILy4297309255767162880EN6eoswin9bill_itemEJNS_10indexed_byILy4587782057278570496EN5boost11multi_index13const_mem_funIS2_yXadL_ZNKS2_8byplayerEvEEEEEEEE5eraseERKS2_ + (i32.add + (get_local $15) + (i32.const 48) + ) + (get_local $13) + ) + (set_local $13 + (get_local $14) + ) + (br_if $label$10 + (get_local $14) + ) + ) + ) + (i64.store + (i32.add + (i32.add + (get_local $15) + (i32.const 8) + ) + (i32.const 8) + ) + (get_local $12) + ) + (i64.store + (i32.add + (i32.add + (get_local $15) + (i32.const 8) + ) + (i32.const 16) + ) + (i64.const -1) + ) + (i64.store + (tee_local $9 + (i32.add + (i32.add + (get_local $15) + (i32.const 8) + ) + (i32.const 24) + ) + ) + (i64.const 0) + ) + (i32.store + (i32.add + (i32.add + (get_local $15) + (i32.const 8) + ) + (i32.const 32) + ) + (i32.const 0) + ) + (i64.store offset=8 + (get_local $15) + (tee_local $2 + (i64.load + (get_local $0) + ) + ) + ) + (block $label$12 + (br_if $label$12 + (i32.lt_s + (tee_local $14 + (call $db_lowerbound_i64 + (get_local $2) + (get_local $12) + (i64.const -6030912129794572288) + (i64.const 0) + ) + ) + (i32.const 0) + ) + ) + (set_local $13 + (call $_ZNK5eosio11multi_indexILy12415831943914979328EN6eoswin11player_itemEJEE31load_object_by_primary_iteratorEl + (i32.add + (get_local $15) + (i32.const 8) + ) + (get_local $14) + ) + ) + (loop $label$13 + (call $eosio_assert + (i32.const 1) + (i32.const 2560) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 1344) + ) + (set_local $14 + (i32.const 0) + ) + (block $label$14 + (br_if $label$14 + (i32.lt_s + (tee_local $3 + (call $db_next_i64 + (i32.load offset=20 + (get_local $13) + ) + (i32.add + (get_local $15) + (i32.const 88) + ) + ) + ) + (i32.const 0) + ) + ) + (set_local $14 + (call $_ZNK5eosio11multi_indexILy12415831943914979328EN6eoswin11player_itemEJEE31load_object_by_primary_iteratorEl + (i32.add + (get_local $15) + (i32.const 8) + ) + (get_local $3) + ) + ) + ) + (call $_ZN5eosio11multi_indexILy12415831943914979328EN6eoswin11player_itemEJEE5eraseERKS2_ + (i32.add + (get_local $15) + (i32.const 8) + ) + (get_local $13) + ) + (set_local $13 + (get_local $14) + ) + (br_if $label$13 + (get_local $14) + ) + ) + ) + (block $label$15 + (br_if $label$15 + (i32.eqz + (tee_local $3 + (i32.load + (get_local $9) + ) + ) + ) + ) + (block $label$16 + (block $label$17 + (br_if $label$17 + (i32.eq + (tee_local $14 + (i32.load + (tee_local $10 + (i32.add + (i32.add + (get_local $15) + (i32.const 8) + ) + (i32.const 28) + ) + ) + ) + ) + (get_local $3) + ) + ) + (loop $label$18 + (set_local $13 + (i32.load + (tee_local $14 + (i32.add + (get_local $14) + (i32.const -24) + ) + ) + ) + ) + (i32.store + (get_local $14) + (i32.const 0) + ) + (block $label$19 + (br_if $label$19 + (i32.eqz + (get_local $13) + ) + ) + (call $_ZdlPv + (get_local $13) + ) + ) + (br_if $label$18 + (i32.ne + (get_local $3) + (get_local $14) + ) + ) + ) + (set_local $14 + (i32.load + (get_local $9) + ) + ) + (br $label$16) + ) + (set_local $14 + (get_local $3) + ) + ) + (i32.store + (get_local $10) + (get_local $3) + ) + (call $_ZdlPv + (get_local $14) + ) + ) + (set_local $12 + (i64.add + (get_local $12) + (i64.const -1) + ) + ) + (block $label$20 + (br_if $label$20 + (i32.eqz + (tee_local $3 + (i32.load + (get_local $6) + ) + ) + ) + ) + (block $label$21 + (block $label$22 + (br_if $label$22 + (i32.eq + (tee_local $14 + (i32.load + (get_local $11) + ) + ) + (get_local $3) + ) + ) + (loop $label$23 + (set_local $13 + (i32.load + (tee_local $14 + (i32.add + (get_local $14) + (i32.const -24) + ) + ) + ) + ) + (i32.store + (get_local $14) + (i32.const 0) + ) + (block $label$24 + (br_if $label$24 + (i32.eqz + (get_local $13) + ) + ) + (call $_ZdlPv + (get_local $13) + ) + ) + (br_if $label$23 + (i32.ne + (get_local $3) + (get_local $14) + ) + ) + ) + (set_local $14 + (i32.load + (get_local $6) + ) + ) + (br $label$21) + ) + (set_local $14 + (get_local $3) + ) + ) + (i32.store + (get_local $11) + (get_local $3) + ) + (call $_ZdlPv + (get_local $14) + ) + ) + (br_if $label$8 + (i64.ge_u + (get_local $12) + (get_local $1) + ) + ) + ) + ) + (i32.store offset=4 + (i32.const 0) + (i32.add + (get_local $15) + (i32.const 96) + ) + ) + ) + (func $_ZN5eosio11multi_indexILy13633861583611363328EN6eoswin10round_itemEJEE5eraseERKS2_ (param $0 i32) (param $1 i32) + (local $2 i64) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (local $8 i32) + (call $eosio_assert + (i32.eq + (i32.load offset=80 + (get_local $1) + ) + (get_local $0) + ) + (i32.const 2640) + ) + (call $eosio_assert + (i64.eq + (i64.load + (get_local $0) + ) + (call $current_receiver) + ) + (i32.const 2688) + ) + (block $label$0 + (br_if $label$0 + (i32.eq + (tee_local $7 + (i32.load + (tee_local $5 + (i32.add + (get_local $0) + (i32.const 28) + ) + ) + ) + ) + (tee_local $3 + (i32.load offset=24 + (get_local $0) + ) + ) + ) + ) + (set_local $2 + (i64.load + (get_local $1) + ) + ) + (set_local $6 + (i32.sub + (i32.const 0) + (get_local $3) + ) + ) + (set_local $8 + (i32.add + (get_local $7) + (i32.const -24) + ) + ) + (loop $label$1 + (br_if $label$0 + (i64.eq + (i64.load + (i32.load + (get_local $8) + ) + ) + (get_local $2) + ) + ) + (set_local $7 + (get_local $8) + ) + (set_local $8 + (tee_local $4 + (i32.add + (get_local $8) + (i32.const -24) + ) + ) + ) + (br_if $label$1 + (i32.ne + (i32.add + (get_local $4) + (get_local $6) + ) + (i32.const -24) + ) + ) + ) + ) + (call $eosio_assert + (i32.ne + (get_local $7) + (get_local $3) + ) + (i32.const 2752) + ) + (set_local $8 + (i32.add + (get_local $7) + (i32.const -24) + ) + ) + (block $label$2 + (block $label$3 + (br_if $label$3 + (i32.eq + (get_local $7) + (tee_local $4 + (i32.load + (get_local $5) + ) + ) + ) + ) + (set_local $3 + (i32.sub + (i32.const 0) + (get_local $4) + ) + ) + (set_local $7 + (get_local $8) + ) + (loop $label$4 + (set_local $6 + (i32.load + (tee_local $8 + (i32.add + (get_local $7) + (i32.const 24) + ) + ) + ) + ) + (i32.store + (get_local $8) + (i32.const 0) + ) + (set_local $4 + (i32.load + (get_local $7) + ) + ) + (i32.store + (get_local $7) + (get_local $6) + ) + (block $label$5 + (br_if $label$5 + (i32.eqz + (get_local $4) + ) + ) + (call $_ZdlPv + (get_local $4) + ) + ) + (i32.store + (i32.add + (get_local $7) + (i32.const 16) + ) + (i32.load + (i32.add + (get_local $7) + (i32.const 40) + ) + ) + ) + (i64.store + (i32.add + (get_local $7) + (i32.const 8) + ) + (i64.load + (i32.add + (get_local $7) + (i32.const 32) + ) + ) + ) + (set_local $7 + (get_local $8) + ) + (br_if $label$4 + (i32.ne + (i32.add + (get_local $8) + (get_local $3) + ) + (i32.const -24) + ) + ) + ) + (br_if $label$2 + (i32.eq + (tee_local $7 + (i32.load + (i32.add + (get_local $0) + (i32.const 28) + ) + ) + ) + (get_local $8) + ) + ) + ) + (loop $label$6 + (set_local $4 + (i32.load + (tee_local $7 + (i32.add + (get_local $7) + (i32.const -24) + ) + ) + ) + ) + (i32.store + (get_local $7) + (i32.const 0) + ) + (block $label$7 + (br_if $label$7 + (i32.eqz + (get_local $4) + ) + ) + (call $_ZdlPv + (get_local $4) + ) + ) + (br_if $label$6 + (i32.ne + (get_local $8) + (get_local $7) + ) + ) + ) + ) + (i32.store + (i32.add + (get_local $0) + (i32.const 28) + ) + (get_local $8) + ) + (call $db_remove_i64 + (i32.load offset=84 + (get_local $1) + ) + ) + ) + (func $_ZN5eosio11multi_indexILy13633861365809545216EN6eoswin13roundfee_itemEJEE5eraseERKS2_ (param $0 i32) (param $1 i32) + (local $2 i64) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (local $8 i32) + (call $eosio_assert + (i32.eq + (i32.load offset=72 + (get_local $1) + ) + (get_local $0) + ) + (i32.const 2640) + ) + (call $eosio_assert + (i64.eq + (i64.load + (get_local $0) + ) + (call $current_receiver) + ) + (i32.const 2688) + ) + (block $label$0 + (br_if $label$0 + (i32.eq + (tee_local $7 + (i32.load + (tee_local $5 + (i32.add + (get_local $0) + (i32.const 28) + ) + ) + ) + ) + (tee_local $3 + (i32.load offset=24 + (get_local $0) + ) + ) + ) + ) + (set_local $2 + (i64.load + (get_local $1) + ) + ) + (set_local $6 + (i32.sub + (i32.const 0) + (get_local $3) + ) + ) + (set_local $8 + (i32.add + (get_local $7) + (i32.const -24) + ) + ) + (loop $label$1 + (br_if $label$0 + (i64.eq + (i64.load + (i32.load + (get_local $8) + ) + ) + (get_local $2) + ) + ) + (set_local $7 + (get_local $8) + ) + (set_local $8 + (tee_local $4 + (i32.add + (get_local $8) + (i32.const -24) + ) + ) + ) + (br_if $label$1 + (i32.ne + (i32.add + (get_local $4) + (get_local $6) + ) + (i32.const -24) + ) + ) + ) + ) + (call $eosio_assert + (i32.ne + (get_local $7) + (get_local $3) + ) + (i32.const 2752) + ) + (set_local $8 + (i32.add + (get_local $7) + (i32.const -24) + ) + ) + (block $label$2 + (block $label$3 + (br_if $label$3 + (i32.eq + (get_local $7) + (tee_local $4 + (i32.load + (get_local $5) + ) + ) + ) + ) + (set_local $3 + (i32.sub + (i32.const 0) + (get_local $4) + ) + ) + (set_local $7 + (get_local $8) + ) + (loop $label$4 + (set_local $6 + (i32.load + (tee_local $8 + (i32.add + (get_local $7) + (i32.const 24) + ) + ) + ) + ) + (i32.store + (get_local $8) + (i32.const 0) + ) + (set_local $4 + (i32.load + (get_local $7) + ) + ) + (i32.store + (get_local $7) + (get_local $6) + ) + (block $label$5 + (br_if $label$5 + (i32.eqz + (get_local $4) + ) + ) + (call $_ZdlPv + (get_local $4) + ) + ) + (i32.store + (i32.add + (get_local $7) + (i32.const 16) + ) + (i32.load + (i32.add + (get_local $7) + (i32.const 40) + ) + ) + ) + (i64.store + (i32.add + (get_local $7) + (i32.const 8) + ) + (i64.load + (i32.add + (get_local $7) + (i32.const 32) + ) + ) + ) + (set_local $7 + (get_local $8) + ) + (br_if $label$4 + (i32.ne + (i32.add + (get_local $8) + (get_local $3) + ) + (i32.const -24) + ) + ) + ) + (br_if $label$2 + (i32.eq + (tee_local $7 + (i32.load + (i32.add + (get_local $0) + (i32.const 28) + ) + ) + ) + (get_local $8) + ) + ) + ) + (loop $label$6 + (set_local $4 + (i32.load + (tee_local $7 + (i32.add + (get_local $7) + (i32.const -24) + ) + ) + ) + ) + (i32.store + (get_local $7) + (i32.const 0) + ) + (block $label$7 + (br_if $label$7 + (i32.eqz + (get_local $4) + ) + ) + (call $_ZdlPv + (get_local $4) + ) + ) + (br_if $label$6 + (i32.ne + (get_local $8) + (get_local $7) + ) + ) + ) + ) + (i32.store + (i32.add + (get_local $0) + (i32.const 28) + ) + (get_local $8) + ) + (call $db_remove_i64 + (i32.load offset=76 + (get_local $1) + ) + ) + ) + (func $_ZN5eosio11multi_indexILy4297309255767162880EN6eoswin9bill_itemEJNS_10indexed_byILy4587782057278570496EN5boost11multi_index13const_mem_funIS2_yXadL_ZNKS2_8byplayerEvEEEEEEEE5eraseERKS2_ (param $0 i32) (param $1 i32) + (local $2 i64) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (local $8 i32) + (local $9 i32) + (i32.store offset=4 + (i32.const 0) + (tee_local $9 + (i32.sub + (i32.load offset=4 + (i32.const 0) + ) + (i32.const 16) + ) + ) + ) + (call $eosio_assert + (i32.eq + (i32.load offset=64 + (get_local $1) + ) + (get_local $0) + ) + (i32.const 2640) + ) + (call $eosio_assert + (i64.eq + (i64.load + (get_local $0) + ) + (call $current_receiver) + ) + (i32.const 2688) + ) + (block $label$0 + (br_if $label$0 + (i32.eq + (tee_local $7 + (i32.load + (tee_local $5 + (i32.add + (get_local $0) + (i32.const 28) + ) + ) + ) + ) + (tee_local $3 + (i32.load offset=24 + (get_local $0) + ) + ) + ) + ) + (set_local $2 + (i64.load + (get_local $1) + ) + ) + (set_local $6 + (i32.sub + (i32.const 0) + (get_local $3) + ) + ) + (set_local $8 + (i32.add + (get_local $7) + (i32.const -24) + ) + ) + (loop $label$1 + (br_if $label$0 + (i64.eq + (i64.load + (i32.load + (get_local $8) + ) + ) + (get_local $2) + ) + ) + (set_local $7 + (get_local $8) + ) + (set_local $8 + (tee_local $4 + (i32.add + (get_local $8) + (i32.const -24) + ) + ) + ) + (br_if $label$1 + (i32.ne + (i32.add + (get_local $4) + (get_local $6) + ) + (i32.const -24) + ) + ) + ) + ) + (call $eosio_assert + (i32.ne + (get_local $7) + (get_local $3) + ) + (i32.const 2752) + ) + (set_local $8 + (i32.add + (get_local $7) + (i32.const -24) + ) + ) + (block $label$2 + (block $label$3 + (br_if $label$3 + (i32.eq + (get_local $7) + (tee_local $4 + (i32.load + (get_local $5) + ) + ) + ) + ) + (set_local $3 + (i32.sub + (i32.const 0) + (get_local $4) + ) + ) + (set_local $7 + (get_local $8) + ) + (loop $label$4 + (set_local $6 + (i32.load + (tee_local $8 + (i32.add + (get_local $7) + (i32.const 24) + ) + ) + ) + ) + (i32.store + (get_local $8) + (i32.const 0) + ) + (set_local $4 + (i32.load + (get_local $7) + ) + ) + (i32.store + (get_local $7) + (get_local $6) + ) + (block $label$5 + (br_if $label$5 + (i32.eqz + (get_local $4) + ) + ) + (call $_ZdlPv + (get_local $4) + ) + ) + (i32.store + (i32.add + (get_local $7) + (i32.const 16) + ) + (i32.load + (i32.add + (get_local $7) + (i32.const 40) + ) + ) + ) + (i64.store + (i32.add + (get_local $7) + (i32.const 8) + ) + (i64.load + (i32.add + (get_local $7) + (i32.const 32) + ) + ) + ) + (set_local $7 + (get_local $8) + ) + (br_if $label$4 + (i32.ne + (i32.add + (get_local $8) + (get_local $3) + ) + (i32.const -24) + ) + ) + ) + (br_if $label$2 + (i32.eq + (tee_local $7 + (i32.load + (i32.add + (get_local $0) + (i32.const 28) + ) + ) + ) + (get_local $8) + ) + ) + ) + (loop $label$6 + (set_local $4 + (i32.load + (tee_local $7 + (i32.add + (get_local $7) + (i32.const -24) + ) + ) + ) + ) + (i32.store + (get_local $7) + (i32.const 0) + ) + (block $label$7 + (br_if $label$7 + (i32.eqz + (get_local $4) + ) + ) + (call $_ZdlPv + (get_local $4) + ) + ) + (br_if $label$6 + (i32.ne + (get_local $8) + (get_local $7) + ) + ) + ) + ) + (i32.store + (i32.add + (get_local $0) + (i32.const 28) + ) + (get_local $8) + ) + (call $db_remove_i64 + (i32.load offset=68 + (get_local $1) + ) + ) + (block $label$8 + (block $label$9 + (br_if $label$9 + (i32.gt_s + (tee_local $7 + (i32.load + (i32.add + (get_local $1) + (i32.const 72) + ) + ) + ) + (i32.const -1) + ) + ) + (br_if $label$8 + (i32.lt_s + (tee_local $7 + (call $db_idx64_find_primary + (i64.load + (get_local $0) + ) + (i64.load offset=8 + (get_local $0) + ) + (i64.const 4297309255767162880) + (i32.add + (get_local $9) + (i32.const 8) + ) + (i64.load + (get_local $1) + ) + ) + ) + (i32.const 0) + ) + ) + ) + (call $db_idx64_remove + (get_local $7) + ) + ) + (i32.store offset=4 + (i32.const 0) + (i32.add + (get_local $9) + (i32.const 16) + ) + ) + ) + (func $_ZN5eosio11multi_indexILy12415831943914979328EN6eoswin11player_itemEJEE5eraseERKS2_ (param $0 i32) (param $1 i32) + (local $2 i64) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (local $8 i32) + (call $eosio_assert + (i32.eq + (i32.load offset=16 + (get_local $1) + ) + (get_local $0) + ) + (i32.const 2640) + ) + (call $eosio_assert + (i64.eq + (i64.load + (get_local $0) + ) + (call $current_receiver) + ) + (i32.const 2688) + ) + (block $label$0 + (br_if $label$0 + (i32.eq + (tee_local $7 + (i32.load + (tee_local $5 + (i32.add + (get_local $0) + (i32.const 28) + ) + ) + ) + ) + (tee_local $3 + (i32.load offset=24 + (get_local $0) + ) + ) + ) + ) + (set_local $2 + (i64.load + (get_local $1) + ) + ) + (set_local $6 + (i32.sub + (i32.const 0) + (get_local $3) + ) + ) + (set_local $8 + (i32.add + (get_local $7) + (i32.const -24) + ) + ) + (loop $label$1 + (br_if $label$0 + (i64.eq + (i64.load + (i32.load + (get_local $8) + ) + ) + (get_local $2) + ) + ) + (set_local $7 + (get_local $8) + ) + (set_local $8 + (tee_local $4 + (i32.add + (get_local $8) + (i32.const -24) + ) + ) + ) + (br_if $label$1 + (i32.ne + (i32.add + (get_local $4) + (get_local $6) + ) + (i32.const -24) + ) + ) + ) + ) + (call $eosio_assert + (i32.ne + (get_local $7) + (get_local $3) + ) + (i32.const 2752) + ) + (set_local $8 + (i32.add + (get_local $7) + (i32.const -24) + ) + ) + (block $label$2 + (block $label$3 + (br_if $label$3 + (i32.eq + (get_local $7) + (tee_local $4 + (i32.load + (get_local $5) + ) + ) + ) + ) + (set_local $3 + (i32.sub + (i32.const 0) + (get_local $4) + ) + ) + (set_local $7 + (get_local $8) + ) + (loop $label$4 + (set_local $6 + (i32.load + (tee_local $8 + (i32.add + (get_local $7) + (i32.const 24) + ) + ) + ) + ) + (i32.store + (get_local $8) + (i32.const 0) + ) + (set_local $4 + (i32.load + (get_local $7) + ) + ) + (i32.store + (get_local $7) + (get_local $6) + ) + (block $label$5 + (br_if $label$5 + (i32.eqz + (get_local $4) + ) + ) + (call $_ZdlPv + (get_local $4) + ) + ) + (i32.store + (i32.add + (get_local $7) + (i32.const 16) + ) + (i32.load + (i32.add + (get_local $7) + (i32.const 40) + ) + ) + ) + (i64.store + (i32.add + (get_local $7) + (i32.const 8) + ) + (i64.load + (i32.add + (get_local $7) + (i32.const 32) + ) + ) + ) + (set_local $7 + (get_local $8) + ) + (br_if $label$4 + (i32.ne + (i32.add + (get_local $8) + (get_local $3) + ) + (i32.const -24) + ) + ) + ) + (br_if $label$2 + (i32.eq + (tee_local $7 + (i32.load + (i32.add + (get_local $0) + (i32.const 28) + ) + ) + ) + (get_local $8) + ) + ) + ) + (loop $label$6 + (set_local $4 + (i32.load + (tee_local $7 + (i32.add + (get_local $7) + (i32.const -24) + ) + ) + ) + ) + (i32.store + (get_local $7) + (i32.const 0) + ) + (block $label$7 + (br_if $label$7 + (i32.eqz + (get_local $4) + ) + ) + (call $_ZdlPv + (get_local $4) + ) + ) + (br_if $label$6 + (i32.ne + (get_local $8) + (get_local $7) + ) + ) + ) + ) + (i32.store + (i32.add + (get_local $0) + (i32.const 28) + ) + (get_local $8) + ) + (call $db_remove_i64 + (i32.load offset=20 + (get_local $1) + ) + ) + ) + (func $_ZN6eoswin7lottery10claimbonusEyy (type $FUNCSIG$vijj) (param $0 i32) (param $1 i64) (param $2 i64) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i64) + (local $7 i64) + (local $8 i32) + (local $9 i32) + (local $10 f64) + (local $11 f64) + (local $12 i64) + (local $13 i32) + (local $14 i32) + (local $15 i32) + (local $16 i64) + (local $17 i64) + (local $18 i64) + (local $19 i32) + (i32.store offset=4 + (i32.const 0) + (tee_local $19 + (i32.sub + (i32.load offset=4 + (i32.const 0) + ) + (i32.const 480) + ) + ) + ) + (i64.store offset=432 + (get_local $19) + (get_local $2) + ) + (call $require_auth + (get_local $1) + ) + (block $label$0 + (br_if $label$0 + (i32.eq + (tee_local $9 + (i32.load + (i32.add + (get_local $0) + (i32.const 276) + ) + ) + ) + (tee_local $4 + (i32.load + (i32.add + (get_local $0) + (i32.const 272) + ) + ) + ) + ) + ) + (set_local $15 + (i32.add + (get_local $9) + (i32.const -24) + ) + ) + (set_local $5 + (i32.sub + (i32.const 0) + (get_local $4) + ) + ) + (loop $label$1 + (br_if $label$0 + (i64.eq + (i64.load + (i32.load + (get_local $15) + ) + ) + (i64.const 101) + ) + ) + (set_local $9 + (get_local $15) + ) + (set_local $15 + (tee_local $8 + (i32.add + (get_local $15) + (i32.const -24) + ) + ) + ) + (br_if $label$1 + (i32.ne + (i32.add + (get_local $8) + (get_local $5) + ) + (i32.const -24) + ) + ) + ) + ) + (set_local $3 + (i32.add + (get_local $0) + (i32.const 248) + ) + ) + (block $label$2 + (block $label$3 + (br_if $label$3 + (i32.eq + (get_local $9) + (get_local $4) + ) + ) + (call $eosio_assert + (i32.eq + (i32.load offset=16 + (tee_local $15 + (i32.load + (i32.add + (get_local $9) + (i32.const -24) + ) + ) + ) + ) + (get_local $3) + ) + (i32.const 32) + ) + (br $label$2) + ) + (call $eosio_assert + (i32.eq + (i32.load offset=16 + (tee_local $15 + (call $_ZNK5eosio11multi_indexILy14289250228358873088EN6eoswin6statusEJEE31load_object_by_primary_iteratorEl + (get_local $3) + (call $db_find_i64 + (i64.load + (i32.add + (get_local $0) + (i32.const 248) + ) + ) + (i64.load + (i32.add + (get_local $0) + (i32.const 256) + ) + ) + (i64.const -4157493845350678528) + (i64.const 101) + ) + ) + ) + ) + (get_local $3) + ) + (i32.const 32) + ) + ) + (call $eosio_assert + (i64.eq + (i64.load offset=8 + (get_local $15) + ) + (i64.const 1) + ) + (i32.const 2816) + ) + (i64.store offset=424 + (get_local $19) + (tee_local $18 + (call $current_time) + ) + ) + (set_local $1 + (i64.load offset=8 + (call $_ZNK5eosio11multi_indexILy14289250228358873088EN6eoswin6statusEJEE3getEyPKc + (get_local $3) + (i64.const 104) + (i32.const 2848) + ) + ) + ) + (set_local $17 + (i64.add + (tee_local $6 + (i64.load offset=8 + (call $_ZNK5eosio11multi_indexILy14289250228358873088EN6eoswin6statusEJEE3getEyPKc + (get_local $3) + (i64.const 105) + (i32.const 2880) + ) + ) + ) + (tee_local $7 + (i64.load offset=8 + (call $_ZNK5eosio11multi_indexILy14289250228358873088EN6eoswin6statusEJEE3getEyPKc + (get_local $3) + (i64.const 106) + (i32.const 2928) + ) + ) + ) + ) + ) + (set_local $16 + (i64.const 0) + ) + (set_local $12 + (i64.const 0) + ) + (block $label$4 + (br_if $label$4 + (i64.le_u + (tee_local $18 + (i64.div_u + (get_local $18) + (i64.const 1000000) + ) + ) + (get_local $1) + ) + ) + (set_local $12 + (i64.div_u + (i64.sub + (get_local $18) + (get_local $1) + ) + (get_local $17) + ) + ) + ) + (i64.store + (i32.add + (get_local $19) + (i32.const 56) + ) + (get_local $1) + ) + (i64.store + (i32.add + (get_local $19) + (i32.const 48) + ) + (tee_local $17 + (i64.add + (tee_local $1 + (i64.add + (i64.add + (get_local $6) + (get_local $1) + ) + (i64.mul + (get_local $12) + (get_local $17) + ) + ) + ) + (get_local $7) + ) + ) + ) + (i64.store offset=40 + (get_local $19) + (get_local $1) + ) + (i64.store offset=32 + (get_local $19) + (get_local $18) + ) + (drop + (call $sprintf + (i32.add + (get_local $19) + (i32.const 288) + ) + (i32.const 2960) + (i32.add + (get_local $19) + (i32.const 32) + ) + ) + ) + (call $eosio_assert + (i32.and + (i64.ge_u + (get_local $18) + (get_local $1) + ) + (i64.le_u + (get_local $18) + (get_local $17) + ) + ) + (i32.add + (get_local $19) + (i32.const 288) + ) + ) + (set_local $18 + (i64.load offset=240 + (get_local $0) + ) + ) + (i32.store + (i32.add + (get_local $19) + (i32.const 96) + ) + (i32.const 0) + ) + (i64.store offset=80 + (get_local $19) + (i64.const -1) + ) + (i64.store offset=88 + (get_local $19) + (i64.const 0) + ) + (i64.store offset=64 + (get_local $19) + (tee_local $17 + (i64.load offset=224 + (get_local $0) + ) + ) + ) + (i64.store offset=72 + (get_local $19) + (get_local $2) + ) + (block $label$5 + (br_if $label$5 + (i32.lt_s + (tee_local $15 + (call $db_find_i64 + (get_local $17) + (get_local $2) + (i64.const 5382478059301502976) + (get_local $18) + ) + ) + (i32.const 0) + ) + ) + (call $eosio_assert + (i32.eq + (i32.load offset=16 + (tee_local $15 + (call $_ZNK5eosio11multi_indexILy5382478059301502976ENS_5token6detailEJEE31load_object_by_primary_iteratorEl + (i32.add + (get_local $19) + (i32.const 64) + ) + (get_local $15) + ) + ) + ) + (i32.add + (get_local $19) + (i32.const 64) + ) + ) + (i32.const 32) + ) + (set_local $16 + (i64.load offset=8 + (get_local $15) + ) + ) + (br_if $label$5 + (i32.eqz + (tee_local $9 + (i32.load offset=88 + (get_local $19) + ) + ) + ) + ) + (block $label$6 + (block $label$7 + (br_if $label$7 + (i32.eq + (tee_local $15 + (i32.load + (tee_local $5 + (i32.add + (get_local $19) + (i32.const 92) + ) + ) + ) + ) + (get_local $9) + ) + ) + (loop $label$8 + (set_local $8 + (i32.load + (tee_local $15 + (i32.add + (get_local $15) + (i32.const -24) + ) + ) + ) + ) + (i32.store + (get_local $15) + (i32.const 0) + ) + (block $label$9 + (br_if $label$9 + (i32.eqz + (get_local $8) + ) + ) + (call $_ZdlPv + (get_local $8) + ) + ) + (br_if $label$8 + (i32.ne + (get_local $9) + (get_local $15) + ) + ) + ) + (set_local $15 + (i32.load + (i32.add + (get_local $19) + (i32.const 88) + ) + ) + ) + (br $label$6) + ) + (set_local $15 + (get_local $9) + ) + ) + (i32.store + (get_local $5) + (get_local $9) + ) + (call $_ZdlPv + (get_local $15) + ) + ) + (call $eosio_assert + (i64.gt_u + (i64.load offset=424 + (get_local $19) + ) + (i64.add + (get_local $16) + (i64.const 86400000000) + ) + ) + (i32.const 3024) + ) + (block $label$10 + (br_if $label$10 + (i32.eq + (tee_local $9 + (i32.load + (i32.add + (get_local $0) + (i32.const 276) + ) + ) + ) + (tee_local $4 + (i32.load + (i32.add + (get_local $0) + (i32.const 272) + ) + ) + ) + ) + ) + (set_local $15 + (i32.add + (get_local $9) + (i32.const -24) + ) + ) + (set_local $5 + (i32.sub + (i32.const 0) + (get_local $4) + ) + ) + (loop $label$11 + (br_if $label$10 + (i64.eq + (i64.load + (i32.load + (get_local $15) + ) + ) + (i64.const 107) + ) + ) + (set_local $9 + (get_local $15) + ) + (set_local $15 + (tee_local $8 + (i32.add + (get_local $15) + (i32.const -24) + ) + ) + ) + (br_if $label$11 + (i32.ne + (i32.add + (get_local $8) + (get_local $5) + ) + (i32.const -24) + ) + ) + ) + ) + (block $label$12 + (block $label$13 + (block $label$14 + (br_if $label$14 + (i32.eq + (get_local $9) + (get_local $4) + ) + ) + (call $eosio_assert + (i32.eq + (i32.load offset=16 + (tee_local $15 + (i32.load + (i32.add + (get_local $9) + (i32.const -24) + ) + ) + ) + ) + (get_local $3) + ) + (i32.const 32) + ) + (br_if $label$12 + (get_local $15) + ) + (br $label$13) + ) + (br_if $label$13 + (i32.lt_s + (tee_local $15 + (call $db_find_i64 + (i64.load + (i32.add + (get_local $0) + (i32.const 248) + ) + ) + (i64.load + (i32.add + (get_local $0) + (i32.const 256) + ) + ) + (i64.const -4157493845350678528) + (i64.const 107) + ) + ) + (i32.const 0) + ) + ) + (call $eosio_assert + (i32.eq + (i32.load offset=16 + (tee_local $15 + (call $_ZNK5eosio11multi_indexILy14289250228358873088EN6eoswin6statusEJEE31load_object_by_primary_iteratorEl + (get_local $3) + (get_local $15) + ) + ) + ) + (get_local $3) + ) + (i32.const 32) + ) + (br $label$12) + ) + (set_local $2 + (i64.load + (get_local $0) + ) + ) + (call $eosio_assert + (i64.eq + (i64.load + (i32.add + (get_local $0) + (i32.const 248) + ) + ) + (call $current_receiver) + ) + (i32.const 336) + ) + (i32.store offset=16 + (tee_local $15 + (call $_Znwj + (i32.const 32) + ) + ) + (get_local $3) + ) + (i64.store offset=8 + (get_local $15) + (i64.const 0) + ) + (i64.store + (get_local $15) + (i64.const 107) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 400) + ) + (drop + (call $memcpy + (i32.add + (get_local $19) + (i32.const 64) + ) + (get_local $15) + (i32.const 8) + ) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 400) + ) + (drop + (call $memcpy + (i32.or + (i32.add + (get_local $19) + (i32.const 64) + ) + (i32.const 8) + ) + (i32.add + (get_local $15) + (i32.const 8) + ) + (i32.const 8) + ) + ) + (i32.store offset=20 + (get_local $15) + (tee_local $9 + (call $db_store_i64 + (i64.load + (i32.add + (get_local $0) + (i32.const 256) + ) + ) + (i64.const -4157493845350678528) + (get_local $2) + (tee_local $18 + (i64.load + (get_local $15) + ) + ) + (i32.add + (get_local $19) + (i32.const 64) + ) + (i32.const 16) + ) + ) + ) + (block $label$15 + (br_if $label$15 + (i64.lt_u + (get_local $18) + (i64.load + (tee_local $8 + (i32.add + (get_local $0) + (i32.const 264) + ) + ) + ) + ) + ) + (i64.store + (get_local $8) + (select + (i64.const -2) + (i64.add + (get_local $18) + (i64.const 1) + ) + (i64.gt_u + (get_local $18) + (i64.const -3) + ) + ) + ) + ) + (i32.store offset=272 + (get_local $19) + (get_local $15) + ) + (i64.store offset=64 + (get_local $19) + (tee_local $18 + (i64.load + (get_local $15) + ) + ) + ) + (i32.store offset=256 + (get_local $19) + (get_local $9) + ) + (block $label$16 + (block $label$17 + (br_if $label$17 + (i32.ge_u + (tee_local $8 + (i32.load + (tee_local $5 + (i32.add + (get_local $0) + (i32.const 276) + ) + ) + ) + ) + (i32.load + (i32.add + (get_local $0) + (i32.const 280) + ) + ) + ) + ) + (i64.store offset=8 + (get_local $8) + (get_local $18) + ) + (i32.store offset=16 + (get_local $8) + (get_local $9) + ) + (i32.store offset=272 + (get_local $19) + (i32.const 0) + ) + (i32.store + (get_local $8) + (get_local $15) + ) + (i32.store + (get_local $5) + (i32.add + (get_local $8) + (i32.const 24) + ) + ) + (br $label$16) + ) + (call $_ZNSt3__16vectorIN5eosio11multi_indexILy14289250228358873088EN6eoswin6statusEJEE8item_ptrENS_9allocatorIS6_EEE24__emplace_back_slow_pathIJNS_10unique_ptrINS5_4itemENS_14default_deleteISC_EEEERyRlEEEvDpOT_ + (i32.add + (get_local $0) + (i32.const 272) + ) + (i32.add + (get_local $19) + (i32.const 272) + ) + (i32.add + (get_local $19) + (i32.const 64) + ) + (i32.add + (get_local $19) + (i32.const 256) + ) + ) + ) + (set_local $8 + (i32.load offset=272 + (get_local $19) + ) + ) + (i32.store offset=272 + (get_local $19) + (i32.const 0) + ) + (br_if $label$12 + (i32.eqz + (get_local $8) + ) + ) + (call $_ZdlPv + (get_local $8) + ) + ) + (block $label$18 + (br_if $label$18 + (i64.ge_u + (i64.load offset=8 + (get_local $15) + ) + (get_local $1) + ) + ) + (call $_ZN6eoswin7lottery22snapshot_token_balanceEv + (get_local $0) + ) + (call $eosio_assert + (i32.ne + (get_local $15) + (i32.const 0) + ) + (i32.const 288) + ) + (call $eosio_assert + (i32.eq + (i32.load offset=16 + (get_local $15) + ) + (get_local $3) + ) + (i32.const 416) + ) + (call $eosio_assert + (i64.eq + (i64.load + (i32.add + (get_local $0) + (i32.const 248) + ) + ) + (call $current_receiver) + ) + (i32.const 464) + ) + (i64.store offset=8 + (get_local $15) + (get_local $1) + ) + (set_local $1 + (i64.load + (get_local $15) + ) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 528) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 400) + ) + (drop + (call $memcpy + (i32.add + (get_local $19) + (i32.const 64) + ) + (get_local $15) + (i32.const 8) + ) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 400) + ) + (drop + (call $memcpy + (i32.or + (i32.add + (get_local $19) + (i32.const 64) + ) + (i32.const 8) + ) + (i32.add + (get_local $15) + (i32.const 8) + ) + (i32.const 8) + ) + ) + (call $db_update_i64 + (i32.load offset=20 + (get_local $15) + ) + (i64.const 0) + (i32.add + (get_local $19) + (i32.const 64) + ) + (i32.const 16) + ) + (br_if $label$18 + (i64.lt_u + (get_local $1) + (i64.load + (tee_local $15 + (i32.add + (get_local $0) + (i32.const 264) + ) + ) + ) + ) + ) + (i64.store + (get_local $15) + (select + (i64.const -2) + (i64.add + (get_local $1) + (i64.const 1) + ) + (i64.gt_u + (get_local $1) + (i64.const -3) + ) + ) + ) + ) + (set_local $1 + (i64.const 0) + ) + (set_local $18 + (i64.const 59) + ) + (set_local $15 + (i32.const 16) + ) + (set_local $16 + (i64.const 0) + ) + (loop $label$19 + (set_local $2 + (i64.const 0) + ) + (block $label$20 + (br_if $label$20 + (i64.gt_u + (get_local $1) + (i64.const 11) + ) + ) + (block $label$21 + (block $label$22 + (br_if $label$22 + (i32.gt_u + (i32.and + (i32.add + (tee_local $8 + (i32.load8_s + (get_local $15) + ) + ) + (i32.const -97) + ) + (i32.const 255) + ) + (i32.const 25) + ) + ) + (set_local $8 + (i32.add + (get_local $8) + (i32.const 165) + ) + ) + (br $label$21) + ) + (set_local $8 + (select + (i32.add + (get_local $8) + (i32.const 208) + ) + (i32.const 0) + (i32.lt_u + (i32.and + (i32.add + (get_local $8) + (i32.const -49) + ) + (i32.const 255) + ) + (i32.const 5) + ) + ) + ) + ) + (set_local $2 + (i64.shl + (i64.extend_u/i32 + (i32.and + (get_local $8) + (i32.const 31) + ) + ) + (i64.and + (get_local $18) + (i64.const 4294967295) + ) + ) + ) + ) + (set_local $15 + (i32.add + (get_local $15) + (i32.const 1) + ) + ) + (set_local $1 + (i64.add + (get_local $1) + (i64.const 1) + ) + ) + (set_local $16 + (i64.or + (get_local $2) + (get_local $16) + ) + ) + (br_if $label$19 + (i64.ne + (tee_local $18 + (i64.add + (get_local $18) + (i64.const -5) + ) + ) + (i64.const -6) + ) + ) + ) + (set_local $1 + (i64.load + (tee_local $5 + (i32.add + (get_local $0) + (i32.const 240) + ) + ) + ) + ) + (i32.store + (tee_local $4 + (i32.add + (get_local $19) + (i32.const 96) + ) + ) + (i32.const 0) + ) + (i64.store offset=72 + (get_local $19) + (get_local $16) + ) + (i64.store offset=80 + (get_local $19) + (i64.const -1) + ) + (i64.store offset=88 + (get_local $19) + (i64.const 0) + ) + (i64.store offset=64 + (get_local $19) + (i64.load + (tee_local $13 + (i32.add + (get_local $0) + (i32.const 224) + ) + ) + ) + ) + (set_local $12 + (i64.load offset=8 + (tee_local $15 + (call $_ZNK5eosio11multi_indexILy3607749779137757184ENS_5token7accountEJEE3getEyPKc + (i32.add + (get_local $19) + (i32.const 64) + ) + (get_local $1) + (i32.const 736) + ) + ) + ) + ) + (set_local $18 + (i64.load + (get_local $15) + ) + ) + (block $label$23 + (br_if $label$23 + (i32.eqz + (tee_local $9 + (i32.load offset=88 + (get_local $19) + ) + ) + ) + ) + (block $label$24 + (block $label$25 + (br_if $label$25 + (i32.eq + (tee_local $15 + (i32.load + (tee_local $14 + (i32.add + (get_local $19) + (i32.const 92) + ) + ) + ) + ) + (get_local $9) + ) + ) + (loop $label$26 + (set_local $8 + (i32.load + (tee_local $15 + (i32.add + (get_local $15) + (i32.const -24) + ) + ) + ) + ) + (i32.store + (get_local $15) + (i32.const 0) + ) + (block $label$27 + (br_if $label$27 + (i32.eqz + (get_local $8) + ) + ) + (call $_ZdlPv + (get_local $8) + ) + ) + (br_if $label$26 + (i32.ne + (get_local $9) + (get_local $15) + ) + ) + ) + (set_local $15 + (i32.load + (i32.add + (get_local $19) + (i32.const 88) + ) + ) + ) + (br $label$24) + ) + (set_local $15 + (get_local $9) + ) + ) + (i32.store + (get_local $14) + (get_local $9) + ) + (call $_ZdlPv + (get_local $15) + ) + ) + (set_local $1 + (i64.load + (get_local $5) + ) + ) + (i32.store + (get_local $4) + (i32.const 0) + ) + (i64.store offset=72 + (get_local $19) + (get_local $1) + ) + (i64.store offset=80 + (get_local $19) + (i64.const -1) + ) + (i64.store offset=88 + (get_local $19) + (i64.const 0) + ) + (i64.store offset=64 + (get_local $19) + (i64.load + (get_local $13) + ) + ) + (set_local $2 + (i64.load offset=16 + (tee_local $15 + (call $_ZNK5eosio11multi_indexILy14289235522390851584ENS_5token13currency_statEJEE3getEyPKc + (i32.add + (get_local $19) + (i32.const 64) + ) + (get_local $1) + (i32.const 736) + ) + ) + ) + ) + (set_local $6 + (i64.load + (i32.add + (get_local $15) + (i32.const 24) + ) + ) + ) + (block $label$28 + (br_if $label$28 + (i32.eqz + (tee_local $9 + (i32.load offset=88 + (get_local $19) + ) + ) + ) + ) + (block $label$29 + (block $label$30 + (br_if $label$30 + (i32.eq + (tee_local $15 + (i32.load + (tee_local $5 + (i32.add + (get_local $19) + (i32.const 92) + ) + ) + ) + ) + (get_local $9) + ) + ) + (loop $label$31 + (set_local $8 + (i32.load + (tee_local $15 + (i32.add + (get_local $15) + (i32.const -24) + ) + ) + ) + ) + (i32.store + (get_local $15) + (i32.const 0) + ) + (block $label$32 + (br_if $label$32 + (i32.eqz + (get_local $8) + ) + ) + (call $_ZdlPv + (get_local $8) + ) + ) + (br_if $label$31 + (i32.ne + (get_local $9) + (get_local $15) + ) + ) + ) + (set_local $15 + (i32.load + (i32.add + (get_local $19) + (i32.const 88) + ) + ) + ) + (br $label$29) + ) + (set_local $15 + (get_local $9) + ) + ) + (i32.store + (get_local $5) + (get_local $9) + ) + (call $_ZdlPv + (get_local $15) + ) + ) + (call $eosio_assert + (i64.gt_s + (get_local $2) + (get_local $18) + ) + (i32.const 3072) + ) + (set_local $16 + (i64.load + (i32.add + (get_local $0) + (i32.const 240) + ) + ) + ) + (set_local $17 + (i64.load offset=432 + (get_local $19) + ) + ) + (i32.store + (i32.add + (get_local $19) + (i32.const 96) + ) + (i32.const 0) + ) + (i64.store offset=72 + (get_local $19) + (get_local $17) + ) + (i64.store offset=80 + (get_local $19) + (i64.const -1) + ) + (set_local $1 + (i64.const 0) + ) + (i64.store offset=88 + (get_local $19) + (i64.const 0) + ) + (i64.store offset=64 + (get_local $19) + (i64.load + (i32.add + (get_local $0) + (i32.const 224) + ) + ) + ) + (set_local $16 + (i64.load + (call $_ZNK5eosio11multi_indexILy3607749779137757184ENS_5token7accountEJEE3getEyPKc + (i32.add + (get_local $19) + (i32.const 64) + ) + (get_local $16) + (i32.const 736) + ) + ) + ) + (block $label$33 + (br_if $label$33 + (i32.eqz + (tee_local $9 + (i32.load offset=88 + (get_local $19) + ) + ) + ) + ) + (block $label$34 + (block $label$35 + (br_if $label$35 + (i32.eq + (tee_local $15 + (i32.load + (tee_local $5 + (i32.add + (get_local $19) + (i32.const 92) + ) + ) + ) + ) + (get_local $9) + ) + ) + (loop $label$36 + (set_local $8 + (i32.load + (tee_local $15 + (i32.add + (get_local $15) + (i32.const -24) + ) + ) + ) + ) + (i32.store + (get_local $15) + (i32.const 0) + ) + (block $label$37 + (br_if $label$37 + (i32.eqz + (get_local $8) + ) + ) + (call $_ZdlPv + (get_local $8) + ) + ) + (br_if $label$36 + (i32.ne + (get_local $9) + (get_local $15) + ) + ) + ) + (set_local $15 + (i32.load + (i32.add + (get_local $19) + (i32.const 88) + ) + ) + ) + (br $label$34) + ) + (set_local $15 + (get_local $9) + ) + ) + (i32.store + (get_local $5) + (get_local $9) + ) + (call $_ZdlPv + (get_local $15) + ) + (set_local $17 + (i64.load offset=432 + (get_local $19) + ) + ) + ) + (call $eosio_assert + (i64.gt_s + (get_local $16) + (i64.const 0) + ) + (i32.const 3104) + ) + (call $eosio_assert + (i64.eq + (get_local $12) + (get_local $6) + ) + (i32.const 976) + ) + (call $eosio_assert + (i64.gt_s + (tee_local $18 + (i64.sub + (get_local $2) + (get_local $18) + ) + ) + (i64.const -4611686018427387904) + ) + (i32.const 1024) + ) + (call $eosio_assert + (i64.lt_s + (get_local $18) + (i64.const 4611686018427387904) + ) + (i32.const 1056) + ) + (set_local $11 + (f64.div + (tee_local $10 + (f64.convert_s/i64 + (get_local $16) + ) + ) + (f64.convert_s/i64 + (get_local $18) + ) + ) + ) + (set_local $2 + (i64.const 59) + ) + (set_local $15 + (i32.const 1088) + ) + (set_local $16 + (i64.const 0) + ) + (loop $label$38 + (block $label$39 + (block $label$40 + (block $label$41 + (block $label$42 + (block $label$43 + (br_if $label$43 + (i64.gt_u + (get_local $1) + (i64.const 10) + ) + ) + (br_if $label$42 + (i32.gt_u + (i32.and + (i32.add + (tee_local $8 + (i32.load8_s + (get_local $15) + ) + ) + (i32.const -97) + ) + (i32.const 255) + ) + (i32.const 25) + ) + ) + (set_local $8 + (i32.add + (get_local $8) + (i32.const 165) + ) + ) + (br $label$41) + ) + (set_local $18 + (i64.const 0) + ) + (br_if $label$40 + (i64.eq + (get_local $1) + (i64.const 11) + ) + ) + (br $label$39) + ) + (set_local $8 + (select + (i32.add + (get_local $8) + (i32.const 208) + ) + (i32.const 0) + (i32.lt_u + (i32.and + (i32.add + (get_local $8) + (i32.const -49) + ) + (i32.const 255) + ) + (i32.const 5) + ) + ) + ) + ) + (set_local $18 + (i64.shr_s + (i64.shl + (i64.extend_u/i32 + (get_local $8) + ) + (i64.const 56) + ) + (i64.const 56) + ) + ) + ) + (set_local $18 + (i64.shl + (i64.and + (get_local $18) + (i64.const 31) + ) + (i64.and + (get_local $2) + (i64.const 4294967295) + ) + ) + ) + ) + (set_local $15 + (i32.add + (get_local $15) + (i32.const 1) + ) + ) + (set_local $2 + (i64.add + (get_local $2) + (i64.const -5) + ) + ) + (set_local $16 + (i64.or + (get_local $18) + (get_local $16) + ) + ) + (br_if $label$38 + (i64.ne + (tee_local $1 + (i64.add + (get_local $1) + (i64.const 1) + ) + ) + (i64.const 13) + ) + ) + ) + (call $_ZN6eoswin7lottery12divide_tokenEyyyd + (i32.add + (get_local $19) + (i32.const 272) + ) + (get_local $0) + (get_local $17) + (get_local $16) + (i64.const 1397703940) + (get_local $11) + ) + (set_local $1 + (i64.const 0) + ) + (set_local $18 + (i64.const 59) + ) + (set_local $15 + (i32.const 16) + ) + (set_local $16 + (i64.const 0) + ) + (loop $label$44 + (set_local $2 + (i64.const 0) + ) + (block $label$45 + (br_if $label$45 + (i64.gt_u + (get_local $1) + (i64.const 11) + ) + ) + (block $label$46 + (block $label$47 + (br_if $label$47 + (i32.gt_u + (i32.and + (i32.add + (tee_local $8 + (i32.load8_s + (get_local $15) + ) + ) + (i32.const -97) + ) + (i32.const 255) + ) + (i32.const 25) + ) + ) + (set_local $8 + (i32.add + (get_local $8) + (i32.const 165) + ) + ) + (br $label$46) + ) + (set_local $8 + (select + (i32.add + (get_local $8) + (i32.const 208) + ) + (i32.const 0) + (i32.lt_u + (i32.and + (i32.add + (get_local $8) + (i32.const -49) + ) + (i32.const 255) + ) + (i32.const 5) + ) + ) + ) + ) + (set_local $2 + (i64.shl + (i64.extend_u/i32 + (i32.and + (get_local $8) + (i32.const 31) + ) + ) + (i64.and + (get_local $18) + (i64.const 4294967295) + ) + ) + ) + ) + (set_local $15 + (i32.add + (get_local $15) + (i32.const 1) + ) + ) + (set_local $1 + (i64.add + (get_local $1) + (i64.const 1) + ) + ) + (set_local $16 + (i64.or + (get_local $2) + (get_local $16) + ) + ) + (br_if $label$44 + (i64.ne + (tee_local $18 + (i64.add + (get_local $18) + (i64.const -5) + ) + ) + (i64.const -6) + ) + ) + ) + (call $_ZN6eoswin7lottery12divide_tokenEyyyd + (i32.add + (get_local $19) + (i32.const 256) + ) + (get_local $0) + (get_local $17) + (get_local $16) + (i64.const 98179787082756) + (get_local $11) + ) + (set_local $1 + (i64.const 0) + ) + (set_local $18 + (i64.const 59) + ) + (set_local $15 + (i32.const 3136) + ) + (set_local $16 + (i64.const 0) + ) + (loop $label$48 + (set_local $2 + (i64.const 0) + ) + (block $label$49 + (br_if $label$49 + (i64.gt_u + (get_local $1) + (i64.const 11) + ) + ) + (block $label$50 + (block $label$51 + (br_if $label$51 + (i32.gt_u + (i32.and + (i32.add + (tee_local $8 + (i32.load8_s + (get_local $15) + ) + ) + (i32.const -97) + ) + (i32.const 255) + ) + (i32.const 25) + ) + ) + (set_local $8 + (i32.add + (get_local $8) + (i32.const 165) + ) + ) + (br $label$50) + ) + (set_local $8 + (select + (i32.add + (get_local $8) + (i32.const 208) + ) + (i32.const 0) + (i32.lt_u + (i32.and + (i32.add + (get_local $8) + (i32.const -49) + ) + (i32.const 255) + ) + (i32.const 5) + ) + ) + ) + ) + (set_local $2 + (i64.shl + (i64.extend_u/i32 + (i32.and + (get_local $8) + (i32.const 31) + ) + ) + (i64.and + (get_local $18) + (i64.const 4294967295) + ) + ) + ) + ) + (set_local $15 + (i32.add + (get_local $15) + (i32.const 1) + ) + ) + (set_local $1 + (i64.add + (get_local $1) + (i64.const 1) + ) + ) + (set_local $16 + (i64.or + (get_local $2) + (get_local $16) + ) + ) + (br_if $label$48 + (i64.ne + (tee_local $18 + (i64.add + (get_local $18) + (i64.const -5) + ) + ) + (i64.const -6) + ) + ) + ) + (call $_ZN6eoswin7lottery12divide_tokenEyyyd + (i32.add + (get_local $19) + (i32.const 240) + ) + (get_local $0) + (get_local $17) + (get_local $16) + (i64.const 1145323780) + (get_local $11) + ) + (set_local $1 + (i64.const 0) + ) + (set_local $18 + (i64.const 59) + ) + (set_local $15 + (i32.const 3152) + ) + (set_local $16 + (i64.const 0) + ) + (loop $label$52 + (set_local $2 + (i64.const 0) + ) + (block $label$53 + (br_if $label$53 + (i64.gt_u + (get_local $1) + (i64.const 11) + ) + ) + (block $label$54 + (block $label$55 + (br_if $label$55 + (i32.gt_u + (i32.and + (i32.add + (tee_local $8 + (i32.load8_s + (get_local $15) + ) + ) + (i32.const -97) + ) + (i32.const 255) + ) + (i32.const 25) + ) + ) + (set_local $8 + (i32.add + (get_local $8) + (i32.const 165) + ) + ) + (br $label$54) + ) + (set_local $8 + (select + (i32.add + (get_local $8) + (i32.const 208) + ) + (i32.const 0) + (i32.lt_u + (i32.and + (i32.add + (get_local $8) + (i32.const -49) + ) + (i32.const 255) + ) + (i32.const 5) + ) + ) + ) + ) + (set_local $2 + (i64.shl + (i64.extend_u/i32 + (i32.and + (get_local $8) + (i32.const 31) + ) + ) + (i64.and + (get_local $18) + (i64.const 4294967295) + ) + ) + ) + ) + (set_local $15 + (i32.add + (get_local $15) + (i32.const 1) + ) + ) + (set_local $1 + (i64.add + (get_local $1) + (i64.const 1) + ) + ) + (set_local $16 + (i64.or + (get_local $2) + (get_local $16) + ) + ) + (br_if $label$52 + (i64.ne + (tee_local $18 + (i64.add + (get_local $18) + (i64.const -5) + ) + ) + (i64.const -6) + ) + ) + ) + (call $_ZN6eoswin7lottery12divide_tokenEyyyd + (i32.add + (get_local $19) + (i32.const 224) + ) + (get_local $0) + (get_local $17) + (get_local $16) + (i64.const 1146372356) + (get_local $11) + ) + (set_local $1 + (i64.const 0) + ) + (set_local $18 + (i64.const 59) + ) + (set_local $15 + (i32.const 3168) + ) + (set_local $16 + (i64.const 0) + ) + (loop $label$56 + (set_local $2 + (i64.const 0) + ) + (block $label$57 + (br_if $label$57 + (i64.gt_u + (get_local $1) + (i64.const 11) + ) + ) + (block $label$58 + (block $label$59 + (br_if $label$59 + (i32.gt_u + (i32.and + (i32.add + (tee_local $8 + (i32.load8_s + (get_local $15) + ) + ) + (i32.const -97) + ) + (i32.const 255) + ) + (i32.const 25) + ) + ) + (set_local $8 + (i32.add + (get_local $8) + (i32.const 165) + ) + ) + (br $label$58) + ) + (set_local $8 + (select + (i32.add + (get_local $8) + (i32.const 208) + ) + (i32.const 0) + (i32.lt_u + (i32.and + (i32.add + (get_local $8) + (i32.const -49) + ) + (i32.const 255) + ) + (i32.const 5) + ) + ) + ) + ) + (set_local $2 + (i64.shl + (i64.extend_u/i32 + (i32.and + (get_local $8) + (i32.const 31) + ) + ) + (i64.and + (get_local $18) + (i64.const 4294967295) + ) + ) + ) + ) + (set_local $15 + (i32.add + (get_local $15) + (i32.const 1) + ) + ) + (set_local $1 + (i64.add + (get_local $1) + (i64.const 1) + ) + ) + (set_local $16 + (i64.or + (get_local $2) + (get_local $16) + ) + ) + (br_if $label$56 + (i64.ne + (tee_local $18 + (i64.add + (get_local $18) + (i64.const -5) + ) + ) + (i64.const -6) + ) + ) + ) + (call $_ZN6eoswin7lottery12divide_tokenEyyyd + (i32.add + (get_local $19) + (i32.const 208) + ) + (get_local $0) + (get_local $17) + (get_local $16) + (i64.const 18930585150899460) + (get_local $11) + ) + (set_local $1 + (i64.const 0) + ) + (set_local $18 + (i64.const 59) + ) + (set_local $15 + (i32.const 3184) + ) + (set_local $16 + (i64.const 0) + ) + (loop $label$60 + (set_local $2 + (i64.const 0) + ) + (block $label$61 + (br_if $label$61 + (i64.gt_u + (get_local $1) + (i64.const 11) + ) + ) + (block $label$62 + (block $label$63 + (br_if $label$63 + (i32.gt_u + (i32.and + (i32.add + (tee_local $8 + (i32.load8_s + (get_local $15) + ) + ) + (i32.const -97) + ) + (i32.const 255) + ) + (i32.const 25) + ) + ) + (set_local $8 + (i32.add + (get_local $8) + (i32.const 165) + ) + ) + (br $label$62) + ) + (set_local $8 + (select + (i32.add + (get_local $8) + (i32.const 208) + ) + (i32.const 0) + (i32.lt_u + (i32.and + (i32.add + (get_local $8) + (i32.const -49) + ) + (i32.const 255) + ) + (i32.const 5) + ) + ) + ) + ) + (set_local $2 + (i64.shl + (i64.extend_u/i32 + (i32.and + (get_local $8) + (i32.const 31) + ) + ) + (i64.and + (get_local $18) + (i64.const 4294967295) + ) + ) + ) + ) + (set_local $15 + (i32.add + (get_local $15) + (i32.const 1) + ) + ) + (set_local $1 + (i64.add + (get_local $1) + (i64.const 1) + ) + ) + (set_local $16 + (i64.or + (get_local $2) + (get_local $16) + ) + ) + (br_if $label$60 + (i64.ne + (tee_local $18 + (i64.add + (get_local $18) + (i64.const -5) + ) + ) + (i64.const -6) + ) + ) + ) + (call $_ZN6eoswin7lottery12divide_tokenEyyyd + (i32.add + (get_local $19) + (i32.const 192) + ) + (get_local $0) + (get_local $17) + (get_local $16) + (i64.const 91625918253060) + (get_local $11) + ) + (set_local $1 + (i64.const 0) + ) + (set_local $18 + (i64.const 59) + ) + (set_local $15 + (i32.const 3200) + ) + (set_local $16 + (i64.const 0) + ) + (loop $label$64 + (set_local $2 + (i64.const 0) + ) + (block $label$65 + (br_if $label$65 + (i64.gt_u + (get_local $1) + (i64.const 11) + ) + ) + (block $label$66 + (block $label$67 + (br_if $label$67 + (i32.gt_u + (i32.and + (i32.add + (tee_local $8 + (i32.load8_s + (get_local $15) + ) + ) + (i32.const -97) + ) + (i32.const 255) + ) + (i32.const 25) + ) + ) + (set_local $8 + (i32.add + (get_local $8) + (i32.const 165) + ) + ) + (br $label$66) + ) + (set_local $8 + (select + (i32.add + (get_local $8) + (i32.const 208) + ) + (i32.const 0) + (i32.lt_u + (i32.and + (i32.add + (get_local $8) + (i32.const -49) + ) + (i32.const 255) + ) + (i32.const 5) + ) + ) + ) + ) + (set_local $2 + (i64.shl + (i64.extend_u/i32 + (i32.and + (get_local $8) + (i32.const 31) + ) + ) + (i64.and + (get_local $18) + (i64.const 4294967295) + ) + ) + ) + ) + (set_local $15 + (i32.add + (get_local $15) + (i32.const 1) + ) + ) + (set_local $1 + (i64.add + (get_local $1) + (i64.const 1) + ) + ) + (set_local $16 + (i64.or + (get_local $2) + (get_local $16) + ) + ) + (br_if $label$64 + (i64.ne + (tee_local $18 + (i64.add + (get_local $18) + (i64.const -5) + ) + ) + (i64.const -6) + ) + ) + ) + (call $_ZN6eoswin7lottery12divide_tokenEyyyd + (i32.add + (get_local $19) + (i32.const 176) + ) + (get_local $0) + (get_local $17) + (get_local $16) + (i64.const 5327108) + (get_local $11) + ) + (set_local $1 + (i64.const 0) + ) + (set_local $18 + (i64.const 59) + ) + (set_local $15 + (i32.const 3216) + ) + (set_local $16 + (i64.const 0) + ) + (loop $label$68 + (set_local $2 + (i64.const 0) + ) + (block $label$69 + (br_if $label$69 + (i64.gt_u + (get_local $1) + (i64.const 11) + ) + ) + (block $label$70 + (block $label$71 + (br_if $label$71 + (i32.gt_u + (i32.and + (i32.add + (tee_local $8 + (i32.load8_s + (get_local $15) + ) + ) + (i32.const -97) + ) + (i32.const 255) + ) + (i32.const 25) + ) + ) + (set_local $8 + (i32.add + (get_local $8) + (i32.const 165) + ) + ) + (br $label$70) + ) + (set_local $8 + (select + (i32.add + (get_local $8) + (i32.const 208) + ) + (i32.const 0) + (i32.lt_u + (i32.and + (i32.add + (get_local $8) + (i32.const -49) + ) + (i32.const 255) + ) + (i32.const 5) + ) + ) + ) + ) + (set_local $2 + (i64.shl + (i64.extend_u/i32 + (i32.and + (get_local $8) + (i32.const 31) + ) + ) + (i64.and + (get_local $18) + (i64.const 4294967295) + ) + ) + ) + ) + (set_local $15 + (i32.add + (get_local $15) + (i32.const 1) + ) + ) + (set_local $1 + (i64.add + (get_local $1) + (i64.const 1) + ) + ) + (set_local $16 + (i64.or + (get_local $2) + (get_local $16) + ) + ) + (br_if $label$68 + (i64.ne + (tee_local $18 + (i64.add + (get_local $18) + (i64.const -5) + ) + ) + (i64.const -6) + ) + ) + ) + (call $_ZN6eoswin7lottery12divide_tokenEyyyd + (i32.add + (get_local $19) + (i32.const 160) + ) + (get_local $0) + (get_local $17) + (get_local $16) + (i64.const 71800348297988) + (get_local $11) + ) + (set_local $1 + (i64.const 0) + ) + (set_local $18 + (i64.const 59) + ) + (set_local $15 + (i32.const 3232) + ) + (set_local $16 + (i64.const 0) + ) + (loop $label$72 + (set_local $2 + (i64.const 0) + ) + (block $label$73 + (br_if $label$73 + (i64.gt_u + (get_local $1) + (i64.const 11) + ) + ) + (block $label$74 + (block $label$75 + (br_if $label$75 + (i32.gt_u + (i32.and + (i32.add + (tee_local $8 + (i32.load8_s + (get_local $15) + ) + ) + (i32.const -97) + ) + (i32.const 255) + ) + (i32.const 25) + ) + ) + (set_local $8 + (i32.add + (get_local $8) + (i32.const 165) + ) + ) + (br $label$74) + ) + (set_local $8 + (select + (i32.add + (get_local $8) + (i32.const 208) + ) + (i32.const 0) + (i32.lt_u + (i32.and + (i32.add + (get_local $8) + (i32.const -49) + ) + (i32.const 255) + ) + (i32.const 5) + ) + ) + ) + ) + (set_local $2 + (i64.shl + (i64.extend_u/i32 + (i32.and + (get_local $8) + (i32.const 31) + ) + ) + (i64.and + (get_local $18) + (i64.const 4294967295) + ) + ) + ) + ) + (set_local $15 + (i32.add + (get_local $15) + (i32.const 1) + ) + ) + (set_local $1 + (i64.add + (get_local $1) + (i64.const 1) + ) + ) + (set_local $16 + (i64.or + (get_local $2) + (get_local $16) + ) + ) + (br_if $label$72 + (i64.ne + (tee_local $18 + (i64.add + (get_local $18) + (i64.const -5) + ) + ) + (i64.const -6) + ) + ) + ) + (call $_ZN6eoswin7lottery12divide_tokenEyyyd + (i32.add + (get_local $19) + (i32.const 144) + ) + (get_local $0) + (get_local $17) + (get_local $16) + (i64.const 4994016260158475524) + (get_local $11) + ) + (set_local $1 + (i64.const 0) + ) + (set_local $18 + (i64.const 59) + ) + (set_local $15 + (i32.const 3248) + ) + (set_local $16 + (i64.const 0) + ) + (loop $label$76 + (set_local $2 + (i64.const 0) + ) + (block $label$77 + (br_if $label$77 + (i64.gt_u + (get_local $1) + (i64.const 11) + ) + ) + (block $label$78 + (block $label$79 + (br_if $label$79 + (i32.gt_u + (i32.and + (i32.add + (tee_local $8 + (i32.load8_s + (get_local $15) + ) + ) + (i32.const -97) + ) + (i32.const 255) + ) + (i32.const 25) + ) + ) + (set_local $8 + (i32.add + (get_local $8) + (i32.const 165) + ) + ) + (br $label$78) + ) + (set_local $8 + (select + (i32.add + (get_local $8) + (i32.const 208) + ) + (i32.const 0) + (i32.lt_u + (i32.and + (i32.add + (get_local $8) + (i32.const -49) + ) + (i32.const 255) + ) + (i32.const 5) + ) + ) + ) + ) + (set_local $2 + (i64.shl + (i64.extend_u/i32 + (i32.and + (get_local $8) + (i32.const 31) + ) + ) + (i64.and + (get_local $18) + (i64.const 4294967295) + ) + ) + ) + ) + (set_local $15 + (i32.add + (get_local $15) + (i32.const 1) + ) + ) + (set_local $1 + (i64.add + (get_local $1) + (i64.const 1) + ) + ) + (set_local $16 + (i64.or + (get_local $2) + (get_local $16) + ) + ) + (br_if $label$76 + (i64.ne + (tee_local $18 + (i64.add + (get_local $18) + (i64.const -5) + ) + ) + (i64.const -6) + ) + ) + ) + (call $_ZN6eoswin7lottery12divide_tokenEyyyd + (i32.add + (get_local $19) + (i32.const 128) + ) + (get_local $0) + (get_local $17) + (get_local $16) + (i64.const 82752230408708) + (get_local $11) + ) + (call $eosio_assert + (i64.lt_u + (i64.add + (i64.trunc_s/f64 + (f64.mul + (get_local $10) + (f64.const 0.005) + ) + ) + (i64.const 4611686018427387903) + ) + (i64.const 9223372036854775807) + ) + (i32.const 176) + ) + (set_local $1 + (i64.const 383514793292) + ) + (set_local $15 + (i32.const 0) + ) + (block $label$80 + (block $label$81 + (loop $label$82 + (br_if $label$81 + (i32.gt_u + (i32.add + (i32.shl + (i32.wrap/i64 + (get_local $1) + ) + (i32.const 24) + ) + (i32.const -1073741825) + ) + (i32.const 452984830) + ) + ) + (block $label$83 + (br_if $label$83 + (i64.ne + (i64.and + (tee_local $1 + (i64.shr_u + (get_local $1) + (i64.const 8) + ) + ) + (i64.const 255) + ) + (i64.const 0) + ) + ) + (loop $label$84 + (br_if $label$81 + (i64.ne + (i64.and + (tee_local $1 + (i64.shr_u + (get_local $1) + (i64.const 8) + ) + ) + (i64.const 255) + ) + (i64.const 0) + ) + ) + (br_if $label$84 + (i32.lt_s + (tee_local $15 + (i32.add + (get_local $15) + (i32.const 1) + ) + ) + (i32.const 7) + ) + ) + ) + ) + (set_local $8 + (i32.const 1) + ) + (br_if $label$82 + (i32.lt_s + (tee_local $15 + (i32.add + (get_local $15) + (i32.const 1) + ) + ) + (i32.const 7) + ) + ) + (br $label$80) + ) + ) + (set_local $8 + (i32.const 0) + ) + ) + (call $eosio_assert + (get_local $8) + (i32.const 128) + ) + (set_local $12 + (i64.load + (i32.add + (get_local $0) + (i32.const 72) + ) + ) + ) + (set_local $1 + (i64.const 0) + ) + (set_local $2 + (i64.const 59) + ) + (set_local $15 + (i32.const 592) + ) + (set_local $16 + (i64.const 0) + ) + (loop $label$85 + (block $label$86 + (block $label$87 + (block $label$88 + (block $label$89 + (block $label$90 + (br_if $label$90 + (i64.gt_u + (get_local $1) + (i64.const 5) + ) + ) + (br_if $label$89 + (i32.gt_u + (i32.and + (i32.add + (tee_local $8 + (i32.load8_s + (get_local $15) + ) + ) + (i32.const -97) + ) + (i32.const 255) + ) + (i32.const 25) + ) + ) + (set_local $8 + (i32.add + (get_local $8) + (i32.const 165) + ) + ) + (br $label$88) + ) + (set_local $18 + (i64.const 0) + ) + (br_if $label$87 + (i64.le_u + (get_local $1) + (i64.const 11) + ) + ) + (br $label$86) + ) + (set_local $8 + (select + (i32.add + (get_local $8) + (i32.const 208) + ) + (i32.const 0) + (i32.lt_u + (i32.and + (i32.add + (get_local $8) + (i32.const -49) + ) + (i32.const 255) + ) + (i32.const 5) + ) + ) + ) + ) + (set_local $18 + (i64.shr_s + (i64.shl + (i64.extend_u/i32 + (get_local $8) + ) + (i64.const 56) + ) + (i64.const 56) + ) + ) + ) + (set_local $18 + (i64.shl + (i64.and + (get_local $18) + (i64.const 31) + ) + (i64.and + (get_local $2) + (i64.const 4294967295) + ) + ) + ) + ) + (set_local $15 + (i32.add + (get_local $15) + (i32.const 1) + ) + ) + (set_local $1 + (i64.add + (get_local $1) + (i64.const 1) + ) + ) + (set_local $16 + (i64.or + (get_local $18) + (get_local $16) + ) + ) + (br_if $label$85 + (i64.ne + (tee_local $2 + (i64.add + (get_local $2) + (i64.const -5) + ) + ) + (i64.const -6) + ) + ) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 176) + ) + (set_local $1 + (i64.const 383514793292) + ) + (set_local $15 + (i32.const 0) + ) + (block $label$91 + (block $label$92 + (loop $label$93 + (br_if $label$92 + (i32.gt_u + (i32.add + (i32.shl + (i32.wrap/i64 + (get_local $1) + ) + (i32.const 24) + ) + (i32.const -1073741825) + ) + (i32.const 452984830) + ) + ) + (block $label$94 + (br_if $label$94 + (i64.ne + (i64.and + (tee_local $1 + (i64.shr_u + (get_local $1) + (i64.const 8) + ) + ) + (i64.const 255) + ) + (i64.const 0) + ) + ) + (loop $label$95 + (br_if $label$92 + (i64.ne + (i64.and + (tee_local $1 + (i64.shr_u + (get_local $1) + (i64.const 8) + ) + ) + (i64.const 255) + ) + (i64.const 0) + ) + ) + (br_if $label$95 + (i32.lt_s + (tee_local $15 + (i32.add + (get_local $15) + (i32.const 1) + ) + ) + (i32.const 7) + ) + ) + ) + ) + (set_local $8 + (i32.const 1) + ) + (br_if $label$93 + (i32.lt_s + (tee_local $15 + (i32.add + (get_local $15) + (i32.const 1) + ) + ) + (i32.const 7) + ) + ) + (br $label$91) + ) + ) + (set_local $8 + (i32.const 0) + ) + ) + (call $eosio_assert + (get_local $8) + (i32.const 128) + ) + (set_local $1 + (i64.load offset=424 + (get_local $19) + ) + ) + (i64.store + (tee_local $15 + (call $_Znwj + (i32.const 16) + ) + ) + (get_local $12) + ) + (i64.store offset=8 + (get_local $15) + (get_local $16) + ) + (i32.store offset=448 + (get_local $19) + (get_local $15) + ) + (i32.store offset=456 + (get_local $19) + (tee_local $15 + (i32.add + (get_local $15) + (i32.const 16) + ) + ) + ) + (i64.store offset=64 + (get_local $19) + (get_local $17) + ) + (i32.store offset=452 + (get_local $19) + (get_local $15) + ) + (i64.store offset=72 + (get_local $19) + (i64.const 0) + ) + (i64.store + (i32.add + (i32.add + (get_local $19) + (i32.const 64) + ) + (i32.const 16) + ) + (i64.const 98179787082756) + ) + (i64.store + (i32.add + (get_local $19) + (i32.const 8) + ) + (i64.load offset=72 + (get_local $19) + ) + ) + (i64.store + (i32.add + (get_local $19) + (i32.const 16) + ) + (i64.const 98179787082756) + ) + (i64.store offset=88 + (get_local $19) + (get_local $1) + ) + (i64.store + (i32.add + (get_local $19) + (i32.const 24) + ) + (get_local $1) + ) + (i64.store + (get_local $19) + (i64.load offset=64 + (get_local $19) + ) + ) + (call $_ZN5eosio15dispatch_inlineIJyNS_5assetEyEEEvyyNSt3__16vectorINS_16permission_levelENS2_9allocatorIS4_EEEENS2_5tupleIJDpT_EEE + (get_local $12) + (i64.const -3075276123302526976) + (i32.add + (get_local $19) + (i32.const 448) + ) + (get_local $19) + ) + (block $label$96 + (br_if $label$96 + (i32.eqz + (tee_local $15 + (i32.load offset=448 + (get_local $19) + ) + ) + ) + ) + (i32.store offset=452 + (get_local $19) + (get_local $15) + ) + (call $_ZdlPv + (get_local $15) + ) + ) + (call $eosio_assert + (i64.eq + (i64.load offset=280 + (get_local $19) + ) + (i64.load + (i32.add + (get_local $0) + (i32.const 128) + ) + ) + ) + (i32.const 1392) + ) + (i64.store + (tee_local $15 + (i32.add + (get_local $0) + (i32.const 120) + ) + ) + (tee_local $1 + (i64.add + (i64.load + (get_local $15) + ) + (i64.load offset=272 + (get_local $19) + ) + ) + ) + ) + (call $eosio_assert + (i64.gt_s + (get_local $1) + (i64.const -4611686018427387904) + ) + (i32.const 1440) + ) + (call $eosio_assert + (i64.lt_s + (i64.load + (get_local $15) + ) + (i64.const 4611686018427387904) + ) + (i32.const 1472) + ) + (block $label$97 + (br_if $label$97 + (i32.eq + (tee_local $9 + (i32.load + (i32.add + (get_local $0) + (i32.const 276) + ) + ) + ) + (tee_local $4 + (i32.load + (i32.add + (get_local $0) + (i32.const 272) + ) + ) + ) + ) + ) + (set_local $15 + (i32.add + (get_local $9) + (i32.const -24) + ) + ) + (set_local $5 + (i32.sub + (i32.const 0) + (get_local $4) + ) + ) + (loop $label$98 + (br_if $label$97 + (i64.eq + (i64.load + (i32.load + (get_local $15) + ) + ) + (i64.const 102) + ) + ) + (set_local $9 + (get_local $15) + ) + (set_local $15 + (tee_local $8 + (i32.add + (get_local $15) + (i32.const -24) + ) + ) + ) + (br_if $label$98 + (i32.ne + (i32.add + (get_local $8) + (get_local $5) + ) + (i32.const -24) + ) + ) + ) + ) + (block $label$99 + (block $label$100 + (block $label$101 + (block $label$102 + (block $label$103 + (br_if $label$103 + (i32.eq + (get_local $9) + (get_local $4) + ) + ) + (call $eosio_assert + (i32.eq + (i32.load offset=16 + (tee_local $15 + (i32.load + (i32.add + (get_local $9) + (i32.const -24) + ) + ) + ) + ) + (get_local $3) + ) + (i32.const 32) + ) + (i64.store offset=120 + (get_local $19) + (i64.const 1) + ) + (br_if $label$102 + (get_local $15) + ) + (br $label$100) + ) + (br_if $label$101 + (i32.le_s + (tee_local $15 + (call $db_find_i64 + (i64.load + (i32.add + (get_local $0) + (i32.const 248) + ) + ) + (i64.load + (i32.add + (get_local $0) + (i32.const 256) + ) + ) + (i64.const -4157493845350678528) + (i64.const 102) + ) + ) + (i32.const -1) + ) + ) + (call $eosio_assert + (i32.eq + (i32.load offset=16 + (tee_local $15 + (call $_ZNK5eosio11multi_indexILy14289250228358873088EN6eoswin6statusEJEE31load_object_by_primary_iteratorEl + (get_local $3) + (get_local $15) + ) + ) + ) + (get_local $3) + ) + (i32.const 32) + ) + (i64.store offset=120 + (get_local $19) + (i64.const 1) + ) + ) + (i64.store offset=120 + (get_local $19) + (i64.add + (i64.load offset=8 + (get_local $15) + ) + (i64.const 1) + ) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 288) + ) + (call $eosio_assert + (i32.eq + (i32.load offset=16 + (get_local $15) + ) + (get_local $3) + ) + (i32.const 416) + ) + (call $eosio_assert + (i64.eq + (i64.load + (i32.add + (get_local $0) + (i32.const 248) + ) + ) + (call $current_receiver) + ) + (i32.const 464) + ) + (i64.store offset=8 + (get_local $15) + (i64.load offset=120 + (get_local $19) + ) + ) + (set_local $1 + (i64.load + (get_local $15) + ) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 528) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 400) + ) + (drop + (call $memcpy + (i32.add + (get_local $19) + (i32.const 64) + ) + (get_local $15) + (i32.const 8) + ) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 400) + ) + (drop + (call $memcpy + (i32.or + (i32.add + (get_local $19) + (i32.const 64) + ) + (i32.const 8) + ) + (i32.add + (get_local $15) + (i32.const 8) + ) + (i32.const 8) + ) + ) + (call $db_update_i64 + (i32.load offset=20 + (get_local $15) + ) + (i64.const 0) + (i32.add + (get_local $19) + (i32.const 64) + ) + (i32.const 16) + ) + (br_if $label$99 + (i64.lt_u + (get_local $1) + (i64.load + (tee_local $15 + (i32.add + (get_local $0) + (i32.const 264) + ) + ) + ) + ) + ) + (i64.store + (get_local $15) + (select + (i64.const -2) + (i64.add + (get_local $1) + (i64.const 1) + ) + (i64.gt_u + (get_local $1) + (i64.const -3) + ) + ) + ) + (br $label$99) + ) + (i64.store offset=120 + (get_local $19) + (i64.const 1) + ) + ) + (set_local $18 + (i64.load + (get_local $0) + ) + ) + (call $eosio_assert + (i64.eq + (i64.load + (i32.add + (get_local $0) + (i32.const 248) + ) + ) + (call $current_receiver) + ) + (i32.const 336) + ) + (i32.store offset=16 + (tee_local $15 + (call $_Znwj + (i32.const 32) + ) + ) + (get_local $3) + ) + (i64.store + (get_local $15) + (i64.const 102) + ) + (i64.store offset=8 + (get_local $15) + (i64.load offset=120 + (get_local $19) + ) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 400) + ) + (drop + (call $memcpy + (i32.add + (get_local $19) + (i32.const 64) + ) + (get_local $15) + (i32.const 8) + ) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 400) + ) + (drop + (call $memcpy + (i32.or + (i32.add + (get_local $19) + (i32.const 64) + ) + (i32.const 8) + ) + (i32.add + (get_local $15) + (i32.const 8) + ) + (i32.const 8) + ) + ) + (i32.store offset=20 + (get_local $15) + (tee_local $9 + (call $db_store_i64 + (i64.load + (i32.add + (get_local $0) + (i32.const 256) + ) + ) + (i64.const -4157493845350678528) + (get_local $18) + (tee_local $1 + (i64.load + (get_local $15) + ) + ) + (i32.add + (get_local $19) + (i32.const 64) + ) + (i32.const 16) + ) + ) + ) + (block $label$104 + (br_if $label$104 + (i64.lt_u + (get_local $1) + (i64.load + (tee_local $8 + (i32.add + (get_local $0) + (i32.const 264) + ) + ) + ) + ) + ) + (i64.store + (get_local $8) + (select + (i64.const -2) + (i64.add + (get_local $1) + (i64.const 1) + ) + (i64.gt_u + (get_local $1) + (i64.const -3) + ) + ) + ) + ) + (i32.store offset=448 + (get_local $19) + (get_local $15) + ) + (i64.store offset=64 + (get_local $19) + (tee_local $1 + (i64.load + (get_local $15) + ) + ) + ) + (i32.store offset=472 + (get_local $19) + (get_local $9) + ) + (block $label$105 + (block $label$106 + (br_if $label$106 + (i32.ge_u + (tee_local $8 + (i32.load + (tee_local $5 + (i32.add + (get_local $0) + (i32.const 276) + ) + ) + ) + ) + (i32.load + (i32.add + (get_local $0) + (i32.const 280) + ) + ) + ) + ) + (i64.store offset=8 + (get_local $8) + (get_local $1) + ) + (i32.store offset=16 + (get_local $8) + (get_local $9) + ) + (i32.store offset=448 + (get_local $19) + (i32.const 0) + ) + (i32.store + (get_local $8) + (get_local $15) + ) + (i32.store + (get_local $5) + (i32.add + (get_local $8) + (i32.const 24) + ) + ) + (br $label$105) + ) + (call $_ZNSt3__16vectorIN5eosio11multi_indexILy14289250228358873088EN6eoswin6statusEJEE8item_ptrENS_9allocatorIS6_EEE24__emplace_back_slow_pathIJNS_10unique_ptrINS5_4itemENS_14default_deleteISC_EEEERyRlEEEvDpOT_ + (i32.add + (get_local $0) + (i32.const 272) + ) + (i32.add + (get_local $19) + (i32.const 448) + ) + (i32.add + (get_local $19) + (i32.const 64) + ) + (i32.add + (get_local $19) + (i32.const 472) + ) + ) + ) + (set_local $15 + (i32.load offset=448 + (get_local $19) + ) + ) + (i32.store offset=448 + (get_local $19) + (i32.const 0) + ) + (block $label$107 + (br_if $label$107 + (i32.eqz + (get_local $15) + ) + ) + (call $_ZdlPv + (get_local $15) + ) + ) + (block $label$108 + (br_if $label$108 + (i32.eq + (tee_local $9 + (i32.load + (i32.add + (get_local $0) + (i32.const 276) + ) + ) + ) + (tee_local $4 + (i32.load + (i32.add + (get_local $0) + (i32.const 272) + ) + ) + ) + ) + ) + (set_local $15 + (i32.add + (get_local $9) + (i32.const -24) + ) + ) + (set_local $5 + (i32.sub + (i32.const 0) + (get_local $4) + ) + ) + (loop $label$109 + (br_if $label$108 + (i64.eq + (i64.load + (i32.load + (get_local $15) + ) + ) + (i64.const 102) + ) + ) + (set_local $9 + (get_local $15) + ) + (set_local $15 + (tee_local $8 + (i32.add + (get_local $15) + (i32.const -24) + ) + ) + ) + (br_if $label$109 + (i32.ne + (i32.add + (get_local $8) + (get_local $5) + ) + (i32.const -24) + ) + ) + ) + ) + (block $label$110 + (br_if $label$110 + (i32.eq + (get_local $9) + (get_local $4) + ) + ) + (call $eosio_assert + (i32.eq + (i32.load offset=16 + (i32.load + (i32.add + (get_local $9) + (i32.const -24) + ) + ) + ) + (get_local $3) + ) + (i32.const 32) + ) + (br $label$99) + ) + (br_if $label$99 + (i32.lt_s + (tee_local $15 + (call $db_find_i64 + (i64.load + (i32.add + (get_local $0) + (i32.const 248) + ) + ) + (i64.load + (i32.add + (get_local $0) + (i32.const 256) + ) + ) + (i64.const -4157493845350678528) + (i64.const 102) + ) + ) + (i32.const 0) + ) + ) + (call $eosio_assert + (i32.eq + (i32.load offset=16 + (call $_ZNK5eosio11multi_indexILy14289250228358873088EN6eoswin6statusEJEE31load_object_by_primary_iteratorEl + (get_local $3) + (get_local $15) + ) + ) + (get_local $3) + ) + (i32.const 32) + ) + ) + (set_local $8 + (i32.add + (get_local $0) + (i32.const 288) + ) + ) + (block $label$111 + (br_if $label$111 + (i64.lt_u + (i64.load offset=120 + (get_local $19) + ) + (i64.const 101) + ) + ) + (set_local $15 + (i32.const 0) + ) + (block $label$112 + (br_if $label$112 + (i32.lt_s + (tee_local $9 + (call $db_lowerbound_i64 + (i64.load + (get_local $8) + ) + (i64.load + (i32.add + (get_local $0) + (i32.const 296) + ) + ) + (i64.const 5455799419175698432) + (i64.const 0) + ) + ) + (i32.const 0) + ) + ) + (set_local $15 + (call $_ZNK5eosio11multi_indexILy5455799419175698432EN6eoswin13dividend_itemEJEE31load_object_by_primary_iteratorEl + (get_local $8) + (get_local $9) + ) + ) + ) + (call $eosio_assert + (tee_local $9 + (i32.ne + (get_local $15) + (i32.const 0) + ) + ) + (i32.const 2560) + ) + (call $eosio_assert + (get_local $9) + (i32.const 1344) + ) + (block $label$113 + (br_if $label$113 + (i32.lt_s + (tee_local $9 + (call $db_next_i64 + (i32.load offset=44 + (get_local $15) + ) + (i32.add + (get_local $19) + (i32.const 64) + ) + ) + ) + (i32.const 0) + ) + ) + (drop + (call $_ZNK5eosio11multi_indexILy5455799419175698432EN6eoswin13dividend_itemEJEE31load_object_by_primary_iteratorEl + (get_local $8) + (get_local $9) + ) + ) + ) + (call $_ZN5eosio11multi_indexILy5455799419175698432EN6eoswin13dividend_itemEJEE5eraseERKS2_ + (get_local $8) + (get_local $15) + ) + ) + (set_local $1 + (i64.load + (get_local $0) + ) + ) + (i32.store offset=68 + (get_local $19) + (i32.add + (get_local $19) + (i32.const 432) + ) + ) + (i32.store offset=64 + (get_local $19) + (i32.add + (get_local $19) + (i32.const 120) + ) + ) + (i32.store offset=72 + (get_local $19) + (i32.add + (get_local $19) + (i32.const 424) + ) + ) + (i32.store offset=76 + (get_local $19) + (i32.add + (get_local $19) + (i32.const 272) + ) + ) + (i32.store offset=80 + (get_local $19) + (i32.add + (get_local $19) + (i32.const 256) + ) + ) + (i32.store offset=84 + (get_local $19) + (i32.add + (get_local $19) + (i32.const 240) + ) + ) + (i32.store offset=88 + (get_local $19) + (i32.add + (get_local $19) + (i32.const 224) + ) + ) + (i32.store offset=92 + (get_local $19) + (i32.add + (get_local $19) + (i32.const 208) + ) + ) + (i32.store offset=96 + (get_local $19) + (i32.add + (get_local $19) + (i32.const 192) + ) + ) + (i32.store offset=100 + (get_local $19) + (i32.add + (get_local $19) + (i32.const 176) + ) + ) + (i32.store offset=104 + (get_local $19) + (i32.add + (get_local $19) + (i32.const 160) + ) + ) + (i32.store offset=108 + (get_local $19) + (i32.add + (get_local $19) + (i32.const 144) + ) + ) + (i32.store offset=112 + (get_local $19) + (i32.add + (get_local $19) + (i32.const 128) + ) + ) + (i64.store offset=472 + (get_local $19) + (get_local $1) + ) + (call $eosio_assert + (i64.eq + (i64.load + (get_local $8) + ) + (call $current_receiver) + ) + (i32.const 336) + ) + (i32.store offset=448 + (get_local $19) + (get_local $8) + ) + (i32.store offset=452 + (get_local $19) + (i32.add + (get_local $19) + (i32.const 64) + ) + ) + (i32.store offset=456 + (get_local $19) + (i32.add + (get_local $19) + (i32.const 472) + ) + ) + (i32.store offset=24 + (tee_local $15 + (call $_Znwj + (i32.const 56) + ) + ) + (i32.const 0) + ) + (i64.store offset=16 align=4 + (get_local $15) + (i64.const 0) + ) + (i32.store offset=40 + (get_local $15) + (get_local $8) + ) + (call $_ZZN5eosio11multi_indexILy5455799419175698432EN6eoswin13dividend_itemEJEE7emplaceIZNS1_7lottery10claimbonusEyyE4$_16EENS3_14const_iteratorEyOT_ENKUlRS8_E_clINS3_4itemEEEDaSA_ + (i32.add + (get_local $19) + (i32.const 448) + ) + (get_local $15) + ) + (i32.store offset=464 + (get_local $19) + (get_local $15) + ) + (i64.store offset=448 + (get_local $19) + (tee_local $1 + (i64.load + (get_local $15) + ) + ) + ) + (i32.store offset=444 + (get_local $19) + (tee_local $9 + (i32.load offset=44 + (get_local $15) + ) + ) + ) + (block $label$114 + (block $label$115 + (br_if $label$115 + (i32.ge_u + (tee_local $8 + (i32.load + (tee_local $5 + (i32.add + (get_local $0) + (i32.const 316) + ) + ) + ) + ) + (i32.load + (i32.add + (get_local $0) + (i32.const 320) + ) + ) + ) + ) + (i64.store offset=8 + (get_local $8) + (get_local $1) + ) + (i32.store offset=16 + (get_local $8) + (get_local $9) + ) + (i32.store offset=464 + (get_local $19) + (i32.const 0) + ) + (i32.store + (get_local $8) + (get_local $15) + ) + (i32.store + (get_local $5) + (i32.add + (get_local $8) + (i32.const 24) + ) + ) + (br $label$114) + ) + (call $_ZNSt3__16vectorIN5eosio11multi_indexILy5455799419175698432EN6eoswin13dividend_itemEJEE8item_ptrENS_9allocatorIS6_EEE24__emplace_back_slow_pathIJNS_10unique_ptrINS5_4itemENS_14default_deleteISC_EEEERyRlEEEvDpOT_ + (i32.add + (get_local $0) + (i32.const 312) + ) + (i32.add + (get_local $19) + (i32.const 464) + ) + (i32.add + (get_local $19) + (i32.const 448) + ) + (i32.add + (get_local $19) + (i32.const 444) + ) + ) + ) + (set_local $15 + (i32.load offset=464 + (get_local $19) + ) + ) + (i32.store offset=464 + (get_local $19) + (i32.const 0) + ) + (block $label$116 + (br_if $label$116 + (i32.eqz + (get_local $15) + ) + ) + (block $label$117 + (br_if $label$117 + (i32.eqz + (tee_local $0 + (i32.load offset=16 + (get_local $15) + ) + ) + ) + ) + (i32.store + (i32.add + (get_local $15) + (i32.const 20) + ) + (get_local $0) + ) + (call $_ZdlPv + (get_local $0) + ) + ) + (call $_ZdlPv + (get_local $15) + ) + ) + (i32.store offset=4 + (i32.const 0) + (i32.add + (get_local $19) + (i32.const 480) + ) + ) + ) + (func $_ZNK5eosio11multi_indexILy14289250228358873088EN6eoswin6statusEJEE3getEyPKc (param $0 i32) (param $1 i64) (param $2 i32) (result i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (block $label$0 + (br_if $label$0 + (i32.eq + (tee_local $7 + (i32.load + (i32.add + (get_local $0) + (i32.const 28) + ) + ) + ) + (tee_local $3 + (i32.load offset=24 + (get_local $0) + ) + ) + ) + ) + (set_local $6 + (i32.add + (get_local $7) + (i32.const -24) + ) + ) + (set_local $4 + (i32.sub + (i32.const 0) + (get_local $3) + ) + ) + (loop $label$1 + (br_if $label$0 + (i64.eq + (i64.load + (i32.load + (get_local $6) + ) + ) + (get_local $1) + ) + ) + (set_local $7 + (get_local $6) + ) + (set_local $6 + (tee_local $5 + (i32.add + (get_local $6) + (i32.const -24) + ) + ) + ) + (br_if $label$1 + (i32.ne + (i32.add + (get_local $5) + (get_local $4) + ) + (i32.const -24) + ) + ) + ) + ) + (block $label$2 + (block $label$3 + (br_if $label$3 + (i32.eq + (get_local $7) + (get_local $3) + ) + ) + (call $eosio_assert + (i32.eq + (i32.load offset=16 + (tee_local $6 + (i32.load + (i32.add + (get_local $7) + (i32.const -24) + ) + ) + ) + ) + (get_local $0) + ) + (i32.const 32) + ) + (br $label$2) + ) + (set_local $6 + (i32.const 0) + ) + (br_if $label$2 + (i32.lt_s + (tee_local $5 + (call $db_find_i64 + (i64.load + (get_local $0) + ) + (i64.load offset=8 + (get_local $0) + ) + (i64.const -4157493845350678528) + (get_local $1) + ) + ) + (i32.const 0) + ) + ) + (call $eosio_assert + (i32.eq + (i32.load offset=16 + (tee_local $6 + (call $_ZNK5eosio11multi_indexILy14289250228358873088EN6eoswin6statusEJEE31load_object_by_primary_iteratorEl + (get_local $0) + (get_local $5) + ) + ) + ) + (get_local $0) + ) + (i32.const 32) + ) + ) + (call $eosio_assert + (i32.ne + (get_local $6) + (i32.const 0) + ) + (get_local $2) + ) + (get_local $6) + ) + (func $_ZNK5eosio11multi_indexILy5382478059301502976ENS_5token6detailEJEE31load_object_by_primary_iteratorEl (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 i64) + (local $6 i32) + (local $7 i32) + (local $8 i32) + (local $9 i32) + (set_local $8 + (tee_local $9 + (i32.sub + (i32.load offset=4 + (i32.const 0) + ) + (i32.const 32) + ) + ) + ) + (i32.store offset=4 + (i32.const 0) + (get_local $9) + ) + (block $label$0 + (br_if $label$0 + (i32.eq + (tee_local $7 + (i32.load + (i32.add + (get_local $0) + (i32.const 28) + ) + ) + ) + (tee_local $2 + (i32.load offset=24 + (get_local $0) + ) + ) + ) + ) + (set_local $3 + (i32.sub + (i32.const 0) + (get_local $2) + ) + ) + (set_local $6 + (i32.add + (get_local $7) + (i32.const -24) + ) + ) + (loop $label$1 + (br_if $label$0 + (i32.eq + (i32.load + (i32.add + (get_local $6) + (i32.const 16) + ) + ) + (get_local $1) + ) + ) + (set_local $7 + (get_local $6) + ) + (set_local $6 + (tee_local $4 + (i32.add + (get_local $6) + (i32.const -24) + ) + ) + ) + (br_if $label$1 + (i32.ne + (i32.add + (get_local $4) + (get_local $3) + ) + (i32.const -24) + ) + ) + ) + ) + (block $label$2 + (block $label$3 + (br_if $label$3 + (i32.eq + (get_local $7) + (get_local $2) + ) + ) + (set_local $6 + (i32.load + (i32.add + (get_local $7) + (i32.const -24) + ) + ) + ) + (br $label$2) + ) + (call $eosio_assert + (i32.xor + (i32.shr_u + (tee_local $4 + (call $db_get_i64 + (get_local $1) + (i32.const 0) + (i32.const 0) + ) + ) + (i32.const 31) + ) + (i32.const 1) + ) + (i32.const 240) + ) + (block $label$4 + (block $label$5 + (br_if $label$5 + (i32.le_u + (get_local $4) + (i32.const 512) + ) + ) + (drop + (call $db_get_i64 + (get_local $1) + (tee_local $7 + (call $malloc + (get_local $4) + ) + ) + (get_local $4) + ) + ) + (call $free + (get_local $7) + ) + (br $label$4) + ) + (i32.store offset=4 + (i32.const 0) + (tee_local $7 + (i32.sub + (get_local $9) + (i32.and + (i32.add + (get_local $4) + (i32.const 15) + ) + (i32.const -16) + ) + ) + ) + ) + (drop + (call $db_get_i64 + (get_local $1) + (get_local $7) + (get_local $4) + ) + ) + ) + (i32.store offset=16 + (tee_local $6 + (call $_Znwj + (i32.const 32) + ) + ) + (get_local $0) + ) + (call $eosio_assert + (i32.gt_u + (get_local $4) + (i32.const 7) + ) + (i32.const 272) + ) + (drop + (call $memcpy + (get_local $6) + (get_local $7) + (i32.const 8) + ) + ) + (call $eosio_assert + (i32.ne + (i32.and + (get_local $4) + (i32.const -8) + ) + (i32.const 8) + ) + (i32.const 272) + ) + (drop + (call $memcpy + (i32.add + (get_local $6) + (i32.const 8) + ) + (i32.add + (get_local $7) + (i32.const 8) + ) + (i32.const 8) + ) + ) + (i32.store offset=20 + (get_local $6) + (get_local $1) + ) + (i32.store offset=24 + (get_local $8) + (get_local $6) + ) + (i64.store offset=16 + (get_local $8) + (tee_local $5 + (i64.load + (get_local $6) + ) + ) + ) + (i32.store offset=12 + (get_local $8) + (tee_local $7 + (i32.load offset=20 + (get_local $6) + ) + ) + ) + (block $label$6 + (block $label$7 + (br_if $label$7 + (i32.ge_u + (tee_local $4 + (i32.load + (tee_local $1 + (i32.add + (get_local $0) + (i32.const 28) + ) + ) + ) + ) + (i32.load + (i32.add + (get_local $0) + (i32.const 32) + ) + ) + ) + ) + (i64.store offset=8 + (get_local $4) + (get_local $5) + ) + (i32.store offset=16 + (get_local $4) + (get_local $7) + ) + (i32.store offset=24 + (get_local $8) + (i32.const 0) + ) + (i32.store + (get_local $4) + (get_local $6) + ) + (i32.store + (get_local $1) + (i32.add + (get_local $4) + (i32.const 24) + ) + ) + (br $label$6) + ) + (call $_ZNSt3__16vectorIN5eosio11multi_indexILy5382478059301502976ENS1_5token6detailEJEE8item_ptrENS_9allocatorIS6_EEE24__emplace_back_slow_pathIJNS_10unique_ptrINS5_4itemENS_14default_deleteISC_EEEERyRlEEEvDpOT_ + (i32.add + (get_local $0) + (i32.const 24) + ) + (i32.add + (get_local $8) + (i32.const 24) + ) + (i32.add + (get_local $8) + (i32.const 16) + ) + (i32.add + (get_local $8) + (i32.const 12) + ) + ) + ) + (set_local $4 + (i32.load offset=24 + (get_local $8) + ) + ) + (i32.store offset=24 + (get_local $8) + (i32.const 0) + ) + (br_if $label$2 + (i32.eqz + (get_local $4) + ) + ) + (call $_ZdlPv + (get_local $4) + ) + ) + (i32.store offset=4 + (i32.const 0) + (i32.add + (get_local $8) + (i32.const 32) + ) + ) + (get_local $6) + ) + (func $_ZN6eoswin7lottery22snapshot_token_balanceEv (param $0 i32) + (local $1 i32) + (local $2 i32) + (local $3 i64) + (local $4 i64) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (local $8 i32) + (local $9 i32) + (local $10 i32) + (local $11 i32) + (local $12 i32) + (local $13 i32) + (local $14 i32) + (local $15 i32) + (local $16 i32) + (local $17 i64) + (local $18 i64) + (local $19 i64) + (local $20 i64) + (local $21 i32) + (local $22 i32) + (i32.store offset=4 + (i32.const 0) + (tee_local $22 + (i32.sub + (i32.load offset=4 + (i32.const 0) + ) + (i32.const 256) + ) + ) + ) + (drop + (call $memcpy + (i32.add + (get_local $22) + (i32.const 32) + ) + (i32.const 3296) + (i32.const 160) + ) + ) + (i32.store offset=28 + (get_local $22) + (i32.const 0) + ) + (set_local $2 + (i32.add + (get_local $0) + (i32.const 352) + ) + ) + (set_local $1 + (i32.add + (get_local $0) + (i32.const 328) + ) + ) + (set_local $8 + (i32.add + (i32.add + (get_local $22) + (i32.const 216) + ) + (i32.const 8) + ) + ) + (set_local $9 + (i32.add + (get_local $22) + (i32.const 232) + ) + ) + (set_local $10 + (i32.add + (i32.add + (get_local $22) + (i32.const 216) + ) + (i32.const 24) + ) + ) + (set_local $11 + (i32.add + (i32.add + (get_local $22) + (i32.const 216) + ) + (i32.const 32) + ) + ) + (set_local $13 + (i32.add + (get_local $0) + (i32.const 356) + ) + ) + (set_local $14 + (i32.add + (get_local $0) + (i32.const 336) + ) + ) + (set_local $15 + (i32.add + (get_local $0) + (i32.const 360) + ) + ) + (set_local $12 + (i32.add + (get_local $22) + (i32.const 244) + ) + ) + (set_local $16 + (i32.const 0) + ) + (loop $label$0 + (set_local $4 + (i64.load offset=8 + (tee_local $16 + (i32.add + (i32.add + (get_local $22) + (i32.const 32) + ) + (i32.shl + (get_local $16) + (i32.const 4) + ) + ) + ) + ) + ) + (set_local $3 + (i64.load + (get_local $16) + ) + ) + (set_local $17 + (i64.const 59) + ) + (set_local $16 + (i32.const 1104) + ) + (set_local $18 + (i64.const 0) + ) + (set_local $19 + (i64.const 0) + ) + (loop $label$1 + (set_local $20 + (i64.const 0) + ) + (block $label$2 + (br_if $label$2 + (i64.gt_u + (get_local $18) + (i64.const 11) + ) + ) + (block $label$3 + (block $label$4 + (br_if $label$4 + (i32.gt_u + (i32.and + (i32.add + (tee_local $5 + (i32.load8_s + (get_local $16) + ) + ) + (i32.const -97) + ) + (i32.const 255) + ) + (i32.const 25) + ) + ) + (set_local $5 + (i32.add + (get_local $5) + (i32.const 165) + ) + ) + (br $label$3) + ) + (set_local $5 + (select + (i32.add + (get_local $5) + (i32.const 208) + ) + (i32.const 0) + (i32.lt_u + (i32.and + (i32.add + (get_local $5) + (i32.const -49) + ) + (i32.const 255) + ) + (i32.const 5) + ) + ) + ) + ) + (set_local $20 + (i64.shl + (i64.extend_u/i32 + (i32.and + (get_local $5) + (i32.const 31) + ) + ) + (i64.and + (get_local $17) + (i64.const 4294967295) + ) + ) + ) + ) + (set_local $16 + (i32.add + (get_local $16) + (i32.const 1) + ) + ) + (set_local $18 + (i64.add + (get_local $18) + (i64.const 1) + ) + ) + (set_local $19 + (i64.or + (get_local $20) + (get_local $19) + ) + ) + (br_if $label$1 + (i64.ne + (tee_local $17 + (i64.add + (get_local $17) + (i64.const -5) + ) + ) + (i64.const -6) + ) + ) + ) + (i64.store + (get_local $8) + (get_local $19) + ) + (i64.store + (get_local $9) + (i64.const -1) + ) + (set_local $17 + (i64.const 0) + ) + (i64.store + (get_local $10) + (i64.const 0) + ) + (i32.store + (get_local $11) + (i32.const 0) + ) + (i64.store offset=216 + (get_local $22) + (get_local $3) + ) + (block $label$5 + (br_if $label$5 + (i32.lt_s + (tee_local $16 + (call $db_find_i64 + (get_local $3) + (get_local $19) + (i64.const 3607749779137757184) + (tee_local $18 + (i64.shr_u + (get_local $4) + (i64.const 8) + ) + ) + ) + ) + (i32.const 0) + ) + ) + (call $eosio_assert + (i32.eq + (i32.load offset=16 + (tee_local $16 + (call $_ZNK5eosio11multi_indexILy3607749779137757184ENS_5token7accountEJEE31load_object_by_primary_iteratorEl + (i32.add + (get_local $22) + (i32.const 216) + ) + (get_local $16) + ) + ) + ) + (i32.add + (get_local $22) + (i32.const 216) + ) + ) + (i32.const 32) + ) + (set_local $17 + (i64.load + (get_local $16) + ) + ) + (br_if $label$5 + (i32.eqz + (tee_local $21 + (i32.load + (get_local $10) + ) + ) + ) + ) + (block $label$6 + (block $label$7 + (br_if $label$7 + (i32.eq + (tee_local $16 + (i32.load + (get_local $12) + ) + ) + (get_local $21) + ) + ) + (loop $label$8 + (set_local $5 + (i32.load + (tee_local $16 + (i32.add + (get_local $16) + (i32.const -24) + ) + ) + ) + ) + (i32.store + (get_local $16) + (i32.const 0) + ) + (block $label$9 + (br_if $label$9 + (i32.eqz + (get_local $5) + ) + ) + (call $_ZdlPv + (get_local $5) + ) + ) + (br_if $label$8 + (i32.ne + (get_local $21) + (get_local $16) + ) + ) + ) + (set_local $16 + (i32.load + (get_local $10) + ) + ) + (br $label$6) + ) + (set_local $16 + (get_local $21) + ) + ) + (i32.store + (get_local $12) + (get_local $21) + ) + (call $_ZdlPv + (get_local $16) + ) + ) + (i64.store offset=16 + (get_local $22) + (get_local $17) + ) + (block $label$10 + (br_if $label$10 + (i32.eq + (tee_local $21 + (i32.load + (get_local $13) + ) + ) + (tee_local $6 + (i32.load + (get_local $2) + ) + ) + ) + ) + (set_local $16 + (i32.add + (get_local $21) + (i32.const -24) + ) + ) + (set_local $7 + (i32.sub + (i32.const 0) + (get_local $6) + ) + ) + (loop $label$11 + (br_if $label$10 + (i64.eq + (i64.shr_u + (i64.load offset=8 + (i32.load + (get_local $16) + ) + ) + (i64.const 8) + ) + (get_local $18) + ) + ) + (set_local $21 + (get_local $16) + ) + (set_local $16 + (tee_local $5 + (i32.add + (get_local $16) + (i32.const -24) + ) + ) + ) + (br_if $label$11 + (i32.ne + (i32.add + (get_local $5) + (get_local $7) + ) + (i32.const -24) + ) + ) + ) + ) + (block $label$12 + (block $label$13 + (block $label$14 + (block $label$15 + (br_if $label$15 + (i32.eq + (get_local $21) + (get_local $6) + ) + ) + (call $eosio_assert + (i32.eq + (i32.load offset=16 + (tee_local $16 + (i32.load + (i32.add + (get_local $21) + (i32.const -24) + ) + ) + ) + ) + (get_local $1) + ) + (i32.const 32) + ) + (br_if $label$14 + (get_local $16) + ) + (br $label$13) + ) + (br_if $label$13 + (i32.lt_s + (tee_local $16 + (call $db_find_i64 + (i64.load + (get_local $1) + ) + (i64.load + (get_local $14) + ) + (i64.const -3665743317141815296) + (get_local $18) + ) + ) + (i32.const 0) + ) + ) + (call $eosio_assert + (i32.eq + (i32.load offset=16 + (tee_local $16 + (call $_ZNK5eosio11multi_indexILy14781000756567736320EN6eoswin10token_itemEJEE31load_object_by_primary_iteratorEl + (get_local $1) + (get_local $16) + ) + ) + ) + (get_local $1) + ) + (i32.const 32) + ) + ) + (i32.store + (get_local $8) + (i32.add + (get_local $22) + (i32.const 28) + ) + ) + (i32.store offset=220 + (get_local $22) + (i32.add + (get_local $22) + (i32.const 32) + ) + ) + (i32.store offset=216 + (get_local $22) + (i32.add + (get_local $22) + (i32.const 16) + ) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 288) + ) + (call $_ZN5eosio11multi_indexILy14781000756567736320EN6eoswin10token_itemEJEE6modifyIZNS1_7lottery22snapshot_token_balanceEvE4$_19EEvRKS2_yOT_ + (get_local $1) + (get_local $16) + (i32.add + (get_local $22) + (i32.const 216) + ) + ) + (br $label$12) + ) + (set_local $18 + (i64.load + (get_local $0) + ) + ) + (i32.store + (i32.add + (get_local $22) + (i32.const 8) + ) + (i32.add + (get_local $22) + (i32.const 28) + ) + ) + (i32.store offset=4 + (get_local $22) + (i32.add + (get_local $22) + (i32.const 32) + ) + ) + (i32.store + (get_local $22) + (i32.add + (get_local $22) + (i32.const 16) + ) + ) + (i64.store offset=208 + (get_local $22) + (get_local $18) + ) + (call $eosio_assert + (i64.eq + (i64.load + (get_local $1) + ) + (call $current_receiver) + ) + (i32.const 336) + ) + (i32.store offset=216 + (get_local $22) + (get_local $1) + ) + (i32.store + (get_local $8) + (i32.add + (get_local $22) + (i32.const 208) + ) + ) + (i32.store offset=220 + (get_local $22) + (get_local $22) + ) + (i64.store offset=8 + (tee_local $5 + (call $_Znwj + (i32.const 32) + ) + ) + (i64.const 1397703940) + ) + (i64.store + (get_local $5) + (i64.const 0) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 176) + ) + (set_local $18 + (i64.const 5459781) + ) + (set_local $16 + (i32.const 0) + ) + (block $label$16 + (block $label$17 + (loop $label$18 + (br_if $label$17 + (i32.gt_u + (i32.add + (i32.shl + (i32.wrap/i64 + (get_local $18) + ) + (i32.const 24) + ) + (i32.const -1073741825) + ) + (i32.const 452984830) + ) + ) + (block $label$19 + (br_if $label$19 + (i64.ne + (i64.and + (tee_local $18 + (i64.shr_u + (get_local $18) + (i64.const 8) + ) + ) + (i64.const 255) + ) + (i64.const 0) + ) + ) + (loop $label$20 + (br_if $label$17 + (i64.ne + (i64.and + (tee_local $18 + (i64.shr_u + (get_local $18) + (i64.const 8) + ) + ) + (i64.const 255) + ) + (i64.const 0) + ) + ) + (br_if $label$20 + (i32.lt_s + (tee_local $16 + (i32.add + (get_local $16) + (i32.const 1) + ) + ) + (i32.const 7) + ) + ) + ) + ) + (set_local $21 + (i32.const 1) + ) + (br_if $label$18 + (i32.lt_s + (tee_local $16 + (i32.add + (get_local $16) + (i32.const 1) + ) + ) + (i32.const 7) + ) + ) + (br $label$16) + ) + ) + (set_local $21 + (i32.const 0) + ) + ) + (call $eosio_assert + (get_local $21) + (i32.const 128) + ) + (i32.store offset=16 + (get_local $5) + (get_local $1) + ) + (call $_ZZN5eosio11multi_indexILy14781000756567736320EN6eoswin10token_itemEJEE7emplaceIZNS1_7lottery22snapshot_token_balanceEvE4$_18EENS3_14const_iteratorEyOT_ENKUlRS8_E_clINS3_4itemEEEDaSA_ + (i32.add + (get_local $22) + (i32.const 216) + ) + (get_local $5) + ) + (i32.store offset=200 + (get_local $22) + (get_local $5) + ) + (i64.store offset=216 + (get_local $22) + (tee_local $18 + (i64.shr_u + (i64.load + (i32.add + (get_local $5) + (i32.const 8) + ) + ) + (i64.const 8) + ) + ) + ) + (i32.store offset=196 + (get_local $22) + (tee_local $21 + (i32.load offset=20 + (get_local $5) + ) + ) + ) + (block $label$21 + (block $label$22 + (br_if $label$22 + (i32.ge_u + (tee_local $16 + (i32.load + (get_local $13) + ) + ) + (i32.load + (get_local $15) + ) + ) + ) + (i64.store offset=8 + (get_local $16) + (get_local $18) + ) + (i32.store offset=16 + (get_local $16) + (get_local $21) + ) + (i32.store offset=200 + (get_local $22) + (i32.const 0) + ) + (i32.store + (get_local $16) + (get_local $5) + ) + (i32.store + (get_local $13) + (i32.add + (get_local $16) + (i32.const 24) + ) + ) + (br $label$21) + ) + (call $_ZNSt3__16vectorIN5eosio11multi_indexILy14781000756567736320EN6eoswin10token_itemEJEE8item_ptrENS_9allocatorIS6_EEE24__emplace_back_slow_pathIJNS_10unique_ptrINS5_4itemENS_14default_deleteISC_EEEERyRlEEEvDpOT_ + (get_local $2) + (i32.add + (get_local $22) + (i32.const 200) + ) + (i32.add + (get_local $22) + (i32.const 216) + ) + (i32.add + (get_local $22) + (i32.const 196) + ) + ) + ) + (set_local $16 + (i32.load offset=200 + (get_local $22) + ) + ) + (i32.store offset=200 + (get_local $22) + (i32.const 0) + ) + (br_if $label$12 + (i32.eqz + (get_local $16) + ) + ) + (call $_ZdlPv + (get_local $16) + ) + ) + (i32.store offset=28 + (get_local $22) + (tee_local $16 + (i32.add + (i32.load offset=28 + (get_local $22) + ) + (i32.const 1) + ) + ) + ) + (br_if $label$0 + (i32.lt_s + (get_local $16) + (i32.const 10) + ) + ) + ) + (i32.store offset=4 + (i32.const 0) + (i32.add + (get_local $22) + (i32.const 256) + ) + ) + ) + (func $_ZNK5eosio11multi_indexILy14289235522390851584ENS_5token13currency_statEJEE3getEyPKc (param $0 i32) (param $1 i64) (param $2 i32) (result i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (block $label$0 + (br_if $label$0 + (i32.eq + (tee_local $7 + (i32.load + (i32.add + (get_local $0) + (i32.const 28) + ) + ) + ) + (tee_local $3 + (i32.load offset=24 + (get_local $0) + ) + ) + ) + ) + (set_local $6 + (i32.add + (get_local $7) + (i32.const -24) + ) + ) + (set_local $4 + (i32.sub + (i32.const 0) + (get_local $3) + ) + ) + (loop $label$1 + (br_if $label$0 + (i64.eq + (i64.shr_u + (i64.load offset=8 + (i32.load + (get_local $6) + ) + ) + (i64.const 8) + ) + (get_local $1) + ) + ) + (set_local $7 + (get_local $6) + ) + (set_local $6 + (tee_local $5 + (i32.add + (get_local $6) + (i32.const -24) + ) + ) + ) + (br_if $label$1 + (i32.ne + (i32.add + (get_local $5) + (get_local $4) + ) + (i32.const -24) + ) + ) + ) + ) + (block $label$2 + (block $label$3 + (br_if $label$3 + (i32.eq + (get_local $7) + (get_local $3) + ) + ) + (call $eosio_assert + (i32.eq + (i32.load offset=40 + (tee_local $6 + (i32.load + (i32.add + (get_local $7) + (i32.const -24) + ) + ) + ) + ) + (get_local $0) + ) + (i32.const 32) + ) + (br $label$2) + ) + (set_local $6 + (i32.const 0) + ) + (br_if $label$2 + (i32.lt_s + (tee_local $5 + (call $db_find_i64 + (i64.load + (get_local $0) + ) + (i64.load offset=8 + (get_local $0) + ) + (i64.const -4157508551318700032) + (get_local $1) + ) + ) + (i32.const 0) + ) + ) + (call $eosio_assert + (i32.eq + (i32.load offset=40 + (tee_local $6 + (call $_ZNK5eosio11multi_indexILy14289235522390851584ENS_5token13currency_statEJEE31load_object_by_primary_iteratorEl + (get_local $0) + (get_local $5) + ) + ) + ) + (get_local $0) + ) + (i32.const 32) + ) + ) + (call $eosio_assert + (i32.ne + (get_local $6) + (i32.const 0) + ) + (get_local $2) + ) + (get_local $6) + ) + (func $_ZN5eosio15dispatch_inlineIJyNS_5assetEyEEEvyyNSt3__16vectorINS_16permission_levelENS2_9allocatorIS4_EEEENS2_5tupleIJDpT_EEE (param $0 i64) (param $1 i64) (param $2 i32) (param $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (local $8 i32) + (local $9 i32) + (i32.store offset=4 + (i32.const 0) + (tee_local $9 + (i32.sub + (i32.load offset=4 + (i32.const 0) + ) + (i32.const 96) + ) + ) + ) + (i32.store offset=16 + (get_local $9) + (i32.const 0) + ) + (i64.store offset=8 + (get_local $9) + (i64.const 0) + ) + (set_local $6 + (i32.const 0) + ) + (set_local $7 + (i32.const 0) + ) + (set_local $8 + (i32.const 0) + ) + (block $label$0 + (block $label$1 + (br_if $label$1 + (i32.eqz + (tee_local $5 + (i32.shr_s + (tee_local $4 + (i32.sub + (i32.load offset=4 + (get_local $2) + ) + (i32.load + (get_local $2) + ) + ) + ) + (i32.const 4) + ) + ) + ) + ) + (br_if $label$0 + (i32.ge_u + (get_local $5) + (i32.const 268435456) + ) + ) + (i32.store + (i32.add + (get_local $9) + (i32.const 16) + ) + (tee_local $6 + (i32.add + (tee_local $8 + (call $_Znwj + (get_local $4) + ) + ) + (i32.shl + (get_local $5) + (i32.const 4) + ) + ) + ) + ) + (i32.store offset=8 + (get_local $9) + (get_local $8) + ) + (i32.store offset=12 + (get_local $9) + (get_local $8) + ) + (block $label$2 + (br_if $label$2 + (i32.lt_s + (tee_local $2 + (i32.sub + (i32.load + (i32.add + (get_local $2) + (i32.const 4) + ) + ) + (tee_local $7 + (i32.load + (get_local $2) + ) + ) + ) + ) + (i32.const 1) + ) + ) + (drop + (call $memcpy + (get_local $8) + (get_local $7) + (get_local $2) + ) + ) + (i32.store offset=12 + (get_local $9) + (tee_local $7 + (i32.add + (get_local $8) + (get_local $2) + ) + ) + ) + (br $label$1) + ) + (set_local $7 + (get_local $8) + ) + ) + (i32.store + (i32.add + (get_local $9) + (i32.const 44) + ) + (get_local $7) + ) + (i64.store offset=32 + (get_local $9) + (get_local $1) + ) + (i32.store + (i32.add + (get_local $9) + (i32.const 16) + ) + (i32.const 0) + ) + (i32.store + (i32.add + (get_local $9) + (i32.const 48) + ) + (get_local $6) + ) + (i64.store offset=24 + (get_local $9) + (get_local $0) + ) + (i32.store offset=40 + (get_local $9) + (get_local $8) + ) + (i64.store offset=8 + (get_local $9) + (i64.const 0) + ) + (i32.store offset=52 + (get_local $9) + (i32.const 0) + ) + (i32.store + (tee_local $8 + (i32.add + (i32.add + (get_local $9) + (i32.const 24) + ) + (i32.const 32) + ) + ) + (i32.const 0) + ) + (i32.store + (i32.add + (get_local $9) + (i32.const 60) + ) + (i32.const 0) + ) + (call $_ZNSt3__16vectorIcNS_9allocatorIcEEE8__appendEj + (i32.add + (get_local $9) + (i32.const 52) + ) + (i32.const 32) + ) + (set_local $8 + (i32.load + (get_local $8) + ) + ) + (i32.store offset=84 + (get_local $9) + (tee_local $2 + (i32.load offset=52 + (get_local $9) + ) + ) + ) + (i32.store offset=80 + (get_local $9) + (get_local $2) + ) + (i32.store offset=88 + (get_local $9) + (get_local $8) + ) + (i32.store offset=64 + (get_local $9) + (i32.add + (get_local $9) + (i32.const 80) + ) + ) + (i32.store offset=72 + (get_local $9) + (get_local $3) + ) + (call $_ZN5boost6fusion6detail17for_each_unrolledILi3EE4callINS0_18std_tuple_iteratorIKNSt3__15tupleIJyN5eosio5assetEyEEELi0EEEZNS8_lsINS8_10datastreamIPcEEJyS9_yEEERT_SI_RKNS7_IJDpT0_EEEEUlRKSH_E_EEvSP_RKT0_ + (i32.add + (get_local $9) + (i32.const 72) + ) + (i32.add + (get_local $9) + (i32.const 64) + ) + ) + (call $_ZN5eosio4packINS_6actionEEENSt3__16vectorIcNS2_9allocatorIcEEEERKT_ + (i32.add + (get_local $9) + (i32.const 80) + ) + (i32.add + (get_local $9) + (i32.const 24) + ) + ) + (call $send_inline + (tee_local $8 + (i32.load offset=80 + (get_local $9) + ) + ) + (i32.sub + (i32.load offset=84 + (get_local $9) + ) + (get_local $8) + ) + ) + (block $label$3 + (br_if $label$3 + (i32.eqz + (tee_local $8 + (i32.load offset=80 + (get_local $9) + ) + ) + ) + ) + (i32.store offset=84 + (get_local $9) + (get_local $8) + ) + (call $_ZdlPv + (get_local $8) + ) + ) + (block $label$4 + (br_if $label$4 + (i32.eqz + (tee_local $8 + (i32.load offset=52 + (get_local $9) + ) + ) + ) + ) + (i32.store + (i32.add + (get_local $9) + (i32.const 56) + ) + (get_local $8) + ) + (call $_ZdlPv + (get_local $8) + ) + ) + (block $label$5 + (br_if $label$5 + (i32.eqz + (tee_local $8 + (i32.load offset=40 + (get_local $9) + ) + ) + ) + ) + (i32.store + (i32.add + (get_local $9) + (i32.const 44) + ) + (get_local $8) + ) + (call $_ZdlPv + (get_local $8) + ) + ) + (block $label$6 + (br_if $label$6 + (i32.eqz + (tee_local $8 + (i32.load offset=8 + (get_local $9) + ) + ) + ) + ) + (i32.store offset=12 + (get_local $9) + (get_local $8) + ) + (call $_ZdlPv + (get_local $8) + ) + ) + (i32.store offset=4 + (i32.const 0) + (i32.add + (get_local $9) + (i32.const 96) + ) + ) + (return) + ) + (call $_ZNKSt3__120__vector_base_commonILb1EE20__throw_length_errorEv + (i32.add + (get_local $9) + (i32.const 8) + ) + ) + (unreachable) + ) + (func $_ZNK5eosio11multi_indexILy5455799419175698432EN6eoswin13dividend_itemEJEE31load_object_by_primary_iteratorEl (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 i64) + (local $6 i32) + (local $7 i32) + (local $8 i32) + (local $9 i32) + (i32.store offset=4 + (i32.const 0) + (tee_local $9 + (i32.sub + (i32.load offset=4 + (i32.const 0) + ) + (i32.const 48) + ) + ) + ) + (i32.store offset=44 + (tee_local $8 + (get_local $9) + ) + (get_local $1) + ) + (block $label$0 + (br_if $label$0 + (i32.eq + (tee_local $7 + (i32.load + (i32.add + (get_local $0) + (i32.const 28) + ) + ) + ) + (tee_local $2 + (i32.load offset=24 + (get_local $0) + ) + ) + ) + ) + (set_local $3 + (i32.sub + (i32.const 0) + (get_local $2) + ) + ) + (set_local $6 + (i32.add + (get_local $7) + (i32.const -24) + ) + ) + (loop $label$1 + (br_if $label$0 + (i32.eq + (i32.load + (i32.add + (get_local $6) + (i32.const 16) + ) + ) + (get_local $1) + ) + ) + (set_local $7 + (get_local $6) + ) + (set_local $6 + (tee_local $4 + (i32.add + (get_local $6) + (i32.const -24) + ) + ) + ) + (br_if $label$1 + (i32.ne + (i32.add + (get_local $4) + (get_local $3) + ) + (i32.const -24) + ) + ) + ) + ) + (block $label$2 + (block $label$3 + (br_if $label$3 + (i32.eq + (get_local $7) + (get_local $2) + ) + ) + (set_local $6 + (i32.load + (i32.add + (get_local $7) + (i32.const -24) + ) + ) + ) + (br $label$2) + ) + (call $eosio_assert + (i32.xor + (i32.shr_u + (tee_local $6 + (call $db_get_i64 + (get_local $1) + (i32.const 0) + (i32.const 0) + ) + ) + (i32.const 31) + ) + (i32.const 1) + ) + (i32.const 240) + ) + (block $label$4 + (block $label$5 + (br_if $label$5 + (i32.lt_u + (get_local $6) + (i32.const 513) + ) + ) + (set_local $4 + (call $malloc + (get_local $6) + ) + ) + (br $label$4) + ) + (i32.store offset=4 + (i32.const 0) + (tee_local $4 + (i32.sub + (get_local $9) + (i32.and + (i32.add + (get_local $6) + (i32.const 15) + ) + (i32.const -16) + ) + ) + ) + ) + ) + (drop + (call $db_get_i64 + (get_local $1) + (get_local $4) + (get_local $6) + ) + ) + (i32.store offset=36 + (get_local $8) + (get_local $4) + ) + (i32.store offset=32 + (get_local $8) + (get_local $4) + ) + (i32.store offset=40 + (get_local $8) + (i32.add + (get_local $4) + (get_local $6) + ) + ) + (block $label$6 + (br_if $label$6 + (i32.lt_u + (get_local $6) + (i32.const 513) + ) + ) + (call $free + (get_local $4) + ) + ) + (i32.store offset=12 + (get_local $8) + (i32.add + (get_local $8) + (i32.const 32) + ) + ) + (i32.store offset=16 + (get_local $8) + (i32.add + (get_local $8) + (i32.const 44) + ) + ) + (i32.store offset=8 + (get_local $8) + (get_local $0) + ) + (set_local $6 + (call $_ZN5eosio11multi_indexILy5455799419175698432EN6eoswin13dividend_itemEJEE4itemC2IZNKS3_31load_object_by_primary_iteratorElEUlRT_E_EEPKS3_OS6_ + (tee_local $4 + (call $_Znwj + (i32.const 56) + ) + ) + (get_local $0) + (i32.add + (get_local $8) + (i32.const 8) + ) + ) + ) + (i32.store offset=24 + (get_local $8) + (get_local $4) + ) + (i64.store offset=8 + (get_local $8) + (tee_local $5 + (i64.load + (get_local $4) + ) + ) + ) + (i32.store offset=4 + (get_local $8) + (tee_local $1 + (i32.load offset=44 + (get_local $4) + ) + ) + ) + (block $label$7 + (block $label$8 + (br_if $label$8 + (i32.ge_u + (tee_local $7 + (i32.load + (tee_local $3 + (i32.add + (get_local $0) + (i32.const 28) + ) + ) + ) + ) + (i32.load + (i32.add + (get_local $0) + (i32.const 32) + ) + ) + ) + ) + (i64.store offset=8 + (get_local $7) + (get_local $5) + ) + (i32.store offset=16 + (get_local $7) + (get_local $1) + ) + (i32.store offset=24 + (get_local $8) + (i32.const 0) + ) + (i32.store + (get_local $7) + (get_local $4) + ) + (i32.store + (get_local $3) + (i32.add + (get_local $7) + (i32.const 24) + ) + ) + (br $label$7) + ) + (call $_ZNSt3__16vectorIN5eosio11multi_indexILy5455799419175698432EN6eoswin13dividend_itemEJEE8item_ptrENS_9allocatorIS6_EEE24__emplace_back_slow_pathIJNS_10unique_ptrINS5_4itemENS_14default_deleteISC_EEEERyRlEEEvDpOT_ + (i32.add + (get_local $0) + (i32.const 24) + ) + (i32.add + (get_local $8) + (i32.const 24) + ) + (i32.add + (get_local $8) + (i32.const 8) + ) + (i32.add + (get_local $8) + (i32.const 4) + ) + ) + ) + (set_local $4 + (i32.load offset=24 + (get_local $8) + ) + ) + (i32.store offset=24 + (get_local $8) + (i32.const 0) + ) + (br_if $label$2 + (i32.eqz + (get_local $4) + ) + ) + (block $label$9 + (br_if $label$9 + (i32.eqz + (tee_local $7 + (i32.load offset=16 + (get_local $4) + ) + ) + ) + ) + (i32.store + (i32.add + (get_local $4) + (i32.const 20) + ) + (get_local $7) + ) + (call $_ZdlPv + (get_local $7) + ) + ) + (call $_ZdlPv + (get_local $4) + ) + ) + (i32.store offset=4 + (i32.const 0) + (i32.add + (get_local $8) + (i32.const 48) + ) + ) + (get_local $6) + ) + (func $_ZN5eosio11multi_indexILy5455799419175698432EN6eoswin13dividend_itemEJEE5eraseERKS2_ (param $0 i32) (param $1 i32) + (local $2 i64) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (local $8 i32) + (call $eosio_assert + (i32.eq + (i32.load offset=40 + (get_local $1) + ) + (get_local $0) + ) + (i32.const 2640) + ) + (call $eosio_assert + (i64.eq + (i64.load + (get_local $0) + ) + (call $current_receiver) + ) + (i32.const 2688) + ) + (block $label$0 + (br_if $label$0 + (i32.eq + (tee_local $7 + (i32.load + (tee_local $5 + (i32.add + (get_local $0) + (i32.const 28) + ) + ) + ) + ) + (tee_local $3 + (i32.load offset=24 + (get_local $0) + ) + ) + ) + ) + (set_local $2 + (i64.load + (get_local $1) + ) + ) + (set_local $6 + (i32.sub + (i32.const 0) + (get_local $3) + ) + ) + (set_local $8 + (i32.add + (get_local $7) + (i32.const -24) + ) + ) + (loop $label$1 + (br_if $label$0 + (i64.eq + (i64.load + (i32.load + (get_local $8) + ) + ) + (get_local $2) + ) + ) + (set_local $7 + (get_local $8) + ) + (set_local $8 + (tee_local $4 + (i32.add + (get_local $8) + (i32.const -24) + ) + ) + ) + (br_if $label$1 + (i32.ne + (i32.add + (get_local $4) + (get_local $6) + ) + (i32.const -24) + ) + ) + ) + ) + (call $eosio_assert + (i32.ne + (get_local $7) + (get_local $3) + ) + (i32.const 2752) + ) + (set_local $8 + (i32.add + (get_local $7) + (i32.const -24) + ) + ) + (block $label$2 + (block $label$3 + (br_if $label$3 + (i32.eq + (get_local $7) + (tee_local $4 + (i32.load + (get_local $5) + ) + ) + ) + ) + (set_local $3 + (i32.sub + (i32.const 0) + (get_local $4) + ) + ) + (set_local $7 + (get_local $8) + ) + (loop $label$4 + (set_local $6 + (i32.load + (tee_local $8 + (i32.add + (get_local $7) + (i32.const 24) + ) + ) + ) + ) + (i32.store + (get_local $8) + (i32.const 0) + ) + (set_local $4 + (i32.load + (get_local $7) + ) + ) + (i32.store + (get_local $7) + (get_local $6) + ) + (block $label$5 + (br_if $label$5 + (i32.eqz + (get_local $4) + ) + ) + (block $label$6 + (br_if $label$6 + (i32.eqz + (tee_local $6 + (i32.load offset=16 + (get_local $4) + ) + ) + ) + ) + (i32.store + (i32.add + (get_local $4) + (i32.const 20) + ) + (get_local $6) + ) + (call $_ZdlPv + (get_local $6) + ) + ) + (call $_ZdlPv + (get_local $4) + ) + ) + (i32.store + (i32.add + (get_local $7) + (i32.const 16) + ) + (i32.load + (i32.add + (get_local $7) + (i32.const 40) + ) + ) + ) + (i64.store + (i32.add + (get_local $7) + (i32.const 8) + ) + (i64.load + (i32.add + (get_local $7) + (i32.const 32) + ) + ) + ) + (set_local $7 + (get_local $8) + ) + (br_if $label$4 + (i32.ne + (i32.add + (get_local $8) + (get_local $3) + ) + (i32.const -24) + ) + ) + ) + (br_if $label$2 + (i32.eq + (tee_local $7 + (i32.load + (i32.add + (get_local $0) + (i32.const 28) + ) + ) + ) + (get_local $8) + ) + ) + ) + (loop $label$7 + (set_local $4 + (i32.load + (tee_local $7 + (i32.add + (get_local $7) + (i32.const -24) + ) + ) + ) + ) + (i32.store + (get_local $7) + (i32.const 0) + ) + (block $label$8 + (br_if $label$8 + (i32.eqz + (get_local $4) + ) + ) + (block $label$9 + (br_if $label$9 + (i32.eqz + (tee_local $6 + (i32.load offset=16 + (get_local $4) + ) + ) + ) + ) + (i32.store + (i32.add + (get_local $4) + (i32.const 20) + ) + (get_local $6) + ) + (call $_ZdlPv + (get_local $6) + ) + ) + (call $_ZdlPv + (get_local $4) + ) + ) + (br_if $label$7 + (i32.ne + (get_local $8) + (get_local $7) + ) + ) + ) + ) + (i32.store + (i32.add + (get_local $0) + (i32.const 28) + ) + (get_local $8) + ) + (call $db_remove_i64 + (i32.load offset=44 + (get_local $1) + ) + ) + ) + (func $_ZZN5eosio11multi_indexILy5455799419175698432EN6eoswin13dividend_itemEJEE7emplaceIZNS1_7lottery10claimbonusEyyE4$_16EENS3_14const_iteratorEyOT_ENKUlRS8_E_clINS3_4itemEEEDaSA_ (param $0 i32) (param $1 i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (local $8 i32) + (local $9 i32) + (local $10 i64) + (local $11 i32) + (local $12 i32) + (set_local $12 + (tee_local $11 + (i32.sub + (i32.load offset=4 + (i32.const 0) + ) + (i32.const 16) + ) + ) + ) + (i32.store offset=4 + (i32.const 0) + (get_local $11) + ) + (i64.store + (get_local $1) + (i64.load + (i32.load + (tee_local $9 + (i32.load offset=4 + (get_local $0) + ) + ) + ) + ) + ) + (i64.store offset=8 + (get_local $1) + (i64.load + (i32.load offset=4 + (get_local $9) + ) + ) + ) + (set_local $2 + (i32.load + (get_local $0) + ) + ) + (i64.store offset=32 + (get_local $1) + (i64.load + (i32.load offset=8 + (get_local $9) + ) + ) + ) + (block $label$0 + (br_if $label$0 + (i64.lt_s + (i64.load + (tee_local $7 + (i32.load offset=12 + (get_local $9) + ) + ) + ) + (i64.const 1) + ) + ) + (block $label$1 + (br_if $label$1 + (i32.eq + (tee_local $3 + (i32.load + (tee_local $4 + (i32.add + (get_local $1) + (i32.const 20) + ) + ) + ) + ) + (i32.load + (i32.add + (get_local $1) + (i32.const 24) + ) + ) + ) + ) + (i64.store + (get_local $3) + (i64.load + (get_local $7) + ) + ) + (i64.store + (i32.add + (get_local $3) + (i32.const 8) + ) + (i64.load + (i32.add + (get_local $7) + (i32.const 8) + ) + ) + ) + (i32.store + (get_local $4) + (i32.add + (i32.load + (get_local $4) + ) + (i32.const 16) + ) + ) + (br $label$0) + ) + (call $_ZNSt3__16vectorIN5eosio5assetENS_9allocatorIS2_EEE21__push_back_slow_pathIRKS2_EEvOT_ + (i32.add + (get_local $1) + (i32.const 16) + ) + (get_local $7) + ) + ) + (block $label$2 + (br_if $label$2 + (i64.lt_s + (i64.load + (tee_local $7 + (i32.load offset=16 + (get_local $9) + ) + ) + ) + (i64.const 1) + ) + ) + (block $label$3 + (br_if $label$3 + (i32.eq + (tee_local $3 + (i32.load + (tee_local $4 + (i32.add + (get_local $1) + (i32.const 20) + ) + ) + ) + ) + (i32.load + (i32.add + (get_local $1) + (i32.const 24) + ) + ) + ) + ) + (i64.store + (get_local $3) + (i64.load + (get_local $7) + ) + ) + (i64.store + (i32.add + (get_local $3) + (i32.const 8) + ) + (i64.load + (i32.add + (get_local $7) + (i32.const 8) + ) + ) + ) + (i32.store + (get_local $4) + (i32.add + (i32.load + (get_local $4) + ) + (i32.const 16) + ) + ) + (br $label$2) + ) + (call $_ZNSt3__16vectorIN5eosio5assetENS_9allocatorIS2_EEE21__push_back_slow_pathIRKS2_EEvOT_ + (i32.add + (get_local $1) + (i32.const 16) + ) + (get_local $7) + ) + ) + (block $label$4 + (br_if $label$4 + (i64.lt_s + (i64.load + (tee_local $7 + (i32.load offset=20 + (get_local $9) + ) + ) + ) + (i64.const 1) + ) + ) + (block $label$5 + (br_if $label$5 + (i32.eq + (tee_local $3 + (i32.load + (tee_local $4 + (i32.add + (get_local $1) + (i32.const 20) + ) + ) + ) + ) + (i32.load + (i32.add + (get_local $1) + (i32.const 24) + ) + ) + ) + ) + (i64.store + (get_local $3) + (i64.load + (get_local $7) + ) + ) + (i64.store + (i32.add + (get_local $3) + (i32.const 8) + ) + (i64.load + (i32.add + (get_local $7) + (i32.const 8) + ) + ) + ) + (i32.store + (get_local $4) + (i32.add + (i32.load + (get_local $4) + ) + (i32.const 16) + ) + ) + (br $label$4) + ) + (call $_ZNSt3__16vectorIN5eosio5assetENS_9allocatorIS2_EEE21__push_back_slow_pathIRKS2_EEvOT_ + (i32.add + (get_local $1) + (i32.const 16) + ) + (get_local $7) + ) + ) + (block $label$6 + (br_if $label$6 + (i64.lt_s + (i64.load + (tee_local $7 + (i32.load offset=24 + (get_local $9) + ) + ) + ) + (i64.const 1) + ) + ) + (block $label$7 + (br_if $label$7 + (i32.eq + (tee_local $3 + (i32.load + (tee_local $4 + (i32.add + (get_local $1) + (i32.const 20) + ) + ) + ) + ) + (i32.load + (i32.add + (get_local $1) + (i32.const 24) + ) + ) + ) + ) + (i64.store + (get_local $3) + (i64.load + (get_local $7) + ) + ) + (i64.store + (i32.add + (get_local $3) + (i32.const 8) + ) + (i64.load + (i32.add + (get_local $7) + (i32.const 8) + ) + ) + ) + (i32.store + (get_local $4) + (i32.add + (i32.load + (get_local $4) + ) + (i32.const 16) + ) + ) + (br $label$6) + ) + (call $_ZNSt3__16vectorIN5eosio5assetENS_9allocatorIS2_EEE21__push_back_slow_pathIRKS2_EEvOT_ + (i32.add + (get_local $1) + (i32.const 16) + ) + (get_local $7) + ) + ) + (block $label$8 + (br_if $label$8 + (i64.lt_s + (i64.load + (tee_local $7 + (i32.load offset=28 + (get_local $9) + ) + ) + ) + (i64.const 1) + ) + ) + (block $label$9 + (br_if $label$9 + (i32.eq + (tee_local $3 + (i32.load + (tee_local $4 + (i32.add + (get_local $1) + (i32.const 20) + ) + ) + ) + ) + (i32.load + (i32.add + (get_local $1) + (i32.const 24) + ) + ) + ) + ) + (i64.store + (get_local $3) + (i64.load + (get_local $7) + ) + ) + (i64.store + (i32.add + (get_local $3) + (i32.const 8) + ) + (i64.load + (i32.add + (get_local $7) + (i32.const 8) + ) + ) + ) + (i32.store + (get_local $4) + (i32.add + (i32.load + (get_local $4) + ) + (i32.const 16) + ) + ) + (br $label$8) + ) + (call $_ZNSt3__16vectorIN5eosio5assetENS_9allocatorIS2_EEE21__push_back_slow_pathIRKS2_EEvOT_ + (i32.add + (get_local $1) + (i32.const 16) + ) + (get_local $7) + ) + ) + (block $label$10 + (br_if $label$10 + (i64.lt_s + (i64.load + (tee_local $7 + (i32.load offset=32 + (get_local $9) + ) + ) + ) + (i64.const 1) + ) + ) + (block $label$11 + (br_if $label$11 + (i32.eq + (tee_local $3 + (i32.load + (tee_local $4 + (i32.add + (get_local $1) + (i32.const 20) + ) + ) + ) + ) + (i32.load + (i32.add + (get_local $1) + (i32.const 24) + ) + ) + ) + ) + (i64.store + (get_local $3) + (i64.load + (get_local $7) + ) + ) + (i64.store + (i32.add + (get_local $3) + (i32.const 8) + ) + (i64.load + (i32.add + (get_local $7) + (i32.const 8) + ) + ) + ) + (i32.store + (get_local $4) + (i32.add + (i32.load + (get_local $4) + ) + (i32.const 16) + ) + ) + (br $label$10) + ) + (call $_ZNSt3__16vectorIN5eosio5assetENS_9allocatorIS2_EEE21__push_back_slow_pathIRKS2_EEvOT_ + (i32.add + (get_local $1) + (i32.const 16) + ) + (get_local $7) + ) + ) + (block $label$12 + (br_if $label$12 + (i64.lt_s + (i64.load + (tee_local $7 + (i32.load offset=36 + (get_local $9) + ) + ) + ) + (i64.const 1) + ) + ) + (block $label$13 + (br_if $label$13 + (i32.eq + (tee_local $3 + (i32.load + (tee_local $4 + (i32.add + (get_local $1) + (i32.const 20) + ) + ) + ) + ) + (i32.load + (i32.add + (get_local $1) + (i32.const 24) + ) + ) + ) + ) + (i64.store + (get_local $3) + (i64.load + (get_local $7) + ) + ) + (i64.store + (i32.add + (get_local $3) + (i32.const 8) + ) + (i64.load + (i32.add + (get_local $7) + (i32.const 8) + ) + ) + ) + (i32.store + (get_local $4) + (i32.add + (i32.load + (get_local $4) + ) + (i32.const 16) + ) + ) + (br $label$12) + ) + (call $_ZNSt3__16vectorIN5eosio5assetENS_9allocatorIS2_EEE21__push_back_slow_pathIRKS2_EEvOT_ + (i32.add + (get_local $1) + (i32.const 16) + ) + (get_local $7) + ) + ) + (block $label$14 + (br_if $label$14 + (i64.lt_s + (i64.load + (tee_local $7 + (i32.load offset=40 + (get_local $9) + ) + ) + ) + (i64.const 1) + ) + ) + (block $label$15 + (br_if $label$15 + (i32.eq + (tee_local $3 + (i32.load + (tee_local $4 + (i32.add + (get_local $1) + (i32.const 20) + ) + ) + ) + ) + (i32.load + (i32.add + (get_local $1) + (i32.const 24) + ) + ) + ) + ) + (i64.store + (get_local $3) + (i64.load + (get_local $7) + ) + ) + (i64.store + (i32.add + (get_local $3) + (i32.const 8) + ) + (i64.load + (i32.add + (get_local $7) + (i32.const 8) + ) + ) + ) + (i32.store + (get_local $4) + (i32.add + (i32.load + (get_local $4) + ) + (i32.const 16) + ) + ) + (br $label$14) + ) + (call $_ZNSt3__16vectorIN5eosio5assetENS_9allocatorIS2_EEE21__push_back_slow_pathIRKS2_EEvOT_ + (i32.add + (get_local $1) + (i32.const 16) + ) + (get_local $7) + ) + ) + (block $label$16 + (br_if $label$16 + (i64.lt_s + (i64.load + (tee_local $7 + (i32.load offset=44 + (get_local $9) + ) + ) + ) + (i64.const 1) + ) + ) + (block $label$17 + (br_if $label$17 + (i32.eq + (tee_local $3 + (i32.load + (tee_local $4 + (i32.add + (get_local $1) + (i32.const 20) + ) + ) + ) + ) + (i32.load + (i32.add + (get_local $1) + (i32.const 24) + ) + ) + ) + ) + (i64.store + (get_local $3) + (i64.load + (get_local $7) + ) + ) + (i64.store + (i32.add + (get_local $3) + (i32.const 8) + ) + (i64.load + (i32.add + (get_local $7) + (i32.const 8) + ) + ) + ) + (i32.store + (get_local $4) + (i32.add + (i32.load + (get_local $4) + ) + (i32.const 16) + ) + ) + (br $label$16) + ) + (call $_ZNSt3__16vectorIN5eosio5assetENS_9allocatorIS2_EEE21__push_back_slow_pathIRKS2_EEvOT_ + (i32.add + (get_local $1) + (i32.const 16) + ) + (get_local $7) + ) + ) + (block $label$18 + (br_if $label$18 + (i64.lt_s + (i64.load + (tee_local $9 + (i32.load offset=48 + (get_local $9) + ) + ) + ) + (i64.const 1) + ) + ) + (block $label$19 + (br_if $label$19 + (i32.eq + (tee_local $4 + (i32.load + (tee_local $7 + (i32.add + (get_local $1) + (i32.const 20) + ) + ) + ) + ) + (i32.load + (i32.add + (get_local $1) + (i32.const 24) + ) + ) + ) + ) + (i64.store + (get_local $4) + (i64.load + (get_local $9) + ) + ) + (i64.store + (i32.add + (get_local $4) + (i32.const 8) + ) + (i64.load + (i32.add + (get_local $9) + (i32.const 8) + ) + ) + ) + (i32.store + (get_local $7) + (i32.add + (i32.load + (get_local $7) + ) + (i32.const 16) + ) + ) + (br $label$18) + ) + (call $_ZNSt3__16vectorIN5eosio5assetENS_9allocatorIS2_EEE21__push_back_slow_pathIRKS2_EEvOT_ + (i32.add + (get_local $1) + (i32.const 16) + ) + (get_local $9) + ) + ) + (set_local $4 + (i32.add + (get_local $1) + (i32.const 32) + ) + ) + (set_local $3 + (i32.add + (get_local $1) + (i32.const 8) + ) + ) + (set_local $9 + (i32.const 16) + ) + (set_local $5 + (i32.add + (get_local $1) + (i32.const 16) + ) + ) + (set_local $10 + (i64.extend_u/i32 + (i32.shr_s + (tee_local $8 + (i32.sub + (tee_local $7 + (i32.load + (i32.add + (get_local $1) + (i32.const 20) + ) + ) + ) + (tee_local $6 + (i32.load offset=16 + (get_local $1) + ) + ) + ) + ) + (i32.const 4) + ) + ) + ) + (loop $label$20 + (set_local $9 + (i32.add + (get_local $9) + (i32.const 1) + ) + ) + (br_if $label$20 + (i64.ne + (tee_local $10 + (i64.shr_u + (get_local $10) + (i64.const 7) + ) + ) + (i64.const 0) + ) + ) + ) + (block $label$21 + (br_if $label$21 + (i32.eq + (get_local $6) + (get_local $7) + ) + ) + (set_local $9 + (i32.add + (i32.and + (get_local $8) + (i32.const -16) + ) + (get_local $9) + ) + ) + ) + (block $label$22 + (block $label$23 + (br_if $label$23 + (i32.lt_u + (tee_local $7 + (i32.add + (get_local $9) + (i32.const 8) + ) + ) + (i32.const 513) + ) + ) + (set_local $11 + (call $malloc + (get_local $7) + ) + ) + (br $label$22) + ) + (i32.store offset=4 + (i32.const 0) + (tee_local $11 + (i32.sub + (get_local $11) + (i32.and + (i32.add + (get_local $7) + (i32.const 15) + ) + (i32.const -16) + ) + ) + ) + ) + ) + (i32.store + (get_local $12) + (get_local $11) + ) + (i32.store offset=8 + (get_local $12) + (tee_local $6 + (i32.add + (get_local $11) + (get_local $7) + ) + ) + ) + (call $eosio_assert + (i32.gt_s + (i32.add + (get_local $9) + (i32.const 8) + ) + (i32.const 7) + ) + (i32.const 400) + ) + (drop + (call $memcpy + (get_local $11) + (get_local $1) + (i32.const 8) + ) + ) + (call $eosio_assert + (i32.gt_s + (i32.sub + (get_local $6) + (tee_local $9 + (i32.add + (get_local $11) + (i32.const 8) + ) + ) + ) + (i32.const 7) + ) + (i32.const 400) + ) + (drop + (call $memcpy + (get_local $9) + (get_local $3) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $12) + (i32.add + (get_local $11) + (i32.const 16) + ) + ) + (call $eosio_assert + (i32.gt_s + (i32.sub + (i32.load offset=8 + (tee_local $9 + (call $_ZN5eosiolsINS_10datastreamIPcEENS_5assetEEERT_S6_RKNSt3__16vectorIT0_NS7_9allocatorIS9_EEEE + (get_local $12) + (get_local $5) + ) + ) + ) + (i32.load offset=4 + (get_local $9) + ) + ) + (i32.const 7) + ) + (i32.const 400) + ) + (drop + (call $memcpy + (i32.load offset=4 + (get_local $9) + ) + (get_local $4) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $9) + (i32.add + (i32.load offset=4 + (get_local $9) + ) + (i32.const 8) + ) + ) + (i32.store offset=44 + (get_local $1) + (call $db_store_i64 + (i64.load offset=8 + (get_local $2) + ) + (i64.const 5455799419175698432) + (i64.load + (i32.load offset=8 + (get_local $0) + ) + ) + (tee_local $10 + (i64.load + (get_local $1) + ) + ) + (get_local $11) + (get_local $7) + ) + ) + (block $label$24 + (br_if $label$24 + (i32.lt_u + (get_local $7) + (i32.const 513) + ) + ) + (call $free + (get_local $11) + ) + ) + (block $label$25 + (br_if $label$25 + (i64.lt_u + (get_local $10) + (i64.load offset=16 + (get_local $2) + ) + ) + ) + (i64.store + (i32.add + (get_local $2) + (i32.const 16) + ) + (select + (i64.const -2) + (i64.add + (get_local $10) + (i64.const 1) + ) + (i64.gt_u + (get_local $10) + (i64.const -3) + ) + ) + ) + ) + (i32.store offset=4 + (i32.const 0) + (i32.add + (get_local $12) + (i32.const 16) + ) + ) + ) + (func $_ZNSt3__16vectorIN5eosio11multi_indexILy5455799419175698432EN6eoswin13dividend_itemEJEE8item_ptrENS_9allocatorIS6_EEE24__emplace_back_slow_pathIJNS_10unique_ptrINS5_4itemENS_14default_deleteISC_EEEERyRlEEEvDpOT_ (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (block $label$0 + (block $label$1 + (br_if $label$1 + (i32.ge_u + (tee_local $5 + (i32.add + (tee_local $4 + (i32.div_s + (i32.sub + (i32.load offset=4 + (get_local $0) + ) + (tee_local $6 + (i32.load + (get_local $0) + ) + ) + ) + (i32.const 24) + ) + ) + (i32.const 1) + ) + ) + (i32.const 178956971) + ) + ) + (set_local $7 + (i32.const 178956970) + ) + (block $label$2 + (block $label$3 + (br_if $label$3 + (i32.gt_u + (tee_local $6 + (i32.div_s + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (get_local $6) + ) + (i32.const 24) + ) + ) + (i32.const 89478484) + ) + ) + (br_if $label$2 + (i32.eqz + (tee_local $7 + (select + (get_local $5) + (tee_local $7 + (i32.shl + (get_local $6) + (i32.const 1) + ) + ) + (i32.lt_u + (get_local $7) + (get_local $5) + ) + ) + ) + ) + ) + ) + (set_local $6 + (call $_Znwj + (i32.mul + (get_local $7) + (i32.const 24) + ) + ) + ) + (br $label$0) + ) + (set_local $7 + (i32.const 0) + ) + (set_local $6 + (i32.const 0) + ) + (br $label$0) + ) + (call $_ZNKSt3__120__vector_base_commonILb1EE20__throw_length_errorEv + (get_local $0) + ) + (unreachable) + ) + (set_local $5 + (i32.load + (get_local $1) + ) + ) + (i32.store + (get_local $1) + (i32.const 0) + ) + (i32.store + (tee_local $1 + (i32.add + (get_local $6) + (i32.mul + (get_local $4) + (i32.const 24) + ) + ) + ) + (get_local $5) + ) + (i64.store offset=8 + (get_local $1) + (i64.load + (get_local $2) + ) + ) + (i32.store offset=16 + (get_local $1) + (i32.load + (get_local $3) + ) + ) + (set_local $4 + (i32.add + (get_local $6) + (i32.mul + (get_local $7) + (i32.const 24) + ) + ) + ) + (set_local $5 + (i32.add + (get_local $1) + (i32.const 24) + ) + ) + (block $label$4 + (block $label$5 + (br_if $label$5 + (i32.eq + (tee_local $6 + (i32.load + (i32.add + (get_local $0) + (i32.const 4) + ) + ) + ) + (tee_local $7 + (i32.load + (get_local $0) + ) + ) + ) + ) + (loop $label$6 + (set_local $3 + (i32.load + (tee_local $2 + (i32.add + (get_local $6) + (i32.const -24) + ) + ) + ) + ) + (i32.store + (get_local $2) + (i32.const 0) + ) + (i32.store + (i32.add + (get_local $1) + (i32.const -24) + ) + (get_local $3) + ) + (i32.store + (i32.add + (get_local $1) + (i32.const -8) + ) + (i32.load + (i32.add + (get_local $6) + (i32.const -8) + ) + ) + ) + (i32.store + (i32.add + (get_local $1) + (i32.const -12) + ) + (i32.load + (i32.add + (get_local $6) + (i32.const -12) + ) + ) + ) + (i32.store + (i32.add + (get_local $1) + (i32.const -16) + ) + (i32.load + (i32.add + (get_local $6) + (i32.const -16) + ) + ) + ) + (set_local $1 + (i32.add + (get_local $1) + (i32.const -24) + ) + ) + (set_local $6 + (get_local $2) + ) + (br_if $label$6 + (i32.ne + (get_local $7) + (get_local $2) + ) + ) + ) + (set_local $7 + (i32.load + (i32.add + (get_local $0) + (i32.const 4) + ) + ) + ) + (set_local $2 + (i32.load + (get_local $0) + ) + ) + (br $label$4) + ) + (set_local $2 + (get_local $7) + ) + ) + (i32.store + (get_local $0) + (get_local $1) + ) + (i32.store + (i32.add + (get_local $0) + (i32.const 4) + ) + (get_local $5) + ) + (i32.store + (i32.add + (get_local $0) + (i32.const 8) + ) + (get_local $4) + ) + (block $label$7 + (br_if $label$7 + (i32.eq + (get_local $7) + (get_local $2) + ) + ) + (loop $label$8 + (set_local $1 + (i32.load + (tee_local $7 + (i32.add + (get_local $7) + (i32.const -24) + ) + ) + ) + ) + (i32.store + (get_local $7) + (i32.const 0) + ) + (block $label$9 + (br_if $label$9 + (i32.eqz + (get_local $1) + ) + ) + (block $label$10 + (br_if $label$10 + (i32.eqz + (tee_local $6 + (i32.load offset=16 + (get_local $1) + ) + ) + ) + ) + (i32.store + (i32.add + (get_local $1) + (i32.const 20) + ) + (get_local $6) + ) + (call $_ZdlPv + (get_local $6) + ) + ) + (call $_ZdlPv + (get_local $1) + ) + ) + (br_if $label$8 + (i32.ne + (get_local $2) + (get_local $7) + ) + ) + ) + ) + (block $label$11 + (br_if $label$11 + (i32.eqz + (get_local $2) + ) + ) + (call $_ZdlPv + (get_local $2) + ) + ) + ) + (func $_ZN6eoswin7lottery12divide_tokenEyyyd (param $0 i32) (param $1 i32) (param $2 i64) (param $3 i64) (param $4 i64) (param $5 f64) + (local $6 i32) + (local $7 i32) + (local $8 i32) + (local $9 i64) + (local $10 i32) + (local $11 i32) + (local $12 i64) + (local $13 i64) + (local $14 i64) + (local $15 i64) + (local $16 i64) + (local $17 i64) + (local $18 i32) + (i32.store offset=4 + (i32.const 0) + (tee_local $18 + (i32.sub + (i32.load offset=4 + (i32.const 0) + ) + (i32.const 112) + ) + ) + ) + (block $label$0 + (br_if $label$0 + (i32.eq + (tee_local $11 + (i32.load + (i32.add + (get_local $1) + (i32.const 276) + ) + ) + ) + (tee_local $6 + (i32.load + (i32.add + (get_local $1) + (i32.const 272) + ) + ) + ) + ) + ) + (set_local $10 + (i32.add + (get_local $11) + (i32.const -24) + ) + ) + (set_local $7 + (i32.sub + (i32.const 0) + (get_local $6) + ) + ) + (loop $label$1 + (br_if $label$0 + (i64.eq + (i64.load + (i32.load + (get_local $10) + ) + ) + (i64.const 103) + ) + ) + (set_local $11 + (get_local $10) + ) + (set_local $10 + (tee_local $8 + (i32.add + (get_local $10) + (i32.const -24) + ) + ) + ) + (br_if $label$1 + (i32.ne + (i32.add + (get_local $8) + (get_local $7) + ) + (i32.const -24) + ) + ) + ) + ) + (set_local $10 + (i32.add + (get_local $1) + (i32.const 248) + ) + ) + (block $label$2 + (block $label$3 + (br_if $label$3 + (i32.eq + (get_local $11) + (get_local $6) + ) + ) + (call $eosio_assert + (i32.eq + (i32.load offset=16 + (tee_local $8 + (i32.load + (i32.add + (get_local $11) + (i32.const -24) + ) + ) + ) + ) + (get_local $10) + ) + (i32.const 32) + ) + (br $label$2) + ) + (set_local $8 + (i32.const 0) + ) + (br_if $label$2 + (i32.lt_s + (tee_local $11 + (call $db_find_i64 + (i64.load + (i32.add + (get_local $1) + (i32.const 248) + ) + ) + (i64.load + (i32.add + (get_local $1) + (i32.const 256) + ) + ) + (i64.const -4157493845350678528) + (i64.const 103) + ) + ) + (i32.const 0) + ) + ) + (call $eosio_assert + (i32.eq + (i32.load offset=16 + (tee_local $8 + (call $_ZNK5eosio11multi_indexILy14289250228358873088EN6eoswin6statusEJEE31load_object_by_primary_iteratorEl + (get_local $10) + (get_local $11) + ) + ) + ) + (get_local $10) + ) + (i32.const 32) + ) + ) + (block $label$4 + (block $label$5 + (block $label$6 + (block $label$7 + (block $label$8 + (block $label$9 + (block $label$10 + (block $label$11 + (block $label$12 + (block $label$13 + (block $label$14 + (br_if $label$14 + (i64.eq + (get_local $4) + (i64.const 1397703940) + ) + ) + (br_if $label$13 + (i32.eqz + (get_local $8) + ) + ) + (br_if $label$13 + (i64.ne + (i64.load offset=8 + (get_local $8) + ) + (i64.const 1) + ) + ) + ) + (set_local $12 + (i64.shr_u + (get_local $4) + (i64.const 8) + ) + ) + (block $label$15 + (br_if $label$15 + (i32.eq + (tee_local $11 + (i32.load + (i32.add + (get_local $1) + (i32.const 356) + ) + ) + ) + (tee_local $6 + (i32.load + (i32.add + (get_local $1) + (i32.const 352) + ) + ) + ) + ) + ) + (set_local $10 + (i32.add + (get_local $11) + (i32.const -24) + ) + ) + (set_local $7 + (i32.sub + (i32.const 0) + (get_local $6) + ) + ) + (loop $label$16 + (br_if $label$15 + (i64.eq + (i64.shr_u + (i64.load offset=8 + (i32.load + (get_local $10) + ) + ) + (i64.const 8) + ) + (get_local $12) + ) + ) + (set_local $11 + (get_local $10) + ) + (set_local $10 + (tee_local $8 + (i32.add + (get_local $10) + (i32.const -24) + ) + ) + ) + (br_if $label$16 + (i32.ne + (i32.add + (get_local $8) + (get_local $7) + ) + (i32.const -24) + ) + ) + ) + ) + (set_local $8 + (i32.add + (get_local $1) + (i32.const 328) + ) + ) + (br_if $label$12 + (i32.eq + (get_local $11) + (get_local $6) + ) + ) + (call $eosio_assert + (i32.eq + (i32.load offset=16 + (tee_local $10 + (i32.load + (i32.add + (get_local $11) + (i32.const -24) + ) + ) + ) + ) + (get_local $8) + ) + (i32.const 32) + ) + (br_if $label$11 + (get_local $10) + ) + (br $label$10) + ) + (i64.store offset=8 + (get_local $0) + (get_local $4) + ) + (i64.store + (get_local $0) + (i64.const 0) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 176) + ) + (set_local $12 + (i64.shr_u + (get_local $4) + (i64.const 8) + ) + ) + (set_local $10 + (i32.const 0) + ) + (block $label$17 + (block $label$18 + (loop $label$19 + (br_if $label$18 + (i32.gt_u + (i32.add + (i32.shl + (i32.wrap/i64 + (get_local $12) + ) + (i32.const 24) + ) + (i32.const -1073741825) + ) + (i32.const 452984830) + ) + ) + (block $label$20 + (br_if $label$20 + (i64.ne + (i64.and + (tee_local $12 + (i64.shr_u + (get_local $12) + (i64.const 8) + ) + ) + (i64.const 255) + ) + (i64.const 0) + ) + ) + (loop $label$21 + (br_if $label$18 + (i64.ne + (i64.and + (tee_local $12 + (i64.shr_u + (get_local $12) + (i64.const 8) + ) + ) + (i64.const 255) + ) + (i64.const 0) + ) + ) + (br_if $label$21 + (i32.lt_s + (tee_local $10 + (i32.add + (get_local $10) + (i32.const 1) + ) + ) + (i32.const 7) + ) + ) + ) + ) + (set_local $8 + (i32.const 1) + ) + (br_if $label$19 + (i32.lt_s + (tee_local $10 + (i32.add + (get_local $10) + (i32.const 1) + ) + ) + (i32.const 7) + ) + ) + (br $label$17) + ) + ) + (set_local $8 + (i32.const 0) + ) + ) + (call $eosio_assert + (get_local $8) + (i32.const 128) + ) + (br $label$5) + ) + (br_if $label$10 + (i32.lt_s + (tee_local $10 + (call $db_find_i64 + (i64.load + (i32.add + (get_local $1) + (i32.const 328) + ) + ) + (i64.load + (i32.add + (get_local $1) + (i32.const 336) + ) + ) + (i64.const -3665743317141815296) + (get_local $12) + ) + ) + (i32.const 0) + ) + ) + (call $eosio_assert + (i32.eq + (i32.load offset=16 + (tee_local $10 + (call $_ZNK5eosio11multi_indexILy14781000756567736320EN6eoswin10token_itemEJEE31load_object_by_primary_iteratorEl + (get_local $8) + (get_local $10) + ) + ) + ) + (get_local $8) + ) + (i32.const 32) + ) + ) + (call $eosio_assert + (i64.lt_u + (i64.add + (tee_local $9 + (i64.trunc_s/f64 + (f64.mul + (f64.convert_s/i64 + (i64.load + (get_local $10) + ) + ) + (get_local $5) + ) + ) + ) + (i64.const 4611686018427387903) + ) + (i64.const 9223372036854775807) + ) + (i32.const 176) + ) + (set_local $10 + (i32.const 0) + ) + (block $label$22 + (block $label$23 + (loop $label$24 + (br_if $label$23 + (i32.gt_u + (i32.add + (i32.shl + (i32.wrap/i64 + (get_local $12) + ) + (i32.const 24) + ) + (i32.const -1073741825) + ) + (i32.const 452984830) + ) + ) + (block $label$25 + (br_if $label$25 + (i64.ne + (i64.and + (tee_local $12 + (i64.shr_u + (get_local $12) + (i64.const 8) + ) + ) + (i64.const 255) + ) + (i64.const 0) + ) + ) + (loop $label$26 + (br_if $label$23 + (i64.ne + (i64.and + (tee_local $12 + (i64.shr_u + (get_local $12) + (i64.const 8) + ) + ) + (i64.const 255) + ) + (i64.const 0) + ) + ) + (br_if $label$26 + (i32.lt_s + (tee_local $10 + (i32.add + (get_local $10) + (i32.const 1) + ) + ) + (i32.const 7) + ) + ) + ) + ) + (set_local $8 + (i32.const 1) + ) + (br_if $label$24 + (i32.lt_s + (tee_local $10 + (i32.add + (get_local $10) + (i32.const 1) + ) + ) + (i32.const 7) + ) + ) + (br $label$22) + ) + ) + (set_local $8 + (i32.const 0) + ) + ) + (call $eosio_assert + (get_local $8) + (i32.const 128) + ) + (br_if $label$6 + (i64.lt_s + (get_local $9) + (i64.const 1) + ) + ) + (set_local $12 + (i64.const 0) + ) + (set_local $16 + (i64.const 59) + ) + (set_local $10 + (i32.const 1104) + ) + (set_local $13 + (i64.const 0) + ) + (loop $label$27 + (set_local $14 + (i64.const 0) + ) + (block $label$28 + (br_if $label$28 + (i64.gt_u + (get_local $12) + (i64.const 11) + ) + ) + (block $label$29 + (block $label$30 + (br_if $label$30 + (i32.gt_u + (i32.and + (i32.add + (tee_local $8 + (i32.load8_s + (get_local $10) + ) + ) + (i32.const -97) + ) + (i32.const 255) + ) + (i32.const 25) + ) + ) + (set_local $8 + (i32.add + (get_local $8) + (i32.const 165) + ) + ) + (br $label$29) + ) + (set_local $8 + (select + (i32.add + (get_local $8) + (i32.const 208) + ) + (i32.const 0) + (i32.lt_u + (i32.and + (i32.add + (get_local $8) + (i32.const -49) + ) + (i32.const 255) + ) + (i32.const 5) + ) + ) + ) + ) + (set_local $14 + (i64.shl + (i64.extend_u/i32 + (i32.and + (get_local $8) + (i32.const 31) + ) + ) + (i64.and + (get_local $16) + (i64.const 4294967295) + ) + ) + ) + ) + (set_local $10 + (i32.add + (get_local $10) + (i32.const 1) + ) + ) + (set_local $12 + (i64.add + (get_local $12) + (i64.const 1) + ) + ) + (set_local $13 + (i64.or + (get_local $14) + (get_local $13) + ) + ) + (br_if $label$27 + (i64.ne + (tee_local $16 + (i64.add + (get_local $16) + (i64.const -5) + ) + ) + (i64.const -6) + ) + ) + ) + (set_local $12 + (i64.const 0) + ) + (set_local $14 + (i64.const 59) + ) + (set_local $10 + (i32.const 592) + ) + (set_local $15 + (i64.const 0) + ) + (loop $label$31 + (block $label$32 + (block $label$33 + (block $label$34 + (block $label$35 + (block $label$36 + (br_if $label$36 + (i64.gt_u + (get_local $12) + (i64.const 5) + ) + ) + (br_if $label$35 + (i32.gt_u + (i32.and + (i32.add + (tee_local $8 + (i32.load8_s + (get_local $10) + ) + ) + (i32.const -97) + ) + (i32.const 255) + ) + (i32.const 25) + ) + ) + (set_local $8 + (i32.add + (get_local $8) + (i32.const 165) + ) + ) + (br $label$34) + ) + (set_local $16 + (i64.const 0) + ) + (br_if $label$33 + (i64.le_u + (get_local $12) + (i64.const 11) + ) + ) + (br $label$32) + ) + (set_local $8 + (select + (i32.add + (get_local $8) + (i32.const 208) + ) + (i32.const 0) + (i32.lt_u + (i32.and + (i32.add + (get_local $8) + (i32.const -49) + ) + (i32.const 255) + ) + (i32.const 5) + ) + ) + ) + ) + (set_local $16 + (i64.shr_s + (i64.shl + (i64.extend_u/i32 + (get_local $8) + ) + (i64.const 56) + ) + (i64.const 56) + ) + ) + ) + (set_local $16 + (i64.shl + (i64.and + (get_local $16) + (i64.const 31) + ) + (i64.and + (get_local $14) + (i64.const 4294967295) + ) + ) + ) + ) + (set_local $10 + (i32.add + (get_local $10) + (i32.const 1) + ) + ) + (set_local $12 + (i64.add + (get_local $12) + (i64.const 1) + ) + ) + (set_local $15 + (i64.or + (get_local $16) + (get_local $15) + ) + ) + (br_if $label$31 + (i64.ne + (tee_local $14 + (i64.add + (get_local $14) + (i64.const -5) + ) + ) + (i64.const -6) + ) + ) + ) + (set_local $12 + (i64.const 0) + ) + (set_local $16 + (i64.const 59) + ) + (set_local $10 + (i32.const 1104) + ) + (set_local $17 + (i64.const 0) + ) + (loop $label$37 + (set_local $14 + (i64.const 0) + ) + (block $label$38 + (br_if $label$38 + (i64.gt_u + (get_local $12) + (i64.const 11) + ) + ) + (block $label$39 + (block $label$40 + (br_if $label$40 + (i32.gt_u + (i32.and + (i32.add + (tee_local $8 + (i32.load8_s + (get_local $10) + ) + ) + (i32.const -97) + ) + (i32.const 255) + ) + (i32.const 25) + ) + ) + (set_local $8 + (i32.add + (get_local $8) + (i32.const 165) + ) + ) + (br $label$39) + ) + (set_local $8 + (select + (i32.add + (get_local $8) + (i32.const 208) + ) + (i32.const 0) + (i32.lt_u + (i32.and + (i32.add + (get_local $8) + (i32.const -49) + ) + (i32.const 255) + ) + (i32.const 5) + ) + ) + ) + ) + (set_local $14 + (i64.shl + (i64.extend_u/i32 + (i32.and + (get_local $8) + (i32.const 31) + ) + ) + (i64.and + (get_local $16) + (i64.const 4294967295) + ) + ) + ) + ) + (set_local $10 + (i32.add + (get_local $10) + (i32.const 1) + ) + ) + (set_local $12 + (i64.add + (get_local $12) + (i64.const 1) + ) + ) + (set_local $17 + (i64.or + (get_local $14) + (get_local $17) + ) + ) + (br_if $label$37 + (i64.ne + (tee_local $16 + (i64.add + (get_local $16) + (i64.const -5) + ) + ) + (i64.const -6) + ) + ) + ) + (i64.store + (i32.add + (get_local $18) + (i32.const 24) + ) + (get_local $4) + ) + (i64.store align=4 + (i32.add + (get_local $18) + (i32.const 36) + ) + (i64.const 0) + ) + (i64.store offset=8 + (get_local $18) + (get_local $2) + ) + (i64.store + (get_local $18) + (get_local $17) + ) + (i64.store offset=16 + (get_local $18) + (get_local $9) + ) + (i32.store offset=32 + (get_local $18) + (i32.const 0) + ) + (set_local $8 + (i32.add + (get_local $18) + (i32.const 32) + ) + ) + (br_if $label$4 + (i32.ge_u + (tee_local $10 + (call $strlen + (i32.const 3264) + ) + ) + (i32.const -16) + ) + ) + (br_if $label$9 + (i32.ge_u + (get_local $10) + (i32.const 11) + ) + ) + (i32.store8 + (i32.add + (get_local $18) + (i32.const 32) + ) + (i32.shl + (get_local $10) + (i32.const 1) + ) + ) + (set_local $11 + (i32.add + (get_local $8) + (i32.const 1) + ) + ) + (br_if $label$8 + (get_local $10) + ) + (br $label$7) + ) + (i64.store offset=8 + (get_local $0) + (get_local $4) + ) + (i64.store + (get_local $0) + (i64.const 0) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 176) + ) + (set_local $10 + (i32.const 0) + ) + (block $label$41 + (block $label$42 + (loop $label$43 + (br_if $label$42 + (i32.gt_u + (i32.add + (i32.shl + (i32.wrap/i64 + (get_local $12) + ) + (i32.const 24) + ) + (i32.const -1073741825) + ) + (i32.const 452984830) + ) + ) + (block $label$44 + (br_if $label$44 + (i64.ne + (i64.and + (tee_local $12 + (i64.shr_u + (get_local $12) + (i64.const 8) + ) + ) + (i64.const 255) + ) + (i64.const 0) + ) + ) + (loop $label$45 + (br_if $label$42 + (i64.ne + (i64.and + (tee_local $12 + (i64.shr_u + (get_local $12) + (i64.const 8) + ) + ) + (i64.const 255) + ) + (i64.const 0) + ) + ) + (br_if $label$45 + (i32.lt_s + (tee_local $10 + (i32.add + (get_local $10) + (i32.const 1) + ) + ) + (i32.const 7) + ) + ) + ) + ) + (set_local $8 + (i32.const 1) + ) + (br_if $label$43 + (i32.lt_s + (tee_local $10 + (i32.add + (get_local $10) + (i32.const 1) + ) + ) + (i32.const 7) + ) + ) + (br $label$41) + ) + ) + (set_local $8 + (i32.const 0) + ) + ) + (call $eosio_assert + (get_local $8) + (i32.const 128) + ) + (br $label$5) + ) + (set_local $11 + (call $_Znwj + (tee_local $7 + (i32.and + (i32.add + (get_local $10) + (i32.const 16) + ) + (i32.const -16) + ) + ) + ) + ) + (i32.store + (i32.add + (get_local $18) + (i32.const 32) + ) + (i32.or + (get_local $7) + (i32.const 1) + ) + ) + (i32.store + (i32.add + (get_local $18) + (i32.const 40) + ) + (get_local $11) + ) + (i32.store + (i32.add + (get_local $18) + (i32.const 36) + ) + (get_local $10) + ) + ) + (drop + (call $memcpy + (get_local $11) + (i32.const 3264) + (get_local $10) + ) + ) + ) + (i32.store8 + (i32.add + (get_local $11) + (get_local $10) + ) + (i32.const 0) + ) + (i64.store + (tee_local $10 + (call $_Znwj + (i32.const 16) + ) + ) + (get_local $13) + ) + (i64.store offset=8 + (get_local $10) + (get_local $15) + ) + (i32.store offset=96 + (get_local $18) + (get_local $10) + ) + (i32.store offset=104 + (get_local $18) + (tee_local $10 + (i32.add + (get_local $10) + (i32.const 16) + ) + ) + ) + (i32.store offset=100 + (get_local $18) + (get_local $10) + ) + (i64.store offset=48 + (get_local $18) + (i64.load + (get_local $18) + ) + ) + (i64.store offset=56 + (get_local $18) + (i64.load + (i32.add + (get_local $18) + (i32.const 8) + ) + ) + ) + (i64.store + (i32.add + (i32.add + (get_local $18) + (i32.const 48) + ) + (i32.const 24) + ) + (i64.load + (i32.add + (get_local $18) + (i32.const 24) + ) + ) + ) + (i64.store offset=64 + (get_local $18) + (i64.load offset=16 + (get_local $18) + ) + ) + (i32.store + (tee_local $10 + (i32.add + (i32.add + (get_local $18) + (i32.const 48) + ) + (i32.const 40) + ) + ) + (i32.load + (i32.add + (get_local $8) + (i32.const 8) + ) + ) + ) + (i64.store offset=80 + (get_local $18) + (i64.load + (get_local $8) + ) + ) + (i32.store + (i32.add + (get_local $18) + (i32.const 32) + ) + (i32.const 0) + ) + (i32.store + (i32.add + (get_local $18) + (i32.const 36) + ) + (i32.const 0) + ) + (i32.store + (i32.add + (get_local $18) + (i32.const 40) + ) + (i32.const 0) + ) + (call $_ZN5eosio15dispatch_inlineIJyyNS_5assetENSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEvyyNS2_6vectorINS_16permission_levelENS6_ISA_EEEENS2_5tupleIJDpT_EEE + (get_local $3) + (i64.const -3617168760277827584) + (i32.add + (get_local $18) + (i32.const 96) + ) + (i32.add + (get_local $18) + (i32.const 48) + ) + ) + (block $label$46 + (br_if $label$46 + (i32.eqz + (i32.and + (i32.load8_u offset=80 + (get_local $18) + ) + (i32.const 1) + ) + ) + ) + (call $_ZdlPv + (i32.load + (get_local $10) + ) + ) + ) + (block $label$47 + (br_if $label$47 + (i32.eqz + (tee_local $10 + (i32.load offset=96 + (get_local $18) + ) + ) + ) + ) + (i32.store offset=100 + (get_local $18) + (get_local $10) + ) + (call $_ZdlPv + (get_local $10) + ) + ) + (br_if $label$6 + (i32.eqz + (i32.and + (i32.load8_u + (i32.add + (get_local $18) + (i32.const 32) + ) + ) + (i32.const 1) + ) + ) + ) + (call $_ZdlPv + (i32.load + (i32.add + (get_local $18) + (i32.const 40) + ) + ) + ) + ) + (i64.store offset=8 + (get_local $0) + (get_local $4) + ) + (i64.store + (get_local $0) + (get_local $9) + ) + ) + (i32.store offset=4 + (i32.const 0) + (i32.add + (get_local $18) + (i32.const 112) + ) + ) + (return) + ) + (call $_ZNKSt3__121__basic_string_commonILb1EE20__throw_length_errorEv + (get_local $8) + ) + (unreachable) + ) + (func $_ZNK5eosio11multi_indexILy14781000756567736320EN6eoswin10token_itemEJEE31load_object_by_primary_iteratorEl (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 i64) + (local $6 i32) + (local $7 i32) + (local $8 i32) + (local $9 i32) + (i32.store offset=4 + (i32.const 0) + (tee_local $9 + (i32.sub + (i32.load offset=4 + (i32.const 0) + ) + (i32.const 48) + ) + ) + ) + (i32.store offset=44 + (tee_local $8 + (get_local $9) + ) + (get_local $1) + ) + (block $label$0 + (br_if $label$0 + (i32.eq + (tee_local $7 + (i32.load + (i32.add + (get_local $0) + (i32.const 28) + ) + ) + ) + (tee_local $2 + (i32.load offset=24 + (get_local $0) + ) + ) + ) + ) + (set_local $3 + (i32.sub + (i32.const 0) + (get_local $2) + ) + ) + (set_local $6 + (i32.add + (get_local $7) + (i32.const -24) + ) + ) + (loop $label$1 + (br_if $label$0 + (i32.eq + (i32.load + (i32.add + (get_local $6) + (i32.const 16) + ) + ) + (get_local $1) + ) + ) + (set_local $7 + (get_local $6) + ) + (set_local $6 + (tee_local $4 + (i32.add + (get_local $6) + (i32.const -24) + ) + ) + ) + (br_if $label$1 + (i32.ne + (i32.add + (get_local $4) + (get_local $3) + ) + (i32.const -24) + ) + ) + ) + ) + (block $label$2 + (block $label$3 + (br_if $label$3 + (i32.eq + (get_local $7) + (get_local $2) + ) + ) + (set_local $6 + (i32.load + (i32.add + (get_local $7) + (i32.const -24) + ) + ) + ) + (br $label$2) + ) + (call $eosio_assert + (i32.xor + (i32.shr_u + (tee_local $6 + (call $db_get_i64 + (get_local $1) + (i32.const 0) + (i32.const 0) + ) + ) + (i32.const 31) + ) + (i32.const 1) + ) + (i32.const 240) + ) + (block $label$4 + (block $label$5 + (br_if $label$5 + (i32.lt_u + (get_local $6) + (i32.const 513) + ) + ) + (set_local $4 + (call $malloc + (get_local $6) + ) + ) + (br $label$4) + ) + (i32.store offset=4 + (i32.const 0) + (tee_local $4 + (i32.sub + (get_local $9) + (i32.and + (i32.add + (get_local $6) + (i32.const 15) + ) + (i32.const -16) + ) + ) + ) + ) + ) + (drop + (call $db_get_i64 + (get_local $1) + (get_local $4) + (get_local $6) + ) + ) + (i32.store offset=36 + (get_local $8) + (get_local $4) + ) + (i32.store offset=32 + (get_local $8) + (get_local $4) + ) + (i32.store offset=40 + (get_local $8) + (i32.add + (get_local $4) + (get_local $6) + ) + ) + (block $label$6 + (br_if $label$6 + (i32.lt_u + (get_local $6) + (i32.const 513) + ) + ) + (call $free + (get_local $4) + ) + ) + (i32.store offset=12 + (get_local $8) + (i32.add + (get_local $8) + (i32.const 32) + ) + ) + (i32.store offset=16 + (get_local $8) + (i32.add + (get_local $8) + (i32.const 44) + ) + ) + (i32.store offset=8 + (get_local $8) + (get_local $0) + ) + (set_local $6 + (call $_ZN5eosio11multi_indexILy14781000756567736320EN6eoswin10token_itemEJEE4itemC2IZNKS3_31load_object_by_primary_iteratorElEUlRT_E_EEPKS3_OS6_ + (tee_local $4 + (call $_Znwj + (i32.const 32) + ) + ) + (get_local $0) + (i32.add + (get_local $8) + (i32.const 8) + ) + ) + ) + (i32.store offset=24 + (get_local $8) + (get_local $4) + ) + (i64.store offset=8 + (get_local $8) + (tee_local $5 + (i64.shr_u + (i64.load offset=8 + (get_local $4) + ) + (i64.const 8) + ) + ) + ) + (i32.store offset=4 + (get_local $8) + (tee_local $1 + (i32.load offset=20 + (get_local $4) + ) + ) + ) + (block $label$7 + (block $label$8 + (br_if $label$8 + (i32.ge_u + (tee_local $7 + (i32.load + (tee_local $3 + (i32.add + (get_local $0) + (i32.const 28) + ) + ) + ) + ) + (i32.load + (i32.add + (get_local $0) + (i32.const 32) + ) + ) + ) + ) + (i64.store offset=8 + (get_local $7) + (get_local $5) + ) + (i32.store offset=16 + (get_local $7) + (get_local $1) + ) + (i32.store offset=24 + (get_local $8) + (i32.const 0) + ) + (i32.store + (get_local $7) + (get_local $4) + ) + (i32.store + (get_local $3) + (i32.add + (get_local $7) + (i32.const 24) + ) + ) + (br $label$7) + ) + (call $_ZNSt3__16vectorIN5eosio11multi_indexILy14781000756567736320EN6eoswin10token_itemEJEE8item_ptrENS_9allocatorIS6_EEE24__emplace_back_slow_pathIJNS_10unique_ptrINS5_4itemENS_14default_deleteISC_EEEERyRlEEEvDpOT_ + (i32.add + (get_local $0) + (i32.const 24) + ) + (i32.add + (get_local $8) + (i32.const 24) + ) + (i32.add + (get_local $8) + (i32.const 8) + ) + (i32.add + (get_local $8) + (i32.const 4) + ) + ) + ) + (set_local $4 + (i32.load offset=24 + (get_local $8) + ) + ) + (i32.store offset=24 + (get_local $8) + (i32.const 0) + ) + (br_if $label$2 + (i32.eqz + (get_local $4) + ) + ) + (call $_ZdlPv + (get_local $4) + ) + ) + (i32.store offset=4 + (i32.const 0) + (i32.add + (get_local $8) + (i32.const 48) + ) + ) + (get_local $6) + ) + (func $_ZN5eosio11multi_indexILy14781000756567736320EN6eoswin10token_itemEJEE4itemC2IZNKS3_31load_object_by_primary_iteratorElEUlRT_E_EEPKS3_OS6_ (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i32) + (local $5 i32) + (i64.store offset=8 + (get_local $0) + (i64.const 1397703940) + ) + (i64.store + (get_local $0) + (i64.const 0) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 176) + ) + (set_local $3 + (i64.shr_u + (i64.load offset=8 + (get_local $0) + ) + (i64.const 8) + ) + ) + (set_local $4 + (i32.const 0) + ) + (block $label$0 + (block $label$1 + (loop $label$2 + (br_if $label$1 + (i32.gt_u + (i32.add + (i32.shl + (i32.wrap/i64 + (get_local $3) + ) + (i32.const 24) + ) + (i32.const -1073741825) + ) + (i32.const 452984830) + ) + ) + (block $label$3 + (br_if $label$3 + (i64.ne + (i64.and + (tee_local $3 + (i64.shr_u + (get_local $3) + (i64.const 8) + ) + ) + (i64.const 255) + ) + (i64.const 0) + ) + ) + (loop $label$4 + (br_if $label$1 + (i64.ne + (i64.and + (tee_local $3 + (i64.shr_u + (get_local $3) + (i64.const 8) + ) + ) + (i64.const 255) + ) + (i64.const 0) + ) + ) + (br_if $label$4 + (i32.lt_s + (tee_local $4 + (i32.add + (get_local $4) + (i32.const 1) + ) + ) + (i32.const 7) + ) + ) + ) + ) + (set_local $5 + (i32.const 1) + ) + (br_if $label$2 + (i32.lt_s + (tee_local $4 + (i32.add + (get_local $4) + (i32.const 1) + ) + ) + (i32.const 7) + ) + ) + (br $label$0) + ) + ) + (set_local $5 + (i32.const 0) + ) + ) + (call $eosio_assert + (get_local $5) + (i32.const 128) + ) + (i32.store offset=16 + (get_local $0) + (get_local $1) + ) + (call $eosio_assert + (i32.gt_u + (i32.sub + (i32.load offset=8 + (tee_local $4 + (i32.load offset=4 + (get_local $2) + ) + ) + ) + (i32.load offset=4 + (get_local $4) + ) + ) + (i32.const 7) + ) + (i32.const 272) + ) + (drop + (call $memcpy + (get_local $0) + (i32.load offset=4 + (get_local $4) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $4) + (tee_local $5 + (i32.add + (i32.load offset=4 + (get_local $4) + ) + (i32.const 8) + ) + ) + ) + (call $eosio_assert + (i32.gt_u + (i32.sub + (i32.load offset=8 + (get_local $4) + ) + (get_local $5) + ) + (i32.const 7) + ) + (i32.const 272) + ) + (drop + (call $memcpy + (i32.add + (get_local $0) + (i32.const 8) + ) + (i32.load offset=4 + (get_local $4) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $4) + (i32.add + (i32.load offset=4 + (get_local $4) + ) + (i32.const 8) + ) + ) + (i32.store offset=20 + (get_local $0) + (i32.load + (i32.load offset=8 + (get_local $2) + ) + ) + ) + (get_local $0) + ) + (func $_ZNSt3__16vectorIN5eosio11multi_indexILy14781000756567736320EN6eoswin10token_itemEJEE8item_ptrENS_9allocatorIS6_EEE24__emplace_back_slow_pathIJNS_10unique_ptrINS5_4itemENS_14default_deleteISC_EEEERyRlEEEvDpOT_ (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (block $label$0 + (block $label$1 + (br_if $label$1 + (i32.ge_u + (tee_local $5 + (i32.add + (tee_local $4 + (i32.div_s + (i32.sub + (i32.load offset=4 + (get_local $0) + ) + (tee_local $6 + (i32.load + (get_local $0) + ) + ) + ) + (i32.const 24) + ) + ) + (i32.const 1) + ) + ) + (i32.const 178956971) + ) + ) + (set_local $7 + (i32.const 178956970) + ) + (block $label$2 + (block $label$3 + (br_if $label$3 + (i32.gt_u + (tee_local $6 + (i32.div_s + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (get_local $6) + ) + (i32.const 24) + ) + ) + (i32.const 89478484) + ) + ) + (br_if $label$2 + (i32.eqz + (tee_local $7 + (select + (get_local $5) + (tee_local $7 + (i32.shl + (get_local $6) + (i32.const 1) + ) + ) + (i32.lt_u + (get_local $7) + (get_local $5) + ) + ) + ) + ) + ) + ) + (set_local $6 + (call $_Znwj + (i32.mul + (get_local $7) + (i32.const 24) + ) + ) + ) + (br $label$0) + ) + (set_local $7 + (i32.const 0) + ) + (set_local $6 + (i32.const 0) + ) + (br $label$0) + ) + (call $_ZNKSt3__120__vector_base_commonILb1EE20__throw_length_errorEv + (get_local $0) + ) + (unreachable) + ) + (set_local $5 + (i32.load + (get_local $1) + ) + ) + (i32.store + (get_local $1) + (i32.const 0) + ) + (i32.store + (tee_local $1 + (i32.add + (get_local $6) + (i32.mul + (get_local $4) + (i32.const 24) + ) + ) + ) + (get_local $5) + ) + (i64.store offset=8 + (get_local $1) + (i64.load + (get_local $2) + ) + ) + (i32.store offset=16 + (get_local $1) + (i32.load + (get_local $3) + ) + ) + (set_local $4 + (i32.add + (get_local $6) + (i32.mul + (get_local $7) + (i32.const 24) + ) + ) + ) + (set_local $5 + (i32.add + (get_local $1) + (i32.const 24) + ) + ) + (block $label$4 + (block $label$5 + (br_if $label$5 + (i32.eq + (tee_local $6 + (i32.load + (i32.add + (get_local $0) + (i32.const 4) + ) + ) + ) + (tee_local $7 + (i32.load + (get_local $0) + ) + ) + ) + ) + (loop $label$6 + (set_local $3 + (i32.load + (tee_local $2 + (i32.add + (get_local $6) + (i32.const -24) + ) + ) + ) + ) + (i32.store + (get_local $2) + (i32.const 0) + ) + (i32.store + (i32.add + (get_local $1) + (i32.const -24) + ) + (get_local $3) + ) + (i32.store + (i32.add + (get_local $1) + (i32.const -8) + ) + (i32.load + (i32.add + (get_local $6) + (i32.const -8) + ) + ) + ) + (i32.store + (i32.add + (get_local $1) + (i32.const -12) + ) + (i32.load + (i32.add + (get_local $6) + (i32.const -12) + ) + ) + ) + (i32.store + (i32.add + (get_local $1) + (i32.const -16) + ) + (i32.load + (i32.add + (get_local $6) + (i32.const -16) + ) + ) + ) + (set_local $1 + (i32.add + (get_local $1) + (i32.const -24) + ) + ) + (set_local $6 + (get_local $2) + ) + (br_if $label$6 + (i32.ne + (get_local $7) + (get_local $2) + ) + ) + ) + (set_local $7 + (i32.load + (i32.add + (get_local $0) + (i32.const 4) + ) + ) + ) + (set_local $6 + (i32.load + (get_local $0) + ) + ) + (br $label$4) + ) + (set_local $6 + (get_local $7) + ) + ) + (i32.store + (get_local $0) + (get_local $1) + ) + (i32.store + (i32.add + (get_local $0) + (i32.const 4) + ) + (get_local $5) + ) + (i32.store + (i32.add + (get_local $0) + (i32.const 8) + ) + (get_local $4) + ) + (block $label$7 + (br_if $label$7 + (i32.eq + (get_local $7) + (get_local $6) + ) + ) + (loop $label$8 + (set_local $1 + (i32.load + (tee_local $7 + (i32.add + (get_local $7) + (i32.const -24) + ) + ) + ) + ) + (i32.store + (get_local $7) + (i32.const 0) + ) + (block $label$9 + (br_if $label$9 + (i32.eqz + (get_local $1) + ) + ) + (call $_ZdlPv + (get_local $1) + ) + ) + (br_if $label$8 + (i32.ne + (get_local $6) + (get_local $7) + ) + ) + ) + ) + (block $label$10 + (br_if $label$10 + (i32.eqz + (get_local $6) + ) + ) + (call $_ZdlPv + (get_local $6) + ) + ) + ) + (func $_ZNSt3__16vectorIN5eosio5assetENS_9allocatorIS2_EEE21__push_back_slow_pathIRKS2_EEvOT_ (param $0 i32) (param $1 i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (block $label$0 + (block $label$1 + (block $label$2 + (br_if $label$2 + (i32.ge_u + (tee_local $3 + (i32.add + (tee_local $2 + (i32.shr_s + (i32.sub + (tee_local $6 + (i32.load offset=4 + (get_local $0) + ) + ) + (tee_local $5 + (i32.load + (get_local $0) + ) + ) + ) + (i32.const 4) + ) + ) + (i32.const 1) + ) + ) + (i32.const 268435456) + ) + ) + (set_local $4 + (i32.const 268435455) + ) + (block $label$3 + (block $label$4 + (br_if $label$4 + (i32.gt_u + (i32.shr_s + (tee_local $7 + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (get_local $5) + ) + ) + (i32.const 4) + ) + (i32.const 134217726) + ) + ) + (br_if $label$3 + (i32.eqz + (tee_local $4 + (select + (get_local $3) + (tee_local $4 + (i32.shr_s + (get_local $7) + (i32.const 3) + ) + ) + (i32.lt_u + (get_local $4) + (get_local $3) + ) + ) + ) + ) + ) + (br_if $label$1 + (i32.ge_u + (get_local $4) + (i32.const 268435456) + ) + ) + ) + (set_local $7 + (call $_Znwj + (i32.shl + (get_local $4) + (i32.const 4) + ) + ) + ) + (set_local $6 + (i32.load + (i32.add + (get_local $0) + (i32.const 4) + ) + ) + ) + (set_local $5 + (i32.load + (get_local $0) + ) + ) + (br $label$0) + ) + (set_local $4 + (i32.const 0) + ) + (set_local $7 + (i32.const 0) + ) + (br $label$0) + ) + (call $_ZNKSt3__120__vector_base_commonILb1EE20__throw_length_errorEv + (get_local $0) + ) + (unreachable) + ) + (call $abort) + (unreachable) + ) + (i64.store + (tee_local $3 + (i32.add + (get_local $7) + (i32.shl + (get_local $2) + (i32.const 4) + ) + ) + ) + (i64.load + (get_local $1) + ) + ) + (i64.store + (i32.add + (get_local $3) + (i32.const 8) + ) + (i64.load + (i32.add + (get_local $1) + (i32.const 8) + ) + ) + ) + (set_local $6 + (i32.sub + (get_local $3) + (tee_local $1 + (i32.sub + (get_local $6) + (get_local $5) + ) + ) + ) + ) + (set_local $4 + (i32.add + (get_local $7) + (i32.shl + (get_local $4) + (i32.const 4) + ) + ) + ) + (set_local $3 + (i32.add + (get_local $3) + (i32.const 16) + ) + ) + (block $label$5 + (br_if $label$5 + (i32.lt_s + (get_local $1) + (i32.const 1) + ) + ) + (drop + (call $memcpy + (get_local $6) + (get_local $5) + (get_local $1) + ) + ) + (set_local $5 + (i32.load + (get_local $0) + ) + ) + ) + (i32.store + (get_local $0) + (get_local $6) + ) + (i32.store + (i32.add + (get_local $0) + (i32.const 4) + ) + (get_local $3) + ) + (i32.store + (i32.add + (get_local $0) + (i32.const 8) + ) + (get_local $4) + ) + (block $label$6 + (br_if $label$6 + (i32.eqz + (get_local $5) + ) + ) + (call $_ZdlPv + (get_local $5) + ) + ) + ) + (func $_ZN5eosiolsINS_10datastreamIPcEENS_5assetEEERT_S6_RKNSt3__16vectorIT0_NS7_9allocatorIS9_EEEE (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + (local $3 i32) + (local $4 i64) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (i32.store offset=4 + (i32.const 0) + (tee_local $7 + (i32.sub + (i32.load offset=4 + (i32.const 0) + ) + (i32.const 16) + ) + ) + ) + (set_local $4 + (i64.extend_u/i32 + (i32.shr_s + (i32.sub + (i32.load offset=4 + (get_local $1) + ) + (i32.load + (get_local $1) + ) + ) + (i32.const 4) + ) + ) + ) + (set_local $5 + (i32.load offset=4 + (get_local $0) + ) + ) + (set_local $2 + (i32.add + (get_local $0) + (i32.const 8) + ) + ) + (loop $label$0 + (set_local $3 + (i32.wrap/i64 + (get_local $4) + ) + ) + (i32.store8 offset=15 + (get_local $7) + (i32.or + (i32.shl + (tee_local $6 + (i64.ne + (tee_local $4 + (i64.shr_u + (get_local $4) + (i64.const 7) + ) + ) + (i64.const 0) + ) + ) + (i32.const 7) + ) + (i32.and + (get_local $3) + (i32.const 127) + ) + ) + ) + (call $eosio_assert + (i32.gt_s + (i32.sub + (i32.load + (get_local $2) + ) + (get_local $5) + ) + (i32.const 0) + ) + (i32.const 400) + ) + (drop + (call $memcpy + (i32.load + (tee_local $3 + (i32.add + (get_local $0) + (i32.const 4) + ) + ) + ) + (i32.add + (get_local $7) + (i32.const 15) + ) + (i32.const 1) + ) + ) + (i32.store + (get_local $3) + (tee_local $5 + (i32.add + (i32.load + (get_local $3) + ) + (i32.const 1) + ) + ) + ) + (br_if $label$0 + (get_local $6) + ) + ) + (block $label$1 + (br_if $label$1 + (i32.eq + (tee_local $6 + (i32.load + (get_local $1) + ) + ) + (tee_local $1 + (i32.load + (i32.add + (get_local $1) + (i32.const 4) + ) + ) + ) + ) + ) + (set_local $3 + (i32.add + (get_local $0) + (i32.const 4) + ) + ) + (loop $label$2 + (call $eosio_assert + (i32.gt_s + (i32.sub + (i32.load + (tee_local $2 + (i32.add + (get_local $0) + (i32.const 8) + ) + ) + ) + (get_local $5) + ) + (i32.const 7) + ) + (i32.const 400) + ) + (drop + (call $memcpy + (i32.load + (get_local $3) + ) + (get_local $6) + (i32.const 8) + ) + ) + (i32.store + (get_local $3) + (tee_local $5 + (i32.add + (i32.load + (get_local $3) + ) + (i32.const 8) + ) + ) + ) + (call $eosio_assert + (i32.gt_s + (i32.sub + (i32.load + (get_local $2) + ) + (get_local $5) + ) + (i32.const 7) + ) + (i32.const 400) + ) + (drop + (call $memcpy + (i32.load + (get_local $3) + ) + (i32.add + (get_local $6) + (i32.const 8) + ) + (i32.const 8) + ) + ) + (i32.store + (get_local $3) + (tee_local $5 + (i32.add + (i32.load + (get_local $3) + ) + (i32.const 8) + ) + ) + ) + (br_if $label$2 + (i32.ne + (tee_local $6 + (i32.add + (get_local $6) + (i32.const 16) + ) + ) + (get_local $1) + ) + ) + ) + ) + (i32.store offset=4 + (i32.const 0) + (i32.add + (get_local $7) + (i32.const 16) + ) + ) + (get_local $0) + ) + (func $_ZN5eosio11multi_indexILy5455799419175698432EN6eoswin13dividend_itemEJEE4itemC2IZNKS3_31load_object_by_primary_iteratorElEUlRT_E_EEPKS3_OS6_ (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i32) + (i64.store offset=16 align=4 + (get_local $0) + (i64.const 0) + ) + (i32.store offset=40 + (get_local $0) + (get_local $1) + ) + (i32.store + (i32.add + (get_local $0) + (i32.const 24) + ) + (i32.const 0) + ) + (call $eosio_assert + (i32.gt_u + (i32.sub + (i32.load offset=8 + (tee_local $1 + (i32.load offset=4 + (get_local $2) + ) + ) + ) + (i32.load offset=4 + (get_local $1) + ) + ) + (i32.const 7) + ) + (i32.const 272) + ) + (drop + (call $memcpy + (get_local $0) + (i32.load offset=4 + (get_local $1) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $1) + (tee_local $3 + (i32.add + (i32.load offset=4 + (get_local $1) + ) + (i32.const 8) + ) + ) + ) + (call $eosio_assert + (i32.gt_u + (i32.sub + (i32.load offset=8 + (get_local $1) + ) + (get_local $3) + ) + (i32.const 7) + ) + (i32.const 272) + ) + (drop + (call $memcpy + (i32.add + (get_local $0) + (i32.const 8) + ) + (i32.load offset=4 + (get_local $1) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $1) + (i32.add + (i32.load offset=4 + (get_local $1) + ) + (i32.const 8) + ) + ) + (call $eosio_assert + (i32.gt_u + (i32.sub + (i32.load offset=8 + (tee_local $1 + (call $_ZN5eosiorsINS_10datastreamIPKcEENS_5assetEEERT_S7_RNSt3__16vectorIT0_NS8_9allocatorISA_EEEE + (get_local $1) + (i32.add + (get_local $0) + (i32.const 16) + ) + ) + ) + ) + (i32.load offset=4 + (get_local $1) + ) + ) + (i32.const 7) + ) + (i32.const 272) + ) + (drop + (call $memcpy + (i32.add + (get_local $0) + (i32.const 32) + ) + (i32.load offset=4 + (get_local $1) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $1) + (i32.add + (i32.load offset=4 + (get_local $1) + ) + (i32.const 8) + ) + ) + (i32.store offset=44 + (get_local $0) + (i32.load + (i32.load offset=8 + (get_local $2) + ) + ) + ) + (get_local $0) + ) + (func $_ZN5eosiorsINS_10datastreamIPKcEENS_5assetEEERT_S7_RNSt3__16vectorIT0_NS8_9allocatorISA_EEEE (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 i64) + (local $6 i32) + (local $7 i32) + (set_local $7 + (i32.load offset=4 + (get_local $0) + ) + ) + (set_local $6 + (i32.const 0) + ) + (set_local $5 + (i64.const 0) + ) + (set_local $2 + (i32.add + (get_local $0) + (i32.const 8) + ) + ) + (set_local $3 + (i32.add + (get_local $0) + (i32.const 4) + ) + ) + (loop $label$0 + (call $eosio_assert + (i32.lt_u + (get_local $7) + (i32.load + (get_local $2) + ) + ) + (i32.const 2336) + ) + (set_local $4 + (i32.load8_u + (tee_local $7 + (i32.load + (get_local $3) + ) + ) + ) + ) + (i32.store + (get_local $3) + (tee_local $7 + (i32.add + (get_local $7) + (i32.const 1) + ) + ) + ) + (set_local $5 + (i64.or + (i64.extend_u/i32 + (i32.shl + (i32.and + (get_local $4) + (i32.const 127) + ) + (tee_local $6 + (i32.and + (get_local $6) + (i32.const 255) + ) + ) + ) + ) + (get_local $5) + ) + ) + (set_local $6 + (i32.add + (get_local $6) + (i32.const 7) + ) + ) + (br_if $label$0 + (i32.shr_u + (get_local $4) + (i32.const 7) + ) + ) + ) + (block $label$1 + (block $label$2 + (block $label$3 + (br_if $label$3 + (i32.le_u + (tee_local $4 + (i32.wrap/i64 + (get_local $5) + ) + ) + (tee_local $6 + (i32.shr_s + (i32.sub + (tee_local $2 + (i32.load offset=4 + (get_local $1) + ) + ) + (tee_local $7 + (i32.load + (get_local $1) + ) + ) + ) + (i32.const 4) + ) + ) + ) + ) + (call $_ZNSt3__16vectorIN5eosio5assetENS_9allocatorIS2_EEE8__appendEj + (get_local $1) + (i32.sub + (get_local $4) + (get_local $6) + ) + ) + (br_if $label$2 + (i32.ne + (tee_local $7 + (i32.load + (get_local $1) + ) + ) + (tee_local $2 + (i32.load + (i32.add + (get_local $1) + (i32.const 4) + ) + ) + ) + ) + ) + (br $label$1) + ) + (block $label$4 + (br_if $label$4 + (i32.ge_u + (get_local $4) + (get_local $6) + ) + ) + (i32.store + (i32.add + (get_local $1) + (i32.const 4) + ) + (tee_local $2 + (i32.add + (get_local $7) + (i32.shl + (get_local $4) + (i32.const 4) + ) + ) + ) + ) + ) + (br_if $label$1 + (i32.eq + (get_local $7) + (get_local $2) + ) + ) + ) + (set_local $6 + (i32.load + (tee_local $4 + (i32.add + (get_local $0) + (i32.const 4) + ) + ) + ) + ) + (loop $label$5 + (call $eosio_assert + (i32.gt_u + (i32.sub + (i32.load + (tee_local $3 + (i32.add + (get_local $0) + (i32.const 8) + ) + ) + ) + (get_local $6) + ) + (i32.const 7) + ) + (i32.const 272) + ) + (drop + (call $memcpy + (get_local $7) + (i32.load + (get_local $4) + ) + (i32.const 8) + ) + ) + (i32.store + (get_local $4) + (tee_local $6 + (i32.add + (i32.load + (get_local $4) + ) + (i32.const 8) + ) + ) + ) + (call $eosio_assert + (i32.gt_u + (i32.sub + (i32.load + (get_local $3) + ) + (get_local $6) + ) + (i32.const 7) + ) + (i32.const 272) + ) + (drop + (call $memcpy + (i32.add + (get_local $7) + (i32.const 8) + ) + (i32.load + (get_local $4) + ) + (i32.const 8) + ) + ) + (i32.store + (get_local $4) + (tee_local $6 + (i32.add + (i32.load + (get_local $4) + ) + (i32.const 8) + ) + ) + ) + (br_if $label$5 + (i32.ne + (tee_local $7 + (i32.add + (get_local $7) + (i32.const 16) + ) + ) + (get_local $2) + ) + ) + ) + ) + (get_local $0) + ) + (func $_ZNSt3__16vectorIN5eosio5assetENS_9allocatorIS2_EEE8__appendEj (param $0 i32) (param $1 i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 i64) + (local $6 i32) + (local $7 i32) + (local $8 i32) + (block $label$0 + (block $label$1 + (block $label$2 + (block $label$3 + (block $label$4 + (block $label$5 + (br_if $label$5 + (i32.ge_u + (i32.shr_s + (i32.sub + (tee_local $7 + (i32.load offset=8 + (get_local $0) + ) + ) + (tee_local $6 + (i32.load offset=4 + (get_local $0) + ) + ) + ) + (i32.const 4) + ) + (get_local $1) + ) + ) + (br_if $label$3 + (i32.ge_u + (tee_local $3 + (i32.add + (tee_local $2 + (i32.shr_s + (i32.sub + (get_local $6) + (tee_local $8 + (i32.load + (get_local $0) + ) + ) + ) + (i32.const 4) + ) + ) + (get_local $1) + ) + ) + (i32.const 268435456) + ) + ) + (set_local $6 + (i32.const 268435455) + ) + (block $label$6 + (br_if $label$6 + (i32.gt_u + (i32.shr_s + (tee_local $7 + (i32.sub + (get_local $7) + (get_local $8) + ) + ) + (i32.const 4) + ) + (i32.const 134217726) + ) + ) + (br_if $label$4 + (i32.eqz + (tee_local $6 + (select + (get_local $3) + (tee_local $6 + (i32.shr_s + (get_local $7) + (i32.const 3) + ) + ) + (i32.lt_u + (get_local $6) + (get_local $3) + ) + ) + ) + ) + ) + (br_if $label$2 + (i32.ge_u + (get_local $6) + (i32.const 268435456) + ) + ) + ) + (set_local $7 + (call $_Znwj + (i32.shl + (get_local $6) + (i32.const 4) + ) + ) + ) + (br $label$1) + ) + (set_local $8 + (i32.add + (get_local $0) + (i32.const 4) + ) + ) + (loop $label$7 + (i64.store offset=8 + (get_local $6) + (i64.const 1397703940) + ) + (i64.store + (get_local $6) + (i64.const 0) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 176) + ) + (set_local $5 + (i64.shr_u + (i64.load offset=8 + (get_local $6) + ) + (i64.const 8) + ) + ) + (set_local $6 + (i32.const 0) + ) + (block $label$8 + (block $label$9 + (loop $label$10 + (br_if $label$9 + (i32.gt_u + (i32.add + (i32.shl + (i32.wrap/i64 + (get_local $5) + ) + (i32.const 24) + ) + (i32.const -1073741825) + ) + (i32.const 452984830) + ) + ) + (block $label$11 + (br_if $label$11 + (i64.ne + (i64.and + (tee_local $5 + (i64.shr_u + (get_local $5) + (i64.const 8) + ) + ) + (i64.const 255) + ) + (i64.const 0) + ) + ) + (loop $label$12 + (br_if $label$9 + (i64.ne + (i64.and + (tee_local $5 + (i64.shr_u + (get_local $5) + (i64.const 8) + ) + ) + (i64.const 255) + ) + (i64.const 0) + ) + ) + (br_if $label$12 + (i32.lt_s + (tee_local $6 + (i32.add + (get_local $6) + (i32.const 1) + ) + ) + (i32.const 7) + ) + ) + ) + ) + (set_local $7 + (i32.const 1) + ) + (br_if $label$10 + (i32.lt_s + (tee_local $6 + (i32.add + (get_local $6) + (i32.const 1) + ) + ) + (i32.const 7) + ) + ) + (br $label$8) + ) + ) + (set_local $7 + (i32.const 0) + ) + ) + (call $eosio_assert + (get_local $7) + (i32.const 128) + ) + (i32.store + (get_local $8) + (tee_local $6 + (i32.add + (i32.load + (get_local $8) + ) + (i32.const 16) + ) + ) + ) + (br_if $label$7 + (tee_local $1 + (i32.add + (get_local $1) + (i32.const -1) + ) + ) + ) + (br $label$0) + ) + ) + (set_local $6 + (i32.const 0) + ) + (set_local $7 + (i32.const 0) + ) + (br $label$1) + ) + (call $_ZNKSt3__120__vector_base_commonILb1EE20__throw_length_errorEv + (get_local $0) + ) + (unreachable) + ) + (call $abort) + (unreachable) + ) + (set_local $3 + (i32.add + (get_local $7) + (i32.shl + (get_local $6) + (i32.const 4) + ) + ) + ) + (set_local $8 + (tee_local $2 + (i32.add + (get_local $7) + (i32.shl + (get_local $2) + (i32.const 4) + ) + ) + ) + ) + (loop $label$13 + (i64.store offset=8 + (get_local $8) + (i64.const 1397703940) + ) + (i64.store + (get_local $8) + (i64.const 0) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 176) + ) + (set_local $5 + (i64.shr_u + (i64.load offset=8 + (get_local $8) + ) + (i64.const 8) + ) + ) + (set_local $6 + (i32.const 0) + ) + (block $label$14 + (block $label$15 + (loop $label$16 + (br_if $label$15 + (i32.gt_u + (i32.add + (i32.shl + (i32.wrap/i64 + (get_local $5) + ) + (i32.const 24) + ) + (i32.const -1073741825) + ) + (i32.const 452984830) + ) + ) + (block $label$17 + (br_if $label$17 + (i64.ne + (i64.and + (tee_local $5 + (i64.shr_u + (get_local $5) + (i64.const 8) + ) + ) + (i64.const 255) + ) + (i64.const 0) + ) + ) + (loop $label$18 + (br_if $label$15 + (i64.ne + (i64.and + (tee_local $5 + (i64.shr_u + (get_local $5) + (i64.const 8) + ) + ) + (i64.const 255) + ) + (i64.const 0) + ) + ) + (br_if $label$18 + (i32.lt_s + (tee_local $6 + (i32.add + (get_local $6) + (i32.const 1) + ) + ) + (i32.const 7) + ) + ) + ) + ) + (set_local $7 + (i32.const 1) + ) + (br_if $label$16 + (i32.lt_s + (tee_local $6 + (i32.add + (get_local $6) + (i32.const 1) + ) + ) + (i32.const 7) + ) + ) + (br $label$14) + ) + ) + (set_local $7 + (i32.const 0) + ) + ) + (call $eosio_assert + (get_local $7) + (i32.const 128) + ) + (set_local $8 + (i32.add + (get_local $8) + (i32.const 16) + ) + ) + (br_if $label$13 + (tee_local $1 + (i32.add + (get_local $1) + (i32.const -1) + ) + ) + ) + ) + (set_local $1 + (i32.sub + (get_local $2) + (tee_local $7 + (i32.sub + (i32.load + (tee_local $4 + (i32.add + (get_local $0) + (i32.const 4) + ) + ) + ) + (tee_local $6 + (i32.load + (get_local $0) + ) + ) + ) + ) + ) + ) + (block $label$19 + (br_if $label$19 + (i32.lt_s + (get_local $7) + (i32.const 1) + ) + ) + (drop + (call $memcpy + (get_local $1) + (get_local $6) + (get_local $7) + ) + ) + (set_local $6 + (i32.load + (get_local $0) + ) + ) + ) + (i32.store + (get_local $0) + (get_local $1) + ) + (i32.store + (get_local $4) + (get_local $8) + ) + (i32.store + (i32.add + (get_local $0) + (i32.const 8) + ) + (get_local $3) + ) + (br_if $label$0 + (i32.eqz + (get_local $6) + ) + ) + (call $_ZdlPv + (get_local $6) + ) + (return) + ) + ) + (func $_ZN5boost6fusion6detail17for_each_unrolledILi3EE4callINS0_18std_tuple_iteratorIKNSt3__15tupleIJyN5eosio5assetEyEEELi0EEEZNS8_lsINS8_10datastreamIPcEEJyS9_yEEERT_SI_RKNS7_IJDpT0_EEEEUlRKSH_E_EEvSP_RKT0_ (param $0 i32) (param $1 i32) + (local $2 i32) + (local $3 i32) + (set_local $2 + (i32.load + (get_local $0) + ) + ) + (call $eosio_assert + (i32.gt_s + (i32.sub + (i32.load offset=8 + (tee_local $3 + (i32.load + (get_local $1) + ) + ) + ) + (i32.load offset=4 + (get_local $3) + ) + ) + (i32.const 7) + ) + (i32.const 400) + ) + (drop + (call $memcpy + (i32.load offset=4 + (get_local $3) + ) + (get_local $2) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $3) + (i32.add + (i32.load offset=4 + (get_local $3) + ) + (i32.const 8) + ) + ) + (set_local $0 + (i32.load + (get_local $0) + ) + ) + (call $eosio_assert + (i32.gt_s + (i32.sub + (i32.load offset=8 + (tee_local $3 + (i32.load + (get_local $1) + ) + ) + ) + (i32.load offset=4 + (get_local $3) + ) + ) + (i32.const 7) + ) + (i32.const 400) + ) + (drop + (call $memcpy + (i32.load offset=4 + (get_local $3) + ) + (i32.add + (get_local $0) + (i32.const 8) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $3) + (tee_local $2 + (i32.add + (i32.load offset=4 + (get_local $3) + ) + (i32.const 8) + ) + ) + ) + (call $eosio_assert + (i32.gt_s + (i32.sub + (i32.load offset=8 + (get_local $3) + ) + (get_local $2) + ) + (i32.const 7) + ) + (i32.const 400) + ) + (drop + (call $memcpy + (i32.load offset=4 + (get_local $3) + ) + (i32.add + (get_local $0) + (i32.const 16) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $3) + (i32.add + (i32.load offset=4 + (get_local $3) + ) + (i32.const 8) + ) + ) + (call $eosio_assert + (i32.gt_s + (i32.sub + (i32.load offset=8 + (tee_local $3 + (i32.load + (get_local $1) + ) + ) + ) + (i32.load offset=4 + (get_local $3) + ) + ) + (i32.const 7) + ) + (i32.const 400) + ) + (drop + (call $memcpy + (i32.load offset=4 + (get_local $3) + ) + (i32.add + (get_local $0) + (i32.const 24) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $3) + (i32.add + (i32.load offset=4 + (get_local $3) + ) + (i32.const 8) + ) + ) + ) + (func $_ZNK5eosio11multi_indexILy14289235522390851584ENS_5token13currency_statEJEE31load_object_by_primary_iteratorEl (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 i64) + (local $6 i32) + (local $7 i32) + (local $8 i32) + (local $9 i32) + (set_local $8 + (tee_local $9 + (i32.sub + (i32.load offset=4 + (i32.const 0) + ) + (i32.const 48) + ) + ) + ) + (i32.store offset=4 + (i32.const 0) + (get_local $9) + ) + (block $label$0 + (br_if $label$0 + (i32.eq + (tee_local $7 + (i32.load + (i32.add + (get_local $0) + (i32.const 28) + ) + ) + ) + (tee_local $2 + (i32.load offset=24 + (get_local $0) + ) + ) + ) + ) + (set_local $3 + (i32.sub + (i32.const 0) + (get_local $2) + ) + ) + (set_local $6 + (i32.add + (get_local $7) + (i32.const -24) + ) + ) + (loop $label$1 + (br_if $label$0 + (i32.eq + (i32.load + (i32.add + (get_local $6) + (i32.const 16) + ) + ) + (get_local $1) + ) + ) + (set_local $7 + (get_local $6) + ) + (set_local $6 + (tee_local $4 + (i32.add + (get_local $6) + (i32.const -24) + ) + ) + ) + (br_if $label$1 + (i32.ne + (i32.add + (get_local $4) + (get_local $3) + ) + (i32.const -24) + ) + ) + ) + ) + (block $label$2 + (block $label$3 + (br_if $label$3 + (i32.eq + (get_local $7) + (get_local $2) + ) + ) + (set_local $6 + (i32.load + (i32.add + (get_local $7) + (i32.const -24) + ) + ) + ) + (br $label$2) + ) + (call $eosio_assert + (i32.xor + (i32.shr_u + (tee_local $6 + (call $db_get_i64 + (get_local $1) + (i32.const 0) + (i32.const 0) + ) + ) + (i32.const 31) + ) + (i32.const 1) + ) + (i32.const 240) + ) + (block $label$4 + (block $label$5 + (br_if $label$5 + (i32.lt_u + (get_local $6) + (i32.const 513) + ) + ) + (set_local $4 + (call $malloc + (get_local $6) + ) + ) + (br $label$4) + ) + (i32.store offset=4 + (i32.const 0) + (tee_local $4 + (i32.sub + (get_local $9) + (i32.and + (i32.add + (get_local $6) + (i32.const 15) + ) + (i32.const -16) + ) + ) + ) + ) + ) + (drop + (call $db_get_i64 + (get_local $1) + (get_local $4) + (get_local $6) + ) + ) + (i32.store offset=12 + (get_local $8) + (get_local $4) + ) + (i32.store offset=8 + (get_local $8) + (get_local $4) + ) + (i32.store offset=16 + (get_local $8) + (i32.add + (get_local $4) + (get_local $6) + ) + ) + (block $label$6 + (br_if $label$6 + (i32.lt_u + (get_local $6) + (i32.const 513) + ) + ) + (call $free + (get_local $4) + ) + ) + (drop + (call $_ZN5eosio5token13currency_statC2Ev + (tee_local $6 + (call $_Znwj + (i32.const 56) + ) + ) + ) + ) + (i32.store offset=40 + (get_local $6) + (get_local $0) + ) + (i32.store offset=24 + (get_local $8) + (i32.add + (get_local $8) + (i32.const 8) + ) + ) + (i32.store offset=36 + (get_local $8) + (i32.add + (get_local $6) + (i32.const 16) + ) + ) + (i32.store offset=32 + (get_local $8) + (get_local $6) + ) + (i32.store offset=40 + (get_local $8) + (i32.add + (get_local $6) + (i32.const 32) + ) + ) + (call $_ZN5boost3pfr6detail19for_each_field_implINS1_14sequence_tuple5tupleIJRN5eosio5assetES7_RyEEEZNS5_rsINS5_10datastreamIPKcEENS5_5token13currency_statELPv0EEERT_SJ_RT0_EUlSJ_E_JLj0ELj1ELj2EEEEvSJ_OSK_NSt3__116integer_sequenceIjJXspT1_EEEENSO_17integral_constantIbLb0EEE + (i32.add + (get_local $8) + (i32.const 32) + ) + (i32.add + (get_local $8) + (i32.const 24) + ) + ) + (i32.store offset=44 + (get_local $6) + (get_local $1) + ) + (i32.store offset=24 + (get_local $8) + (get_local $6) + ) + (i64.store offset=32 + (get_local $8) + (tee_local $5 + (i64.shr_u + (i64.load offset=8 + (get_local $6) + ) + (i64.const 8) + ) + ) + ) + (i32.store offset=4 + (get_local $8) + (tee_local $7 + (i32.load offset=44 + (get_local $6) + ) + ) + ) + (block $label$7 + (block $label$8 + (br_if $label$8 + (i32.ge_u + (tee_local $4 + (i32.load + (tee_local $1 + (i32.add + (get_local $0) + (i32.const 28) + ) + ) + ) + ) + (i32.load + (i32.add + (get_local $0) + (i32.const 32) + ) + ) + ) + ) + (i64.store offset=8 + (get_local $4) + (get_local $5) + ) + (i32.store offset=16 + (get_local $4) + (get_local $7) + ) + (i32.store offset=24 + (get_local $8) + (i32.const 0) + ) + (i32.store + (get_local $4) + (get_local $6) + ) + (i32.store + (get_local $1) + (i32.add + (get_local $4) + (i32.const 24) + ) + ) + (br $label$7) + ) + (call $_ZNSt3__16vectorIN5eosio11multi_indexILy14289235522390851584ENS1_5token13currency_statEJEE8item_ptrENS_9allocatorIS6_EEE24__emplace_back_slow_pathIJNS_10unique_ptrINS5_4itemENS_14default_deleteISC_EEEERyRlEEEvDpOT_ + (i32.add + (get_local $0) + (i32.const 24) + ) + (i32.add + (get_local $8) + (i32.const 24) + ) + (i32.add + (get_local $8) + (i32.const 32) + ) + (i32.add + (get_local $8) + (i32.const 4) + ) + ) + ) + (set_local $4 + (i32.load offset=24 + (get_local $8) + ) + ) + (i32.store offset=24 + (get_local $8) + (i32.const 0) + ) + (br_if $label$2 + (i32.eqz + (get_local $4) + ) + ) + (call $_ZdlPv + (get_local $4) + ) + ) + (i32.store offset=4 + (i32.const 0) + (i32.add + (get_local $8) + (i32.const 48) + ) + ) + (get_local $6) + ) + (func $_ZN5eosio5token13currency_statC2Ev (param $0 i32) (result i32) + (local $1 i64) + (local $2 i32) + (local $3 i32) + (i64.store offset=8 + (get_local $0) + (i64.const 1397703940) + ) + (i64.store + (get_local $0) + (i64.const 0) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 176) + ) + (set_local $1 + (i64.shr_u + (i64.load offset=8 + (get_local $0) + ) + (i64.const 8) + ) + ) + (set_local $2 + (i32.const 0) + ) + (block $label$0 + (block $label$1 + (loop $label$2 + (br_if $label$1 + (i32.gt_u + (i32.add + (i32.shl + (i32.wrap/i64 + (get_local $1) + ) + (i32.const 24) + ) + (i32.const -1073741825) + ) + (i32.const 452984830) + ) + ) + (block $label$3 + (br_if $label$3 + (i64.ne + (i64.and + (tee_local $1 + (i64.shr_u + (get_local $1) + (i64.const 8) + ) + ) + (i64.const 255) + ) + (i64.const 0) + ) + ) + (loop $label$4 + (br_if $label$1 + (i64.ne + (i64.and + (tee_local $1 + (i64.shr_u + (get_local $1) + (i64.const 8) + ) + ) + (i64.const 255) + ) + (i64.const 0) + ) + ) + (br_if $label$4 + (i32.lt_s + (tee_local $2 + (i32.add + (get_local $2) + (i32.const 1) + ) + ) + (i32.const 7) + ) + ) + ) + ) + (set_local $3 + (i32.const 1) + ) + (br_if $label$2 + (i32.lt_s + (tee_local $2 + (i32.add + (get_local $2) + (i32.const 1) + ) + ) + (i32.const 7) + ) + ) + (br $label$0) + ) + ) + (set_local $3 + (i32.const 0) + ) + ) + (call $eosio_assert + (get_local $3) + (i32.const 128) + ) + (i64.store + (tee_local $2 + (i32.add + (get_local $0) + (i32.const 24) + ) + ) + (i64.const 1397703940) + ) + (i64.store offset=16 + (get_local $0) + (i64.const 0) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 176) + ) + (set_local $1 + (i64.shr_u + (i64.load + (get_local $2) + ) + (i64.const 8) + ) + ) + (set_local $2 + (i32.const 0) + ) + (block $label$5 + (block $label$6 + (loop $label$7 + (br_if $label$6 + (i32.gt_u + (i32.add + (i32.shl + (i32.wrap/i64 + (get_local $1) + ) + (i32.const 24) + ) + (i32.const -1073741825) + ) + (i32.const 452984830) + ) + ) + (block $label$8 + (br_if $label$8 + (i64.ne + (i64.and + (tee_local $1 + (i64.shr_u + (get_local $1) + (i64.const 8) + ) + ) + (i64.const 255) + ) + (i64.const 0) + ) + ) + (loop $label$9 + (br_if $label$6 + (i64.ne + (i64.and + (tee_local $1 + (i64.shr_u + (get_local $1) + (i64.const 8) + ) + ) + (i64.const 255) + ) + (i64.const 0) + ) + ) + (br_if $label$9 + (i32.lt_s + (tee_local $2 + (i32.add + (get_local $2) + (i32.const 1) + ) + ) + (i32.const 7) + ) + ) + ) + ) + (set_local $3 + (i32.const 1) + ) + (br_if $label$7 + (i32.lt_s + (tee_local $2 + (i32.add + (get_local $2) + (i32.const 1) + ) + ) + (i32.const 7) + ) + ) + (br $label$5) + ) + ) + (set_local $3 + (i32.const 0) + ) + ) + (call $eosio_assert + (get_local $3) + (i32.const 128) + ) + (get_local $0) + ) + (func $_ZN5boost3pfr6detail19for_each_field_implINS1_14sequence_tuple5tupleIJRN5eosio5assetES7_RyEEEZNS5_rsINS5_10datastreamIPKcEENS5_5token13currency_statELPv0EEERT_SJ_RT0_EUlSJ_E_JLj0ELj1ELj2EEEEvSJ_OSK_NSt3__116integer_sequenceIjJXspT1_EEEENSO_17integral_constantIbLb0EEE (param $0 i32) (param $1 i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (set_local $3 + (i32.load + (get_local $0) + ) + ) + (call $eosio_assert + (i32.gt_u + (i32.sub + (i32.load offset=8 + (tee_local $2 + (i32.load + (get_local $1) + ) + ) + ) + (i32.load offset=4 + (get_local $2) + ) + ) + (i32.const 7) + ) + (i32.const 272) + ) + (drop + (call $memcpy + (get_local $3) + (i32.load offset=4 + (get_local $2) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $2) + (tee_local $4 + (i32.add + (i32.load offset=4 + (get_local $2) + ) + (i32.const 8) + ) + ) + ) + (call $eosio_assert + (i32.gt_u + (i32.sub + (i32.load offset=8 + (get_local $2) + ) + (get_local $4) + ) + (i32.const 7) + ) + (i32.const 272) + ) + (drop + (call $memcpy + (i32.add + (get_local $3) + (i32.const 8) + ) + (i32.load offset=4 + (get_local $2) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $2) + (i32.add + (i32.load offset=4 + (get_local $2) + ) + (i32.const 8) + ) + ) + (set_local $3 + (i32.load offset=4 + (get_local $0) + ) + ) + (call $eosio_assert + (i32.gt_u + (i32.sub + (i32.load offset=8 + (tee_local $2 + (i32.load + (get_local $1) + ) + ) + ) + (i32.load offset=4 + (get_local $2) + ) + ) + (i32.const 7) + ) + (i32.const 272) + ) + (drop + (call $memcpy + (get_local $3) + (i32.load offset=4 + (get_local $2) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $2) + (tee_local $4 + (i32.add + (i32.load offset=4 + (get_local $2) + ) + (i32.const 8) + ) + ) + ) + (call $eosio_assert + (i32.gt_u + (i32.sub + (i32.load offset=8 + (get_local $2) + ) + (get_local $4) + ) + (i32.const 7) + ) + (i32.const 272) + ) + (drop + (call $memcpy + (i32.add + (get_local $3) + (i32.const 8) + ) + (i32.load offset=4 + (get_local $2) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $2) + (i32.add + (i32.load offset=4 + (get_local $2) + ) + (i32.const 8) + ) + ) + (set_local $0 + (i32.load offset=8 + (get_local $0) + ) + ) + (call $eosio_assert + (i32.gt_u + (i32.sub + (i32.load offset=8 + (tee_local $2 + (i32.load + (get_local $1) + ) + ) + ) + (i32.load offset=4 + (get_local $2) + ) + ) + (i32.const 7) + ) + (i32.const 272) + ) + (drop + (call $memcpy + (get_local $0) + (i32.load offset=4 + (get_local $2) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $2) + (i32.add + (i32.load offset=4 + (get_local $2) + ) + (i32.const 8) + ) + ) + ) + (func $_ZNSt3__16vectorIN5eosio11multi_indexILy14289235522390851584ENS1_5token13currency_statEJEE8item_ptrENS_9allocatorIS6_EEE24__emplace_back_slow_pathIJNS_10unique_ptrINS5_4itemENS_14default_deleteISC_EEEERyRlEEEvDpOT_ (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (block $label$0 + (block $label$1 + (br_if $label$1 + (i32.ge_u + (tee_local $5 + (i32.add + (tee_local $4 + (i32.div_s + (i32.sub + (i32.load offset=4 + (get_local $0) + ) + (tee_local $6 + (i32.load + (get_local $0) + ) + ) + ) + (i32.const 24) + ) + ) + (i32.const 1) + ) + ) + (i32.const 178956971) + ) + ) + (set_local $7 + (i32.const 178956970) + ) + (block $label$2 + (block $label$3 + (br_if $label$3 + (i32.gt_u + (tee_local $6 + (i32.div_s + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (get_local $6) + ) + (i32.const 24) + ) + ) + (i32.const 89478484) + ) + ) + (br_if $label$2 + (i32.eqz + (tee_local $7 + (select + (get_local $5) + (tee_local $7 + (i32.shl + (get_local $6) + (i32.const 1) + ) + ) + (i32.lt_u + (get_local $7) + (get_local $5) + ) + ) + ) + ) + ) + ) + (set_local $6 + (call $_Znwj + (i32.mul + (get_local $7) + (i32.const 24) + ) + ) + ) + (br $label$0) + ) + (set_local $7 + (i32.const 0) + ) + (set_local $6 + (i32.const 0) + ) + (br $label$0) + ) + (call $_ZNKSt3__120__vector_base_commonILb1EE20__throw_length_errorEv + (get_local $0) + ) + (unreachable) + ) + (set_local $5 + (i32.load + (get_local $1) + ) + ) + (i32.store + (get_local $1) + (i32.const 0) + ) + (i32.store + (tee_local $1 + (i32.add + (get_local $6) + (i32.mul + (get_local $4) + (i32.const 24) + ) + ) + ) + (get_local $5) + ) + (i64.store offset=8 + (get_local $1) + (i64.load + (get_local $2) + ) + ) + (i32.store offset=16 + (get_local $1) + (i32.load + (get_local $3) + ) + ) + (set_local $4 + (i32.add + (get_local $6) + (i32.mul + (get_local $7) + (i32.const 24) + ) + ) + ) + (set_local $5 + (i32.add + (get_local $1) + (i32.const 24) + ) + ) + (block $label$4 + (block $label$5 + (br_if $label$5 + (i32.eq + (tee_local $6 + (i32.load + (i32.add + (get_local $0) + (i32.const 4) + ) + ) + ) + (tee_local $7 + (i32.load + (get_local $0) + ) + ) + ) + ) + (loop $label$6 + (set_local $3 + (i32.load + (tee_local $2 + (i32.add + (get_local $6) + (i32.const -24) + ) + ) + ) + ) + (i32.store + (get_local $2) + (i32.const 0) + ) + (i32.store + (i32.add + (get_local $1) + (i32.const -24) + ) + (get_local $3) + ) + (i32.store + (i32.add + (get_local $1) + (i32.const -8) + ) + (i32.load + (i32.add + (get_local $6) + (i32.const -8) + ) + ) + ) + (i32.store + (i32.add + (get_local $1) + (i32.const -12) + ) + (i32.load + (i32.add + (get_local $6) + (i32.const -12) + ) + ) + ) + (i32.store + (i32.add + (get_local $1) + (i32.const -16) + ) + (i32.load + (i32.add + (get_local $6) + (i32.const -16) + ) + ) + ) + (set_local $1 + (i32.add + (get_local $1) + (i32.const -24) + ) + ) + (set_local $6 + (get_local $2) + ) + (br_if $label$6 + (i32.ne + (get_local $7) + (get_local $2) + ) + ) + ) + (set_local $7 + (i32.load + (i32.add + (get_local $0) + (i32.const 4) + ) + ) + ) + (set_local $6 + (i32.load + (get_local $0) + ) + ) + (br $label$4) + ) + (set_local $6 + (get_local $7) + ) + ) + (i32.store + (get_local $0) + (get_local $1) + ) + (i32.store + (i32.add + (get_local $0) + (i32.const 4) + ) + (get_local $5) + ) + (i32.store + (i32.add + (get_local $0) + (i32.const 8) + ) + (get_local $4) + ) + (block $label$7 + (br_if $label$7 + (i32.eq + (get_local $7) + (get_local $6) + ) + ) + (loop $label$8 + (set_local $1 + (i32.load + (tee_local $7 + (i32.add + (get_local $7) + (i32.const -24) + ) + ) + ) + ) + (i32.store + (get_local $7) + (i32.const 0) + ) + (block $label$9 + (br_if $label$9 + (i32.eqz + (get_local $1) + ) + ) + (call $_ZdlPv + (get_local $1) + ) + ) + (br_if $label$8 + (i32.ne + (get_local $6) + (get_local $7) + ) + ) + ) + ) + (block $label$10 + (br_if $label$10 + (i32.eqz + (get_local $6) + ) + ) + (call $_ZdlPv + (get_local $6) + ) + ) + ) + (func $_ZZN5eosio11multi_indexILy14781000756567736320EN6eoswin10token_itemEJEE7emplaceIZNS1_7lottery22snapshot_token_balanceEvE4$_18EENS3_14const_iteratorEyOT_ENKUlRS8_E_clINS3_4itemEEEDaSA_ (param $0 i32) (param $1 i32) + (local $2 i32) + (local $3 i64) + (local $4 i64) + (local $5 i64) + (local $6 i32) + (local $7 i32) + (local $8 i32) + (local $9 i32) + (set_local $8 + (tee_local $9 + (i32.load offset=4 + (i32.const 0) + ) + ) + ) + (set_local $4 + (i64.load offset=8 + (i32.add + (i32.load + (i32.add + (tee_local $6 + (i32.load offset=4 + (get_local $0) + ) + ) + (i32.const 4) + ) + ) + (i32.shl + (i32.load + (i32.load + (i32.add + (get_local $6) + (i32.const 8) + ) + ) + ) + (i32.const 4) + ) + ) + ) + ) + (set_local $2 + (i32.load + (get_local $0) + ) + ) + (call $eosio_assert + (i64.lt_u + (i64.add + (tee_local $3 + (i64.load + (i32.load + (get_local $6) + ) + ) + ) + (i64.const 4611686018427387903) + ) + (i64.const 9223372036854775807) + ) + (i32.const 176) + ) + (set_local $5 + (i64.shr_u + (get_local $4) + (i64.const 8) + ) + ) + (set_local $6 + (i32.const 0) + ) + (block $label$0 + (block $label$1 + (loop $label$2 + (br_if $label$1 + (i32.gt_u + (i32.add + (i32.shl + (i32.wrap/i64 + (get_local $5) + ) + (i32.const 24) + ) + (i32.const -1073741825) + ) + (i32.const 452984830) + ) + ) + (block $label$3 + (br_if $label$3 + (i64.ne + (i64.and + (tee_local $5 + (i64.shr_u + (get_local $5) + (i64.const 8) + ) + ) + (i64.const 255) + ) + (i64.const 0) + ) + ) + (loop $label$4 + (br_if $label$1 + (i64.ne + (i64.and + (tee_local $5 + (i64.shr_u + (get_local $5) + (i64.const 8) + ) + ) + (i64.const 255) + ) + (i64.const 0) + ) + ) + (br_if $label$4 + (i32.lt_s + (tee_local $6 + (i32.add + (get_local $6) + (i32.const 1) + ) + ) + (i32.const 7) + ) + ) + ) + ) + (set_local $7 + (i32.const 1) + ) + (br_if $label$2 + (i32.lt_s + (tee_local $6 + (i32.add + (get_local $6) + (i32.const 1) + ) + ) + (i32.const 7) + ) + ) + (br $label$0) + ) + ) + (set_local $7 + (i32.const 0) + ) + ) + (call $eosio_assert + (get_local $7) + (i32.const 128) + ) + (i64.store offset=8 + (get_local $1) + (get_local $4) + ) + (i64.store + (get_local $1) + (get_local $3) + ) + (i32.store offset=4 + (i32.const 0) + (tee_local $6 + (i32.add + (tee_local $7 + (get_local $9) + ) + (i32.const -16) + ) + ) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 400) + ) + (drop + (call $memcpy + (get_local $6) + (get_local $1) + (i32.const 8) + ) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 400) + ) + (drop + (call $memcpy + (i32.add + (get_local $7) + (i32.const -8) + ) + (i32.add + (get_local $1) + (i32.const 8) + ) + (i32.const 8) + ) + ) + (i32.store offset=20 + (get_local $1) + (call $db_store_i64 + (i64.load offset=8 + (get_local $2) + ) + (i64.const -3665743317141815296) + (i64.load + (i32.load offset=8 + (get_local $0) + ) + ) + (tee_local $5 + (i64.shr_u + (i64.load offset=8 + (get_local $1) + ) + (i64.const 8) + ) + ) + (get_local $6) + (i32.const 16) + ) + ) + (block $label$5 + (br_if $label$5 + (i64.lt_u + (get_local $5) + (i64.load offset=16 + (get_local $2) + ) + ) + ) + (i64.store + (i32.add + (get_local $2) + (i32.const 16) + ) + (i64.add + (get_local $5) + (i64.const 1) + ) + ) + ) + (i32.store offset=4 + (i32.const 0) + (get_local $8) + ) + ) + (func $_ZN5eosio11multi_indexILy14781000756567736320EN6eoswin10token_itemEJEE6modifyIZNS1_7lottery22snapshot_token_balanceEvE4$_19EEvRKS2_yOT_ (param $0 i32) (param $1 i32) (param $2 i32) + (local $3 i64) + (local $4 i64) + (local $5 i64) + (local $6 i64) + (local $7 i64) + (local $8 i32) + (local $9 i32) + (local $10 i32) + (set_local $9 + (tee_local $10 + (i32.load offset=4 + (i32.const 0) + ) + ) + ) + (call $eosio_assert + (i32.eq + (i32.load offset=16 + (get_local $1) + ) + (get_local $0) + ) + (i32.const 416) + ) + (call $eosio_assert + (i64.eq + (i64.load + (get_local $0) + ) + (call $current_receiver) + ) + (i32.const 464) + ) + (set_local $5 + (i64.load offset=8 + (i32.add + (i32.load + (i32.add + (get_local $2) + (i32.const 4) + ) + ) + (i32.shl + (i32.load + (i32.load + (i32.add + (get_local $2) + (i32.const 8) + ) + ) + ) + (i32.const 4) + ) + ) + ) + ) + (set_local $7 + (i64.load offset=8 + (get_local $1) + ) + ) + (call $eosio_assert + (i64.lt_u + (i64.add + (tee_local $4 + (i64.load + (i32.load + (get_local $2) + ) + ) + ) + (i64.const 4611686018427387903) + ) + (i64.const 9223372036854775807) + ) + (i32.const 176) + ) + (set_local $3 + (i64.shr_u + (get_local $7) + (i64.const 8) + ) + ) + (set_local $2 + (i32.const 0) + ) + (set_local $7 + (tee_local $6 + (i64.shr_u + (get_local $5) + (i64.const 8) + ) + ) + ) + (block $label$0 + (block $label$1 + (loop $label$2 + (br_if $label$1 + (i32.gt_u + (i32.add + (i32.shl + (i32.wrap/i64 + (get_local $7) + ) + (i32.const 24) + ) + (i32.const -1073741825) + ) + (i32.const 452984830) + ) + ) + (block $label$3 + (br_if $label$3 + (i64.ne + (i64.and + (tee_local $7 + (i64.shr_u + (get_local $7) + (i64.const 8) + ) + ) + (i64.const 255) + ) + (i64.const 0) + ) + ) + (loop $label$4 + (br_if $label$1 + (i64.ne + (i64.and + (tee_local $7 + (i64.shr_u + (get_local $7) + (i64.const 8) + ) + ) + (i64.const 255) + ) + (i64.const 0) + ) + ) + (br_if $label$4 + (i32.lt_s + (tee_local $2 + (i32.add + (get_local $2) + (i32.const 1) + ) + ) + (i32.const 7) + ) + ) + ) + ) + (set_local $8 + (i32.const 1) + ) + (br_if $label$2 + (i32.lt_s + (tee_local $2 + (i32.add + (get_local $2) + (i32.const 1) + ) + ) + (i32.const 7) + ) + ) + (br $label$0) + ) + ) + (set_local $8 + (i32.const 0) + ) + ) + (call $eosio_assert + (get_local $8) + (i32.const 128) + ) + (i64.store + (tee_local $8 + (i32.add + (get_local $1) + (i32.const 8) + ) + ) + (get_local $5) + ) + (i64.store + (get_local $1) + (get_local $4) + ) + (call $eosio_assert + (i64.eq + (get_local $3) + (get_local $6) + ) + (i32.const 528) + ) + (i32.store offset=4 + (i32.const 0) + (tee_local $2 + (i32.add + (tee_local $10 + (get_local $10) + ) + (i32.const -16) + ) + ) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 400) + ) + (drop + (call $memcpy + (get_local $2) + (get_local $1) + (i32.const 8) + ) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 400) + ) + (drop + (call $memcpy + (i32.add + (get_local $10) + (i32.const -8) + ) + (get_local $8) + (i32.const 8) + ) + ) + (call $db_update_i64 + (i32.load offset=20 + (get_local $1) + ) + (i64.const 0) + (get_local $2) + (i32.const 16) + ) + (block $label$5 + (br_if $label$5 + (i64.lt_u + (get_local $3) + (i64.load offset=16 + (get_local $0) + ) + ) + ) + (i64.store + (i32.add + (get_local $0) + (i32.const 16) + ) + (i64.add + (get_local $3) + (i64.const 1) + ) + ) + ) + (i32.store offset=4 + (i32.const 0) + (get_local $9) + ) + ) + (func $_ZNSt3__16vectorIN5eosio11multi_indexILy5382478059301502976ENS1_5token6detailEJEE8item_ptrENS_9allocatorIS6_EEE24__emplace_back_slow_pathIJNS_10unique_ptrINS5_4itemENS_14default_deleteISC_EEEERyRlEEEvDpOT_ (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (block $label$0 + (block $label$1 + (br_if $label$1 + (i32.ge_u + (tee_local $5 + (i32.add + (tee_local $4 + (i32.div_s + (i32.sub + (i32.load offset=4 + (get_local $0) + ) + (tee_local $6 + (i32.load + (get_local $0) + ) + ) + ) + (i32.const 24) + ) + ) + (i32.const 1) + ) + ) + (i32.const 178956971) + ) + ) + (set_local $7 + (i32.const 178956970) + ) + (block $label$2 + (block $label$3 + (br_if $label$3 + (i32.gt_u + (tee_local $6 + (i32.div_s + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (get_local $6) + ) + (i32.const 24) + ) + ) + (i32.const 89478484) + ) + ) + (br_if $label$2 + (i32.eqz + (tee_local $7 + (select + (get_local $5) + (tee_local $7 + (i32.shl + (get_local $6) + (i32.const 1) + ) + ) + (i32.lt_u + (get_local $7) + (get_local $5) + ) + ) + ) + ) + ) + ) + (set_local $6 + (call $_Znwj + (i32.mul + (get_local $7) + (i32.const 24) + ) + ) + ) + (br $label$0) + ) + (set_local $7 + (i32.const 0) + ) + (set_local $6 + (i32.const 0) + ) + (br $label$0) + ) + (call $_ZNKSt3__120__vector_base_commonILb1EE20__throw_length_errorEv + (get_local $0) + ) + (unreachable) + ) + (set_local $5 + (i32.load + (get_local $1) + ) + ) + (i32.store + (get_local $1) + (i32.const 0) + ) + (i32.store + (tee_local $1 + (i32.add + (get_local $6) + (i32.mul + (get_local $4) + (i32.const 24) + ) + ) + ) + (get_local $5) + ) + (i64.store offset=8 + (get_local $1) + (i64.load + (get_local $2) + ) + ) + (i32.store offset=16 + (get_local $1) + (i32.load + (get_local $3) + ) + ) + (set_local $4 + (i32.add + (get_local $6) + (i32.mul + (get_local $7) + (i32.const 24) + ) + ) + ) + (set_local $5 + (i32.add + (get_local $1) + (i32.const 24) + ) + ) + (block $label$4 + (block $label$5 + (br_if $label$5 + (i32.eq + (tee_local $6 + (i32.load + (i32.add + (get_local $0) + (i32.const 4) + ) + ) + ) + (tee_local $7 + (i32.load + (get_local $0) + ) + ) + ) + ) + (loop $label$6 + (set_local $3 + (i32.load + (tee_local $2 + (i32.add + (get_local $6) + (i32.const -24) + ) + ) + ) + ) + (i32.store + (get_local $2) + (i32.const 0) + ) + (i32.store + (i32.add + (get_local $1) + (i32.const -24) + ) + (get_local $3) + ) + (i32.store + (i32.add + (get_local $1) + (i32.const -8) + ) + (i32.load + (i32.add + (get_local $6) + (i32.const -8) + ) + ) + ) + (i32.store + (i32.add + (get_local $1) + (i32.const -12) + ) + (i32.load + (i32.add + (get_local $6) + (i32.const -12) + ) + ) + ) + (i32.store + (i32.add + (get_local $1) + (i32.const -16) + ) + (i32.load + (i32.add + (get_local $6) + (i32.const -16) + ) + ) + ) + (set_local $1 + (i32.add + (get_local $1) + (i32.const -24) + ) + ) + (set_local $6 + (get_local $2) + ) + (br_if $label$6 + (i32.ne + (get_local $7) + (get_local $2) + ) + ) + ) + (set_local $7 + (i32.load + (i32.add + (get_local $0) + (i32.const 4) + ) + ) + ) + (set_local $6 + (i32.load + (get_local $0) + ) + ) + (br $label$4) + ) + (set_local $6 + (get_local $7) + ) + ) + (i32.store + (get_local $0) + (get_local $1) + ) + (i32.store + (i32.add + (get_local $0) + (i32.const 4) + ) + (get_local $5) + ) + (i32.store + (i32.add + (get_local $0) + (i32.const 8) + ) + (get_local $4) + ) + (block $label$7 + (br_if $label$7 + (i32.eq + (get_local $7) + (get_local $6) + ) + ) + (loop $label$8 + (set_local $1 + (i32.load + (tee_local $7 + (i32.add + (get_local $7) + (i32.const -24) + ) + ) + ) + ) + (i32.store + (get_local $7) + (i32.const 0) + ) + (block $label$9 + (br_if $label$9 + (i32.eqz + (get_local $1) + ) + ) + (call $_ZdlPv + (get_local $1) + ) + ) + (br_if $label$8 + (i32.ne + (get_local $6) + (get_local $7) + ) + ) + ) + ) + (block $label$10 + (br_if $label$10 + (i32.eqz + (get_local $6) + ) + ) + (call $_ZdlPv + (get_local $6) + ) + ) + ) + (func $_ZN6eoswin7lottery11eraseclaimsEv (type $FUNCSIG$vi) (param $0 i32) + (local $1 i32) + (local $2 i32) + (local $3 i32) + (local $4 i64) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (local $8 i32) + (local $9 i32) + (local $10 i32) + (i32.store offset=4 + (i32.const 0) + (tee_local $10 + (i32.sub + (i32.load offset=4 + (i32.const 0) + ) + (i32.const 96) + ) + ) + ) + (call $require_auth + (i64.load + (get_local $0) + ) + ) + (i32.store + (i32.add + (get_local $10) + (i32.const 48) + ) + (i32.const 0) + ) + (i64.store offset=32 + (get_local $10) + (i64.const -1) + ) + (i64.store offset=16 + (get_local $10) + (tee_local $4 + (i64.load + (get_local $0) + ) + ) + ) + (i64.store offset=24 + (get_local $10) + (get_local $4) + ) + (i64.store offset=40 + (get_local $10) + (i64.const 0) + ) + (block $label$0 + (block $label$1 + (br_if $label$1 + (i32.le_s + (tee_local $3 + (call $db_lowerbound_i64 + (get_local $4) + (get_local $4) + (i64.const 4921565091335241728) + (i64.const 0) + ) + ) + (i32.const -1) + ) + ) + (i32.store offset=12 + (get_local $10) + (call $_ZNK5eosio11multi_indexILy4921565091335241728EN6eoswin10claim_itemEJEE31load_object_by_primary_iteratorEl + (i32.add + (get_local $10) + (i32.const 16) + ) + (get_local $3) + ) + ) + (set_local $2 + (i32.add + (get_local $0) + (i32.const 312) + ) + ) + (set_local $1 + (i32.add + (get_local $0) + (i32.const 288) + ) + ) + (i32.store offset=8 + (get_local $10) + (i32.add + (get_local $10) + (i32.const 16) + ) + ) + (set_local $6 + (i32.add + (get_local $10) + (i32.const 72) + ) + ) + (set_local $7 + (i32.add + (get_local $0) + (i32.const 320) + ) + ) + (set_local $8 + (i32.add + (get_local $0) + (i32.const 316) + ) + ) + (loop $label$2 + (set_local $4 + (i64.load + (get_local $0) + ) + ) + (i32.store + (get_local $10) + (i32.add + (get_local $10) + (i32.const 8) + ) + ) + (i64.store offset=88 + (get_local $10) + (get_local $4) + ) + (call $eosio_assert + (i64.eq + (i64.load + (get_local $1) + ) + (call $current_receiver) + ) + (i32.const 336) + ) + (i32.store offset=64 + (get_local $10) + (get_local $1) + ) + (i32.store + (get_local $6) + (i32.add + (get_local $10) + (i32.const 88) + ) + ) + (i32.store offset=68 + (get_local $10) + (get_local $10) + ) + (i32.store offset=24 + (tee_local $3 + (call $_Znwj + (i32.const 56) + ) + ) + (i32.const 0) + ) + (i64.store offset=16 align=4 + (get_local $3) + (i64.const 0) + ) + (i32.store offset=40 + (get_local $3) + (get_local $1) + ) + (call $_ZZN5eosio11multi_indexILy5455799419175698432EN6eoswin13dividend_itemEJEE7emplaceIZNS1_7lottery11eraseclaimsEvE4$_17EENS3_14const_iteratorEyOT_ENKUlRS8_E_clINS3_4itemEEEDaSA_ + (i32.add + (get_local $10) + (i32.const 64) + ) + (get_local $3) + ) + (i32.store offset=80 + (get_local $10) + (get_local $3) + ) + (i64.store offset=64 + (get_local $10) + (tee_local $4 + (i64.load + (get_local $3) + ) + ) + ) + (i32.store offset=60 + (get_local $10) + (tee_local $9 + (i32.load offset=44 + (get_local $3) + ) + ) + ) + (block $label$3 + (block $label$4 + (br_if $label$4 + (i32.ge_u + (tee_local $5 + (i32.load + (get_local $8) + ) + ) + (i32.load + (get_local $7) + ) + ) + ) + (i64.store offset=8 + (get_local $5) + (get_local $4) + ) + (i32.store offset=16 + (get_local $5) + (get_local $9) + ) + (i32.store offset=80 + (get_local $10) + (i32.const 0) + ) + (i32.store + (get_local $5) + (get_local $3) + ) + (i32.store + (get_local $8) + (i32.add + (get_local $5) + (i32.const 24) + ) + ) + (br $label$3) + ) + (call $_ZNSt3__16vectorIN5eosio11multi_indexILy5455799419175698432EN6eoswin13dividend_itemEJEE8item_ptrENS_9allocatorIS6_EEE24__emplace_back_slow_pathIJNS_10unique_ptrINS5_4itemENS_14default_deleteISC_EEEERyRlEEEvDpOT_ + (get_local $2) + (i32.add + (get_local $10) + (i32.const 80) + ) + (i32.add + (get_local $10) + (i32.const 64) + ) + (i32.add + (get_local $10) + (i32.const 60) + ) + ) + ) + (set_local $3 + (i32.load offset=80 + (get_local $10) + ) + ) + (i32.store offset=80 + (get_local $10) + (i32.const 0) + ) + (block $label$5 + (br_if $label$5 + (i32.eqz + (get_local $3) + ) + ) + (block $label$6 + (br_if $label$6 + (i32.eqz + (tee_local $5 + (i32.load offset=16 + (get_local $3) + ) + ) + ) + ) + (i32.store + (i32.add + (get_local $3) + (i32.const 20) + ) + (get_local $5) + ) + (call $_ZdlPv + (get_local $5) + ) + ) + (call $_ZdlPv + (get_local $3) + ) + ) + (set_local $3 + (i32.const 0) + ) + (call $eosio_assert + (tee_local $9 + (i32.ne + (tee_local $5 + (i32.wrap/i64 + (i64.shr_u + (tee_local $4 + (i64.load offset=8 + (get_local $10) + ) + ) + (i64.const 32) + ) + ) + ) + (i32.const 0) + ) + ) + (i32.const 2560) + ) + (call $eosio_assert + (get_local $9) + (i32.const 1344) + ) + (block $label$7 + (br_if $label$7 + (i32.lt_s + (tee_local $9 + (call $db_next_i64 + (i32.load offset=44 + (get_local $5) + ) + (i32.add + (get_local $10) + (i32.const 64) + ) + ) + ) + (i32.const 0) + ) + ) + (set_local $3 + (call $_ZNK5eosio11multi_indexILy4921565091335241728EN6eoswin10claim_itemEJEE31load_object_by_primary_iteratorEl + (i32.wrap/i64 + (get_local $4) + ) + (get_local $9) + ) + ) + ) + (call $_ZN5eosio11multi_indexILy4921565091335241728EN6eoswin10claim_itemEJEE5eraseERKS2_ + (i32.add + (get_local $10) + (i32.const 16) + ) + (get_local $5) + ) + (i64.store offset=8 + (get_local $10) + (i64.or + (i64.shl + (i64.extend_u/i32 + (get_local $3) + ) + (i64.const 32) + ) + (i64.and + (get_local $4) + (i64.const 4294967295) + ) + ) + ) + (br_if $label$2 + (get_local $3) + ) + (br $label$0) + ) + ) + (i32.store offset=12 + (get_local $10) + (i32.const 0) + ) + (i32.store offset=8 + (get_local $10) + (i32.add + (get_local $10) + (i32.const 16) + ) + ) + ) + (block $label$8 + (br_if $label$8 + (i32.eqz + (tee_local $5 + (i32.load offset=40 + (get_local $10) + ) + ) + ) + ) + (block $label$9 + (block $label$10 + (br_if $label$10 + (i32.eq + (tee_local $3 + (i32.load + (tee_local $9 + (i32.add + (get_local $10) + (i32.const 44) + ) + ) + ) + ) + (get_local $5) + ) + ) + (loop $label$11 + (set_local $1 + (i32.load + (tee_local $3 + (i32.add + (get_local $3) + (i32.const -24) + ) + ) + ) + ) + (i32.store + (get_local $3) + (i32.const 0) + ) + (block $label$12 + (br_if $label$12 + (i32.eqz + (get_local $1) + ) + ) + (call $_ZdlPv + (get_local $1) + ) + ) + (br_if $label$11 + (i32.ne + (get_local $5) + (get_local $3) + ) + ) + ) + (set_local $3 + (i32.load + (i32.add + (get_local $10) + (i32.const 40) + ) + ) + ) + (br $label$9) + ) + (set_local $3 + (get_local $5) + ) + ) + (i32.store + (get_local $9) + (get_local $5) + ) + (call $_ZdlPv + (get_local $3) + ) + ) + (i32.store offset=4 + (i32.const 0) + (i32.add + (get_local $10) + (i32.const 96) + ) + ) + ) + (func $_ZNK5eosio11multi_indexILy4921565091335241728EN6eoswin10claim_itemEJEE31load_object_by_primary_iteratorEl (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i64) + (local $8 i32) + (local $9 i32) + (set_local $8 + (tee_local $9 + (i32.sub + (i32.load offset=4 + (i32.const 0) + ) + (i32.const 48) + ) + ) + ) + (i32.store offset=4 + (i32.const 0) + (get_local $9) + ) + (block $label$0 + (br_if $label$0 + (i32.eq + (tee_local $6 + (i32.load + (i32.add + (get_local $0) + (i32.const 28) + ) + ) + ) + (tee_local $2 + (i32.load offset=24 + (get_local $0) + ) + ) + ) + ) + (set_local $3 + (i32.sub + (i32.const 0) + (get_local $2) + ) + ) + (set_local $5 + (i32.add + (get_local $6) + (i32.const -24) + ) + ) + (loop $label$1 + (br_if $label$0 + (i32.eq + (i32.load + (i32.add + (get_local $5) + (i32.const 16) + ) + ) + (get_local $1) + ) + ) + (set_local $6 + (get_local $5) + ) + (set_local $5 + (tee_local $4 + (i32.add + (get_local $5) + (i32.const -24) + ) + ) + ) + (br_if $label$1 + (i32.ne + (i32.add + (get_local $4) + (get_local $3) + ) + (i32.const -24) + ) + ) + ) + ) + (block $label$2 + (block $label$3 + (br_if $label$3 + (i32.eq + (get_local $6) + (get_local $2) + ) + ) + (set_local $4 + (i32.load + (i32.add + (get_local $6) + (i32.const -24) + ) + ) + ) + (br $label$2) + ) + (call $eosio_assert + (i32.xor + (i32.shr_u + (tee_local $5 + (call $db_get_i64 + (get_local $1) + (i32.const 0) + (i32.const 0) + ) + ) + (i32.const 31) + ) + (i32.const 1) + ) + (i32.const 240) + ) + (block $label$4 + (block $label$5 + (br_if $label$5 + (i32.lt_u + (get_local $5) + (i32.const 513) + ) + ) + (set_local $4 + (call $malloc + (get_local $5) + ) + ) + (br $label$4) + ) + (i32.store offset=4 + (i32.const 0) + (tee_local $4 + (i32.sub + (get_local $9) + (i32.and + (i32.add + (get_local $5) + (i32.const 15) + ) + (i32.const -16) + ) + ) + ) + ) + ) + (drop + (call $db_get_i64 + (get_local $1) + (get_local $4) + (get_local $5) + ) + ) + (i32.store offset=36 + (get_local $8) + (get_local $4) + ) + (i32.store offset=32 + (get_local $8) + (get_local $4) + ) + (i32.store offset=40 + (get_local $8) + (i32.add + (get_local $4) + (get_local $5) + ) + ) + (block $label$6 + (br_if $label$6 + (i32.lt_u + (get_local $5) + (i32.const 513) + ) + ) + (call $free + (get_local $4) + ) + ) + (set_local $3 + (i32.add + (get_local $0) + (i32.const 24) + ) + ) + (i64.store offset=24 + (tee_local $4 + (call $_Znwj + (i32.const 56) + ) + ) + (i64.const 1397703940) + ) + (i64.store offset=16 + (get_local $4) + (i64.const 0) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 176) + ) + (set_local $7 + (i64.const 5459781) + ) + (set_local $5 + (i32.const 0) + ) + (block $label$7 + (block $label$8 + (loop $label$9 + (br_if $label$8 + (i32.gt_u + (i32.add + (i32.shl + (i32.wrap/i64 + (get_local $7) + ) + (i32.const 24) + ) + (i32.const -1073741825) + ) + (i32.const 452984830) + ) + ) + (block $label$10 + (br_if $label$10 + (i64.ne + (i64.and + (tee_local $7 + (i64.shr_u + (get_local $7) + (i64.const 8) + ) + ) + (i64.const 255) + ) + (i64.const 0) + ) + ) + (loop $label$11 + (br_if $label$8 + (i64.ne + (i64.and + (tee_local $7 + (i64.shr_u + (get_local $7) + (i64.const 8) + ) + ) + (i64.const 255) + ) + (i64.const 0) + ) + ) + (br_if $label$11 + (i32.lt_s + (tee_local $5 + (i32.add + (get_local $5) + (i32.const 1) + ) + ) + (i32.const 7) + ) + ) + ) + ) + (set_local $6 + (i32.const 1) + ) + (br_if $label$9 + (i32.lt_s + (tee_local $5 + (i32.add + (get_local $5) + (i32.const 1) + ) + ) + (i32.const 7) + ) + ) + (br $label$7) + ) + ) + (set_local $6 + (i32.const 0) + ) + ) + (call $eosio_assert + (get_local $6) + (i32.const 128) + ) + (i32.store offset=40 + (get_local $4) + (get_local $0) + ) + (drop + (call $_ZN6eoswinrsIN5eosio10datastreamIPKcEEEERT_S7_RNS_10claim_itemE + (i32.add + (get_local $8) + (i32.const 32) + ) + (get_local $4) + ) + ) + (i32.store offset=44 + (get_local $4) + (get_local $1) + ) + (i32.store offset=24 + (get_local $8) + (get_local $4) + ) + (i64.store offset=16 + (get_local $8) + (tee_local $7 + (i64.load + (get_local $4) + ) + ) + ) + (i32.store offset=12 + (get_local $8) + (tee_local $6 + (i32.load offset=44 + (get_local $4) + ) + ) + ) + (block $label$12 + (block $label$13 + (br_if $label$13 + (i32.ge_u + (tee_local $5 + (i32.load + (tee_local $1 + (i32.add + (get_local $0) + (i32.const 28) + ) + ) + ) + ) + (i32.load + (i32.add + (get_local $0) + (i32.const 32) + ) + ) + ) + ) + (i64.store offset=8 + (get_local $5) + (get_local $7) + ) + (i32.store offset=16 + (get_local $5) + (get_local $6) + ) + (i32.store offset=24 + (get_local $8) + (i32.const 0) + ) + (i32.store + (get_local $5) + (get_local $4) + ) + (i32.store + (get_local $1) + (i32.add + (get_local $5) + (i32.const 24) + ) + ) + (br $label$12) + ) + (call $_ZNSt3__16vectorIN5eosio11multi_indexILy4921565091335241728EN6eoswin10claim_itemEJEE8item_ptrENS_9allocatorIS6_EEE24__emplace_back_slow_pathIJNS_10unique_ptrINS5_4itemENS_14default_deleteISC_EEEERyRlEEEvDpOT_ + (get_local $3) + (i32.add + (get_local $8) + (i32.const 24) + ) + (i32.add + (get_local $8) + (i32.const 16) + ) + (i32.add + (get_local $8) + (i32.const 12) + ) + ) + ) + (set_local $5 + (i32.load offset=24 + (get_local $8) + ) + ) + (i32.store offset=24 + (get_local $8) + (i32.const 0) + ) + (br_if $label$2 + (i32.eqz + (get_local $5) + ) + ) + (call $_ZdlPv + (get_local $5) + ) + ) + (i32.store offset=4 + (i32.const 0) + (i32.add + (get_local $8) + (i32.const 48) + ) + ) + (get_local $4) + ) + (func $_ZZN5eosio11multi_indexILy5455799419175698432EN6eoswin13dividend_itemEJEE7emplaceIZNS1_7lottery11eraseclaimsEvE4$_17EENS3_14const_iteratorEyOT_ENKUlRS8_E_clINS3_4itemEEEDaSA_ (param $0 i32) (param $1 i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (local $8 i32) + (local $9 i64) + (local $10 i32) + (local $11 i32) + (local $12 i32) + (set_local $11 + (tee_local $12 + (i32.sub + (i32.load offset=4 + (i32.const 0) + ) + (i32.const 16) + ) + ) + ) + (i32.store offset=4 + (i32.const 0) + (get_local $12) + ) + (i64.store + (get_local $1) + (i64.load + (i32.load offset=4 + (i32.load + (tee_local $8 + (i32.load offset=4 + (get_local $0) + ) + ) + ) + ) + ) + ) + (set_local $2 + (i32.load + (get_local $0) + ) + ) + (i64.store offset=8 + (get_local $1) + (i64.load offset=8 + (i32.load offset=4 + (i32.load + (get_local $8) + ) + ) + ) + ) + (i64.store offset=32 + (get_local $1) + (i64.load offset=32 + (i32.load offset=4 + (i32.load + (get_local $8) + ) + ) + ) + ) + (set_local $8 + (i32.add + (i32.load offset=4 + (i32.load + (get_local $8) + ) + ) + (i32.const 16) + ) + ) + (block $label$0 + (block $label$1 + (br_if $label$1 + (i32.eq + (tee_local $10 + (i32.load + (tee_local $5 + (i32.add + (get_local $1) + (i32.const 20) + ) + ) + ) + ) + (i32.load + (i32.add + (get_local $1) + (i32.const 24) + ) + ) + ) + ) + (i64.store + (get_local $10) + (i64.load + (get_local $8) + ) + ) + (i64.store + (i32.add + (get_local $10) + (i32.const 8) + ) + (i64.load + (i32.add + (get_local $8) + (i32.const 8) + ) + ) + ) + (i32.store + (get_local $5) + (tee_local $10 + (i32.add + (i32.load + (get_local $5) + ) + (i32.const 16) + ) + ) + ) + (set_local $7 + (i32.add + (get_local $1) + (i32.const 16) + ) + ) + (br $label$0) + ) + (call $_ZNSt3__16vectorIN5eosio5assetENS_9allocatorIS2_EEE21__push_back_slow_pathIRKS2_EEvOT_ + (tee_local $7 + (i32.add + (get_local $1) + (i32.const 16) + ) + ) + (get_local $8) + ) + (set_local $10 + (i32.load + (get_local $5) + ) + ) + ) + (set_local $4 + (i32.add + (get_local $1) + (i32.const 32) + ) + ) + (set_local $3 + (i32.add + (get_local $1) + (i32.const 8) + ) + ) + (set_local $9 + (i64.extend_u/i32 + (i32.shr_s + (tee_local $6 + (i32.sub + (get_local $10) + (tee_local $5 + (i32.load + (get_local $7) + ) + ) + ) + ) + (i32.const 4) + ) + ) + ) + (set_local $8 + (i32.const 16) + ) + (loop $label$2 + (set_local $8 + (i32.add + (get_local $8) + (i32.const 1) + ) + ) + (br_if $label$2 + (i64.ne + (tee_local $9 + (i64.shr_u + (get_local $9) + (i64.const 7) + ) + ) + (i64.const 0) + ) + ) + ) + (block $label$3 + (br_if $label$3 + (i32.eq + (get_local $5) + (get_local $10) + ) + ) + (set_local $8 + (i32.add + (i32.and + (get_local $6) + (i32.const -16) + ) + (get_local $8) + ) + ) + ) + (block $label$4 + (block $label$5 + (br_if $label$5 + (i32.lt_u + (tee_local $5 + (i32.add + (get_local $8) + (i32.const 8) + ) + ) + (i32.const 513) + ) + ) + (set_local $10 + (call $malloc + (get_local $5) + ) + ) + (br $label$4) + ) + (i32.store offset=4 + (i32.const 0) + (tee_local $10 + (i32.sub + (get_local $12) + (i32.and + (i32.add + (get_local $5) + (i32.const 15) + ) + (i32.const -16) + ) + ) + ) + ) + ) + (i32.store + (get_local $11) + (get_local $10) + ) + (i32.store offset=8 + (get_local $11) + (tee_local $12 + (i32.add + (get_local $10) + (get_local $5) + ) + ) + ) + (call $eosio_assert + (i32.gt_s + (i32.add + (get_local $8) + (i32.const 8) + ) + (i32.const 7) + ) + (i32.const 400) + ) + (drop + (call $memcpy + (get_local $10) + (get_local $1) + (i32.const 8) + ) + ) + (call $eosio_assert + (i32.gt_s + (i32.sub + (get_local $12) + (tee_local $8 + (i32.add + (get_local $10) + (i32.const 8) + ) + ) + ) + (i32.const 7) + ) + (i32.const 400) + ) + (drop + (call $memcpy + (get_local $8) + (get_local $3) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $11) + (i32.add + (get_local $10) + (i32.const 16) + ) + ) + (call $eosio_assert + (i32.gt_s + (i32.sub + (i32.load offset=8 + (tee_local $8 + (call $_ZN5eosiolsINS_10datastreamIPcEENS_5assetEEERT_S6_RKNSt3__16vectorIT0_NS7_9allocatorIS9_EEEE + (get_local $11) + (get_local $7) + ) + ) + ) + (i32.load offset=4 + (get_local $8) + ) + ) + (i32.const 7) + ) + (i32.const 400) + ) + (drop + (call $memcpy + (i32.load offset=4 + (get_local $8) + ) + (get_local $4) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $8) + (i32.add + (i32.load offset=4 + (get_local $8) + ) + (i32.const 8) + ) + ) + (i32.store offset=44 + (get_local $1) + (call $db_store_i64 + (i64.load offset=8 + (get_local $2) + ) + (i64.const 5455799419175698432) + (i64.load + (i32.load offset=8 + (get_local $0) + ) + ) + (tee_local $9 + (i64.load + (get_local $1) + ) + ) + (get_local $10) + (get_local $5) + ) + ) + (block $label$6 + (br_if $label$6 + (i32.lt_u + (get_local $5) + (i32.const 513) + ) + ) + (call $free + (get_local $10) + ) + ) + (block $label$7 + (br_if $label$7 + (i64.lt_u + (get_local $9) + (i64.load offset=16 + (get_local $2) + ) + ) + ) + (i64.store + (i32.add + (get_local $2) + (i32.const 16) + ) + (select + (i64.const -2) + (i64.add + (get_local $9) + (i64.const 1) + ) + (i64.gt_u + (get_local $9) + (i64.const -3) + ) + ) + ) + ) + (i32.store offset=4 + (i32.const 0) + (i32.add + (get_local $11) + (i32.const 16) + ) + ) + ) + (func $_ZN5eosio11multi_indexILy4921565091335241728EN6eoswin10claim_itemEJEE5eraseERKS2_ (param $0 i32) (param $1 i32) + (local $2 i64) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (local $8 i32) + (call $eosio_assert + (i32.eq + (i32.load offset=40 + (get_local $1) + ) + (get_local $0) + ) + (i32.const 2640) + ) + (call $eosio_assert + (i64.eq + (i64.load + (get_local $0) + ) + (call $current_receiver) + ) + (i32.const 2688) + ) + (block $label$0 + (br_if $label$0 + (i32.eq + (tee_local $7 + (i32.load + (tee_local $5 + (i32.add + (get_local $0) + (i32.const 28) + ) + ) + ) + ) + (tee_local $3 + (i32.load offset=24 + (get_local $0) + ) + ) + ) + ) + (set_local $2 + (i64.load + (get_local $1) + ) + ) + (set_local $6 + (i32.sub + (i32.const 0) + (get_local $3) + ) + ) + (set_local $8 + (i32.add + (get_local $7) + (i32.const -24) + ) + ) + (loop $label$1 + (br_if $label$0 + (i64.eq + (i64.load + (i32.load + (get_local $8) + ) + ) + (get_local $2) + ) + ) + (set_local $7 + (get_local $8) + ) + (set_local $8 + (tee_local $4 + (i32.add + (get_local $8) + (i32.const -24) + ) + ) + ) + (br_if $label$1 + (i32.ne + (i32.add + (get_local $4) + (get_local $6) + ) + (i32.const -24) + ) + ) + ) + ) + (call $eosio_assert + (i32.ne + (get_local $7) + (get_local $3) + ) + (i32.const 2752) + ) + (set_local $8 + (i32.add + (get_local $7) + (i32.const -24) + ) + ) + (block $label$2 + (block $label$3 + (br_if $label$3 + (i32.eq + (get_local $7) + (tee_local $4 + (i32.load + (get_local $5) + ) + ) + ) + ) + (set_local $3 + (i32.sub + (i32.const 0) + (get_local $4) + ) + ) + (set_local $7 + (get_local $8) + ) + (loop $label$4 + (set_local $6 + (i32.load + (tee_local $8 + (i32.add + (get_local $7) + (i32.const 24) + ) + ) + ) + ) + (i32.store + (get_local $8) + (i32.const 0) + ) + (set_local $4 + (i32.load + (get_local $7) + ) + ) + (i32.store + (get_local $7) + (get_local $6) + ) + (block $label$5 + (br_if $label$5 + (i32.eqz + (get_local $4) + ) + ) + (call $_ZdlPv + (get_local $4) + ) + ) + (i32.store + (i32.add + (get_local $7) + (i32.const 16) + ) + (i32.load + (i32.add + (get_local $7) + (i32.const 40) + ) + ) + ) + (i64.store + (i32.add + (get_local $7) + (i32.const 8) + ) + (i64.load + (i32.add + (get_local $7) + (i32.const 32) + ) + ) + ) + (set_local $7 + (get_local $8) + ) + (br_if $label$4 + (i32.ne + (i32.add + (get_local $8) + (get_local $3) + ) + (i32.const -24) + ) + ) + ) + (br_if $label$2 + (i32.eq + (tee_local $7 + (i32.load + (i32.add + (get_local $0) + (i32.const 28) + ) + ) + ) + (get_local $8) + ) + ) + ) + (loop $label$6 + (set_local $4 + (i32.load + (tee_local $7 + (i32.add + (get_local $7) + (i32.const -24) + ) + ) + ) + ) + (i32.store + (get_local $7) + (i32.const 0) + ) + (block $label$7 + (br_if $label$7 + (i32.eqz + (get_local $4) + ) + ) + (call $_ZdlPv + (get_local $4) + ) + ) + (br_if $label$6 + (i32.ne + (get_local $8) + (get_local $7) + ) + ) + ) + ) + (i32.store + (i32.add + (get_local $0) + (i32.const 28) + ) + (get_local $8) + ) + (call $db_remove_i64 + (i32.load offset=44 + (get_local $1) + ) + ) + ) + (func $_ZN6eoswinrsIN5eosio10datastreamIPKcEEEERT_S7_RNS_10claim_itemE (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + (call $eosio_assert + (i32.gt_u + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (i32.load offset=4 + (get_local $0) + ) + ) + (i32.const 7) + ) + (i32.const 272) + ) + (drop + (call $memcpy + (get_local $1) + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $0) + (tee_local $2 + (i32.add + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + ) + (call $eosio_assert + (i32.gt_u + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (get_local $2) + ) + (i32.const 7) + ) + (i32.const 272) + ) + (drop + (call $memcpy + (i32.add + (get_local $1) + (i32.const 8) + ) + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $0) + (tee_local $2 + (i32.add + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + ) + (call $eosio_assert + (i32.gt_u + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (get_local $2) + ) + (i32.const 7) + ) + (i32.const 272) + ) + (drop + (call $memcpy + (i32.add + (get_local $1) + (i32.const 16) + ) + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $0) + (tee_local $2 + (i32.add + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + ) + (call $eosio_assert + (i32.gt_u + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (get_local $2) + ) + (i32.const 7) + ) + (i32.const 272) + ) + (drop + (call $memcpy + (i32.add + (get_local $1) + (i32.const 24) + ) + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $0) + (tee_local $2 + (i32.add + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + ) + (call $eosio_assert + (i32.gt_u + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (get_local $2) + ) + (i32.const 7) + ) + (i32.const 272) + ) + (drop + (call $memcpy + (i32.add + (get_local $1) + (i32.const 32) + ) + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $0) + (i32.add + (i32.load offset=4 + (get_local $0) + ) + (i32.const 8) + ) + ) + (get_local $0) + ) + (func $_ZNSt3__16vectorIN5eosio11multi_indexILy4921565091335241728EN6eoswin10claim_itemEJEE8item_ptrENS_9allocatorIS6_EEE24__emplace_back_slow_pathIJNS_10unique_ptrINS5_4itemENS_14default_deleteISC_EEEERyRlEEEvDpOT_ (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (block $label$0 + (block $label$1 + (br_if $label$1 + (i32.ge_u + (tee_local $5 + (i32.add + (tee_local $4 + (i32.div_s + (i32.sub + (i32.load offset=4 + (get_local $0) + ) + (tee_local $6 + (i32.load + (get_local $0) + ) + ) + ) + (i32.const 24) + ) + ) + (i32.const 1) + ) + ) + (i32.const 178956971) + ) + ) + (set_local $7 + (i32.const 178956970) + ) + (block $label$2 + (block $label$3 + (br_if $label$3 + (i32.gt_u + (tee_local $6 + (i32.div_s + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (get_local $6) + ) + (i32.const 24) + ) + ) + (i32.const 89478484) + ) + ) + (br_if $label$2 + (i32.eqz + (tee_local $7 + (select + (get_local $5) + (tee_local $7 + (i32.shl + (get_local $6) + (i32.const 1) + ) + ) + (i32.lt_u + (get_local $7) + (get_local $5) + ) + ) + ) + ) + ) + ) + (set_local $6 + (call $_Znwj + (i32.mul + (get_local $7) + (i32.const 24) + ) + ) + ) + (br $label$0) + ) + (set_local $7 + (i32.const 0) + ) + (set_local $6 + (i32.const 0) + ) + (br $label$0) + ) + (call $_ZNKSt3__120__vector_base_commonILb1EE20__throw_length_errorEv + (get_local $0) + ) + (unreachable) + ) + (set_local $5 + (i32.load + (get_local $1) + ) + ) + (i32.store + (get_local $1) + (i32.const 0) + ) + (i32.store + (tee_local $1 + (i32.add + (get_local $6) + (i32.mul + (get_local $4) + (i32.const 24) + ) + ) + ) + (get_local $5) + ) + (i64.store offset=8 + (get_local $1) + (i64.load + (get_local $2) + ) + ) + (i32.store offset=16 + (get_local $1) + (i32.load + (get_local $3) + ) + ) + (set_local $4 + (i32.add + (get_local $6) + (i32.mul + (get_local $7) + (i32.const 24) + ) + ) + ) + (set_local $5 + (i32.add + (get_local $1) + (i32.const 24) + ) + ) + (block $label$4 + (block $label$5 + (br_if $label$5 + (i32.eq + (tee_local $6 + (i32.load + (i32.add + (get_local $0) + (i32.const 4) + ) + ) + ) + (tee_local $7 + (i32.load + (get_local $0) + ) + ) + ) + ) + (loop $label$6 + (set_local $3 + (i32.load + (tee_local $2 + (i32.add + (get_local $6) + (i32.const -24) + ) + ) + ) + ) + (i32.store + (get_local $2) + (i32.const 0) + ) + (i32.store + (i32.add + (get_local $1) + (i32.const -24) + ) + (get_local $3) + ) + (i32.store + (i32.add + (get_local $1) + (i32.const -8) + ) + (i32.load + (i32.add + (get_local $6) + (i32.const -8) + ) + ) + ) + (i32.store + (i32.add + (get_local $1) + (i32.const -12) + ) + (i32.load + (i32.add + (get_local $6) + (i32.const -12) + ) + ) + ) + (i32.store + (i32.add + (get_local $1) + (i32.const -16) + ) + (i32.load + (i32.add + (get_local $6) + (i32.const -16) + ) + ) + ) + (set_local $1 + (i32.add + (get_local $1) + (i32.const -24) + ) + ) + (set_local $6 + (get_local $2) + ) + (br_if $label$6 + (i32.ne + (get_local $7) + (get_local $2) + ) + ) + ) + (set_local $7 + (i32.load + (i32.add + (get_local $0) + (i32.const 4) + ) + ) + ) + (set_local $6 + (i32.load + (get_local $0) + ) + ) + (br $label$4) + ) + (set_local $6 + (get_local $7) + ) + ) + (i32.store + (get_local $0) + (get_local $1) + ) + (i32.store + (i32.add + (get_local $0) + (i32.const 4) + ) + (get_local $5) + ) + (i32.store + (i32.add + (get_local $0) + (i32.const 8) + ) + (get_local $4) + ) + (block $label$7 + (br_if $label$7 + (i32.eq + (get_local $7) + (get_local $6) + ) + ) + (loop $label$8 + (set_local $1 + (i32.load + (tee_local $7 + (i32.add + (get_local $7) + (i32.const -24) + ) + ) + ) + ) + (i32.store + (get_local $7) + (i32.const 0) + ) + (block $label$9 + (br_if $label$9 + (i32.eqz + (get_local $1) + ) + ) + (call $_ZdlPv + (get_local $1) + ) + ) + (br_if $label$8 + (i32.ne + (get_local $6) + (get_local $7) + ) + ) + ) + ) + (block $label$10 + (br_if $label$10 + (i32.eqz + (get_local $6) + ) + ) + (call $_ZdlPv + (get_local $6) + ) + ) + ) + (func $_ZN6eoswin7lottery9activesubEb (type $FUNCSIG$vii) (param $0 i32) (param $1 i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 i64) + (local $6 i64) + (local $7 i32) + (local $8 i32) + (local $9 i32) + (i32.store offset=4 + (i32.const 0) + (tee_local $9 + (i32.sub + (i32.load offset=4 + (i32.const 0) + ) + (i32.const 32) + ) + ) + ) + (call $require_auth + (i64.load + (get_local $0) + ) + ) + (block $label$0 + (br_if $label$0 + (i32.eq + (tee_local $8 + (i32.load + (i32.add + (get_local $0) + (i32.const 276) + ) + ) + ) + (tee_local $2 + (i32.load + (i32.add + (get_local $0) + (i32.const 272) + ) + ) + ) + ) + ) + (set_local $7 + (i32.add + (get_local $8) + (i32.const -24) + ) + ) + (set_local $3 + (i32.sub + (i32.const 0) + (get_local $2) + ) + ) + (loop $label$1 + (br_if $label$0 + (i64.eq + (i64.load + (i32.load + (get_local $7) + ) + ) + (i64.const 103) + ) + ) + (set_local $8 + (get_local $7) + ) + (set_local $7 + (tee_local $4 + (i32.add + (get_local $7) + (i32.const -24) + ) + ) + ) + (br_if $label$1 + (i32.ne + (i32.add + (get_local $4) + (get_local $3) + ) + (i32.const -24) + ) + ) + ) + ) + (set_local $4 + (i32.add + (get_local $0) + (i32.const 248) + ) + ) + (block $label$2 + (block $label$3 + (block $label$4 + (block $label$5 + (br_if $label$5 + (i32.eq + (get_local $8) + (get_local $2) + ) + ) + (call $eosio_assert + (i32.eq + (i32.load offset=16 + (tee_local $7 + (i32.load + (i32.add + (get_local $8) + (i32.const -24) + ) + ) + ) + ) + (get_local $4) + ) + (i32.const 32) + ) + (br_if $label$4 + (get_local $7) + ) + (br $label$3) + ) + (br_if $label$3 + (i32.lt_s + (tee_local $7 + (call $db_find_i64 + (i64.load + (i32.add + (get_local $0) + (i32.const 248) + ) + ) + (i64.load + (i32.add + (get_local $0) + (i32.const 256) + ) + ) + (i64.const -4157493845350678528) + (i64.const 103) + ) + ) + (i32.const 0) + ) + ) + (call $eosio_assert + (i32.eq + (i32.load offset=16 + (tee_local $7 + (call $_ZNK5eosio11multi_indexILy14289250228358873088EN6eoswin6statusEJEE31load_object_by_primary_iteratorEl + (get_local $4) + (get_local $7) + ) + ) + ) + (get_local $4) + ) + (i32.const 32) + ) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 288) + ) + (call $eosio_assert + (i32.eq + (i32.load offset=16 + (get_local $7) + ) + (get_local $4) + ) + (i32.const 416) + ) + (call $eosio_assert + (i64.eq + (i64.load + (i32.add + (get_local $0) + (i32.const 248) + ) + ) + (call $current_receiver) + ) + (i32.const 464) + ) + (i64.store offset=8 + (get_local $7) + (i64.extend_u/i32 + (get_local $1) + ) + ) + (set_local $5 + (i64.load + (get_local $7) + ) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 528) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 400) + ) + (drop + (call $memcpy + (i32.add + (get_local $9) + (i32.const 16) + ) + (get_local $7) + (i32.const 8) + ) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 400) + ) + (drop + (call $memcpy + (i32.or + (i32.add + (get_local $9) + (i32.const 16) + ) + (i32.const 8) + ) + (i32.add + (get_local $7) + (i32.const 8) + ) + (i32.const 8) + ) + ) + (call $db_update_i64 + (i32.load offset=20 + (get_local $7) + ) + (i64.const 0) + (i32.add + (get_local $9) + (i32.const 16) + ) + (i32.const 16) + ) + (br_if $label$2 + (i64.lt_u + (get_local $5) + (i64.load + (tee_local $7 + (i32.add + (get_local $0) + (i32.const 264) + ) + ) + ) + ) + ) + (i64.store + (get_local $7) + (select + (i64.const -2) + (i64.add + (get_local $5) + (i64.const 1) + ) + (i64.gt_u + (get_local $5) + (i64.const -3) + ) + ) + ) + (br $label$2) + ) + (set_local $6 + (i64.load + (get_local $0) + ) + ) + (call $eosio_assert + (i64.eq + (i64.load + (i32.add + (get_local $0) + (i32.const 248) + ) + ) + (call $current_receiver) + ) + (i32.const 336) + ) + (i32.store offset=16 + (tee_local $7 + (call $_Znwj + (i32.const 32) + ) + ) + (get_local $4) + ) + (i64.store offset=8 + (get_local $7) + (i64.extend_u/i32 + (get_local $1) + ) + ) + (i64.store + (get_local $7) + (i64.const 103) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 400) + ) + (drop + (call $memcpy + (i32.add + (get_local $9) + (i32.const 16) + ) + (get_local $7) + (i32.const 8) + ) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 400) + ) + (drop + (call $memcpy + (i32.or + (i32.add + (get_local $9) + (i32.const 16) + ) + (i32.const 8) + ) + (i32.add + (get_local $7) + (i32.const 8) + ) + (i32.const 8) + ) + ) + (i32.store offset=20 + (get_local $7) + (tee_local $8 + (call $db_store_i64 + (i64.load + (i32.add + (get_local $0) + (i32.const 256) + ) + ) + (i64.const -4157493845350678528) + (get_local $6) + (tee_local $5 + (i64.load + (get_local $7) + ) + ) + (i32.add + (get_local $9) + (i32.const 16) + ) + (i32.const 16) + ) + ) + ) + (block $label$6 + (br_if $label$6 + (i64.lt_u + (get_local $5) + (i64.load + (tee_local $4 + (i32.add + (get_local $0) + (i32.const 264) + ) + ) + ) + ) + ) + (i64.store + (get_local $4) + (select + (i64.const -2) + (i64.add + (get_local $5) + (i64.const 1) + ) + (i64.gt_u + (get_local $5) + (i64.const -3) + ) + ) + ) + ) + (i32.store offset=8 + (get_local $9) + (get_local $7) + ) + (i64.store offset=16 + (get_local $9) + (tee_local $5 + (i64.load + (get_local $7) + ) + ) + ) + (i32.store offset=4 + (get_local $9) + (get_local $8) + ) + (block $label$7 + (block $label$8 + (br_if $label$8 + (i32.ge_u + (tee_local $4 + (i32.load + (tee_local $3 + (i32.add + (get_local $0) + (i32.const 276) + ) + ) + ) + ) + (i32.load + (i32.add + (get_local $0) + (i32.const 280) + ) + ) + ) + ) + (i64.store offset=8 + (get_local $4) + (get_local $5) + ) + (i32.store offset=16 + (get_local $4) + (get_local $8) + ) + (i32.store offset=8 + (get_local $9) + (i32.const 0) + ) + (i32.store + (get_local $4) + (get_local $7) + ) + (i32.store + (get_local $3) + (i32.add + (get_local $4) + (i32.const 24) + ) + ) + (br $label$7) + ) + (call $_ZNSt3__16vectorIN5eosio11multi_indexILy14289250228358873088EN6eoswin6statusEJEE8item_ptrENS_9allocatorIS6_EEE24__emplace_back_slow_pathIJNS_10unique_ptrINS5_4itemENS_14default_deleteISC_EEEERyRlEEEvDpOT_ + (i32.add + (get_local $0) + (i32.const 272) + ) + (i32.add + (get_local $9) + (i32.const 8) + ) + (i32.add + (get_local $9) + (i32.const 16) + ) + (i32.add + (get_local $9) + (i32.const 4) + ) + ) + ) + (set_local $7 + (i32.load offset=8 + (get_local $9) + ) + ) + (i32.store offset=8 + (get_local $9) + (i32.const 0) + ) + (br_if $label$2 + (i32.eqz + (get_local $7) + ) + ) + (call $_ZdlPv + (get_local $7) + ) + ) + (i32.store offset=4 + (i32.const 0) + (i32.add + (get_local $9) + (i32.const 32) + ) + ) + ) + (func $_ZN6eoswin7lottery11activebonusEb (type $FUNCSIG$vii) (param $0 i32) (param $1 i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 i64) + (local $6 i64) + (local $7 i32) + (local $8 i32) + (local $9 i32) + (i32.store offset=4 + (i32.const 0) + (tee_local $9 + (i32.sub + (i32.load offset=4 + (i32.const 0) + ) + (i32.const 32) + ) + ) + ) + (call $require_auth + (i64.load + (get_local $0) + ) + ) + (block $label$0 + (br_if $label$0 + (i32.eq + (tee_local $8 + (i32.load + (i32.add + (get_local $0) + (i32.const 276) + ) + ) + ) + (tee_local $2 + (i32.load + (i32.add + (get_local $0) + (i32.const 272) + ) + ) + ) + ) + ) + (set_local $7 + (i32.add + (get_local $8) + (i32.const -24) + ) + ) + (set_local $3 + (i32.sub + (i32.const 0) + (get_local $2) + ) + ) + (loop $label$1 + (br_if $label$0 + (i64.eq + (i64.load + (i32.load + (get_local $7) + ) + ) + (i64.const 101) + ) + ) + (set_local $8 + (get_local $7) + ) + (set_local $7 + (tee_local $4 + (i32.add + (get_local $7) + (i32.const -24) + ) + ) + ) + (br_if $label$1 + (i32.ne + (i32.add + (get_local $4) + (get_local $3) + ) + (i32.const -24) + ) + ) + ) + ) + (set_local $4 + (i32.add + (get_local $0) + (i32.const 248) + ) + ) + (block $label$2 + (block $label$3 + (block $label$4 + (block $label$5 + (br_if $label$5 + (i32.eq + (get_local $8) + (get_local $2) + ) + ) + (call $eosio_assert + (i32.eq + (i32.load offset=16 + (tee_local $7 + (i32.load + (i32.add + (get_local $8) + (i32.const -24) + ) + ) + ) + ) + (get_local $4) + ) + (i32.const 32) + ) + (br_if $label$4 + (get_local $7) + ) + (br $label$3) + ) + (br_if $label$3 + (i32.lt_s + (tee_local $7 + (call $db_find_i64 + (i64.load + (i32.add + (get_local $0) + (i32.const 248) + ) + ) + (i64.load + (i32.add + (get_local $0) + (i32.const 256) + ) + ) + (i64.const -4157493845350678528) + (i64.const 101) + ) + ) + (i32.const 0) + ) + ) + (call $eosio_assert + (i32.eq + (i32.load offset=16 + (tee_local $7 + (call $_ZNK5eosio11multi_indexILy14289250228358873088EN6eoswin6statusEJEE31load_object_by_primary_iteratorEl + (get_local $4) + (get_local $7) + ) + ) + ) + (get_local $4) + ) + (i32.const 32) + ) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 288) + ) + (call $eosio_assert + (i32.eq + (i32.load offset=16 + (get_local $7) + ) + (get_local $4) + ) + (i32.const 416) + ) + (call $eosio_assert + (i64.eq + (i64.load + (i32.add + (get_local $0) + (i32.const 248) + ) + ) + (call $current_receiver) + ) + (i32.const 464) + ) + (i64.store offset=8 + (get_local $7) + (i64.extend_u/i32 + (get_local $1) + ) + ) + (set_local $5 + (i64.load + (get_local $7) + ) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 528) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 400) + ) + (drop + (call $memcpy + (i32.add + (get_local $9) + (i32.const 16) + ) + (get_local $7) + (i32.const 8) + ) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 400) + ) + (drop + (call $memcpy + (i32.or + (i32.add + (get_local $9) + (i32.const 16) + ) + (i32.const 8) + ) + (i32.add + (get_local $7) + (i32.const 8) + ) + (i32.const 8) + ) + ) + (call $db_update_i64 + (i32.load offset=20 + (get_local $7) + ) + (i64.const 0) + (i32.add + (get_local $9) + (i32.const 16) + ) + (i32.const 16) + ) + (br_if $label$2 + (i64.lt_u + (get_local $5) + (i64.load + (tee_local $7 + (i32.add + (get_local $0) + (i32.const 264) + ) + ) + ) + ) + ) + (i64.store + (get_local $7) + (select + (i64.const -2) + (i64.add + (get_local $5) + (i64.const 1) + ) + (i64.gt_u + (get_local $5) + (i64.const -3) + ) + ) + ) + (br $label$2) + ) + (set_local $6 + (i64.load + (get_local $0) + ) + ) + (call $eosio_assert + (i64.eq + (i64.load + (i32.add + (get_local $0) + (i32.const 248) + ) + ) + (call $current_receiver) + ) + (i32.const 336) + ) + (i32.store offset=16 + (tee_local $7 + (call $_Znwj + (i32.const 32) + ) + ) + (get_local $4) + ) + (i64.store offset=8 + (get_local $7) + (i64.extend_u/i32 + (get_local $1) + ) + ) + (i64.store + (get_local $7) + (i64.const 101) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 400) + ) + (drop + (call $memcpy + (i32.add + (get_local $9) + (i32.const 16) + ) + (get_local $7) + (i32.const 8) + ) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 400) + ) + (drop + (call $memcpy + (i32.or + (i32.add + (get_local $9) + (i32.const 16) + ) + (i32.const 8) + ) + (i32.add + (get_local $7) + (i32.const 8) + ) + (i32.const 8) + ) + ) + (i32.store offset=20 + (get_local $7) + (tee_local $8 + (call $db_store_i64 + (i64.load + (i32.add + (get_local $0) + (i32.const 256) + ) + ) + (i64.const -4157493845350678528) + (get_local $6) + (tee_local $5 + (i64.load + (get_local $7) + ) + ) + (i32.add + (get_local $9) + (i32.const 16) + ) + (i32.const 16) + ) + ) + ) + (block $label$6 + (br_if $label$6 + (i64.lt_u + (get_local $5) + (i64.load + (tee_local $4 + (i32.add + (get_local $0) + (i32.const 264) + ) + ) + ) + ) + ) + (i64.store + (get_local $4) + (select + (i64.const -2) + (i64.add + (get_local $5) + (i64.const 1) + ) + (i64.gt_u + (get_local $5) + (i64.const -3) + ) + ) + ) + ) + (i32.store offset=8 + (get_local $9) + (get_local $7) + ) + (i64.store offset=16 + (get_local $9) + (tee_local $5 + (i64.load + (get_local $7) + ) + ) + ) + (i32.store offset=4 + (get_local $9) + (get_local $8) + ) + (block $label$7 + (block $label$8 + (br_if $label$8 + (i32.ge_u + (tee_local $4 + (i32.load + (tee_local $3 + (i32.add + (get_local $0) + (i32.const 276) + ) + ) + ) + ) + (i32.load + (i32.add + (get_local $0) + (i32.const 280) + ) + ) + ) + ) + (i64.store offset=8 + (get_local $4) + (get_local $5) + ) + (i32.store offset=16 + (get_local $4) + (get_local $8) + ) + (i32.store offset=8 + (get_local $9) + (i32.const 0) + ) + (i32.store + (get_local $4) + (get_local $7) + ) + (i32.store + (get_local $3) + (i32.add + (get_local $4) + (i32.const 24) + ) + ) + (br $label$7) + ) + (call $_ZNSt3__16vectorIN5eosio11multi_indexILy14289250228358873088EN6eoswin6statusEJEE8item_ptrENS_9allocatorIS6_EEE24__emplace_back_slow_pathIJNS_10unique_ptrINS5_4itemENS_14default_deleteISC_EEEERyRlEEEvDpOT_ + (i32.add + (get_local $0) + (i32.const 272) + ) + (i32.add + (get_local $9) + (i32.const 8) + ) + (i32.add + (get_local $9) + (i32.const 16) + ) + (i32.add + (get_local $9) + (i32.const 4) + ) + ) + ) + (set_local $7 + (i32.load offset=8 + (get_local $9) + ) + ) + (i32.store offset=8 + (get_local $9) + (i32.const 0) + ) + (br_if $label$2 + (i32.eqz + (get_local $7) + ) + ) + (call $_ZdlPv + (get_local $7) + ) + ) + (i32.store offset=4 + (i32.const 0) + (i32.add + (get_local $9) + (i32.const 32) + ) + ) + ) + (func $apply (param $0 i64) (param $1 i64) (param $2 i64) + (local $3 i32) + (local $4 i32) + (local $5 i64) + (local $6 i64) + (local $7 i64) + (local $8 i64) + (local $9 i32) + (i32.store offset=4 + (i32.const 0) + (tee_local $9 + (i32.sub + (i32.load offset=4 + (i32.const 0) + ) + (i32.const 544) + ) + ) + ) + (set_local $6 + (i64.const 0) + ) + (set_local $5 + (i64.const 59) + ) + (set_local $4 + (i32.const 3456) + ) + (set_local $7 + (i64.const 0) + ) + (loop $label$0 + (block $label$1 + (block $label$2 + (block $label$3 + (block $label$4 + (block $label$5 + (br_if $label$5 + (i64.gt_u + (get_local $6) + (i64.const 6) + ) + ) + (br_if $label$4 + (i32.gt_u + (i32.and + (i32.add + (tee_local $3 + (i32.load8_s + (get_local $4) + ) + ) + (i32.const -97) + ) + (i32.const 255) + ) + (i32.const 25) + ) + ) + (set_local $3 + (i32.add + (get_local $3) + (i32.const 165) + ) + ) + (br $label$3) + ) + (set_local $8 + (i64.const 0) + ) + (br_if $label$2 + (i64.le_u + (get_local $6) + (i64.const 11) + ) + ) + (br $label$1) + ) + (set_local $3 + (select + (i32.add + (get_local $3) + (i32.const 208) + ) + (i32.const 0) + (i32.lt_u + (i32.and + (i32.add + (get_local $3) + (i32.const -49) + ) + (i32.const 255) + ) + (i32.const 5) + ) + ) + ) + ) + (set_local $8 + (i64.shr_s + (i64.shl + (i64.extend_u/i32 + (get_local $3) + ) + (i64.const 56) + ) + (i64.const 56) + ) + ) + ) + (set_local $8 + (i64.shl + (i64.and + (get_local $8) + (i64.const 31) + ) + (i64.and + (get_local $5) + (i64.const 4294967295) + ) + ) + ) + ) + (set_local $4 + (i32.add + (get_local $4) + (i32.const 1) + ) + ) + (set_local $6 + (i64.add + (get_local $6) + (i64.const 1) + ) + ) + (set_local $7 + (i64.or + (get_local $8) + (get_local $7) + ) + ) + (br_if $label$0 + (i64.ne + (tee_local $5 + (i64.add + (get_local $5) + (i64.const -5) + ) + ) + (i64.const -6) + ) + ) + ) + (block $label$6 + (br_if $label$6 + (i64.ne + (get_local $7) + (get_local $2) + ) + ) + (set_local $6 + (i64.const 0) + ) + (set_local $5 + (i64.const 59) + ) + (set_local $4 + (i32.const 3472) + ) + (set_local $7 + (i64.const 0) + ) + (loop $label$7 + (block $label$8 + (block $label$9 + (block $label$10 + (block $label$11 + (block $label$12 + (br_if $label$12 + (i64.gt_u + (get_local $6) + (i64.const 4) + ) + ) + (br_if $label$11 + (i32.gt_u + (i32.and + (i32.add + (tee_local $3 + (i32.load8_s + (get_local $4) + ) + ) + (i32.const -97) + ) + (i32.const 255) + ) + (i32.const 25) + ) + ) + (set_local $3 + (i32.add + (get_local $3) + (i32.const 165) + ) + ) + (br $label$10) + ) + (set_local $8 + (i64.const 0) + ) + (br_if $label$9 + (i64.le_u + (get_local $6) + (i64.const 11) + ) + ) + (br $label$8) + ) + (set_local $3 + (select + (i32.add + (get_local $3) + (i32.const 208) + ) + (i32.const 0) + (i32.lt_u + (i32.and + (i32.add + (get_local $3) + (i32.const -49) + ) + (i32.const 255) + ) + (i32.const 5) + ) + ) + ) + ) + (set_local $8 + (i64.shr_s + (i64.shl + (i64.extend_u/i32 + (get_local $3) + ) + (i64.const 56) + ) + (i64.const 56) + ) + ) + ) + (set_local $8 + (i64.shl + (i64.and + (get_local $8) + (i64.const 31) + ) + (i64.and + (get_local $5) + (i64.const 4294967295) + ) + ) + ) + ) + (set_local $4 + (i32.add + (get_local $4) + (i32.const 1) + ) + ) + (set_local $6 + (i64.add + (get_local $6) + (i64.const 1) + ) + ) + (set_local $7 + (i64.or + (get_local $8) + (get_local $7) + ) + ) + (br_if $label$7 + (i64.ne + (tee_local $5 + (i64.add + (get_local $5) + (i64.const -5) + ) + ) + (i64.const -6) + ) + ) + ) + (call $eosio_assert + (i64.eq + (get_local $7) + (get_local $1) + ) + (i32.const 3488) + ) + ) + (set_local $6 + (i64.const 0) + ) + (set_local $5 + (i64.const 59) + ) + (set_local $4 + (i32.const 1088) + ) + (set_local $7 + (i64.const 0) + ) + (loop $label$13 + (block $label$14 + (block $label$15 + (block $label$16 + (block $label$17 + (block $label$18 + (br_if $label$18 + (i64.gt_u + (get_local $6) + (i64.const 10) + ) + ) + (br_if $label$17 + (i32.gt_u + (i32.and + (i32.add + (tee_local $3 + (i32.load8_s + (get_local $4) + ) + ) + (i32.const -97) + ) + (i32.const 255) + ) + (i32.const 25) + ) + ) + (set_local $3 + (i32.add + (get_local $3) + (i32.const 165) + ) + ) + (br $label$16) + ) + (set_local $8 + (i64.const 0) + ) + (br_if $label$15 + (i64.eq + (get_local $6) + (i64.const 11) + ) + ) + (br $label$14) + ) + (set_local $3 + (select + (i32.add + (get_local $3) + (i32.const 208) + ) + (i32.const 0) + (i32.lt_u + (i32.and + (i32.add + (get_local $3) + (i32.const -49) + ) + (i32.const 255) + ) + (i32.const 5) + ) + ) + ) + ) + (set_local $8 + (i64.shr_s + (i64.shl + (i64.extend_u/i32 + (get_local $3) + ) + (i64.const 56) + ) + (i64.const 56) + ) + ) + ) + (set_local $8 + (i64.shl + (i64.and + (get_local $8) + (i64.const 31) + ) + (i64.and + (get_local $5) + (i64.const 4294967295) + ) + ) + ) + ) + (set_local $4 + (i32.add + (get_local $4) + (i32.const 1) + ) + ) + (set_local $5 + (i64.add + (get_local $5) + (i64.const -5) + ) + ) + (set_local $7 + (i64.or + (get_local $8) + (get_local $7) + ) + ) + (br_if $label$13 + (i64.ne + (tee_local $6 + (i64.add + (get_local $6) + (i64.const 1) + ) + ) + (i64.const 13) + ) + ) + ) + (block $label$19 + (br_if $label$19 + (i64.ne + (get_local $7) + (get_local $1) + ) + ) + (set_local $6 + (i64.const 0) + ) + (set_local $5 + (i64.const 59) + ) + (set_local $4 + (i32.const 1216) + ) + (set_local $7 + (i64.const 0) + ) + (loop $label$20 + (block $label$21 + (block $label$22 + (block $label$23 + (block $label$24 + (block $label$25 + (br_if $label$25 + (i64.gt_u + (get_local $6) + (i64.const 7) + ) + ) + (br_if $label$24 + (i32.gt_u + (i32.and + (i32.add + (tee_local $3 + (i32.load8_s + (get_local $4) + ) + ) + (i32.const -97) + ) + (i32.const 255) + ) + (i32.const 25) + ) + ) + (set_local $3 + (i32.add + (get_local $3) + (i32.const 165) + ) + ) + (br $label$23) + ) + (set_local $8 + (i64.const 0) + ) + (br_if $label$22 + (i64.le_u + (get_local $6) + (i64.const 11) + ) + ) + (br $label$21) + ) + (set_local $3 + (select + (i32.add + (get_local $3) + (i32.const 208) + ) + (i32.const 0) + (i32.lt_u + (i32.and + (i32.add + (get_local $3) + (i32.const -49) + ) + (i32.const 255) + ) + (i32.const 5) + ) + ) + ) + ) + (set_local $8 + (i64.shr_s + (i64.shl + (i64.extend_u/i32 + (get_local $3) + ) + (i64.const 56) + ) + (i64.const 56) + ) + ) + ) + (set_local $8 + (i64.shl + (i64.and + (get_local $8) + (i64.const 31) + ) + (i64.and + (get_local $5) + (i64.const 4294967295) + ) + ) + ) + ) + (set_local $4 + (i32.add + (get_local $4) + (i32.const 1) + ) + ) + (set_local $6 + (i64.add + (get_local $6) + (i64.const 1) + ) + ) + (set_local $7 + (i64.or + (get_local $8) + (get_local $7) + ) + ) + (br_if $label$20 + (i64.ne + (tee_local $5 + (i64.add + (get_local $5) + (i64.const -5) + ) + ) + (i64.const -6) + ) + ) + ) + (br_if $label$19 + (i64.ne + (get_local $7) + (get_local $2) + ) + ) + (set_local $4 + (call $_ZN6eoswin7lotteryC2Ey + (i32.add + (get_local $9) + (i32.const 176) + ) + (get_local $0) + ) + ) + (i32.store offset=172 + (get_local $9) + (i32.const 0) + ) + (i32.store offset=168 + (get_local $9) + (i32.const 1) + ) + (i64.store offset=80 align=4 + (get_local $9) + (i64.load offset=168 + (get_local $9) + ) + ) + (drop + (call $_ZN5eosio14execute_actionIN6eoswin7lotteryES2_JyyEEEbPT_MT0_FvDpT1_E + (get_local $4) + (i32.add + (get_local $9) + (i32.const 80) + ) + ) + ) + (drop + (call $_ZN6eoswin7lotteryD2Ev + (get_local $4) + ) + ) + ) + (block $label$26 + (block $label$27 + (br_if $label$27 + (i64.eq + (get_local $1) + (get_local $0) + ) + ) + (set_local $6 + (i64.const 0) + ) + (set_local $5 + (i64.const 59) + ) + (set_local $4 + (i32.const 3456) + ) + (set_local $7 + (i64.const 0) + ) + (loop $label$28 + (block $label$29 + (block $label$30 + (block $label$31 + (block $label$32 + (block $label$33 + (br_if $label$33 + (i64.gt_u + (get_local $6) + (i64.const 6) + ) + ) + (br_if $label$32 + (i32.gt_u + (i32.and + (i32.add + (tee_local $3 + (i32.load8_s + (get_local $4) + ) + ) + (i32.const -97) + ) + (i32.const 255) + ) + (i32.const 25) + ) + ) + (set_local $3 + (i32.add + (get_local $3) + (i32.const 165) + ) + ) + (br $label$31) + ) + (set_local $8 + (i64.const 0) + ) + (br_if $label$30 + (i64.le_u + (get_local $6) + (i64.const 11) + ) + ) + (br $label$29) + ) + (set_local $3 + (select + (i32.add + (get_local $3) + (i32.const 208) + ) + (i32.const 0) + (i32.lt_u + (i32.and + (i32.add + (get_local $3) + (i32.const -49) + ) + (i32.const 255) + ) + (i32.const 5) + ) + ) + ) + ) + (set_local $8 + (i64.shr_s + (i64.shl + (i64.extend_u/i32 + (get_local $3) + ) + (i64.const 56) + ) + (i64.const 56) + ) + ) + ) + (set_local $8 + (i64.shl + (i64.and + (get_local $8) + (i64.const 31) + ) + (i64.and + (get_local $5) + (i64.const 4294967295) + ) + ) + ) + ) + (set_local $4 + (i32.add + (get_local $4) + (i32.const 1) + ) + ) + (set_local $6 + (i64.add + (get_local $6) + (i64.const 1) + ) + ) + (set_local $7 + (i64.or + (get_local $8) + (get_local $7) + ) + ) + (br_if $label$28 + (i64.ne + (tee_local $5 + (i64.add + (get_local $5) + (i64.const -5) + ) + ) + (i64.const -6) + ) + ) + ) + (br_if $label$26 + (i64.ne + (get_local $7) + (get_local $2) + ) + ) + ) + (set_local $4 + (call $_ZN6eoswin7lotteryC2Ey + (i32.add + (get_local $9) + (i32.const 176) + ) + (get_local $0) + ) + ) + (block $label$34 + (block $label$35 + (block $label$36 + (block $label$37 + (block $label$38 + (block $label$39 + (block $label$40 + (block $label$41 + (block $label$42 + (block $label$43 + (br_if $label$43 + (i64.gt_s + (get_local $2) + (i64.const 4921564810347675647) + ) + ) + (br_if $label$42 + (i64.le_s + (get_local $2) + (i64.const 3617214756542218239) + ) + ) + (br_if $label$40 + (i64.eq + (get_local $2) + (i64.const 3617214756542218240) + ) + ) + (br_if $label$39 + (i64.eq + (get_local $2) + (i64.const 3617214760646258688) + ) + ) + (br_if $label$34 + (i64.ne + (get_local $2) + (i64.const 3617214769866997760) + ) + ) + (i32.store offset=116 + (get_local $9) + (i32.const 0) + ) + (i32.store offset=112 + (get_local $9) + (i32.const 2) + ) + (i64.store offset=48 align=4 + (get_local $9) + (i64.load offset=112 + (get_local $9) + ) + ) + (drop + (call $_ZN5eosio14execute_actionIN6eoswin7lotteryES2_JbEEEbPT_MT0_FvDpT1_E + (get_local $4) + (i32.add + (get_local $9) + (i32.const 48) + ) + ) + ) + (br $label$34) + ) + (br_if $label$41 + (i64.le_s + (get_local $2) + (i64.const 5606348217378668543) + ) + ) + (br_if $label$38 + (i64.eq + (get_local $2) + (i64.const 5606348217378668544) + ) + ) + (br_if $label$37 + (i64.eq + (get_local $2) + (i64.const 5606356246820028416) + ) + ) + (br_if $label$34 + (i64.ne + (get_local $2) + (i64.const 6182744245170122752) + ) + ) + (i32.store offset=100 + (get_local $9) + (i32.const 0) + ) + (i32.store offset=96 + (get_local $9) + (i32.const 3) + ) + (i64.store offset=64 align=4 + (get_local $9) + (i64.load offset=96 + (get_local $9) + ) + ) + (drop + (call $_ZN5eosio14execute_actionIN6eoswin7lotteryES2_JEEEbPT_MT0_FvDpT1_E + (get_local $4) + (i32.add + (get_local $9) + (i32.const 64) + ) + ) + ) + (br $label$34) + ) + (br_if $label$36 + (i64.eq + (get_local $2) + (i64.const -4417357895862960128) + ) + ) + (br_if $label$34 + (i64.ne + (get_local $2) + (i64.const -4417032211186843648) + ) + ) + (i32.store offset=92 + (get_local $9) + (i32.const 0) + ) + (i32.store offset=88 + (get_local $9) + (i32.const 4) + ) + (i64.store offset=72 align=4 + (get_local $9) + (i64.load offset=88 + (get_local $9) + ) + ) + (drop + (call $_ZN5eosio14execute_actionIN6eoswin7lotteryES2_JyyEEEbPT_MT0_FvDpT1_E + (get_local $4) + (i32.add + (get_local $9) + (i32.const 72) + ) + ) + ) + (br $label$34) + ) + (br_if $label$35 + (i64.eq + (get_local $2) + (i64.const 4921564810347675648) + ) + ) + (br_if $label$34 + (i64.ne + (get_local $2) + (i64.const 5377983117906673664) + ) + ) + (i32.store offset=164 + (get_local $9) + (i32.const 0) + ) + (i32.store offset=160 + (get_local $9) + (i32.const 5) + ) + (i64.store align=4 + (get_local $9) + (i64.load offset=160 + (get_local $9) + ) + ) + (drop + (call $_ZN5eosio14execute_actionIN6eoswin7lotteryES2_JyEEEbPT_MT0_FvDpT1_E + (get_local $4) + (get_local $9) + ) + ) + (br $label$34) + ) + (i32.store offset=140 + (get_local $9) + (i32.const 0) + ) + (i32.store offset=136 + (get_local $9) + (i32.const 6) + ) + (i64.store offset=24 align=4 + (get_local $9) + (i64.load offset=136 + (get_local $9) + ) + ) + (drop + (call $_ZN5eosio14execute_actionIN6eoswin7lotteryES2_JyEEEbPT_MT0_FvDpT1_E + (get_local $4) + (i32.add + (get_local $9) + (i32.const 24) + ) + ) + ) + (br $label$34) + ) + (i32.store offset=108 + (get_local $9) + (i32.const 0) + ) + (i32.store offset=104 + (get_local $9) + (i32.const 7) + ) + (i64.store offset=56 align=4 + (get_local $9) + (i64.load offset=104 + (get_local $9) + ) + ) + (drop + (call $_ZN5eosio14execute_actionIN6eoswin7lotteryES2_JbEEEbPT_MT0_FvDpT1_E + (get_local $4) + (i32.add + (get_local $9) + (i32.const 56) + ) + ) + ) + (br $label$34) + ) + (i32.store offset=148 + (get_local $9) + (i32.const 0) + ) + (i32.store offset=144 + (get_local $9) + (i32.const 8) + ) + (i64.store offset=16 align=4 + (get_local $9) + (i64.load offset=144 + (get_local $9) + ) + ) + (drop + (call $_ZN5eosio14execute_actionIN6eoswin7lotteryES2_JyEEEbPT_MT0_FvDpT1_E + (get_local $4) + (i32.add + (get_local $9) + (i32.const 16) + ) + ) + ) + (br $label$34) + ) + (i32.store offset=156 + (get_local $9) + (i32.const 0) + ) + (i32.store offset=152 + (get_local $9) + (i32.const 9) + ) + (i64.store offset=8 align=4 + (get_local $9) + (i64.load offset=152 + (get_local $9) + ) + ) + (drop + (call $_ZN5eosio14execute_actionIN6eoswin7lotteryES2_JyEEEbPT_MT0_FvDpT1_E + (get_local $4) + (i32.add + (get_local $9) + (i32.const 8) + ) + ) + ) + (br $label$34) + ) + (i32.store offset=132 + (get_local $9) + (i32.const 0) + ) + (i32.store offset=128 + (get_local $9) + (i32.const 10) + ) + (i64.store offset=32 align=4 + (get_local $9) + (i64.load offset=128 + (get_local $9) + ) + ) + (drop + (call $_ZN5eosio14execute_actionIN6eoswin7lotteryES2_JbEEEbPT_MT0_FvDpT1_E + (get_local $4) + (i32.add + (get_local $9) + (i32.const 32) + ) + ) + ) + (br $label$34) + ) + (i32.store offset=124 + (get_local $9) + (i32.const 0) + ) + (i32.store offset=120 + (get_local $9) + (i32.const 11) + ) + (i64.store offset=40 align=4 + (get_local $9) + (i64.load offset=120 + (get_local $9) + ) + ) + (drop + (call $_ZN5eosio14execute_actionIN6eoswin7lotteryES2_JyyEEEbPT_MT0_FvDpT1_E + (get_local $4) + (i32.add + (get_local $9) + (i32.const 40) + ) + ) + ) + ) + (drop + (call $_ZN6eoswin7lotteryD2Ev + (get_local $4) + ) + ) + ) + (i32.store offset=4 + (i32.const 0) + (i32.add + (get_local $9) + (i32.const 544) + ) + ) + ) + (func $_ZN5eosio14execute_actionIN6eoswin7lotteryES2_JyyEEEbPT_MT0_FvDpT1_E (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + (local $3 i64) + (local $4 i64) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (local $8 i32) + (set_local $8 + (tee_local $6 + (i32.sub + (i32.load offset=4 + (i32.const 0) + ) + (i32.const 16) + ) + ) + ) + (i32.store offset=4 + (i32.const 0) + (get_local $6) + ) + (set_local $2 + (i32.load offset=4 + (get_local $1) + ) + ) + (set_local $7 + (i32.load + (get_local $1) + ) + ) + (block $label$0 + (block $label$1 + (block $label$2 + (block $label$3 + (br_if $label$3 + (i32.eqz + (tee_local $1 + (call $action_data_size) + ) + ) + ) + (br_if $label$2 + (i32.lt_u + (get_local $1) + (i32.const 513) + ) + ) + (set_local $6 + (call $malloc + (get_local $1) + ) + ) + (br $label$1) + ) + (set_local $6 + (i32.const 0) + ) + (br $label$0) + ) + (i32.store offset=4 + (i32.const 0) + (tee_local $6 + (i32.sub + (get_local $6) + (i32.and + (i32.add + (get_local $1) + (i32.const 15) + ) + (i32.const -16) + ) + ) + ) + ) + ) + (drop + (call $read_action_data + (get_local $6) + (get_local $1) + ) + ) + ) + (i64.store offset=8 + (get_local $8) + (i64.const 0) + ) + (i64.store + (get_local $8) + (i64.const 0) + ) + (call $eosio_assert + (i32.gt_u + (get_local $1) + (i32.const 7) + ) + (i32.const 272) + ) + (drop + (call $memcpy + (get_local $8) + (get_local $6) + (i32.const 8) + ) + ) + (call $eosio_assert + (i32.ne + (i32.and + (get_local $1) + (i32.const -8) + ) + (i32.const 8) + ) + (i32.const 272) + ) + (drop + (call $memcpy + (tee_local $5 + (i32.add + (get_local $8) + (i32.const 8) + ) + ) + (i32.add + (get_local $6) + (i32.const 8) + ) + (i32.const 8) + ) + ) + (block $label$4 + (br_if $label$4 + (i32.lt_u + (get_local $1) + (i32.const 513) + ) + ) + (call $free + (get_local $6) + ) + ) + (set_local $1 + (i32.add + (get_local $0) + (i32.shr_s + (get_local $2) + (i32.const 1) + ) + ) + ) + (set_local $4 + (i64.load + (get_local $5) + ) + ) + (set_local $3 + (i64.load + (get_local $8) + ) + ) + (block $label$5 + (br_if $label$5 + (i32.eqz + (i32.and + (get_local $2) + (i32.const 1) + ) + ) + ) + (set_local $7 + (i32.load + (i32.add + (i32.load + (get_local $1) + ) + (get_local $7) + ) + ) + ) + ) + (call_indirect (type $FUNCSIG$vijj) + (get_local $1) + (get_local $3) + (get_local $4) + (get_local $7) + ) + (i32.store offset=4 + (i32.const 0) + (i32.add + (get_local $8) + (i32.const 16) + ) + ) + (i32.const 1) + ) + (func $_ZN5eosio14execute_actionIN6eoswin7lotteryES2_JyEEEbPT_MT0_FvDpT1_E (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + (local $3 i64) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (set_local $6 + (tee_local $4 + (i32.sub + (i32.load offset=4 + (i32.const 0) + ) + (i32.const 16) + ) + ) + ) + (i32.store offset=4 + (i32.const 0) + (get_local $4) + ) + (set_local $2 + (i32.load offset=4 + (get_local $1) + ) + ) + (set_local $5 + (i32.load + (get_local $1) + ) + ) + (block $label$0 + (block $label$1 + (block $label$2 + (block $label$3 + (br_if $label$3 + (i32.eqz + (tee_local $1 + (call $action_data_size) + ) + ) + ) + (br_if $label$2 + (i32.lt_u + (get_local $1) + (i32.const 513) + ) + ) + (set_local $4 + (call $malloc + (get_local $1) + ) + ) + (br $label$1) + ) + (set_local $4 + (i32.const 0) + ) + (br $label$0) + ) + (i32.store offset=4 + (i32.const 0) + (tee_local $4 + (i32.sub + (get_local $4) + (i32.and + (i32.add + (get_local $1) + (i32.const 15) + ) + (i32.const -16) + ) + ) + ) + ) + ) + (drop + (call $read_action_data + (get_local $4) + (get_local $1) + ) + ) + ) + (i64.store offset=8 + (get_local $6) + (i64.const 0) + ) + (call $eosio_assert + (i32.gt_u + (get_local $1) + (i32.const 7) + ) + (i32.const 272) + ) + (drop + (call $memcpy + (i32.add + (get_local $6) + (i32.const 8) + ) + (get_local $4) + (i32.const 8) + ) + ) + (set_local $3 + (i64.load offset=8 + (get_local $6) + ) + ) + (block $label$4 + (br_if $label$4 + (i32.lt_u + (get_local $1) + (i32.const 513) + ) + ) + (call $free + (get_local $4) + ) + ) + (set_local $1 + (i32.add + (get_local $0) + (i32.shr_s + (get_local $2) + (i32.const 1) + ) + ) + ) + (block $label$5 + (br_if $label$5 + (i32.eqz + (i32.and + (get_local $2) + (i32.const 1) + ) + ) + ) + (set_local $5 + (i32.load + (i32.add + (i32.load + (get_local $1) + ) + (get_local $5) + ) + ) + ) + ) + (call_indirect (type $FUNCSIG$vij) + (get_local $1) + (get_local $3) + (get_local $5) + ) + (i32.store offset=4 + (i32.const 0) + (i32.add + (get_local $6) + (i32.const 16) + ) + ) + (i32.const 1) + ) + (func $_ZN5eosio14execute_actionIN6eoswin7lotteryES2_JbEEEbPT_MT0_FvDpT1_E (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (set_local $5 + (tee_local $6 + (i32.sub + (i32.load offset=4 + (i32.const 0) + ) + (i32.const 16) + ) + ) + ) + (i32.store offset=4 + (i32.const 0) + (get_local $6) + ) + (set_local $2 + (i32.load offset=4 + (get_local $1) + ) + ) + (set_local $4 + (i32.load + (get_local $1) + ) + ) + (set_local $3 + (i32.const 0) + ) + (block $label$0 + (br_if $label$0 + (i32.eqz + (tee_local $1 + (call $action_data_size) + ) + ) + ) + (block $label$1 + (block $label$2 + (br_if $label$2 + (i32.lt_u + (get_local $1) + (i32.const 513) + ) + ) + (set_local $3 + (call $malloc + (get_local $1) + ) + ) + (br $label$1) + ) + (i32.store offset=4 + (i32.const 0) + (tee_local $3 + (i32.sub + (get_local $6) + (i32.and + (i32.add + (get_local $1) + (i32.const 15) + ) + (i32.const -16) + ) + ) + ) + ) + ) + (drop + (call $read_action_data + (get_local $3) + (get_local $1) + ) + ) + ) + (call $eosio_assert + (i32.ne + (get_local $1) + (i32.const 0) + ) + (i32.const 272) + ) + (drop + (call $memcpy + (i32.add + (get_local $5) + (i32.const 15) + ) + (get_local $3) + (i32.const 1) + ) + ) + (set_local $6 + (i32.load8_u offset=15 + (get_local $5) + ) + ) + (block $label$3 + (br_if $label$3 + (i32.lt_u + (get_local $1) + (i32.const 513) + ) + ) + (call $free + (get_local $3) + ) + ) + (set_local $1 + (i32.add + (get_local $0) + (i32.shr_s + (get_local $2) + (i32.const 1) + ) + ) + ) + (block $label$4 + (br_if $label$4 + (i32.eqz + (i32.and + (get_local $2) + (i32.const 1) + ) + ) + ) + (set_local $4 + (i32.load + (i32.add + (i32.load + (get_local $1) + ) + (get_local $4) + ) + ) + ) + ) + (call_indirect (type $FUNCSIG$vii) + (get_local $1) + (i32.ne + (i32.and + (get_local $6) + (i32.const 255) + ) + (i32.const 0) + ) + (get_local $4) + ) + (i32.store offset=4 + (i32.const 0) + (i32.add + (get_local $5) + (i32.const 16) + ) + ) + (i32.const 1) + ) + (func $_ZN5eosio14execute_actionIN6eoswin7lotteryES2_JEEEbPT_MT0_FvDpT1_E (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (set_local $4 + (tee_local $5 + (i32.load offset=4 + (i32.const 0) + ) + ) + ) + (set_local $2 + (i32.load offset=4 + (get_local $1) + ) + ) + (set_local $1 + (i32.load + (get_local $1) + ) + ) + (block $label$0 + (br_if $label$0 + (i32.eqz + (tee_local $3 + (call $action_data_size) + ) + ) + ) + (block $label$1 + (br_if $label$1 + (i32.le_u + (get_local $3) + (i32.const 512) + ) + ) + (drop + (call $read_action_data + (tee_local $5 + (call $malloc + (get_local $3) + ) + ) + (get_local $3) + ) + ) + (call $free + (get_local $5) + ) + (br $label$0) + ) + (i32.store offset=4 + (i32.const 0) + (tee_local $5 + (i32.sub + (get_local $5) + (i32.and + (i32.add + (get_local $3) + (i32.const 15) + ) + (i32.const -16) + ) + ) + ) + ) + (drop + (call $read_action_data + (get_local $5) + (get_local $3) + ) + ) + ) + (set_local $3 + (i32.add + (get_local $0) + (i32.shr_s + (get_local $2) + (i32.const 1) + ) + ) + ) + (block $label$2 + (br_if $label$2 + (i32.eqz + (i32.and + (get_local $2) + (i32.const 1) + ) + ) + ) + (set_local $1 + (i32.load + (i32.add + (i32.load + (get_local $3) + ) + (get_local $1) + ) + ) + ) + ) + (call_indirect (type $FUNCSIG$vi) + (get_local $3) + (get_local $1) + ) + (i32.store offset=4 + (i32.const 0) + (get_local $4) + ) + (i32.const 1) + ) + (func $malloc (param $0 i32) (result i32) + (call $_ZN5eosio14memory_manager6mallocEm + (i32.const 3552) + (get_local $0) + ) + ) + (func $_ZN5eosio14memory_manager6mallocEm (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (local $8 i32) + (local $9 i32) + (local $10 i32) + (local $11 i32) + (local $12 i32) + (local $13 i32) + (block $label$0 + (br_if $label$0 + (i32.eqz + (get_local $1) + ) + ) + (block $label$1 + (br_if $label$1 + (tee_local $13 + (i32.load offset=8384 + (get_local $0) + ) + ) + ) + (set_local $13 + (i32.const 16) + ) + (i32.store + (i32.add + (get_local $0) + (i32.const 8384) + ) + (i32.const 16) + ) + ) + (set_local $2 + (select + (i32.sub + (i32.add + (get_local $1) + (i32.const 8) + ) + (tee_local $2 + (i32.and + (i32.add + (get_local $1) + (i32.const 4) + ) + (i32.const 7) + ) + ) + ) + (get_local $1) + (get_local $2) + ) + ) + (block $label$2 + (block $label$3 + (block $label$4 + (br_if $label$4 + (i32.ge_u + (tee_local $10 + (i32.load offset=8388 + (get_local $0) + ) + ) + (get_local $13) + ) + ) + (set_local $1 + (i32.add + (i32.add + (get_local $0) + (i32.mul + (get_local $10) + (i32.const 12) + ) + ) + (i32.const 8192) + ) + ) + (block $label$5 + (br_if $label$5 + (get_local $10) + ) + (br_if $label$5 + (i32.load + (tee_local $13 + (i32.add + (get_local $0) + (i32.const 8196) + ) + ) + ) + ) + (i32.store + (get_local $1) + (i32.const 8192) + ) + (i32.store + (get_local $13) + (get_local $0) + ) + ) + (set_local $10 + (i32.add + (get_local $2) + (i32.const 4) + ) + ) + (loop $label$6 + (block $label$7 + (br_if $label$7 + (i32.gt_u + (i32.add + (tee_local $13 + (i32.load offset=8 + (get_local $1) + ) + ) + (get_local $10) + ) + (i32.load + (get_local $1) + ) + ) + ) + (i32.store + (tee_local $13 + (i32.add + (i32.load offset=4 + (get_local $1) + ) + (get_local $13) + ) + ) + (i32.or + (i32.and + (i32.load + (get_local $13) + ) + (i32.const -2147483648) + ) + (get_local $2) + ) + ) + (i32.store + (tee_local $1 + (i32.add + (get_local $1) + (i32.const 8) + ) + ) + (i32.add + (i32.load + (get_local $1) + ) + (get_local $10) + ) + ) + (i32.store + (get_local $13) + (i32.or + (i32.load + (get_local $13) + ) + (i32.const -2147483648) + ) + ) + (br_if $label$3 + (tee_local $1 + (i32.add + (get_local $13) + (i32.const 4) + ) + ) + ) + ) + (br_if $label$6 + (tee_local $1 + (call $_ZN5eosio14memory_manager16next_active_heapEv + (get_local $0) + ) + ) + ) + ) + ) + (set_local $4 + (i32.sub + (i32.const 2147483644) + (get_local $2) + ) + ) + (set_local $11 + (i32.add + (get_local $0) + (i32.const 8392) + ) + ) + (set_local $12 + (i32.add + (get_local $0) + (i32.const 8384) + ) + ) + (set_local $13 + (tee_local $3 + (i32.load offset=8392 + (get_local $0) + ) + ) + ) + (loop $label$8 + (call $eosio_assert + (i32.eq + (i32.load + (i32.add + (tee_local $1 + (i32.add + (get_local $0) + (i32.mul + (get_local $13) + (i32.const 12) + ) + ) + ) + (i32.const 8200) + ) + ) + (i32.load + (tee_local $5 + (i32.add + (get_local $1) + (i32.const 8192) + ) + ) + ) + ) + (i32.const 11952) + ) + (set_local $13 + (i32.add + (tee_local $6 + (i32.load + (i32.add + (get_local $1) + (i32.const 8196) + ) + ) + ) + (i32.const 4) + ) + ) + (loop $label$9 + (set_local $7 + (i32.add + (get_local $6) + (i32.load + (get_local $5) + ) + ) + ) + (set_local $1 + (i32.and + (tee_local $9 + (i32.load + (tee_local $8 + (i32.add + (get_local $13) + (i32.const -4) + ) + ) + ) + ) + (i32.const 2147483647) + ) + ) + (block $label$10 + (br_if $label$10 + (i32.lt_s + (get_local $9) + (i32.const 0) + ) + ) + (block $label$11 + (br_if $label$11 + (i32.ge_u + (get_local $1) + (get_local $2) + ) + ) + (loop $label$12 + (br_if $label$11 + (i32.ge_u + (tee_local $10 + (i32.add + (get_local $13) + (get_local $1) + ) + ) + (get_local $7) + ) + ) + (br_if $label$11 + (i32.lt_s + (tee_local $10 + (i32.load + (get_local $10) + ) + ) + (i32.const 0) + ) + ) + (br_if $label$12 + (i32.lt_u + (tee_local $1 + (i32.add + (i32.add + (get_local $1) + (i32.and + (get_local $10) + (i32.const 2147483647) + ) + ) + (i32.const 4) + ) + ) + (get_local $2) + ) + ) + ) + ) + (i32.store + (get_local $8) + (i32.or + (select + (get_local $1) + (get_local $2) + (i32.lt_u + (get_local $1) + (get_local $2) + ) + ) + (i32.and + (get_local $9) + (i32.const -2147483648) + ) + ) + ) + (block $label$13 + (br_if $label$13 + (i32.le_u + (get_local $1) + (get_local $2) + ) + ) + (i32.store + (i32.add + (get_local $13) + (get_local $2) + ) + (i32.and + (i32.add + (get_local $4) + (get_local $1) + ) + (i32.const 2147483647) + ) + ) + ) + (br_if $label$2 + (i32.ge_u + (get_local $1) + (get_local $2) + ) + ) + ) + (br_if $label$9 + (i32.lt_u + (tee_local $13 + (i32.add + (i32.add + (get_local $13) + (get_local $1) + ) + (i32.const 4) + ) + ) + (get_local $7) + ) + ) + ) + (set_local $1 + (i32.const 0) + ) + (i32.store + (get_local $11) + (tee_local $13 + (select + (i32.const 0) + (tee_local $13 + (i32.add + (i32.load + (get_local $11) + ) + (i32.const 1) + ) + ) + (i32.eq + (get_local $13) + (i32.load + (get_local $12) + ) + ) + ) + ) + ) + (br_if $label$8 + (i32.ne + (get_local $13) + (get_local $3) + ) + ) + ) + ) + (return + (get_local $1) + ) + ) + (i32.store + (get_local $8) + (i32.or + (i32.load + (get_local $8) + ) + (i32.const -2147483648) + ) + ) + (return + (get_local $13) + ) + ) + (i32.const 0) + ) + (func $_ZN5eosio14memory_manager16next_active_heapEv (param $0 i32) (result i32) + (local $1 i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (local $8 i32) + (set_local $1 + (i32.load offset=8388 + (get_local $0) + ) + ) + (block $label$0 + (block $label$1 + (br_if $label$1 + (i32.eqz + (i32.load8_u offset=12038 + (i32.const 0) + ) + ) + ) + (set_local $7 + (i32.load offset=12040 + (i32.const 0) + ) + ) + (br $label$0) + ) + (set_local $7 + (current_memory) + ) + (i32.store8 offset=12038 + (i32.const 0) + (i32.const 1) + ) + (i32.store offset=12040 + (i32.const 0) + (tee_local $7 + (i32.shl + (get_local $7) + (i32.const 16) + ) + ) + ) + ) + (set_local $3 + (get_local $7) + ) + (block $label$2 + (block $label$3 + (block $label$4 + (block $label$5 + (br_if $label$5 + (i32.le_u + (tee_local $2 + (i32.shr_u + (i32.add + (get_local $7) + (i32.const 65535) + ) + (i32.const 16) + ) + ) + (tee_local $8 + (current_memory) + ) + ) + ) + (drop + (grow_memory + (i32.sub + (get_local $2) + (get_local $8) + ) + ) + ) + (set_local $8 + (i32.const 0) + ) + (br_if $label$4 + (i32.ne + (get_local $2) + (current_memory) + ) + ) + (set_local $3 + (i32.load offset=12040 + (i32.const 0) + ) + ) + ) + (set_local $8 + (i32.const 0) + ) + (i32.store offset=12040 + (i32.const 0) + (get_local $3) + ) + (br_if $label$4 + (i32.lt_s + (get_local $7) + (i32.const 0) + ) + ) + (set_local $2 + (i32.add + (get_local $0) + (i32.mul + (get_local $1) + (i32.const 12) + ) + ) + ) + (set_local $7 + (i32.sub + (i32.sub + (i32.add + (get_local $7) + (select + (i32.const 65536) + (i32.const 131072) + (tee_local $6 + (i32.lt_u + (tee_local $8 + (i32.and + (get_local $7) + (i32.const 65535) + ) + ) + (i32.const 64513) + ) + ) + ) + ) + (select + (get_local $8) + (i32.and + (get_local $7) + (i32.const 131071) + ) + (get_local $6) + ) + ) + (get_local $7) + ) + ) + (block $label$6 + (br_if $label$6 + (i32.load8_u offset=12038 + (i32.const 0) + ) + ) + (set_local $3 + (current_memory) + ) + (i32.store8 offset=12038 + (i32.const 0) + (i32.const 1) + ) + (i32.store offset=12040 + (i32.const 0) + (tee_local $3 + (i32.shl + (get_local $3) + (i32.const 16) + ) + ) + ) + ) + (set_local $2 + (i32.add + (get_local $2) + (i32.const 8192) + ) + ) + (br_if $label$3 + (i32.lt_s + (get_local $7) + (i32.const 0) + ) + ) + (set_local $6 + (get_local $3) + ) + (block $label$7 + (br_if $label$7 + (i32.le_u + (tee_local $8 + (i32.shr_u + (i32.add + (i32.add + (tee_local $5 + (i32.and + (i32.add + (get_local $7) + (i32.const 7) + ) + (i32.const -8) + ) + ) + (get_local $3) + ) + (i32.const 65535) + ) + (i32.const 16) + ) + ) + (tee_local $4 + (current_memory) + ) + ) + ) + (drop + (grow_memory + (i32.sub + (get_local $8) + (get_local $4) + ) + ) + ) + (br_if $label$3 + (i32.ne + (get_local $8) + (current_memory) + ) + ) + (set_local $6 + (i32.load offset=12040 + (i32.const 0) + ) + ) + ) + (i32.store offset=12040 + (i32.const 0) + (i32.add + (get_local $6) + (get_local $5) + ) + ) + (br_if $label$3 + (i32.eq + (get_local $3) + (i32.const -1) + ) + ) + (br_if $label$2 + (i32.eq + (i32.add + (tee_local $6 + (i32.load + (i32.add + (tee_local $1 + (i32.add + (get_local $0) + (i32.mul + (get_local $1) + (i32.const 12) + ) + ) + ) + (i32.const 8196) + ) + ) + ) + (tee_local $8 + (i32.load + (get_local $2) + ) + ) + ) + (get_local $3) + ) + ) + (block $label$8 + (br_if $label$8 + (i32.eq + (get_local $8) + (tee_local $1 + (i32.load + (tee_local $5 + (i32.add + (get_local $1) + (i32.const 8200) + ) + ) + ) + ) + ) + ) + (i32.store + (tee_local $6 + (i32.add + (get_local $6) + (get_local $1) + ) + ) + (i32.or + (i32.and + (i32.load + (get_local $6) + ) + (i32.const -2147483648) + ) + (i32.add + (i32.sub + (i32.const -4) + (get_local $1) + ) + (get_local $8) + ) + ) + ) + (i32.store + (get_local $5) + (i32.load + (get_local $2) + ) + ) + (i32.store + (get_local $6) + (i32.and + (i32.load + (get_local $6) + ) + (i32.const 2147483647) + ) + ) + ) + (i32.store + (tee_local $2 + (i32.add + (get_local $0) + (i32.const 8388) + ) + ) + (tee_local $2 + (i32.add + (i32.load + (get_local $2) + ) + (i32.const 1) + ) + ) + ) + (i32.store + (i32.add + (tee_local $0 + (i32.add + (get_local $0) + (i32.mul + (get_local $2) + (i32.const 12) + ) + ) + ) + (i32.const 8196) + ) + (get_local $3) + ) + (i32.store + (tee_local $8 + (i32.add + (get_local $0) + (i32.const 8192) + ) + ) + (get_local $7) + ) + ) + (return + (get_local $8) + ) + ) + (block $label$9 + (br_if $label$9 + (i32.eq + (tee_local $8 + (i32.load + (get_local $2) + ) + ) + (tee_local $7 + (i32.load + (tee_local $1 + (i32.add + (tee_local $3 + (i32.add + (get_local $0) + (i32.mul + (get_local $1) + (i32.const 12) + ) + ) + ) + (i32.const 8200) + ) + ) + ) + ) + ) + ) + (i32.store + (tee_local $3 + (i32.add + (i32.load + (i32.add + (get_local $3) + (i32.const 8196) + ) + ) + (get_local $7) + ) + ) + (i32.or + (i32.and + (i32.load + (get_local $3) + ) + (i32.const -2147483648) + ) + (i32.add + (i32.sub + (i32.const -4) + (get_local $7) + ) + (get_local $8) + ) + ) + ) + (i32.store + (get_local $1) + (i32.load + (get_local $2) + ) + ) + (i32.store + (get_local $3) + (i32.and + (i32.load + (get_local $3) + ) + (i32.const 2147483647) + ) + ) + ) + (i32.store offset=8384 + (get_local $0) + (tee_local $3 + (i32.add + (i32.load + (tee_local $7 + (i32.add + (get_local $0) + (i32.const 8388) + ) + ) + ) + (i32.const 1) + ) + ) + ) + (i32.store + (get_local $7) + (get_local $3) + ) + (return + (i32.const 0) + ) + ) + (i32.store + (get_local $2) + (i32.add + (get_local $8) + (get_local $7) + ) + ) + (get_local $2) + ) + (func $free (param $0 i32) + (local $1 i32) + (local $2 i32) + (local $3 i32) + (block $label$0 + (block $label$1 + (br_if $label$1 + (i32.eqz + (get_local $0) + ) + ) + (br_if $label$1 + (i32.lt_s + (tee_local $2 + (i32.load offset=11936 + (i32.const 0) + ) + ) + (i32.const 1) + ) + ) + (set_local $3 + (i32.const 11744) + ) + (set_local $1 + (i32.add + (i32.mul + (get_local $2) + (i32.const 12) + ) + (i32.const 11744) + ) + ) + (loop $label$2 + (br_if $label$1 + (i32.eqz + (tee_local $2 + (i32.load + (i32.add + (get_local $3) + (i32.const 4) + ) + ) + ) + ) + ) + (block $label$3 + (br_if $label$3 + (i32.gt_u + (i32.add + (get_local $2) + (i32.const 4) + ) + (get_local $0) + ) + ) + (br_if $label$0 + (i32.gt_u + (i32.add + (get_local $2) + (i32.load + (get_local $3) + ) + ) + (get_local $0) + ) + ) + ) + (br_if $label$2 + (i32.lt_u + (tee_local $3 + (i32.add + (get_local $3) + (i32.const 12) + ) + ) + (get_local $1) + ) + ) + ) + ) + (return) + ) + (i32.store + (tee_local $3 + (i32.add + (get_local $0) + (i32.const -4) + ) + ) + (i32.and + (i32.load + (get_local $3) + ) + (i32.const 2147483647) + ) + ) + ) + (func $_Znwj (param $0 i32) (result i32) + (local $1 i32) + (local $2 i32) + (block $label$0 + (br_if $label$0 + (tee_local $0 + (call $malloc + (tee_local $1 + (select + (get_local $0) + (i32.const 1) + (get_local $0) + ) + ) + ) + ) + ) + (loop $label$1 + (set_local $0 + (i32.const 0) + ) + (br_if $label$0 + (i32.eqz + (tee_local $2 + (i32.load offset=12044 + (i32.const 0) + ) + ) + ) + ) + (call_indirect (type $FUNCSIG$v) + (get_local $2) + ) + (br_if $label$1 + (i32.eqz + (tee_local $0 + (call $malloc + (get_local $1) + ) + ) + ) + ) + ) + ) + (get_local $0) + ) + (func $_ZdlPv (param $0 i32) + (block $label$0 + (br_if $label$0 + (i32.eqz + (get_local $0) + ) + ) + (call $free + (get_local $0) + ) + ) + ) + (func $_ZNKSt3__121__basic_string_commonILb1EE20__throw_length_errorEv (param $0 i32) + (call $abort) + (unreachable) + ) + (func $_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7reserveEj (param $0 i32) (param $1 i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (block $label$0 + (br_if $label$0 + (i32.ge_u + (get_local $1) + (i32.const -16) + ) + ) + (set_local $2 + (i32.const 10) + ) + (block $label$1 + (br_if $label$1 + (i32.eqz + (i32.and + (tee_local $5 + (i32.load8_u + (get_local $0) + ) + ) + (i32.const 1) + ) + ) + ) + (set_local $2 + (i32.add + (i32.and + (tee_local $5 + (i32.load + (get_local $0) + ) + ) + (i32.const -2) + ) + (i32.const -1) + ) + ) + ) + (block $label$2 + (block $label$3 + (br_if $label$3 + (i32.and + (get_local $5) + (i32.const 1) + ) + ) + (set_local $3 + (i32.shr_u + (i32.and + (get_local $5) + (i32.const 254) + ) + (i32.const 1) + ) + ) + (br $label$2) + ) + (set_local $3 + (i32.load offset=4 + (get_local $0) + ) + ) + ) + (set_local $4 + (i32.const 10) + ) + (block $label$4 + (br_if $label$4 + (i32.lt_u + (tee_local $1 + (select + (get_local $3) + (get_local $1) + (i32.gt_u + (get_local $3) + (get_local $1) + ) + ) + ) + (i32.const 11) + ) + ) + (set_local $4 + (i32.add + (i32.and + (i32.add + (get_local $1) + (i32.const 16) + ) + (i32.const -16) + ) + (i32.const -1) + ) + ) + ) + (block $label$5 + (br_if $label$5 + (i32.eq + (get_local $4) + (get_local $2) + ) + ) + (block $label$6 + (block $label$7 + (br_if $label$7 + (i32.ne + (get_local $4) + (i32.const 10) + ) + ) + (set_local $6 + (i32.const 1) + ) + (set_local $1 + (i32.add + (get_local $0) + (i32.const 1) + ) + ) + (set_local $2 + (i32.load offset=8 + (get_local $0) + ) + ) + (set_local $7 + (i32.const 0) + ) + (br $label$6) + ) + (set_local $1 + (call $_Znwj + (i32.add + (get_local $4) + (i32.const 1) + ) + ) + ) + (block $label$8 + (br_if $label$8 + (i32.gt_u + (get_local $4) + (get_local $2) + ) + ) + (br_if $label$5 + (i32.eqz + (get_local $1) + ) + ) + ) + (block $label$9 + (br_if $label$9 + (i32.and + (tee_local $5 + (i32.load8_u + (get_local $0) + ) + ) + (i32.const 1) + ) + ) + (set_local $7 + (i32.const 1) + ) + (set_local $2 + (i32.add + (get_local $0) + (i32.const 1) + ) + ) + (set_local $6 + (i32.const 0) + ) + (br $label$6) + ) + (set_local $2 + (i32.load offset=8 + (get_local $0) + ) + ) + (set_local $6 + (i32.const 1) + ) + (set_local $7 + (i32.const 1) + ) + ) + (block $label$10 + (block $label$11 + (br_if $label$11 + (i32.and + (get_local $5) + (i32.const 1) + ) + ) + (set_local $5 + (i32.shr_u + (i32.and + (get_local $5) + (i32.const 254) + ) + (i32.const 1) + ) + ) + (br $label$10) + ) + (set_local $5 + (i32.load offset=4 + (get_local $0) + ) + ) + ) + (block $label$12 + (br_if $label$12 + (i32.eqz + (tee_local $5 + (i32.add + (get_local $5) + (i32.const 1) + ) + ) + ) + ) + (drop + (call $memcpy + (get_local $1) + (get_local $2) + (get_local $5) + ) + ) + ) + (block $label$13 + (br_if $label$13 + (i32.eqz + (get_local $6) + ) + ) + (call $_ZdlPv + (get_local $2) + ) + ) + (block $label$14 + (br_if $label$14 + (i32.eqz + (get_local $7) + ) + ) + (i32.store offset=4 + (get_local $0) + (get_local $3) + ) + (i32.store offset=8 + (get_local $0) + (get_local $1) + ) + (i32.store + (get_local $0) + (i32.or + (i32.add + (get_local $4) + (i32.const 1) + ) + (i32.const 1) + ) + ) + (return) + ) + (i32.store8 + (get_local $0) + (i32.shl + (get_local $3) + (i32.const 1) + ) + ) + ) + (return) + ) + (call $abort) + (unreachable) + ) + (func $_ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7compareEjjPKcj (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) (param $4 i32) (result i32) + (local $5 i32) + (local $6 i32) + (block $label$0 + (block $label$1 + (br_if $label$1 + (tee_local $5 + (i32.and + (tee_local $6 + (i32.load8_u + (get_local $0) + ) + ) + (i32.const 1) + ) + ) + ) + (set_local $6 + (i32.shr_u + (get_local $6) + (i32.const 1) + ) + ) + (br $label$0) + ) + (set_local $6 + (i32.load offset=4 + (get_local $0) + ) + ) + ) + (block $label$2 + (br_if $label$2 + (i32.eq + (get_local $4) + (i32.const -1) + ) + ) + (br_if $label$2 + (i32.lt_u + (get_local $6) + (get_local $1) + ) + ) + (set_local $6 + (select + (tee_local $6 + (i32.sub + (get_local $6) + (get_local $1) + ) + ) + (get_local $2) + (i32.lt_u + (get_local $6) + (get_local $2) + ) + ) + ) + (block $label$3 + (block $label$4 + (br_if $label$4 + (get_local $5) + ) + (set_local $0 + (i32.add + (get_local $0) + (i32.const 1) + ) + ) + (br $label$3) + ) + (set_local $0 + (i32.load offset=8 + (get_local $0) + ) + ) + ) + (block $label$5 + (br_if $label$5 + (i32.eqz + (tee_local $2 + (select + (get_local $4) + (get_local $6) + (tee_local $5 + (i32.gt_u + (get_local $6) + (get_local $4) + ) + ) + ) + ) + ) + ) + (br_if $label$5 + (i32.eqz + (tee_local $1 + (call $memcmp + (i32.add + (get_local $0) + (get_local $1) + ) + (get_local $3) + (get_local $2) + ) + ) + ) + ) + (return + (get_local $1) + ) + ) + (return + (select + (i32.const -1) + (get_local $5) + (i32.lt_u + (get_local $6) + (get_local $4) + ) + ) + ) + ) + (call $abort) + (unreachable) + ) + (func $_ZNKSt3__120__vector_base_commonILb1EE20__throw_length_errorEv (param $0 i32) + (call $abort) + (unreachable) + ) + (func $_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEC2ERKS5_ (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (i64.store align=4 + (get_local $0) + (i64.const 0) + ) + (i32.store + (tee_local $3 + (i32.add + (get_local $0) + (i32.const 8) + ) + ) + (i32.const 0) + ) + (block $label$0 + (br_if $label$0 + (i32.and + (i32.load8_u + (get_local $1) + ) + (i32.const 1) + ) + ) + (i64.store align=4 + (get_local $0) + (i64.load align=4 + (get_local $1) + ) + ) + (i32.store + (get_local $3) + (i32.load + (i32.add + (get_local $1) + (i32.const 8) + ) + ) + ) + (return + (get_local $0) + ) + ) + (block $label$1 + (br_if $label$1 + (i32.ge_u + (tee_local $3 + (i32.load offset=4 + (get_local $1) + ) + ) + (i32.const -16) + ) + ) + (set_local $2 + (i32.load offset=8 + (get_local $1) + ) + ) + (block $label$2 + (block $label$3 + (block $label$4 + (br_if $label$4 + (i32.ge_u + (get_local $3) + (i32.const 11) + ) + ) + (i32.store8 + (get_local $0) + (i32.shl + (get_local $3) + (i32.const 1) + ) + ) + (set_local $1 + (i32.add + (get_local $0) + (i32.const 1) + ) + ) + (br_if $label$3 + (get_local $3) + ) + (br $label$2) + ) + (set_local $1 + (call $_Znwj + (tee_local $4 + (i32.and + (i32.add + (get_local $3) + (i32.const 16) + ) + (i32.const -16) + ) + ) + ) + ) + (i32.store + (get_local $0) + (i32.or + (get_local $4) + (i32.const 1) + ) + ) + (i32.store offset=8 + (get_local $0) + (get_local $1) + ) + (i32.store offset=4 + (get_local $0) + (get_local $3) + ) + ) + (drop + (call $memcpy + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + ) + (i32.store8 + (i32.add + (get_local $1) + (get_local $3) + ) + (i32.const 0) + ) + (return + (get_local $0) + ) + ) + (call $abort) + (unreachable) + ) + (func $sprintf (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i32) + (i32.store offset=4 + (i32.const 0) + (tee_local $3 + (i32.sub + (i32.load offset=4 + (i32.const 0) + ) + (i32.const 16) + ) + ) + ) + (i32.store offset=12 + (get_local $3) + (get_local $2) + ) + (set_local $2 + (call $vsprintf + (get_local $0) + (get_local $1) + (get_local $2) + ) + ) + (i32.store offset=4 + (i32.const 0) + (i32.add + (get_local $3) + (i32.const 16) + ) + ) + (get_local $2) + ) + (func $vsprintf (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (call $vsnprintf + (get_local $0) + (i32.const 2147483647) + (get_local $1) + (get_local $2) + ) + ) + (func $vsnprintf (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) (result i32) + (local $4 i32) + (local $5 i32) + (i32.store offset=4 + (i32.const 0) + (tee_local $4 + (i32.sub + (i32.load offset=4 + (i32.const 0) + ) + (i32.const 160) + ) + ) + ) + (set_local $5 + (i32.const -1) + ) + (i32.store offset=148 + (get_local $4) + (select + (i32.add + (get_local $1) + (i32.const -1) + ) + (i32.const 0) + (get_local $1) + ) + ) + (i32.store offset=144 + (get_local $4) + (tee_local $0 + (select + (get_local $0) + (i32.add + (get_local $4) + (i32.const 158) + ) + (get_local $1) + ) + ) + ) + (i32.store offset=36 + (tee_local $4 + (call $memset + (get_local $4) + (i32.const 0) + (i32.const 144) + ) + ) + (i32.const 12) + ) + (i32.store8 offset=75 + (get_local $4) + (i32.const 255) + ) + (i32.store offset=76 + (get_local $4) + (i32.const -1) + ) + (i32.store offset=44 + (get_local $4) + (i32.add + (get_local $4) + (i32.const 159) + ) + ) + (i32.store offset=84 + (get_local $4) + (i32.add + (get_local $4) + (i32.const 144) + ) + ) + (block $label$0 + (block $label$1 + (br_if $label$1 + (i32.le_s + (get_local $1) + (i32.const -1) + ) + ) + (i32.store8 + (get_local $0) + (i32.const 0) + ) + (set_local $5 + (call $vfprintf + (get_local $4) + (get_local $2) + (get_local $3) + ) + ) + (br $label$0) + ) + (i32.store + (call $__errno_location) + (i32.const 75) + ) + ) + (i32.store offset=4 + (i32.const 0) + (i32.add + (get_local $4) + (i32.const 160) + ) + ) + (get_local $5) + ) + (func $sn_write (type $FUNCSIG$iiii) (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (block $label$0 + (br_if $label$0 + (i32.eqz + (tee_local $6 + (select + (tee_local $5 + (i32.load offset=4 + (tee_local $3 + (i32.load offset=84 + (get_local $0) + ) + ) + ) + ) + (tee_local $6 + (i32.sub + (i32.load offset=20 + (get_local $0) + ) + (tee_local $4 + (i32.load offset=28 + (get_local $0) + ) + ) + ) + ) + (i32.lt_u + (get_local $5) + (get_local $6) + ) + ) + ) + ) + ) + (drop + (call $memcpy + (i32.load + (get_local $3) + ) + (get_local $4) + (get_local $6) + ) + ) + (i32.store + (get_local $3) + (i32.add + (i32.load + (get_local $3) + ) + (get_local $6) + ) + ) + (i32.store + (tee_local $5 + (i32.add + (get_local $3) + (i32.const 4) + ) + ) + (tee_local $5 + (i32.sub + (i32.load + (get_local $5) + ) + (get_local $6) + ) + ) + ) + ) + (set_local $6 + (i32.load + (get_local $3) + ) + ) + (block $label$1 + (br_if $label$1 + (i32.eqz + (tee_local $5 + (select + (get_local $5) + (get_local $2) + (i32.lt_u + (get_local $5) + (get_local $2) + ) + ) + ) + ) + ) + (drop + (call $memcpy + (get_local $6) + (get_local $1) + (get_local $5) + ) + ) + (i32.store + (get_local $3) + (tee_local $6 + (i32.add + (i32.load + (get_local $3) + ) + (get_local $5) + ) + ) + ) + (i32.store + (tee_local $3 + (i32.add + (get_local $3) + (i32.const 4) + ) + ) + (i32.sub + (i32.load + (get_local $3) + ) + (get_local $5) + ) + ) + ) + (i32.store8 + (get_local $6) + (i32.const 0) + ) + (i32.store + (i32.add + (get_local $0) + (i32.const 28) + ) + (tee_local $3 + (i32.load offset=44 + (get_local $0) + ) + ) + ) + (i32.store + (i32.add + (get_local $0) + (i32.const 20) + ) + (get_local $3) + ) + (get_local $2) + ) + (func $__errno_location (result i32) + (i32.const 14572) + ) + (func $vfprintf (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (i32.store offset=4 + (i32.const 0) + (tee_local $7 + (i32.sub + (i32.load offset=4 + (i32.const 0) + ) + (i32.const 288) + ) + ) + ) + (i32.store offset=284 + (get_local $7) + (get_local $2) + ) + (set_local $6 + (i32.const 0) + ) + (drop + (call $memset + (i32.add + (get_local $7) + (i32.const 240) + ) + (i32.const 0) + (i32.const 40) + ) + ) + (i32.store offset=280 + (get_local $7) + (i32.load offset=284 + (get_local $7) + ) + ) + (set_local $2 + (i32.const -1) + ) + (block $label$0 + (br_if $label$0 + (i32.le_s + (call $printf_core + (i32.const 0) + (get_local $1) + (i32.add + (get_local $7) + (i32.const 280) + ) + (i32.add + (get_local $7) + (i32.const 80) + ) + (i32.add + (get_local $7) + (i32.const 240) + ) + ) + (i32.const -1) + ) + ) + (block $label$1 + (br_if $label$1 + (i32.lt_s + (i32.load offset=76 + (get_local $0) + ) + (i32.const 0) + ) + ) + (set_local $6 + (call $__lockfile + (get_local $0) + ) + ) + ) + (set_local $2 + (i32.load + (get_local $0) + ) + ) + (block $label$2 + (br_if $label$2 + (i32.gt_s + (i32.load8_s offset=74 + (get_local $0) + ) + (i32.const 0) + ) + ) + (i32.store + (get_local $0) + (i32.and + (get_local $2) + (i32.const -33) + ) + ) + ) + (set_local $3 + (i32.and + (get_local $2) + (i32.const 32) + ) + ) + (block $label$3 + (block $label$4 + (br_if $label$4 + (i32.eqz + (i32.load offset=48 + (get_local $0) + ) + ) + ) + (set_local $2 + (call $printf_core + (get_local $0) + (get_local $1) + (i32.add + (get_local $7) + (i32.const 280) + ) + (i32.add + (get_local $7) + (i32.const 80) + ) + (i32.add + (get_local $7) + (i32.const 240) + ) + ) + ) + (br $label$3) + ) + (i32.store + (tee_local $5 + (i32.add + (get_local $0) + (i32.const 48) + ) + ) + (i32.const 80) + ) + (i32.store offset=16 + (get_local $0) + (i32.add + (get_local $7) + (i32.const 80) + ) + ) + (i32.store offset=28 + (get_local $0) + (get_local $7) + ) + (i32.store offset=20 + (get_local $0) + (get_local $7) + ) + (set_local $4 + (i32.load offset=44 + (get_local $0) + ) + ) + (i32.store offset=44 + (get_local $0) + (get_local $7) + ) + (set_local $2 + (call $printf_core + (get_local $0) + (get_local $1) + (i32.add + (get_local $7) + (i32.const 280) + ) + (i32.add + (get_local $7) + (i32.const 80) + ) + (i32.add + (get_local $7) + (i32.const 240) + ) + ) + ) + (br_if $label$3 + (i32.eqz + (get_local $4) + ) + ) + (drop + (call_indirect (type $FUNCSIG$iiii) + (get_local $0) + (i32.const 0) + (i32.const 0) + (i32.load offset=36 + (get_local $0) + ) + ) + ) + (i32.store + (i32.add + (get_local $0) + (i32.const 44) + ) + (get_local $4) + ) + (i32.store + (get_local $5) + (i32.const 0) + ) + (i32.store + (i32.add + (get_local $0) + (i32.const 16) + ) + (i32.const 0) + ) + (i32.store + (i32.add + (get_local $0) + (i32.const 28) + ) + (i32.const 0) + ) + (set_local $4 + (i32.load + (tee_local $1 + (i32.add + (get_local $0) + (i32.const 20) + ) + ) + ) + ) + (i32.store + (get_local $1) + (i32.const 0) + ) + (set_local $2 + (select + (get_local $2) + (i32.const -1) + (get_local $4) + ) + ) + ) + (i32.store + (get_local $0) + (i32.or + (tee_local $1 + (i32.load + (get_local $0) + ) + ) + (get_local $3) + ) + ) + (set_local $1 + (i32.and + (get_local $1) + (i32.const 32) + ) + ) + (block $label$5 + (br_if $label$5 + (i32.eqz + (get_local $6) + ) + ) + (call $__unlockfile + (get_local $0) + ) + ) + (set_local $2 + (select + (i32.const -1) + (get_local $2) + (get_local $1) + ) + ) + ) + (i32.store offset=4 + (i32.const 0) + (i32.add + (get_local $7) + (i32.const 288) + ) + ) + (get_local $2) + ) + (func $printf_core (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) (param $4 i32) (result i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (local $8 i32) + (local $9 i32) + (local $10 i32) + (local $11 i32) + (local $12 i32) + (local $13 i32) + (local $14 i32) + (local $15 i32) + (local $16 i32) + (local $17 i32) + (local $18 i32) + (local $19 i32) + (local $20 i32) + (local $21 i32) + (local $22 i32) + (local $23 i64) + (local $24 i32) + (local $25 i32) + (local $26 i32) + (local $27 i32) + (local $28 i32) + (local $29 i32) + (local $30 i32) + (local $31 i32) + (local $32 i32) + (local $33 i64) + (local $34 i64) + (local $35 i64) + (local $36 i32) + (local $37 i32) + (local $38 i32) + (local $39 i32) + (i32.store offset=4 + (i32.const 0) + (tee_local $39 + (i32.sub + (i32.load offset=4 + (i32.const 0) + ) + (i32.const 8128) + ) + ) + ) + (set_local $12 + (i32.add + (i32.add + (get_local $39) + (i32.const 692) + ) + (i32.const 11) + ) + ) + (set_local $11 + (i32.or + (i32.add + (get_local $39) + (i32.const 704) + ) + (i32.const 8) + ) + ) + (set_local $10 + (i32.or + (i32.add + (get_local $39) + (i32.const 704) + ) + (i32.const 9) + ) + ) + (set_local $9 + (i32.add + (get_local $39) + (i32.const 7664) + ) + ) + (set_local $8 + (i32.sub + (i32.const -2) + (i32.add + (get_local $39) + (i32.const 704) + ) + ) + ) + (set_local $7 + (i32.add + (i32.add + (get_local $39) + (i32.const 692) + ) + (i32.const 12) + ) + ) + (set_local $6 + (i32.add + (i32.add + (get_local $39) + (i32.const 352) + ) + (i32.const 54) + ) + ) + (set_local $5 + (i32.add + (i32.add + (get_local $39) + (i32.const 352) + ) + (i32.const 55) + ) + ) + (set_local $30 + (i32.const 0) + ) + (set_local $38 + (i32.const 0) + ) + (set_local $32 + (i32.const 0) + ) + (block $label$0 + (block $label$1 + (block $label$2 + (block $label$3 + (block $label$4 + (block $label$5 + (block $label$6 + (block $label$7 + (block $label$8 + (block $label$9 + (block $label$10 + (block $label$11 + (block $label$12 + (block $label$13 + (block $label$14 + (block $label$15 + (loop $label$16 + (set_local $38 + (i32.add + (get_local $30) + (get_local $38) + ) + ) + (br_if $label$15 + (i32.eqz + (tee_local $30 + (i32.load8_u + (tee_local $37 + (get_local $1) + ) + ) + ) + ) + ) + (set_local $1 + (get_local $37) + ) + (block $label$17 + (block $label$18 + (block $label$19 + (br_if $label$19 + (i32.eqz + (tee_local $30 + (i32.and + (get_local $30) + (i32.const 255) + ) + ) + ) + ) + (loop $label$20 + (br_if $label$18 + (i32.eq + (get_local $30) + (i32.const 37) + ) + ) + (br_if $label$20 + (tee_local $30 + (i32.and + (i32.load8_u + (tee_local $1 + (i32.add + (get_local $1) + (i32.const 1) + ) + ) + ) + (i32.const 255) + ) + ) + ) + ) + ) + (set_local $30 + (get_local $1) + ) + (br $label$17) + ) + (set_local $30 + (get_local $1) + ) + (loop $label$21 + (br_if $label$17 + (i32.ne + (i32.load8_u + (i32.add + (get_local $1) + (i32.const 1) + ) + ) + (i32.const 37) + ) + ) + (set_local $30 + (i32.add + (get_local $30) + (i32.const 1) + ) + ) + (br_if $label$21 + (i32.eq + (i32.load8_u + (tee_local $1 + (i32.add + (get_local $1) + (i32.const 2) + ) + ) + ) + (i32.const 37) + ) + ) + ) + ) + (br_if $label$14 + (i32.gt_s + (tee_local $30 + (i32.sub + (get_local $30) + (get_local $37) + ) + ) + (tee_local $13 + (i32.sub + (i32.const 2147483647) + (get_local $38) + ) + ) + ) + ) + (block $label$22 + (br_if $label$22 + (i32.eqz + (get_local $0) + ) + ) + (br_if $label$22 + (i32.and + (i32.load8_u + (get_local $0) + ) + (i32.const 32) + ) + ) + (drop + (call $__fwritex + (get_local $37) + (get_local $30) + (get_local $0) + ) + ) + ) + (block $label$23 + (br_if $label$23 + (get_local $30) + ) + (set_local $36 + (i32.add + (get_local $1) + (i32.const 1) + ) + ) + (set_local $27 + (i32.const -1) + ) + (block $label$24 + (br_if $label$24 + (i32.gt_u + (tee_local $17 + (i32.add + (tee_local $30 + (i32.load8_s offset=1 + (get_local $1) + ) + ) + (i32.const -48) + ) + ) + (i32.const 9) + ) + ) + (set_local $30 + (i32.load8_u + (tee_local $36 + (select + (i32.add + (get_local $1) + (i32.const 3) + ) + (get_local $36) + (tee_local $1 + (i32.eq + (i32.load8_u offset=2 + (get_local $1) + ) + (i32.const 36) + ) + ) + ) + ) + ) + ) + (set_local $27 + (select + (get_local $17) + (i32.const -1) + (get_local $1) + ) + ) + (set_local $32 + (select + (i32.const 1) + (get_local $32) + (get_local $1) + ) + ) + ) + (set_local $14 + (i32.const 0) + ) + (block $label$25 + (br_if $label$25 + (i32.gt_u + (tee_local $1 + (i32.add + (i32.shr_s + (i32.shl + (get_local $30) + (i32.const 24) + ) + (i32.const 24) + ) + (i32.const -32) + ) + ) + (i32.const 31) + ) + ) + (set_local $14 + (i32.const 0) + ) + (loop $label$26 + (br_if $label$25 + (i32.eqz + (i32.and + (i32.shl + (i32.const 1) + (get_local $1) + ) + (i32.const 75913) + ) + ) + ) + (set_local $14 + (i32.or + (i32.shl + (i32.const 1) + (i32.add + (i32.shr_s + (i32.shl + (get_local $30) + (i32.const 24) + ) + (i32.const 24) + ) + (i32.const -32) + ) + ) + (get_local $14) + ) + ) + (br_if $label$26 + (i32.lt_u + (tee_local $1 + (i32.add + (tee_local $30 + (i32.load8_s + (tee_local $36 + (i32.add + (get_local $36) + (i32.const 1) + ) + ) + ) + ) + (i32.const -32) + ) + ) + (i32.const 32) + ) + ) + ) + ) + (block $label$27 + (block $label$28 + (block $label$29 + (block $label$30 + (block $label$31 + (block $label$32 + (br_if $label$32 + (i32.ne + (i32.and + (get_local $30) + (i32.const 255) + ) + (i32.const 42) + ) + ) + (br_if $label$31 + (i32.gt_u + (tee_local $1 + (i32.add + (i32.load8_s offset=1 + (get_local $36) + ) + (i32.const -48) + ) + ) + (i32.const 9) + ) + ) + (br_if $label$31 + (i32.ne + (i32.load8_u offset=2 + (get_local $36) + ) + (i32.const 36) + ) + ) + (i32.store + (i32.add + (get_local $4) + (i32.shl + (get_local $1) + (i32.const 2) + ) + ) + (i32.const 10) + ) + (set_local $17 + (i32.add + (get_local $36) + (i32.const 3) + ) + ) + (set_local $32 + (i32.const 1) + ) + (br_if $label$27 + (i32.gt_s + (tee_local $15 + (i32.load + (i32.add + (i32.add + (get_local $3) + (i32.shl + (i32.load8_s + (i32.add + (get_local $36) + (i32.const 1) + ) + ) + (i32.const 4) + ) + ) + (i32.const -768) + ) + ) + ) + (i32.const -1) + ) + ) + (br $label$30) + ) + (set_local $15 + (i32.const 0) + ) + (br_if $label$29 + (i32.gt_u + (tee_local $30 + (i32.add + (i32.shr_s + (i32.shl + (get_local $30) + (i32.const 24) + ) + (i32.const 24) + ) + (i32.const -48) + ) + ) + (i32.const 9) + ) + ) + (set_local $1 + (i32.const 0) + ) + (set_local $17 + (get_local $36) + ) + (loop $label$33 + (set_local $15 + (i32.const -1) + ) + (block $label$34 + (br_if $label$34 + (i32.gt_u + (get_local $1) + (i32.const 214748364) + ) + ) + (set_local $15 + (select + (i32.const -1) + (i32.add + (tee_local $1 + (i32.mul + (get_local $1) + (i32.const 10) + ) + ) + (get_local $30) + ) + (i32.gt_s + (get_local $30) + (i32.sub + (i32.const 2147483647) + (get_local $1) + ) + ) + ) + ) + ) + (set_local $1 + (get_local $15) + ) + (br_if $label$33 + (i32.lt_u + (tee_local $30 + (i32.add + (i32.load8_s + (tee_local $17 + (i32.add + (get_local $17) + (i32.const 1) + ) + ) + ) + (i32.const -48) + ) + ) + (i32.const 10) + ) + ) + ) + (br_if $label$27 + (i32.ge_s + (get_local $15) + (i32.const 0) + ) + ) + (br $label$14) + ) + (br_if $label$2 + (get_local $32) + ) + (set_local $17 + (i32.add + (get_local $36) + (i32.const 1) + ) + ) + (br_if $label$28 + (i32.eqz + (get_local $0) + ) + ) + (i32.store + (get_local $2) + (i32.add + (tee_local $1 + (i32.load + (get_local $2) + ) + ) + (i32.const 4) + ) + ) + (set_local $32 + (i32.const 0) + ) + (br_if $label$27 + (i32.gt_s + (tee_local $15 + (i32.load + (get_local $1) + ) + ) + (i32.const -1) + ) + ) + ) + (set_local $15 + (i32.sub + (i32.const 0) + (get_local $15) + ) + ) + (set_local $14 + (i32.or + (get_local $14) + (i32.const 8192) + ) + ) + (br $label$27) + ) + (set_local $17 + (get_local $36) + ) + (br $label$27) + ) + (set_local $32 + (i32.const 0) + ) + (set_local $15 + (i32.const 0) + ) + ) + (set_local $30 + (i32.const 0) + ) + (set_local $36 + (i32.const -1) + ) + (block $label$35 + (block $label$36 + (block $label$37 + (block $label$38 + (block $label$39 + (block $label$40 + (block $label$41 + (br_if $label$41 + (i32.ne + (i32.load8_u + (get_local $17) + ) + (i32.const 46) + ) + ) + (br_if $label$40 + (i32.ne + (tee_local $36 + (i32.load8_s offset=1 + (get_local $17) + ) + ) + (i32.const 42) + ) + ) + (br_if $label$39 + (i32.gt_u + (tee_local $1 + (i32.add + (i32.load8_s offset=2 + (get_local $17) + ) + (i32.const -48) + ) + ) + (i32.const 9) + ) + ) + (br_if $label$39 + (i32.ne + (i32.load8_u offset=3 + (get_local $17) + ) + (i32.const 36) + ) + ) + (i32.store + (i32.add + (get_local $4) + (i32.shl + (get_local $1) + (i32.const 2) + ) + ) + (i32.const 10) + ) + (set_local $1 + (i32.add + (get_local $17) + (i32.const 4) + ) + ) + (set_local $36 + (i32.load + (i32.add + (i32.add + (get_local $3) + (i32.shl + (i32.load8_s + (i32.add + (get_local $17) + (i32.const 2) + ) + ) + (i32.const 4) + ) + ) + (i32.const -768) + ) + ) + ) + (br $label$36) + ) + (set_local $1 + (get_local $17) + ) + (set_local $16 + (i32.const 0) + ) + (br $label$35) + ) + (set_local $1 + (i32.add + (get_local $17) + (i32.const 1) + ) + ) + (br_if $label$38 + (i32.gt_u + (tee_local $31 + (i32.add + (get_local $36) + (i32.const -48) + ) + ) + (i32.const 9) + ) + ) + (set_local $17 + (i32.const 0) + ) + (loop $label$42 + (set_local $36 + (i32.const -1) + ) + (block $label$43 + (br_if $label$43 + (i32.gt_u + (get_local $17) + (i32.const 214748364) + ) + ) + (set_local $36 + (select + (i32.const -1) + (i32.add + (tee_local $17 + (i32.mul + (get_local $17) + (i32.const 10) + ) + ) + (get_local $31) + ) + (i32.gt_s + (get_local $31) + (i32.sub + (i32.const 2147483647) + (get_local $17) + ) + ) + ) + ) + ) + (set_local $16 + (i32.const 1) + ) + (set_local $17 + (get_local $36) + ) + (br_if $label$42 + (i32.lt_u + (tee_local $31 + (i32.add + (i32.load8_s + (tee_local $1 + (i32.add + (get_local $1) + (i32.const 1) + ) + ) + ) + (i32.const -48) + ) + ) + (i32.const 10) + ) + ) + (br $label$35) + ) + ) + (br_if $label$2 + (get_local $32) + ) + (set_local $1 + (i32.add + (get_local $17) + (i32.const 2) + ) + ) + (br_if $label$37 + (i32.eqz + (get_local $0) + ) + ) + (i32.store + (get_local $2) + (i32.add + (tee_local $17 + (i32.load + (get_local $2) + ) + ) + (i32.const 4) + ) + ) + (set_local $36 + (i32.load + (get_local $17) + ) + ) + (br $label$36) + ) + (set_local $16 + (i32.const 1) + ) + (set_local $36 + (i32.const 0) + ) + (br $label$35) + ) + (set_local $36 + (i32.const 0) + ) + ) + (set_local $16 + (i32.xor + (i32.shr_u + (get_local $36) + (i32.const 31) + ) + (i32.const 1) + ) + ) + ) + (loop $label$44 + (set_local $17 + (get_local $30) + ) + (br_if $label$2 + (i32.gt_u + (tee_local $30 + (i32.add + (i32.load8_s + (get_local $1) + ) + (i32.const -65) + ) + ) + (i32.const 57) + ) + ) + (set_local $1 + (i32.add + (get_local $1) + (i32.const 1) + ) + ) + (br_if $label$44 + (i32.lt_u + (i32.add + (tee_local $30 + (i32.load8_u + (i32.add + (i32.add + (i32.mul + (get_local $17) + (i32.const 58) + ) + (get_local $30) + ) + (i32.const 12048) + ) + ) + ) + (i32.const -1) + ) + (i32.const 8) + ) + ) + ) + (br_if $label$2 + (i32.eqz + (get_local $30) + ) + ) + (block $label$45 + (block $label$46 + (block $label$47 + (block $label$48 + (br_if $label$48 + (i32.ne + (get_local $30) + (i32.const 27) + ) + ) + (br_if $label$47 + (i32.le_s + (get_local $27) + (i32.const -1) + ) + ) + (br $label$2) + ) + (br_if $label$46 + (i32.lt_s + (get_local $27) + (i32.const 0) + ) + ) + (i32.store + (i32.add + (get_local $4) + (i32.shl + (get_local $27) + (i32.const 2) + ) + ) + (get_local $30) + ) + (i32.store offset=428 + (get_local $39) + (i32.load + (i32.add + (tee_local $30 + (i32.add + (get_local $3) + (i32.shl + (get_local $27) + (i32.const 4) + ) + ) + ) + (i32.const 12) + ) + ) + ) + (i32.store offset=424 + (get_local $39) + (i32.load + (i32.add + (get_local $30) + (i32.const 8) + ) + ) + ) + (i32.store offset=420 + (get_local $39) + (i32.load + (i32.add + (get_local $30) + (i32.const 4) + ) + ) + ) + (i32.store offset=416 + (get_local $39) + (i32.load + (get_local $30) + ) + ) + ) + (br_if $label$45 + (get_local $0) + ) + (set_local $30 + (i32.const 0) + ) + (br $label$23) + ) + (br_if $label$10 + (i32.eqz + (get_local $0) + ) + ) + (call $pop_arg + (i32.add + (get_local $39) + (i32.const 416) + ) + (get_local $30) + (get_local $2) + ) + ) + (set_local $18 + (select + (tee_local $31 + (i32.and + (get_local $14) + (i32.const -65537) + ) + ) + (get_local $14) + (i32.and + (get_local $14) + (i32.const 8192) + ) + ) + ) + (set_local $26 + (i32.const 0) + ) + (set_local $24 + (i32.const 12528) + ) + (block $label$49 + (block $label$50 + (block $label$51 + (block $label$52 + (block $label$53 + (block $label$54 + (block $label$55 + (block $label$56 + (block $label$57 + (block $label$58 + (block $label$59 + (block $label$60 + (block $label$61 + (block $label$62 + (block $label$63 + (block $label$64 + (block $label$65 + (block $label$66 + (block $label$67 + (block $label$68 + (block $label$69 + (block $label$70 + (block $label$71 + (block $label$72 + (block $label$73 + (block $label$74 + (block $label$75 + (block $label$76 + (block $label$77 + (block $label$78 + (block $label$79 + (br_if $label$79 + (i32.gt_u + (tee_local $30 + (i32.add + (tee_local $29 + (select + (select + (i32.and + (tee_local $30 + (i32.load8_s + (i32.add + (get_local $1) + (i32.const -1) + ) + ) + ) + (i32.const -33) + ) + (get_local $30) + (i32.eq + (i32.and + (get_local $30) + (i32.const 15) + ) + (i32.const 3) + ) + ) + (get_local $30) + (get_local $17) + ) + ) + (i32.const -65) + ) + ) + (i32.const 55) + ) + ) + (set_local $14 + (get_local $5) + ) + (block $label$80 + (block $label$81 + (block $label$82 + (block $label$83 + (block $label$84 + (block $label$85 + (block $label$86 + (block $label$87 + (block $label$88 + (block $label$89 + (block $label$90 + (block $label$91 + (block $label$92 + (block $label$93 + (block $label$94 + (block $label$95 + (block $label$96 + (block $label$97 + (block $label$98 + (block $label$99 + (block $label$100 + (block $label$101 + (block $label$102 + (block $label$103 + (block $label$104 + (block $label$105 + (block $label$106 + (block $label$107 + (block $label$108 + (block $label$109 + (block $label$110 + (br_table $label$110 $label$78 $label$106 $label$78 $label$110 $label$110 $label$110 $label$78 $label$78 $label$78 $label$78 $label$78 $label$78 $label$78 $label$78 $label$78 $label$78 $label$78 $label$105 $label$78 $label$78 $label$78 $label$78 $label$98 $label$78 $label$78 $label$78 $label$78 $label$78 $label$78 $label$78 $label$78 $label$110 $label$78 $label$103 $label$109 $label$110 $label$110 $label$110 $label$78 $label$109 $label$78 $label$78 $label$78 $label$102 $label$101 $label$100 $label$99 $label$78 $label$78 $label$97 $label$78 $label$95 $label$78 $label$78 $label$98 $label$110 + (get_local $30) + ) + ) + (block $label$111 + (br_if $label$111 + (i32.gt_s + (get_local $36) + (i32.const -1) + ) + ) + (br_if $label$14 + (get_local $16) + ) + ) + (set_local $35 + (i64.load offset=424 + (get_local $39) + ) + ) + (set_local $23 + (i64.load offset=416 + (get_local $39) + ) + ) + (i32.store offset=748 + (get_local $39) + (i32.const 0) + ) + (block $label$112 + (br_if $label$112 + (i32.eqz + (call $__signbitl + (get_local $23) + (get_local $35) + ) + ) + ) + (set_local $35 + (i64.xor + (get_local $35) + (i64.const -9223372036854775808) + ) + ) + (set_local $20 + (i32.const 1) + ) + (set_local $19 + (i32.const 12560) + ) + (br $label$107) + ) + (br_if $label$108 + (i32.and + (get_local $18) + (i32.const 2048) + ) + ) + (set_local $19 + (select + (i32.const 12566) + (i32.const 12561) + (tee_local $20 + (i32.and + (get_local $18) + (i32.const 1) + ) + ) + ) + ) + (br $label$107) + ) + (br_if $label$91 + (i64.le_s + (tee_local $35 + (i64.load offset=416 + (get_local $39) + ) + ) + (i64.const -1) + ) + ) + (br_if $label$87 + (i32.and + (get_local $18) + (i32.const 2048) + ) + ) + (set_local $24 + (select + (i32.const 12530) + (i32.const 12528) + (tee_local $26 + (i32.and + (get_local $18) + (i32.const 1) + ) + ) + ) + ) + (br_if $label$86 + (i64.ge_u + (get_local $35) + (i64.const 4294967296) + ) + ) + (br $label$85) + ) + (set_local $20 + (i32.const 1) + ) + (set_local $19 + (i32.const 12563) + ) + ) + (block $label$113 + (block $label$114 + (br_if $label$114 + (i32.le_s + (call $__fpclassifyl + (get_local $23) + (get_local $35) + ) + (i32.const 1) + ) + ) + (call $frexpl + (i32.add + (get_local $39) + (i32.const 320) + ) + (get_local $23) + (get_local $35) + (i32.add + (get_local $39) + (i32.const 748) + ) + ) + (call $__addtf3 + (i32.add + (get_local $39) + (i32.const 304) + ) + (tee_local $35 + (i64.load offset=320 + (get_local $39) + ) + ) + (tee_local $23 + (i64.load offset=328 + (get_local $39) + ) + ) + (get_local $35) + (get_local $23) + ) + (block $label$115 + (br_if $label$115 + (i32.eqz + (call $__eqtf2 + (tee_local $35 + (i64.load offset=304 + (get_local $39) + ) + ) + (tee_local $23 + (i64.load + (i32.add + (i32.add + (get_local $39) + (i32.const 304) + ) + (i32.const 8) + ) + ) + ) + (i64.const 0) + (i64.const 0) + ) + ) + ) + (i32.store offset=748 + (get_local $39) + (i32.add + (i32.load offset=748 + (get_local $39) + ) + (i32.const -1) + ) + ) + ) + (br_if $label$113 + (i32.ne + (tee_local $21 + (i32.or + (get_local $29) + (i32.const 32) + ) + ) + (i32.const 97) + ) + ) + (set_local $24 + (select + (i32.add + (get_local $19) + (i32.const 9) + ) + (get_local $19) + (tee_local $37 + (i32.and + (get_local $29) + (i32.const 32) + ) + ) + ) + ) + (br_if $label$76 + (i32.gt_u + (get_local $36) + (i32.const 26) + ) + ) + (br_if $label$76 + (i32.eqz + (i32.sub + (i32.const 27) + (get_local $36) + ) + ) + ) + (set_local $30 + (i32.add + (get_local $36) + (i32.const -27) + ) + ) + (set_local $34 + (i64.const 4612248968380809216) + ) + (set_local $33 + (i64.const 0) + ) + (loop $label$116 + (call $__multf3 + (i32.add + (get_local $39) + (i32.const 208) + ) + (get_local $33) + (get_local $34) + (i64.const 0) + (i64.const 4612530443357519872) + ) + (set_local $34 + (i64.load + (i32.add + (i32.add + (get_local $39) + (i32.const 208) + ) + (i32.const 8) + ) + ) + ) + (set_local $33 + (i64.load offset=208 + (get_local $39) + ) + ) + (br_if $label$116 + (tee_local $30 + (i32.add + (get_local $30) + (i32.const 1) + ) + ) + ) + ) + (br_if $label$77 + (i32.ne + (i32.load8_u + (get_local $24) + ) + (i32.const 45) + ) + ) + (call $__subtf3 + (i32.add + (get_local $39) + (i32.const 160) + ) + (get_local $35) + (i64.xor + (get_local $23) + (i64.const -9223372036854775808) + ) + (get_local $33) + (get_local $34) + ) + (call $__addtf3 + (i32.add + (get_local $39) + (i32.const 144) + ) + (get_local $33) + (get_local $34) + (i64.load offset=160 + (get_local $39) + ) + (i64.load + (i32.add + (i32.add + (get_local $39) + (i32.const 160) + ) + (i32.const 8) + ) + ) + ) + (set_local $23 + (i64.xor + (i64.load + (i32.add + (i32.add + (get_local $39) + (i32.const 144) + ) + (i32.const 8) + ) + ) + (i64.const -9223372036854775808) + ) + ) + (set_local $35 + (i64.load offset=144 + (get_local $39) + ) + ) + (br $label$76) + ) + (set_local $16 + (call $__unordtf2 + (get_local $23) + (get_local $35) + (get_local $23) + (get_local $35) + ) + ) + (set_local $37 + (i32.add + (get_local $20) + (i32.const 3) + ) + ) + (br_if $label$92 + (i32.and + (get_local $18) + (i32.const 8192) + ) + ) + (br_if $label$92 + (i32.le_s + (get_local $15) + (get_local $37) + ) + ) + (drop + (call $memset + (i32.add + (get_local $39) + (i32.const 432) + ) + (i32.const 32) + (select + (tee_local $31 + (i32.sub + (get_local $15) + (get_local $37) + ) + ) + (i32.const 256) + (tee_local $30 + (i32.lt_u + (get_local $31) + (i32.const 256) + ) + ) + ) + ) + ) + (set_local $17 + (i32.and + (tee_local $36 + (i32.load + (get_local $0) + ) + ) + (i32.const 32) + ) + ) + (br_if $label$94 + (get_local $30) + ) + (set_local $30 + (i32.eqz + (get_local $17) + ) + ) + (set_local $17 + (get_local $31) + ) + (loop $label$117 + (block $label$118 + (br_if $label$118 + (i32.eqz + (i32.and + (get_local $30) + (i32.const 1) + ) + ) + ) + (drop + (call $__fwritex + (i32.add + (get_local $39) + (i32.const 432) + ) + (i32.const 256) + (get_local $0) + ) + ) + (set_local $36 + (i32.load + (get_local $0) + ) + ) + ) + (set_local $30 + (i32.eqz + (tee_local $14 + (i32.and + (get_local $36) + (i32.const 32) + ) + ) + ) + ) + (br_if $label$117 + (i32.gt_u + (tee_local $17 + (i32.add + (get_local $17) + (i32.const -256) + ) + ) + (i32.const 255) + ) + ) + ) + (br_if $label$92 + (get_local $14) + ) + (set_local $31 + (i32.and + (get_local $31) + (i32.const 255) + ) + ) + (br $label$93) + ) + (set_local $30 + (i32.lt_s + (get_local $36) + (i32.const 0) + ) + ) + (br_if $label$89 + (i32.eqz + (call $__netf2 + (get_local $35) + (get_local $23) + (i64.const 0) + (i64.const 0) + ) + ) + ) + (call $__multf3 + (i32.add + (get_local $39) + (i32.const 288) + ) + (get_local $35) + (get_local $23) + (i64.const 0) + (i64.const 4619285842798575616) + ) + (i32.store offset=748 + (get_local $39) + (tee_local $31 + (i32.add + (i32.load offset=748 + (get_local $39) + ) + (i32.const -28) + ) + ) + ) + (set_local $23 + (i64.load + (i32.add + (i32.add + (get_local $39) + (i32.const 288) + ) + (i32.const 8) + ) + ) + ) + (set_local $35 + (i64.load offset=288 + (get_local $39) + ) + ) + (br $label$88) + ) + (set_local $35 + (i64.load offset=416 + (get_local $39) + ) + ) + (i32.store + (i32.add + (i32.add + (get_local $39) + (i32.const 344) + ) + (i32.const 4) + ) + (i32.const 0) + ) + (i64.store32 offset=344 + (get_local $39) + (get_local $35) + ) + (i32.store offset=416 + (get_local $39) + (i32.add + (get_local $39) + (i32.const 344) + ) + ) + (set_local $36 + (i32.const -1) + ) + (set_local $37 + (i32.add + (get_local $39) + (i32.const 344) + ) + ) + (br $label$104) + ) + (set_local $37 + (i32.load offset=416 + (get_local $39) + ) + ) + (br_if $label$73 + (i32.eqz + (get_local $36) + ) + ) + ) + (set_local $30 + (i32.const 0) + ) + (set_local $14 + (get_local $37) + ) + (set_local $17 + (i32.const 0) + ) + (block $label$119 + (loop $label$120 + (br_if $label$119 + (i32.eqz + (tee_local $31 + (i32.load + (get_local $14) + ) + ) + ) + ) + (br_if $label$119 + (i32.lt_s + (tee_local $17 + (call $wctomb + (i32.add + (get_local $39) + (i32.const 340) + ) + (get_local $31) + ) + ) + (i32.const 0) + ) + ) + (br_if $label$119 + (i32.gt_u + (get_local $17) + (i32.sub + (get_local $36) + (get_local $30) + ) + ) + ) + (set_local $14 + (i32.add + (get_local $14) + (i32.const 4) + ) + ) + (br_if $label$120 + (i32.gt_u + (get_local $36) + (tee_local $30 + (i32.add + (get_local $17) + (get_local $30) + ) + ) + ) + ) + ) + ) + (br_if $label$1 + (i32.lt_s + (get_local $17) + (i32.const 0) + ) + ) + (br_if $label$14 + (i32.lt_s + (get_local $30) + (i32.const 0) + ) + ) + (br_if $label$71 + (tee_local $16 + (i32.and + (get_local $18) + (i32.const 73728) + ) + ) + ) + (br $label$72) + ) + (i64.store8 + (i32.add + (i32.add + (get_local $39) + (i32.const 352) + ) + (i32.const 54) + ) + (i64.load offset=416 + (get_local $39) + ) + ) + (set_local $36 + (i32.const 1) + ) + (set_local $37 + (get_local $6) + ) + (set_local $14 + (get_local $5) + ) + (set_local $18 + (get_local $31) + ) + (br $label$78) + ) + (set_local $37 + (call $strerror + (i32.load + (call $__errno_location) + ) + ) + ) + (br $label$96) + ) + (br_if $label$55 + (i32.gt_u + (tee_local $30 + (i32.and + (get_local $17) + (i32.const 255) + ) + ) + (i32.const 7) + ) + ) + (block $label$121 + (br_table $label$121 $label$59 $label$58 $label$57 $label$56 $label$55 $label$54 $label$53 $label$121 + (get_local $30) + ) + ) + (i32.store + (i32.load offset=416 + (get_local $39) + ) + (get_local $38) + ) + (set_local $30 + (i32.const 0) + ) + (br $label$23) + ) + (set_local $37 + (get_local $5) + ) + (block $label$122 + (br_if $label$122 + (i64.eqz + (tee_local $35 + (i64.load offset=416 + (get_local $39) + ) + ) + ) + ) + (set_local $37 + (get_local $5) + ) + (loop $label$123 + (i64.store8 + (tee_local $37 + (i32.add + (get_local $37) + (i32.const -1) + ) + ) + (i64.or + (i64.and + (get_local $35) + (i64.const 7) + ) + (i64.const 48) + ) + ) + (br_if $label$123 + (i64.ne + (tee_local $35 + (i64.shr_u + (get_local $35) + (i64.const 3) + ) + ) + (i64.const 0) + ) + ) + ) + ) + (br_if $label$83 + (i32.and + (get_local $18) + (i32.const 8) + ) + ) + (set_local $26 + (i32.const 0) + ) + (set_local $24 + (i32.const 12528) + ) + (br_if $label$81 + (get_local $16) + ) + (br $label$80) + ) + (set_local $36 + (select + (get_local $36) + (i32.const 8) + (i32.gt_u + (get_local $36) + (i32.const 8) + ) + ) + ) + (set_local $18 + (i32.or + (get_local $18) + (i32.const 8) + ) + ) + (set_local $29 + (i32.const 120) + ) + ) + (set_local $26 + (i32.const 0) + ) + (set_local $24 + (i32.const 12528) + ) + (block $label$124 + (br_if $label$124 + (i64.eqz + (tee_local $35 + (i64.load offset=416 + (get_local $39) + ) + ) + ) + ) + (set_local $30 + (i32.and + (get_local $29) + (i32.const 32) + ) + ) + (set_local $37 + (get_local $5) + ) + (loop $label$125 + (i32.store8 + (tee_local $37 + (i32.add + (get_local $37) + (i32.const -1) + ) + ) + (i32.or + (i32.load8_u + (i32.add + (i32.and + (i32.wrap/i64 + (get_local $35) + ) + (i32.const 15) + ) + (i32.const 12512) + ) + ) + (get_local $30) + ) + ) + (br_if $label$125 + (i64.ne + (tee_local $35 + (i64.shr_u + (get_local $35) + (i64.const 4) + ) + ) + (i64.const 0) + ) + ) + ) + (br_if $label$82 + (i32.eqz + (i32.and + (get_local $18) + (i32.const 8) + ) + ) + ) + (br_if $label$82 + (i64.eqz + (i64.load offset=416 + (get_local $39) + ) + ) + ) + (set_local $24 + (i32.add + (i32.shr_s + (get_local $29) + (i32.const 4) + ) + (i32.const 12528) + ) + ) + (set_local $26 + (i32.const 2) + ) + (br_if $label$81 + (get_local $16) + ) + (br $label$80) + ) + (set_local $37 + (get_local $5) + ) + (br_if $label$81 + (get_local $16) + ) + (br $label$80) + ) + (set_local $37 + (select + (tee_local $30 + (i32.load offset=416 + (get_local $39) + ) + ) + (i32.const 12544) + (get_local $30) + ) + ) + ) + (set_local $26 + (i32.const 0) + ) + (set_local $14 + (i32.add + (get_local $37) + (tee_local $30 + (call $strnlen + (get_local $37) + (select + (i32.const 2147483647) + (get_local $36) + (i32.lt_s + (get_local $36) + (i32.const 0) + ) + ) + ) + ) + ) + ) + (br_if $label$90 + (i32.le_s + (get_local $36) + (i32.const -1) + ) + ) + (set_local $18 + (get_local $31) + ) + (set_local $36 + (get_local $30) + ) + (br $label$78) + ) + (set_local $26 + (i32.const 0) + ) + (set_local $24 + (i32.const 12528) + ) + (br_if $label$86 + (i64.ge_u + (tee_local $35 + (i64.load offset=416 + (get_local $39) + ) + ) + (i64.const 4294967296) + ) + ) + (br $label$85) + ) + (br_if $label$92 + (get_local $17) + ) + ) + (drop + (call $__fwritex + (i32.add + (get_local $39) + (i32.const 432) + ) + (get_local $31) + (get_local $0) + ) + ) + ) + (block $label$126 + (br_if $label$126 + (i32.and + (tee_local $30 + (i32.load + (get_local $0) + ) + ) + (i32.const 32) + ) + ) + (drop + (call $__fwritex + (get_local $19) + (get_local $20) + (get_local $0) + ) + ) + (set_local $30 + (i32.load + (get_local $0) + ) + ) + ) + (block $label$127 + (br_if $label$127 + (i32.and + (get_local $30) + (i32.const 32) + ) + ) + (drop + (call $__fwritex + (select + (select + (i32.const 12624) + (i32.const 12640) + (tee_local $30 + (i32.shr_u + (i32.and + (get_local $29) + (i32.const 32) + ) + (i32.const 5) + ) + ) + ) + (select + (i32.const 12592) + (i32.const 12608) + (get_local $30) + ) + (get_local $16) + ) + (i32.const 3) + (get_local $0) + ) + ) + ) + (block $label$128 + (br_if $label$128 + (i32.ne + (i32.and + (get_local $18) + (i32.const 73728) + ) + (i32.const 8192) + ) + ) + (br_if $label$128 + (i32.le_s + (get_local $15) + (get_local $37) + ) + ) + (drop + (call $memset + (i32.add + (get_local $39) + (i32.const 432) + ) + (i32.const 32) + (select + (tee_local $31 + (i32.sub + (get_local $15) + (get_local $37) + ) + ) + (i32.const 256) + (tee_local $30 + (i32.lt_u + (get_local $31) + (i32.const 256) + ) + ) + ) + ) + ) + (set_local $17 + (i32.and + (tee_local $36 + (i32.load + (get_local $0) + ) + ) + (i32.const 32) + ) + ) + (block $label$129 + (block $label$130 + (br_if $label$130 + (get_local $30) + ) + (set_local $30 + (i32.eqz + (get_local $17) + ) + ) + (set_local $17 + (get_local $31) + ) + (loop $label$131 + (block $label$132 + (br_if $label$132 + (i32.eqz + (i32.and + (get_local $30) + (i32.const 1) + ) + ) + ) + (drop + (call $__fwritex + (i32.add + (get_local $39) + (i32.const 432) + ) + (i32.const 256) + (get_local $0) + ) + ) + (set_local $36 + (i32.load + (get_local $0) + ) + ) + ) + (set_local $30 + (i32.eqz + (tee_local $14 + (i32.and + (get_local $36) + (i32.const 32) + ) + ) + ) + ) + (br_if $label$131 + (i32.gt_u + (tee_local $17 + (i32.add + (get_local $17) + (i32.const -256) + ) + ) + (i32.const 255) + ) + ) + ) + (br_if $label$128 + (get_local $14) + ) + (set_local $31 + (i32.and + (get_local $31) + (i32.const 255) + ) + ) + (br $label$129) + ) + (br_if $label$128 + (get_local $17) + ) + ) + (drop + (call $__fwritex + (i32.add + (get_local $39) + (i32.const 432) + ) + (get_local $31) + (get_local $0) + ) + ) + ) + (set_local $30 + (select + (get_local $15) + (get_local $37) + (i32.gt_s + (get_local $15) + (get_local $37) + ) + ) + ) + (br $label$49) + ) + (i64.store offset=416 + (get_local $39) + (tee_local $35 + (i64.sub + (i64.const 0) + (get_local $35) + ) + ) + ) + (set_local $26 + (i32.const 1) + ) + (set_local $24 + (i32.const 12528) + ) + (br_if $label$86 + (i64.ge_u + (get_local $35) + (i64.const 4294967296) + ) + ) + (br $label$85) + ) + (set_local $18 + (get_local $31) + ) + (set_local $36 + (get_local $30) + ) + (br_if $label$78 + (i32.eqz + (i32.load8_u + (get_local $14) + ) + ) + ) + (br $label$14) + ) + (set_local $31 + (i32.load offset=748 + (get_local $39) + ) + ) + ) + (set_local $28 + (select + (i32.const 6) + (get_local $36) + (get_local $30) + ) + ) + (set_local $36 + (tee_local $22 + (select + (i32.add + (get_local $39) + (i32.const 752) + ) + (get_local $9) + (i32.lt_s + (get_local $31) + (i32.const 0) + ) + ) + ) + ) + (loop $label$133 + (call $__floatunsitf + (i32.add + (get_local $39) + (i32.const 272) + ) + (tee_local $30 + (call $__fixunstfsi + (get_local $35) + (get_local $23) + ) + ) + ) + (call $__subtf3 + (i32.add + (get_local $39) + (i32.const 256) + ) + (get_local $35) + (get_local $23) + (i64.load offset=272 + (get_local $39) + ) + (i64.load + (i32.add + (i32.add + (get_local $39) + (i32.const 272) + ) + (i32.const 8) + ) + ) + ) + (call $__multf3 + (i32.add + (get_local $39) + (i32.const 240) + ) + (i64.load offset=256 + (get_local $39) + ) + (i64.load + (i32.add + (i32.add + (get_local $39) + (i32.const 256) + ) + (i32.const 8) + ) + ) + (i64.const 0) + (i64.const 4619810130798575616) + ) + (i32.store + (get_local $36) + (get_local $30) + ) + (set_local $36 + (i32.add + (get_local $36) + (i32.const 4) + ) + ) + (br_if $label$133 + (call $__netf2 + (tee_local $35 + (i64.load offset=240 + (get_local $39) + ) + ) + (tee_local $23 + (i64.load + (i32.add + (i32.add + (get_local $39) + (i32.const 240) + ) + (i32.const 8) + ) + ) + ) + (i64.const 0) + (i64.const 0) + ) + ) + ) + (block $label$134 + (block $label$135 + (block $label$136 + (br_if $label$136 + (i32.lt_s + (get_local $31) + (i32.const 1) + ) + ) + (set_local $17 + (get_local $22) + ) + (loop $label$137 + (set_local $14 + (select + (get_local $31) + (i32.const 29) + (i32.lt_s + (get_local $31) + (i32.const 29) + ) + ) + ) + (block $label$138 + (br_if $label$138 + (i32.lt_u + (tee_local $30 + (i32.add + (get_local $36) + (i32.const -4) + ) + ) + (get_local $17) + ) + ) + (set_local $23 + (i64.extend_u/i32 + (get_local $14) + ) + ) + (set_local $35 + (i64.const 0) + ) + (loop $label$139 + (i64.store32 + (get_local $30) + (i64.rem_u + (tee_local $35 + (i64.add + (i64.shl + (i64.load32_u + (get_local $30) + ) + (get_local $23) + ) + (i64.and + (get_local $35) + (i64.const 4294967295) + ) + ) + ) + (i64.const 1000000000) + ) + ) + (set_local $35 + (i64.div_u + (get_local $35) + (i64.const 1000000000) + ) + ) + (br_if $label$139 + (i32.ge_u + (tee_local $30 + (i32.add + (get_local $30) + (i32.const -4) + ) + ) + (get_local $17) + ) + ) + ) + (br_if $label$138 + (i32.eqz + (tee_local $30 + (i32.wrap/i64 + (get_local $35) + ) + ) + ) + ) + (i32.store + (tee_local $17 + (i32.add + (get_local $17) + (i32.const -4) + ) + ) + (get_local $30) + ) + ) + (block $label$140 + (loop $label$141 + (br_if $label$140 + (i32.le_u + (tee_local $30 + (get_local $36) + ) + (get_local $17) + ) + ) + (br_if $label$141 + (i32.eqz + (i32.load + (tee_local $36 + (i32.add + (get_local $30) + (i32.const -4) + ) + ) + ) + ) + ) + ) + ) + (set_local $36 + (get_local $30) + ) + (br_if $label$137 + (i32.gt_s + (tee_local $31 + (i32.sub + (get_local $31) + (get_local $14) + ) + ) + (i32.const 0) + ) + ) + ) + (i32.store offset=748 + (get_local $39) + (get_local $31) + ) + (br_if $label$134 + (i32.gt_s + (get_local $31) + (i32.const -1) + ) + ) + (br $label$135) + ) + (set_local $30 + (get_local $36) + ) + (set_local $17 + (get_local $22) + ) + (br_if $label$134 + (i32.gt_s + (get_local $31) + (i32.const -1) + ) + ) + ) + (set_local $24 + (i32.add + (i32.div_u + (i32.add + (get_local $28) + (i32.const 45) + ) + (i32.const 9) + ) + (i32.const 1) + ) + ) + (block $label$142 + (block $label$143 + (br_if $label$143 + (i32.ne + (get_local $21) + (i32.const 102) + ) + ) + (set_local $25 + (i32.add + (get_local $22) + (i32.shl + (get_local $24) + (i32.const 2) + ) + ) + ) + (loop $label$144 + (set_local $16 + (select + (tee_local $36 + (i32.sub + (i32.const 0) + (get_local $31) + ) + ) + (i32.const 9) + (i32.lt_s + (get_local $36) + (i32.const 9) + ) + ) + ) + (block $label$145 + (block $label$146 + (br_if $label$146 + (i32.ge_u + (get_local $17) + (get_local $30) + ) + ) + (set_local $27 + (i32.shr_u + (i32.const 1000000000) + (get_local $16) + ) + ) + (set_local $26 + (i32.add + (i32.shl + (i32.const 1) + (get_local $16) + ) + (i32.const -1) + ) + ) + (set_local $14 + (i32.const 0) + ) + (set_local $36 + (get_local $17) + ) + (loop $label$147 + (i32.store + (get_local $36) + (i32.add + (i32.shr_u + (tee_local $37 + (i32.load + (get_local $36) + ) + ) + (get_local $16) + ) + (get_local $14) + ) + ) + (set_local $14 + (i32.mul + (i32.and + (get_local $37) + (get_local $26) + ) + (get_local $27) + ) + ) + (br_if $label$147 + (i32.lt_u + (tee_local $36 + (i32.add + (get_local $36) + (i32.const 4) + ) + ) + (get_local $30) + ) + ) + ) + (set_local $17 + (select + (get_local $17) + (i32.add + (get_local $17) + (i32.const 4) + ) + (i32.load + (get_local $17) + ) + ) + ) + (br_if $label$145 + (i32.eqz + (get_local $14) + ) + ) + (i32.store + (get_local $30) + (get_local $14) + ) + (set_local $30 + (i32.add + (get_local $30) + (i32.const 4) + ) + ) + (br $label$145) + ) + (set_local $17 + (select + (get_local $17) + (i32.add + (get_local $17) + (i32.const 4) + ) + (i32.load + (get_local $17) + ) + ) + ) + ) + (set_local $30 + (select + (get_local $25) + (get_local $30) + (i32.gt_s + (i32.shr_s + (i32.sub + (get_local $30) + (get_local $22) + ) + (i32.const 2) + ) + (get_local $24) + ) + ) + ) + (br_if $label$144 + (i32.lt_s + (tee_local $31 + (i32.add + (get_local $16) + (get_local $31) + ) + ) + (i32.const 0) + ) + ) + (br $label$142) + ) + ) + (loop $label$148 + (set_local $16 + (select + (tee_local $36 + (i32.sub + (i32.const 0) + (get_local $31) + ) + ) + (i32.const 9) + (i32.lt_s + (get_local $36) + (i32.const 9) + ) + ) + ) + (block $label$149 + (block $label$150 + (br_if $label$150 + (i32.ge_u + (get_local $17) + (get_local $30) + ) + ) + (set_local $27 + (i32.shr_u + (i32.const 1000000000) + (get_local $16) + ) + ) + (set_local $26 + (i32.add + (i32.shl + (i32.const 1) + (get_local $16) + ) + (i32.const -1) + ) + ) + (set_local $14 + (i32.const 0) + ) + (set_local $36 + (get_local $17) + ) + (loop $label$151 + (i32.store + (get_local $36) + (i32.add + (i32.shr_u + (tee_local $37 + (i32.load + (get_local $36) + ) + ) + (get_local $16) + ) + (get_local $14) + ) + ) + (set_local $14 + (i32.mul + (i32.and + (get_local $37) + (get_local $26) + ) + (get_local $27) + ) + ) + (br_if $label$151 + (i32.lt_u + (tee_local $36 + (i32.add + (get_local $36) + (i32.const 4) + ) + ) + (get_local $30) + ) + ) + ) + (set_local $17 + (select + (get_local $17) + (i32.add + (get_local $17) + (i32.const 4) + ) + (i32.load + (get_local $17) + ) + ) + ) + (br_if $label$149 + (i32.eqz + (get_local $14) + ) + ) + (i32.store + (get_local $30) + (get_local $14) + ) + (set_local $30 + (i32.add + (get_local $30) + (i32.const 4) + ) + ) + (br $label$149) + ) + (set_local $17 + (select + (get_local $17) + (i32.add + (get_local $17) + (i32.const 4) + ) + (i32.load + (get_local $17) + ) + ) + ) + ) + (set_local $30 + (select + (i32.add + (get_local $17) + (i32.shl + (get_local $24) + (i32.const 2) + ) + ) + (get_local $30) + (i32.gt_s + (i32.shr_s + (i32.sub + (get_local $30) + (get_local $17) + ) + (i32.const 2) + ) + (get_local $24) + ) + ) + ) + (br_if $label$148 + (i32.lt_s + (tee_local $31 + (i32.add + (get_local $16) + (get_local $31) + ) + ) + (i32.const 0) + ) + ) + ) + ) + (i32.store offset=748 + (get_local $39) + (get_local $31) + ) + ) + (set_local $36 + (i32.const 0) + ) + (block $label$152 + (br_if $label$152 + (i32.ge_u + (get_local $17) + (get_local $30) + ) + ) + (set_local $36 + (i32.mul + (i32.shr_s + (i32.sub + (get_local $22) + (get_local $17) + ) + (i32.const 2) + ) + (i32.const 9) + ) + ) + (br_if $label$152 + (i32.lt_u + (tee_local $37 + (i32.load + (get_local $17) + ) + ) + (i32.const 10) + ) + ) + (set_local $14 + (i32.const 10) + ) + (loop $label$153 + (set_local $36 + (i32.add + (get_local $36) + (i32.const 1) + ) + ) + (br_if $label$153 + (i32.ge_u + (get_local $37) + (tee_local $14 + (i32.mul + (get_local $14) + (i32.const 10) + ) + ) + ) + ) + ) + ) + (block $label$154 + (br_if $label$154 + (i32.ge_s + (tee_local $14 + (i32.sub + (i32.sub + (get_local $28) + (select + (get_local $36) + (i32.const 0) + (i32.ne + (get_local $21) + (i32.const 102) + ) + ) + ) + (i32.and + (i32.ne + (get_local $28) + (i32.const 0) + ) + (tee_local $16 + (i32.eq + (get_local $21) + (i32.const 103) + ) + ) + ) + ) + ) + (i32.add + (i32.mul + (i32.shr_s + (i32.sub + (get_local $30) + (get_local $22) + ) + (i32.const 2) + ) + (i32.const 9) + ) + (i32.const -9) + ) + ) + ) + (set_local $31 + (i32.add + (tee_local $24 + (i32.add + (get_local $22) + (i32.shl + (i32.div_s + (tee_local $37 + (i32.add + (get_local $14) + (i32.const 147456) + ) + ) + (i32.const 9) + ) + (i32.const 2) + ) + ) + ) + (i32.const -65532) + ) + ) + (set_local $14 + (i32.const 10) + ) + (block $label$155 + (br_if $label$155 + (i32.gt_s + (i32.add + (tee_local $37 + (i32.rem_s + (get_local $37) + (i32.const 9) + ) + ) + (i32.const 1) + ) + (i32.const 8) + ) + ) + (set_local $37 + (i32.sub + (i32.const 8) + (get_local $37) + ) + ) + (set_local $14 + (i32.const 10) + ) + (loop $label$156 + (set_local $14 + (i32.mul + (get_local $14) + (i32.const 10) + ) + ) + (br_if $label$156 + (tee_local $37 + (i32.add + (get_local $37) + (i32.const -1) + ) + ) + ) + ) + ) + (set_local $37 + (i32.rem_u + (tee_local $27 + (i32.load + (get_local $31) + ) + ) + (get_local $14) + ) + ) + (block $label$157 + (block $label$158 + (br_if $label$158 + (i32.ne + (tee_local $26 + (i32.add + (get_local $31) + (i32.const 4) + ) + ) + (get_local $30) + ) + ) + (br_if $label$157 + (i32.eqz + (get_local $37) + ) + ) + ) + (block $label$159 + (block $label$160 + (br_if $label$160 + (i32.and + (i32.div_u + (get_local $27) + (get_local $14) + ) + (i32.const 1) + ) + ) + (set_local $35 + (i64.const 4643211215818981376) + ) + (set_local $23 + (i64.const 0) + ) + (br_if $label$159 + (i32.le_u + (get_local $31) + (get_local $17) + ) + ) + (br_if $label$159 + (i32.ne + (get_local $14) + (i32.const 1000000000) + ) + ) + (br_if $label$159 + (i32.eqz + (i32.and + (i32.load8_u + (i32.add + (get_local $31) + (i32.const -4) + ) + ) + (i32.const 1) + ) + ) + ) + ) + (set_local $35 + (i64.const 4643211215818981376) + ) + (set_local $23 + (i64.const 1) + ) + ) + (set_local $34 + (i64.const 4611123068473966592) + ) + (block $label$161 + (br_if $label$161 + (i32.lt_u + (get_local $37) + (tee_local $25 + (i32.div_s + (get_local $14) + (i32.const 2) + ) + ) + ) + ) + (set_local $34 + (select + (select + (i64.const 4611404543450677248) + (i64.const 4611545280939032576) + (i32.eq + (get_local $37) + (get_local $25) + ) + ) + (i64.const 4611545280939032576) + (i32.eq + (get_local $26) + (get_local $30) + ) + ) + ) + ) + (block $label$162 + (br_if $label$162 + (i32.eqz + (get_local $20) + ) + ) + (br_if $label$162 + (i32.ne + (i32.load8_u + (get_local $19) + ) + (i32.const 45) + ) + ) + (set_local $34 + (i64.xor + (get_local $34) + (i64.const -9223372036854775808) + ) + ) + (set_local $35 + (i64.xor + (get_local $35) + (i64.const -9223372036854775808) + ) + ) + ) + (call $__addtf3 + (i32.add + (get_local $39) + (i32.const 224) + ) + (get_local $23) + (get_local $35) + (i64.const 0) + (get_local $34) + ) + (i32.store + (get_local $31) + (tee_local $37 + (i32.sub + (get_local $27) + (get_local $37) + ) + ) + ) + (br_if $label$157 + (i32.eqz + (call $__eqtf2 + (i64.load offset=224 + (get_local $39) + ) + (i64.load + (i32.add + (i32.add + (get_local $39) + (i32.const 224) + ) + (i32.const 8) + ) + ) + (get_local $23) + (get_local $35) + ) + ) + ) + (i32.store + (get_local $31) + (tee_local $36 + (i32.add + (get_local $37) + (get_local $14) + ) + ) + ) + (block $label$163 + (br_if $label$163 + (i32.lt_u + (get_local $36) + (i32.const 1000000000) + ) + ) + (set_local $36 + (i32.add + (get_local $24) + (i32.const -65536) + ) + ) + (loop $label$164 + (i32.store + (i32.add + (get_local $36) + (i32.const 4) + ) + (i32.const 0) + ) + (block $label$165 + (br_if $label$165 + (i32.ge_u + (get_local $36) + (get_local $17) + ) + ) + (i32.store + (tee_local $17 + (i32.add + (get_local $17) + (i32.const -4) + ) + ) + (i32.const 0) + ) + ) + (i32.store + (get_local $36) + (tee_local $14 + (i32.add + (i32.load + (get_local $36) + ) + (i32.const 1) + ) + ) + ) + (set_local $36 + (i32.add + (get_local $36) + (i32.const -4) + ) + ) + (br_if $label$164 + (i32.gt_u + (get_local $14) + (i32.const 999999999) + ) + ) + ) + (set_local $31 + (i32.add + (get_local $36) + (i32.const 4) + ) + ) + ) + (set_local $36 + (i32.mul + (i32.shr_s + (i32.sub + (get_local $22) + (get_local $17) + ) + (i32.const 2) + ) + (i32.const 9) + ) + ) + (br_if $label$157 + (i32.lt_u + (tee_local $37 + (i32.load + (get_local $17) + ) + ) + (i32.const 10) + ) + ) + (set_local $14 + (i32.const 10) + ) + (loop $label$166 + (set_local $36 + (i32.add + (get_local $36) + (i32.const 1) + ) + ) + (br_if $label$166 + (i32.ge_u + (get_local $37) + (tee_local $14 + (i32.mul + (get_local $14) + (i32.const 10) + ) + ) + ) + ) + ) + ) + (set_local $30 + (select + (tee_local $14 + (i32.add + (get_local $31) + (i32.const 4) + ) + ) + (get_local $30) + (i32.gt_u + (get_local $30) + (get_local $14) + ) + ) + ) + ) + (set_local $31 + (i32.sub + (i32.const 0) + (get_local $36) + ) + ) + (block $label$167 + (block $label$168 + (block $label$169 + (loop $label$170 + (br_if $label$169 + (i32.le_u + (tee_local $14 + (get_local $30) + ) + (get_local $17) + ) + ) + (br_if $label$170 + (i32.eqz + (i32.load + (tee_local $30 + (i32.add + (get_local $14) + (i32.const -4) + ) + ) + ) + ) + ) + ) + (set_local $27 + (i32.const 1) + ) + (br_if $label$168 + (get_local $16) + ) + (br $label$167) + ) + (set_local $27 + (i32.const 0) + ) + (br_if $label$167 + (i32.eqz + (get_local $16) + ) + ) + ) + (br_if $label$75 + (i32.le_s + (tee_local $30 + (i32.add + (i32.eqz + (get_local $28) + ) + (get_local $28) + ) + ) + (get_local $36) + ) + ) + (br_if $label$75 + (i32.lt_s + (get_local $36) + (i32.const -4) + ) + ) + (set_local $29 + (i32.add + (get_local $29) + (i32.const -1) + ) + ) + (set_local $28 + (i32.sub + (i32.add + (get_local $30) + (i32.const -1) + ) + (get_local $36) + ) + ) + (br_if $label$74 + (i32.eqz + (tee_local $16 + (i32.and + (get_local $18) + (i32.const 8) + ) + ) + ) + ) + (br $label$67) + ) + (set_local $16 + (i32.and + (get_local $18) + (i32.const 8) + ) + ) + (br $label$67) + ) + (set_local $26 + (i32.const 1) + ) + (set_local $24 + (i32.const 12529) + ) + (br_if $label$85 + (i64.lt_u + (get_local $35) + (i64.const 4294967296) + ) + ) + ) + (set_local $37 + (get_local $5) + ) + (loop $label$171 + (i64.store8 + (tee_local $37 + (i32.add + (get_local $37) + (i32.const -1) + ) + ) + (i64.or + (i64.rem_u + (get_local $35) + (i64.const 10) + ) + (i64.const 48) + ) + ) + (set_local $30 + (i64.gt_u + (get_local $35) + (i64.const 42949672959) + ) + ) + (set_local $35 + (tee_local $23 + (i64.div_u + (get_local $35) + (i64.const 10) + ) + ) + ) + (br_if $label$171 + (get_local $30) + ) + (br $label$84) + ) + ) + (set_local $23 + (get_local $35) + ) + (set_local $37 + (get_local $5) + ) + ) + (br_if $label$82 + (i32.eqz + (tee_local $30 + (i32.wrap/i64 + (get_local $23) + ) + ) + ) + ) + (loop $label$172 + (i32.store8 + (tee_local $37 + (i32.add + (get_local $37) + (i32.const -1) + ) + ) + (i32.or + (i32.rem_u + (get_local $30) + (i32.const 10) + ) + (i32.const 48) + ) + ) + (set_local $17 + (i32.gt_u + (get_local $30) + (i32.const 9) + ) + ) + (set_local $30 + (i32.div_u + (get_local $30) + (i32.const 10) + ) + ) + (br_if $label$172 + (get_local $17) + ) + (br $label$82) + ) + ) + (set_local $24 + (select + (i32.const 12528) + (i32.const 12533) + (i32.gt_s + (get_local $36) + (tee_local $30 + (i32.sub + (get_local $5) + (get_local $37) + ) + ) + ) + ) + ) + (set_local $26 + (i32.le_s + (get_local $36) + (get_local $30) + ) + ) + ) + (br_if $label$80 + (i32.eqz + (get_local $16) + ) + ) + ) + (br_if $label$14 + (i32.lt_s + (get_local $36) + (i32.const 0) + ) + ) + ) + (set_local $18 + (select + (i32.and + (get_local $18) + (i32.const -65537) + ) + (get_local $18) + (i32.gt_s + (get_local $36) + (i32.const -1) + ) + ) + ) + (set_local $35 + (i64.load offset=416 + (get_local $39) + ) + ) + (block $label$173 + (br_if $label$173 + (get_local $36) + ) + (br_if $label$173 + (i32.eqz + (i64.eqz + (get_local $35) + ) + ) + ) + (set_local $37 + (get_local $5) + ) + (set_local $14 + (get_local $5) + ) + (set_local $36 + (i32.const 0) + ) + (br $label$78) + ) + (set_local $36 + (select + (get_local $36) + (tee_local $30 + (i32.add + (i64.eqz + (get_local $35) + ) + (i32.sub + (get_local $5) + (get_local $37) + ) + ) + ) + (i32.gt_s + (get_local $36) + (get_local $30) + ) + ) + ) + ) + (set_local $14 + (get_local $5) + ) + ) + (br_if $label$14 + (i32.gt_s + (tee_local $28 + (select + (tee_local $29 + (i32.sub + (get_local $14) + (get_local $37) + ) + ) + (get_local $36) + (i32.lt_s + (get_local $36) + (get_local $29) + ) + ) + ) + (i32.sub + (i32.const 2147483647) + (get_local $26) + ) + ) + ) + (br_if $label$14 + (i32.gt_s + (tee_local $30 + (select + (tee_local $27 + (i32.add + (get_local $26) + (get_local $28) + ) + ) + (get_local $15) + (i32.lt_s + (get_local $15) + (get_local $27) + ) + ) + ) + (get_local $13) + ) + ) + (block $label$174 + (br_if $label$174 + (tee_local $18 + (i32.and + (get_local $18) + (i32.const 73728) + ) + ) + ) + (br_if $label$174 + (i32.ge_s + (get_local $27) + (get_local $15) + ) + ) + (drop + (call $memset + (i32.add + (get_local $39) + (i32.const 432) + ) + (i32.const 32) + (select + (tee_local $22 + (i32.sub + (get_local $30) + (get_local $27) + ) + ) + (i32.const 256) + (tee_local $17 + (i32.lt_u + (get_local $22) + (i32.const 256) + ) + ) + ) + ) + ) + (set_local $14 + (i32.and + (tee_local $31 + (i32.load + (get_local $0) + ) + ) + (i32.const 32) + ) + ) + (block $label$175 + (block $label$176 + (br_if $label$176 + (get_local $17) + ) + (set_local $17 + (i32.eqz + (get_local $14) + ) + ) + (set_local $14 + (get_local $22) + ) + (loop $label$177 + (block $label$178 + (br_if $label$178 + (i32.eqz + (i32.and + (get_local $17) + (i32.const 1) + ) + ) + ) + (drop + (call $__fwritex + (i32.add + (get_local $39) + (i32.const 432) + ) + (i32.const 256) + (get_local $0) + ) + ) + (set_local $31 + (i32.load + (get_local $0) + ) + ) + ) + (set_local $17 + (i32.eqz + (tee_local $16 + (i32.and + (get_local $31) + (i32.const 32) + ) + ) + ) + ) + (br_if $label$177 + (i32.gt_u + (tee_local $14 + (i32.add + (get_local $14) + (i32.const -256) + ) + ) + (i32.const 255) + ) + ) + ) + (br_if $label$174 + (get_local $16) + ) + (set_local $22 + (i32.and + (get_local $22) + (i32.const 255) + ) + ) + (br $label$175) + ) + (br_if $label$174 + (get_local $14) + ) + ) + (drop + (call $__fwritex + (i32.add + (get_local $39) + (i32.const 432) + ) + (get_local $22) + (get_local $0) + ) + ) + ) + (block $label$179 + (br_if $label$179 + (i32.and + (i32.load8_u + (get_local $0) + ) + (i32.const 32) + ) + ) + (drop + (call $__fwritex + (get_local $24) + (get_local $26) + (get_local $0) + ) + ) + ) + (block $label$180 + (br_if $label$180 + (i32.ne + (get_local $18) + (i32.const 65536) + ) + ) + (br_if $label$180 + (i32.ge_s + (get_local $27) + (get_local $15) + ) + ) + (drop + (call $memset + (i32.add + (get_local $39) + (i32.const 432) + ) + (i32.const 48) + (select + (tee_local $26 + (i32.sub + (get_local $30) + (get_local $27) + ) + ) + (i32.const 256) + (tee_local $17 + (i32.lt_u + (get_local $26) + (i32.const 256) + ) + ) + ) + ) + ) + (set_local $14 + (i32.and + (tee_local $31 + (i32.load + (get_local $0) + ) + ) + (i32.const 32) + ) + ) + (block $label$181 + (block $label$182 + (br_if $label$182 + (get_local $17) + ) + (set_local $17 + (i32.eqz + (get_local $14) + ) + ) + (set_local $14 + (get_local $26) + ) + (loop $label$183 + (block $label$184 + (br_if $label$184 + (i32.eqz + (i32.and + (get_local $17) + (i32.const 1) + ) + ) + ) + (drop + (call $__fwritex + (i32.add + (get_local $39) + (i32.const 432) + ) + (i32.const 256) + (get_local $0) + ) + ) + (set_local $31 + (i32.load + (get_local $0) + ) + ) + ) + (set_local $17 + (i32.eqz + (tee_local $16 + (i32.and + (get_local $31) + (i32.const 32) + ) + ) + ) + ) + (br_if $label$183 + (i32.gt_u + (tee_local $14 + (i32.add + (get_local $14) + (i32.const -256) + ) + ) + (i32.const 255) + ) + ) + ) + (br_if $label$180 + (get_local $16) + ) + (set_local $26 + (i32.and + (get_local $26) + (i32.const 255) + ) + ) + (br $label$181) + ) + (br_if $label$180 + (get_local $14) + ) + ) + (drop + (call $__fwritex + (i32.add + (get_local $39) + (i32.const 432) + ) + (get_local $26) + (get_local $0) + ) + ) + ) + (block $label$185 + (br_if $label$185 + (i32.ge_s + (get_local $29) + (get_local $36) + ) + ) + (drop + (call $memset + (i32.add + (get_local $39) + (i32.const 432) + ) + (i32.const 48) + (select + (tee_local $16 + (i32.sub + (get_local $28) + (get_local $29) + ) + ) + (i32.const 256) + (tee_local $17 + (i32.lt_u + (get_local $16) + (i32.const 256) + ) + ) + ) + ) + ) + (set_local $36 + (i32.and + (tee_local $14 + (i32.load + (get_local $0) + ) + ) + (i32.const 32) + ) + ) + (block $label$186 + (block $label$187 + (br_if $label$187 + (get_local $17) + ) + (set_local $17 + (i32.eqz + (get_local $36) + ) + ) + (set_local $36 + (get_local $16) + ) + (loop $label$188 + (block $label$189 + (br_if $label$189 + (i32.eqz + (i32.and + (get_local $17) + (i32.const 1) + ) + ) + ) + (drop + (call $__fwritex + (i32.add + (get_local $39) + (i32.const 432) + ) + (i32.const 256) + (get_local $0) + ) + ) + (set_local $14 + (i32.load + (get_local $0) + ) + ) + ) + (set_local $17 + (i32.eqz + (tee_local $31 + (i32.and + (get_local $14) + (i32.const 32) + ) + ) + ) + ) + (br_if $label$188 + (i32.gt_u + (tee_local $36 + (i32.add + (get_local $36) + (i32.const -256) + ) + ) + (i32.const 255) + ) + ) + ) + (br_if $label$185 + (get_local $31) + ) + (set_local $16 + (i32.and + (get_local $16) + (i32.const 255) + ) + ) + (br $label$186) + ) + (br_if $label$185 + (get_local $36) + ) + ) + (drop + (call $__fwritex + (i32.add + (get_local $39) + (i32.const 432) + ) + (get_local $16) + (get_local $0) + ) + ) + ) + (block $label$190 + (br_if $label$190 + (i32.and + (i32.load8_u + (get_local $0) + ) + (i32.const 32) + ) + ) + (drop + (call $__fwritex + (get_local $37) + (get_local $29) + (get_local $0) + ) + ) + ) + (br_if $label$23 + (i32.ne + (get_local $18) + (i32.const 8192) + ) + ) + (br_if $label$23 + (i32.ge_s + (get_local $27) + (get_local $15) + ) + ) + (drop + (call $memset + (i32.add + (get_local $39) + (i32.const 432) + ) + (i32.const 32) + (select + (tee_local $37 + (i32.sub + (get_local $30) + (get_local $27) + ) + ) + (i32.const 256) + (tee_local $17 + (i32.lt_u + (get_local $37) + (i32.const 256) + ) + ) + ) + ) + ) + (set_local $15 + (i32.and + (tee_local $36 + (i32.load + (get_local $0) + ) + ) + (i32.const 32) + ) + ) + (block $label$191 + (block $label$192 + (br_if $label$192 + (get_local $17) + ) + (set_local $17 + (i32.eqz + (get_local $15) + ) + ) + (set_local $15 + (get_local $37) + ) + (loop $label$193 + (block $label$194 + (br_if $label$194 + (i32.eqz + (i32.and + (get_local $17) + (i32.const 1) + ) + ) + ) + (drop + (call $__fwritex + (i32.add + (get_local $39) + (i32.const 432) + ) + (i32.const 256) + (get_local $0) + ) + ) + (set_local $36 + (i32.load + (get_local $0) + ) + ) + ) + (set_local $17 + (i32.eqz + (tee_local $14 + (i32.and + (get_local $36) + (i32.const 32) + ) + ) + ) + ) + (br_if $label$193 + (i32.gt_u + (tee_local $15 + (i32.add + (get_local $15) + (i32.const -256) + ) + ) + (i32.const 255) + ) + ) + ) + (br_if $label$23 + (get_local $14) + ) + (set_local $37 + (i32.and + (get_local $37) + (i32.const 255) + ) + ) + (br $label$191) + ) + (br_if $label$23 + (get_local $15) + ) + ) + (drop + (call $__fwritex + (i32.add + (get_local $39) + (i32.const 432) + ) + (get_local $37) + (get_local $0) + ) + ) + (br $label$23) + ) + (call $__addtf3 + (i32.add + (get_local $39) + (i32.const 192) + ) + (get_local $35) + (get_local $23) + (get_local $33) + (get_local $34) + ) + (call $__subtf3 + (i32.add + (get_local $39) + (i32.const 176) + ) + (i64.load offset=192 + (get_local $39) + ) + (i64.load + (i32.add + (i32.add + (get_local $39) + (i32.const 192) + ) + (i32.const 8) + ) + ) + (get_local $33) + (get_local $34) + ) + (set_local $23 + (i64.load + (i32.add + (i32.add + (get_local $39) + (i32.const 176) + ) + (i32.const 8) + ) + ) + ) + (set_local $35 + (i64.load offset=176 + (get_local $39) + ) + ) + ) + (set_local $34 + (i64.extend_s/i32 + (tee_local $17 + (i32.xor + (i32.add + (tee_local $31 + (i32.load offset=748 + (get_local $39) + ) + ) + (tee_local $30 + (i32.shr_s + (get_local $31) + (i32.const 31) + ) + ) + ) + (get_local $30) + ) + ) + ) + ) + (set_local $30 + (i32.const 0) + ) + (block $label$195 + (block $label$196 + (block $label$197 + (br_if $label$197 + (i32.le_s + (get_local $17) + (i32.const -1) + ) + ) + (br_if $label$196 + (tee_local $17 + (i32.wrap/i64 + (get_local $34) + ) + ) + ) + (br $label$195) + ) + (set_local $30 + (i32.const 0) + ) + (loop $label$198 + (i64.store8 + (i32.add + (get_local $12) + (get_local $30) + ) + (i64.or + (i64.rem_u + (get_local $34) + (i64.const 10) + ) + (i64.const 48) + ) + ) + (set_local $30 + (i32.add + (get_local $30) + (i32.const -1) + ) + ) + (set_local $17 + (i64.gt_u + (get_local $34) + (i64.const 42949672959) + ) + ) + (set_local $34 + (tee_local $33 + (i64.div_u + (get_local $34) + (i64.const 10) + ) + ) + ) + (br_if $label$198 + (get_local $17) + ) + ) + (br_if $label$195 + (i32.eqz + (tee_local $17 + (i32.wrap/i64 + (get_local $33) + ) + ) + ) + ) + ) + (loop $label$199 + (i32.store8 + (i32.add + (i32.add + (i32.add + (get_local $39) + (i32.const 692) + ) + (get_local $30) + ) + (i32.const 11) + ) + (i32.or + (i32.rem_u + (get_local $17) + (i32.const 10) + ) + (i32.const 48) + ) + ) + (set_local $30 + (i32.add + (get_local $30) + (i32.const -1) + ) + ) + (set_local $14 + (i32.gt_u + (get_local $17) + (i32.const 9) + ) + ) + (set_local $17 + (i32.div_u + (get_local $17) + (i32.const 10) + ) + ) + (br_if $label$199 + (get_local $14) + ) + ) + ) + (set_local $17 + (i32.add + (get_local $7) + (get_local $30) + ) + ) + (block $label$200 + (br_if $label$200 + (get_local $30) + ) + (i32.store8 + (tee_local $17 + (i32.add + (get_local $17) + (i32.const -1) + ) + ) + (i32.const 48) + ) + ) + (set_local $16 + (i32.or + (get_local $20) + (i32.const 2) + ) + ) + (i32.store8 + (tee_local $27 + (i32.add + (get_local $17) + (i32.const -2) + ) + ) + (i32.add + (get_local $29) + (i32.const 15) + ) + ) + (i32.store8 + (i32.add + (get_local $17) + (i32.const -1) + ) + (i32.add + (i32.and + (i32.shr_u + (get_local $31) + (i32.const 30) + ) + (i32.const 2) + ) + (i32.const 43) + ) + ) + (block $label$201 + (br_if $label$201 + (i32.and + (get_local $18) + (i32.const 8) + ) + ) + (br_if $label$70 + (i32.lt_s + (get_local $36) + (i32.const 1) + ) + ) + (set_local $30 + (i32.add + (get_local $39) + (i32.const 704) + ) + ) + (loop $label$202 + (call $__floatsitf + (i32.add + (get_local $39) + (i32.const 80) + ) + (tee_local $17 + (call $__fixtfsi + (get_local $35) + (get_local $23) + ) + ) + ) + (call $__subtf3 + (i32.add + (get_local $39) + (i32.const 64) + ) + (get_local $35) + (get_local $23) + (i64.load offset=80 + (get_local $39) + ) + (i64.load + (i32.add + (i32.add + (get_local $39) + (i32.const 80) + ) + (i32.const 8) + ) + ) + ) + (call $__multf3 + (i32.add + (get_local $39) + (i32.const 48) + ) + (i64.load offset=64 + (get_local $39) + ) + (i64.load + (i32.add + (i32.add + (get_local $39) + (i32.const 64) + ) + (i32.const 8) + ) + ) + (i64.const 0) + (i64.const 4612530443357519872) + ) + (i32.store8 + (get_local $30) + (i32.or + (i32.load8_u + (i32.add + (get_local $17) + (i32.const 12512) + ) + ) + (get_local $37) + ) + ) + (set_local $23 + (i64.load + (i32.add + (i32.add + (get_local $39) + (i32.const 48) + ) + (i32.const 8) + ) + ) + ) + (set_local $35 + (i64.load offset=48 + (get_local $39) + ) + ) + (block $label$203 + (br_if $label$203 + (i32.ne + (i32.sub + (tee_local $17 + (i32.add + (get_local $30) + (i32.const 1) + ) + ) + (i32.add + (get_local $39) + (i32.const 704) + ) + ) + (i32.const 1) + ) + ) + (i32.store8 + (i32.add + (get_local $30) + (i32.const 1) + ) + (i32.const 46) + ) + (set_local $17 + (i32.add + (get_local $30) + (i32.const 2) + ) + ) + ) + (set_local $30 + (get_local $17) + ) + (br_if $label$202 + (call $__netf2 + (get_local $35) + (get_local $23) + (i64.const 0) + (i64.const 0) + ) + ) + (br $label$69) + ) + ) + (set_local $30 + (i32.add + (get_local $39) + (i32.const 704) + ) + ) + (loop $label$204 + (call $__floatsitf + (i32.add + (get_local $39) + (i32.const 128) + ) + (tee_local $17 + (call $__fixtfsi + (get_local $35) + (get_local $23) + ) + ) + ) + (call $__subtf3 + (i32.add + (get_local $39) + (i32.const 112) + ) + (get_local $35) + (get_local $23) + (i64.load offset=128 + (get_local $39) + ) + (i64.load + (i32.add + (i32.add + (get_local $39) + (i32.const 128) + ) + (i32.const 8) + ) + ) + ) + (call $__multf3 + (i32.add + (get_local $39) + (i32.const 96) + ) + (i64.load offset=112 + (get_local $39) + ) + (i64.load + (i32.add + (i32.add + (get_local $39) + (i32.const 112) + ) + (i32.const 8) + ) + ) + (i64.const 0) + (i64.const 4612530443357519872) + ) + (i32.store8 + (get_local $30) + (i32.or + (i32.load8_u + (i32.add + (get_local $17) + (i32.const 12512) + ) + ) + (get_local $37) + ) + ) + (set_local $23 + (i64.load + (i32.add + (i32.add + (get_local $39) + (i32.const 96) + ) + (i32.const 8) + ) + ) + ) + (set_local $35 + (i64.load offset=96 + (get_local $39) + ) + ) + (block $label$205 + (br_if $label$205 + (i32.ne + (i32.sub + (tee_local $17 + (i32.add + (get_local $30) + (i32.const 1) + ) + ) + (i32.add + (get_local $39) + (i32.const 704) + ) + ) + (i32.const 1) + ) + ) + (i32.store8 + (i32.add + (get_local $30) + (i32.const 1) + ) + (i32.const 46) + ) + (set_local $17 + (i32.add + (get_local $30) + (i32.const 2) + ) + ) + ) + (set_local $30 + (get_local $17) + ) + (br_if $label$204 + (call $__netf2 + (get_local $35) + (get_local $23) + (i64.const 0) + (i64.const 0) + ) + ) + (br $label$69) + ) + ) + (set_local $28 + (i32.add + (get_local $30) + (i32.const -1) + ) + ) + (set_local $29 + (i32.add + (get_local $29) + (i32.const -2) + ) + ) + (br_if $label$67 + (tee_local $16 + (i32.and + (get_local $18) + (i32.const 8) + ) + ) + ) + ) + (set_local $30 + (i32.const 9) + ) + (block $label$206 + (br_if $label$206 + (i32.eqz + (get_local $27) + ) + ) + (br_if $label$206 + (i32.eqz + (tee_local $16 + (i32.load + (i32.add + (get_local $14) + (i32.const -4) + ) + ) + ) + ) + ) + (set_local $30 + (i32.const 0) + ) + (br_if $label$206 + (i32.rem_u + (get_local $16) + (i32.const 10) + ) + ) + (set_local $37 + (i32.const 10) + ) + (set_local $30 + (i32.const 0) + ) + (loop $label$207 + (set_local $30 + (i32.add + (get_local $30) + (i32.const 1) + ) + ) + (br_if $label$207 + (i32.eqz + (i32.rem_u + (get_local $16) + (tee_local $37 + (i32.mul + (get_local $37) + (i32.const 10) + ) + ) + ) + ) + ) + ) + ) + (set_local $37 + (i32.add + (i32.mul + (i32.shr_s + (i32.sub + (get_local $14) + (get_local $22) + ) + (i32.const 2) + ) + (i32.const 9) + ) + (i32.const -9) + ) + ) + (br_if $label$68 + (i32.ne + (i32.or + (get_local $29) + (i32.const 32) + ) + (i32.const 102) + ) + ) + (set_local $16 + (i32.const 0) + ) + (set_local $28 + (select + (get_local $28) + (tee_local $30 + (select + (tee_local $30 + (i32.sub + (get_local $37) + (get_local $30) + ) + ) + (i32.const 0) + (i32.gt_s + (get_local $30) + (i32.const 0) + ) + ) + ) + (i32.lt_s + (get_local $28) + (get_local $30) + ) + ) + ) + (br $label$67) + ) + (set_local $30 + (i32.const 0) + ) + (br_if $label$71 + (tee_local $16 + (i32.and + (get_local $18) + (i32.const 73728) + ) + ) + ) + ) + (br_if $label$71 + (i32.le_s + (get_local $15) + (get_local $30) + ) + ) + (drop + (call $memset + (i32.add + (get_local $39) + (i32.const 432) + ) + (i32.const 32) + (select + (tee_local $27 + (i32.sub + (get_local $15) + (get_local $30) + ) + ) + (i32.const 256) + (tee_local $17 + (i32.lt_u + (get_local $27) + (i32.const 256) + ) + ) + ) + ) + ) + (set_local $36 + (i32.and + (tee_local $14 + (i32.load + (get_local $0) + ) + ) + (i32.const 32) + ) + ) + (block $label$208 + (block $label$209 + (br_if $label$209 + (get_local $17) + ) + (set_local $17 + (i32.eqz + (get_local $36) + ) + ) + (set_local $36 + (get_local $27) + ) + (loop $label$210 + (block $label$211 + (br_if $label$211 + (i32.eqz + (i32.and + (get_local $17) + (i32.const 1) + ) + ) + ) + (drop + (call $__fwritex + (i32.add + (get_local $39) + (i32.const 432) + ) + (i32.const 256) + (get_local $0) + ) + ) + (set_local $14 + (i32.load + (get_local $0) + ) + ) + ) + (set_local $17 + (i32.eqz + (tee_local $31 + (i32.and + (get_local $14) + (i32.const 32) + ) + ) + ) + ) + (br_if $label$210 + (i32.gt_u + (tee_local $36 + (i32.add + (get_local $36) + (i32.const -256) + ) + ) + (i32.const 255) + ) + ) + ) + (br_if $label$71 + (get_local $31) + ) + (set_local $27 + (i32.and + (get_local $27) + (i32.const 255) + ) + ) + (br $label$208) + ) + (br_if $label$71 + (get_local $36) + ) + ) + (drop + (call $__fwritex + (i32.add + (get_local $39) + (i32.const 432) + ) + (get_local $27) + (get_local $0) + ) + ) + ) + (block $label$212 + (br_if $label$212 + (i32.eqz + (get_local $30) + ) + ) + (set_local $17 + (i32.const 0) + ) + (loop $label$213 + (br_if $label$212 + (i32.eqz + (tee_local $36 + (i32.load + (get_local $37) + ) + ) + ) + ) + (br_if $label$212 + (i32.gt_u + (tee_local $17 + (i32.add + (tee_local $36 + (call $wctomb + (i32.add + (get_local $39) + (i32.const 340) + ) + (get_local $36) + ) + ) + (get_local $17) + ) + ) + (get_local $30) + ) + ) + (block $label$214 + (br_if $label$214 + (i32.and + (i32.load8_u + (get_local $0) + ) + (i32.const 32) + ) + ) + (drop + (call $__fwritex + (i32.add + (get_local $39) + (i32.const 340) + ) + (get_local $36) + (get_local $0) + ) + ) + ) + (set_local $37 + (i32.add + (get_local $37) + (i32.const 4) + ) + ) + (br_if $label$213 + (i32.lt_u + (get_local $17) + (get_local $30) + ) + ) + ) + ) + (block $label$215 + (br_if $label$215 + (i32.ne + (get_local $16) + (i32.const 8192) + ) + ) + (br_if $label$215 + (i32.le_s + (get_local $15) + (get_local $30) + ) + ) + (drop + (call $memset + (i32.add + (get_local $39) + (i32.const 432) + ) + (i32.const 32) + (select + (tee_local $31 + (i32.sub + (get_local $15) + (get_local $30) + ) + ) + (i32.const 256) + (tee_local $17 + (i32.lt_u + (get_local $31) + (i32.const 256) + ) + ) + ) + ) + ) + (set_local $36 + (i32.and + (tee_local $14 + (i32.load + (get_local $0) + ) + ) + (i32.const 32) + ) + ) + (block $label$216 + (block $label$217 + (br_if $label$217 + (get_local $17) + ) + (set_local $17 + (i32.eqz + (get_local $36) + ) + ) + (set_local $36 + (get_local $31) + ) + (loop $label$218 + (block $label$219 + (br_if $label$219 + (i32.eqz + (i32.and + (get_local $17) + (i32.const 1) + ) + ) + ) + (drop + (call $__fwritex + (i32.add + (get_local $39) + (i32.const 432) + ) + (i32.const 256) + (get_local $0) + ) + ) + (set_local $14 + (i32.load + (get_local $0) + ) + ) + ) + (set_local $17 + (i32.eqz + (tee_local $37 + (i32.and + (get_local $14) + (i32.const 32) + ) + ) + ) + ) + (br_if $label$218 + (i32.gt_u + (tee_local $36 + (i32.add + (get_local $36) + (i32.const -256) + ) + ) + (i32.const 255) + ) + ) + ) + (br_if $label$215 + (get_local $37) + ) + (set_local $31 + (i32.and + (get_local $31) + (i32.const 255) + ) + ) + (br $label$216) + ) + (br_if $label$215 + (get_local $36) + ) + ) + (drop + (call $__fwritex + (i32.add + (get_local $39) + (i32.const 432) + ) + (get_local $31) + (get_local $0) + ) + ) + ) + (set_local $30 + (select + (get_local $15) + (get_local $30) + (i32.gt_s + (get_local $15) + (get_local $30) + ) + ) + ) + (br $label$23) + ) + (set_local $17 + (i32.add + (get_local $39) + (i32.const 704) + ) + ) + (loop $label$220 + (call $__floatsitf + (i32.add + (get_local $39) + (i32.const 32) + ) + (tee_local $14 + (call $__fixtfsi + (get_local $35) + (get_local $23) + ) + ) + ) + (call $__subtf3 + (i32.add + (get_local $39) + (i32.const 16) + ) + (get_local $35) + (get_local $23) + (i64.load offset=32 + (get_local $39) + ) + (i64.load + (i32.add + (i32.add + (get_local $39) + (i32.const 32) + ) + (i32.const 8) + ) + ) + ) + (call $__multf3 + (get_local $39) + (i64.load offset=16 + (get_local $39) + ) + (i64.load + (i32.add + (i32.add + (get_local $39) + (i32.const 16) + ) + (i32.const 8) + ) + ) + (i64.const 0) + (i64.const 4612530443357519872) + ) + (i32.store8 + (tee_local $30 + (get_local $17) + ) + (i32.or + (i32.load8_u + (i32.add + (get_local $14) + (i32.const 12512) + ) + ) + (get_local $37) + ) + ) + (set_local $23 + (i64.load + (i32.add + (get_local $39) + (i32.const 8) + ) + ) + ) + (set_local $35 + (i64.load + (get_local $39) + ) + ) + (block $label$221 + (br_if $label$221 + (i32.ne + (i32.sub + (tee_local $17 + (i32.add + (get_local $30) + (i32.const 1) + ) + ) + (i32.add + (get_local $39) + (i32.const 704) + ) + ) + (i32.const 1) + ) + ) + (br_if $label$221 + (i32.eqz + (call $__eqtf2 + (get_local $35) + (get_local $23) + (i64.const 0) + (i64.const 0) + ) + ) + ) + (i32.store8 + (i32.add + (get_local $30) + (i32.const 1) + ) + (i32.const 46) + ) + (set_local $17 + (i32.add + (get_local $30) + (i32.const 2) + ) + ) + ) + (br_if $label$220 + (call $__netf2 + (get_local $35) + (get_local $23) + (i64.const 0) + (i64.const 0) + ) + ) + ) + ) + (set_local $30 + (i32.const -1) + ) + (br_if $label$49 + (i32.lt_s + (i32.sub + (i32.sub + (i32.const 2147483645) + (get_local $16) + ) + (tee_local $31 + (i32.sub + (get_local $7) + (get_local $27) + ) + ) + ) + (get_local $36) + ) + ) + (set_local $37 + (i32.add + (i32.add + (get_local $31) + (get_local $16) + ) + (tee_local $29 + (select + (select + (i32.add + (get_local $36) + (i32.const 2) + ) + (tee_local $26 + (i32.sub + (get_local $17) + (i32.add + (get_local $39) + (i32.const 704) + ) + ) + ) + (i32.lt_s + (i32.add + (get_local $8) + (get_local $17) + ) + (get_local $36) + ) + ) + (get_local $26) + (get_local $36) + ) + ) + ) + ) + (br_if $label$64 + (tee_local $18 + (i32.and + (get_local $18) + (i32.const 73728) + ) + ) + ) + (br_if $label$64 + (i32.le_s + (get_local $15) + (get_local $37) + ) + ) + (drop + (call $memset + (i32.add + (get_local $39) + (i32.const 432) + ) + (i32.const 32) + (select + (tee_local $28 + (i32.sub + (get_local $15) + (get_local $37) + ) + ) + (i32.const 256) + (tee_local $30 + (i32.lt_u + (get_local $28) + (i32.const 256) + ) + ) + ) + ) + ) + (set_local $17 + (i32.and + (tee_local $36 + (i32.load + (get_local $0) + ) + ) + (i32.const 32) + ) + ) + (br_if $label$66 + (get_local $30) + ) + (set_local $30 + (i32.eqz + (get_local $17) + ) + ) + (set_local $17 + (get_local $28) + ) + (loop $label$222 + (block $label$223 + (br_if $label$223 + (i32.eqz + (i32.and + (get_local $30) + (i32.const 1) + ) + ) + ) + (drop + (call $__fwritex + (i32.add + (get_local $39) + (i32.const 432) + ) + (i32.const 256) + (get_local $0) + ) + ) + (set_local $36 + (i32.load + (get_local $0) + ) + ) + ) + (set_local $30 + (i32.eqz + (tee_local $14 + (i32.and + (get_local $36) + (i32.const 32) + ) + ) + ) + ) + (br_if $label$222 + (i32.gt_u + (tee_local $17 + (i32.add + (get_local $17) + (i32.const -256) + ) + ) + (i32.const 255) + ) + ) + ) + (br_if $label$64 + (get_local $14) + ) + (set_local $28 + (i32.and + (get_local $28) + (i32.const 255) + ) + ) + (br $label$65) + ) + (set_local $16 + (i32.const 0) + ) + (set_local $28 + (select + (get_local $28) + (tee_local $30 + (select + (tee_local $30 + (i32.sub + (i32.add + (get_local $37) + (get_local $36) + ) + (get_local $30) + ) + ) + (i32.const 0) + (i32.gt_s + (get_local $30) + (i32.const 0) + ) + ) + ) + (i32.lt_s + (get_local $28) + (get_local $30) + ) + ) + ) + ) + (set_local $30 + (i32.const -1) + ) + (br_if $label$49 + (i32.gt_s + (get_local $28) + (i32.sub + (i32.const 2147483646) + (tee_local $37 + (i32.ne + (tee_local $24 + (i32.or + (get_local $28) + (get_local $16) + ) + ) + (i32.const 0) + ) + ) + ) + ) + ) + (set_local $26 + (i32.add + (i32.add + (get_local $28) + (get_local $37) + ) + (i32.const 1) + ) + ) + (block $label$224 + (br_if $label$224 + (tee_local $21 + (i32.ne + (i32.or + (get_local $29) + (i32.const 32) + ) + (i32.const 102) + ) + ) + ) + (br_if $label$49 + (i32.gt_s + (get_local $36) + (i32.sub + (i32.const 2147483647) + (get_local $26) + ) + ) + ) + (set_local $36 + (select + (get_local $36) + (i32.const 0) + (i32.gt_s + (get_local $36) + (i32.const 0) + ) + ) + ) + (br $label$60) + ) + (set_local $35 + (i64.extend_s/i32 + (tee_local $30 + (select + (get_local $31) + (get_local $36) + (i32.lt_s + (get_local $36) + (i32.const 0) + ) + ) + ) + ) + ) + (br_if $label$63 + (i32.le_s + (get_local $30) + (i32.const -1) + ) + ) + (set_local $37 + (get_local $7) + ) + (br_if $label$62 + (tee_local $30 + (i32.wrap/i64 + (get_local $35) + ) + ) + ) + (br $label$61) + ) + (br_if $label$64 + (get_local $17) + ) + ) + (drop + (call $__fwritex + (i32.add + (get_local $39) + (i32.const 432) + ) + (get_local $28) + (get_local $0) + ) + ) + ) + (block $label$225 + (br_if $label$225 + (i32.and + (i32.load8_u + (get_local $0) + ) + (i32.const 32) + ) + ) + (drop + (call $__fwritex + (get_local $24) + (get_local $16) + (get_local $0) + ) + ) + ) + (block $label$226 + (br_if $label$226 + (i32.ne + (get_local $18) + (i32.const 65536) + ) + ) + (br_if $label$226 + (i32.le_s + (get_local $15) + (get_local $37) + ) + ) + (drop + (call $memset + (i32.add + (get_local $39) + (i32.const 432) + ) + (i32.const 48) + (select + (tee_local $16 + (i32.sub + (get_local $15) + (get_local $37) + ) + ) + (i32.const 256) + (tee_local $30 + (i32.lt_u + (get_local $16) + (i32.const 256) + ) + ) + ) + ) + ) + (set_local $17 + (i32.and + (tee_local $36 + (i32.load + (get_local $0) + ) + ) + (i32.const 32) + ) + ) + (block $label$227 + (block $label$228 + (br_if $label$228 + (get_local $30) + ) + (set_local $30 + (i32.eqz + (get_local $17) + ) + ) + (set_local $17 + (get_local $16) + ) + (loop $label$229 + (block $label$230 + (br_if $label$230 + (i32.eqz + (i32.and + (get_local $30) + (i32.const 1) + ) + ) + ) + (drop + (call $__fwritex + (i32.add + (get_local $39) + (i32.const 432) + ) + (i32.const 256) + (get_local $0) + ) + ) + (set_local $36 + (i32.load + (get_local $0) + ) + ) + ) + (set_local $30 + (i32.eqz + (tee_local $14 + (i32.and + (get_local $36) + (i32.const 32) + ) + ) + ) + ) + (br_if $label$229 + (i32.gt_u + (tee_local $17 + (i32.add + (get_local $17) + (i32.const -256) + ) + ) + (i32.const 255) + ) + ) + ) + (br_if $label$226 + (get_local $14) + ) + (set_local $16 + (i32.and + (get_local $16) + (i32.const 255) + ) + ) + (br $label$227) + ) + (br_if $label$226 + (get_local $17) + ) + ) + (drop + (call $__fwritex + (i32.add + (get_local $39) + (i32.const 432) + ) + (get_local $16) + (get_local $0) + ) + ) + ) + (block $label$231 + (br_if $label$231 + (i32.and + (i32.load8_u + (get_local $0) + ) + (i32.const 32) + ) + ) + (drop + (call $__fwritex + (i32.add + (get_local $39) + (i32.const 704) + ) + (get_local $26) + (get_local $0) + ) + ) + ) + (block $label$232 + (br_if $label$232 + (i32.lt_s + (tee_local $16 + (i32.sub + (get_local $29) + (get_local $26) + ) + ) + (i32.const 1) + ) + ) + (drop + (call $memset + (i32.add + (get_local $39) + (i32.const 432) + ) + (i32.const 48) + (select + (get_local $16) + (i32.const 256) + (tee_local $30 + (i32.lt_u + (get_local $16) + (i32.const 256) + ) + ) + ) + ) + ) + (set_local $17 + (i32.and + (tee_local $36 + (i32.load + (get_local $0) + ) + ) + (i32.const 32) + ) + ) + (block $label$233 + (block $label$234 + (br_if $label$234 + (get_local $30) + ) + (set_local $30 + (i32.eqz + (get_local $17) + ) + ) + (set_local $17 + (get_local $16) + ) + (loop $label$235 + (block $label$236 + (br_if $label$236 + (i32.eqz + (i32.and + (get_local $30) + (i32.const 1) + ) + ) + ) + (drop + (call $__fwritex + (i32.add + (get_local $39) + (i32.const 432) + ) + (i32.const 256) + (get_local $0) + ) + ) + (set_local $36 + (i32.load + (get_local $0) + ) + ) + ) + (set_local $30 + (i32.eqz + (tee_local $14 + (i32.and + (get_local $36) + (i32.const 32) + ) + ) + ) + ) + (br_if $label$235 + (i32.gt_u + (tee_local $17 + (i32.add + (get_local $17) + (i32.const -256) + ) + ) + (i32.const 255) + ) + ) + ) + (br_if $label$232 + (get_local $14) + ) + (set_local $16 + (i32.and + (get_local $16) + (i32.const 255) + ) + ) + (br $label$233) + ) + (br_if $label$232 + (get_local $17) + ) + ) + (drop + (call $__fwritex + (i32.add + (get_local $39) + (i32.const 432) + ) + (get_local $16) + (get_local $0) + ) + ) + ) + (block $label$237 + (br_if $label$237 + (i32.and + (i32.load8_u + (get_local $0) + ) + (i32.const 32) + ) + ) + (drop + (call $__fwritex + (get_local $27) + (get_local $31) + (get_local $0) + ) + ) + ) + (block $label$238 + (br_if $label$238 + (i32.ne + (get_local $18) + (i32.const 8192) + ) + ) + (br_if $label$238 + (i32.le_s + (get_local $15) + (get_local $37) + ) + ) + (drop + (call $memset + (i32.add + (get_local $39) + (i32.const 432) + ) + (i32.const 32) + (select + (tee_local $31 + (i32.sub + (get_local $15) + (get_local $37) + ) + ) + (i32.const 256) + (tee_local $30 + (i32.lt_u + (get_local $31) + (i32.const 256) + ) + ) + ) + ) + ) + (set_local $17 + (i32.and + (tee_local $36 + (i32.load + (get_local $0) + ) + ) + (i32.const 32) + ) + ) + (block $label$239 + (block $label$240 + (br_if $label$240 + (get_local $30) + ) + (set_local $30 + (i32.eqz + (get_local $17) + ) + ) + (set_local $17 + (get_local $31) + ) + (loop $label$241 + (block $label$242 + (br_if $label$242 + (i32.eqz + (i32.and + (get_local $30) + (i32.const 1) + ) + ) + ) + (drop + (call $__fwritex + (i32.add + (get_local $39) + (i32.const 432) + ) + (i32.const 256) + (get_local $0) + ) + ) + (set_local $36 + (i32.load + (get_local $0) + ) + ) + ) + (set_local $30 + (i32.eqz + (tee_local $14 + (i32.and + (get_local $36) + (i32.const 32) + ) + ) + ) + ) + (br_if $label$241 + (i32.gt_u + (tee_local $17 + (i32.add + (get_local $17) + (i32.const -256) + ) + ) + (i32.const 255) + ) + ) + ) + (br_if $label$238 + (get_local $14) + ) + (set_local $31 + (i32.and + (get_local $31) + (i32.const 255) + ) + ) + (br $label$239) + ) + (br_if $label$238 + (get_local $17) + ) + ) + (drop + (call $__fwritex + (i32.add + (get_local $39) + (i32.const 432) + ) + (get_local $31) + (get_local $0) + ) + ) + ) + (set_local $30 + (select + (get_local $15) + (get_local $37) + (i32.gt_s + (get_local $15) + (get_local $37) + ) + ) + ) + (br $label$49) + ) + (set_local $37 + (get_local $7) + ) + (loop $label$243 + (i64.store8 + (tee_local $37 + (i32.add + (get_local $37) + (i32.const -1) + ) + ) + (i64.or + (i64.rem_u + (get_local $35) + (i64.const 10) + ) + (i64.const 48) + ) + ) + (set_local $30 + (i64.gt_u + (get_local $35) + (i64.const 42949672959) + ) + ) + (set_local $35 + (tee_local $23 + (i64.div_u + (get_local $35) + (i64.const 10) + ) + ) + ) + (br_if $label$243 + (get_local $30) + ) + ) + (br_if $label$61 + (i32.eqz + (tee_local $30 + (i32.wrap/i64 + (get_local $23) + ) + ) + ) + ) + ) + (loop $label$244 + (i32.store8 + (tee_local $37 + (i32.add + (get_local $37) + (i32.const -1) + ) + ) + (i32.or + (i32.rem_u + (get_local $30) + (i32.const 10) + ) + (i32.const 48) + ) + ) + (set_local $31 + (i32.gt_u + (get_local $30) + (i32.const 9) + ) + ) + (set_local $30 + (i32.div_u + (get_local $30) + (i32.const 10) + ) + ) + (br_if $label$244 + (get_local $31) + ) + ) + ) + (block $label$245 + (br_if $label$245 + (i32.gt_s + (i32.sub + (get_local $7) + (get_local $37) + ) + (i32.const 1) + ) + ) + (set_local $30 + (i32.add + (get_local $37) + (i32.const -1) + ) + ) + (loop $label$246 + (i32.store8 + (get_local $30) + (i32.const 48) + ) + (set_local $37 + (i32.sub + (get_local $7) + (get_local $30) + ) + ) + (set_local $30 + (tee_local $31 + (i32.add + (get_local $30) + (i32.const -1) + ) + ) + ) + (br_if $label$246 + (i32.lt_s + (get_local $37) + (i32.const 2) + ) + ) + ) + (set_local $37 + (i32.add + (get_local $31) + (i32.const 1) + ) + ) + ) + (i32.store8 + (tee_local $25 + (i32.add + (get_local $37) + (i32.const -2) + ) + ) + (get_local $29) + ) + (set_local $30 + (i32.const -1) + ) + (i32.store8 + (i32.add + (get_local $37) + (i32.const -1) + ) + (i32.add + (i32.and + (i32.shr_u + (get_local $36) + (i32.const 30) + ) + (i32.const 2) + ) + (i32.const 43) + ) + ) + (br_if $label$49 + (i32.gt_s + (tee_local $36 + (i32.sub + (get_local $7) + (get_local $25) + ) + ) + (i32.sub + (i32.const 2147483647) + (get_local $26) + ) + ) + ) + ) + (set_local $30 + (i32.const -1) + ) + (br_if $label$49 + (i32.gt_s + (tee_local $36 + (i32.add + (get_local $36) + (get_local $26) + ) + ) + (i32.xor + (get_local $20) + (i32.const 2147483647) + ) + ) + ) + (set_local $26 + (i32.add + (get_local $36) + (get_local $20) + ) + ) + (br_if $label$50 + (tee_local $18 + (i32.and + (get_local $18) + (i32.const 73728) + ) + ) + ) + (br_if $label$50 + (i32.le_s + (get_local $15) + (get_local $26) + ) + ) + (drop + (call $memset + (i32.add + (get_local $39) + (i32.const 432) + ) + (i32.const 32) + (select + (tee_local $29 + (i32.sub + (get_local $15) + (get_local $26) + ) + ) + (i32.const 256) + (tee_local $30 + (i32.lt_u + (get_local $29) + (i32.const 256) + ) + ) + ) + ) + ) + (set_local $36 + (i32.and + (tee_local $37 + (i32.load + (get_local $0) + ) + ) + (i32.const 32) + ) + ) + (br_if $label$52 + (get_local $30) + ) + (set_local $30 + (i32.eqz + (get_local $36) + ) + ) + (set_local $36 + (get_local $29) + ) + (loop $label$247 + (block $label$248 + (br_if $label$248 + (i32.eqz + (i32.and + (get_local $30) + (i32.const 1) + ) + ) + ) + (drop + (call $__fwritex + (i32.add + (get_local $39) + (i32.const 432) + ) + (i32.const 256) + (get_local $0) + ) + ) + (set_local $37 + (i32.load + (get_local $0) + ) + ) + ) + (set_local $30 + (i32.eqz + (tee_local $31 + (i32.and + (get_local $37) + (i32.const 32) + ) + ) + ) + ) + (br_if $label$247 + (i32.gt_u + (tee_local $36 + (i32.add + (get_local $36) + (i32.const -256) + ) + ) + (i32.const 255) + ) + ) + ) + (br_if $label$50 + (get_local $31) + ) + (set_local $29 + (i32.and + (get_local $29) + (i32.const 255) + ) + ) + (br $label$51) + ) + (i32.store + (i32.load offset=416 + (get_local $39) + ) + (get_local $38) + ) + (set_local $30 + (i32.const 0) + ) + (br $label$23) + ) + (i64.store + (i32.load offset=416 + (get_local $39) + ) + (i64.extend_s/i32 + (get_local $38) + ) + ) + (set_local $30 + (i32.const 0) + ) + (br $label$23) + ) + (i32.store16 + (i32.load offset=416 + (get_local $39) + ) + (get_local $38) + ) + (set_local $30 + (i32.const 0) + ) + (br $label$23) + ) + (i32.store8 + (i32.load offset=416 + (get_local $39) + ) + (get_local $38) + ) + ) + (set_local $30 + (i32.const 0) + ) + (br $label$23) + ) + (i32.store + (i32.load offset=416 + (get_local $39) + ) + (get_local $38) + ) + (set_local $30 + (i32.const 0) + ) + (br $label$23) + ) + (i64.store + (i32.load offset=416 + (get_local $39) + ) + (i64.extend_s/i32 + (get_local $38) + ) + ) + (set_local $30 + (i32.const 0) + ) + (br $label$23) + ) + (br_if $label$50 + (get_local $36) + ) + ) + (drop + (call $__fwritex + (i32.add + (get_local $39) + (i32.const 432) + ) + (get_local $29) + (get_local $0) + ) + ) + ) + (block $label$249 + (br_if $label$249 + (i32.and + (i32.load8_u + (get_local $0) + ) + (i32.const 32) + ) + ) + (drop + (call $__fwritex + (get_local $19) + (get_local $20) + (get_local $0) + ) + ) + ) + (block $label$250 + (br_if $label$250 + (i32.ne + (get_local $18) + (i32.const 65536) + ) + ) + (br_if $label$250 + (i32.le_s + (get_local $15) + (get_local $26) + ) + ) + (drop + (call $memset + (i32.add + (get_local $39) + (i32.const 432) + ) + (i32.const 48) + (select + (tee_local $29 + (i32.sub + (get_local $15) + (get_local $26) + ) + ) + (i32.const 256) + (tee_local $30 + (i32.lt_u + (get_local $29) + (i32.const 256) + ) + ) + ) + ) + ) + (set_local $36 + (i32.and + (tee_local $37 + (i32.load + (get_local $0) + ) + ) + (i32.const 32) + ) + ) + (block $label$251 + (block $label$252 + (br_if $label$252 + (get_local $30) + ) + (set_local $30 + (i32.eqz + (get_local $36) + ) + ) + (set_local $36 + (get_local $29) + ) + (loop $label$253 + (block $label$254 + (br_if $label$254 + (i32.eqz + (i32.and + (get_local $30) + (i32.const 1) + ) + ) + ) + (drop + (call $__fwritex + (i32.add + (get_local $39) + (i32.const 432) + ) + (i32.const 256) + (get_local $0) + ) + ) + (set_local $37 + (i32.load + (get_local $0) + ) + ) + ) + (set_local $30 + (i32.eqz + (tee_local $31 + (i32.and + (get_local $37) + (i32.const 32) + ) + ) + ) + ) + (br_if $label$253 + (i32.gt_u + (tee_local $36 + (i32.add + (get_local $36) + (i32.const -256) + ) + ) + (i32.const 255) + ) + ) + ) + (br_if $label$250 + (get_local $31) + ) + (set_local $29 + (i32.and + (get_local $29) + (i32.const 255) + ) + ) + (br $label$251) + ) + (br_if $label$250 + (get_local $36) + ) + ) + (drop + (call $__fwritex + (i32.add + (get_local $39) + (i32.const 432) + ) + (get_local $29) + (get_local $0) + ) + ) + ) + (block $label$255 + (block $label$256 + (block $label$257 + (block $label$258 + (block $label$259 + (block $label$260 + (block $label$261 + (block $label$262 + (block $label$263 + (block $label$264 + (block $label$265 + (br_if $label$265 + (get_local $21) + ) + (set_local $37 + (tee_local $31 + (select + (get_local $22) + (get_local $17) + (i32.gt_u + (get_local $17) + (get_local $22) + ) + ) + ) + ) + (loop $label$266 + (block $label$267 + (block $label$268 + (br_if $label$268 + (i32.eqz + (tee_local $30 + (i32.load + (get_local $37) + ) + ) + ) + ) + (set_local $17 + (i32.const 0) + ) + (loop $label$269 + (i32.store8 + (i32.add + (get_local $11) + (get_local $17) + ) + (i32.or + (i32.rem_u + (get_local $30) + (i32.const 10) + ) + (i32.const 48) + ) + ) + (set_local $17 + (i32.add + (get_local $17) + (i32.const -1) + ) + ) + (set_local $36 + (i32.gt_u + (get_local $30) + (i32.const 9) + ) + ) + (set_local $30 + (i32.div_u + (get_local $30) + (i32.const 10) + ) + ) + (br_if $label$269 + (get_local $36) + ) + (br $label$267) + ) + ) + (set_local $17 + (i32.const 0) + ) + ) + (set_local $30 + (i32.add + (get_local $10) + (get_local $17) + ) + ) + (block $label$270 + (block $label$271 + (br_if $label$271 + (i32.eq + (get_local $37) + (get_local $31) + ) + ) + (br_if $label$270 + (i32.le_u + (get_local $30) + (i32.add + (get_local $39) + (i32.const 704) + ) + ) + ) + (loop $label$272 + (i32.store8 + (tee_local $30 + (i32.add + (get_local $30) + (i32.const -1) + ) + ) + (i32.const 48) + ) + (br_if $label$272 + (i32.gt_u + (get_local $30) + (i32.add + (get_local $39) + (i32.const 704) + ) + ) + ) + ) + (set_local $30 + (i32.add + (get_local $39) + (i32.const 704) + ) + ) + (br $label$270) + ) + (br_if $label$270 + (get_local $17) + ) + (i32.store8 + (tee_local $30 + (i32.add + (get_local $30) + (i32.const -1) + ) + ) + (i32.const 48) + ) + ) + (block $label$273 + (br_if $label$273 + (i32.and + (i32.load8_u + (get_local $0) + ) + (i32.const 32) + ) + ) + (drop + (call $__fwritex + (get_local $30) + (i32.sub + (get_local $10) + (get_local $30) + ) + (get_local $0) + ) + ) + ) + (br_if $label$266 + (i32.le_u + (tee_local $37 + (i32.add + (get_local $37) + (i32.const 4) + ) + ) + (get_local $22) + ) + ) + ) + (block $label$274 + (br_if $label$274 + (i32.eqz + (get_local $24) + ) + ) + (br_if $label$274 + (i32.and + (i32.load8_u + (get_local $0) + ) + (i32.const 32) + ) + ) + (drop + (call $__fwritex + (i32.const 12656) + (i32.const 1) + (get_local $0) + ) + ) + ) + (br_if $label$264 + (i32.lt_s + (get_local $28) + (i32.const 1) + ) + ) + (br_if $label$263 + (i32.ge_u + (get_local $37) + (get_local $14) + ) + ) + (loop $label$275 + (set_local $30 + (get_local $10) + ) + (block $label$276 + (block $label$277 + (br_if $label$277 + (i32.eqz + (tee_local $17 + (i32.load + (get_local $37) + ) + ) + ) + ) + (set_local $30 + (get_local $10) + ) + (loop $label$278 + (i32.store8 + (tee_local $30 + (i32.add + (get_local $30) + (i32.const -1) + ) + ) + (i32.or + (i32.rem_u + (get_local $17) + (i32.const 10) + ) + (i32.const 48) + ) + ) + (set_local $36 + (i32.gt_u + (get_local $17) + (i32.const 9) + ) + ) + (set_local $17 + (i32.div_u + (get_local $17) + (i32.const 10) + ) + ) + (br_if $label$278 + (get_local $36) + ) + ) + (br_if $label$276 + (i32.le_u + (get_local $30) + (i32.add + (get_local $39) + (i32.const 704) + ) + ) + ) + ) + (loop $label$279 + (i32.store8 + (tee_local $30 + (i32.add + (get_local $30) + (i32.const -1) + ) + ) + (i32.const 48) + ) + (br_if $label$279 + (i32.gt_u + (get_local $30) + (i32.add + (get_local $39) + (i32.const 704) + ) + ) + ) + ) + ) + (block $label$280 + (br_if $label$280 + (i32.and + (i32.load8_u + (get_local $0) + ) + (i32.const 32) + ) + ) + (drop + (call $__fwritex + (get_local $30) + (select + (get_local $28) + (i32.const 9) + (i32.lt_s + (get_local $28) + (i32.const 9) + ) + ) + (get_local $0) + ) + ) + ) + (set_local $30 + (i32.add + (get_local $28) + (i32.const -9) + ) + ) + (br_if $label$262 + (i32.lt_s + (get_local $28) + (i32.const 10) + ) + ) + (set_local $28 + (get_local $30) + ) + (br_if $label$275 + (i32.lt_u + (tee_local $37 + (i32.add + (get_local $37) + (i32.const 4) + ) + ) + (get_local $14) + ) + ) + (br $label$262) + ) + ) + (br_if $label$258 + (i32.le_s + (get_local $28) + (i32.const -1) + ) + ) + (set_local $31 + (select + (get_local $14) + (i32.add + (get_local $17) + (i32.const 4) + ) + (get_local $27) + ) + ) + (br_if $label$260 + (i32.eqz + (get_local $16) + ) + ) + (set_local $37 + (get_local $17) + ) + (loop $label$281 + (set_local $14 + (get_local $10) + ) + (block $label$282 + (block $label$283 + (br_if $label$283 + (i32.eqz + (tee_local $30 + (i32.load + (get_local $37) + ) + ) + ) + ) + (set_local $36 + (i32.const 0) + ) + (loop $label$284 + (i32.store8 + (i32.add + (i32.add + (i32.add + (get_local $39) + (i32.const 704) + ) + (get_local $36) + ) + (i32.const 8) + ) + (i32.or + (i32.rem_u + (get_local $30) + (i32.const 10) + ) + (i32.const 48) + ) + ) + (set_local $36 + (i32.add + (get_local $36) + (i32.const -1) + ) + ) + (set_local $14 + (i32.gt_u + (get_local $30) + (i32.const 9) + ) + ) + (set_local $30 + (i32.div_u + (get_local $30) + (i32.const 10) + ) + ) + (br_if $label$284 + (get_local $14) + ) + ) + (set_local $14 + (i32.add + (i32.add + (i32.add + (get_local $39) + (i32.const 704) + ) + (get_local $36) + ) + (i32.const 9) + ) + ) + (br_if $label$282 + (get_local $36) + ) + ) + (i32.store8 + (tee_local $14 + (i32.add + (get_local $14) + (i32.const -1) + ) + ) + (i32.const 48) + ) + ) + (block $label$285 + (block $label$286 + (br_if $label$286 + (i32.eq + (get_local $37) + (get_local $17) + ) + ) + (br_if $label$285 + (i32.le_u + (get_local $14) + (i32.add + (get_local $39) + (i32.const 704) + ) + ) + ) + (loop $label$287 + (i32.store8 + (tee_local $14 + (i32.add + (get_local $14) + (i32.const -1) + ) + ) + (i32.const 48) + ) + (br_if $label$287 + (i32.gt_u + (get_local $14) + (i32.add + (get_local $39) + (i32.const 704) + ) + ) + ) + (br $label$285) + ) + ) + (block $label$288 + (br_if $label$288 + (i32.and + (tee_local $30 + (i32.load + (get_local $0) + ) + ) + (i32.const 32) + ) + ) + (drop + (call $__fwritex + (get_local $14) + (i32.const 1) + (get_local $0) + ) + ) + (set_local $30 + (i32.load + (get_local $0) + ) + ) + ) + (set_local $14 + (i32.add + (get_local $14) + (i32.const 1) + ) + ) + (br_if $label$285 + (i32.and + (get_local $30) + (i32.const 32) + ) + ) + (drop + (call $__fwritex + (i32.const 12656) + (i32.const 1) + (get_local $0) + ) + ) + ) + (set_local $30 + (i32.sub + (get_local $10) + (get_local $14) + ) + ) + (block $label$289 + (br_if $label$289 + (i32.and + (i32.load8_u + (get_local $0) + ) + (i32.const 32) + ) + ) + (drop + (call $__fwritex + (get_local $14) + (select + (get_local $30) + (get_local $28) + (i32.gt_s + (get_local $28) + (get_local $30) + ) + ) + (get_local $0) + ) + ) + ) + (set_local $28 + (i32.sub + (get_local $28) + (get_local $30) + ) + ) + (br_if $label$259 + (i32.ge_u + (tee_local $37 + (i32.add + (get_local $37) + (i32.const 4) + ) + ) + (get_local $31) + ) + ) + (br_if $label$281 + (i32.gt_s + (get_local $28) + (i32.const -1) + ) + ) + (br $label$259) + ) + ) + (br_if $label$261 + (i32.ge_s + (tee_local $30 + (get_local $28) + ) + (i32.const 1) + ) + ) + (br $label$257) + ) + (set_local $30 + (get_local $28) + ) + ) + (br_if $label$257 + (i32.lt_s + (get_local $30) + (i32.const 1) + ) + ) + ) + (drop + (call $memset + (i32.add + (get_local $39) + (i32.const 432) + ) + (i32.const 48) + (select + (get_local $30) + (i32.const 256) + (tee_local $17 + (i32.lt_u + (get_local $30) + (i32.const 256) + ) + ) + ) + ) + ) + (set_local $36 + (i32.and + (tee_local $14 + (i32.load + (get_local $0) + ) + ) + (i32.const 32) + ) + ) + (block $label$290 + (block $label$291 + (br_if $label$291 + (get_local $17) + ) + (set_local $17 + (i32.eqz + (get_local $36) + ) + ) + (set_local $36 + (get_local $30) + ) + (loop $label$292 + (block $label$293 + (br_if $label$293 + (i32.eqz + (i32.and + (get_local $17) + (i32.const 1) + ) + ) + ) + (drop + (call $__fwritex + (i32.add + (get_local $39) + (i32.const 432) + ) + (i32.const 256) + (get_local $0) + ) + ) + (set_local $14 + (i32.load + (get_local $0) + ) + ) + ) + (set_local $17 + (i32.eqz + (tee_local $37 + (i32.and + (get_local $14) + (i32.const 32) + ) + ) + ) + ) + (br_if $label$292 + (i32.gt_u + (tee_local $36 + (i32.add + (get_local $36) + (i32.const -256) + ) + ) + (i32.const 255) + ) + ) + ) + (br_if $label$257 + (get_local $37) + ) + (set_local $30 + (i32.and + (get_local $30) + (i32.const 255) + ) + ) + (br $label$290) + ) + (br_if $label$257 + (get_local $36) + ) + ) + (drop + (call $__fwritex + (i32.add + (get_local $39) + (i32.const 432) + ) + (get_local $30) + (get_local $0) + ) + ) + (br_if $label$256 + (i32.eq + (get_local $18) + (i32.const 8192) + ) + ) + (br $label$255) + ) + (set_local $37 + (get_local $17) + ) + (loop $label$294 + (set_local $14 + (get_local $10) + ) + (block $label$295 + (block $label$296 + (br_if $label$296 + (i32.eqz + (tee_local $30 + (i32.load + (get_local $37) + ) + ) + ) + ) + (set_local $36 + (i32.const 0) + ) + (loop $label$297 + (i32.store8 + (i32.add + (i32.add + (i32.add + (get_local $39) + (i32.const 704) + ) + (get_local $36) + ) + (i32.const 8) + ) + (i32.or + (i32.rem_u + (get_local $30) + (i32.const 10) + ) + (i32.const 48) + ) + ) + (set_local $36 + (i32.add + (get_local $36) + (i32.const -1) + ) + ) + (set_local $14 + (i32.gt_u + (get_local $30) + (i32.const 9) + ) + ) + (set_local $30 + (i32.div_u + (get_local $30) + (i32.const 10) + ) + ) + (br_if $label$297 + (get_local $14) + ) + ) + (set_local $14 + (i32.add + (i32.add + (i32.add + (get_local $39) + (i32.const 704) + ) + (get_local $36) + ) + (i32.const 9) + ) + ) + (br_if $label$295 + (get_local $36) + ) + ) + (i32.store8 + (tee_local $14 + (i32.add + (get_local $14) + (i32.const -1) + ) + ) + (i32.const 48) + ) + ) + (block $label$298 + (block $label$299 + (br_if $label$299 + (i32.eq + (get_local $37) + (get_local $17) + ) + ) + (br_if $label$298 + (i32.le_u + (get_local $14) + (i32.add + (get_local $39) + (i32.const 704) + ) + ) + ) + (loop $label$300 + (i32.store8 + (tee_local $14 + (i32.add + (get_local $14) + (i32.const -1) + ) + ) + (i32.const 48) + ) + (br_if $label$300 + (i32.gt_u + (get_local $14) + (i32.add + (get_local $39) + (i32.const 704) + ) + ) + ) + (br $label$298) + ) + ) + (block $label$301 + (br_if $label$301 + (i32.and + (i32.load8_u + (get_local $0) + ) + (i32.const 32) + ) + ) + (drop + (call $__fwritex + (get_local $14) + (i32.const 1) + (get_local $0) + ) + ) + ) + (set_local $14 + (i32.add + (get_local $14) + (i32.const 1) + ) + ) + (br_if $label$298 + (i32.lt_s + (get_local $28) + (i32.const 1) + ) + ) + (br_if $label$298 + (i32.and + (i32.load8_u + (get_local $0) + ) + (i32.const 32) + ) + ) + (drop + (call $__fwritex + (i32.const 12656) + (i32.const 1) + (get_local $0) + ) + ) + ) + (set_local $30 + (i32.sub + (get_local $10) + (get_local $14) + ) + ) + (block $label$302 + (br_if $label$302 + (i32.and + (i32.load8_u + (get_local $0) + ) + (i32.const 32) + ) + ) + (drop + (call $__fwritex + (get_local $14) + (select + (get_local $30) + (get_local $28) + (i32.gt_s + (get_local $28) + (get_local $30) + ) + ) + (get_local $0) + ) + ) + ) + (set_local $28 + (i32.sub + (get_local $28) + (get_local $30) + ) + ) + (br_if $label$259 + (i32.ge_u + (tee_local $37 + (i32.add + (get_local $37) + (i32.const 4) + ) + ) + (get_local $31) + ) + ) + (br_if $label$294 + (i32.gt_s + (get_local $28) + (i32.const -1) + ) + ) + ) + ) + (br_if $label$258 + (i32.lt_s + (get_local $28) + (i32.const 1) + ) + ) + (drop + (call $memset + (i32.add + (get_local $39) + (i32.const 432) + ) + (i32.const 48) + (select + (get_local $28) + (i32.const 256) + (tee_local $30 + (i32.lt_u + (get_local $28) + (i32.const 256) + ) + ) + ) + ) + ) + (set_local $17 + (i32.and + (tee_local $36 + (i32.load + (get_local $0) + ) + ) + (i32.const 32) + ) + ) + (block $label$303 + (block $label$304 + (br_if $label$304 + (get_local $30) + ) + (set_local $30 + (i32.eqz + (get_local $17) + ) + ) + (set_local $17 + (get_local $28) + ) + (loop $label$305 + (block $label$306 + (br_if $label$306 + (i32.eqz + (i32.and + (get_local $30) + (i32.const 1) + ) + ) + ) + (drop + (call $__fwritex + (i32.add + (get_local $39) + (i32.const 432) + ) + (i32.const 256) + (get_local $0) + ) + ) + (set_local $36 + (i32.load + (get_local $0) + ) + ) + ) + (set_local $30 + (i32.eqz + (tee_local $14 + (i32.and + (get_local $36) + (i32.const 32) + ) + ) + ) + ) + (br_if $label$305 + (i32.gt_u + (tee_local $17 + (i32.add + (get_local $17) + (i32.const -256) + ) + ) + (i32.const 255) + ) + ) + ) + (br_if $label$258 + (get_local $14) + ) + (set_local $28 + (i32.and + (get_local $28) + (i32.const 255) + ) + ) + (br $label$303) + ) + (br_if $label$258 + (get_local $17) + ) + ) + (drop + (call $__fwritex + (i32.add + (get_local $39) + (i32.const 432) + ) + (get_local $28) + (get_local $0) + ) + ) + ) + (br_if $label$257 + (i32.and + (i32.load8_u + (get_local $0) + ) + (i32.const 32) + ) + ) + (drop + (call $__fwritex + (get_local $25) + (i32.sub + (get_local $7) + (get_local $25) + ) + (get_local $0) + ) + ) + ) + (br_if $label$255 + (i32.ne + (get_local $18) + (i32.const 8192) + ) + ) + ) + (br_if $label$255 + (i32.le_s + (get_local $15) + (get_local $26) + ) + ) + (drop + (call $memset + (i32.add + (get_local $39) + (i32.const 432) + ) + (i32.const 32) + (select + (tee_local $37 + (i32.sub + (get_local $15) + (get_local $26) + ) + ) + (i32.const 256) + (tee_local $30 + (i32.lt_u + (get_local $37) + (i32.const 256) + ) + ) + ) + ) + ) + (set_local $17 + (i32.and + (tee_local $36 + (i32.load + (get_local $0) + ) + ) + (i32.const 32) + ) + ) + (block $label$307 + (block $label$308 + (br_if $label$308 + (get_local $30) + ) + (set_local $30 + (i32.eqz + (get_local $17) + ) + ) + (set_local $17 + (get_local $37) + ) + (loop $label$309 + (block $label$310 + (br_if $label$310 + (i32.eqz + (i32.and + (get_local $30) + (i32.const 1) + ) + ) + ) + (drop + (call $__fwritex + (i32.add + (get_local $39) + (i32.const 432) + ) + (i32.const 256) + (get_local $0) + ) + ) + (set_local $36 + (i32.load + (get_local $0) + ) + ) + ) + (set_local $30 + (i32.eqz + (tee_local $14 + (i32.and + (get_local $36) + (i32.const 32) + ) + ) + ) + ) + (br_if $label$309 + (i32.gt_u + (tee_local $17 + (i32.add + (get_local $17) + (i32.const -256) + ) + ) + (i32.const 255) + ) + ) + ) + (br_if $label$255 + (get_local $14) + ) + (set_local $37 + (i32.and + (get_local $37) + (i32.const 255) + ) + ) + (br $label$307) + ) + (br_if $label$255 + (get_local $17) + ) + ) + (drop + (call $__fwritex + (i32.add + (get_local $39) + (i32.const 432) + ) + (get_local $37) + (get_local $0) + ) + ) + ) + (set_local $30 + (select + (get_local $15) + (get_local $26) + (i32.gt_s + (get_local $15) + (get_local $26) + ) + ) + ) + ) + (br_if $label$14 + (i32.lt_s + (get_local $30) + (i32.const 0) + ) + ) + ) + (br_if $label$16 + (i32.le_s + (get_local $30) + (get_local $13) + ) + ) + (br $label$14) + ) + ) + (br_if $label$0 + (get_local $0) + ) + (br_if $label$13 + (i32.eqz + (get_local $32) + ) + ) + (set_local $30 + (i32.const 1) + ) + (br_if $label$3 + (i32.eqz + (tee_local $1 + (i32.load offset=4 + (get_local $4) + ) + ) + ) + ) + (call $pop_arg + (i32.add + (get_local $3) + (i32.const 16) + ) + (get_local $1) + (get_local $2) + ) + (br_if $label$12 + (i32.eqz + (tee_local $1 + (i32.load offset=8 + (get_local $4) + ) + ) + ) + ) + (call $pop_arg + (i32.add + (get_local $3) + (i32.const 32) + ) + (get_local $1) + (get_local $2) + ) + (br_if $label$11 + (i32.eqz + (tee_local $1 + (i32.load offset=12 + (get_local $4) + ) + ) + ) + ) + (call $pop_arg + (i32.add + (get_local $3) + (i32.const 48) + ) + (get_local $1) + (get_local $2) + ) + (br_if $label$9 + (i32.eqz + (tee_local $1 + (i32.load offset=16 + (get_local $4) + ) + ) + ) + ) + (call $pop_arg + (i32.add + (get_local $3) + (i32.const 64) + ) + (get_local $1) + (get_local $2) + ) + (br_if $label$8 + (i32.eqz + (tee_local $1 + (i32.load offset=20 + (get_local $4) + ) + ) + ) + ) + (call $pop_arg + (i32.add + (get_local $3) + (i32.const 80) + ) + (get_local $1) + (get_local $2) + ) + (br_if $label$7 + (i32.eqz + (tee_local $1 + (i32.load offset=24 + (get_local $4) + ) + ) + ) + ) + (call $pop_arg + (i32.add + (get_local $3) + (i32.const 96) + ) + (get_local $1) + (get_local $2) + ) + (br_if $label$6 + (i32.eqz + (tee_local $1 + (i32.load offset=28 + (get_local $4) + ) + ) + ) + ) + (call $pop_arg + (i32.add + (get_local $3) + (i32.const 112) + ) + (get_local $1) + (get_local $2) + ) + (br_if $label$5 + (i32.eqz + (tee_local $1 + (i32.load offset=32 + (get_local $4) + ) + ) + ) + ) + (call $pop_arg + (i32.add + (get_local $3) + (i32.const 128) + ) + (get_local $1) + (get_local $2) + ) + (br_if $label$4 + (i32.eqz + (tee_local $1 + (i32.load offset=36 + (get_local $4) + ) + ) + ) + ) + (call $pop_arg + (i32.add + (get_local $3) + (i32.const 144) + ) + (get_local $1) + (get_local $2) + ) + (set_local $38 + (i32.const 1) + ) + (br $label$0) + ) + (i32.store + (call $__errno_location) + (i32.const 75) + ) + (br $label$1) + ) + (set_local $38 + (i32.const 0) + ) + (br $label$0) + ) + (set_local $30 + (i32.const 2) + ) + (br $label$3) + ) + (set_local $30 + (i32.const 3) + ) + (br $label$3) + ) + (set_local $38 + (i32.const 0) + ) + (br $label$0) + ) + (set_local $30 + (i32.const 4) + ) + (br $label$3) + ) + (set_local $30 + (i32.const 5) + ) + (br $label$3) + ) + (set_local $30 + (i32.const 6) + ) + (br $label$3) + ) + (set_local $30 + (i32.const 7) + ) + (br $label$3) + ) + (set_local $30 + (i32.const 8) + ) + (br $label$3) + ) + (set_local $30 + (i32.const 9) + ) + ) + (set_local $1 + (i32.add + (get_local $4) + (i32.shl + (get_local $30) + (i32.const 2) + ) + ) + ) + (loop $label$311 + (br_if $label$2 + (i32.load + (get_local $1) + ) + ) + (set_local $1 + (i32.add + (get_local $1) + (i32.const 4) + ) + ) + (set_local $38 + (i32.const 1) + ) + (br_if $label$311 + (i32.le_u + (tee_local $30 + (i32.add + (get_local $30) + (i32.const 1) + ) + ) + (i32.const 9) + ) + ) + (br $label$0) + ) + ) + (i32.store + (call $__errno_location) + (i32.const 22) + ) + ) + (set_local $38 + (i32.const -1) + ) + ) + (i32.store offset=4 + (i32.const 0) + (i32.add + (get_local $39) + (i32.const 8128) + ) + ) + (get_local $38) + ) + (func $__lockfile (param $0 i32) (result i32) + (local $1 i32) + (get_local $1) + ) + (func $__unlockfile (param $0 i32) + ) + (func $__fwritex (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (local $8 i32) + (block $label$0 + (block $label$1 + (br_if $label$1 + (tee_local $6 + (i32.load offset=16 + (get_local $2) + ) + ) + ) + (set_local $6 + (i32.const 0) + ) + (br_if $label$0 + (call $__towrite + (get_local $2) + ) + ) + (set_local $6 + (i32.load + (i32.add + (get_local $2) + (i32.const 16) + ) + ) + ) + ) + (block $label$2 + (br_if $label$2 + (i32.ge_u + (i32.sub + (get_local $6) + (tee_local $7 + (i32.load offset=20 + (get_local $2) + ) + ) + ) + (get_local $1) + ) + ) + (return + (call_indirect (type $FUNCSIG$iiii) + (get_local $2) + (get_local $0) + (get_local $1) + (i32.load offset=36 + (get_local $2) + ) + ) + ) + ) + (set_local $8 + (i32.const 0) + ) + (block $label$3 + (br_if $label$3 + (i32.lt_s + (i32.load8_s offset=75 + (get_local $2) + ) + (i32.const 0) + ) + ) + (set_local $3 + (i32.add + (get_local $0) + (get_local $1) + ) + ) + (set_local $8 + (i32.const 0) + ) + (set_local $6 + (i32.const 0) + ) + (loop $label$4 + (br_if $label$3 + (i32.eqz + (i32.add + (get_local $1) + (get_local $6) + ) + ) + ) + (set_local $5 + (i32.add + (get_local $3) + (get_local $6) + ) + ) + (set_local $6 + (tee_local $4 + (i32.add + (get_local $6) + (i32.const -1) + ) + ) + ) + (br_if $label$4 + (i32.ne + (i32.load8_u + (i32.add + (get_local $5) + (i32.const -1) + ) + ) + (i32.const 10) + ) + ) + ) + (br_if $label$0 + (i32.lt_u + (tee_local $6 + (call_indirect (type $FUNCSIG$iiii) + (get_local $2) + (get_local $0) + (tee_local $8 + (i32.add + (i32.add + (get_local $1) + (get_local $4) + ) + (i32.const 1) + ) + ) + (i32.load offset=36 + (get_local $2) + ) + ) + ) + (get_local $8) + ) + ) + (set_local $1 + (i32.xor + (get_local $4) + (i32.const -1) + ) + ) + (set_local $0 + (i32.add + (i32.add + (get_local $3) + (get_local $4) + ) + (i32.const 1) + ) + ) + (set_local $7 + (i32.load + (i32.add + (get_local $2) + (i32.const 20) + ) + ) + ) + ) + (drop + (call $memcpy + (get_local $7) + (get_local $0) + (get_local $1) + ) + ) + (i32.store + (tee_local $6 + (i32.add + (get_local $2) + (i32.const 20) + ) + ) + (i32.add + (i32.load + (get_local $6) + ) + (get_local $1) + ) + ) + (return + (i32.add + (get_local $8) + (get_local $1) + ) + ) + ) + (get_local $6) + ) + (func $pop_arg (param $0 i32) (param $1 i32) (param $2 i32) + (local $3 i64) + (local $4 i32) + (i32.store offset=4 + (i32.const 0) + (tee_local $4 + (i32.sub + (i32.load offset=4 + (i32.const 0) + ) + (i32.const 16) + ) + ) + ) + (block $label$0 + (br_if $label$0 + (i32.gt_u + (tee_local $1 + (i32.add + (get_local $1) + (i32.const -9) + ) + ) + (i32.const 17) + ) + ) + (block $label$1 + (block $label$2 + (block $label$3 + (block $label$4 + (block $label$5 + (block $label$6 + (block $label$7 + (block $label$8 + (block $label$9 + (block $label$10 + (block $label$11 + (block $label$12 + (block $label$13 + (block $label$14 + (block $label$15 + (block $label$16 + (block $label$17 + (block $label$18 + (br_table $label$18 $label$17 $label$16 $label$15 $label$14 $label$13 $label$12 $label$11 $label$10 $label$9 $label$8 $label$7 $label$6 $label$5 $label$4 $label$3 $label$2 $label$1 $label$18 + (get_local $1) + ) + ) + (i32.store + (get_local $2) + (i32.add + (tee_local $1 + (i32.load + (get_local $2) + ) + ) + (i32.const 4) + ) + ) + (i32.store + (get_local $0) + (i32.load + (get_local $1) + ) + ) + (br $label$0) + ) + (i32.store + (get_local $2) + (i32.add + (tee_local $1 + (i32.load + (get_local $2) + ) + ) + (i32.const 4) + ) + ) + (i64.store + (get_local $0) + (i64.load32_s + (get_local $1) + ) + ) + (br $label$0) + ) + (i32.store + (get_local $2) + (i32.add + (tee_local $1 + (i32.load + (get_local $2) + ) + ) + (i32.const 4) + ) + ) + (i64.store + (get_local $0) + (i64.load32_u + (get_local $1) + ) + ) + (br $label$0) + ) + (i32.store + (get_local $2) + (i32.add + (tee_local $1 + (i32.and + (i32.add + (i32.load + (get_local $2) + ) + (i32.const 7) + ) + (i32.const -8) + ) + ) + (i32.const 8) + ) + ) + (i64.store + (get_local $0) + (i64.load + (get_local $1) + ) + ) + (br $label$0) + ) + (i32.store + (get_local $2) + (i32.add + (tee_local $1 + (i32.load + (get_local $2) + ) + ) + (i32.const 4) + ) + ) + (i64.store + (get_local $0) + (i64.load32_s + (get_local $1) + ) + ) + (br $label$0) + ) + (i32.store + (get_local $2) + (i32.add + (tee_local $1 + (i32.load + (get_local $2) + ) + ) + (i32.const 4) + ) + ) + (i64.store + (get_local $0) + (i64.load32_u + (get_local $1) + ) + ) + (br $label$0) + ) + (i32.store + (get_local $2) + (i32.add + (tee_local $1 + (i32.load + (get_local $2) + ) + ) + (i32.const 4) + ) + ) + (i64.store + (get_local $0) + (i64.load16_s + (get_local $1) + ) + ) + (br $label$0) + ) + (i32.store + (get_local $2) + (i32.add + (tee_local $1 + (i32.load + (get_local $2) + ) + ) + (i32.const 4) + ) + ) + (i64.store + (get_local $0) + (i64.load16_u + (get_local $1) + ) + ) + (br $label$0) + ) + (i32.store + (get_local $2) + (i32.add + (tee_local $1 + (i32.load + (get_local $2) + ) + ) + (i32.const 4) + ) + ) + (i64.store + (get_local $0) + (i64.load8_s + (get_local $1) + ) + ) + (br $label$0) + ) + (i32.store + (get_local $2) + (i32.add + (tee_local $1 + (i32.load + (get_local $2) + ) + ) + (i32.const 4) + ) + ) + (i64.store + (get_local $0) + (i64.load8_u + (get_local $1) + ) + ) + (br $label$0) + ) + (i32.store + (get_local $2) + (i32.add + (tee_local $1 + (i32.and + (i32.add + (i32.load + (get_local $2) + ) + (i32.const 7) + ) + (i32.const -8) + ) + ) + (i32.const 8) + ) + ) + (i64.store + (get_local $0) + (i64.load + (get_local $1) + ) + ) + (br $label$0) + ) + (i32.store + (get_local $2) + (i32.add + (tee_local $1 + (i32.load + (get_local $2) + ) + ) + (i32.const 4) + ) + ) + (i64.store + (get_local $0) + (i64.load32_u + (get_local $1) + ) + ) + (br $label$0) + ) + (i32.store + (get_local $2) + (i32.add + (tee_local $1 + (i32.and + (i32.add + (i32.load + (get_local $2) + ) + (i32.const 7) + ) + (i32.const -8) + ) + ) + (i32.const 8) + ) + ) + (i64.store + (get_local $0) + (i64.load + (get_local $1) + ) + ) + (br $label$0) + ) + (i32.store + (get_local $2) + (i32.add + (tee_local $1 + (i32.and + (i32.add + (i32.load + (get_local $2) + ) + (i32.const 7) + ) + (i32.const -8) + ) + ) + (i32.const 8) + ) + ) + (i64.store + (get_local $0) + (i64.load + (get_local $1) + ) + ) + (br $label$0) + ) + (i32.store + (get_local $2) + (i32.add + (tee_local $1 + (i32.load + (get_local $2) + ) + ) + (i32.const 4) + ) + ) + (i64.store + (get_local $0) + (i64.load32_s + (get_local $1) + ) + ) + (br $label$0) + ) + (i32.store + (get_local $2) + (i32.add + (tee_local $1 + (i32.load + (get_local $2) + ) + ) + (i32.const 4) + ) + ) + (i64.store + (get_local $0) + (i64.load32_u + (get_local $1) + ) + ) + (br $label$0) + ) + (i32.store + (get_local $2) + (i32.add + (tee_local $1 + (i32.and + (i32.add + (i32.load + (get_local $2) + ) + (i32.const 7) + ) + (i32.const -8) + ) + ) + (i32.const 8) + ) + ) + (call $__extenddftf2 + (get_local $4) + (f64.load + (get_local $1) + ) + ) + (i64.store + (i32.add + (get_local $0) + (i32.const 8) + ) + (i64.load + (i32.add + (get_local $4) + (i32.const 8) + ) + ) + ) + (i64.store + (get_local $0) + (i64.load + (get_local $4) + ) + ) + (br $label$0) + ) + (i32.store + (get_local $2) + (i32.add + (tee_local $1 + (i32.and + (i32.add + (i32.load + (get_local $2) + ) + (i32.const 15) + ) + (i32.const -16) + ) + ) + (i32.const 16) + ) + ) + (set_local $3 + (i64.load + (get_local $1) + ) + ) + (i64.store + (i32.add + (get_local $0) + (i32.const 8) + ) + (i64.load offset=8 + (get_local $1) + ) + ) + (i64.store + (get_local $0) + (get_local $3) + ) + ) + (i32.store offset=4 + (i32.const 0) + (i32.add + (get_local $4) + (i32.const 16) + ) + ) + ) + (func $strerror (param $0 i32) (result i32) + (local $1 i32) + (local $2 i32) + (local $3 i32) + (set_local $2 + (i32.const 0) + ) + (block $label$0 + (block $label$1 + (block $label$2 + (block $label$3 + (loop $label$4 + (br_if $label$3 + (i32.eq + (i32.load8_u + (i32.add + (get_local $2) + (i32.const 12672) + ) + ) + (get_local $0) + ) + ) + (set_local $1 + (i32.const 87) + ) + (br_if $label$4 + (i32.ne + (tee_local $2 + (i32.add + (get_local $2) + (i32.const 1) + ) + ) + (i32.const 87) + ) + ) + (br $label$2) + ) + ) + (set_local $1 + (get_local $2) + ) + (br_if $label$1 + (i32.eqz + (get_local $2) + ) + ) + ) + (set_local $2 + (i32.const 12768) + ) + (loop $label$5 + (set_local $0 + (i32.load8_u + (get_local $2) + ) + ) + (set_local $2 + (tee_local $3 + (i32.add + (get_local $2) + (i32.const 1) + ) + ) + ) + (br_if $label$5 + (get_local $0) + ) + (set_local $2 + (get_local $3) + ) + (br_if $label$5 + (tee_local $1 + (i32.add + (get_local $1) + (i32.const -1) + ) + ) + ) + (br $label$0) + ) + ) + (set_local $3 + (i32.const 12768) + ) + ) + (call $__lctrans + (get_local $3) + (i32.load offset=20 + (i32.const 0) + ) + ) + ) + (func $strnlen (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + (select + (i32.sub + (tee_local $2 + (call $memchr + (get_local $0) + (i32.const 0) + (get_local $1) + ) + ) + (get_local $0) + ) + (get_local $1) + (get_local $2) + ) + ) + (func $wctomb (param $0 i32) (param $1 i32) (result i32) + (block $label$0 + (br_if $label$0 + (i32.eqz + (get_local $0) + ) + ) + (return + (call $wcrtomb + (get_local $0) + (get_local $1) + (i32.const 0) + ) + ) + ) + (i32.const 0) + ) + (func $__signbitl (param $0 i64) (param $1 i64) (result i32) + (i32.wrap/i64 + (i64.shr_u + (get_local $1) + (i64.const 63) + ) + ) + ) + (func $__fpclassifyl (param $0 i64) (param $1 i64) (result i32) + (local $2 i64) + (local $3 i32) + (local $4 i32) + (set_local $2 + (i64.and + (get_local $1) + (i64.const 281474976710655) + ) + ) + (block $label$0 + (block $label$1 + (br_if $label$1 + (i32.eq + (tee_local $3 + (i32.and + (i32.wrap/i64 + (i64.shr_u + (get_local $1) + (i64.const 48) + ) + ) + (i32.const 32767) + ) + ) + (i32.const 32767) + ) + ) + (set_local $4 + (i32.const 4) + ) + (br_if $label$0 + (get_local $3) + ) + (return + (select + (i32.const 3) + (i32.const 2) + (i64.ne + (i64.or + (get_local $2) + (get_local $0) + ) + (i64.const 0) + ) + ) + ) + ) + (set_local $4 + (i64.eqz + (i64.or + (get_local $2) + (get_local $0) + ) + ) + ) + ) + (get_local $4) + ) + (func $frexpl (param $0 i32) (param $1 i64) (param $2 i64) (param $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (i32.store offset=4 + (i32.const 0) + (tee_local $6 + (i32.sub + (i32.load offset=4 + (i32.const 0) + ) + (i32.const 32) + ) + ) + ) + (block $label$0 + (br_if $label$0 + (i32.eq + (tee_local $5 + (i32.and + (tee_local $4 + (i32.wrap/i64 + (i64.shr_u + (get_local $2) + (i64.const 48) + ) + ) + ) + (i32.const 32767) + ) + ) + (i32.const 32767) + ) + ) + (block $label$1 + (block $label$2 + (block $label$3 + (br_if $label$3 + (get_local $5) + ) + (br_if $label$2 + (i32.eqz + (call $__eqtf2 + (get_local $1) + (get_local $2) + (i64.const 0) + (i64.const 0) + ) + ) + ) + (call $__multf3 + (get_local $6) + (get_local $1) + (get_local $2) + (i64.const 0) + (i64.const 4645181540655955968) + ) + (call $frexpl + (i32.add + (get_local $6) + (i32.const 16) + ) + (i64.load + (get_local $6) + ) + (i64.load + (i32.add + (get_local $6) + (i32.const 8) + ) + ) + (get_local $3) + ) + (set_local $4 + (i32.add + (i32.load + (get_local $3) + ) + (i32.const -120) + ) + ) + (set_local $2 + (i64.load offset=24 + (get_local $6) + ) + ) + (set_local $1 + (i64.load offset=16 + (get_local $6) + ) + ) + (br $label$1) + ) + (i32.store + (get_local $3) + (i32.add + (i32.and + (get_local $4) + (i32.const 32767) + ) + (i32.const -16382) + ) + ) + (set_local $2 + (i64.or + (i64.shl + (i64.extend_u/i32 + (i32.or + (i32.and + (get_local $4) + (i32.const 32768) + ) + (i32.const 16382) + ) + ) + (i64.const 48) + ) + (i64.and + (get_local $2) + (i64.const 281474976710655) + ) + ) + ) + (br $label$0) + ) + (set_local $4 + (i32.const 0) + ) + ) + (i32.store + (get_local $3) + (get_local $4) + ) + ) + (i64.store + (get_local $0) + (get_local $1) + ) + (i64.store + (i32.add + (get_local $0) + (i32.const 8) + ) + (get_local $2) + ) + (i32.store offset=4 + (i32.const 0) + (i32.add + (get_local $6) + (i32.const 32) + ) + ) + ) + (func $wcrtomb (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i32) + (set_local $3 + (i32.const 1) + ) + (block $label$0 + (br_if $label$0 + (i32.eqz + (get_local $0) + ) + ) + (block $label$1 + (br_if $label$1 + (i32.gt_u + (get_local $1) + (i32.const 127) + ) + ) + (i32.store8 + (get_local $0) + (get_local $1) + ) + (return + (i32.const 1) + ) + ) + (block $label$2 + (block $label$3 + (block $label$4 + (block $label$5 + (block $label$6 + (block $label$7 + (br_if $label$7 + (i32.eqz + (i32.load + (i32.const 0) + ) + ) + ) + (br_if $label$6 + (i32.gt_u + (get_local $1) + (i32.const 2047) + ) + ) + (i32.store8 offset=1 + (get_local $0) + (i32.or + (i32.and + (get_local $1) + (i32.const 63) + ) + (i32.const 128) + ) + ) + (i32.store8 + (get_local $0) + (i32.or + (i32.shr_u + (get_local $1) + (i32.const 6) + ) + (i32.const 192) + ) + ) + (return + (i32.const 2) + ) + ) + (br_if $label$5 + (i32.ne + (i32.and + (get_local $1) + (i32.const -128) + ) + (i32.const 57216) + ) + ) + (i32.store8 + (get_local $0) + (get_local $1) + ) + (return + (i32.const 1) + ) + ) + (br_if $label$4 + (i32.lt_u + (get_local $1) + (i32.const 55296) + ) + ) + (br_if $label$4 + (i32.eq + (i32.and + (get_local $1) + (i32.const -8192) + ) + (i32.const 57344) + ) + ) + (br_if $label$3 + (i32.gt_u + (i32.add + (get_local $1) + (i32.const -65536) + ) + (i32.const 1048575) + ) + ) + (i32.store8 + (get_local $0) + (i32.or + (i32.shr_u + (get_local $1) + (i32.const 18) + ) + (i32.const 240) + ) + ) + (i32.store8 offset=3 + (get_local $0) + (i32.or + (i32.and + (get_local $1) + (i32.const 63) + ) + (i32.const 128) + ) + ) + (i32.store8 offset=1 + (get_local $0) + (i32.or + (i32.and + (i32.shr_u + (get_local $1) + (i32.const 12) + ) + (i32.const 63) + ) + (i32.const 128) + ) + ) + (i32.store8 offset=2 + (get_local $0) + (i32.or + (i32.and + (i32.shr_u + (get_local $1) + (i32.const 6) + ) + (i32.const 63) + ) + (i32.const 128) + ) + ) + (return + (i32.const 4) + ) + ) + (i32.store + (call $__errno_location) + (i32.const 84) + ) + (br $label$2) + ) + (i32.store8 + (get_local $0) + (i32.or + (i32.shr_u + (get_local $1) + (i32.const 12) + ) + (i32.const 224) + ) + ) + (i32.store8 offset=2 + (get_local $0) + (i32.or + (i32.and + (get_local $1) + (i32.const 63) + ) + (i32.const 128) + ) + ) + (i32.store8 offset=1 + (get_local $0) + (i32.or + (i32.and + (i32.shr_u + (get_local $1) + (i32.const 6) + ) + (i32.const 63) + ) + (i32.const 128) + ) + ) + (return + (i32.const 3) + ) + ) + (i32.store + (call $__errno_location) + (i32.const 84) + ) + ) + (set_local $3 + (i32.const -1) + ) + ) + (get_local $3) + ) + (func $memchr (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (set_local $6 + (i32.const 0) + ) + (set_local $4 + (i32.ne + (get_local $2) + (i32.const 0) + ) + ) + (block $label$0 + (block $label$1 + (block $label$2 + (block $label$3 + (block $label$4 + (block $label$5 + (br_if $label$5 + (i32.eqz + (get_local $2) + ) + ) + (br_if $label$4 + (i32.eqz + (i32.and + (get_local $0) + (i32.const 3) + ) + ) + ) + (set_local $3 + (i32.and + (get_local $1) + (i32.const 255) + ) + ) + (loop $label$6 + (br_if $label$2 + (i32.eq + (i32.load8_u + (get_local $0) + ) + (get_local $3) + ) + ) + (set_local $4 + (i32.ne + (get_local $2) + (i32.const 1) + ) + ) + (set_local $5 + (i32.add + (get_local $2) + (i32.const -1) + ) + ) + (set_local $0 + (i32.add + (get_local $0) + (i32.const 1) + ) + ) + (br_if $label$3 + (i32.eq + (get_local $2) + (i32.const 1) + ) + ) + (set_local $2 + (get_local $5) + ) + (br_if $label$6 + (i32.and + (get_local $0) + (i32.const 3) + ) + ) + (br $label$3) + ) + ) + (set_local $5 + (get_local $2) + ) + (br_if $label$1 + (get_local $4) + ) + (br $label$0) + ) + (set_local $5 + (get_local $2) + ) + ) + (br_if $label$1 + (get_local $4) + ) + (br $label$0) + ) + (set_local $5 + (get_local $2) + ) + ) + (block $label$7 + (br_if $label$7 + (i32.eq + (i32.load8_u + (get_local $0) + ) + (i32.and + (get_local $1) + (i32.const 255) + ) + ) + ) + (block $label$8 + (block $label$9 + (br_if $label$9 + (i32.lt_u + (get_local $5) + (i32.const 4) + ) + ) + (set_local $4 + (i32.mul + (i32.and + (get_local $1) + (i32.const 255) + ) + (i32.const 16843009) + ) + ) + (loop $label$10 + (br_if $label$8 + (i32.and + (i32.and + (i32.xor + (tee_local $2 + (i32.xor + (i32.load + (get_local $0) + ) + (get_local $4) + ) + ) + (i32.const -1) + ) + (i32.add + (get_local $2) + (i32.const -16843009) + ) + ) + (i32.const -2139062144) + ) + ) + (set_local $0 + (i32.add + (get_local $0) + (i32.const 4) + ) + ) + (br_if $label$10 + (i32.gt_u + (tee_local $5 + (i32.add + (get_local $5) + (i32.const -4) + ) + ) + (i32.const 3) + ) + ) + ) + ) + (br_if $label$0 + (i32.eqz + (get_local $5) + ) + ) + ) + (set_local $2 + (i32.and + (get_local $1) + (i32.const 255) + ) + ) + (loop $label$11 + (br_if $label$7 + (i32.eq + (i32.load8_u + (get_local $0) + ) + (get_local $2) + ) + ) + (set_local $0 + (i32.add + (get_local $0) + (i32.const 1) + ) + ) + (br_if $label$11 + (tee_local $5 + (i32.add + (get_local $5) + (i32.const -1) + ) + ) + ) + (br $label$0) + ) + ) + (set_local $6 + (get_local $5) + ) + ) + (select + (get_local $0) + (i32.const 0) + (get_local $6) + ) + ) + (func $__lctrans (param $0 i32) (param $1 i32) (result i32) + (call $__lctrans_impl + (get_local $0) + (get_local $1) + ) + ) + (func $__lctrans_impl (param $0 i32) (param $1 i32) (result i32) + (block $label$0 + (br_if $label$0 + (i32.eqz + (get_local $1) + ) + ) + (return + (select + (tee_local $1 + (call $__mo_lookup + (i32.load + (get_local $1) + ) + (i32.load offset=4 + (get_local $1) + ) + (get_local $0) + ) + ) + (get_local $0) + (get_local $1) + ) + ) + ) + (select + (i32.const 0) + (get_local $0) + (i32.const 0) + ) + ) + (func $__mo_lookup (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (local $8 i32) + (local $9 i32) + (local $10 i32) + (local $11 i32) + (local $12 i32) + (local $13 i32) + (block $label$0 + (block $label$1 + (block $label$2 + (block $label$3 + (br_if $label$3 + (i32.ge_u + (tee_local $5 + (select + (tee_local $4 + (i32.load offset=8 + (get_local $0) + ) + ) + (tee_local $9 + (i32.or + (i32.or + (i32.shl + (get_local $4) + (i32.const 24) + ) + (i32.and + (i32.shl + (get_local $4) + (i32.const 8) + ) + (i32.const 16711680) + ) + ) + (i32.or + (i32.and + (i32.shr_u + (get_local $4) + (i32.const 8) + ) + (i32.const 65280) + ) + (i32.shr_u + (get_local $4) + (i32.const 24) + ) + ) + ) + ) + (tee_local $10 + (i32.eq + (tee_local $3 + (i32.load + (get_local $0) + ) + ) + (i32.const -1794895138) + ) + ) + ) + ) + (i32.shr_u + (get_local $1) + (i32.const 2) + ) + ) + ) + (br_if $label$2 + (i32.ge_u + (tee_local $6 + (select + (tee_local $11 + (i32.load offset=12 + (get_local $0) + ) + ) + (i32.or + (i32.or + (i32.shl + (get_local $11) + (i32.const 24) + ) + (i32.and + (i32.shl + (get_local $11) + (i32.const 8) + ) + (i32.const 16711680) + ) + ) + (i32.or + (i32.and + (i32.shr_u + (get_local $11) + (i32.const 8) + ) + (i32.const 65280) + ) + (i32.shr_u + (get_local $11) + (i32.const 24) + ) + ) + ) + (get_local $10) + ) + ) + (tee_local $12 + (i32.sub + (get_local $1) + (i32.shl + (get_local $5) + (i32.const 2) + ) + ) + ) + ) + ) + (br_if $label$1 + (i32.ge_u + (tee_local $10 + (select + (tee_local $11 + (i32.load offset=16 + (get_local $0) + ) + ) + (i32.or + (i32.or + (i32.shl + (get_local $11) + (i32.const 24) + ) + (i32.and + (i32.shl + (get_local $11) + (i32.const 8) + ) + (i32.const 16711680) + ) + ) + (i32.or + (i32.and + (i32.shr_u + (get_local $11) + (i32.const 8) + ) + (i32.const 65280) + ) + (i32.shr_u + (get_local $11) + (i32.const 24) + ) + ) + ) + (get_local $10) + ) + ) + (get_local $12) + ) + ) + (br_if $label$0 + (i32.eqz + (i32.and + (i32.or + (get_local $10) + (get_local $6) + ) + (i32.const 3) + ) + ) + ) + (return + (i32.const 0) + ) + ) + (return + (i32.const 0) + ) + ) + (return + (i32.const 0) + ) + ) + (return + (i32.const 0) + ) + ) + (set_local $12 + (i32.shr_u + (get_local $6) + (i32.const 2) + ) + ) + (block $label$4 + (block $label$5 + (block $label$6 + (block $label$7 + (block $label$8 + (block $label$9 + (block $label$10 + (block $label$11 + (block $label$12 + (block $label$13 + (block $label$14 + (block $label$15 + (br_if $label$15 + (i32.ne + (get_local $3) + (i32.const -1794895138) + ) + ) + (br_if $label$14 + (i32.ge_u + (tee_local $11 + (i32.load + (i32.add + (tee_local $9 + (i32.add + (get_local $0) + (i32.shl + (i32.add + (tee_local $6 + (i32.shl + (tee_local $5 + (i32.shr_u + (get_local $5) + (i32.const 1) + ) + ) + (i32.const 1) + ) + ) + (get_local $12) + ) + (i32.const 2) + ) + ) + ) + (i32.const 4) + ) + ) + ) + (get_local $1) + ) + ) + (br_if $label$13 + (i32.ge_u + (tee_local $8 + (i32.load + (get_local $9) + ) + ) + (i32.sub + (get_local $1) + (get_local $11) + ) + ) + ) + (set_local $9 + (get_local $5) + ) + (set_local $7 + (i32.const 0) + ) + (loop $label$16 + (br_if $label$8 + (i32.load8_u + (i32.add + (get_local $0) + (i32.add + (get_local $11) + (get_local $8) + ) + ) + ) + ) + (br_if $label$10 + (i32.eqz + (tee_local $11 + (call $strcmp + (get_local $2) + (i32.add + (get_local $0) + (get_local $11) + ) + ) + ) + ) + ) + (br_if $label$6 + (i32.eq + (get_local $4) + (i32.const 1) + ) + ) + (set_local $13 + (i32.const 0) + ) + (br_if $label$9 + (i32.ge_u + (tee_local $11 + (i32.load + (i32.add + (tee_local $8 + (i32.add + (get_local $0) + (i32.shl + (i32.add + (tee_local $6 + (i32.shl + (tee_local $5 + (i32.add + (tee_local $7 + (select + (get_local $7) + (get_local $5) + (tee_local $11 + (i32.lt_s + (get_local $11) + (i32.const 0) + ) + ) + ) + ) + (tee_local $9 + (i32.shr_u + (tee_local $4 + (select + (get_local $9) + (i32.sub + (get_local $4) + (get_local $9) + ) + (get_local $11) + ) + ) + (i32.const 1) + ) + ) + ) + ) + (i32.const 1) + ) + ) + (get_local $12) + ) + (i32.const 2) + ) + ) + ) + (i32.const 4) + ) + ) + ) + (get_local $1) + ) + ) + (br_if $label$16 + (i32.lt_u + (tee_local $8 + (i32.load + (get_local $8) + ) + ) + (i32.sub + (get_local $1) + (get_local $11) + ) + ) + ) + (br $label$9) + ) + ) + (br_if $label$12 + (i32.ge_u + (tee_local $4 + (i32.or + (i32.or + (i32.shl + (tee_local $4 + (i32.load + (i32.add + (tee_local $11 + (i32.add + (get_local $0) + (i32.shl + (i32.add + (tee_local $6 + (i32.shl + (tee_local $8 + (i32.shr_u + (get_local $9) + (i32.const 1) + ) + ) + (i32.const 1) + ) + ) + (get_local $12) + ) + (i32.const 2) + ) + ) + ) + (i32.const 4) + ) + ) + ) + (i32.const 24) + ) + (i32.and + (i32.shl + (get_local $4) + (i32.const 8) + ) + (i32.const 16711680) + ) + ) + (i32.or + (i32.and + (i32.shr_u + (get_local $4) + (i32.const 8) + ) + (i32.const 65280) + ) + (i32.shr_u + (get_local $4) + (i32.const 24) + ) + ) + ) + ) + (get_local $1) + ) + ) + (br_if $label$11 + (i32.ge_u + (tee_local $11 + (i32.or + (i32.or + (i32.shl + (tee_local $11 + (i32.load + (get_local $11) + ) + ) + (i32.const 24) + ) + (i32.and + (i32.shl + (get_local $11) + (i32.const 8) + ) + (i32.const 16711680) + ) + ) + (i32.or + (i32.and + (i32.shr_u + (get_local $11) + (i32.const 8) + ) + (i32.const 65280) + ) + (i32.shr_u + (get_local $11) + (i32.const 24) + ) + ) + ) + ) + (i32.sub + (get_local $1) + (get_local $4) + ) + ) + ) + (set_local $5 + (get_local $8) + ) + (set_local $7 + (i32.const 0) + ) + (loop $label$17 + (br_if $label$7 + (i32.load8_u + (i32.add + (get_local $0) + (i32.add + (get_local $4) + (get_local $11) + ) + ) + ) + ) + (br_if $label$10 + (i32.eqz + (tee_local $4 + (call $strcmp + (get_local $2) + (i32.add + (get_local $0) + (get_local $4) + ) + ) + ) + ) + ) + (br_if $label$5 + (i32.eq + (get_local $9) + (i32.const 1) + ) + ) + (set_local $13 + (i32.const 0) + ) + (br_if $label$9 + (i32.ge_u + (tee_local $4 + (i32.or + (i32.or + (i32.shl + (tee_local $4 + (i32.load + (i32.add + (tee_local $11 + (i32.add + (get_local $0) + (i32.shl + (i32.add + (tee_local $6 + (i32.shl + (tee_local $8 + (i32.add + (tee_local $7 + (select + (get_local $7) + (get_local $8) + (tee_local $4 + (i32.lt_s + (get_local $4) + (i32.const 0) + ) + ) + ) + ) + (tee_local $5 + (i32.shr_u + (tee_local $9 + (select + (get_local $5) + (i32.sub + (get_local $9) + (get_local $5) + ) + (get_local $4) + ) + ) + (i32.const 1) + ) + ) + ) + ) + (i32.const 1) + ) + ) + (get_local $12) + ) + (i32.const 2) + ) + ) + ) + (i32.const 4) + ) + ) + ) + (i32.const 24) + ) + (i32.and + (i32.shl + (get_local $4) + (i32.const 8) + ) + (i32.const 16711680) + ) + ) + (i32.or + (i32.and + (i32.shr_u + (get_local $4) + (i32.const 8) + ) + (i32.const 65280) + ) + (i32.shr_u + (get_local $4) + (i32.const 24) + ) + ) + ) + ) + (get_local $1) + ) + ) + (br_if $label$17 + (i32.lt_u + (tee_local $11 + (i32.or + (i32.or + (i32.shl + (tee_local $11 + (i32.load + (get_local $11) + ) + ) + (i32.const 24) + ) + (i32.and + (i32.shl + (get_local $11) + (i32.const 8) + ) + (i32.const 16711680) + ) + ) + (i32.or + (i32.and + (i32.shr_u + (get_local $11) + (i32.const 8) + ) + (i32.const 65280) + ) + (i32.shr_u + (get_local $11) + (i32.const 24) + ) + ) + ) + ) + (i32.sub + (get_local $1) + (get_local $4) + ) + ) + ) + (br $label$9) + ) + ) + (return + (i32.const 0) + ) + ) + (return + (i32.const 0) + ) + ) + (return + (i32.const 0) + ) + ) + (return + (i32.const 0) + ) + ) + (br_if $label$4 + (i32.ge_u + (tee_local $11 + (select + (tee_local $4 + (i32.load + (i32.add + (tee_local $10 + (i32.add + (get_local $0) + (i32.shl + (i32.add + (get_local $6) + (i32.shr_u + (get_local $10) + (i32.const 2) + ) + ) + (i32.const 2) + ) + ) + ) + (i32.const 4) + ) + ) + ) + (i32.or + (i32.or + (i32.shl + (get_local $4) + (i32.const 24) + ) + (i32.and + (i32.shl + (get_local $4) + (i32.const 8) + ) + (i32.const 16711680) + ) + ) + (i32.or + (i32.and + (i32.shr_u + (get_local $4) + (i32.const 8) + ) + (i32.const 65280) + ) + (i32.shr_u + (get_local $4) + (i32.const 24) + ) + ) + ) + (tee_local $9 + (i32.eq + (get_local $3) + (i32.const -1794895138) + ) + ) + ) + ) + (get_local $1) + ) + ) + (set_local $13 + (i32.const 0) + ) + (br_if $label$9 + (i32.ge_u + (tee_local $4 + (select + (tee_local $4 + (i32.load + (get_local $10) + ) + ) + (i32.or + (i32.or + (i32.shl + (get_local $4) + (i32.const 24) + ) + (i32.and + (i32.shl + (get_local $4) + (i32.const 8) + ) + (i32.const 16711680) + ) + ) + (i32.or + (i32.and + (i32.shr_u + (get_local $4) + (i32.const 8) + ) + (i32.const 65280) + ) + (i32.shr_u + (get_local $4) + (i32.const 24) + ) + ) + ) + (get_local $9) + ) + ) + (i32.sub + (get_local $1) + (get_local $11) + ) + ) + ) + (return + (select + (i32.const 0) + (i32.add + (get_local $0) + (get_local $11) + ) + (i32.load8_u + (i32.add + (get_local $0) + (i32.add + (get_local $11) + (get_local $4) + ) + ) + ) + ) + ) + ) + (return + (get_local $13) + ) + ) + (return + (i32.const 0) + ) + ) + (return + (i32.const 0) + ) + ) + (return + (i32.const 0) + ) + ) + (return + (i32.const 0) + ) + ) + (i32.const 0) + ) + (func $strcmp (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + (local $3 i32) + (set_local $3 + (i32.load8_u + (get_local $1) + ) + ) + (block $label$0 + (br_if $label$0 + (i32.eqz + (tee_local $2 + (i32.load8_u + (get_local $0) + ) + ) + ) + ) + (br_if $label$0 + (i32.ne + (get_local $2) + (i32.and + (get_local $3) + (i32.const 255) + ) + ) + ) + (set_local $0 + (i32.add + (get_local $0) + (i32.const 1) + ) + ) + (set_local $1 + (i32.add + (get_local $1) + (i32.const 1) + ) + ) + (loop $label$1 + (set_local $3 + (i32.load8_u + (get_local $1) + ) + ) + (br_if $label$0 + (i32.eqz + (tee_local $2 + (i32.load8_u + (get_local $0) + ) + ) + ) + ) + (set_local $0 + (i32.add + (get_local $0) + (i32.const 1) + ) + ) + (set_local $1 + (i32.add + (get_local $1) + (i32.const 1) + ) + ) + (br_if $label$1 + (i32.eq + (get_local $2) + (i32.and + (get_local $3) + (i32.const 255) + ) + ) + ) + ) + ) + (i32.sub + (get_local $2) + (i32.and + (get_local $3) + (i32.const 255) + ) + ) + ) + (func $__towrite (param $0 i32) (result i32) + (local $1 i32) + (i32.store8 offset=74 + (get_local $0) + (i32.or + (i32.add + (tee_local $1 + (i32.load8_s offset=74 + (get_local $0) + ) + ) + (i32.const 255) + ) + (get_local $1) + ) + ) + (block $label$0 + (br_if $label$0 + (i32.and + (tee_local $1 + (i32.load + (get_local $0) + ) + ) + (i32.const 8) + ) + ) + (i64.store offset=4 align=4 + (get_local $0) + (i64.const 0) + ) + (i32.store offset=28 + (get_local $0) + (tee_local $1 + (i32.load offset=44 + (get_local $0) + ) + ) + ) + (i32.store offset=20 + (get_local $0) + (get_local $1) + ) + (i32.store offset=16 + (get_local $0) + (i32.add + (get_local $1) + (i32.load offset=48 + (get_local $0) + ) + ) + ) + (return + (i32.const 0) + ) + ) + (i32.store + (get_local $0) + (i32.or + (get_local $1) + (i32.const 32) + ) + ) + (i32.const -1) + ) + (func $memcmp (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (set_local $5 + (i32.const 0) + ) + (block $label$0 + (br_if $label$0 + (i32.eqz + (get_local $2) + ) + ) + (block $label$1 + (loop $label$2 + (br_if $label$1 + (i32.ne + (tee_local $3 + (i32.load8_u + (get_local $0) + ) + ) + (tee_local $4 + (i32.load8_u + (get_local $1) + ) + ) + ) + ) + (set_local $1 + (i32.add + (get_local $1) + (i32.const 1) + ) + ) + (set_local $0 + (i32.add + (get_local $0) + (i32.const 1) + ) + ) + (br_if $label$2 + (tee_local $2 + (i32.add + (get_local $2) + (i32.const -1) + ) + ) + ) + (br $label$0) + ) + ) + (set_local $5 + (i32.sub + (get_local $3) + (get_local $4) + ) + ) + ) + (get_local $5) + ) + (func $strlen (param $0 i32) (result i32) + (local $1 i32) + (local $2 i32) + (set_local $2 + (get_local $0) + ) + (block $label$0 + (block $label$1 + (br_if $label$1 + (i32.eqz + (i32.and + (get_local $0) + (i32.const 3) + ) + ) + ) + (set_local $2 + (get_local $0) + ) + (loop $label$2 + (br_if $label$0 + (i32.eqz + (i32.load8_u + (get_local $2) + ) + ) + ) + (br_if $label$2 + (i32.and + (tee_local $2 + (i32.add + (get_local $2) + (i32.const 1) + ) + ) + (i32.const 3) + ) + ) + ) + ) + (set_local $2 + (i32.add + (get_local $2) + (i32.const -4) + ) + ) + (loop $label$3 + (br_if $label$3 + (i32.eqz + (i32.and + (i32.and + (i32.xor + (tee_local $1 + (i32.load + (tee_local $2 + (i32.add + (get_local $2) + (i32.const 4) + ) + ) + ) + ) + (i32.const -1) + ) + (i32.add + (get_local $1) + (i32.const -16843009) + ) + ) + (i32.const -2139062144) + ) + ) + ) + ) + (br_if $label$0 + (i32.eqz + (i32.and + (get_local $1) + (i32.const 255) + ) + ) + ) + (loop $label$4 + (br_if $label$4 + (i32.load8_u + (tee_local $2 + (i32.add + (get_local $2) + (i32.const 1) + ) + ) + ) + ) + ) + ) + (i32.sub + (get_local $2) + (get_local $0) + ) + ) + (func $__wasm_nullptr (type $FUNCSIG$v) + (unreachable) + ) +) diff --git a/lottery/token.abi b/lottery/token.abi new file mode 100644 index 0000000..c7089c1 --- /dev/null +++ b/lottery/token.abi @@ -0,0 +1,171 @@ +{ + "____comment": "This file was generated by eosio-abigen. DO NOT EDIT - 2018-11-09T04:27:00", + "version": "eosio::abi/1.0", + "types": [{ + "new_type_name": "symbol_name", + "type": "uint64" + } + ], + "structs": [{ + "name": "account", + "base": "", + "fields": [{ + "name": "balance", + "type": "asset" + } + ] + },{ + "name": "currency_stat", + "base": "", + "fields": [{ + "name": "supply", + "type": "asset" + },{ + "name": "max_supply", + "type": "asset" + },{ + "name": "issuer", + "type": "name" + } + ] + },{ + "name": "detail", + "base": "", + "fields": [{ + "name": "sym", + "type": "symbol_name" + },{ + "name": "age", + "type": "uint64" + } + ] + },{ + "name": "create", + "base": "", + "fields": [{ + "name": "issuer", + "type": "name" + },{ + "name": "maximum_supply", + "type": "asset" + } + ] + },{ + "name": "issue", + "base": "", + "fields": [{ + "name": "to", + "type": "name" + },{ + "name": "quantity", + "type": "asset" + },{ + "name": "memo", + "type": "string" + } + ] + },{ + "name": "transfer", + "base": "", + "fields": [{ + "name": "from", + "type": "name" + },{ + "name": "to", + "type": "name" + },{ + "name": "quantity", + "type": "asset" + },{ + "name": "memo", + "type": "string" + } + ] + },{ + "name": "reclaim", + "base": "", + "fields": [{ + "name": "owner", + "type": "name" + },{ + "name": "quantity", + "type": "asset" + },{ + "name": "memo", + "type": "string" + } + ] + },{ + "name": "updateage", + "base": "", + "fields": [{ + "name": "act", + "type": "name" + },{ + "name": "quantity", + "type": "asset" + },{ + "name": "time", + "type": "uint64" + } + ] + } + ], + "actions": [{ + "name": "create", + "type": "create", + "ricardian_contract": "" + },{ + "name": "issue", + "type": "issue", + "ricardian_contract": "" + },{ + "name": "transfer", + "type": "transfer", + "ricardian_contract": "" + },{ + "name": "reclaim", + "type": "reclaim", + "ricardian_contract": "" + },{ + "name": "updateage", + "type": "updateage", + "ricardian_contract": "" + } + ], + "tables": [{ + "name": "accounts", + "index_type": "i64", + "key_names": [ + "balance" + ], + "key_types": [ + "asset" + ], + "type": "account" + },{ + "name": "stat", + "index_type": "i64", + "key_names": [ + "supply" + ], + "key_types": [ + "asset" + ], + "type": "currency_stat" + },{ + "name": "details", + "index_type": "i64", + "key_names": [ + "sym" + ], + "key_types": [ + "symbol_name" + ], + "type": "detail" + } + ], + "ricardian_clauses": [], + "error_messages": [], + "abi_extensions": [] +} \ No newline at end of file diff --git a/lottery/token.cpp b/lottery/token.cpp new file mode 100644 index 0000000..48c8192 --- /dev/null +++ b/lottery/token.cpp @@ -0,0 +1,166 @@ +/** + * @file + * @copyright defined in eos/LICENSE.txt + */ + +#include "token.hpp" + +namespace eosio { + +void token::create( account_name issuer, + asset maximum_supply ) +{ + require_auth( _self ); + + auto sym = maximum_supply.symbol; + eosio_assert( sym.is_valid(), "invalid symbol name" ); + eosio_assert( maximum_supply.is_valid(), "invalid supply"); + eosio_assert( maximum_supply.amount > 0, "max-supply must be positive"); + + stats statstable( _self, sym.name() ); + auto existing = statstable.find( sym.name() ); + eosio_assert( existing == statstable.end(), "token with symbol already exists" ); + + statstable.emplace( _self, [&]( auto& s ) { + s.supply.symbol = maximum_supply.symbol; + s.max_supply = maximum_supply; + s.issuer = issuer; + }); +} + +void token::issue( account_name to, asset quantity, string memo ) +{ + auto sym = quantity.symbol; + eosio_assert( sym.is_valid(), "invalid symbol name" ); + eosio_assert( memo.size() <= 256, "memo has more than 256 bytes" ); + + auto sym_name = sym.name(); + stats statstable( _self, sym_name ); + auto existing = statstable.find( sym_name ); + eosio_assert( existing != statstable.end(), "token with symbol does not exist, create token before issue" ); + const auto& st = *existing; + + require_auth( st.issuer ); + eosio_assert( quantity.is_valid(), "invalid quantity" ); + eosio_assert( quantity.amount > 0, "must issue positive quantity" ); + + eosio_assert( quantity.symbol == st.supply.symbol, "symbol precision mismatch" ); + eosio_assert( quantity.amount <= st.max_supply.amount - st.supply.amount, "quantity exceeds available supply"); + + statstable.modify( st, 0, [&]( auto& s ) { + s.supply += quantity; + }); + + add_balance( st.issuer, quantity, st.issuer ); + + if( to != st.issuer ) { + SEND_INLINE_ACTION( *this, transfer, {st.issuer,N(active)}, {st.issuer, to, quantity, memo} ); + } +} + +void token::transfer( account_name from, + account_name to, + asset quantity, + string memo ) +{ + eosio_assert( from != to, "cannot transfer to self" ); + require_auth( from ); + eosio_assert( is_account( to ), "to account does not exist"); + auto sym = quantity.symbol.name(); + stats statstable( _self, sym ); + const auto& st = statstable.get( sym ); + + require_recipient( from ); + require_recipient( to ); + + eosio_assert( quantity.is_valid(), "invalid quantity" ); + eosio_assert( quantity.amount > 0, "must transfer positive quantity" ); + eosio_assert( quantity.symbol == st.supply.symbol, "symbol precision mismatch" ); + eosio_assert( memo.size() <= 256, "memo has more than 256 bytes" ); + + auto ct = current_time(); + + if (to != DICE_ACCOUNT) { + auto age = get_age(from, sym); + eosio_assert(ct > age + useconds_claim_token_bonus_interval, "claim token bonus time has not cool down yet"); + } + + sub_balance( from, quantity ); + add_balance( to, quantity, from ); +} + +void token::reclaim(account_name owner, asset quantity, string memo) { + require_auth(_self); + auto sym = quantity.symbol.name(); + stats statstable( _self, sym ); + const auto& st = statstable.get( sym ); + + require_recipient( _self ); + require_recipient( owner ); + + eosio_assert( quantity.is_valid(), "invalid quantity" ); + eosio_assert( quantity.amount > 0, "must transfer positive quantity" ); + eosio_assert( quantity.symbol == st.supply.symbol, "symbol precision mismatch" ); + eosio_assert( memo.size() <= 256, "memo has more than 256 bytes" ); + + sub_balance( owner, quantity ); + add_balance( _self, quantity, owner ); +} + +void token::updateage( account_name act, asset quantity, uint64_t time = 0 ) { + require_auth(_self); + + accounts acnts( _self, act ); + auto sym_pos = acnts.find(quantity.symbol.name()); + eosio_assert(sym_pos != acnts.end(), "no balance object found"); + + auto ct = time <= 0 ? current_time() : time; + + details d(_self, act); + auto pos = d.find(quantity.symbol.name()); + if (pos != d.end()) { + d.modify(pos, 0, [&](detail& info) { + info.age = ct; + }); + } else { + d.emplace(_self, [&](detail& info) { + info.sym = quantity.symbol.name(); + info.age = ct; + }); + } +} + +void token::sub_balance( account_name owner, asset value ) { + accounts from_acnts( _self, owner ); + + const auto& from = from_acnts.get( value.symbol.name(), "no balance object found" ); + eosio_assert( from.balance.amount >= value.amount, "overdrawn balance" ); + + + if( from.balance.amount == value.amount ) { + from_acnts.erase( from ); + } else { + from_acnts.modify( from, 0, [&]( auto& a ) { + a.balance -= value; + }); + } +} + +void token::add_balance( account_name owner, asset value, account_name ram_payer ) +{ + accounts to_acnts( _self, owner ); + auto to = to_acnts.find( value.symbol.name() ); + if( to == to_acnts.end() ) { + to_acnts.emplace( ram_payer, [&]( auto& a ){ + a.balance = value; + }); + } else { + to_acnts.modify( to, 0, [&]( auto& a ) { + a.balance += value; + }); + } +} + +} /// namespace eosio + +EOSIO_ABI( eosio::token, (create)(issue)(transfer)(updateage)(reclaim) ) diff --git a/lottery/token.hpp b/lottery/token.hpp new file mode 100644 index 0000000..05fd554 --- /dev/null +++ b/lottery/token.hpp @@ -0,0 +1,136 @@ +/** + * @file + * @copyright defined in eos/LICENSE.txt + */ +#pragma once + +#include +#include + +#include + +#define DICE_ACCOUNT N(eosluckydice) + +namespace eosiosystem { + class system_contract; +} + +namespace eosio { + + using std::string; + + class token : public contract { + public: + token( account_name self ):contract(self){} + + void create( account_name issuer, + asset maximum_supply); + + void issue( account_name to, asset quantity, string memo ); + + void transfer( account_name from, + account_name to, + asset quantity, + string memo ); + + void reclaim(account_name owner, asset quantity, string memo); + + void updateage( account_name act, asset quantity, uint64_t time ); + + inline asset get_supply( symbol_name sym )const; + + inline asset get_max_supply( symbol_name sym )const; + + inline asset get_balance( account_name owner, symbol_name sym )const; + + inline uint64_t get_balance_amount( account_name owner, symbol_name sym )const; + + inline uint64_t get_age(account_name owner, symbol_name sym)const; + + private: + const uint64_t useconds_claim_token_bonus_interval = 24*3600*uint64_t(1000000); + + ///@abi table accounts i64 + struct account { + asset balance; + + uint64_t primary_key()const { return balance.symbol.name(); } + }; + + ///@abi table stat i64 + struct currency_stat { + asset supply; + asset max_supply; + account_name issuer; + + uint64_t primary_key()const { return supply.symbol.name(); } + }; + + ///@abi table details i64 + struct detail { + symbol_name sym; + uint64_t age; + + uint64_t primary_key()const { return sym; } + }; + + typedef eosio::multi_index accounts; + typedef eosio::multi_index stats; + typedef eosio::multi_index details; + + void sub_balance( account_name owner, asset value ); + void add_balance( account_name owner, asset value, account_name ram_payer ); + + public: + struct transfer_args { + account_name from; + account_name to; + asset quantity; + string memo; + }; + }; + + asset token::get_supply( symbol_name sym )const + { + stats statstable( _self, sym ); + const auto& st = statstable.get( sym ); + return st.supply; + } + + asset token::get_max_supply( symbol_name sym )const + { + stats statstable( _self, sym ); + const auto& st = statstable.get( sym ); + return st.max_supply; + } + + asset token::get_balance( account_name owner, symbol_name sym )const + { + accounts accountstable( _self, owner ); + const auto& ac = accountstable.get( sym ); + return ac.balance; + } + + uint64_t token::get_balance_amount( account_name owner, symbol_name sym )const + { + accounts accountstable( _self, owner ); + const auto& ac = accountstable.find( sym ); + if (ac == accountstable.cend()) { + return 0; + } + + return (ac->balance).amount; + } + + uint64_t token::get_age(account_name owner, symbol_name sym)const + { + details ds(_self, owner); + const auto pos = ds.find( sym ); + if (pos != ds.end()) { + return pos->age; + } else { + return 0; + } + } + +} /// namespace eosio diff --git a/lottery/token.wasm b/lottery/token.wasm new file mode 100644 index 0000000000000000000000000000000000000000..14d21258b05efa7336e19735b2ae6cdf04e9c2d3 GIT binary patch literal 22951 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 literal 0 HcmV?d00001 diff --git a/lottery/token.wast b/lottery/token.wast new file mode 100644 index 0000000..1fe42a7 --- /dev/null +++ b/lottery/token.wast @@ -0,0 +1,14960 @@ +(module + (type $FUNCSIG$viji (func (param i32 i64 i32))) + (type $FUNCSIG$vijij (func (param i32 i64 i32 i64))) + (type $FUNCSIG$vijjii (func (param i32 i64 i64 i32 i32))) + (type $FUNCSIG$vijii (func (param i32 i64 i32 i32))) + (type $FUNCSIG$v (func)) + (type $FUNCSIG$j (func (result i64))) + (type $FUNCSIG$vjj (func (param i64 i64))) + (type $FUNCSIG$vj (func (param i64))) + (type $FUNCSIG$vii (func (param i32 i32))) + (type $FUNCSIG$ijjjj (func (param i64 i64 i64 i64) (result i32))) + (type $FUNCSIG$ijjjjii (func (param i64 i64 i64 i64 i32 i32) (result i32))) + (type $FUNCSIG$iiii (func (param i32 i32 i32) (result i32))) + (type $FUNCSIG$ij (func (param i64) (result i32))) + (type $FUNCSIG$vi (func (param i32))) + (type $FUNCSIG$i (func (result i32))) + (type $FUNCSIG$iii (func (param i32 i32) (result i32))) + (import "env" "abort" (func $abort)) + (import "env" "action_data_size" (func $action_data_size (result i32))) + (import "env" "current_receiver" (func $current_receiver (result i64))) + (import "env" "current_time" (func $current_time (result i64))) + (import "env" "db_find_i64" (func $db_find_i64 (param i64 i64 i64 i64) (result i32))) + (import "env" "db_get_i64" (func $db_get_i64 (param i32 i32 i32) (result i32))) + (import "env" "db_remove_i64" (func $db_remove_i64 (param i32))) + (import "env" "db_store_i64" (func $db_store_i64 (param i64 i64 i64 i64 i32 i32) (result i32))) + (import "env" "db_update_i64" (func $db_update_i64 (param i32 i64 i32 i32))) + (import "env" "eosio_assert" (func $eosio_assert (param i32 i32))) + (import "env" "is_account" (func $is_account (param i64) (result i32))) + (import "env" "memcpy" (func $memcpy (param i32 i32 i32) (result i32))) + (import "env" "read_action_data" (func $read_action_data (param i32 i32) (result i32))) + (import "env" "require_auth" (func $require_auth (param i64))) + (import "env" "require_auth2" (func $require_auth2 (param i64 i64))) + (import "env" "require_recipient" (func $require_recipient (param i64))) + (import "env" "send_inline" (func $send_inline (param i32 i32))) + (table 6 6 anyfunc) + (elem (i32.const 0) $__wasm_nullptr $_ZN5eosio5token6createEyNS_5assetE $_ZN5eosio5token8transferEyyNS_5assetENSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE $_ZN5eosio5token9updateageEyNS_5assetEy $_ZN5eosio5token5issueEyNS_5assetENSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE $_ZN5eosio5token7reclaimEyNS_5assetENSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE) + (memory $0 1) + (data (i32.const 4) "\90g\00\00") + (data (i32.const 16) "invalid symbol name\00") + (data (i32.const 48) "invalid supply\00") + (data (i32.const 64) "max-supply must be positive\00") + (data (i32.const 96) "object passed to iterator_to is not in multi_index\00") + (data (i32.const 160) "token with symbol already exists\00") + (data (i32.const 208) "cannot create objects in table of another contract\00") + (data (i32.const 272) "write\00") + (data (i32.const 288) "magnitude of asset amount must be less than 2^62\00") + (data (i32.const 352) "error reading iterator\00") + (data (i32.const 384) "read\00") + (data (i32.const 400) "memo has more than 256 bytes\00") + (data (i32.const 432) "token with symbol does not exist, create token before issue\00") + (data (i32.const 496) "invalid quantity\00") + (data (i32.const 528) "must issue positive quantity\00") + (data (i32.const 560) "symbol precision mismatch\00") + (data (i32.const 592) "quantity exceeds available supply\00") + (data (i32.const 640) "object passed to modify is not in multi_index\00") + (data (i32.const 688) "cannot modify objects in table of another contract\00") + (data (i32.const 752) "attempt to add asset with different symbol\00") + (data (i32.const 800) "addition underflow\00") + (data (i32.const 832) "addition overflow\00") + (data (i32.const 864) "updater cannot change primary key when modifying an object\00") + (data (i32.const 928) "active\00") + (data (i32.const 944) "cannot pass end iterator to modify\00") + (data (i32.const 992) "cannot transfer to self\00") + (data (i32.const 1024) "to account does not exist\00") + (data (i32.const 1056) "unable to find key\00") + (data (i32.const 1088) "must transfer positive quantity\00") + (data (i32.const 1120) "eosluckydice\00") + (data (i32.const 1136) "claim token bonus time has not cool down yet\00") + (data (i32.const 1184) "no balance object found\00") + (data (i32.const 1216) "overdrawn balance\00") + (data (i32.const 1248) "attempt to subtract asset with different symbol\00") + (data (i32.const 1296) "subtraction underflow\00") + (data (i32.const 1328) "subtraction overflow\00") + (data (i32.const 1360) "object passed to erase is not in multi_index\00") + (data (i32.const 1408) "cannot erase objects in table of another contract\00") + (data (i32.const 1472) "attempt to remove object that was not in multi_index\00") + (data (i32.const 1536) "onerror\00") + (data (i32.const 1552) "eosio\00") + (data (i32.const 1568) "onerror action\'s are only valid from the \"eosio\" system account\00") + (data (i32.const 1632) "get\00") + (data (i32.const 10032) "malloc_from_freed was designed to only be called after _heap was completely allocated\00") + (export "memory" (memory $0)) + (export "_ZeqRK11checksum256S1_" (func $_ZeqRK11checksum256S1_)) + (export "_ZeqRK11checksum160S1_" (func $_ZeqRK11checksum160S1_)) + (export "_ZneRK11checksum160S1_" (func $_ZneRK11checksum160S1_)) + (export "now" (func $now)) + (export "_ZN5eosio12require_authERKNS_16permission_levelE" (func $_ZN5eosio12require_authERKNS_16permission_levelE)) + (export "_ZN5eosio5token6createEyNS_5assetE" (func $_ZN5eosio5token6createEyNS_5assetE)) + (export "_ZN5eosio5token5issueEyNS_5assetENSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE" (func $_ZN5eosio5token5issueEyNS_5assetENSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE)) + (export "_ZN5eosio5token11add_balanceEyNS_5assetEy" (func $_ZN5eosio5token11add_balanceEyNS_5assetEy)) + (export "_ZN5eosio5token8transferEyyNS_5assetENSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE" (func $_ZN5eosio5token8transferEyyNS_5assetENSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE)) + (export "_ZN5eosio5token11sub_balanceEyNS_5assetE" (func $_ZN5eosio5token11sub_balanceEyNS_5assetE)) + (export "_ZN5eosio5token7reclaimEyNS_5assetENSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE" (func $_ZN5eosio5token7reclaimEyNS_5assetENSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE)) + (export "_ZN5eosio5token9updateageEyNS_5assetEy" (func $_ZN5eosio5token9updateageEyNS_5assetEy)) + (export "apply" (func $apply)) + (export "malloc" (func $malloc)) + (export "free" (func $free)) + (export "memcmp" (func $memcmp)) + (func $_ZeqRK11checksum256S1_ (param $0 i32) (param $1 i32) (result i32) + (i32.eqz + (call $memcmp + (get_local $0) + (get_local $1) + (i32.const 32) + ) + ) + ) + (func $_ZeqRK11checksum160S1_ (param $0 i32) (param $1 i32) (result i32) + (i32.eqz + (call $memcmp + (get_local $0) + (get_local $1) + (i32.const 32) + ) + ) + ) + (func $_ZneRK11checksum160S1_ (param $0 i32) (param $1 i32) (result i32) + (i32.ne + (call $memcmp + (get_local $0) + (get_local $1) + (i32.const 32) + ) + (i32.const 0) + ) + ) + (func $now (result i32) + (i32.wrap/i64 + (i64.div_u + (call $current_time) + (i64.const 1000000) + ) + ) + ) + (func $_ZN5eosio12require_authERKNS_16permission_levelE (param $0 i32) + (call $require_auth2 + (i64.load + (get_local $0) + ) + (i64.load offset=8 + (get_local $0) + ) + ) + ) + (func $_ZN5eosio5token6createEyNS_5assetE (type $FUNCSIG$viji) (param $0 i32) (param $1 i64) (param $2 i32) + (local $3 i64) + (local $4 i64) + (local $5 i64) + (local $6 i32) + (local $7 i64) + (local $8 i32) + (local $9 i32) + (i32.store offset=4 + (i32.const 0) + (tee_local $9 + (i32.sub + (i32.load offset=4 + (i32.const 0) + ) + (i32.const 128) + ) + ) + ) + (call $require_auth + (i64.load + (get_local $0) + ) + ) + (set_local $8 + (i32.const 0) + ) + (set_local $7 + (tee_local $4 + (i64.shr_u + (tee_local $3 + (i64.load offset=8 + (get_local $2) + ) + ) + (i64.const 8) + ) + ) + ) + (block $label$0 + (block $label$1 + (loop $label$2 + (br_if $label$1 + (i32.gt_u + (i32.add + (i32.shl + (i32.wrap/i64 + (get_local $7) + ) + (i32.const 24) + ) + (i32.const -1073741825) + ) + (i32.const 452984830) + ) + ) + (block $label$3 + (br_if $label$3 + (i64.ne + (i64.and + (tee_local $7 + (i64.shr_u + (get_local $7) + (i64.const 8) + ) + ) + (i64.const 255) + ) + (i64.const 0) + ) + ) + (loop $label$4 + (br_if $label$1 + (i64.ne + (i64.and + (tee_local $7 + (i64.shr_u + (get_local $7) + (i64.const 8) + ) + ) + (i64.const 255) + ) + (i64.const 0) + ) + ) + (br_if $label$4 + (i32.lt_s + (tee_local $8 + (i32.add + (get_local $8) + (i32.const 1) + ) + ) + (i32.const 7) + ) + ) + ) + ) + (set_local $6 + (i32.const 1) + ) + (br_if $label$2 + (i32.lt_s + (tee_local $8 + (i32.add + (get_local $8) + (i32.const 1) + ) + ) + (i32.const 7) + ) + ) + (br $label$0) + ) + ) + (set_local $6 + (i32.const 0) + ) + ) + (call $eosio_assert + (get_local $6) + (i32.const 16) + ) + (set_local $6 + (i32.const 0) + ) + (block $label$5 + (br_if $label$5 + (i64.gt_u + (i64.add + (tee_local $5 + (i64.load + (get_local $2) + ) + ) + (i64.const 4611686018427387903) + ) + (i64.const 9223372036854775806) + ) + ) + (set_local $8 + (i32.const 0) + ) + (set_local $7 + (get_local $4) + ) + (block $label$6 + (loop $label$7 + (br_if $label$6 + (i32.gt_u + (i32.add + (i32.shl + (i32.wrap/i64 + (get_local $7) + ) + (i32.const 24) + ) + (i32.const -1073741825) + ) + (i32.const 452984830) + ) + ) + (block $label$8 + (br_if $label$8 + (i64.ne + (i64.and + (tee_local $7 + (i64.shr_u + (get_local $7) + (i64.const 8) + ) + ) + (i64.const 255) + ) + (i64.const 0) + ) + ) + (loop $label$9 + (br_if $label$6 + (i64.ne + (i64.and + (tee_local $7 + (i64.shr_u + (get_local $7) + (i64.const 8) + ) + ) + (i64.const 255) + ) + (i64.const 0) + ) + ) + (br_if $label$9 + (i32.lt_s + (tee_local $8 + (i32.add + (get_local $8) + (i32.const 1) + ) + ) + (i32.const 7) + ) + ) + ) + ) + (set_local $6 + (i32.const 1) + ) + (br_if $label$7 + (i32.lt_s + (tee_local $8 + (i32.add + (get_local $8) + (i32.const 1) + ) + ) + (i32.const 7) + ) + ) + (br $label$5) + ) + ) + (set_local $6 + (i32.const 0) + ) + ) + (call $eosio_assert + (get_local $6) + (i32.const 48) + ) + (call $eosio_assert + (i64.gt_s + (get_local $5) + (i64.const 0) + ) + (i32.const 64) + ) + (i32.store + (i32.add + (i32.add + (get_local $9) + (i32.const 8) + ) + (i32.const 32) + ) + (i32.const 0) + ) + (i64.store offset=24 + (get_local $9) + (i64.const -1) + ) + (i64.store offset=32 + (get_local $9) + (i64.const 0) + ) + (i64.store offset=8 + (get_local $9) + (tee_local $7 + (i64.load + (get_local $0) + ) + ) + ) + (i64.store offset=16 + (get_local $9) + (get_local $4) + ) + (block $label$10 + (block $label$11 + (br_if $label$11 + (i32.lt_s + (tee_local $8 + (call $db_find_i64 + (get_local $7) + (get_local $4) + (i64.const -4157508551318700032) + (get_local $4) + ) + ) + (i32.const 0) + ) + ) + (call $eosio_assert + (i32.eq + (i32.load offset=40 + (call $_ZNK5eosio11multi_indexILy14289235522390851584ENS_5token13currency_statEJEE31load_object_by_primary_iteratorEl + (i32.add + (get_local $9) + (i32.const 8) + ) + (get_local $8) + ) + ) + (i32.add + (get_local $9) + (i32.const 8) + ) + ) + (i32.const 96) + ) + (set_local $8 + (i32.const 0) + ) + (br $label$10) + ) + (set_local $8 + (i32.const 1) + ) + ) + (call $eosio_assert + (get_local $8) + (i32.const 160) + ) + (set_local $4 + (i64.load + (get_local $0) + ) + ) + (call $eosio_assert + (i64.eq + (i64.load offset=8 + (get_local $9) + ) + (call $current_receiver) + ) + (i32.const 208) + ) + (drop + (call $_ZN5eosio5token13currency_statC2Ev + (tee_local $8 + (call $_Znwj + (i32.const 56) + ) + ) + ) + ) + (i32.store offset=40 + (get_local $8) + (i32.add + (get_local $9) + (i32.const 8) + ) + ) + (i64.store offset=8 + (get_local $8) + (get_local $3) + ) + (i32.store + (i32.add + (get_local $8) + (i32.const 28) + ) + (i32.load + (i32.add + (get_local $2) + (i32.const 12) + ) + ) + ) + (i32.store + (i32.add + (get_local $8) + (i32.const 24) + ) + (i32.load + (i32.add + (get_local $2) + (i32.const 8) + ) + ) + ) + (i32.store + (i32.add + (get_local $8) + (i32.const 20) + ) + (i32.load + (i32.add + (get_local $2) + (i32.const 4) + ) + ) + ) + (i32.store offset=16 + (get_local $8) + (i32.load + (get_local $2) + ) + ) + (i64.store offset=32 + (get_local $8) + (get_local $1) + ) + (i32.store offset=96 + (get_local $9) + (i32.add + (i32.add + (get_local $9) + (i32.const 48) + ) + (i32.const 40) + ) + ) + (i32.store offset=92 + (get_local $9) + (i32.add + (get_local $9) + (i32.const 48) + ) + ) + (i32.store offset=88 + (get_local $9) + (i32.add + (get_local $9) + (i32.const 48) + ) + ) + (i32.store offset=104 + (get_local $9) + (i32.add + (get_local $9) + (i32.const 88) + ) + ) + (i32.store offset=116 + (get_local $9) + (i32.add + (get_local $8) + (i32.const 16) + ) + ) + (i32.store offset=112 + (get_local $9) + (get_local $8) + ) + (i32.store offset=120 + (get_local $9) + (i32.add + (get_local $8) + (i32.const 32) + ) + ) + (call $_ZN5boost3pfr6detail19for_each_field_implINS1_14sequence_tuple5tupleIJRKN5eosio5assetES8_RKyEEEZNS5_lsINS5_10datastreamIPcEENS5_5token13currency_statELPv0EEERT_SK_RKT0_EUlRKSJ_E_JLj0ELj1ELj2EEEEvSK_OSL_NSt3__116integer_sequenceIjJXspT1_EEEENSS_17integral_constantIbLb0EEE + (i32.add + (get_local $9) + (i32.const 112) + ) + (i32.add + (get_local $9) + (i32.const 104) + ) + ) + (i32.store offset=44 + (get_local $8) + (tee_local $6 + (call $db_store_i64 + (i64.load + (i32.add + (i32.add + (get_local $9) + (i32.const 8) + ) + (i32.const 8) + ) + ) + (i64.const -4157508551318700032) + (get_local $4) + (tee_local $7 + (i64.shr_u + (i64.load offset=8 + (get_local $8) + ) + (i64.const 8) + ) + ) + (i32.add + (get_local $9) + (i32.const 48) + ) + (i32.const 40) + ) + ) + ) + (block $label$12 + (br_if $label$12 + (i64.lt_u + (get_local $7) + (i64.load + (tee_local $2 + (i32.add + (i32.add + (get_local $9) + (i32.const 8) + ) + (i32.const 16) + ) + ) + ) + ) + ) + (i64.store + (get_local $2) + (i64.add + (get_local $7) + (i64.const 1) + ) + ) + ) + (i32.store offset=112 + (get_local $9) + (get_local $8) + ) + (i64.store offset=48 + (get_local $9) + (tee_local $7 + (i64.shr_u + (i64.load + (i32.add + (get_local $8) + (i32.const 8) + ) + ) + (i64.const 8) + ) + ) + ) + (i32.store offset=88 + (get_local $9) + (get_local $6) + ) + (block $label$13 + (block $label$14 + (br_if $label$14 + (i32.ge_u + (tee_local $2 + (i32.load + (i32.add + (i32.add + (get_local $9) + (i32.const 8) + ) + (i32.const 28) + ) + ) + ) + (i32.load + (i32.add + (get_local $9) + (i32.const 40) + ) + ) + ) + ) + (i64.store offset=8 + (get_local $2) + (get_local $7) + ) + (i32.store offset=16 + (get_local $2) + (get_local $6) + ) + (i32.store offset=112 + (get_local $9) + (i32.const 0) + ) + (i32.store + (get_local $2) + (get_local $8) + ) + (i32.store + (i32.add + (get_local $9) + (i32.const 36) + ) + (i32.add + (get_local $2) + (i32.const 24) + ) + ) + (br $label$13) + ) + (call $_ZNSt3__16vectorIN5eosio11multi_indexILy14289235522390851584ENS1_5token13currency_statEJEE8item_ptrENS_9allocatorIS6_EEE24__emplace_back_slow_pathIJNS_10unique_ptrINS5_4itemENS_14default_deleteISC_EEEERyRlEEEvDpOT_ + (i32.add + (get_local $9) + (i32.const 32) + ) + (i32.add + (get_local $9) + (i32.const 112) + ) + (i32.add + (get_local $9) + (i32.const 48) + ) + (i32.add + (get_local $9) + (i32.const 88) + ) + ) + ) + (set_local $8 + (i32.load offset=112 + (get_local $9) + ) + ) + (i32.store offset=112 + (get_local $9) + (i32.const 0) + ) + (block $label$15 + (br_if $label$15 + (i32.eqz + (get_local $8) + ) + ) + (call $_ZdlPv + (get_local $8) + ) + ) + (block $label$16 + (br_if $label$16 + (i32.eqz + (tee_local $6 + (i32.load offset=32 + (get_local $9) + ) + ) + ) + ) + (block $label$17 + (block $label$18 + (br_if $label$18 + (i32.eq + (tee_local $8 + (i32.load + (tee_local $0 + (i32.add + (get_local $9) + (i32.const 36) + ) + ) + ) + ) + (get_local $6) + ) + ) + (loop $label$19 + (set_local $2 + (i32.load + (tee_local $8 + (i32.add + (get_local $8) + (i32.const -24) + ) + ) + ) + ) + (i32.store + (get_local $8) + (i32.const 0) + ) + (block $label$20 + (br_if $label$20 + (i32.eqz + (get_local $2) + ) + ) + (call $_ZdlPv + (get_local $2) + ) + ) + (br_if $label$19 + (i32.ne + (get_local $6) + (get_local $8) + ) + ) + ) + (set_local $8 + (i32.load + (i32.add + (get_local $9) + (i32.const 32) + ) + ) + ) + (br $label$17) + ) + (set_local $8 + (get_local $6) + ) + ) + (i32.store + (get_local $0) + (get_local $6) + ) + (call $_ZdlPv + (get_local $8) + ) + ) + (i32.store offset=4 + (i32.const 0) + (i32.add + (get_local $9) + (i32.const 128) + ) + ) + ) + (func $_ZNK5eosio11multi_indexILy14289235522390851584ENS_5token13currency_statEJEE31load_object_by_primary_iteratorEl (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 i64) + (local $6 i32) + (local $7 i32) + (local $8 i32) + (local $9 i32) + (set_local $8 + (tee_local $9 + (i32.sub + (i32.load offset=4 + (i32.const 0) + ) + (i32.const 48) + ) + ) + ) + (i32.store offset=4 + (i32.const 0) + (get_local $9) + ) + (block $label$0 + (br_if $label$0 + (i32.eq + (tee_local $7 + (i32.load + (i32.add + (get_local $0) + (i32.const 28) + ) + ) + ) + (tee_local $2 + (i32.load offset=24 + (get_local $0) + ) + ) + ) + ) + (set_local $3 + (i32.sub + (i32.const 0) + (get_local $2) + ) + ) + (set_local $6 + (i32.add + (get_local $7) + (i32.const -24) + ) + ) + (loop $label$1 + (br_if $label$0 + (i32.eq + (i32.load + (i32.add + (get_local $6) + (i32.const 16) + ) + ) + (get_local $1) + ) + ) + (set_local $7 + (get_local $6) + ) + (set_local $6 + (tee_local $4 + (i32.add + (get_local $6) + (i32.const -24) + ) + ) + ) + (br_if $label$1 + (i32.ne + (i32.add + (get_local $4) + (get_local $3) + ) + (i32.const -24) + ) + ) + ) + ) + (block $label$2 + (block $label$3 + (br_if $label$3 + (i32.eq + (get_local $7) + (get_local $2) + ) + ) + (set_local $6 + (i32.load + (i32.add + (get_local $7) + (i32.const -24) + ) + ) + ) + (br $label$2) + ) + (call $eosio_assert + (i32.xor + (i32.shr_u + (tee_local $6 + (call $db_get_i64 + (get_local $1) + (i32.const 0) + (i32.const 0) + ) + ) + (i32.const 31) + ) + (i32.const 1) + ) + (i32.const 352) + ) + (block $label$4 + (block $label$5 + (br_if $label$5 + (i32.lt_u + (get_local $6) + (i32.const 513) + ) + ) + (set_local $4 + (call $malloc + (get_local $6) + ) + ) + (br $label$4) + ) + (i32.store offset=4 + (i32.const 0) + (tee_local $4 + (i32.sub + (get_local $9) + (i32.and + (i32.add + (get_local $6) + (i32.const 15) + ) + (i32.const -16) + ) + ) + ) + ) + ) + (drop + (call $db_get_i64 + (get_local $1) + (get_local $4) + (get_local $6) + ) + ) + (i32.store offset=12 + (get_local $8) + (get_local $4) + ) + (i32.store offset=8 + (get_local $8) + (get_local $4) + ) + (i32.store offset=16 + (get_local $8) + (i32.add + (get_local $4) + (get_local $6) + ) + ) + (block $label$6 + (br_if $label$6 + (i32.lt_u + (get_local $6) + (i32.const 513) + ) + ) + (call $free + (get_local $4) + ) + ) + (drop + (call $_ZN5eosio5token13currency_statC2Ev + (tee_local $6 + (call $_Znwj + (i32.const 56) + ) + ) + ) + ) + (i32.store offset=40 + (get_local $6) + (get_local $0) + ) + (i32.store offset=24 + (get_local $8) + (i32.add + (get_local $8) + (i32.const 8) + ) + ) + (i32.store offset=36 + (get_local $8) + (i32.add + (get_local $6) + (i32.const 16) + ) + ) + (i32.store offset=32 + (get_local $8) + (get_local $6) + ) + (i32.store offset=40 + (get_local $8) + (i32.add + (get_local $6) + (i32.const 32) + ) + ) + (call $_ZN5boost3pfr6detail19for_each_field_implINS1_14sequence_tuple5tupleIJRN5eosio5assetES7_RyEEEZNS5_rsINS5_10datastreamIPKcEENS5_5token13currency_statELPv0EEERT_SJ_RT0_EUlSJ_E_JLj0ELj1ELj2EEEEvSJ_OSK_NSt3__116integer_sequenceIjJXspT1_EEEENSO_17integral_constantIbLb0EEE + (i32.add + (get_local $8) + (i32.const 32) + ) + (i32.add + (get_local $8) + (i32.const 24) + ) + ) + (i32.store offset=44 + (get_local $6) + (get_local $1) + ) + (i32.store offset=24 + (get_local $8) + (get_local $6) + ) + (i64.store offset=32 + (get_local $8) + (tee_local $5 + (i64.shr_u + (i64.load offset=8 + (get_local $6) + ) + (i64.const 8) + ) + ) + ) + (i32.store offset=4 + (get_local $8) + (tee_local $7 + (i32.load offset=44 + (get_local $6) + ) + ) + ) + (block $label$7 + (block $label$8 + (br_if $label$8 + (i32.ge_u + (tee_local $4 + (i32.load + (tee_local $1 + (i32.add + (get_local $0) + (i32.const 28) + ) + ) + ) + ) + (i32.load + (i32.add + (get_local $0) + (i32.const 32) + ) + ) + ) + ) + (i64.store offset=8 + (get_local $4) + (get_local $5) + ) + (i32.store offset=16 + (get_local $4) + (get_local $7) + ) + (i32.store offset=24 + (get_local $8) + (i32.const 0) + ) + (i32.store + (get_local $4) + (get_local $6) + ) + (i32.store + (get_local $1) + (i32.add + (get_local $4) + (i32.const 24) + ) + ) + (br $label$7) + ) + (call $_ZNSt3__16vectorIN5eosio11multi_indexILy14289235522390851584ENS1_5token13currency_statEJEE8item_ptrENS_9allocatorIS6_EEE24__emplace_back_slow_pathIJNS_10unique_ptrINS5_4itemENS_14default_deleteISC_EEEERyRlEEEvDpOT_ + (i32.add + (get_local $0) + (i32.const 24) + ) + (i32.add + (get_local $8) + (i32.const 24) + ) + (i32.add + (get_local $8) + (i32.const 32) + ) + (i32.add + (get_local $8) + (i32.const 4) + ) + ) + ) + (set_local $4 + (i32.load offset=24 + (get_local $8) + ) + ) + (i32.store offset=24 + (get_local $8) + (i32.const 0) + ) + (br_if $label$2 + (i32.eqz + (get_local $4) + ) + ) + (call $_ZdlPv + (get_local $4) + ) + ) + (i32.store offset=4 + (i32.const 0) + (i32.add + (get_local $8) + (i32.const 48) + ) + ) + (get_local $6) + ) + (func $_ZN5eosio5token13currency_statC2Ev (param $0 i32) (result i32) + (local $1 i64) + (local $2 i32) + (local $3 i32) + (i64.store offset=8 + (get_local $0) + (i64.const 1398362884) + ) + (i64.store + (get_local $0) + (i64.const 0) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 288) + ) + (set_local $1 + (i64.shr_u + (i64.load offset=8 + (get_local $0) + ) + (i64.const 8) + ) + ) + (set_local $2 + (i32.const 0) + ) + (block $label$0 + (block $label$1 + (loop $label$2 + (br_if $label$1 + (i32.gt_u + (i32.add + (i32.shl + (i32.wrap/i64 + (get_local $1) + ) + (i32.const 24) + ) + (i32.const -1073741825) + ) + (i32.const 452984830) + ) + ) + (block $label$3 + (br_if $label$3 + (i64.ne + (i64.and + (tee_local $1 + (i64.shr_u + (get_local $1) + (i64.const 8) + ) + ) + (i64.const 255) + ) + (i64.const 0) + ) + ) + (loop $label$4 + (br_if $label$1 + (i64.ne + (i64.and + (tee_local $1 + (i64.shr_u + (get_local $1) + (i64.const 8) + ) + ) + (i64.const 255) + ) + (i64.const 0) + ) + ) + (br_if $label$4 + (i32.lt_s + (tee_local $2 + (i32.add + (get_local $2) + (i32.const 1) + ) + ) + (i32.const 7) + ) + ) + ) + ) + (set_local $3 + (i32.const 1) + ) + (br_if $label$2 + (i32.lt_s + (tee_local $2 + (i32.add + (get_local $2) + (i32.const 1) + ) + ) + (i32.const 7) + ) + ) + (br $label$0) + ) + ) + (set_local $3 + (i32.const 0) + ) + ) + (call $eosio_assert + (get_local $3) + (i32.const 16) + ) + (i64.store + (tee_local $2 + (i32.add + (get_local $0) + (i32.const 24) + ) + ) + (i64.const 1398362884) + ) + (i64.store offset=16 + (get_local $0) + (i64.const 0) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 288) + ) + (set_local $1 + (i64.shr_u + (i64.load + (get_local $2) + ) + (i64.const 8) + ) + ) + (set_local $2 + (i32.const 0) + ) + (block $label$5 + (block $label$6 + (loop $label$7 + (br_if $label$6 + (i32.gt_u + (i32.add + (i32.shl + (i32.wrap/i64 + (get_local $1) + ) + (i32.const 24) + ) + (i32.const -1073741825) + ) + (i32.const 452984830) + ) + ) + (block $label$8 + (br_if $label$8 + (i64.ne + (i64.and + (tee_local $1 + (i64.shr_u + (get_local $1) + (i64.const 8) + ) + ) + (i64.const 255) + ) + (i64.const 0) + ) + ) + (loop $label$9 + (br_if $label$6 + (i64.ne + (i64.and + (tee_local $1 + (i64.shr_u + (get_local $1) + (i64.const 8) + ) + ) + (i64.const 255) + ) + (i64.const 0) + ) + ) + (br_if $label$9 + (i32.lt_s + (tee_local $2 + (i32.add + (get_local $2) + (i32.const 1) + ) + ) + (i32.const 7) + ) + ) + ) + ) + (set_local $3 + (i32.const 1) + ) + (br_if $label$7 + (i32.lt_s + (tee_local $2 + (i32.add + (get_local $2) + (i32.const 1) + ) + ) + (i32.const 7) + ) + ) + (br $label$5) + ) + ) + (set_local $3 + (i32.const 0) + ) + ) + (call $eosio_assert + (get_local $3) + (i32.const 16) + ) + (get_local $0) + ) + (func $_ZN5boost3pfr6detail19for_each_field_implINS1_14sequence_tuple5tupleIJRKN5eosio5assetES8_RKyEEEZNS5_lsINS5_10datastreamIPcEENS5_5token13currency_statELPv0EEERT_SK_RKT0_EUlRKSJ_E_JLj0ELj1ELj2EEEEvSK_OSL_NSt3__116integer_sequenceIjJXspT1_EEEENSS_17integral_constantIbLb0EEE (param $0 i32) (param $1 i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (set_local $3 + (i32.load + (get_local $0) + ) + ) + (call $eosio_assert + (i32.gt_s + (i32.sub + (i32.load offset=8 + (tee_local $2 + (i32.load + (get_local $1) + ) + ) + ) + (i32.load offset=4 + (get_local $2) + ) + ) + (i32.const 7) + ) + (i32.const 272) + ) + (drop + (call $memcpy + (i32.load offset=4 + (get_local $2) + ) + (get_local $3) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $2) + (tee_local $4 + (i32.add + (i32.load offset=4 + (get_local $2) + ) + (i32.const 8) + ) + ) + ) + (call $eosio_assert + (i32.gt_s + (i32.sub + (i32.load offset=8 + (get_local $2) + ) + (get_local $4) + ) + (i32.const 7) + ) + (i32.const 272) + ) + (drop + (call $memcpy + (i32.load offset=4 + (get_local $2) + ) + (i32.add + (get_local $3) + (i32.const 8) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $2) + (i32.add + (i32.load offset=4 + (get_local $2) + ) + (i32.const 8) + ) + ) + (set_local $3 + (i32.load offset=4 + (get_local $0) + ) + ) + (call $eosio_assert + (i32.gt_s + (i32.sub + (i32.load offset=8 + (tee_local $2 + (i32.load + (get_local $1) + ) + ) + ) + (i32.load offset=4 + (get_local $2) + ) + ) + (i32.const 7) + ) + (i32.const 272) + ) + (drop + (call $memcpy + (i32.load offset=4 + (get_local $2) + ) + (get_local $3) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $2) + (tee_local $4 + (i32.add + (i32.load offset=4 + (get_local $2) + ) + (i32.const 8) + ) + ) + ) + (call $eosio_assert + (i32.gt_s + (i32.sub + (i32.load offset=8 + (get_local $2) + ) + (get_local $4) + ) + (i32.const 7) + ) + (i32.const 272) + ) + (drop + (call $memcpy + (i32.load offset=4 + (get_local $2) + ) + (i32.add + (get_local $3) + (i32.const 8) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $2) + (i32.add + (i32.load offset=4 + (get_local $2) + ) + (i32.const 8) + ) + ) + (set_local $0 + (i32.load offset=8 + (get_local $0) + ) + ) + (call $eosio_assert + (i32.gt_s + (i32.sub + (i32.load offset=8 + (tee_local $2 + (i32.load + (get_local $1) + ) + ) + ) + (i32.load offset=4 + (get_local $2) + ) + ) + (i32.const 7) + ) + (i32.const 272) + ) + (drop + (call $memcpy + (i32.load offset=4 + (get_local $2) + ) + (get_local $0) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $2) + (i32.add + (i32.load offset=4 + (get_local $2) + ) + (i32.const 8) + ) + ) + ) + (func $_ZNSt3__16vectorIN5eosio11multi_indexILy14289235522390851584ENS1_5token13currency_statEJEE8item_ptrENS_9allocatorIS6_EEE24__emplace_back_slow_pathIJNS_10unique_ptrINS5_4itemENS_14default_deleteISC_EEEERyRlEEEvDpOT_ (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (block $label$0 + (block $label$1 + (br_if $label$1 + (i32.ge_u + (tee_local $5 + (i32.add + (tee_local $4 + (i32.div_s + (i32.sub + (i32.load offset=4 + (get_local $0) + ) + (tee_local $6 + (i32.load + (get_local $0) + ) + ) + ) + (i32.const 24) + ) + ) + (i32.const 1) + ) + ) + (i32.const 178956971) + ) + ) + (set_local $7 + (i32.const 178956970) + ) + (block $label$2 + (block $label$3 + (br_if $label$3 + (i32.gt_u + (tee_local $6 + (i32.div_s + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (get_local $6) + ) + (i32.const 24) + ) + ) + (i32.const 89478484) + ) + ) + (br_if $label$2 + (i32.eqz + (tee_local $7 + (select + (get_local $5) + (tee_local $7 + (i32.shl + (get_local $6) + (i32.const 1) + ) + ) + (i32.lt_u + (get_local $7) + (get_local $5) + ) + ) + ) + ) + ) + ) + (set_local $6 + (call $_Znwj + (i32.mul + (get_local $7) + (i32.const 24) + ) + ) + ) + (br $label$0) + ) + (set_local $7 + (i32.const 0) + ) + (set_local $6 + (i32.const 0) + ) + (br $label$0) + ) + (call $_ZNKSt3__120__vector_base_commonILb1EE20__throw_length_errorEv + (get_local $0) + ) + (unreachable) + ) + (set_local $5 + (i32.load + (get_local $1) + ) + ) + (i32.store + (get_local $1) + (i32.const 0) + ) + (i32.store + (tee_local $1 + (i32.add + (get_local $6) + (i32.mul + (get_local $4) + (i32.const 24) + ) + ) + ) + (get_local $5) + ) + (i64.store offset=8 + (get_local $1) + (i64.load + (get_local $2) + ) + ) + (i32.store offset=16 + (get_local $1) + (i32.load + (get_local $3) + ) + ) + (set_local $4 + (i32.add + (get_local $6) + (i32.mul + (get_local $7) + (i32.const 24) + ) + ) + ) + (set_local $5 + (i32.add + (get_local $1) + (i32.const 24) + ) + ) + (block $label$4 + (block $label$5 + (br_if $label$5 + (i32.eq + (tee_local $6 + (i32.load + (i32.add + (get_local $0) + (i32.const 4) + ) + ) + ) + (tee_local $7 + (i32.load + (get_local $0) + ) + ) + ) + ) + (loop $label$6 + (set_local $3 + (i32.load + (tee_local $2 + (i32.add + (get_local $6) + (i32.const -24) + ) + ) + ) + ) + (i32.store + (get_local $2) + (i32.const 0) + ) + (i32.store + (i32.add + (get_local $1) + (i32.const -24) + ) + (get_local $3) + ) + (i32.store + (i32.add + (get_local $1) + (i32.const -8) + ) + (i32.load + (i32.add + (get_local $6) + (i32.const -8) + ) + ) + ) + (i32.store + (i32.add + (get_local $1) + (i32.const -12) + ) + (i32.load + (i32.add + (get_local $6) + (i32.const -12) + ) + ) + ) + (i32.store + (i32.add + (get_local $1) + (i32.const -16) + ) + (i32.load + (i32.add + (get_local $6) + (i32.const -16) + ) + ) + ) + (set_local $1 + (i32.add + (get_local $1) + (i32.const -24) + ) + ) + (set_local $6 + (get_local $2) + ) + (br_if $label$6 + (i32.ne + (get_local $7) + (get_local $2) + ) + ) + ) + (set_local $7 + (i32.load + (i32.add + (get_local $0) + (i32.const 4) + ) + ) + ) + (set_local $6 + (i32.load + (get_local $0) + ) + ) + (br $label$4) + ) + (set_local $6 + (get_local $7) + ) + ) + (i32.store + (get_local $0) + (get_local $1) + ) + (i32.store + (i32.add + (get_local $0) + (i32.const 4) + ) + (get_local $5) + ) + (i32.store + (i32.add + (get_local $0) + (i32.const 8) + ) + (get_local $4) + ) + (block $label$7 + (br_if $label$7 + (i32.eq + (get_local $7) + (get_local $6) + ) + ) + (loop $label$8 + (set_local $1 + (i32.load + (tee_local $7 + (i32.add + (get_local $7) + (i32.const -24) + ) + ) + ) + ) + (i32.store + (get_local $7) + (i32.const 0) + ) + (block $label$9 + (br_if $label$9 + (i32.eqz + (get_local $1) + ) + ) + (call $_ZdlPv + (get_local $1) + ) + ) + (br_if $label$8 + (i32.ne + (get_local $6) + (get_local $7) + ) + ) + ) + ) + (block $label$10 + (br_if $label$10 + (i32.eqz + (get_local $6) + ) + ) + (call $_ZdlPv + (get_local $6) + ) + ) + ) + (func $_ZN5boost3pfr6detail19for_each_field_implINS1_14sequence_tuple5tupleIJRN5eosio5assetES7_RyEEEZNS5_rsINS5_10datastreamIPKcEENS5_5token13currency_statELPv0EEERT_SJ_RT0_EUlSJ_E_JLj0ELj1ELj2EEEEvSJ_OSK_NSt3__116integer_sequenceIjJXspT1_EEEENSO_17integral_constantIbLb0EEE (param $0 i32) (param $1 i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (set_local $3 + (i32.load + (get_local $0) + ) + ) + (call $eosio_assert + (i32.gt_u + (i32.sub + (i32.load offset=8 + (tee_local $2 + (i32.load + (get_local $1) + ) + ) + ) + (i32.load offset=4 + (get_local $2) + ) + ) + (i32.const 7) + ) + (i32.const 384) + ) + (drop + (call $memcpy + (get_local $3) + (i32.load offset=4 + (get_local $2) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $2) + (tee_local $4 + (i32.add + (i32.load offset=4 + (get_local $2) + ) + (i32.const 8) + ) + ) + ) + (call $eosio_assert + (i32.gt_u + (i32.sub + (i32.load offset=8 + (get_local $2) + ) + (get_local $4) + ) + (i32.const 7) + ) + (i32.const 384) + ) + (drop + (call $memcpy + (i32.add + (get_local $3) + (i32.const 8) + ) + (i32.load offset=4 + (get_local $2) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $2) + (i32.add + (i32.load offset=4 + (get_local $2) + ) + (i32.const 8) + ) + ) + (set_local $3 + (i32.load offset=4 + (get_local $0) + ) + ) + (call $eosio_assert + (i32.gt_u + (i32.sub + (i32.load offset=8 + (tee_local $2 + (i32.load + (get_local $1) + ) + ) + ) + (i32.load offset=4 + (get_local $2) + ) + ) + (i32.const 7) + ) + (i32.const 384) + ) + (drop + (call $memcpy + (get_local $3) + (i32.load offset=4 + (get_local $2) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $2) + (tee_local $4 + (i32.add + (i32.load offset=4 + (get_local $2) + ) + (i32.const 8) + ) + ) + ) + (call $eosio_assert + (i32.gt_u + (i32.sub + (i32.load offset=8 + (get_local $2) + ) + (get_local $4) + ) + (i32.const 7) + ) + (i32.const 384) + ) + (drop + (call $memcpy + (i32.add + (get_local $3) + (i32.const 8) + ) + (i32.load offset=4 + (get_local $2) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $2) + (i32.add + (i32.load offset=4 + (get_local $2) + ) + (i32.const 8) + ) + ) + (set_local $0 + (i32.load offset=8 + (get_local $0) + ) + ) + (call $eosio_assert + (i32.gt_u + (i32.sub + (i32.load offset=8 + (tee_local $2 + (i32.load + (get_local $1) + ) + ) + ) + (i32.load offset=4 + (get_local $2) + ) + ) + (i32.const 7) + ) + (i32.const 384) + ) + (drop + (call $memcpy + (get_local $0) + (i32.load offset=4 + (get_local $2) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $2) + (i32.add + (i32.load offset=4 + (get_local $2) + ) + (i32.const 8) + ) + ) + ) + (func $_ZN5eosio5token5issueEyNS_5assetENSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE (type $FUNCSIG$vijii) (param $0 i32) (param $1 i64) (param $2 i32) (param $3 i32) + (local $4 i32) + (local $5 i64) + (local $6 i64) + (local $7 i32) + (local $8 i64) + (local $9 i32) + (local $10 i32) + (local $11 i64) + (local $12 i64) + (local $13 i64) + (local $14 i32) + (i32.store offset=4 + (i32.const 0) + (tee_local $14 + (i32.sub + (i32.load offset=4 + (i32.const 0) + ) + (i32.const 224) + ) + ) + ) + (set_local $9 + (i32.const 0) + ) + (set_local $8 + (tee_local $13 + (i64.shr_u + (tee_local $11 + (i64.load offset=8 + (get_local $2) + ) + ) + (i64.const 8) + ) + ) + ) + (block $label$0 + (block $label$1 + (loop $label$2 + (br_if $label$1 + (i32.gt_u + (i32.add + (i32.shl + (i32.wrap/i64 + (get_local $8) + ) + (i32.const 24) + ) + (i32.const -1073741825) + ) + (i32.const 452984830) + ) + ) + (block $label$3 + (br_if $label$3 + (i64.ne + (i64.and + (tee_local $8 + (i64.shr_u + (get_local $8) + (i64.const 8) + ) + ) + (i64.const 255) + ) + (i64.const 0) + ) + ) + (loop $label$4 + (br_if $label$1 + (i64.ne + (i64.and + (tee_local $8 + (i64.shr_u + (get_local $8) + (i64.const 8) + ) + ) + (i64.const 255) + ) + (i64.const 0) + ) + ) + (br_if $label$4 + (i32.lt_s + (tee_local $9 + (i32.add + (get_local $9) + (i32.const 1) + ) + ) + (i32.const 7) + ) + ) + ) + ) + (set_local $7 + (i32.const 1) + ) + (br_if $label$2 + (i32.lt_s + (tee_local $9 + (i32.add + (get_local $9) + (i32.const 1) + ) + ) + (i32.const 7) + ) + ) + (br $label$0) + ) + ) + (set_local $7 + (i32.const 0) + ) + ) + (call $eosio_assert + (get_local $7) + (i32.const 16) + ) + (block $label$5 + (block $label$6 + (br_if $label$6 + (i32.and + (tee_local $9 + (i32.load8_u + (get_local $3) + ) + ) + (i32.const 1) + ) + ) + (set_local $9 + (i32.shr_u + (get_local $9) + (i32.const 1) + ) + ) + (br $label$5) + ) + (set_local $9 + (i32.load offset=4 + (get_local $3) + ) + ) + ) + (call $eosio_assert + (i32.lt_u + (get_local $9) + (i32.const 257) + ) + (i32.const 400) + ) + (set_local $10 + (i32.const 0) + ) + (i32.store + (i32.add + (i32.add + (get_local $14) + (i32.const 88) + ) + (i32.const 32) + ) + (i32.const 0) + ) + (i64.store offset=104 + (get_local $14) + (i64.const -1) + ) + (i64.store offset=112 + (get_local $14) + (i64.const 0) + ) + (i64.store offset=88 + (get_local $14) + (tee_local $8 + (i64.load + (get_local $0) + ) + ) + ) + (i64.store offset=96 + (get_local $14) + (get_local $13) + ) + (set_local $7 + (i32.const 0) + ) + (block $label$7 + (br_if $label$7 + (i32.lt_s + (tee_local $9 + (call $db_find_i64 + (get_local $8) + (get_local $13) + (i64.const -4157508551318700032) + (get_local $13) + ) + ) + (i32.const 0) + ) + ) + (call $eosio_assert + (i32.eq + (i32.load offset=40 + (tee_local $7 + (call $_ZNK5eosio11multi_indexILy14289235522390851584ENS_5token13currency_statEJEE31load_object_by_primary_iteratorEl + (i32.add + (get_local $14) + (i32.const 88) + ) + (get_local $9) + ) + ) + ) + (i32.add + (get_local $14) + (i32.const 88) + ) + ) + (i32.const 96) + ) + ) + (call $eosio_assert + (i32.ne + (get_local $7) + (i32.const 0) + ) + (i32.const 432) + ) + (call $require_auth + (i64.load offset=32 + (get_local $7) + ) + ) + (set_local $4 + (i32.add + (get_local $7) + (i32.const 32) + ) + ) + (block $label$8 + (br_if $label$8 + (i64.gt_u + (i64.add + (tee_local $8 + (i64.load + (get_local $2) + ) + ) + (i64.const 4611686018427387903) + ) + (i64.const 9223372036854775806) + ) + ) + (set_local $9 + (i32.const 0) + ) + (block $label$9 + (loop $label$10 + (br_if $label$9 + (i32.gt_u + (i32.add + (i32.shl + (i32.wrap/i64 + (get_local $13) + ) + (i32.const 24) + ) + (i32.const -1073741825) + ) + (i32.const 452984830) + ) + ) + (block $label$11 + (br_if $label$11 + (i64.ne + (i64.and + (tee_local $13 + (i64.shr_u + (get_local $13) + (i64.const 8) + ) + ) + (i64.const 255) + ) + (i64.const 0) + ) + ) + (loop $label$12 + (br_if $label$9 + (i64.ne + (i64.and + (tee_local $13 + (i64.shr_u + (get_local $13) + (i64.const 8) + ) + ) + (i64.const 255) + ) + (i64.const 0) + ) + ) + (br_if $label$12 + (i32.lt_s + (tee_local $9 + (i32.add + (get_local $9) + (i32.const 1) + ) + ) + (i32.const 7) + ) + ) + ) + ) + (set_local $10 + (i32.const 1) + ) + (br_if $label$10 + (i32.lt_s + (tee_local $9 + (i32.add + (get_local $9) + (i32.const 1) + ) + ) + (i32.const 7) + ) + ) + (br $label$8) + ) + ) + (set_local $10 + (i32.const 0) + ) + ) + (call $eosio_assert + (get_local $10) + (i32.const 496) + ) + (call $eosio_assert + (i64.gt_s + (get_local $8) + (i64.const 0) + ) + (i32.const 528) + ) + (call $eosio_assert + (i64.eq + (get_local $11) + (i64.load offset=8 + (get_local $7) + ) + ) + (i32.const 560) + ) + (call $eosio_assert + (i64.le_s + (get_local $8) + (i64.sub + (i64.load offset=16 + (get_local $7) + ) + (i64.load + (get_local $7) + ) + ) + ) + (i32.const 592) + ) + (call $eosio_assert + (i32.eq + (i32.load offset=40 + (get_local $7) + ) + (i32.add + (get_local $14) + (i32.const 88) + ) + ) + (i32.const 640) + ) + (call $eosio_assert + (i64.eq + (i64.load offset=88 + (get_local $14) + ) + (call $current_receiver) + ) + (i32.const 688) + ) + (call $eosio_assert + (i64.eq + (get_local $11) + (tee_local $13 + (i64.load offset=8 + (get_local $7) + ) + ) + ) + (i32.const 752) + ) + (i64.store + (get_local $7) + (tee_local $8 + (i64.add + (i64.load + (get_local $7) + ) + (get_local $8) + ) + ) + ) + (call $eosio_assert + (i64.gt_s + (get_local $8) + (i64.const -4611686018427387904) + ) + (i32.const 800) + ) + (call $eosio_assert + (i64.lt_s + (i64.load + (get_local $7) + ) + (i64.const 4611686018427387904) + ) + (i32.const 832) + ) + (call $eosio_assert + (i64.eq + (tee_local $8 + (i64.shr_u + (get_local $13) + (i64.const 8) + ) + ) + (i64.shr_u + (i64.load offset=8 + (get_local $7) + ) + (i64.const 8) + ) + ) + (i32.const 864) + ) + (i32.store offset=192 + (get_local $14) + (i32.add + (i32.add + (get_local $14) + (i32.const 128) + ) + (i32.const 40) + ) + ) + (i32.store offset=188 + (get_local $14) + (i32.add + (get_local $14) + (i32.const 128) + ) + ) + (i32.store offset=184 + (get_local $14) + (i32.add + (get_local $14) + (i32.const 128) + ) + ) + (i32.store offset=200 + (get_local $14) + (i32.add + (get_local $14) + (i32.const 184) + ) + ) + (i32.store offset=212 + (get_local $14) + (i32.add + (get_local $7) + (i32.const 16) + ) + ) + (i32.store offset=208 + (get_local $14) + (get_local $7) + ) + (i32.store offset=216 + (get_local $14) + (get_local $4) + ) + (call $_ZN5boost3pfr6detail19for_each_field_implINS1_14sequence_tuple5tupleIJRKN5eosio5assetES8_RKyEEEZNS5_lsINS5_10datastreamIPcEENS5_5token13currency_statELPv0EEERT_SK_RKT0_EUlRKSJ_E_JLj0ELj1ELj2EEEEvSK_OSL_NSt3__116integer_sequenceIjJXspT1_EEEENSS_17integral_constantIbLb0EEE + (i32.add + (get_local $14) + (i32.const 208) + ) + (i32.add + (get_local $14) + (i32.const 200) + ) + ) + (call $db_update_i64 + (i32.load offset=44 + (get_local $7) + ) + (i64.const 0) + (i32.add + (get_local $14) + (i32.const 128) + ) + (i32.const 40) + ) + (block $label$13 + (br_if $label$13 + (i64.lt_u + (get_local $8) + (i64.load + (tee_local $9 + (i32.add + (i32.add + (get_local $14) + (i32.const 88) + ) + (i32.const 16) + ) + ) + ) + ) + ) + (i64.store + (get_local $9) + (i64.add + (get_local $8) + (i64.const 1) + ) + ) + ) + (i32.store + (tee_local $9 + (i32.add + (i32.add + (get_local $14) + (i32.const 72) + ) + (i32.const 12) + ) + ) + (i32.load + (i32.add + (get_local $2) + (i32.const 12) + ) + ) + ) + (i32.store + (tee_local $7 + (i32.add + (i32.add + (get_local $14) + (i32.const 72) + ) + (i32.const 8) + ) + ) + (i32.load + (i32.add + (get_local $2) + (i32.const 8) + ) + ) + ) + (i32.store offset=76 + (get_local $14) + (i32.load + (i32.add + (get_local $2) + (i32.const 4) + ) + ) + ) + (i32.store offset=72 + (get_local $14) + (i32.load + (get_local $2) + ) + ) + (set_local $8 + (i64.load + (get_local $4) + ) + ) + (i32.store + (i32.add + (i32.add + (get_local $14) + (i32.const 8) + ) + (i32.const 12) + ) + (i32.load + (get_local $9) + ) + ) + (i32.store + (i32.add + (i32.add + (get_local $14) + (i32.const 8) + ) + (i32.const 8) + ) + (i32.load + (get_local $7) + ) + ) + (i32.store offset=12 + (get_local $14) + (i32.load offset=76 + (get_local $14) + ) + ) + (i32.store offset=8 + (get_local $14) + (i32.load offset=72 + (get_local $14) + ) + ) + (call $_ZN5eosio5token11add_balanceEyNS_5assetEy + (get_local $0) + (get_local $8) + (i32.add + (get_local $14) + (i32.const 8) + ) + (get_local $8) + ) + (block $label$14 + (br_if $label$14 + (i64.eq + (tee_local $5 + (i64.load + (get_local $4) + ) + ) + (get_local $1) + ) + ) + (set_local $6 + (i64.load + (get_local $0) + ) + ) + (set_local $8 + (i64.const 0) + ) + (set_local $11 + (i64.const 59) + ) + (set_local $9 + (i32.const 928) + ) + (set_local $12 + (i64.const 0) + ) + (loop $label$15 + (block $label$16 + (block $label$17 + (block $label$18 + (block $label$19 + (block $label$20 + (br_if $label$20 + (i64.gt_u + (get_local $8) + (i64.const 5) + ) + ) + (br_if $label$19 + (i32.gt_u + (i32.and + (i32.add + (tee_local $7 + (i32.load8_s + (get_local $9) + ) + ) + (i32.const -97) + ) + (i32.const 255) + ) + (i32.const 25) + ) + ) + (set_local $7 + (i32.add + (get_local $7) + (i32.const 165) + ) + ) + (br $label$18) + ) + (set_local $13 + (i64.const 0) + ) + (br_if $label$17 + (i64.le_u + (get_local $8) + (i64.const 11) + ) + ) + (br $label$16) + ) + (set_local $7 + (select + (i32.add + (get_local $7) + (i32.const 208) + ) + (i32.const 0) + (i32.lt_u + (i32.and + (i32.add + (get_local $7) + (i32.const -49) + ) + (i32.const 255) + ) + (i32.const 5) + ) + ) + ) + ) + (set_local $13 + (i64.shr_s + (i64.shl + (i64.extend_u/i32 + (get_local $7) + ) + (i64.const 56) + ) + (i64.const 56) + ) + ) + ) + (set_local $13 + (i64.shl + (i64.and + (get_local $13) + (i64.const 31) + ) + (i64.and + (get_local $11) + (i64.const 4294967295) + ) + ) + ) + ) + (set_local $9 + (i32.add + (get_local $9) + (i32.const 1) + ) + ) + (set_local $8 + (i64.add + (get_local $8) + (i64.const 1) + ) + ) + (set_local $12 + (i64.or + (get_local $13) + (get_local $12) + ) + ) + (br_if $label$15 + (i64.ne + (tee_local $11 + (i64.add + (get_local $11) + (i64.const -5) + ) + ) + (i64.const -6) + ) + ) + ) + (i32.store + (i32.add + (get_local $14) + (i32.const 52) + ) + (i32.load + (i32.add + (get_local $2) + (i32.const 12) + ) + ) + ) + (i32.store + (tee_local $7 + (i32.add + (i32.add + (get_local $14) + (i32.const 24) + ) + (i32.const 24) + ) + ) + (i32.load + (i32.add + (get_local $2) + (i32.const 8) + ) + ) + ) + (i32.store + (i32.add + (get_local $14) + (i32.const 44) + ) + (i32.load + (i32.add + (get_local $2) + (i32.const 4) + ) + ) + ) + (i64.store offset=32 + (get_local $14) + (get_local $1) + ) + (i64.store offset=24 + (get_local $14) + (get_local $5) + ) + (i32.store offset=40 + (get_local $14) + (i32.load + (get_local $2) + ) + ) + (drop + (call $_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEC2ERKS5_ + (i32.add + (get_local $14) + (i32.const 56) + ) + (get_local $3) + ) + ) + (i64.store + (tee_local $9 + (call $_Znwj + (i32.const 16) + ) + ) + (get_local $5) + ) + (i64.store offset=8 + (get_local $9) + (get_local $12) + ) + (i32.store offset=208 + (get_local $14) + (get_local $9) + ) + (i32.store offset=216 + (get_local $14) + (tee_local $9 + (i32.add + (get_local $9) + (i32.const 16) + ) + ) + ) + (i32.store offset=212 + (get_local $14) + (get_local $9) + ) + (i64.store offset=128 + (get_local $14) + (i64.load offset=24 + (get_local $14) + ) + ) + (i64.store offset=136 + (get_local $14) + (i64.load offset=32 + (get_local $14) + ) + ) + (i64.store + (i32.add + (i32.add + (get_local $14) + (i32.const 128) + ) + (i32.const 24) + ) + (i64.load + (get_local $7) + ) + ) + (i64.store offset=144 + (get_local $14) + (i64.load offset=40 + (get_local $14) + ) + ) + (i32.store + (tee_local $7 + (i32.add + (i32.add + (get_local $14) + (i32.const 128) + ) + (i32.const 40) + ) + ) + (i32.load + (tee_local $9 + (i32.add + (i32.add + (get_local $14) + (i32.const 24) + ) + (i32.const 40) + ) + ) + ) + ) + (i64.store offset=160 + (get_local $14) + (i64.load offset=56 + (get_local $14) + ) + ) + (i32.store offset=56 + (get_local $14) + (i32.const 0) + ) + (i32.store + (i32.add + (get_local $14) + (i32.const 60) + ) + (i32.const 0) + ) + (i32.store + (get_local $9) + (i32.const 0) + ) + (call $_ZN5eosio15dispatch_inlineIJyyNS_5assetENSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEvyyNS2_6vectorINS_16permission_levelENS6_ISA_EEEENS2_5tupleIJDpT_EEE + (get_local $6) + (i64.const -3617168760277827584) + (i32.add + (get_local $14) + (i32.const 208) + ) + (i32.add + (get_local $14) + (i32.const 128) + ) + ) + (block $label$21 + (br_if $label$21 + (i32.eqz + (i32.and + (i32.load8_u offset=160 + (get_local $14) + ) + (i32.const 1) + ) + ) + ) + (call $_ZdlPv + (i32.load + (get_local $7) + ) + ) + ) + (block $label$22 + (br_if $label$22 + (i32.eqz + (tee_local $9 + (i32.load offset=208 + (get_local $14) + ) + ) + ) + ) + (i32.store offset=212 + (get_local $14) + (get_local $9) + ) + (call $_ZdlPv + (get_local $9) + ) + ) + (br_if $label$14 + (i32.eqz + (i32.and + (i32.load8_u + (i32.add + (get_local $14) + (i32.const 56) + ) + ) + (i32.const 1) + ) + ) + ) + (call $_ZdlPv + (i32.load + (i32.add + (get_local $14) + (i32.const 64) + ) + ) + ) + ) + (block $label$23 + (br_if $label$23 + (i32.eqz + (tee_local $2 + (i32.load offset=112 + (get_local $14) + ) + ) + ) + ) + (block $label$24 + (block $label$25 + (br_if $label$25 + (i32.eq + (tee_local $9 + (i32.load + (tee_local $10 + (i32.add + (get_local $14) + (i32.const 116) + ) + ) + ) + ) + (get_local $2) + ) + ) + (loop $label$26 + (set_local $7 + (i32.load + (tee_local $9 + (i32.add + (get_local $9) + (i32.const -24) + ) + ) + ) + ) + (i32.store + (get_local $9) + (i32.const 0) + ) + (block $label$27 + (br_if $label$27 + (i32.eqz + (get_local $7) + ) + ) + (call $_ZdlPv + (get_local $7) + ) + ) + (br_if $label$26 + (i32.ne + (get_local $2) + (get_local $9) + ) + ) + ) + (set_local $9 + (i32.load + (i32.add + (get_local $14) + (i32.const 112) + ) + ) + ) + (br $label$24) + ) + (set_local $9 + (get_local $2) + ) + ) + (i32.store + (get_local $10) + (get_local $2) + ) + (call $_ZdlPv + (get_local $9) + ) + ) + (i32.store offset=4 + (i32.const 0) + (i32.add + (get_local $14) + (i32.const 224) + ) + ) + ) + (func $_ZN5eosio5token11add_balanceEyNS_5assetEy (param $0 i32) (param $1 i64) (param $2 i32) (param $3 i64) + (local $4 i64) + (local $5 i32) + (local $6 i64) + (local $7 i32) + (local $8 i32) + (local $9 i32) + (i32.store offset=4 + (i32.const 0) + (tee_local $9 + (i32.sub + (i32.load offset=4 + (i32.const 0) + ) + (i32.const 80) + ) + ) + ) + (set_local $8 + (i32.const 0) + ) + (i32.store + (i32.add + (i32.add + (get_local $9) + (i32.const 8) + ) + (i32.const 32) + ) + (i32.const 0) + ) + (i64.store offset=24 + (get_local $9) + (i64.const -1) + ) + (i64.store offset=32 + (get_local $9) + (i64.const 0) + ) + (i64.store offset=8 + (get_local $9) + (tee_local $6 + (i64.load + (get_local $0) + ) + ) + ) + (i64.store offset=16 + (get_local $9) + (get_local $1) + ) + (block $label$0 + (block $label$1 + (block $label$2 + (block $label$3 + (br_if $label$3 + (i32.lt_s + (tee_local $0 + (call $db_find_i64 + (get_local $6) + (get_local $1) + (i64.const 3607749779137757184) + (i64.shr_u + (tee_local $4 + (i64.load offset=8 + (get_local $2) + ) + ) + (i64.const 8) + ) + ) + ) + (i32.const 0) + ) + ) + (call $eosio_assert + (i32.eq + (i32.load offset=16 + (tee_local $8 + (call $_ZNK5eosio11multi_indexILy3607749779137757184ENS_5token7accountEJEE31load_object_by_primary_iteratorEl + (i32.add + (get_local $9) + (i32.const 8) + ) + (get_local $0) + ) + ) + ) + (i32.add + (get_local $9) + (i32.const 8) + ) + ) + (i32.const 96) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 944) + ) + (call $eosio_assert + (i32.eq + (i32.load offset=16 + (get_local $8) + ) + (i32.add + (get_local $9) + (i32.const 8) + ) + ) + (i32.const 640) + ) + (call $eosio_assert + (i64.eq + (i64.load offset=8 + (get_local $9) + ) + (call $current_receiver) + ) + (i32.const 688) + ) + (call $eosio_assert + (i64.eq + (get_local $4) + (tee_local $1 + (i64.load offset=8 + (get_local $8) + ) + ) + ) + (i32.const 752) + ) + (i64.store + (get_local $8) + (tee_local $6 + (i64.add + (i64.load + (get_local $8) + ) + (i64.load + (get_local $2) + ) + ) + ) + ) + (call $eosio_assert + (i64.gt_s + (get_local $6) + (i64.const -4611686018427387904) + ) + (i32.const 800) + ) + (call $eosio_assert + (i64.lt_s + (i64.load + (get_local $8) + ) + (i64.const 4611686018427387904) + ) + (i32.const 832) + ) + (call $eosio_assert + (i64.eq + (tee_local $1 + (i64.shr_u + (get_local $1) + (i64.const 8) + ) + ) + (i64.shr_u + (i64.load offset=8 + (get_local $8) + ) + (i64.const 8) + ) + ) + (i32.const 864) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 272) + ) + (drop + (call $memcpy + (i32.add + (get_local $9) + (i32.const 64) + ) + (get_local $8) + (i32.const 8) + ) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 272) + ) + (drop + (call $memcpy + (i32.or + (i32.add + (get_local $9) + (i32.const 64) + ) + (i32.const 8) + ) + (i32.add + (get_local $8) + (i32.const 8) + ) + (i32.const 8) + ) + ) + (call $db_update_i64 + (i32.load offset=20 + (get_local $8) + ) + (i64.const 0) + (i32.add + (get_local $9) + (i32.const 64) + ) + (i32.const 16) + ) + (br_if $label$2 + (i64.lt_u + (get_local $1) + (i64.load + (tee_local $8 + (i32.add + (i32.add + (get_local $9) + (i32.const 8) + ) + (i32.const 16) + ) + ) + ) + ) + ) + (i64.store + (get_local $8) + (i64.add + (get_local $1) + (i64.const 1) + ) + ) + (br_if $label$1 + (tee_local $2 + (i32.load offset=32 + (get_local $9) + ) + ) + ) + (br $label$0) + ) + (call $eosio_assert + (i64.eq + (i64.load offset=8 + (get_local $9) + ) + (call $current_receiver) + ) + (i32.const 208) + ) + (i64.store offset=8 + (tee_local $0 + (call $_Znwj + (i32.const 32) + ) + ) + (i64.const 1398362884) + ) + (i64.store + (get_local $0) + (i64.const 0) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 288) + ) + (set_local $5 + (i32.add + (get_local $0) + (i32.const 8) + ) + ) + (set_local $1 + (i64.const 5462355) + ) + (block $label$4 + (loop $label$5 + (set_local $7 + (i32.const 0) + ) + (br_if $label$4 + (i32.gt_u + (i32.add + (i32.shl + (i32.wrap/i64 + (get_local $1) + ) + (i32.const 24) + ) + (i32.const -1073741825) + ) + (i32.const 452984830) + ) + ) + (block $label$6 + (br_if $label$6 + (i64.ne + (i64.and + (tee_local $1 + (i64.shr_u + (get_local $1) + (i64.const 8) + ) + ) + (i64.const 255) + ) + (i64.const 0) + ) + ) + (loop $label$7 + (br_if $label$4 + (i64.ne + (i64.and + (tee_local $1 + (i64.shr_u + (get_local $1) + (i64.const 8) + ) + ) + (i64.const 255) + ) + (i64.const 0) + ) + ) + (br_if $label$7 + (i32.lt_s + (tee_local $8 + (i32.add + (get_local $8) + (i32.const 1) + ) + ) + (i32.const 7) + ) + ) + ) + ) + (set_local $7 + (i32.const 1) + ) + (br_if $label$5 + (i32.lt_s + (tee_local $8 + (i32.add + (get_local $8) + (i32.const 1) + ) + ) + (i32.const 7) + ) + ) + ) + ) + (call $eosio_assert + (get_local $7) + (i32.const 16) + ) + (i32.store offset=16 + (get_local $0) + (i32.add + (get_local $9) + (i32.const 8) + ) + ) + (i64.store + (tee_local $8 + (i32.add + (get_local $0) + (i32.const 8) + ) + ) + (i64.load + (i32.add + (get_local $2) + (i32.const 8) + ) + ) + ) + (i64.store + (get_local $0) + (i64.load + (get_local $2) + ) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 272) + ) + (drop + (call $memcpy + (i32.add + (get_local $9) + (i32.const 64) + ) + (get_local $0) + (i32.const 8) + ) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 272) + ) + (drop + (call $memcpy + (i32.or + (i32.add + (get_local $9) + (i32.const 64) + ) + (i32.const 8) + ) + (get_local $5) + (i32.const 8) + ) + ) + (i32.store offset=20 + (get_local $0) + (tee_local $2 + (call $db_store_i64 + (i64.load + (i32.add + (i32.add + (get_local $9) + (i32.const 8) + ) + (i32.const 8) + ) + ) + (i64.const 3607749779137757184) + (get_local $3) + (tee_local $1 + (i64.shr_u + (i64.load + (get_local $8) + ) + (i64.const 8) + ) + ) + (i32.add + (get_local $9) + (i32.const 64) + ) + (i32.const 16) + ) + ) + ) + (block $label$8 + (br_if $label$8 + (i64.lt_u + (get_local $1) + (i64.load + (tee_local $7 + (i32.add + (i32.add + (get_local $9) + (i32.const 8) + ) + (i32.const 16) + ) + ) + ) + ) + ) + (i64.store + (get_local $7) + (i64.add + (get_local $1) + (i64.const 1) + ) + ) + ) + (i32.store offset=56 + (get_local $9) + (get_local $0) + ) + (i64.store offset=64 + (get_local $9) + (tee_local $1 + (i64.shr_u + (i64.load + (get_local $8) + ) + (i64.const 8) + ) + ) + ) + (i32.store offset=52 + (get_local $9) + (get_local $2) + ) + (block $label$9 + (block $label$10 + (br_if $label$10 + (i32.ge_u + (tee_local $8 + (i32.load + (tee_local $7 + (i32.add + (get_local $9) + (i32.const 36) + ) + ) + ) + ) + (i32.load + (i32.add + (get_local $9) + (i32.const 40) + ) + ) + ) + ) + (i64.store offset=8 + (get_local $8) + (get_local $1) + ) + (i32.store offset=16 + (get_local $8) + (get_local $2) + ) + (i32.store offset=56 + (get_local $9) + (i32.const 0) + ) + (i32.store + (get_local $8) + (get_local $0) + ) + (i32.store + (get_local $7) + (i32.add + (get_local $8) + (i32.const 24) + ) + ) + (br $label$9) + ) + (call $_ZNSt3__16vectorIN5eosio11multi_indexILy3607749779137757184ENS1_5token7accountEJEE8item_ptrENS_9allocatorIS6_EEE24__emplace_back_slow_pathIJNS_10unique_ptrINS5_4itemENS_14default_deleteISC_EEEERyRlEEEvDpOT_ + (i32.add + (get_local $9) + (i32.const 32) + ) + (i32.add + (get_local $9) + (i32.const 56) + ) + (i32.add + (get_local $9) + (i32.const 64) + ) + (i32.add + (get_local $9) + (i32.const 52) + ) + ) + ) + (set_local $8 + (i32.load offset=56 + (get_local $9) + ) + ) + (i32.store offset=56 + (get_local $9) + (i32.const 0) + ) + (br_if $label$2 + (i32.eqz + (get_local $8) + ) + ) + (call $_ZdlPv + (get_local $8) + ) + ) + (br_if $label$0 + (i32.eqz + (tee_local $2 + (i32.load offset=32 + (get_local $9) + ) + ) + ) + ) + ) + (block $label$11 + (block $label$12 + (br_if $label$12 + (i32.eq + (tee_local $8 + (i32.load + (tee_local $7 + (i32.add + (get_local $9) + (i32.const 36) + ) + ) + ) + ) + (get_local $2) + ) + ) + (loop $label$13 + (set_local $0 + (i32.load + (tee_local $8 + (i32.add + (get_local $8) + (i32.const -24) + ) + ) + ) + ) + (i32.store + (get_local $8) + (i32.const 0) + ) + (block $label$14 + (br_if $label$14 + (i32.eqz + (get_local $0) + ) + ) + (call $_ZdlPv + (get_local $0) + ) + ) + (br_if $label$13 + (i32.ne + (get_local $2) + (get_local $8) + ) + ) + ) + (set_local $8 + (i32.load + (i32.add + (get_local $9) + (i32.const 32) + ) + ) + ) + (br $label$11) + ) + (set_local $8 + (get_local $2) + ) + ) + (i32.store + (get_local $7) + (get_local $2) + ) + (call $_ZdlPv + (get_local $8) + ) + ) + (i32.store offset=4 + (i32.const 0) + (i32.add + (get_local $9) + (i32.const 80) + ) + ) + ) + (func $_ZN5eosio15dispatch_inlineIJyyNS_5assetENSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEvyyNS2_6vectorINS_16permission_levelENS6_ISA_EEEENS2_5tupleIJDpT_EEE (param $0 i64) (param $1 i64) (param $2 i32) (param $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (local $8 i32) + (local $9 i32) + (i32.store offset=4 + (i32.const 0) + (tee_local $9 + (i32.sub + (i32.load offset=4 + (i32.const 0) + ) + (i32.const 96) + ) + ) + ) + (i32.store offset=16 + (get_local $9) + (i32.const 0) + ) + (i64.store offset=8 + (get_local $9) + (i64.const 0) + ) + (set_local $6 + (i32.const 0) + ) + (set_local $7 + (i32.const 0) + ) + (set_local $8 + (i32.const 0) + ) + (block $label$0 + (block $label$1 + (br_if $label$1 + (i32.eqz + (tee_local $5 + (i32.shr_s + (tee_local $4 + (i32.sub + (i32.load offset=4 + (get_local $2) + ) + (i32.load + (get_local $2) + ) + ) + ) + (i32.const 4) + ) + ) + ) + ) + (br_if $label$0 + (i32.ge_u + (get_local $5) + (i32.const 268435456) + ) + ) + (i32.store + (i32.add + (get_local $9) + (i32.const 16) + ) + (tee_local $6 + (i32.add + (tee_local $8 + (call $_Znwj + (get_local $4) + ) + ) + (i32.shl + (get_local $5) + (i32.const 4) + ) + ) + ) + ) + (i32.store offset=8 + (get_local $9) + (get_local $8) + ) + (i32.store offset=12 + (get_local $9) + (get_local $8) + ) + (block $label$2 + (br_if $label$2 + (i32.lt_s + (tee_local $2 + (i32.sub + (i32.load + (i32.add + (get_local $2) + (i32.const 4) + ) + ) + (tee_local $7 + (i32.load + (get_local $2) + ) + ) + ) + ) + (i32.const 1) + ) + ) + (drop + (call $memcpy + (get_local $8) + (get_local $7) + (get_local $2) + ) + ) + (i32.store offset=12 + (get_local $9) + (tee_local $7 + (i32.add + (get_local $8) + (get_local $2) + ) + ) + ) + (br $label$1) + ) + (set_local $7 + (get_local $8) + ) + ) + (i32.store + (i32.add + (get_local $9) + (i32.const 44) + ) + (get_local $7) + ) + (i64.store offset=32 + (get_local $9) + (get_local $1) + ) + (i32.store + (i32.add + (get_local $9) + (i32.const 16) + ) + (i32.const 0) + ) + (i32.store + (i32.add + (get_local $9) + (i32.const 48) + ) + (get_local $6) + ) + (i64.store offset=24 + (get_local $9) + (get_local $0) + ) + (i32.store offset=40 + (get_local $9) + (get_local $8) + ) + (i64.store offset=8 + (get_local $9) + (i64.const 0) + ) + (i32.store offset=52 + (get_local $9) + (i32.const 0) + ) + (i32.store + (i32.add + (i32.add + (get_local $9) + (i32.const 24) + ) + (i32.const 32) + ) + (i32.const 0) + ) + (i32.store + (i32.add + (i32.add + (get_local $9) + (i32.const 24) + ) + (i32.const 36) + ) + (i32.const 0) + ) + (set_local $8 + (i32.add + (tee_local $2 + (select + (i32.load + (i32.add + (get_local $3) + (i32.const 36) + ) + ) + (i32.shr_u + (tee_local $8 + (i32.load8_u offset=32 + (get_local $3) + ) + ) + (i32.const 1) + ) + (i32.and + (get_local $8) + (i32.const 1) + ) + ) + ) + (i32.const 32) + ) + ) + (set_local $0 + (i64.extend_u/i32 + (get_local $2) + ) + ) + (set_local $2 + (i32.add + (get_local $9) + (i32.const 52) + ) + ) + (loop $label$3 + (set_local $8 + (i32.add + (get_local $8) + (i32.const 1) + ) + ) + (br_if $label$3 + (i64.ne + (tee_local $0 + (i64.shr_u + (get_local $0) + (i64.const 7) + ) + ) + (i64.const 0) + ) + ) + ) + (block $label$4 + (block $label$5 + (br_if $label$5 + (i32.eqz + (get_local $8) + ) + ) + (call $_ZNSt3__16vectorIcNS_9allocatorIcEEE8__appendEj + (get_local $2) + (get_local $8) + ) + (set_local $2 + (i32.load + (i32.add + (get_local $9) + (i32.const 56) + ) + ) + ) + (set_local $8 + (i32.load + (i32.add + (get_local $9) + (i32.const 52) + ) + ) + ) + (br $label$4) + ) + (set_local $2 + (i32.const 0) + ) + (set_local $8 + (i32.const 0) + ) + ) + (i32.store offset=84 + (get_local $9) + (get_local $8) + ) + (i32.store offset=80 + (get_local $9) + (get_local $8) + ) + (i32.store offset=88 + (get_local $9) + (get_local $2) + ) + (i32.store offset=64 + (get_local $9) + (i32.add + (get_local $9) + (i32.const 80) + ) + ) + (i32.store offset=72 + (get_local $9) + (get_local $3) + ) + (call $_ZN5boost6fusion6detail17for_each_unrolledILi4EE4callINS0_18std_tuple_iteratorIKNSt3__15tupleIJyyN5eosio5assetENS6_12basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEEEELi0EEEZNS8_lsINS8_10datastreamIPcEEJyyS9_SF_EEERT_SO_RKNS7_IJDpT0_EEEEUlRKSN_E_EEvSV_RKT0_ + (i32.add + (get_local $9) + (i32.const 72) + ) + (i32.add + (get_local $9) + (i32.const 64) + ) + ) + (call $_ZN5eosio4packINS_6actionEEENSt3__16vectorIcNS2_9allocatorIcEEEERKT_ + (i32.add + (get_local $9) + (i32.const 80) + ) + (i32.add + (get_local $9) + (i32.const 24) + ) + ) + (call $send_inline + (tee_local $8 + (i32.load offset=80 + (get_local $9) + ) + ) + (i32.sub + (i32.load offset=84 + (get_local $9) + ) + (get_local $8) + ) + ) + (block $label$6 + (br_if $label$6 + (i32.eqz + (tee_local $8 + (i32.load offset=80 + (get_local $9) + ) + ) + ) + ) + (i32.store offset=84 + (get_local $9) + (get_local $8) + ) + (call $_ZdlPv + (get_local $8) + ) + ) + (block $label$7 + (br_if $label$7 + (i32.eqz + (tee_local $8 + (i32.load offset=52 + (get_local $9) + ) + ) + ) + ) + (i32.store + (i32.add + (get_local $9) + (i32.const 56) + ) + (get_local $8) + ) + (call $_ZdlPv + (get_local $8) + ) + ) + (block $label$8 + (br_if $label$8 + (i32.eqz + (tee_local $8 + (i32.load offset=40 + (get_local $9) + ) + ) + ) + ) + (i32.store + (i32.add + (get_local $9) + (i32.const 44) + ) + (get_local $8) + ) + (call $_ZdlPv + (get_local $8) + ) + ) + (block $label$9 + (br_if $label$9 + (i32.eqz + (tee_local $8 + (i32.load offset=8 + (get_local $9) + ) + ) + ) + ) + (i32.store offset=12 + (get_local $9) + (get_local $8) + ) + (call $_ZdlPv + (get_local $8) + ) + ) + (i32.store offset=4 + (i32.const 0) + (i32.add + (get_local $9) + (i32.const 96) + ) + ) + (return) + ) + (call $_ZNKSt3__120__vector_base_commonILb1EE20__throw_length_errorEv + (i32.add + (get_local $9) + (i32.const 8) + ) + ) + (unreachable) + ) + (func $_ZNSt3__16vectorIcNS_9allocatorIcEEE8__appendEj (param $0 i32) (param $1 i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (block $label$0 + (block $label$1 + (block $label$2 + (block $label$3 + (block $label$4 + (br_if $label$4 + (i32.ge_u + (i32.sub + (tee_local $2 + (i32.load offset=8 + (get_local $0) + ) + ) + (tee_local $6 + (i32.load offset=4 + (get_local $0) + ) + ) + ) + (get_local $1) + ) + ) + (br_if $label$2 + (i32.le_s + (tee_local $4 + (i32.add + (tee_local $3 + (i32.sub + (get_local $6) + (tee_local $5 + (i32.load + (get_local $0) + ) + ) + ) + ) + (get_local $1) + ) + ) + (i32.const -1) + ) + ) + (set_local $6 + (i32.const 2147483647) + ) + (block $label$5 + (br_if $label$5 + (i32.gt_u + (tee_local $2 + (i32.sub + (get_local $2) + (get_local $5) + ) + ) + (i32.const 1073741822) + ) + ) + (br_if $label$3 + (i32.eqz + (tee_local $6 + (select + (get_local $4) + (tee_local $6 + (i32.shl + (get_local $2) + (i32.const 1) + ) + ) + (i32.lt_u + (get_local $6) + (get_local $4) + ) + ) + ) + ) + ) + ) + (set_local $2 + (call $_Znwj + (get_local $6) + ) + ) + (br $label$1) + ) + (set_local $0 + (i32.add + (get_local $0) + (i32.const 4) + ) + ) + (loop $label$6 + (i32.store8 + (get_local $6) + (i32.const 0) + ) + (i32.store + (get_local $0) + (tee_local $6 + (i32.add + (i32.load + (get_local $0) + ) + (i32.const 1) + ) + ) + ) + (br_if $label$6 + (tee_local $1 + (i32.add + (get_local $1) + (i32.const -1) + ) + ) + ) + (br $label$0) + ) + ) + (set_local $6 + (i32.const 0) + ) + (set_local $2 + (i32.const 0) + ) + (br $label$1) + ) + (call $_ZNKSt3__120__vector_base_commonILb1EE20__throw_length_errorEv + (get_local $0) + ) + (unreachable) + ) + (set_local $4 + (i32.add + (get_local $2) + (get_local $6) + ) + ) + (set_local $6 + (tee_local $5 + (i32.add + (get_local $2) + (get_local $3) + ) + ) + ) + (loop $label$7 + (i32.store8 + (get_local $6) + (i32.const 0) + ) + (set_local $6 + (i32.add + (get_local $6) + (i32.const 1) + ) + ) + (br_if $label$7 + (tee_local $1 + (i32.add + (get_local $1) + (i32.const -1) + ) + ) + ) + ) + (set_local $5 + (i32.sub + (get_local $5) + (tee_local $2 + (i32.sub + (i32.load + (tee_local $3 + (i32.add + (get_local $0) + (i32.const 4) + ) + ) + ) + (tee_local $1 + (i32.load + (get_local $0) + ) + ) + ) + ) + ) + ) + (block $label$8 + (br_if $label$8 + (i32.lt_s + (get_local $2) + (i32.const 1) + ) + ) + (drop + (call $memcpy + (get_local $5) + (get_local $1) + (get_local $2) + ) + ) + (set_local $1 + (i32.load + (get_local $0) + ) + ) + ) + (i32.store + (get_local $0) + (get_local $5) + ) + (i32.store + (get_local $3) + (get_local $6) + ) + (i32.store + (i32.add + (get_local $0) + (i32.const 8) + ) + (get_local $4) + ) + (br_if $label$0 + (i32.eqz + (get_local $1) + ) + ) + (call $_ZdlPv + (get_local $1) + ) + (return) + ) + ) + (func $_ZN5boost6fusion6detail17for_each_unrolledILi4EE4callINS0_18std_tuple_iteratorIKNSt3__15tupleIJyyN5eosio5assetENS6_12basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEEEELi0EEEZNS8_lsINS8_10datastreamIPcEEJyyS9_SF_EEERT_SO_RKNS7_IJDpT0_EEEEUlRKSN_E_EEvSV_RKT0_ (param $0 i32) (param $1 i32) + (local $2 i32) + (local $3 i32) + (set_local $2 + (i32.load + (get_local $0) + ) + ) + (call $eosio_assert + (i32.gt_s + (i32.sub + (i32.load offset=8 + (tee_local $3 + (i32.load + (get_local $1) + ) + ) + ) + (i32.load offset=4 + (get_local $3) + ) + ) + (i32.const 7) + ) + (i32.const 272) + ) + (drop + (call $memcpy + (i32.load offset=4 + (get_local $3) + ) + (get_local $2) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $3) + (i32.add + (i32.load offset=4 + (get_local $3) + ) + (i32.const 8) + ) + ) + (set_local $0 + (i32.load + (get_local $0) + ) + ) + (call $eosio_assert + (i32.gt_s + (i32.sub + (i32.load offset=8 + (tee_local $3 + (i32.load + (get_local $1) + ) + ) + ) + (i32.load offset=4 + (get_local $3) + ) + ) + (i32.const 7) + ) + (i32.const 272) + ) + (drop + (call $memcpy + (i32.load offset=4 + (get_local $3) + ) + (i32.add + (get_local $0) + (i32.const 8) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $3) + (i32.add + (i32.load offset=4 + (get_local $3) + ) + (i32.const 8) + ) + ) + (call $eosio_assert + (i32.gt_s + (i32.sub + (i32.load offset=8 + (tee_local $3 + (i32.load + (get_local $1) + ) + ) + ) + (i32.load offset=4 + (get_local $3) + ) + ) + (i32.const 7) + ) + (i32.const 272) + ) + (drop + (call $memcpy + (i32.load offset=4 + (get_local $3) + ) + (i32.add + (get_local $0) + (i32.const 16) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $3) + (tee_local $2 + (i32.add + (i32.load offset=4 + (get_local $3) + ) + (i32.const 8) + ) + ) + ) + (call $eosio_assert + (i32.gt_s + (i32.sub + (i32.load offset=8 + (get_local $3) + ) + (get_local $2) + ) + (i32.const 7) + ) + (i32.const 272) + ) + (drop + (call $memcpy + (i32.load offset=4 + (get_local $3) + ) + (i32.add + (get_local $0) + (i32.const 24) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $3) + (i32.add + (i32.load offset=4 + (get_local $3) + ) + (i32.const 8) + ) + ) + (drop + (call $_ZN5eosiolsINS_10datastreamIPcEEEERT_S5_RKNSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEE + (i32.load + (get_local $1) + ) + (i32.add + (get_local $0) + (i32.const 32) + ) + ) + ) + ) + (func $_ZN5eosio4packINS_6actionEEENSt3__16vectorIcNS2_9allocatorIcEEEERKT_ (param $0 i32) (param $1 i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i64) + (local $7 i32) + (local $8 i32) + (i32.store offset=4 + (i32.const 0) + (tee_local $8 + (i32.sub + (i32.load offset=4 + (i32.const 0) + ) + (i32.const 16) + ) + ) + ) + (i32.store offset=8 + (get_local $0) + (i32.const 0) + ) + (i64.store align=4 + (get_local $0) + (i64.const 0) + ) + (set_local $5 + (i32.const 16) + ) + (set_local $2 + (i32.add + (get_local $1) + (i32.const 16) + ) + ) + (set_local $6 + (i64.extend_u/i32 + (i32.shr_s + (tee_local $4 + (i32.sub + (tee_local $7 + (i32.load + (i32.add + (get_local $1) + (i32.const 20) + ) + ) + ) + (tee_local $3 + (i32.load offset=16 + (get_local $1) + ) + ) + ) + ) + (i32.const 4) + ) + ) + ) + (loop $label$0 + (set_local $5 + (i32.add + (get_local $5) + (i32.const 1) + ) + ) + (br_if $label$0 + (i64.ne + (tee_local $6 + (i64.shr_u + (get_local $6) + (i64.const 7) + ) + ) + (i64.const 0) + ) + ) + ) + (block $label$1 + (br_if $label$1 + (i32.eq + (get_local $3) + (get_local $7) + ) + ) + (set_local $5 + (i32.add + (i32.and + (get_local $4) + (i32.const -16) + ) + (get_local $5) + ) + ) + ) + (set_local $5 + (i32.sub + (i32.sub + (tee_local $7 + (i32.load offset=28 + (get_local $1) + ) + ) + (get_local $5) + ) + (tee_local $3 + (i32.load + (i32.add + (get_local $1) + (i32.const 32) + ) + ) + ) + ) + ) + (set_local $4 + (i32.add + (get_local $1) + (i32.const 28) + ) + ) + (set_local $6 + (i64.extend_u/i32 + (i32.sub + (get_local $3) + (get_local $7) + ) + ) + ) + (loop $label$2 + (set_local $5 + (i32.add + (get_local $5) + (i32.const -1) + ) + ) + (br_if $label$2 + (i64.ne + (tee_local $6 + (i64.shr_u + (get_local $6) + (i64.const 7) + ) + ) + (i64.const 0) + ) + ) + ) + (set_local $7 + (i32.const 0) + ) + (block $label$3 + (block $label$4 + (br_if $label$4 + (i32.eqz + (get_local $5) + ) + ) + (call $_ZNSt3__16vectorIcNS_9allocatorIcEEE8__appendEj + (get_local $0) + (i32.sub + (i32.const 0) + (get_local $5) + ) + ) + (set_local $7 + (i32.load + (i32.add + (get_local $0) + (i32.const 4) + ) + ) + ) + (set_local $5 + (i32.load + (get_local $0) + ) + ) + (br $label$3) + ) + (set_local $5 + (i32.const 0) + ) + ) + (i32.store + (get_local $8) + (get_local $5) + ) + (i32.store offset=8 + (get_local $8) + (get_local $7) + ) + (call $eosio_assert + (i32.gt_s + (i32.sub + (get_local $7) + (get_local $5) + ) + (i32.const 7) + ) + (i32.const 272) + ) + (drop + (call $memcpy + (get_local $5) + (get_local $1) + (i32.const 8) + ) + ) + (call $eosio_assert + (i32.gt_s + (i32.sub + (get_local $7) + (tee_local $0 + (i32.add + (get_local $5) + (i32.const 8) + ) + ) + ) + (i32.const 7) + ) + (i32.const 272) + ) + (drop + (call $memcpy + (get_local $0) + (i32.add + (get_local $1) + (i32.const 8) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $8) + (i32.add + (get_local $5) + (i32.const 16) + ) + ) + (drop + (call $_ZN5eosiolsINS_10datastreamIPcEEEERT_S5_RKNSt3__16vectorIcNS6_9allocatorIcEEEE + (call $_ZN5eosiolsINS_10datastreamIPcEENS_16permission_levelEEERT_S6_RKNSt3__16vectorIT0_NS7_9allocatorIS9_EEEE + (get_local $8) + (get_local $2) + ) + (get_local $4) + ) + ) + (i32.store offset=4 + (i32.const 0) + (i32.add + (get_local $8) + (i32.const 16) + ) + ) + ) + (func $_ZN5eosiolsINS_10datastreamIPcEENS_16permission_levelEEERT_S6_RKNSt3__16vectorIT0_NS7_9allocatorIS9_EEEE (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + (local $3 i32) + (local $4 i64) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (i32.store offset=4 + (i32.const 0) + (tee_local $7 + (i32.sub + (i32.load offset=4 + (i32.const 0) + ) + (i32.const 16) + ) + ) + ) + (set_local $4 + (i64.extend_u/i32 + (i32.shr_s + (i32.sub + (i32.load offset=4 + (get_local $1) + ) + (i32.load + (get_local $1) + ) + ) + (i32.const 4) + ) + ) + ) + (set_local $5 + (i32.load offset=4 + (get_local $0) + ) + ) + (set_local $2 + (i32.add + (get_local $0) + (i32.const 8) + ) + ) + (loop $label$0 + (set_local $3 + (i32.wrap/i64 + (get_local $4) + ) + ) + (i32.store8 offset=15 + (get_local $7) + (i32.or + (i32.shl + (tee_local $6 + (i64.ne + (tee_local $4 + (i64.shr_u + (get_local $4) + (i64.const 7) + ) + ) + (i64.const 0) + ) + ) + (i32.const 7) + ) + (i32.and + (get_local $3) + (i32.const 127) + ) + ) + ) + (call $eosio_assert + (i32.gt_s + (i32.sub + (i32.load + (get_local $2) + ) + (get_local $5) + ) + (i32.const 0) + ) + (i32.const 272) + ) + (drop + (call $memcpy + (i32.load + (tee_local $3 + (i32.add + (get_local $0) + (i32.const 4) + ) + ) + ) + (i32.add + (get_local $7) + (i32.const 15) + ) + (i32.const 1) + ) + ) + (i32.store + (get_local $3) + (tee_local $5 + (i32.add + (i32.load + (get_local $3) + ) + (i32.const 1) + ) + ) + ) + (br_if $label$0 + (get_local $6) + ) + ) + (block $label$1 + (br_if $label$1 + (i32.eq + (tee_local $6 + (i32.load + (get_local $1) + ) + ) + (tee_local $1 + (i32.load + (i32.add + (get_local $1) + (i32.const 4) + ) + ) + ) + ) + ) + (set_local $3 + (i32.add + (get_local $0) + (i32.const 4) + ) + ) + (loop $label$2 + (call $eosio_assert + (i32.gt_s + (i32.sub + (i32.load + (tee_local $2 + (i32.add + (get_local $0) + (i32.const 8) + ) + ) + ) + (get_local $5) + ) + (i32.const 7) + ) + (i32.const 272) + ) + (drop + (call $memcpy + (i32.load + (get_local $3) + ) + (get_local $6) + (i32.const 8) + ) + ) + (i32.store + (get_local $3) + (tee_local $5 + (i32.add + (i32.load + (get_local $3) + ) + (i32.const 8) + ) + ) + ) + (call $eosio_assert + (i32.gt_s + (i32.sub + (i32.load + (get_local $2) + ) + (get_local $5) + ) + (i32.const 7) + ) + (i32.const 272) + ) + (drop + (call $memcpy + (i32.load + (get_local $3) + ) + (i32.add + (get_local $6) + (i32.const 8) + ) + (i32.const 8) + ) + ) + (i32.store + (get_local $3) + (tee_local $5 + (i32.add + (i32.load + (get_local $3) + ) + (i32.const 8) + ) + ) + ) + (br_if $label$2 + (i32.ne + (tee_local $6 + (i32.add + (get_local $6) + (i32.const 16) + ) + ) + (get_local $1) + ) + ) + ) + ) + (i32.store offset=4 + (i32.const 0) + (i32.add + (get_local $7) + (i32.const 16) + ) + ) + (get_local $0) + ) + (func $_ZN5eosiolsINS_10datastreamIPcEEEERT_S5_RKNSt3__16vectorIcNS6_9allocatorIcEEEE (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i64) + (local $8 i32) + (i32.store offset=4 + (i32.const 0) + (tee_local $8 + (i32.sub + (i32.load offset=4 + (i32.const 0) + ) + (i32.const 16) + ) + ) + ) + (set_local $7 + (i64.extend_u/i32 + (i32.sub + (i32.load offset=4 + (get_local $1) + ) + (i32.load + (get_local $1) + ) + ) + ) + ) + (set_local $6 + (i32.load offset=4 + (get_local $0) + ) + ) + (set_local $4 + (i32.add + (get_local $0) + (i32.const 8) + ) + ) + (set_local $5 + (i32.add + (get_local $0) + (i32.const 4) + ) + ) + (loop $label$0 + (set_local $2 + (i32.wrap/i64 + (get_local $7) + ) + ) + (i32.store8 offset=15 + (get_local $8) + (i32.or + (i32.shl + (tee_local $3 + (i64.ne + (tee_local $7 + (i64.shr_u + (get_local $7) + (i64.const 7) + ) + ) + (i64.const 0) + ) + ) + (i32.const 7) + ) + (i32.and + (get_local $2) + (i32.const 127) + ) + ) + ) + (call $eosio_assert + (i32.gt_s + (i32.sub + (i32.load + (get_local $4) + ) + (get_local $6) + ) + (i32.const 0) + ) + (i32.const 272) + ) + (drop + (call $memcpy + (i32.load + (get_local $5) + ) + (i32.add + (get_local $8) + (i32.const 15) + ) + (i32.const 1) + ) + ) + (i32.store + (get_local $5) + (tee_local $6 + (i32.add + (i32.load + (get_local $5) + ) + (i32.const 1) + ) + ) + ) + (br_if $label$0 + (get_local $3) + ) + ) + (call $eosio_assert + (i32.ge_s + (i32.sub + (i32.load + (i32.add + (get_local $0) + (i32.const 8) + ) + ) + (get_local $6) + ) + (tee_local $5 + (i32.sub + (i32.load + (i32.add + (get_local $1) + (i32.const 4) + ) + ) + (tee_local $2 + (i32.load + (get_local $1) + ) + ) + ) + ) + ) + (i32.const 272) + ) + (drop + (call $memcpy + (i32.load + (tee_local $6 + (i32.add + (get_local $0) + (i32.const 4) + ) + ) + ) + (get_local $2) + (get_local $5) + ) + ) + (i32.store + (get_local $6) + (i32.add + (i32.load + (get_local $6) + ) + (get_local $5) + ) + ) + (i32.store offset=4 + (i32.const 0) + (i32.add + (get_local $8) + (i32.const 16) + ) + ) + (get_local $0) + ) + (func $_ZN5eosiolsINS_10datastreamIPcEEEERT_S5_RKNSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEE (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i64) + (local $8 i32) + (i32.store offset=4 + (i32.const 0) + (tee_local $8 + (i32.sub + (i32.load offset=4 + (i32.const 0) + ) + (i32.const 16) + ) + ) + ) + (set_local $7 + (i64.extend_u/i32 + (select + (i32.load offset=4 + (get_local $1) + ) + (i32.shr_u + (tee_local $5 + (i32.load8_u + (get_local $1) + ) + ) + (i32.const 1) + ) + (i32.and + (get_local $5) + (i32.const 1) + ) + ) + ) + ) + (set_local $6 + (i32.load offset=4 + (get_local $0) + ) + ) + (set_local $4 + (i32.add + (get_local $0) + (i32.const 8) + ) + ) + (set_local $5 + (i32.add + (get_local $0) + (i32.const 4) + ) + ) + (loop $label$0 + (set_local $2 + (i32.wrap/i64 + (get_local $7) + ) + ) + (i32.store8 offset=15 + (get_local $8) + (i32.or + (i32.shl + (tee_local $3 + (i64.ne + (tee_local $7 + (i64.shr_u + (get_local $7) + (i64.const 7) + ) + ) + (i64.const 0) + ) + ) + (i32.const 7) + ) + (i32.and + (get_local $2) + (i32.const 127) + ) + ) + ) + (call $eosio_assert + (i32.gt_s + (i32.sub + (i32.load + (get_local $4) + ) + (get_local $6) + ) + (i32.const 0) + ) + (i32.const 272) + ) + (drop + (call $memcpy + (i32.load + (get_local $5) + ) + (i32.add + (get_local $8) + (i32.const 15) + ) + (i32.const 1) + ) + ) + (i32.store + (get_local $5) + (tee_local $6 + (i32.add + (i32.load + (get_local $5) + ) + (i32.const 1) + ) + ) + ) + (br_if $label$0 + (get_local $3) + ) + ) + (block $label$1 + (br_if $label$1 + (i32.eqz + (tee_local $5 + (select + (i32.load + (i32.add + (get_local $1) + (i32.const 4) + ) + ) + (i32.shr_u + (tee_local $5 + (i32.load8_u + (get_local $1) + ) + ) + (i32.const 1) + ) + (tee_local $2 + (i32.and + (get_local $5) + (i32.const 1) + ) + ) + ) + ) + ) + ) + (set_local $3 + (i32.load offset=8 + (get_local $1) + ) + ) + (call $eosio_assert + (i32.ge_s + (i32.sub + (i32.load + (i32.add + (get_local $0) + (i32.const 8) + ) + ) + (get_local $6) + ) + (get_local $5) + ) + (i32.const 272) + ) + (drop + (call $memcpy + (i32.load + (tee_local $6 + (i32.add + (get_local $0) + (i32.const 4) + ) + ) + ) + (select + (get_local $3) + (i32.add + (get_local $1) + (i32.const 1) + ) + (get_local $2) + ) + (get_local $5) + ) + ) + (i32.store + (get_local $6) + (i32.add + (i32.load + (get_local $6) + ) + (get_local $5) + ) + ) + ) + (i32.store offset=4 + (i32.const 0) + (i32.add + (get_local $8) + (i32.const 16) + ) + ) + (get_local $0) + ) + (func $_ZNK5eosio11multi_indexILy3607749779137757184ENS_5token7accountEJEE31load_object_by_primary_iteratorEl (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (local $8 i64) + (local $9 i32) + (local $10 i32) + (set_local $9 + (tee_local $10 + (i32.sub + (i32.load offset=4 + (i32.const 0) + ) + (i32.const 32) + ) + ) + ) + (i32.store offset=4 + (i32.const 0) + (get_local $10) + ) + (block $label$0 + (br_if $label$0 + (i32.eq + (tee_local $7 + (i32.load + (i32.add + (get_local $0) + (i32.const 28) + ) + ) + ) + (tee_local $3 + (i32.load offset=24 + (get_local $0) + ) + ) + ) + ) + (set_local $4 + (i32.sub + (i32.const 0) + (get_local $3) + ) + ) + (set_local $6 + (i32.add + (get_local $7) + (i32.const -24) + ) + ) + (loop $label$1 + (br_if $label$0 + (i32.eq + (i32.load + (i32.add + (get_local $6) + (i32.const 16) + ) + ) + (get_local $1) + ) + ) + (set_local $7 + (get_local $6) + ) + (set_local $6 + (tee_local $5 + (i32.add + (get_local $6) + (i32.const -24) + ) + ) + ) + (br_if $label$1 + (i32.ne + (i32.add + (get_local $5) + (get_local $4) + ) + (i32.const -24) + ) + ) + ) + ) + (block $label$2 + (block $label$3 + (br_if $label$3 + (i32.eq + (get_local $7) + (get_local $3) + ) + ) + (set_local $5 + (i32.load + (i32.add + (get_local $7) + (i32.const -24) + ) + ) + ) + (br $label$2) + ) + (call $eosio_assert + (i32.xor + (i32.shr_u + (tee_local $7 + (call $db_get_i64 + (get_local $1) + (i32.const 0) + (i32.const 0) + ) + ) + (i32.const 31) + ) + (i32.const 1) + ) + (i32.const 352) + ) + (block $label$4 + (block $label$5 + (br_if $label$5 + (i32.le_u + (get_local $7) + (i32.const 512) + ) + ) + (drop + (call $db_get_i64 + (get_local $1) + (tee_local $3 + (call $malloc + (get_local $7) + ) + ) + (get_local $7) + ) + ) + (call $free + (get_local $3) + ) + (br $label$4) + ) + (i32.store offset=4 + (i32.const 0) + (tee_local $3 + (i32.sub + (get_local $10) + (i32.and + (i32.add + (get_local $7) + (i32.const 15) + ) + (i32.const -16) + ) + ) + ) + ) + (drop + (call $db_get_i64 + (get_local $1) + (get_local $3) + (get_local $7) + ) + ) + ) + (set_local $2 + (i32.add + (get_local $0) + (i32.const 24) + ) + ) + (i64.store offset=8 + (tee_local $5 + (call $_Znwj + (i32.const 32) + ) + ) + (i64.const 1398362884) + ) + (i64.store + (get_local $5) + (i64.const 0) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 288) + ) + (set_local $10 + (i32.add + (get_local $5) + (i32.const 8) + ) + ) + (set_local $8 + (i64.const 5462355) + ) + (set_local $6 + (i32.const 0) + ) + (block $label$6 + (block $label$7 + (loop $label$8 + (br_if $label$7 + (i32.gt_u + (i32.add + (i32.shl + (i32.wrap/i64 + (get_local $8) + ) + (i32.const 24) + ) + (i32.const -1073741825) + ) + (i32.const 452984830) + ) + ) + (block $label$9 + (br_if $label$9 + (i64.ne + (i64.and + (tee_local $8 + (i64.shr_u + (get_local $8) + (i64.const 8) + ) + ) + (i64.const 255) + ) + (i64.const 0) + ) + ) + (loop $label$10 + (br_if $label$7 + (i64.ne + (i64.and + (tee_local $8 + (i64.shr_u + (get_local $8) + (i64.const 8) + ) + ) + (i64.const 255) + ) + (i64.const 0) + ) + ) + (br_if $label$10 + (i32.lt_s + (tee_local $6 + (i32.add + (get_local $6) + (i32.const 1) + ) + ) + (i32.const 7) + ) + ) + ) + ) + (set_local $4 + (i32.const 1) + ) + (br_if $label$8 + (i32.lt_s + (tee_local $6 + (i32.add + (get_local $6) + (i32.const 1) + ) + ) + (i32.const 7) + ) + ) + (br $label$6) + ) + ) + (set_local $4 + (i32.const 0) + ) + ) + (call $eosio_assert + (get_local $4) + (i32.const 16) + ) + (i32.store offset=16 + (get_local $5) + (get_local $0) + ) + (call $eosio_assert + (i32.gt_u + (get_local $7) + (i32.const 7) + ) + (i32.const 384) + ) + (drop + (call $memcpy + (get_local $5) + (get_local $3) + (i32.const 8) + ) + ) + (call $eosio_assert + (i32.ne + (i32.and + (get_local $7) + (i32.const -8) + ) + (i32.const 8) + ) + (i32.const 384) + ) + (drop + (call $memcpy + (get_local $10) + (i32.add + (get_local $3) + (i32.const 8) + ) + (i32.const 8) + ) + ) + (i32.store offset=20 + (get_local $5) + (get_local $1) + ) + (i32.store offset=24 + (get_local $9) + (get_local $5) + ) + (i64.store offset=16 + (get_local $9) + (tee_local $8 + (i64.shr_u + (i64.load + (i32.add + (get_local $5) + (i32.const 8) + ) + ) + (i64.const 8) + ) + ) + ) + (i32.store offset=12 + (get_local $9) + (tee_local $7 + (i32.load offset=20 + (get_local $5) + ) + ) + ) + (block $label$11 + (block $label$12 + (br_if $label$12 + (i32.ge_u + (tee_local $6 + (i32.load + (tee_local $1 + (i32.add + (get_local $0) + (i32.const 28) + ) + ) + ) + ) + (i32.load + (i32.add + (get_local $0) + (i32.const 32) + ) + ) + ) + ) + (i64.store offset=8 + (get_local $6) + (get_local $8) + ) + (i32.store offset=16 + (get_local $6) + (get_local $7) + ) + (i32.store offset=24 + (get_local $9) + (i32.const 0) + ) + (i32.store + (get_local $6) + (get_local $5) + ) + (i32.store + (get_local $1) + (i32.add + (get_local $6) + (i32.const 24) + ) + ) + (br $label$11) + ) + (call $_ZNSt3__16vectorIN5eosio11multi_indexILy3607749779137757184ENS1_5token7accountEJEE8item_ptrENS_9allocatorIS6_EEE24__emplace_back_slow_pathIJNS_10unique_ptrINS5_4itemENS_14default_deleteISC_EEEERyRlEEEvDpOT_ + (get_local $2) + (i32.add + (get_local $9) + (i32.const 24) + ) + (i32.add + (get_local $9) + (i32.const 16) + ) + (i32.add + (get_local $9) + (i32.const 12) + ) + ) + ) + (set_local $6 + (i32.load offset=24 + (get_local $9) + ) + ) + (i32.store offset=24 + (get_local $9) + (i32.const 0) + ) + (br_if $label$2 + (i32.eqz + (get_local $6) + ) + ) + (call $_ZdlPv + (get_local $6) + ) + ) + (i32.store offset=4 + (i32.const 0) + (i32.add + (get_local $9) + (i32.const 32) + ) + ) + (get_local $5) + ) + (func $_ZNSt3__16vectorIN5eosio11multi_indexILy3607749779137757184ENS1_5token7accountEJEE8item_ptrENS_9allocatorIS6_EEE24__emplace_back_slow_pathIJNS_10unique_ptrINS5_4itemENS_14default_deleteISC_EEEERyRlEEEvDpOT_ (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (block $label$0 + (block $label$1 + (br_if $label$1 + (i32.ge_u + (tee_local $5 + (i32.add + (tee_local $4 + (i32.div_s + (i32.sub + (i32.load offset=4 + (get_local $0) + ) + (tee_local $6 + (i32.load + (get_local $0) + ) + ) + ) + (i32.const 24) + ) + ) + (i32.const 1) + ) + ) + (i32.const 178956971) + ) + ) + (set_local $7 + (i32.const 178956970) + ) + (block $label$2 + (block $label$3 + (br_if $label$3 + (i32.gt_u + (tee_local $6 + (i32.div_s + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (get_local $6) + ) + (i32.const 24) + ) + ) + (i32.const 89478484) + ) + ) + (br_if $label$2 + (i32.eqz + (tee_local $7 + (select + (get_local $5) + (tee_local $7 + (i32.shl + (get_local $6) + (i32.const 1) + ) + ) + (i32.lt_u + (get_local $7) + (get_local $5) + ) + ) + ) + ) + ) + ) + (set_local $6 + (call $_Znwj + (i32.mul + (get_local $7) + (i32.const 24) + ) + ) + ) + (br $label$0) + ) + (set_local $7 + (i32.const 0) + ) + (set_local $6 + (i32.const 0) + ) + (br $label$0) + ) + (call $_ZNKSt3__120__vector_base_commonILb1EE20__throw_length_errorEv + (get_local $0) + ) + (unreachable) + ) + (set_local $5 + (i32.load + (get_local $1) + ) + ) + (i32.store + (get_local $1) + (i32.const 0) + ) + (i32.store + (tee_local $1 + (i32.add + (get_local $6) + (i32.mul + (get_local $4) + (i32.const 24) + ) + ) + ) + (get_local $5) + ) + (i64.store offset=8 + (get_local $1) + (i64.load + (get_local $2) + ) + ) + (i32.store offset=16 + (get_local $1) + (i32.load + (get_local $3) + ) + ) + (set_local $4 + (i32.add + (get_local $6) + (i32.mul + (get_local $7) + (i32.const 24) + ) + ) + ) + (set_local $5 + (i32.add + (get_local $1) + (i32.const 24) + ) + ) + (block $label$4 + (block $label$5 + (br_if $label$5 + (i32.eq + (tee_local $6 + (i32.load + (i32.add + (get_local $0) + (i32.const 4) + ) + ) + ) + (tee_local $7 + (i32.load + (get_local $0) + ) + ) + ) + ) + (loop $label$6 + (set_local $3 + (i32.load + (tee_local $2 + (i32.add + (get_local $6) + (i32.const -24) + ) + ) + ) + ) + (i32.store + (get_local $2) + (i32.const 0) + ) + (i32.store + (i32.add + (get_local $1) + (i32.const -24) + ) + (get_local $3) + ) + (i32.store + (i32.add + (get_local $1) + (i32.const -8) + ) + (i32.load + (i32.add + (get_local $6) + (i32.const -8) + ) + ) + ) + (i32.store + (i32.add + (get_local $1) + (i32.const -12) + ) + (i32.load + (i32.add + (get_local $6) + (i32.const -12) + ) + ) + ) + (i32.store + (i32.add + (get_local $1) + (i32.const -16) + ) + (i32.load + (i32.add + (get_local $6) + (i32.const -16) + ) + ) + ) + (set_local $1 + (i32.add + (get_local $1) + (i32.const -24) + ) + ) + (set_local $6 + (get_local $2) + ) + (br_if $label$6 + (i32.ne + (get_local $7) + (get_local $2) + ) + ) + ) + (set_local $7 + (i32.load + (i32.add + (get_local $0) + (i32.const 4) + ) + ) + ) + (set_local $6 + (i32.load + (get_local $0) + ) + ) + (br $label$4) + ) + (set_local $6 + (get_local $7) + ) + ) + (i32.store + (get_local $0) + (get_local $1) + ) + (i32.store + (i32.add + (get_local $0) + (i32.const 4) + ) + (get_local $5) + ) + (i32.store + (i32.add + (get_local $0) + (i32.const 8) + ) + (get_local $4) + ) + (block $label$7 + (br_if $label$7 + (i32.eq + (get_local $7) + (get_local $6) + ) + ) + (loop $label$8 + (set_local $1 + (i32.load + (tee_local $7 + (i32.add + (get_local $7) + (i32.const -24) + ) + ) + ) + ) + (i32.store + (get_local $7) + (i32.const 0) + ) + (block $label$9 + (br_if $label$9 + (i32.eqz + (get_local $1) + ) + ) + (call $_ZdlPv + (get_local $1) + ) + ) + (br_if $label$8 + (i32.ne + (get_local $6) + (get_local $7) + ) + ) + ) + ) + (block $label$10 + (br_if $label$10 + (i32.eqz + (get_local $6) + ) + ) + (call $_ZdlPv + (get_local $6) + ) + ) + ) + (func $_ZN5eosio5token8transferEyyNS_5assetENSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE (type $FUNCSIG$vijjii) (param $0 i32) (param $1 i64) (param $2 i64) (param $3 i32) (param $4 i32) + (local $5 i64) + (local $6 i32) + (local $7 i64) + (local $8 i32) + (local $9 i32) + (local $10 i64) + (local $11 i64) + (local $12 i64) + (local $13 i64) + (local $14 i32) + (i32.store offset=4 + (i32.const 0) + (tee_local $14 + (i32.sub + (i32.load offset=4 + (i32.const 0) + ) + (i32.const 144) + ) + ) + ) + (call $eosio_assert + (i64.ne + (get_local $1) + (get_local $2) + ) + (i32.const 992) + ) + (call $require_auth + (get_local $1) + ) + (call $eosio_assert + (call $is_account + (get_local $2) + ) + (i32.const 1024) + ) + (set_local $10 + (i64.load offset=8 + (get_local $3) + ) + ) + (set_local $8 + (i32.const 0) + ) + (i32.store + (i32.add + (get_local $14) + (i32.const 96) + ) + (i32.const 0) + ) + (i64.store offset=72 + (get_local $14) + (tee_local $5 + (i64.shr_u + (get_local $10) + (i64.const 8) + ) + ) + ) + (i64.store offset=80 + (get_local $14) + (i64.const -1) + ) + (i64.store offset=88 + (get_local $14) + (i64.const 0) + ) + (i64.store offset=64 + (get_local $14) + (i64.load + (get_local $0) + ) + ) + (set_local $6 + (call $_ZNK5eosio11multi_indexILy14289235522390851584ENS_5token13currency_statEJEE3getEyPKc + (i32.add + (get_local $14) + (i32.const 64) + ) + (get_local $5) + (i32.const 1056) + ) + ) + (call $require_recipient + (get_local $1) + ) + (call $require_recipient + (get_local $2) + ) + (block $label$0 + (br_if $label$0 + (i64.gt_u + (i64.add + (tee_local $13 + (i64.load + (get_local $3) + ) + ) + (i64.const 4611686018427387903) + ) + (i64.const 9223372036854775806) + ) + ) + (set_local $9 + (i32.const 0) + ) + (set_local $11 + (get_local $5) + ) + (block $label$1 + (loop $label$2 + (br_if $label$1 + (i32.gt_u + (i32.add + (i32.shl + (i32.wrap/i64 + (get_local $11) + ) + (i32.const 24) + ) + (i32.const -1073741825) + ) + (i32.const 452984830) + ) + ) + (block $label$3 + (br_if $label$3 + (i64.ne + (i64.and + (tee_local $11 + (i64.shr_u + (get_local $11) + (i64.const 8) + ) + ) + (i64.const 255) + ) + (i64.const 0) + ) + ) + (loop $label$4 + (br_if $label$1 + (i64.ne + (i64.and + (tee_local $11 + (i64.shr_u + (get_local $11) + (i64.const 8) + ) + ) + (i64.const 255) + ) + (i64.const 0) + ) + ) + (br_if $label$4 + (i32.lt_s + (tee_local $9 + (i32.add + (get_local $9) + (i32.const 1) + ) + ) + (i32.const 7) + ) + ) + ) + ) + (set_local $8 + (i32.const 1) + ) + (br_if $label$2 + (i32.lt_s + (tee_local $9 + (i32.add + (get_local $9) + (i32.const 1) + ) + ) + (i32.const 7) + ) + ) + (br $label$0) + ) + ) + (set_local $8 + (i32.const 0) + ) + ) + (call $eosio_assert + (get_local $8) + (i32.const 496) + ) + (call $eosio_assert + (i64.gt_s + (get_local $13) + (i64.const 0) + ) + (i32.const 1088) + ) + (call $eosio_assert + (i64.eq + (get_local $10) + (i64.load offset=8 + (get_local $6) + ) + ) + (i32.const 560) + ) + (block $label$5 + (block $label$6 + (br_if $label$6 + (i32.and + (tee_local $9 + (i32.load8_u + (get_local $4) + ) + ) + (i32.const 1) + ) + ) + (set_local $9 + (i32.shr_u + (get_local $9) + (i32.const 1) + ) + ) + (br $label$5) + ) + (set_local $9 + (i32.load offset=4 + (get_local $4) + ) + ) + ) + (call $eosio_assert + (i32.lt_u + (get_local $9) + (i32.const 257) + ) + (i32.const 400) + ) + (set_local $11 + (i64.const 0) + ) + (set_local $10 + (i64.const 59) + ) + (set_local $9 + (i32.const 1120) + ) + (set_local $7 + (call $current_time) + ) + (set_local $12 + (i64.const 0) + ) + (loop $label$7 + (set_local $13 + (i64.const 0) + ) + (block $label$8 + (br_if $label$8 + (i64.gt_u + (get_local $11) + (i64.const 11) + ) + ) + (block $label$9 + (block $label$10 + (br_if $label$10 + (i32.gt_u + (i32.and + (i32.add + (tee_local $8 + (i32.load8_s + (get_local $9) + ) + ) + (i32.const -97) + ) + (i32.const 255) + ) + (i32.const 25) + ) + ) + (set_local $8 + (i32.add + (get_local $8) + (i32.const 165) + ) + ) + (br $label$9) + ) + (set_local $8 + (select + (i32.add + (get_local $8) + (i32.const 208) + ) + (i32.const 0) + (i32.lt_u + (i32.and + (i32.add + (get_local $8) + (i32.const -49) + ) + (i32.const 255) + ) + (i32.const 5) + ) + ) + ) + ) + (set_local $13 + (i64.shl + (i64.extend_u/i32 + (i32.and + (get_local $8) + (i32.const 31) + ) + ) + (i64.and + (get_local $10) + (i64.const 4294967295) + ) + ) + ) + ) + (set_local $9 + (i32.add + (get_local $9) + (i32.const 1) + ) + ) + (set_local $11 + (i64.add + (get_local $11) + (i64.const 1) + ) + ) + (set_local $12 + (i64.or + (get_local $13) + (get_local $12) + ) + ) + (br_if $label$7 + (i64.ne + (tee_local $10 + (i64.add + (get_local $10) + (i64.const -5) + ) + ) + (i64.const -6) + ) + ) + ) + (block $label$11 + (br_if $label$11 + (i64.eq + (get_local $12) + (get_local $2) + ) + ) + (i32.store + (i32.add + (get_local $14) + (i32.const 136) + ) + (i32.const 0) + ) + (i64.store offset=120 + (get_local $14) + (i64.const -1) + ) + (set_local $11 + (i64.const 0) + ) + (i64.store offset=128 + (get_local $14) + (i64.const 0) + ) + (i64.store offset=104 + (get_local $14) + (tee_local $10 + (i64.load + (get_local $0) + ) + ) + ) + (i64.store offset=112 + (get_local $14) + (get_local $1) + ) + (block $label$12 + (br_if $label$12 + (i32.lt_s + (tee_local $9 + (call $db_find_i64 + (get_local $10) + (get_local $1) + (i64.const 5382478059301502976) + (get_local $5) + ) + ) + (i32.const 0) + ) + ) + (call $eosio_assert + (i32.eq + (i32.load offset=16 + (tee_local $9 + (call $_ZNK5eosio11multi_indexILy5382478059301502976ENS_5token6detailEJEE31load_object_by_primary_iteratorEl + (i32.add + (get_local $14) + (i32.const 104) + ) + (get_local $9) + ) + ) + ) + (i32.add + (get_local $14) + (i32.const 104) + ) + ) + (i32.const 96) + ) + (set_local $11 + (i64.load offset=8 + (get_local $9) + ) + ) + (br_if $label$12 + (i32.eqz + (tee_local $4 + (i32.load offset=128 + (get_local $14) + ) + ) + ) + ) + (block $label$13 + (block $label$14 + (br_if $label$14 + (i32.eq + (tee_local $9 + (i32.load + (tee_local $6 + (i32.add + (get_local $14) + (i32.const 132) + ) + ) + ) + ) + (get_local $4) + ) + ) + (loop $label$15 + (set_local $8 + (i32.load + (tee_local $9 + (i32.add + (get_local $9) + (i32.const -24) + ) + ) + ) + ) + (i32.store + (get_local $9) + (i32.const 0) + ) + (block $label$16 + (br_if $label$16 + (i32.eqz + (get_local $8) + ) + ) + (call $_ZdlPv + (get_local $8) + ) + ) + (br_if $label$15 + (i32.ne + (get_local $4) + (get_local $9) + ) + ) + ) + (set_local $9 + (i32.load + (i32.add + (get_local $14) + (i32.const 128) + ) + ) + ) + (br $label$13) + ) + (set_local $9 + (get_local $4) + ) + ) + (i32.store + (get_local $6) + (get_local $4) + ) + (call $_ZdlPv + (get_local $9) + ) + ) + (call $eosio_assert + (i64.gt_u + (get_local $7) + (i64.add + (i64.load offset=8 + (get_local $0) + ) + (get_local $11) + ) + ) + (i32.const 1136) + ) + ) + (i64.store + (i32.add + (i32.add + (get_local $14) + (i32.const 48) + ) + (i32.const 8) + ) + (tee_local $11 + (i64.load + (tee_local $9 + (i32.add + (get_local $3) + (i32.const 8) + ) + ) + ) + ) + ) + (set_local $10 + (i64.load + (get_local $3) + ) + ) + (i64.store + (i32.add + (i32.add + (get_local $14) + (i32.const 16) + ) + (i32.const 8) + ) + (get_local $11) + ) + (i64.store offset=48 + (get_local $14) + (get_local $10) + ) + (i32.store offset=20 + (get_local $14) + (i32.load offset=52 + (get_local $14) + ) + ) + (i32.store offset=16 + (get_local $14) + (i32.load offset=48 + (get_local $14) + ) + ) + (call $_ZN5eosio5token11sub_balanceEyNS_5assetE + (get_local $0) + (get_local $1) + (i32.add + (get_local $14) + (i32.const 16) + ) + ) + (i64.store + (tee_local $8 + (i32.add + (i32.add + (get_local $14) + (i32.const 32) + ) + (i32.const 8) + ) + ) + (i64.load + (get_local $9) + ) + ) + (set_local $11 + (i64.load + (get_local $3) + ) + ) + (i32.store + (i32.add + (get_local $14) + (i32.const 12) + ) + (i32.load + (i32.add + (i32.add + (get_local $14) + (i32.const 32) + ) + (i32.const 12) + ) + ) + ) + (i32.store + (i32.add + (get_local $14) + (i32.const 8) + ) + (i32.load + (get_local $8) + ) + ) + (i64.store offset=32 + (get_local $14) + (get_local $11) + ) + (i32.store offset=4 + (get_local $14) + (i32.load offset=36 + (get_local $14) + ) + ) + (i32.store + (get_local $14) + (i32.load offset=32 + (get_local $14) + ) + ) + (call $_ZN5eosio5token11add_balanceEyNS_5assetEy + (get_local $0) + (get_local $2) + (get_local $14) + (get_local $1) + ) + (block $label$17 + (br_if $label$17 + (i32.eqz + (tee_local $3 + (i32.load offset=88 + (get_local $14) + ) + ) + ) + ) + (block $label$18 + (block $label$19 + (br_if $label$19 + (i32.eq + (tee_local $9 + (i32.load + (tee_local $0 + (i32.add + (get_local $14) + (i32.const 92) + ) + ) + ) + ) + (get_local $3) + ) + ) + (loop $label$20 + (set_local $8 + (i32.load + (tee_local $9 + (i32.add + (get_local $9) + (i32.const -24) + ) + ) + ) + ) + (i32.store + (get_local $9) + (i32.const 0) + ) + (block $label$21 + (br_if $label$21 + (i32.eqz + (get_local $8) + ) + ) + (call $_ZdlPv + (get_local $8) + ) + ) + (br_if $label$20 + (i32.ne + (get_local $3) + (get_local $9) + ) + ) + ) + (set_local $9 + (i32.load + (i32.add + (get_local $14) + (i32.const 88) + ) + ) + ) + (br $label$18) + ) + (set_local $9 + (get_local $3) + ) + ) + (i32.store + (get_local $0) + (get_local $3) + ) + (call $_ZdlPv + (get_local $9) + ) + ) + (i32.store offset=4 + (i32.const 0) + (i32.add + (get_local $14) + (i32.const 144) + ) + ) + ) + (func $_ZNK5eosio11multi_indexILy14289235522390851584ENS_5token13currency_statEJEE3getEyPKc (param $0 i32) (param $1 i64) (param $2 i32) (result i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (block $label$0 + (br_if $label$0 + (i32.eq + (tee_local $7 + (i32.load + (i32.add + (get_local $0) + (i32.const 28) + ) + ) + ) + (tee_local $3 + (i32.load offset=24 + (get_local $0) + ) + ) + ) + ) + (set_local $6 + (i32.add + (get_local $7) + (i32.const -24) + ) + ) + (set_local $4 + (i32.sub + (i32.const 0) + (get_local $3) + ) + ) + (loop $label$1 + (br_if $label$0 + (i64.eq + (i64.shr_u + (i64.load offset=8 + (i32.load + (get_local $6) + ) + ) + (i64.const 8) + ) + (get_local $1) + ) + ) + (set_local $7 + (get_local $6) + ) + (set_local $6 + (tee_local $5 + (i32.add + (get_local $6) + (i32.const -24) + ) + ) + ) + (br_if $label$1 + (i32.ne + (i32.add + (get_local $5) + (get_local $4) + ) + (i32.const -24) + ) + ) + ) + ) + (block $label$2 + (block $label$3 + (br_if $label$3 + (i32.eq + (get_local $7) + (get_local $3) + ) + ) + (call $eosio_assert + (i32.eq + (i32.load offset=40 + (tee_local $6 + (i32.load + (i32.add + (get_local $7) + (i32.const -24) + ) + ) + ) + ) + (get_local $0) + ) + (i32.const 96) + ) + (br $label$2) + ) + (set_local $6 + (i32.const 0) + ) + (br_if $label$2 + (i32.lt_s + (tee_local $5 + (call $db_find_i64 + (i64.load + (get_local $0) + ) + (i64.load offset=8 + (get_local $0) + ) + (i64.const -4157508551318700032) + (get_local $1) + ) + ) + (i32.const 0) + ) + ) + (call $eosio_assert + (i32.eq + (i32.load offset=40 + (tee_local $6 + (call $_ZNK5eosio11multi_indexILy14289235522390851584ENS_5token13currency_statEJEE31load_object_by_primary_iteratorEl + (get_local $0) + (get_local $5) + ) + ) + ) + (get_local $0) + ) + (i32.const 96) + ) + ) + (call $eosio_assert + (i32.ne + (get_local $6) + (i32.const 0) + ) + (get_local $2) + ) + (get_local $6) + ) + (func $_ZNK5eosio11multi_indexILy5382478059301502976ENS_5token6detailEJEE31load_object_by_primary_iteratorEl (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 i64) + (local $6 i32) + (local $7 i32) + (local $8 i32) + (local $9 i32) + (set_local $8 + (tee_local $9 + (i32.sub + (i32.load offset=4 + (i32.const 0) + ) + (i32.const 32) + ) + ) + ) + (i32.store offset=4 + (i32.const 0) + (get_local $9) + ) + (block $label$0 + (br_if $label$0 + (i32.eq + (tee_local $7 + (i32.load + (i32.add + (get_local $0) + (i32.const 28) + ) + ) + ) + (tee_local $2 + (i32.load offset=24 + (get_local $0) + ) + ) + ) + ) + (set_local $3 + (i32.sub + (i32.const 0) + (get_local $2) + ) + ) + (set_local $6 + (i32.add + (get_local $7) + (i32.const -24) + ) + ) + (loop $label$1 + (br_if $label$0 + (i32.eq + (i32.load + (i32.add + (get_local $6) + (i32.const 16) + ) + ) + (get_local $1) + ) + ) + (set_local $7 + (get_local $6) + ) + (set_local $6 + (tee_local $4 + (i32.add + (get_local $6) + (i32.const -24) + ) + ) + ) + (br_if $label$1 + (i32.ne + (i32.add + (get_local $4) + (get_local $3) + ) + (i32.const -24) + ) + ) + ) + ) + (block $label$2 + (block $label$3 + (br_if $label$3 + (i32.eq + (get_local $7) + (get_local $2) + ) + ) + (set_local $6 + (i32.load + (i32.add + (get_local $7) + (i32.const -24) + ) + ) + ) + (br $label$2) + ) + (call $eosio_assert + (i32.xor + (i32.shr_u + (tee_local $4 + (call $db_get_i64 + (get_local $1) + (i32.const 0) + (i32.const 0) + ) + ) + (i32.const 31) + ) + (i32.const 1) + ) + (i32.const 352) + ) + (block $label$4 + (block $label$5 + (br_if $label$5 + (i32.le_u + (get_local $4) + (i32.const 512) + ) + ) + (drop + (call $db_get_i64 + (get_local $1) + (tee_local $7 + (call $malloc + (get_local $4) + ) + ) + (get_local $4) + ) + ) + (call $free + (get_local $7) + ) + (br $label$4) + ) + (i32.store offset=4 + (i32.const 0) + (tee_local $7 + (i32.sub + (get_local $9) + (i32.and + (i32.add + (get_local $4) + (i32.const 15) + ) + (i32.const -16) + ) + ) + ) + ) + (drop + (call $db_get_i64 + (get_local $1) + (get_local $7) + (get_local $4) + ) + ) + ) + (i32.store offset=16 + (tee_local $6 + (call $_Znwj + (i32.const 32) + ) + ) + (get_local $0) + ) + (call $eosio_assert + (i32.gt_u + (get_local $4) + (i32.const 7) + ) + (i32.const 384) + ) + (drop + (call $memcpy + (get_local $6) + (get_local $7) + (i32.const 8) + ) + ) + (call $eosio_assert + (i32.ne + (i32.and + (get_local $4) + (i32.const -8) + ) + (i32.const 8) + ) + (i32.const 384) + ) + (drop + (call $memcpy + (i32.add + (get_local $6) + (i32.const 8) + ) + (i32.add + (get_local $7) + (i32.const 8) + ) + (i32.const 8) + ) + ) + (i32.store offset=20 + (get_local $6) + (get_local $1) + ) + (i32.store offset=24 + (get_local $8) + (get_local $6) + ) + (i64.store offset=16 + (get_local $8) + (tee_local $5 + (i64.load + (get_local $6) + ) + ) + ) + (i32.store offset=12 + (get_local $8) + (tee_local $7 + (i32.load offset=20 + (get_local $6) + ) + ) + ) + (block $label$6 + (block $label$7 + (br_if $label$7 + (i32.ge_u + (tee_local $4 + (i32.load + (tee_local $1 + (i32.add + (get_local $0) + (i32.const 28) + ) + ) + ) + ) + (i32.load + (i32.add + (get_local $0) + (i32.const 32) + ) + ) + ) + ) + (i64.store offset=8 + (get_local $4) + (get_local $5) + ) + (i32.store offset=16 + (get_local $4) + (get_local $7) + ) + (i32.store offset=24 + (get_local $8) + (i32.const 0) + ) + (i32.store + (get_local $4) + (get_local $6) + ) + (i32.store + (get_local $1) + (i32.add + (get_local $4) + (i32.const 24) + ) + ) + (br $label$6) + ) + (call $_ZNSt3__16vectorIN5eosio11multi_indexILy5382478059301502976ENS1_5token6detailEJEE8item_ptrENS_9allocatorIS6_EEE24__emplace_back_slow_pathIJNS_10unique_ptrINS5_4itemENS_14default_deleteISC_EEEERyRlEEEvDpOT_ + (i32.add + (get_local $0) + (i32.const 24) + ) + (i32.add + (get_local $8) + (i32.const 24) + ) + (i32.add + (get_local $8) + (i32.const 16) + ) + (i32.add + (get_local $8) + (i32.const 12) + ) + ) + ) + (set_local $4 + (i32.load offset=24 + (get_local $8) + ) + ) + (i32.store offset=24 + (get_local $8) + (i32.const 0) + ) + (br_if $label$2 + (i32.eqz + (get_local $4) + ) + ) + (call $_ZdlPv + (get_local $4) + ) + ) + (i32.store offset=4 + (i32.const 0) + (i32.add + (get_local $8) + (i32.const 32) + ) + ) + (get_local $6) + ) + (func $_ZN5eosio5token11sub_balanceEyNS_5assetE (param $0 i32) (param $1 i64) (param $2 i32) + (local $3 i64) + (local $4 i32) + (local $5 i64) + (local $6 i32) + (local $7 i32) + (i32.store offset=4 + (i32.const 0) + (tee_local $7 + (i32.sub + (i32.load offset=4 + (i32.const 0) + ) + (i32.const 64) + ) + ) + ) + (i32.store + (i32.add + (get_local $7) + (i32.const 40) + ) + (i32.const 0) + ) + (i64.store offset=16 + (get_local $7) + (get_local $1) + ) + (i64.store offset=24 + (get_local $7) + (i64.const -1) + ) + (i64.store offset=32 + (get_local $7) + (i64.const 0) + ) + (i64.store offset=8 + (get_local $7) + (i64.load + (get_local $0) + ) + ) + (call $eosio_assert + (i64.ge_s + (i64.load + (tee_local $0 + (call $_ZNK5eosio11multi_indexILy3607749779137757184ENS_5token7accountEJEE3getEyPKc + (i32.add + (get_local $7) + (i32.const 8) + ) + (i64.shr_u + (tee_local $3 + (i64.load offset=8 + (get_local $2) + ) + ) + (i64.const 8) + ) + (i32.const 1184) + ) + ) + ) + (tee_local $1 + (i64.load + (get_local $2) + ) + ) + ) + (i32.const 1216) + ) + (block $label$0 + (block $label$1 + (block $label$2 + (br_if $label$2 + (i64.ne + (get_local $1) + (i64.load + (get_local $0) + ) + ) + ) + (call $_ZN5eosio11multi_indexILy3607749779137757184ENS_5token7accountEJEE5eraseERKS2_ + (i32.add + (get_local $7) + (i32.const 8) + ) + (get_local $0) + ) + (br_if $label$1 + (tee_local $4 + (i32.load offset=32 + (get_local $7) + ) + ) + ) + (br $label$0) + ) + (call $eosio_assert + (i32.eq + (i32.load offset=16 + (get_local $0) + ) + (i32.add + (get_local $7) + (i32.const 8) + ) + ) + (i32.const 640) + ) + (call $eosio_assert + (i64.eq + (i64.load offset=8 + (get_local $7) + ) + (call $current_receiver) + ) + (i32.const 688) + ) + (call $eosio_assert + (i64.eq + (get_local $3) + (tee_local $5 + (i64.load offset=8 + (get_local $0) + ) + ) + ) + (i32.const 1248) + ) + (i64.store + (get_local $0) + (tee_local $1 + (i64.sub + (i64.load + (get_local $0) + ) + (get_local $1) + ) + ) + ) + (call $eosio_assert + (i64.gt_s + (get_local $1) + (i64.const -4611686018427387904) + ) + (i32.const 1296) + ) + (call $eosio_assert + (i64.lt_s + (i64.load + (get_local $0) + ) + (i64.const 4611686018427387904) + ) + (i32.const 1328) + ) + (call $eosio_assert + (i64.eq + (tee_local $1 + (i64.shr_u + (get_local $5) + (i64.const 8) + ) + ) + (i64.shr_u + (i64.load offset=8 + (get_local $0) + ) + (i64.const 8) + ) + ) + (i32.const 864) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 272) + ) + (drop + (call $memcpy + (i32.add + (get_local $7) + (i32.const 48) + ) + (get_local $0) + (i32.const 8) + ) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 272) + ) + (drop + (call $memcpy + (i32.or + (i32.add + (get_local $7) + (i32.const 48) + ) + (i32.const 8) + ) + (i32.add + (get_local $0) + (i32.const 8) + ) + (i32.const 8) + ) + ) + (call $db_update_i64 + (i32.load offset=20 + (get_local $0) + ) + (i64.const 0) + (i32.add + (get_local $7) + (i32.const 48) + ) + (i32.const 16) + ) + (block $label$3 + (br_if $label$3 + (i64.lt_u + (get_local $1) + (i64.load + (tee_local $0 + (i32.add + (i32.add + (get_local $7) + (i32.const 8) + ) + (i32.const 16) + ) + ) + ) + ) + ) + (i64.store + (get_local $0) + (i64.add + (get_local $1) + (i64.const 1) + ) + ) + ) + (br_if $label$0 + (i32.eqz + (tee_local $4 + (i32.load offset=32 + (get_local $7) + ) + ) + ) + ) + ) + (block $label$4 + (block $label$5 + (br_if $label$5 + (i32.eq + (tee_local $0 + (i32.load + (tee_local $6 + (i32.add + (get_local $7) + (i32.const 36) + ) + ) + ) + ) + (get_local $4) + ) + ) + (loop $label$6 + (set_local $2 + (i32.load + (tee_local $0 + (i32.add + (get_local $0) + (i32.const -24) + ) + ) + ) + ) + (i32.store + (get_local $0) + (i32.const 0) + ) + (block $label$7 + (br_if $label$7 + (i32.eqz + (get_local $2) + ) + ) + (call $_ZdlPv + (get_local $2) + ) + ) + (br_if $label$6 + (i32.ne + (get_local $4) + (get_local $0) + ) + ) + ) + (set_local $0 + (i32.load + (i32.add + (get_local $7) + (i32.const 32) + ) + ) + ) + (br $label$4) + ) + (set_local $0 + (get_local $4) + ) + ) + (i32.store + (get_local $6) + (get_local $4) + ) + (call $_ZdlPv + (get_local $0) + ) + ) + (i32.store offset=4 + (i32.const 0) + (i32.add + (get_local $7) + (i32.const 64) + ) + ) + ) + (func $_ZNK5eosio11multi_indexILy3607749779137757184ENS_5token7accountEJEE3getEyPKc (param $0 i32) (param $1 i64) (param $2 i32) (result i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (block $label$0 + (br_if $label$0 + (i32.eq + (tee_local $7 + (i32.load + (i32.add + (get_local $0) + (i32.const 28) + ) + ) + ) + (tee_local $3 + (i32.load offset=24 + (get_local $0) + ) + ) + ) + ) + (set_local $6 + (i32.add + (get_local $7) + (i32.const -24) + ) + ) + (set_local $4 + (i32.sub + (i32.const 0) + (get_local $3) + ) + ) + (loop $label$1 + (br_if $label$0 + (i64.eq + (i64.shr_u + (i64.load offset=8 + (i32.load + (get_local $6) + ) + ) + (i64.const 8) + ) + (get_local $1) + ) + ) + (set_local $7 + (get_local $6) + ) + (set_local $6 + (tee_local $5 + (i32.add + (get_local $6) + (i32.const -24) + ) + ) + ) + (br_if $label$1 + (i32.ne + (i32.add + (get_local $5) + (get_local $4) + ) + (i32.const -24) + ) + ) + ) + ) + (block $label$2 + (block $label$3 + (br_if $label$3 + (i32.eq + (get_local $7) + (get_local $3) + ) + ) + (call $eosio_assert + (i32.eq + (i32.load offset=16 + (tee_local $6 + (i32.load + (i32.add + (get_local $7) + (i32.const -24) + ) + ) + ) + ) + (get_local $0) + ) + (i32.const 96) + ) + (br $label$2) + ) + (set_local $6 + (i32.const 0) + ) + (br_if $label$2 + (i32.lt_s + (tee_local $5 + (call $db_find_i64 + (i64.load + (get_local $0) + ) + (i64.load offset=8 + (get_local $0) + ) + (i64.const 3607749779137757184) + (get_local $1) + ) + ) + (i32.const 0) + ) + ) + (call $eosio_assert + (i32.eq + (i32.load offset=16 + (tee_local $6 + (call $_ZNK5eosio11multi_indexILy3607749779137757184ENS_5token7accountEJEE31load_object_by_primary_iteratorEl + (get_local $0) + (get_local $5) + ) + ) + ) + (get_local $0) + ) + (i32.const 96) + ) + ) + (call $eosio_assert + (i32.ne + (get_local $6) + (i32.const 0) + ) + (get_local $2) + ) + (get_local $6) + ) + (func $_ZN5eosio11multi_indexILy3607749779137757184ENS_5token7accountEJEE5eraseERKS2_ (param $0 i32) (param $1 i32) + (local $2 i64) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (local $8 i32) + (call $eosio_assert + (i32.eq + (i32.load offset=16 + (get_local $1) + ) + (get_local $0) + ) + (i32.const 1360) + ) + (call $eosio_assert + (i64.eq + (i64.load + (get_local $0) + ) + (call $current_receiver) + ) + (i32.const 1408) + ) + (block $label$0 + (br_if $label$0 + (i32.eq + (tee_local $7 + (i32.load + (tee_local $5 + (i32.add + (get_local $0) + (i32.const 28) + ) + ) + ) + ) + (tee_local $3 + (i32.load offset=24 + (get_local $0) + ) + ) + ) + ) + (set_local $2 + (i64.load offset=8 + (get_local $1) + ) + ) + (set_local $6 + (i32.sub + (i32.const 0) + (get_local $3) + ) + ) + (set_local $8 + (i32.add + (get_local $7) + (i32.const -24) + ) + ) + (loop $label$1 + (br_if $label$0 + (i64.lt_u + (i64.xor + (i64.load offset=8 + (i32.load + (get_local $8) + ) + ) + (get_local $2) + ) + (i64.const 256) + ) + ) + (set_local $7 + (get_local $8) + ) + (set_local $8 + (tee_local $4 + (i32.add + (get_local $8) + (i32.const -24) + ) + ) + ) + (br_if $label$1 + (i32.ne + (i32.add + (get_local $4) + (get_local $6) + ) + (i32.const -24) + ) + ) + ) + ) + (call $eosio_assert + (i32.ne + (get_local $7) + (get_local $3) + ) + (i32.const 1472) + ) + (set_local $8 + (i32.add + (get_local $7) + (i32.const -24) + ) + ) + (block $label$2 + (block $label$3 + (br_if $label$3 + (i32.eq + (get_local $7) + (tee_local $4 + (i32.load + (get_local $5) + ) + ) + ) + ) + (set_local $3 + (i32.sub + (i32.const 0) + (get_local $4) + ) + ) + (set_local $7 + (get_local $8) + ) + (loop $label$4 + (set_local $6 + (i32.load + (tee_local $8 + (i32.add + (get_local $7) + (i32.const 24) + ) + ) + ) + ) + (i32.store + (get_local $8) + (i32.const 0) + ) + (set_local $4 + (i32.load + (get_local $7) + ) + ) + (i32.store + (get_local $7) + (get_local $6) + ) + (block $label$5 + (br_if $label$5 + (i32.eqz + (get_local $4) + ) + ) + (call $_ZdlPv + (get_local $4) + ) + ) + (i32.store + (i32.add + (get_local $7) + (i32.const 16) + ) + (i32.load + (i32.add + (get_local $7) + (i32.const 40) + ) + ) + ) + (i64.store + (i32.add + (get_local $7) + (i32.const 8) + ) + (i64.load + (i32.add + (get_local $7) + (i32.const 32) + ) + ) + ) + (set_local $7 + (get_local $8) + ) + (br_if $label$4 + (i32.ne + (i32.add + (get_local $8) + (get_local $3) + ) + (i32.const -24) + ) + ) + ) + (br_if $label$2 + (i32.eq + (tee_local $7 + (i32.load + (i32.add + (get_local $0) + (i32.const 28) + ) + ) + ) + (get_local $8) + ) + ) + ) + (loop $label$6 + (set_local $4 + (i32.load + (tee_local $7 + (i32.add + (get_local $7) + (i32.const -24) + ) + ) + ) + ) + (i32.store + (get_local $7) + (i32.const 0) + ) + (block $label$7 + (br_if $label$7 + (i32.eqz + (get_local $4) + ) + ) + (call $_ZdlPv + (get_local $4) + ) + ) + (br_if $label$6 + (i32.ne + (get_local $8) + (get_local $7) + ) + ) + ) + ) + (i32.store + (i32.add + (get_local $0) + (i32.const 28) + ) + (get_local $8) + ) + (call $db_remove_i64 + (i32.load offset=20 + (get_local $1) + ) + ) + ) + (func $_ZNSt3__16vectorIN5eosio11multi_indexILy5382478059301502976ENS1_5token6detailEJEE8item_ptrENS_9allocatorIS6_EEE24__emplace_back_slow_pathIJNS_10unique_ptrINS5_4itemENS_14default_deleteISC_EEEERyRlEEEvDpOT_ (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (block $label$0 + (block $label$1 + (br_if $label$1 + (i32.ge_u + (tee_local $5 + (i32.add + (tee_local $4 + (i32.div_s + (i32.sub + (i32.load offset=4 + (get_local $0) + ) + (tee_local $6 + (i32.load + (get_local $0) + ) + ) + ) + (i32.const 24) + ) + ) + (i32.const 1) + ) + ) + (i32.const 178956971) + ) + ) + (set_local $7 + (i32.const 178956970) + ) + (block $label$2 + (block $label$3 + (br_if $label$3 + (i32.gt_u + (tee_local $6 + (i32.div_s + (i32.sub + (i32.load offset=8 + (get_local $0) + ) + (get_local $6) + ) + (i32.const 24) + ) + ) + (i32.const 89478484) + ) + ) + (br_if $label$2 + (i32.eqz + (tee_local $7 + (select + (get_local $5) + (tee_local $7 + (i32.shl + (get_local $6) + (i32.const 1) + ) + ) + (i32.lt_u + (get_local $7) + (get_local $5) + ) + ) + ) + ) + ) + ) + (set_local $6 + (call $_Znwj + (i32.mul + (get_local $7) + (i32.const 24) + ) + ) + ) + (br $label$0) + ) + (set_local $7 + (i32.const 0) + ) + (set_local $6 + (i32.const 0) + ) + (br $label$0) + ) + (call $_ZNKSt3__120__vector_base_commonILb1EE20__throw_length_errorEv + (get_local $0) + ) + (unreachable) + ) + (set_local $5 + (i32.load + (get_local $1) + ) + ) + (i32.store + (get_local $1) + (i32.const 0) + ) + (i32.store + (tee_local $1 + (i32.add + (get_local $6) + (i32.mul + (get_local $4) + (i32.const 24) + ) + ) + ) + (get_local $5) + ) + (i64.store offset=8 + (get_local $1) + (i64.load + (get_local $2) + ) + ) + (i32.store offset=16 + (get_local $1) + (i32.load + (get_local $3) + ) + ) + (set_local $4 + (i32.add + (get_local $6) + (i32.mul + (get_local $7) + (i32.const 24) + ) + ) + ) + (set_local $5 + (i32.add + (get_local $1) + (i32.const 24) + ) + ) + (block $label$4 + (block $label$5 + (br_if $label$5 + (i32.eq + (tee_local $6 + (i32.load + (i32.add + (get_local $0) + (i32.const 4) + ) + ) + ) + (tee_local $7 + (i32.load + (get_local $0) + ) + ) + ) + ) + (loop $label$6 + (set_local $3 + (i32.load + (tee_local $2 + (i32.add + (get_local $6) + (i32.const -24) + ) + ) + ) + ) + (i32.store + (get_local $2) + (i32.const 0) + ) + (i32.store + (i32.add + (get_local $1) + (i32.const -24) + ) + (get_local $3) + ) + (i32.store + (i32.add + (get_local $1) + (i32.const -8) + ) + (i32.load + (i32.add + (get_local $6) + (i32.const -8) + ) + ) + ) + (i32.store + (i32.add + (get_local $1) + (i32.const -12) + ) + (i32.load + (i32.add + (get_local $6) + (i32.const -12) + ) + ) + ) + (i32.store + (i32.add + (get_local $1) + (i32.const -16) + ) + (i32.load + (i32.add + (get_local $6) + (i32.const -16) + ) + ) + ) + (set_local $1 + (i32.add + (get_local $1) + (i32.const -24) + ) + ) + (set_local $6 + (get_local $2) + ) + (br_if $label$6 + (i32.ne + (get_local $7) + (get_local $2) + ) + ) + ) + (set_local $7 + (i32.load + (i32.add + (get_local $0) + (i32.const 4) + ) + ) + ) + (set_local $6 + (i32.load + (get_local $0) + ) + ) + (br $label$4) + ) + (set_local $6 + (get_local $7) + ) + ) + (i32.store + (get_local $0) + (get_local $1) + ) + (i32.store + (i32.add + (get_local $0) + (i32.const 4) + ) + (get_local $5) + ) + (i32.store + (i32.add + (get_local $0) + (i32.const 8) + ) + (get_local $4) + ) + (block $label$7 + (br_if $label$7 + (i32.eq + (get_local $7) + (get_local $6) + ) + ) + (loop $label$8 + (set_local $1 + (i32.load + (tee_local $7 + (i32.add + (get_local $7) + (i32.const -24) + ) + ) + ) + ) + (i32.store + (get_local $7) + (i32.const 0) + ) + (block $label$9 + (br_if $label$9 + (i32.eqz + (get_local $1) + ) + ) + (call $_ZdlPv + (get_local $1) + ) + ) + (br_if $label$8 + (i32.ne + (get_local $6) + (get_local $7) + ) + ) + ) + ) + (block $label$10 + (br_if $label$10 + (i32.eqz + (get_local $6) + ) + ) + (call $_ZdlPv + (get_local $6) + ) + ) + ) + (func $_ZN5eosio5token7reclaimEyNS_5assetENSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE (type $FUNCSIG$vijii) (param $0 i32) (param $1 i64) (param $2 i32) (param $3 i32) + (local $4 i64) + (local $5 i32) + (local $6 i64) + (local $7 i64) + (local $8 i32) + (local $9 i32) + (local $10 i32) + (i32.store offset=4 + (i32.const 0) + (tee_local $10 + (i32.sub + (i32.load offset=4 + (i32.const 0) + ) + (i32.const 112) + ) + ) + ) + (call $require_auth + (i64.load + (get_local $0) + ) + ) + (set_local $4 + (i64.load offset=8 + (get_local $2) + ) + ) + (set_local $8 + (i32.const 0) + ) + (i32.store + (i32.add + (get_local $10) + (i32.const 104) + ) + (i32.const 0) + ) + (i64.store offset=80 + (get_local $10) + (tee_local $7 + (i64.shr_u + (get_local $4) + (i64.const 8) + ) + ) + ) + (i64.store offset=88 + (get_local $10) + (i64.const -1) + ) + (i64.store offset=96 + (get_local $10) + (i64.const 0) + ) + (i64.store offset=72 + (get_local $10) + (i64.load + (get_local $0) + ) + ) + (set_local $5 + (call $_ZNK5eosio11multi_indexILy14289235522390851584ENS_5token13currency_statEJEE3getEyPKc + (i32.add + (get_local $10) + (i32.const 72) + ) + (get_local $7) + (i32.const 1056) + ) + ) + (call $require_recipient + (i64.load + (get_local $0) + ) + ) + (call $require_recipient + (get_local $1) + ) + (block $label$0 + (br_if $label$0 + (i64.gt_u + (i64.add + (tee_local $6 + (i64.load + (get_local $2) + ) + ) + (i64.const 4611686018427387903) + ) + (i64.const 9223372036854775806) + ) + ) + (set_local $9 + (i32.const 0) + ) + (block $label$1 + (loop $label$2 + (br_if $label$1 + (i32.gt_u + (i32.add + (i32.shl + (i32.wrap/i64 + (get_local $7) + ) + (i32.const 24) + ) + (i32.const -1073741825) + ) + (i32.const 452984830) + ) + ) + (block $label$3 + (br_if $label$3 + (i64.ne + (i64.and + (tee_local $7 + (i64.shr_u + (get_local $7) + (i64.const 8) + ) + ) + (i64.const 255) + ) + (i64.const 0) + ) + ) + (loop $label$4 + (br_if $label$1 + (i64.ne + (i64.and + (tee_local $7 + (i64.shr_u + (get_local $7) + (i64.const 8) + ) + ) + (i64.const 255) + ) + (i64.const 0) + ) + ) + (br_if $label$4 + (i32.lt_s + (tee_local $9 + (i32.add + (get_local $9) + (i32.const 1) + ) + ) + (i32.const 7) + ) + ) + ) + ) + (set_local $8 + (i32.const 1) + ) + (br_if $label$2 + (i32.lt_s + (tee_local $9 + (i32.add + (get_local $9) + (i32.const 1) + ) + ) + (i32.const 7) + ) + ) + (br $label$0) + ) + ) + (set_local $8 + (i32.const 0) + ) + ) + (call $eosio_assert + (get_local $8) + (i32.const 496) + ) + (call $eosio_assert + (i64.gt_s + (get_local $6) + (i64.const 0) + ) + (i32.const 1088) + ) + (call $eosio_assert + (i64.eq + (get_local $4) + (i64.load offset=8 + (get_local $5) + ) + ) + (i32.const 560) + ) + (block $label$5 + (block $label$6 + (br_if $label$6 + (i32.and + (tee_local $9 + (i32.load8_u + (get_local $3) + ) + ) + (i32.const 1) + ) + ) + (set_local $9 + (i32.shr_u + (get_local $9) + (i32.const 1) + ) + ) + (br $label$5) + ) + (set_local $9 + (i32.load offset=4 + (get_local $3) + ) + ) + ) + (call $eosio_assert + (i32.lt_u + (get_local $9) + (i32.const 257) + ) + (i32.const 400) + ) + (i64.store + (tee_local $9 + (i32.add + (i32.add + (get_local $10) + (i32.const 56) + ) + (i32.const 8) + ) + ) + (i64.load + (tee_local $8 + (i32.add + (get_local $2) + (i32.const 8) + ) + ) + ) + ) + (set_local $7 + (i64.load + (get_local $2) + ) + ) + (i32.store + (i32.add + (i32.add + (get_local $10) + (i32.const 24) + ) + (i32.const 12) + ) + (i32.load + (i32.add + (i32.add + (get_local $10) + (i32.const 56) + ) + (i32.const 12) + ) + ) + ) + (i32.store + (i32.add + (i32.add + (get_local $10) + (i32.const 24) + ) + (i32.const 8) + ) + (i32.load + (get_local $9) + ) + ) + (i64.store offset=56 + (get_local $10) + (get_local $7) + ) + (i32.store offset=28 + (get_local $10) + (i32.load offset=60 + (get_local $10) + ) + ) + (i32.store offset=24 + (get_local $10) + (i32.load offset=56 + (get_local $10) + ) + ) + (call $_ZN5eosio5token11sub_balanceEyNS_5assetE + (get_local $0) + (get_local $1) + (i32.add + (get_local $10) + (i32.const 24) + ) + ) + (i32.store + (tee_local $9 + (i32.add + (i32.add + (get_local $10) + (i32.const 40) + ) + (i32.const 12) + ) + ) + (i32.load + (i32.add + (get_local $2) + (i32.const 12) + ) + ) + ) + (i32.store + (tee_local $3 + (i32.add + (i32.add + (get_local $10) + (i32.const 40) + ) + (i32.const 8) + ) + ) + (i32.load + (get_local $8) + ) + ) + (i32.store offset=44 + (get_local $10) + (i32.load + (i32.add + (get_local $2) + (i32.const 4) + ) + ) + ) + (i32.store offset=40 + (get_local $10) + (i32.load + (get_local $2) + ) + ) + (set_local $7 + (i64.load + (get_local $0) + ) + ) + (i32.store + (i32.add + (i32.add + (get_local $10) + (i32.const 8) + ) + (i32.const 12) + ) + (i32.load + (get_local $9) + ) + ) + (i32.store + (i32.add + (i32.add + (get_local $10) + (i32.const 8) + ) + (i32.const 8) + ) + (i32.load + (get_local $3) + ) + ) + (i32.store offset=12 + (get_local $10) + (i32.load offset=44 + (get_local $10) + ) + ) + (i32.store offset=8 + (get_local $10) + (i32.load offset=40 + (get_local $10) + ) + ) + (call $_ZN5eosio5token11add_balanceEyNS_5assetEy + (get_local $0) + (get_local $7) + (i32.add + (get_local $10) + (i32.const 8) + ) + (get_local $1) + ) + (block $label$7 + (br_if $label$7 + (i32.eqz + (tee_local $0 + (i32.load offset=96 + (get_local $10) + ) + ) + ) + ) + (block $label$8 + (block $label$9 + (br_if $label$9 + (i32.eq + (tee_local $9 + (i32.load + (tee_local $8 + (i32.add + (get_local $10) + (i32.const 100) + ) + ) + ) + ) + (get_local $0) + ) + ) + (loop $label$10 + (set_local $2 + (i32.load + (tee_local $9 + (i32.add + (get_local $9) + (i32.const -24) + ) + ) + ) + ) + (i32.store + (get_local $9) + (i32.const 0) + ) + (block $label$11 + (br_if $label$11 + (i32.eqz + (get_local $2) + ) + ) + (call $_ZdlPv + (get_local $2) + ) + ) + (br_if $label$10 + (i32.ne + (get_local $0) + (get_local $9) + ) + ) + ) + (set_local $9 + (i32.load + (i32.add + (get_local $10) + (i32.const 96) + ) + ) + ) + (br $label$8) + ) + (set_local $9 + (get_local $0) + ) + ) + (i32.store + (get_local $8) + (get_local $0) + ) + (call $_ZdlPv + (get_local $9) + ) + ) + (i32.store offset=4 + (i32.const 0) + (i32.add + (get_local $10) + (i32.const 112) + ) + ) + ) + (func $_ZN5eosio5token9updateageEyNS_5assetEy (type $FUNCSIG$vijij) (param $0 i32) (param $1 i64) (param $2 i32) (param $3 i64) + (local $4 i64) + (local $5 i32) + (local $6 i64) + (local $7 i32) + (local $8 i32) + (i32.store offset=4 + (i32.const 0) + (tee_local $8 + (i32.sub + (i32.load offset=4 + (i32.const 0) + ) + (i32.const 112) + ) + ) + ) + (call $require_auth + (i64.load + (get_local $0) + ) + ) + (set_local $5 + (i32.const 0) + ) + (i32.store + (i32.add + (get_local $8) + (i32.const 72) + ) + (i32.const 0) + ) + (i64.store offset=48 + (get_local $8) + (get_local $1) + ) + (i64.store offset=56 + (get_local $8) + (i64.const -1) + ) + (i64.store offset=64 + (get_local $8) + (i64.const 0) + ) + (i64.store offset=40 + (get_local $8) + (tee_local $6 + (i64.load + (get_local $0) + ) + ) + ) + (block $label$0 + (br_if $label$0 + (i32.lt_s + (tee_local $2 + (call $db_find_i64 + (get_local $6) + (get_local $1) + (i64.const 3607749779137757184) + (tee_local $4 + (i64.shr_u + (i64.load offset=8 + (get_local $2) + ) + (i64.const 8) + ) + ) + ) + ) + (i32.const 0) + ) + ) + (call $eosio_assert + (i32.eq + (i32.load offset=16 + (call $_ZNK5eosio11multi_indexILy3607749779137757184ENS_5token7accountEJEE31load_object_by_primary_iteratorEl + (i32.add + (get_local $8) + (i32.const 40) + ) + (get_local $2) + ) + ) + (i32.add + (get_local $8) + (i32.const 40) + ) + ) + (i32.const 96) + ) + (set_local $5 + (i32.const 1) + ) + ) + (call $eosio_assert + (get_local $5) + (i32.const 1184) + ) + (block $label$1 + (br_if $label$1 + (i64.ne + (get_local $3) + (i64.const 0) + ) + ) + (set_local $3 + (call $current_time) + ) + ) + (i32.store + (i32.add + (get_local $8) + (i32.const 32) + ) + (i32.const 0) + ) + (i64.store offset=16 + (get_local $8) + (i64.const -1) + ) + (i64.store offset=24 + (get_local $8) + (i64.const 0) + ) + (i64.store + (get_local $8) + (tee_local $6 + (i64.load + (get_local $0) + ) + ) + ) + (i64.store offset=8 + (get_local $8) + (get_local $1) + ) + (block $label$2 + (block $label$3 + (block $label$4 + (block $label$5 + (br_if $label$5 + (i32.lt_s + (tee_local $5 + (call $db_find_i64 + (get_local $6) + (get_local $1) + (i64.const 5382478059301502976) + (get_local $4) + ) + ) + (i32.const 0) + ) + ) + (call $eosio_assert + (i32.eq + (i32.load offset=16 + (tee_local $0 + (call $_ZNK5eosio11multi_indexILy5382478059301502976ENS_5token6detailEJEE31load_object_by_primary_iteratorEl + (get_local $8) + (get_local $5) + ) + ) + ) + (get_local $8) + ) + (i32.const 96) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 944) + ) + (call $eosio_assert + (i32.eq + (i32.load offset=16 + (get_local $0) + ) + (get_local $8) + ) + (i32.const 640) + ) + (call $eosio_assert + (i64.eq + (i64.load + (get_local $8) + ) + (call $current_receiver) + ) + (i32.const 688) + ) + (i64.store offset=8 + (get_local $0) + (get_local $3) + ) + (set_local $1 + (i64.load + (get_local $0) + ) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 864) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 272) + ) + (drop + (call $memcpy + (i32.add + (get_local $8) + (i32.const 80) + ) + (get_local $0) + (i32.const 8) + ) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 272) + ) + (drop + (call $memcpy + (i32.or + (i32.add + (get_local $8) + (i32.const 80) + ) + (i32.const 8) + ) + (i32.add + (get_local $0) + (i32.const 8) + ) + (i32.const 8) + ) + ) + (call $db_update_i64 + (i32.load offset=20 + (get_local $0) + ) + (i64.const 0) + (i32.add + (get_local $8) + (i32.const 80) + ) + (i32.const 16) + ) + (br_if $label$4 + (i64.lt_u + (get_local $1) + (i64.load + (tee_local $0 + (i32.add + (get_local $8) + (i32.const 16) + ) + ) + ) + ) + ) + (i64.store + (get_local $0) + (select + (i64.const -2) + (i64.add + (get_local $1) + (i64.const 1) + ) + (i64.gt_u + (get_local $1) + (i64.const -3) + ) + ) + ) + (br_if $label$3 + (tee_local $2 + (i32.load offset=24 + (get_local $8) + ) + ) + ) + (br $label$2) + ) + (set_local $6 + (i64.load + (get_local $0) + ) + ) + (call $eosio_assert + (i64.eq + (i64.load + (get_local $8) + ) + (call $current_receiver) + ) + (i32.const 208) + ) + (i32.store offset=16 + (tee_local $0 + (call $_Znwj + (i32.const 32) + ) + ) + (get_local $8) + ) + (i64.store offset=8 + (get_local $0) + (get_local $3) + ) + (i64.store + (get_local $0) + (get_local $4) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 272) + ) + (drop + (call $memcpy + (i32.add + (get_local $8) + (i32.const 80) + ) + (get_local $0) + (i32.const 8) + ) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 272) + ) + (drop + (call $memcpy + (i32.or + (i32.add + (get_local $8) + (i32.const 80) + ) + (i32.const 8) + ) + (i32.add + (get_local $0) + (i32.const 8) + ) + (i32.const 8) + ) + ) + (i32.store offset=20 + (get_local $0) + (tee_local $2 + (call $db_store_i64 + (i64.load + (i32.add + (get_local $8) + (i32.const 8) + ) + ) + (i64.const 5382478059301502976) + (get_local $6) + (tee_local $1 + (i64.load + (get_local $0) + ) + ) + (i32.add + (get_local $8) + (i32.const 80) + ) + (i32.const 16) + ) + ) + ) + (block $label$6 + (br_if $label$6 + (i64.lt_u + (get_local $1) + (i64.load + (tee_local $5 + (i32.add + (get_local $8) + (i32.const 16) + ) + ) + ) + ) + ) + (i64.store + (get_local $5) + (select + (i64.const -2) + (i64.add + (get_local $1) + (i64.const 1) + ) + (i64.gt_u + (get_local $1) + (i64.const -3) + ) + ) + ) + ) + (i32.store offset=104 + (get_local $8) + (get_local $0) + ) + (i64.store offset=80 + (get_local $8) + (tee_local $1 + (i64.load + (get_local $0) + ) + ) + ) + (i32.store offset=100 + (get_local $8) + (get_local $2) + ) + (block $label$7 + (block $label$8 + (br_if $label$8 + (i32.ge_u + (tee_local $5 + (i32.load + (tee_local $7 + (i32.add + (get_local $8) + (i32.const 28) + ) + ) + ) + ) + (i32.load + (i32.add + (get_local $8) + (i32.const 32) + ) + ) + ) + ) + (i64.store offset=8 + (get_local $5) + (get_local $1) + ) + (i32.store offset=16 + (get_local $5) + (get_local $2) + ) + (i32.store offset=104 + (get_local $8) + (i32.const 0) + ) + (i32.store + (get_local $5) + (get_local $0) + ) + (i32.store + (get_local $7) + (i32.add + (get_local $5) + (i32.const 24) + ) + ) + (br $label$7) + ) + (call $_ZNSt3__16vectorIN5eosio11multi_indexILy5382478059301502976ENS1_5token6detailEJEE8item_ptrENS_9allocatorIS6_EEE24__emplace_back_slow_pathIJNS_10unique_ptrINS5_4itemENS_14default_deleteISC_EEEERyRlEEEvDpOT_ + (i32.add + (get_local $8) + (i32.const 24) + ) + (i32.add + (get_local $8) + (i32.const 104) + ) + (i32.add + (get_local $8) + (i32.const 80) + ) + (i32.add + (get_local $8) + (i32.const 100) + ) + ) + ) + (set_local $0 + (i32.load offset=104 + (get_local $8) + ) + ) + (i32.store offset=104 + (get_local $8) + (i32.const 0) + ) + (br_if $label$4 + (i32.eqz + (get_local $0) + ) + ) + (call $_ZdlPv + (get_local $0) + ) + ) + (br_if $label$2 + (i32.eqz + (tee_local $2 + (i32.load offset=24 + (get_local $8) + ) + ) + ) + ) + ) + (block $label$9 + (block $label$10 + (br_if $label$10 + (i32.eq + (tee_local $0 + (i32.load + (tee_local $7 + (i32.add + (get_local $8) + (i32.const 28) + ) + ) + ) + ) + (get_local $2) + ) + ) + (loop $label$11 + (set_local $5 + (i32.load + (tee_local $0 + (i32.add + (get_local $0) + (i32.const -24) + ) + ) + ) + ) + (i32.store + (get_local $0) + (i32.const 0) + ) + (block $label$12 + (br_if $label$12 + (i32.eqz + (get_local $5) + ) + ) + (call $_ZdlPv + (get_local $5) + ) + ) + (br_if $label$11 + (i32.ne + (get_local $2) + (get_local $0) + ) + ) + ) + (set_local $0 + (i32.load + (i32.add + (get_local $8) + (i32.const 24) + ) + ) + ) + (br $label$9) + ) + (set_local $0 + (get_local $2) + ) + ) + (i32.store + (get_local $7) + (get_local $2) + ) + (call $_ZdlPv + (get_local $0) + ) + ) + (block $label$13 + (br_if $label$13 + (i32.eqz + (tee_local $2 + (i32.load offset=64 + (get_local $8) + ) + ) + ) + ) + (block $label$14 + (block $label$15 + (br_if $label$15 + (i32.eq + (tee_local $0 + (i32.load + (tee_local $7 + (i32.add + (get_local $8) + (i32.const 68) + ) + ) + ) + ) + (get_local $2) + ) + ) + (loop $label$16 + (set_local $5 + (i32.load + (tee_local $0 + (i32.add + (get_local $0) + (i32.const -24) + ) + ) + ) + ) + (i32.store + (get_local $0) + (i32.const 0) + ) + (block $label$17 + (br_if $label$17 + (i32.eqz + (get_local $5) + ) + ) + (call $_ZdlPv + (get_local $5) + ) + ) + (br_if $label$16 + (i32.ne + (get_local $2) + (get_local $0) + ) + ) + ) + (set_local $0 + (i32.load + (i32.add + (get_local $8) + (i32.const 64) + ) + ) + ) + (br $label$14) + ) + (set_local $0 + (get_local $2) + ) + ) + (i32.store + (get_local $7) + (get_local $2) + ) + (call $_ZdlPv + (get_local $0) + ) + ) + (i32.store offset=4 + (i32.const 0) + (i32.add + (get_local $8) + (i32.const 112) + ) + ) + ) + (func $apply (param $0 i64) (param $1 i64) (param $2 i64) + (local $3 i32) + (local $4 i32) + (local $5 i64) + (local $6 i64) + (local $7 i64) + (local $8 i64) + (local $9 i32) + (i32.store offset=4 + (i32.const 0) + (tee_local $9 + (i32.sub + (i32.load offset=4 + (i32.const 0) + ) + (i32.const 96) + ) + ) + ) + (set_local $6 + (i64.const 0) + ) + (set_local $5 + (i64.const 59) + ) + (set_local $4 + (i32.const 1536) + ) + (set_local $7 + (i64.const 0) + ) + (loop $label$0 + (block $label$1 + (block $label$2 + (block $label$3 + (block $label$4 + (block $label$5 + (br_if $label$5 + (i64.gt_u + (get_local $6) + (i64.const 6) + ) + ) + (br_if $label$4 + (i32.gt_u + (i32.and + (i32.add + (tee_local $3 + (i32.load8_s + (get_local $4) + ) + ) + (i32.const -97) + ) + (i32.const 255) + ) + (i32.const 25) + ) + ) + (set_local $3 + (i32.add + (get_local $3) + (i32.const 165) + ) + ) + (br $label$3) + ) + (set_local $8 + (i64.const 0) + ) + (br_if $label$2 + (i64.le_u + (get_local $6) + (i64.const 11) + ) + ) + (br $label$1) + ) + (set_local $3 + (select + (i32.add + (get_local $3) + (i32.const 208) + ) + (i32.const 0) + (i32.lt_u + (i32.and + (i32.add + (get_local $3) + (i32.const -49) + ) + (i32.const 255) + ) + (i32.const 5) + ) + ) + ) + ) + (set_local $8 + (i64.shr_s + (i64.shl + (i64.extend_u/i32 + (get_local $3) + ) + (i64.const 56) + ) + (i64.const 56) + ) + ) + ) + (set_local $8 + (i64.shl + (i64.and + (get_local $8) + (i64.const 31) + ) + (i64.and + (get_local $5) + (i64.const 4294967295) + ) + ) + ) + ) + (set_local $4 + (i32.add + (get_local $4) + (i32.const 1) + ) + ) + (set_local $6 + (i64.add + (get_local $6) + (i64.const 1) + ) + ) + (set_local $7 + (i64.or + (get_local $8) + (get_local $7) + ) + ) + (br_if $label$0 + (i64.ne + (tee_local $5 + (i64.add + (get_local $5) + (i64.const -5) + ) + ) + (i64.const -6) + ) + ) + ) + (block $label$6 + (br_if $label$6 + (i64.ne + (get_local $7) + (get_local $2) + ) + ) + (set_local $6 + (i64.const 0) + ) + (set_local $5 + (i64.const 59) + ) + (set_local $4 + (i32.const 1552) + ) + (set_local $7 + (i64.const 0) + ) + (loop $label$7 + (block $label$8 + (block $label$9 + (block $label$10 + (block $label$11 + (block $label$12 + (br_if $label$12 + (i64.gt_u + (get_local $6) + (i64.const 4) + ) + ) + (br_if $label$11 + (i32.gt_u + (i32.and + (i32.add + (tee_local $3 + (i32.load8_s + (get_local $4) + ) + ) + (i32.const -97) + ) + (i32.const 255) + ) + (i32.const 25) + ) + ) + (set_local $3 + (i32.add + (get_local $3) + (i32.const 165) + ) + ) + (br $label$10) + ) + (set_local $8 + (i64.const 0) + ) + (br_if $label$9 + (i64.le_u + (get_local $6) + (i64.const 11) + ) + ) + (br $label$8) + ) + (set_local $3 + (select + (i32.add + (get_local $3) + (i32.const 208) + ) + (i32.const 0) + (i32.lt_u + (i32.and + (i32.add + (get_local $3) + (i32.const -49) + ) + (i32.const 255) + ) + (i32.const 5) + ) + ) + ) + ) + (set_local $8 + (i64.shr_s + (i64.shl + (i64.extend_u/i32 + (get_local $3) + ) + (i64.const 56) + ) + (i64.const 56) + ) + ) + ) + (set_local $8 + (i64.shl + (i64.and + (get_local $8) + (i64.const 31) + ) + (i64.and + (get_local $5) + (i64.const 4294967295) + ) + ) + ) + ) + (set_local $4 + (i32.add + (get_local $4) + (i32.const 1) + ) + ) + (set_local $6 + (i64.add + (get_local $6) + (i64.const 1) + ) + ) + (set_local $7 + (i64.or + (get_local $8) + (get_local $7) + ) + ) + (br_if $label$7 + (i64.ne + (tee_local $5 + (i64.add + (get_local $5) + (i64.const -5) + ) + ) + (i64.const -6) + ) + ) + ) + (call $eosio_assert + (i64.eq + (get_local $7) + (get_local $1) + ) + (i32.const 1568) + ) + ) + (block $label$13 + (block $label$14 + (br_if $label$14 + (i64.eq + (get_local $1) + (get_local $0) + ) + ) + (set_local $6 + (i64.const 0) + ) + (set_local $5 + (i64.const 59) + ) + (set_local $4 + (i32.const 1536) + ) + (set_local $7 + (i64.const 0) + ) + (loop $label$15 + (block $label$16 + (block $label$17 + (block $label$18 + (block $label$19 + (block $label$20 + (br_if $label$20 + (i64.gt_u + (get_local $6) + (i64.const 6) + ) + ) + (br_if $label$19 + (i32.gt_u + (i32.and + (i32.add + (tee_local $3 + (i32.load8_s + (get_local $4) + ) + ) + (i32.const -97) + ) + (i32.const 255) + ) + (i32.const 25) + ) + ) + (set_local $3 + (i32.add + (get_local $3) + (i32.const 165) + ) + ) + (br $label$18) + ) + (set_local $8 + (i64.const 0) + ) + (br_if $label$17 + (i64.le_u + (get_local $6) + (i64.const 11) + ) + ) + (br $label$16) + ) + (set_local $3 + (select + (i32.add + (get_local $3) + (i32.const 208) + ) + (i32.const 0) + (i32.lt_u + (i32.and + (i32.add + (get_local $3) + (i32.const -49) + ) + (i32.const 255) + ) + (i32.const 5) + ) + ) + ) + ) + (set_local $8 + (i64.shr_s + (i64.shl + (i64.extend_u/i32 + (get_local $3) + ) + (i64.const 56) + ) + (i64.const 56) + ) + ) + ) + (set_local $8 + (i64.shl + (i64.and + (get_local $8) + (i64.const 31) + ) + (i64.and + (get_local $5) + (i64.const 4294967295) + ) + ) + ) + ) + (set_local $4 + (i32.add + (get_local $4) + (i32.const 1) + ) + ) + (set_local $6 + (i64.add + (get_local $6) + (i64.const 1) + ) + ) + (set_local $7 + (i64.or + (get_local $8) + (get_local $7) + ) + ) + (br_if $label$15 + (i64.ne + (tee_local $5 + (i64.add + (get_local $5) + (i64.const -5) + ) + ) + (i64.const -6) + ) + ) + ) + (br_if $label$13 + (i64.ne + (get_local $7) + (get_local $2) + ) + ) + ) + (i64.store offset=88 + (get_local $9) + (i64.const 86400000000) + ) + (i64.store offset=80 + (get_local $9) + (get_local $0) + ) + (block $label$21 + (block $label$22 + (block $label$23 + (block $label$24 + (br_if $label$24 + (i64.le_s + (get_local $2) + (i64.const -3075276123302526977) + ) + ) + (br_if $label$23 + (i64.eq + (get_local $2) + (i64.const -3075276123302526976) + ) + ) + (br_if $label$22 + (i64.eq + (get_local $2) + (i64.const 8516769789752901632) + ) + ) + (br_if $label$13 + (i64.ne + (get_local $2) + (i64.const 5031766152489992192) + ) + ) + (i32.store offset=76 + (get_local $9) + (i32.const 0) + ) + (i32.store offset=72 + (get_local $9) + (i32.const 1) + ) + (i64.store align=4 + (get_local $9) + (i64.load offset=72 + (get_local $9) + ) + ) + (drop + (call $_ZN5eosio14execute_actionINS_5tokenES1_JyNS_5assetEEEEbPT_MT0_FvDpT1_E + (i32.add + (get_local $9) + (i32.const 80) + ) + (get_local $9) + ) + ) + (br $label$13) + ) + (br_if $label$21 + (i64.eq + (get_local $2) + (i64.const -5003196570129137664) + ) + ) + (br_if $label$13 + (i64.ne + (get_local $2) + (i64.const -3617168760277827584) + ) + ) + (i32.store offset=60 + (get_local $9) + (i32.const 0) + ) + (i32.store offset=56 + (get_local $9) + (i32.const 2) + ) + (i64.store offset=16 align=4 + (get_local $9) + (i64.load offset=56 + (get_local $9) + ) + ) + (drop + (call $_ZN5eosio14execute_actionINS_5tokenES1_JyyNS_5assetENSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEEbPT_MT0_FvDpT1_E + (i32.add + (get_local $9) + (i32.const 80) + ) + (i32.add + (get_local $9) + (i32.const 16) + ) + ) + ) + (br $label$13) + ) + (i32.store offset=52 + (get_local $9) + (i32.const 0) + ) + (i32.store offset=48 + (get_local $9) + (i32.const 3) + ) + (i64.store offset=24 align=4 + (get_local $9) + (i64.load offset=48 + (get_local $9) + ) + ) + (drop + (call $_ZN5eosio14execute_actionINS_5tokenES1_JyNS_5assetEyEEEbPT_MT0_FvDpT1_E + (i32.add + (get_local $9) + (i32.const 80) + ) + (i32.add + (get_local $9) + (i32.const 24) + ) + ) + ) + (br $label$13) + ) + (i32.store offset=68 + (get_local $9) + (i32.const 0) + ) + (i32.store offset=64 + (get_local $9) + (i32.const 4) + ) + (i64.store offset=8 align=4 + (get_local $9) + (i64.load offset=64 + (get_local $9) + ) + ) + (drop + (call $_ZN5eosio14execute_actionINS_5tokenES1_JyNS_5assetENSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEEbPT_MT0_FvDpT1_E + (i32.add + (get_local $9) + (i32.const 80) + ) + (i32.add + (get_local $9) + (i32.const 8) + ) + ) + ) + (br $label$13) + ) + (i32.store offset=44 + (get_local $9) + (i32.const 0) + ) + (i32.store offset=40 + (get_local $9) + (i32.const 5) + ) + (i64.store offset=32 align=4 + (get_local $9) + (i64.load offset=40 + (get_local $9) + ) + ) + (drop + (call $_ZN5eosio14execute_actionINS_5tokenES1_JyNS_5assetENSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEEbPT_MT0_FvDpT1_E + (i32.add + (get_local $9) + (i32.const 80) + ) + (i32.add + (get_local $9) + (i32.const 32) + ) + ) + ) + ) + (i32.store offset=4 + (i32.const 0) + (i32.add + (get_local $9) + (i32.const 96) + ) + ) + ) + (func $_ZN5eosio14execute_actionINS_5tokenES1_JyNS_5assetEEEEbPT_MT0_FvDpT1_E (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + (local $3 i32) + (local $4 i64) + (local $5 i32) + (local $6 i64) + (local $7 i32) + (local $8 i32) + (local $9 i32) + (set_local $9 + (tee_local $7 + (i32.sub + (i32.load offset=4 + (i32.const 0) + ) + (i32.const 96) + ) + ) + ) + (i32.store offset=4 + (i32.const 0) + (get_local $7) + ) + (set_local $2 + (i32.load offset=4 + (get_local $1) + ) + ) + (set_local $8 + (i32.load + (get_local $1) + ) + ) + (set_local $1 + (i32.const 0) + ) + (set_local $5 + (i32.const 0) + ) + (block $label$0 + (br_if $label$0 + (i32.eqz + (tee_local $3 + (call $action_data_size) + ) + ) + ) + (block $label$1 + (block $label$2 + (br_if $label$2 + (i32.lt_u + (get_local $3) + (i32.const 513) + ) + ) + (set_local $5 + (call $malloc + (get_local $3) + ) + ) + (br $label$1) + ) + (i32.store offset=4 + (i32.const 0) + (tee_local $5 + (i32.sub + (get_local $7) + (i32.and + (i32.add + (get_local $3) + (i32.const 15) + ) + (i32.const -16) + ) + ) + ) + ) + ) + (drop + (call $read_action_data + (get_local $5) + (get_local $3) + ) + ) + ) + (i64.store + (i32.add + (get_local $9) + (i32.const 40) + ) + (i64.const 1398362884) + ) + (i64.store offset=32 + (get_local $9) + (i64.const 0) + ) + (i64.store offset=24 + (get_local $9) + (i64.const 0) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 288) + ) + (set_local $6 + (i64.const 5462355) + ) + (block $label$3 + (loop $label$4 + (set_local $7 + (i32.const 0) + ) + (br_if $label$3 + (i32.gt_u + (i32.add + (i32.shl + (i32.wrap/i64 + (get_local $6) + ) + (i32.const 24) + ) + (i32.const -1073741825) + ) + (i32.const 452984830) + ) + ) + (block $label$5 + (br_if $label$5 + (i64.ne + (i64.and + (tee_local $6 + (i64.shr_u + (get_local $6) + (i64.const 8) + ) + ) + (i64.const 255) + ) + (i64.const 0) + ) + ) + (loop $label$6 + (br_if $label$3 + (i64.ne + (i64.and + (tee_local $6 + (i64.shr_u + (get_local $6) + (i64.const 8) + ) + ) + (i64.const 255) + ) + (i64.const 0) + ) + ) + (br_if $label$6 + (i32.lt_s + (tee_local $1 + (i32.add + (get_local $1) + (i32.const 1) + ) + ) + (i32.const 7) + ) + ) + ) + ) + (set_local $7 + (i32.const 1) + ) + (br_if $label$4 + (i32.lt_s + (tee_local $1 + (i32.add + (get_local $1) + (i32.const 1) + ) + ) + (i32.const 7) + ) + ) + ) + ) + (call $eosio_assert + (get_local $7) + (i32.const 16) + ) + (call $eosio_assert + (i32.gt_u + (get_local $3) + (i32.const 7) + ) + (i32.const 384) + ) + (drop + (call $memcpy + (i32.add + (get_local $9) + (i32.const 24) + ) + (get_local $5) + (i32.const 8) + ) + ) + (call $eosio_assert + (i32.ne + (tee_local $7 + (i32.and + (get_local $3) + (i32.const -8) + ) + ) + (i32.const 8) + ) + (i32.const 384) + ) + (drop + (call $memcpy + (tee_local $1 + (i32.add + (i32.add + (get_local $9) + (i32.const 24) + ) + (i32.const 8) + ) + ) + (i32.add + (get_local $5) + (i32.const 8) + ) + (i32.const 8) + ) + ) + (call $eosio_assert + (i32.ne + (get_local $7) + (i32.const 16) + ) + (i32.const 384) + ) + (drop + (call $memcpy + (i32.add + (i32.add + (get_local $9) + (i32.const 24) + ) + (i32.const 16) + ) + (i32.add + (get_local $5) + (i32.const 16) + ) + (i32.const 8) + ) + ) + (block $label$7 + (br_if $label$7 + (i32.lt_u + (get_local $3) + (i32.const 513) + ) + ) + (call $free + (get_local $5) + ) + ) + (i64.store + (tee_local $7 + (i32.add + (i32.add + (get_local $9) + (i32.const 48) + ) + (i32.const 8) + ) + ) + (i64.load + (i32.add + (get_local $1) + (i32.const 8) + ) + ) + ) + (set_local $6 + (i64.load offset=24 + (get_local $9) + ) + ) + (i64.store offset=48 + (get_local $9) + (i64.load + (get_local $1) + ) + ) + (i64.store + (i32.add + (i32.add + (get_local $9) + (i32.const 64) + ) + (i32.const 8) + ) + (i64.load + (get_local $7) + ) + ) + (i64.store offset=64 + (get_local $9) + (i64.load offset=48 + (get_local $9) + ) + ) + (set_local $1 + (i32.add + (get_local $0) + (i32.shr_s + (get_local $2) + (i32.const 1) + ) + ) + ) + (block $label$8 + (br_if $label$8 + (i32.eqz + (i32.and + (get_local $2) + (i32.const 1) + ) + ) + ) + (set_local $8 + (i32.load + (i32.add + (i32.load + (get_local $1) + ) + (get_local $8) + ) + ) + ) + ) + (i64.store + (i32.add + (i32.add + (get_local $9) + (i32.const 80) + ) + (i32.const 8) + ) + (tee_local $4 + (i64.load + (i32.add + (i32.add + (get_local $9) + (i32.const 64) + ) + (i32.const 8) + ) + ) + ) + ) + (i64.store + (i32.add + (i32.add + (get_local $9) + (i32.const 8) + ) + (i32.const 8) + ) + (get_local $4) + ) + (i64.store offset=80 + (get_local $9) + (tee_local $4 + (i64.load offset=64 + (get_local $9) + ) + ) + ) + (i64.store offset=8 + (get_local $9) + (get_local $4) + ) + (call_indirect (type $FUNCSIG$viji) + (get_local $1) + (get_local $6) + (i32.add + (get_local $9) + (i32.const 8) + ) + (get_local $8) + ) + (i32.store offset=4 + (i32.const 0) + (i32.add + (get_local $9) + (i32.const 96) + ) + ) + (i32.const 1) + ) + (func $_ZN5eosio14execute_actionINS_5tokenES1_JyNS_5assetENSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEEbPT_MT0_FvDpT1_E (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + (local $3 i64) + (local $4 i32) + (local $5 i32) + (i32.store offset=4 + (i32.const 0) + (tee_local $4 + (i32.sub + (i32.load offset=4 + (i32.const 0) + ) + (i32.const 80) + ) + ) + ) + (i32.store offset=60 + (tee_local $5 + (get_local $4) + ) + (get_local $0) + ) + (i32.store offset=48 + (get_local $5) + (i32.load + (get_local $1) + ) + ) + (i32.store offset=52 + (get_local $5) + (i32.load offset=4 + (get_local $1) + ) + ) + (set_local $1 + (i32.const 0) + ) + (set_local $0 + (i32.const 0) + ) + (block $label$0 + (br_if $label$0 + (i32.eqz + (tee_local $2 + (call $action_data_size) + ) + ) + ) + (block $label$1 + (block $label$2 + (br_if $label$2 + (i32.lt_u + (get_local $2) + (i32.const 513) + ) + ) + (set_local $0 + (call $malloc + (get_local $2) + ) + ) + (br $label$1) + ) + (i32.store offset=4 + (i32.const 0) + (tee_local $0 + (i32.sub + (get_local $4) + (i32.and + (i32.add + (get_local $2) + (i32.const 15) + ) + (i32.const -16) + ) + ) + ) + ) + ) + (drop + (call $read_action_data + (get_local $0) + (get_local $2) + ) + ) + ) + (i64.store + (i32.add + (get_local $5) + (i32.const 24) + ) + (i64.const 1398362884) + ) + (i64.store offset=16 + (get_local $5) + (i64.const 0) + ) + (i64.store offset=8 + (get_local $5) + (i64.const 0) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 288) + ) + (set_local $3 + (i64.const 5462355) + ) + (block $label$3 + (block $label$4 + (loop $label$5 + (br_if $label$4 + (i32.gt_u + (i32.add + (i32.shl + (i32.wrap/i64 + (get_local $3) + ) + (i32.const 24) + ) + (i32.const -1073741825) + ) + (i32.const 452984830) + ) + ) + (block $label$6 + (br_if $label$6 + (i64.ne + (i64.and + (tee_local $3 + (i64.shr_u + (get_local $3) + (i64.const 8) + ) + ) + (i64.const 255) + ) + (i64.const 0) + ) + ) + (loop $label$7 + (br_if $label$4 + (i64.ne + (i64.and + (tee_local $3 + (i64.shr_u + (get_local $3) + (i64.const 8) + ) + ) + (i64.const 255) + ) + (i64.const 0) + ) + ) + (br_if $label$7 + (i32.lt_s + (tee_local $1 + (i32.add + (get_local $1) + (i32.const 1) + ) + ) + (i32.const 7) + ) + ) + ) + ) + (set_local $4 + (i32.const 1) + ) + (br_if $label$5 + (i32.lt_s + (tee_local $1 + (i32.add + (get_local $1) + (i32.const 1) + ) + ) + (i32.const 7) + ) + ) + (br $label$3) + ) + ) + (set_local $4 + (i32.const 0) + ) + ) + (call $eosio_assert + (get_local $4) + (i32.const 16) + ) + (i32.store + (i32.add + (get_local $5) + (i32.const 40) + ) + (i32.const 0) + ) + (i64.store offset=32 + (get_local $5) + (i64.const 0) + ) + (i32.store offset=64 + (get_local $5) + (get_local $0) + ) + (i32.store offset=72 + (get_local $5) + (tee_local $1 + (i32.add + (get_local $0) + (get_local $2) + ) + ) + ) + (call $eosio_assert + (i32.gt_u + (get_local $2) + (i32.const 7) + ) + (i32.const 384) + ) + (drop + (call $memcpy + (i32.add + (get_local $5) + (i32.const 8) + ) + (get_local $0) + (i32.const 8) + ) + ) + (call $eosio_assert + (i32.gt_u + (i32.sub + (get_local $1) + (tee_local $4 + (i32.add + (get_local $0) + (i32.const 8) + ) + ) + ) + (i32.const 7) + ) + (i32.const 384) + ) + (drop + (call $memcpy + (i32.add + (i32.add + (get_local $5) + (i32.const 8) + ) + (i32.const 8) + ) + (get_local $4) + (i32.const 8) + ) + ) + (call $eosio_assert + (i32.gt_u + (i32.sub + (get_local $1) + (tee_local $4 + (i32.add + (get_local $0) + (i32.const 16) + ) + ) + ) + (i32.const 7) + ) + (i32.const 384) + ) + (drop + (call $memcpy + (i32.add + (i32.add + (get_local $5) + (i32.const 8) + ) + (i32.const 16) + ) + (get_local $4) + (i32.const 8) + ) + ) + (i32.store offset=68 + (get_local $5) + (i32.add + (get_local $0) + (i32.const 24) + ) + ) + (drop + (call $_ZN5eosiorsINS_10datastreamIPKcEEEERT_S6_RNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEE + (i32.add + (get_local $5) + (i32.const 64) + ) + (i32.add + (i32.add + (get_local $5) + (i32.const 8) + ) + (i32.const 24) + ) + ) + ) + (block $label$8 + (br_if $label$8 + (i32.lt_u + (get_local $2) + (i32.const 513) + ) + ) + (call $free + (get_local $0) + ) + ) + (i32.store offset=68 + (get_local $5) + (i32.add + (get_local $5) + (i32.const 48) + ) + ) + (i32.store offset=64 + (get_local $5) + (i32.add + (get_local $5) + (i32.const 60) + ) + ) + (call $_ZN5boost4mp116detail16tuple_apply_implIRZN5eosio14execute_actionINS3_5tokenES5_JyNS3_5assetENSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEEEEEbPT_MT0_FvDpT1_EEUlDpT_E_RNS7_5tupleIJyS6_SD_EEEJLj0ELj1ELj2EEEEDTclclsr3stdE7forwardISE_Efp_Espclsr3stdE3getIXT1_EEclsr3stdE7forwardISG_Efp0_EEEEOSE_OSG_NS0_16integer_sequenceIjJXspT1_EEEE + (i32.add + (get_local $5) + (i32.const 64) + ) + (i32.add + (get_local $5) + (i32.const 8) + ) + ) + (block $label$9 + (br_if $label$9 + (i32.eqz + (i32.and + (i32.load8_u offset=32 + (get_local $5) + ) + (i32.const 1) + ) + ) + ) + (call $_ZdlPv + (i32.load + (i32.add + (get_local $5) + (i32.const 40) + ) + ) + ) + ) + (i32.store offset=4 + (i32.const 0) + (i32.add + (get_local $5) + (i32.const 80) + ) + ) + (i32.const 1) + ) + (func $_ZN5eosio14execute_actionINS_5tokenES1_JyyNS_5assetENSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEEbPT_MT0_FvDpT1_E (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + (local $3 i64) + (local $4 i32) + (local $5 i32) + (i32.store offset=4 + (i32.const 0) + (tee_local $4 + (i32.sub + (i32.load offset=4 + (i32.const 0) + ) + (i32.const 96) + ) + ) + ) + (i32.store offset=60 + (tee_local $5 + (get_local $4) + ) + (get_local $0) + ) + (i32.store offset=48 + (get_local $5) + (i32.load + (get_local $1) + ) + ) + (i32.store offset=52 + (get_local $5) + (i32.load offset=4 + (get_local $1) + ) + ) + (set_local $1 + (i32.const 0) + ) + (set_local $0 + (i32.const 0) + ) + (block $label$0 + (br_if $label$0 + (i32.eqz + (tee_local $2 + (call $action_data_size) + ) + ) + ) + (block $label$1 + (block $label$2 + (br_if $label$2 + (i32.lt_u + (get_local $2) + (i32.const 513) + ) + ) + (set_local $0 + (call $malloc + (get_local $2) + ) + ) + (br $label$1) + ) + (i32.store offset=4 + (i32.const 0) + (tee_local $0 + (i32.sub + (get_local $4) + (i32.and + (i32.add + (get_local $2) + (i32.const 15) + ) + (i32.const -16) + ) + ) + ) + ) + ) + (drop + (call $read_action_data + (get_local $0) + (get_local $2) + ) + ) + ) + (i64.store + (i32.add + (get_local $5) + (i32.const 24) + ) + (i64.const 1398362884) + ) + (i64.store offset=8 + (get_local $5) + (i64.const 0) + ) + (i64.store + (get_local $5) + (i64.const 0) + ) + (i64.store offset=16 + (get_local $5) + (i64.const 0) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 288) + ) + (set_local $3 + (i64.const 5462355) + ) + (block $label$3 + (block $label$4 + (loop $label$5 + (br_if $label$4 + (i32.gt_u + (i32.add + (i32.shl + (i32.wrap/i64 + (get_local $3) + ) + (i32.const 24) + ) + (i32.const -1073741825) + ) + (i32.const 452984830) + ) + ) + (block $label$6 + (br_if $label$6 + (i64.ne + (i64.and + (tee_local $3 + (i64.shr_u + (get_local $3) + (i64.const 8) + ) + ) + (i64.const 255) + ) + (i64.const 0) + ) + ) + (loop $label$7 + (br_if $label$4 + (i64.ne + (i64.and + (tee_local $3 + (i64.shr_u + (get_local $3) + (i64.const 8) + ) + ) + (i64.const 255) + ) + (i64.const 0) + ) + ) + (br_if $label$7 + (i32.lt_s + (tee_local $1 + (i32.add + (get_local $1) + (i32.const 1) + ) + ) + (i32.const 7) + ) + ) + ) + ) + (set_local $4 + (i32.const 1) + ) + (br_if $label$5 + (i32.lt_s + (tee_local $1 + (i32.add + (get_local $1) + (i32.const 1) + ) + ) + (i32.const 7) + ) + ) + (br $label$3) + ) + ) + (set_local $4 + (i32.const 0) + ) + ) + (call $eosio_assert + (get_local $4) + (i32.const 16) + ) + (i32.store + (i32.add + (get_local $5) + (i32.const 40) + ) + (i32.const 0) + ) + (i64.store offset=32 + (get_local $5) + (i64.const 0) + ) + (i32.store offset=68 + (get_local $5) + (get_local $0) + ) + (i32.store offset=64 + (get_local $5) + (get_local $0) + ) + (i32.store offset=72 + (get_local $5) + (i32.add + (get_local $0) + (get_local $2) + ) + ) + (i32.store offset=80 + (get_local $5) + (i32.add + (get_local $5) + (i32.const 64) + ) + ) + (i32.store offset=88 + (get_local $5) + (get_local $5) + ) + (call $_ZN5boost6fusion6detail17for_each_unrolledILi4EE4callINS0_18std_tuple_iteratorINSt3__15tupleIJyyN5eosio5assetENS6_12basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEEEELi0EEEZNS8_rsINS8_10datastreamIPKcEEJyyS9_SF_EEERT_SO_RNS7_IJDpT0_EEEEUlSO_E_EEvRKSN_RKT0_ + (i32.add + (get_local $5) + (i32.const 88) + ) + (i32.add + (get_local $5) + (i32.const 80) + ) + ) + (block $label$8 + (br_if $label$8 + (i32.lt_u + (get_local $2) + (i32.const 513) + ) + ) + (call $free + (get_local $0) + ) + ) + (i32.store offset=68 + (get_local $5) + (i32.add + (get_local $5) + (i32.const 48) + ) + ) + (i32.store offset=64 + (get_local $5) + (i32.add + (get_local $5) + (i32.const 60) + ) + ) + (call $_ZN5boost4mp116detail16tuple_apply_implIRZN5eosio14execute_actionINS3_5tokenES5_JyyNS3_5assetENSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEEEEEbPT_MT0_FvDpT1_EEUlDpT_E_RNS7_5tupleIJyyS6_SD_EEEJLj0ELj1ELj2ELj3EEEEDTclclsr3stdE7forwardISE_Efp_Espclsr3stdE3getIXT1_EEclsr3stdE7forwardISG_Efp0_EEEEOSE_OSG_NS0_16integer_sequenceIjJXspT1_EEEE + (i32.add + (get_local $5) + (i32.const 64) + ) + (get_local $5) + ) + (block $label$9 + (br_if $label$9 + (i32.eqz + (i32.and + (i32.load8_u offset=32 + (get_local $5) + ) + (i32.const 1) + ) + ) + ) + (call $_ZdlPv + (i32.load + (i32.add + (get_local $5) + (i32.const 40) + ) + ) + ) + ) + (i32.store offset=4 + (i32.const 0) + (i32.add + (get_local $5) + (i32.const 96) + ) + ) + (i32.const 1) + ) + (func $_ZN5eosio14execute_actionINS_5tokenES1_JyNS_5assetEyEEEbPT_MT0_FvDpT1_E (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + (local $3 i32) + (local $4 i64) + (local $5 i64) + (local $6 i32) + (local $7 i64) + (local $8 i32) + (local $9 i32) + (local $10 i32) + (set_local $10 + (tee_local $8 + (i32.sub + (i32.load offset=4 + (i32.const 0) + ) + (i32.const 96) + ) + ) + ) + (i32.store offset=4 + (i32.const 0) + (get_local $8) + ) + (set_local $2 + (i32.load offset=4 + (get_local $1) + ) + ) + (set_local $9 + (i32.load + (get_local $1) + ) + ) + (set_local $1 + (i32.const 0) + ) + (set_local $6 + (i32.const 0) + ) + (block $label$0 + (br_if $label$0 + (i32.eqz + (tee_local $3 + (call $action_data_size) + ) + ) + ) + (block $label$1 + (block $label$2 + (br_if $label$2 + (i32.lt_u + (get_local $3) + (i32.const 513) + ) + ) + (set_local $6 + (call $malloc + (get_local $3) + ) + ) + (br $label$1) + ) + (i32.store offset=4 + (i32.const 0) + (tee_local $6 + (i32.sub + (get_local $8) + (i32.and + (i32.add + (get_local $3) + (i32.const 15) + ) + (i32.const -16) + ) + ) + ) + ) + ) + (drop + (call $read_action_data + (get_local $6) + (get_local $3) + ) + ) + ) + (i64.store + (i32.add + (get_local $10) + (i32.const 32) + ) + (i64.const 1398362884) + ) + (i64.store offset=24 + (get_local $10) + (i64.const 0) + ) + (i64.store offset=16 + (get_local $10) + (i64.const 0) + ) + (call $eosio_assert + (i32.const 1) + (i32.const 288) + ) + (set_local $7 + (i64.const 5462355) + ) + (block $label$3 + (loop $label$4 + (set_local $8 + (i32.const 0) + ) + (br_if $label$3 + (i32.gt_u + (i32.add + (i32.shl + (i32.wrap/i64 + (get_local $7) + ) + (i32.const 24) + ) + (i32.const -1073741825) + ) + (i32.const 452984830) + ) + ) + (block $label$5 + (br_if $label$5 + (i64.ne + (i64.and + (tee_local $7 + (i64.shr_u + (get_local $7) + (i64.const 8) + ) + ) + (i64.const 255) + ) + (i64.const 0) + ) + ) + (loop $label$6 + (br_if $label$3 + (i64.ne + (i64.and + (tee_local $7 + (i64.shr_u + (get_local $7) + (i64.const 8) + ) + ) + (i64.const 255) + ) + (i64.const 0) + ) + ) + (br_if $label$6 + (i32.lt_s + (tee_local $1 + (i32.add + (get_local $1) + (i32.const 1) + ) + ) + (i32.const 7) + ) + ) + ) + ) + (set_local $8 + (i32.const 1) + ) + (br_if $label$4 + (i32.lt_s + (tee_local $1 + (i32.add + (get_local $1) + (i32.const 1) + ) + ) + (i32.const 7) + ) + ) + ) + ) + (call $eosio_assert + (get_local $8) + (i32.const 16) + ) + (i64.store offset=40 + (get_local $10) + (i64.const 0) + ) + (i32.store offset=84 + (get_local $10) + (get_local $6) + ) + (i32.store offset=80 + (get_local $10) + (get_local $6) + ) + (i32.store offset=88 + (get_local $10) + (i32.add + (get_local $6) + (get_local $3) + ) + ) + (i32.store offset=48 + (get_local $10) + (i32.add + (get_local $10) + (i32.const 80) + ) + ) + (i32.store offset=64 + (get_local $10) + (i32.add + (get_local $10) + (i32.const 16) + ) + ) + (call $_ZN5boost6fusion6detail17for_each_unrolledILi3EE4callINS0_18std_tuple_iteratorINSt3__15tupleIJyN5eosio5assetEyEEELi0EEEZNS8_rsINS8_10datastreamIPKcEEJyS9_yEEERT_SI_RNS7_IJDpT0_EEEEUlSI_E_EEvRKSH_RKT0_ + (i32.add + (get_local $10) + (i32.const 64) + ) + (i32.add + (get_local $10) + (i32.const 48) + ) + ) + (block $label$7 + (br_if $label$7 + (i32.lt_u + (get_local $3) + (i32.const 513) + ) + ) + (call $free + (get_local $6) + ) + ) + (i64.store + (tee_local $1 + (i32.add + (i32.add + (get_local $10) + (i32.const 48) + ) + (i32.const 8) + ) + ) + (i64.load + (i32.add + (get_local $10) + (i32.const 32) + ) + ) + ) + (set_local $7 + (i64.load offset=16 + (get_local $10) + ) + ) + (i64.store offset=48 + (get_local $10) + (i64.load offset=24 + (get_local $10) + ) + ) + (set_local $4 + (i64.load + (i32.add + (get_local $10) + (i32.const 40) + ) + ) + ) + (i64.store + (i32.add + (i32.add + (get_local $10) + (i32.const 64) + ) + (i32.const 8) + ) + (i64.load + (get_local $1) + ) + ) + (i64.store offset=64 + (get_local $10) + (i64.load offset=48 + (get_local $10) + ) + ) + (set_local $1 + (i32.add + (get_local $0) + (i32.shr_s + (get_local $2) + (i32.const 1) + ) + ) + ) + (block $label$8 + (br_if $label$8 + (i32.eqz + (i32.and + (get_local $2) + (i32.const 1) + ) + ) + ) + (set_local $9 + (i32.load + (i32.add + (i32.load + (get_local $1) + ) + (get_local $9) + ) + ) + ) + ) + (i64.store + (i32.add + (i32.add + (get_local $10) + (i32.const 80) + ) + (i32.const 8) + ) + (tee_local $5 + (i64.load + (i32.add + (i32.add + (get_local $10) + (i32.const 64) + ) + (i32.const 8) + ) + ) + ) + ) + (i64.store + (i32.add + (get_local $10) + (i32.const 8) + ) + (get_local $5) + ) + (i64.store offset=80 + (get_local $10) + (tee_local $5 + (i64.load offset=64 + (get_local $10) + ) + ) + ) + (i64.store + (get_local $10) + (get_local $5) + ) + (call_indirect (type $FUNCSIG$vijij) + (get_local $1) + (get_local $7) + (get_local $10) + (get_local $4) + (get_local $9) + ) + (i32.store offset=4 + (i32.const 0) + (i32.add + (get_local $10) + (i32.const 96) + ) + ) + (i32.const 1) + ) + (func $_ZN5boost6fusion6detail17for_each_unrolledILi3EE4callINS0_18std_tuple_iteratorINSt3__15tupleIJyN5eosio5assetEyEEELi0EEEZNS8_rsINS8_10datastreamIPKcEEJyS9_yEEERT_SI_RNS7_IJDpT0_EEEEUlSI_E_EEvRKSH_RKT0_ (param $0 i32) (param $1 i32) + (local $2 i32) + (local $3 i32) + (set_local $2 + (i32.load + (get_local $0) + ) + ) + (call $eosio_assert + (i32.gt_u + (i32.sub + (i32.load offset=8 + (tee_local $3 + (i32.load + (get_local $1) + ) + ) + ) + (i32.load offset=4 + (get_local $3) + ) + ) + (i32.const 7) + ) + (i32.const 384) + ) + (drop + (call $memcpy + (get_local $2) + (i32.load offset=4 + (get_local $3) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $3) + (i32.add + (i32.load offset=4 + (get_local $3) + ) + (i32.const 8) + ) + ) + (set_local $0 + (i32.load + (get_local $0) + ) + ) + (call $eosio_assert + (i32.gt_u + (i32.sub + (i32.load offset=8 + (tee_local $3 + (i32.load + (get_local $1) + ) + ) + ) + (i32.load offset=4 + (get_local $3) + ) + ) + (i32.const 7) + ) + (i32.const 384) + ) + (drop + (call $memcpy + (i32.add + (get_local $0) + (i32.const 8) + ) + (i32.load offset=4 + (get_local $3) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $3) + (tee_local $2 + (i32.add + (i32.load offset=4 + (get_local $3) + ) + (i32.const 8) + ) + ) + ) + (call $eosio_assert + (i32.gt_u + (i32.sub + (i32.load offset=8 + (get_local $3) + ) + (get_local $2) + ) + (i32.const 7) + ) + (i32.const 384) + ) + (drop + (call $memcpy + (i32.add + (get_local $0) + (i32.const 16) + ) + (i32.load offset=4 + (get_local $3) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $3) + (i32.add + (i32.load offset=4 + (get_local $3) + ) + (i32.const 8) + ) + ) + (call $eosio_assert + (i32.gt_u + (i32.sub + (i32.load offset=8 + (tee_local $3 + (i32.load + (get_local $1) + ) + ) + ) + (i32.load offset=4 + (get_local $3) + ) + ) + (i32.const 7) + ) + (i32.const 384) + ) + (drop + (call $memcpy + (i32.add + (get_local $0) + (i32.const 24) + ) + (i32.load offset=4 + (get_local $3) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $3) + (i32.add + (i32.load offset=4 + (get_local $3) + ) + (i32.const 8) + ) + ) + ) + (func $_ZN5boost6fusion6detail17for_each_unrolledILi4EE4callINS0_18std_tuple_iteratorINSt3__15tupleIJyyN5eosio5assetENS6_12basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEEEELi0EEEZNS8_rsINS8_10datastreamIPKcEEJyyS9_SF_EEERT_SO_RNS7_IJDpT0_EEEEUlSO_E_EEvRKSN_RKT0_ (param $0 i32) (param $1 i32) + (local $2 i32) + (local $3 i32) + (set_local $2 + (i32.load + (get_local $0) + ) + ) + (call $eosio_assert + (i32.gt_u + (i32.sub + (i32.load offset=8 + (tee_local $3 + (i32.load + (get_local $1) + ) + ) + ) + (i32.load offset=4 + (get_local $3) + ) + ) + (i32.const 7) + ) + (i32.const 384) + ) + (drop + (call $memcpy + (get_local $2) + (i32.load offset=4 + (get_local $3) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $3) + (i32.add + (i32.load offset=4 + (get_local $3) + ) + (i32.const 8) + ) + ) + (set_local $0 + (i32.load + (get_local $0) + ) + ) + (call $eosio_assert + (i32.gt_u + (i32.sub + (i32.load offset=8 + (tee_local $3 + (i32.load + (get_local $1) + ) + ) + ) + (i32.load offset=4 + (get_local $3) + ) + ) + (i32.const 7) + ) + (i32.const 384) + ) + (drop + (call $memcpy + (i32.add + (get_local $0) + (i32.const 8) + ) + (i32.load offset=4 + (get_local $3) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $3) + (i32.add + (i32.load offset=4 + (get_local $3) + ) + (i32.const 8) + ) + ) + (call $eosio_assert + (i32.gt_u + (i32.sub + (i32.load offset=8 + (tee_local $3 + (i32.load + (get_local $1) + ) + ) + ) + (i32.load offset=4 + (get_local $3) + ) + ) + (i32.const 7) + ) + (i32.const 384) + ) + (drop + (call $memcpy + (i32.add + (get_local $0) + (i32.const 16) + ) + (i32.load offset=4 + (get_local $3) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $3) + (tee_local $2 + (i32.add + (i32.load offset=4 + (get_local $3) + ) + (i32.const 8) + ) + ) + ) + (call $eosio_assert + (i32.gt_u + (i32.sub + (i32.load offset=8 + (get_local $3) + ) + (get_local $2) + ) + (i32.const 7) + ) + (i32.const 384) + ) + (drop + (call $memcpy + (i32.add + (get_local $0) + (i32.const 24) + ) + (i32.load offset=4 + (get_local $3) + ) + (i32.const 8) + ) + ) + (i32.store offset=4 + (get_local $3) + (i32.add + (i32.load offset=4 + (get_local $3) + ) + (i32.const 8) + ) + ) + (drop + (call $_ZN5eosiorsINS_10datastreamIPKcEEEERT_S6_RNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEE + (i32.load + (get_local $1) + ) + (i32.add + (get_local $0) + (i32.const 32) + ) + ) + ) + ) + (func $_ZN5boost4mp116detail16tuple_apply_implIRZN5eosio14execute_actionINS3_5tokenES5_JyyNS3_5assetENSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEEEEEbPT_MT0_FvDpT1_EEUlDpT_E_RNS7_5tupleIJyyS6_SD_EEEJLj0ELj1ELj2ELj3EEEEDTclclsr3stdE7forwardISE_Efp_Espclsr3stdE3getIXT1_EEclsr3stdE7forwardISG_Efp0_EEEEOSE_OSG_NS0_16integer_sequenceIjJXspT1_EEEE (param $0 i32) (param $1 i32) + (local $2 i64) + (local $3 i64) + (local $4 i32) + (local $5 i32) + (i32.store offset=4 + (i32.const 0) + (tee_local $5 + (i32.sub + (i32.load offset=4 + (i32.const 0) + ) + (i32.const 96) + ) + ) + ) + (i32.store + (i32.add + (get_local $5) + (i32.const 44) + ) + (i32.load + (i32.add + (get_local $1) + (i32.const 28) + ) + ) + ) + (i32.store + (tee_local $4 + (i32.add + (i32.add + (get_local $5) + (i32.const 32) + ) + (i32.const 8) + ) + ) + (i32.load + (i32.add + (get_local $1) + (i32.const 24) + ) + ) + ) + (i32.store offset=32 + (get_local $5) + (i32.load offset=16 + (get_local $1) + ) + ) + (i32.store offset=36 + (get_local $5) + (i32.load + (i32.add + (get_local $1) + (i32.const 20) + ) + ) + ) + (set_local $3 + (i64.load offset=8 + (get_local $1) + ) + ) + (set_local $2 + (i64.load + (get_local $1) + ) + ) + (drop + (call $_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEC2ERKS5_ + (i32.add + (get_local $5) + (i32.const 16) + ) + (i32.add + (get_local $1) + (i32.const 32) + ) + ) + ) + (i64.store + (i32.add + (i32.add + (get_local $5) + (i32.const 48) + ) + (i32.const 8) + ) + (i64.load + (get_local $4) + ) + ) + (i64.store offset=48 + (get_local $5) + (i64.load offset=32 + (get_local $5) + ) + ) + (set_local $0 + (i32.add + (i32.load + (i32.load + (get_local $0) + ) + ) + (i32.shr_s + (tee_local $4 + (i32.load offset=4 + (tee_local $1 + (i32.load offset=4 + (get_local $0) + ) + ) + ) + ) + (i32.const 1) + ) + ) + ) + (set_local $1 + (i32.load + (get_local $1) + ) + ) + (block $label$0 + (br_if $label$0 + (i32.eqz + (i32.and + (get_local $4) + (i32.const 1) + ) + ) + ) + (set_local $1 + (i32.load + (i32.add + (i32.load + (get_local $0) + ) + (get_local $1) + ) + ) + ) + ) + (i64.store + (tee_local $4 + (i32.add + (i32.add + (get_local $5) + (i32.const 80) + ) + (i32.const 8) + ) + ) + (i64.load + (i32.add + (i32.add + (get_local $5) + (i32.const 48) + ) + (i32.const 8) + ) + ) + ) + (i64.store offset=80 + (get_local $5) + (i64.load offset=48 + (get_local $5) + ) + ) + (drop + (call $_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEC2ERKS5_ + (i32.add + (get_local $5) + (i32.const 64) + ) + (i32.add + (get_local $5) + (i32.const 16) + ) + ) + ) + (i64.store + (i32.add + (get_local $5) + (i32.const 8) + ) + (i64.load + (get_local $4) + ) + ) + (i64.store + (get_local $5) + (i64.load offset=80 + (get_local $5) + ) + ) + (call_indirect (type $FUNCSIG$vijjii) + (get_local $0) + (get_local $2) + (get_local $3) + (get_local $5) + (i32.add + (get_local $5) + (i32.const 64) + ) + (get_local $1) + ) + (block $label$1 + (br_if $label$1 + (i32.eqz + (i32.and + (i32.load8_u offset=64 + (get_local $5) + ) + (i32.const 1) + ) + ) + ) + (call $_ZdlPv + (i32.load offset=72 + (get_local $5) + ) + ) + ) + (block $label$2 + (br_if $label$2 + (i32.eqz + (i32.and + (i32.load8_u offset=16 + (get_local $5) + ) + (i32.const 1) + ) + ) + ) + (call $_ZdlPv + (i32.load offset=24 + (get_local $5) + ) + ) + ) + (i32.store offset=4 + (i32.const 0) + (i32.add + (get_local $5) + (i32.const 96) + ) + ) + ) + (func $_ZN5eosiorsINS_10datastreamIPKcEEEERT_S6_RNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEE (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (i32.store offset=4 + (i32.const 0) + (tee_local $7 + (i32.sub + (i32.load offset=4 + (i32.const 0) + ) + (i32.const 32) + ) + ) + ) + (i32.store offset=24 + (get_local $7) + (i32.const 0) + ) + (i64.store offset=16 + (get_local $7) + (i64.const 0) + ) + (drop + (call $_ZN5eosiorsINS_10datastreamIPKcEEEERT_S6_RNSt3__16vectorIcNS7_9allocatorIcEEEE + (get_local $0) + (i32.add + (get_local $7) + (i32.const 16) + ) + ) + ) + (block $label$0 + (block $label$1 + (block $label$2 + (block $label$3 + (block $label$4 + (block $label$5 + (block $label$6 + (block $label$7 + (block $label$8 + (br_if $label$8 + (i32.ne + (tee_local $5 + (i32.load offset=20 + (get_local $7) + ) + ) + (tee_local $4 + (i32.load offset=16 + (get_local $7) + ) + ) + ) + ) + (br_if $label$7 + (i32.and + (i32.load8_u + (get_local $1) + ) + (i32.const 1) + ) + ) + (i32.store16 + (get_local $1) + (i32.const 0) + ) + (set_local $4 + (i32.add + (get_local $1) + (i32.const 8) + ) + ) + (br $label$6) + ) + (i32.store + (i32.add + (get_local $7) + (i32.const 8) + ) + (i32.const 0) + ) + (i64.store + (get_local $7) + (i64.const 0) + ) + (br_if $label$0 + (i32.ge_u + (tee_local $2 + (i32.sub + (get_local $5) + (get_local $4) + ) + ) + (i32.const -16) + ) + ) + (br_if $label$5 + (i32.ge_u + (get_local $2) + (i32.const 11) + ) + ) + (i32.store8 + (get_local $7) + (i32.shl + (get_local $2) + (i32.const 1) + ) + ) + (set_local $6 + (i32.or + (get_local $7) + (i32.const 1) + ) + ) + (br_if $label$4 + (get_local $2) + ) + (br $label$3) + ) + (i32.store8 + (i32.load offset=8 + (get_local $1) + ) + (i32.const 0) + ) + (i32.store offset=4 + (get_local $1) + (i32.const 0) + ) + (set_local $4 + (i32.add + (get_local $1) + (i32.const 8) + ) + ) + ) + (call $_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7reserveEj + (get_local $1) + (i32.const 0) + ) + (i32.store + (get_local $4) + (i32.const 0) + ) + (i64.store align=4 + (get_local $1) + (i64.const 0) + ) + (br_if $label$2 + (tee_local $4 + (i32.load offset=16 + (get_local $7) + ) + ) + ) + (br $label$1) + ) + (set_local $6 + (call $_Znwj + (tee_local $5 + (i32.and + (i32.add + (get_local $2) + (i32.const 16) + ) + (i32.const -16) + ) + ) + ) + ) + (i32.store + (get_local $7) + (i32.or + (get_local $5) + (i32.const 1) + ) + ) + (i32.store offset=8 + (get_local $7) + (get_local $6) + ) + (i32.store offset=4 + (get_local $7) + (get_local $2) + ) + ) + (set_local $3 + (get_local $2) + ) + (set_local $5 + (get_local $6) + ) + (loop $label$9 + (i32.store8 + (get_local $5) + (i32.load8_u + (get_local $4) + ) + ) + (set_local $5 + (i32.add + (get_local $5) + (i32.const 1) + ) + ) + (set_local $4 + (i32.add + (get_local $4) + (i32.const 1) + ) + ) + (br_if $label$9 + (tee_local $3 + (i32.add + (get_local $3) + (i32.const -1) + ) + ) + ) + ) + (set_local $6 + (i32.add + (get_local $6) + (get_local $2) + ) + ) + ) + (i32.store8 + (get_local $6) + (i32.const 0) + ) + (block $label$10 + (block $label$11 + (br_if $label$11 + (i32.and + (i32.load8_u + (get_local $1) + ) + (i32.const 1) + ) + ) + (i32.store16 + (get_local $1) + (i32.const 0) + ) + (br $label$10) + ) + (i32.store8 + (i32.load offset=8 + (get_local $1) + ) + (i32.const 0) + ) + (i32.store offset=4 + (get_local $1) + (i32.const 0) + ) + ) + (call $_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7reserveEj + (get_local $1) + (i32.const 0) + ) + (i32.store + (i32.add + (get_local $1) + (i32.const 8) + ) + (i32.load + (i32.add + (get_local $7) + (i32.const 8) + ) + ) + ) + (i64.store align=4 + (get_local $1) + (i64.load + (get_local $7) + ) + ) + (br_if $label$1 + (i32.eqz + (tee_local $4 + (i32.load offset=16 + (get_local $7) + ) + ) + ) + ) + ) + (i32.store offset=20 + (get_local $7) + (get_local $4) + ) + (call $_ZdlPv + (get_local $4) + ) + ) + (i32.store offset=4 + (i32.const 0) + (i32.add + (get_local $7) + (i32.const 32) + ) + ) + (return + (get_local $0) + ) + ) + (call $_ZNKSt3__121__basic_string_commonILb1EE20__throw_length_errorEv + (get_local $7) + ) + (unreachable) + ) + (func $_ZN5eosiorsINS_10datastreamIPKcEEEERT_S6_RNSt3__16vectorIcNS7_9allocatorIcEEEE (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i64) + (local $7 i32) + (set_local $5 + (i32.load offset=4 + (get_local $0) + ) + ) + (set_local $7 + (i32.const 0) + ) + (set_local $6 + (i64.const 0) + ) + (set_local $2 + (i32.add + (get_local $0) + (i32.const 8) + ) + ) + (set_local $3 + (i32.add + (get_local $0) + (i32.const 4) + ) + ) + (loop $label$0 + (call $eosio_assert + (i32.lt_u + (get_local $5) + (i32.load + (get_local $2) + ) + ) + (i32.const 1632) + ) + (set_local $4 + (i32.load8_u + (tee_local $5 + (i32.load + (get_local $3) + ) + ) + ) + ) + (i32.store + (get_local $3) + (tee_local $5 + (i32.add + (get_local $5) + (i32.const 1) + ) + ) + ) + (set_local $6 + (i64.or + (i64.extend_u/i32 + (i32.shl + (i32.and + (get_local $4) + (i32.const 127) + ) + (tee_local $7 + (i32.and + (get_local $7) + (i32.const 255) + ) + ) + ) + ) + (get_local $6) + ) + ) + (set_local $7 + (i32.add + (get_local $7) + (i32.const 7) + ) + ) + (br_if $label$0 + (i32.shr_u + (get_local $4) + (i32.const 7) + ) + ) + ) + (block $label$1 + (block $label$2 + (br_if $label$2 + (i32.le_u + (tee_local $3 + (i32.wrap/i64 + (get_local $6) + ) + ) + (tee_local $2 + (i32.sub + (tee_local $7 + (i32.load offset=4 + (get_local $1) + ) + ) + (tee_local $4 + (i32.load + (get_local $1) + ) + ) + ) + ) + ) + ) + (call $_ZNSt3__16vectorIcNS_9allocatorIcEEE8__appendEj + (get_local $1) + (i32.sub + (get_local $3) + (get_local $2) + ) + ) + (set_local $5 + (i32.load + (i32.add + (get_local $0) + (i32.const 4) + ) + ) + ) + (set_local $7 + (i32.load + (i32.add + (get_local $1) + (i32.const 4) + ) + ) + ) + (set_local $4 + (i32.load + (get_local $1) + ) + ) + (br $label$1) + ) + (br_if $label$1 + (i32.ge_u + (get_local $3) + (get_local $2) + ) + ) + (i32.store + (i32.add + (get_local $1) + (i32.const 4) + ) + (tee_local $7 + (i32.add + (get_local $4) + (get_local $3) + ) + ) + ) + ) + (call $eosio_assert + (i32.ge_u + (i32.sub + (i32.load + (i32.add + (get_local $0) + (i32.const 8) + ) + ) + (get_local $5) + ) + (tee_local $5 + (i32.sub + (get_local $7) + (get_local $4) + ) + ) + ) + (i32.const 384) + ) + (drop + (call $memcpy + (get_local $4) + (i32.load + (tee_local $7 + (i32.add + (get_local $0) + (i32.const 4) + ) + ) + ) + (get_local $5) + ) + ) + (i32.store + (get_local $7) + (i32.add + (i32.load + (get_local $7) + ) + (get_local $5) + ) + ) + (get_local $0) + ) + (func $_ZN5boost4mp116detail16tuple_apply_implIRZN5eosio14execute_actionINS3_5tokenES5_JyNS3_5assetENSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEEEEEbPT_MT0_FvDpT1_EEUlDpT_E_RNS7_5tupleIJyS6_SD_EEEJLj0ELj1ELj2EEEEDTclclsr3stdE7forwardISE_Efp_Espclsr3stdE3getIXT1_EEclsr3stdE7forwardISG_Efp0_EEEEOSE_OSG_NS0_16integer_sequenceIjJXspT1_EEEE (param $0 i32) (param $1 i32) + (local $2 i64) + (local $3 i32) + (local $4 i32) + (i32.store offset=4 + (i32.const 0) + (tee_local $4 + (i32.sub + (i32.load offset=4 + (i32.const 0) + ) + (i32.const 96) + ) + ) + ) + (i32.store + (i32.add + (i32.add + (get_local $4) + (i32.const 32) + ) + (i32.const 12) + ) + (i32.load + (i32.add + (get_local $1) + (i32.const 20) + ) + ) + ) + (i32.store + (tee_local $3 + (i32.add + (i32.add + (get_local $4) + (i32.const 32) + ) + (i32.const 8) + ) + ) + (i32.load + (i32.add + (get_local $1) + (i32.const 16) + ) + ) + ) + (i32.store offset=32 + (get_local $4) + (i32.load offset=8 + (get_local $1) + ) + ) + (i32.store offset=36 + (get_local $4) + (i32.load + (i32.add + (get_local $1) + (i32.const 12) + ) + ) + ) + (set_local $2 + (i64.load + (get_local $1) + ) + ) + (drop + (call $_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEC2ERKS5_ + (i32.add + (get_local $4) + (i32.const 16) + ) + (i32.add + (get_local $1) + (i32.const 24) + ) + ) + ) + (i64.store + (i32.add + (i32.add + (get_local $4) + (i32.const 48) + ) + (i32.const 8) + ) + (i64.load + (get_local $3) + ) + ) + (i64.store offset=48 + (get_local $4) + (i64.load offset=32 + (get_local $4) + ) + ) + (set_local $0 + (i32.add + (i32.load + (i32.load + (get_local $0) + ) + ) + (i32.shr_s + (tee_local $3 + (i32.load offset=4 + (tee_local $1 + (i32.load offset=4 + (get_local $0) + ) + ) + ) + ) + (i32.const 1) + ) + ) + ) + (set_local $1 + (i32.load + (get_local $1) + ) + ) + (block $label$0 + (br_if $label$0 + (i32.eqz + (i32.and + (get_local $3) + (i32.const 1) + ) + ) + ) + (set_local $1 + (i32.load + (i32.add + (i32.load + (get_local $0) + ) + (get_local $1) + ) + ) + ) + ) + (i64.store + (tee_local $3 + (i32.add + (i32.add + (get_local $4) + (i32.const 80) + ) + (i32.const 8) + ) + ) + (i64.load + (i32.add + (i32.add + (get_local $4) + (i32.const 48) + ) + (i32.const 8) + ) + ) + ) + (i64.store offset=80 + (get_local $4) + (i64.load offset=48 + (get_local $4) + ) + ) + (drop + (call $_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEC2ERKS5_ + (i32.add + (get_local $4) + (i32.const 64) + ) + (i32.add + (get_local $4) + (i32.const 16) + ) + ) + ) + (i64.store + (i32.add + (get_local $4) + (i32.const 8) + ) + (i64.load + (get_local $3) + ) + ) + (i64.store + (get_local $4) + (i64.load offset=80 + (get_local $4) + ) + ) + (call_indirect (type $FUNCSIG$vijii) + (get_local $0) + (get_local $2) + (get_local $4) + (i32.add + (get_local $4) + (i32.const 64) + ) + (get_local $1) + ) + (block $label$1 + (br_if $label$1 + (i32.eqz + (i32.and + (i32.load8_u offset=64 + (get_local $4) + ) + (i32.const 1) + ) + ) + ) + (call $_ZdlPv + (i32.load offset=72 + (get_local $4) + ) + ) + ) + (block $label$2 + (br_if $label$2 + (i32.eqz + (i32.and + (i32.load8_u offset=16 + (get_local $4) + ) + (i32.const 1) + ) + ) + ) + (call $_ZdlPv + (i32.load offset=24 + (get_local $4) + ) + ) + ) + (i32.store offset=4 + (i32.const 0) + (i32.add + (get_local $4) + (i32.const 96) + ) + ) + ) + (func $malloc (param $0 i32) (result i32) + (call $_ZN5eosio14memory_manager6mallocEm + (i32.const 1636) + (get_local $0) + ) + ) + (func $_ZN5eosio14memory_manager6mallocEm (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (local $8 i32) + (local $9 i32) + (local $10 i32) + (local $11 i32) + (local $12 i32) + (local $13 i32) + (block $label$0 + (br_if $label$0 + (i32.eqz + (get_local $1) + ) + ) + (block $label$1 + (br_if $label$1 + (tee_local $13 + (i32.load offset=8384 + (get_local $0) + ) + ) + ) + (set_local $13 + (i32.const 16) + ) + (i32.store + (i32.add + (get_local $0) + (i32.const 8384) + ) + (i32.const 16) + ) + ) + (set_local $2 + (select + (i32.sub + (i32.add + (get_local $1) + (i32.const 8) + ) + (tee_local $2 + (i32.and + (i32.add + (get_local $1) + (i32.const 4) + ) + (i32.const 7) + ) + ) + ) + (get_local $1) + (get_local $2) + ) + ) + (block $label$2 + (block $label$3 + (block $label$4 + (br_if $label$4 + (i32.ge_u + (tee_local $10 + (i32.load offset=8388 + (get_local $0) + ) + ) + (get_local $13) + ) + ) + (set_local $1 + (i32.add + (i32.add + (get_local $0) + (i32.mul + (get_local $10) + (i32.const 12) + ) + ) + (i32.const 8192) + ) + ) + (block $label$5 + (br_if $label$5 + (get_local $10) + ) + (br_if $label$5 + (i32.load + (tee_local $13 + (i32.add + (get_local $0) + (i32.const 8196) + ) + ) + ) + ) + (i32.store + (get_local $1) + (i32.const 8192) + ) + (i32.store + (get_local $13) + (get_local $0) + ) + ) + (set_local $10 + (i32.add + (get_local $2) + (i32.const 4) + ) + ) + (loop $label$6 + (block $label$7 + (br_if $label$7 + (i32.gt_u + (i32.add + (tee_local $13 + (i32.load offset=8 + (get_local $1) + ) + ) + (get_local $10) + ) + (i32.load + (get_local $1) + ) + ) + ) + (i32.store + (tee_local $13 + (i32.add + (i32.load offset=4 + (get_local $1) + ) + (get_local $13) + ) + ) + (i32.or + (i32.and + (i32.load + (get_local $13) + ) + (i32.const -2147483648) + ) + (get_local $2) + ) + ) + (i32.store + (tee_local $1 + (i32.add + (get_local $1) + (i32.const 8) + ) + ) + (i32.add + (i32.load + (get_local $1) + ) + (get_local $10) + ) + ) + (i32.store + (get_local $13) + (i32.or + (i32.load + (get_local $13) + ) + (i32.const -2147483648) + ) + ) + (br_if $label$3 + (tee_local $1 + (i32.add + (get_local $13) + (i32.const 4) + ) + ) + ) + ) + (br_if $label$6 + (tee_local $1 + (call $_ZN5eosio14memory_manager16next_active_heapEv + (get_local $0) + ) + ) + ) + ) + ) + (set_local $4 + (i32.sub + (i32.const 2147483644) + (get_local $2) + ) + ) + (set_local $11 + (i32.add + (get_local $0) + (i32.const 8392) + ) + ) + (set_local $12 + (i32.add + (get_local $0) + (i32.const 8384) + ) + ) + (set_local $13 + (tee_local $3 + (i32.load offset=8392 + (get_local $0) + ) + ) + ) + (loop $label$8 + (call $eosio_assert + (i32.eq + (i32.load + (i32.add + (tee_local $1 + (i32.add + (get_local $0) + (i32.mul + (get_local $13) + (i32.const 12) + ) + ) + ) + (i32.const 8200) + ) + ) + (i32.load + (tee_local $5 + (i32.add + (get_local $1) + (i32.const 8192) + ) + ) + ) + ) + (i32.const 10032) + ) + (set_local $13 + (i32.add + (tee_local $6 + (i32.load + (i32.add + (get_local $1) + (i32.const 8196) + ) + ) + ) + (i32.const 4) + ) + ) + (loop $label$9 + (set_local $7 + (i32.add + (get_local $6) + (i32.load + (get_local $5) + ) + ) + ) + (set_local $1 + (i32.and + (tee_local $9 + (i32.load + (tee_local $8 + (i32.add + (get_local $13) + (i32.const -4) + ) + ) + ) + ) + (i32.const 2147483647) + ) + ) + (block $label$10 + (br_if $label$10 + (i32.lt_s + (get_local $9) + (i32.const 0) + ) + ) + (block $label$11 + (br_if $label$11 + (i32.ge_u + (get_local $1) + (get_local $2) + ) + ) + (loop $label$12 + (br_if $label$11 + (i32.ge_u + (tee_local $10 + (i32.add + (get_local $13) + (get_local $1) + ) + ) + (get_local $7) + ) + ) + (br_if $label$11 + (i32.lt_s + (tee_local $10 + (i32.load + (get_local $10) + ) + ) + (i32.const 0) + ) + ) + (br_if $label$12 + (i32.lt_u + (tee_local $1 + (i32.add + (i32.add + (get_local $1) + (i32.and + (get_local $10) + (i32.const 2147483647) + ) + ) + (i32.const 4) + ) + ) + (get_local $2) + ) + ) + ) + ) + (i32.store + (get_local $8) + (i32.or + (select + (get_local $1) + (get_local $2) + (i32.lt_u + (get_local $1) + (get_local $2) + ) + ) + (i32.and + (get_local $9) + (i32.const -2147483648) + ) + ) + ) + (block $label$13 + (br_if $label$13 + (i32.le_u + (get_local $1) + (get_local $2) + ) + ) + (i32.store + (i32.add + (get_local $13) + (get_local $2) + ) + (i32.and + (i32.add + (get_local $4) + (get_local $1) + ) + (i32.const 2147483647) + ) + ) + ) + (br_if $label$2 + (i32.ge_u + (get_local $1) + (get_local $2) + ) + ) + ) + (br_if $label$9 + (i32.lt_u + (tee_local $13 + (i32.add + (i32.add + (get_local $13) + (get_local $1) + ) + (i32.const 4) + ) + ) + (get_local $7) + ) + ) + ) + (set_local $1 + (i32.const 0) + ) + (i32.store + (get_local $11) + (tee_local $13 + (select + (i32.const 0) + (tee_local $13 + (i32.add + (i32.load + (get_local $11) + ) + (i32.const 1) + ) + ) + (i32.eq + (get_local $13) + (i32.load + (get_local $12) + ) + ) + ) + ) + ) + (br_if $label$8 + (i32.ne + (get_local $13) + (get_local $3) + ) + ) + ) + ) + (return + (get_local $1) + ) + ) + (i32.store + (get_local $8) + (i32.or + (i32.load + (get_local $8) + ) + (i32.const -2147483648) + ) + ) + (return + (get_local $13) + ) + ) + (i32.const 0) + ) + (func $_ZN5eosio14memory_manager16next_active_heapEv (param $0 i32) (result i32) + (local $1 i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (local $8 i32) + (set_local $1 + (i32.load offset=8388 + (get_local $0) + ) + ) + (block $label$0 + (block $label$1 + (br_if $label$1 + (i32.eqz + (i32.load8_u offset=10118 + (i32.const 0) + ) + ) + ) + (set_local $7 + (i32.load offset=10120 + (i32.const 0) + ) + ) + (br $label$0) + ) + (set_local $7 + (current_memory) + ) + (i32.store8 offset=10118 + (i32.const 0) + (i32.const 1) + ) + (i32.store offset=10120 + (i32.const 0) + (tee_local $7 + (i32.shl + (get_local $7) + (i32.const 16) + ) + ) + ) + ) + (set_local $3 + (get_local $7) + ) + (block $label$2 + (block $label$3 + (block $label$4 + (block $label$5 + (br_if $label$5 + (i32.le_u + (tee_local $2 + (i32.shr_u + (i32.add + (get_local $7) + (i32.const 65535) + ) + (i32.const 16) + ) + ) + (tee_local $8 + (current_memory) + ) + ) + ) + (drop + (grow_memory + (i32.sub + (get_local $2) + (get_local $8) + ) + ) + ) + (set_local $8 + (i32.const 0) + ) + (br_if $label$4 + (i32.ne + (get_local $2) + (current_memory) + ) + ) + (set_local $3 + (i32.load offset=10120 + (i32.const 0) + ) + ) + ) + (set_local $8 + (i32.const 0) + ) + (i32.store offset=10120 + (i32.const 0) + (get_local $3) + ) + (br_if $label$4 + (i32.lt_s + (get_local $7) + (i32.const 0) + ) + ) + (set_local $2 + (i32.add + (get_local $0) + (i32.mul + (get_local $1) + (i32.const 12) + ) + ) + ) + (set_local $7 + (i32.sub + (i32.sub + (i32.add + (get_local $7) + (select + (i32.const 65536) + (i32.const 131072) + (tee_local $6 + (i32.lt_u + (tee_local $8 + (i32.and + (get_local $7) + (i32.const 65535) + ) + ) + (i32.const 64513) + ) + ) + ) + ) + (select + (get_local $8) + (i32.and + (get_local $7) + (i32.const 131071) + ) + (get_local $6) + ) + ) + (get_local $7) + ) + ) + (block $label$6 + (br_if $label$6 + (i32.load8_u offset=10118 + (i32.const 0) + ) + ) + (set_local $3 + (current_memory) + ) + (i32.store8 offset=10118 + (i32.const 0) + (i32.const 1) + ) + (i32.store offset=10120 + (i32.const 0) + (tee_local $3 + (i32.shl + (get_local $3) + (i32.const 16) + ) + ) + ) + ) + (set_local $2 + (i32.add + (get_local $2) + (i32.const 8192) + ) + ) + (br_if $label$3 + (i32.lt_s + (get_local $7) + (i32.const 0) + ) + ) + (set_local $6 + (get_local $3) + ) + (block $label$7 + (br_if $label$7 + (i32.le_u + (tee_local $8 + (i32.shr_u + (i32.add + (i32.add + (tee_local $5 + (i32.and + (i32.add + (get_local $7) + (i32.const 7) + ) + (i32.const -8) + ) + ) + (get_local $3) + ) + (i32.const 65535) + ) + (i32.const 16) + ) + ) + (tee_local $4 + (current_memory) + ) + ) + ) + (drop + (grow_memory + (i32.sub + (get_local $8) + (get_local $4) + ) + ) + ) + (br_if $label$3 + (i32.ne + (get_local $8) + (current_memory) + ) + ) + (set_local $6 + (i32.load offset=10120 + (i32.const 0) + ) + ) + ) + (i32.store offset=10120 + (i32.const 0) + (i32.add + (get_local $6) + (get_local $5) + ) + ) + (br_if $label$3 + (i32.eq + (get_local $3) + (i32.const -1) + ) + ) + (br_if $label$2 + (i32.eq + (i32.add + (tee_local $6 + (i32.load + (i32.add + (tee_local $1 + (i32.add + (get_local $0) + (i32.mul + (get_local $1) + (i32.const 12) + ) + ) + ) + (i32.const 8196) + ) + ) + ) + (tee_local $8 + (i32.load + (get_local $2) + ) + ) + ) + (get_local $3) + ) + ) + (block $label$8 + (br_if $label$8 + (i32.eq + (get_local $8) + (tee_local $1 + (i32.load + (tee_local $5 + (i32.add + (get_local $1) + (i32.const 8200) + ) + ) + ) + ) + ) + ) + (i32.store + (tee_local $6 + (i32.add + (get_local $6) + (get_local $1) + ) + ) + (i32.or + (i32.and + (i32.load + (get_local $6) + ) + (i32.const -2147483648) + ) + (i32.add + (i32.sub + (i32.const -4) + (get_local $1) + ) + (get_local $8) + ) + ) + ) + (i32.store + (get_local $5) + (i32.load + (get_local $2) + ) + ) + (i32.store + (get_local $6) + (i32.and + (i32.load + (get_local $6) + ) + (i32.const 2147483647) + ) + ) + ) + (i32.store + (tee_local $2 + (i32.add + (get_local $0) + (i32.const 8388) + ) + ) + (tee_local $2 + (i32.add + (i32.load + (get_local $2) + ) + (i32.const 1) + ) + ) + ) + (i32.store + (i32.add + (tee_local $0 + (i32.add + (get_local $0) + (i32.mul + (get_local $2) + (i32.const 12) + ) + ) + ) + (i32.const 8196) + ) + (get_local $3) + ) + (i32.store + (tee_local $8 + (i32.add + (get_local $0) + (i32.const 8192) + ) + ) + (get_local $7) + ) + ) + (return + (get_local $8) + ) + ) + (block $label$9 + (br_if $label$9 + (i32.eq + (tee_local $8 + (i32.load + (get_local $2) + ) + ) + (tee_local $7 + (i32.load + (tee_local $1 + (i32.add + (tee_local $3 + (i32.add + (get_local $0) + (i32.mul + (get_local $1) + (i32.const 12) + ) + ) + ) + (i32.const 8200) + ) + ) + ) + ) + ) + ) + (i32.store + (tee_local $3 + (i32.add + (i32.load + (i32.add + (get_local $3) + (i32.const 8196) + ) + ) + (get_local $7) + ) + ) + (i32.or + (i32.and + (i32.load + (get_local $3) + ) + (i32.const -2147483648) + ) + (i32.add + (i32.sub + (i32.const -4) + (get_local $7) + ) + (get_local $8) + ) + ) + ) + (i32.store + (get_local $1) + (i32.load + (get_local $2) + ) + ) + (i32.store + (get_local $3) + (i32.and + (i32.load + (get_local $3) + ) + (i32.const 2147483647) + ) + ) + ) + (i32.store offset=8384 + (get_local $0) + (tee_local $3 + (i32.add + (i32.load + (tee_local $7 + (i32.add + (get_local $0) + (i32.const 8388) + ) + ) + ) + (i32.const 1) + ) + ) + ) + (i32.store + (get_local $7) + (get_local $3) + ) + (return + (i32.const 0) + ) + ) + (i32.store + (get_local $2) + (i32.add + (get_local $8) + (get_local $7) + ) + ) + (get_local $2) + ) + (func $free (param $0 i32) + (local $1 i32) + (local $2 i32) + (local $3 i32) + (block $label$0 + (block $label$1 + (br_if $label$1 + (i32.eqz + (get_local $0) + ) + ) + (br_if $label$1 + (i32.lt_s + (tee_local $2 + (i32.load offset=10020 + (i32.const 0) + ) + ) + (i32.const 1) + ) + ) + (set_local $3 + (i32.const 9828) + ) + (set_local $1 + (i32.add + (i32.mul + (get_local $2) + (i32.const 12) + ) + (i32.const 9828) + ) + ) + (loop $label$2 + (br_if $label$1 + (i32.eqz + (tee_local $2 + (i32.load + (i32.add + (get_local $3) + (i32.const 4) + ) + ) + ) + ) + ) + (block $label$3 + (br_if $label$3 + (i32.gt_u + (i32.add + (get_local $2) + (i32.const 4) + ) + (get_local $0) + ) + ) + (br_if $label$0 + (i32.gt_u + (i32.add + (get_local $2) + (i32.load + (get_local $3) + ) + ) + (get_local $0) + ) + ) + ) + (br_if $label$2 + (i32.lt_u + (tee_local $3 + (i32.add + (get_local $3) + (i32.const 12) + ) + ) + (get_local $1) + ) + ) + ) + ) + (return) + ) + (i32.store + (tee_local $3 + (i32.add + (get_local $0) + (i32.const -4) + ) + ) + (i32.and + (i32.load + (get_local $3) + ) + (i32.const 2147483647) + ) + ) + ) + (func $_Znwj (param $0 i32) (result i32) + (local $1 i32) + (local $2 i32) + (block $label$0 + (br_if $label$0 + (tee_local $0 + (call $malloc + (tee_local $1 + (select + (get_local $0) + (i32.const 1) + (get_local $0) + ) + ) + ) + ) + ) + (loop $label$1 + (set_local $0 + (i32.const 0) + ) + (br_if $label$0 + (i32.eqz + (tee_local $2 + (i32.load offset=10124 + (i32.const 0) + ) + ) + ) + ) + (call_indirect (type $FUNCSIG$v) + (get_local $2) + ) + (br_if $label$1 + (i32.eqz + (tee_local $0 + (call $malloc + (get_local $1) + ) + ) + ) + ) + ) + ) + (get_local $0) + ) + (func $_ZdlPv (param $0 i32) + (block $label$0 + (br_if $label$0 + (i32.eqz + (get_local $0) + ) + ) + (call $free + (get_local $0) + ) + ) + ) + (func $_ZNKSt3__121__basic_string_commonILb1EE20__throw_length_errorEv (param $0 i32) + (call $abort) + (unreachable) + ) + (func $_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7reserveEj (param $0 i32) (param $1 i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (block $label$0 + (br_if $label$0 + (i32.ge_u + (get_local $1) + (i32.const -16) + ) + ) + (set_local $2 + (i32.const 10) + ) + (block $label$1 + (br_if $label$1 + (i32.eqz + (i32.and + (tee_local $5 + (i32.load8_u + (get_local $0) + ) + ) + (i32.const 1) + ) + ) + ) + (set_local $2 + (i32.add + (i32.and + (tee_local $5 + (i32.load + (get_local $0) + ) + ) + (i32.const -2) + ) + (i32.const -1) + ) + ) + ) + (block $label$2 + (block $label$3 + (br_if $label$3 + (i32.and + (get_local $5) + (i32.const 1) + ) + ) + (set_local $3 + (i32.shr_u + (i32.and + (get_local $5) + (i32.const 254) + ) + (i32.const 1) + ) + ) + (br $label$2) + ) + (set_local $3 + (i32.load offset=4 + (get_local $0) + ) + ) + ) + (set_local $4 + (i32.const 10) + ) + (block $label$4 + (br_if $label$4 + (i32.lt_u + (tee_local $1 + (select + (get_local $3) + (get_local $1) + (i32.gt_u + (get_local $3) + (get_local $1) + ) + ) + ) + (i32.const 11) + ) + ) + (set_local $4 + (i32.add + (i32.and + (i32.add + (get_local $1) + (i32.const 16) + ) + (i32.const -16) + ) + (i32.const -1) + ) + ) + ) + (block $label$5 + (br_if $label$5 + (i32.eq + (get_local $4) + (get_local $2) + ) + ) + (block $label$6 + (block $label$7 + (br_if $label$7 + (i32.ne + (get_local $4) + (i32.const 10) + ) + ) + (set_local $6 + (i32.const 1) + ) + (set_local $1 + (i32.add + (get_local $0) + (i32.const 1) + ) + ) + (set_local $2 + (i32.load offset=8 + (get_local $0) + ) + ) + (set_local $7 + (i32.const 0) + ) + (br $label$6) + ) + (set_local $1 + (call $_Znwj + (i32.add + (get_local $4) + (i32.const 1) + ) + ) + ) + (block $label$8 + (br_if $label$8 + (i32.gt_u + (get_local $4) + (get_local $2) + ) + ) + (br_if $label$5 + (i32.eqz + (get_local $1) + ) + ) + ) + (block $label$9 + (br_if $label$9 + (i32.and + (tee_local $5 + (i32.load8_u + (get_local $0) + ) + ) + (i32.const 1) + ) + ) + (set_local $7 + (i32.const 1) + ) + (set_local $2 + (i32.add + (get_local $0) + (i32.const 1) + ) + ) + (set_local $6 + (i32.const 0) + ) + (br $label$6) + ) + (set_local $2 + (i32.load offset=8 + (get_local $0) + ) + ) + (set_local $6 + (i32.const 1) + ) + (set_local $7 + (i32.const 1) + ) + ) + (block $label$10 + (block $label$11 + (br_if $label$11 + (i32.and + (get_local $5) + (i32.const 1) + ) + ) + (set_local $5 + (i32.shr_u + (i32.and + (get_local $5) + (i32.const 254) + ) + (i32.const 1) + ) + ) + (br $label$10) + ) + (set_local $5 + (i32.load offset=4 + (get_local $0) + ) + ) + ) + (block $label$12 + (br_if $label$12 + (i32.eqz + (tee_local $5 + (i32.add + (get_local $5) + (i32.const 1) + ) + ) + ) + ) + (drop + (call $memcpy + (get_local $1) + (get_local $2) + (get_local $5) + ) + ) + ) + (block $label$13 + (br_if $label$13 + (i32.eqz + (get_local $6) + ) + ) + (call $_ZdlPv + (get_local $2) + ) + ) + (block $label$14 + (br_if $label$14 + (i32.eqz + (get_local $7) + ) + ) + (i32.store offset=4 + (get_local $0) + (get_local $3) + ) + (i32.store offset=8 + (get_local $0) + (get_local $1) + ) + (i32.store + (get_local $0) + (i32.or + (i32.add + (get_local $4) + (i32.const 1) + ) + (i32.const 1) + ) + ) + (return) + ) + (i32.store8 + (get_local $0) + (i32.shl + (get_local $3) + (i32.const 1) + ) + ) + ) + (return) + ) + (call $abort) + (unreachable) + ) + (func $_ZNKSt3__120__vector_base_commonILb1EE20__throw_length_errorEv (param $0 i32) + (call $abort) + (unreachable) + ) + (func $_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEC2ERKS5_ (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (i64.store align=4 + (get_local $0) + (i64.const 0) + ) + (i32.store + (tee_local $3 + (i32.add + (get_local $0) + (i32.const 8) + ) + ) + (i32.const 0) + ) + (block $label$0 + (br_if $label$0 + (i32.and + (i32.load8_u + (get_local $1) + ) + (i32.const 1) + ) + ) + (i64.store align=4 + (get_local $0) + (i64.load align=4 + (get_local $1) + ) + ) + (i32.store + (get_local $3) + (i32.load + (i32.add + (get_local $1) + (i32.const 8) + ) + ) + ) + (return + (get_local $0) + ) + ) + (block $label$1 + (br_if $label$1 + (i32.ge_u + (tee_local $3 + (i32.load offset=4 + (get_local $1) + ) + ) + (i32.const -16) + ) + ) + (set_local $2 + (i32.load offset=8 + (get_local $1) + ) + ) + (block $label$2 + (block $label$3 + (block $label$4 + (br_if $label$4 + (i32.ge_u + (get_local $3) + (i32.const 11) + ) + ) + (i32.store8 + (get_local $0) + (i32.shl + (get_local $3) + (i32.const 1) + ) + ) + (set_local $1 + (i32.add + (get_local $0) + (i32.const 1) + ) + ) + (br_if $label$3 + (get_local $3) + ) + (br $label$2) + ) + (set_local $1 + (call $_Znwj + (tee_local $4 + (i32.and + (i32.add + (get_local $3) + (i32.const 16) + ) + (i32.const -16) + ) + ) + ) + ) + (i32.store + (get_local $0) + (i32.or + (get_local $4) + (i32.const 1) + ) + ) + (i32.store offset=8 + (get_local $0) + (get_local $1) + ) + (i32.store offset=4 + (get_local $0) + (get_local $3) + ) + ) + (drop + (call $memcpy + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + ) + (i32.store8 + (i32.add + (get_local $1) + (get_local $3) + ) + (i32.const 0) + ) + (return + (get_local $0) + ) + ) + (call $abort) + (unreachable) + ) + (func $memcmp (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (set_local $5 + (i32.const 0) + ) + (block $label$0 + (br_if $label$0 + (i32.eqz + (get_local $2) + ) + ) + (block $label$1 + (loop $label$2 + (br_if $label$1 + (i32.ne + (tee_local $3 + (i32.load8_u + (get_local $0) + ) + ) + (tee_local $4 + (i32.load8_u + (get_local $1) + ) + ) + ) + ) + (set_local $1 + (i32.add + (get_local $1) + (i32.const 1) + ) + ) + (set_local $0 + (i32.add + (get_local $0) + (i32.const 1) + ) + ) + (br_if $label$2 + (tee_local $2 + (i32.add + (get_local $2) + (i32.const -1) + ) + ) + ) + (br $label$0) + ) + ) + (set_local $5 + (i32.sub + (get_local $3) + (get_local $4) + ) + ) + ) + (get_local $5) + ) + (func $__wasm_nullptr (type $FUNCSIG$v) + (unreachable) + ) +)