Package

// Move bytecode v6
module bf9e709da3d786480c22b9c56fb0ad746c4c8fb7b2c0cb5b91f0d5c485bd9bb2.pool {
use 0000000000000000000000000000000000000000000000000000000000000002::balance;
use 0000000000000000000000000000000000000000000000000000000000000002::coin;
use 0000000000000000000000000000000000000000000000000000000000000002::event;
use 0000000000000000000000000000000000000000000000000000000000000002::object;
use 0000000000000000000000000000000000000000000000000000000000000002::table;
use 0000000000000000000000000000000000000000000000000000000000000002::transfer;
use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;
use 0000000000000000000000000000000000000000000000000000000000000001::option;
use 0000000000000000000000000000000000000000000000000000000000000001::type_name;
use 0000000000000000000000000000000000000000000000000000000000000001::u128;

struct LP<phantom Ty0, phantom Ty1> has drop {
	dummy_field: bool
}

struct Pool<phantom Ty0, phantom Ty1> has key {
	id: UID,
	reserve_a: Balance<Ty0>,
	reserve_b: Balance<Ty1>,
	lp_supply: Supply<LP<Ty0, Ty1>>,
	locked_lp: Balance<LP<Ty0, Ty1>>,
	fee_bps: u64
}

struct PoolKey has copy, drop, store {
	a: TypeName,
	b: TypeName
}

struct Registry has key {
	id: UID,
	pools: Table<PoolKey, ID>
}

struct PoolCreated has copy, drop {
	pool_id: ID,
	coin_a: TypeName,
	coin_b: TypeName,
	fee_bps: u64
}

struct LiquidityAdded has copy, drop {
	pool_id: ID,
	provider: address,
	amount_a: u64,
	amount_b: u64,
	lp_minted: u64
}

struct LiquidityRemoved has copy, drop {
	pool_id: ID,
	provider: address,
	amount_a: u64,
	amount_b: u64,
	lp_burned: u64
}

struct Swapped has copy, drop {
	pool_id: ID,
	trader: address,
	a_to_b: bool,
	amount_in: u64,
	amount_out: u64
}

init(Arg0: &mut TxContext) {
B0:
	0: CopyLoc[0](Arg0: &mut TxContext)
	1: Call object::new(&mut TxContext): UID
	2: MoveLoc[0](Arg0: &mut TxContext)
	3: Call table::new<PoolKey, ID>(&mut TxContext): Table<PoolKey, ID>
	4: Pack[3](Registry)
	5: Call transfer::share_object<Registry>(Registry)
	6: Ret
}

public create_pool<Ty0, Ty1>(Arg0: &mut Registry, Arg1: u64, Arg2: &mut TxContext): ID {
L3:	loc0: bool
L4:	loc1: TypeName
L5:	loc2: TypeName
L6:	loc3: Pool<Ty0, Ty1>
L7:	loc4: ID
B0:
	0: CopyLoc[1](Arg1: u64)
	1: LdConst[7](u64: 10000)
	2: Lt
	3: BrFalse(5)
B1:
	4: Branch(11)
B2:
	5: MoveLoc[0](Arg0: &mut Registry)
	6: Pop
	7: MoveLoc[2](Arg2: &mut TxContext)
	8: Pop
	9: LdConst[5](u64: 5)
	10: Abort
B3:
	11: Call type_name::get<Ty0>(): TypeName
	12: StLoc[4](loc1: TypeName)
	13: Call type_name::get<Ty1>(): TypeName
	14: StLoc[5](loc2: TypeName)
	15: CopyLoc[4](loc1: TypeName)
	16: CopyLoc[5](loc2: TypeName)
	17: Neq
	18: BrFalse(20)
B4:
	19: Branch(26)
B5:
	20: MoveLoc[0](Arg0: &mut Registry)
	21: Pop
	22: MoveLoc[2](Arg2: &mut TxContext)
	23: Pop
	24: LdConst[4](u64: 4)
	25: Abort
B6:
	26: CopyLoc[0](Arg0: &mut Registry)
	27: ImmBorrowField[0](Registry.pools: Table<PoolKey, ID>)
	28: CopyLoc[4](loc1: TypeName)
	29: CopyLoc[5](loc2: TypeName)
	30: Pack[2](PoolKey)
	31: Call table::contains<PoolKey, ID>(&Table<PoolKey, ID>, PoolKey): bool
	32: Not
	33: BrFalse(43)
B7:
	34: CopyLoc[0](Arg0: &mut Registry)
	35: ImmBorrowField[0](Registry.pools: Table<PoolKey, ID>)
	36: CopyLoc[5](loc2: TypeName)
	37: CopyLoc[4](loc1: TypeName)
	38: Pack[2](PoolKey)
	39: Call table::contains<PoolKey, ID>(&Table<PoolKey, ID>, PoolKey): bool
	40: Not
	41: StLoc[3](loc0: bool)
	42: Branch(45)
B8:
	43: LdFalse
	44: StLoc[3](loc0: bool)
B9:
	45: MoveLoc[3](loc0: bool)
	46: BrFalse(48)
B10:
	47: Branch(54)
B11:
	48: MoveLoc[0](Arg0: &mut Registry)
	49: Pop
	50: MoveLoc[2](Arg2: &mut TxContext)
	51: Pop
	52: LdConst[2](u64: 2)
	53: Abort
B12:
	54: MoveLoc[2](Arg2: &mut TxContext)
	55: Call object::new(&mut TxContext): UID
	56: Call balance::zero<Ty0>(): Balance<Ty0>
	57: Call balance::zero<Ty1>(): Balance<Ty1>
	58: LdFalse
	59: PackGeneric[0](LP<Ty0, Ty1>)
	60: Call balance::create_supply<LP<Ty0, Ty1>>(LP<Ty0, Ty1>): Supply<LP<Ty0, Ty1>>
	61: Call balance::zero<LP<Ty0, Ty1>>(): Balance<LP<Ty0, Ty1>>
	62: CopyLoc[1](Arg1: u64)
	63: PackGeneric[1](Pool<Ty0, Ty1>)
	64: StLoc[6](loc3: Pool<Ty0, Ty1>)
	65: ImmBorrowLoc[6](loc3: Pool<Ty0, Ty1>)
	66: Call object::id<Pool<Ty0, Ty1>>(&Pool<Ty0, Ty1>): ID
	67: StLoc[7](loc4: ID)
	68: MoveLoc[0](Arg0: &mut Registry)
	69: MutBorrowField[0](Registry.pools: Table<PoolKey, ID>)
	70: CopyLoc[4](loc1: TypeName)
	71: CopyLoc[5](loc2: TypeName)
	72: Pack[2](PoolKey)
	73: CopyLoc[7](loc4: ID)
	74: Call table::add<PoolKey, ID>(&mut Table<PoolKey, ID>, PoolKey, ID)
	75: CopyLoc[7](loc4: ID)
	76: MoveLoc[4](loc1: TypeName)
	77: MoveLoc[5](loc2: TypeName)
	78: MoveLoc[1](Arg1: u64)
	79: Pack[4](PoolCreated)
	80: Call event::emit<PoolCreated>(PoolCreated)
	81: MoveLoc[6](loc3: Pool<Ty0, Ty1>)
	82: Call transfer::share_object<Pool<Ty0, Ty1>>(Pool<Ty0, Ty1>)
	83: MoveLoc[7](loc4: ID)
	84: Ret
}

public find_pool<Ty0, Ty1>(Arg0: &Registry): Option<ID> {
L1:	loc0: Option<ID>
L2:	loc1: Option<ID>
L3:	loc2: TypeName
L4:	loc3: TypeName
B0:
	0: Call type_name::get<Ty0>(): TypeName
	1: StLoc[3](loc2: TypeName)
	2: Call type_name::get<Ty1>(): TypeName
	3: StLoc[4](loc3: TypeName)
	4: CopyLoc[0](Arg0: &Registry)
	5: ImmBorrowField[0](Registry.pools: Table<PoolKey, ID>)
	6: CopyLoc[3](loc2: TypeName)
	7: CopyLoc[4](loc3: TypeName)
	8: Pack[2](PoolKey)
	9: Call table::contains<PoolKey, ID>(&Table<PoolKey, ID>, PoolKey): bool
	10: BrFalse(21)
B1:
	11: MoveLoc[0](Arg0: &Registry)
	12: ImmBorrowField[0](Registry.pools: Table<PoolKey, ID>)
	13: MoveLoc[3](loc2: TypeName)
	14: MoveLoc[4](loc3: TypeName)
	15: Pack[2](PoolKey)
	16: Call table::borrow<PoolKey, ID>(&Table<PoolKey, ID>, PoolKey): &ID
	17: ReadRef
	18: Call option::some<ID>(ID): Option<ID>
	19: StLoc[2](loc1: Option<ID>)
	20: Branch(44)
B2:
	21: CopyLoc[0](Arg0: &Registry)
	22: ImmBorrowField[0](Registry.pools: Table<PoolKey, ID>)
	23: CopyLoc[4](loc3: TypeName)
	24: CopyLoc[3](loc2: TypeName)
	25: Pack[2](PoolKey)
	26: Call table::contains<PoolKey, ID>(&Table<PoolKey, ID>, PoolKey): bool
	27: BrFalse(38)
B3:
	28: MoveLoc[0](Arg0: &Registry)
	29: ImmBorrowField[0](Registry.pools: Table<PoolKey, ID>)
	30: MoveLoc[4](loc3: TypeName)
	31: MoveLoc[3](loc2: TypeName)
	32: Pack[2](PoolKey)
	33: Call table::borrow<PoolKey, ID>(&Table<PoolKey, ID>, PoolKey): &ID
	34: ReadRef
	35: Call option::some<ID>(ID): Option<ID>
	36: StLoc[1](loc0: Option<ID>)
	37: Branch(42)
B4:
	38: MoveLoc[0](Arg0: &Registry)
	39: Pop
	40: Call option::none<ID>(): Option<ID>
	41: StLoc[1](loc0: Option<ID>)
B5:
	42: MoveLoc[1](loc0: Option<ID>)
	43: StLoc[2](loc1: Option<ID>)
B6:
	44: MoveLoc[2](loc1: Option<ID>)
	45: Ret
}

public add_liquidity<Ty0, Ty1>(Arg0: &mut Pool<Ty0, Ty1>, Arg1: Coin<Ty0>, Arg2: Coin<Ty1>, Arg3: u64, Arg4: &mut TxContext): Coin<LP<Ty0, Ty1>> {
L5:	loc0: bool
L6:	loc1: u64
L7:	loc2: u64
L8:	loc3: u64
L9:	loc4: u64
L10:	loc5: u64
L11:	loc6: u64
L12:	loc7: u64
L13:	loc8: u64
L14:	loc9: u64
L15:	loc10: u64
L16:	loc11: Balance<LP<Ty0, Ty1>>
L17:	loc12: u64
L18:	loc13: u64
L19:	loc14: u64
L20:	loc15: address
L21:	loc16: u64
L22:	loc17: u64
L23:	loc18: u64
B0:
	0: ImmBorrowLoc[1](Arg1: Coin<Ty0>)
	1: Call coin::value<Ty0>(&Coin<Ty0>): u64
	2: StLoc[12](loc7: u64)
	3: ImmBorrowLoc[2](Arg2: Coin<Ty1>)
	4: Call coin::value<Ty1>(&Coin<Ty1>): u64
	5: StLoc[13](loc8: u64)
	6: CopyLoc[12](loc7: u64)
	7: LdU64(0)
	8: Gt
	9: BrFalse(15)
B1:
	10: CopyLoc[13](loc8: u64)
	11: LdU64(0)
	12: Gt
	13: StLoc[5](loc0: bool)
	14: Branch(17)
B2:
	15: LdFalse
	16: StLoc[5](loc0: bool)
B3:
	17: MoveLoc[5](loc0: bool)
	18: BrFalse(20)
B4:
	19: Branch(26)
B5:
	20: MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
	21: Pop
	22: MoveLoc[4](Arg4: &mut TxContext)
	23: Pop
	24: LdConst[0](u64: 0)
	25: Abort
B6:
	26: CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
	27: ImmBorrowFieldGeneric[0](Pool.reserve_a: Balance<Ty0>)
	28: Call balance::value<Ty0>(&Balance<Ty0>): u64
	29: StLoc[18](loc13: u64)
	30: CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
	31: ImmBorrowFieldGeneric[1](Pool.reserve_b: Balance<Ty1>)
	32: Call balance::value<Ty1>(&Balance<Ty1>): u64
	33: StLoc[19](loc14: u64)
	34: CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
	35: ImmBorrowFieldGeneric[2](Pool.lp_supply: Supply<LP<Ty0, Ty1>>)
	36: Call balance::supply_value<LP<Ty0, Ty1>>(&Supply<LP<Ty0, Ty1>>): u64
	37: StLoc[21](loc16: u64)
	38: CopyLoc[4](Arg4: &mut TxContext)
	39: FreezeRef
	40: Call tx_context::sender(&TxContext): address
	41: StLoc[20](loc15: address)
	42: CopyLoc[21](loc16: u64)
	43: LdU64(0)
	44: Eq
	45: BrFalse(84)
B7:
	46: CopyLoc[12](loc7: u64)
	47: CastU128
	48: CopyLoc[13](loc8: u64)
	49: CastU128
	50: Mul
	51: Call u128::sqrt(u128): u128
	52: CastU64
	53: StLoc[15](loc10: u64)
	54: CopyLoc[15](loc10: u64)
	55: LdConst[8](u64: 1000)
	56: Gt
	57: BrFalse(59)
B8:
	58: Branch(65)
B9:
	59: MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
	60: Pop
	61: MoveLoc[4](Arg4: &mut TxContext)
	62: Pop
	63: LdConst[3](u64: 3)
	64: Abort
B10:
	65: CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
	66: MutBorrowFieldGeneric[2](Pool.lp_supply: Supply<LP<Ty0, Ty1>>)
	67: LdConst[8](u64: 1000)
	68: Call balance::increase_supply<LP<Ty0, Ty1>>(&mut Supply<LP<Ty0, Ty1>>, u64): Balance<LP<Ty0, Ty1>>
	69: StLoc[16](loc11: Balance<LP<Ty0, Ty1>>)
	70: CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
	71: MutBorrowFieldGeneric[3](Pool.locked_lp: Balance<LP<Ty0, Ty1>>)
	72: MoveLoc[16](loc11: Balance<LP<Ty0, Ty1>>)
	73: Call balance::join<LP<Ty0, Ty1>>(&mut Balance<LP<Ty0, Ty1>>, Balance<LP<Ty0, Ty1>>): u64
	74: Pop
	75: MoveLoc[12](loc7: u64)
	76: MoveLoc[13](loc8: u64)
	77: MoveLoc[15](loc10: u64)
	78: LdConst[8](u64: 1000)
	79: Sub
	80: StLoc[11](loc6: u64)
	81: StLoc[10](loc5: u64)
	82: StLoc[9](loc4: u64)
	83: Branch(121)
B11:
	84: CopyLoc[12](loc7: u64)
	85: CopyLoc[19](loc14: u64)
	86: CopyLoc[18](loc13: u64)
	87: Call mul_div(u64, u64, u64): u64
	88: StLoc[14](loc9: u64)
	89: CopyLoc[14](loc9: u64)
	90: CopyLoc[13](loc8: u64)
	91: Le
	92: BrFalse(103)
B12:
	93: CopyLoc[12](loc7: u64)
	94: MoveLoc[14](loc9: u64)
	95: MoveLoc[12](loc7: u64)
	96: MoveLoc[21](loc16: u64)
	97: MoveLoc[18](loc13: u64)
	98: Call mul_div(u64, u64, u64): u64
	99: StLoc[8](loc3: u64)
	100: StLoc[7](loc2: u64)
	101: StLoc[6](loc1: u64)
	102: Branch(115)
B13:
	103: CopyLoc[13](loc8: u64)
	104: MoveLoc[18](loc13: u64)
	105: CopyLoc[19](loc14: u64)
	106: Call mul_div(u64, u64, u64): u64
	107: CopyLoc[13](loc8: u64)
	108: MoveLoc[13](loc8: u64)
	109: MoveLoc[21](loc16: u64)
	110: MoveLoc[19](loc14: u64)
	111: Call mul_div(u64, u64, u64): u64
	112: StLoc[8](loc3: u64)
	113: StLoc[7](loc2: u64)
	114: StLoc[6](loc1: u64)
B14:
	115: MoveLoc[6](loc1: u64)
	116: MoveLoc[7](loc2: u64)
	117: MoveLoc[8](loc3: u64)
	118: StLoc[11](loc6: u64)
	119: StLoc[10](loc5: u64)
	120: StLoc[9](loc4: u64)
B15:
	121: MoveLoc[9](loc4: u64)
	122: MoveLoc[10](loc5: u64)
	123: MoveLoc[11](loc6: u64)
	124: StLoc[17](loc12: u64)
	125: StLoc[23](loc18: u64)
	126: StLoc[22](loc17: u64)
	127: CopyLoc[17](loc12: u64)
	128: LdU64(0)
	129: Gt
	130: BrFalse(132)
B16:
	131: Branch(138)
B17:
	132: MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
	133: Pop
	134: MoveLoc[4](Arg4: &mut TxContext)
	135: Pop
	136: LdConst[3](u64: 3)
	137: Abort
B18:
	138: CopyLoc[17](loc12: u64)
	139: MoveLoc[3](Arg3: u64)
	140: Ge
	141: BrFalse(143)
B19:
	142: Branch(149)
B20:
	143: MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
	144: Pop
	145: MoveLoc[4](Arg4: &mut TxContext)
	146: Pop
	147: LdConst[1](u64: 1)
	148: Abort
B21:
	149: CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
	150: MutBorrowFieldGeneric[0](Pool.reserve_a: Balance<Ty0>)
	151: MutBorrowLoc[1](Arg1: Coin<Ty0>)
	152: CopyLoc[22](loc17: u64)
	153: CopyLoc[4](Arg4: &mut TxContext)
	154: Call coin::split<Ty0>(&mut Coin<Ty0>, u64, &mut TxContext): Coin<Ty0>
	155: Call coin::into_balance<Ty0>(Coin<Ty0>): Balance<Ty0>
	156: Call balance::join<Ty0>(&mut Balance<Ty0>, Balance<Ty0>): u64
	157: Pop
	158: CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
	159: MutBorrowFieldGeneric[1](Pool.reserve_b: Balance<Ty1>)
	160: MutBorrowLoc[2](Arg2: Coin<Ty1>)
	161: CopyLoc[23](loc18: u64)
	162: CopyLoc[4](Arg4: &mut TxContext)
	163: Call coin::split<Ty1>(&mut Coin<Ty1>, u64, &mut TxContext): Coin<Ty1>
	164: Call coin::into_balance<Ty1>(Coin<Ty1>): Balance<Ty1>
	165: Call balance::join<Ty1>(&mut Balance<Ty1>, Balance<Ty1>): u64
	166: Pop
	167: MoveLoc[1](Arg1: Coin<Ty0>)
	168: CopyLoc[20](loc15: address)
	169: Call refund_or_destroy<Ty0>(Coin<Ty0>, address)
	170: MoveLoc[2](Arg2: Coin<Ty1>)
	171: CopyLoc[20](loc15: address)
	172: Call refund_or_destroy<Ty1>(Coin<Ty1>, address)
	173: CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
	174: FreezeRef
	175: Call object::id<Pool<Ty0, Ty1>>(&Pool<Ty0, Ty1>): ID
	176: MoveLoc[20](loc15: address)
	177: MoveLoc[22](loc17: u64)
	178: MoveLoc[23](loc18: u64)
	179: CopyLoc[17](loc12: u64)
	180: Pack[5](LiquidityAdded)
	181: Call event::emit<LiquidityAdded>(LiquidityAdded)
	182: MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
	183: MutBorrowFieldGeneric[2](Pool.lp_supply: Supply<LP<Ty0, Ty1>>)
	184: MoveLoc[17](loc12: u64)
	185: Call balance::increase_supply<LP<Ty0, Ty1>>(&mut Supply<LP<Ty0, Ty1>>, u64): Balance<LP<Ty0, Ty1>>
	186: MoveLoc[4](Arg4: &mut TxContext)
	187: Call coin::from_balance<LP<Ty0, Ty1>>(Balance<LP<Ty0, Ty1>>, &mut TxContext): Coin<LP<Ty0, Ty1>>
	188: Ret
}

public remove_liquidity<Ty0, Ty1>(Arg0: &mut Pool<Ty0, Ty1>, Arg1: Coin<LP<Ty0, Ty1>>, Arg2: u64, Arg3: u64, Arg4: &mut TxContext): Coin<Ty0> * Coin<Ty1> {
L5:	loc0: bool
L6:	loc1: bool
L7:	loc2: u64
L8:	loc3: u64
L9:	loc4: u64
L10:	loc5: u64
B0:
	0: ImmBorrowLoc[1](Arg1: Coin<LP<Ty0, Ty1>>)
	1: Call coin::value<LP<Ty0, Ty1>>(&Coin<LP<Ty0, Ty1>>): u64
	2: StLoc[9](loc4: u64)
	3: CopyLoc[9](loc4: u64)
	4: LdU64(0)
	5: Gt
	6: BrFalse(8)
B1:
	7: Branch(14)
B2:
	8: MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
	9: Pop
	10: MoveLoc[4](Arg4: &mut TxContext)
	11: Pop
	12: LdConst[0](u64: 0)
	13: Abort
B3:
	14: CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
	15: ImmBorrowFieldGeneric[2](Pool.lp_supply: Supply<LP<Ty0, Ty1>>)
	16: Call balance::supply_value<LP<Ty0, Ty1>>(&Supply<LP<Ty0, Ty1>>): u64
	17: StLoc[10](loc5: u64)
	18: CopyLoc[9](loc4: u64)
	19: CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
	20: ImmBorrowFieldGeneric[0](Pool.reserve_a: Balance<Ty0>)
	21: Call balance::value<Ty0>(&Balance<Ty0>): u64
	22: CopyLoc[10](loc5: u64)
	23: Call mul_div(u64, u64, u64): u64
	24: StLoc[7](loc2: u64)
	25: CopyLoc[9](loc4: u64)
	26: CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
	27: ImmBorrowFieldGeneric[1](Pool.reserve_b: Balance<Ty1>)
	28: Call balance::value<Ty1>(&Balance<Ty1>): u64
	29: MoveLoc[10](loc5: u64)
	30: Call mul_div(u64, u64, u64): u64
	31: StLoc[8](loc3: u64)
	32: CopyLoc[7](loc2: u64)
	33: LdU64(0)
	34: Gt
	35: BrFalse(41)
B4:
	36: CopyLoc[8](loc3: u64)
	37: LdU64(0)
	38: Gt
	39: StLoc[5](loc0: bool)
	40: Branch(43)
B5:
	41: LdFalse
	42: StLoc[5](loc0: bool)
B6:
	43: MoveLoc[5](loc0: bool)
	44: BrFalse(46)
B7:
	45: Branch(52)
B8:
	46: MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
	47: Pop
	48: MoveLoc[4](Arg4: &mut TxContext)
	49: Pop
	50: LdConst[3](u64: 3)
	51: Abort
B9:
	52: CopyLoc[7](loc2: u64)
	53: MoveLoc[2](Arg2: u64)
	54: Ge
	55: BrFalse(61)
B10:
	56: CopyLoc[8](loc3: u64)
	57: MoveLoc[3](Arg3: u64)
	58: Ge
	59: StLoc[6](loc1: bool)
	60: Branch(63)
B11:
	61: LdFalse
	62: StLoc[6](loc1: bool)
B12:
	63: MoveLoc[6](loc1: bool)
	64: BrFalse(66)
B13:
	65: Branch(72)
B14:
	66: MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
	67: Pop
	68: MoveLoc[4](Arg4: &mut TxContext)
	69: Pop
	70: LdConst[1](u64: 1)
	71: Abort
B15:
	72: CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
	73: MutBorrowFieldGeneric[2](Pool.lp_supply: Supply<LP<Ty0, Ty1>>)
	74: MoveLoc[1](Arg1: Coin<LP<Ty0, Ty1>>)
	75: Call coin::into_balance<LP<Ty0, Ty1>>(Coin<LP<Ty0, Ty1>>): Balance<LP<Ty0, Ty1>>
	76: Call balance::decrease_supply<LP<Ty0, Ty1>>(&mut Supply<LP<Ty0, Ty1>>, Balance<LP<Ty0, Ty1>>): u64
	77: Pop
	78: CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
	79: FreezeRef
	80: Call object::id<Pool<Ty0, Ty1>>(&Pool<Ty0, Ty1>): ID
	81: CopyLoc[4](Arg4: &mut TxContext)
	82: FreezeRef
	83: Call tx_context::sender(&TxContext): address
	84: CopyLoc[7](loc2: u64)
	85: CopyLoc[8](loc3: u64)
	86: MoveLoc[9](loc4: u64)
	87: Pack[6](LiquidityRemoved)
	88: Call event::emit<LiquidityRemoved>(LiquidityRemoved)
	89: CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
	90: MutBorrowFieldGeneric[0](Pool.reserve_a: Balance<Ty0>)
	91: MoveLoc[7](loc2: u64)
	92: Call balance::split<Ty0>(&mut Balance<Ty0>, u64): Balance<Ty0>
	93: CopyLoc[4](Arg4: &mut TxContext)
	94: Call coin::from_balance<Ty0>(Balance<Ty0>, &mut TxContext): Coin<Ty0>
	95: MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
	96: MutBorrowFieldGeneric[1](Pool.reserve_b: Balance<Ty1>)
	97: MoveLoc[8](loc3: u64)
	98: Call balance::split<Ty1>(&mut Balance<Ty1>, u64): Balance<Ty1>
	99: MoveLoc[4](Arg4: &mut TxContext)
	100: Call coin::from_balance<Ty1>(Balance<Ty1>, &mut TxContext): Coin<Ty1>
	101: Ret
}

public swap_a_to_b<Ty0, Ty1>(Arg0: &mut Pool<Ty0, Ty1>, Arg1: Coin<Ty0>, Arg2: u64, Arg3: &mut TxContext): Coin<Ty1> {
L4:	loc0: u64
L5:	loc1: u64
B0:
	0: ImmBorrowLoc[1](Arg1: Coin<Ty0>)
	1: Call coin::value<Ty0>(&Coin<Ty0>): u64
	2: StLoc[4](loc0: u64)
	3: CopyLoc[4](loc0: u64)
	4: LdU64(0)
	5: Gt
	6: BrFalse(8)
B1:
	7: Branch(14)
B2:
	8: MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
	9: Pop
	10: MoveLoc[3](Arg3: &mut TxContext)
	11: Pop
	12: LdConst[0](u64: 0)
	13: Abort
B3:
	14: CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
	15: FreezeRef
	16: CopyLoc[4](loc0: u64)
	17: Call quote_a_to_b<Ty0, Ty1>(&Pool<Ty0, Ty1>, u64): u64
	18: StLoc[5](loc1: u64)
	19: CopyLoc[5](loc1: u64)
	20: MoveLoc[2](Arg2: u64)
	21: Ge
	22: BrFalse(24)
B4:
	23: Branch(30)
B5:
	24: MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
	25: Pop
	26: MoveLoc[3](Arg3: &mut TxContext)
	27: Pop
	28: LdConst[1](u64: 1)
	29: Abort
B6:
	30: CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
	31: MutBorrowFieldGeneric[0](Pool.reserve_a: Balance<Ty0>)
	32: MoveLoc[1](Arg1: Coin<Ty0>)
	33: Call coin::into_balance<Ty0>(Coin<Ty0>): Balance<Ty0>
	34: Call balance::join<Ty0>(&mut Balance<Ty0>, Balance<Ty0>): u64
	35: Pop
	36: CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
	37: FreezeRef
	38: Call object::id<Pool<Ty0, Ty1>>(&Pool<Ty0, Ty1>): ID
	39: CopyLoc[3](Arg3: &mut TxContext)
	40: FreezeRef
	41: Call tx_context::sender(&TxContext): address
	42: LdTrue
	43: MoveLoc[4](loc0: u64)
	44: CopyLoc[5](loc1: u64)
	45: Pack[7](Swapped)
	46: Call event::emit<Swapped>(Swapped)
	47: MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
	48: MutBorrowFieldGeneric[1](Pool.reserve_b: Balance<Ty1>)
	49: MoveLoc[5](loc1: u64)
	50: Call balance::split<Ty1>(&mut Balance<Ty1>, u64): Balance<Ty1>
	51: MoveLoc[3](Arg3: &mut TxContext)
	52: Call coin::from_balance<Ty1>(Balance<Ty1>, &mut TxContext): Coin<Ty1>
	53: Ret
}

public swap_b_to_a<Ty0, Ty1>(Arg0: &mut Pool<Ty0, Ty1>, Arg1: Coin<Ty1>, Arg2: u64, Arg3: &mut TxContext): Coin<Ty0> {
L4:	loc0: u64
L5:	loc1: u64
B0:
	0: ImmBorrowLoc[1](Arg1: Coin<Ty1>)
	1: Call coin::value<Ty1>(&Coin<Ty1>): u64
	2: StLoc[4](loc0: u64)
	3: CopyLoc[4](loc0: u64)
	4: LdU64(0)
	5: Gt
	6: BrFalse(8)
B1:
	7: Branch(14)
B2:
	8: MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
	9: Pop
	10: MoveLoc[3](Arg3: &mut TxContext)
	11: Pop
	12: LdConst[0](u64: 0)
	13: Abort
B3:
	14: CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
	15: FreezeRef
	16: CopyLoc[4](loc0: u64)
	17: Call quote_b_to_a<Ty0, Ty1>(&Pool<Ty0, Ty1>, u64): u64
	18: StLoc[5](loc1: u64)
	19: CopyLoc[5](loc1: u64)
	20: MoveLoc[2](Arg2: u64)
	21: Ge
	22: BrFalse(24)
B4:
	23: Branch(30)
B5:
	24: MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
	25: Pop
	26: MoveLoc[3](Arg3: &mut TxContext)
	27: Pop
	28: LdConst[1](u64: 1)
	29: Abort
B6:
	30: CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
	31: MutBorrowFieldGeneric[1](Pool.reserve_b: Balance<Ty1>)
	32: MoveLoc[1](Arg1: Coin<Ty1>)
	33: Call coin::into_balance<Ty1>(Coin<Ty1>): Balance<Ty1>
	34: Call balance::join<Ty1>(&mut Balance<Ty1>, Balance<Ty1>): u64
	35: Pop
	36: CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
	37: FreezeRef
	38: Call object::id<Pool<Ty0, Ty1>>(&Pool<Ty0, Ty1>): ID
	39: CopyLoc[3](Arg3: &mut TxContext)
	40: FreezeRef
	41: Call tx_context::sender(&TxContext): address
	42: LdFalse
	43: MoveLoc[4](loc0: u64)
	44: CopyLoc[5](loc1: u64)
	45: Pack[7](Swapped)
	46: Call event::emit<Swapped>(Swapped)
	47: MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
	48: MutBorrowFieldGeneric[0](Pool.reserve_a: Balance<Ty0>)
	49: MoveLoc[5](loc1: u64)
	50: Call balance::split<Ty0>(&mut Balance<Ty0>, u64): Balance<Ty0>
	51: MoveLoc[3](Arg3: &mut TxContext)
	52: Call coin::from_balance<Ty0>(Balance<Ty0>, &mut TxContext): Coin<Ty0>
	53: Ret
}

public quote_a_to_b<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>, Arg1: u64): u64 {
B0:
	0: MoveLoc[1](Arg1: u64)
	1: CopyLoc[0](Arg0: &Pool<Ty0, Ty1>)
	2: ImmBorrowFieldGeneric[0](Pool.reserve_a: Balance<Ty0>)
	3: Call balance::value<Ty0>(&Balance<Ty0>): u64
	4: CopyLoc[0](Arg0: &Pool<Ty0, Ty1>)
	5: ImmBorrowFieldGeneric[1](Pool.reserve_b: Balance<Ty1>)
	6: Call balance::value<Ty1>(&Balance<Ty1>): u64
	7: MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
	8: ImmBorrowFieldGeneric[4](Pool.fee_bps: u64)
	9: ReadRef
	10: Call get_amount_out(u64, u64, u64, u64): u64
	11: Ret
}

