/**
 * This code was AUTOGENERATED using the Codama library.
 * Please DO NOT EDIT THIS FILE, instead use visitors
 * to add features, then rerun Codama to update it.
 *
 * @see https://github.com/codama-idl/codama
 */

import {
  assertIsInstructionWithAccounts,
  containsBytes,
  extendClient,
  fixEncoderSize,
  getBytesEncoder,
  SOLANA_ERROR__PROGRAM_CLIENTS__FAILED_TO_IDENTIFY_ACCOUNT,
  SOLANA_ERROR__PROGRAM_CLIENTS__FAILED_TO_IDENTIFY_INSTRUCTION,
  SOLANA_ERROR__PROGRAM_CLIENTS__UNRECOGNIZED_INSTRUCTION_TYPE,
  SolanaError,
  type Address,
  type ClientWithPayer,
  type ClientWithRpc,
  type ClientWithTransactionPlanning,
  type ClientWithTransactionSending,
  type ExtendedClient,
  type GetAccountInfoApi,
  type GetMultipleAccountsApi,
  type Instruction,
  type InstructionWithData,
  type ReadonlyUint8Array,
} from "@solana/kit";
import {
  addSelfFetchFunctions,
  addSelfPlanAndSendFunctions,
  type SelfFetchFunctions,
  type SelfPlanAndSendFunctions,
} from "@solana/program-client-core";
import {
  getClaimFeeOperatorCodec,
  getConfigCodec,
  getPoolCodec,
  getPositionCodec,
  getTokenBadgeCodec,
  getVestingCodec,
  type ClaimFeeOperator,
  type ClaimFeeOperatorArgs,
  type Config,
  type ConfigArgs,
  type Pool,
  type PoolArgs,
  type Position,
  type PositionArgs,
  type TokenBadge,
  type TokenBadgeArgs,
  type Vesting,
  type VestingArgs,
} from "../accounts/index.js";
import {
  getAddLiquidityInstructionAsync,
  getClaimPartnerFeeInstructionAsync,
  getClaimPositionFeeInstructionAsync,
  getClaimProtocolFeeInstructionAsync,
  getClaimRewardInstructionAsync,
  getCloseClaimFeeOperatorInstructionAsync,
  getCloseConfigInstructionAsync,
  getClosePositionInstructionAsync,
  getCloseTokenBadgeInstructionAsync,
  getCreateClaimFeeOperatorInstructionAsync,
  getCreateConfigInstructionAsync,
  getCreateDynamicConfigInstructionAsync,
  getCreatePositionInstructionAsync,
  getCreateTokenBadgeInstructionAsync,
  getFundRewardInstructionAsync,
  getInitializeCustomizablePoolInstructionAsync,
  getInitializePoolInstructionAsync,
  getInitializePoolWithDynamicConfigInstructionAsync,
  getInitializeRewardInstructionAsync,
  getLockPositionInstructionAsync,
  getPermanentLockPositionInstructionAsync,
  getRefreshVestingInstruction,
  getRemoveAllLiquidityInstructionAsync,
  getRemoveLiquidityInstructionAsync,
  getSetPoolStatusInstructionAsync,
  getSplitPosition2InstructionAsync,
  getSplitPositionInstructionAsync,
  getSwap2InstructionAsync,
  getSwapInstructionAsync,
  getUpdateRewardDurationInstructionAsync,
  getUpdateRewardFunderInstructionAsync,
  getWithdrawIneligibleRewardInstructionAsync,
  parseAddLiquidityInstruction,
  parseClaimPartnerFeeInstruction,
  parseClaimPositionFeeInstruction,
  parseClaimProtocolFeeInstruction,
  parseClaimRewardInstruction,
  parseCloseClaimFeeOperatorInstruction,
  parseCloseConfigInstruction,
  parseClosePositionInstruction,
  parseCloseTokenBadgeInstruction,
  parseCreateClaimFeeOperatorInstruction,
  parseCreateConfigInstruction,
  parseCreateDynamicConfigInstruction,
  parseCreatePositionInstruction,
  parseCreateTokenBadgeInstruction,
  parseFundRewardInstruction,
  parseInitializeCustomizablePoolInstruction,
  parseInitializePoolInstruction,
  parseInitializePoolWithDynamicConfigInstruction,
  parseInitializeRewardInstruction,
  parseLockPositionInstruction,
  parsePermanentLockPositionInstruction,
  parseRefreshVestingInstruction,
  parseRemoveAllLiquidityInstruction,
  parseRemoveLiquidityInstruction,
  parseSetPoolStatusInstruction,
  parseSplitPosition2Instruction,
  parseSplitPositionInstruction,
  parseSwap2Instruction,
  parseSwapInstruction,
  parseUpdateRewardDurationInstruction,
  parseUpdateRewardFunderInstruction,
  parseWithdrawIneligibleRewardInstruction,
  type AddLiquidityAsyncInput,
  type ClaimPartnerFeeAsyncInput,
  type ClaimPositionFeeAsyncInput,
  type ClaimProtocolFeeAsyncInput,
  type ClaimRewardAsyncInput,
  type CloseClaimFeeOperatorAsyncInput,
  type CloseConfigAsyncInput,
  type ClosePositionAsyncInput,
  type CloseTokenBadgeAsyncInput,
  type CreateClaimFeeOperatorAsyncInput,
  type CreateConfigAsyncInput,
  type CreateDynamicConfigAsyncInput,
  type CreatePositionAsyncInput,
  type CreateTokenBadgeAsyncInput,
  type FundRewardAsyncInput,
  type InitializeCustomizablePoolAsyncInput,
  type InitializePoolAsyncInput,
  type InitializePoolWithDynamicConfigAsyncInput,
  type InitializeRewardAsyncInput,
  type LockPositionAsyncInput,
  type ParsedAddLiquidityInstruction,
  type ParsedClaimPartnerFeeInstruction,
  type ParsedClaimPositionFeeInstruction,
  type ParsedClaimProtocolFeeInstruction,
  type ParsedClaimRewardInstruction,
  type ParsedCloseClaimFeeOperatorInstruction,
  type ParsedCloseConfigInstruction,
  type ParsedClosePositionInstruction,
  type ParsedCloseTokenBadgeInstruction,
  type ParsedCreateClaimFeeOperatorInstruction,
  type ParsedCreateConfigInstruction,
  type ParsedCreateDynamicConfigInstruction,
  type ParsedCreatePositionInstruction,
  type ParsedCreateTokenBadgeInstruction,
  type ParsedFundRewardInstruction,
  type ParsedInitializeCustomizablePoolInstruction,
  type ParsedInitializePoolInstruction,
  type ParsedInitializePoolWithDynamicConfigInstruction,
  type ParsedInitializeRewardInstruction,
  type ParsedLockPositionInstruction,
  type ParsedPermanentLockPositionInstruction,
  type ParsedRefreshVestingInstruction,
  type ParsedRemoveAllLiquidityInstruction,
  type ParsedRemoveLiquidityInstruction,
  type ParsedSetPoolStatusInstruction,
  type ParsedSplitPosition2Instruction,
  type ParsedSplitPositionInstruction,
  type ParsedSwap2Instruction,
  type ParsedSwapInstruction,
  type ParsedUpdateRewardDurationInstruction,
  type ParsedUpdateRewardFunderInstruction,
  type ParsedWithdrawIneligibleRewardInstruction,
  type PermanentLockPositionAsyncInput,
  type RefreshVestingInput,
  type RemoveAllLiquidityAsyncInput,
  type RemoveLiquidityAsyncInput,
  type SetPoolStatusAsyncInput,
  type SplitPosition2AsyncInput,
  type SplitPositionAsyncInput,
  type Swap2AsyncInput,
  type SwapAsyncInput,
  type UpdateRewardDurationAsyncInput,
  type UpdateRewardFunderAsyncInput,
  type WithdrawIneligibleRewardAsyncInput,
} from "../instructions/index.js";
import {
  findClaimFeeOperatorPda,
  findConfigPda,
  findCustomizablePoolPda,
  findEventAuthorityPda,
  findPoolAuthorityPda,
  findPoolPda,
  findPositionNftAccountPda,
  findPositionPda,
  findRewardVaultPda,
  findTokenBadgePda,
  findTokenVaultPda,
} from "../pdas/index.js";

