Package

// Move bytecode v6
module 1.address {

public length(): u64 {
B0:
	0: LdU64(32)
	1: Ret
}

}

// Move bytecode v6
module 1.ascii {
use 0000000000000000000000000000000000000000000000000000000000000001::option;
use 0000000000000000000000000000000000000000000000000000000000000001::vector;

struct String has copy, drop, store {
	bytes: vector<u8>
}

struct Char has copy, drop, store {
	byte: u8
}

public char(Arg0: u8): Char {
B0:
	0: CopyLoc[0](Arg0: u8)
	1: Call is_valid_char(u8): bool
	2: BrFalse(4)
B1:
	3: Branch(6)
B2:
	4: LdConst[0](u64: 65536)
	5: Abort
B3:
	6: MoveLoc[0](Arg0: u8)
	7: Pack[1](Char)
	8: Ret
}

public string(Arg0: vector<u8>): String {
L1:	loc0: Option<String>
B0:
	0: MoveLoc[0](Arg0: vector<u8>)
	1: Call try_string(vector<u8>): Option<String>
	2: StLoc[1](loc0: Option<String>)
	3: ImmBorrowLoc[1](loc0: Option<String>)
	4: Call option::is_some<String>(&Option<String>): bool
	5: BrFalse(7)
B1:
	6: Branch(9)
B2:
	7: LdConst[0](u64: 65536)
	8: Abort
B3:
	9: MoveLoc[1](loc0: Option<String>)
	10: Call option::destroy_some<String>(Option<String>): String
	11: Ret
}

public try_string(Arg0: vector<u8>): Option<String> {
L1:	loc0: u64
L2:	loc1: bool
L3:	loc2: Option<String>
L4:	loc3: u64
L5:	loc4: u64
L6:	loc5: u64
L7:	loc6: &vector<u8>
B0:
	0: ImmBorrowLoc[0](Arg0: vector<u8>)
	1: StLoc[7](loc6: &vector<u8>)
	2: CopyLoc[7](loc6: &vector<u8>)
	3: VecLen(0)
	4: StLoc[1](loc0: u64)
	5: LdU64(0)
	6: StLoc[5](loc4: u64)
	7: MoveLoc[1](loc0: u64)
	8: StLoc[6](loc5: u64)
B1:
	9: CopyLoc[5](loc4: u64)
	10: CopyLoc[6](loc5: u64)
	11: Lt
	12: BrFalse(32)
B2:
	13: CopyLoc[5](loc4: u64)
	14: StLoc[4](loc3: u64)
	15: CopyLoc[7](loc6: &vector<u8>)
	16: MoveLoc[4](loc3: u64)
	17: VecImmBorrow(0)
	18: ReadRef
	19: Call is_valid_char(u8): bool
	20: Not
	21: BrFalse(27)
B3:
	22: MoveLoc[7](loc6: &vector<u8>)
	23: Pop
	24: LdFalse
	25: StLoc[2](loc1: bool)
	26: Branch(36)
B4:
	27: MoveLoc[5](loc4: u64)
	28: LdU64(1)
	29: Add
	30: StLoc[5](loc4: u64)
	31: Branch(9)
B5:
	32: MoveLoc[7](loc6: &vector<u8>)
	33: Pop
	34: LdTrue
	35: StLoc[2](loc1: bool)
B6:
	36: MoveLoc[2](loc1: bool)
	37: BrFalse(43)
B7:
	38: MoveLoc[0](Arg0: vector<u8>)
	39: Pack[0](String)
	40: Call option::some<String>(String): Option<String>
	41: StLoc[3](loc2: Option<String>)
	42: Branch(45)
B8:
	43: Call option::none<String>(): Option<String>
	44: StLoc[3](loc2: Option<String>)
B9:
	45: MoveLoc[3](loc2: Option<String>)
	46: Ret
}

public all_characters_printable(Arg0: &String): bool {
L1:	loc0: u64
L2:	loc1: bool
L3:	loc2: u64
L4:	loc3: u64
L5:	loc4: u64
L6:	loc5: &vector<u8>
B0:
	0: MoveLoc[0](Arg0: &String)
	1: ImmBorrowField[0](String.bytes: vector<u8>)
	2: StLoc[6](loc5: &vector<u8>)
	3: CopyLoc[6](loc5: &vector<u8>)
	4: VecLen(0)
	5: StLoc[1](loc0: u64)
	6: LdU64(0)
	7: StLoc[4](loc3: u64)
	8: MoveLoc[1](loc0: u64)
	9: StLoc[5](loc4: u64)
B1:
	10: CopyLoc[4](loc3: u64)
	11: CopyLoc[5](loc4: u64)
	12: Lt
	13: BrFalse(33)
B2:
	14: CopyLoc[4](loc3: u64)
	15: StLoc[3](loc2: u64)
	16: CopyLoc[6](loc5: &vector<u8>)
	17: MoveLoc[3](loc2: u64)
	18: VecImmBorrow(0)
	19: ReadRef
	20: Call is_printable_char(u8): bool
	21: Not
	22: BrFalse(28)
B3:
	23: MoveLoc[6](loc5: &vector<u8>)
	24: Pop
	25: LdFalse
	26: StLoc[2](loc1: bool)
	27: Branch(37)
B4:
	28: MoveLoc[4](loc3: u64)
	29: LdU64(1)
	30: Add
	31: StLoc[4](loc3: u64)
	32: Branch(10)
B5:
	33: MoveLoc[6](loc5: &vector<u8>)
	34: Pop
	35: LdTrue
	36: StLoc[2](loc1: bool)
B6:
	37: MoveLoc[2](loc1: bool)
	38: Ret
}

public push_char(Arg0: &mut String, Arg1: Char) {
B0:
	0: MoveLoc[0](Arg0: &mut String)
	1: MutBorrowField[0](String.bytes: vector<u8>)
	2: ImmBorrowLoc[1](Arg1: Char)
	3: ImmBorrowField[1](Char.byte: u8)
	4: ReadRef
	5: VecPushBack(0)
	6: Ret
}

public pop_char(Arg0: &mut String): Char {
B0:
	0: MoveLoc[0](Arg0: &mut String)
	1: MutBorrowField[0](String.bytes: vector<u8>)
	2: VecPopBack(0)
	3: Pack[1](Char)
	4: Ret
}

public length(Arg0: &String): u64 {
B0:
	0: MoveLoc[0](Arg0: &String)
	1: Call as_bytes(&String): &vector<u8>
	2: VecLen(0)
	3: Ret
}

public append(Arg0: &mut String, Arg1: String) {
B0:
	0: MoveLoc[0](Arg0: &mut String)
	1: MutBorrowField[0](String.bytes: vector<u8>)
	2: MoveLoc[1](Arg1: String)
	3: Call into_bytes(String): vector<u8>
	4: Call vector::append<u8>(&mut vector<u8>, vector<u8>)
	5: Ret
}

public insert(Arg0: &mut String, Arg1: u64, Arg2: String) {
L3:	loc0: u64
L4:	loc1: u8
L5:	loc2: u64
L6:	loc3: u64
L7:	loc4: vector<u8>
B0:
	0: CopyLoc[1](Arg1: u64)
	1: CopyLoc[0](Arg0: &mut String)
	2: FreezeRef
	3: Call length(&String): u64
	4: Le
	5: BrFalse(7)
B1:
	6: Branch(11)
B2:
	7: MoveLoc[0](Arg0: &mut String)
	8: Pop
	9: LdConst[1](u64: 65537)
	10: Abort
B3:
	11: MoveLoc[2](Arg2: String)
	12: Call into_bytes(String): vector<u8>
	13: StLoc[7](loc4: vector<u8>)
	14: ImmBorrowLoc[7](loc4: vector<u8>)
	15: VecLen(0)
	16: StLoc[3](loc0: u64)
	17: LdU64(0)
	18: StLoc[5](loc2: u64)
	19: MoveLoc[3](loc0: u64)
	20: StLoc[6](loc3: u64)
B4:
	21: CopyLoc[5](loc2: u64)
	22: CopyLoc[6](loc3: u64)
	23: Lt
	24: BrFalse(40)
B5:
	25: CopyLoc[5](loc2: u64)
	26: Pop
	27: MutBorrowLoc[7](loc4: vector<u8>)
	28: VecPopBack(0)
	29: StLoc[4](loc1: u8)
	30: CopyLoc[0](Arg0: &mut String)
	31: MutBorrowField[0](String.bytes: vector<u8>)
	32: MoveLoc[4](loc1: u8)
	33: CopyLoc[1](Arg1: u64)
	34: Call vector::insert<u8>(&mut vector<u8>, u8, u64)
	35: MoveLoc[5](loc2: u64)
	36: LdU64(1)
	37: Add
	38: StLoc[5](loc2: u64)
	39: Branch(21)
B6:
	40: MoveLoc[0](Arg0: &mut String)
	41: Pop
	42: MoveLoc[7](loc4: vector<u8>)
	43: VecUnpack(0, 0)
	44: Ret
}

public substring(Arg0: &String, Arg1: u64, Arg2: u64): String {
L3:	loc0: bool
L4:	loc1: vector<u8>
L5:	loc2: u64
L6:	loc3: u64
L7:	loc4: u64
B0:
	0: CopyLoc[1](Arg1: u64)
	1: CopyLoc[2](Arg2: u64)
	2: Le
	3: BrFalse(10)
B1:
	4: CopyLoc[2](Arg2: u64)
	5: CopyLoc[0](Arg0: &String)
	6: Call length(&String): u64
	7: Le
	8: StLoc[3](loc0: bool)
	9: Branch(12)
B2:
	10: LdFalse
	11: StLoc[3](loc0: bool)
B3:
	12: MoveLoc[3](loc0: bool)
	13: BrFalse(15)
B4:
	14: Branch(19)
B5:
	15: MoveLoc[0](Arg0: &String)
	16: Pop
	17: LdConst[1](u64: 65537)
	18: Abort
B6:
	19: LdConst[2](vector<u8>: "" /..)
	20: StLoc[4](loc1: vector<u8>)
	21: MoveLoc[1](Arg1: u64)
	22: StLoc[5](loc2: u64)
	23: MoveLoc[2](Arg2: u64)
	24: StLoc[7](loc4: u64)
B7:
	25: CopyLoc[5](loc2: u64)
	26: CopyLoc[7](loc4: u64)
	27: Lt
	28: BrFalse(43)
B8:
	29: CopyLoc[5](loc2: u64)
	30: StLoc[6](loc3: u64)
	31: MutBorrowLoc[4](loc1: vector<u8>)
	32: CopyLoc[0](Arg0: &String)
	33: ImmBorrowField[0](String.bytes: vector<u8>)
	34: MoveLoc[6](loc3: u64)
	35: VecImmBorrow(0)
	36: ReadRef
	37: VecPushBack(0)
	38: MoveLoc[5](loc2: u64)
	39: LdU64(1)
	40: Add
	41: StLoc[5](loc2: u64)
	42: Branch(25)
B9:
	43: MoveLoc[0](Arg0: &String)
	44: Pop
	45: MoveLoc[4](loc1: vector<u8>)
	46: Pack[0](String)
	47: Ret
}

public as_bytes(Arg0: &String): &vector<u8> {
B0:
	0: MoveLoc[0](Arg0: &String)
	1: ImmBorrowField[0](String.bytes: vector<u8>)
	2: Ret
}

public into_bytes(Arg0: String): vector<u8> {
B0:
	0: MoveLoc[0](Arg0: String)
	1: Unpack[0](String)
	2: Ret
}

public byte(Arg0: Char): u8 {
B0:
	0: MoveLoc[0](Arg0: Char)
	1: Unpack[1](Char)
	2: Ret
}

public is_valid_char(Arg0: u8): bool {
B0:
	0: MoveLoc[0](Arg0: u8)
	1: LdU8(127)
	2: Le
	3: Ret
}

public is_printable_char(Arg0: u8): bool {
L1:	loc0: bool
B0:
	0: CopyLoc[0](Arg0: u8)
	1: LdU8(32)
	2: Ge
	3: BrFalse(9)
B1:
	4: MoveLoc[0](Arg0: u8)
	5: LdU8(126)
	6: Le
	7: StLoc[1](loc0: bool)
	8: Branch(11)
B2:
	9: LdFalse
	10: StLoc[1](loc0: bool)
B3:
	11: MoveLoc[1](loc0: bool)
	12: Ret
}

public is_empty(Arg0: &String): bool {
B0:
	0: MoveLoc[0](Arg0: &String)
	1: ImmBorrowField[0](String.bytes: vector<u8>)
	2: Call vector::is_empty<u8>(&vector<u8>): bool
	3: Ret
}

public to_uppercase(Arg0: &String): String {
L1:	loc0: u64
L2:	loc1: u8
L3:	loc2: &mut vector<u8>
L4:	loc3: &u8
L5:	loc4: u64
L6:	loc5: u64
L7:	loc6: vector<u8>
L8:	loc7: u64
L9:	loc8: &vector<u8>
L10:	loc9: &vector<u8>
B0:
	0: MoveLoc[0](Arg0: &String)
	1: Call as_bytes(&String): &vector<u8>
	2: StLoc[9](loc8: &vector<u8>)
	3: LdConst[2](vector<u8>: "" /..)
	4: StLoc[7](loc6: vector<u8>)
	5: MoveLoc[9](loc8: &vector<u8>)
	6: StLoc[10](loc9: &vector<u8>)
	7: CopyLoc[10](loc9: &vector<u8>)
	8: VecLen(0)
	9: StLoc[1](loc0: u64)
	10: LdU64(0)
	11: StLoc[6](loc5: u64)
	12: MoveLoc[1](loc0: u64)
	13: StLoc[8](loc7: u64)
B1:
	14: CopyLoc[6](loc5: u64)
	15: CopyLoc[8](loc7: u64)
	16: Lt
	17: BrFalse(38)
B2:
	18: CopyLoc[6](loc5: u64)
	19: StLoc[5](loc4: u64)
	20: CopyLoc[10](loc9: &vector<u8>)
	21: MoveLoc[5](loc4: u64)
	22: VecImmBorrow(0)
	23: StLoc[4](loc3: &u8)
	24: MutBorrowLoc[7](loc6: vector<u8>)
	25: StLoc[3](loc2: &mut vector<u8>)
	26: MoveLoc[4](loc3: &u8)
	27: ReadRef
	28: Call char_to_uppercase(u8): u8
	29: StLoc[2](loc1: u8)
	30: MoveLoc[3](loc2: &mut vector<u8>)
	31: MoveLoc[2](loc1: u8)
	32: VecPushBack(0)
	33: MoveLoc[6](loc5: u64)
	34: LdU64(1)
	35: Add
	36: StLoc[6](loc5: u64)
	37: Branch(14)
B3:
	38: MoveLoc[10](loc9: &vector<u8>)
	39: Pop
	40: MoveLoc[7](loc6: vector<u8>)
	41: Pack[0](String)
	42: Ret
}

public to_lowercase(Arg0: &String): String {
L1:	loc0: u64
L2:	loc1: u8
L3:	loc2: &mut vector<u8>
L4:	loc3: &u8
L5:	loc4: u64
L6:	loc5: u64
L7:	loc6: vector<u8>
L8:	loc7: u64
L9:	loc8: &vector<u8>
L10:	loc9: &vector<u8>
B0:
	0: MoveLoc[0](Arg0: &String)
	1: Call as_bytes(&String): &vector<u8>
	2: StLoc[9](loc8: &vector<u8>)
	3: LdConst[2](vector<u8>: "" /..)
	4: StLoc[7](loc6: vector<u8>)
	5: MoveLoc[9](loc8: &vector<u8>)
	6: StLoc[10](loc9: &vector<u8>)
	7: CopyLoc[10](loc9: &vector<u8>)
	8: VecLen(0)
	9: StLoc[1](loc0: u64)
	10: LdU64(0)
	11: StLoc[6](loc5: u64)
	12: MoveLoc[1](loc0: u64)
	13: StLoc[8](loc7: u64)
B1:
	14: CopyLoc[6](loc5: u64)
	15: CopyLoc[8](loc7: u64)
	16: Lt
	17: BrFalse(38)
B2:
	18: CopyLoc[6](loc5: u64)
	19: StLoc[5](loc4: u64)
	20: CopyLoc[10](loc9: &vector<u8>)
	21: MoveLoc[5](loc4: u64)
	22: VecImmBorrow(0)
	23: StLoc[4](loc3: &u8)
	24: MutBorrowLoc[7](loc6: vector<u8>)
	25: StLoc[3](loc2: &mut vector<u8>)
	26: MoveLoc[4](loc3: &u8)
	27: ReadRef
	28: Call char_to_lowercase(u8): u8
	29: StLoc[2](loc1: u8)
	30: MoveLoc[3](loc2: &mut vector<u8>)
	31: MoveLoc[2](loc1: u8)
	32: VecPushBack(0)
	33: MoveLoc[6](loc5: u64)
	34: LdU64(1)
	35: Add
	36: StLoc[6](loc5: u64)
	37: Branch(14)
B3:
	38: MoveLoc[10](loc9: &vector<u8>)
	39: Pop
	40: MoveLoc[7](loc6: vector<u8>)
	41: Pack[0](String)
	42: Ret
}

public index_of(Arg0: &String, Arg1: &String): u64 {
L2:	loc0: bool
L3:	loc1: u64
L4:	loc2: u64
L5:	loc3: u64
L6:	loc4: u64
B0:
	0: LdU64(0)
	1: StLoc[3](loc1: u64)
	2: CopyLoc[0](Arg0: &String)
	3: Call length(&String): u64
	4: CopyLoc[1](Arg1: &String)
	5: Call length(&String): u64
	6: StLoc[5](loc3: u64)
	7: StLoc[6](loc4: u64)
	8: CopyLoc[6](loc4: u64)
	9: CopyLoc[5](loc3: u64)
	10: Lt
	11: BrFalse(18)
B1:
	12: MoveLoc[1](Arg1: &String)
	13: Pop
	14: MoveLoc[0](Arg0: &String)
	15: Pop
	16: MoveLoc[6](loc4: u64)
	17: Ret
B2:
	18: CopyLoc[3](loc1: u64)
	19: CopyLoc[6](loc4: u64)
	20: CopyLoc[5](loc3: u64)
	21: Sub
	22: Le
	23: BrFalse(71)
B3:
	24: LdU64(0)
	25: StLoc[4](loc2: u64)
B4:
	26: CopyLoc[4](loc2: u64)
	27: CopyLoc[5](loc3: u64)
	28: Lt
	29: BrFalse(46)
B5:
	30: Branch(31)
B6:
	31: CopyLoc[0](Arg0: &String)
	32: ImmBorrowField[0](String.bytes: vector<u8>)
	33: CopyLoc[3](loc1: u64)
	34: CopyLoc[4](loc2: u64)
	35: Add
	36: VecImmBorrow(0)
	37: ReadRef
	38: CopyLoc[1](Arg1: &String)
	39: ImmBorrowField[0](String.bytes: vector<u8>)
	40: CopyLoc[4](loc2: u64)
	41: VecImmBorrow(0)
	42: ReadRef
	43: Eq
	44: StLoc[2](loc0: bool)
	45: Branch(49)
B7:
	46: LdFalse
	47: StLoc[2](loc0: bool)
	48: Branch(49)
B8:
	49: MoveLoc[2](loc0: bool)
	50: BrFalse(56)
B9:
	51: MoveLoc[4](loc2: u64)
	52: LdU64(1)
	53: Add
	54: StLoc[4](loc2: u64)
	55: Branch(26)
B10:
	56: MoveLoc[4](loc2: u64)
	57: CopyLoc[5](loc3: u64)
	58: Eq
	59: BrFalse(66)
B11:
	60: MoveLoc[1](Arg1: &String)
	61: Pop
	62: MoveLoc[0](Arg0: &String)
	63: Pop
	64: MoveLoc[3](loc1: u64)
	65: Ret
B12:
	66: MoveLoc[3](loc1: u64)
	67: LdU64(1)
	68: Add
	69: StLoc[3](loc1: u64)
	70: Branch(18)
B13:
	71: MoveLoc[1](Arg1: &String)
	72: Pop
	73: MoveLoc[0](Arg0: &String)
	74: Pop
	75: MoveLoc[6](loc4: u64)
	76: Ret
}

char_to_uppercase(Arg0: u8): u8 {
L1:	loc0: bool
L2:	loc1: u8
B0:
	0: CopyLoc[0](Arg0: u8)
	1: LdU8(97)
	2: Ge
	3: BrFalse(9)
B1:
	4: CopyLoc[0](Arg0: u8)
	5: LdU8(122)
	6: Le
	7: StLoc[1](loc0: bool)
	8: Branch(11)
B2:
	9: LdFalse
	10: StLoc[1](loc0: bool)
B3:
	11: MoveLoc[1](loc0: bool)
	12: BrFalse(18)
B4:
	13: MoveLoc[0](Arg0: u8)
	14: LdU8(32)
	15: Sub
	16: StLoc[2](loc1: u8)
	17: Branch(20)
B5:
	18: MoveLoc[0](Arg0: u8)
	19: StLoc[2](loc1: u8)
B6:
	20: MoveLoc[2](loc1: u8)
	21: Ret
}

char_to_lowercase(Arg0: u8): u8 {
L1:	loc0: bool
L2:	loc1: u8
B0:
	0: CopyLoc[0](Arg0: u8)
	1: LdU8(65)
	2: Ge
	3: BrFalse(9)
B1:
	4: CopyLoc[0](Arg0: u8)
	5: LdU8(90)
	6: Le
	7: StLoc[1](loc0: bool)
	8: Branch(11)
B2:
	9: LdFalse
	10: StLoc[1](loc0: bool)
B3:
	11: MoveLoc[1](loc0: bool)
	12: BrFalse(18)
B4:
	13: MoveLoc[0](Arg0: u8)
	14: LdU8(32)
	15: Add
	16: StLoc[2](loc1: u8)
	17: Branch(20)
B5:
	18: MoveLoc[0](Arg0: u8)
	19: StLoc[2](loc1: u8)
B6:
	20: MoveLoc[2](loc1: u8)
	21: Ret
}

Constants [
	0 => u64: 65536
	1 => u64: 65537
	2 => vector<u8>: "" // interpreted as UTF8 string
]
}