public quote_b_to_a<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>, Arg1: u64): u64 {
B0:
	0: MoveLoc[1](Arg1: u64)
	1: CopyLoc[0](Arg0: &Pool<Ty0, Ty1>)
	2: ImmBorrowFieldGeneric[1](Pool.reserve_b: Balance<Ty1>)
	3: Call balance::value<Ty1>(&Balance<Ty1>): u64
	4: CopyLoc[0](Arg0: &Pool<Ty0, Ty1>)
	5: ImmBorrowFieldGeneric[0](Pool.reserve_a: Balance<Ty0>)
	6: Call balance::value<Ty0>(&Balance<Ty0>): u64
	7: MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
	8: ImmBorrowFieldGeneric[4](Pool.fee_bps: u64)
	9: ReadRef
	10: Call get_amount_out(u64, u64, u64, u64): u64
	11: Ret
}

public reserves<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>): u64 * u64 {
B0:
	0: CopyLoc[0](Arg0: &Pool<Ty0, Ty1>)
	1: ImmBorrowFieldGeneric[0](Pool.reserve_a: Balance<Ty0>)
	2: Call balance::value<Ty0>(&Balance<Ty0>): u64
	3: MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
	4: ImmBorrowFieldGeneric[1](Pool.reserve_b: Balance<Ty1>)
	5: Call balance::value<Ty1>(&Balance<Ty1>): u64
	6: Ret
}