export const CP_AMM_PROGRAM_ADDRESS =
  "cpamdpZCGKUy5JxQXB4dcpGPiikHawvSWAd6mEn1sGG" as Address<"cpamdpZCGKUy5JxQXB4dcpGPiikHawvSWAd6mEn1sGG">;

export enum CpAmmAccount {
  ClaimFeeOperator,
  Config,
  Pool,
  Position,
  TokenBadge,
  Vesting,
}

export function identifyCpAmmAccount(
  account: { data: ReadonlyUint8Array } | ReadonlyUint8Array,
): CpAmmAccount {
  const data = "data" in account ? account.data : account;
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([166, 48, 134, 86, 34, 200, 188, 150]),
      ),
      0,
    )
  ) {
    return CpAmmAccount.ClaimFeeOperator;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([155, 12, 170, 224, 30, 250, 204, 130]),
      ),
      0,
    )
  ) {
    return CpAmmAccount.Config;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([241, 154, 109, 4, 17, 177, 109, 188]),
      ),
      0,
    )
  ) {
    return CpAmmAccount.Pool;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([170, 188, 143, 228, 122, 64, 247, 208]),
      ),
      0,
    )
  ) {
    return CpAmmAccount.Position;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([116, 219, 204, 229, 249, 116, 255, 150]),
      ),
      0,
    )
  ) {
    return CpAmmAccount.TokenBadge;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([100, 149, 66, 138, 95, 200, 128, 241]),
      ),
      0,
    )
  ) {
    return CpAmmAccount.Vesting;
  }
  throw new SolanaError(
    SOLANA_ERROR__PROGRAM_CLIENTS__FAILED_TO_IDENTIFY_ACCOUNT,
    { accountData: data, programName: "cpAmm" },
  );
}

export enum CpAmmInstruction {
  AddLiquidity,
  ClaimPartnerFee,
  ClaimPositionFee,
  ClaimProtocolFee,
  ClaimReward,
  CloseClaimFeeOperator,
  CloseConfig,
  ClosePosition,
  CloseTokenBadge,
  CreateClaimFeeOperator,
  CreateConfig,
  CreateDynamicConfig,
  CreatePosition,
  CreateTokenBadge,
  FundReward,
  InitializeCustomizablePool,
  InitializePool,
  InitializePoolWithDynamicConfig,
  InitializeReward,
  LockPosition,
  PermanentLockPosition,
  RefreshVesting,
  RemoveAllLiquidity,
  RemoveLiquidity,
  SetPoolStatus,
  SplitPosition,
  SplitPosition2,
  Swap,
  Swap2,
  UpdateRewardDuration,
  UpdateRewardFunder,
  WithdrawIneligibleReward,
}