// Move bytecode v6
module 1.bcs {

native public to_bytes<Ty0>(Arg0: &Ty0): vector<u8>;

}

// Move bytecode v6
module 1.bit_vector {

struct BitVector has copy, drop, store {
	length: u64,
	bit_field: vector<bool>
}

public new(Arg0: u64): BitVector {
L1:	loc0: vector<bool>
L2:	loc1: u64
B0:
	0: CopyLoc[0](Arg0: u64)
	1: LdU64(0)
	2: Gt
	3: BrFalse(5)
B1:
	4: Branch(7)
B2:
	5: LdConst[1](u64: 131073)
	6: Abort
B3:
	7: CopyLoc[0](Arg0: u64)
	8: LdConst[3](u64: 1024)
	9: Lt
	10: BrFalse(12)
B4:
	11: Branch(14)
B5:
	12: LdConst[1](u64: 131073)
	13: Abort
B6:
	14: LdU64(0)
	15: StLoc[2](loc1: u64)
	16: VecPack(5, 0)
	17: StLoc[1](loc0: vector<bool>)
B7:
	18: CopyLoc[2](loc1: u64)
	19: CopyLoc[0](Arg0: u64)
	20: Lt
	21: BrFalse(30)
B8:
	22: MutBorrowLoc[1](loc0: vector<bool>)
	23: LdFalse
	24: VecPushBack(5)
	25: MoveLoc[2](loc1: u64)
	26: LdU64(1)
	27: Add
	28: StLoc[2](loc1: u64)
	29: Branch(18)
B9:
	30: MoveLoc[0](Arg0: u64)
	31: MoveLoc[1](loc0: vector<bool>)
	32: Pack[0](BitVector)
	33: Ret
}

public set(Arg0: &mut BitVector, Arg1: u64) {
L2:	loc0: &mut bool
B0:
	0: CopyLoc[1](Arg1: u64)
	1: CopyLoc[0](Arg0: &mut BitVector)
	2: ImmBorrowField[0](BitVector.bit_field: vector<bool>)
	3: VecLen(5)
	4: Lt
	5: BrFalse(7)
B1:
	6: Branch(11)
B2:
	7: MoveLoc[0](Arg0: &mut BitVector)
	8: Pop
	9: LdConst[0](u64: 131072)
	10: Abort
B3:
	11: MoveLoc[0](Arg0: &mut BitVector)
	12: MutBorrowField[0](BitVector.bit_field: vector<bool>)
	13: MoveLoc[1](Arg1: u64)
	14: VecMutBorrow(5)
	15: StLoc[2](loc0: &mut bool)
	16: LdTrue
	17: MoveLoc[2](loc0: &mut bool)
	18: WriteRef
	19: Ret
}

public unset(Arg0: &mut BitVector, Arg1: u64) {
L2:	loc0: &mut bool
B0:
	0: CopyLoc[1](Arg1: u64)
	1: CopyLoc[0](Arg0: &mut BitVector)
	2: ImmBorrowField[0](BitVector.bit_field: vector<bool>)
	3: VecLen(5)
	4: Lt
	5: BrFalse(7)
B1:
	6: Branch(11)
B2:
	7: MoveLoc[0](Arg0: &mut BitVector)
	8: Pop
	9: LdConst[0](u64: 131072)
	10: Abort
B3:
	11: MoveLoc[0](Arg0: &mut BitVector)
	12: MutBorrowField[0](BitVector.bit_field: vector<bool>)
	13: MoveLoc[1](Arg1: u64)
	14: VecMutBorrow(5)
	15: StLoc[2](loc0: &mut bool)
	16: LdFalse
	17: MoveLoc[2](loc0: &mut bool)
	18: WriteRef
	19: Ret
}

public shift_left(Arg0: &mut BitVector, Arg1: u64) {
L2:	loc0: &mut bool
L3:	loc1: u64
L4:	loc2: u64
L5:	loc3: u64
B0:
	0: CopyLoc[1](Arg1: u64)
	1: CopyLoc[0](Arg0: &mut BitVector)
	2: ImmBorrowField[1](BitVector.length: u64)
	3: ReadRef
	4: Ge
	5: BrFalse(33)
B1:
	6: CopyLoc[0](Arg0: &mut BitVector)
	7: ImmBorrowField[0](BitVector.bit_field: vector<bool>)
	8: VecLen(5)
	9: StLoc[5](loc3: u64)
	10: LdU64(0)
	11: StLoc[3](loc1: u64)
B2:
	12: CopyLoc[3](loc1: u64)
	13: CopyLoc[5](loc3: u64)
	14: Lt
	15: BrFalse(30)
B3:
	16: Branch(17)
B4:
	17: CopyLoc[0](Arg0: &mut BitVector)
	18: MutBorrowField[0](BitVector.bit_field: vector<bool>)
	19: CopyLoc[3](loc1: u64)
	20: VecMutBorrow(5)
	21: StLoc[2](loc0: &mut bool)
	22: LdFalse
	23: MoveLoc[2](loc0: &mut bool)
	24: WriteRef
	25: MoveLoc[3](loc1: u64)
	26: LdU64(1)
	27: Add
	28: StLoc[3](loc1: u64)
	29: Branch(12)
B5:
	30: MoveLoc[0](Arg0: &mut BitVector)
	31: Pop
	32: Branch(86)
B6:
	33: CopyLoc[1](Arg1: u64)
	34: StLoc[4](loc2: u64)
B7:
	35: CopyLoc[4](loc2: u64)
	36: CopyLoc[0](Arg0: &mut BitVector)
	37: ImmBorrowField[1](BitVector.length: u64)
	38: ReadRef
	39: Lt
	40: BrFalse(63)
B8:
	41: Branch(42)
B9:
	42: CopyLoc[0](Arg0: &mut BitVector)
	43: FreezeRef
	44: CopyLoc[4](loc2: u64)
	45: Call is_index_set(&BitVector, u64): bool
	46: BrFalse(53)
B10:
	47: CopyLoc[0](Arg0: &mut BitVector)
	48: CopyLoc[4](loc2: u64)
	49: CopyLoc[1](Arg1: u64)
	50: Sub
	51: Call set(&mut BitVector, u64)
	52: Branch(58)
B11:
	53: CopyLoc[0](Arg0: &mut BitVector)
	54: CopyLoc[4](loc2: u64)
	55: CopyLoc[1](Arg1: u64)
	56: Sub
	57: Call unset(&mut BitVector, u64)
B12:
	58: MoveLoc[4](loc2: u64)
	59: LdU64(1)
	60: Add
	61: StLoc[4](loc2: u64)
	62: Branch(35)
B13:
	63: CopyLoc[0](Arg0: &mut BitVector)
	64: ImmBorrowField[1](BitVector.length: u64)
	65: ReadRef
	66: MoveLoc[1](Arg1: u64)
	67: Sub
	68: StLoc[4](loc2: u64)
B14:
	69: CopyLoc[4](loc2: u64)
	70: CopyLoc[0](Arg0: &mut BitVector)
	71: ImmBorrowField[1](BitVector.length: u64)
	72: ReadRef
	73: Lt
	74: BrFalse(84)
B15:
	75: Branch(76)
B16:
	76: CopyLoc[0](Arg0: &mut BitVector)
	77: CopyLoc[4](loc2: u64)
	78: Call unset(&mut BitVector, u64)
	79: MoveLoc[4](loc2: u64)
	80: LdU64(1)
	81: Add
	82: StLoc[4](loc2: u64)
	83: Branch(69)
B17:
	84: MoveLoc[0](Arg0: &mut BitVector)
	85: Pop
B18:
	86: Ret
}

public is_index_set(Arg0: &BitVector, Arg1: u64): bool {
B0:
	0: CopyLoc[1](Arg1: u64)
	1: CopyLoc[0](Arg0: &BitVector)
	2: ImmBorrowField[0](BitVector.bit_field: vector<bool>)
	3: VecLen(5)
	4: Lt
	5: BrFalse(7)
B1:
	6: Branch(11)
B2:
	7: MoveLoc[0](Arg0: &BitVector)
	8: Pop
	9: LdConst[0](u64: 131072)
	10: Abort
B3:
	11: MoveLoc[0](Arg0: &BitVector)
	12: ImmBorrowField[0](BitVector.bit_field: vector<bool>)
	13: MoveLoc[1](Arg1: u64)
	14: VecImmBorrow(5)
	15: ReadRef
	16: Ret
}

public length(Arg0: &BitVector): u64 {
B0:
	0: MoveLoc[0](Arg0: &BitVector)
	1: ImmBorrowField[0](BitVector.bit_field: vector<bool>)
	2: VecLen(5)
	3: Ret
}

public longest_set_sequence_starting_at(Arg0: &BitVector, Arg1: u64): u64 {
L2:	loc0: u64
B0:
	0: CopyLoc[1](Arg1: u64)
	1: CopyLoc[0](Arg0: &BitVector)
	2: ImmBorrowField[1](BitVector.length: u64)
	3: ReadRef
	4: Lt
	5: BrFalse(7)
B1:
	6: Branch(11)
B2:
	7: MoveLoc[0](Arg0: &BitVector)
	8: Pop
	9: LdConst[0](u64: 131072)
	10: Abort
B3:
	11: CopyLoc[1](Arg1: u64)
	12: StLoc[2](loc0: u64)
B4:
	13: CopyLoc[2](loc0: u64)
	14: CopyLoc[0](Arg0: &BitVector)
	15: ImmBorrowField[1](BitVector.length: u64)
	16: ReadRef
	17: Lt
	18: BrFalse(33)
B5:
	19: CopyLoc[0](Arg0: &BitVector)
	20: CopyLoc[2](loc0: u64)
	21: Call is_index_set(&BitVector, u64): bool
	22: Not
	23: BrFalse(28)
B6:
	24: Branch(25)
B7:
	25: MoveLoc[0](Arg0: &BitVector)
	26: Pop
	27: Branch(33)
B8:
	28: MoveLoc[2](loc0: u64)
	29: LdU64(1)
	30: Add
	31: StLoc[2](loc0: u64)
	32: Branch(13)
B9:
	33: MoveLoc[2](loc0: u64)
	34: MoveLoc[1](Arg1: u64)
	35: Sub
	36: Ret
}

Constants [
	0 => u64: 131072
	1 => u64: 131073
	2 => u64: 1
	3 => u64: 1024
]
}

// Move bytecode v6
module 1.bool {

}

// Move bytecode v6
module 1.debug {

native public print<Ty0>(Arg0: &Ty0);

native public print_stack_trace();

}

// Move bytecode v6
module 1.fixed_point32 {

struct FixedPoint32 has copy, drop, store {
	value: u64
}

public multiply_u64(Arg0: u64, Arg1: FixedPoint32): u64 {
L2:	loc0: u128
B0:
	0: MoveLoc[0](Arg0: u64)
	1: CastU128
	2: ImmBorrowLoc[1](Arg1: FixedPoint32)
	3: ImmBorrowField[0](FixedPoint32.value: u64)
	4: ReadRef
	5: CastU128
	6: Mul
	7: LdU8(32)
	8: Shr
	9: StLoc[2](loc0: u128)
	10: CopyLoc[2](loc0: u128)
	11: LdConst[0](u128: 1844..)
	12: Le
	13: BrFalse(15)
B1:
	14: Branch(17)
B2:
	15: LdConst[3](u64: 131075)
	16: Abort
B3:
	17: MoveLoc[2](loc0: u128)
	18: CastU64
	19: Ret
}

public divide_u64(Arg0: u64, Arg1: FixedPoint32): u64 {
L2:	loc0: u128
B0:
	0: ImmBorrowLoc[1](Arg1: FixedPoint32)
	1: ImmBorrowField[0](FixedPoint32.value: u64)
	2: ReadRef
	3: LdU64(0)
	4: Neq
	5: BrFalse(7)
B1:
	6: Branch(9)
B2:
	7: LdConst[4](u64: 65540)
	8: Abort
B3:
	9: MoveLoc[0](Arg0: u64)
	10: CastU128
	11: LdU8(32)
	12: Shl
	13: ImmBorrowLoc[1](Arg1: FixedPoint32)
	14: ImmBorrowField[0](FixedPoint32.value: u64)
	15: ReadRef
	16: CastU128
	17: Div
	18: StLoc[2](loc0: u128)
	19: CopyLoc[2](loc0: u128)
	20: LdConst[0](u128: 1844..)
	21: Le
	22: BrFalse(24)
B4:
	23: Branch(26)
B5:
	24: LdConst[2](u64: 131074)
	25: Abort
B6:
	26: MoveLoc[2](loc0: u128)
	27: CastU64
	28: Ret
}

public create_from_rational(Arg0: u64, Arg1: u64): FixedPoint32 {
L2:	loc0: bool
L3:	loc1: u128
L4:	loc2: u128
L5:	loc3: u128
B0:
	0: CopyLoc[0](Arg0: u64)
	1: CastU128
	2: LdU8(64)
	3: Shl
	4: StLoc[5](loc3: u128)
	5: MoveLoc[1](Arg1: u64)
	6: CastU128
	7: LdU8(32)
	8: Shl
	9: StLoc[4](loc2: u128)
	10: CopyLoc[4](loc2: u128)
	11: LdU128(0)
	12: Neq
	13: BrFalse(15)
B1:
	14: Branch(17)
B2:
	15: LdConst[1](u64: 65537)
	16: Abort
B3:
	17: MoveLoc[5](loc3: u128)
	18: MoveLoc[4](loc2: u128)
	19: Div
	20: StLoc[3](loc1: u128)
	21: CopyLoc[3](loc1: u128)
	22: LdU128(0)
	23: Neq
	24: BrFalse(28)
B4:
	25: LdTrue
	26: StLoc[2](loc0: bool)
	27: Branch(32)
B5:
	28: MoveLoc[0](Arg0: u64)
	29: LdU64(0)
	30: Eq
	31: StLoc[2](loc0: bool)
B6:
	32: MoveLoc[2](loc0: bool)
	33: BrFalse(35)
B7:
	34: Branch(37)
B8:
	35: LdConst[5](u64: 131077)
	36: Abort
B9:
	37: CopyLoc[3](loc1: u128)
	38: LdConst[0](u128: 1844..)
	39: Le
	40: BrFalse(42)
B10:
	41: Branch(44)
B11:
	42: LdConst[5](u64: 131077)
	43: Abort
B12:
	44: MoveLoc[3](loc1: u128)
	45: CastU64
	46: Pack[0](FixedPoint32)
	47: Ret
}

public create_from_raw_value(Arg0: u64): FixedPoint32 {
B0:
	0: MoveLoc[0](Arg0: u64)
	1: Pack[0](FixedPoint32)
	2: Ret
}

public get_raw_value(Arg0: FixedPoint32): u64 {
B0:
	0: ImmBorrowLoc[0](Arg0: FixedPoint32)
	1: ImmBorrowField[0](FixedPoint32.value: u64)
	2: ReadRef
	3: Ret
}

public is_zero(Arg0: FixedPoint32): bool {
B0:
	0: ImmBorrowLoc[0](Arg0: FixedPoint32)
	1: ImmBorrowField[0](FixedPoint32.value: u64)
	2: ReadRef
	3: LdU64(0)
	4: Eq
	5: Ret
}

Constants [
	0 => u128: 18446744073709551615
	1 => u64: 65537
	2 => u64: 131074
	3 => u64: 131075
	4 => u64: 65540
	5 => u64: 131077
]
}

// Move bytecode v6
module 1.hash {

native public sha2_256(Arg0: vector<u8>): vector<u8>;

native public sha3_256(Arg0: vector<u8>): vector<u8>;

}

// Move bytecode v6
module 1.macros {

}

// Move bytecode v6
module 1.option {
use 0000000000000000000000000000000000000000000000000000000000000001::vector;

struct Option<Ty0> has copy, drop, store {
	vec: vector<Ty0>
}

public none<Ty0>(): Option<Ty0> {
B0:
	0: VecPack(2, 0)
	1: PackGeneric[0](Option<Ty0>)
	2: Ret
}

public some<Ty0>(Arg0: Ty0): Option<Ty0> {
B0:
	0: MoveLoc[0](Arg0: Ty0)
	1: Call vector::singleton<Ty0>(Ty0): vector<Ty0>
	2: PackGeneric[0](Option<Ty0>)
	3: Ret
}

public is_none<Ty0>(Arg0: &Option<Ty0>): bool {
B0:
	0: MoveLoc[0](Arg0: &Option<Ty0>)
	1: ImmBorrowFieldGeneric[0](Option.vec: vector<Ty0>)
	2: Call vector::is_empty<Ty0>(&vector<Ty0>): bool
	3: Ret
}

public is_some<Ty0>(Arg0: &Option<Ty0>): bool {
B0:
	0: MoveLoc[0](Arg0: &Option<Ty0>)
	1: ImmBorrowFieldGeneric[0](Option.vec: vector<Ty0>)
	2: Call vector::is_empty<Ty0>(&vector<Ty0>): bool
	3: Not
	4: Ret
}

public contains<Ty0>(Arg0: &Option<Ty0>, Arg1: &Ty0): bool {
B0:
	0: MoveLoc[0](Arg0: &Option<Ty0>)
	1: ImmBorrowFieldGeneric[0](Option.vec: vector<Ty0>)
	2: MoveLoc[1](Arg1: &Ty0)
	3: Call vector::contains<Ty0>(&vector<Ty0>, &Ty0): bool
	4: Ret
}

public borrow<Ty0>(Arg0: &Option<Ty0>): &Ty0 {
B0:
	0: CopyLoc[0](Arg0: &Option<Ty0>)
	1: Call is_some<Ty0>(&Option<Ty0>): bool
	2: BrFalse(4)
B1:
	3: Branch(8)
B2:
	4: MoveLoc[0](Arg0: &Option<Ty0>)
	5: Pop
	6: LdConst[1](u64: 262145)
	7: Abort
B3:
	8: MoveLoc[0](Arg0: &Option<Ty0>)
	9: ImmBorrowFieldGeneric[0](Option.vec: vector<Ty0>)
	10: LdU64(0)
	11: VecImmBorrow(2)
	12: Ret
}

public borrow_with_default<Ty0>(Arg0: &Option<Ty0>, Arg1: &Ty0): &Ty0 {
L2:	loc0: &Ty0
L3:	loc1: &vector<Ty0>
B0:
	0: MoveLoc[0](Arg0: &Option<Ty0>)
	1: ImmBorrowFieldGeneric[0](Option.vec: vector<Ty0>)
	2: StLoc[3](loc1: &vector<Ty0>)
	3: CopyLoc[3](loc1: &vector<Ty0>)
	4: Call vector::is_empty<Ty0>(&vector<Ty0>): bool
	5: BrFalse(11)
B1:
	6: MoveLoc[3](loc1: &vector<Ty0>)
	7: Pop
	8: MoveLoc[1](Arg1: &Ty0)
	9: StLoc[2](loc0: &Ty0)
	10: Branch(17)
B2:
	11: MoveLoc[1](Arg1: &Ty0)
	12: Pop
	13: MoveLoc[3](loc1: &vector<Ty0>)
	14: LdU64(0)
	15: VecImmBorrow(2)
	16: StLoc[2](loc0: &Ty0)
B3:
	17: MoveLoc[2](loc0: &Ty0)
	18: Ret
}

public get_with_default<Ty0: copy + drop>(Arg0: &Option<Ty0>, Arg1: Ty0): Ty0 {
L2:	loc0: Ty0
L3:	loc1: &vector<Ty0>
B0:
	0: MoveLoc[0](Arg0: &Option<Ty0>)
	1: ImmBorrowFieldGeneric[0](Option.vec: vector<Ty0>)
	2: StLoc[3](loc1: &vector<Ty0>)
	3: CopyLoc[3](loc1: &vector<Ty0>)
	4: Call vector::is_empty<Ty0>(&vector<Ty0>): bool
	5: BrFalse(11)
B1:
	6: MoveLoc[3](loc1: &vector<Ty0>)
	7: Pop
	8: MoveLoc[1](Arg1: Ty0)
	9: StLoc[2](loc0: Ty0)
	10: Branch(16)
B2:
	11: MoveLoc[3](loc1: &vector<Ty0>)
	12: LdU64(0)
	13: VecImmBorrow(2)
	14: ReadRef
	15: StLoc[2](loc0: Ty0)
B3:
	16: MoveLoc[2](loc0: Ty0)
	17: Ret
}

public fill<Ty0>(Arg0: &mut Option<Ty0>, Arg1: Ty0) {
L2:	loc0: &mut vector<Ty0>
B0:
	0: MoveLoc[0](Arg0: &mut Option<Ty0>)
	1: MutBorrowFieldGeneric[0](Option.vec: vector<Ty0>)
	2: StLoc[2](loc0: &mut vector<Ty0>)
	3: CopyLoc[2](loc0: &mut vector<Ty0>)
	4: FreezeRef
	5: Call vector::is_empty<Ty0>(&vector<Ty0>): bool
	6: BrFalse(8)
B1:
	7: Branch(12)
B2:
	8: MoveLoc[2](loc0: &mut vector<Ty0>)
	9: Pop
	10: LdConst[0](u64: 262144)
	11: Abort
B3:
	12: MoveLoc[2](loc0: &mut vector<Ty0>)
	13: MoveLoc[1](Arg1: Ty0)
	14: VecPushBack(2)
	15: Ret
}

public extract<Ty0>(Arg0: &mut Option<Ty0>): Ty0 {
B0:
	0: CopyLoc[0](Arg0: &mut Option<Ty0>)
	1: FreezeRef
	2: Call is_some<Ty0>(&Option<Ty0>): bool
	3: BrFalse(5)
B1:
	4: Branch(9)
B2:
	5: MoveLoc[0](Arg0: &mut Option<Ty0>)
	6: Pop
	7: LdConst[1](u64: 262145)
	8: Abort
B3:
	9: MoveLoc[0](Arg0: &mut Option<Ty0>)
	10: MutBorrowFieldGeneric[0](Option.vec: vector<Ty0>)
	11: VecPopBack(2)
	12: Ret
}

public borrow_mut<Ty0>(Arg0: &mut Option<Ty0>): &mut Ty0 {
B0:
	0: CopyLoc[0](Arg0: &mut Option<Ty0>)
	1: FreezeRef
	2: Call is_some<Ty0>(&Option<Ty0>): bool
	3: BrFalse(5)
B1:
	4: Branch(9)
B2:
	5: MoveLoc[0](Arg0: &mut Option<Ty0>)
	6: Pop
	7: LdConst[1](u64: 262145)
	8: Abort
B3:
	9: MoveLoc[0](Arg0: &mut Option<Ty0>)
	10: MutBorrowFieldGeneric[0](Option.vec: vector<Ty0>)
	11: LdU64(0)
	12: VecMutBorrow(2)
	13: Ret
}

public swap<Ty0>(Arg0: &mut Option<Ty0>, Arg1: Ty0): Ty0 {
L2:	loc0: Ty0
L3:	loc1: &mut vector<Ty0>
B0:
	0: CopyLoc[0](Arg0: &mut Option<Ty0>)
	1: FreezeRef
	2: Call is_some<Ty0>(&Option<Ty0>): bool
	3: BrFalse(5)
B1:
	4: Branch(9)
B2:
	5: MoveLoc[0](Arg0: &mut Option<Ty0>)
	6: Pop
	7: LdConst[1](u64: 262145)
	8: Abort
B3:
	9: MoveLoc[0](Arg0: &mut Option<Ty0>)
	10: MutBorrowFieldGeneric[0](Option.vec: vector<Ty0>)
	11: StLoc[3](loc1: &mut vector<Ty0>)
	12: CopyLoc[3](loc1: &mut vector<Ty0>)
	13: VecPopBack(2)
	14: StLoc[2](loc0: Ty0)
	15: MoveLoc[3](loc1: &mut vector<Ty0>)
	16: MoveLoc[1](Arg1: Ty0)
	17: VecPushBack(2)
	18: MoveLoc[2](loc0: Ty0)
	19: Ret
}

public swap_or_fill<Ty0>(Arg0: &mut Option<Ty0>, Arg1: Ty0): Option<Ty0> {
L2:	loc0: Option<Ty0>
L3:	loc1: Option<Ty0>
L4:	loc2: &mut vector<Ty0>
B0:
	0: MoveLoc[0](Arg0: &mut Option<Ty0>)
	1: MutBorrowFieldGeneric[0](Option.vec: vector<Ty0>)
	2: StLoc[4](loc2: &mut vector<Ty0>)
	3: CopyLoc[4](loc2: &mut vector<Ty0>)
	4: FreezeRef
	5: Call vector::is_empty<Ty0>(&vector<Ty0>): bool
	6: BrFalse(10)
B1:
	7: Call none<Ty0>(): Option<Ty0>
	8: StLoc[2](loc0: Option<Ty0>)
	9: Branch(14)
B2:
	10: CopyLoc[4](loc2: &mut vector<Ty0>)
	11: VecPopBack(2)
	12: Call some<Ty0>(Ty0): Option<Ty0>
	13: StLoc[2](loc0: Option<Ty0>)
B3:
	14: MoveLoc[2](loc0: Option<Ty0>)
	15: StLoc[3](loc1: Option<Ty0>)
	16: MoveLoc[4](loc2: &mut vector<Ty0>)
	17: MoveLoc[1](Arg1: Ty0)
	18: VecPushBack(2)
	19: MoveLoc[3](loc1: Option<Ty0>)
	20: Ret
}

public destroy_with_default<Ty0: drop>(Arg0: Option<Ty0>, Arg1: Ty0): Ty0 {
L2:	loc0: Ty0
L3:	loc1: vector<Ty0>
B0:
	0: MoveLoc[0](Arg0: Option<Ty0>)
	1: UnpackGeneric[0](Option<Ty0>)
	2: StLoc[3](loc1: vector<Ty0>)
	3: ImmBorrowLoc[3](loc1: vector<Ty0>)
	4: Call vector::is_empty<Ty0>(&vector<Ty0>): bool
	5: BrFalse(9)
B1:
	6: MoveLoc[1](Arg1: Ty0)
	7: StLoc[2](loc0: Ty0)
	8: Branch(12)
B2:
	9: MutBorrowLoc[3](loc1: vector<Ty0>)
	10: VecPopBack(2)
	11: StLoc[2](loc0: Ty0)
B3:
	12: MoveLoc[2](loc0: Ty0)
	13: Ret
}

public destroy_some<Ty0>(Arg0: Option<Ty0>): Ty0 {
L1:	loc0: Ty0
L2:	loc1: vector<Ty0>
B0:
	0: ImmBorrowLoc[0](Arg0: Option<Ty0>)
	1: Call is_some<Ty0>(&Option<Ty0>): bool
	2: BrFalse(4)
B1:
	3: Branch(6)
B2:
	4: LdConst[1](u64: 262145)
	5: Abort
B3:
	6: MoveLoc[0](Arg0: Option<Ty0>)
	7: UnpackGeneric[0](Option<Ty0>)
	8: StLoc[2](loc1: vector<Ty0>)
	9: MutBorrowLoc[2](loc1: vector<Ty0>)
	10: VecPopBack(2)
	11: StLoc[1](loc0: Ty0)
	12: MoveLoc[2](loc1: vector<Ty0>)
	13: VecUnpack(2, 0)
	14: MoveLoc[1](loc0: Ty0)
	15: Ret
}

public destroy_none<Ty0>(Arg0: Option<Ty0>) {
B0:
	0: ImmBorrowLoc[0](Arg0: Option<Ty0>)
	1: Call is_none<Ty0>(&Option<Ty0>): bool
	2: BrFalse(4)
B1:
	3: Branch(6)
B2:
	4: LdConst[0](u64: 262144)
	5: Abort
B3:
	6: MoveLoc[0](Arg0: Option<Ty0>)
	7: UnpackGeneric[0](Option<Ty0>)
	8: VecUnpack(2, 0)
	9: Ret
}

public to_vec<Ty0>(Arg0: Option<Ty0>): vector<Ty0> {
B0:
	0: MoveLoc[0](Arg0: Option<Ty0>)
	1: UnpackGeneric[0](Option<Ty0>)
	2: Ret
}

Constants [
	0 => u64: 262144
	1 => u64: 262145
]
}

