Skip to content

Instantly share code, notes, and snippets.

@CryZe

CryZe/libm.rs

Created May 4, 2018
Embed
What would you like to do?
libm.rs
This file has been truncated, but you can view the full file.
#![allow(
unreachable_code, dead_code, unused_assignments, unused_mut, unused_variables, non_snake_case,
non_upper_case_globals, unconditional_recursion, path_statements
)]
pub const PAGE_SIZE: usize = 64 << 10;
pub trait Imports {
type Memory: Memory;
fn __start(&mut self, context: &mut Context<Self::Memory>);
}
pub trait Memory {
fn load8(&mut self, addr: usize) -> u8;
fn load16(&mut self, addr: usize) -> u16;
fn load32(&mut self, addr: usize) -> u32;
fn load64(&mut self, addr: usize) -> u64;
fn store8(&mut self, addr: usize, val: u8);
fn store16(&mut self, addr: usize, val: u16);
fn store32(&mut self, addr: usize, val: u32);
fn store64(&mut self, addr: usize, val: u64);
fn store_slice(&mut self, addr: usize, val: &'static [u8]);
fn grow(&mut self, pages: usize) -> i32;
fn size(&mut self) -> i32;
}
pub struct Instance<I: Imports<Memory = M>, M: Memory> {
pub imports: I,
pub context: Context<M>,
}
pub struct Context<M: Memory> {
pub memory: M,
global0: i32,
}
pub mod consts {
pub const __heap_base: i32 = 82976;
pub const __data_end: i32 = 17440;
}
impl<I: Imports<Memory = M>, M: Memory> Instance<I, M> {
pub fn new(imports: I, mut memory: M) -> Self {
let current_pages = memory.size() as usize;
if current_pages < 2 {
memory.grow(2 - current_pages);
assert_eq!(memory.size(), 2, "Not enough memory pages allocated");
}
memory.store_slice(1024, b"h\xA2\xB7\xFAj\x84\xD1BD\xB5\x92\xFF?");
memory.store_slice(1040, b"]y\xAA;\\v\xF9\xA3\xEB\xCC\xD9\xBD\xBF");
memory.store_slice(1056, b"O\xBBag\xAC\xDD?-DT\xFB!\xE9?\x9B\xF6\x81\xD2 s\xEF?-DT\xFB!\xF9?8c\xED>\xDAI?^\x98{?\xDA\xC9?hb1 E\xF8\x89\xF6\xB4Vp\xC6\xDA\xFD?\x81Y\x98\xFEi\x84\xD1BD\xB5\x92\xFE?Y\xD8\xB1\xEC:\xFE\xFF\xB1i(\xBD0\xF7\xFE?h\xA2\xB7\xFAj\x84\xD1BD\xB5\x92\xFF?");
memory.store_slice(1168, b"\xE2e/\"+z<\\3&\xA6\x81<\xBD\xCB\xF0z\x88p<\\3&\xA6\x91<i7\xAC1h!\"3\xB43h!\xA23\x91S\xE7\xA14\xEA\xF0\xB2\x91\xBF\xBC?\xAE\x8A[\xEF\x83\xEBu\xF9\xA3\xEB\xCC\xD9\xBC\xBF\xA0\x8F$)\xE8\x85'\xEF2\xBC\xE2\xBD?]y\xAA;\\v\xF9\xA3\xEB\xCC\xD9\xBD\xBF");
memory.store_slice(1280, b"\xD2!3|\xD9@\xD2!3|\xD9\xC0-DT\xFB!\xE9?-DT\xFB!\xE9\xBF");
memory.store_slice(1312, b"-DT\xFB!\t@-DT\xFB!\t\xC0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x80");
memory.store_slice(1344, b"\xE4\xCB@\xE4\xCB\xC0\xDBI?\xDBI\xBF");
memory.store_slice(1360, b"\xDBI@\xDBI\xC0\0\0\0\0\0\0\0\x80");
memory.store_slice(1376, b"\0\0\0\0\0\0\0\0\0\0\0\0");
memory.store_slice(1392, b"\x83\xF9\xA2\0DNn\0\xFC)\0\xD1W'\0\xDD4\xF5\0b\xDB\xC0\0<\x99\x95\0A\x90C\0cQ\xFE\0\xBB\xDE\xAB\0\xB7a\xC5\0:n$\0\xD2MB\0I\xE0\0\t\xEA.\0\x92\xD1\0\xEB\xFE\0)\xB1\0\xE8>\xA7\0\xF55\x82\0D\xBB.\0\x9C\xE9\x84\0\xB4&p\0A~_\0\xD6\x919\0S\x839\0\x9C\xF49\0\x8B_\x84\0(\xF9\xBD\0\xF8;\0\xDE\xFF\x97\0\x98\0/\xEF\0\nZ\x8B\0mm\0\xCF~6\0\t\xCB'\0FO\xB7\0\x9Ef?\0-\xEA_\0\xBA'u\0\xE5\xEB\xC7\0={\xF1\0\xF79\0\x92R\x8A\0\xFBk\xEA\0\xB1_\0]\x8D\00V\0{\xFCF\0\xF0\xABk\0 \xBC\xCF\06\xF4\x9A\0\xE3\xA9\0^a\x91\0\xE6\0\x85\x99e\0\xA0_\0\x8D@h\0\x80\xD8\xFF\0'sM\01\0\xCAV\0\xC9\xA8s\0{\xE2`\0k\x8C\xC0\0\xC4G\0\xCDg\xC3\0\t\xE8\xDC\0Y\x83*\0\x8Bv\xC4\0\xA6\x96\0D\xAF\xDD\0W\xD1\0\xA5>\0\xFF\03~?\0\xC22\xE8\0\x98O\xDE\0\xBB}2\0&=\xC3\0k\xEF\0\x9F\xF8^\05:\0\xF2\xCA\0\xF1\x87\0|\x90!\0j$|\0\xD5n\xFA\00-w\0;C\0\xB5\xC6\0\xC3\x9D\0\xAD\xC4\xC2\0,MA\0 \0]\0\x86}F\0\xE3q-\0\x9B\xC6\x9A\03b\0\0\xB4\xD2|\0\xB4\xA7\x97\07U\xD5\0\xD7>\xF6\0\xA3\0Mv\xFC\0d\x9D*\0p\xD7\xAB\0c|\xF8\0z\xB0W\0\xE7\0\xC0IV\0;\xD6\xD9\0\xA7\x848\0$#\xCB\0\xD6\x8Aw\0ZT#\0\0\xB9\0\xF1\n\0\xCE\xDF\0\x9F1\xFF\0fj\0\x99Wa\0\xAC\xFBG\0~\xD8\0\"e\xB7\02\xE8\x89\0\xE6\xBF`\0\xEF\xC4\xCD\0l6\t\0]?\xD4\0\xDE\xD7\0X;\xDE\0\xDE\x9B\x92\0\xD2\"(\0(\x86\xE8\0\xE2XM\0\xC6\xCA2\0\xE3\0\xE0}\xCB\0\xC0P\0\xF3\xA7\0\xE0[\0.4\0\x83b\0\x83H\0\xF5\x8E[\0\xAD\xB0\0\xE9\xF2\0HJC\0g\xD3\0\xAA\xDD\xD8\0\xAE_B\0ja\xCE\0\n(\xA4\0\xD3\x99\xB4\0\xA6\xF2\0\\w\0\xA3\xC2\x83\0a<\x88\0\x8Asx\0\xAF\x8CZ\0o\xD7\xBD\0-\xA6c\0\xF4\xBF\xCB\0\x8D\x81\xEF\0&\xC1g\0U\xCAE\0\xCA\xD96\0(\xA8\xD2\0\xC2a\x8D\0\xC9w\0&\0F\x9B\0\xC4Y\xC4\0\xC8\xC5D\0M\xB2\x91\0\0\xF3\0\xD4C\xAD\0)I\xE5\0\xFD\xD5\0\0\xBE\xFC\0\x94\xCC\0p\xCE\xEE\0>\xF5\0\xEC\xF1\x80\0\xB3\xE7\xC3\0\xC7\xF8(\0\x93\x94\0\xC1q>\0.\t\xB3\0 E\xF3\0\x88\x9C\0\xAB {\0.\xB5\x9F\0G\x92\xC2\0{2/\0 Um\0r\xA7\x90\0k\xE7\01\xCB\x96\0yJ\0Ay\xE2\0\xF4\xDF\x89\0\xE8\x94\x97\0\xE2\xE6\x84\0\x991\x97\0\x88\xEDk\0__6\0\xBB\xFD\0H\x9A\xB4\0g\xA4l\0qrB\0\x8D]2\0\x9F\xB8\0\xBC\xE5\t\0\x8D1%\0\xF7t9\00\0\r \0Kh\0,\xEEX\0G\xAA\x90\0t\xE7\0\xBD\xD6$\0\xF7}\xA6\0nHr\0\x9F\xEF\0\x8E\x94\xA6\0\xB4\x91\xF6\0\xD1SQ\0\xCF\n\xF2\0 \x983\0\xF5K~\0\xB2ch\0\xDD>_\0@]\0\x85\x89\0UR)\07d\xC0\0m\xD8\02H2\0[Lu\0Nq\xD4\0ETn\0 \t\xC1\0*\xF5i\0f\xD5\0'\x9D\0]P\0\xB4;\xDB\0\xEAv\xC5\0\x87\xF9\0Ik}\0'\xBA\0\x96i)\0\xC6\xCC\xAC\0\xADT\0\x90\xE2j\0\x88\xD9\x89\0,rP\0\xA4\xBE\0w\x94\0\xF30p\0\0\xFC'\0\xEAq\xA8\0f\xC2I\0d\xE0=\0\x97\xDD\x83\0\xA3?\x97\0C\x94\xFD\0\r\x86\x8C\01A\xDE\0\x929\x9D\0\xDDp\x8C\0\xB7\xE7\0\xDF;\07+\0\\\x80\xA0\0Z\x80\x93\0\x92\0\xE8\xD8\0l\x80\xAF\0\xDB\xFFK\08\x90\0Yv\0b\xA5\0a\xCB\xBB\0\xC7\x89\xB9\0@\xBD\0\xD2\xF2\0Iu'\0\xEB\xB6\xF6\0\xDB\"\xBB\0\n\xAA\0\x89&/\0d\x83v\0\t;3\0\x94\0Q:\xAA\0\xA3\xC2\0\xAF\xED\xAE\0\\&\0m\xC2M\0-z\x9C\0\xC0V\x97\0?\x83\0\t\xF0\xF6\0+@\x8C\0m1\x99\09\xB4\0 \0\xD8\xC3[\0\xF5\x92\xC4\0\xC6\xADK\0N\xCA\xA5\0\xA77\xCD\0\xE6\xA96\0\xAB\x92\x94\0\xDDBh\0c\xDE\0v\x8C\xEF\0h\x8BR\0\xFC\xDB7\0\xAE\xA1\xAB\0\xDF1\0\0\xAE\xA1\0 \xFB\xDA\0dMf\0\xED\xB7\0)e0\0WV\xBF\0G\xFF:\0j\xF9\xB9\0u\xBE\xF3\0(\x93\xDF\0\xAB\x800\0f\x8C\xF6\0\xCB\0\xFA\"\0\xD9\xE4\0=\xB3\xA4\0W\x8F\06\xCD\t\0NB\xE9\0\xBE\xA4\03#\xB5\0\xF0\xAA\0Oe\xA8\0\xD2\xC1\xA5\0 ?\0[x\xCD\0#\xF9v\0{\x8B\0\x89r\0\xC6\xA6S\0on\xE2\0\xEF\xEB\0\0\x9BJX\0\xC4\xDA\xB7\0\xAAf\xBA\0v\xCF\xCF\0\xD1\0\xB1\xF1-\0\x8C\x99\xC1\0\xC3\xADw\0\x86H\xDA\0\xF7]\xA0\0\xC6\x80\xF4\0\xAC\xF0/\0\xDD\xEC\x9A\0?\\\xBC\0\xD0\xDEm\0\x90\xC7\0*\xDB\xB6\0\xA3%:\0\0\xAF\x9A\0\xADS\x93\0\xB6W\0)-\xB4\0K\x80~\0\xDA\xA7\0v\xAA\0{Y\xA1\0*\0\xDC\xB7-\0\xFA\xE5\xFD\0\x89\xDB\xFE\0\x89\xBE\xFD\0\xE4vl\0\xA9\xFC\0>\x80p\0\x85n\0\xFD\x87\xFF\0(>\0ag3\0*\x86\0M\xBD\xEA\0\xB3\xE7\xAF\0\x8Fmn\0\x95g9\01\xBF[\0\x84\xD7H\00\xDF\0\xC7-C\0%a5\0\xC9p\xCE\00\xCB\xB8\0\xBFl\xFD\0\xA4\0\xA2\0l\xE4\0Z\xDD\xA0\0!oG\0b\xD2\0\xB9\\\x84\0paI\0kV\xE0\0\x99R\0PU7\0\xD5\xB7\03\xF1\xC4\0n_\0]0\xE4\0\x85.\xA9\0\xB2\xC3\0\xA126\0\xB7\xA4\0\xEA\xB1\xD4\0\xF7!\0\x8Fi\xE4\0'\xFFw\0 \x80\0\x8D@-\0O\xCD\xA0\0 \xA5\x99\0\xB3\xA2\xD3\0/]\n\0\xB4\xF9B\0\xDA\xCB\0}\xBE\xD0\0\x9B\xDB\xC1\0\xAB\xBD\0\xCA\xA2\x81\0j\\\0.U\0'\0U\0\xF0\0\xE1\x86\0 d\0\x96A\x8D\0\x87\xBE\xDE\0\xDA\xFD*\0k%\xB6\0{\x894\0\xF3\xFE\0\xB9\xBF\x9E\0hjO\0J*\xA8\0O\xC4Z\0-\xF8\xBC\0\xD7Z\x98\0\xF4\xC7\x95\0\rM\x8D\0 :\xA6\0\xA4W_\0?\xB1\0\x808\x95\0\xCC \0q\xDD\x86\0\xC9\xDE\xB6\0\xBF`\xF5\0Me\0k\0\x8C\xB0\xAC\0\xB2\xC0\xD0\0QUH\0\xFB\0\x95r\xC3\0\xA3;\0\xC0@5\0\xDC{\0\xE0E\xCC\0N)\xFA\0\xD6\xCA\xC8\0\xE8\xF3A\0|d\xDE\0\x9Bd\xD8\0\xD9\xBE1\0\xA4\x97\xC3\0wX\xD4\0i\xE3\xC5\0\xF0\xDA\0\xBA:<\0FF\0Uu_\0\xD2\xBD\xF5\0n\x92\xC6\0\xAC.]\0D\xED\0>B\0a\xC4\x87\0)\xFD\xE9\0\xE7\xD6\xF3\0\"|\xCA\0o\x915\0\xE0\xC5\0\xFF\xD7\x8D\0nj\xE2\0\xB0\xFD\xC6\0\x93\xC1\0|]t\0k\xAD\xB2\0\xCDn\x9D\0>r{\0\xC6j\0\xF7\xCF\xA9\0)s\xDF\0\xB5\xC9\xBA\0\xB7\0Q\0\xE2\xB2\r\0t\xBA$\0\xE5}`\0t\xD8\x8A\0\r,\0\x81 \0~f\x94\0)\0\x9Fzv\0\xFD\xFD\xBE\0VE\xEF\0\xD9~6\0\xEC\xD9\0\x8B\xBA\xB9\0\xC4\x97\xFC\01\xA8'\0\xF1n\xC3\0\x94\xC56\0\xD8\xA8V\0\xB4\xA8\xB5\0\xCF\xCC\0\x89-\0oW4\0,V\x89\0\x99\xCE\xE3\0\xD6 \xB9\0k^\xAA\0>*\x9C\0_\xCC\0\xFD J\0\xE1\xF4\xFB\0\x8E;m\0\xE2\x86,\0\xE9\xD4\x84\0\xFC\xB4\xA9\0\xEF\xEE\xD1\0.5\xC9\0/9a\08!D\0\xD9\xC8\0\x81\xFC\n\0\xFBJj\0/\xD8\0S\xB4\x84\0N\x99\x8C\0T\"\xCC\0*U\xDC\0\xC0\xC6\xD6\0 \x96\0p\xB8\0i\x95d\0&Z`\0?R\xEE\0\0\xF4\xB5\0\xFC\xCB\xF5\04\xBC-\04\xBC\xEE\0\xE8]\xCC\0\xDD^`\0g\x8E\x9B\0\x923\xEF\0\xC9\xB8\0aX\x9B\0\xE1W\xBC\0Q\x83\xC6\0\xD8>\0\xDDqH\0-\xDD\0\xAF\xA1\0!,F\0Y\xF3\xD7\0\xD9z\x98\0\x9ET\xC0\0O\x86\xFA\0V\xFC\0\xE5y\xAE\0\x89\"6\08\xAD\"\0g\x93\xDC\0U\xE8\xAA\0\x82&8\0\xCA\xE7\x9B\0Q\r\xA4\0\x993\xB1\0\xA9\xD7\0iH\0e\xB2\xF0\0\x88\xA7\0\x88L\x97\0\xF9\xD16\0!\x92\xB3\0{\x82J\0\x98\xCF!\0@\x9F\xDC\0\xDCGU\0\xE1t:\0g\xEBB\0\xFE\x9D\xDF\0^\xD4_\0{g\xA4\0\xBA\xACz\0U\xF6\xA2\0+\x88#\0A\xBAU\0Yn\0!*\x86\09G\x83\0\x89\xE3\xE6\0\xE5\x9E\xD4\0I\xFB@\0\xFFV\xE9\0\xCA\0\xC5Y\x8A\0\x94\xFA+\0\xD3\xC1\xC5\0\xC5\xCF\0\xDBZ\xAE\0G\xC5\x86\0\x85Cb\0!\x86;\0,y\x94\0a\x87\0*L{\0\x80,\0C\xBF\0\x88&\x90\0x<\x89\0\xA8\xC4\xE4\0\xE5\xDB{\0\xC4:\xC2\0&\xF4\xEA\0\xF7g\x8A\0\r\x92\xBF\0e\xA3+\0=\x93\xB1\0\xBD| \0\xA4Q\xDC\0'\xDDc\0i\xE1\xDD\0\x9A\x94\0\xA8)\x95\0h\xCE(\0\t\xED\xB4\0D\x9F \0N\x98\xCA\0p\x82c\0~|#\0\xB92\0\xA7\xF5\x8E\0V\xE7\0!\xF1\0\xB5\x9D*\0o~M\0\xA5Q\0\xB5\xF9\xAB\0\x82\xDF\xD6\0\x96\xDDa\06\0\xC4:\x9F\0\x83\xA2\xA1\0r\xEDm\09\x8Dz\0\x82\xB8\xA9\0k2\\\0F'[\0\04\xED\0\xD2\0w\0\xFC\xF4U\0YM\0\xE0q\x80\0");
memory.store_slice(4160, b"\0\0\0@\xFB!\xF9?\0\0\0\0-Dt>\0\0\0\x80\x98F\xF8<\0\0\0`Q\xCCx;\0\0\0\x80\x83\xF09\0\0\0@ %z8\0\0\0\x80\"\x82\xE36\0\0\0\0\xF3i5");
memory.store_slice(4224, b"\0\0\0\0\0\0\xE0?\0\0\0\0\0\0\xE0\xBF\0\0\0?\0\0\0\xBF");
memory.store_slice(4256, b"V\xE7\x9E\xAF\xD2<\x9B+\xA1\x86\x9B\x84=\x82vIh\xC2%<=\xEA-\x81\x99\x97q=\x95dy\xE1\xFD\xA5=\xBB\xBD\xD7\xD9\xDF|\xDB=\x95\xD6&\xE8 .>:\x8C0\xE2\x8EyE>H\xAF\xBC\x9A\xF2\xD7z>\x8D\xED\xB5\xA0\xF7\xC6\xB0>\xF1h\xE3\x88\xB5\xF8\xE4>-C\xEB\xE26?\xFC\xA9\xF1\xD2MbP?{\xAEG\xE1z\x84?\x9A\x99\x99\x99\x99\x99\xB9?\0\0\0\0\0\0\xF0?\0\0\0\0\0\0$@\0\0\0\0\0\0Y@\0\0\0\0\0@\x8F@\0\0\0\0\0\x88\xC3@\0\0\0\0\0j\xF8@\0\0\0\0\x80\x84.A\0\0\0\0\xD0cA\0\0\0\0\x84\xD7\x97A\0\0\0\0e\xCD\xCDA\0\0\0 _\xA0B\0\0\0\xE8vH7B\0\0\0\xA2\x94mB\0\0@\xE5\x9C0\xA2B\0\0\x90\xC4\xBC\xD6B\0\04&\xF5k C");
memory.store_slice(4512, b"\x95\xBF\xD63\xBD7\x865\xAC\xC5'7\xB7\xD18o\x83:\n\xD7#<\xCD\xCC\xCC=\0\0\x80?\0\0 A\0\0\xC8B\0\0zD\0@F\0P\xC3G\0$tI\x80\x96K");
memory.store_slice(4576, b"\xEC\x97n:\xB2Yau\xEE\xF9: \xCD?\xE7=\x83\t\t\xA7\xB0\xB9j\xB8Ih\xD0?a\r\xE4K\xCBP&h\x97\x84&\\\xC2\xD3?]\x88n\xF2\x97\xA1\xDE\x98y\xD7?t*J\xD3\xEF\xFDUI\x96\xFE\xD7_\xDA?\xB5\x88\xE6j}\xAB\xDB{\x9D\xFD\xCD\xB7\xDD?*\xF1\xD0b.Kim\x82\xBE\xE0\xE1?umV\x84\xFB\xF9\x9D\xC3#\xEE\x98W\xE4?\xD2\xEC ezx\x85\xF4\xCA\xAB)\xAD\xE7?\x83\x85\x934Lk\xD3\xD8^ zo \xEB?\xE4f\xB8\x9FF\x8F6\x8EX\x8BO\xEE?\x9D\x80&\xC2\x86\xA7W\xCA2\xC4\xB1.n\xA3\xF1?bX9\xB4\xC8v\xBE\x9F/\xDD$\xF5?{\xAEG\xE1z\xAEG\xE1z\xAEG\xF8?\x9A\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\xFB?\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xFF?\0\0\0\0\0\0\0\0\0\0\0\0\0@@\0\0\0\0\0\0\0\0\0\0\0\0\0\x90@\0\0\0\0\0\0\0\0\0\0\0\0\0\xF4@\0\0\0\0\0\0\0\0\0\0\0\0\x808 @\0\0\0\0\0\0\0\0\0\0\0\0\xA0\x86@\0\0\0\0\0\0\0\0\0\0\0\0H\xE8@\0\0\0\0\0\0\0\0\0\0\0\0-1@\0\0\0\0\0\0\0\0\0\0\0@x}@\0\0\0\0\0\0\0\0\0\0\0P\xD6\xDC@\0\0\0\0\0\0\0\0\0\0\0\xF2* @\0\0\0\0\0\0\0\0\0\0\x80n\x87t#@\0\0\0\0\0\0\0\0\0\0 J\xA9\xD1&@\0\0\0\0\0\0\0\0\0\0T\xCE\t#*@\0\0\0\0\0\0\0\0\0\0\xE9A\xCCk-@\0\0\0\0\0\0\0\0\0@cR\xBF\xC60@");
memory.store_slice(5072, b"]=f\x9E\xA0\xE6?\0\0\0\0\0\x889=Du\xFAR\xB0\xE6?\0\0\0\0\0\0\xD8<\xFE\xD9 u\xC0\xE6?\0\0\0\0\0x(\xBD\xBFv\xD4\xDD\xDC\xCF\xE6?\0\0\0\0\0\xC0=)e<\xB2\xDF\xE6?\0\0\0\0\0\0\xD8\xBC\xE3:Y\x98\x92\xEF\xE6?\0\0\0\0\0\0\xBC\xBC\x86\x93Q\xF9}\xFF\xE6?\0\0\0\0\0\xD8/\xBD\xA3-\xF4ft\xE7?\0\0\0\0\0\x88,\xBD\xC3_\xEC\xE8u\xE7?\0\0\0\0\0\xC0=\xCF\xEA\x86\x82/\xE7?\0\0\0\0\008\xBDR\x81\xA5H\x9A?\xE7?\0\0\0\0\0\xC0\0\xBD\xFC\xCC\xD75\xBDO\xE7?\0\0\0\0\0\x88/=\xF1gBV\xEB_\xE7?\0\0\0\0\0\xE0=Hm\xAB\xB1$p\xE7?\0\0\0\0\0\xD0'\xBD8]\xDEOi\x80\xE7?\0\0\0\0\0\0\xDD\xBC\0\xAC8\xB9\x90\xE7?\0\0\0\0\0\0\xE3<x\xEBs\xA1\xE7?\0\0\0\0\0\0\xED\xBC`\xD0v\t{\xB1\xE7?\0\0\0\0\0@ =3\xC10\xED\xC1\xE7?\0\0\0\0\0\0\xA0<6\x86\xFFbj\xD2\xE7?\0\0\0\0\0\x90&\xBD;N\xCF6\xF3\xE2\xE7?\0\0\0\0\0\xE0\xBD\xE8\xC3\x91\x84\x87\xF3\xE7?\0\0\0\0\0X$\xBDN>T'\xE8?\0\0\0\0\0\03=\xD1\xAD\xD2\xE8?\0\0\0\0\0\0=~\xCDL\x99\x89%\xE8?\0\0\0\0\0\xC0!\xBD\xD0B\xB9L6\xE8?\0\0\0\0\0\xD0)=\xB5\xCA#FG\xE8?\0\0\0\0\0G=\xBC[\x9F\xF4W\xE8?\0\0\0\0\0`\"=\xAF\x91D\x9B\xD9h\xE8?\0\0\0\0\0\xC42\xBD\x95\xA31\xD9\xCAy\xE8?\0\0\0\0\0\0#\xBD\xB8e\x8A\xD9\xC7\x8A\xE8?\0\0\0\0\0\x80*\xBD\0Xx\xA4\xD0\x9B\xE8?\0\0\0\0\0\0\xED\xBC#\xA2*B\xE5\xAC\xE8?\0\0\0\0\0(3=\xFA\xD6\xBA\xBE\xE8?\0\0\0\0\0\xB4B=\x83C\xB52\xCF\xE8?\0\0\0\0\0\xD0.\xBDLf^j\xE0\xE8?\0\0\0\0\0P \xBDx\x99\xAE\xF1\xE8?\0\0\0\0\0((=,(\xD0\xFE\xE9?\0\0\0\0\0\xB0\xBD\x96\xFF\x91 [\xE9?\0\0\0\0\0\xE0\xBD\xF9/\xAAS\xC3%\xE9?\0\0\0\0\0@\xF5<J\xC6\xCD\xB077\xE9?\0\0\0\0\0 =\xAE\x98_+\xB8H\xE9?\0\0\0\0\0\0\t\xBD\xCBR\xC8\xCBDZ\xE9?\0\0\0\0\0h%=!ov\x9A\xDDk\xE9?\0\0\0\0\0\xD06\xBD*N\xDE\x9F\x82}\xE9?\0\0\0\0\0\0\xBD\xA3#z\xE43\x8F\xE9?\0\0\0\0\0\0-=\xCAp\xF1\xA0\xE9?\0\0\0\0\0\xA48\xBD\x89\xFFSM\xBB\xB2\xE9?\0\0\0\0\0\\5=[\xF1\xA3\x82\x91\xC4\xE9?\0\0\0\0\0\xB8&=\xC5\xB8Kt\xD6\xE9?\0\0\0\0\0\0\xEC\xBC\x8E#\xE3c\xE8\xE9?\0\0\0\0\0\xD0=\xF3\x8D^\xFA\xE9?\0\0\0\0\0@=M\xE5]{f \xEA?\0\0\0\0\0\0\xF5\xBC\xF6\xB8\x8E\xEDz\xEA?\0\0\0\0\0\xE0\t='.J\xEC\x9B0\xEA?\0\0\0\0\0\xD8*=]\nF\x80\xC9B\xEA?\0\0\0\0\0\xF0\xBD\x9B%>\xB2U\xEA?\0\0\0\0\0` =b\xF4\x8AJg\xEA?\0\0\0\0\0\x888=\xA7\xB30\x9Ey\xEA?\0\0\0\0\0 =\x8D.\xC1S\xFE\x8B\xEA?\0\0\0\0\0\xC0=\xD2\xFCyUk\x9E\xEA?\0\0\0\0\0\xB8)\xBD\xB8o5!\xE5\xB0\xEA?\0\0\0\0\0p+=\x81\xF3\xD3\xBFk\xC3\xEA?\0\0\0\0\0\0\xD9<\x80'<:\xFF\xD5\xEA?\0\0\0\0\0\0\xE4<\xA3\xD2Z\x99\x9F\xE8\xEA?\0\0\0\0\0\x90,\xBDg\xF3\"\xE6L\xFB\xEA?\0\0\0\0\0P=\x90\xB7\x8D)\xEB?\0\0\0\0\0\xD4/=\xA9\x89\x9Al\xCE \xEB?\0\0\0\0\0p=KO\xB8\xA23\xEB?\0\0\0\0\0GM=\xE7G\xB7\x84F\xEB?\0\0\0\0\088\xBD:Y\xE5\x8DrY\xEB?\0\0\0\0\0\0\x98<j\xC5\xF1)nl\xEB?\0\0\0\0\0\xD0\n=P^\xFB\xF2v\xEB?\0\0\0\0\0\x80\xDE<\xB2I'\xF2\x8C\x92\xEB?\0\0\0\0\0\xC0\xBD\xA10\xB0\xA5\xEB?\0\0\0\0\0p\r\xBDfo\x9A\xB7\xE0\xB8\xEB?\0\0\0\0\0\x90\r=\xFF\xC1K\x90\xCC\xEB?\0\0\0\0\0\xA0=o\xA1\xF3\xC3i\xDF\xEB?\0\0\0\0\0x\xBD\xB8\xD7[\xC2\xF2\xEB?\0\0\0\0\0\xA0\xBD\xE9\xB2Aa(\xEC?\0\0\0\0\0@\xBD\xE0R\x85\xDD\x9B\xEC?\0\0\0\0\0\xE0 =\xEEd\xFA\xD9-\xEC?\0\0\0\0\0@\t\xBD/\xD0\xFF_\xAB@\xEC?\0\0\0\0\0\xD0\xBD\xFD\xFAxGT\xEC?\0\0\0\0\0f9=\xCB\xD0W.\xF1g\xEC?\0\0\0\0\0\xBD\xB6\xC1\x88\x89\xA8{\xEC?\0\0\0\0\x80EX\xBD3\xE7\x94m\x8F\xEC?\0\0\0\0\0H\xBD\xDF\xC4QW@\xA3\xEC?\0\0\0\0\0\0\xCB<\x94\x90\xEF\xDC \xB7\xEC?\0\0\0\0\0@=\x89m.\xCB\xEC?\0\0\0\0\0 \xF0<\xC4]U \xDF\xEC?\0\0\0\0\0`\xF3<;\xAB[[\xF3\xEC?\0\0\0\0\0\x90\xBD\xBC\x89J-\xED?\0\0\0\0\0\xA0\t=\xFA\xC8+S\xED?\0\0\0\0\0\xE0\xBD\x85\x8A\r\x87/\xED?\0\0\0\0\0(=\xA2\xCA\xEA\xC8C\xED?\0\0\0\0\0\xA0=\x91\xA4\xFB\xDCX\xED?\0\0\0\0\0\0\xDF<\xA1\xE6b\xE8vl\xED?\0\0\0\0\0\xA0\xBDN\x83\xC9\xE3\x80\xED?\0\0\0\0\0\xD8 \xBD\x90`\xFFq]\x95\xED?\0\0\0\0\0\xC0\xF4<\xAE2\xDB\xE6\xA9\xED?\0\0\0\0\0\x90\xFF<%\x83:\xD6|\xBE\xED?\0\0\0\0\0\x80\xE9<E\xB4\xF3!\xD3\xED?\0\0\0\0\0 \xF5\xBC\xBFd\xD5\xE7\xED?\0\0\0\0\0p\xBD\xEC\x9A{3\x97\xFC\xED?\0\0\0\0\0\xBD^}kg\xEE?\0\0\0\0\0H =\xE7\xA3\xF5F&\xEE?\0\0\0\0\0\xCE@=\\\xEE;3;\xEE?\0\0\0\0\0h =\xB4?\x8B\xE7.P\xEE?\0\0\0\0\00\t\xBDhmg$9e\xEE?\0\0\0\0\0\0\xE5\xBCDL\xC7\xFBQz\xEE?\0\0\0\0\0\xF8\xBD&\xB7\xCDwy\x8F\xEE?\0\0\0\0\0p\xF3\xBC\xE8\x90\xA4\xA2\xAF\xA4\xEE?\0\0\0\0\0\xD0\xE5<\xE4\xCA|\x86\xF4\xB9\xEE?\0\0\0\0\0=\rh\x8E-H\xCF\xEE?\0\0\0\0\0P\xF5<\x85\xA2\xAA\xE4\xEE?\0\0\0\0\0@\xC6<Za\xEE\xFA\xEE?\0\0\0\0\0\x80\xEE\xBCA\xB6\x9C\xEF?\0\0\0\0\0\x88\xFA\xBCc\xB9k7+%\xEF?\0\0\0\0\0\x90,\xBDur\xDDH\xC9:\xEF?\0\0\0\0\0\0\xAA<$En[vP\xEF?\0\0\0\0\0\xF0\xF4\xBC\xFDD\x88y2f\xEF?\0\0\0\0\0\x80\xCA<8\xBE\x9C\xAD\xFD{\xEF?\0\0\0\0\0\xBC\xFA<\x82<$\xD8\x91\xEF?\0\0\0\0\0`\xD4\xBC\x8E\x90\x9E\x81\xC1\xA7\xEF?\0\0\0\0\0 \xBD\xD5\x926\xBA\xBD\xEF?\0\0\0\0\0\xE0\xC0\xBC\x94q\x8F+\xC2\xD3\xEF?\0\0\0\0\x80\xDE\xBD\xEE#*k\xD9\xE9\xEF?\0\0\0\0\0C\xEE<\0\0\0\0\0\0\xF0?\0\0\0\0\0\0\0\0\xBE\xBCZ\xFA \xF0?\0\0\0\0\0@\xB3\xBC3\xFB\xA9=\xF0?\0\0\0\0\0\xBD\x82;h!\xF0?\0\0\0\0\0@\xBA<l\x80w>\x9A,\xF0?\0\0\0\0\0\x98\xEF<\xCA\xBB.\xD47\xF0?\0\0\0\0\0@\xC7\xBC\x89n\xE8C\xF0?\0\0\0\0\00\xD8<gT\xF6r_N\xF0?\0\0\0\0\0?\xBDZ\x85\xD3\xB0Y\xF0?\0\0\0\0\0\x84\xBD\x95<\ne\xF0?\0\0\0\0\0`\xF1<\xF7\xDD)kp\xF0?\0\0\0\0\0$=-\xA8r+\xD4{\xF0?\0\0\0\0\0\xA0\xE9\xBC\xD0\x9BuE\x87\xF0?\0\0\0\0\0@\xE6<\xC8f\xF6\xBD\x92\xF0?\0\0\0\0\0x\0\xBD\x83\xF3\xC6\xCA>\x9E\xF0?\0\0\0\0\0\0\x98\xBC09\x9B\xC7\xA9\xF0?\0\0\0\0\0\xA0\xFF<\xFC\x88\xF9lX\xB5\xF0?\0\0\0\0\0\xC8\xFA\xBC\x8Al\xE4E\xF1\xC0\xF0?\0\0\0\0\0\xC0\xD9<Hr+\x92\xCC\xF0?\0\0\0\0\0 =\xD8]9#;\xD8\xF0?\0\0\0\0\0\xD0\xFA\xBC\xF3\xD1\xD32\xEC\xE3\xF0?\0\0\0\0\0\xAC=\xA6\xA9\xDF_\xA5\xEF\xF0?\0\0\0\0\0\xE8\xBD\xF0\xD2\xFE\xAFf\xFB\xF0?\0\0\0\0\00\r\xBDK#\xD7(0\xF1?\0\0\0\0\0P\xF1<[[\xD0\xF1?\0\0\0\0\0\0\xEC<\xF9*^\xAB\xDB\xF1?\0\0\0\0\0\xBC=\xD51l\xC0\xBD*\xF1?\0\0\0\0\0@\xE8<}\xF2\xA86\xF1?\0\0\0\0\0\xD0\xBD\xE9-\xA9\xAE\x9AB\xF1?\0\0\0\0\0\xE0\xE8<81O\x93\x95N\xF1?\0\0\0\0\0@\xEB<q\x8E\xA5\xC8\x98Z\xF1?\0\0\0\0\00=\xDF\xC3qT\xA4f\xF1?\0\0\0\0\08=R}<\xB8r\xF1?\0\0\0\0\0\xD4(=\x9F\xBB\x95\x86\xD4~\xF1?\0\0\0\0\0\xD0\xBD\x93\x8D\x8C8\xF9\x8A\xF1?\0\0\0\0\0\x88\xBDf]7X&\x97\xF1?\0\0\0\0\0\xF0=\xA7\xCBo\xEB[\xA3\xF1?\0\0\0\0\0H=\xE3\x87\xF8\x99\xAF\xF1?\0\0\0\0\09G\xBDT]\x84\xE0\xBB\xF1?\0\0\0\0\0\xE4$=C(\x95/\xC8\xF1?\0\0\0\0\0 \n\xBD\xB2\xB9h1\x87\xD4\xF1?\0\0\0\0\0\x80\xE3<1@\xB4^\xE7\xE0\xF1?\0\0\0\0\0\xC0\xEA<8\xD9\xFC\"P\xED\xF1?\0\0\0\0\0\x90=\xF7\xCD8\x84\xC1\xF9\xF1?\0\0\0\0\0x\xBD\x8F\x8Db\x88;\xF2?\0\0\0\0\0\x94-=\xA8x5\xBE\xF2?\0\0\0\0\0\0\xD8<A\xDD}\x91I\xF2?\0\0\0\0\04+=#y\xA2\xDD+\xF2?\0\0\0\0\0\xF8=\xE7aunz8\xF2?\0\0\0\0\0\xC8\xBD'\x82\xFBE\xF2?\0\0\0\0\00=\xA6\xB2O\xCEQ\xF2?\0\0\0\0\0H\xBD\xB0\xCEq\x85^\xF2?\0\0\0\0\0p=}\xE2eEk\xF2?\0\0\0\0\0\xD0=\xE04x\xF2?\0\0\0\0\0\xEE1=>c\xF5\xE1\xDF\x84\xF2?\0\0\0\0\0\xC0\xBD0\xBB\x91u\xBA\x91\xF2?\0\0\0\0\0\xD8\xBD\t\xDF\xF5\x9D\x9E\xF2?\0\0\0\0\0\xB0=\x9B\xD1f\x8A\xAB\xF2?\0\0\0\0\0|\"\xBD:\xDA\xDA\xD0\xB8\xF2?\0\0\0\0\04*=\xF9w9~\xC5\xF2?\0\0\0\0\0\x80\xBD\xD9\xE4\xA6\x85\xD2\xF2?\0\0\0\0\0\xD0\xBDyd\x96\xDF\xF2?\0\0\0\0\0 \xF4\xBC\xCF.>\xA9\xAF\xEC\xF2?\0\0\0\0\0\x98$\xBD\"\x88\xBDJ\xD2\xF9\xF2?\0\0\0\0\00\xBD%\xB61\n\xFE\xF3?\0\0\0\0\062\xBD \xA5\xEE\xED2\xF3?\0\0\0\0\x80\xDFp\xBD\xB8\xD7L\xFCp!\xF3?\0\0\0\0\0H\"\xBD\xA2\xE9\xA8;\xB8.\xF3?\0\0\0\0\0\x98%\xBDfd\xB2<\xF3?\0\0\0\0\0\xD0='\xFA\xE3fbI\xF3?\0\0\0\0\0\0\xDC\xBC\x9F\x92_\xC5V\xF3?\0\0\0\0\0\xD80\xBD\xB9\x88\xDE\xA21d\xF3?\0\0\0\0\0\xC8\"=9\xAA:7\xA7q\xF3?\0\0\0\0\0` =\xFEt#&\xF3?\0\0\0\0\0`\xBD8\xD8m\xAE\x8C\xF3?\0\0\0\0\0\xE0\n\xBD\xC3>q@\x9A\xF3?\0\0\0\0\0rD\xBD \xA0\xE54\xDB\xA7\xF3?\0\0\0\0\0 =\x95n\xEC\xBF\xB5\xF3?\0\0\0\0\0\x80>=\xF2\xA8\xC3-\xC3\xF3?\0\0\0\0\0\x80\xEF<\"\xE1\xEDD\xE5\xD0\xF3?\0\0\0\0\0\xA0\xBD\xBB4L\xA6\xDE\xF3?\0\0\0\0\00&=\xCCN\xDFp\xEC\xF3?\0\0\0\0\0\xA6H\xBD\x8C~\xACE\xFA\xF3?\0\0\0\0\0\xDC<\xBD\xBB\xA0g\xC3\"\xF4?\0\0\0\0\0\xB8%=\x95.\xF7!\n\xF4?\0\0\0\0\0\xC0=FF\t'\xFB#\xF4?\0\0\0\0\0`\xBD \xA9P\xD9\xF51\xF4?\0\0\0\0\0\x98#=\xEB\xB9\x84?\xFA?\xF4?\0\0\0\0\0\0\xFA<\x89a`N\xF4?\0\0\0\0\0\xC0\xF6\xBC\xD2\xA7B \\\xF4?\0\0\0\0\0\xC0 \xBD\0\xEDAj\xF4?\0\0\0\0\0\x80\xBD&3\x8Bfmx\xF4?\0\0\0\0\0\xE00=\0<\xC1\xB5\xA2\x86\xF4?\0\0\0\0\0@-\xBD\xAF\x92\xE1\xE1\x94\xF4?\0\0\0\0\0 =r\xD3\xD7\xF0*\xA3\xF4?\0\0\0\0\0P\xBD\xB8m\xEA}\xB1\xF4?\0\0\0\0\0\x80=\xE1)6\xD5\xDA\xBF\xF4?\0\0\0\0\0\x80\xBD2\xC1\xB8A\xCE\xF4?\0\0\0\0\0\x80\0=\xDB\xDD\xFD\x99\xB2\xDC\xF4?\0\0\0\0\0p,=\x96\xAB\xD8\x81-\xEB\xF4?\0\0\0\0\0\xE0\xBD-\x9Dv\xB2\xF9\xF4?\0\0\0\0\0 =\xC11EA\xF5?\0\0\0\0\0\xC0\xBD*f\xCF\xA2\xDA\xF5?\0\0\0\0\0\0\xFA\xBC\xEAQ?\xE8}%\xF5?\0\0\0\0\0J=\xDAN\x9DV+4\xF5?\0\0\0\0\0\xD8&\xBD\xAC\xF6\xF4\xE2B\xF5?\0\0\0\0\0D2\xBD\xDB\x94]\xCA\xA4Q\xF5?\0\0\0\0\0<H=k\xE9\xDDp`\xF5?\0\0\0\0\0\xB0$=\xDE)\xB56Go\xF5?\0\0\0\0\0ZA=\xC4\xE2\xDB'~\xF5?\0\0\0\0\0\xE0)\xBDo\xC7\x97\xD4\x8D\xF5?\0\0\0\0\0#\xBDL \xFF'\x9C\xF5?\0\0\0\0\0\xECM='TH\xDD\xAB\xF5?\0\0\0\0\0\0\xC4\xBC\xF4z\xA8\xFB\xBA\xF5?\0\0\0\0\00= FY\x8A&\xC9\xF5?\0\0\0\0\0\xC8&\xBD?\x8E\x99\x90E\xD8\xF5?\0\0\0\0\0\x9AF=\xE1 \xADo\xE7\xF5?\0\0\0\0\0@\xBD\xCA\xEB\xDC \xA3\xF6\xF5?\0\0\0\0\0p=\xB8\xDCv\xB9\xE1\xF6?\0\0\0\0\0\xF8&=\xF7\xCD\xE6*\xF6?\0\0\0\0\0\0=1U:\xB0~$\xF6?\0\0\0\0\0\xD0\xBD\xB5)\xDD3\xF6?\0\0\0\0\0\xD0\xBD\xC3\xCC4FC\xF6?\0\0\0\0\0\x80\xEA\xBC\xFA\x8E\xBC\xFE\xB9R\xF6?\0\0\0\0\0`(\xBD\x973U\x828b\xF6?\0\0\0\0\0\xFEq=\x8E2\xC7\xC1q\xF6?\0\0\0\0\0 7\xBD~\xA9L\xD4U\x81\xF6?\0\0\0\0\0\x80\xE6<q\x94\x9E\xB1\xF4\x90\xF6?\0\0\0\0\0x)\xBD\xCD;f\x9E\xA0\xE6?\x80d\xB24\xDD\x8B\xBC\xBF\xDA u\xC0\xE6?\0 \xFFgV\x89b\xBC/e<\xB2\xDF\xE6?\0\x88<h:\xBE[\xBC\x84\x94Q\xF9}\xFF\xE6?\0\x86%<x\xBCt_\xEC\xE8u\xE7?\0{\x88\x86Gnq\xBCt\x81\xA5H\x9A?\xE7?\0\xD5el\xD9\xA8\x80\xBC\xC9gBV\xEB_\xE7?\0n1WY$\x80\xBC?]\xDEOi\x80\xE7?\0\n\xB8f\x88<\x87\xEBs\xA1\xE7?\0\x99\xEEwt\xBC2\xC10\xED\xC1\xE7?\0N\xD1L\x8F<bN\xCF6\xF3\xE2\xE7?\0z\xBA]`<>T'\xE8?\0\x97mb\x86|\x82\xBC\xCEL\x99\x89%\xE8?\03\xD4L\x8D\xBC\xAD\xC7#FG\xE8?\0\xCEA\xA3\x84\xD6x\xBC\xED\x92D\x9B\xD9h\xE8?\x80\xF6\xD4\x9B\xF8\xC6\x8F\xBC\x99f\x8A\xD9\xC7\x8A\xE8?\0\xB5|\xF3\xC2\x94\x89<\xDB\xA0*B\xE5\xAC\xE8?\0K\x86V\xF1\xE9\x86<\x8CD\xB52\xCF\xE8?\0\xE4\xE92^\xD5`\xBC6w\x99\xAE\xF1\xE8?\0\x97\xE3\xA2\xCCu<\xC6\xFF\x91 [\xE9?\0%X.y\xD6\x8D\xBC\xE5\xC5\xCD\xB077\xE9?\0\x80\xB5\x81\xC7_W\xBCR\xC8\xCBDZ\xE9?\0\xF0\xA5\x96|Kf\xBCPN\xDE\x9F\x82}\xE9?\0\x86|[\x8D\xBC\xBA\xCAp\xF1\xA0\xE9?\0\xE6\xCE\x91\xBDs\x81\xBC\x90\xF0\xA3\x82\x91\xC4\xE9?\0\xF2q\xB0F|l<##\xE3c\xE8\xE9?\0L\xE6x\xCA$h<e\xE5]{f \xEA?\0\xD5]IY\x83\xBC3-J\xEC\x9B0\xEA?\x806\xDC}\\0\x86<]%>\xB2U\xEA?\0B\x8D\xDBn/\x8D\xBCX\xB30\x9Ey\xEA?\0d\xC5\xCA~\xCB\x8B<\xBF\xFDyUk\x9E\xEA?\0\xFD\xF7\xC9\xFA\x80<z\xF3\xD3\xBFk\xC3\xEA?\0m\xE7\xCA4\x92\xBC\xAD\xD3Z\x99\x9F\xE8\xEA?\x80\xCC]4\xCD\xA1\x87<f\xB6\x8D)\xEB?\0\xE4\x80L\xF5\xDE\x8B\xBC\xFBO\xB8\xA23\xEB?\0\xD8\x840^\x80R\xBC:Y\xE5\x8DrY\xEB?\0n\xBA\xBB\xDFq\x8C\xBCG^\xFB\xF2v\xEB?\0\xACT~OXe\xBCJ\xA10\xB0\xA5\xEB?\0)T\xD3\xFC\x8E\xBC\xD2\xC1K\x90\xCC\xEB?\0\x9F-z\xD0=r<\t\xD7[\xC2\xF2\xEB?\x80\x9Ck?\xCA\xFD\x8E\xBC\x9CR\x85\xDD\x9B\xEC?\0IP\x89eq<z\xD0\xFF_\xAB@\xEC?\0\xC6\x83\xE07E\x8B<K\xD1W.\xF1g\xEC?\x80<H\xFFM\x88\x82<\xB5\xE7\x94m\x8F\xEC?\0\\\x80H\xBC\xACa<i\x90\xEF\xDC \xB7\xEC?\0J\xE9\xD1\xCBe<\xFA\xC3]U \xDF\xEC?\0\x9D\x82S;\xD8}\xBC|\x89J-\xED?\x80zyC7\xBC\x8C\xBC\xF2\x89\r\x87/\xED?\x80\x85\x9Dq{H\x8D\xBC\x87\xA4\xFB\xDCX\xED?\07[\xD7\xEDr<\x98\x83\xC9\xE3\x80\xED?\0\xE0\xED\x8B\xC1\x81\xBC\x852\xDB\xE6\xA9\xED?\0\xB5mi\0#\x8C<`\xB4\xF3!\xD3\xED?\0\xF0xW\xDA\x82<_\x9B{3\x97\xFC\xED?\x80KO\xCD\xA5\x81\xBC)\xA1\xF5F&\xEE?\x80z\x81'\xB6\x87\xBC\xF6?\x8B\xE7.P\xEE?\0\xCD\xA9\x80\x89\x9Es<\x83L\xC7\xFBQz\xEE?\0\x8E \xCA\"\xD5\x82<\xDA\x90\xA4\xA2\xAF\xA4\xEE?\x80(\x9C#\x9C\x8E\xBC\xF1g\x8E-H\xCF\xEE?\x80\xAD\xB4\xF3\x93\x8C\xBC'Za\xEE\xFA\xEE?\x80\xB6\xA4\x86\xF4\xC7\x8D<\x97\xBAk7+%\xEF?\x80\x8E\r\xBF\xA5\xA1\x83<@En[vP\xEF?\x80\xA1\xD8-\xE1\xD3\x89<\xBE\x9C\xAD\xFD{\xEF?\05\xD0\xBB\x8D\xBC\xD8\x90\x9E\x81\xC1\xA7\xEF?\0\x93\xA5\xF3SHw<\xF1q\x8F+\xC2\xD3\xEF?\0xe\x96t\xEBR<\0\0\0\0\0\0\xF0?\0\0\0\0\0\0\0\053\xFB\xA9=\xF0?\x80\xCD\xB8\x9A)a\x9B<a\x80w>\x9A,\xF0?\0[S\x83\x90q\xBC\x85n\xE8C\xF0?\x80\xC9w\xA3\x90\xBCt\x85\xD3\xB0Y\xF0?\0\xB4u\xA4\xE2s\x8D<\xDE\xF6\xDD)kp\xF0?\0<\xB1\xE2\xDF\x91\x8C\xBC\xC8\x9BuE\x87\xF0?\0\x84\xB2K\xBE\x86a<\x83\xF3\xC6\xCA>\x9E\xF0?\0a1xH\x91<\x89\xF9lX\xB5\xF0?\0a\xDCJ.\xA6\x98<\xF7Gr+\x92\xCC\xF0?\x80O\xE2\xDC\x90<\xA2\xD1\xD32\xEC\xE3\xF0?\0\x80\xC5':@<\xD3\xFE\xAFf\xFB\xF0?\0\xBCN\xC4\xED\x9Bk\xBCQ[\xD0\xF1?\0\x9BD9\xC5\x96\xBC\xCC1l\xC0\xBD*\xF1?\0\xA8l\xB3\xB5Q\xBC\xE0-\xA9\xAE\x9AB\xF1?\x806\xF1\x9A\xBF/\x93\xBCQ\x8E\xA5\xC8\x98Z\xF1?\0\xAB\xEE\xB9j@\x82<{Q}<\xB8r\xF1?\0\x8A\xD7\xB9A\x90\x81\xBC\xEA\x8D\x8C8\xF9\x8A\xF1?\x80\x97\xD1#\x91\xBCu\xCBo\xEB[\xA3\xF1?\0iI{L[\x8E<\xD4\\\x84\xE0\xBB\xF1?\0\xF6.5\x86S\x99\xBC\xAA\xB9h1\x87\xD4\xF1?\0d\xA2\0n\x9E<\xD9\xFC\"P\xED\xF1?\x80\xB7{\x98\xDF\x91\xBC\xD6\x8Cb\x88;\xF2?\0\x85J\x81u\xC7\x8D<\x96\xDC}\x91I\xF2?\0\xA6\x94\x94~\xA9\x82<8bunz8\xF2?\x80\xC7\xB6~\xB0\x99<?\xA6\xB2O\xCEQ\xF2?\0\xF5\xF4\xBEU\xC1\x8A<\xDD|\xE2eEk\xF2?\0\xEA@\x993\xBD\x82<\x81c\xF5\xE1\xDF\x84\xF2?\x80\r?\x8C:L\x9A\xBC\xE1\xDE\xF5\x9D\x9E\xF2?\0\xAD\xAF\xE8\x86<\x90\xD9\xDA\xD0\xB8\xF2?\0 8\xD6\xDC\nA\xBC \xE4\xA6\x85\xD2\xF2?\0B\xDBTG\x90<V/>\xA9\xAF\xEC\xF2?\0$\xD5E\xCAq<\xB71\n\xFE\xF3?\0\x831\xD2j\xF4\x86<1\xD8L\xFCp!\xF3?\0\x8E\xE7\x9C\x8A<\xFFd\xB2<\xF3?\x80Y6\x84!'\x93<\xF1\x9F\x92_\xC5V\xF3?\0FN\\\xEE\\\x8B\xBC\xCB\xA9:7\xA7q\xF3?\0\xEBB\xBF\xEA:\x96\xBCf\xD8m\xAE\x8C\xF3?\x80\x99<\x8D\x95\x9E\xBC\xF7\x9F\xE54\xDB\xA7\xF3?\0\xF6a\xD66\xE4u\xBC\xE5\xA8\xC3-\xC3\xF3?\0*]7\xF8\xFF\x9E\xBC\"4L\xA6\xDE\xF3?\0\x9F\xF0\t\xDA\x8A<\x80\xACE\xFA\xF3?\0\xFAV\xF9#\xD0\x97\xBC*.\xF7!\n\xF4?\0\x900i\xF3^\xBC\x97\xA8P\xD9\xF51\xF4?\0z_\xE3\xDD\xC7\x81\xBC-\x89a`N\xF4?\0\x80\xEFz\x9BH<W\0\xEDAj\xF4?\x80\x8Ad\xD1K\x94\x9C<\xD0<\xC1\xB5\xA2\x86\xF4?\0b\x90\xB6\xA3\xC1s<\xDE\xD3\xD7\xF0*\xA3\xF4?\x80\xBE\xD1\xF3b\xCB\x99<'*6\xD5\xDA\xBF\xF4?\0B\xEC\xAF\x97C}<\r\xDD\xFD\x99\xB2\xDC\xF4?\0xj\xBC\xDB\xEC\x98<\xA7,\x9Dv\xB2\xF9\xF4?\0XY\xD2\t\xB3\x94\xBCBf\xCF\xA2\xDA\xF5?\0\x94\xBDi\x85v\x8F\xBC\x82O\x9DV+4\xF5?\0=\xB1\xBEz\x80\xBC\x92]\xCA\xA4Q\xF5?\0\xE6\xED\xEF\x9Ch\x8D\xBC\xDA'\xB56Go\xF5?\x80\x93,\xBB\x99<\xFD\xC7\x97\xD4\x8D\xF5?\0\x9A[\xE1\x95\x82<)TH\xDD\xAB\xF5?\x80GFL2\x96<\xB7FY\x8A&\xC9\xF5?\0\x80i\x81K<<H!\xADo\xE7\xF5?\x80\xE6\x800\xF9\xA6\x9B<\t\xDCv\xB9\xE1\xF6?\x80\xDEV\x9BB\xE2\x93\xBC\x85U:\xB0~$\xF6?\x80\xB4@~\xC1\x83\x93\xBC \xC3\xCC4FC\xF6?\0\x89\x9Du<H\x8C\xBC%\"U\x828b\xF6?\0Y\x87\t\xB6\x9B\xBCs\xA9L\xD4U\x81\xF6?\0@\xF7D\xAE8`<");
memory.store_slice(11216, b"\xCD;f\x9E\xA0\xE6?\x87\xEBs\xA1\xE7?\xDB\xA0*B\xE5\xAC\xE8?\x90\xF0\xA3\x82\x91\xC4\xE9?\xAD\xD3Z\x99\x9F\xE8\xEA?\x9CR\x85\xDD\x9B\xEC?\x87\xA4\xFB\xDCX\xED?\xDA\x90\xA4\xA2\xAF\xA4\xEE?\0\0\0\0\0\0\xF0?\x89\xF9lX\xB5\xF0?{Q}<\xB8r\xF1?8bunz8\xF2?\xB71\n\xFE\xF3?\"4L\xA6\xDE\xF3?'*6\xD5\xDA\xBF\xF4?)TH\xDD\xAB\xF5?");
memory.store_slice(11344, b"\xDE\x9B\xC1f'\xAB\x9C\x84\xBED^\xDD\x9C\xF2?*\xFB\xAC6;\xE7\xC7\xA2\xCCm\xF0\xF9?\x86\xB0\xBC\xD0U\xB0\xFC\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFE?\r\xE4\xE3\xFCE\x9Cs\xAF\x9D\xFF\xFD?\xAE9s\n\xF0ni\xE2X\x8EX@m\"\xA6>x \xD5\xA3\x8E\xF1-\xAF6@?\x81\xDA\xD3\xC0^\xFD\xD4\xF6\xCF4\0@\xC3WU\xB3\xD6\xA4\xE4\xFF\xA3\xA8@/\x84q\xFC\xB0;\x9Bs\xEC>\t\x95V@Q\x9C\x80dq6\xE8\\\xA6\xE6\xAD@\x90V\xC8m\xA1Sr\xA3\\9+\x96\xC0{\xF0?\x92\xD3\0\xE1\xDB\xD3\x9E3\xA8\xE1\x8A\x81\xFE\xFD?\x9Eb\xC3\xEE\xBC\x842\xA5Oo\xF4\t\xA5@ \xCD:j\xA9\xB9\x95\x9C\xCB\xB88\x97\xDE@\x93\x92\x80\xDBq?\x895\xC3\x86\xEB\x98\xE7@\xD6d\x8E@\xD3 V\xA1ytY\xE7\xC8@Oo\xFB}\x990\x98\xD9\xA2@@\r\xE4\xE3\xFCE\x9Cs\xAF\x9D\xFF\xFD?\xAE9s\n\xF0ni\xE2X\x8EX@m\"\xA6>x \xD5\xA3\x8E\xF1-\xAF6@?\x81\xDA\xD3\xC0^\xFD\xD4\xF6\xCF4\0@\xC3WU\xB3\xD6\xA4\xE4\xFF\xA3\xA8@/\x84q\xFC\xB0;\x9Bs\xEC>\t\x95V@Q\x9C\x80dq6\xE8\\\xA6\xE6\xAD@\x90V\xC8m\xA1Sr\xA3\\9+\x96\xC0{\xF0?\x92\xD3\0\xE1\xDB\xD3\x9E3\xA8\xE1\x8A\x81\xFE\xFD?\x9Eb\xC3\xEE\xBC\x842\xA5Oo\xF4\t\xA5@ \xCD:j\xA9\xB9\x95\x9C\xCB\xB88\x97\xDE@\x93\x92\x80\xDBq?\x895\xC3\x86\xEB\x98\xE7@\xD6d\x8E@\xD3 V\xA1ytY\xE7\xC8@Oo\xFB}\x990\x98\xD9\xA2@@\xDA\xDF\xC9\x8B\xB6\xFApoQ\xE9\x8D\xD5\xB4\xF4?^L\x8B?\x8B\xF3\xD2\xFB\x9E\x81\xB1\xC2\xF5\xFD?\xF0L\x8D \xE7\x82\xB4\x80Dn\x92\xCF\0\xC0\xFF?r[@\xBE\xA4$2\x9B\x87\xD6\x94gf\xFF?H2\xA3\x88n\x93\x86D~\xB4Wda\xF0?\xA7\xD13\xD7\xDC\x8CT\xEB_\xD0\xB7f\\\xDC\xF3?<B\x94\xF7\xD8|\xAFn.\x8E7 \xF7?Z\x97\x9B\xEA\xA0\x85\xFE,\xA3\xCCb\xD1\x86\xF9?\xFF\xC2Km`\xDA\x92*ku\xE9\xC7\xFB?7Awf\x84\xEA_G\xC8\x91\xA9s\xFD?yG\xDFB\xC1j\x9ESf3\x90-\xF4\xAC\xFE?\xDD\xA0U\x80*\0\0\0\0\0\0\0\0\xFF?");
memory.store_slice(12032, b"_<)\xCB\x8E;\xFE\xF9e\xC3k\xEB\x92\xEC?x\xDDS|\xFEk\x8BP\x9B\xE3J\xF6?\x89t\xC7\xB9\x8B)\xC1=~\x88\x99p\xD1\xFC?\xC7\xC3\xB0R\xCC\xD3\0\0\0\0\0\0\0\0\0@\xF9~Cns^L~\xAB'\xADw@f \xD6!\xC0?\x90'4\xF6Z\xE2\x84@\x8CuzNY39\x89&3f\xB2\xC3\x85@\xD4A\xA3P\xCA\xB6\x9C\xAE\xCB\xA6\t@\x825\xD1 L\x9C\xB9L\xA5w\x86\x80\xB1\xFB\t@@\xDD\x85\xFC\xF4\xE6Av\xD4\xFF\xEB9d=\t@\r\xF3\xBB\xA4\xA1L\xB8\xA8\xAE\xC5\xFClB@\xC5\xA8\xC1\x88=Gnq\xE3\xE9Y\xE2@\xA5]\x81F\0axI\"\xB50L@\x93&z\xFE\xF9\xD7]\xB5\xCFY\x86\xBB@\xDE\xF3q\\\xD4\xF5\xBCW\x8A\x90\xDCE5@\xA2\xC9\xBD\xE8.D?b\x8E\xE4\xDB\xB0@\xD0\xCBq\xE2\x8D\xE6HdF\xF3\xE0@\xF9~Cns^L~\xAB'\xADw@f \xD6!\xC0?\x90'4\xF6Z\xE2\x84@\x8CuzNY39\x89&3f\xB2\xC3\x85@\xD4A\xA3P\xCA\xB6\x9C\xAE\xCB\xA6\t@\x825\xD1 L\x9C\xB9L\xA5w\x86\x80\xB1\xFB\t@@\xDD\x85\xFC\xF4\xE6Av\xD4\xFF\xEB9d=\t@\r\xF3\xBB\xA4\xA1L\xB8\xA8\xAE\xC5\xFClB@\xC5\xA8\xC1\x88=Gnq\xE3\xE9Y\xE2@\xA5]\x81F\0axI\"\xB50L@\x93&z\xFE\xF9\xD7]\xB5\xCFY\x86\xBB@\xDE\xF3q\\\xD4\xF5\xBCW\x8A\x90\xDCE5@\xA2\xC9\xBD\xE8.D?b\x8E\xE4\xDB\xB0@\xD0\xCBq\xE2\x8D\xE6HdF\xF3\xE0@l\xF6\x93n\x8A\xAC\r\xC6\xD2Hgv\0P@H2q\n\xAA\x93\x84\xFD\xAF\xC58J\xCD @lIBO\x9Ad\xB4\xE5\xA0\xAFK\xCD @jo\xCA2u&\xE6\xA8\xD0[\xD0$\xCE\xD4\xEE\xBF\xE3\xBE\x87\xC7>n\x96f\xE0\x85\xBBE\xEC\xF2?Ux\xAD0\xEFK\xDA}\xA70\"M{D\xF5\xBF\xC1\xF7L~#+\xDBRb\xF9\xFA\xBB\xA1\xF4\xBF\xDE@\xE2\x82-\xF3x\xAFq\xC6\xF9?tx\xB2$\0)e0m\0\xAB\x9B{\xFA\xBF\xFF)\"6\x81\x94\xDD\xEBnu\xA6\x95x\xCB\xFC\xBFvW\x9B,\xB5\xAF\xC8\x8F]\xAE\xFA\xF9\xA8\xFD?\xCF\xBC\xD1\xC3\xA9\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFE?");
memory.store_slice(12704, b"\0\0\0\0\0\0\0\02\xFD\xFF\xFF\xFF\xFF\xB1\xBFy\xA7O\xB4\xD0) \xC0c\xE8{p\xC0\xFC\xCAM\xCDnj\xA3\xC0=d\xCC6 \x85\xB4\xC0\0\0\0\0\0\0\x90\xBD\x86N\xC1\x88\x80\xC3vS\xC5Z(\xA4\xC5");
memory.store_slice(12784, b"Qg\xA93\"]@8iYP}\xF3\xAD@_\xB0\xB6n\xBB\xD2\xE3@\xBD\xA9\x9F\x8F\x81\xFC@\xDCI,OwA\xE7@\0\0\0\0\0\0\0\0\x98\xE9B\xEB\x9BoE\xDB\x95G|\xE4G\xBA :G");
memory.store_slice(12864, b"\xCC\x95\xE4G\xB1\xA9\xBD\xC6\xFB\x9A\xE6\xFF\xFF\xB1\xBF\xBFk \xF9p\xA3\xC0\x83}Z/\xEBP\xC0c\xCCBg\xB3\xB3t\xC0\xD7\x8B\xA3(\xEF\xA6u\xC0\x8A\xC5H\xAD\xFF\xFF\x8F\xBD\x88\x85\xC0{Y\x87\xC2\x9B\x9D\xA5\xC3y7\xAD\xC3");
memory.store_slice(12944, b"\xDE\xC5\x98 \x81`N@d(~\\m\x90@`\xBE\x8F\xF8Z\xB7@8\xFAv\xFA\xB8\xCC\xC2@d\xE8 \xC7\xCC\xA2@\0\0\0\0\0\0\0\0sBh\x83D\xC4\xD7\xBAE\xC8eF\xEE`E");
memory.store_slice(13024, b"\x86\xAA\xE1o\xE1%\xBEK\xE2\xC0\xF7\xF6\xFF\xB1\xBFt\x80\xA4\xAE\xB2E\xC0N\xB9LJ\xF75\xC0E\nB\"\nM\xC0\xD8\x92\xA8\xACr?\xC0/\xB1\xB8\xFF\x8F\xBD\x95-\xC0R\xBA\xAF\xC1Qh\xC2e\x95\xFB\xC1");
memory.store_slice(13104, b"\xD3}\x84\x92\xEDA@|JF9\x98v@\xD6amn\xA6\x92@~\x9B\xC3\xB8\xFC\x9F\x91@\x81\x907\xFC\x96\xB2e@\0\0\0\0\0\0\0\0\x94lB\xCA\xC1\xB4Cs3\x95D\xE6\xFF\x8CD\xB8\x94-C");
memory.store_slice(13184, b"m'\xE9\xD3w\xBEB^Ib\xFF\xB1\xBFC\xA8$\x8A96\xF7\xBF\xF3\xA7\xAF\xED\xF3\x8A\xC0c$\xC5\xE6b&\xC0\xE7\x8F\xAF\x81\xDE\t\xC0\xB7\x98\xBE\xB3\xFB\x8F\xBD\xCC\xB1\xB9\xBF\x9FW\xF4\xC063\xC1\r\xF4N\xC0");
memory.store_slice(13264, b"YY\x8B\x90e86@\x8F\x87\xE8\x9Ea@\x9B\xEAB\x86\xE7p@\xFF\xFA\xB6:<c@\t9D\xB3P-@\0\0\0\0\0\0\0\0-\xC3\xB1A\xF04C2<\x87C\xE0C\x9A\x85jA");
memory.store_slice(13344, b"\0\0\0\0\0\0\0\0,\xFE\xFF\xFF\xFF\xBF\xB2?\xD64\xB3[R\x89'@%0cm\x81@m\xF4>\x99M\xC1@f\x90\xD4\xE2@\0\0\0\0\0\0\x96=\x93J<Ak D\xCAl\nF\xA0\x96G");
memory.store_slice(13424, b"\xBC9[6\xD5xd@ckNX\xA2\xBF@?\x8C\xD3TRfAC+\xA5\x83\xDA\x83(A= \xDE(k\xA6)A\xC50\x95,m\xFD\xC1\xAA\xC6#C\xC2\xFDE\x932 H\xD4DIY3MIi\xEB\xA7\xC8");
memory.store_slice(13504, b"\xD9\x8C\xCC)\x8F=\xB4=L\xB0r\xD1\xFF\xBF\xB2?\xD3=\x95\xB9\xB0W@\xE9\x88\x87\n\x92\xE3`@\x81\xC4\xC8\x9D\xF9 \x90@\xA6\xE3\xC6S\xE9\x9F@y\xEC\xA1-\xFF\xFF\x95=\x86\xBD\xBA@\x90C\xCDg\x80DK\xBF\xF8D");
memory.store_slice(13584, b"C^\xFB\xB3\xB1T@\xCE\xC0!\xDA\xA0;\xA0@mY{\xD2g\xD2@r#\xE0\x97\xE3\xB5\xEB@\xA0Tz\x91\xE1@\t\xC6\xDB\xBEW\xEA\xB4\xC0\xA0\x8D\xA5B\xDDE\x94>\x93F\xAF]G\xC1\x88 G\xBER\xA7\xC5");
memory.store_slice(13664, b"\x82\xCB\xDEj\xCD2>B\x8D\xEE\xBF\xB2?\xF5\x9Ca\xFC\xC0\n@\xDD\xAE-\x96\x98OE@\xFD^\xE2\xDBYe@\xE0!\xFA\x81|\xD7d@h\x961p\xFF\x95=\xE3V@\xC5|*B\xDF\xCE*C\xE4\xBB&C");
memory.store_slice(13744, b"\xA6C\xE3\xBF\"aH@\xB3NT\x86\x83-\x86@c\xFCM\xE4K\xF0\xAC@(j\xC7\xD7l<\xB9@\xC0\xB1O\xD9\xAA\xA8\xA3@\xF4 \xEB\xA7b\xC0\tCBl1D_\x82gEg\xE3\xC9EWEEY?\xC3");
memory.store_slice(13824, b"\xDBk\xF7T;1\x84>4>\x88>\xC5\xBE\xB2?\x9Cw'\xE7\x97\xF8\xFF?\xE5o\xF9\xAA\xBF\xFD,@J\xDC\xFB)\x8E\xAA?@\xB4K\x81q\xB1@0@\xDB\x89!4*\xF6\x95=\xBF\xC4\xFF?\xFD\xEDgAqT\xFDA\x8C\x82A");
memory.store_slice(13904, b"\xEDz\xC0\xF7\x96]>@@K\xD1\xE4\x91\xD5p@\"\xBF\xB3\"Ef\x8A@\xC2\\\x9C|\x97\x8B@e\0S\x95j@1)\xB3\xF8j>\xC0\xB8\xEC\xF2A\x8F\xAC\x86C)2SD\xE5\xBB\\D\x98\xAATCX\xF3\xA9\xC0");
memory.store_slice(13984, b"\0\0\0\0\0\0\0\0\xCE\xFC\xFF\xFF\xFF\xFF\xBD?\xCE5\x9Dz*@\x90\xA5.e\xD4\xC0y@\xCC2\xA5\xA3}E\xAE@\xDD\x82'\xC3z\xEA\xBE@\0\0\0\0\0\0\xF0=\xEA\xD4SA\xA3\xCEC\xED+rE\xD6S\xF7E");
memory.store_slice(14064, b"\xACle\x8EE\x8D\\@O'M\x96\xDC\x85\xAC@\xBB\xC5\x97\x86 \xE2@\xBB\x8F\xB2,\xD4\xF7@- zi\xDE@\0\0\0\0\0\0\0\0,j\xE4B\xE5.dE5\\Gf\xA1\xBEG\x8B\xA8\xF0F");
memory.store_slice(14144, b"}\xCA\xE1\xDAg\xAD=C\0\xC1\xE2\xFF\xFF\xBD?\xE3cn6@\xED&E\xB9[@I\xD6R\xD0-\x80@\xB7 ~\xBB\xB8\x85\x80@?3h-\xFF\xFF\xEF=#\xB0\xD9@\xCA\x9D\xD8B\xB7hD\xC6-D");
memory.store_slice(14224, b"=c\xAF\xA8\xEA\xA3M@g6\xFB\x8E@\xFB\xB6WD\xE9\xB4@\xBB\xA5\xB8\xB0\xA4\xBE@Q^o0\x80\x97@\0\0\0\0\0\0\0\0UmB\xB1\xD9wD#J\xA7E\x86%\xF5E\x80\xBCD");
memory.store_slice(14304, b"\xDD\x9E\xAD\xA7!\xFC)>{\xD1![\xF5\xFF\xBD?\x8A\xAD^\xE8\xBCv@)\xD1\xA6\x9DH\x8FA@7,M\x85\xC3V@\xE5>\xA8\x8E\x8FGH@\r\xE1O1\xAB\xFF\xEF=\xE7\xB5{@Ez B*\xB6B|<BB");
memory.store_slice(14384, b"\x9C4\xA1IeA@_\xA7\xF13 u@#\xD57P|[\x90@\xE91.\xA3}\xD6\x8B@S\xED.|m\xF2Y@\0\0\0\0\0\0\0\0M* B\x98a\xA8C\xE3\xDB\x82D\xED\xB3^Dl\x93\xCFB");
memory.store_slice(14464, b"\xF4DU\xF6\xD4\xE9|>\x83\rv\xBEB\xFF\xBD?\xC0\xAE\x8F\xF9\xB7\xF2@d\xA9q7|(@\xE2\x8E\xA8\xB11@\xFE\xC1t\xA5IK@\xA8N\xE73\xFA\xEF=\xC0\x95@\xBC\xE1CAA\x8D\x8DAMZ\xA2@");
memory.store_slice(14544, b"\xDC\xEC\xD5\x8A\xBDo5@\xD5,\xF9\x93R_@\xD9\xDB\xA2\xD5\xD8m@\xA9\x84\xDAzk]@\x92QN\xF4\xB1\xBA @\0\0\0\0\0\0\0\0\xEC}\xABA\x99\x94\xFAB\xC7FhC\xD7[\xEBB\x90\xD5A");
memory.store_slice(14624, b"\0\0\0\0\0\0\0\0\xF3\xFD\xFF\xFF\xFF?\xBA\xBF\xF7yg\xA2\x91E0\xC0v\xB5\xE4S\xD0\xBC\x87\xC0t\xF8@\xE7$\xC7\xC0j\x9C\xD0e\xD0\xA6\xE7\xC0\0\0\0\0\0\0\xD2\xBD\x8D,\x82\xC1\x83\xE6=\xC4:'9\xC6\x836=\xC7");
memory.store_slice(14704, b"\xE5\xCD[\xDE\xA6,d@\x84\xD8\xD0b\x91\xBE@\x98^\xB7\xB0\x9AW\0A\x9C\x86rS\xF6%A\\\xADw\xD2W$A\xAA\xA5i\xF9\xC17e!C\x8B\xF4E\xD6\xBCH\x9C\xB2/I\x94\xBE\"IH\xCB\x8F\xC8");
memory.store_slice(14784, b"\x98\xA0\xA1C\xFA\xB6\xBD\xEFY\xCB\xFF?\xBA\xBFK\xAD\xCA\xE6 \xC0\xB0\xB9\xA7lm\xF5f\xC0Os1i\xC6t\x95\xC0\x9D\xA7\xFD\x88\xE3h\xA4\xC0\xD2\xB7\xAD\xFE\xFF\xD1\xBD6\xE7\0\xC1k\xAB7\xC33\xA6\xAB\xC4G#\xC5");
memory.store_slice(14864, b"\xB2Z\xFF\xB2QT@9\xF8{\xE71\x9F@)\xCEd\r\xD1@\x97\xD1\xBA\xAAmW\xE8@K6|\xCFK\xDB@\xA0\xFF\xFC.o\xB2\xC0\x98\x8D\xA2B\x8F\xF9\xF8D\xF8x\x88Fm\xBBBG&X\xDAFxy\x93\xC5");
memory.store_slice(14944, b"O\xC8\x8F\xD3\xA9\xCF5\xBET\xED\xAEQ\xEB?\xBA\xBF\xFF\xD93\xC2p\xC0\xDA]\xC2q\xECL\xC0_\xD5G\xD3\x87l\xC0\xF6\\_\xB9fk\xC0O}\xAE\xB1[\xFF\xD1\xBD\x86\x93\xC0\x8Ecg\xC2\x9A>d\xC3\xCB5[\xC3");
memory.store_slice(15024, b"\xE4g\xD3\xCC#\xD5G@>\xEE1\xC0\xEB\x85@\x9A|\x8EDNh\xAA@\xA6T\xA6\xBA\xAB\xB5@K\xDF\xD4\rz\xBC\x9D@1\n)p\xE6`\xC0\xA9>B^w(DrBSE\xD5]\xADE\xD0\xE3\xEDD\x813\xC3");
memory.store_slice(15104, b"\xD2&\xC6D&\xF1\x87\xBE\xB0H\x91\x8E>\xBA\xBF\xDAN\xBBi\x84\xC0\x90h\xC1\xE2\xA93\xC0\xAAJ\xDE\xA3)E\xC0Rn\xCF96_5\xC02\x89?\xB4u\xF4\xD1\xBD#$0\xC0O\x9D\xC1M)\xC2\xB2\xF9\xAA\xC1");
memory.store_slice(15184, b"\xFFd\xAEx\x8A\x88=@\xBA\x82\xDBh\x9Fo@\xF7\xA0I\xCE\xAC\x87@)\xC0\xD4H%\x87@\xD4\xD8><^~c@k\xE8\xE7\x86\xD6\xC0TD\xECAG\xFB|C.`=D*\xD98D\xF2\xF2C7\xB4\x9E\xC0");
memory.store_slice(15264, b"i\xFD\xCC\xFB\xA1\xE7\xDDD\xF2\xC7\xEE\xF6\xF6?\xBDn^\x82\xD8\xFA+\xF25\xBD\x97p\xFE\xBF\xD7X\xEEX]+\x9FxJ\xDFX@\xC6\xA0\xB6\xD8Tc\xC7i]\xD1\xBD\xC0i\xFD\xCC\xFB\xA1\xE7\xDDD\xF2\xC7\xEE\xF6\xF6?\xBDn^\x82\xD8\xFA+\xF25\xBD\x97p\xFE\xBF\xD7X\xEEX]+\x9FxJ\xDFX@\xC6\xA0\xB6\xD8Tc\xC7i]\xD1\xBD\xC0i\xFD\xCC\xFB\xA1\xE7\xDDD\xF2\xC7\xEE\xF6\xF6?\xBDn^\x82\xD8\xFA+\xF25\xBD\x97p\xFE\xBF\xD7X\xEEX]+\x9FxJ\xDFX@\xC6\xA0\xB6\xD8Tc\xC7i]\xD1\xBD\xC0i\xFD\xCC\xFB\xA1\xE7\xDDD\xF2\xC7\xEE\xF6\xF6?\xBDn^\x82\xD8\xFA+\xF25\xBD\x97p\xFE\xBF\xD7X\xEEX]+\x9FxJ\xDFX@\xC6\xA0\xB6\xD8Tc\xC7i]\xD1\xBD\xC0\xAE2~-\xE65M\xA6:\xDCU\xFA\xEE?\xFA^Y \xD3i\x8C\x8E\xFD\xC1\xB2C\xF2?\x9D\"\xDA\xB5qk\xC7\xB4[\xD5\xFA\x87]\xF5?\n\xDBA3\x823\xFB\xF9\xB6*;\xF8?\xE42\xE5\xDFA\x9F\xBC\xC0;Ip\x8D\xB0\xC6\xFA?\xC5\t\xA3C\x89\xB79\xBAX,\xF8\xDF\xFB\xEB\xFC?\xA2\xD9\xD67\xC9S\xF3\x9E\xA3\xEF/\xE4b\xFE?");
memory.store_slice(15632, b"d\xFCv&{-\xC8\xF9\x92?\x8A{7\xA3\xC0\xBD[4*\xBB\xB3\xE5 \xDE\xE2<\x83@II\xAA\xBD=\xB6\xF9\x9A\xAA \xBA\x9C\xAC\xC0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0d\xFCv&{-\xC8\xF9\x92?\x8A{7\xA3\xC0\xBD[4*\xBB\xB3\xE5 \xDE\xE2<\x83@II\xAA\xBD=\xB6\xF9\x9A\xAA \xBA\x9C\xAC\xC0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0d\xFCv&{-\xC8\xF9\x92?\x8A{7\xA3\xC0\xBD[4*\xBB\xB3\xE5 \xDE\xE2<\x83@II\xAA\xBD=\xB6\xF9\x9A\xAA \xBA\x9C\xAC\xC0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0d\xFCv&{-\xC8\xF9\x92?\x8A{7\xA3\xC0\xBD[4*\xBB\xB3\xE5 \xDE\xE2<\x83@II\xAA\xBD=\xB6\xF9\x9A\xAA \xBA\x9C\xAC\xC0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xB7\xEE\x83<A\xB0\xD5u\xA7\xAD\xCBK\xFC8\xF5\xBF+\xC0\xC7ar\x913\xFDi\x9D\x9D\x8E5\xD9\xF7?;\x8BPL\xCC\xF2I$\xDF\xBF\xD3aK;\xF8\xBF\xCD[\x92R\xDF]`!.\xD8\xB9\xAFY\xFA\xBF?~\x83>\xD7*\xEA\n2U\xFC?dEN\xB5F\xF1\xE3\xD7$\xFA\xE8X\xFA\xBF\xC5=t\x99\0\xFB\xEC\xF7\xA2\xAF&@\xCFO\xFE\xBF\xC39\xE83\xE1\xB5Q\x8Fa\xFB\xC6\xCF\x88'\xFE?\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xFF?");
memory.store_slice(16032, b"\0\0\0\0\0\0\xF0?\0\0\0\0\0\0\xF8?\0\0\x80?\0\0\xC0?");
memory.store_slice(16064, b"\0\0\0\0\0\0\0\0\xD0\xCFC\xEB\xFDL>\0\0\0\0\xDC\xCF\xD15");
memory.store_slice(16096, b"\0\0\0\0\0\0\0\0\0\0\0@\xB8\xE2?\0\0\0\0\0\xC0?");
memory.store_slice(16128, b"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xFF?> k\xFB\xFFsT\xE4\xB6e\xF5\xFE?\xAA\x8FK\0X\x98\rI*\xFAJ\xEA\xFE?a\xAAN\xAF \0\x96\xEB\xB5\xB97s\xC9\xDF\xFE?\xB42\x92\xE6\0^rH\xBA\xCF\x8D\x81\xD5\xFE?\xDB\xF6i\xFE\xFFO\x91\xF9\xCE\rr\xCB\xFE?\x9A\x85~\0\"\xC2)U\xD8\xBD\x99\xC1\xFE?\xB1\xC5\x9Ab\n\0\xAAn\xE4\xB5/o\xF7\xB7\xFE?\xF4\xFC\x95\0\xE8\xD5:\xAD\x95\xF9\x89\xAE\xFE? `u\x85\0\xB4\xC8U\xE2#;P\xA5\xFE?\xD5\x99h\xDD\0\xC8\t?*I\x9C\xFE?\xB2C\xD5:\xF8\xFFEO^\xDC {s\x93\xFE?\x94\xC2\xF9\\\xFC\xFF\xB9\xB5\r\xAA\"T\xCE\x8A\xFE?sZ\xBB\xAA\xF5\xFF\xAB(\xE1\xCC\x94\x99X\x82\xFE?\xFCV\xD3\xFE\xFB\xFF}m\xB0>Gz\xFE?Mm\x90\xF7\xFF\xD1=\xF7\xC5\x8E^\xF7q\xFE?\x9F\x85\x84=\xF6\xFF\xC9\xBC\xF3g\xE6\tj\xFE? \xBD U\xFF\xFFKX\xA5\xEBGb\xFE?766\xBA\xF9\xFF\x8B\x95B\x85\xD4}\xB0Z\xFE?\xF0\xF4\xB1\xDC\t\0\xF0\xF8\xD4i\xB5BS\xFE?\x88@\xCDc\xFD\xFF\xD3q\xA2bS\xAD\xFDK\xFE?\xA5\xFB\xFE5\t\02\xD0\x92\x86\xE0D\xFE?\xCF\x90\0\\#B#\xC1d\xEA=\xFE?\x86\xFB\xC5\xCE\0r\xAA\x9C\xAAss7\xFE?\xAE\xF7\xFF\xDDRq\xA3\xE0o0\xFE?\xC3\xAC9\xAE\xFD\xFF\xC1\xEE\xFDQ\xDF\xE9)\xFE?j\xA6~u\xFD\xFFk\x86#V\xE7\xA6\x87#\xFE?\xBE\xD9\xD5\xB0\0\x80\xA7\x9A\x8BsH\xFE?f`\xE0\x98 \0\xCE\xAD\xD5\xC7\x83+\xFE?\xE5\xEC\x86\xFD\xFFM\n\xB5%0\xFE?\xC23]\xFE\xFE\xFF)\xF6\x90\x98\xCF\x86U \xFE?q\x8A\x8Aw\t\0\xAECWX1\r\x9B\xFE?\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xFE?");
memory.store_slice(16656, b"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0U,\x99\xDD=\xBD\r?`\xB6\xEB1t\xEE\xBD?\xB7\xAD\xD2\xD7)X\x8D|dR\x94~\xBC\xBF\xC6\xED\xE6P\xE7\x92\x88\xF2\xCCt#A%\x96\xB9?\x9A>\xE8\x92\xEB\xF0\xFEi\x81\xCC]4\xCD\xBC?\xFB\x80x\xADu\r)\x91\xD3\xA0\xC7\xA7\xDC\xBB\xBF\xA9W\n\xE0HX\xBB\xF9\xEC&K\x86V\xF1\xBC?\n\xB2g \xA9B\xC1K&\x81\xFB]\xBD\xBF\x89;p\xDFu|\xFA*\xD5\xCD&\xF6e\xBD?\xB0(\xA4\xBE\xB4\xAF\xBBh\xD6#\xA3&\xBD?\xC95\xEC\xDD\xB1q!\xF6\xD7\xCB\xBB?S\xEA\xA7i\xBAQ\xD8\x83\xBB}\xBD\xBF\xA7\x96\x8B5x\xD9\xDB \xB9`\x8C\xB4\xBD?\rT\xB0\x8Ce(;Y\xCB\xDB\xFA\xBA?\x9B\xF2\xD7&\xEBU\xF9\xDB\xB0\xD6)^\xE7\xB9\xBF\x88O\xAE\n\xE7[o\xF2Y\xF5\x9E#\xB5\xD1\xBC\xBF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0");
memory.store_slice(16928, b"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xEF");
memory.store_slice(16944, &[0; 4]);
memory.store_slice(16960, b"\0\0\0\0\0\0\xF0?\0\0\0\0\0\0\xF0?\0\0\0\0\0\0\0@\0\0\0\0\0\0@\0\0\0\0\0\08@\0\0\0\0\0\0^@\0\0\0\0\0\x80\x86@\0\0\0\0\0\xB0\xB3@\0\0\0\0\0\xB0\xE3@\0\0\0\0\0&A\0\0\0\0\x80\xAFKA\0\0\0\0\xA8\x83A\0\0\0\0\xFC\x8C\xBCA\0\0\0\xC0\x8C2\xF7A\0\0\0(;L4B\0\0\x80uwsB\0\0\x80uw\xB3B\0\0\xD8\xEC\xEE7\xF4B\0\0s\xCA\xEC\xBE6C\0\x90h0\xB9{C\0ZA\xBE\xB3\xE1\xC0C \xC6\xB5\xE9;(Dl\xF0YaRwND");
memory.store_slice(17152, b"\xD0R\xDE\xDEh}\xA2\xBB\xBC\xEEs)\xF5?F\xEA\x9475\x8161\xD1\xBA\xE3\x8B9\xD9\xF7?\xD3C\x9C\xE50\xFCBY\xE01\xDEpJ;\xF8?@\xDC1s}\xF0\xBA\x83\xA2\xAFY\xFA\xBF2\xF3w$>\"\xB6\xF4\xDA\xAE 2U\xFC\xBF=?\xC9\xE3\x8A\xAC\xC7\xFEh$\xFA\xE8X\xFA\xBF\x84Z0\n\xA0L\xBC\xA2\xAF&@\xCFO\xFE?\xF1\x93\xD6^\x8FuS\x8Fa\xFB\xC6\xCF\x88'\xFE?\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xFF\xBF");
memory.store_slice(17296, b"\x82\xD00z\xA2\xE7\xBC\xDD\xEE\xD3\xC6\xA9\xBAv\xF4?E}\\gC\x88)\x87+\x86\x88\x96\x8C\xEF\xBF#\xB5kh\t[\xDEt\xB3\xF8\x8E\xBC\xF67\xF4\xBF\xCB\xF1P\xFB\xAEr4:b'%\xF1?\xEBW\xF0/JBmaB4d1\x9B\xF4?\xC5\xE5\x8A\xA6wB\xE6}G\xE0\xD4<\xE1\xF2\xBF\xD1\xD8G\xAC\xD9B7t\x90\xB5\xF0hr_\xF6\xBF\xF4\r\xB9\x9C\x92\x87\xDD \xC7q\xC7\xF6?T\xF7Z<8\xA9CUUUUUU\xFB?");
let mut instance = Self {
imports,
context: Context {
memory,
global0: 82976,
},
};
instance
}
pub fn rust_acos(&mut self, var0: f64) -> f64 {
self.context.rust_acos(&mut self.imports, var0)
}
pub fn rust_acosf(&mut self, var0: f32) -> f32 {
self.context.rust_acosf(&mut self.imports, var0)
}
pub fn rust_acosl(&mut self, var0: i32, var1: i64, var2: i64) {
self.context.rust_acosl(&mut self.imports, var0, var1, var2)
}
pub fn rust_acosh(&mut self, var0: f64) -> f64 {
self.context.rust_acosh(&mut self.imports, var0)
}
pub fn rust_acoshf(&mut self, var0: f32) -> f32 {
self.context.rust_acoshf(&mut self.imports, var0)
}
pub fn rust_acoshl(&mut self, var0: i32, var1: i64, var2: i64) {
self.context.rust_acoshl(&mut self.imports, var0, var1, var2)
}
pub fn rust_asin(&mut self, var0: f64) -> f64 {
self.context.rust_asin(&mut self.imports, var0)
}
pub fn rust_asinf(&mut self, var0: f32) -> f32 {
self.context.rust_asinf(&mut self.imports, var0)
}
pub fn rust_asinl(&mut self, var0: i32, var1: i64, var2: i64) {
self.context.rust_asinl(&mut self.imports, var0, var1, var2)
}
pub fn rust_asinh(&mut self, var0: f64) -> f64 {
self.context.rust_asinh(&mut self.imports, var0)
}
pub fn rust_asinhf(&mut self, var0: f32) -> f32 {
self.context.rust_asinhf(&mut self.imports, var0)
}
pub fn rust_asinhl(&mut self, var0: i32, var1: i64, var2: i64) {
self.context.rust_asinhl(&mut self.imports, var0, var1, var2)
}
pub fn rust_atan(&mut self, var0: f64) -> f64 {
self.context.rust_atan(&mut self.imports, var0)
}
pub fn rust_atanf(&mut self, var0: f32) -> f32 {
self.context.rust_atanf(&mut self.imports, var0)
}
pub fn rust_atanl(&mut self, var0: i32, var1: i64, var2: i64) {
self.context.rust_atanl(&mut self.imports, var0, var1, var2)
}
pub fn rust_atan2(&mut self, var0: f64, var1: f64) -> f64 {
self.context.rust_atan2(&mut self.imports, var0, var1)
}
pub fn rust_atan2f(&mut self, var0: f32, var1: f32) -> f32 {
self.context.rust_atan2f(&mut self.imports, var0, var1)
}
pub fn rust_atan2l(&mut self, var0: i32, var1: i64, var2: i64, var3: i64, var4: i64) {
self.context.rust_atan2l(&mut self.imports, var0, var1, var2, var3, var4)
}
pub fn rust_atanh(&mut self, var0: f64) -> f64 {
self.context.rust_atanh(&mut self.imports, var0)
}
pub fn rust_atanhf(&mut self, var0: f32) -> f32 {
self.context.rust_atanhf(&mut self.imports, var0)
}
pub fn rust_atanhl(&mut self, var0: i32, var1: i64, var2: i64) {
self.context.rust_atanhl(&mut self.imports, var0, var1, var2)
}
pub fn rust_cbrt(&mut self, var0: f64) -> f64 {
self.context.rust_cbrt(&mut self.imports, var0)
}
pub fn rust_cbrtf(&mut self, var0: f32) -> f32 {
self.context.rust_cbrtf(&mut self.imports, var0)
}
pub fn rust_cbrtl(&mut self, var0: i32, var1: i64, var2: i64) {
self.context.rust_cbrtl(&mut self.imports, var0, var1, var2)
}
pub fn rust_ceil(&mut self, var0: f64) -> f64 {
self.context.rust_ceil(&mut self.imports, var0)
}
pub fn rust_ceilf(&mut self, var0: f32) -> f32 {
self.context.rust_ceilf(&mut self.imports, var0)
}
pub fn rust_ceill(&mut self, var0: i32, var1: i64, var2: i64) {
self.context.rust_ceill(&mut self.imports, var0, var1, var2)
}
pub fn rust_copysign(&mut self, var0: f64, var1: f64) -> f64 {
self.context.rust_copysign(&mut self.imports, var0, var1)
}
pub fn rust_copysignf(&mut self, var0: f32, var1: f32) -> f32 {
self.context.rust_copysignf(&mut self.imports, var0, var1)
}
pub fn rust_copysignl(&mut self, var0: i32, var1: i64, var2: i64, var3: i64, var4: i64) {
self.context.rust_copysignl(&mut self.imports, var0, var1, var2, var3, var4)
}
pub fn rust_cos(&mut self, var0: f64) -> f64 {
self.context.rust_cos(&mut self.imports, var0)
}
pub fn rust_cosf(&mut self, var0: f32) -> f32 {
self.context.rust_cosf(&mut self.imports, var0)
}
pub fn rust_cosl(&mut self, var0: i32, var1: i64, var2: i64) {
self.context.rust_cosl(&mut self.imports, var0, var1, var2)
}
pub fn rust_cosh(&mut self, var0: f64) -> f64 {
self.context.rust_cosh(&mut self.imports, var0)
}
pub fn rust_coshf(&mut self, var0: f32) -> f32 {
self.context.rust_coshf(&mut self.imports, var0)
}
pub fn rust_coshl(&mut self, var0: i32, var1: i64, var2: i64) {
self.context.rust_coshl(&mut self.imports, var0, var1, var2)
}
pub fn rust_erf(&mut self, var0: f64) -> f64 {
self.context.rust_erf(&mut self.imports, var0)
}
pub fn rust_erff(&mut self, var0: f32) -> f32 {
self.context.rust_erff(&mut self.imports, var0)
}
pub fn rust_erfl(&mut self, var0: i32, var1: i64, var2: i64) {
self.context.rust_erfl(&mut self.imports, var0, var1, var2)
}
pub fn rust_erfc(&mut self, var0: f64) -> f64 {
self.context.rust_erfc(&mut self.imports, var0)
}
pub fn rust_erfcf(&mut self, var0: f32) -> f32 {
self.context.rust_erfcf(&mut self.imports, var0)
}
pub fn rust_erfcl(&mut self, var0: i32, var1: i64, var2: i64) {
self.context.rust_erfcl(&mut self.imports, var0, var1, var2)
}
pub fn rust_exp(&mut self, var0: f64) -> f64 {
self.context.rust_exp(&mut self.imports, var0)
}
pub fn rust_expf(&mut self, var0: f32) -> f32 {
self.context.rust_expf(&mut self.imports, var0)
}
pub fn rust_expl(&mut self, var0: i32, var1: i64, var2: i64) {
self.context.rust_expl(&mut self.imports, var0, var1, var2)
}
pub fn rust_exp2(&mut self, var0: f64) -> f64 {
self.context.rust_exp2(&mut self.imports, var0)
}
pub fn rust_exp2f(&mut self, var0: f32) -> f32 {
self.context.rust_exp2f(&mut self.imports, var0)
}
pub fn rust_exp2l(&mut self, var0: i32, var1: i64, var2: i64) {
self.context.rust_exp2l(&mut self.imports, var0, var1, var2)
}
pub fn rust_expm1(&mut self, var0: f64) -> f64 {
self.context.rust_expm1(&mut self.imports, var0)
}
pub fn rust_expm1f(&mut self, var0: f32) -> f32 {
self.context.rust_expm1f(&mut self.imports, var0)
}
pub fn rust_expm1l(&mut self, var0: i32, var1: i64, var2: i64) {
self.context.rust_expm1l(&mut self.imports, var0, var1, var2)
}
pub fn rust_fabs(&mut self, var0: f64) -> f64 {
self.context.rust_fabs(&mut self.imports, var0)
}
pub fn rust_fabsf(&mut self, var0: f32) -> f32 {
self.context.rust_fabsf(&mut self.imports, var0)
}
pub fn rust_fabsl(&mut self, var0: i32, var1: i64, var2: i64) {
self.context.rust_fabsl(&mut self.imports, var0, var1, var2)
}
pub fn rust_fdim(&mut self, var0: f64, var1: f64) -> f64 {
self.context.rust_fdim(&mut self.imports, var0, var1)
}
pub fn rust_fdimf(&mut self, var0: f32, var1: f32) -> f32 {
self.context.rust_fdimf(&mut self.imports, var0, var1)
}
pub fn rust_fdiml(&mut self, var0: i32, var1: i64, var2: i64, var3: i64, var4: i64) {
self.context.rust_fdiml(&mut self.imports, var0, var1, var2, var3, var4)
}
pub fn rust_floor(&mut self, var0: f64) -> f64 {
self.context.rust_floor(&mut self.imports, var0)
}
pub fn rust_floorf(&mut self, var0: f32) -> f32 {
self.context.rust_floorf(&mut self.imports, var0)
}
pub fn rust_floorl(&mut self, var0: i32, var1: i64, var2: i64) {
self.context.rust_floorl(&mut self.imports, var0, var1, var2)
}
pub fn rust_fma(&mut self, var0: f64, var1: f64, var2: f64) -> f64 {
self.context.rust_fma(&mut self.imports, var0, var1, var2)
}
pub fn rust_fmaf(&mut self, var0: f32, var1: f32, var2: f32) -> f32 {
self.context.rust_fmaf(&mut self.imports, var0, var1, var2)
}
pub fn rust_fmal(&mut self, var0: i32, var1: i64, var2: i64, var3: i64, var4: i64, var5: i64, var6: i64) {
self.context.rust_fmal(&mut self.imports, var0, var1, var2, var3, var4, var5, var6)
}
pub fn rust_fmax(&mut self, var0: f64, var1: f64) -> f64 {
self.context.rust_fmax(&mut self.imports, var0, var1)
}
pub fn rust_fmaxf(&mut self, var0: f32, var1: f32) -> f32 {
self.context.rust_fmaxf(&mut self.imports, var0, var1)
}
pub fn rust_fmaxl(&mut self, var0: i32, var1: i64, var2: i64, var3: i64, var4: i64) {
self.context.rust_fmaxl(&mut self.imports, var0, var1, var2, var3, var4)
}
pub fn rust_fmin(&mut self, var0: f64, var1: f64) -> f64 {
self.context.rust_fmin(&mut self.imports, var0, var1)
}
pub fn rust_fminf(&mut self, var0: f32, var1: f32) -> f32 {
self.context.rust_fminf(&mut self.imports, var0, var1)
}
pub fn rust_fminl(&mut self, var0: i32, var1: i64, var2: i64, var3: i64, var4: i64) {
self.context.rust_fminl(&mut self.imports, var0, var1, var2, var3, var4)
}
pub fn rust_fmod(&mut self, var0: f64, var1: f64) -> f64 {
self.context.rust_fmod(&mut self.imports, var0, var1)
}
pub fn rust_fmodf(&mut self, var0: f32, var1: f32) -> f32 {
self.context.rust_fmodf(&mut self.imports, var0, var1)
}
pub fn rust_fmodl(&mut self, var0: i32, var1: i64, var2: i64, var3: i64, var4: i64) {
self.context.rust_fmodl(&mut self.imports, var0, var1, var2, var3, var4)
}
pub fn rust_frexp(&mut self, var0: f64, var1: i32) -> f64 {
self.context.rust_frexp(&mut self.imports, var0, var1)
}
pub fn rust_frexpf(&mut self, var0: f32, var1: i32) -> f32 {
self.context.rust_frexpf(&mut self.imports, var0, var1)
}
pub fn rust_frexpl(&mut self, var0: i32, var1: i64, var2: i64, var3: i32) {
self.context.rust_frexpl(&mut self.imports, var0, var1, var2, var3)
}
pub fn rust_hypot(&mut self, var0: f64, var1: f64) -> f64 {
self.context.rust_hypot(&mut self.imports, var0, var1)
}
pub fn rust_hypotf(&mut self, var0: f32, var1: f32) -> f32 {
self.context.rust_hypotf(&mut self.imports, var0, var1)
}
pub fn rust_hypotl(&mut self, var0: i32, var1: i64, var2: i64, var3: i64, var4: i64) {
self.context.rust_hypotl(&mut self.imports, var0, var1, var2, var3, var4)
}
pub fn rust_ilogb(&mut self, var0: f64) -> i32 {
self.context.rust_ilogb(&mut self.imports, var0)
}
pub fn rust_ilogbf(&mut self, var0: f32) -> i32 {
self.context.rust_ilogbf(&mut self.imports, var0)
}
pub fn rust_ilogbl(&mut self, var0: i64, var1: i64) -> i32 {
self.context.rust_ilogbl(&mut self.imports, var0, var1)
}
pub fn rust_ldexp(&mut self, var0: f64, var1: i32) -> f64 {
self.context.rust_ldexp(&mut self.imports, var0, var1)
}
pub fn rust_ldexpf(&mut self, var0: f32, var1: i32) -> f32 {
self.context.rust_ldexpf(&mut self.imports, var0, var1)
}
pub fn rust_ldexpl(&mut self, var0: i32, var1: i64, var2: i64, var3: i32) {
self.context.rust_ldexpl(&mut self.imports, var0, var1, var2, var3)
}
pub fn rust_lgamma(&mut self, var0: f64) -> f64 {
self.context.rust_lgamma(&mut self.imports, var0)
}
pub fn rust_lgammaf(&mut self, var0: f32) -> f32 {
self.context.rust_lgammaf(&mut self.imports, var0)
}
pub fn rust_lgammal(&mut self, var0: i32, var1: i64, var2: i64) {
self.context.rust_lgammal(&mut self.imports, var0, var1, var2)
}
pub fn rust_llrint(&mut self, var0: f64) -> i64 {
self.context.rust_llrint(&mut self.imports, var0)
}
pub fn rust_llrintf(&mut self, var0: f32) -> i64 {
self.context.rust_llrintf(&mut self.imports, var0)
}
pub fn rust_llrintl(&mut self, var0: i64, var1: i64) -> i64 {
self.context.rust_llrintl(&mut self.imports, var0, var1)
}
pub fn rust_llround(&mut self, var0: f64) -> i64 {
self.context.rust_llround(&mut self.imports, var0)
}
pub fn rust_llroundf(&mut self, var0: f32) -> i64 {
self.context.rust_llroundf(&mut self.imports, var0)
}
pub fn rust_llroundl(&mut self, var0: i64, var1: i64) -> i64 {
self.context.rust_llroundl(&mut self.imports, var0, var1)
}
pub fn rust_log(&mut self, var0: f64) -> f64 {
self.context.rust_log(&mut self.imports, var0)
}
pub fn rust_logf(&mut self, var0: f32) -> f32 {
self.context.rust_logf(&mut self.imports, var0)
}
pub fn rust_logl(&mut self, var0: i32, var1: i64, var2: i64) {
self.context.rust_logl(&mut self.imports, var0, var1, var2)
}
pub fn rust_log10(&mut self, var0: f64) -> f64 {
self.context.rust_log10(&mut self.imports, var0)
}
pub fn rust_log10f(&mut self, var0: f32) -> f32 {
self.context.rust_log10f(&mut self.imports, var0)
}
pub fn rust_log10l(&mut self, var0: i32, var1: i64, var2: i64) {
self.context.rust_log10l(&mut self.imports, var0, var1, var2)
}
pub fn rust_log1p(&mut self, var0: f64) -> f64 {
self.context.rust_log1p(&mut self.imports, var0)
}
pub fn rust_log1pf(&mut self, var0: f32) -> f32 {
self.context.rust_log1pf(&mut self.imports, var0)
}
pub fn rust_log1pl(&mut self, var0: i32, var1: i64, var2: i64) {
self.context.rust_log1pl(&mut self.imports, var0, var1, var2)
}
pub fn rust_log2(&mut self, var0: f64) -> f64 {
self.context.rust_log2(&mut self.imports, var0)
}
pub fn rust_log2f(&mut self, var0: f32) -> f32 {
self.context.rust_log2f(&mut self.imports, var0)
}
pub fn rust_log2l(&mut self, var0: i32, var1: i64, var2: i64) {
self.context.rust_log2l(&mut self.imports, var0, var1, var2)
}
pub fn rust_logb(&mut self, var0: f64) -> f64 {
self.context.rust_logb(&mut self.imports, var0)
}
pub fn rust_logbf(&mut self, var0: f32) -> f32 {
self.context.rust_logbf(&mut self.imports, var0)
}
pub fn rust_logbl(&mut self, var0: i32, var1: i64, var2: i64) {
self.context.rust_logbl(&mut self.imports, var0, var1, var2)
}
pub fn rust_lrint(&mut self, var0: f64) -> i32 {
self.context.rust_lrint(&mut self.imports, var0)
}
pub fn rust_lrintf(&mut self, var0: f32) -> i32 {
self.context.rust_lrintf(&mut self.imports, var0)
}
pub fn rust_lrintl(&mut self, var0: i64, var1: i64) -> i32 {
self.context.rust_lrintl(&mut self.imports, var0, var1)
}
pub fn rust_lround(&mut self, var0: f64) -> i32 {
self.context.rust_lround(&mut self.imports, var0)
}
pub fn rust_lroundf(&mut self, var0: f32) -> i32 {
self.context.rust_lroundf(&mut self.imports, var0)
}
pub fn rust_lroundl(&mut self, var0: i64, var1: i64) -> i32 {
self.context.rust_lroundl(&mut self.imports, var0, var1)
}
pub fn rust_modf(&mut self, var0: f64, var1: i32) -> f64 {
self.context.rust_modf(&mut self.imports, var0, var1)
}
pub fn rust_modff(&mut self, var0: f32, var1: i32) -> f32 {
self.context.rust_modff(&mut self.imports, var0, var1)
}
pub fn rust_modfl(&mut self, var0: i32, var1: i64, var2: i64, var3: i32) {
self.context.rust_modfl(&mut self.imports, var0, var1, var2, var3)
}
pub fn rust_nan(&mut self, var0: i32) -> f64 {
self.context.rust_nan(&mut self.imports, var0)
}
pub fn rust_nanf(&mut self, var0: i32) -> f32 {
self.context.rust_nanf(&mut self.imports, var0)
}
pub fn rust_nanl(&mut self, var0: i32, var1: i32) {
self.context.rust_nanl(&mut self.imports, var0, var1)
}
pub fn rust_nearbyint(&mut self, var0: f64) -> f64 {
self.context.rust_nearbyint(&mut self.imports, var0)
}
pub fn rust_nearbyintf(&mut self, var0: f32) -> f32 {
self.context.rust_nearbyintf(&mut self.imports, var0)
}
pub fn rust_nearbyintl(&mut self, var0: i32, var1: i64, var2: i64) {
self.context.rust_nearbyintl(&mut self.imports, var0, var1, var2)
}
pub fn rust_nextafter(&mut self, var0: f64, var1: f64) -> f64 {
self.context.rust_nextafter(&mut self.imports, var0, var1)
}
pub fn rust_nextafterf(&mut self, var0: f32, var1: f32) -> f32 {
self.context.rust_nextafterf(&mut self.imports, var0, var1)
}
pub fn rust_nextafterl(&mut self, var0: i32, var1: i64, var2: i64, var3: i64, var4: i64) {
self.context.rust_nextafterl(&mut self.imports, var0, var1, var2, var3, var4)
}
pub fn rust_nexttoward(&mut self, var0: f64, var1: i64, var2: i64) -> f64 {
self.context.rust_nexttoward(&mut self.imports, var0, var1, var2)
}
pub fn rust_nexttowardf(&mut self, var0: f32, var1: i64, var2: i64) -> f32 {
self.context.rust_nexttowardf(&mut self.imports, var0, var1, var2)
}
pub fn rust_nexttowardl(&mut self, var0: i32, var1: i64, var2: i64, var3: i64, var4: i64) {
self.context.rust_nexttowardl(&mut self.imports, var0, var1, var2, var3, var4)
}
pub fn rust_pow(&mut self, var0: f64, var1: f64) -> f64 {
self.context.rust_pow(&mut self.imports, var0, var1)
}
pub fn rust_powf(&mut self, var0: f32, var1: f32) -> f32 {
self.context.rust_powf(&mut self.imports, var0, var1)
}
pub fn rust_powl(&mut self, var0: i32, var1: i64, var2: i64, var3: i64, var4: i64) {
self.context.rust_powl(&mut self.imports, var0, var1, var2, var3, var4)
}
pub fn rust_remainder(&mut self, var0: f64, var1: f64) -> f64 {
self.context.rust_remainder(&mut self.imports, var0, var1)
}
pub fn rust_remainderf(&mut self, var0: f32, var1: f32) -> f32 {
self.context.rust_remainderf(&mut self.imports, var0, var1)
}
pub fn rust_remainderl(&mut self, var0: i32, var1: i64, var2: i64, var3: i64, var4: i64) {
self.context.rust_remainderl(&mut self.imports, var0, var1, var2, var3, var4)
}
pub fn rust_remquo(&mut self, var0: f64, var1: f64, var2: i32) -> f64 {
self.context.rust_remquo(&mut self.imports, var0, var1, var2)
}
pub fn rust_remquof(&mut self, var0: f32, var1: f32, var2: i32) -> f32 {
self.context.rust_remquof(&mut self.imports, var0, var1, var2)
}
pub fn rust_remquol(&mut self, var0: i32, var1: i64, var2: i64, var3: i64, var4: i64, var5: i32) {
self.context.rust_remquol(&mut self.imports, var0, var1, var2, var3, var4, var5)
}
pub fn rust_rint(&mut self, var0: f64) -> f64 {
self.context.rust_rint(&mut self.imports, var0)
}
pub fn rust_rintf(&mut self, var0: f32) -> f32 {
self.context.rust_rintf(&mut self.imports, var0)
}
pub fn rust_rintl(&mut self, var0: i32, var1: i64, var2: i64) {
self.context.rust_rintl(&mut self.imports, var0, var1, var2)
}
pub fn rust_round(&mut self, var0: f64) -> f64 {
self.context.rust_round(&mut self.imports, var0)
}
pub fn rust_roundf(&mut self, var0: f32) -> f32 {
self.context.rust_roundf(&mut self.imports, var0)
}
pub fn rust_roundl(&mut self, var0: i32, var1: i64, var2: i64) {
self.context.rust_roundl(&mut self.imports, var0, var1, var2)
}
pub fn rust_scalbln(&mut self, var0: f64, var1: i32) -> f64 {
self.context.rust_scalbln(&mut self.imports, var0, var1)
}
pub fn rust_scalblnf(&mut self, var0: f32, var1: i32) -> f32 {
self.context.rust_scalblnf(&mut self.imports, var0, var1)
}
pub fn rust_scalblnl(&mut self, var0: i32, var1: i64, var2: i64, var3: i32) {
self.context.rust_scalblnl(&mut self.imports, var0, var1, var2, var3)
}
pub fn rust_scalbn(&mut self, var0: f64, var1: i32) -> f64 {
self.context.rust_scalbn(&mut self.imports, var0, var1)
}
pub fn rust_scalbnf(&mut self, var0: f32, var1: i32) -> f32 {
self.context.rust_scalbnf(&mut self.imports, var0, var1)
}
pub fn rust_scalbnl(&mut self, var0: i32, var1: i64, var2: i64, var3: i32) {
self.context.rust_scalbnl(&mut self.imports, var0, var1, var2, var3)
}
pub fn rust_sin(&mut self, var0: f64) -> f64 {
self.context.rust_sin(&mut self.imports, var0)
}
pub fn rust_sinf(&mut self, var0: f32) -> f32 {
self.context.rust_sinf(&mut self.imports, var0)
}
pub fn rust_sinl(&mut self, var0: i32, var1: i64, var2: i64) {
self.context.rust_sinl(&mut self.imports, var0, var1, var2)
}
pub fn rust_sinh(&mut self, var0: f64) -> f64 {
self.context.rust_sinh(&mut self.imports, var0)
}
pub fn rust_sinhf(&mut self, var0: f32) -> f32 {
self.context.rust_sinhf(&mut self.imports, var0)
}
pub fn rust_sinhl(&mut self, var0: i32, var1: i64, var2: i64) {
self.context.rust_sinhl(&mut self.imports, var0, var1, var2)
}
pub fn rust_sqrt(&mut self, var0: f64) -> f64 {
self.context.rust_sqrt(&mut self.imports, var0)
}
pub fn rust_sqrtf(&mut self, var0: f32) -> f32 {
self.context.rust_sqrtf(&mut self.imports, var0)
}
pub fn rust_sqrtl(&mut self, var0: i32, var1: i64, var2: i64) {
self.context.rust_sqrtl(&mut self.imports, var0, var1, var2)
}
pub fn rust_tan(&mut self, var0: f64) -> f64 {
self.context.rust_tan(&mut self.imports, var0)
}
pub fn rust_tanf(&mut self, var0: f32) -> f32 {
self.context.rust_tanf(&mut self.imports, var0)
}
pub fn rust_tanl(&mut self, var0: i32, var1: i64, var2: i64) {
self.context.rust_tanl(&mut self.imports, var0, var1, var2)
}
pub fn rust_tanh(&mut self, var0: f64) -> f64 {
self.context.rust_tanh(&mut self.imports, var0)
}
pub fn rust_tanhf(&mut self, var0: f32) -> f32 {
self.context.rust_tanhf(&mut self.imports, var0)
}
pub fn rust_tanhl(&mut self, var0: i32, var1: i64, var2: i64) {
self.context.rust_tanhl(&mut self.imports, var0, var1, var2)
}
pub fn rust_tgamma(&mut self, var0: f64) -> f64 {
self.context.rust_tgamma(&mut self.imports, var0)
}
pub fn rust_tgammaf(&mut self, var0: f32) -> f32 {
self.context.rust_tgammaf(&mut self.imports, var0)
}
pub fn rust_tgammal(&mut self, var0: i32, var1: i64, var2: i64) {
self.context.rust_tgammal(&mut self.imports, var0, var1, var2)
}
pub fn rust_trunc(&mut self, var0: f64) -> f64 {
self.context.rust_trunc(&mut self.imports, var0)
}
pub fn rust_truncf(&mut self, var0: f32) -> f32 {
self.context.rust_truncf(&mut self.imports, var0)
}
pub fn rust_truncl(&mut self, var0: i32, var1: i64, var2: i64) {
self.context.rust_truncl(&mut self.imports, var0, var1, var2)
}
pub fn rust_j0(&mut self, var0: f64) -> f64 {
self.context.rust_j0(&mut self.imports, var0)
}
pub fn rust_j1(&mut self, var0: f64) -> f64 {
self.context.rust_j1(&mut self.imports, var0)
}
pub fn rust_jn(&mut self, var0: i32, var1: f64) -> f64 {
self.context.rust_jn(&mut self.imports, var0, var1)
}
pub fn rust_y0(&mut self, var0: f64) -> f64 {
self.context.rust_y0(&mut self.imports, var0)
}
pub fn rust_y1(&mut self, var0: f64) -> f64 {
self.context.rust_y1(&mut self.imports, var0)
}
pub fn rust_yn(&mut self, var0: i32, var1: f64) -> f64 {
self.context.rust_yn(&mut self.imports, var0, var1)
}
pub fn rust_drem(&mut self, var0: f64, var1: f64) -> f64 {
self.context.rust_drem(&mut self.imports, var0, var1)
}
pub fn rust_dremf(&mut self, var0: f32, var1: f32) -> f32 {
self.context.rust_dremf(&mut self.imports, var0, var1)
}
pub fn rust_finite(&mut self, var0: f64) -> i32 {
self.context.rust_finite(&mut self.imports, var0)
}
pub fn rust_finitef(&mut self, var0: f32) -> i32 {
self.context.rust_finitef(&mut self.imports, var0)
}
pub fn rust_scalb(&mut self, var0: f64, var1: f64) -> f64 {
self.context.rust_scalb(&mut self.imports, var0, var1)
}
pub fn rust_scalbf(&mut self, var0: f32, var1: f32) -> f32 {
self.context.rust_scalbf(&mut self.imports, var0, var1)
}
pub fn rust_significand(&mut self, var0: f64) -> f64 {
self.context.rust_significand(&mut self.imports, var0)
}
pub fn rust_significandf(&mut self, var0: f32) -> f32 {
self.context.rust_significandf(&mut self.imports, var0)
}
pub fn rust_lgamma_r(&mut self, var0: f64, var1: i32) -> f64 {
self.context.rust_lgamma_r(&mut self.imports, var0, var1)
}
pub fn rust_lgammaf_r(&mut self, var0: f32, var1: i32) -> f32 {
self.context.rust_lgammaf_r(&mut self.imports, var0, var1)
}
pub fn rust_j0f(&mut self, var0: f32) -> f32 {
self.context.rust_j0f(&mut self.imports, var0)
}
pub fn rust_j1f(&mut self, var0: f32) -> f32 {
self.context.rust_j1f(&mut self.imports, var0)
}
pub fn rust_jnf(&mut self, var0: i32, var1: f32) -> f32 {
self.context.rust_jnf(&mut self.imports, var0, var1)
}
pub fn rust_y0f(&mut self, var0: f32) -> f32 {
self.context.rust_y0f(&mut self.imports, var0)
}
pub fn rust_y1f(&mut self, var0: f32) -> f32 {
self.context.rust_y1f(&mut self.imports, var0)
}
pub fn rust_ynf(&mut self, var0: i32, var1: f32) -> f32 {
self.context.rust_ynf(&mut self.imports, var0, var1)
}
pub fn rust_lgammal_r(&mut self, var0: i32, var1: i64, var2: i64, var3: i32) {
self.context.rust_lgammal_r(&mut self.imports, var0, var1, var2, var3)
}
pub fn rust_sincos(&mut self, var0: f64, var1: i32, var2: i32) {
self.context.rust_sincos(&mut self.imports, var0, var1, var2)
}
pub fn rust_sincosf(&mut self, var0: f32, var1: i32, var2: i32) {
self.context.rust_sincosf(&mut self.imports, var0, var1, var2)
}
pub fn rust_sincosl(&mut self, var0: i64, var1: i64, var2: i32, var3: i32) {
self.context.rust_sincosl(&mut self.imports, var0, var1, var2, var3)
}
pub fn rust_exp10(&mut self, var0: f64) -> f64 {
self.context.rust_exp10(&mut self.imports, var0)
}
pub fn rust_exp10f(&mut self, var0: f32) -> f32 {
self.context.rust_exp10f(&mut self.imports, var0)
}
pub fn rust_exp10l(&mut self, var0: i32, var1: i64, var2: i64) {
self.context.rust_exp10l(&mut self.imports, var0, var1, var2)
}
pub fn rust_pow10(&mut self, var0: f64) -> f64 {
self.context.rust_pow10(&mut self.imports, var0)
}
pub fn rust_pow10f(&mut self, var0: f32) -> f32 {
self.context.rust_pow10f(&mut self.imports, var0)
}
pub fn rust_pow10l(&mut self, var0: i32, var1: i64, var2: i64) {
self.context.rust_pow10l(&mut self.imports, var0, var1, var2)
}
pub fn okok_floor(&mut self, var0: f64) -> f64 {
self.context.okok_floor(&mut self.imports, var0)
}
}
impl<M: Memory> Context<M> {
pub fn rust_acos<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f64) -> f64 {
let var1 = self.acos(imports, var0);
var1
}
pub fn rust_acosf<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f32) -> f32 {
let var1 = self.acosf(imports, var0);
var1
}
pub fn rust_acosl<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: i32, mut var1: i64, mut var2: i64) {
let mut var3: i32 = 0;
let var4 = self.global0;
var3 = var4.wrapping_sub(16i32);
self.global0 = var3;
self.acosl(imports, var3, var1, var2);
let var5 = self.memory.load64(var3 as usize) as i64;
var1 = var5;
let var6 = self.memory.load64(var3 as usize + 8) as i64;
self.memory.store64(var0 as usize + 8, var6 as u64);
self.memory.store64(var0 as usize, var1 as u64);
self.global0 = var3.wrapping_add(16i32);
}
pub fn rust_acosh<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f64) -> f64 {
let var1 = self.acosh(imports, var0);
var1
}
pub fn rust_acoshf<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f32) -> f32 {
let var1 = self.acoshf(imports, var0);
var1
}
pub fn rust_acoshl<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: i32, mut var1: i64, mut var2: i64) {
let mut var3: i32 = 0;
let var4 = self.global0;
var3 = var4.wrapping_sub(16i32);
self.global0 = var3;
self.acoshl(imports, var3, var1, var2);
let var5 = self.memory.load64(var3 as usize) as i64;
var1 = var5;
let var6 = self.memory.load64(var3 as usize + 8) as i64;
self.memory.store64(var0 as usize + 8, var6 as u64);
self.memory.store64(var0 as usize, var1 as u64);
self.global0 = var3.wrapping_add(16i32);
}
pub fn rust_asin<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f64) -> f64 {
let var1 = self.asin(imports, var0);
var1
}
pub fn rust_asinf<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f32) -> f32 {
let var1 = self.asinf(imports, var0);
var1
}
pub fn rust_asinl<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: i32, mut var1: i64, mut var2: i64) {
let mut var3: i32 = 0;
let var4 = self.global0;
var3 = var4.wrapping_sub(16i32);
self.global0 = var3;
self.asinl(imports, var3, var1, var2);
let var5 = self.memory.load64(var3 as usize) as i64;
var1 = var5;
let var6 = self.memory.load64(var3 as usize + 8) as i64;
self.memory.store64(var0 as usize + 8, var6 as u64);
self.memory.store64(var0 as usize, var1 as u64);
self.global0 = var3.wrapping_add(16i32);
}
pub fn rust_asinh<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f64) -> f64 {
let var1 = self.asinh(imports, var0);
var1
}
pub fn rust_asinhf<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f32) -> f32 {
let var1 = self.asinhf(imports, var0);
var1
}
pub fn rust_asinhl<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: i32, mut var1: i64, mut var2: i64) {
let mut var3: i32 = 0;
let var4 = self.global0;
var3 = var4.wrapping_sub(16i32);
self.global0 = var3;
self.asinhl(imports, var3, var1, var2);
let var5 = self.memory.load64(var3 as usize) as i64;
var1 = var5;
let var6 = self.memory.load64(var3 as usize + 8) as i64;
self.memory.store64(var0 as usize + 8, var6 as u64);
self.memory.store64(var0 as usize, var1 as u64);
self.global0 = var3.wrapping_add(16i32);
}
pub fn rust_atan<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f64) -> f64 {
let var1 = self.atan(imports, var0);
var1
}
pub fn rust_atanf<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f32) -> f32 {
let var1 = self.atanf(imports, var0);
var1
}
pub fn rust_atanl<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: i32, mut var1: i64, mut var2: i64) {
let mut var3: i32 = 0;
let var4 = self.global0;
var3 = var4.wrapping_sub(16i32);
self.global0 = var3;
self.atanl(imports, var3, var1, var2);
let var5 = self.memory.load64(var3 as usize) as i64;
var1 = var5;
let var6 = self.memory.load64(var3 as usize + 8) as i64;
self.memory.store64(var0 as usize + 8, var6 as u64);
self.memory.store64(var0 as usize, var1 as u64);
self.global0 = var3.wrapping_add(16i32);
}
pub fn rust_atan2<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f64, mut var1: f64) -> f64 {
let var2 = self.atan2(imports, var0, var1);
var2
}
pub fn rust_atan2f<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f32, mut var1: f32) -> f32 {
let var2 = self.atan2f(imports, var0, var1);
var2
}
pub fn rust_atan2l<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: i32, mut var1: i64, mut var2: i64, mut var3: i64, mut var4: i64) {
let mut var5: i32 = 0;
let var6 = self.global0;
var5 = var6.wrapping_sub(16i32);
self.global0 = var5;
self.atan2l(imports, var5, var1, var2, var3, var4);
let var7 = self.memory.load64(var5 as usize) as i64;
var1 = var7;
let var8 = self.memory.load64(var5 as usize + 8) as i64;
self.memory.store64(var0 as usize + 8, var8 as u64);
self.memory.store64(var0 as usize, var1 as u64);
self.global0 = var5.wrapping_add(16i32);
}
pub fn rust_atanh<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f64) -> f64 {
let var1 = self.atanh(imports, var0);
var1
}
pub fn rust_atanhf<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f32) -> f32 {
let var1 = self.atanhf(imports, var0);
var1
}
pub fn rust_atanhl<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: i32, mut var1: i64, mut var2: i64) {
let mut var3: i32 = 0;
let var4 = self.global0;
var3 = var4.wrapping_sub(16i32);
self.global0 = var3;
self.atanhl(imports, var3, var1, var2);
let var5 = self.memory.load64(var3 as usize) as i64;
var1 = var5;
let var6 = self.memory.load64(var3 as usize + 8) as i64;
self.memory.store64(var0 as usize + 8, var6 as u64);
self.memory.store64(var0 as usize, var1 as u64);
self.global0 = var3.wrapping_add(16i32);
}
pub fn rust_cbrt<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f64) -> f64 {
let var1 = self.cbrt(imports, var0);
var1
}
pub fn rust_cbrtf<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f32) -> f32 {
let var1 = self.cbrtf(imports, var0);
var1
}
pub fn rust_cbrtl<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: i32, mut var1: i64, mut var2: i64) {
let mut var3: i32 = 0;
let var4 = self.global0;
var3 = var4.wrapping_sub(16i32);
self.global0 = var3;
self.cbrtl(imports, var3, var1, var2);
let var5 = self.memory.load64(var3 as usize) as i64;
var1 = var5;
let var6 = self.memory.load64(var3 as usize + 8) as i64;
self.memory.store64(var0 as usize + 8, var6 as u64);
self.memory.store64(var0 as usize, var1 as u64);
self.global0 = var3.wrapping_add(16i32);
}
pub fn rust_ceil<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f64) -> f64 {
let var1 = self.ceil(imports, var0);
var1
}
pub fn rust_ceilf<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f32) -> f32 {
let var1 = self.ceilf(imports, var0);
var1
}
pub fn rust_ceill<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: i32, mut var1: i64, mut var2: i64) {
let mut var3: i32 = 0;
let var4 = self.global0;
var3 = var4.wrapping_sub(16i32);
self.global0 = var3;
self.ceill(imports, var3, var1, var2);
let var5 = self.memory.load64(var3 as usize) as i64;
var1 = var5;
let var6 = self.memory.load64(var3 as usize + 8) as i64;
self.memory.store64(var0 as usize + 8, var6 as u64);
self.memory.store64(var0 as usize, var1 as u64);
self.global0 = var3.wrapping_add(16i32);
}
pub fn rust_copysign<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f64, mut var1: f64) -> f64 {
let var2 = self.copysign(imports, var0, var1);
var2
}
pub fn rust_copysignf<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f32, mut var1: f32) -> f32 {
let var2 = self.copysignf(imports, var0, var1);
var2
}
pub fn rust_copysignl<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: i32, mut var1: i64, mut var2: i64, mut var3: i64, mut var4: i64) {
let mut var5: i32 = 0;
let var6 = self.global0;
var5 = var6.wrapping_sub(16i32);
self.global0 = var5;
self.copysignl(imports, var5, var1, var2, var3, var4);
let var7 = self.memory.load64(var5 as usize) as i64;
var1 = var7;
let var8 = self.memory.load64(var5 as usize + 8) as i64;
self.memory.store64(var0 as usize + 8, var8 as u64);
self.memory.store64(var0 as usize, var1 as u64);
self.global0 = var5.wrapping_add(16i32);
}
pub fn rust_cos<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f64) -> f64 {
let var1 = self.cos(imports, var0);
var1
}
pub fn rust_cosf<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f32) -> f32 {
let var1 = self.cosf(imports, var0);
var1
}
pub fn rust_cosl<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: i32, mut var1: i64, mut var2: i64) {
let mut var3: i32 = 0;
let var4 = self.global0;
var3 = var4.wrapping_sub(16i32);
self.global0 = var3;
self.cosl(imports, var3, var1, var2);
let var5 = self.memory.load64(var3 as usize) as i64;
var1 = var5;
let var6 = self.memory.load64(var3 as usize + 8) as i64;
self.memory.store64(var0 as usize + 8, var6 as u64);
self.memory.store64(var0 as usize, var1 as u64);
self.global0 = var3.wrapping_add(16i32);
}
pub fn rust_cosh<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f64) -> f64 {
let var1 = self.cosh(imports, var0);
var1
}
pub fn rust_coshf<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f32) -> f32 {
let var1 = self.coshf(imports, var0);
var1
}
pub fn rust_coshl<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: i32, mut var1: i64, mut var2: i64) {
let mut var3: i32 = 0;
let var4 = self.global0;
var3 = var4.wrapping_sub(16i32);
self.global0 = var3;
self.coshl(imports, var3, var1, var2);
let var5 = self.memory.load64(var3 as usize) as i64;
var1 = var5;
let var6 = self.memory.load64(var3 as usize + 8) as i64;
self.memory.store64(var0 as usize + 8, var6 as u64);
self.memory.store64(var0 as usize, var1 as u64);
self.global0 = var3.wrapping_add(16i32);
}
pub fn rust_erf<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f64) -> f64 {
let var1 = self.erf(imports, var0);
var1
}
pub fn rust_erff<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f32) -> f32 {
let var1 = self.erff(imports, var0);
var1
}
pub fn rust_erfl<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: i32, mut var1: i64, mut var2: i64) {
let mut var3: i32 = 0;
let var4 = self.global0;
var3 = var4.wrapping_sub(16i32);
self.global0 = var3;
self.erfl(imports, var3, var1, var2);
let var5 = self.memory.load64(var3 as usize) as i64;
var1 = var5;
let var6 = self.memory.load64(var3 as usize + 8) as i64;
self.memory.store64(var0 as usize + 8, var6 as u64);
self.memory.store64(var0 as usize, var1 as u64);
self.global0 = var3.wrapping_add(16i32);
}
pub fn rust_erfc<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f64) -> f64 {
let var1 = self.erfc(imports, var0);
var1
}
pub fn rust_erfcf<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f32) -> f32 {
let var1 = self.erfcf(imports, var0);
var1
}
pub fn rust_erfcl<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: i32, mut var1: i64, mut var2: i64) {
let mut var3: i32 = 0;
let var4 = self.global0;
var3 = var4.wrapping_sub(16i32);
self.global0 = var3;
self.erfcl(imports, var3, var1, var2);
let var5 = self.memory.load64(var3 as usize) as i64;
var1 = var5;
let var6 = self.memory.load64(var3 as usize + 8) as i64;
self.memory.store64(var0 as usize + 8, var6 as u64);
self.memory.store64(var0 as usize, var1 as u64);
self.global0 = var3.wrapping_add(16i32);
}
pub fn rust_exp<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f64) -> f64 {
let var1 = self.exp(imports, var0);
var1
}
pub fn rust_expf<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f32) -> f32 {
let var1 = self.expf(imports, var0);
var1
}
pub fn rust_expl<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: i32, mut var1: i64, mut var2: i64) {
let mut var3: i32 = 0;
let var4 = self.global0;
var3 = var4.wrapping_sub(16i32);
self.global0 = var3;
self.expl(imports, var3, var1, var2);
let var5 = self.memory.load64(var3 as usize) as i64;
var1 = var5;
let var6 = self.memory.load64(var3 as usize + 8) as i64;
self.memory.store64(var0 as usize + 8, var6 as u64);
self.memory.store64(var0 as usize, var1 as u64);
self.global0 = var3.wrapping_add(16i32);
}
pub fn rust_exp2<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f64) -> f64 {
let var1 = self.exp2(imports, var0);
var1
}
pub fn rust_exp2f<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f32) -> f32 {
let var1 = self.exp2f(imports, var0);
var1
}
pub fn rust_exp2l<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: i32, mut var1: i64, mut var2: i64) {
let mut var3: i32 = 0;
let var4 = self.global0;
var3 = var4.wrapping_sub(16i32);
self.global0 = var3;
self.exp2l(imports, var3, var1, var2);
let var5 = self.memory.load64(var3 as usize) as i64;
var1 = var5;
let var6 = self.memory.load64(var3 as usize + 8) as i64;
self.memory.store64(var0 as usize + 8, var6 as u64);
self.memory.store64(var0 as usize, var1 as u64);
self.global0 = var3.wrapping_add(16i32);
}
pub fn rust_expm1<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f64) -> f64 {
let var1 = self.expm1(imports, var0);
var1
}
pub fn rust_expm1f<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f32) -> f32 {
let var1 = self.expm1f(imports, var0);
var1
}
pub fn rust_expm1l<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: i32, mut var1: i64, mut var2: i64) {
let mut var3: i32 = 0;
let var4 = self.global0;
var3 = var4.wrapping_sub(16i32);
self.global0 = var3;
self.expm1l(imports, var3, var1, var2);
let var5 = self.memory.load64(var3 as usize) as i64;
var1 = var5;
let var6 = self.memory.load64(var3 as usize + 8) as i64;
self.memory.store64(var0 as usize + 8, var6 as u64);
self.memory.store64(var0 as usize, var1 as u64);
self.global0 = var3.wrapping_add(16i32);
}
pub fn rust_fabs<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f64) -> f64 {
let var1 = self.fabs(imports, var0);
var1
}
pub fn rust_fabsf<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f32) -> f32 {
let var1 = self.fabsf(imports, var0);
var1
}
pub fn rust_fabsl<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: i32, mut var1: i64, mut var2: i64) {
let mut var3: i32 = 0;
let var4 = self.global0;
var3 = var4.wrapping_sub(16i32);
self.global0 = var3;
self.fabsl(imports, var3, var1, var2);
let var5 = self.memory.load64(var3 as usize) as i64;
var1 = var5;
let var6 = self.memory.load64(var3 as usize + 8) as i64;
self.memory.store64(var0 as usize + 8, var6 as u64);
self.memory.store64(var0 as usize, var1 as u64);
self.global0 = var3.wrapping_add(16i32);
}
pub fn rust_fdim<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f64, mut var1: f64) -> f64 {
let var2 = self.fdim(imports, var0, var1);
var2
}
pub fn rust_fdimf<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f32, mut var1: f32) -> f32 {
let var2 = self.fdimf(imports, var0, var1);
var2
}
pub fn rust_fdiml<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: i32, mut var1: i64, mut var2: i64, mut var3: i64, mut var4: i64) {
let mut var5: i32 = 0;
let var6 = self.global0;
var5 = var6.wrapping_sub(16i32);
self.global0 = var5;
self.fdiml(imports, var5, var1, var2, var3, var4);
let var7 = self.memory.load64(var5 as usize) as i64;
var1 = var7;
let var8 = self.memory.load64(var5 as usize + 8) as i64;
self.memory.store64(var0 as usize + 8, var8 as u64);
self.memory.store64(var0 as usize, var1 as u64);
self.global0 = var5.wrapping_add(16i32);
}
pub fn rust_floor<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f64) -> f64 {
let var1 = self.floor(imports, var0);
var1
}
pub fn rust_floorf<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f32) -> f32 {
let var1 = self.floorf(imports, var0);
var1
}
pub fn rust_floorl<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: i32, mut var1: i64, mut var2: i64) {
let mut var3: i32 = 0;
let var4 = self.global0;
var3 = var4.wrapping_sub(16i32);
self.global0 = var3;
self.floorl(imports, var3, var1, var2);
let var5 = self.memory.load64(var3 as usize) as i64;
var1 = var5;
let var6 = self.memory.load64(var3 as usize + 8) as i64;
self.memory.store64(var0 as usize + 8, var6 as u64);
self.memory.store64(var0 as usize, var1 as u64);
self.global0 = var3.wrapping_add(16i32);
}
pub fn rust_fma<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f64, mut var1: f64, mut var2: f64) -> f64 {
let var3 = self.fma(imports, var0, var1, var2);
var3
}
pub fn rust_fmaf<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f32, mut var1: f32, mut var2: f32) -> f32 {
let var3 = self.fmaf(imports, var0, var1, var2);
var3
}
pub fn rust_fmal<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: i32, mut var1: i64, mut var2: i64, mut var3: i64, mut var4: i64, mut var5: i64, mut var6: i64) {
let mut var7: i32 = 0;
let var8 = self.global0;
var7 = var8.wrapping_sub(16i32);
self.global0 = var7;
self.fmal(imports, var7, var1, var2, var3, var4, var5, var6);
let var9 = self.memory.load64(var7 as usize) as i64;
var1 = var9;
let var10 = self.memory.load64(var7 as usize + 8) as i64;
self.memory.store64(var0 as usize + 8, var10 as u64);
self.memory.store64(var0 as usize, var1 as u64);
self.global0 = var7.wrapping_add(16i32);
}
pub fn rust_fmax<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f64, mut var1: f64) -> f64 {
let var2 = self.fmax(imports, var0, var1);
var2
}
pub fn rust_fmaxf<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f32, mut var1: f32) -> f32 {
let var2 = self.fmaxf(imports, var0, var1);
var2
}
pub fn rust_fmaxl<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: i32, mut var1: i64, mut var2: i64, mut var3: i64, mut var4: i64) {
let mut var5: i32 = 0;
let var6 = self.global0;
var5 = var6.wrapping_sub(16i32);
self.global0 = var5;
self.fmaxl(imports, var5, var1, var2, var3, var4);
let var7 = self.memory.load64(var5 as usize) as i64;
var1 = var7;
let var8 = self.memory.load64(var5 as usize + 8) as i64;
self.memory.store64(var0 as usize + 8, var8 as u64);
self.memory.store64(var0 as usize, var1 as u64);
self.global0 = var5.wrapping_add(16i32);
}
pub fn rust_fmin<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f64, mut var1: f64) -> f64 {
let var2 = self.fmin(imports, var0, var1);
var2
}
pub fn rust_fminf<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f32, mut var1: f32) -> f32 {
let var2 = self.fminf(imports, var0, var1);
var2
}
pub fn rust_fminl<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: i32, mut var1: i64, mut var2: i64, mut var3: i64, mut var4: i64) {
let mut var5: i32 = 0;
let var6 = self.global0;
var5 = var6.wrapping_sub(16i32);
self.global0 = var5;
self.fminl(imports, var5, var1, var2, var3, var4);
let var7 = self.memory.load64(var5 as usize) as i64;
var1 = var7;
let var8 = self.memory.load64(var5 as usize + 8) as i64;
self.memory.store64(var0 as usize + 8, var8 as u64);
self.memory.store64(var0 as usize, var1 as u64);
self.global0 = var5.wrapping_add(16i32);
}
pub fn rust_fmod<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f64, mut var1: f64) -> f64 {
let var2 = self.fmod(imports, var0, var1);
var2
}
pub fn rust_fmodf<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f32, mut var1: f32) -> f32 {
let var2 = self.fmodf(imports, var0, var1);
var2
}
pub fn rust_fmodl<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: i32, mut var1: i64, mut var2: i64, mut var3: i64, mut var4: i64) {
let mut var5: i32 = 0;
let var6 = self.global0;
var5 = var6.wrapping_sub(16i32);
self.global0 = var5;
self.fmodl(imports, var5, var1, var2, var3, var4);
let var7 = self.memory.load64(var5 as usize) as i64;
var1 = var7;
let var8 = self.memory.load64(var5 as usize + 8) as i64;
self.memory.store64(var0 as usize + 8, var8 as u64);
self.memory.store64(var0 as usize, var1 as u64);
self.global0 = var5.wrapping_add(16i32);
}
pub fn rust_frexp<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f64, mut var1: i32) -> f64 {
let var2 = self.frexp(imports, var0, var1);
var2
}
pub fn rust_frexpf<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f32, mut var1: i32) -> f32 {
let var2 = self.frexpf(imports, var0, var1);
var2
}
pub fn rust_frexpl<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: i32, mut var1: i64, mut var2: i64, mut var3: i32) {
let mut var4: i32 = 0;
let var5 = self.global0;
var4 = var5.wrapping_sub(16i32);
self.global0 = var4;
self.frexpl(imports, var4, var1, var2, var3);
let var6 = self.memory.load64(var4 as usize) as i64;
var1 = var6;
let var7 = self.memory.load64(var4 as usize + 8) as i64;
self.memory.store64(var0 as usize + 8, var7 as u64);
self.memory.store64(var0 as usize, var1 as u64);
self.global0 = var4.wrapping_add(16i32);
}
pub fn rust_hypot<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f64, mut var1: f64) -> f64 {
let var2 = self.hypot(imports, var0, var1);
var2
}
pub fn rust_hypotf<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f32, mut var1: f32) -> f32 {
let var2 = self.hypotf(imports, var0, var1);
var2
}
pub fn rust_hypotl<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: i32, mut var1: i64, mut var2: i64, mut var3: i64, mut var4: i64) {
let mut var5: i32 = 0;
let var6 = self.global0;
var5 = var6.wrapping_sub(16i32);
self.global0 = var5;
self.hypotl(imports, var5, var1, var2, var3, var4);
let var7 = self.memory.load64(var5 as usize) as i64;
var1 = var7;
let var8 = self.memory.load64(var5 as usize + 8) as i64;
self.memory.store64(var0 as usize + 8, var8 as u64);
self.memory.store64(var0 as usize, var1 as u64);
self.global0 = var5.wrapping_add(16i32);
}
pub fn rust_ilogb<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f64) -> i32 {
let var1 = self.ilogb(imports, var0);
var1
}
pub fn rust_ilogbf<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f32) -> i32 {
let var1 = self.ilogbf(imports, var0);
var1
}
pub fn rust_ilogbl<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: i64, mut var1: i64) -> i32 {
let var2 = self.ilogbl(imports, var0, var1);
var2
}
pub fn rust_ldexp<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f64, mut var1: i32) -> f64 {
let var2 = self.ldexp(imports, var0, var1);
var2
}
pub fn rust_ldexpf<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f32, mut var1: i32) -> f32 {
let var2 = self.ldexpf(imports, var0, var1);
var2
}
pub fn rust_ldexpl<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: i32, mut var1: i64, mut var2: i64, mut var3: i32) {
let mut var4: i32 = 0;
let var5 = self.global0;
var4 = var5.wrapping_sub(16i32);
self.global0 = var4;
self.ldexpl(imports, var4, var1, var2, var3);
let var6 = self.memory.load64(var4 as usize) as i64;
var1 = var6;
let var7 = self.memory.load64(var4 as usize + 8) as i64;
self.memory.store64(var0 as usize + 8, var7 as u64);
self.memory.store64(var0 as usize, var1 as u64);
self.global0 = var4.wrapping_add(16i32);
}
pub fn rust_lgamma<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f64) -> f64 {
let var1 = self.lgamma(imports, var0);
var1
}
pub fn rust_lgammaf<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f32) -> f32 {
let var1 = self.lgammaf(imports, var0);
var1
}
pub fn rust_lgammal<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: i32, mut var1: i64, mut var2: i64) {
let mut var3: i32 = 0;
let var4 = self.global0;
var3 = var4.wrapping_sub(16i32);
self.global0 = var3;
self.lgammal(imports, var3, var1, var2);
let var5 = self.memory.load64(var3 as usize) as i64;
var1 = var5;
let var6 = self.memory.load64(var3 as usize + 8) as i64;
self.memory.store64(var0 as usize + 8, var6 as u64);
self.memory.store64(var0 as usize, var1 as u64);
self.global0 = var3.wrapping_add(16i32);
}
pub fn rust_llrint<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f64) -> i64 {
let var1 = self.llrint(imports, var0);
var1
}
pub fn rust_llrintf<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f32) -> i64 {
let var1 = self.llrintf(imports, var0);
var1
}
pub fn rust_llrintl<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: i64, mut var1: i64) -> i64 {
let var2 = self.llrintl(imports, var0, var1);
var2
}
pub fn rust_llround<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f64) -> i64 {
let var1 = self.llround(imports, var0);
var1
}
pub fn rust_llroundf<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f32) -> i64 {
let var1 = self.llroundf(imports, var0);
var1
}
pub fn rust_llroundl<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: i64, mut var1: i64) -> i64 {
let var2 = self.llroundl(imports, var0, var1);
var2
}
pub fn rust_log<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f64) -> f64 {
let var1 = self.log(imports, var0);
var1
}
pub fn rust_logf<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f32) -> f32 {
let var1 = self.logf(imports, var0);
var1
}
pub fn rust_logl<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: i32, mut var1: i64, mut var2: i64) {
let mut var3: i32 = 0;
let var4 = self.global0;
var3 = var4.wrapping_sub(16i32);
self.global0 = var3;
self.logl(imports, var3, var1, var2);
let var5 = self.memory.load64(var3 as usize) as i64;
var1 = var5;
let var6 = self.memory.load64(var3 as usize + 8) as i64;
self.memory.store64(var0 as usize + 8, var6 as u64);
self.memory.store64(var0 as usize, var1 as u64);
self.global0 = var3.wrapping_add(16i32);
}
pub fn rust_log10<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f64) -> f64 {
let var1 = self.log10(imports, var0);
var1
}
pub fn rust_log10f<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f32) -> f32 {
let var1 = self.log10f(imports, var0);
var1
}
pub fn rust_log10l<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: i32, mut var1: i64, mut var2: i64) {
let mut var3: i32 = 0;
let var4 = self.global0;
var3 = var4.wrapping_sub(16i32);
self.global0 = var3;
self.log10l(imports, var3, var1, var2);
let var5 = self.memory.load64(var3 as usize) as i64;
var1 = var5;
let var6 = self.memory.load64(var3 as usize + 8) as i64;
self.memory.store64(var0 as usize + 8, var6 as u64);
self.memory.store64(var0 as usize, var1 as u64);
self.global0 = var3.wrapping_add(16i32);
}
pub fn rust_log1p<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f64) -> f64 {
let var1 = self.log1p(imports, var0);
var1
}
pub fn rust_log1pf<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f32) -> f32 {
let var1 = self.log1pf(imports, var0);
var1
}
pub fn rust_log1pl<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: i32, mut var1: i64, mut var2: i64) {
let mut var3: i32 = 0;
let var4 = self.global0;
var3 = var4.wrapping_sub(16i32);
self.global0 = var3;
self.log1pl(imports, var3, var1, var2);
let var5 = self.memory.load64(var3 as usize) as i64;
var1 = var5;
let var6 = self.memory.load64(var3 as usize + 8) as i64;
self.memory.store64(var0 as usize + 8, var6 as u64);
self.memory.store64(var0 as usize, var1 as u64);
self.global0 = var3.wrapping_add(16i32);
}
pub fn rust_log2<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f64) -> f64 {
let var1 = self.log2(imports, var0);
var1
}
pub fn rust_log2f<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f32) -> f32 {
let var1 = self.log2f(imports, var0);
var1
}
pub fn rust_log2l<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: i32, mut var1: i64, mut var2: i64) {
let mut var3: i32 = 0;
let var4 = self.global0;
var3 = var4.wrapping_sub(16i32);
self.global0 = var3;
self.log2l(imports, var3, var1, var2);
let var5 = self.memory.load64(var3 as usize) as i64;
var1 = var5;
let var6 = self.memory.load64(var3 as usize + 8) as i64;
self.memory.store64(var0 as usize + 8, var6 as u64);
self.memory.store64(var0 as usize, var1 as u64);
self.global0 = var3.wrapping_add(16i32);
}
pub fn rust_logb<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f64) -> f64 {
let var1 = self.logb(imports, var0);
var1
}
pub fn rust_logbf<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f32) -> f32 {
let var1 = self.logbf(imports, var0);
var1
}
pub fn rust_logbl<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: i32, mut var1: i64, mut var2: i64) {
let mut var3: i32 = 0;
let var4 = self.global0;
var3 = var4.wrapping_sub(16i32);
self.global0 = var3;
self.logbl(imports, var3, var1, var2);
let var5 = self.memory.load64(var3 as usize) as i64;
var1 = var5;
let var6 = self.memory.load64(var3 as usize + 8) as i64;
self.memory.store64(var0 as usize + 8, var6 as u64);
self.memory.store64(var0 as usize, var1 as u64);
self.global0 = var3.wrapping_add(16i32);
}
pub fn rust_lrint<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f64) -> i32 {
let var1 = self.lrint(imports, var0);
var1
}
pub fn rust_lrintf<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f32) -> i32 {
let var1 = self.lrintf(imports, var0);
var1
}
pub fn rust_lrintl<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: i64, mut var1: i64) -> i32 {
let var2 = self.lrintl(imports, var0, var1);
var2
}
pub fn rust_lround<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f64) -> i32 {
let var1 = self.lround(imports, var0);
var1
}
pub fn rust_lroundf<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f32) -> i32 {
let var1 = self.lroundf(imports, var0);
var1
}
pub fn rust_lroundl<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: i64, mut var1: i64) -> i32 {
let var2 = self.lroundl(imports, var0, var1);
var2
}
pub fn rust_modf<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f64, mut var1: i32) -> f64 {
let var2 = self.modf(imports, var0, var1);
var2
}
pub fn rust_modff<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f32, mut var1: i32) -> f32 {
let var2 = self.modff(imports, var0, var1);
var2
}
pub fn rust_modfl<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: i32, mut var1: i64, mut var2: i64, mut var3: i32) {
let mut var4: i32 = 0;
let var5 = self.global0;
var4 = var5.wrapping_sub(16i32);
self.global0 = var4;
self.modfl(imports, var4, var1, var2, var3);
let var6 = self.memory.load64(var4 as usize) as i64;
var1 = var6;
let var7 = self.memory.load64(var4 as usize + 8) as i64;
self.memory.store64(var0 as usize + 8, var7 as u64);
self.memory.store64(var0 as usize, var1 as u64);
self.global0 = var4.wrapping_add(16i32);
}
pub fn rust_nan<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: i32) -> f64 {
let var1 = self.nan(imports, var0);
var1
}
pub fn rust_nanf<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: i32) -> f32 {
let var1 = self.nanf(imports, var0);
var1
}
pub fn rust_nanl<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: i32, mut var1: i32) {
let mut var2: i32 = 0;
let mut var3: i64 = 0;
let var4 = self.global0;
var2 = var4.wrapping_sub(16i32);
self.global0 = var2;
self.nanl(imports, var2, var1);
let var5 = self.memory.load64(var2 as usize) as i64;
var3 = var5;
let var6 = self.memory.load64(var2 as usize + 8) as i64;
self.memory.store64(var0 as usize + 8, var6 as u64);
self.memory.store64(var0 as usize, var3 as u64);
self.global0 = var2.wrapping_add(16i32);
}
pub fn rust_nearbyint<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f64) -> f64 {
let var1 = self.nearbyint(imports, var0);
var1
}
pub fn rust_nearbyintf<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f32) -> f32 {
let var1 = self.nearbyintf(imports, var0);
var1
}
pub fn rust_nearbyintl<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: i32, mut var1: i64, mut var2: i64) {
let mut var3: i32 = 0;
let var4 = self.global0;
var3 = var4.wrapping_sub(16i32);
self.global0 = var3;
self.nearbyintl(imports, var3, var1, var2);
let var5 = self.memory.load64(var3 as usize) as i64;
var1 = var5;
let var6 = self.memory.load64(var3 as usize + 8) as i64;
self.memory.store64(var0 as usize + 8, var6 as u64);
self.memory.store64(var0 as usize, var1 as u64);
self.global0 = var3.wrapping_add(16i32);
}
pub fn rust_nextafter<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f64, mut var1: f64) -> f64 {
let var2 = self.nextafter(imports, var0, var1);
var2
}
pub fn rust_nextafterf<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f32, mut var1: f32) -> f32 {
let var2 = self.nextafterf(imports, var0, var1);
var2
}
pub fn rust_nextafterl<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: i32, mut var1: i64, mut var2: i64, mut var3: i64, mut var4: i64) {
let mut var5: i32 = 0;
let var6 = self.global0;
var5 = var6.wrapping_sub(16i32);
self.global0 = var5;
self.nextafterl(imports, var5, var1, var2, var3, var4);
let var7 = self.memory.load64(var5 as usize) as i64;
var1 = var7;
let var8 = self.memory.load64(var5 as usize + 8) as i64;
self.memory.store64(var0 as usize + 8, var8 as u64);
self.memory.store64(var0 as usize, var1 as u64);
self.global0 = var5.wrapping_add(16i32);
}
pub fn rust_nexttoward<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f64, mut var1: i64, mut var2: i64) -> f64 {
let var3 = self.nexttoward(imports, var0, var1, var2);
var3
}
pub fn rust_nexttowardf<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f32, mut var1: i64, mut var2: i64) -> f32 {
let var3 = self.nexttowardf(imports, var0, var1, var2);
var3
}
pub fn rust_nexttowardl<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: i32, mut var1: i64, mut var2: i64, mut var3: i64, mut var4: i64) {
let mut var5: i32 = 0;
let var6 = self.global0;
var5 = var6.wrapping_sub(16i32);
self.global0 = var5;
self.nexttowardl(imports, var5, var1, var2, var3, var4);
let var7 = self.memory.load64(var5 as usize) as i64;
var1 = var7;
let var8 = self.memory.load64(var5 as usize + 8) as i64;
self.memory.store64(var0 as usize + 8, var8 as u64);
self.memory.store64(var0 as usize, var1 as u64);
self.global0 = var5.wrapping_add(16i32);
}
pub fn rust_pow<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f64, mut var1: f64) -> f64 {
let var2 = self.pow(imports, var0, var1);
var2
}
pub fn rust_powf<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f32, mut var1: f32) -> f32 {
let var2 = self.powf(imports, var0, var1);
var2
}
pub fn rust_powl<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: i32, mut var1: i64, mut var2: i64, mut var3: i64, mut var4: i64) {
let mut var5: i32 = 0;
let var6 = self.global0;
var5 = var6.wrapping_sub(16i32);
self.global0 = var5;
self.powl(imports, var5, var1, var2, var3, var4);
let var7 = self.memory.load64(var5 as usize) as i64;
var1 = var7;
let var8 = self.memory.load64(var5 as usize + 8) as i64;
self.memory.store64(var0 as usize + 8, var8 as u64);
self.memory.store64(var0 as usize, var1 as u64);
self.global0 = var5.wrapping_add(16i32);
}
pub fn rust_remainder<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f64, mut var1: f64) -> f64 {
let var2 = self.remainder(imports, var0, var1);
var2
}
pub fn rust_remainderf<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f32, mut var1: f32) -> f32 {
let var2 = self.remainderf(imports, var0, var1);
var2
}
pub fn rust_remainderl<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: i32, mut var1: i64, mut var2: i64, mut var3: i64, mut var4: i64) {
let mut var5: i32 = 0;
let var6 = self.global0;
var5 = var6.wrapping_sub(16i32);
self.global0 = var5;
self.remainderl(imports, var5, var1, var2, var3, var4);
let var7 = self.memory.load64(var5 as usize) as i64;
var1 = var7;
let var8 = self.memory.load64(var5 as usize + 8) as i64;
self.memory.store64(var0 as usize + 8, var8 as u64);
self.memory.store64(var0 as usize, var1 as u64);
self.global0 = var5.wrapping_add(16i32);
}
pub fn rust_remquo<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f64, mut var1: f64, mut var2: i32) -> f64 {
let var3 = self.remquo(imports, var0, var1, var2);
var3
}
pub fn rust_remquof<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f32, mut var1: f32, mut var2: i32) -> f32 {
let var3 = self.remquof(imports, var0, var1, var2);
var3
}
pub fn rust_remquol<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: i32, mut var1: i64, mut var2: i64, mut var3: i64, mut var4: i64, mut var5: i32) {
let mut var6: i32 = 0;
let var7 = self.global0;
var6 = var7.wrapping_sub(16i32);
self.global0 = var6;
self.remquol(imports, var6, var1, var2, var3, var4, var5);
let var8 = self.memory.load64(var6 as usize) as i64;
var1 = var8;
let var9 = self.memory.load64(var6 as usize + 8) as i64;
self.memory.store64(var0 as usize + 8, var9 as u64);
self.memory.store64(var0 as usize, var1 as u64);
self.global0 = var6.wrapping_add(16i32);
}
pub fn rust_rint<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f64) -> f64 {
let var1 = self.rint(imports, var0);
var1
}
pub fn rust_rintf<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f32) -> f32 {
let var1 = self.rintf(imports, var0);
var1
}
pub fn rust_rintl<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: i32, mut var1: i64, mut var2: i64) {
let mut var3: i32 = 0;
let var4 = self.global0;
var3 = var4.wrapping_sub(16i32);
self.global0 = var3;
self.rintl(imports, var3, var1, var2);
let var5 = self.memory.load64(var3 as usize) as i64;
var1 = var5;
let var6 = self.memory.load64(var3 as usize + 8) as i64;
self.memory.store64(var0 as usize + 8, var6 as u64);
self.memory.store64(var0 as usize, var1 as u64);
self.global0 = var3.wrapping_add(16i32);
}
pub fn rust_round<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f64) -> f64 {
let var1 = self.round(imports, var0);
var1
}
pub fn rust_roundf<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f32) -> f32 {
let var1 = self.roundf(imports, var0);
var1
}
pub fn rust_roundl<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: i32, mut var1: i64, mut var2: i64) {
let mut var3: i32 = 0;
let var4 = self.global0;
var3 = var4.wrapping_sub(16i32);
self.global0 = var3;
self.roundl(imports, var3, var1, var2);
let var5 = self.memory.load64(var3 as usize) as i64;
var1 = var5;
let var6 = self.memory.load64(var3 as usize + 8) as i64;
self.memory.store64(var0 as usize + 8, var6 as u64);
self.memory.store64(var0 as usize, var1 as u64);
self.global0 = var3.wrapping_add(16i32);
}
pub fn rust_scalbln<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f64, mut var1: i32) -> f64 {
let var2 = self.scalbln(imports, var0, var1);
var2
}
pub fn rust_scalblnf<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f32, mut var1: i32) -> f32 {
let var2 = self.scalblnf(imports, var0, var1);
var2
}
pub fn rust_scalblnl<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: i32, mut var1: i64, mut var2: i64, mut var3: i32) {
let mut var4: i32 = 0;
let var5 = self.global0;
var4 = var5.wrapping_sub(16i32);
self.global0 = var4;
self.scalblnl(imports, var4, var1, var2, var3);
let var6 = self.memory.load64(var4 as usize) as i64;
var1 = var6;
let var7 = self.memory.load64(var4 as usize + 8) as i64;
self.memory.store64(var0 as usize + 8, var7 as u64);
self.memory.store64(var0 as usize, var1 as u64);
self.global0 = var4.wrapping_add(16i32);
}
pub fn rust_scalbn<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f64, mut var1: i32) -> f64 {
let var2 = self.scalbn(imports, var0, var1);
var2
}
pub fn rust_scalbnf<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f32, mut var1: i32) -> f32 {
let var2 = self.scalbnf(imports, var0, var1);
var2
}
pub fn rust_scalbnl<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: i32, mut var1: i64, mut var2: i64, mut var3: i32) {
let mut var4: i32 = 0;
let var5 = self.global0;
var4 = var5.wrapping_sub(16i32);
self.global0 = var4;
self.scalbnl(imports, var4, var1, var2, var3);
let var6 = self.memory.load64(var4 as usize) as i64;
var1 = var6;
let var7 = self.memory.load64(var4 as usize + 8) as i64;
self.memory.store64(var0 as usize + 8, var7 as u64);
self.memory.store64(var0 as usize, var1 as u64);
self.global0 = var4.wrapping_add(16i32);
}
pub fn rust_sin<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f64) -> f64 {
let var1 = self.sin(imports, var0);
var1
}
pub fn rust_sinf<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f32) -> f32 {
let var1 = self.sinf(imports, var0);
var1
}
pub fn rust_sinl<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: i32, mut var1: i64, mut var2: i64) {
let mut var3: i32 = 0;
let var4 = self.global0;
var3 = var4.wrapping_sub(16i32);
self.global0 = var3;
self.sinl(imports, var3, var1, var2);
let var5 = self.memory.load64(var3 as usize) as i64;
var1 = var5;
let var6 = self.memory.load64(var3 as usize + 8) as i64;
self.memory.store64(var0 as usize + 8, var6 as u64);
self.memory.store64(var0 as usize, var1 as u64);
self.global0 = var3.wrapping_add(16i32);
}
pub fn rust_sinh<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f64) -> f64 {
let var1 = self.sinh(imports, var0);
var1
}
pub fn rust_sinhf<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f32) -> f32 {
let var1 = self.sinhf(imports, var0);
var1
}
pub fn rust_sinhl<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: i32, mut var1: i64, mut var2: i64) {
let mut var3: i32 = 0;
let var4 = self.global0;
var3 = var4.wrapping_sub(16i32);
self.global0 = var3;
self.sinhl(imports, var3, var1, var2);
let var5 = self.memory.load64(var3 as usize) as i64;
var1 = var5;
let var6 = self.memory.load64(var3 as usize + 8) as i64;
self.memory.store64(var0 as usize + 8, var6 as u64);
self.memory.store64(var0 as usize, var1 as u64);
self.global0 = var3.wrapping_add(16i32);
}
pub fn rust_sqrt<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f64) -> f64 {
let var1 = self.sqrt(imports, var0);
var1
}
pub fn rust_sqrtf<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f32) -> f32 {
let var1 = self.sqrtf(imports, var0);
var1
}
pub fn rust_sqrtl<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: i32, mut var1: i64, mut var2: i64) {
let mut var3: i32 = 0;
let var4 = self.global0;
var3 = var4.wrapping_sub(16i32);
self.global0 = var3;
self.sqrtl(imports, var3, var1, var2);
let var5 = self.memory.load64(var3 as usize) as i64;
var1 = var5;
let var6 = self.memory.load64(var3 as usize + 8) as i64;
self.memory.store64(var0 as usize + 8, var6 as u64);
self.memory.store64(var0 as usize, var1 as u64);
self.global0 = var3.wrapping_add(16i32);
}
pub fn rust_tan<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f64) -> f64 {
let var1 = self.tan(imports, var0);
var1
}
pub fn rust_tanf<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f32) -> f32 {
let var1 = self.tanf(imports, var0);
var1
}
pub fn rust_tanl<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: i32, mut var1: i64, mut var2: i64) {
let mut var3: i32 = 0;
let var4 = self.global0;
var3 = var4.wrapping_sub(16i32);
self.global0 = var3;
self.tanl(imports, var3, var1, var2);
let var5 = self.memory.load64(var3 as usize) as i64;
var1 = var5;
let var6 = self.memory.load64(var3 as usize + 8) as i64;
self.memory.store64(var0 as usize + 8, var6 as u64);
self.memory.store64(var0 as usize, var1 as u64);
self.global0 = var3.wrapping_add(16i32);
}
pub fn rust_tanh<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f64) -> f64 {
let var1 = self.tanh(imports, var0);
var1
}
pub fn rust_tanhf<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f32) -> f32 {
let var1 = self.tanhf(imports, var0);
var1
}
pub fn rust_tanhl<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: i32, mut var1: i64, mut var2: i64) {
let mut var3: i32 = 0;
let var4 = self.global0;
var3 = var4.wrapping_sub(16i32);
self.global0 = var3;
self.tanhl(imports, var3, var1, var2);
let var5 = self.memory.load64(var3 as usize) as i64;
var1 = var5;
let var6 = self.memory.load64(var3 as usize + 8) as i64;
self.memory.store64(var0 as usize + 8, var6 as u64);
self.memory.store64(var0 as usize, var1 as u64);
self.global0 = var3.wrapping_add(16i32);
}
pub fn rust_tgamma<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f64) -> f64 {
let var1 = self.tgamma(imports, var0);
var1
}
pub fn rust_tgammaf<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f32) -> f32 {
let var1 = self.tgammaf(imports, var0);
var1
}
pub fn rust_tgammal<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: i32, mut var1: i64, mut var2: i64) {
let mut var3: i32 = 0;
let var4 = self.global0;
var3 = var4.wrapping_sub(16i32);
self.global0 = var3;
self.tgammal(imports, var3, var1, var2);
let var5 = self.memory.load64(var3 as usize) as i64;
var1 = var5;
let var6 = self.memory.load64(var3 as usize + 8) as i64;
self.memory.store64(var0 as usize + 8, var6 as u64);
self.memory.store64(var0 as usize, var1 as u64);
self.global0 = var3.wrapping_add(16i32);
}
pub fn rust_trunc<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f64) -> f64 {
let var1 = self.trunc(imports, var0);
var1
}
pub fn rust_truncf<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f32) -> f32 {
let var1 = self.truncf(imports, var0);
var1
}
pub fn rust_truncl<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: i32, mut var1: i64, mut var2: i64) {
let mut var3: i32 = 0;
let var4 = self.global0;
var3 = var4.wrapping_sub(16i32);
self.global0 = var3;
self.truncl(imports, var3, var1, var2);
let var5 = self.memory.load64(var3 as usize) as i64;
var1 = var5;
let var6 = self.memory.load64(var3 as usize + 8) as i64;
self.memory.store64(var0 as usize + 8, var6 as u64);
self.memory.store64(var0 as usize, var1 as u64);
self.global0 = var3.wrapping_add(16i32);
}
pub fn rust_j0<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f64) -> f64 {
let var1 = self.j0(imports, var0);
var1
}
pub fn rust_j1<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f64) -> f64 {
let var1 = self.j1(imports, var0);
var1
}
pub fn rust_jn<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: i32, mut var1: f64) -> f64 {
let var2 = self.jn(imports, var0, var1);
var2
}
pub fn rust_y0<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f64) -> f64 {
let var1 = self.y0(imports, var0);
var1
}
pub fn rust_y1<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f64) -> f64 {
let var1 = self.y1(imports, var0);
var1
}
pub fn rust_yn<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: i32, mut var1: f64) -> f64 {
let var2 = self.yn(imports, var0, var1);
var2
}
pub fn rust_drem<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f64, mut var1: f64) -> f64 {
let var2 = self.remainder(imports, var0, var1);
var2
}
pub fn rust_dremf<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f32, mut var1: f32) -> f32 {
let var2 = self.remainderf(imports, var0, var1);
var2
}
pub fn rust_finite<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f64) -> i32 {
let var1 = self.finite(imports, var0);
var1
}
pub fn rust_finitef<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f32) -> i32 {
let var1 = self.finitef(imports, var0);
var1
}
pub fn rust_scalb<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f64, mut var1: f64) -> f64 {
let var2 = self.scalb(imports, var0, var1);
var2
}
pub fn rust_scalbf<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f32, mut var1: f32) -> f32 {
let var2 = self.scalbf(imports, var0, var1);
var2
}
pub fn rust_significand<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f64) -> f64 {
let var1 = self.significand(imports, var0);
var1
}
pub fn rust_significandf<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f32) -> f32 {
let var1 = self.significandf(imports, var0);
var1
}
pub fn rust_lgamma_r<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f64, mut var1: i32) -> f64 {
let var2 = self.___lgamma_r(imports, var0, var1);
var2
}
pub fn rust_lgammaf_r<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f32, mut var1: i32) -> f32 {
let var2 = self.___lgammaf_r(imports, var0, var1);
var2
}
pub fn rust_j0f<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f32) -> f32 {
let var1 = self.j0f(imports, var0);
var1
}
pub fn rust_j1f<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f32) -> f32 {
let var1 = self.j1f(imports, var0);
var1
}
pub fn rust_jnf<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: i32, mut var1: f32) -> f32 {
let var2 = self.jnf(imports, var0, var1);
var2
}
pub fn rust_y0f<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f32) -> f32 {
let var1 = self.y0f(imports, var0);
var1
}
pub fn rust_y1f<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f32) -> f32 {
let var1 = self.y1f(imports, var0);
var1
}
pub fn rust_ynf<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: i32, mut var1: f32) -> f32 {
let var2 = self.ynf(imports, var0, var1);
var2
}
pub fn rust_lgammal_r<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: i32, mut var1: i64, mut var2: i64, mut var3: i32) {
let mut var4: i32 = 0;
let var5 = self.global0;
var4 = var5.wrapping_sub(16i32);
self.global0 = var4;
self.___lgammal_r(imports, var4, var1, var2, var3);
let var6 = self.memory.load64(var4 as usize) as i64;
var1 = var6;
let var7 = self.memory.load64(var4 as usize + 8) as i64;
self.memory.store64(var0 as usize + 8, var7 as u64);
self.memory.store64(var0 as usize, var1 as u64);
self.global0 = var4.wrapping_add(16i32);
}
pub fn rust_sincos<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f64, mut var1: i32, mut var2: i32) {
self.sincos(imports, var0, var1, var2);
}
pub fn rust_sincosf<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f32, mut var1: i32, mut var2: i32) {
self.sincosf(imports, var0, var1, var2);
}
pub fn rust_sincosl<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: i64, mut var1: i64, mut var2: i32, mut var3: i32) {
self.sincosl(imports, var0, var1, var2, var3);
}
pub fn rust_exp10<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f64) -> f64 {
let var1 = self.exp10(imports, var0);
var1
}
pub fn rust_exp10f<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f32) -> f32 {
let var1 = self.exp10f(imports, var0);
var1
}
pub fn rust_exp10l<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: i32, mut var1: i64, mut var2: i64) {
let mut var3: i32 = 0;
let var4 = self.global0;
var3 = var4.wrapping_sub(16i32);
self.global0 = var3;
self.exp10l(imports, var3, var1, var2);
let var5 = self.memory.load64(var3 as usize) as i64;
var1 = var5;
let var6 = self.memory.load64(var3 as usize + 8) as i64;
self.memory.store64(var0 as usize + 8, var6 as u64);
self.memory.store64(var0 as usize, var1 as u64);
self.global0 = var3.wrapping_add(16i32);
}
pub fn rust_pow10<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f64) -> f64 {
let var1 = self.exp10(imports, var0);
var1
}
pub fn rust_pow10f<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f32) -> f32 {
let var1 = self.exp10f(imports, var0);
var1
}
pub fn rust_pow10l<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: i32, mut var1: i64, mut var2: i64) {
let mut var3: i32 = 0;
let var4 = self.global0;
var3 = var4.wrapping_sub(16i32);
self.global0 = var3;
self.exp10l(imports, var3, var1, var2);
let var5 = self.memory.load64(var3 as usize) as i64;
var1 = var5;
let var6 = self.memory.load64(var3 as usize + 8) as i64;
self.memory.store64(var0 as usize + 8, var6 as u64);
self.memory.store64(var0 as usize, var1 as u64);
self.global0 = var3.wrapping_add(16i32);
}
pub fn okok_floor<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f64) -> f64 {
let mut var1: i64 = 0;
let mut var2: i32 = 0;
let mut var3: f64 = 0.0;
'label0: loop {
if (var0 == f64::from_bits(0x0)) as i32 != 0 {
break 'label0;
}
var1 = var0.to_bits() as i64;
var2 = (var1 as u64).wrapping_shr(52i64 as u32) as i64 as i32 & 2047i32;
if (var2 as u32 > 1074i32 as u32) as i32 != 0 {
break 'label0;
}
'label1: loop {
if (var2 as u32 > 1022i32 as u32) as i32 != 0 {
break 'label1;
}
return var1.wrapping_shr(63i64 as u32) as i32 as f64;
break;
}
var3 = ({ let a = var0 + f64::from_bits(0xC330000000000000) + f64::from_bits(0x4330000000000000); let b = var0 + f64::from_bits(0x4330000000000000) + f64::from_bits(0xC330000000000000); if (var1 < 0i64) as i32 != 0 { a } else { b } }) - var0;
var0 = var3 + var0;
if (var3 > f64::from_bits(0x0)) as i32 ^ 1i32 != 0 {
break 'label0;
}
var0 = var0 + f64::from_bits(0xBFF0000000000000);
break;
}
var0
}
fn acos<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f64) -> f64 {
let mut var1: i64 = 0;
let mut var2: i32 = 0;
let mut var3: f64 = 0.0;
let mut var4: f64 = 0.0;
'label0: loop {
'label1: loop {
'label2: loop {
var1 = var0.to_bits() as i64;
var2 = (var1 as u64).wrapping_shr(32i64 as u32) as i64 as i32 & 2147483647i32;
if ((var2 as u32) < 1072693248i32 as u32) as i32 != 0 {
break 'label2;
}
if (var2.wrapping_add(-1072693248i32) | var1 as i32 == 0) as i32 != 0 {
break 'label1;
}
return f64::from_bits(0x0) / (var0 - var0);
break;
}
'label3: loop {
'label4: loop {
if (var2 as u32 > 1071644671i32 as u32) as i32 != 0 {
break 'label4;
}
var3 = f64::from_bits(0x3FF921FB54442D18);
if ((var2 as u32) < 1012924417i32 as u32) as i32 != 0 {
break 'label3;
}
var3 = var0 * var0;
return f64::from_bits(0x3FF921FB54442D18) - (var0 - (f64::from_bits(0x3C91A62633145C07) - var3 * (var3 * (var3 * (var3 * (var3 * (var3 * f64::from_bits(0x3F023DE10DFDF709) + f64::from_bits(0x3F49EFE07501B288)) + f64::from_bits(0xBFA48228B5688F3B)) + f64::from_bits(0x3FC9C1550E884455)) + f64::from_bits(0xBFD4D61203EB6F7D)) + f64::from_bits(0x3FC5555555555555)) / (var3 * (var3 * (var3 * (var3 * f64::from_bits(0x3FB3B8C5B12E9282) + f64::from_bits(0xBFE6066C1B8D0159)) + f64::from_bits(0x40002AE59C598AC8)) + f64::from_bits(0xC0033A271C8A2D4B)) + f64::from_bits(0x3FF0000000000000)) * var0));
break;
}
if (var1 <= -1i64) as i32 != 0 {
break 'label0;
}
var0 = (f64::from_bits(0x3FF0000000000000) - var0) * f64::from_bits(0x3FE0000000000000);
var4 = var0.sqrt();
var3 = f64::from_bits((var4.to_bits() as i64 & -4294967296i64) as u64);
var0 = (var0 - var3 * var3) / (var4 + var3) + var4 * (var0 * (var0 * (var0 * (var0 * (var0 * (var0 * f64::from_bits(0x3F023DE10DFDF709) + f64::from_bits(0x3F49EFE07501B288)) + f64::from_bits(0xBFA48228B5688F3B)) + f64::from_bits(0x3FC9C1550E884455)) + f64::from_bits(0xBFD4D61203EB6F7D)) + f64::from_bits(0x3FC5555555555555)) / (var0 * (var0 * (var0 * (var0 * f64::from_bits(0x3FB3B8C5B12E9282) + f64::from_bits(0xBFE6066C1B8D0159)) + f64::from_bits(0x40002AE59C598AC8)) + f64::from_bits(0xC0033A271C8A2D4B)) + f64::from_bits(0x3FF0000000000000))) + var3;
var3 = var0 + var0;
break;
}
return var3;
break;
}
return { let a = f64::from_bits(0x400921FB54442D18); let b = f64::from_bits(0x0); if (var1 < 0i64) as i32 != 0 { a } else { b } };
break;
}
var0 = (var0 + f64::from_bits(0x3FF0000000000000)) * f64::from_bits(0x3FE0000000000000);
var3 = var0.sqrt();
var0 = f64::from_bits(0x3FF921FB54442D18) - (var3 + (var3 * (var0 * (var0 * (var0 * (var0 * (var0 * (var0 * f64::from_bits(0x3F023DE10DFDF709) + f64::from_bits(0x3F49EFE07501B288)) + f64::from_bits(0xBFA48228B5688F3B)) + f64::from_bits(0x3FC9C1550E884455)) + f64::from_bits(0xBFD4D61203EB6F7D)) + f64::from_bits(0x3FC5555555555555)) / (var0 * (var0 * (var0 * (var0 * f64::from_bits(0x3FB3B8C5B12E9282) + f64::from_bits(0xBFE6066C1B8D0159)) + f64::from_bits(0x40002AE59C598AC8)) + f64::from_bits(0xC0033A271C8A2D4B)) + f64::from_bits(0x3FF0000000000000))) + f64::from_bits(0xBC91A62633145C07)));
var0 + var0
}
fn acosf<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f32) -> f32 {
let mut var1: i32 = 0;
let mut var2: i32 = 0;
let mut var3: f32 = 0.0;
let mut var4: f32 = 0.0;
'label0: loop {
'label1: loop {
'label2: loop {
'label3: loop {
'label4: loop {
var1 = var0.to_bits() as i32;
var2 = var1 & 2147483647i32;
if ((var2 as u32) < 1065353216i32 as u32) as i32 != 0 {
break 'label4;
}
if (var2 != 1065353216i32) as i32 != 0 {
break 'label3;
}
return { let a = f32::from_bits(0x40490FDA); let b = f32::from_bits(0x0); if (var1 < 0i32) as i32 != 0 { a } else { b } };
break;
}
if (var2 as u32 > 1056964607i32 as u32) as i32 != 0 {
break 'label2;
}
var3 = f32::from_bits(0x3FC90FDA);
if ((var2 as u32) < 847249409i32 as u32) as i32 != 0 {
break 'label1;
}
var3 = var0 * var0;
return f32::from_bits(0x3FC90FDA) - (var0 - (f32::from_bits(0x33A22168) - var3 * (var3 * (var3 * f32::from_bits(0xBC0DD36B) + f32::from_bits(0xBD2F13BA)) + f32::from_bits(0x3E2AAA75)) / (var3 * f32::from_bits(0xBF34E5AE) + f32::from_bits(0x3F800000)) * var0));
break;
}
return f32::from_bits(0x0) / (var0 - var0);
break;
}
if (var1 <= -1i32) as i32 != 0 {
break 'label0;
}
var0 = (f32::from_bits(0x3F800000) - var0) * f32::from_bits(0x3F000000);
var4 = var0.sqrt();
var3 = f32::from_bits((var4.to_bits() as i32 & -4096i32) as u32);
var0 = var4 * (var0 * (var0 * (var0 * f32::from_bits(0xBC0DD36B) + f32::from_bits(0xBD2F13BA)) + f32::from_bits(0x3E2AAA75)) / (var0 * f32::from_bits(0xBF34E5AE) + f32::from_bits(0x3F800000))) + (var0 - var3 * var3) / (var4 + var3) + var3;
var3 = var0 + var0;
break;
}
return var3;
break;
}
var0 = (var0 + f32::from_bits(0x3F800000)) * f32::from_bits(0x3F000000);
var3 = var0.sqrt();
var0 = f32::from_bits(0x3FC90FDA) - (var3 + (var3 * (var0 * (var0 * (var0 * f32::from_bits(0xBC0DD36B) + f32::from_bits(0xBD2F13BA)) + f32::from_bits(0x3E2AAA75)) / (var0 * f32::from_bits(0xBF34E5AE) + f32::from_bits(0x3F800000))) + f32::from_bits(0xB3A22168)));
var0 + var0
}
fn acosh<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f64) -> f64 {
let mut var1: i32 = 0;
'label0: loop {
var1 = (var0.to_bits() as i64 as u64).wrapping_shr(52i64 as u32) as i64 as i32 & 2047i32;
if (var1 as u32 > 1023i32 as u32) as i32 != 0 {
break 'label0;
}
var0 = var0 + f64::from_bits(0xBFF0000000000000);
let var2 = self.log1p(imports, var0 + (var0 * var0 + (var0 + var0)).sqrt());
return var2;
break;
}
'label1: loop {
if (var1 as u32 > 1048i32 as u32) as i32 != 0 {
break 'label1;
}
let var3 = self.log(imports, var0 + var0 + f64::from_bits(0xBFF0000000000000) / ((var0 * var0 + f64::from_bits(0xBFF0000000000000)).sqrt() + var0));
return var3;
break;
}
let var4 = self.log(imports, var0);
var4 + f64::from_bits(0x3FE62E42FEFA39EF)
}
fn acoshf<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: f32) -> f32 {
let mut var1: i32 = 0;
'label0: loop {
var1 = var0.to_bits() as i32 & 2147483647i32;
if (var1 as u32 > 1073741823i32 as u32) as i32 != 0 {
break 'label0;
}
var0 = var0 + f32::from_bits(0xBF800000);
let var2 = self.log1pf(imports, var0 + (var0 * var0 + (var0 + var0)).sqrt());
return var2;
break;
}
'label1: loop {
if (var1 as u32 > 1166016511i32 as u32) as i32 != 0 {
break 'label1;
}
let var3 = self.logf(imports, var0 + var0 + f32::from_bits(0xBF800000) / ((var0 * var0 + f32::from_bits(0xBF800000)).sqrt() + var0));
return var3;
break;
}
let var4 = self.logf(imports, var0);
var4 + f32::from_bits(0x3F317218)
}
fn acoshl<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: i32, mut var1: i64, mut var2: i64) {
let mut var3: i32 = 0;
let mut var4: i32 = 0;
let var5 = self.global0;
var3 = var5.wrapping_sub(272i32);
self.global0 = var3;
'label0: loop {
'label1: loop {
var4 = var2 as i32 & 32767i32;
if (var4 as u32 > 16383i32 as u32) as i32 != 0 {
break 'label1;
}
self.___addtf3(imports, var3.wrapping_add(80i32), var1, var2, 0i64, -4611967493404098560i64);
let var6 = self.memory.load64(var3 as usize + 80) as i64;
var2 = var6;
let var7 = self.memory.load64(var3.wrapping_add(80i32).wrapping_add(8i32) as usize) as i64;
var1 = var7;
self.___addtf3(imports, var3.wrapping_add(48i32), var2, var1, var2, var1);
self.___multf3(imports, var3.wrapping_add(64i32), var2, var1, var2, var1);
let var8 = self.memory.load64(var3 as usize + 64) as i64;
let var9 = self.memory.load64(var3.wrapping_add(64i32).wrapping_add(8i32) as usize) as i64;
let var10 = self.memory.load64(var3 as usize + 48) as i64;
let var11 = self.memory.load64(var3.wrapping_add(48i32).wrapping_add(8i32) as usize) as i64;
self.___addtf3(imports, var3.wrapping_add(32i32), var8, var9, var10, var11);
let var12 = self.memory.load64(var3 as usize + 32) as i64;
let var13 = self.memory.load64(var3.wrapping_add(32i32).wrapping_add(8i32) as usize) as i64;
self.sqrtl(imports, var3.wrapping_add(16i32), var12, var13);
let var14 = self.memory.load64(var3 as usize + 16) as i64;
let var15 = self.memory.load64(var3.wrapping_add(16i32).wrapping_add(8i32) as usize) as i64;
self.___addtf3(imports, var3, var2, var1, var14, var15);
let var16 = self.memory.load64(var3 as usize) as i64;
let var17 = self.memory.load64(var3.wrapping_add(8i32) as usize) as i64;
self.log1pl(imports, var3.wrapping_add(96i32), var16, var17);
let var18 = self.memory.load64(var3 as usize + 104) as i64;
var2 = var18;
let var19 = self.memory.load64(var3 as usize + 96) as i64;
var1 = var19;
break 'label0;
break;
}
'label2: loop {
if (var4 as u32 > 16414i32 as u32) as i32 != 0 {
break 'label2;
}
self.___multf3(imports, var3.wrapping_add(224i32), var1, var2, var1, var2);
let var20 = self.memory.load64(var3 as usize + 224) as i64;
let var21 = self.memory.load64(var3.wrapping_add(224i32).wrapping_add(8i32) as usize) as i64;
self.___addtf3(imports, var3.wrapping_add(208i32), var20, var21, 0i64, -4611967493404098560i64);
let var22 = self.memory.load64(var3 as usize + 208) as i64;
let var23 = self.memory.load64(var3.wrapping_add(208i32).wrapping_add(8i32) as usize) as i64;
self.sqrtl(imports, var3.wrapping_add(192i32), var22, var23);
let var24 = self.memory.load64(var3 as usize + 192) as i64;
let var25 = self.memory.load64(var3.wrapping_add(192i32).wrapping_add(8i32) as usize) as i64;
self.___addtf3(imports, var3.wrapping_add(176i32), var24, var25, var1, var2);
let var26 = self.memory.load64(var3 as usize + 176) as i64;
let var27 = self.memory.load64(var3.wrapping_add(176i32).wrapping_add(8i32) as usize) as i64;
self.___divtf3(imports, var3.wrapping_add(160i32), 0i64, -4611967493404098560i64, var26, var27);
self.___addtf3(imports, var3.wrapping_add(144i32), var1, var2, var1, var2);
let var28 = self.memory.load64(var3 as usize + 144) as i64;
let var29 = self.memory.load64(var3.wrapping_add(144i32).wrapping_add(8i32) as usize) as i64;
let var30 = self.memory.load64(var3 as usize + 160) as i64;
let var31 = self.memory.load64(var3.wrapping_add(160i32).wrapping_add(8i32) as usize) as i64;
self.___addtf3(imports, var3.wrapping_add(128i32), var28, var29, var30, var31);
let var32 = self.memory.load64(var3 as usize + 128) as i64;
let var33 = self.memory.load64(var3.wrapping_add(128i32).wrapping_add(8i32) as usize) as i64;
self.logl(imports, var3.wrapping_add(112i32), var32, var33);
let var34 = self.memory.load64(var3.wrapping_add(112i32).wrapping_add(8i32) as usize) as i64;
var2 = var34;
let var35 = self.memory.load64(var3 as usize + 112) as i64;
var1 = var35;
break 'label0;
break;
}
self.logl(imports, var3.wrapping_add(256i32), var1, var2);
let var36 = self.memory.load64(var3 as usize + 256) as i64;
let var37 = self.memory.load64(var3.wrapping_add(256i32).wrapping_add(8i32) as usize) as i64;
self.___addtf3(imports, var3.wrapping_add(240i32), var36, var37, -912097914880260122i64, 4611231800670266270i64);
let var38 = self.memory.load64(var3.wrapping_add(240i32).wrapping_add(8i32) as usize) as i64;
var2 = var38;
let var39 = self.memory.load64(var3 as usize + 240) as i64;
var1 = var39;
break;
}
self.memory.store64(var0 as usize, var1 as u64);
self.memory.store64(var0 as usize + 8, var2 as u64);
self.global0 = var3.wrapping_add(272i32);
}
fn ___invtrigl_R<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: i32, mut var1: i64, mut var2: i64) {
let mut var3: i32 = 0;
let var4 = self.global0;
var3 = var4.wrapping_sub(384i32);
self.global0 = var3;
self.___multf3(imports, var3.wrapping_add(208i32), var1, var2, -3269049007530446212i64, -4616791241850225810i64);
let var5 = self.memory.load64(var3 as usize + 208) as i64;
let var6 = self.memory.load64(var3.wrapping_add(208i32).wrapping_add(8i32) as usize) as i64;
self.___addtf3(imports, var3.wrapping_add(192i32), var5, var6, -6838732663412819884i64, -4615402664409156920i64);
let var7 = self.memory.load64(var3 as usize + 192) as i64;
let var8 = self.memory.load64(var3.wrapping_add(192i32).wrapping_add(8i32) as usize) as i64;
self.___multf3(imports, var3.wrapping_add(176i32), var7, var8, var1, var2);
self.___multf3(imports, var3.wrapping_add(368i32), var1, var2, -2689208353081412596i64, -4613373187811247847i64);
let var9 = self.memory.load64(var3 as usize + 176) as i64;
let var10 = self.memory.load64(var3.wrapping_add(176i32).wrapping_add(8i32) as usize) as i64;
self.___addtf3(imports, var3.wrapping_add(160i32), var9, var10, -128350042679704000i64, 4609755458915431543i64);
let var11 = self.memory.load64(var3 as usize + 368) as i64;
let var12 = self.memory.load64(var3.wrapping_add(368i32).wrapping_add(8i32) as usize) as i64;
self.___addtf3(imports, var3.wrapping_add(352i32), var11, var12, -6814516473677417138i64, 4611000006952842081i64);
let var13 = self.memory.load64(var3 as usize + 160) as i64;
let var14 = self.memory.load64(var3.wrapping_add(160i32).wrapping_add(8i32) as usize) as i64;
self.___multf3(imports, var3.wrapping_add(144i32), var13, var14, var1, var2);
let var15 = self.memory.load64(var3 as usize + 352) as i64;
let var16 = self.memory.load64(var3.wrapping_add(352i32).wrapping_add(8i32) as usize) as i64;
self.___multf3(imports, var3.wrapping_add(336i32), var15, var16, var1, var2);
let var17 = self.memory.load64(var3 as usize + 144) as i64;
let var18 = self.memory.load64(var3.wrapping_add(144i32).wrapping_add(8i32) as usize) as i64;
self.___addtf3(imports, var3.wrapping_add(128i32), var17, var18, 439679652337631173i64, -4612786666804204557i64);
let var19 = self.memory.load64(var3 as usize + 336) as i64;
let var20 = self.memory.load64(var3.wrapping_add(336i32).wrapping_add(8i32) as usize) as i64;
self.___addtf3(imports, var3.wrapping_add(320i32), var19, var20, -7469202038914379878i64, -4611775285964860514i64);
let var21 = self.memory.load64(var3 as usize + 128) as i64;
let var22 = self.memory.load64(var3.wrapping_add(128i32).wrapping_add(8i32) as usize) as i64;
self.___multf3(imports, var3.wrapping_add(112i32), var21, var22, var1, var2);
let var23 = self.memory.load64(var3 as usize + 320) as i64;
let var24 = self.memory.load64(var3.wrapping_add(320i32).wrapping_add(8i32) as usize) as i64;
self.___multf3(imports, var3.wrapping_add(304i32), var23, var24, var1, var2);
let var25 = self.memory.load64(var3 as usize + 112) as i64;
let var26 = self.memory.load64(var3.wrapping_add(112i32).wrapping_add(8i32) as usize) as i64;
self.___addtf3(imports, var3.wrapping_add(96i32), var25, var26, -3198126544380142596i64, 4610975652199519212i64);
let var27 = self.memory.load64(var3 as usize + 304) as i64;
let var28 = self.memory.load64(var3.wrapping_add(304i32).wrapping_add(8i32) as usize) as i64;
self.___addtf3(imports, var3.wrapping_add(288i32), var27, var28, -7470912995925850299i64, 4611865191169376940i64);
let var29 = self.memory.load64(var3 as usize + 96) as i64;
let var30 = self.memory.load64(var3.wrapping_add(96i32).wrapping_add(8i32) as usize) as i64;
self.___multf3(imports, var3.wrapping_add(80i32), var29, var30, var1, var2);
let var31 = self.memory.load64(var3 as usize + 288) as i64;
let var32 = self.memory.load64(var3.wrapping_add(288i32).wrapping_add(8i32) as usize) as i64;
self.___multf3(imports, var3.wrapping_add(272i32), var31, var32, var1, var2);
let var33 = self.memory.load64(var3 as usize + 80) as i64;
let var34 = self.memory.load64(var3.wrapping_add(80i32).wrapping_add(8i32) as usize) as i64;
self.___addtf3(imports, var3.wrapping_add(64i32), var33, var34, 1726004020292912777i64, -4612343190453931159i64);
let var35 = self.memory.load64(var3 as usize + 272) as i64;
let var36 = self.memory.load64(var3.wrapping_add(272i32).wrapping_add(8i32) as usize) as i64;
self.___addtf3(imports, var3.wrapping_add(256i32), var35, var36, 7872285303054864592i64, -4611552615624114136i64);
let var37 = self.memory.load64(var3 as usize + 64) as i64;
let var38 = self.memory.load64(var3.wrapping_add(64i32).wrapping_add(8i32) as usize) as i64;
self.___multf3(imports, var3.wrapping_add(48i32), var37, var38, var1, var2);
let var39 = self.memory.load64(var3 as usize + 256) as i64;
let var40 = self.memory.load64(var3.wrapping_add(256i32).wrapping_add(8i32) as usize) as i64;
self.___multf3(imports, var3.wrapping_add(240i32), var39, var40, var1, var2);
let var41 = self.memory.load64(var3 as usize + 48) as i64;
let var42 = self.memory.load64(var3.wrapping_add(48i32).wrapping_add(8i32) as usize) as i64;
self.___addtf3(imports, var3.wrapping_add(32i32), var41, var42, 6147433155866215268i64, 4610653943512782165i64);
let var43 = self.memory.load64(var3 as usize + 240) as i64;
let var44 = self.memory.load64(var3.wrapping_add(240i32).wrapping_add(8i32) as usize) as i64;
self.___addtf3(imports, var3.wrapping_add(224i32), var43, var44, 0i64, 4611404543450677248i64);
let var45 = self.memory.load64(var3 as usize + 32) as i64;
let var46 = self.memory.load64(var3.wrapping_add(32i32).wrapping_add(8i32) as usize) as i64;
self.___multf3(imports, var3.wrapping_add(16i32), var45, var46, var1, var2);
let var47 = self.memory.load64(var3 as usize + 16) as i64;
let var48 = self.memory.load64(var3.wrapping_add(16i32).wrapping_add(8i32) as usize) as i64;
let var49 = self.memory.load64(var3 as usize + 224) as i64;
let var50 = self.memory.load64(var3.wrapping_add(224i32).wrapping_add(8i32) as usize) as i64;
self.___divtf3(imports, var3, var47, var48, var49, var50);
let var51 = self.memory.load64(var3.wrapping_add(8i32) as usize) as i64;
self.memory.store64(var0 as usize + 8, var51 as u64);
let var52 = self.memory.load64(var3 as usize) as i64;
self.memory.store64(var0 as usize, var52 as u64);
self.global0 = var3.wrapping_add(384i32);
}
fn acosl<I: Imports<Memory = M>>(&mut self, imports: &mut I, mut var0: i32, mut var1: i64, mut var2: i64) {
let mut var3: i32 = 0;
let mut var4: i32 = 0;
let mut var5: i64 = 0;
let mut var6: i64 = 0;
let mut var7: i64 = 0;
let var8 = self.global0;
var3 = var8.wrapping_sub(512i32);
self.global0 = var3;
'label0: loop {
'label1: loop {
'label2: loop {