export function identifyCpAmmInstruction(
  instruction: { data: ReadonlyUint8Array } | ReadonlyUint8Array,
): CpAmmInstruction {
  const data = "data" in instruction ? instruction.data : instruction;
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([181, 157, 89, 67, 143, 182, 52, 72]),
      ),
      0,
    )
  ) {
    return CpAmmInstruction.AddLiquidity;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([97, 206, 39, 105, 94, 94, 126, 148]),
      ),
      0,
    )
  ) {
    return CpAmmInstruction.ClaimPartnerFee;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([180, 38, 154, 17, 133, 33, 162, 211]),
      ),
      0,
    )
  ) {
    return CpAmmInstruction.ClaimPositionFee;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([165, 228, 133, 48, 99, 249, 255, 33]),
      ),
      0,
    )
  ) {
    return CpAmmInstruction.ClaimProtocolFee;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([149, 95, 181, 242, 94, 90, 158, 162]),
      ),
      0,
    )
  ) {
    return CpAmmInstruction.ClaimReward;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([38, 134, 82, 216, 95, 124, 17, 99]),
      ),
      0,
    )
  ) {
    return CpAmmInstruction.CloseClaimFeeOperator;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([145, 9, 72, 157, 95, 125, 61, 85]),
      ),
      0,
    )
  ) {
    return CpAmmInstruction.CloseConfig;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([123, 134, 81, 0, 49, 68, 98, 98]),
      ),
      0,
    )
  ) {
    return CpAmmInstruction.ClosePosition;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([108, 146, 86, 110, 179, 254, 10, 104]),
      ),
      0,
    )
  ) {
    return CpAmmInstruction.CloseTokenBadge;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([169, 62, 207, 107, 58, 187, 162, 109]),
      ),
      0,
    )
  ) {
    return CpAmmInstruction.CreateClaimFeeOperator;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([201, 207, 243, 114, 75, 111, 47, 189]),
      ),
      0,
    )
  ) {
    return CpAmmInstruction.CreateConfig;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([81, 251, 122, 78, 66, 57, 208, 82]),
      ),
      0,
    )
  ) {
    return CpAmmInstruction.CreateDynamicConfig;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([48, 215, 197, 153, 96, 203, 180, 133]),
      ),
      0,
    )
  ) {
    return CpAmmInstruction.CreatePosition;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([88, 206, 0, 91, 60, 175, 151, 118]),
      ),
      0,
    )
  ) {
    return CpAmmInstruction.CreateTokenBadge;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([188, 50, 249, 165, 93, 151, 38, 63]),
      ),
      0,
    )
  ) {
    return CpAmmInstruction.FundReward;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([20, 161, 241, 24, 189, 221, 180, 2]),
      ),
      0,
    )
  ) {
    return CpAmmInstruction.InitializeCustomizablePool;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([95, 180, 10, 172, 84, 174, 232, 40]),
      ),
      0,
    )
  ) {
    return CpAmmInstruction.InitializePool;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([149, 82, 72, 197, 253, 252, 68, 15]),
      ),
      0,
    )
  ) {
    return CpAmmInstruction.InitializePoolWithDynamicConfig;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([95, 135, 192, 196, 242, 129, 230, 68]),
      ),
      0,
    )
  ) {
    return CpAmmInstruction.InitializeReward;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([227, 62, 2, 252, 247, 10, 171, 185]),
      ),
      0,
    )
  ) {
    return CpAmmInstruction.LockPosition;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([165, 176, 125, 6, 231, 171, 186, 213]),
      ),
      0,
    )
  ) {
    return CpAmmInstruction.PermanentLockPosition;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([9, 94, 216, 14, 116, 204, 247, 0]),
      ),
      0,
    )
  ) {
    return CpAmmInstruction.RefreshVesting;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([10, 51, 61, 35, 112, 105, 24, 85]),
      ),
      0,
    )
  ) {
    return CpAmmInstruction.RemoveAllLiquidity;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([80, 85, 209, 72, 24, 206, 177, 108]),
      ),
      0,
    )
  ) {
    return CpAmmInstruction.RemoveLiquidity;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([112, 87, 135, 223, 83, 204, 132, 53]),
      ),
      0,
    )
  ) {
    return CpAmmInstruction.SetPoolStatus;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([172, 241, 221, 138, 161, 29, 253, 42]),
      ),
      0,
    )
  ) {
    return CpAmmInstruction.SplitPosition;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([221, 147, 228, 207, 140, 212, 17, 119]),
      ),
      0,
    )
  ) {
    return CpAmmInstruction.SplitPosition2;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([248, 198, 158, 145, 225, 117, 135, 200]),
      ),
      0,
    )
  ) {
    return CpAmmInstruction.Swap;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([65, 75, 63, 76, 235, 91, 91, 136]),
      ),
      0,
    )
  ) {
    return CpAmmInstruction.Swap2;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([138, 174, 196, 169, 213, 235, 254, 107]),
      ),
      0,
    )
  ) {
    return CpAmmInstruction.UpdateRewardDuration;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([211, 28, 48, 32, 215, 160, 35, 23]),
      ),
      0,
    )
  ) {
    return CpAmmInstruction.UpdateRewardFunder;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([148, 206, 42, 195, 247, 49, 103, 8]),
      ),
      0,
    )
  ) {
    return CpAmmInstruction.WithdrawIneligibleReward;
  }
  throw new SolanaError(
    SOLANA_ERROR__PROGRAM_CLIENTS__FAILED_TO_IDENTIFY_INSTRUCTION,
    { instructionData: data, programName: "cpAmm" },
  );
}