public lp_supply<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>): u64 {
B0:
	0: MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
	1: ImmBorrowFieldGeneric[2](Pool.lp_supply: Supply<LP<Ty0, Ty1>>)
	2: Call balance::supply_value<LP<Ty0, Ty1>>(&Supply<LP<Ty0, Ty1>>): u64
	3: Ret
}

public fee_bps<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>): u64 {
B0:
	0: MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
	1: ImmBorrowFieldGeneric[4](Pool.fee_bps: u64)
	2: ReadRef
	3: Ret
}

public get_amount_out(Arg0: u64, Arg1: u64, Arg2: u64, Arg3: u64): u64 {
L4:	loc0: bool
L5:	loc1: u128
L6:	loc2: u128
L7:	loc3: u128
B0:
	0: CopyLoc[1](Arg1: u64)
	1: LdU64(0)
	2: Gt
	3: BrFalse(9)
B1:
	4: CopyLoc[2](Arg2: u64)
	5: LdU64(0)
	6: Gt
	7: StLoc[4](loc0: bool)
	8: Branch(11)
B2:
	9: LdFalse
	10: StLoc[4](loc0: bool)
B3:
	11: MoveLoc[4](loc0: bool)
	12: BrFalse(14)
B4:
	13: Branch(16)
B5:
	14: LdConst[6](u64: 6)
	15: Abort
B6:
	16: MoveLoc[0](Arg0: u64)
	17: CastU128
	18: LdConst[7](u64: 10000)
	19: MoveLoc[3](Arg3: u64)
	20: Sub
	21: CastU128
	22: Mul
	23: StLoc[6](loc2: u128)
	24: CopyLoc[6](loc2: u128)
	25: MoveLoc[2](Arg2: u64)
	26: CastU128
	27: Mul
	28: StLoc[7](loc3: u128)
	29: MoveLoc[1](Arg1: u64)
	30: CastU128
	31: LdConst[7](u64: 10000)
	32: CastU128
	33: Mul
	34: MoveLoc[6](loc2: u128)
	35: Add
	36: StLoc[5](loc1: u128)
	37: MoveLoc[7](loc3: u128)
	38: MoveLoc[5](loc1: u128)
	39: Div
	40: CastU64
	41: Ret
}