// Move bytecode v6
module 1.string {
use 0000000000000000000000000000000000000000000000000000000000000001::ascii;
use 0000000000000000000000000000000000000000000000000000000000000001::option;
use 0000000000000000000000000000000000000000000000000000000000000001::vector;

struct String has copy, drop, store {
	bytes: vector<u8>
}

public utf8(Arg0: vector<u8>): String {
B0:
	0: ImmBorrowLoc[0](Arg0: vector<u8>)
	1: Call internal_check_utf8(&vector<u8>): bool
	2: BrFalse(4)
B1:
	3: Branch(6)
B2:
	4: LdConst[0](u64: 1)
	5: Abort
B3:
	6: MoveLoc[0](Arg0: vector<u8>)
	7: Pack[0](String)
	8: Ret
}

public from_ascii(Arg0: String): String {
B0:
	0: MoveLoc[0](Arg0: String)
	1: Call ascii::into_bytes(String): vector<u8>
	2: Pack[0](String)
	3: Ret
}

public to_ascii(Arg0: String): String {
B0:
	0: MoveLoc[0](Arg0: String)
	1: Unpack[0](String)
	2: Call ascii::string(vector<u8>): String
	3: Ret
}

public try_utf8(Arg0: vector<u8>): Option<String> {
L1:	loc0: Option<String>
B0:
	0: ImmBorrowLoc[0](Arg0: vector<u8>)
	1: Call internal_check_utf8(&vector<u8>): bool
	2: BrFalse(8)
B1:
	3: MoveLoc[0](Arg0: vector<u8>)
	4: Pack[0](String)
	5: Call option::some<String>(String): Option<String>
	6: StLoc[1](loc0: Option<String>)
	7: Branch(10)
B2:
	8: Call option::none<String>(): Option<String>
	9: StLoc[1](loc0: Option<String>)
B3:
	10: MoveLoc[1](loc0: Option<String>)
	11: Ret
}

public as_bytes(Arg0: &String): &vector<u8> {
B0:
	0: MoveLoc[0](Arg0: &String)
	1: ImmBorrowField[0](String.bytes: vector<u8>)
	2: Ret
}

public into_bytes(Arg0: String): vector<u8> {
B0:
	0: MoveLoc[0](Arg0: String)
	1: Unpack[0](String)
	2: Ret
}

public is_empty(Arg0: &String): bool {
B0:
	0: MoveLoc[0](Arg0: &String)
	1: ImmBorrowField[0](String.bytes: vector<u8>)
	2: Call vector::is_empty<u8>(&vector<u8>): bool
	3: Ret
}

public length(Arg0: &String): u64 {
B0:
	0: MoveLoc[0](Arg0: &String)
	1: ImmBorrowField[0](String.bytes: vector<u8>)
	2: VecLen(19)
	3: Ret
}

public append(Arg0: &mut String, Arg1: String) {
B0:
	0: MoveLoc[0](Arg0: &mut String)
	1: MutBorrowField[0](String.bytes: vector<u8>)
	2: ImmBorrowLoc[1](Arg1: String)
	3: ImmBorrowField[0](String.bytes: vector<u8>)
	4: ReadRef
	5: Call vector::append<u8>(&mut vector<u8>, vector<u8>)
	6: Ret
}

public append_utf8(Arg0: &mut String, Arg1: vector<u8>) {
B0:
	0: MoveLoc[0](Arg0: &mut String)
	1: MoveLoc[1](Arg1: vector<u8>)
	2: Call utf8(vector<u8>): String
	3: Call append(&mut String, String)
	4: Ret
}

public insert(Arg0: &mut String, Arg1: u64, Arg2: String) {
L3:	loc0: bool
L4:	loc1: &vector<u8>
L5:	loc2: String
L6:	loc3: String
L7:	loc4: u64
B0:
	0: CopyLoc[0](Arg0: &mut String)
	1: ImmBorrowField[0](String.bytes: vector<u8>)
	2: StLoc[4](loc1: &vector<u8>)
	3: CopyLoc[1](Arg1: u64)
	4: CopyLoc[4](loc1: &vector<u8>)
	5: VecLen(19)
	6: Le
	7: BrFalse(13)
B1:
	8: MoveLoc[4](loc1: &vector<u8>)
	9: CopyLoc[1](Arg1: u64)
	10: Call internal_is_char_boundary(&vector<u8>, u64): bool
	11: StLoc[3](loc0: bool)
	12: Branch(17)
B2:
	13: MoveLoc[4](loc1: &vector<u8>)
	14: Pop
	15: LdFalse
	16: StLoc[3](loc0: bool)
B3:
	17: MoveLoc[3](loc0: bool)
	18: BrFalse(20)
B4:
	19: Branch(24)
B5:
	20: MoveLoc[0](Arg0: &mut String)
	21: Pop
	22: LdConst[1](u64: 2)
	23: Abort
B6:
	24: CopyLoc[0](Arg0: &mut String)
	25: FreezeRef
	26: Call length(&String): u64
	27: StLoc[7](loc4: u64)
	28: CopyLoc[0](Arg0: &mut String)
	29: FreezeRef
	30: LdU64(0)
	31: CopyLoc[1](Arg1: u64)
	32: Call substring(&String, u64, u64): String
	33: StLoc[6](loc3: String)
	34: CopyLoc[0](Arg0: &mut String)
	35: FreezeRef
	36: MoveLoc[1](Arg1: u64)
	37: MoveLoc[7](loc4: u64)
	38: Call substring(&String, u64, u64): String
	39: StLoc[5](loc2: String)
	40: MutBorrowLoc[6](loc3: String)
	41: MoveLoc[2](Arg2: String)
	42: Call append(&mut String, String)
	43: MutBorrowLoc[6](loc3: String)
	44: MoveLoc[5](loc2: String)
	45: Call append(&mut String, String)
	46: MoveLoc[6](loc3: String)
	47: MoveLoc[0](Arg0: &mut String)
	48: WriteRef
	49: Ret
}

public substring(Arg0: &String, Arg1: u64, Arg2: u64): String {
L3:	loc0: bool
L4:	loc1: &vector<u8>
L5:	loc2: u64
B0:
	0: MoveLoc[0](Arg0: &String)
	1: ImmBorrowField[0](String.bytes: vector<u8>)
	2: StLoc[4](loc1: &vector<u8>)
	3: CopyLoc[4](loc1: &vector<u8>)
	4: VecLen(19)
	5: StLoc[5](loc2: u64)
	6: CopyLoc[2](Arg2: u64)
	7: MoveLoc[5](loc2: u64)
	8: Le
	9: BrFalse(29)
B1:
	10: CopyLoc[1](Arg1: u64)
	11: CopyLoc[2](Arg2: u64)
	12: Le
	13: BrFalse(26)
B2:
	14: CopyLoc[4](loc1: &vector<u8>)
	15: CopyLoc[1](Arg1: u64)
	16: Call internal_is_char_boundary(&vector<u8>, u64): bool
	17: BrFalse(23)
B3:
	18: CopyLoc[4](loc1: &vector<u8>)
	19: CopyLoc[2](Arg2: u64)
	20: Call internal_is_char_boundary(&vector<u8>, u64): bool
	21: StLoc[3](loc0: bool)
	22: Branch(31)
B4:
	23: LdFalse
	24: StLoc[3](loc0: bool)
	25: Branch(31)
B5:
	26: LdFalse
	27: StLoc[3](loc0: bool)
	28: Branch(31)
B6:
	29: LdFalse
	30: StLoc[3](loc0: bool)
B7:
	31: MoveLoc[3](loc0: bool)
	32: BrFalse(34)
B8:
	33: Branch(38)
B9:
	34: MoveLoc[4](loc1: &vector<u8>)
	35: Pop
	36: LdConst[1](u64: 2)
	37: Abort
B10:
	38: MoveLoc[4](loc1: &vector<u8>)
	39: MoveLoc[1](Arg1: u64)
	40: MoveLoc[2](Arg2: u64)
	41: Call internal_sub_string(&vector<u8>, u64, u64): vector<u8>
	42: Pack[0](String)
	43: Ret
}

public index_of(Arg0: &String, Arg1: &String): u64 {
B0:
	0: MoveLoc[0](Arg0: &String)
	1: ImmBorrowField[0](String.bytes: vector<u8>)
	2: MoveLoc[1](Arg1: &String)
	3: ImmBorrowField[0](String.bytes: vector<u8>)
	4: Call internal_index_of(&vector<u8>, &vector<u8>): u64
	5: Ret
}

native internal_check_utf8(Arg0: &vector<u8>): bool;

native internal_is_char_boundary(Arg0: &vector<u8>, Arg1: u64): bool;

native internal_sub_string(Arg0: &vector<u8>, Arg1: u64, Arg2: u64): vector<u8>;

native internal_index_of(Arg0: &vector<u8>, Arg1: &vector<u8>): u64;

public bytes(Arg0: &String): &vector<u8> {
B0:
	0: MoveLoc[0](Arg0: &String)
	1: Call as_bytes(&String): &vector<u8>
	2: Ret
}

public sub_string(Arg0: &String, Arg1: u64, Arg2: u64): String {
B0:
	0: MoveLoc[0](Arg0: &String)
	1: MoveLoc[1](Arg1: u64)
	2: MoveLoc[2](Arg2: u64)
	3: Call substring(&String, u64, u64): String
	4: Ret
}

Constants [
	0 => u64: 1
	1 => u64: 2
]
}