export type ParsedCpAmmInstruction<
  TProgram extends string = "cpamdpZCGKUy5JxQXB4dcpGPiikHawvSWAd6mEn1sGG",
> =
  | ({
      instructionType: CpAmmInstruction.AddLiquidity;
    } & ParsedAddLiquidityInstruction<TProgram>)
  | ({
      instructionType: CpAmmInstruction.ClaimPartnerFee;
    } & ParsedClaimPartnerFeeInstruction<TProgram>)
  | ({
      instructionType: CpAmmInstruction.ClaimPositionFee;
    } & ParsedClaimPositionFeeInstruction<TProgram>)
  | ({
      instructionType: CpAmmInstruction.ClaimProtocolFee;
    } & ParsedClaimProtocolFeeInstruction<TProgram>)
  | ({
      instructionType: CpAmmInstruction.ClaimReward;
    } & ParsedClaimRewardInstruction<TProgram>)
  | ({
      instructionType: CpAmmInstruction.CloseClaimFeeOperator;
    } & ParsedCloseClaimFeeOperatorInstruction<TProgram>)
  | ({
      instructionType: CpAmmInstruction.CloseConfig;
    } & ParsedCloseConfigInstruction<TProgram>)
  | ({
      instructionType: CpAmmInstruction.ClosePosition;
    } & ParsedClosePositionInstruction<TProgram>)
  | ({
      instructionType: CpAmmInstruction.CloseTokenBadge;
    } & ParsedCloseTokenBadgeInstruction<TProgram>)
  | ({
      instructionType: CpAmmInstruction.CreateClaimFeeOperator;
    } & ParsedCreateClaimFeeOperatorInstruction<TProgram>)
  | ({
      instructionType: CpAmmInstruction.CreateConfig;
    } & ParsedCreateConfigInstruction<TProgram>)
  | ({
      instructionType: CpAmmInstruction.CreateDynamicConfig;
    } & ParsedCreateDynamicConfigInstruction<TProgram>)
  | ({
      instructionType: CpAmmInstruction.CreatePosition;
    } & ParsedCreatePositionInstruction<TProgram>)
  | ({
      instructionType: CpAmmInstruction.CreateTokenBadge;
    } & ParsedCreateTokenBadgeInstruction<TProgram>)
  | ({
      instructionType: CpAmmInstruction.FundReward;
    } & ParsedFundRewardInstruction<TProgram>)
  | ({
      instructionType: CpAmmInstruction.InitializeCustomizablePool;
    } & ParsedInitializeCustomizablePoolInstruction<TProgram>)
  | ({
      instructionType: CpAmmInstruction.InitializePool;
    } & ParsedInitializePoolInstruction<TProgram>)
  | ({
      instructionType: CpAmmInstruction.InitializePoolWithDynamicConfig;
    } & ParsedInitializePoolWithDynamicConfigInstruction<TProgram>)
  | ({
      instructionType: CpAmmInstruction.InitializeReward;
    } & ParsedInitializeRewardInstruction<TProgram>)
  | ({
      instructionType: CpAmmInstruction.LockPosition;
    } & ParsedLockPositionInstruction<TProgram>)
  | ({
      instructionType: CpAmmInstruction.PermanentLockPosition;
    } & ParsedPermanentLockPositionInstruction<TProgram>)
  | ({
      instructionType: CpAmmInstruction.RefreshVesting;
    } & ParsedRefreshVestingInstruction<TProgram>)
  | ({
      instructionType: CpAmmInstruction.RemoveAllLiquidity;
    } & ParsedRemoveAllLiquidityInstruction<TProgram>)
  | ({
      instructionType: CpAmmInstruction.RemoveLiquidity;
    } & ParsedRemoveLiquidityInstruction<TProgram>)
  | ({
      instructionType: CpAmmInstruction.SetPoolStatus;
    } & ParsedSetPoolStatusInstruction<TProgram>)
  | ({
      instructionType: CpAmmInstruction.SplitPosition;
    } & ParsedSplitPositionInstruction<TProgram>)
  | ({
      instructionType: CpAmmInstruction.SplitPosition2;
    } & ParsedSplitPosition2Instruction<TProgram>)
  | ({
      instructionType: CpAmmInstruction.Swap;
    } & ParsedSwapInstruction<TProgram>)
  | ({
      instructionType: CpAmmInstruction.Swap2;
    } & ParsedSwap2Instruction<TProgram>)
  | ({
      instructionType: CpAmmInstruction.UpdateRewardDuration;
    } & ParsedUpdateRewardDurationInstruction<TProgram>)
  | ({
      instructionType: CpAmmInstruction.UpdateRewardFunder;
    } & ParsedUpdateRewardFunderInstruction<TProgram>)
  | ({
      instructionType: CpAmmInstruction.WithdrawIneligibleReward;
    } & ParsedWithdrawIneligibleRewardInstruction<TProgram>);