mul_div(Arg0: u64, Arg1: u64, Arg2: u64): u64 {
B0:
	0: MoveLoc[0](Arg0: u64)
	1: CastU128
	2: MoveLoc[1](Arg1: u64)
	3: CastU128
	4: Mul
	5: MoveLoc[2](Arg2: u64)
	6: CastU128
	7: Div
	8: CastU64
	9: Ret
}

refund_or_destroy<Ty0>(Arg0: Coin<Ty0>, Arg1: address) {
B0:
	0: ImmBorrowLoc[0](Arg0: Coin<Ty0>)
	1: Call coin::value<Ty0>(&Coin<Ty0>): u64
	2: LdU64(0)
	3: Eq
	4: BrFalse(8)
B1:
	5: MoveLoc[0](Arg0: Coin<Ty0>)
	6: Call coin::destroy_zero<Ty0>(Coin<Ty0>)
	7: Branch(11)
B2:
	8: MoveLoc[0](Arg0: Coin<Ty0>)
	9: MoveLoc[1](Arg1: address)
	10: Call transfer::public_transfer<Coin<Ty0>>(Coin<Ty0>, address)
B3:
	11: Ret
}

Constants [
	0 => u64: 0
	1 => u64: 1
	2 => u64: 2
	3 => u64: 3
	4 => u64: 4
	5 => u64: 5
	6 => u64: 6
	7 => u64: 10000
	8 => u64: 1000
]
}