// Move bytecode v6
module 1.type_name {
use 0000000000000000000000000000000000000000000000000000000000000001::address;
use 0000000000000000000000000000000000000000000000000000000000000001::ascii;

struct TypeName has copy, drop, store {
	name: String
}

native public get<Ty0>(): TypeName;

native public get_with_original_ids<Ty0>(): TypeName;

public is_primitive(Arg0: &TypeName): bool {
L1:	loc0: bool
L2:	loc1: &vector<u8>
L3:	loc2: vector<u8>
L4:	loc3: &vector<u8>
L5:	loc4: vector<u8>
L6:	loc5: &vector<u8>
L7:	loc6: vector<u8>
L8:	loc7: &vector<u8>
L9:	loc8: vector<u8>
L10:	loc9: &vector<u8>
L11:	loc10: bool
L12:	loc11: vector<u8>
L13:	loc12: &vector<u8>
L14:	loc13: vector<u8>
L15:	loc14: &vector<u8>
L16:	loc15: vector<u8>
L17:	loc16: &vector<u8>
L18:	loc17: vector<u8>
L19:	loc18: &vector<u8>
B0:
	0: MoveLoc[0](Arg0: &TypeName)
	1: ImmBorrowField[0](TypeName.name: String)
	2: Call ascii::as_bytes(&String): &vector<u8>
	3: StLoc[19](loc18: &vector<u8>)
	4: CopyLoc[19](loc18: &vector<u8>)
	5: StLoc[10](loc9: &vector<u8>)
	6: LdConst[8](vector<u8>: "boo..)
	7: StLoc[9](loc8: vector<u8>)
	8: MoveLoc[10](loc9: &vector<u8>)
	9: ImmBorrowLoc[9](loc8: vector<u8>)
	10: Eq
	11: BrFalse(17)
B1:
	12: MoveLoc[19](loc18: &vector<u8>)
	13: Pop
	14: LdTrue
	15: StLoc[1](loc0: bool)
	16: Branch(187)
B2:
	17: CopyLoc[19](loc18: &vector<u8>)
	18: StLoc[8](loc7: &vector<u8>)
	19: LdConst[9](vector<u8>: "u8"..)
	20: StLoc[7](loc6: vector<u8>)
	21: MoveLoc[8](loc7: &vector<u8>)
	22: ImmBorrowLoc[7](loc6: vector<u8>)
	23: Eq
	24: BrFalse(30)
B3:
	25: MoveLoc[19](loc18: &vector<u8>)
	26: Pop
	27: LdTrue
	28: StLoc[1](loc0: bool)
	29: Branch(187)
B4:
	30: CopyLoc[19](loc18: &vector<u8>)
	31: StLoc[6](loc5: &vector<u8>)
	32: LdConst[10](vector<u8>: "u16..)
	33: StLoc[5](loc4: vector<u8>)
	34: MoveLoc[6](loc5: &vector<u8>)
	35: ImmBorrowLoc[5](loc4: vector<u8>)
	36: Eq
	37: BrFalse(43)
B5:
	38: MoveLoc[19](loc18: &vector<u8>)
	39: Pop
	40: LdTrue
	41: StLoc[1](loc0: bool)
	42: Branch(187)
B6:
	43: CopyLoc[19](loc18: &vector<u8>)
	44: StLoc[4](loc3: &vector<u8>)
	45: LdConst[11](vector<u8>: "u32..)
	46: StLoc[3](loc2: vector<u8>)
	47: MoveLoc[4](loc3: &vector<u8>)
	48: ImmBorrowLoc[3](loc2: vector<u8>)
	49: Eq
	50: BrFalse(56)
B7:
	51: MoveLoc[19](loc18: &vector<u8>)
	52: Pop
	53: LdTrue
	54: StLoc[1](loc0: bool)
	55: Branch(187)
B8:
	56: CopyLoc[19](loc18: &vector<u8>)
	57: StLoc[2](loc1: &vector<u8>)
	58: LdConst[12](vector<u8>: "u64..)
	59: StLoc[18](loc17: vector<u8>)
	60: MoveLoc[2](loc1: &vector<u8>)
	61: ImmBorrowLoc[18](loc17: vector<u8>)
	62: Eq
	63: BrFalse(69)
B9:
	64: MoveLoc[19](loc18: &vector<u8>)
	65: Pop
	66: LdTrue
	67: StLoc[1](loc0: bool)
	68: Branch(187)
B10:
	69: CopyLoc[19](loc18: &vector<u8>)
	70: StLoc[17](loc16: &vector<u8>)
	71: LdConst[13](vector<u8>: "u12..)
	72: StLoc[16](loc15: vector<u8>)
	73: MoveLoc[17](loc16: &vector<u8>)
	74: ImmBorrowLoc[16](loc15: vector<u8>)
	75: Eq
	76: BrFalse(82)
B11:
	77: MoveLoc[19](loc18: &vector<u8>)
	78: Pop
	79: LdTrue
	80: StLoc[1](loc0: bool)
	81: Branch(187)
B12:
	82: CopyLoc[19](loc18: &vector<u8>)
	83: StLoc[15](loc14: &vector<u8>)
	84: LdConst[14](vector<u8>: "u25..)
	85: StLoc[14](loc13: vector<u8>)
	86: MoveLoc[15](loc14: &vector<u8>)
	87: ImmBorrowLoc[14](loc13: vector<u8>)
	88: Eq
	89: BrFalse(95)
B13:
	90: MoveLoc[19](loc18: &vector<u8>)
	91: Pop
	92: LdTrue
	93: StLoc[1](loc0: bool)
	94: Branch(187)
B14:
	95: CopyLoc[19](loc18: &vector<u8>)
	96: StLoc[13](loc12: &vector<u8>)
	97: LdConst[15](vector<u8>: "add..)
	98: StLoc[12](loc11: vector<u8>)
	99: MoveLoc[13](loc12: &vector<u8>)
	100: ImmBorrowLoc[12](loc11: vector<u8>)
	101: Eq
	102: BrFalse(108)
B15:
	103: MoveLoc[19](loc18: &vector<u8>)
	104: Pop
	105: LdTrue
	106: StLoc[1](loc0: bool)
	107: Branch(187)
B16:
	108: CopyLoc[19](loc18: &vector<u8>)
	109: VecLen(8)
	110: LdU64(6)
	111: Ge
	112: BrFalse(181)
B17:
	113: CopyLoc[19](loc18: &vector<u8>)
	114: LdU64(0)
	115: VecImmBorrow(8)
	116: ReadRef
	117: LdConst[1](u8: 118)
	118: Eq
	119: BrFalse(176)
B18:
	120: CopyLoc[19](loc18: &vector<u8>)
	121: LdU64(1)
	122: VecImmBorrow(8)
	123: ReadRef
	124: LdConst[2](u8: 101)
	125: Eq
	126: BrFalse(171)
B19:
	127: CopyLoc[19](loc18: &vector<u8>)
	128: LdU64(2)
	129: VecImmBorrow(8)
	130: ReadRef
	131: LdConst[3](u8: 99)
	132: Eq
	133: BrFalse(166)
B20:
	134: CopyLoc[19](loc18: &vector<u8>)
	135: LdU64(3)
	136: VecImmBorrow(8)
	137: ReadRef
	138: LdConst[4](u8: 116)
	139: Eq
	140: BrFalse(161)
B21:
	141: CopyLoc[19](loc18: &vector<u8>)
	142: LdU64(4)
	143: VecImmBorrow(8)
	144: ReadRef
	145: LdConst[5](u8: 111)
	146: Eq
	147: BrFalse(156)
B22:
	148: MoveLoc[19](loc18: &vector<u8>)
	149: LdU64(5)
	150: VecImmBorrow(8)
	151: ReadRef
	152: LdConst[6](u8: 114)
	153: Eq
	154: StLoc[11](loc10: bool)
	155: Branch(185)
B23:
	156: MoveLoc[19](loc18: &vector<u8>)
	157: Pop
	158: LdFalse
	159: StLoc[11](loc10: bool)
	160: Branch(185)
B24:
	161: MoveLoc[19](loc18: &vector<u8>)
	162: Pop
	163: LdFalse
	164: StLoc[11](loc10: bool)
	165: Branch(185)
B25:
	166: MoveLoc[19](loc18: &vector<u8>)
	167: Pop
	168: LdFalse
	169: StLoc[11](loc10: bool)
	170: Branch(185)
B26:
	171: MoveLoc[19](loc18: &vector<u8>)
	172: Pop
	173: LdFalse
	174: StLoc[11](loc10: bool)
	175: Branch(185)
B27:
	176: MoveLoc[19](loc18: &vector<u8>)
	177: Pop
	178: LdFalse
	179: StLoc[11](loc10: bool)
	180: Branch(185)
B28:
	181: MoveLoc[19](loc18: &vector<u8>)
	182: Pop
	183: LdFalse
	184: StLoc[11](loc10: bool)
B29:
	185: MoveLoc[11](loc10: bool)
	186: StLoc[1](loc0: bool)
B30:
	187: MoveLoc[1](loc0: bool)
	188: Ret
}

public borrow_string(Arg0: &TypeName): &String {
B0:
	0: MoveLoc[0](Arg0: &TypeName)
	1: ImmBorrowField[0](TypeName.name: String)
	2: Ret
}

public get_address(Arg0: &TypeName): String {
L1:	loc0: vector<u8>
L2:	loc1: u64
L3:	loc2: u64
L4:	loc3: &vector<u8>
B0:
	0: CopyLoc[0](Arg0: &TypeName)
	1: Call is_primitive(&TypeName): bool
	2: Not
	3: BrFalse(5)
B1:
	4: Branch(9)
B2:
	5: MoveLoc[0](Arg0: &TypeName)
	6: Pop
	7: LdConst[7](u64: 0)
	8: Abort
B3:
	9: Call address::length(): u64
	10: LdU64(2)
	11: Mul
	12: StLoc[3](loc2: u64)
	13: MoveLoc[0](Arg0: &TypeName)
	14: ImmBorrowField[0](TypeName.name: String)
	15: Call ascii::as_bytes(&String): &vector<u8>
	16: StLoc[4](loc3: &vector<u8>)
	17: LdConst[16](vector<u8>: "" /..)
	18: StLoc[1](loc0: vector<u8>)
	19: LdU64(0)
	20: StLoc[2](loc1: u64)
B4:
	21: CopyLoc[2](loc1: u64)
	22: CopyLoc[3](loc2: u64)
	23: Lt
	24: BrFalse(36)
B5:
	25: MutBorrowLoc[1](loc0: vector<u8>)
	26: CopyLoc[4](loc3: &vector<u8>)
	27: CopyLoc[2](loc1: u64)
	28: VecImmBorrow(8)
	29: ReadRef
	30: VecPushBack(8)
	31: MoveLoc[2](loc1: u64)
	32: LdU64(1)
	33: Add
	34: StLoc[2](loc1: u64)
	35: Branch(21)
B6:
	36: MoveLoc[4](loc3: &vector<u8>)
	37: Pop
	38: MoveLoc[1](loc0: vector<u8>)
	39: Call ascii::string(vector<u8>): String
	40: Ret
}

public get_module(Arg0: &TypeName): String {
L1:	loc0: &u8
L2:	loc1: u8
L3:	loc2: u64
L4:	loc3: vector<u8>
L5:	loc4: &vector<u8>
B0:
	0: CopyLoc[0](Arg0: &TypeName)
	1: Call is_primitive(&TypeName): bool
	2: Not
	3: BrFalse(5)
B1:
	4: Branch(9)
B2:
	5: MoveLoc[0](Arg0: &TypeName)
	6: Pop
	7: LdConst[7](u64: 0)
	8: Abort
B3:
	9: Call address::length(): u64
	10: LdU64(2)
	11: Mul
	12: LdU64(2)
	13: Add
	14: StLoc[3](loc2: u64)
	15: MoveLoc[0](Arg0: &TypeName)
	16: ImmBorrowField[0](TypeName.name: String)
	17: Call ascii::as_bytes(&String): &vector<u8>
	18: StLoc[5](loc4: &vector<u8>)
	19: LdConst[16](vector<u8>: "" /..)
	20: StLoc[4](loc3: vector<u8>)
	21: LdConst[0](u8: 58)
	22: StLoc[2](loc1: u8)
B4:
	23: CopyLoc[5](loc4: &vector<u8>)
	24: CopyLoc[3](loc2: u64)
	25: VecImmBorrow(8)
	26: StLoc[1](loc0: &u8)
	27: CopyLoc[1](loc0: &u8)
	28: ImmBorrowLoc[2](loc1: u8)
	29: Neq
	30: BrFalse(40)
B5:
	31: MutBorrowLoc[4](loc3: vector<u8>)
	32: MoveLoc[1](loc0: &u8)
	33: ReadRef
	34: VecPushBack(8)
	35: MoveLoc[3](loc2: u64)
	36: LdU64(1)
	37: Add
	38: StLoc[3](loc2: u64)
	39: Branch(23)
B6:
	40: MoveLoc[5](loc4: &vector<u8>)
	41: Pop
	42: MoveLoc[1](loc0: &u8)
	43: Pop
	44: MoveLoc[4](loc3: vector<u8>)
	45: Call ascii::string(vector<u8>): String
	46: Ret
}

public into_string(Arg0: TypeName): String {
B0:
	0: ImmBorrowLoc[0](Arg0: TypeName)
	1: ImmBorrowField[0](TypeName.name: String)
	2: ReadRef
	3: Ret
}

Constants [
	0 => u8: 58
	1 => u8: 118
	2 => u8: 101
	3 => u8: 99
	4 => u8: 116
	5 => u8: 111
	6 => u8: 114
	7 => u64: 0
	8 => vector<u8>: "bool" // interpreted as UTF8 string
	9 => vector<u8>: "u8" // interpreted as UTF8 string
	10 => vector<u8>: "u16" // interpreted as UTF8 string
	11 => vector<u8>: "u32" // interpreted as UTF8 string
	12 => vector<u8>: "u64" // interpreted as UTF8 string
	13 => vector<u8>: "u128" // interpreted as UTF8 string
	14 => vector<u8>: "u256" // interpreted as UTF8 string
	15 => vector<u8>: "address" // interpreted as UTF8 string
	16 => vector<u8>: "" // interpreted as UTF8 string
]
}

// Move bytecode v6
module 1.u128 {
use 0000000000000000000000000000000000000000000000000000000000000001::option;
use 0000000000000000000000000000000000000000000000000000000000000001::string;
use 0000000000000000000000000000000000000000000000000000000000000001::vector;

public bitwise_not(Arg0: u128): u128 {
B0:
	0: MoveLoc[0](Arg0: u128)
	1: LdU128(340282366920938463463374607431768211455)
	2: Xor
	3: Ret
}

public max(Arg0: u128, Arg1: u128): u128 {
L2:	loc0: u128
L3:	loc1: u128
L4:	loc2: u128
B0:
	0: MoveLoc[0](Arg0: u128)
	1: StLoc[3](loc1: u128)
	2: MoveLoc[1](Arg1: u128)
	3: StLoc[4](loc2: u128)
	4: CopyLoc[3](loc1: u128)
	5: CopyLoc[4](loc2: u128)
	6: Gt
	7: BrFalse(11)
B1:
	8: MoveLoc[3](loc1: u128)
	9: StLoc[2](loc0: u128)
	10: Branch(13)
B2:
	11: MoveLoc[4](loc2: u128)
	12: StLoc[2](loc0: u128)
B3:
	13: MoveLoc[2](loc0: u128)
	14: Ret
}

public min(Arg0: u128, Arg1: u128): u128 {
L2:	loc0: u128
L3:	loc1: u128
L4:	loc2: u128
B0:
	0: MoveLoc[0](Arg0: u128)
	1: StLoc[3](loc1: u128)
	2: MoveLoc[1](Arg1: u128)
	3: StLoc[4](loc2: u128)
	4: CopyLoc[3](loc1: u128)
	5: CopyLoc[4](loc2: u128)
	6: Lt
	7: BrFalse(11)
B1:
	8: MoveLoc[3](loc1: u128)
	9: StLoc[2](loc0: u128)
	10: Branch(13)
B2:
	11: MoveLoc[4](loc2: u128)
	12: StLoc[2](loc0: u128)
B3:
	13: MoveLoc[2](loc0: u128)
	14: Ret
}

public diff(Arg0: u128, Arg1: u128): u128 {
L2:	loc0: u128
L3:	loc1: u128
L4:	loc2: u128
B0:
	0: MoveLoc[0](Arg0: u128)
	1: StLoc[3](loc1: u128)
	2: MoveLoc[1](Arg1: u128)
	3: StLoc[4](loc2: u128)
	4: CopyLoc[3](loc1: u128)
	5: CopyLoc[4](loc2: u128)
	6: Gt
	7: BrFalse(13)
B1:
	8: MoveLoc[3](loc1: u128)
	9: MoveLoc[4](loc2: u128)
	10: Sub
	11: StLoc[2](loc0: u128)
	12: Branch(17)
B2:
	13: MoveLoc[4](loc2: u128)
	14: MoveLoc[3](loc1: u128)
	15: Sub
	16: StLoc[2](loc0: u128)
B3:
	17: MoveLoc[2](loc0: u128)
	18: Ret
}

public divide_and_round_up(Arg0: u128, Arg1: u128): u128 {
L2:	loc0: u128
L3:	loc1: u128
L4:	loc2: u128
B0:
	0: MoveLoc[0](Arg0: u128)
	1: StLoc[3](loc1: u128)
	2: MoveLoc[1](Arg1: u128)
	3: StLoc[4](loc2: u128)
	4: CopyLoc[3](loc1: u128)
	5: CopyLoc[4](loc2: u128)
	6: Mod
	7: LdU128(0)
	8: Eq
	9: BrFalse(15)
B1:
	10: MoveLoc[3](loc1: u128)
	11: MoveLoc[4](loc2: u128)
	12: Div
	13: StLoc[2](loc0: u128)
	14: Branch(21)
B2:
	15: MoveLoc[3](loc1: u128)
	16: MoveLoc[4](loc2: u128)
	17: Div
	18: LdU128(1)
	19: Add
	20: StLoc[2](loc0: u128)
B3:
	21: MoveLoc[2](loc0: u128)
	22: Ret
}

public pow(Arg0: u128, Arg1: u8): u128 {
L2:	loc0: u128
L3:	loc1: u8
L4:	loc2: u128
B0:
	0: MoveLoc[0](Arg0: u128)
	1: StLoc[2](loc0: u128)
	2: MoveLoc[1](Arg1: u8)
	3: StLoc[3](loc1: u8)
	4: LdU128(1)
	5: StLoc[4](loc2: u128)
B1:
	6: CopyLoc[3](loc1: u8)
	7: LdU8(1)
	8: Ge
	9: BrFalse(35)
B2:
	10: Branch(11)
B3:
	11: CopyLoc[3](loc1: u8)
	12: LdU8(2)
	13: Mod
	14: LdU8(0)
	15: Eq
	16: BrFalse(26)
B4:
	17: CopyLoc[2](loc0: u128)
	18: MoveLoc[2](loc0: u128)
	19: Mul
	20: StLoc[2](loc0: u128)
	21: MoveLoc[3](loc1: u8)
	22: LdU8(2)
	23: Div
	24: StLoc[3](loc1: u8)
	25: Branch(6)
B5:
	26: MoveLoc[4](loc2: u128)
	27: CopyLoc[2](loc0: u128)
	28: Mul
	29: StLoc[4](loc2: u128)
	30: MoveLoc[3](loc1: u8)
	31: LdU8(1)
	32: Sub
	33: StLoc[3](loc1: u8)
	34: Branch(6)
B6:
	35: MoveLoc[4](loc2: u128)
	36: Ret
}

public sqrt(Arg0: u128): u128 {
L1:	loc0: u256
L2:	loc1: u256
L3:	loc2: u128
L4:	loc3: u256
B0:
	0: MoveLoc[0](Arg0: u128)
	1: StLoc[3](loc2: u128)
	2: LdU256(340282366920938463463374607431768211456)
	3: StLoc[1](loc0: u256)
	4: LdU256(0)
	5: StLoc[2](loc1: u256)
	6: MoveLoc[3](loc2: u128)
	7: CastU256
	8: StLoc[4](loc3: u256)
B1:
	9: CopyLoc[1](loc0: u256)
	10: LdU256(0)
	11: Neq
	12: BrFalse(42)
B2:
	13: Branch(14)
B3:
	14: CopyLoc[4](loc3: u256)
	15: CopyLoc[2](loc1: u256)
	16: CopyLoc[1](loc0: u256)
	17: Add
	18: Ge
	19: BrFalse(33)
B4:
	20: MoveLoc[4](loc3: u256)
	21: CopyLoc[2](loc1: u256)
	22: CopyLoc[1](loc0: u256)
	23: Add
	24: Sub
	25: StLoc[4](loc3: u256)
	26: MoveLoc[2](loc1: u256)
	27: LdU8(1)
	28: Shr
	29: CopyLoc[1](loc0: u256)
	30: Add
	31: StLoc[2](loc1: u256)
	32: Branch(37)
B5:
	33: MoveLoc[2](loc1: u256)
	34: LdU8(1)
	35: Shr
	36: StLoc[2](loc1: u256)
B6:
	37: MoveLoc[1](loc0: u256)
	38: LdU8(2)
	39: Shr
	40: StLoc[1](loc0: u256)
	41: Branch(9)
B7:
	42: MoveLoc[2](loc1: u256)
	43: CastU128
	44: Ret
}

public try_as_u8(Arg0: u128): Option<u8> {
L1:	loc0: Option<u8>
L2:	loc1: u128
B0:
	0: MoveLoc[0](Arg0: u128)
	1: StLoc[2](loc1: u128)
	2: CopyLoc[2](loc1: u128)
	3: LdU128(255)
	4: Gt
	5: BrFalse(9)
B1:
	6: Call option::none<u8>(): Option<u8>
	7: StLoc[1](loc0: Option<u8>)
	8: Branch(13)
B2:
	9: MoveLoc[2](loc1: u128)
	10: CastU8
	11: Call option::some<u8>(u8): Option<u8>
	12: StLoc[1](loc0: Option<u8>)
B3:
	13: MoveLoc[1](loc0: Option<u8>)
	14: Ret
}

public try_as_u16(Arg0: u128): Option<u16> {
L1:	loc0: Option<u16>
L2:	loc1: u128
B0:
	0: MoveLoc[0](Arg0: u128)
	1: StLoc[2](loc1: u128)
	2: CopyLoc[2](loc1: u128)
	3: LdU128(65535)
	4: Gt
	5: BrFalse(9)
B1:
	6: Call option::none<u16>(): Option<u16>
	7: StLoc[1](loc0: Option<u16>)
	8: Branch(13)
B2:
	9: MoveLoc[2](loc1: u128)
	10: CastU16
	11: Call option::some<u16>(u16): Option<u16>
	12: StLoc[1](loc0: Option<u16>)
B3:
	13: MoveLoc[1](loc0: Option<u16>)
	14: Ret
}

public try_as_u32(Arg0: u128): Option<u32> {
L1:	loc0: Option<u32>
L2:	loc1: u128
B0:
	0: MoveLoc[0](Arg0: u128)
	1: StLoc[2](loc1: u128)
	2: CopyLoc[2](loc1: u128)
	3: LdU128(4294967295)
	4: Gt
	5: BrFalse(9)
B1:
	6: Call option::none<u32>(): Option<u32>
	7: StLoc[1](loc0: Option<u32>)
	8: Branch(13)
B2:
	9: MoveLoc[2](loc1: u128)
	10: CastU32
	11: Call option::some<u32>(u32): Option<u32>
	12: StLoc[1](loc0: Option<u32>)
B3:
	13: MoveLoc[1](loc0: Option<u32>)
	14: Ret
}

public try_as_u64(Arg0: u128): Option<u64> {
L1:	loc0: Option<u64>
L2:	loc1: u128
B0:
	0: MoveLoc[0](Arg0: u128)
	1: StLoc[2](loc1: u128)
	2: CopyLoc[2](loc1: u128)
	3: LdU128(18446744073709551615)
	4: Gt
	5: BrFalse(9)
B1:
	6: Call option::none<u64>(): Option<u64>
	7: StLoc[1](loc0: Option<u64>)
	8: Branch(13)
B2:
	9: MoveLoc[2](loc1: u128)
	10: CastU64
	11: Call option::some<u64>(u64): Option<u64>
	12: StLoc[1](loc0: Option<u64>)
B3:
	13: MoveLoc[1](loc0: Option<u64>)
	14: Ret
}

public to_string(Arg0: u128): String {
L1:	loc0: String
L2:	loc1: vector<u8>
L3:	loc2: u128
B0:
	0: MoveLoc[0](Arg0: u128)
	1: StLoc[3](loc2: u128)
	2: CopyLoc[3](loc2: u128)
	3: LdU128(0)
	4: Eq
	5: BrFalse(10)
B1:
	6: LdConst[0](vector<u8>: "0" ..)
	7: Call string::utf8(vector<u8>): String
	8: StLoc[1](loc0: String)
	9: Branch(34)
B2:
	10: LdConst[1](vector<u8>: "" /..)
	11: StLoc[2](loc1: vector<u8>)
B3:
	12: CopyLoc[3](loc2: u128)
	13: LdU128(0)
	14: Neq
	15: BrFalse(29)
B4:
	16: MutBorrowLoc[2](loc1: vector<u8>)
	17: LdU128(48)
	18: CopyLoc[3](loc2: u128)
	19: LdU128(10)
	20: Mod
	21: Add
	22: CastU8
	23: VecPushBack(13)
	24: MoveLoc[3](loc2: u128)
	25: LdU128(10)
	26: Div
	27: StLoc[3](loc2: u128)
	28: Branch(12)
B5:
	29: MutBorrowLoc[2](loc1: vector<u8>)
	30: Call vector::reverse<u8>(&mut vector<u8>)
	31: MoveLoc[2](loc1: vector<u8>)
	32: Call string::utf8(vector<u8>): String
	33: StLoc[1](loc0: String)
B6:
	34: MoveLoc[1](loc0: String)
	35: Ret
}

Constants [
	0 => vector<u8>: "0" // interpreted as UTF8 string
	1 => vector<u8>: "" // interpreted as UTF8 string
]
}

// Move bytecode v6
module 1.u16 {
use 0000000000000000000000000000000000000000000000000000000000000001::option;
use 0000000000000000000000000000000000000000000000000000000000000001::string;
use 0000000000000000000000000000000000000000000000000000000000000001::vector;

public bitwise_not(Arg0: u16): u16 {
B0:
	0: MoveLoc[0](Arg0: u16)
	1: LdU16(65535)
	2: Xor
	3: Ret
}

public max(Arg0: u16, Arg1: u16): u16 {
L2:	loc0: u16
L3:	loc1: u16
L4:	loc2: u16
B0:
	0: MoveLoc[0](Arg0: u16)
	1: StLoc[3](loc1: u16)
	2: MoveLoc[1](Arg1: u16)
	3: StLoc[4](loc2: u16)
	4: CopyLoc[3](loc1: u16)
	5: CopyLoc[4](loc2: u16)
	6: Gt
	7: BrFalse(11)
B1:
	8: MoveLoc[3](loc1: u16)
	9: StLoc[2](loc0: u16)
	10: Branch(13)
B2:
	11: MoveLoc[4](loc2: u16)
	12: StLoc[2](loc0: u16)
B3:
	13: MoveLoc[2](loc0: u16)
	14: Ret
}

public min(Arg0: u16, Arg1: u16): u16 {
L2:	loc0: u16
L3:	loc1: u16
L4:	loc2: u16
B0:
	0: MoveLoc[0](Arg0: u16)
	1: StLoc[3](loc1: u16)
	2: MoveLoc[1](Arg1: u16)
	3: StLoc[4](loc2: u16)
	4: CopyLoc[3](loc1: u16)
	5: CopyLoc[4](loc2: u16)
	6: Lt
	7: BrFalse(11)
B1:
	8: MoveLoc[3](loc1: u16)
	9: StLoc[2](loc0: u16)
	10: Branch(13)
B2:
	11: MoveLoc[4](loc2: u16)
	12: StLoc[2](loc0: u16)
B3:
	13: MoveLoc[2](loc0: u16)
	14: Ret
}

public diff(Arg0: u16, Arg1: u16): u16 {
L2:	loc0: u16
L3:	loc1: u16
L4:	loc2: u16
B0:
	0: MoveLoc[0](Arg0: u16)
	1: StLoc[3](loc1: u16)
	2: MoveLoc[1](Arg1: u16)
	3: StLoc[4](loc2: u16)
	4: CopyLoc[3](loc1: u16)
	5: CopyLoc[4](loc2: u16)
	6: Gt
	7: BrFalse(13)
B1:
	8: MoveLoc[3](loc1: u16)
	9: MoveLoc[4](loc2: u16)
	10: Sub
	11: StLoc[2](loc0: u16)
	12: Branch(17)
B2:
	13: MoveLoc[4](loc2: u16)
	14: MoveLoc[3](loc1: u16)
	15: Sub
	16: StLoc[2](loc0: u16)
B3:
	17: MoveLoc[2](loc0: u16)
	18: Ret
}

public divide_and_round_up(Arg0: u16, Arg1: u16): u16 {
L2:	loc0: u16
L3:	loc1: u16
L4:	loc2: u16
B0:
	0: MoveLoc[0](Arg0: u16)
	1: StLoc[3](loc1: u16)
	2: MoveLoc[1](Arg1: u16)
	3: StLoc[4](loc2: u16)
	4: CopyLoc[3](loc1: u16)
	5: CopyLoc[4](loc2: u16)
	6: Mod
	7: LdU16(0)
	8: Eq
	9: BrFalse(15)
B1:
	10: MoveLoc[3](loc1: u16)
	11: MoveLoc[4](loc2: u16)
	12: Div
	13: StLoc[2](loc0: u16)
	14: Branch(21)
B2:
	15: MoveLoc[3](loc1: u16)
	16: MoveLoc[4](loc2: u16)
	17: Div
	18: LdU16(1)
	19: Add
	20: StLoc[2](loc0: u16)
B3:
	21: MoveLoc[2](loc0: u16)
	22: Ret
}

public pow(Arg0: u16, Arg1: u8): u16 {
L2:	loc0: u16
L3:	loc1: u8
L4:	loc2: u16
B0:
	0: MoveLoc[0](Arg0: u16)
	1: StLoc[2](loc0: u16)
	2: MoveLoc[1](Arg1: u8)
	3: StLoc[3](loc1: u8)
	4: LdU16(1)
	5: StLoc[4](loc2: u16)
B1:
	6: CopyLoc[3](loc1: u8)
	7: LdU8(1)
	8: Ge
	9: BrFalse(35)
B2:
	10: Branch(11)
B3:
	11: CopyLoc[3](loc1: u8)
	12: LdU8(2)
	13: Mod
	14: LdU8(0)
	15: Eq
	16: BrFalse(26)
B4:
	17: CopyLoc[2](loc0: u16)
	18: MoveLoc[2](loc0: u16)
	19: Mul
	20: StLoc[2](loc0: u16)
	21: MoveLoc[3](loc1: u8)
	22: LdU8(2)
	23: Div
	24: StLoc[3](loc1: u8)
	25: Branch(6)
B5:
	26: MoveLoc[4](loc2: u16)
	27: CopyLoc[2](loc0: u16)
	28: Mul
	29: StLoc[4](loc2: u16)
	30: MoveLoc[3](loc1: u8)
	31: LdU8(1)
	32: Sub
	33: StLoc[3](loc1: u8)
	34: Branch(6)
B6:
	35: MoveLoc[4](loc2: u16)
	36: Ret
}

public sqrt(Arg0: u16): u16 {
L1:	loc0: u32
L2:	loc1: u32
L3:	loc2: u16
L4:	loc3: u32
B0:
	0: MoveLoc[0](Arg0: u16)
	1: StLoc[3](loc2: u16)
	2: LdU32(65536)
	3: StLoc[1](loc0: u32)
	4: LdU32(0)
	5: StLoc[2](loc1: u32)
	6: MoveLoc[3](loc2: u16)
	7: CastU32
	8: StLoc[4](loc3: u32)
B1:
	9: CopyLoc[1](loc0: u32)
	10: LdU32(0)
	11: Neq
	12: BrFalse(42)
B2:
	13: Branch(14)
B3:
	14: CopyLoc[4](loc3: u32)
	15: CopyLoc[2](loc1: u32)
	16: CopyLoc[1](loc0: u32)
	17: Add
	18: Ge
	19: BrFalse(33)
B4:
	20: MoveLoc[4](loc3: u32)
	21: CopyLoc[2](loc1: u32)
	22: CopyLoc[1](loc0: u32)
	23: Add
	24: Sub
	25: StLoc[4](loc3: u32)
	26: MoveLoc[2](loc1: u32)
	27: LdU8(1)
	28: Shr
	29: CopyLoc[1](loc0: u32)
	30: Add
	31: StLoc[2](loc1: u32)
	32: Branch(37)
B5:
	33: MoveLoc[2](loc1: u32)
	34: LdU8(1)
	35: Shr
	36: StLoc[2](loc1: u32)
B6:
	37: MoveLoc[1](loc0: u32)
	38: LdU8(2)
	39: Shr
	40: StLoc[1](loc0: u32)
	41: Branch(9)
B7:
	42: MoveLoc[2](loc1: u32)
	43: CastU16
	44: Ret
}

public try_as_u8(Arg0: u16): Option<u8> {
L1:	loc0: Option<u8>
L2:	loc1: u16
B0:
	0: MoveLoc[0](Arg0: u16)
	1: StLoc[2](loc1: u16)
	2: CopyLoc[2](loc1: u16)
	3: LdU16(255)
	4: Gt
	5: BrFalse(9)
B1:
	6: Call option::none<u8>(): Option<u8>
	7: StLoc[1](loc0: Option<u8>)
	8: Branch(13)
B2:
	9: MoveLoc[2](loc1: u16)
	10: CastU8
	11: Call option::some<u8>(u8): Option<u8>
	12: StLoc[1](loc0: Option<u8>)
B3:
	13: MoveLoc[1](loc0: Option<u8>)
	14: Ret
}

public to_string(Arg0: u16): String {
L1:	loc0: String
L2:	loc1: vector<u8>
L3:	loc2: u16
B0:
	0: MoveLoc[0](Arg0: u16)
	1: StLoc[3](loc2: u16)
	2: CopyLoc[3](loc2: u16)
	3: LdU16(0)
	4: Eq
	5: BrFalse(10)
B1:
	6: LdConst[0](vector<u8>: "0" ..)
	7: Call string::utf8(vector<u8>): String
	8: StLoc[1](loc0: String)
	9: Branch(34)
B2:
	10: LdConst[1](vector<u8>: "" /..)
	11: StLoc[2](loc1: vector<u8>)
B3:
	12: CopyLoc[3](loc2: u16)
	13: LdU16(0)
	14: Neq
	15: BrFalse(29)
B4:
	16: MutBorrowLoc[2](loc1: vector<u8>)
	17: LdU16(48)
	18: CopyLoc[3](loc2: u16)
	19: LdU16(10)
	20: Mod
	21: Add
	22: CastU8
	23: VecPushBack(10)
	24: MoveLoc[3](loc2: u16)
	25: LdU16(10)
	26: Div
	27: StLoc[3](loc2: u16)
	28: Branch(12)
B5:
	29: MutBorrowLoc[2](loc1: vector<u8>)
	30: Call vector::reverse<u8>(&mut vector<u8>)
	31: MoveLoc[2](loc1: vector<u8>)
	32: Call string::utf8(vector<u8>): String
	33: StLoc[1](loc0: String)
B6:
	34: MoveLoc[1](loc0: String)
	35: Ret
}

Constants [
	0 => vector<u8>: "0" // interpreted as UTF8 string
	1 => vector<u8>: "" // interpreted as UTF8 string
]
}

// Move bytecode v6
module 1.u256 {
use 0000000000000000000000000000000000000000000000000000000000000001::option;
use 0000000000000000000000000000000000000000000000000000000000000001::string;
use 0000000000000000000000000000000000000000000000000000000000000001::vector;

public bitwise_not(Arg0: u256): u256 {
B0:
	0: MoveLoc[0](Arg0: u256)
	1: LdU256(115792089237316195423570985008687907853269984665640564039457584007913129639935)
	2: Xor
	3: Ret
}

public max(Arg0: u256, Arg1: u256): u256 {
L2:	loc0: u256
L3:	loc1: u256
L4:	loc2: u256
B0:
	0: MoveLoc[0](Arg0: u256)
	1: StLoc[3](loc1: u256)
	2: MoveLoc[1](Arg1: u256)
	3: StLoc[4](loc2: u256)
	4: CopyLoc[3](loc1: u256)
	5: CopyLoc[4](loc2: u256)
	6: Gt
	7: BrFalse(11)
B1:
	8: MoveLoc[3](loc1: u256)
	9: StLoc[2](loc0: u256)
	10: Branch(13)
B2:
	11: MoveLoc[4](loc2: u256)
	12: StLoc[2](loc0: u256)
B3:
	13: MoveLoc[2](loc0: u256)
	14: Ret
}

public min(Arg0: u256, Arg1: u256): u256 {
L2:	loc0: u256
L3:	loc1: u256
L4:	loc2: u256
B0:
	0: MoveLoc[0](Arg0: u256)
	1: StLoc[3](loc1: u256)
	2: MoveLoc[1](Arg1: u256)
	3: StLoc[4](loc2: u256)
	4: CopyLoc[3](loc1: u256)
	5: CopyLoc[4](loc2: u256)
	6: Lt
	7: BrFalse(11)
B1:
	8: MoveLoc[3](loc1: u256)
	9: StLoc[2](loc0: u256)
	10: Branch(13)
B2:
	11: MoveLoc[4](loc2: u256)
	12: StLoc[2](loc0: u256)
B3:
	13: MoveLoc[2](loc0: u256)
	14: Ret
}

public diff(Arg0: u256, Arg1: u256): u256 {
L2:	loc0: u256
L3:	loc1: u256
L4:	loc2: u256
B0:
	0: MoveLoc[0](Arg0: u256)
	1: StLoc[3](loc1: u256)
	2: MoveLoc[1](Arg1: u256)
	3: StLoc[4](loc2: u256)
	4: CopyLoc[3](loc1: u256)
	5: CopyLoc[4](loc2: u256)
	6: Gt
	7: BrFalse(13)
B1:
	8: MoveLoc[3](loc1: u256)
	9: MoveLoc[4](loc2: u256)
	10: Sub
	11: StLoc[2](loc0: u256)
	12: Branch(17)
B2:
	13: MoveLoc[4](loc2: u256)
	14: MoveLoc[3](loc1: u256)
	15: Sub
	16: StLoc[2](loc0: u256)
B3:
	17: MoveLoc[2](loc0: u256)
	18: Ret
}

public divide_and_round_up(Arg0: u256, Arg1: u256): u256 {
L2:	loc0: u256
L3:	loc1: u256
L4:	loc2: u256
B0:
	0: MoveLoc[0](Arg0: u256)
	1: StLoc[3](loc1: u256)
	2: MoveLoc[1](Arg1: u256)
	3: StLoc[4](loc2: u256)
	4: CopyLoc[3](loc1: u256)
	5: CopyLoc[4](loc2: u256)
	6: Mod
	7: LdU256(0)
	8: Eq
	9: BrFalse(15)
B1:
	10: MoveLoc[3](loc1: u256)
	11: MoveLoc[4](loc2: u256)
	12: Div
	13: StLoc[2](loc0: u256)
	14: Branch(21)
B2:
	15: MoveLoc[3](loc1: u256)
	16: MoveLoc[4](loc2: u256)
	17: Div
	18: LdU256(1)
	19: Add
	20: StLoc[2](loc0: u256)
B3:
	21: MoveLoc[2](loc0: u256)
	22: Ret
}

public pow(Arg0: u256, Arg1: u8): u256 {
L2:	loc0: u256
L3:	loc1: u8
L4:	loc2: u256
B0:
	0: MoveLoc[0](Arg0: u256)
	1: StLoc[2](loc0: u256)
	2: MoveLoc[1](Arg1: u8)
	3: StLoc[3](loc1: u8)
	4: LdU256(1)
	5: StLoc[4](loc2: u256)
B1:
	6: CopyLoc[3](loc1: u8)
	7: LdU8(1)
	8: Ge
	9: BrFalse(35)
B2:
	10: Branch(11)
B3:
	11: CopyLoc[3](loc1: u8)
	12: LdU8(2)
	13: Mod
	14: LdU8(0)
	15: Eq
	16: BrFalse(26)
B4:
	17: CopyLoc[2](loc0: u256)
	18: MoveLoc[2](loc0: u256)
	19: Mul
	20: StLoc[2](loc0: u256)
	21: MoveLoc[3](loc1: u8)
	22: LdU8(2)
	23: Div
	24: StLoc[3](loc1: u8)
	25: Branch(6)
B5:
	26: MoveLoc[4](loc2: u256)
	27: CopyLoc[2](loc0: u256)
	28: Mul
	29: StLoc[4](loc2: u256)
	30: MoveLoc[3](loc1: u8)
	31: LdU8(1)
	32: Sub
	33: StLoc[3](loc1: u8)
	34: Branch(6)
B6:
	35: MoveLoc[4](loc2: u256)
	36: Ret
}

public try_as_u8(Arg0: u256): Option<u8> {
L1:	loc0: Option<u8>
L2:	loc1: u256
B0:
	0: MoveLoc[0](Arg0: u256)
	1: StLoc[2](loc1: u256)
	2: CopyLoc[2](loc1: u256)
	3: LdU256(255)
	4: Gt
	5: BrFalse(9)
B1:
	6: Call option::none<u8>(): Option<u8>
	7: StLoc[1](loc0: Option<u8>)
	8: Branch(13)
B2:
	9: MoveLoc[2](loc1: u256)
	10: CastU8
	11: Call option::some<u8>(u8): Option<u8>
	12: StLoc[1](loc0: Option<u8>)
B3:
	13: MoveLoc[1](loc0: Option<u8>)
	14: Ret
}

public try_as_u16(Arg0: u256): Option<u16> {
L1:	loc0: Option<u16>
L2:	loc1: u256
B0:
	0: MoveLoc[0](Arg0: u256)
	1: StLoc[2](loc1: u256)
	2: CopyLoc[2](loc1: u256)
	3: LdU256(65535)
	4: Gt
	5: BrFalse(9)
B1:
	6: Call option::none<u16>(): Option<u16>
	7: StLoc[1](loc0: Option<u16>)
	8: Branch(13)
B2:
	9: MoveLoc[2](loc1: u256)
	10: CastU16
	11: Call option::some<u16>(u16): Option<u16>
	12: StLoc[1](loc0: Option<u16>)
B3:
	13: MoveLoc[1](loc0: Option<u16>)
	14: Ret
}

public try_as_u32(Arg0: u256): Option<u32> {
L1:	loc0: Option<u32>
L2:	loc1: u256
B0:
	0: MoveLoc[0](Arg0: u256)
	1: StLoc[2](loc1: u256)
	2: CopyLoc[2](loc1: u256)
	3: LdU256(4294967295)
	4: Gt
	5: BrFalse(9)
B1:
	6: Call option::none<u32>(): Option<u32>
	7: StLoc[1](loc0: Option<u32>)
	8: Branch(13)
B2:
	9: MoveLoc[2](loc1: u256)
	10: CastU32
	11: Call option::some<u32>(u32): Option<u32>
	12: StLoc[1](loc0: Option<u32>)
B3:
	13: MoveLoc[1](loc0: Option<u32>)
	14: Ret
}

public try_as_u64(Arg0: u256): Option<u64> {
L1:	loc0: Option<u64>
L2:	loc1: u256
B0:
	0: MoveLoc[0](Arg0: u256)
	1: StLoc[2](loc1: u256)
	2: CopyLoc[2](loc1: u256)
	3: LdU256(18446744073709551615)
	4: Gt
	5: BrFalse(9)
B1:
	6: Call option::none<u64>(): Option<u64>
	7: StLoc[1](loc0: Option<u64>)
	8: Branch(13)
B2:
	9: MoveLoc[2](loc1: u256)
	10: CastU64
	11: Call option::some<u64>(u64): Option<u64>
	12: StLoc[1](loc0: Option<u64>)
B3:
	13: MoveLoc[1](loc0: Option<u64>)
	14: Ret
}

public try_as_u128(Arg0: u256): Option<u128> {
L1:	loc0: Option<u128>
L2:	loc1: u256
B0:
	0: MoveLoc[0](Arg0: u256)
	1: StLoc[2](loc1: u256)
	2: CopyLoc[2](loc1: u256)
	3: LdU256(340282366920938463463374607431768211455)
	4: Gt
	5: BrFalse(9)
B1:
	6: Call option::none<u128>(): Option<u128>
	7: StLoc[1](loc0: Option<u128>)
	8: Branch(13)
B2:
	9: MoveLoc[2](loc1: u256)
	10: CastU128
	11: Call option::some<u128>(u128): Option<u128>
	12: StLoc[1](loc0: Option<u128>)
B3:
	13: MoveLoc[1](loc0: Option<u128>)
	14: Ret
}

public to_string(Arg0: u256): String {
L1:	loc0: String
L2:	loc1: vector<u8>
L3:	loc2: u256
B0:
	0: MoveLoc[0](Arg0: u256)
	1: StLoc[3](loc2: u256)
	2: CopyLoc[3](loc2: u256)
	3: LdU256(0)
	4: Eq
	5: BrFalse(10)
B1:
	6: LdConst[0](vector<u8>: "0" ..)
	7: Call string::utf8(vector<u8>): String
	8: StLoc[1](loc0: String)
	9: Branch(34)
B2:
	10: LdConst[1](vector<u8>: "" /..)
	11: StLoc[2](loc1: vector<u8>)
B3:
	12: CopyLoc[3](loc2: u256)
	13: LdU256(0)
	14: Neq
	15: BrFalse(29)
B4:
	16: MutBorrowLoc[2](loc1: vector<u8>)
	17: LdU256(48)
	18: CopyLoc[3](loc2: u256)
	19: LdU256(10)
	20: Mod
	21: Add
	22: CastU8
	23: VecPushBack(13)
	24: MoveLoc[3](loc2: u256)
	25: LdU256(10)
	26: Div
	27: StLoc[3](loc2: u256)
	28: Branch(12)
B5:
	29: MutBorrowLoc[2](loc1: vector<u8>)
	30: Call vector::reverse<u8>(&mut vector<u8>)
	31: MoveLoc[2](loc1: vector<u8>)
	32: Call string::utf8(vector<u8>): String
	33: StLoc[1](loc0: String)
B6:
	34: MoveLoc[1](loc0: String)
	35: Ret
}

Constants [
	0 => vector<u8>: "0" // interpreted as UTF8 string
	1 => vector<u8>: "" // interpreted as UTF8 string
]
}

// Move bytecode v6
module 1.u32 {
use 0000000000000000000000000000000000000000000000000000000000000001::option;
use 0000000000000000000000000000000000000000000000000000000000000001::string;
use 0000000000000000000000000000000000000000000000000000000000000001::vector;

public bitwise_not(Arg0: u32): u32 {
B0:
	0: MoveLoc[0](Arg0: u32)
	1: LdU32(4294967295)
	2: Xor
	3: Ret
}

public max(Arg0: u32, Arg1: u32): u32 {
L2:	loc0: u32
L3:	loc1: u32
L4:	loc2: u32
B0:
	0: MoveLoc[0](Arg0: u32)
	1: StLoc[3](loc1: u32)
	2: MoveLoc[1](Arg1: u32)
	3: StLoc[4](loc2: u32)
	4: CopyLoc[3](loc1: u32)
	5: CopyLoc[4](loc2: u32)
	6: Gt
	7: BrFalse(11)
B1:
	8: MoveLoc[3](loc1: u32)
	9: StLoc[2](loc0: u32)
	10: Branch(13)
B2:
	11: MoveLoc[4](loc2: u32)
	12: StLoc[2](loc0: u32)
B3:
	13: MoveLoc[2](loc0: u32)
	14: Ret
}

public min(Arg0: u32, Arg1: u32): u32 {
L2:	loc0: u32
L3:	loc1: u32
L4:	loc2: u32
B0:
	0: MoveLoc[0](Arg0: u32)
	1: StLoc[3](loc1: u32)
	2: MoveLoc[1](Arg1: u32)
	3: StLoc[4](loc2: u32)
	4: CopyLoc[3](loc1: u32)
	5: CopyLoc[4](loc2: u32)
	6: Lt
	7: BrFalse(11)
B1:
	8: MoveLoc[3](loc1: u32)
	9: StLoc[2](loc0: u32)
	10: Branch(13)
B2:
	11: MoveLoc[4](loc2: u32)
	12: StLoc[2](loc0: u32)
B3:
	13: MoveLoc[2](loc0: u32)
	14: Ret
}

public diff(Arg0: u32, Arg1: u32): u32 {
L2:	loc0: u32
L3:	loc1: u32
L4:	loc2: u32
B0:
	0: MoveLoc[0](Arg0: u32)
	1: StLoc[3](loc1: u32)
	2: MoveLoc[1](Arg1: u32)
	3: StLoc[4](loc2: u32)
	4: CopyLoc[3](loc1: u32)
	5: CopyLoc[4](loc2: u32)
	6: Gt
	7: BrFalse(13)
B1:
	8: MoveLoc[3](loc1: u32)
	9: MoveLoc[4](loc2: u32)
	10: Sub
	11: StLoc[2](loc0: u32)
	12: Branch(17)
B2:
	13: MoveLoc[4](loc2: u32)
	14: MoveLoc[3](loc1: u32)
	15: Sub
	16: StLoc[2](loc0: u32)
B3:
	17: MoveLoc[2](loc0: u32)
	18: Ret
}

public divide_and_round_up(Arg0: u32, Arg1: u32): u32 {
L2:	loc0: u32
L3:	loc1: u32
L4:	loc2: u32
B0:
	0: MoveLoc[0](Arg0: u32)
	1: StLoc[3](loc1: u32)
	2: MoveLoc[1](Arg1: u32)
	3: StLoc[4](loc2: u32)
	4: CopyLoc[3](loc1: u32)
	5: CopyLoc[4](loc2: u32)
	6: Mod
	7: LdU32(0)
	8: Eq
	9: BrFalse(15)
B1:
	10: MoveLoc[3](loc1: u32)
	11: MoveLoc[4](loc2: u32)
	12: Div
	13: StLoc[2](loc0: u32)
	14: Branch(21)
B2:
	15: MoveLoc[3](loc1: u32)
	16: MoveLoc[4](loc2: u32)
	17: Div
	18: LdU32(1)
	19: Add
	20: StLoc[2](loc0: u32)
B3:
	21: MoveLoc[2](loc0: u32)
	22: Ret
}

public pow(Arg0: u32, Arg1: u8): u32 {
L2:	loc0: u32
L3:	loc1: u8
L4:	loc2: u32
B0:
	0: MoveLoc[0](Arg0: u32)
	1: StLoc[2](loc0: u32)
	2: MoveLoc[1](Arg1: u8)
	3: StLoc[3](loc1: u8)
	4: LdU32(1)
	5: StLoc[4](loc2: u32)
B1:
	6: CopyLoc[3](loc1: u8)
	7: LdU8(1)
	8: Ge
	9: BrFalse(35)
B2:
	10: Branch(11)
B3:
	11: CopyLoc[3](loc1: u8)
	12: LdU8(2)
	13: Mod
	14: LdU8(0)
	15: Eq
	16: BrFalse(26)
B4:
	17: CopyLoc[2](loc0: u32)
	18: MoveLoc[2](loc0: u32)
	19: Mul
	20: StLoc[2](loc0: u32)
	21: MoveLoc[3](loc1: u8)
	22: LdU8(2)
	23: Div
	24: StLoc[3](loc1: u8)
	25: Branch(6)
B5:
	26: MoveLoc[4](loc2: u32)
	27: CopyLoc[2](loc0: u32)
	28: Mul
	29: StLoc[4](loc2: u32)
	30: MoveLoc[3](loc1: u8)
	31: LdU8(1)
	32: Sub
	33: StLoc[3](loc1: u8)
	34: Branch(6)
B6:
	35: MoveLoc[4](loc2: u32)
	36: Ret
}

public sqrt(Arg0: u32): u32 {
L1:	loc0: u64
L2:	loc1: u64
L3:	loc2: u32
L4:	loc3: u64
B0:
	0: MoveLoc[0](Arg0: u32)
	1: StLoc[3](loc2: u32)
	2: LdU64(4294967296)
	3: StLoc[1](loc0: u64)
	4: LdU64(0)
	5: StLoc[2](loc1: u64)
	6: MoveLoc[3](loc2: u32)
	7: CastU64
	8: StLoc[4](loc3: u64)
B1:
	9: CopyLoc[1](loc0: u64)
	10: LdU64(0)
	11: Neq
	12: BrFalse(42)
B2:
	13: Branch(14)
B3:
	14: CopyLoc[4](loc3: u64)
	15: CopyLoc[2](loc1: u64)
	16: CopyLoc[1](loc0: u64)
	17: Add
	18: Ge
	19: BrFalse(33)
B4:
	20: MoveLoc[4](loc3: u64)
	21: CopyLoc[2](loc1: u64)
	22: CopyLoc[1](loc0: u64)
	23: Add
	24: Sub
	25: StLoc[4](loc3: u64)
	26: MoveLoc[2](loc1: u64)
	27: LdU8(1)
	28: Shr
	29: CopyLoc[1](loc0: u64)
	30: Add
	31: StLoc[2](loc1: u64)
	32: Branch(37)
B5:
	33: MoveLoc[2](loc1: u64)
	34: LdU8(1)
	35: Shr
	36: StLoc[2](loc1: u64)
B6:
	37: MoveLoc[1](loc0: u64)
	38: LdU8(2)
	39: Shr
	40: StLoc[1](loc0: u64)
	41: Branch(9)
B7:
	42: MoveLoc[2](loc1: u64)
	43: CastU32
	44: Ret
}

public try_as_u8(Arg0: u32): Option<u8> {
L1:	loc0: Option<u8>
L2:	loc1: u32
B0:
	0: MoveLoc[0](Arg0: u32)
	1: StLoc[2](loc1: u32)
	2: CopyLoc[2](loc1: u32)
	3: LdU32(255)
	4: Gt
	5: BrFalse(9)
B1:
	6: Call option::none<u8>(): Option<u8>
	7: StLoc[1](loc0: Option<u8>)
	8: Branch(13)
B2:
	9: MoveLoc[2](loc1: u32)
	10: CastU8
	11: Call option::some<u8>(u8): Option<u8>
	12: StLoc[1](loc0: Option<u8>)
B3:
	13: MoveLoc[1](loc0: Option<u8>)
	14: Ret
}

public try_as_u16(Arg0: u32): Option<u16> {
L1:	loc0: Option<u16>
L2:	loc1: u32
B0:
	0: MoveLoc[0](Arg0: u32)
	1: StLoc[2](loc1: u32)
	2: CopyLoc[2](loc1: u32)
	3: LdU32(65535)
	4: Gt
	5: BrFalse(9)
B1:
	6: Call option::none<u16>(): Option<u16>
	7: StLoc[1](loc0: Option<u16>)
	8: Branch(13)
B2:
	9: MoveLoc[2](loc1: u32)
	10: CastU16
	11: Call option::some<u16>(u16): Option<u16>
	12: StLoc[1](loc0: Option<u16>)
B3:
	13: MoveLoc[1](loc0: Option<u16>)
	14: Ret
}

public to_string(Arg0: u32): String {
L1:	loc0: String
L2:	loc1: vector<u8>
L3:	loc2: u32
B0:
	0: MoveLoc[0](Arg0: u32)
	1: StLoc[3](loc2: u32)
	2: CopyLoc[3](loc2: u32)
	3: LdU32(0)
	4: Eq
	5: BrFalse(10)
B1:
	6: LdConst[0](vector<u8>: "0" ..)
	7: Call string::utf8(vector<u8>): String
	8: StLoc[1](loc0: String)
	9: Branch(34)
B2:
	10: LdConst[1](vector<u8>: "" /..)
	11: StLoc[2](loc1: vector<u8>)
B3:
	12: CopyLoc[3](loc2: u32)
	13: LdU32(0)
	14: Neq
	15: BrFalse(29)
B4:
	16: MutBorrowLoc[2](loc1: vector<u8>)
	17: LdU32(48)
	18: CopyLoc[3](loc2: u32)
	19: LdU32(10)
	20: Mod
	21: Add
	22: CastU8
	23: VecPushBack(11)
	24: MoveLoc[3](loc2: u32)
	25: LdU32(10)
	26: Div
	27: StLoc[3](loc2: u32)
	28: Branch(12)
B5:
	29: MutBorrowLoc[2](loc1: vector<u8>)
	30: Call vector::reverse<u8>(&mut vector<u8>)
	31: MoveLoc[2](loc1: vector<u8>)
	32: Call string::utf8(vector<u8>): String
	33: StLoc[1](loc0: String)
B6:
	34: MoveLoc[1](loc0: String)
	35: Ret
}

Constants [
	0 => vector<u8>: "0" // interpreted as UTF8 string
	1 => vector<u8>: "" // interpreted as UTF8 string
]
}

// Move bytecode v6
module 1.u64 {
use 0000000000000000000000000000000000000000000000000000000000000001::option;
use 0000000000000000000000000000000000000000000000000000000000000001::string;
use 0000000000000000000000000000000000000000000000000000000000000001::vector;

public bitwise_not(Arg0: u64): u64 {
B0:
	0: MoveLoc[0](Arg0: u64)
	1: LdU64(18446744073709551615)
	2: Xor
	3: Ret
}

public max(Arg0: u64, Arg1: u64): u64 {
L2:	loc0: u64
L3:	loc1: u64
L4:	loc2: u64
B0:
	0: MoveLoc[0](Arg0: u64)
	1: StLoc[3](loc1: u64)
	2: MoveLoc[1](Arg1: u64)
	3: StLoc[4](loc2: u64)
	4: CopyLoc[3](loc1: u64)
	5: CopyLoc[4](loc2: u64)
	6: Gt
	7: BrFalse(11)
B1:
	8: MoveLoc[3](loc1: u64)
	9: StLoc[2](loc0: u64)
	10: Branch(13)
B2:
	11: MoveLoc[4](loc2: u64)
	12: StLoc[2](loc0: u64)
B3:
	13: MoveLoc[2](loc0: u64)
	14: Ret
}

public min(Arg0: u64, Arg1: u64): u64 {
L2:	loc0: u64
L3:	loc1: u64
L4:	loc2: u64
B0:
	0: MoveLoc[0](Arg0: u64)
	1: StLoc[3](loc1: u64)
	2: MoveLoc[1](Arg1: u64)
	3: StLoc[4](loc2: u64)
	4: CopyLoc[3](loc1: u64)
	5: CopyLoc[4](loc2: u64)
	6: Lt
	7: BrFalse(11)
B1:
	8: MoveLoc[3](loc1: u64)
	9: StLoc[2](loc0: u64)
	10: Branch(13)
B2:
	11: MoveLoc[4](loc2: u64)
	12: StLoc[2](loc0: u64)
B3:
	13: MoveLoc[2](loc0: u64)
	14: Ret
}

public diff(Arg0: u64, Arg1: u64): u64 {
L2:	loc0: u64
L3:	loc1: u64
L4:	loc2: u64
B0:
	0: MoveLoc[0](Arg0: u64)
	1: StLoc[3](loc1: u64)
	2: MoveLoc[1](Arg1: u64)
	3: StLoc[4](loc2: u64)
	4: CopyLoc[3](loc1: u64)
	5: CopyLoc[4](loc2: u64)
	6: Gt
	7: BrFalse(13)
B1:
	8: MoveLoc[3](loc1: u64)
	9: MoveLoc[4](loc2: u64)
	10: Sub
	11: StLoc[2](loc0: u64)
	12: Branch(17)
B2:
	13: MoveLoc[4](loc2: u64)
	14: MoveLoc[3](loc1: u64)
	15: Sub
	16: StLoc[2](loc0: u64)
B3:
	17: MoveLoc[2](loc0: u64)
	18: Ret
}

public divide_and_round_up(Arg0: u64, Arg1: u64): u64 {
L2:	loc0: u64
L3:	loc1: u64
L4:	loc2: u64
B0:
	0: MoveLoc[0](Arg0: u64)
	1: StLoc[3](loc1: u64)
	2: MoveLoc[1](Arg1: u64)
	3: StLoc[4](loc2: u64)
	4: CopyLoc[3](loc1: u64)
	5: CopyLoc[4](loc2: u64)
	6: Mod
	7: LdU64(0)
	8: Eq
	9: BrFalse(15)
B1:
	10: MoveLoc[3](loc1: u64)
	11: MoveLoc[4](loc2: u64)
	12: Div
	13: StLoc[2](loc0: u64)
	14: Branch(21)
B2:
	15: MoveLoc[3](loc1: u64)
	16: MoveLoc[4](loc2: u64)
	17: Div
	18: LdU64(1)
	19: Add
	20: StLoc[2](loc0: u64)
B3:
	21: MoveLoc[2](loc0: u64)
	22: Ret
}

public pow(Arg0: u64, Arg1: u8): u64 {
L2:	loc0: u64
L3:	loc1: u8
L4:	loc2: u64
B0:
	0: MoveLoc[0](Arg0: u64)
	1: StLoc[2](loc0: u64)
	2: MoveLoc[1](Arg1: u8)
	3: StLoc[3](loc1: u8)
	4: LdU64(1)
	5: StLoc[4](loc2: u64)
B1:
	6: CopyLoc[3](loc1: u8)
	7: LdU8(1)
	8: Ge
	9: BrFalse(35)
B2:
	10: Branch(11)
B3:
	11: CopyLoc[3](loc1: u8)
	12: LdU8(2)
	13: Mod
	14: LdU8(0)
	15: Eq
	16: BrFalse(26)
B4:
	17: CopyLoc[2](loc0: u64)
	18: MoveLoc[2](loc0: u64)
	19: Mul
	20: StLoc[2](loc0: u64)
	21: MoveLoc[3](loc1: u8)
	22: LdU8(2)
	23: Div
	24: StLoc[3](loc1: u8)
	25: Branch(6)
B5:
	26: MoveLoc[4](loc2: u64)
	27: CopyLoc[2](loc0: u64)
	28: Mul
	29: StLoc[4](loc2: u64)
	30: MoveLoc[3](loc1: u8)
	31: LdU8(1)
	32: Sub
	33: StLoc[3](loc1: u8)
	34: Branch(6)
B6:
	35: MoveLoc[4](loc2: u64)
	36: Ret
}

public sqrt(Arg0: u64): u64 {
L1:	loc0: u128
L2:	loc1: u128
L3:	loc2: u64
L4:	loc3: u128
B0:
	0: MoveLoc[0](Arg0: u64)
	1: StLoc[3](loc2: u64)
	2: LdU128(18446744073709551616)
	3: StLoc[1](loc0: u128)
	4: LdU128(0)
	5: StLoc[2](loc1: u128)
	6: MoveLoc[3](loc2: u64)
	7: CastU128
	8: StLoc[4](loc3: u128)
B1:
	9: CopyLoc[1](loc0: u128)
	10: LdU128(0)
	11: Neq
	12: BrFalse(42)
B2:
	13: Branch(14)
B3:
	14: CopyLoc[4](loc3: u128)
	15: CopyLoc[2](loc1: u128)
	16: CopyLoc[1](loc0: u128)
	17: Add
	18: Ge
	19: BrFalse(33)
B4:
	20: MoveLoc[4](loc3: u128)
	21: CopyLoc[2](loc1: u128)
	22: CopyLoc[1](loc0: u128)
	23: Add
	24: Sub
	25: StLoc[4](loc3: u128)
	26: MoveLoc[2](loc1: u128)
	27: LdU8(1)
	28: Shr
	29: CopyLoc[1](loc0: u128)
	30: Add
	31: StLoc[2](loc1: u128)
	32: Branch(37)
B5:
	33: MoveLoc[2](loc1: u128)
	34: LdU8(1)
	35: Shr
	36: StLoc[2](loc1: u128)
B6:
	37: MoveLoc[1](loc0: u128)
	38: LdU8(2)
	39: Shr
	40: StLoc[1](loc0: u128)
	41: Branch(9)
B7:
	42: MoveLoc[2](loc1: u128)
	43: CastU64
	44: Ret
}

public try_as_u8(Arg0: u64): Option<u8> {
L1:	loc0: Option<u8>
L2:	loc1: u64
B0:
	0: MoveLoc[0](Arg0: u64)
	1: StLoc[2](loc1: u64)
	2: CopyLoc[2](loc1: u64)
	3: LdU64(255)
	4: Gt
	5: BrFalse(9)
B1:
	6: Call option::none<u8>(): Option<u8>
	7: StLoc[1](loc0: Option<u8>)
	8: Branch(13)
B2:
	9: MoveLoc[2](loc1: u64)
	10: CastU8
	11: Call option::some<u8>(u8): Option<u8>
	12: StLoc[1](loc0: Option<u8>)
B3:
	13: MoveLoc[1](loc0: Option<u8>)
	14: Ret
}

public try_as_u16(Arg0: u64): Option<u16> {
L1:	loc0: Option<u16>
L2:	loc1: u64
B0:
	0: MoveLoc[0](Arg0: u64)
	1: StLoc[2](loc1: u64)
	2: CopyLoc[2](loc1: u64)
	3: LdU64(65535)
	4: Gt
	5: BrFalse(9)
B1:
	6: Call option::none<u16>(): Option<u16>
	7: StLoc[1](loc0: Option<u16>)
	8: Branch(13)
B2:
	9: MoveLoc[2](loc1: u64)
	10: CastU16
	11: Call option::some<u16>(u16): Option<u16>
	12: StLoc[1](loc0: Option<u16>)
B3:
	13: MoveLoc[1](loc0: Option<u16>)
	14: Ret
}

public try_as_u32(Arg0: u64): Option<u32> {
L1:	loc0: Option<u32>
L2:	loc1: u64
B0:
	0: MoveLoc[0](Arg0: u64)
	1: StLoc[2](loc1: u64)
	2: CopyLoc[2](loc1: u64)
	3: LdU64(4294967295)
	4: Gt
	5: BrFalse(9)
B1:
	6: Call option::none<u32>(): Option<u32>
	7: StLoc[1](loc0: Option<u32>)
	8: Branch(13)
B2:
	9: MoveLoc[2](loc1: u64)
	10: CastU32
	11: Call option::some<u32>(u32): Option<u32>
	12: StLoc[1](loc0: Option<u32>)
B3:
	13: MoveLoc[1](loc0: Option<u32>)
	14: Ret
}

public to_string(Arg0: u64): String {
L1:	loc0: String
L2:	loc1: vector<u8>
L3:	loc2: u64
B0:
	0: MoveLoc[0](Arg0: u64)
	1: StLoc[3](loc2: u64)
	2: CopyLoc[3](loc2: u64)
	3: LdU64(0)
	4: Eq
	5: BrFalse(10)
B1:
	6: LdConst[0](vector<u8>: "0" ..)
	7: Call string::utf8(vector<u8>): String
	8: StLoc[1](loc0: String)
	9: Branch(34)
B2:
	10: LdConst[1](vector<u8>: "" /..)
	11: StLoc[2](loc1: vector<u8>)
B3:
	12: CopyLoc[3](loc2: u64)
	13: LdU64(0)
	14: Neq
	15: BrFalse(29)
B4:
	16: MutBorrowLoc[2](loc1: vector<u8>)
	17: LdU64(48)
	18: CopyLoc[3](loc2: u64)
	19: LdU64(10)
	20: Mod
	21: Add
	22: CastU8
	23: VecPushBack(12)
	24: MoveLoc[3](loc2: u64)
	25: LdU64(10)
	26: Div
	27: StLoc[3](loc2: u64)
	28: Branch(12)
B5:
	29: MutBorrowLoc[2](loc1: vector<u8>)
	30: Call vector::reverse<u8>(&mut vector<u8>)
	31: MoveLoc[2](loc1: vector<u8>)
	32: Call string::utf8(vector<u8>): String
	33: StLoc[1](loc0: String)
B6:
	34: MoveLoc[1](loc0: String)
	35: Ret
}

Constants [
	0 => vector<u8>: "0" // interpreted as UTF8 string
	1 => vector<u8>: "" // interpreted as UTF8 string
]
}

// Move bytecode v6
module 1.u8 {
use 0000000000000000000000000000000000000000000000000000000000000001::string;
use 0000000000000000000000000000000000000000000000000000000000000001::vector;

public bitwise_not(Arg0: u8): u8 {
B0:
	0: MoveLoc[0](Arg0: u8)
	1: LdU8(255)
	2: Xor
	3: Ret
}

public max(Arg0: u8, Arg1: u8): u8 {
L2:	loc0: u8
L3:	loc1: u8
L4:	loc2: u8
B0:
	0: MoveLoc[0](Arg0: u8)
	1: StLoc[3](loc1: u8)
	2: MoveLoc[1](Arg1: u8)
	3: StLoc[4](loc2: u8)
	4: CopyLoc[3](loc1: u8)
	5: CopyLoc[4](loc2: u8)
	6: Gt
	7: BrFalse(11)
B1:
	8: MoveLoc[3](loc1: u8)
	9: StLoc[2](loc0: u8)
	10: Branch(13)
B2:
	11: MoveLoc[4](loc2: u8)
	12: StLoc[2](loc0: u8)
B3:
	13: MoveLoc[2](loc0: u8)
	14: Ret
}

public min(Arg0: u8, Arg1: u8): u8 {
L2:	loc0: u8
L3:	loc1: u8
L4:	loc2: u8
B0:
	0: MoveLoc[0](Arg0: u8)
	1: StLoc[3](loc1: u8)
	2: MoveLoc[1](Arg1: u8)
	3: StLoc[4](loc2: u8)
	4: CopyLoc[3](loc1: u8)
	5: CopyLoc[4](loc2: u8)
	6: Lt
	7: BrFalse(11)
B1:
	8: MoveLoc[3](loc1: u8)
	9: StLoc[2](loc0: u8)
	10: Branch(13)
B2:
	11: MoveLoc[4](loc2: u8)
	12: StLoc[2](loc0: u8)
B3:
	13: MoveLoc[2](loc0: u8)
	14: Ret
}

public diff(Arg0: u8, Arg1: u8): u8 {
L2:	loc0: u8
L3:	loc1: u8
L4:	loc2: u8
B0:
	0: MoveLoc[0](Arg0: u8)
	1: StLoc[3](loc1: u8)
	2: MoveLoc[1](Arg1: u8)
	3: StLoc[4](loc2: u8)
	4: CopyLoc[3](loc1: u8)
	5: CopyLoc[4](loc2: u8)
	6: Gt
	7: BrFalse(13)
B1:
	8: MoveLoc[3](loc1: u8)
	9: MoveLoc[4](loc2: u8)
	10: Sub
	11: StLoc[2](loc0: u8)
	12: Branch(17)
B2:
	13: MoveLoc[4](loc2: u8)
	14: MoveLoc[3](loc1: u8)
	15: Sub
	16: StLoc[2](loc0: u8)
B3:
	17: MoveLoc[2](loc0: u8)
	18: Ret
}

public divide_and_round_up(Arg0: u8, Arg1: u8): u8 {
L2:	loc0: u8
L3:	loc1: u8
L4:	loc2: u8
B0:
	0: MoveLoc[0](Arg0: u8)
	1: StLoc[3](loc1: u8)
	2: MoveLoc[1](Arg1: u8)
	3: StLoc[4](loc2: u8)
	4: CopyLoc[3](loc1: u8)
	5: CopyLoc[4](loc2: u8)
	6: Mod
	7: LdU8(0)
	8: Eq
	9: BrFalse(15)
B1:
	10: MoveLoc[3](loc1: u8)
	11: MoveLoc[4](loc2: u8)
	12: Div
	13: StLoc[2](loc0: u8)
	14: Branch(21)
B2:
	15: MoveLoc[3](loc1: u8)
	16: MoveLoc[4](loc2: u8)
	17: Div
	18: LdU8(1)
	19: Add
	20: StLoc[2](loc0: u8)
B3:
	21: MoveLoc[2](loc0: u8)
	22: Ret
}

public pow(Arg0: u8, Arg1: u8): u8 {
L2:	loc0: u8
L3:	loc1: u8
L4:	loc2: u8
B0:
	0: MoveLoc[0](Arg0: u8)
	1: StLoc[2](loc0: u8)
	2: MoveLoc[1](Arg1: u8)
	3: StLoc[3](loc1: u8)
	4: LdU8(1)
	5: StLoc[4](loc2: u8)
B1:
	6: CopyLoc[3](loc1: u8)
	7: LdU8(1)
	8: Ge
	9: BrFalse(35)
B2:
	10: Branch(11)
B3:
	11: CopyLoc[3](loc1: u8)
	12: LdU8(2)
	13: Mod
	14: LdU8(0)
	15: Eq
	16: BrFalse(26)
B4:
	17: CopyLoc[2](loc0: u8)
	18: MoveLoc[2](loc0: u8)
	19: Mul
	20: StLoc[2](loc0: u8)
	21: MoveLoc[3](loc1: u8)
	22: LdU8(2)
	23: Div
	24: StLoc[3](loc1: u8)
	25: Branch(6)
B5:
	26: MoveLoc[4](loc2: u8)
	27: CopyLoc[2](loc0: u8)
	28: Mul
	29: StLoc[4](loc2: u8)
	30: MoveLoc[3](loc1: u8)
	31: LdU8(1)
	32: Sub
	33: StLoc[3](loc1: u8)
	34: Branch(6)
B6:
	35: MoveLoc[4](loc2: u8)
	36: Ret
}

public sqrt(Arg0: u8): u8 {
L1:	loc0: u16
L2:	loc1: u16
L3:	loc2: u8
L4:	loc3: u16
B0:
	0: MoveLoc[0](Arg0: u8)
	1: StLoc[3](loc2: u8)
	2: LdU16(256)
	3: StLoc[1](loc0: u16)
	4: LdU16(0)
	5: StLoc[2](loc1: u16)
	6: MoveLoc[3](loc2: u8)
	7: CastU16
	8: StLoc[4](loc3: u16)
B1:
	9: CopyLoc[1](loc0: u16)
	10: LdU16(0)
	11: Neq
	12: BrFalse(42)
B2:
	13: Branch(14)
B3:
	14: CopyLoc[4](loc3: u16)
	15: CopyLoc[2](loc1: u16)
	16: CopyLoc[1](loc0: u16)
	17: Add
	18: Ge
	19: BrFalse(33)
B4:
	20: MoveLoc[4](loc3: u16)
	21: CopyLoc[2](loc1: u16)
	22: CopyLoc[1](loc0: u16)
	23: Add
	24: Sub
	25: StLoc[4](loc3: u16)
	26: MoveLoc[2](loc1: u16)
	27: LdU8(1)
	28: Shr
	29: CopyLoc[1](loc0: u16)
	30: Add
	31: StLoc[2](loc1: u16)
	32: Branch(37)
B5:
	33: MoveLoc[2](loc1: u16)
	34: LdU8(1)
	35: Shr
	36: StLoc[2](loc1: u16)
B6:
	37: MoveLoc[1](loc0: u16)
	38: LdU8(2)
	39: Shr
	40: StLoc[1](loc0: u16)
	41: Branch(9)
B7:
	42: MoveLoc[2](loc1: u16)
	43: CastU8
	44: Ret
}

public to_string(Arg0: u8): String {
L1:	loc0: String
L2:	loc1: vector<u8>
L3:	loc2: u8
B0:
	0: MoveLoc[0](Arg0: u8)
	1: StLoc[3](loc2: u8)
	2: CopyLoc[3](loc2: u8)
	3: LdU8(0)
	4: Eq
	5: BrFalse(10)
B1:
	6: LdConst[0](vector<u8>: "0" ..)
	7: Call string::utf8(vector<u8>): String
	8: StLoc[1](loc0: String)
	9: Branch(34)
B2:
	10: LdConst[1](vector<u8>: "" /..)
	11: StLoc[2](loc1: vector<u8>)
B3:
	12: CopyLoc[3](loc2: u8)
	13: LdU8(0)
	14: Neq
	15: BrFalse(29)
B4:
	16: MutBorrowLoc[2](loc1: vector<u8>)
	17: LdU8(48)
	18: CopyLoc[3](loc2: u8)
	19: LdU8(10)
	20: Mod
	21: Add
	22: CastU8
	23: VecPushBack(0)
	24: MoveLoc[3](loc2: u8)
	25: LdU8(10)
	26: Div
	27: StLoc[3](loc2: u8)
	28: Branch(12)
B5:
	29: MutBorrowLoc[2](loc1: vector<u8>)
	30: Call vector::reverse<u8>(&mut vector<u8>)
	31: MoveLoc[2](loc1: vector<u8>)
	32: Call string::utf8(vector<u8>): String
	33: StLoc[1](loc0: String)
B6:
	34: MoveLoc[1](loc0: String)
	35: Ret
}

Constants [
	0 => vector<u8>: "0" // interpreted as UTF8 string
	1 => vector<u8>: "" // interpreted as UTF8 string
]
}

// Move bytecode v6
module 1.uq32_32 {

struct UQ32_32 has copy, drop, store {
	pos0: u64
}

public from_quotient(Arg0: u64, Arg1: u64): UQ32_32 {
L2:	loc0: bool
L3:	loc1: u64
L4:	loc2: u64
L5:	loc3: u128
L6:	loc4: u128
L7:	loc5: u128
B0:
	0: MoveLoc[0](Arg0: u64)
	1: StLoc[4](loc2: u64)
	2: MoveLoc[1](Arg1: u64)
	3: StLoc[3](loc1: u64)
	4: CopyLoc[3](loc1: u64)
	5: LdU64(0)
	6: Eq
	7: BrFalse(10)
B1:
	8: LdU64(13906834419156516865)
	9: Abort
B2:
	10: CopyLoc[4](loc2: u64)
	11: CastU128
	12: LdConst[10](u8: 64)
	13: Shl
	14: StLoc[7](loc5: u128)
	15: MoveLoc[3](loc1: u64)
	16: CastU128
	17: LdConst[10](u8: 64)
	18: LdConst[11](u8: 32)
	19: Sub
	20: Shl
	21: StLoc[6](loc4: u128)
	22: MoveLoc[7](loc5: u128)
	23: MoveLoc[6](loc4: u128)
	24: Div
	25: StLoc[5](loc3: u128)
	26: CopyLoc[5](loc3: u128)
	27: LdU128(0)
	28: Eq
	29: BrFalse(35)
B3:
	30: MoveLoc[4](loc2: u64)
	31: LdU64(0)
	32: Neq
	33: StLoc[2](loc0: bool)
	34: Branch(37)
B4:
	35: LdFalse
	36: StLoc[2](loc0: bool)
B5:
	37: MoveLoc[2](loc0: bool)
	38: BrFalse(41)
B6:
	39: LdU64(13906834423451615235)
	40: Abort
B7:
	41: CopyLoc[5](loc3: u128)
	42: LdU128(18446744073709551615)
	43: Gt
	44: BrFalse(47)
B8:
	45: LdU64(13906834427746713605)
	46: Abort
B9:
	47: MoveLoc[5](loc3: u128)
	48: CastU64
	49: Pack[0](UQ32_32)
	50: Ret
}

public from_int(Arg0: u32): UQ32_32 {
B0:
	0: MoveLoc[0](Arg0: u32)
	1: CastU64
	2: LdConst[11](u8: 32)
	3: Shl
	4: Pack[0](UQ32_32)
	5: Ret
}

public add(Arg0: UQ32_32, Arg1: UQ32_32): UQ32_32 {
L2:	loc0: u128
B0:
	0: ImmBorrowLoc[0](Arg0: UQ32_32)
	1: ImmBorrowField[0](UQ32_32.pos0: u64)
	2: ReadRef
	3: CastU128
	4: ImmBorrowLoc[1](Arg1: UQ32_32)
	5: ImmBorrowField[0](UQ32_32.pos0: u64)
	6: ReadRef
	7: CastU128
	8: Add
	9: StLoc[2](loc0: u128)
	10: CopyLoc[2](loc0: u128)
	11: LdU128(18446744073709551615)
	12: Gt
	13: BrFalse(16)
B1:
	14: LdU64(13906834487876386823)
	15: Abort
B2:
	16: MoveLoc[2](loc0: u128)
	17: CastU64
	18: Pack[0](UQ32_32)
	19: Ret
}

public sub(Arg0: UQ32_32, Arg1: UQ32_32): UQ32_32 {
L2:	loc0: u64
L3:	loc1: u64
B0:
	0: ImmBorrowLoc[0](Arg0: UQ32_32)
	1: ImmBorrowField[0](UQ32_32.pos0: u64)
	2: ReadRef
	3: StLoc[2](loc0: u64)
	4: ImmBorrowLoc[1](Arg1: UQ32_32)
	5: ImmBorrowField[0](UQ32_32.pos0: u64)
	6: ReadRef
	7: StLoc[3](loc1: u64)
	8: CopyLoc[2](loc0: u64)
	9: CopyLoc[3](loc1: u64)
	10: Lt
	11: BrFalse(14)
B1:
	12: LdU64(13906834513646190599)
	13: Abort
B2:
	14: MoveLoc[2](loc0: u64)
	15: MoveLoc[3](loc1: u64)
	16: Sub
	17: Pack[0](UQ32_32)
	18: Ret
}

public mul(Arg0: UQ32_32, Arg1: UQ32_32): UQ32_32 {
B0:
	0: ImmBorrowLoc[0](Arg0: UQ32_32)
	1: ImmBorrowField[0](UQ32_32.pos0: u64)
	2: ReadRef
	3: MoveLoc[1](Arg1: UQ32_32)
	4: Call int_mul(u64, UQ32_32): u64
	5: Pack[0](UQ32_32)
	6: Ret
}

public div(Arg0: UQ32_32, Arg1: UQ32_32): UQ32_32 {
B0:
	0: ImmBorrowLoc[0](Arg0: UQ32_32)
	1: ImmBorrowField[0](UQ32_32.pos0: u64)
	2: ReadRef
	3: MoveLoc[1](Arg1: UQ32_32)
	4: Call int_div(u64, UQ32_32): u64
	5: Pack[0](UQ32_32)
	6: Ret
}

public to_int(Arg0: UQ32_32): u32 {
B0:
	0: ImmBorrowLoc[0](Arg0: UQ32_32)
	1: ImmBorrowField[0](UQ32_32.pos0: u64)
	2: ReadRef
	3: LdConst[11](u8: 32)
	4: Shr
	5: CastU32
	6: Ret
}

public int_mul(Arg0: u64, Arg1: UQ32_32): u64 {
L2:	loc0: u128
B0:
	0: MoveLoc[0](Arg0: u64)
	1: CastU128
	2: ImmBorrowLoc[1](Arg1: UQ32_32)
	3: ImmBorrowField[0](UQ32_32.pos0: u64)
	4: ReadRef
	5: CastU128
	6: Mul
	7: LdConst[11](u8: 32)
	8: Shr
	9: StLoc[2](loc0: u128)
	10: CopyLoc[2](loc0: u128)
	11: LdU128(18446744073709551615)
	12: Gt
	13: BrFalse(16)
B1:
	14: LdU64(13906834638200242183)
	15: Abort
B2:
	16: MoveLoc[2](loc0: u128)
	17: CastU64
	18: Ret
}

public int_div(Arg0: u64, Arg1: UQ32_32): u64 {
L2:	loc0: u64
L3:	loc1: u128
L4:	loc2: u64
B0:
	0: MoveLoc[0](Arg0: u64)
	1: StLoc[4](loc2: u64)
	2: ImmBorrowLoc[1](Arg1: UQ32_32)
	3: ImmBorrowField[0](UQ32_32.pos0: u64)
	4: ReadRef
	5: StLoc[2](loc0: u64)
	6: CopyLoc[2](loc0: u64)
	7: LdU64(0)
	8: Eq
	9: BrFalse(12)
B1:
	10: LdU64(13906834694034948105)
	11: Abort
B2:
	12: MoveLoc[4](loc2: u64)
	13: CastU128
	14: LdConst[11](u8: 32)
	15: Shl
	16: MoveLoc[2](loc0: u64)
	17: CastU128
	18: Div
	19: StLoc[3](loc1: u128)
	20: CopyLoc[3](loc1: u128)
	21: LdU128(18446744073709551615)
	22: Gt
	23: BrFalse(26)
B3:
	24: LdU64(13906834698329784327)
	25: Abort
B4:
	26: MoveLoc[3](loc1: u128)
	27: CastU64
	28: Ret
}

public le(Arg0: UQ32_32, Arg1: UQ32_32): bool {
B0:
	0: ImmBorrowLoc[0](Arg0: UQ32_32)
	1: ImmBorrowField[0](UQ32_32.pos0: u64)
	2: ReadRef
	3: ImmBorrowLoc[1](Arg1: UQ32_32)
	4: ImmBorrowField[0](UQ32_32.pos0: u64)
	5: ReadRef
	6: Le
	7: Ret
}

public lt(Arg0: UQ32_32, Arg1: UQ32_32): bool {
B0:
	0: ImmBorrowLoc[0](Arg0: UQ32_32)
	1: ImmBorrowField[0](UQ32_32.pos0: u64)
	2: ReadRef
	3: ImmBorrowLoc[1](Arg1: UQ32_32)
	4: ImmBorrowField[0](UQ32_32.pos0: u64)
	5: ReadRef
	6: Lt
	7: Ret
}

public ge(Arg0: UQ32_32, Arg1: UQ32_32): bool {
B0:
	0: ImmBorrowLoc[0](Arg0: UQ32_32)
	1: ImmBorrowField[0](UQ32_32.pos0: u64)
	2: ReadRef
	3: ImmBorrowLoc[1](Arg1: UQ32_32)
	4: ImmBorrowField[0](UQ32_32.pos0: u64)
	5: ReadRef
	6: Ge
	7: Ret
}

public gt(Arg0: UQ32_32, Arg1: UQ32_32): bool {
B0:
	0: ImmBorrowLoc[0](Arg0: UQ32_32)
	1: ImmBorrowField[0](UQ32_32.pos0: u64)
	2: ReadRef
	3: ImmBorrowLoc[1](Arg1: UQ32_32)
	4: ImmBorrowField[0](UQ32_32.pos0: u64)
	5: ReadRef
	6: Gt
	7: Ret
}

public to_raw(Arg0: UQ32_32): u64 {
B0:
	0: ImmBorrowLoc[0](Arg0: UQ32_32)
	1: ImmBorrowField[0](UQ32_32.pos0: u64)
	2: ReadRef
	3: Ret
}

public from_raw(Arg0: u64): UQ32_32 {
B0:
	0: MoveLoc[0](Arg0: u64)
	1: Pack[0](UQ32_32)
	2: Ret
}

Constants [
	0 => vector<u8>: "EDenominator" // interpreted as UTF8 string
	1 => vector<u8>: "Quotient specified with a zero denominator" // interpreted as UTF8 string
	2 => vector<u8>: "EQuotientTooSmall" // interpreted as UTF8 string
	3 => vector<u8>: "Quotient specified is too small, and is outside of the supported range" // interpreted as UTF8 string
	4 => vector<u8>: "EQuotientTooLarge" // interpreted as UTF8 string
	5 => vector<u8>: "Quotient specified is too large, and is outside of the supported range" // interpreted as UTF8 string
	6 => vector<u8>: "EOverflow" // interpreted as UTF8 string
	7 => vector<u8>: "Overflow from an arithmetic operation" // interpreted as UTF8 string
	8 => vector<u8>: "EDivisionByZero" // interpreted as UTF8 string
	9 => vector<u8>: "Division by zero" // interpreted as UTF8 string
	10 => u8: 64
	11 => u8: 32
]
}

// Move bytecode v6
module 1.uq64_64 {

struct UQ64_64 has copy, drop, store {
	pos0: u128
}

public from_quotient(Arg0: u128, Arg1: u128): UQ64_64 {
L2:	loc0: bool
L3:	loc1: u128
L4:	loc2: u128
L5:	loc3: u256
L6:	loc4: u256
L7:	loc5: u256
B0:
	0: MoveLoc[0](Arg0: u128)
	1: StLoc[4](loc2: u128)
	2: MoveLoc[1](Arg1: u128)
	3: StLoc[3](loc1: u128)
	4: CopyLoc[3](loc1: u128)
	5: LdU128(0)
	6: Eq
	7: BrFalse(10)
B1:
	8: LdU64(13906834419156516865)
	9: Abort
B2:
	10: CopyLoc[4](loc2: u128)
	11: CastU256
	12: LdConst[10](u8: 128)
	13: Shl
	14: StLoc[7](loc5: u256)
	15: MoveLoc[3](loc1: u128)
	16: CastU256
	17: LdConst[10](u8: 128)
	18: LdConst[11](u8: 64)
	19: Sub
	20: Shl
	21: StLoc[6](loc4: u256)
	22: MoveLoc[7](loc5: u256)
	23: MoveLoc[6](loc4: u256)
	24: Div
	25: StLoc[5](loc3: u256)
	26: CopyLoc[5](loc3: u256)
	27: LdU256(0)
	28: Eq
	29: BrFalse(35)
B3:
	30: MoveLoc[4](loc2: u128)
	31: LdU128(0)
	32: Neq
	33: StLoc[2](loc0: bool)
	34: Branch(37)
B4:
	35: LdFalse
	36: StLoc[2](loc0: bool)
B5:
	37: MoveLoc[2](loc0: bool)
	38: BrFalse(41)
B6:
	39: LdU64(13906834423451615235)
	40: Abort
B7:
	41: CopyLoc[5](loc3: u256)
	42: LdU256(340282366920938463463374607431768211455)
	43: Gt
	44: BrFalse(47)
B8:
	45: LdU64(13906834427746713605)
	46: Abort
B9:
	47: MoveLoc[5](loc3: u256)
	48: CastU128
	49: Pack[0](UQ64_64)
	50: Ret
}

public from_int(Arg0: u64): UQ64_64 {
B0:
	0: MoveLoc[0](Arg0: u64)
	1: CastU128
	2: LdConst[11](u8: 64)
	3: Shl
	4: Pack[0](UQ64_64)
	5: Ret
}

public add(Arg0: UQ64_64, Arg1: UQ64_64): UQ64_64 {
L2:	loc0: u256
B0:
	0: ImmBorrowLoc[0](Arg0: UQ64_64)
	1: ImmBorrowField[0](UQ64_64.pos0: u128)
	2: ReadRef
	3: CastU256
	4: ImmBorrowLoc[1](Arg1: UQ64_64)
	5: ImmBorrowField[0](UQ64_64.pos0: u128)
	6: ReadRef
	7: CastU256
	8: Add
	9: StLoc[2](loc0: u256)
	10: CopyLoc[2](loc0: u256)
	11: LdU256(340282366920938463463374607431768211455)
	12: Gt
	13: BrFalse(16)
B1:
	14: LdU64(13906834487876386823)
	15: Abort
B2:
	16: MoveLoc[2](loc0: u256)
	17: CastU128
	18: Pack[0](UQ64_64)
	19: Ret
}

public sub(Arg0: UQ64_64, Arg1: UQ64_64): UQ64_64 {
L2:	loc0: u128
L3:	loc1: u128
B0:
	0: ImmBorrowLoc[0](Arg0: UQ64_64)
	1: ImmBorrowField[0](UQ64_64.pos0: u128)
	2: ReadRef
	3: StLoc[2](loc0: u128)
	4: ImmBorrowLoc[1](Arg1: UQ64_64)
	5: ImmBorrowField[0](UQ64_64.pos0: u128)
	6: ReadRef
	7: StLoc[3](loc1: u128)
	8: CopyLoc[2](loc0: u128)
	9: CopyLoc[3](loc1: u128)
	10: Lt
	11: BrFalse(14)
B1:
	12: LdU64(13906834513646190599)
	13: Abort
B2:
	14: MoveLoc[2](loc0: u128)
	15: MoveLoc[3](loc1: u128)
	16: Sub
	17: Pack[0](UQ64_64)
	18: Ret
}

public mul(Arg0: UQ64_64, Arg1: UQ64_64): UQ64_64 {
B0:
	0: ImmBorrowLoc[0](Arg0: UQ64_64)
	1: ImmBorrowField[0](UQ64_64.pos0: u128)
	2: ReadRef
	3: MoveLoc[1](Arg1: UQ64_64)
	4: Call int_mul(u128, UQ64_64): u128
	5: Pack[0](UQ64_64)
	6: Ret
}

public div(Arg0: UQ64_64, Arg1: UQ64_64): UQ64_64 {
B0:
	0: ImmBorrowLoc[0](Arg0: UQ64_64)
	1: ImmBorrowField[0](UQ64_64.pos0: u128)
	2: ReadRef
	3: MoveLoc[1](Arg1: UQ64_64)
	4: Call int_div(u128, UQ64_64): u128
	5: Pack[0](UQ64_64)
	6: Ret
}

public to_int(Arg0: UQ64_64): u64 {
B0:
	0: ImmBorrowLoc[0](Arg0: UQ64_64)
	1: ImmBorrowField[0](UQ64_64.pos0: u128)
	2: ReadRef
	3: LdConst[11](u8: 64)
	4: Shr
	5: CastU64
	6: Ret
}

public int_mul(Arg0: u128, Arg1: UQ64_64): u128 {
L2:	loc0: u256
B0:
	0: MoveLoc[0](Arg0: u128)
	1: CastU256
	2: ImmBorrowLoc[1](Arg1: UQ64_64)
	3: ImmBorrowField[0](UQ64_64.pos0: u128)
	4: ReadRef
	5: CastU256
	6: Mul
	7: LdConst[11](u8: 64)
	8: Shr
	9: StLoc[2](loc0: u256)
	10: CopyLoc[2](loc0: u256)
	11: LdU256(340282366920938463463374607431768211455)
	12: Gt
	13: BrFalse(16)
B1:
	14: LdU64(13906834638200242183)
	15: Abort
B2:
	16: MoveLoc[2](loc0: u256)
	17: CastU128
	18: Ret
}

public int_div(Arg0: u128, Arg1: UQ64_64): u128 {
L2:	loc0: u128
L3:	loc1: u256
L4:	loc2: u128
B0:
	0: MoveLoc[0](Arg0: u128)
	1: StLoc[4](loc2: u128)
	2: ImmBorrowLoc[1](Arg1: UQ64_64)
	3: ImmBorrowField[0](UQ64_64.pos0: u128)
	4: ReadRef
	5: StLoc[2](loc0: u128)
	6: CopyLoc[2](loc0: u128)
	7: LdU128(0)
	8: Eq
	9: BrFalse(12)
B1:
	10: LdU64(13906834694034948105)
	11: Abort
B2:
	12: MoveLoc[4](loc2: u128)
	13: CastU256
	14: LdConst[11](u8: 64)
	15: Shl
	16: MoveLoc[2](loc0: u128)
	17: CastU256
	18: Div
	19: StLoc[3](loc1: u256)
	20: CopyLoc[3](loc1: u256)
	21: LdU256(340282366920938463463374607431768211455)
	22: Gt
	23: BrFalse(26)
B3:
	24: LdU64(13906834698329784327)
	25: Abort
B4:
	26: MoveLoc[3](loc1: u256)
	27: CastU128
	28: Ret
}

public le(Arg0: UQ64_64, Arg1: UQ64_64): bool {
B0:
	0: ImmBorrowLoc[0](Arg0: UQ64_64)
	1: ImmBorrowField[0](UQ64_64.pos0: u128)
	2: ReadRef
	3: ImmBorrowLoc[1](Arg1: UQ64_64)
	4: ImmBorrowField[0](UQ64_64.pos0: u128)
	5: ReadRef
	6: Le
	7: Ret
}

public lt(Arg0: UQ64_64, Arg1: UQ64_64): bool {
B0:
	0: ImmBorrowLoc[0](Arg0: UQ64_64)
	1: ImmBorrowField[0](UQ64_64.pos0: u128)
	2: ReadRef
	3: ImmBorrowLoc[1](Arg1: UQ64_64)
	4: ImmBorrowField[0](UQ64_64.pos0: u128)
	5: ReadRef
	6: Lt
	7: Ret
}

public ge(Arg0: UQ64_64, Arg1: UQ64_64): bool {
B0:
	0: ImmBorrowLoc[0](Arg0: UQ64_64)
	1: ImmBorrowField[0](UQ64_64.pos0: u128)
	2: ReadRef
	3: ImmBorrowLoc[1](Arg1: UQ64_64)
	4: ImmBorrowField[0](UQ64_64.pos0: u128)
	5: ReadRef
	6: Ge
	7: Ret
}

public gt(Arg0: UQ64_64, Arg1: UQ64_64): bool {
B0:
	0: ImmBorrowLoc[0](Arg0: UQ64_64)
	1: ImmBorrowField[0](UQ64_64.pos0: u128)
	2: ReadRef
	3: ImmBorrowLoc[1](Arg1: UQ64_64)
	4: ImmBorrowField[0](UQ64_64.pos0: u128)
	5: ReadRef
	6: Gt
	7: Ret
}

public to_raw(Arg0: UQ64_64): u128 {
B0:
	0: ImmBorrowLoc[0](Arg0: UQ64_64)
	1: ImmBorrowField[0](UQ64_64.pos0: u128)
	2: ReadRef
	3: Ret
}

public from_raw(Arg0: u128): UQ64_64 {
B0:
	0: MoveLoc[0](Arg0: u128)
	1: Pack[0](UQ64_64)
	2: Ret
}

Constants [
	0 => vector<u8>: "EDenominator" // interpreted as UTF8 string
	1 => vector<u8>: "Quotient specified with a zero denominator" // interpreted as UTF8 string
	2 => vector<u8>: "EQuotientTooSmall" // interpreted as UTF8 string
	3 => vector<u8>: "Quotient specified is too small, and is outside of the supported range" // interpreted as UTF8 string
	4 => vector<u8>: "EQuotientTooLarge" // interpreted as UTF8 string
	5 => vector<u8>: "Quotient specified is too large, and is outside of the supported range" // interpreted as UTF8 string
	6 => vector<u8>: "EOverflow" // interpreted as UTF8 string
	7 => vector<u8>: "Overflow from an arithmetic operation" // interpreted as UTF8 string
	8 => vector<u8>: "EDivisionByZero" // interpreted as UTF8 string
	9 => vector<u8>: "Division by zero" // interpreted as UTF8 string
	10 => u8: 128
	11 => u8: 64
]
}

// Move bytecode v6
module 1.vector {

native public empty<Ty0>(): vector<Ty0>;

native public length<Ty0>(Arg0: &vector<Ty0>): u64;

native public borrow<Ty0>(Arg0: &vector<Ty0>, Arg1: u64): &Ty0;

native public push_back<Ty0>(Arg0: &mut vector<Ty0>, Arg1: Ty0);

native public borrow_mut<Ty0>(Arg0: &mut vector<Ty0>, Arg1: u64): &mut Ty0;

native public pop_back<Ty0>(Arg0: &mut vector<Ty0>): Ty0;

native public destroy_empty<Ty0>(Arg0: vector<Ty0>);

native public swap<Ty0>(Arg0: &mut vector<Ty0>, Arg1: u64, Arg2: u64);

public singleton<Ty0>(Arg0: Ty0): vector<Ty0> {
L1:	loc0: vector<Ty0>
B0:
	0: VecPack(10, 0)
	1: StLoc[1](loc0: vector<Ty0>)
	2: MutBorrowLoc[1](loc0: vector<Ty0>)
	3: MoveLoc[0](Arg0: Ty0)
	4: VecPushBack(10)
	5: MoveLoc[1](loc0: vector<Ty0>)
	6: Ret
}

public reverse<Ty0>(Arg0: &mut vector<Ty0>) {
L1:	loc0: u64
L2:	loc1: u64
L3:	loc2: u64
B0:
	0: CopyLoc[0](Arg0: &mut vector<Ty0>)
	1: FreezeRef
	2: VecLen(10)
	3: StLoc[3](loc2: u64)
	4: CopyLoc[3](loc2: u64)
	5: LdU64(0)
	6: Eq
	7: BrFalse(11)
B1:
	8: MoveLoc[0](Arg0: &mut vector<Ty0>)
	9: Pop
	10: Ret
B2:
	11: LdU64(0)
	12: StLoc[2](loc1: u64)
	13: MoveLoc[3](loc2: u64)
	14: LdU64(1)
	15: Sub
	16: StLoc[1](loc0: u64)
B3:
	17: CopyLoc[2](loc1: u64)
	18: CopyLoc[1](loc0: u64)
	19: Lt
	20: BrFalse(34)
B4:
	21: CopyLoc[0](Arg0: &mut vector<Ty0>)
	22: CopyLoc[2](loc1: u64)
	23: CopyLoc[1](loc0: u64)
	24: VecSwap(10)
	25: MoveLoc[2](loc1: u64)
	26: LdU64(1)
	27: Add
	28: StLoc[2](loc1: u64)
	29: MoveLoc[1](loc0: u64)
	30: LdU64(1)
	31: Sub
	32: StLoc[1](loc0: u64)
	33: Branch(17)
B5:
	34: MoveLoc[0](Arg0: &mut vector<Ty0>)
	35: Pop
	36: Ret
}

public append<Ty0>(Arg0: &mut vector<Ty0>, Arg1: vector<Ty0>) {
L2:	loc0: u64
L3:	loc1: Ty0
L4:	loc2: u64
L5:	loc3: u64
L6:	loc4: vector<Ty0>
B0:
	0: MoveLoc[1](Arg1: vector<Ty0>)
	1: StLoc[6](loc4: vector<Ty0>)
	2: MutBorrowLoc[6](loc4: vector<Ty0>)
	3: Call reverse<Ty0>(&mut vector<Ty0>)
	4: ImmBorrowLoc[6](loc4: vector<Ty0>)
	5: VecLen(10)
	6: StLoc[2](loc0: u64)
	7: LdU64(0)
	8: StLoc[4](loc2: u64)
	9: MoveLoc[2](loc0: u64)
	10: StLoc[5](loc3: u64)
B1:
	11: CopyLoc[4](loc2: u64)
	12: CopyLoc[5](loc3: u64)
	13: Lt
	14: BrFalse(28)
B2:
	15: CopyLoc[4](loc2: u64)
	16: Pop
	17: MutBorrowLoc[6](loc4: vector<Ty0>)
	18: VecPopBack(10)
	19: StLoc[3](loc1: Ty0)
	20: CopyLoc[0](Arg0: &mut vector<Ty0>)
	21: MoveLoc[3](loc1: Ty0)
	22: VecPushBack(10)
	23: MoveLoc[4](loc2: u64)
	24: LdU64(1)
	25: Add
	26: StLoc[4](loc2: u64)
	27: Branch(11)
B3:
	28: MoveLoc[0](Arg0: &mut vector<Ty0>)
	29: Pop
	30: MoveLoc[6](loc4: vector<Ty0>)
	31: VecUnpack(10, 0)
	32: Ret
}

public is_empty<Ty0>(Arg0: &vector<Ty0>): bool {
B0:
	0: MoveLoc[0](Arg0: &vector<Ty0>)
	1: VecLen(10)
	2: LdU64(0)
	3: Eq
	4: Ret
}

public contains<Ty0>(Arg0: &vector<Ty0>, Arg1: &Ty0): bool {
L2:	loc0: u64
L3:	loc1: u64
B0:
	0: LdU64(0)
	1: StLoc[2](loc0: u64)
	2: CopyLoc[0](Arg0: &vector<Ty0>)
	3: VecLen(10)
	4: StLoc[3](loc1: u64)
B1:
	5: CopyLoc[2](loc0: u64)
	6: CopyLoc[3](loc1: u64)
	7: Lt
	8: BrFalse(27)
B2:
	9: Branch(10)
B3:
	10: CopyLoc[0](Arg0: &vector<Ty0>)
	11: CopyLoc[2](loc0: u64)
	12: VecImmBorrow(10)
	13: CopyLoc[1](Arg1: &Ty0)
	14: Eq
	15: BrFalse(22)
B4:
	16: MoveLoc[0](Arg0: &vector<Ty0>)
	17: Pop
	18: MoveLoc[1](Arg1: &Ty0)
	19: Pop
	20: LdTrue
	21: Ret
B5:
	22: MoveLoc[2](loc0: u64)
	23: LdU64(1)
	24: Add
	25: StLoc[2](loc0: u64)
	26: Branch(5)
B6:
	27: MoveLoc[0](Arg0: &vector<Ty0>)
	28: Pop
	29: MoveLoc[1](Arg1: &Ty0)
	30: Pop
	31: LdFalse
	32: Ret
}

public index_of<Ty0>(Arg0: &vector<Ty0>, Arg1: &Ty0): bool * u64 {
L2:	loc0: u64
L3:	loc1: u64
B0:
	0: LdU64(0)
	1: StLoc[2](loc0: u64)
	2: CopyLoc[0](Arg0: &vector<Ty0>)
	3: VecLen(10)
	4: StLoc[3](loc1: u64)
B1:
	5: CopyLoc[2](loc0: u64)
	6: CopyLoc[3](loc1: u64)
	7: Lt
	8: BrFalse(28)
B2:
	9: Branch(10)
B3:
	10: CopyLoc[0](Arg0: &vector<Ty0>)
	11: CopyLoc[2](loc0: u64)
	12: VecImmBorrow(10)
	13: CopyLoc[1](Arg1: &Ty0)
	14: Eq
	15: BrFalse(23)
B4:
	16: MoveLoc[0](Arg0: &vector<Ty0>)
	17: Pop
	18: MoveLoc[1](Arg1: &Ty0)
	19: Pop
	20: LdTrue
	21: MoveLoc[2](loc0: u64)
	22: Ret
B5:
	23: MoveLoc[2](loc0: u64)
	24: LdU64(1)
	25: Add
	26: StLoc[2](loc0: u64)
	27: Branch(5)
B6:
	28: MoveLoc[0](Arg0: &vector<Ty0>)
	29: Pop
	30: MoveLoc[1](Arg1: &Ty0)
	31: Pop
	32: LdFalse
	33: LdU64(0)
	34: Ret
}

public remove<Ty0>(Arg0: &mut vector<Ty0>, Arg1: u64): Ty0 {
L2:	loc0: u64
L3:	loc1: &mut vector<Ty0>
L4:	loc2: u64
B0:
	0: CopyLoc[0](Arg0: &mut vector<Ty0>)
	1: FreezeRef
	2: VecLen(10)
	3: StLoc[4](loc2: u64)
	4: CopyLoc[1](Arg1: u64)
	5: CopyLoc[4](loc2: u64)
	6: Ge
	7: BrFalse(12)
B1:
	8: MoveLoc[0](Arg0: &mut vector<Ty0>)
	9: Pop
	10: LdConst[0](u64: 131072)
	11: Abort
B2:
	12: MoveLoc[4](loc2: u64)
	13: LdU64(1)
	14: Sub
	15: StLoc[4](loc2: u64)
B3:
	16: CopyLoc[1](Arg1: u64)
	17: CopyLoc[4](loc2: u64)
	18: Lt
	19: BrFalse(33)
B4:
	20: CopyLoc[0](Arg0: &mut vector<Ty0>)
	21: StLoc[3](loc1: &mut vector<Ty0>)
	22: CopyLoc[1](Arg1: u64)
	23: StLoc[2](loc0: u64)
	24: MoveLoc[1](Arg1: u64)
	25: LdU64(1)
	26: Add
	27: StLoc[1](Arg1: u64)
	28: MoveLoc[3](loc1: &mut vector<Ty0>)
	29: MoveLoc[2](loc0: u64)
	30: CopyLoc[1](Arg1: u64)
	31: VecSwap(10)
	32: Branch(16)
B5:
	33: MoveLoc[0](Arg0: &mut vector<Ty0>)
	34: VecPopBack(10)
	35: Ret
}

public insert<Ty0>(Arg0: &mut vector<Ty0>, Arg1: Ty0, Arg2: u64) {
L3:	loc0: u64
B0:
	0: CopyLoc[0](Arg0: &mut vector<Ty0>)
	1: FreezeRef
	2: VecLen(10)
	3: StLoc[3](loc0: u64)
	4: CopyLoc[2](Arg2: u64)
	5: CopyLoc[3](loc0: u64)
	6: Gt
	7: BrFalse(12)
B1:
	8: MoveLoc[0](Arg0: &mut vector<Ty0>)
	9: Pop
	10: LdConst[0](u64: 131072)
	11: Abort
B2:
	12: CopyLoc[0](Arg0: &mut vector<Ty0>)
	13: MoveLoc[1](Arg1: Ty0)
	14: VecPushBack(10)
B3:
	15: CopyLoc[2](Arg2: u64)
	16: CopyLoc[3](loc0: u64)
	17: Lt
	18: BrFalse(28)
B4:
	19: CopyLoc[0](Arg0: &mut vector<Ty0>)
	20: CopyLoc[2](Arg2: u64)
	21: CopyLoc[3](loc0: u64)
	22: VecSwap(10)
	23: MoveLoc[2](Arg2: u64)
	24: LdU64(1)
	25: Add
	26: StLoc[2](Arg2: u64)
	27: Branch(15)
B5:
	28: MoveLoc[0](Arg0: &mut vector<Ty0>)
	29: Pop
	30: Ret
}

public swap_remove<Ty0>(Arg0: &mut vector<Ty0>, Arg1: u64): Ty0 {
L2:	loc0: u64
B0:
	0: CopyLoc[0](Arg0: &mut vector<Ty0>)
	1: FreezeRef
	2: VecLen(10)
	3: LdU64(0)
	4: Neq
	5: BrFalse(7)
B1:
	6: Branch(11)
B2:
	7: MoveLoc[0](Arg0: &mut vector<Ty0>)
	8: Pop
	9: LdConst[0](u64: 131072)
	10: Abort
B3:
	11: CopyLoc[0](Arg0: &mut vector<Ty0>)
	12: FreezeRef
	13: VecLen(10)
	14: LdU64(1)
	15: Sub
	16: StLoc[2](loc0: u64)
	17: CopyLoc[0](Arg0: &mut vector<Ty0>)
	18: MoveLoc[1](Arg1: u64)
	19: MoveLoc[2](loc0: u64)
	20: VecSwap(10)
	21: MoveLoc[0](Arg0: &mut vector<Ty0>)
	22: VecPopBack(10)
	23: Ret
}

public skip<Ty0: drop>(Arg0: vector<Ty0>, Arg1: u64): vector<Ty0> {
L2:	loc0: u64
L3:	loc1: Ty0
L4:	loc2: &mut vector<Ty0>
L5:	loc3: u64
L6:	loc4: u64
L7:	loc5: u64
L8:	loc6: vector<Ty0>
L9:	loc7: u64
L10:	loc8: vector<Ty0>
B0:
	0: ImmBorrowLoc[0](Arg0: vector<Ty0>)
	1: VecLen(10)
	2: StLoc[7](loc5: u64)
	3: CopyLoc[1](Arg1: u64)
	4: CopyLoc[7](loc5: u64)
	5: Ge
	6: BrFalse(9)
B1:
	7: VecPack(10, 0)
	8: Ret
B2:
	9: VecPack(10, 0)
	10: StLoc[10](loc8: vector<Ty0>)
	11: MoveLoc[7](loc5: u64)
	12: MoveLoc[1](Arg1: u64)
	13: Sub
	14: StLoc[2](loc0: u64)
	15: LdU64(0)
	16: StLoc[6](loc4: u64)
	17: MoveLoc[2](loc0: u64)
	18: StLoc[9](loc7: u64)
B3:
	19: CopyLoc[6](loc4: u64)
	20: CopyLoc[9](loc7: u64)
	21: Lt
	22: BrFalse(40)
B4:
	23: CopyLoc[6](loc4: u64)
	24: StLoc[5](loc3: u64)
	25: MutBorrowLoc[10](loc8: vector<Ty0>)
	26: StLoc[4](loc2: &mut vector<Ty0>)
	27: MoveLoc[5](loc3: u64)
	28: Pop
	29: MutBorrowLoc[0](Arg0: vector<Ty0>)
	30: VecPopBack(10)
	31: StLoc[3](loc1: Ty0)
	32: MoveLoc[4](loc2: &mut vector<Ty0>)
	33: MoveLoc[3](loc1: Ty0)
	34: VecPushBack(10)
	35: MoveLoc[6](loc4: u64)
	36: LdU64(1)
	37: Add
	38: StLoc[6](loc4: u64)
	39: Branch(19)
B5:
	40: MoveLoc[10](loc8: vector<Ty0>)
	41: StLoc[8](loc6: vector<Ty0>)
	42: MutBorrowLoc[8](loc6: vector<Ty0>)
	43: Call reverse<Ty0>(&mut vector<Ty0>)
	44: MoveLoc[8](loc6: vector<Ty0>)
	45: Ret
}

public take<Ty0: drop>(Arg0: vector<Ty0>, Arg1: u64): vector<Ty0> {
L2:	loc0: u64
L3:	loc1: Ty0
L4:	loc2: &mut vector<Ty0>
L5:	loc3: u64
L6:	loc4: u64
L7:	loc5: u64
L8:	loc6: vector<Ty0>
B0:
	0: CopyLoc[1](Arg1: u64)
	1: ImmBorrowLoc[0](Arg0: vector<Ty0>)
	2: VecLen(10)
	3: Le
	4: BrFalse(6)
B1:
	5: Branch(8)
B2:
	6: LdU64(13906834934552592383)
	7: Abort
B3:
	8: CopyLoc[1](Arg1: u64)
	9: ImmBorrowLoc[0](Arg0: vector<Ty0>)
	10: VecLen(10)
	11: Eq
	12: BrFalse(15)
B4:
	13: MoveLoc[0](Arg0: vector<Ty0>)
	14: Ret
B5:
	15: MutBorrowLoc[0](Arg0: vector<Ty0>)
	16: Call reverse<Ty0>(&mut vector<Ty0>)
	17: VecPack(10, 0)
	18: StLoc[8](loc6: vector<Ty0>)
	19: MoveLoc[1](Arg1: u64)
	20: StLoc[2](loc0: u64)
	21: LdU64(0)
	22: StLoc[6](loc4: u64)
	23: MoveLoc[2](loc0: u64)
	24: StLoc[7](loc5: u64)
B6:
	25: CopyLoc[6](loc4: u64)
	26: CopyLoc[7](loc5: u64)
	27: Lt
	28: BrFalse(46)
B7:
	29: CopyLoc[6](loc4: u64)
	30: StLoc[5](loc3: u64)
	31: MutBorrowLoc[8](loc6: vector<Ty0>)
	32: StLoc[4](loc2: &mut vector<Ty0>)
	33: MoveLoc[5](loc3: u64)
	34: Pop
	35: MutBorrowLoc[0](Arg0: vector<Ty0>)
	36: VecPopBack(10)
	37: StLoc[3](loc1: Ty0)
	38: MoveLoc[4](loc2: &mut vector<Ty0>)
	39: MoveLoc[3](loc1: Ty0)
	40: VecPushBack(10)
	41: MoveLoc[6](loc4: u64)
	42: LdU64(1)
	43: Add
	44: StLoc[6](loc4: u64)
	45: Branch(25)
B8:
	46: MoveLoc[8](loc6: vector<Ty0>)
	47: Ret
}

public flatten<Ty0>(Arg0: vector<vector<Ty0>>): vector<Ty0> {
L1:	loc0: u64
L2:	loc1: u64
L3:	loc2: vector<Ty0>
L4:	loc3: u64
L5:	loc4: vector<Ty0>
L6:	loc5: vector<vector<Ty0>>
B0:
	0: VecPack(10, 0)
	1: StLoc[3](loc2: vector<Ty0>)
	2: MoveLoc[0](Arg0: vector<vector<Ty0>>)
	3: StLoc[6](loc5: vector<vector<Ty0>>)
	4: MutBorrowLoc[6](loc5: vector<vector<Ty0>>)
	5: Call reverse<vector<Ty0>>(&mut vector<vector<Ty0>>)
	6: ImmBorrowLoc[6](loc5: vector<vector<Ty0>>)
	7: VecLen(1)
	8: StLoc[1](loc0: u64)
	9: LdU64(0)
	10: StLoc[2](loc1: u64)
	11: MoveLoc[1](loc0: u64)
	12: StLoc[4](loc3: u64)
B1:
	13: CopyLoc[2](loc1: u64)
	14: CopyLoc[4](loc3: u64)
	15: Lt
	16: BrFalse(30)
B2:
	17: CopyLoc[2](loc1: u64)
	18: Pop
	19: MutBorrowLoc[6](loc5: vector<vector<Ty0>>)
	20: VecPopBack(1)
	21: StLoc[5](loc4: vector<Ty0>)
	22: MutBorrowLoc[3](loc2: vector<Ty0>)
	23: MoveLoc[5](loc4: vector<Ty0>)
	24: Call append<Ty0>(&mut vector<Ty0>, vector<Ty0>)
	25: MoveLoc[2](loc1: u64)
	26: LdU64(1)
	27: Add
	28: StLoc[2](loc1: u64)
	29: Branch(13)
B3:
	30: MoveLoc[6](loc5: vector<vector<Ty0>>)
	31: VecUnpack(1, 0)
	32: MoveLoc[3](loc2: vector<Ty0>)
	33: Ret
}

Constants [
	0 => u64: 131072
]
}