export function parseCpAmmInstruction<TProgram extends string>(
  instruction: Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array>,
): ParsedCpAmmInstruction<TProgram> {
  const instructionType = identifyCpAmmInstruction(instruction);
  switch (instructionType) {
    case CpAmmInstruction.AddLiquidity: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: CpAmmInstruction.AddLiquidity,
        ...parseAddLiquidityInstruction(instruction),
      };
    }
    case CpAmmInstruction.ClaimPartnerFee: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: CpAmmInstruction.ClaimPartnerFee,
        ...parseClaimPartnerFeeInstruction(instruction),
      };
    }
    case CpAmmInstruction.ClaimPositionFee: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: CpAmmInstruction.ClaimPositionFee,
        ...parseClaimPositionFeeInstruction(instruction),
      };
    }
    case CpAmmInstruction.ClaimProtocolFee: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: CpAmmInstruction.ClaimProtocolFee,
        ...parseClaimProtocolFeeInstruction(instruction),
      };
    }
    case CpAmmInstruction.ClaimReward: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: CpAmmInstruction.ClaimReward,
        ...parseClaimRewardInstruction(instruction),
      };
    }
    case CpAmmInstruction.CloseClaimFeeOperator: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: CpAmmInstruction.CloseClaimFeeOperator,
        ...parseCloseClaimFeeOperatorInstruction(instruction),
      };
    }
    case CpAmmInstruction.CloseConfig: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: CpAmmInstruction.CloseConfig,
        ...parseCloseConfigInstruction(instruction),
      };
    }
    case CpAmmInstruction.ClosePosition: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: CpAmmInstruction.ClosePosition,
        ...parseClosePositionInstruction(instruction),
      };
    }
    case CpAmmInstruction.CloseTokenBadge: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: CpAmmInstruction.CloseTokenBadge,
        ...parseCloseTokenBadgeInstruction(instruction),
      };
    }
    case CpAmmInstruction.CreateClaimFeeOperator: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: CpAmmInstruction.CreateClaimFeeOperator,
        ...parseCreateClaimFeeOperatorInstruction(instruction),
      };
    }
    case CpAmmInstruction.CreateConfig: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: CpAmmInstruction.CreateConfig,
        ...parseCreateConfigInstruction(instruction),
      };
    }
    case CpAmmInstruction.CreateDynamicConfig: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: CpAmmInstruction.CreateDynamicConfig,
        ...parseCreateDynamicConfigInstruction(instruction),
      };
    }
    case CpAmmInstruction.CreatePosition: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: CpAmmInstruction.CreatePosition,
        ...parseCreatePositionInstruction(instruction),
      };
    }
    case CpAmmInstruction.CreateTokenBadge: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: CpAmmInstruction.CreateTokenBadge,
        ...parseCreateTokenBadgeInstruction(instruction),
      };
    }
    case CpAmmInstruction.FundReward: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: CpAmmInstruction.FundReward,
        ...parseFundRewardInstruction(instruction),
      };
    }
    case CpAmmInstruction.InitializeCustomizablePool: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: CpAmmInstruction.InitializeCustomizablePool,
        ...parseInitializeCustomizablePoolInstruction(instruction),
      };
    }
    case CpAmmInstruction.InitializePool: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: CpAmmInstruction.InitializePool,
        ...parseInitializePoolInstruction(instruction),
      };
    }
    case CpAmmInstruction.InitializePoolWithDynamicConfig: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: CpAmmInstruction.InitializePoolWithDynamicConfig,
        ...parseInitializePoolWithDynamicConfigInstruction(instruction),
      };
    }
    case CpAmmInstruction.InitializeReward: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: CpAmmInstruction.InitializeReward,
        ...parseInitializeRewardInstruction(instruction),
      };
    }
    case CpAmmInstruction.LockPosition: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: CpAmmInstruction.LockPosition,
        ...parseLockPositionInstruction(instruction),
      };
    }
    case CpAmmInstruction.PermanentLockPosition: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: CpAmmInstruction.PermanentLockPosition,
        ...parsePermanentLockPositionInstruction(instruction),
      };
    }
    case CpAmmInstruction.RefreshVesting: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: CpAmmInstruction.RefreshVesting,
        ...parseRefreshVestingInstruction(instruction),
      };
    }
    case CpAmmInstruction.RemoveAllLiquidity: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: CpAmmInstruction.RemoveAllLiquidity,
        ...parseRemoveAllLiquidityInstruction(instruction),
      };
    }
    case CpAmmInstruction.RemoveLiquidity: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: CpAmmInstruction.RemoveLiquidity,
        ...parseRemoveLiquidityInstruction(instruction),
      };
    }
    case CpAmmInstruction.SetPoolStatus: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: CpAmmInstruction.SetPoolStatus,
        ...parseSetPoolStatusInstruction(instruction),
      };
    }
    case CpAmmInstruction.SplitPosition: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: CpAmmInstruction.SplitPosition,
        ...parseSplitPositionInstruction(instruction),
      };
    }
    case CpAmmInstruction.SplitPosition2: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: CpAmmInstruction.SplitPosition2,
        ...parseSplitPosition2Instruction(instruction),
      };
    }
    case CpAmmInstruction.Swap: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: CpAmmInstruction.Swap,
        ...parseSwapInstruction(instruction),
      };
    }
    case CpAmmInstruction.Swap2: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: CpAmmInstruction.Swap2,
        ...parseSwap2Instruction(instruction),
      };
    }
    case CpAmmInstruction.UpdateRewardDuration: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: CpAmmInstruction.UpdateRewardDuration,
        ...parseUpdateRewardDurationInstruction(instruction),
      };
    }
    case CpAmmInstruction.UpdateRewardFunder: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: CpAmmInstruction.UpdateRewardFunder,
        ...parseUpdateRewardFunderInstruction(instruction),
      };
    }
    case CpAmmInstruction.WithdrawIneligibleReward: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: CpAmmInstruction.WithdrawIneligibleReward,
        ...parseWithdrawIneligibleRewardInstruction(instruction),
      };
    }
    default:
      throw new SolanaError(
        SOLANA_ERROR__PROGRAM_CLIENTS__UNRECOGNIZED_INSTRUCTION_TYPE,
        { instructionType: instructionType as string, programName: "cpAmm" },
      );
  }
}

export type CpAmmPlugin = {
  accounts: CpAmmPluginAccounts;
  instructions: CpAmmPluginInstructions;
  pdas: CpAmmPluginPdas;
  identifyAccount: typeof identifyCpAmmAccount;
  identifyInstruction: typeof identifyCpAmmInstruction;
  parseInstruction: typeof parseCpAmmInstruction;
};

export type CpAmmPluginAccounts = {
  claimFeeOperator: ReturnType<typeof getClaimFeeOperatorCodec> &
    SelfFetchFunctions<ClaimFeeOperatorArgs, ClaimFeeOperator>;
  config: ReturnType<typeof getConfigCodec> &
    SelfFetchFunctions<ConfigArgs, Config>;
  pool: ReturnType<typeof getPoolCodec> & SelfFetchFunctions<PoolArgs, Pool>;
  position: ReturnType<typeof getPositionCodec> &
    SelfFetchFunctions<PositionArgs, Position>;
  tokenBadge: ReturnType<typeof getTokenBadgeCodec> &
    SelfFetchFunctions<TokenBadgeArgs, TokenBadge>;
  vesting: ReturnType<typeof getVestingCodec> &
    SelfFetchFunctions<VestingArgs, Vesting>;
};

export type CpAmmPluginInstructions = {
  addLiquidity: (
    input: AddLiquidityAsyncInput,
  ) => ReturnType<typeof getAddLiquidityInstructionAsync> &
    SelfPlanAndSendFunctions;
  claimPartnerFee: (
    input: ClaimPartnerFeeAsyncInput,
  ) => ReturnType<typeof getClaimPartnerFeeInstructionAsync> &
    SelfPlanAndSendFunctions;
  claimPositionFee: (
    input: ClaimPositionFeeAsyncInput,
  ) => ReturnType<typeof getClaimPositionFeeInstructionAsync> &
    SelfPlanAndSendFunctions;
  claimProtocolFee: (
    input: ClaimProtocolFeeAsyncInput,
  ) => ReturnType<typeof getClaimProtocolFeeInstructionAsync> &
    SelfPlanAndSendFunctions;
  claimReward: (
    input: ClaimRewardAsyncInput,
  ) => ReturnType<typeof getClaimRewardInstructionAsync> &
    SelfPlanAndSendFunctions;
  closeClaimFeeOperator: (
    input: CloseClaimFeeOperatorAsyncInput,
  ) => ReturnType<typeof getCloseClaimFeeOperatorInstructionAsync> &
    SelfPlanAndSendFunctions;
  closeConfig: (
    input: CloseConfigAsyncInput,
  ) => ReturnType<typeof getCloseConfigInstructionAsync> &
    SelfPlanAndSendFunctions;
  closePosition: (
    input: ClosePositionAsyncInput,
  ) => ReturnType<typeof getClosePositionInstructionAsync> &
    SelfPlanAndSendFunctions;
  closeTokenBadge: (
    input: CloseTokenBadgeAsyncInput,
  ) => ReturnType<typeof getCloseTokenBadgeInstructionAsync> &
    SelfPlanAndSendFunctions;
  createClaimFeeOperator: (
    input: CreateClaimFeeOperatorAsyncInput,
  ) => ReturnType<typeof getCreateClaimFeeOperatorInstructionAsync> &
    SelfPlanAndSendFunctions;
  createConfig: (
    input: CreateConfigAsyncInput,
  ) => ReturnType<typeof getCreateConfigInstructionAsync> &
    SelfPlanAndSendFunctions;
  createDynamicConfig: (
    input: CreateDynamicConfigAsyncInput,
  ) => ReturnType<typeof getCreateDynamicConfigInstructionAsync> &
    SelfPlanAndSendFunctions;
  createPosition: (
    input: MakeOptional<CreatePositionAsyncInput, "payer">,
  ) => ReturnType<typeof getCreatePositionInstructionAsync> &
    SelfPlanAndSendFunctions;
  createTokenBadge: (
    input: CreateTokenBadgeAsyncInput,
  ) => ReturnType<typeof getCreateTokenBadgeInstructionAsync> &
    SelfPlanAndSendFunctions;
  fundReward: (
    input: FundRewardAsyncInput,
  ) => ReturnType<typeof getFundRewardInstructionAsync> &
    SelfPlanAndSendFunctions;
  initializeCustomizablePool: (
    input: MakeOptional<InitializeCustomizablePoolAsyncInput, "payer">,
  ) => ReturnType<typeof getInitializeCustomizablePoolInstructionAsync> &
    SelfPlanAndSendFunctions;
  initializePool: (
    input: MakeOptional<InitializePoolAsyncInput, "payer">,
  ) => ReturnType<typeof getInitializePoolInstructionAsync> &
    SelfPlanAndSendFunctions;
  initializePoolWithDynamicConfig: (
    input: MakeOptional<InitializePoolWithDynamicConfigAsyncInput, "payer">,
  ) => ReturnType<typeof getInitializePoolWithDynamicConfigInstructionAsync> &
    SelfPlanAndSendFunctions;
  initializeReward: (
    input: MakeOptional<InitializeRewardAsyncInput, "payer">,
  ) => ReturnType<typeof getInitializeRewardInstructionAsync> &
    SelfPlanAndSendFunctions;
  lockPosition: (
    input: MakeOptional<LockPositionAsyncInput, "payer">,
  ) => ReturnType<typeof getLockPositionInstructionAsync> &
    SelfPlanAndSendFunctions;
  permanentLockPosition: (
    input: PermanentLockPositionAsyncInput,
  ) => ReturnType<typeof getPermanentLockPositionInstructionAsync> &
    SelfPlanAndSendFunctions;
  refreshVesting: (
    input: RefreshVestingInput,
  ) => ReturnType<typeof getRefreshVestingInstruction> &
    SelfPlanAndSendFunctions;
  removeAllLiquidity: (
    input: RemoveAllLiquidityAsyncInput,
  ) => ReturnType<typeof getRemoveAllLiquidityInstructionAsync> &
    SelfPlanAndSendFunctions;
  removeLiquidity: (
    input: RemoveLiquidityAsyncInput,
  ) => ReturnType<typeof getRemoveLiquidityInstructionAsync> &
    SelfPlanAndSendFunctions;
  setPoolStatus: (
    input: SetPoolStatusAsyncInput,
  ) => ReturnType<typeof getSetPoolStatusInstructionAsync> &
    SelfPlanAndSendFunctions;
  splitPosition: (
    input: SplitPositionAsyncInput,
  ) => ReturnType<typeof getSplitPositionInstructionAsync> &
    SelfPlanAndSendFunctions;
  splitPosition2: (
    input: SplitPosition2AsyncInput,
  ) => ReturnType<typeof getSplitPosition2InstructionAsync> &
    SelfPlanAndSendFunctions;
  swap: (
    input: MakeOptional<SwapAsyncInput, "payer">,
  ) => ReturnType<typeof getSwapInstructionAsync> & SelfPlanAndSendFunctions;
  swap2: (
    input: MakeOptional<Swap2AsyncInput, "payer">,
  ) => ReturnType<typeof getSwap2InstructionAsync> & SelfPlanAndSendFunctions;
  updateRewardDuration: (
    input: UpdateRewardDurationAsyncInput,
  ) => ReturnType<typeof getUpdateRewardDurationInstructionAsync> &
    SelfPlanAndSendFunctions;
  updateRewardFunder: (
    input: UpdateRewardFunderAsyncInput,
  ) => ReturnType<typeof getUpdateRewardFunderInstructionAsync> &
    SelfPlanAndSendFunctions;
  withdrawIneligibleReward: (
    input: WithdrawIneligibleRewardAsyncInput,
  ) => ReturnType<typeof getWithdrawIneligibleRewardInstructionAsync> &
    SelfPlanAndSendFunctions;
};

export type CpAmmPluginPdas = {
  poolAuthority: typeof findPoolAuthorityPda;
  config: typeof findConfigPda;
  pool: typeof findPoolPda;
  position: typeof findPositionPda;
  tokenVault: typeof findTokenVaultPda;
  rewardVault: typeof findRewardVaultPda;
  customizablePool: typeof findCustomizablePoolPda;
  tokenBadge: typeof findTokenBadgePda;
  claimFeeOperator: typeof findClaimFeeOperatorPda;
  positionNftAccount: typeof findPositionNftAccountPda;
  eventAuthority: typeof findEventAuthorityPda;
};

export type CpAmmPluginRequirements = ClientWithRpc<
  GetAccountInfoApi & GetMultipleAccountsApi
> &
  ClientWithPayer &
  ClientWithTransactionPlanning &
  ClientWithTransactionSending;

export function cpAmmProgram() {
  return <T extends CpAmmPluginRequirements>(
    client: T,
  ): ExtendedClient<T, { cpAmm: CpAmmPlugin }> => {
    return extendClient(client, {
      cpAmm: <CpAmmPlugin>{
        accounts: {
          claimFeeOperator: addSelfFetchFunctions(
            client,
            getClaimFeeOperatorCodec(),
          ),
          config: addSelfFetchFunctions(client, getConfigCodec()),
          pool: addSelfFetchFunctions(client, getPoolCodec()),
          position: addSelfFetchFunctions(client, getPositionCodec()),
          tokenBadge: addSelfFetchFunctions(client, getTokenBadgeCodec()),
          vesting: addSelfFetchFunctions(client, getVestingCodec()),
        },
        instructions: {
          addLiquidity: (input) =>
            addSelfPlanAndSendFunctions(
              client,
              getAddLiquidityInstructionAsync(input),
            ),
          claimPartnerFee: (input) =>
            addSelfPlanAndSendFunctions(
              client,
              getClaimPartnerFeeInstructionAsync(input),
            ),
          claimPositionFee: (input) =>
            addSelfPlanAndSendFunctions(
              client,
              getClaimPositionFeeInstructionAsync(input),
            ),
          claimProtocolFee: (input) =>
            addSelfPlanAndSendFunctions(
              client,
              getClaimProtocolFeeInstructionAsync(input),
            ),
          claimReward: (input) =>
            addSelfPlanAndSendFunctions(
              client,
              getClaimRewardInstructionAsync(input),
            ),
          closeClaimFeeOperator: (input) =>
            addSelfPlanAndSendFunctions(
              client,
              getCloseClaimFeeOperatorInstructionAsync(input),
            ),
          closeConfig: (input) =>
            addSelfPlanAndSendFunctions(
              client,
              getCloseConfigInstructionAsync(input),
            ),
          closePosition: (input) =>
            addSelfPlanAndSendFunctions(
              client,
              getClosePositionInstructionAsync(input),
            ),
          closeTokenBadge: (input) =>
            addSelfPlanAndSendFunctions(
              client,
              getCloseTokenBadgeInstructionAsync(input),
            ),
          createClaimFeeOperator: (input) =>
            addSelfPlanAndSendFunctions(
              client,
              getCreateClaimFeeOperatorInstructionAsync(input),
            ),
          createConfig: (input) =>
            addSelfPlanAndSendFunctions(
              client,
              getCreateConfigInstructionAsync(input),
            ),
          createDynamicConfig: (input) =>
            addSelfPlanAndSendFunctions(
              client,
              getCreateDynamicConfigInstructionAsync(input),
            ),
          createPosition: (input) =>
            addSelfPlanAndSendFunctions(
              client,
              getCreatePositionInstructionAsync({
                ...input,
                payer: input.payer ?? client.payer,
              }),
            ),
          createTokenBadge: (input) =>
            addSelfPlanAndSendFunctions(
              client,
              getCreateTokenBadgeInstructionAsync(input),
            ),
          fundReward: (input) =>
            addSelfPlanAndSendFunctions(
              client,
              getFundRewardInstructionAsync(input),
            ),
          initializeCustomizablePool: (input) =>
            addSelfPlanAndSendFunctions(
              client,
              getInitializeCustomizablePoolInstructionAsync({
                ...input,
                payer: input.payer ?? client.payer,
              }),
            ),
          initializePool: (input) =>
            addSelfPlanAndSendFunctions(
              client,
              getInitializePoolInstructionAsync({
                ...input,
                payer: input.payer ?? client.payer,
              }),
            ),
          initializePoolWithDynamicConfig: (input) =>
            addSelfPlanAndSendFunctions(
              client,
              getInitializePoolWithDynamicConfigInstructionAsync({
                ...input,
                payer: input.payer ?? client.payer,
              }),
            ),
          initializeReward: (input) =>
            addSelfPlanAndSendFunctions(
              client,
              getInitializeRewardInstructionAsync({
                ...input,
                payer: input.payer ?? client.payer,
              }),
            ),
          lockPosition: (input) =>
            addSelfPlanAndSendFunctions(
              client,
              getLockPositionInstructionAsync({
                ...input,
                payer: input.payer ?? client.payer,
              }),
            ),
          permanentLockPosition: (input) =>
            addSelfPlanAndSendFunctions(
              client,
              getPermanentLockPositionInstructionAsync(input),
            ),
          refreshVesting: (input) =>
            addSelfPlanAndSendFunctions(
              client,
              getRefreshVestingInstruction(input),
            ),
          removeAllLiquidity: (input) =>
            addSelfPlanAndSendFunctions(
              client,
              getRemoveAllLiquidityInstructionAsync(input),
            ),
          removeLiquidity: (input) =>
            addSelfPlanAndSendFunctions(
              client,
              getRemoveLiquidityInstructionAsync(input),
            ),
          setPoolStatus: (input) =>
            addSelfPlanAndSendFunctions(
              client,
              getSetPoolStatusInstructionAsync(input),
            ),
          splitPosition: (input) =>
            addSelfPlanAndSendFunctions(
              client,
              getSplitPositionInstructionAsync(input),
            ),
          splitPosition2: (input) =>
            addSelfPlanAndSendFunctions(
              client,
              getSplitPosition2InstructionAsync(input),
            ),
          swap: (input) =>
            addSelfPlanAndSendFunctions(
              client,
              getSwapInstructionAsync({
                ...input,
                payer: input.payer ?? client.payer,
              }),
            ),
          swap2: (input) =>
            addSelfPlanAndSendFunctions(
              client,
              getSwap2InstructionAsync({
                ...input,
                payer: input.payer ?? client.payer,
              }),
            ),
          updateRewardDuration: (input) =>
            addSelfPlanAndSendFunctions(
              client,
              getUpdateRewardDurationInstructionAsync(input),
            ),
          updateRewardFunder: (input) =>
            addSelfPlanAndSendFunctions(
              client,
              getUpdateRewardFunderInstructionAsync(input),
            ),
          withdrawIneligibleReward: (input) =>
            addSelfPlanAndSendFunctions(
              client,
              getWithdrawIneligibleRewardInstructionAsync(input),
            ),
        },
        pdas: {
          poolAuthority: findPoolAuthorityPda,
          config: findConfigPda,
          pool: findPoolPda,
          position: findPositionPda,
          tokenVault: findTokenVaultPda,
          rewardVault: findRewardVaultPda,
          customizablePool: findCustomizablePoolPda,
          tokenBadge: findTokenBadgePda,
          claimFeeOperator: findClaimFeeOperatorPda,
          positionNftAccount: findPositionNftAccountPda,
          eventAuthority: findEventAuthorityPda,
        },
        identifyAccount: identifyCpAmmAccount,
        identifyInstruction: identifyCpAmmInstruction,
        parseInstruction: parseCpAmmInstruction,
      },
    });
  };
}

type MakeOptional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;