(* Generated by coq-of-rust *)
Require Import CoqOfRust.CoqOfRust.

Module error.
  (*
  Enum TokenError
  {
    ty_params := [];
    variants :=
      [
        {
          name := "NotRentExempt";
          item := StructTuple [];
          discriminant := None;
        };
        {
          name := "InsufficientFunds";
          item := StructTuple [];
          discriminant := None;
        };
        {
          name := "InvalidMint";
          item := StructTuple [];
          discriminant := None;
        };
        {
          name := "MintMismatch";
          item := StructTuple [];
          discriminant := None;
        };
        {
          name := "OwnerMismatch";
          item := StructTuple [];
          discriminant := None;
        };
        {
          name := "FixedSupply";
          item := StructTuple [];
          discriminant := None;
        };
        {
          name := "AlreadyInUse";
          item := StructTuple [];
          discriminant := None;
        };
        {
          name := "InvalidNumberOfProvidedSigners";
          item := StructTuple [];
          discriminant := None;
        };
        {
          name := "InvalidNumberOfRequiredSigners";
          item := StructTuple [];
          discriminant := None;
        };
        {
          name := "UninitializedState";
          item := StructTuple [];
          discriminant := None;
        };
        {
          name := "NativeNotSupported";
          item := StructTuple [];
          discriminant := None;
        };
        {
          name := "NonNativeHasBalance";
          item := StructTuple [];
          discriminant := None;
        };
        {
          name := "InvalidInstruction";
          item := StructTuple [];
          discriminant := None;
        };
        {
          name := "InvalidState";
          item := StructTuple [];
          discriminant := None;
        };
        {
          name := "Overflow";
          item := StructTuple [];
          discriminant := None;
        };
        {
          name := "AuthorityTypeNotSupported";
          item := StructTuple [];
          discriminant := None;
        };
        {
          name := "MintCannotFreeze";
          item := StructTuple [];
          discriminant := None;
        };
        {
          name := "AccountFrozen";
          item := StructTuple [];
          discriminant := None;
        };
        {
          name := "MintDecimalsMismatch";
          item := StructTuple [];
          discriminant := None;
        };
        {
          name := "NonNativeNotSupported";
          item := StructTuple [];
          discriminant := None;
        };
        {
          name := "ExtensionTypeMismatch";
          item := StructTuple [];
          discriminant := None;
        };
        {
          name := "ExtensionBaseMismatch";
          item := StructTuple [];
          discriminant := None;
        };
        {
          name := "ExtensionAlreadyInitialized";
          item := StructTuple [];
          discriminant := None;
        };
        {
          name := "ConfidentialTransferAccountHasBalance";
          item := StructTuple [];
          discriminant := None;
        };
        {
          name := "ConfidentialTransferAccountNotApproved";
          item := StructTuple [];
          discriminant := None;
        };
        {
          name := "ConfidentialTransferDepositsAndTransfersDisabled";
          item := StructTuple [];
          discriminant := None;
        };
        {
          name := "ConfidentialTransferElGamalPubkeyMismatch";
          item := StructTuple [];
          discriminant := None;
        };
        {
          name := "ConfidentialTransferBalanceMismatch";
          item := StructTuple [];
          discriminant := None;
        };
        {
          name := "MintHasSupply";
          item := StructTuple [];
          discriminant := None;
        };
        {
          name := "NoAuthorityExists";
          item := StructTuple [];
          discriminant := None;
        };
        {
          name := "TransferFeeExceedsMaximum";
          item := StructTuple [];
          discriminant := None;
        };
        {
          name := "MintRequiredForTransfer";
          item := StructTuple [];
          discriminant := None;
        };
        {
          name := "FeeMismatch";
          item := StructTuple [];
          discriminant := None;
        };
        {
          name := "FeeParametersMismatch";
          item := StructTuple [];
          discriminant := None;
        };
        {
          name := "ImmutableOwner";
          item := StructTuple [];
          discriminant := None;
        };
        {
          name := "AccountHasWithheldTransferFees";
          item := StructTuple [];
          discriminant := None;
        };
        {
          name := "NoMemo";
          item := StructTuple [];
          discriminant := None;
        };
        {
          name := "NonTransferable";
          item := StructTuple [];
          discriminant := None;
        };
        {
          name := "NonTransferableNeedsImmutableOwnership";
          item := StructTuple [];
          discriminant := None;
        };
        {
          name := "MaximumPendingBalanceCreditCounterExceeded";
          item := StructTuple [];
          discriminant := None;
        };
        {
          name := "MaximumDepositAmountExceeded";
          item := StructTuple [];
          discriminant := None;
        };
        {
          name := "CpiGuardSettingsLocked";
          item := StructTuple [];
          discriminant := None;
        };
        {
          name := "CpiGuardTransferBlocked";
          item := StructTuple [];
          discriminant := None;
        };
        {
          name := "CpiGuardBurnBlocked";
          item := StructTuple [];
          discriminant := None;
        };
        {
          name := "CpiGuardCloseAccountBlocked";
          item := StructTuple [];
          discriminant := None;
        };
        {
          name := "CpiGuardApproveBlocked";
          item := StructTuple [];
          discriminant := None;
        };
        {
          name := "CpiGuardSetAuthorityBlocked";
          item := StructTuple [];
          discriminant := None;
        };
        {
          name := "CpiGuardOwnerChangeBlocked";
          item := StructTuple [];
          discriminant := None;
        };
        {
          name := "ExtensionNotFound";
          item := StructTuple [];
          discriminant := None;
        };
        {
          name := "NonConfidentialTransfersDisabled";
          item := StructTuple [];
          discriminant := None;
        };
        {
          name := "ConfidentialTransferFeeAccountHasWithheldFee";
          item := StructTuple [];
          discriminant := None;
        };
        {
          name := "InvalidExtensionCombination";
          item := StructTuple [];
          discriminant := None;
        };
        {
          name := "InvalidLengthForAlloc";
          item := StructTuple [];
          discriminant := None;
        };
        {
          name := "AccountDecryption";
          item := StructTuple [];
          discriminant := None;
        };
        {
          name := "ProofGeneration";
          item := StructTuple [];
          discriminant := None;
        };
        {
          name := "InvalidProofInstructionOffset";
          item := StructTuple [];
          discriminant := None;
        };
        {
          name := "HarvestToMintDisabled";
          item := StructTuple [];
          discriminant := None;
        };
        {
          name := "SplitProofContextStateAccountsNotSupported";
          item := StructTuple [];
          discriminant := None;
        };
        {
          name := "NotEnoughProofContextStateAccounts";
          item := StructTuple [];
          discriminant := None;
        };
        {
          name := "MalformedCiphertext";
          item := StructTuple [];
          discriminant := None;
        };
        {
          name := "CiphertextArithmeticFailed";
          item := StructTuple [];
          discriminant := None;
        }
      ];
  }
  *)
  
  Module Impl_core_clone_Clone_for_spl_token_2022_error_TokenError.
    Definition Self : Ty.t := Ty.path "spl_token_2022::error::TokenError".
    
    (* Clone *)
    Definition clone (τ : list Ty.t) (α : list Value.t) : M :=
      match τ, α with
      | [], [ self ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          M.read (|
            M.match_operator (|
              self,
              [
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      Value.StructTuple "spl_token_2022::error::TokenError::NotRentExempt" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      Value.StructTuple "spl_token_2022::error::TokenError::InsufficientFunds" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      Value.StructTuple "spl_token_2022::error::TokenError::InvalidMint" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      Value.StructTuple "spl_token_2022::error::TokenError::MintMismatch" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      Value.StructTuple "spl_token_2022::error::TokenError::OwnerMismatch" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      Value.StructTuple "spl_token_2022::error::TokenError::FixedSupply" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      Value.StructTuple "spl_token_2022::error::TokenError::AlreadyInUse" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      Value.StructTuple
                        "spl_token_2022::error::TokenError::InvalidNumberOfProvidedSigners"
                        []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      Value.StructTuple
                        "spl_token_2022::error::TokenError::InvalidNumberOfRequiredSigners"
                        []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      Value.StructTuple "spl_token_2022::error::TokenError::UninitializedState" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      Value.StructTuple "spl_token_2022::error::TokenError::NativeNotSupported" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      Value.StructTuple "spl_token_2022::error::TokenError::NonNativeHasBalance" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      Value.StructTuple "spl_token_2022::error::TokenError::InvalidInstruction" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      Value.StructTuple "spl_token_2022::error::TokenError::InvalidState" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      Value.StructTuple "spl_token_2022::error::TokenError::Overflow" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      Value.StructTuple
                        "spl_token_2022::error::TokenError::AuthorityTypeNotSupported"
                        []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      Value.StructTuple "spl_token_2022::error::TokenError::MintCannotFreeze" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      Value.StructTuple "spl_token_2022::error::TokenError::AccountFrozen" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      Value.StructTuple "spl_token_2022::error::TokenError::MintDecimalsMismatch" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      Value.StructTuple
                        "spl_token_2022::error::TokenError::NonNativeNotSupported"
                        []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      Value.StructTuple
                        "spl_token_2022::error::TokenError::ExtensionTypeMismatch"
                        []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      Value.StructTuple
                        "spl_token_2022::error::TokenError::ExtensionBaseMismatch"
                        []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      Value.StructTuple
                        "spl_token_2022::error::TokenError::ExtensionAlreadyInitialized"
                        []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      Value.StructTuple
                        "spl_token_2022::error::TokenError::ConfidentialTransferAccountHasBalance"
                        []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      Value.StructTuple
                        "spl_token_2022::error::TokenError::ConfidentialTransferAccountNotApproved"
                        []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      Value.StructTuple
                        "spl_token_2022::error::TokenError::ConfidentialTransferDepositsAndTransfersDisabled"
                        []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      Value.StructTuple
                        "spl_token_2022::error::TokenError::ConfidentialTransferElGamalPubkeyMismatch"
                        []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      Value.StructTuple
                        "spl_token_2022::error::TokenError::ConfidentialTransferBalanceMismatch"
                        []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      Value.StructTuple "spl_token_2022::error::TokenError::MintHasSupply" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      Value.StructTuple "spl_token_2022::error::TokenError::NoAuthorityExists" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      Value.StructTuple
                        "spl_token_2022::error::TokenError::TransferFeeExceedsMaximum"
                        []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      Value.StructTuple
                        "spl_token_2022::error::TokenError::MintRequiredForTransfer"
                        []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      Value.StructTuple "spl_token_2022::error::TokenError::FeeMismatch" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      Value.StructTuple
                        "spl_token_2022::error::TokenError::FeeParametersMismatch"
                        []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      Value.StructTuple "spl_token_2022::error::TokenError::ImmutableOwner" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      Value.StructTuple
                        "spl_token_2022::error::TokenError::AccountHasWithheldTransferFees"
                        []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      Value.StructTuple "spl_token_2022::error::TokenError::NoMemo" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      Value.StructTuple "spl_token_2022::error::TokenError::NonTransferable" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      Value.StructTuple
                        "spl_token_2022::error::TokenError::NonTransferableNeedsImmutableOwnership"
                        []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      Value.StructTuple
                        "spl_token_2022::error::TokenError::MaximumPendingBalanceCreditCounterExceeded"
                        []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      Value.StructTuple
                        "spl_token_2022::error::TokenError::MaximumDepositAmountExceeded"
                        []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      Value.StructTuple
                        "spl_token_2022::error::TokenError::CpiGuardSettingsLocked"
                        []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      Value.StructTuple
                        "spl_token_2022::error::TokenError::CpiGuardTransferBlocked"
                        []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      Value.StructTuple "spl_token_2022::error::TokenError::CpiGuardBurnBlocked" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      Value.StructTuple
                        "spl_token_2022::error::TokenError::CpiGuardCloseAccountBlocked"
                        []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      Value.StructTuple
                        "spl_token_2022::error::TokenError::CpiGuardApproveBlocked"
                        []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      Value.StructTuple
                        "spl_token_2022::error::TokenError::CpiGuardSetAuthorityBlocked"
                        []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      Value.StructTuple
                        "spl_token_2022::error::TokenError::CpiGuardOwnerChangeBlocked"
                        []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      Value.StructTuple "spl_token_2022::error::TokenError::ExtensionNotFound" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      Value.StructTuple
                        "spl_token_2022::error::TokenError::NonConfidentialTransfersDisabled"
                        []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      Value.StructTuple
                        "spl_token_2022::error::TokenError::ConfidentialTransferFeeAccountHasWithheldFee"
                        []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      Value.StructTuple
                        "spl_token_2022::error::TokenError::InvalidExtensionCombination"
                        []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      Value.StructTuple
                        "spl_token_2022::error::TokenError::InvalidLengthForAlloc"
                        []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      Value.StructTuple "spl_token_2022::error::TokenError::AccountDecryption" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      Value.StructTuple "spl_token_2022::error::TokenError::ProofGeneration" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      Value.StructTuple
                        "spl_token_2022::error::TokenError::InvalidProofInstructionOffset"
                        []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      Value.StructTuple
                        "spl_token_2022::error::TokenError::HarvestToMintDisabled"
                        []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      Value.StructTuple
                        "spl_token_2022::error::TokenError::SplitProofContextStateAccountsNotSupported"
                        []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      Value.StructTuple
                        "spl_token_2022::error::TokenError::NotEnoughProofContextStateAccounts"
                        []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      Value.StructTuple "spl_token_2022::error::TokenError::MalformedCiphertext" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      Value.StructTuple
                        "spl_token_2022::error::TokenError::CiphertextArithmeticFailed"
                        []
                    |)))
              ]
            |)
          |)))
      | _, _ => M.impossible
      end.
    
    Axiom Implements :
      M.IsTraitInstance
        "core::clone::Clone"
        Self
        (* Trait polymorphic types *) []
        (* Instance *) [ ("clone", InstanceField.Method clone) ].
  End Impl_core_clone_Clone_for_spl_token_2022_error_TokenError.
  
  Module Impl_core_fmt_Debug_for_spl_token_2022_error_TokenError.
    Definition Self : Ty.t := Ty.path "spl_token_2022::error::TokenError".
    
    (* Debug *)
    Definition fmt (τ : list Ty.t) (α : list Value.t) : M :=
      match τ, α with
      | [], [ self; f ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let f := M.alloc (| f |) in
          M.call_closure (|
            M.get_associated_function (| Ty.path "core::fmt::Formatter", "write_str", [] |),
            [
              M.read (| f |);
              M.read (|
                M.match_operator (|
                  self,
                  [
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        M.alloc (| M.read (| Value.String "NotRentExempt" |) |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        M.alloc (| M.read (| Value.String "InsufficientFunds" |) |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        M.alloc (| M.read (| Value.String "InvalidMint" |) |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        M.alloc (| M.read (| Value.String "MintMismatch" |) |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        M.alloc (| M.read (| Value.String "OwnerMismatch" |) |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        M.alloc (| M.read (| Value.String "FixedSupply" |) |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        M.alloc (| M.read (| Value.String "AlreadyInUse" |) |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        M.alloc (| M.read (| Value.String "InvalidNumberOfProvidedSigners" |) |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        M.alloc (| M.read (| Value.String "InvalidNumberOfRequiredSigners" |) |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        M.alloc (| M.read (| Value.String "UninitializedState" |) |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        M.alloc (| M.read (| Value.String "NativeNotSupported" |) |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        M.alloc (| M.read (| Value.String "NonNativeHasBalance" |) |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        M.alloc (| M.read (| Value.String "InvalidInstruction" |) |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        M.alloc (| M.read (| Value.String "InvalidState" |) |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        M.alloc (| M.read (| Value.String "Overflow" |) |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        M.alloc (| M.read (| Value.String "AuthorityTypeNotSupported" |) |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        M.alloc (| M.read (| Value.String "MintCannotFreeze" |) |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        M.alloc (| M.read (| Value.String "AccountFrozen" |) |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        M.alloc (| M.read (| Value.String "MintDecimalsMismatch" |) |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        M.alloc (| M.read (| Value.String "NonNativeNotSupported" |) |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        M.alloc (| M.read (| Value.String "ExtensionTypeMismatch" |) |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        M.alloc (| M.read (| Value.String "ExtensionBaseMismatch" |) |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        M.alloc (| M.read (| Value.String "ExtensionAlreadyInitialized" |) |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        M.alloc (|
                          M.read (| Value.String "ConfidentialTransferAccountHasBalance" |)
                        |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        M.alloc (|
                          M.read (| Value.String "ConfidentialTransferAccountNotApproved" |)
                        |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        M.alloc (|
                          M.read (|
                            Value.String "ConfidentialTransferDepositsAndTransfersDisabled"
                          |)
                        |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        M.alloc (|
                          M.read (| Value.String "ConfidentialTransferElGamalPubkeyMismatch" |)
                        |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        M.alloc (|
                          M.read (| Value.String "ConfidentialTransferBalanceMismatch" |)
                        |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        M.alloc (| M.read (| Value.String "MintHasSupply" |) |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        M.alloc (| M.read (| Value.String "NoAuthorityExists" |) |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        M.alloc (| M.read (| Value.String "TransferFeeExceedsMaximum" |) |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        M.alloc (| M.read (| Value.String "MintRequiredForTransfer" |) |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        M.alloc (| M.read (| Value.String "FeeMismatch" |) |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        M.alloc (| M.read (| Value.String "FeeParametersMismatch" |) |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        M.alloc (| M.read (| Value.String "ImmutableOwner" |) |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        M.alloc (| M.read (| Value.String "AccountHasWithheldTransferFees" |) |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        M.alloc (| M.read (| Value.String "NoMemo" |) |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        M.alloc (| M.read (| Value.String "NonTransferable" |) |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        M.alloc (|
                          M.read (| Value.String "NonTransferableNeedsImmutableOwnership" |)
                        |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        M.alloc (|
                          M.read (| Value.String "MaximumPendingBalanceCreditCounterExceeded" |)
                        |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        M.alloc (| M.read (| Value.String "MaximumDepositAmountExceeded" |) |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        M.alloc (| M.read (| Value.String "CpiGuardSettingsLocked" |) |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        M.alloc (| M.read (| Value.String "CpiGuardTransferBlocked" |) |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        M.alloc (| M.read (| Value.String "CpiGuardBurnBlocked" |) |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        M.alloc (| M.read (| Value.String "CpiGuardCloseAccountBlocked" |) |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        M.alloc (| M.read (| Value.String "CpiGuardApproveBlocked" |) |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        M.alloc (| M.read (| Value.String "CpiGuardSetAuthorityBlocked" |) |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        M.alloc (| M.read (| Value.String "CpiGuardOwnerChangeBlocked" |) |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        M.alloc (| M.read (| Value.String "ExtensionNotFound" |) |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        M.alloc (|
                          M.read (| Value.String "NonConfidentialTransfersDisabled" |)
                        |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        M.alloc (|
                          M.read (| Value.String "ConfidentialTransferFeeAccountHasWithheldFee" |)
                        |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        M.alloc (| M.read (| Value.String "InvalidExtensionCombination" |) |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        M.alloc (| M.read (| Value.String "InvalidLengthForAlloc" |) |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        M.alloc (| M.read (| Value.String "AccountDecryption" |) |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        M.alloc (| M.read (| Value.String "ProofGeneration" |) |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        M.alloc (| M.read (| Value.String "InvalidProofInstructionOffset" |) |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        M.alloc (| M.read (| Value.String "HarvestToMintDisabled" |) |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        M.alloc (|
                          M.read (| Value.String "SplitProofContextStateAccountsNotSupported" |)
                        |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        M.alloc (|
                          M.read (| Value.String "NotEnoughProofContextStateAccounts" |)
                        |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        M.alloc (| M.read (| Value.String "MalformedCiphertext" |) |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        M.alloc (| M.read (| Value.String "CiphertextArithmeticFailed" |) |)))
                  ]
                |)
              |)
            ]
          |)))
      | _, _ => M.impossible
      end.
    
    Axiom Implements :
      M.IsTraitInstance
        "core::fmt::Debug"
        Self
        (* Trait polymorphic types *) []
        (* Instance *) [ ("fmt", InstanceField.Method fmt) ].
  End Impl_core_fmt_Debug_for_spl_token_2022_error_TokenError.
  
  Module Impl_core_marker_StructuralEq_for_spl_token_2022_error_TokenError.
    Definition Self : Ty.t := Ty.path "spl_token_2022::error::TokenError".
    
    Axiom Implements :
      M.IsTraitInstance
        "core::marker::StructuralEq"
        Self
        (* Trait polymorphic types *) []
        (* Instance *) [].
  End Impl_core_marker_StructuralEq_for_spl_token_2022_error_TokenError.
  
  Module Impl_core_cmp_Eq_for_spl_token_2022_error_TokenError.
    Definition Self : Ty.t := Ty.path "spl_token_2022::error::TokenError".
    
    (* Eq *)
    Definition assert_receiver_is_total_eq (τ : list Ty.t) (α : list Value.t) : M :=
      match τ, α with
      | [], [ self ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          Value.Tuple []))
      | _, _ => M.impossible
      end.
    
    Axiom Implements :
      M.IsTraitInstance
        "core::cmp::Eq"
        Self
        (* Trait polymorphic types *) []
        (* Instance *)
        [ ("assert_receiver_is_total_eq", InstanceField.Method assert_receiver_is_total_eq) ].
  End Impl_core_cmp_Eq_for_spl_token_2022_error_TokenError.
  
  Module Impl_core_error_Error_for_spl_token_2022_error_TokenError.
    Definition Self : Ty.t := Ty.path "spl_token_2022::error::TokenError".
    
    Axiom Implements :
      M.IsTraitInstance
        "core::error::Error"
        Self
        (* Trait polymorphic types *) []
        (* Instance *) [].
  End Impl_core_error_Error_for_spl_token_2022_error_TokenError.
  
  Module Impl_core_fmt_Display_for_spl_token_2022_error_TokenError.
    Definition Self : Ty.t := Ty.path "spl_token_2022::error::TokenError".
    
    (* Error *)
    Definition fmt (τ : list Ty.t) (α : list Value.t) : M :=
      match τ, α with
      | [], [ self; __formatter ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let __formatter := M.alloc (| __formatter |) in
          M.read (|
            M.match_operator (|
              self,
              [
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "write_str",
                          []
                        |),
                        [
                          M.read (| __formatter |);
                          M.read (| Value.String "Lamport balance below rent-exempt threshold" |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "write_str",
                          []
                        |),
                        [ M.read (| __formatter |); M.read (| Value.String "Insufficient funds" |) ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "write_str",
                          []
                        |),
                        [ M.read (| __formatter |); M.read (| Value.String "Invalid Mint" |) ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "write_str",
                          []
                        |),
                        [
                          M.read (| __formatter |);
                          M.read (| Value.String "Account not associated with this Mint" |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "write_str",
                          []
                        |),
                        [ M.read (| __formatter |); M.read (| Value.String "Owner does not match" |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "write_str",
                          []
                        |),
                        [ M.read (| __formatter |); M.read (| Value.String "Fixed supply" |) ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "write_str",
                          []
                        |),
                        [ M.read (| __formatter |); M.read (| Value.String "Already in use" |) ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "write_str",
                          []
                        |),
                        [
                          M.read (| __formatter |);
                          M.read (| Value.String "Invalid number of provided signers" |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "write_str",
                          []
                        |),
                        [
                          M.read (| __formatter |);
                          M.read (| Value.String "Invalid number of required signers" |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "write_str",
                          []
                        |),
                        [
                          M.read (| __formatter |);
                          M.read (| Value.String "State is uninitialized" |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "write_str",
                          []
                        |),
                        [
                          M.read (| __formatter |);
                          M.read (| Value.String "Instruction does not support native tokens" |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "write_str",
                          []
                        |),
                        [
                          M.read (| __formatter |);
                          M.read (|
                            Value.String
                              "Non-native account can only be closed if its balance is zero"
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "write_str",
                          []
                        |),
                        [ M.read (| __formatter |); M.read (| Value.String "Invalid instruction" |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "write_str",
                          []
                        |),
                        [
                          M.read (| __formatter |);
                          M.read (| Value.String "State is invalid for requested operation" |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "write_str",
                          []
                        |),
                        [ M.read (| __formatter |); M.read (| Value.String "Operation overflowed" |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "write_str",
                          []
                        |),
                        [
                          M.read (| __formatter |);
                          M.read (|
                            Value.String "Account does not support specified authority type"
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "write_str",
                          []
                        |),
                        [
                          M.read (| __formatter |);
                          M.read (| Value.String "This token mint cannot freeze accounts" |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "write_str",
                          []
                        |),
                        [ M.read (| __formatter |); M.read (| Value.String "Account is frozen" |) ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "write_str",
                          []
                        |),
                        [
                          M.read (| __formatter |);
                          M.read (|
                            Value.String
                              "The provided decimals value different from the Mint decimals"
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "write_str",
                          []
                        |),
                        [
                          M.read (| __formatter |);
                          M.read (| Value.String "Instruction does not support non-native tokens" |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "write_str",
                          []
                        |),
                        [
                          M.read (| __formatter |);
                          M.read (|
                            Value.String "Extension type does not match already existing extensions"
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "write_str",
                          []
                        |),
                        [
                          M.read (| __formatter |);
                          M.read (|
                            Value.String "Extension does not match the base type provided"
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "write_str",
                          []
                        |),
                        [
                          M.read (| __formatter |);
                          M.read (| Value.String "Extension already initialized on this account" |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "write_str",
                          []
                        |),
                        [
                          M.read (| __formatter |);
                          M.read (|
                            Value.String
                              "An account can only be closed if its confidential balance is zero"
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "write_str",
                          []
                        |),
                        [
                          M.read (| __formatter |);
                          M.read (|
                            Value.String "Account not approved for confidential transfers"
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "write_str",
                          []
                        |),
                        [
                          M.read (| __formatter |);
                          M.read (| Value.String "Account not accepting deposits or transfers" |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "write_str",
                          []
                        |),
                        [
                          M.read (| __formatter |);
                          M.read (| Value.String "ElGamal public key mismatch" |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "write_str",
                          []
                        |),
                        [ M.read (| __formatter |); M.read (| Value.String "Balance mismatch" |) ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "write_str",
                          []
                        |),
                        [
                          M.read (| __formatter |);
                          M.read (|
                            Value.String
                              "Mint has non-zero supply. Burn all tokens before closing the mint"
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "write_str",
                          []
                        |),
                        [
                          M.read (| __formatter |);
                          M.read (|
                            Value.String "No authority exists to perform the desired operation"
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "write_str",
                          []
                        |),
                        [
                          M.read (| __formatter |);
                          M.read (|
                            Value.String "Transfer fee exceeds maximum of 10,000 basis points"
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "write_str",
                          []
                        |),
                        [
                          M.read (| __formatter |);
                          M.read (|
                            Value.String
                              "Mint required for this account to transfer tokens, use `transfer_checked` or `transfer_checked_with_fee`"
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "write_str",
                          []
                        |),
                        [
                          M.read (| __formatter |);
                          M.read (| Value.String "Calculated fee does not match expected fee" |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "write_str",
                          []
                        |),
                        [
                          M.read (| __formatter |);
                          M.read (|
                            Value.String
                              "Fee parameters associated with zero-knowledge proofs do not match fee parameters in mint"
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "write_str",
                          []
                        |),
                        [
                          M.read (| __formatter |);
                          M.read (| Value.String "The owner authority cannot be changed" |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "write_str",
                          []
                        |),
                        [
                          M.read (| __formatter |);
                          M.read (|
                            Value.String
                              "An account can only be closed if its withheld fee balance is zero, harvest fees to the mint and try again"
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "write_str",
                          []
                        |),
                        [
                          M.read (| __formatter |);
                          M.read (|
                            Value.String
                              "No memo in previous instruction; required for recipient to receive a transfer"
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "write_str",
                          []
                        |),
                        [
                          M.read (| __formatter |);
                          M.read (| Value.String "Transfer is disabled for this mint" |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "write_str",
                          []
                        |),
                        [
                          M.read (| __formatter |);
                          M.read (|
                            Value.String
                              "Non-transferable tokens can't be minted to an account without immutable ownership"
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "write_str",
                          []
                        |),
                        [
                          M.read (| __formatter |);
                          M.read (|
                            Value.String
                              "The total number of `Deposit` and `Transfer` instructions to an account cannot exceed
            the associated `maximum_pending_balance_credit_counter`"
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "write_str",
                          []
                        |),
                        [
                          M.read (| __formatter |);
                          M.read (| Value.String "Deposit amount exceeds maximum limit" |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "write_str",
                          []
                        |),
                        [
                          M.read (| __formatter |);
                          M.read (| Value.String "CPI Guard cannot be enabled or disabled in CPI" |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "write_str",
                          []
                        |),
                        [
                          M.read (| __formatter |);
                          M.read (|
                            Value.String
                              "CPI Guard is enabled, and a program attempted to transfer user funds via CPI without using a delegate"
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "write_str",
                          []
                        |),
                        [
                          M.read (| __formatter |);
                          M.read (|
                            Value.String
                              "CPI Guard is enabled, and a program attempted to burn user funds via CPI without using a delegate"
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "write_str",
                          []
                        |),
                        [
                          M.read (| __formatter |);
                          M.read (|
                            Value.String
                              "CPI Guard is enabled, and a program attempted to close an account via CPI without returning lamports to owner"
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "write_str",
                          []
                        |),
                        [
                          M.read (| __formatter |);
                          M.read (|
                            Value.String
                              "CPI Guard is enabled, and a program attempted to approve a delegate via CPI"
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "write_str",
                          []
                        |),
                        [
                          M.read (| __formatter |);
                          M.read (|
                            Value.String
                              "CPI Guard is enabled, and a program attempted to add or replace an authority via CPI"
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "write_str",
                          []
                        |),
                        [
                          M.read (| __formatter |);
                          M.read (|
                            Value.String
                              "Account ownership cannot be changed while CPI Guard is enabled"
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "write_str",
                          []
                        |),
                        [
                          M.read (| __formatter |);
                          M.read (| Value.String "Extension not found in account data" |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "write_str",
                          []
                        |),
                        [
                          M.read (| __formatter |);
                          M.read (| Value.String "Non-confidential transfers disabled" |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "write_str",
                          []
                        |),
                        [
                          M.read (| __formatter |);
                          M.read (|
                            Value.String
                              "An account can only be closed if the confidential withheld fee is zero"
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "write_str",
                          []
                        |),
                        [
                          M.read (| __formatter |);
                          M.read (|
                            Value.String
                              "A mint or an account is initialized to an invalid combination of extensions"
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "write_str",
                          []
                        |),
                        [
                          M.read (| __formatter |);
                          M.read (|
                            Value.String
                              "Extension allocation with overwrite must use the same length"
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "write_str",
                          []
                        |),
                        [
                          M.read (| __formatter |);
                          M.read (|
                            Value.String "Failed to decrypt a confidential transfer account"
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "write_str",
                          []
                        |),
                        [
                          M.read (| __formatter |);
                          M.read (| Value.String "Failed to generate proof" |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "write_str",
                          []
                        |),
                        [
                          M.read (| __formatter |);
                          M.read (|
                            Value.String "An invalid proof instruction offset was provided"
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "write_str",
                          []
                        |),
                        [
                          M.read (| __formatter |);
                          M.read (| Value.String "Harvest of withheld tokens to mint is disabled" |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "write_str",
                          []
                        |),
                        [
                          M.read (| __formatter |);
                          M.read (|
                            Value.String
                              "Split proof context state accounts not supported for instruction"
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "write_str",
                          []
                        |),
                        [
                          M.read (| __formatter |);
                          M.read (|
                            Value.String "Not enough proof context state accounts provided"
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "write_str",
                          []
                        |),
                        [
                          M.read (| __formatter |);
                          M.read (| Value.String "Ciphertext is malformed" |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "write_str",
                          []
                        |),
                        [
                          M.read (| __formatter |);
                          M.read (| Value.String "Ciphertext arithmetic failed" |)
                        ]
                      |)
                    |)))
              ]
            |)
          |)))
      | _, _ => M.impossible
      end.
    
    Axiom Implements :
      M.IsTraitInstance
        "core::fmt::Display"
        Self
        (* Trait polymorphic types *) []
        (* Instance *) [ ("fmt", InstanceField.Method fmt) ].
  End Impl_core_fmt_Display_for_spl_token_2022_error_TokenError.
  
  Module underscore.
    Module Impl_num_traits_cast_FromPrimitive_for_spl_token_2022_error_TokenError.
      Definition Self : Ty.t := Ty.path "spl_token_2022::error::TokenError".
      
      (* FromPrimitive *)
      Definition from_i64 (τ : list Ty.t) (α : list Value.t) : M :=
        match τ, α with
        | [], [ n ] =>
          ltac:(M.monadic
            (let n := M.alloc (| n |) in
            M.read (|
              M.match_operator (|
                M.alloc (| Value.Tuple [] |),
                [
                  fun γ =>
                    ltac:(M.monadic
                      (let γ :=
                        M.use
                          (M.alloc (|
                            BinOp.Pure.eq (M.read (| n |)) (M.rust_cast (Value.Integer 0))
                          |)) in
                      let _ := M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                      M.alloc (|
                        Value.StructTuple
                          "core::option::Option::Some"
                          [ Value.StructTuple "spl_token_2022::error::TokenError::NotRentExempt" []
                          ]
                      |)));
                  fun γ =>
                    ltac:(M.monadic
                      (M.match_operator (|
                        M.alloc (| Value.Tuple [] |),
                        [
                          fun γ =>
                            ltac:(M.monadic
                              (let γ :=
                                M.use
                                  (M.alloc (|
                                    BinOp.Pure.eq (M.read (| n |)) (M.rust_cast (Value.Integer 1))
                                  |)) in
                              let _ :=
                                M.is_constant_or_break_match (|
                                  M.read (| γ |),
                                  Value.Bool true
                                |) in
                              M.alloc (|
                                Value.StructTuple
                                  "core::option::Option::Some"
                                  [
                                    Value.StructTuple
                                      "spl_token_2022::error::TokenError::InsufficientFunds"
                                      []
                                  ]
                              |)));
                          fun γ =>
                            ltac:(M.monadic
                              (M.match_operator (|
                                M.alloc (| Value.Tuple [] |),
                                [
                                  fun γ =>
                                    ltac:(M.monadic
                                      (let γ :=
                                        M.use
                                          (M.alloc (|
                                            BinOp.Pure.eq
                                              (M.read (| n |))
                                              (M.rust_cast (Value.Integer 2))
                                          |)) in
                                      let _ :=
                                        M.is_constant_or_break_match (|
                                          M.read (| γ |),
                                          Value.Bool true
                                        |) in
                                      M.alloc (|
                                        Value.StructTuple
                                          "core::option::Option::Some"
                                          [
                                            Value.StructTuple
                                              "spl_token_2022::error::TokenError::InvalidMint"
                                              []
                                          ]
                                      |)));
                                  fun γ =>
                                    ltac:(M.monadic
                                      (M.match_operator (|
                                        M.alloc (| Value.Tuple [] |),
                                        [
                                          fun γ =>
                                            ltac:(M.monadic
                                              (let γ :=
                                                M.use
                                                  (M.alloc (|
                                                    BinOp.Pure.eq
                                                      (M.read (| n |))
                                                      (M.rust_cast (Value.Integer 3))
                                                  |)) in
                                              let _ :=
                                                M.is_constant_or_break_match (|
                                                  M.read (| γ |),
                                                  Value.Bool true
                                                |) in
                                              M.alloc (|
                                                Value.StructTuple
                                                  "core::option::Option::Some"
                                                  [
                                                    Value.StructTuple
                                                      "spl_token_2022::error::TokenError::MintMismatch"
                                                      []
                                                  ]
                                              |)));
                                          fun γ =>
                                            ltac:(M.monadic
                                              (M.match_operator (|
                                                M.alloc (| Value.Tuple [] |),
                                                [
                                                  fun γ =>
                                                    ltac:(M.monadic
                                                      (let γ :=
                                                        M.use
                                                          (M.alloc (|
                                                            BinOp.Pure.eq
                                                              (M.read (| n |))
                                                              (M.rust_cast (Value.Integer 4))
                                                          |)) in
                                                      let _ :=
                                                        M.is_constant_or_break_match (|
                                                          M.read (| γ |),
                                                          Value.Bool true
                                                        |) in
                                                      M.alloc (|
                                                        Value.StructTuple
                                                          "core::option::Option::Some"
                                                          [
                                                            Value.StructTuple
                                                              "spl_token_2022::error::TokenError::OwnerMismatch"
                                                              []
                                                          ]
                                                      |)));
                                                  fun γ =>
                                                    ltac:(M.monadic
                                                      (M.match_operator (|
                                                        M.alloc (| Value.Tuple [] |),
                                                        [
                                                          fun γ =>
                                                            ltac:(M.monadic
                                                              (let γ :=
                                                                M.use
                                                                  (M.alloc (|
                                                                    BinOp.Pure.eq
                                                                      (M.read (| n |))
                                                                      (M.rust_cast
                                                                        (Value.Integer 5))
                                                                  |)) in
                                                              let _ :=
                                                                M.is_constant_or_break_match (|
                                                                  M.read (| γ |),
                                                                  Value.Bool true
                                                                |) in
                                                              M.alloc (|
                                                                Value.StructTuple
                                                                  "core::option::Option::Some"
                                                                  [
                                                                    Value.StructTuple
                                                                      "spl_token_2022::error::TokenError::FixedSupply"
                                                                      []
                                                                  ]
                                                              |)));
                                                          fun γ =>
                                                            ltac:(M.monadic
                                                              (M.match_operator (|
                                                                M.alloc (| Value.Tuple [] |),
                                                                [
                                                                  fun γ =>
                                                                    ltac:(M.monadic
                                                                      (let γ :=
                                                                        M.use
                                                                          (M.alloc (|
                                                                            BinOp.Pure.eq
                                                                              (M.read (| n |))
                                                                              (M.rust_cast
                                                                                (Value.Integer 6))
                                                                          |)) in
                                                                      let _ :=
                                                                        M.is_constant_or_break_match (|
                                                                          M.read (| γ |),
                                                                          Value.Bool true
                                                                        |) in
                                                                      M.alloc (|
                                                                        Value.StructTuple
                                                                          "core::option::Option::Some"
                                                                          [
                                                                            Value.StructTuple
                                                                              "spl_token_2022::error::TokenError::AlreadyInUse"
                                                                              []
                                                                          ]
                                                                      |)));
                                                                  fun γ =>
                                                                    ltac:(M.monadic
                                                                      (M.match_operator (|
                                                                        M.alloc (|
                                                                          Value.Tuple []
                                                                        |),
                                                                        [
                                                                          fun γ =>
                                                                            ltac:(M.monadic
                                                                              (let γ :=
                                                                                M.use
                                                                                  (M.alloc (|
                                                                                    BinOp.Pure.eq
                                                                                      (M.read (|
                                                                                        n
                                                                                      |))
                                                                                      (M.rust_cast
                                                                                        (Value.Integer
                                                                                          7))
                                                                                  |)) in
                                                                              let _ :=
                                                                                M.is_constant_or_break_match (|
                                                                                  M.read (| γ |),
                                                                                  Value.Bool true
                                                                                |) in
                                                                              M.alloc (|
                                                                                Value.StructTuple
                                                                                  "core::option::Option::Some"
                                                                                  [
                                                                                    Value.StructTuple
                                                                                      "spl_token_2022::error::TokenError::InvalidNumberOfProvidedSigners"
                                                                                      []
                                                                                  ]
                                                                              |)));
                                                                          fun γ =>
                                                                            ltac:(M.monadic
                                                                              (M.match_operator (|
                                                                                M.alloc (|
                                                                                  Value.Tuple []
                                                                                |),
                                                                                [
                                                                                  fun γ =>
                                                                                    ltac:(M.monadic
                                                                                      (let γ :=
                                                                                        M.use
                                                                                          (M.alloc (|
                                                                                            BinOp.Pure.eq
                                                                                              (M.read (|
                                                                                                n
                                                                                              |))
                                                                                              (M.rust_cast
                                                                                                (Value.Integer
                                                                                                  8))
                                                                                          |)) in
                                                                                      let _ :=
                                                                                        M.is_constant_or_break_match (|
                                                                                          M.read (|
                                                                                            γ
                                                                                          |),
                                                                                          Value.Bool
                                                                                            true
                                                                                        |) in
                                                                                      M.alloc (|
                                                                                        Value.StructTuple
                                                                                          "core::option::Option::Some"
                                                                                          [
                                                                                            Value.StructTuple
                                                                                              "spl_token_2022::error::TokenError::InvalidNumberOfRequiredSigners"
                                                                                              []
                                                                                          ]
                                                                                      |)));
                                                                                  fun γ =>
                                                                                    ltac:(M.monadic
                                                                                      (M.match_operator (|
                                                                                        M.alloc (|
                                                                                          Value.Tuple
                                                                                            []
                                                                                        |),
                                                                                        [
                                                                                          fun γ =>
                                                                                            ltac:(M.monadic
                                                                                              (let
                                                                                                    γ :=
                                                                                                M.use
                                                                                                  (M.alloc (|
                                                                                                    BinOp.Pure.eq
                                                                                                      (M.read (|
                                                                                                        n
                                                                                                      |))
                                                                                                      (M.rust_cast
                                                                                                        (Value.Integer
                                                                                                          9))
                                                                                                  |)) in
                                                                                              let
                                                                                                    _ :=
                                                                                                M.is_constant_or_break_match (|
                                                                                                  M.read (|
                                                                                                    γ
                                                                                                  |),
                                                                                                  Value.Bool
                                                                                                    true
                                                                                                |) in
                                                                                              M.alloc (|
                                                                                                Value.StructTuple
                                                                                                  "core::option::Option::Some"
                                                                                                  [
                                                                                                    Value.StructTuple
                                                                                                      "spl_token_2022::error::TokenError::UninitializedState"
                                                                                                      []
                                                                                                  ]
                                                                                              |)));
                                                                                          fun γ =>
                                                                                            ltac:(M.monadic
                                                                                              (M.match_operator (|
                                                                                                M.alloc (|
                                                                                                  Value.Tuple
                                                                                                    []
                                                                                                |),
                                                                                                [
                                                                                                  fun
                                                                                                      γ =>
                                                                                                    ltac:(M.monadic
                                                                                                      (let
                                                                                                            γ :=
                                                                                                        M.use
                                                                                                          (M.alloc (|
                                                                                                            BinOp.Pure.eq
                                                                                                              (M.read (|
                                                                                                                n
                                                                                                              |))
                                                                                                              (M.rust_cast
                                                                                                                (Value.Integer
                                                                                                                  10))
                                                                                                          |)) in
                                                                                                      let
                                                                                                            _ :=
                                                                                                        M.is_constant_or_break_match (|
                                                                                                          M.read (|
                                                                                                            γ
                                                                                                          |),
                                                                                                          Value.Bool
                                                                                                            true
                                                                                                        |) in
                                                                                                      M.alloc (|
                                                                                                        Value.StructTuple
                                                                                                          "core::option::Option::Some"
                                                                                                          [
                                                                                                            Value.StructTuple
                                                                                                              "spl_token_2022::error::TokenError::NativeNotSupported"
                                                                                                              []
                                                                                                          ]
                                                                                                      |)));
                                                                                                  fun
                                                                                                      γ =>
                                                                                                    ltac:(M.monadic
                                                                                                      (M.match_operator (|
                                                                                                        M.alloc (|
                                                                                                          Value.Tuple
                                                                                                            []
                                                                                                        |),
                                                                                                        [
                                                                                                          fun
                                                                                                              γ =>
                                                                                                            ltac:(M.monadic
                                                                                                              (let
                                                                                                                    γ :=
                                                                                                                M.use
                                                                                                                  (M.alloc (|
                                                                                                                    BinOp.Pure.eq
                                                                                                                      (M.read (|
                                                                                                                        n
                                                                                                                      |))
                                                                                                                      (M.rust_cast
                                                                                                                        (Value.Integer
                                                                                                                          11))
                                                                                                                  |)) in
                                                                                                              let
                                                                                                                    _ :=
                                                                                                                M.is_constant_or_break_match (|
                                                                                                                  M.read (|
                                                                                                                    γ
                                                                                                                  |),
                                                                                                                  Value.Bool
                                                                                                                    true
                                                                                                                |) in
                                                                                                              M.alloc (|
                                                                                                                Value.StructTuple
                                                                                                                  "core::option::Option::Some"
                                                                                                                  [
                                                                                                                    Value.StructTuple
                                                                                                                      "spl_token_2022::error::TokenError::NonNativeHasBalance"
                                                                                                                      []
                                                                                                                  ]
                                                                                                              |)));
                                                                                                          fun
                                                                                                              γ =>
                                                                                                            ltac:(M.monadic
                                                                                                              (M.match_operator (|
                                                                                                                M.alloc (|
                                                                                                                  Value.Tuple
                                                                                                                    []
                                                                                                                |),
                                                                                                                [
                                                                                                                  fun
                                                                                                                      γ =>
                                                                                                                    ltac:(M.monadic
                                                                                                                      (let
                                                                                                                            γ :=
                                                                                                                        M.use
                                                                                                                          (M.alloc (|
                                                                                                                            BinOp.Pure.eq
                                                                                                                              (M.read (|
                                                                                                                                n
                                                                                                                              |))
                                                                                                                              (M.rust_cast
                                                                                                                                (Value.Integer
                                                                                                                                  12))
                                                                                                                          |)) in
                                                                                                                      let
                                                                                                                            _ :=
                                                                                                                        M.is_constant_or_break_match (|
                                                                                                                          M.read (|
                                                                                                                            γ
                                                                                                                          |),
                                                                                                                          Value.Bool
                                                                                                                            true
                                                                                                                        |) in
                                                                                                                      M.alloc (|
                                                                                                                        Value.StructTuple
                                                                                                                          "core::option::Option::Some"
                                                                                                                          [
                                                                                                                            Value.StructTuple
                                                                                                                              "spl_token_2022::error::TokenError::InvalidInstruction"
                                                                                                                              []
                                                                                                                          ]
                                                                                                                      |)));
                                                                                                                  fun
                                                                                                                      γ =>
                                                                                                                    ltac:(M.monadic
                                                                                                                      (M.match_operator (|
                                                                                                                        M.alloc (|
                                                                                                                          Value.Tuple
                                                                                                                            []
                                                                                                                        |),
                                                                                                                        [
                                                                                                                          fun
                                                                                                                              γ =>
                                                                                                                            ltac:(M.monadic
                                                                                                                              (let
                                                                                                                                    γ :=
                                                                                                                                M.use
                                                                                                                                  (M.alloc (|
                                                                                                                                    BinOp.Pure.eq
                                                                                                                                      (M.read (|
                                                                                                                                        n
                                                                                                                                      |))
                                                                                                                                      (M.rust_cast
                                                                                                                                        (Value.Integer
                                                                                                                                          13))
                                                                                                                                  |)) in
                                                                                                                              let
                                                                                                                                    _ :=
                                                                                                                                M.is_constant_or_break_match (|
                                                                                                                                  M.read (|
                                                                                                                                    γ
                                                                                                                                  |),
                                                                                                                                  Value.Bool
                                                                                                                                    true
                                                                                                                                |) in
                                                                                                                              M.alloc (|
                                                                                                                                Value.StructTuple
                                                                                                                                  "core::option::Option::Some"
                                                                                                                                  [
                                                                                                                                    Value.StructTuple
                                                                                                                                      "spl_token_2022::error::TokenError::InvalidState"
                                                                                                                                      []
                                                                                                                                  ]
                                                                                                                              |)));
                                                                                                                          fun
                                                                                                                              γ =>
                                                                                                                            ltac:(M.monadic
                                                                                                                              (M.match_operator (|
                                                                                                                                M.alloc (|
                                                                                                                                  Value.Tuple
                                                                                                                                    []
                                                                                                                                |),
                                                                                                                                [
                                                                                                                                  fun
                                                                                                                                      γ =>
                                                                                                                                    ltac:(M.monadic
                                                                                                                                      (let
                                                                                                                                            γ :=
                                                                                                                                        M.use
                                                                                                                                          (M.alloc (|
                                                                                                                                            BinOp.Pure.eq
                                                                                                                                              (M.read (|
                                                                                                                                                n
                                                                                                                                              |))
                                                                                                                                              (M.rust_cast
                                                                                                                                                (Value.Integer
                                                                                                                                                  14))
                                                                                                                                          |)) in
                                                                                                                                      let
                                                                                                                                            _ :=
                                                                                                                                        M.is_constant_or_break_match (|
                                                                                                                                          M.read (|
                                                                                                                                            γ
                                                                                                                                          |),
                                                                                                                                          Value.Bool
                                                                                                                                            true
                                                                                                                                        |) in
                                                                                                                                      M.alloc (|
                                                                                                                                        Value.StructTuple
                                                                                                                                          "core::option::Option::Some"
                                                                                                                                          [
                                                                                                                                            Value.StructTuple
                                                                                                                                              "spl_token_2022::error::TokenError::Overflow"
                                                                                                                                              []
                                                                                                                                          ]
                                                                                                                                      |)));
                                                                                                                                  fun
                                                                                                                                      γ =>
                                                                                                                                    ltac:(M.monadic
                                                                                                                                      (M.match_operator (|
                                                                                                                                        M.alloc (|
                                                                                                                                          Value.Tuple
                                                                                                                                            []
                                                                                                                                        |),
                                                                                                                                        [
                                                                                                                                          fun
                                                                                                                                              γ =>
                                                                                                                                            ltac:(M.monadic
                                                                                                                                              (let
                                                                                                                                                    γ :=
                                                                                                                                                M.use
                                                                                                                                                  (M.alloc (|
                                                                                                                                                    BinOp.Pure.eq
                                                                                                                                                      (M.read (|
                                                                                                                                                        n
                                                                                                                                                      |))
                                                                                                                                                      (M.rust_cast
                                                                                                                                                        (Value.Integer
                                                                                                                                                          15))
                                                                                                                                                  |)) in
                                                                                                                                              let
                                                                                                                                                    _ :=
                                                                                                                                                M.is_constant_or_break_match (|
                                                                                                                                                  M.read (|
                                                                                                                                                    γ
                                                                                                                                                  |),
                                                                                                                                                  Value.Bool
                                                                                                                                                    true
                                                                                                                                                |) in
                                                                                                                                              M.alloc (|
                                                                                                                                                Value.StructTuple
                                                                                                                                                  "core::option::Option::Some"
                                                                                                                                                  [
                                                                                                                                                    Value.StructTuple
                                                                                                                                                      "spl_token_2022::error::TokenError::AuthorityTypeNotSupported"
                                                                                                                                                      []
                                                                                                                                                  ]
                                                                                                                                              |)));
                                                                                                                                          fun
                                                                                                                                              γ =>
                                                                                                                                            ltac:(M.monadic
                                                                                                                                              (M.match_operator (|
                                                                                                                                                M.alloc (|
                                                                                                                                                  Value.Tuple
                                                                                                                                                    []
                                                                                                                                                |),
                                                                                                                                                [
                                                                                                                                                  fun
                                                                                                                                                      γ =>
                                                                                                                                                    ltac:(M.monadic
                                                                                                                                                      (let
                                                                                                                                                            γ :=
                                                                                                                                                        M.use
                                                                                                                                                          (M.alloc (|
                                                                                                                                                            BinOp.Pure.eq
                                                                                                                                                              (M.read (|
                                                                                                                                                                n
                                                                                                                                                              |))
                                                                                                                                                              (M.rust_cast
                                                                                                                                                                (Value.Integer
                                                                                                                                                                  16))
                                                                                                                                                          |)) in
                                                                                                                                                      let
                                                                                                                                                            _ :=
                                                                                                                                                        M.is_constant_or_break_match (|
                                                                                                                                                          M.read (|
                                                                                                                                                            γ
                                                                                                                                                          |),
                                                                                                                                                          Value.Bool
                                                                                                                                                            true
                                                                                                                                                        |) in
                                                                                                                                                      M.alloc (|
                                                                                                                                                        Value.StructTuple
                                                                                                                                                          "core::option::Option::Some"
                                                                                                                                                          [
                                                                                                                                                            Value.StructTuple
                                                                                                                                                              "spl_token_2022::error::TokenError::MintCannotFreeze"
                                                                                                                                                              []
                                                                                                                                                          ]
                                                                                                                                                      |)));
                                                                                                                                                  fun
                                                                                                                                                      γ =>
                                                                                                                                                    ltac:(M.monadic
                                                                                                                                                      (M.match_operator (|
                                                                                                                                                        M.alloc (|
                                                                                                                                                          Value.Tuple
                                                                                                                                                            []
                                                                                                                                                        |),
                                                                                                                                                        [
                                                                                                                                                          fun
                                                                                                                                                              γ =>
                                                                                                                                                            ltac:(M.monadic
                                                                                                                                                              (let
                                                                                                                                                                    γ :=
                                                                                                                                                                M.use
                                                                                                                                                                  (M.alloc (|
                                                                                                                                                                    BinOp.Pure.eq
                                                                                                                                                                      (M.read (|
                                                                                                                                                                        n
                                                                                                                                                                      |))
                                                                                                                                                                      (M.rust_cast
                                                                                                                                                                        (Value.Integer
                                                                                                                                                                          17))
                                                                                                                                                                  |)) in
                                                                                                                                                              let
                                                                                                                                                                    _ :=
                                                                                                                                                                M.is_constant_or_break_match (|
                                                                                                                                                                  M.read (|
                                                                                                                                                                    γ
                                                                                                                                                                  |),
                                                                                                                                                                  Value.Bool
                                                                                                                                                                    true
                                                                                                                                                                |) in
                                                                                                                                                              M.alloc (|
                                                                                                                                                                Value.StructTuple
                                                                                                                                                                  "core::option::Option::Some"
                                                                                                                                                                  [
                                                                                                                                                                    Value.StructTuple
                                                                                                                                                                      "spl_token_2022::error::TokenError::AccountFrozen"
                                                                                                                                                                      []
                                                                                                                                                                  ]
                                                                                                                                                              |)));
                                                                                                                                                          fun
                                                                                                                                                              γ =>
                                                                                                                                                            ltac:(M.monadic
                                                                                                                                                              (M.match_operator (|
                                                                                                                                                                M.alloc (|
                                                                                                                                                                  Value.Tuple
                                                                                                                                                                    []
                                                                                                                                                                |),
                                                                                                                                                                [
                                                                                                                                                                  fun
                                                                                                                                                                      γ =>
                                                                                                                                                                    ltac:(M.monadic
                                                                                                                                                                      (let
                                                                                                                                                                            γ :=
                                                                                                                                                                        M.use
                                                                                                                                                                          (M.alloc (|
                                                                                                                                                                            BinOp.Pure.eq
                                                                                                                                                                              (M.read (|
                                                                                                                                                                                n
                                                                                                                                                                              |))
                                                                                                                                                                              (M.rust_cast
                                                                                                                                                                                (Value.Integer
                                                                                                                                                                                  18))
                                                                                                                                                                          |)) in
                                                                                                                                                                      let
                                                                                                                                                                            _ :=
                                                                                                                                                                        M.is_constant_or_break_match (|
                                                                                                                                                                          M.read (|
                                                                                                                                                                            γ
                                                                                                                                                                          |),
                                                                                                                                                                          Value.Bool
                                                                                                                                                                            true
                                                                                                                                                                        |) in
                                                                                                                                                                      M.alloc (|
                                                                                                                                                                        Value.StructTuple
                                                                                                                                                                          "core::option::Option::Some"
                                                                                                                                                                          [
                                                                                                                                                                            Value.StructTuple
                                                                                                                                                                              "spl_token_2022::error::TokenError::MintDecimalsMismatch"
                                                                                                                                                                              []
                                                                                                                                                                          ]
                                                                                                                                                                      |)));
                                                                                                                                                                  fun
                                                                                                                                                                      γ =>
                                                                                                                                                                    ltac:(M.monadic
                                                                                                                                                                      (M.match_operator (|
                                                                                                                                                                        M.alloc (|
                                                                                                                                                                          Value.Tuple
                                                                                                                                                                            []
                                                                                                                                                                        |),
                                                                                                                                                                        [
                                                                                                                                                                          fun
                                                                                                                                                                              γ =>
                                                                                                                                                                            ltac:(M.monadic
                                                                                                                                                                              (let
                                                                                                                                                                                    γ :=
                                                                                                                                                                                M.use
                                                                                                                                                                                  (M.alloc (|
                                                                                                                                                                                    BinOp.Pure.eq
                                                                                                                                                                                      (M.read (|
                                                                                                                                                                                        n
                                                                                                                                                                                      |))
                                                                                                                                                                                      (M.rust_cast
                                                                                                                                                                                        (Value.Integer
                                                                                                                                                                                          19))
                                                                                                                                                                                  |)) in
                                                                                                                                                                              let
                                                                                                                                                                                    _ :=
                                                                                                                                                                                M.is_constant_or_break_match (|
                                                                                                                                                                                  M.read (|
                                                                                                                                                                                    γ
                                                                                                                                                                                  |),
                                                                                                                                                                                  Value.Bool
                                                                                                                                                                                    true
                                                                                                                                                                                |) in
                                                                                                                                                                              M.alloc (|
                                                                                                                                                                                Value.StructTuple
                                                                                                                                                                                  "core::option::Option::Some"
                                                                                                                                                                                  [
                                                                                                                                                                                    Value.StructTuple
                                                                                                                                                                                      "spl_token_2022::error::TokenError::NonNativeNotSupported"
                                                                                                                                                                                      []
                                                                                                                                                                                  ]
                                                                                                                                                                              |)));
                                                                                                                                                                          fun
                                                                                                                                                                              γ =>
                                                                                                                                                                            ltac:(M.monadic
                                                                                                                                                                              (M.match_operator (|
                                                                                                                                                                                M.alloc (|
                                                                                                                                                                                  Value.Tuple
                                                                                                                                                                                    []
                                                                                                                                                                                |),
                                                                                                                                                                                [
                                                                                                                                                                                  fun
                                                                                                                                                                                      γ =>
                                                                                                                                                                                    ltac:(M.monadic
                                                                                                                                                                                      (let
                                                                                                                                                                                            γ :=
                                                                                                                                                                                        M.use
                                                                                                                                                                                          (M.alloc (|
                                                                                                                                                                                            BinOp.Pure.eq
                                                                                                                                                                                              (M.read (|
                                                                                                                                                                                                n
                                                                                                                                                                                              |))
                                                                                                                                                                                              (M.rust_cast
                                                                                                                                                                                                (Value.Integer
                                                                                                                                                                                                  20))
                                                                                                                                                                                          |)) in
                                                                                                                                                                                      let
                                                                                                                                                                                            _ :=
                                                                                                                                                                                        M.is_constant_or_break_match (|
                                                                                                                                                                                          M.read (|
                                                                                                                                                                                            γ
                                                                                                                                                                                          |),
                                                                                                                                                                                          Value.Bool
                                                                                                                                                                                            true
                                                                                                                                                                                        |) in
                                                                                                                                                                                      M.alloc (|
                                                                                                                                                                                        Value.StructTuple
                                                                                                                                                                                          "core::option::Option::Some"
                                                                                                                                                                                          [
                                                                                                                                                                                            Value.StructTuple
                                                                                                                                                                                              "spl_token_2022::error::TokenError::ExtensionTypeMismatch"
                                                                                                                                                                                              []
                                                                                                                                                                                          ]
                                                                                                                                                                                      |)));
                                                                                                                                                                                  fun
                                                                                                                                                                                      γ =>
                                                                                                                                                                                    ltac:(M.monadic
                                                                                                                                                                                      (M.match_operator (|
                                                                                                                                                                                        M.alloc (|
                                                                                                                                                                                          Value.Tuple
                                                                                                                                                                                            []
                                                                                                                                                                                        |),
                                                                                                                                                                                        [
                                                                                                                                                                                          fun
                                                                                                                                                                                              γ =>
                                                                                                                                                                                            ltac:(M.monadic
                                                                                                                                                                                              (let
                                                                                                                                                                                                    γ :=
                                                                                                                                                                                                M.use
                                                                                                                                                                                                  (M.alloc (|
                                                                                                                                                                                                    BinOp.Pure.eq
                                                                                                                                                                                                      (M.read (|
                                                                                                                                                                                                        n
                                                                                                                                                                                                      |))
                                                                                                                                                                                                      (M.rust_cast
                                                                                                                                                                                                        (Value.Integer
                                                                                                                                                                                                          21))
                                                                                                                                                                                                  |)) in
                                                                                                                                                                                              let
                                                                                                                                                                                                    _ :=
                                                                                                                                                                                                M.is_constant_or_break_match (|
                                                                                                                                                                                                  M.read (|
                                                                                                                                                                                                    γ
                                                                                                                                                                                                  |),
                                                                                                                                                                                                  Value.Bool
                                                                                                                                                                                                    true
                                                                                                                                                                                                |) in
                                                                                                                                                                                              M.alloc (|
                                                                                                                                                                                                Value.StructTuple
                                                                                                                                                                                                  "core::option::Option::Some"
                                                                                                                                                                                                  [
                                                                                                                                                                                                    Value.StructTuple
                                                                                                                                                                                                      "spl_token_2022::error::TokenError::ExtensionBaseMismatch"
                                                                                                                                                                                                      []
                                                                                                                                                                                                  ]
                                                                                                                                                                                              |)));
                                                                                                                                                                                          fun
                                                                                                                                                                                              γ =>
                                                                                                                                                                                            ltac:(M.monadic
                                                                                                                                                                                              (M.match_operator (|
                                                                                                                                                                                                M.alloc (|
                                                                                                                                                                                                  Value.Tuple
                                                                                                                                                                                                    []
                                                                                                                                                                                                |),
                                                                                                                                                                                                [
                                                                                                                                                                                                  fun
                                                                                                                                                                                                      γ =>
                                                                                                                                                                                                    ltac:(M.monadic
                                                                                                                                                                                                      (let
                                                                                                                                                                                                            γ :=
                                                                                                                                                                                                        M.use
                                                                                                                                                                                                          (M.alloc (|
                                                                                                                                                                                                            BinOp.Pure.eq
                                                                                                                                                                                                              (M.read (|
                                                                                                                                                                                                                n
                                                                                                                                                                                                              |))
                                                                                                                                                                                                              (M.rust_cast
                                                                                                                                                                                                                (Value.Integer
                                                                                                                                                                                                                  22))
                                                                                                                                                                                                          |)) in
                                                                                                                                                                                                      let
                                                                                                                                                                                                            _ :=
                                                                                                                                                                                                        M.is_constant_or_break_match (|
                                                                                                                                                                                                          M.read (|
                                                                                                                                                                                                            γ
                                                                                                                                                                                                          |),
                                                                                                                                                                                                          Value.Bool
                                                                                                                                                                                                            true
                                                                                                                                                                                                        |) in
                                                                                                                                                                                                      M.alloc (|
                                                                                                                                                                                                        Value.StructTuple
                                                                                                                                                                                                          "core::option::Option::Some"
                                                                                                                                                                                                          [
                                                                                                                                                                                                            Value.StructTuple
                                                                                                                                                                                                              "spl_token_2022::error::TokenError::ExtensionAlreadyInitialized"
                                                                                                                                                                                                              []
                                                                                                                                                                                                          ]
                                                                                                                                                                                                      |)));
                                                                                                                                                                                                  fun
                                                                                                                                                                                                      γ =>
                                                                                                                                                                                                    ltac:(M.monadic
                                                                                                                                                                                                      (M.match_operator (|
                                                                                                                                                                                                        M.alloc (|
                                                                                                                                                                                                          Value.Tuple
                                                                                                                                                                                                            []
                                                                                                                                                                                                        |),
                                                                                                                                                                                                        [
                                                                                                                                                                                                          fun
                                                                                                                                                                                                              γ =>
                                                                                                                                                                                                            ltac:(M.monadic
                                                                                                                                                                                                              (let
                                                                                                                                                                                                                    γ :=
                                                                                                                                                                                                                M.use
                                                                                                                                                                                                                  (M.alloc (|
                                                                                                                                                                                                                    BinOp.Pure.eq
                                                                                                                                                                                                                      (M.read (|
                                                                                                                                                                                                                        n
                                                                                                                                                                                                                      |))
                                                                                                                                                                                                                      (M.rust_cast
                                                                                                                                                                                                                        (Value.Integer
                                                                                                                                                                                                                          23))
                                                                                                                                                                                                                  |)) in
                                                                                                                                                                                                              let
                                                                                                                                                                                                                    _ :=
                                                                                                                                                                                                                M.is_constant_or_break_match (|
                                                                                                                                                                                                                  M.read (|
                                                                                                                                                                                                                    γ
                                                                                                                                                                                                                  |),
                                                                                                                                                                                                                  Value.Bool
                                                                                                                                                                                                                    true
                                                                                                                                                                                                                |) in
                                                                                                                                                                                                              M.alloc (|
                                                                                                                                                                                                                Value.StructTuple
                                                                                                                                                                                                                  "core::option::Option::Some"
                                                                                                                                                                                                                  [
                                                                                                                                                                                                                    Value.StructTuple
                                                                                                                                                                                                                      "spl_token_2022::error::TokenError::ConfidentialTransferAccountHasBalance"
                                                                                                                                                                                                                      []
                                                                                                                                                                                                                  ]
                                                                                                                                                                                                              |)));
                                                                                                                                                                                                          fun
                                                                                                                                                                                                              γ =>
                                                                                                                                                                                                            ltac:(M.monadic
                                                                                                                                                                                                              (M.match_operator (|
                                                                                                                                                                                                                M.alloc (|
                                                                                                                                                                                                                  Value.Tuple
                                                                                                                                                                                                                    []
                                                                                                                                                                                                                |),
                                                                                                                                                                                                                [
                                                                                                                                                                                                                  fun
                                                                                                                                                                                                                      γ =>
                                                                                                                                                                                                                    ltac:(M.monadic
                                                                                                                                                                                                                      (let
                                                                                                                                                                                                                            γ :=
                                                                                                                                                                                                                        M.use
                                                                                                                                                                                                                          (M.alloc (|
                                                                                                                                                                                                                            BinOp.Pure.eq
                                                                                                                                                                                                                              (M.read (|
                                                                                                                                                                                                                                n
                                                                                                                                                                                                                              |))
                                                                                                                                                                                                                              (M.rust_cast
                                                                                                                                                                                                                                (Value.Integer
                                                                                                                                                                                                                                  24))
                                                                                                                                                                                                                          |)) in
                                                                                                                                                                                                                      let
                                                                                                                                                                                                                            _ :=
                                                                                                                                                                                                                        M.is_constant_or_break_match (|
                                                                                                                                                                                                                          M.read (|
                                                                                                                                                                                                                            γ
                                                                                                                                                                                                                          |),
                                                                                                                                                                                                                          Value.Bool
                                                                                                                                                                                                                            true
                                                                                                                                                                                                                        |) in
                                                                                                                                                                                                                      M.alloc (|
                                                                                                                                                                                                                        Value.StructTuple
                                                                                                                                                                                                                          "core::option::Option::Some"
                                                                                                                                                                                                                          [
                                                                                                                                                                                                                            Value.StructTuple
                                                                                                                                                                                                                              "spl_token_2022::error::TokenError::ConfidentialTransferAccountNotApproved"
                                                                                                                                                                                                                              []
                                                                                                                                                                                                                          ]
                                                                                                                                                                                                                      |)));
                                                                                                                                                                                                                  fun
                                                                                                                                                                                                                      γ =>
                                                                                                                                                                                                                    ltac:(M.monadic
                                                                                                                                                                                                                      (M.match_operator (|
                                                                                                                                                                                                                        M.alloc (|
                                                                                                                                                                                                                          Value.Tuple
                                                                                                                                                                                                                            []
                                                                                                                                                                                                                        |),
                                                                                                                                                                                                                        [
                                                                                                                                                                                                                          fun
                                                                                                                                                                                                                              γ =>
                                                                                                                                                                                                                            ltac:(M.monadic
                                                                                                                                                                                                                              (let
                                                                                                                                                                                                                                    γ :=
                                                                                                                                                                                                                                M.use
                                                                                                                                                                                                                                  (M.alloc (|
                                                                                                                                                                                                                                    BinOp.Pure.eq
                                                                                                                                                                                                                                      (M.read (|
                                                                                                                                                                                                                                        n
                                                                                                                                                                                                                                      |))
                                                                                                                                                                                                                                      (M.rust_cast
                                                                                                                                                                                                                                        (Value.Integer
                                                                                                                                                                                                                                          25))
                                                                                                                                                                                                                                  |)) in
                                                                                                                                                                                                                              let
                                                                                                                                                                                                                                    _ :=
                                                                                                                                                                                                                                M.is_constant_or_break_match (|
                                                                                                                                                                                                                                  M.read (|
                                                                                                                                                                                                                                    γ
                                                                                                                                                                                                                                  |),
                                                                                                                                                                                                                                  Value.Bool
                                                                                                                                                                                                                                    true
                                                                                                                                                                                                                                |) in
                                                                                                                                                                                                                              M.alloc (|
                                                                                                                                                                                                                                Value.StructTuple
                                                                                                                                                                                                                                  "core::option::Option::Some"
                                                                                                                                                                                                                                  [
                                                                                                                                                                                                                                    Value.StructTuple
                                                                                                                                                                                                                                      "spl_token_2022::error::TokenError::ConfidentialTransferDepositsAndTransfersDisabled"
                                                                                                                                                                                                                                      []
                                                                                                                                                                                                                                  ]
                                                                                                                                                                                                                              |)));
                                                                                                                                                                                                                          fun
                                                                                                                                                                                                                              γ =>
                                                                                                                                                                                                                            ltac:(M.monadic
                                                                                                                                                                                                                              (M.match_operator (|
                                                                                                                                                                                                                                M.alloc (|
                                                                                                                                                                                                                                  Value.Tuple
                                                                                                                                                                                                                                    []
                                                                                                                                                                                                                                |),
                                                                                                                                                                                                                                [
                                                                                                                                                                                                                                  fun
                                                                                                                                                                                                                                      γ =>
                                                                                                                                                                                                                                    ltac:(M.monadic
                                                                                                                                                                                                                                      (let
                                                                                                                                                                                                                                            γ :=
                                                                                                                                                                                                                                        M.use
                                                                                                                                                                                                                                          (M.alloc (|
                                                                                                                                                                                                                                            BinOp.Pure.eq
                                                                                                                                                                                                                                              (M.read (|
                                                                                                                                                                                                                                                n
                                                                                                                                                                                                                                              |))
                                                                                                                                                                                                                                              (M.rust_cast
                                                                                                                                                                                                                                                (Value.Integer
                                                                                                                                                                                                                                                  26))
                                                                                                                                                                                                                                          |)) in
                                                                                                                                                                                                                                      let
                                                                                                                                                                                                                                            _ :=
                                                                                                                                                                                                                                        M.is_constant_or_break_match (|
                                                                                                                                                                                                                                          M.read (|
                                                                                                                                                                                                                                            γ
                                                                                                                                                                                                                                          |),
                                                                                                                                                                                                                                          Value.Bool
                                                                                                                                                                                                                                            true
                                                                                                                                                                                                                                        |) in
                                                                                                                                                                                                                                      M.alloc (|
                                                                                                                                                                                                                                        Value.StructTuple
                                                                                                                                                                                                                                          "core::option::Option::Some"
                                                                                                                                                                                                                                          [
                                                                                                                                                                                                                                            Value.StructTuple
                                                                                                                                                                                                                                              "spl_token_2022::error::TokenError::ConfidentialTransferElGamalPubkeyMismatch"
                                                                                                                                                                                                                                              []
                                                                                                                                                                                                                                          ]
                                                                                                                                                                                                                                      |)));
                                                                                                                                                                                                                                  fun
                                                                                                                                                                                                                                      γ =>
                                                                                                                                                                                                                                    ltac:(M.monadic
                                                                                                                                                                                                                                      (M.match_operator (|
                                                                                                                                                                                                                                        M.alloc (|
                                                                                                                                                                                                                                          Value.Tuple
                                                                                                                                                                                                                                            []
                                                                                                                                                                                                                                        |),
                                                                                                                                                                                                                                        [
                                                                                                                                                                                                                                          fun
                                                                                                                                                                                                                                              γ =>
                                                                                                                                                                                                                                            ltac:(M.monadic
                                                                                                                                                                                                                                              (let
                                                                                                                                                                                                                                                    γ :=
                                                                                                                                                                                                                                                M.use
                                                                                                                                                                                                                                                  (M.alloc (|
                                                                                                                                                                                                                                                    BinOp.Pure.eq
                                                                                                                                                                                                                                                      (M.read (|
                                                                                                                                                                                                                                                        n
                                                                                                                                                                                                                                                      |))
                                                                                                                                                                                                                                                      (M.rust_cast
                                                                                                                                                                                                                                                        (Value.Integer
                                                                                                                                                                                                                                                          27))
                                                                                                                                                                                                                                                  |)) in
                                                                                                                                                                                                                                              let
                                                                                                                                                                                                                                                    _ :=
                                                                                                                                                                                                                                                M.is_constant_or_break_match (|
                                                                                                                                                                                                                                                  M.read (|
                                                                                                                                                                                                                                                    γ
                                                                                                                                                                                                                                                  |),
                                                                                                                                                                                                                                                  Value.Bool
                                                                                                                                                                                                                                                    true
                                                                                                                                                                                                                                                |) in
                                                                                                                                                                                                                                              M.alloc (|
                                                                                                                                                                                                                                                Value.StructTuple
                                                                                                                                                                                                                                                  "core::option::Option::Some"
                                                                                                                                                                                                                                                  [
                                                                                                                                                                                                                                                    Value.StructTuple
                                                                                                                                                                                                                                                      "spl_token_2022::error::TokenError::ConfidentialTransferBalanceMismatch"
                                                                                                                                                                                                                                                      []
                                                                                                                                                                                                                                                  ]
                                                                                                                                                                                                                                              |)));
                                                                                                                                                                                                                                          fun
                                                                                                                                                                                                                                              γ =>
                                                                                                                                                                                                                                            ltac:(M.monadic
                                                                                                                                                                                                                                              (M.match_operator (|
                                                                                                                                                                                                                                                M.alloc (|
                                                                                                                                                                                                                                                  Value.Tuple
                                                                                                                                                                                                                                                    []
                                                                                                                                                                                                                                                |),
                                                                                                                                                                                                                                                [
                                                                                                                                                                                                                                                  fun
                                                                                                                                                                                                                                                      γ =>
                                                                                                                                                                                                                                                    ltac:(M.monadic
                                                                                                                                                                                                                                                      (let
                                                                                                                                                                                                                                                            γ :=
                                                                                                                                                                                                                                                        M.use
                                                                                                                                                                                                                                                          (M.alloc (|
                                                                                                                                                                                                                                                            BinOp.Pure.eq
                                                                                                                                                                                                                                                              (M.read (|
                                                                                                                                                                                                                                                                n
                                                                                                                                                                                                                                                              |))
                                                                                                                                                                                                                                                              (M.rust_cast
                                                                                                                                                                                                                                                                (Value.Integer
                                                                                                                                                                                                                                                                  28))
                                                                                                                                                                                                                                                          |)) in
                                                                                                                                                                                                                                                      let
                                                                                                                                                                                                                                                            _ :=
                                                                                                                                                                                                                                                        M.is_constant_or_break_match (|
                                                                                                                                                                                                                                                          M.read (|
                                                                                                                                                                                                                                                            γ
                                                                                                                                                                                                                                                          |),
                                                                                                                                                                                                                                                          Value.Bool
                                                                                                                                                                                                                                                            true
                                                                                                                                                                                                                                                        |) in
                                                                                                                                                                                                                                                      M.alloc (|
                                                                                                                                                                                                                                                        Value.StructTuple
                                                                                                                                                                                                                                                          "core::option::Option::Some"
                                                                                                                                                                                                                                                          [
                                                                                                                                                                                                                                                            Value.StructTuple
                                                                                                                                                                                                                                                              "spl_token_2022::error::TokenError::MintHasSupply"
                                                                                                                                                                                                                                                              []
                                                                                                                                                                                                                                                          ]
                                                                                                                                                                                                                                                      |)));
                                                                                                                                                                                                                                                  fun
                                                                                                                                                                                                                                                      γ =>
                                                                                                                                                                                                                                                    ltac:(M.monadic
                                                                                                                                                                                                                                                      (M.match_operator (|
                                                                                                                                                                                                                                                        M.alloc (|
                                                                                                                                                                                                                                                          Value.Tuple
                                                                                                                                                                                                                                                            []
                                                                                                                                                                                                                                                        |),
                                                                                                                                                                                                                                                        [
                                                                                                                                                                                                                                                          fun
                                                                                                                                                                                                                                                              γ =>
                                                                                                                                                                                                                                                            ltac:(M.monadic
                                                                                                                                                                                                                                                              (let
                                                                                                                                                                                                                                                                    γ :=
                                                                                                                                                                                                                                                                M.use
                                                                                                                                                                                                                                                                  (M.alloc (|
                                                                                                                                                                                                                                                                    BinOp.Pure.eq
                                                                                                                                                                                                                                                                      (M.read (|
                                                                                                                                                                                                                                                                        n
                                                                                                                                                                                                                                                                      |))
                                                                                                                                                                                                                                                                      (M.rust_cast
                                                                                                                                                                                                                                                                        (Value.Integer
                                                                                                                                                                                                                                                                          29))
                                                                                                                                                                                                                                                                  |)) in
                                                                                                                                                                                                                                                              let
                                                                                                                                                                                                                                                                    _ :=
                                                                                                                                                                                                                                                                M.is_constant_or_break_match (|
                                                                                                                                                                                                                                                                  M.read (|
                                                                                                                                                                                                                                                                    γ
                                                                                                                                                                                                                                                                  |),
                                                                                                                                                                                                                                                                  Value.Bool
                                                                                                                                                                                                                                                                    true
                                                                                                                                                                                                                                                                |) in
                                                                                                                                                                                                                                                              M.alloc (|
                                                                                                                                                                                                                                                                Value.StructTuple
                                                                                                                                                                                                                                                                  "core::option::Option::Some"
                                                                                                                                                                                                                                                                  [
                                                                                                                                                                                                                                                                    Value.StructTuple
                                                                                                                                                                                                                                                                      "spl_token_2022::error::TokenError::NoAuthorityExists"
                                                                                                                                                                                                                                                                      []
                                                                                                                                                                                                                                                                  ]
                                                                                                                                                                                                                                                              |)));
                                                                                                                                                                                                                                                          fun
                                                                                                                                                                                                                                                              γ =>
                                                                                                                                                                                                                                                            ltac:(M.monadic
                                                                                                                                                                                                                                                              (M.match_operator (|
                                                                                                                                                                                                                                                                M.alloc (|
                                                                                                                                                                                                                                                                  Value.Tuple
                                                                                                                                                                                                                                                                    []
                                                                                                                                                                                                                                                                |),
                                                                                                                                                                                                                                                                [
                                                                                                                                                                                                                                                                  fun
                                                                                                                                                                                                                                                                      γ =>
                                                                                                                                                                                                                                                                    ltac:(M.monadic
                                                                                                                                                                                                                                                                      (let
                                                                                                                                                                                                                                                                            γ :=
                                                                                                                                                                                                                                                                        M.use
                                                                                                                                                                                                                                                                          (M.alloc (|
                                                                                                                                                                                                                                                                            BinOp.Pure.eq
                                                                                                                                                                                                                                                                              (M.read (|
                                                                                                                                                                                                                                                                                n
                                                                                                                                                                                                                                                                              |))
                                                                                                                                                                                                                                                                              (M.rust_cast
                                                                                                                                                                                                                                                                                (Value.Integer
                                                                                                                                                                                                                                                                                  30))
                                                                                                                                                                                                                                                                          |)) in
                                                                                                                                                                                                                                                                      let
                                                                                                                                                                                                                                                                            _ :=
                                                                                                                                                                                                                                                                        M.is_constant_or_break_match (|
                                                                                                                                                                                                                                                                          M.read (|
                                                                                                                                                                                                                                                                            γ
                                                                                                                                                                                                                                                                          |),
                                                                                                                                                                                                                                                                          Value.Bool
                                                                                                                                                                                                                                                                            true
                                                                                                                                                                                                                                                                        |) in
                                                                                                                                                                                                                                                                      M.alloc (|
                                                                                                                                                                                                                                                                        Value.StructTuple
                                                                                                                                                                                                                                                                          "core::option::Option::Some"
                                                                                                                                                                                                                                                                          [
                                                                                                                                                                                                                                                                            Value.StructTuple
                                                                                                                                                                                                                                                                              "spl_token_2022::error::TokenError::TransferFeeExceedsMaximum"
                                                                                                                                                                                                                                                                              []
                                                                                                                                                                                                                                                                          ]
                                                                                                                                                                                                                                                                      |)));
                                                                                                                                                                                                                                                                  fun
                                                                                                                                                                                                                                                                      γ =>
                                                                                                                                                                                                                                                                    ltac:(M.monadic
                                                                                                                                                                                                                                                                      (M.match_operator (|
                                                                                                                                                                                                                                                                        M.alloc (|
                                                                                                                                                                                                                                                                          Value.Tuple
                                                                                                                                                                                                                                                                            []
                                                                                                                                                                                                                                                                        |),
                                                                                                                                                                                                                                                                        [
                                                                                                                                                                                                                                                                          fun
                                                                                                                                                                                                                                                                              γ =>
                                                                                                                                                                                                                                                                            ltac:(M.monadic
                                                                                                                                                                                                                                                                              (let
                                                                                                                                                                                                                                                                                    γ :=
                                                                                                                                                                                                                                                                                M.use
                                                                                                                                                                                                                                                                                  (M.alloc (|
                                                                                                                                                                                                                                                                                    BinOp.Pure.eq
                                                                                                                                                                                                                                                                                      (M.read (|
                                                                                                                                                                                                                                                                                        n
                                                                                                                                                                                                                                                                                      |))
                                                                                                                                                                                                                                                                                      (M.rust_cast
                                                                                                                                                                                                                                                                                        (Value.Integer
                                                                                                                                                                                                                                                                                          31))
                                                                                                                                                                                                                                                                                  |)) in
                                                                                                                                                                                                                                                                              let
                                                                                                                                                                                                                                                                                    _ :=
                                                                                                                                                                                                                                                                                M.is_constant_or_break_match (|
                                                                                                                                                                                                                                                                                  M.read (|
                                                                                                                                                                                                                                                                                    γ
                                                                                                                                                                                                                                                                                  |),
                                                                                                                                                                                                                                                                                  Value.Bool
                                                                                                                                                                                                                                                                                    true
                                                                                                                                                                                                                                                                                |) in
                                                                                                                                                                                                                                                                              M.alloc (|
                                                                                                                                                                                                                                                                                Value.StructTuple
                                                                                                                                                                                                                                                                                  "core::option::Option::Some"
                                                                                                                                                                                                                                                                                  [
                                                                                                                                                                                                                                                                                    Value.StructTuple
                                                                                                                                                                                                                                                                                      "spl_token_2022::error::TokenError::MintRequiredForTransfer"
                                                                                                                                                                                                                                                                                      []
                                                                                                                                                                                                                                                                                  ]
                                                                                                                                                                                                                                                                              |)));
                                                                                                                                                                                                                                                                          fun
                                                                                                                                                                                                                                                                              γ =>
                                                                                                                                                                                                                                                                            ltac:(M.monadic
                                                                                                                                                                                                                                                                              (M.match_operator (|
                                                                                                                                                                                                                                                                                M.alloc (|
                                                                                                                                                                                                                                                                                  Value.Tuple
                                                                                                                                                                                                                                                                                    []
                                                                                                                                                                                                                                                                                |),
                                                                                                                                                                                                                                                                                [
                                                                                                                                                                                                                                                                                  fun
                                                                                                                                                                                                                                                                                      γ =>
                                                                                                                                                                                                                                                                                    ltac:(M.monadic
                                                                                                                                                                                                                                                                                      (let
                                                                                                                                                                                                                                                                                            γ :=
                                                                                                                                                                                                                                                                                        M.use
                                                                                                                                                                                                                                                                                          (M.alloc (|
                                                                                                                                                                                                                                                                                            BinOp.Pure.eq
                                                                                                                                                                                                                                                                                              (M.read (|
                                                                                                                                                                                                                                                                                                n
                                                                                                                                                                                                                                                                                              |))
                                                                                                                                                                                                                                                                                              (M.rust_cast
                                                                                                                                                                                                                                                                                                (Value.Integer
                                                                                                                                                                                                                                                                                                  32))
                                                                                                                                                                                                                                                                                          |)) in
                                                                                                                                                                                                                                                                                      let
                                                                                                                                                                                                                                                                                            _ :=
                                                                                                                                                                                                                                                                                        M.is_constant_or_break_match (|
                                                                                                                                                                                                                                                                                          M.read (|
                                                                                                                                                                                                                                                                                            γ
                                                                                                                                                                                                                                                                                          |),
                                                                                                                                                                                                                                                                                          Value.Bool
                                                                                                                                                                                                                                                                                            true
                                                                                                                                                                                                                                                                                        |) in
                                                                                                                                                                                                                                                                                      M.alloc (|
                                                                                                                                                                                                                                                                                        Value.StructTuple
                                                                                                                                                                                                                                                                                          "core::option::Option::Some"
                                                                                                                                                                                                                                                                                          [
                                                                                                                                                                                                                                                                                            Value.StructTuple
                                                                                                                                                                                                                                                                                              "spl_token_2022::error::TokenError::FeeMismatch"
                                                                                                                                                                                                                                                                                              []
                                                                                                                                                                                                                                                                                          ]
                                                                                                                                                                                                                                                                                      |)));
                                                                                                                                                                                                                                                                                  fun
                                                                                                                                                                                                                                                                                      γ =>
                                                                                                                                                                                                                                                                                    ltac:(M.monadic
                                                                                                                                                                                                                                                                                      (M.match_operator (|
                                                                                                                                                                                                                                                                                        M.alloc (|
                                                                                                                                                                                                                                                                                          Value.Tuple
                                                                                                                                                                                                                                                                                            []
                                                                                                                                                                                                                                                                                        |),
                                                                                                                                                                                                                                                                                        [
                                                                                                                                                                                                                                                                                          fun
                                                                                                                                                                                                                                                                                              γ =>
                                                                                                                                                                                                                                                                                            ltac:(M.monadic
                                                                                                                                                                                                                                                                                              (let
                                                                                                                                                                                                                                                                                                    γ :=
                                                                                                                                                                                                                                                                                                M.use
                                                                                                                                                                                                                                                                                                  (M.alloc (|
                                                                                                                                                                                                                                                                                                    BinOp.Pure.eq
                                                                                                                                                                                                                                                                                                      (M.read (|
                                                                                                                                                                                                                                                                                                        n
                                                                                                                                                                                                                                                                                                      |))
                                                                                                                                                                                                                                                                                                      (M.rust_cast
                                                                                                                                                                                                                                                                                                        (Value.Integer
                                                                                                                                                                                                                                                                                                          33))
                                                                                                                                                                                                                                                                                                  |)) in
                                                                                                                                                                                                                                                                                              let
                                                                                                                                                                                                                                                                                                    _ :=
                                                                                                                                                                                                                                                                                                M.is_constant_or_break_match (|
                                                                                                                                                                                                                                                                                                  M.read (|
                                                                                                                                                                                                                                                                                                    γ
                                                                                                                                                                                                                                                                                                  |),
                                                                                                                                                                                                                                                                                                  Value.Bool
                                                                                                                                                                                                                                                                                                    true
                                                                                                                                                                                                                                                                                                |) in
                                                                                                                                                                                                                                                                                              M.alloc (|
                                                                                                                                                                                                                                                                                                Value.StructTuple
                                                                                                                                                                                                                                                                                                  "core::option::Option::Some"
                                                                                                                                                                                                                                                                                                  [
                                                                                                                                                                                                                                                                                                    Value.StructTuple
                                                                                                                                                                                                                                                                                                      "spl_token_2022::error::TokenError::FeeParametersMismatch"
                                                                                                                                                                                                                                                                                                      []
                                                                                                                                                                                                                                                                                                  ]
                                                                                                                                                                                                                                                                                              |)));
                                                                                                                                                                                                                                                                                          fun
                                                                                                                                                                                                                                                                                              γ =>
                                                                                                                                                                                                                                                                                            ltac:(M.monadic
                                                                                                                                                                                                                                                                                              (M.match_operator (|
                                                                                                                                                                                                                                                                                                M.alloc (|
                                                                                                                                                                                                                                                                                                  Value.Tuple
                                                                                                                                                                                                                                                                                                    []
                                                                                                                                                                                                                                                                                                |),
                                                                                                                                                                                                                                                                                                [
                                                                                                                                                                                                                                                                                                  fun
                                                                                                                                                                                                                                                                                                      γ =>
                                                                                                                                                                                                                                                                                                    ltac:(M.monadic
                                                                                                                                                                                                                                                                                                      (let
                                                                                                                                                                                                                                                                                                            γ :=
                                                                                                                                                                                                                                                                                                        M.use
                                                                                                                                                                                                                                                                                                          (M.alloc (|
                                                                                                                                                                                                                                                                                                            BinOp.Pure.eq
                                                                                                                                                                                                                                                                                                              (M.read (|
                                                                                                                                                                                                                                                                                                                n
                                                                                                                                                                                                                                                                                                              |))
                                                                                                                                                                                                                                                                                                              (M.rust_cast
                                                                                                                                                                                                                                                                                                                (Value.Integer
                                                                                                                                                                                                                                                                                                                  34))
                                                                                                                                                                                                                                                                                                          |)) in
                                                                                                                                                                                                                                                                                                      let
                                                                                                                                                                                                                                                                                                            _ :=
                                                                                                                                                                                                                                                                                                        M.is_constant_or_break_match (|
                                                                                                                                                                                                                                                                                                          M.read (|
                                                                                                                                                                                                                                                                                                            γ
                                                                                                                                                                                                                                                                                                          |),
                                                                                                                                                                                                                                                                                                          Value.Bool
                                                                                                                                                                                                                                                                                                            true
                                                                                                                                                                                                                                                                                                        |) in
                                                                                                                                                                                                                                                                                                      M.alloc (|
                                                                                                                                                                                                                                                                                                        Value.StructTuple
                                                                                                                                                                                                                                                                                                          "core::option::Option::Some"
                                                                                                                                                                                                                                                                                                          [
                                                                                                                                                                                                                                                                                                            Value.StructTuple
                                                                                                                                                                                                                                                                                                              "spl_token_2022::error::TokenError::ImmutableOwner"
                                                                                                                                                                                                                                                                                                              []
                                                                                                                                                                                                                                                                                                          ]
                                                                                                                                                                                                                                                                                                      |)));
                                                                                                                                                                                                                                                                                                  fun
                                                                                                                                                                                                                                                                                                      γ =>
                                                                                                                                                                                                                                                                                                    ltac:(M.monadic
                                                                                                                                                                                                                                                                                                      (M.match_operator (|
                                                                                                                                                                                                                                                                                                        M.alloc (|
                                                                                                                                                                                                                                                                                                          Value.Tuple
                                                                                                                                                                                                                                                                                                            []
                                                                                                                                                                                                                                                                                                        |),
                                                                                                                                                                                                                                                                                                        [
                                                                                                                                                                                                                                                                                                          fun
                                                                                                                                                                                                                                                                                                              γ =>
                                                                                                                                                                                                                                                                                                            ltac:(M.monadic
                                                                                                                                                                                                                                                                                                              (let
                                                                                                                                                                                                                                                                                                                    γ :=
                                                                                                                                                                                                                                                                                                                M.use
                                                                                                                                                                                                                                                                                                                  (M.alloc (|
                                                                                                                                                                                                                                                                                                                    BinOp.Pure.eq
                                                                                                                                                                                                                                                                                                                      (M.read (|
                                                                                                                                                                                                                                                                                                                        n
                                                                                                                                                                                                                                                                                                                      |))
                                                                                                                                                                                                                                                                                                                      (M.rust_cast
                                                                                                                                                                                                                                                                                                                        (Value.Integer
                                                                                                                                                                                                                                                                                                                          35))
                                                                                                                                                                                                                                                                                                                  |)) in
                                                                                                                                                                                                                                                                                                              let
                                                                                                                                                                                                                                                                                                                    _ :=
                                                                                                                                                                                                                                                                                                                M.is_constant_or_break_match (|
                                                                                                                                                                                                                                                                                                                  M.read (|
                                                                                                                                                                                                                                                                                                                    γ
                                                                                                                                                                                                                                                                                                                  |),
                                                                                                                                                                                                                                                                                                                  Value.Bool
                                                                                                                                                                                                                                                                                                                    true
                                                                                                                                                                                                                                                                                                                |) in
                                                                                                                                                                                                                                                                                                              M.alloc (|
                                                                                                                                                                                                                                                                                                                Value.StructTuple
                                                                                                                                                                                                                                                                                                                  "core::option::Option::Some"
                                                                                                                                                                                                                                                                                                                  [
                                                                                                                                                                                                                                                                                                                    Value.StructTuple
                                                                                                                                                                                                                                                                                                                      "spl_token_2022::error::TokenError::AccountHasWithheldTransferFees"
                                                                                                                                                                                                                                                                                                                      []
                                                                                                                                                                                                                                                                                                                  ]
                                                                                                                                                                                                                                                                                                              |)));
                                                                                                                                                                                                                                                                                                          fun
                                                                                                                                                                                                                                                                                                              γ =>
                                                                                                                                                                                                                                                                                                            ltac:(M.monadic
                                                                                                                                                                                                                                                                                                              (M.match_operator (|
                                                                                                                                                                                                                                                                                                                M.alloc (|
                                                                                                                                                                                                                                                                                                                  Value.Tuple
                                                                                                                                                                                                                                                                                                                    []
                                                                                                                                                                                                                                                                                                                |),
                                                                                                                                                                                                                                                                                                                [
                                                                                                                                                                                                                                                                                                                  fun
                                                                                                                                                                                                                                                                                                                      γ =>
                                                                                                                                                                                                                                                                                                                    ltac:(M.monadic
                                                                                                                                                                                                                                                                                                                      (let
                                                                                                                                                                                                                                                                                                                            γ :=
                                                                                                                                                                                                                                                                                                                        M.use
                                                                                                                                                                                                                                                                                                                          (M.alloc (|
                                                                                                                                                                                                                                                                                                                            BinOp.Pure.eq
                                                                                                                                                                                                                                                                                                                              (M.read (|
                                                                                                                                                                                                                                                                                                                                n
                                                                                                                                                                                                                                                                                                                              |))
                                                                                                                                                                                                                                                                                                                              (M.rust_cast
                                                                                                                                                                                                                                                                                                                                (Value.Integer
                                                                                                                                                                                                                                                                                                                                  36))
                                                                                                                                                                                                                                                                                                                          |)) in
                                                                                                                                                                                                                                                                                                                      let
                                                                                                                                                                                                                                                                                                                            _ :=
                                                                                                                                                                                                                                                                                                                        M.is_constant_or_break_match (|
                                                                                                                                                                                                                                                                                                                          M.read (|
                                                                                                                                                                                                                                                                                                                            γ
                                                                                                                                                                                                                                                                                                                          |),
                                                                                                                                                                                                                                                                                                                          Value.Bool
                                                                                                                                                                                                                                                                                                                            true
                                                                                                                                                                                                                                                                                                                        |) in
                                                                                                                                                                                                                                                                                                                      M.alloc (|
                                                                                                                                                                                                                                                                                                                        Value.StructTuple
                                                                                                                                                                                                                                                                                                                          "core::option::Option::Some"
                                                                                                                                                                                                                                                                                                                          [
                                                                                                                                                                                                                                                                                                                            Value.StructTuple
                                                                                                                                                                                                                                                                                                                              "spl_token_2022::error::TokenError::NoMemo"
                                                                                                                                                                                                                                                                                                                              []
                                                                                                                                                                                                                                                                                                                          ]
                                                                                                                                                                                                                                                                                                                      |)));
                                                                                                                                                                                                                                                                                                                  fun
                                                                                                                                                                                                                                                                                                                      γ =>
                                                                                                                                                                                                                                                                                                                    ltac:(M.monadic
                                                                                                                                                                                                                                                                                                                      (M.match_operator (|
                                                                                                                                                                                                                                                                                                                        M.alloc (|
                                                                                                                                                                                                                                                                                                                          Value.Tuple
                                                                                                                                                                                                                                                                                                                            []
                                                                                                                                                                                                                                                                                                                        |),
                                                                                                                                                                                                                                                                                                                        [
                                                                                                                                                                                                                                                                                                                          fun
                                                                                                                                                                                                                                                                                                                              γ =>
                                                                                                                                                                                                                                                                                                                            ltac:(M.monadic
                                                                                                                                                                                                                                                                                                                              (let
                                                                                                                                                                                                                                                                                                                                    γ :=
                                                                                                                                                                                                                                                                                                                                M.use
                                                                                                                                                                                                                                                                                                                                  (M.alloc (|
                                                                                                                                                                                                                                                                                                                                    BinOp.Pure.eq
                                                                                                                                                                                                                                                                                                                                      (M.read (|
                                                                                                                                                                                                                                                                                                                                        n
                                                                                                                                                                                                                                                                                                                                      |))
                                                                                                                                                                                                                                                                                                                                      (M.rust_cast
                                                                                                                                                                                                                                                                                                                                        (Value.Integer
                                                                                                                                                                                                                                                                                                                                          37))
                                                                                                                                                                                                                                                                                                                                  |)) in
                                                                                                                                                                                                                                                                                                                              let
                                                                                                                                                                                                                                                                                                                                    _ :=
                                                                                                                                                                                                                                                                                                                                M.is_constant_or_break_match (|
                                                                                                                                                                                                                                                                                                                                  M.read (|
                                                                                                                                                                                                                                                                                                                                    γ
                                                                                                                                                                                                                                                                                                                                  |),
                                                                                                                                                                                                                                                                                                                                  Value.Bool
                                                                                                                                                                                                                                                                                                                                    true
                                                                                                                                                                                                                                                                                                                                |) in
                                                                                                                                                                                                                                                                                                                              M.alloc (|
                                                                                                                                                                                                                                                                                                                                Value.StructTuple
                                                                                                                                                                                                                                                                                                                                  "core::option::Option::Some"
                                                                                                                                                                                                                                                                                                                                  [
                                                                                                                                                                                                                                                                                                                                    Value.StructTuple
                                                                                                                                                                                                                                                                                                                                      "spl_token_2022::error::TokenError::NonTransferable"
                                                                                                                                                                                                                                                                                                                                      []
                                                                                                                                                                                                                                                                                                                                  ]
                                                                                                                                                                                                                                                                                                                              |)));
                                                                                                                                                                                                                                                                                                                          fun
                                                                                                                                                                                                                                                                                                                              γ =>
                                                                                                                                                                                                                                                                                                                            ltac:(M.monadic
                                                                                                                                                                                                                                                                                                                              (M.match_operator (|
                                                                                                                                                                                                                                                                                                                                M.alloc (|
                                                                                                                                                                                                                                                                                                                                  Value.Tuple
                                                                                                                                                                                                                                                                                                                                    []
                                                                                                                                                                                                                                                                                                                                |),
                                                                                                                                                                                                                                                                                                                                [
                                                                                                                                                                                                                                                                                                                                  fun
                                                                                                                                                                                                                                                                                                                                      γ =>
                                                                                                                                                                                                                                                                                                                                    ltac:(M.monadic
                                                                                                                                                                                                                                                                                                                                      (let
                                                                                                                                                                                                                                                                                                                                            γ :=
                                                                                                                                                                                                                                                                                                                                        M.use
                                                                                                                                                                                                                                                                                                                                          (M.alloc (|
                                                                                                                                                                                                                                                                                                                                            BinOp.Pure.eq
                                                                                                                                                                                                                                                                                                                                              (M.read (|
                                                                                                                                                                                                                                                                                                                                                n
                                                                                                                                                                                                                                                                                                                                              |))
                                                                                                                                                                                                                                                                                                                                              (M.rust_cast
                                                                                                                                                                                                                                                                                                                                                (Value.Integer
                                                                                                                                                                                                                                                                                                                                                  38))
                                                                                                                                                                                                                                                                                                                                          |)) in
                                                                                                                                                                                                                                                                                                                                      let
                                                                                                                                                                                                                                                                                                                                            _ :=
                                                                                                                                                                                                                                                                                                                                        M.is_constant_or_break_match (|
                                                                                                                                                                                                                                                                                                                                          M.read (|
                                                                                                                                                                                                                                                                                                                                            γ
                                                                                                                                                                                                                                                                                                                                          |),
                                                                                                                                                                                                                                                                                                                                          Value.Bool
                                                                                                                                                                                                                                                                                                                                            true
                                                                                                                                                                                                                                                                                                                                        |) in
                                                                                                                                                                                                                                                                                                                                      M.alloc (|
                                                                                                                                                                                                                                                                                                                                        Value.StructTuple
                                                                                                                                                                                                                                                                                                                                          "core::option::Option::Some"
                                                                                                                                                                                                                                                                                                                                          [
                                                                                                                                                                                                                                                                                                                                            Value.StructTuple
                                                                                                                                                                                                                                                                                                                                              "spl_token_2022::error::TokenError::NonTransferableNeedsImmutableOwnership"
                                                                                                                                                                                                                                                                                                                                              []
                                                                                                                                                                                                                                                                                                                                          ]
                                                                                                                                                                                                                                                                                                                                      |)));
                                                                                                                                                                                                                                                                                                                                  fun
                                                                                                                                                                                                                                                                                                                                      γ =>
                                                                                                                                                                                                                                                                                                                                    ltac:(M.monadic
                                                                                                                                                                                                                                                                                                                                      (M.match_operator (|
                                                                                                                                                                                                                                                                                                                                        M.alloc (|
                                                                                                                                                                                                                                                                                                                                          Value.Tuple
                                                                                                                                                                                                                                                                                                                                            []
                                                                                                                                                                                                                                                                                                                                        |),
                                                                                                                                                                                                                                                                                                                                        [
                                                                                                                                                                                                                                                                                                                                          fun
                                                                                                                                                                                                                                                                                                                                              γ =>
                                                                                                                                                                                                                                                                                                                                            ltac:(M.monadic
                                                                                                                                                                                                                                                                                                                                              (let
                                                                                                                                                                                                                                                                                                                                                    γ :=
                                                                                                                                                                                                                                                                                                                                                M.use
                                                                                                                                                                                                                                                                                                                                                  (M.alloc (|
                                                                                                                                                                                                                                                                                                                                                    BinOp.Pure.eq
                                                                                                                                                                                                                                                                                                                                                      (M.read (|
                                                                                                                                                                                                                                                                                                                                                        n
                                                                                                                                                                                                                                                                                                                                                      |))
                                                                                                                                                                                                                                                                                                                                                      (M.rust_cast
                                                                                                                                                                                                                                                                                                                                                        (Value.Integer
                                                                                                                                                                                                                                                                                                                                                          39))
                                                                                                                                                                                                                                                                                                                                                  |)) in
                                                                                                                                                                                                                                                                                                                                              let
                                                                                                                                                                                                                                                                                                                                                    _ :=
                                                                                                                                                                                                                                                                                                                                                M.is_constant_or_break_match (|
                                                                                                                                                                                                                                                                                                                                                  M.read (|
                                                                                                                                                                                                                                                                                                                                                    γ
                                                                                                                                                                                                                                                                                                                                                  |),
                                                                                                                                                                                                                                                                                                                                                  Value.Bool
                                                                                                                                                                                                                                                                                                                                                    true
                                                                                                                                                                                                                                                                                                                                                |) in
                                                                                                                                                                                                                                                                                                                                              M.alloc (|
                                                                                                                                                                                                                                                                                                                                                Value.StructTuple
                                                                                                                                                                                                                                                                                                                                                  "core::option::Option::Some"
                                                                                                                                                                                                                                                                                                                                                  [
                                                                                                                                                                                                                                                                                                                                                    Value.StructTuple
                                                                                                                                                                                                                                                                                                                                                      "spl_token_2022::error::TokenError::MaximumPendingBalanceCreditCounterExceeded"
                                                                                                                                                                                                                                                                                                                                                      []
                                                                                                                                                                                                                                                                                                                                                  ]
                                                                                                                                                                                                                                                                                                                                              |)));
                                                                                                                                                                                                                                                                                                                                          fun
                                                                                                                                                                                                                                                                                                                                              γ =>
                                                                                                                                                                                                                                                                                                                                            ltac:(M.monadic
                                                                                                                                                                                                                                                                                                                                              (M.match_operator (|
                                                                                                                                                                                                                                                                                                                                                M.alloc (|
                                                                                                                                                                                                                                                                                                                                                  Value.Tuple
                                                                                                                                                                                                                                                                                                                                                    []
                                                                                                                                                                                                                                                                                                                                                |),
                                                                                                                                                                                                                                                                                                                                                [
                                                                                                                                                                                                                                                                                                                                                  fun
                                                                                                                                                                                                                                                                                                                                                      γ =>
                                                                                                                                                                                                                                                                                                                                                    ltac:(M.monadic
                                                                                                                                                                                                                                                                                                                                                      (let
                                                                                                                                                                                                                                                                                                                                                            γ :=
                                                                                                                                                                                                                                                                                                                                                        M.use
                                                                                                                                                                                                                                                                                                                                                          (M.alloc (|
                                                                                                                                                                                                                                                                                                                                                            BinOp.Pure.eq
                                                                                                                                                                                                                                                                                                                                                              (M.read (|
                                                                                                                                                                                                                                                                                                                                                                n
                                                                                                                                                                                                                                                                                                                                                              |))
                                                                                                                                                                                                                                                                                                                                                              (M.rust_cast
                                                                                                                                                                                                                                                                                                                                                                (Value.Integer
                                                                                                                                                                                                                                                                                                                                                                  40))
                                                                                                                                                                                                                                                                                                                                                          |)) in
                                                                                                                                                                                                                                                                                                                                                      let
                                                                                                                                                                                                                                                                                                                                                            _ :=
                                                                                                                                                                                                                                                                                                                                                        M.is_constant_or_break_match (|
                                                                                                                                                                                                                                                                                                                                                          M.read (|
                                                                                                                                                                                                                                                                                                                                                            γ
                                                                                                                                                                                                                                                                                                                                                          |),
                                                                                                                                                                                                                                                                                                                                                          Value.Bool
                                                                                                                                                                                                                                                                                                                                                            true
                                                                                                                                                                                                                                                                                                                                                        |) in
                                                                                                                                                                                                                                                                                                                                                      M.alloc (|
                                                                                                                                                                                                                                                                                                                                                        Value.StructTuple
                                                                                                                                                                                                                                                                                                                                                          "core::option::Option::Some"
                                                                                                                                                                                                                                                                                                                                                          [
                                                                                                                                                                                                                                                                                                                                                            Value.StructTuple
                                                                                                                                                                                                                                                                                                                                                              "spl_token_2022::error::TokenError::MaximumDepositAmountExceeded"
                                                                                                                                                                                                                                                                                                                                                              []
                                                                                                                                                                                                                                                                                                                                                          ]
                                                                                                                                                                                                                                                                                                                                                      |)));
                                                                                                                                                                                                                                                                                                                                                  fun
                                                                                                                                                                                                                                                                                                                                                      γ =>
                                                                                                                                                                                                                                                                                                                                                    ltac:(M.monadic
                                                                                                                                                                                                                                                                                                                                                      (M.match_operator (|
                                                                                                                                                                                                                                                                                                                                                        M.alloc (|
                                                                                                                                                                                                                                                                                                                                                          Value.Tuple
                                                                                                                                                                                                                                                                                                                                                            []
                                                                                                                                                                                                                                                                                                                                                        |),
                                                                                                                                                                                                                                                                                                                                                        [
                                                                                                                                                                                                                                                                                                                                                          fun
                                                                                                                                                                                                                                                                                                                                                              γ =>
                                                                                                                                                                                                                                                                                                                                                            ltac:(M.monadic
                                                                                                                                                                                                                                                                                                                                                              (let
                                                                                                                                                                                                                                                                                                                                                                    γ :=
                                                                                                                                                                                                                                                                                                                                                                M.use
                                                                                                                                                                                                                                                                                                                                                                  (M.alloc (|
                                                                                                                                                                                                                                                                                                                                                                    BinOp.Pure.eq
                                                                                                                                                                                                                                                                                                                                                                      (M.read (|
                                                                                                                                                                                                                                                                                                                                                                        n
                                                                                                                                                                                                                                                                                                                                                                      |))
                                                                                                                                                                                                                                                                                                                                                                      (M.rust_cast
                                                                                                                                                                                                                                                                                                                                                                        (Value.Integer
                                                                                                                                                                                                                                                                                                                                                                          41))
                                                                                                                                                                                                                                                                                                                                                                  |)) in
                                                                                                                                                                                                                                                                                                                                                              let
                                                                                                                                                                                                                                                                                                                                                                    _ :=
                                                                                                                                                                                                                                                                                                                                                                M.is_constant_or_break_match (|
                                                                                                                                                                                                                                                                                                                                                                  M.read (|
                                                                                                                                                                                                                                                                                                                                                                    γ
                                                                                                                                                                                                                                                                                                                                                                  |),
                                                                                                                                                                                                                                                                                                                                                                  Value.Bool
                                                                                                                                                                                                                                                                                                                                                                    true
                                                                                                                                                                                                                                                                                                                                                                |) in
                                                                                                                                                                                                                                                                                                                                                              M.alloc (|
                                                                                                                                                                                                                                                                                                                                                                Value.StructTuple
                                                                                                                                                                                                                                                                                                                                                                  "core::option::Option::Some"
                                                                                                                                                                                                                                                                                                                                                                  [
                                                                                                                                                                                                                                                                                                                                                                    Value.StructTuple
                                                                                                                                                                                                                                                                                                                                                                      "spl_token_2022::error::TokenError::CpiGuardSettingsLocked"
                                                                                                                                                                                                                                                                                                                                                                      []
                                                                                                                                                                                                                                                                                                                                                                  ]
                                                                                                                                                                                                                                                                                                                                                              |)));
                                                                                                                                                                                                                                                                                                                                                          fun
                                                                                                                                                                                                                                                                                                                                                              γ =>
                                                                                                                                                                                                                                                                                                                                                            ltac:(M.monadic
                                                                                                                                                                                                                                                                                                                                                              (M.match_operator (|
                                                                                                                                                                                                                                                                                                                                                                M.alloc (|
                                                                                                                                                                                                                                                                                                                                                                  Value.Tuple
                                                                                                                                                                                                                                                                                                                                                                    []
                                                                                                                                                                                                                                                                                                                                                                |),
                                                                                                                                                                                                                                                                                                                                                                [
                                                                                                                                                                                                                                                                                                                                                                  fun
                                                                                                                                                                                                                                                                                                                                                                      γ =>
                                                                                                                                                                                                                                                                                                                                                                    ltac:(M.monadic
                                                                                                                                                                                                                                                                                                                                                                      (let
                                                                                                                                                                                                                                                                                                                                                                            γ :=
                                                                                                                                                                                                                                                                                                                                                                        M.use
                                                                                                                                                                                                                                                                                                                                                                          (M.alloc (|
                                                                                                                                                                                                                                                                                                                                                                            BinOp.Pure.eq
                                                                                                                                                                                                                                                                                                                                                                              (M.read (|
                                                                                                                                                                                                                                                                                                                                                                                n
                                                                                                                                                                                                                                                                                                                                                                              |))
                                                                                                                                                                                                                                                                                                                                                                              (M.rust_cast
                                                                                                                                                                                                                                                                                                                                                                                (Value.Integer
                                                                                                                                                                                                                                                                                                                                                                                  42))
                                                                                                                                                                                                                                                                                                                                                                          |)) in
                                                                                                                                                                                                                                                                                                                                                                      let
                                                                                                                                                                                                                                                                                                                                                                            _ :=
                                                                                                                                                                                                                                                                                                                                                                        M.is_constant_or_break_match (|
                                                                                                                                                                                                                                                                                                                                                                          M.read (|
                                                                                                                                                                                                                                                                                                                                                                            γ
                                                                                                                                                                                                                                                                                                                                                                          |),
                                                                                                                                                                                                                                                                                                                                                                          Value.Bool
                                                                                                                                                                                                                                                                                                                                                                            true
                                                                                                                                                                                                                                                                                                                                                                        |) in
                                                                                                                                                                                                                                                                                                                                                                      M.alloc (|
                                                                                                                                                                                                                                                                                                                                                                        Value.StructTuple
                                                                                                                                                                                                                                                                                                                                                                          "core::option::Option::Some"
                                                                                                                                                                                                                                                                                                                                                                          [
                                                                                                                                                                                                                                                                                                                                                                            Value.StructTuple
                                                                                                                                                                                                                                                                                                                                                                              "spl_token_2022::error::TokenError::CpiGuardTransferBlocked"
                                                                                                                                                                                                                                                                                                                                                                              []
                                                                                                                                                                                                                                                                                                                                                                          ]
                                                                                                                                                                                                                                                                                                                                                                      |)));
                                                                                                                                                                                                                                                                                                                                                                  fun
                                                                                                                                                                                                                                                                                                                                                                      γ =>
                                                                                                                                                                                                                                                                                                                                                                    ltac:(M.monadic
                                                                                                                                                                                                                                                                                                                                                                      (M.match_operator (|
                                                                                                                                                                                                                                                                                                                                                                        M.alloc (|
                                                                                                                                                                                                                                                                                                                                                                          Value.Tuple
                                                                                                                                                                                                                                                                                                                                                                            []
                                                                                                                                                                                                                                                                                                                                                                        |),
                                                                                                                                                                                                                                                                                                                                                                        [
                                                                                                                                                                                                                                                                                                                                                                          fun
                                                                                                                                                                                                                                                                                                                                                                              γ =>
                                                                                                                                                                                                                                                                                                                                                                            ltac:(M.monadic
                                                                                                                                                                                                                                                                                                                                                                              (let
                                                                                                                                                                                                                                                                                                                                                                                    γ :=
                                                                                                                                                                                                                                                                                                                                                                                M.use
                                                                                                                                                                                                                                                                                                                                                                                  (M.alloc (|
                                                                                                                                                                                                                                                                                                                                                                                    BinOp.Pure.eq
                                                                                                                                                                                                                                                                                                                                                                                      (M.read (|
                                                                                                                                                                                                                                                                                                                                                                                        n
                                                                                                                                                                                                                                                                                                                                                                                      |))
                                                                                                                                                                                                                                                                                                                                                                                      (M.rust_cast
                                                                                                                                                                                                                                                                                                                                                                                        (Value.Integer
                                                                                                                                                                                                                                                                                                                                                                                          43))
                                                                                                                                                                                                                                                                                                                                                                                  |)) in
                                                                                                                                                                                                                                                                                                                                                                              let
                                                                                                                                                                                                                                                                                                                                                                                    _ :=
                                                                                                                                                                                                                                                                                                                                                                                M.is_constant_or_break_match (|
                                                                                                                                                                                                                                                                                                                                                                                  M.read (|
                                                                                                                                                                                                                                                                                                                                                                                    γ
                                                                                                                                                                                                                                                                                                                                                                                  |),
                                                                                                                                                                                                                                                                                                                                                                                  Value.Bool
                                                                                                                                                                                                                                                                                                                                                                                    true
                                                                                                                                                                                                                                                                                                                                                                                |) in
                                                                                                                                                                                                                                                                                                                                                                              M.alloc (|
                                                                                                                                                                                                                                                                                                                                                                                Value.StructTuple
                                                                                                                                                                                                                                                                                                                                                                                  "core::option::Option::Some"
                                                                                                                                                                                                                                                                                                                                                                                  [
                                                                                                                                                                                                                                                                                                                                                                                    Value.StructTuple
                                                                                                                                                                                                                                                                                                                                                                                      "spl_token_2022::error::TokenError::CpiGuardBurnBlocked"
                                                                                                                                                                                                                                                                                                                                                                                      []
                                                                                                                                                                                                                                                                                                                                                                                  ]
                                                                                                                                                                                                                                                                                                                                                                              |)));
                                                                                                                                                                                                                                                                                                                                                                          fun
                                                                                                                                                                                                                                                                                                                                                                              γ =>
                                                                                                                                                                                                                                                                                                                                                                            ltac:(M.monadic
                                                                                                                                                                                                                                                                                                                                                                              (M.match_operator (|
                                                                                                                                                                                                                                                                                                                                                                                M.alloc (|
                                                                                                                                                                                                                                                                                                                                                                                  Value.Tuple
                                                                                                                                                                                                                                                                                                                                                                                    []
                                                                                                                                                                                                                                                                                                                                                                                |),
                                                                                                                                                                                                                                                                                                                                                                                [
                                                                                                                                                                                                                                                                                                                                                                                  fun
                                                                                                                                                                                                                                                                                                                                                                                      γ =>
                                                                                                                                                                                                                                                                                                                                                                                    ltac:(M.monadic
                                                                                                                                                                                                                                                                                                                                                                                      (let
                                                                                                                                                                                                                                                                                                                                                                                            γ :=
                                                                                                                                                                                                                                                                                                                                                                                        M.use
                                                                                                                                                                                                                                                                                                                                                                                          (M.alloc (|
                                                                                                                                                                                                                                                                                                                                                                                            BinOp.Pure.eq
                                                                                                                                                                                                                                                                                                                                                                                              (M.read (|
                                                                                                                                                                                                                                                                                                                                                                                                n
                                                                                                                                                                                                                                                                                                                                                                                              |))
                                                                                                                                                                                                                                                                                                                                                                                              (M.rust_cast
                                                                                                                                                                                                                                                                                                                                                                                                (Value.Integer
                                                                                                                                                                                                                                                                                                                                                                                                  44))
                                                                                                                                                                                                                                                                                                                                                                                          |)) in
                                                                                                                                                                                                                                                                                                                                                                                      let
                                                                                                                                                                                                                                                                                                                                                                                            _ :=
                                                                                                                                                                                                                                                                                                                                                                                        M.is_constant_or_break_match (|
                                                                                                                                                                                                                                                                                                                                                                                          M.read (|
                                                                                                                                                                                                                                                                                                                                                                                            γ
                                                                                                                                                                                                                                                                                                                                                                                          |),
                                                                                                                                                                                                                                                                                                                                                                                          Value.Bool
                                                                                                                                                                                                                                                                                                                                                                                            true
                                                                                                                                                                                                                                                                                                                                                                                        |) in
                                                                                                                                                                                                                                                                                                                                                                                      M.alloc (|
                                                                                                                                                                                                                                                                                                                                                                                        Value.StructTuple
                                                                                                                                                                                                                                                                                                                                                                                          "core::option::Option::Some"
                                                                                                                                                                                                                                                                                                                                                                                          [
                                                                                                                                                                                                                                                                                                                                                                                            Value.StructTuple
                                                                                                                                                                                                                                                                                                                                                                                              "spl_token_2022::error::TokenError::CpiGuardCloseAccountBlocked"
                                                                                                                                                                                                                                                                                                                                                                                              []
                                                                                                                                                                                                                                                                                                                                                                                          ]
                                                                                                                                                                                                                                                                                                                                                                                      |)));
                                                                                                                                                                                                                                                                                                                                                                                  fun
                                                                                                                                                                                                                                                                                                                                                                                      γ =>
                                                                                                                                                                                                                                                                                                                                                                                    ltac:(M.monadic
                                                                                                                                                                                                                                                                                                                                                                                      (M.match_operator (|
                                                                                                                                                                                                                                                                                                                                                                                        M.alloc (|
                                                                                                                                                                                                                                                                                                                                                                                          Value.Tuple
                                                                                                                                                                                                                                                                                                                                                                                            []
                                                                                                                                                                                                                                                                                                                                                                                        |),
                                                                                                                                                                                                                                                                                                                                                                                        [
                                                                                                                                                                                                                                                                                                                                                                                          fun
                                                                                                                                                                                                                                                                                                                                                                                              γ =>
                                                                                                                                                                                                                                                                                                                                                                                            ltac:(M.monadic
                                                                                                                                                                                                                                                                                                                                                                                              (let
                                                                                                                                                                                                                                                                                                                                                                                                    γ :=
                                                                                                                                                                                                                                                                                                                                                                                                M.use
                                                                                                                                                                                                                                                                                                                                                                                                  (M.alloc (|
                                                                                                                                                                                                                                                                                                                                                                                                    BinOp.Pure.eq
                                                                                                                                                                                                                                                                                                                                                                                                      (M.read (|
                                                                                                                                                                                                                                                                                                                                                                                                        n
                                                                                                                                                                                                                                                                                                                                                                                                      |))
                                                                                                                                                                                                                                                                                                                                                                                                      (M.rust_cast
                                                                                                                                                                                                                                                                                                                                                                                                        (Value.Integer
                                                                                                                                                                                                                                                                                                                                                                                                          45))
                                                                                                                                                                                                                                                                                                                                                                                                  |)) in
                                                                                                                                                                                                                                                                                                                                                                                              let
                                                                                                                                                                                                                                                                                                                                                                                                    _ :=
                                                                                                                                                                                                                                                                                                                                                                                                M.is_constant_or_break_match (|
                                                                                                                                                                                                                                                                                                                                                                                                  M.read (|
                                                                                                                                                                                                                                                                                                                                                                                                    γ
                                                                                                                                                                                                                                                                                                                                                                                                  |),
                                                                                                                                                                                                                                                                                                                                                                                                  Value.Bool
                                                                                                                                                                                                                                                                                                                                                                                                    true
                                                                                                                                                                                                                                                                                                                                                                                                |) in
                                                                                                                                                                                                                                                                                                                                                                                              M.alloc (|
                                                                                                                                                                                                                                                                                                                                                                                                Value.StructTuple
                                                                                                                                                                                                                                                                                                                                                                                                  "core::option::Option::Some"
                                                                                                                                                                                                                                                                                                                                                                                                  [
                                                                                                                                                                                                                                                                                                                                                                                                    Value.StructTuple
                                                                                                                                                                                                                                                                                                                                                                                                      "spl_token_2022::error::TokenError::CpiGuardApproveBlocked"
                                                                                                                                                                                                                                                                                                                                                                                                      []
                                                                                                                                                                                                                                                                                                                                                                                                  ]
                                                                                                                                                                                                                                                                                                                                                                                              |)));
                                                                                                                                                                                                                                                                                                                                                                                          fun
                                                                                                                                                                                                                                                                                                                                                                                              γ =>
                                                                                                                                                                                                                                                                                                                                                                                            ltac:(M.monadic
                                                                                                                                                                                                                                                                                                                                                                                              (M.match_operator (|
                                                                                                                                                                                                                                                                                                                                                                                                M.alloc (|
                                                                                                                                                                                                                                                                                                                                                                                                  Value.Tuple
                                                                                                                                                                                                                                                                                                                                                                                                    []
                                                                                                                                                                                                                                                                                                                                                                                                |),
                                                                                                                                                                                                                                                                                                                                                                                                [
                                                                                                                                                                                                                                                                                                                                                                                                  fun
                                                                                                                                                                                                                                                                                                                                                                                                      γ =>
                                                                                                                                                                                                                                                                                                                                                                                                    ltac:(M.monadic
                                                                                                                                                                                                                                                                                                                                                                                                      (let
                                                                                                                                                                                                                                                                                                                                                                                                            γ :=
                                                                                                                                                                                                                                                                                                                                                                                                        M.use
                                                                                                                                                                                                                                                                                                                                                                                                          (M.alloc (|
                                                                                                                                                                                                                                                                                                                                                                                                            BinOp.Pure.eq
                                                                                                                                                                                                                                                                                                                                                                                                              (M.read (|
                                                                                                                                                                                                                                                                                                                                                                                                                n
                                                                                                                                                                                                                                                                                                                                                                                                              |))
                                                                                                                                                                                                                                                                                                                                                                                                              (M.rust_cast
                                                                                                                                                                                                                                                                                                                                                                                                                (Value.Integer
                                                                                                                                                                                                                                                                                                                                                                                                                  46))
                                                                                                                                                                                                                                                                                                                                                                                                          |)) in
                                                                                                                                                                                                                                                                                                                                                                                                      let
                                                                                                                                                                                                                                                                                                                                                                                                            _ :=
                                                                                                                                                                                                                                                                                                                                                                                                        M.is_constant_or_break_match (|
                                                                                                                                                                                                                                                                                                                                                                                                          M.read (|
                                                                                                                                                                                                                                                                                                                                                                                                            γ
                                                                                                                                                                                                                                                                                                                                                                                                          |),
                                                                                                                                                                                                                                                                                                                                                                                                          Value.Bool
                                                                                                                                                                                                                                                                                                                                                                                                            true
                                                                                                                                                                                                                                                                                                                                                                                                        |) in
                                                                                                                                                                                                                                                                                                                                                                                                      M.alloc (|
                                                                                                                                                                                                                                                                                                                                                                                                        Value.StructTuple
                                                                                                                                                                                                                                                                                                                                                                                                          "core::option::Option::Some"
                                                                                                                                                                                                                                                                                                                                                                                                          [
                                                                                                                                                                                                                                                                                                                                                                                                            Value.StructTuple
                                                                                                                                                                                                                                                                                                                                                                                                              "spl_token_2022::error::TokenError::CpiGuardSetAuthorityBlocked"
                                                                                                                                                                                                                                                                                                                                                                                                              []
                                                                                                                                                                                                                                                                                                                                                                                                          ]
                                                                                                                                                                                                                                                                                                                                                                                                      |)));
                                                                                                                                                                                                                                                                                                                                                                                                  fun
                                                                                                                                                                                                                                                                                                                                                                                                      γ =>
                                                                                                                                                                                                                                                                                                                                                                                                    ltac:(M.monadic
                                                                                                                                                                                                                                                                                                                                                                                                      (M.match_operator (|
                                                                                                                                                                                                                                                                                                                                                                                                        M.alloc (|
                                                                                                                                                                                                                                                                                                                                                                                                          Value.Tuple
                                                                                                                                                                                                                                                                                                                                                                                                            []
                                                                                                                                                                                                                                                                                                                                                                                                        |),
                                                                                                                                                                                                                                                                                                                                                                                                        [
                                                                                                                                                                                                                                                                                                                                                                                                          fun
                                                                                                                                                                                                                                                                                                                                                                                                              γ =>
                                                                                                                                                                                                                                                                                                                                                                                                            ltac:(M.monadic
                                                                                                                                                                                                                                                                                                                                                                                                              (let
                                                                                                                                                                                                                                                                                                                                                                                                                    γ :=
                                                                                                                                                                                                                                                                                                                                                                                                                M.use
                                                                                                                                                                                                                                                                                                                                                                                                                  (M.alloc (|
                                                                                                                                                                                                                                                                                                                                                                                                                    BinOp.Pure.eq
                                                                                                                                                                                                                                                                                                                                                                                                                      (M.read (|
                                                                                                                                                                                                                                                                                                                                                                                                                        n
                                                                                                                                                                                                                                                                                                                                                                                                                      |))
                                                                                                                                                                                                                                                                                                                                                                                                                      (M.rust_cast
                                                                                                                                                                                                                                                                                                                                                                                                                        (Value.Integer
                                                                                                                                                                                                                                                                                                                                                                                                                          47))
                                                                                                                                                                                                                                                                                                                                                                                                                  |)) in
                                                                                                                                                                                                                                                                                                                                                                                                              let
                                                                                                                                                                                                                                                                                                                                                                                                                    _ :=
                                                                                                                                                                                                                                                                                                                                                                                                                M.is_constant_or_break_match (|
                                                                                                                                                                                                                                                                                                                                                                                                                  M.read (|
                                                                                                                                                                                                                                                                                                                                                                                                                    γ
                                                                                                                                                                                                                                                                                                                                                                                                                  |),
                                                                                                                                                                                                                                                                                                                                                                                                                  Value.Bool
                                                                                                                                                                                                                                                                                                                                                                                                                    true
                                                                                                                                                                                                                                                                                                                                                                                                                |) in
                                                                                                                                                                                                                                                                                                                                                                                                              M.alloc (|
                                                                                                                                                                                                                                                                                                                                                                                                                Value.StructTuple
                                                                                                                                                                                                                                                                                                                                                                                                                  "core::option::Option::Some"
                                                                                                                                                                                                                                                                                                                                                                                                                  [
                                                                                                                                                                                                                                                                                                                                                                                                                    Value.StructTuple
                                                                                                                                                                                                                                                                                                                                                                                                                      "spl_token_2022::error::TokenError::CpiGuardOwnerChangeBlocked"
                                                                                                                                                                                                                                                                                                                                                                                                                      []
                                                                                                                                                                                                                                                                                                                                                                                                                  ]
                                                                                                                                                                                                                                                                                                                                                                                                              |)));
                                                                                                                                                                                                                                                                                                                                                                                                          fun
                                                                                                                                                                                                                                                                                                                                                                                                              γ =>
                                                                                                                                                                                                                                                                                                                                                                                                            ltac:(M.monadic
                                                                                                                                                                                                                                                                                                                                                                                                              (M.match_operator (|
                                                                                                                                                                                                                                                                                                                                                                                                                M.alloc (|
                                                                                                                                                                                                                                                                                                                                                                                                                  Value.Tuple
                                                                                                                                                                                                                                                                                                                                                                                                                    []
                                                                                                                                                                                                                                                                                                                                                                                                                |),
                                                                                                                                                                                                                                                                                                                                                                                                                [
                                                                                                                                                                                                                                                                                                                                                                                                                  fun
                                                                                                                                                                                                                                                                                                                                                                                                                      γ =>
                                                                                                                                                                                                                                                                                                                                                                                                                    ltac:(M.monadic
                                                                                                                                                                                                                                                                                                                                                                                                                      (let
                                                                                                                                                                                                                                                                                                                                                                                                                            γ :=
                                                                                                                                                                                                                                                                                                                                                                                                                        M.use
                                                                                                                                                                                                                                                                                                                                                                                                                          (M.alloc (|
                                                                                                                                                                                                                                                                                                                                                                                                                            BinOp.Pure.eq
                                                                                                                                                                                                                                                                                                                                                                                                                              (M.read (|
                                                                                                                                                                                                                                                                                                                                                                                                                                n
                                                                                                                                                                                                                                                                                                                                                                                                                              |))
                                                                                                                                                                                                                                                                                                                                                                                                                              (M.rust_cast
                                                                                                                                                                                                                                                                                                                                                                                                                                (Value.Integer
                                                                                                                                                                                                                                                                                                                                                                                                                                  48))
                                                                                                                                                                                                                                                                                                                                                                                                                          |)) in
                                                                                                                                                                                                                                                                                                                                                                                                                      let
                                                                                                                                                                                                                                                                                                                                                                                                                            _ :=
                                                                                                                                                                                                                                                                                                                                                                                                                        M.is_constant_or_break_match (|
                                                                                                                                                                                                                                                                                                                                                                                                                          M.read (|
                                                                                                                                                                                                                                                                                                                                                                                                                            γ
                                                                                                                                                                                                                                                                                                                                                                                                                          |),
                                                                                                                                                                                                                                                                                                                                                                                                                          Value.Bool
                                                                                                                                                                                                                                                                                                                                                                                                                            true
                                                                                                                                                                                                                                                                                                                                                                                                                        |) in
                                                                                                                                                                                                                                                                                                                                                                                                                      M.alloc (|
                                                                                                                                                                                                                                                                                                                                                                                                                        Value.StructTuple
                                                                                                                                                                                                                                                                                                                                                                                                                          "core::option::Option::Some"
                                                                                                                                                                                                                                                                                                                                                                                                                          [
                                                                                                                                                                                                                                                                                                                                                                                                                            Value.StructTuple
                                                                                                                                                                                                                                                                                                                                                                                                                              "spl_token_2022::error::TokenError::ExtensionNotFound"
                                                                                                                                                                                                                                                                                                                                                                                                                              []
                                                                                                                                                                                                                                                                                                                                                                                                                          ]
                                                                                                                                                                                                                                                                                                                                                                                                                      |)));
                                                                                                                                                                                                                                                                                                                                                                                                                  fun
                                                                                                                                                                                                                                                                                                                                                                                                                      γ =>
                                                                                                                                                                                                                                                                                                                                                                                                                    ltac:(M.monadic
                                                                                                                                                                                                                                                                                                                                                                                                                      (M.match_operator (|
                                                                                                                                                                                                                                                                                                                                                                                                                        M.alloc (|
                                                                                                                                                                                                                                                                                                                                                                                                                          Value.Tuple
                                                                                                                                                                                                                                                                                                                                                                                                                            []
                                                                                                                                                                                                                                                                                                                                                                                                                        |),
                                                                                                                                                                                                                                                                                                                                                                                                                        [
                                                                                                                                                                                                                                                                                                                                                                                                                          fun
                                                                                                                                                                                                                                                                                                                                                                                                                              γ =>
                                                                                                                                                                                                                                                                                                                                                                                                                            ltac:(M.monadic
                                                                                                                                                                                                                                                                                                                                                                                                                              (let
                                                                                                                                                                                                                                                                                                                                                                                                                                    γ :=
                                                                                                                                                                                                                                                                                                                                                                                                                                M.use
                                                                                                                                                                                                                                                                                                                                                                                                                                  (M.alloc (|
                                                                                                                                                                                                                                                                                                                                                                                                                                    BinOp.Pure.eq
                                                                                                                                                                                                                                                                                                                                                                                                                                      (M.read (|
                                                                                                                                                                                                                                                                                                                                                                                                                                        n
                                                                                                                                                                                                                                                                                                                                                                                                                                      |))
                                                                                                                                                                                                                                                                                                                                                                                                                                      (M.rust_cast
                                                                                                                                                                                                                                                                                                                                                                                                                                        (Value.Integer
                                                                                                                                                                                                                                                                                                                                                                                                                                          49))
                                                                                                                                                                                                                                                                                                                                                                                                                                  |)) in
                                                                                                                                                                                                                                                                                                                                                                                                                              let
                                                                                                                                                                                                                                                                                                                                                                                                                                    _ :=
                                                                                                                                                                                                                                                                                                                                                                                                                                M.is_constant_or_break_match (|
                                                                                                                                                                                                                                                                                                                                                                                                                                  M.read (|
                                                                                                                                                                                                                                                                                                                                                                                                                                    γ
                                                                                                                                                                                                                                                                                                                                                                                                                                  |),
                                                                                                                                                                                                                                                                                                                                                                                                                                  Value.Bool
                                                                                                                                                                                                                                                                                                                                                                                                                                    true
                                                                                                                                                                                                                                                                                                                                                                                                                                |) in
                                                                                                                                                                                                                                                                                                                                                                                                                              M.alloc (|
                                                                                                                                                                                                                                                                                                                                                                                                                                Value.StructTuple
                                                                                                                                                                                                                                                                                                                                                                                                                                  "core::option::Option::Some"
                                                                                                                                                                                                                                                                                                                                                                                                                                  [
                                                                                                                                                                                                                                                                                                                                                                                                                                    Value.StructTuple
                                                                                                                                                                                                                                                                                                                                                                                                                                      "spl_token_2022::error::TokenError::NonConfidentialTransfersDisabled"
                                                                                                                                                                                                                                                                                                                                                                                                                                      []
                                                                                                                                                                                                                                                                                                                                                                                                                                  ]
                                                                                                                                                                                                                                                                                                                                                                                                                              |)));
                                                                                                                                                                                                                                                                                                                                                                                                                          fun
                                                                                                                                                                                                                                                                                                                                                                                                                              γ =>
                                                                                                                                                                                                                                                                                                                                                                                                                            ltac:(M.monadic
                                                                                                                                                                                                                                                                                                                                                                                                                              (M.match_operator (|
                                                                                                                                                                                                                                                                                                                                                                                                                                M.alloc (|
                                                                                                                                                                                                                                                                                                                                                                                                                                  Value.Tuple
                                                                                                                                                                                                                                                                                                                                                                                                                                    []
                                                                                                                                                                                                                                                                                                                                                                                                                                |),
                                                                                                                                                                                                                                                                                                                                                                                                                                [
                                                                                                                                                                                                                                                                                                                                                                                                                                  fun
                                                                                                                                                                                                                                                                                                                                                                                                                                      γ =>
                                                                                                                                                                                                                                                                                                                                                                                                                                    ltac:(M.monadic
                                                                                                                                                                                                                                                                                                                                                                                                                                      (let
                                                                                                                                                                                                                                                                                                                                                                                                                                            γ :=
                                                                                                                                                                                                                                                                                                                                                                                                                                        M.use
                                                                                                                                                                                                                                                                                                                                                                                                                                          (M.alloc (|
                                                                                                                                                                                                                                                                                                                                                                                                                                            BinOp.Pure.eq
                                                                                                                                                                                                                                                                                                                                                                                                                                              (M.read (|
                                                                                                                                                                                                                                                                                                                                                                                                                                                n
                                                                                                                                                                                                                                                                                                                                                                                                                                              |))
                                                                                                                                                                                                                                                                                                                                                                                                                                              (M.rust_cast
                                                                                                                                                                                                                                                                                                                                                                                                                                                (Value.Integer
                                                                                                                                                                                                                                                                                                                                                                                                                                                  50))
                                                                                                                                                                                                                                                                                                                                                                                                                                          |)) in
                                                                                                                                                                                                                                                                                                                                                                                                                                      let
                                                                                                                                                                                                                                                                                                                                                                                                                                            _ :=
                                                                                                                                                                                                                                                                                                                                                                                                                                        M.is_constant_or_break_match (|
                                                                                                                                                                                                                                                                                                                                                                                                                                          M.read (|
                                                                                                                                                                                                                                                                                                                                                                                                                                            γ
                                                                                                                                                                                                                                                                                                                                                                                                                                          |),
                                                                                                                                                                                                                                                                                                                                                                                                                                          Value.Bool
                                                                                                                                                                                                                                                                                                                                                                                                                                            true
                                                                                                                                                                                                                                                                                                                                                                                                                                        |) in
                                                                                                                                                                                                                                                                                                                                                                                                                                      M.alloc (|
                                                                                                                                                                                                                                                                                                                                                                                                                                        Value.StructTuple
                                                                                                                                                                                                                                                                                                                                                                                                                                          "core::option::Option::Some"
                                                                                                                                                                                                                                                                                                                                                                                                                                          [
                                                                                                                                                                                                                                                                                                                                                                                                                                            Value.StructTuple
                                                                                                                                                                                                                                                                                                                                                                                                                                              "spl_token_2022::error::TokenError::ConfidentialTransferFeeAccountHasWithheldFee"
                                                                                                                                                                                                                                                                                                                                                                                                                                              []
                                                                                                                                                                                                                                                                                                                                                                                                                                          ]
                                                                                                                                                                                                                                                                                                                                                                                                                                      |)));
                                                                                                                                                                                                                                                                                                                                                                                                                                  fun
                                                                                                                                                                                                                                                                                                                                                                                                                                      γ =>
                                                                                                                                                                                                                                                                                                                                                                                                                                    ltac:(M.monadic
                                                                                                                                                                                                                                                                                                                                                                                                                                      (M.match_operator (|
                                                                                                                                                                                                                                                                                                                                                                                                                                        M.alloc (|
                                                                                                                                                                                                                                                                                                                                                                                                                                          Value.Tuple
                                                                                                                                                                                                                                                                                                                                                                                                                                            []
                                                                                                                                                                                                                                                                                                                                                                                                                                        |),
                                                                                                                                                                                                                                                                                                                                                                                                                                        [
                                                                                                                                                                                                                                                                                                                                                                                                                                          fun
                                                                                                                                                                                                                                                                                                                                                                                                                                              γ =>
                                                                                                                                                                                                                                                                                                                                                                                                                                            ltac:(M.monadic
                                                                                                                                                                                                                                                                                                                                                                                                                                              (let
                                                                                                                                                                                                                                                                                                                                                                                                                                                    γ :=
                                                                                                                                                                                                                                                                                                                                                                                                                                                M.use
                                                                                                                                                                                                                                                                                                                                                                                                                                                  (M.alloc (|
                                                                                                                                                                                                                                                                                                                                                                                                                                                    BinOp.Pure.eq
                                                                                                                                                                                                                                                                                                                                                                                                                                                      (M.read (|
                                                                                                                                                                                                                                                                                                                                                                                                                                                        n
                                                                                                                                                                                                                                                                                                                                                                                                                                                      |))
                                                                                                                                                                                                                                                                                                                                                                                                                                                      (M.rust_cast
                                                                                                                                                                                                                                                                                                                                                                                                                                                        (Value.Integer
                                                                                                                                                                                                                                                                                                                                                                                                                                                          51))
                                                                                                                                                                                                                                                                                                                                                                                                                                                  |)) in
                                                                                                                                                                                                                                                                                                                                                                                                                                              let
                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ :=
                                                                                                                                                                                                                                                                                                                                                                                                                                                M.is_constant_or_break_match (|
                                                                                                                                                                                                                                                                                                                                                                                                                                                  M.read (|
                                                                                                                                                                                                                                                                                                                                                                                                                                                    γ
                                                                                                                                                                                                                                                                                                                                                                                                                                                  |),
                                                                                                                                                                                                                                                                                                                                                                                                                                                  Value.Bool
                                                                                                                                                                                                                                                                                                                                                                                                                                                    true
                                                                                                                                                                                                                                                                                                                                                                                                                                                |) in
                                                                                                                                                                                                                                                                                                                                                                                                                                              M.alloc (|
                                                                                                                                                                                                                                                                                                                                                                                                                                                Value.StructTuple
                                                                                                                                                                                                                                                                                                                                                                                                                                                  "core::option::Option::Some"
                                                                                                                                                                                                                                                                                                                                                                                                                                                  [
                                                                                                                                                                                                                                                                                                                                                                                                                                                    Value.StructTuple
                                                                                                                                                                                                                                                                                                                                                                                                                                                      "spl_token_2022::error::TokenError::InvalidExtensionCombination"
                                                                                                                                                                                                                                                                                                                                                                                                                                                      []
                                                                                                                                                                                                                                                                                                                                                                                                                                                  ]
                                                                                                                                                                                                                                                                                                                                                                                                                                              |)));
                                                                                                                                                                                                                                                                                                                                                                                                                                          fun
                                                                                                                                                                                                                                                                                                                                                                                                                                              γ =>
                                                                                                                                                                                                                                                                                                                                                                                                                                            ltac:(M.monadic
                                                                                                                                                                                                                                                                                                                                                                                                                                              (M.match_operator (|
                                                                                                                                                                                                                                                                                                                                                                                                                                                M.alloc (|
                                                                                                                                                                                                                                                                                                                                                                                                                                                  Value.Tuple
                                                                                                                                                                                                                                                                                                                                                                                                                                                    []
                                                                                                                                                                                                                                                                                                                                                                                                                                                |),
                                                                                                                                                                                                                                                                                                                                                                                                                                                [
                                                                                                                                                                                                                                                                                                                                                                                                                                                  fun
                                                                                                                                                                                                                                                                                                                                                                                                                                                      γ =>
                                                                                                                                                                                                                                                                                                                                                                                                                                                    ltac:(M.monadic
                                                                                                                                                                                                                                                                                                                                                                                                                                                      (let
                                                                                                                                                                                                                                                                                                                                                                                                                                                            γ :=
                                                                                                                                                                                                                                                                                                                                                                                                                                                        M.use
                                                                                                                                                                                                                                                                                                                                                                                                                                                          (M.alloc (|
                                                                                                                                                                                                                                                                                                                                                                                                                                                            BinOp.Pure.eq
                                                                                                                                                                                                                                                                                                                                                                                                                                                              (M.read (|
                                                                                                                                                                                                                                                                                                                                                                                                                                                                n
                                                                                                                                                                                                                                                                                                                                                                                                                                                              |))
                                                                                                                                                                                                                                                                                                                                                                                                                                                              (M.rust_cast
                                                                                                                                                                                                                                                                                                                                                                                                                                                                (Value.Integer
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  52))
                                                                                                                                                                                                                                                                                                                                                                                                                                                          |)) in
                                                                                                                                                                                                                                                                                                                                                                                                                                                      let
                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ :=
                                                                                                                                                                                                                                                                                                                                                                                                                                                        M.is_constant_or_break_match (|
                                                                                                                                                                                                                                                                                                                                                                                                                                                          M.read (|
                                                                                                                                                                                                                                                                                                                                                                                                                                                            γ
                                                                                                                                                                                                                                                                                                                                                                                                                                                          |),
                                                                                                                                                                                                                                                                                                                                                                                                                                                          Value.Bool
                                                                                                                                                                                                                                                                                                                                                                                                                                                            true
                                                                                                                                                                                                                                                                                                                                                                                                                                                        |) in
                                                                                                                                                                                                                                                                                                                                                                                                                                                      M.alloc (|
                                                                                                                                                                                                                                                                                                                                                                                                                                                        Value.StructTuple
                                                                                                                                                                                                                                                                                                                                                                                                                                                          "core::option::Option::Some"
                                                                                                                                                                                                                                                                                                                                                                                                                                                          [
                                                                                                                                                                                                                                                                                                                                                                                                                                                            Value.StructTuple
                                                                                                                                                                                                                                                                                                                                                                                                                                                              "spl_token_2022::error::TokenError::InvalidLengthForAlloc"
                                                                                                                                                                                                                                                                                                                                                                                                                                                              []
                                                                                                                                                                                                                                                                                                                                                                                                                                                          ]
                                                                                                                                                                                                                                                                                                                                                                                                                                                      |)));
                                                                                                                                                                                                                                                                                                                                                                                                                                                  fun
                                                                                                                                                                                                                                                                                                                                                                                                                                                      γ =>
                                                                                                                                                                                                                                                                                                                                                                                                                                                    ltac:(M.monadic
                                                                                                                                                                                                                                                                                                                                                                                                                                                      (M.match_operator (|
                                                                                                                                                                                                                                                                                                                                                                                                                                                        M.alloc (|
                                                                                                                                                                                                                                                                                                                                                                                                                                                          Value.Tuple
                                                                                                                                                                                                                                                                                                                                                                                                                                                            []
                                                                                                                                                                                                                                                                                                                                                                                                                                                        |),
                                                                                                                                                                                                                                                                                                                                                                                                                                                        [
                                                                                                                                                                                                                                                                                                                                                                                                                                                          fun
                                                                                                                                                                                                                                                                                                                                                                                                                                                              γ =>
                                                                                                                                                                                                                                                                                                                                                                                                                                                            ltac:(M.monadic
                                                                                                                                                                                                                                                                                                                                                                                                                                                              (let
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    γ :=
                                                                                                                                                                                                                                                                                                                                                                                                                                                                M.use
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (M.alloc (|
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    BinOp.Pure.eq
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (M.read (|
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        n
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |))
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (M.rust_cast
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (Value.Integer
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          53))
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |)) in
                                                                                                                                                                                                                                                                                                                                                                                                                                                              let
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ :=
                                                                                                                                                                                                                                                                                                                                                                                                                                                                M.is_constant_or_break_match (|
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  M.read (|
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    γ
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |),
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Value.Bool
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    true
                                                                                                                                                                                                                                                                                                                                                                                                                                                                |) in
                                                                                                                                                                                                                                                                                                                                                                                                                                                              M.alloc (|
                                                                                                                                                                                                                                                                                                                                                                                                                                                                Value.StructTuple
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  "core::option::Option::Some"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  [
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Value.StructTuple
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      "spl_token_2022::error::TokenError::AccountDecryption"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      []
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ]
                                                                                                                                                                                                                                                                                                                                                                                                                                                              |)));
                                                                                                                                                                                                                                                                                                                                                                                                                                                          fun
                                                                                                                                                                                                                                                                                                                                                                                                                                                              γ =>
                                                                                                                                                                                                                                                                                                                                                                                                                                                            ltac:(M.monadic
                                                                                                                                                                                                                                                                                                                                                                                                                                                              (M.match_operator (|
                                                                                                                                                                                                                                                                                                                                                                                                                                                                M.alloc (|
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Value.Tuple
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    []
                                                                                                                                                                                                                                                                                                                                                                                                                                                                |),
                                                                                                                                                                                                                                                                                                                                                                                                                                                                [
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  fun
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      γ =>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ltac:(M.monadic
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (let
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            γ :=
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        M.use
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (M.alloc (|
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            BinOp.Pure.eq
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (M.read (|
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                n
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |))
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (M.rust_cast
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (Value.Integer
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  54))
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |)) in
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      let
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ :=
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        M.is_constant_or_break_match (|
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          M.read (|
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            γ
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |),
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Value.Bool
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            true
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |) in
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      M.alloc (|
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Value.StructTuple
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          "core::option::Option::Some"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          [
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Value.StructTuple
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "spl_token_2022::error::TokenError::ProofGeneration"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              []
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |)));
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  fun
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      γ =>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ltac:(M.monadic
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (M.match_operator (|
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        M.alloc (|
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Value.Tuple
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            []
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |),
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        [
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          fun
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              γ =>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ltac:(M.monadic
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (let
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    γ :=
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                M.use
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (M.alloc (|
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    BinOp.Pure.eq
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (M.read (|
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        n
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |))
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (M.rust_cast
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (Value.Integer
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          55))
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |)) in
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              let
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ :=
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                M.is_constant_or_break_match (|
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  M.read (|
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    γ
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |),
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Value.Bool
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    true
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |) in
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              M.alloc (|
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Value.StructTuple
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  "core::option::Option::Some"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  [
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Value.StructTuple
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      "spl_token_2022::error::TokenError::InvalidProofInstructionOffset"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      []
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |)));
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          fun
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              γ =>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ltac:(M.monadic
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (M.match_operator (|
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                M.alloc (|
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Value.Tuple
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    []
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |),
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                [
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  fun
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      γ =>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ltac:(M.monadic
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (let
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            γ :=
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        M.use
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (M.alloc (|
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            BinOp.Pure.eq
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (M.read (|
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                n
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |))
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (M.rust_cast
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (Value.Integer
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  56))
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |)) in
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      let
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ :=
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        M.is_constant_or_break_match (|
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          M.read (|
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            γ
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |),
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Value.Bool
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            true
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |) in
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      M.alloc (|
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Value.StructTuple
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          "core::option::Option::Some"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          [
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Value.StructTuple
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "spl_token_2022::error::TokenError::HarvestToMintDisabled"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              []
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |)));
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  fun
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      γ =>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ltac:(M.monadic
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (M.match_operator (|
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        M.alloc (|
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Value.Tuple
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            []
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |),
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        [
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          fun
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              γ =>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ltac:(M.monadic
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (let
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    γ :=
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                M.use
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (M.alloc (|
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    BinOp.Pure.eq
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (M.read (|
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        n
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |))
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (M.rust_cast
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (Value.Integer
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          57))
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |)) in
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              let
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ :=
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                M.is_constant_or_break_match (|
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  M.read (|
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    γ
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |),
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Value.Bool
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    true
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |) in
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              M.alloc (|
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Value.StructTuple
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  "core::option::Option::Some"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  [
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Value.StructTuple
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      "spl_token_2022::error::TokenError::SplitProofContextStateAccountsNotSupported"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      []
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |)));
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          fun
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              γ =>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ltac:(M.monadic
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (M.match_operator (|
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                M.alloc (|
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Value.Tuple
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    []
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |),
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                [
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  fun
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      γ =>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ltac:(M.monadic
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (let
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            γ :=
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        M.use
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (M.alloc (|
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            BinOp.Pure.eq
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (M.read (|
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                n
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |))
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (M.rust_cast
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (Value.Integer
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  58))
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |)) in
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      let
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ :=
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        M.is_constant_or_break_match (|
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          M.read (|
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            γ
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |),
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Value.Bool
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            true
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |) in
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      M.alloc (|
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Value.StructTuple
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          "core::option::Option::Some"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          [
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Value.StructTuple
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "spl_token_2022::error::TokenError::NotEnoughProofContextStateAccounts"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              []
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |)));
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  fun
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      γ =>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ltac:(M.monadic
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (M.match_operator (|
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        M.alloc (|
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Value.Tuple
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            []
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |),
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        [
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          fun
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              γ =>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ltac:(M.monadic
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (let
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    γ :=
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                M.use
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (M.alloc (|
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    BinOp.Pure.eq
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (M.read (|
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        n
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |))
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (M.rust_cast
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (Value.Integer
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          59))
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |)) in
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              let
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ :=
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                M.is_constant_or_break_match (|
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  M.read (|
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    γ
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |),
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Value.Bool
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    true
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |) in
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              M.alloc (|
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Value.StructTuple
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  "core::option::Option::Some"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  [
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Value.StructTuple
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      "spl_token_2022::error::TokenError::MalformedCiphertext"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      []
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |)));
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          fun
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              γ =>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ltac:(M.monadic
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (M.match_operator (|
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                M.alloc (|
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Value.Tuple
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    []
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |),
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                [
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  fun
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      γ =>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ltac:(M.monadic
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (let
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            γ :=
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        M.use
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (M.alloc (|
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            BinOp.Pure.eq
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (M.read (|
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                n
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |))
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (M.rust_cast
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (Value.Integer
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  60))
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |)) in
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      let
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ :=
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        M.is_constant_or_break_match (|
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          M.read (|
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            γ
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |),
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Value.Bool
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            true
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |) in
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      M.alloc (|
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Value.StructTuple
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          "core::option::Option::Some"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          [
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Value.StructTuple
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "spl_token_2022::error::TokenError::CiphertextArithmeticFailed"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              []
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |)));
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  fun
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      γ =>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ltac:(M.monadic
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (M.alloc (|
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Value.StructTuple
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          "core::option::Option::None"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          []
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |)))
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |)))
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |)))
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |)))
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |)))
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |)))
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |)))
                                                                                                                                                                                                                                                                                                                                                                                                                                                                ]
                                                                                                                                                                                                                                                                                                                                                                                                                                                              |)))
                                                                                                                                                                                                                                                                                                                                                                                                                                                        ]
                                                                                                                                                                                                                                                                                                                                                                                                                                                      |)))
                                                                                                                                                                                                                                                                                                                                                                                                                                                ]
                                                                                                                                                                                                                                                                                                                                                                                                                                              |)))
                                                                                                                                                                                                                                                                                                                                                                                                                                        ]
                                                                                                                                                                                                                                                                                                                                                                                                                                      |)))
                                                                                                                                                                                                                                                                                                                                                                                                                                ]
                                                                                                                                                                                                                                                                                                                                                                                                                              |)))
                                                                                                                                                                                                                                                                                                                                                                                                                        ]
                                                                                                                                                                                                                                                                                                                                                                                                                      |)))
                                                                                                                                                                                                                                                                                                                                                                                                                ]
                                                                                                                                                                                                                                                                                                                                                                                                              |)))
                                                                                                                                                                                                                                                                                                                                                                                                        ]
                                                                                                                                                                                                                                                                                                                                                                                                      |)))
                                                                                                                                                                                                                                                                                                                                                                                                ]
                                                                                                                                                                                                                                                                                                                                                                                              |)))
                                                                                                                                                                                                                                                                                                                                                                                        ]
                                                                                                                                                                                                                                                                                                                                                                                      |)))
                                                                                                                                                                                                                                                                                                                                                                                ]
                                                                                                                                                                                                                                                                                                                                                                              |)))
                                                                                                                                                                                                                                                                                                                                                                        ]
                                                                                                                                                                                                                                                                                                                                                                      |)))
                                                                                                                                                                                                                                                                                                                                                                ]
                                                                                                                                                                                                                                                                                                                                                              |)))
                                                                                                                                                                                                                                                                                                                                                        ]
                                                                                                                                                                                                                                                                                                                                                      |)))
                                                                                                                                                                                                                                                                                                                                                ]
                                                                                                                                                                                                                                                                                                                                              |)))
                                                                                                                                                                                                                                                                                                                                        ]
                                                                                                                                                                                                                                                                                                                                      |)))
                                                                                                                                                                                                                                                                                                                                ]
                                                                                                                                                                                                                                                                                                                              |)))
                                                                                                                                                                                                                                                                                                                        ]
                                                                                                                                                                                                                                                                                                                      |)))
                                                                                                                                                                                                                                                                                                                ]
                                                                                                                                                                                                                                                                                                              |)))
                                                                                                                                                                                                                                                                                                        ]
                                                                                                                                                                                                                                                                                                      |)))
                                                                                                                                                                                                                                                                                                ]
                                                                                                                                                                                                                                                                                              |)))
                                                                                                                                                                                                                                                                                        ]
                                                                                                                                                                                                                                                                                      |)))
                                                                                                                                                                                                                                                                                ]
                                                                                                                                                                                                                                                                              |)))
                                                                                                                                                                                                                                                                        ]
                                                                                                                                                                                                                                                                      |)))
                                                                                                                                                                                                                                                                ]
                                                                                                                                                                                                                                                              |)))
                                                                                                                                                                                                                                                        ]
                                                                                                                                                                                                                                                      |)))
                                                                                                                                                                                                                                                ]
                                                                                                                                                                                                                                              |)))
                                                                                                                                                                                                                                        ]
                                                                                                                                                                                                                                      |)))
                                                                                                                                                                                                                                ]
                                                                                                                                                                                                                              |)))
                                                                                                                                                                                                                        ]
                                                                                                                                                                                                                      |)))
                                                                                                                                                                                                                ]
                                                                                                                                                                                                              |)))
                                                                                                                                                                                                        ]
                                                                                                                                                                                                      |)))
                                                                                                                                                                                                ]
                                                                                                                                                                                              |)))
                                                                                                                                                                                        ]
                                                                                                                                                                                      |)))
                                                                                                                                                                                ]
                                                                                                                                                                              |)))
                                                                                                                                                                        ]
                                                                                                                                                                      |)))
                                                                                                                                                                ]
                                                                                                                                                              |)))
                                                                                                                                                        ]
                                                                                                                                                      |)))
                                                                                                                                                ]
                                                                                                                                              |)))
                                                                                                                                        ]
                                                                                                                                      |)))
                                                                                                                                ]
                                                                                                                              |)))
                                                                                                                        ]
                                                                                                                      |)))
                                                                                                                ]
                                                                                                              |)))
                                                                                                        ]
                                                                                                      |)))
                                                                                                ]
                                                                                              |)))
                                                                                        ]
                                                                                      |)))
                                                                                ]
                                                                              |)))
                                                                        ]
                                                                      |)))
                                                                ]
                                                              |)))
                                                        ]
                                                      |)))
                                                ]
                                              |)))
                                        ]
                                      |)))
                                ]
                              |)))
                        ]
                      |)))
                ]
              |)
            |)))
        | _, _ => M.impossible
        end.
      
      (* FromPrimitive *)
      Definition from_u64 (τ : list Ty.t) (α : list Value.t) : M :=
        match τ, α with
        | [], [ n ] =>
          ltac:(M.monadic
            (let n := M.alloc (| n |) in
            M.call_closure (|
              M.get_trait_method (|
                "num_traits::cast::FromPrimitive",
                Ty.path "spl_token_2022::error::TokenError",
                [],
                "from_i64",
                []
              |),
              [ M.rust_cast (M.read (| n |)) ]
            |)))
        | _, _ => M.impossible
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "num_traits::cast::FromPrimitive"
          Self
          (* Trait polymorphic types *) []
          (* Instance *)
          [ ("from_i64", InstanceField.Method from_i64); ("from_u64", InstanceField.Method from_u64)
          ].
    End Impl_num_traits_cast_FromPrimitive_for_spl_token_2022_error_TokenError.
  End underscore.
  
  Module Impl_core_marker_StructuralPartialEq_for_spl_token_2022_error_TokenError.
    Definition Self : Ty.t := Ty.path "spl_token_2022::error::TokenError".
    
    Axiom Implements :
      M.IsTraitInstance
        "core::marker::StructuralPartialEq"
        Self
        (* Trait polymorphic types *) []
        (* Instance *) [].
  End Impl_core_marker_StructuralPartialEq_for_spl_token_2022_error_TokenError.
  
  Module Impl_core_cmp_PartialEq_for_spl_token_2022_error_TokenError.
    Definition Self : Ty.t := Ty.path "spl_token_2022::error::TokenError".
    
    (* PartialEq *)
    Definition eq (τ : list Ty.t) (α : list Value.t) : M :=
      match τ, α with
      | [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          M.read (|
            let __self_tag :=
              M.alloc (|
                M.call_closure (|
                  M.get_function (|
                    "core::intrinsics::discriminant_value",
                    [ Ty.path "spl_token_2022::error::TokenError" ]
                  |),
                  [ M.read (| self |) ]
                |)
              |) in
            let __arg1_tag :=
              M.alloc (|
                M.call_closure (|
                  M.get_function (|
                    "core::intrinsics::discriminant_value",
                    [ Ty.path "spl_token_2022::error::TokenError" ]
                  |),
                  [ M.read (| other |) ]
                |)
              |) in
            M.alloc (| BinOp.Pure.eq (M.read (| __self_tag |)) (M.read (| __arg1_tag |)) |)
          |)))
      | _, _ => M.impossible
      end.
    
    Axiom Implements :
      M.IsTraitInstance
        "core::cmp::PartialEq"
        Self
        (* Trait polymorphic types *) []
        (* Instance *) [ ("eq", InstanceField.Method eq) ].
  End Impl_core_cmp_PartialEq_for_spl_token_2022_error_TokenError.
  
  Module Impl_core_convert_From_spl_token_2022_error_TokenError_for_solana_program_program_error_ProgramError.
    Definition Self : Ty.t := Ty.path "solana_program::program_error::ProgramError".
    
    (*
        fn from(e: TokenError) -> Self {
            ProgramError::Custom(e as u32)
        }
    *)
    Definition from (τ : list Ty.t) (α : list Value.t) : M :=
      match τ, α with
      | [], [ e ] =>
        ltac:(M.monadic
          (let e := M.alloc (| e |) in
          Value.StructTuple
            "solana_program::program_error::ProgramError::Custom"
            [ M.rust_cast (M.read (| e |)) ]))
      | _, _ => M.impossible
      end.
    
    Axiom Implements :
      M.IsTraitInstance
        "core::convert::From"
        Self
        (* Trait polymorphic types *) [ (* T *) Ty.path "spl_token_2022::error::TokenError" ]
        (* Instance *) [ ("from", InstanceField.Method from) ].
  End Impl_core_convert_From_spl_token_2022_error_TokenError_for_solana_program_program_error_ProgramError.
  
  Module Impl_solana_program_decode_error_DecodeError_T_for_spl_token_2022_error_TokenError.
    Definition Self (T : Ty.t) : Ty.t := Ty.path "spl_token_2022::error::TokenError".
    
    (*
        fn type_of() -> &'static str {
            "TokenError"
        }
    *)
    Definition type_of (T : Ty.t) (τ : list Ty.t) (α : list Value.t) : M :=
      let Self : Ty.t := Self T in
      match τ, α with
      | [], [] => ltac:(M.monadic (M.read (| Value.String "TokenError" |)))
      | _, _ => M.impossible
      end.
    
    Axiom Implements :
      forall (T : Ty.t),
      M.IsTraitInstance
        "solana_program::decode_error::DecodeError"
        (Self T)
        (* Trait polymorphic types *) [ (* E *) T ]
        (* Instance *) [ ("type_of", InstanceField.Method (type_of T)) ].
  End Impl_solana_program_decode_error_DecodeError_T_for_spl_token_2022_error_TokenError.
  
  Module Impl_solana_program_program_error_PrintProgramError_for_spl_token_2022_error_TokenError.
    Definition Self : Ty.t := Ty.path "spl_token_2022::error::TokenError".
    
    (*
        fn print<E>(&self)
        where
            E: 'static + std::error::Error + DecodeError<E> + num_traits::FromPrimitive,
        {
            match self {
                TokenError::NotRentExempt => msg!("Error: Lamport balance below rent-exempt threshold"),
                TokenError::InsufficientFunds => msg!("Error: insufficient funds"),
                TokenError::InvalidMint => msg!("Error: Invalid Mint"),
                TokenError::MintMismatch => msg!("Error: Account not associated with this Mint"),
                TokenError::OwnerMismatch => msg!("Error: owner does not match"),
                TokenError::FixedSupply => msg!("Error: the total supply of this token is fixed"),
                TokenError::AlreadyInUse => msg!("Error: account or token already in use"),
                TokenError::InvalidNumberOfProvidedSigners => {
                    msg!("Error: Invalid number of provided signers")
                }
                TokenError::InvalidNumberOfRequiredSigners => {
                    msg!("Error: Invalid number of required signers")
                }
                TokenError::UninitializedState => msg!("Error: State is uninitialized"),
                TokenError::NativeNotSupported => {
                    msg!("Error: Instruction does not support native tokens")
                }
                TokenError::NonNativeHasBalance => {
                    msg!("Error: Non-native account can only be closed if its balance is zero")
                }
                TokenError::InvalidInstruction => msg!("Error: Invalid instruction"),
                TokenError::InvalidState => msg!("Error: Invalid account state for operation"),
                TokenError::Overflow => msg!("Error: Operation overflowed"),
                TokenError::AuthorityTypeNotSupported => {
                    msg!("Error: Account does not support specified authority type")
                }
                TokenError::MintCannotFreeze => msg!("Error: This token mint cannot freeze accounts"),
                TokenError::AccountFrozen => msg!("Error: Account is frozen"),
                TokenError::MintDecimalsMismatch => {
                    msg!("Error: decimals different from the Mint decimals")
                }
                TokenError::NonNativeNotSupported => {
                    msg!("Error: Instruction does not support non-native tokens")
                }
                TokenError::ExtensionTypeMismatch => {
                    msg!("Error: New extension type does not match already existing extensions")
                }
                TokenError::ExtensionBaseMismatch => {
                    msg!("Error: Extension does not match the base type provided")
                }
                TokenError::ExtensionAlreadyInitialized => {
                    msg!("Error: Extension already initialized on this account")
                }
                TokenError::ConfidentialTransferAccountHasBalance => {
                    msg!("Error: An account can only be closed if its confidential balance is zero")
                }
                TokenError::ConfidentialTransferAccountNotApproved => {
                    msg!("Error: Account not approved for confidential transfers")
                }
                TokenError::ConfidentialTransferDepositsAndTransfersDisabled => {
                    msg!("Error: Account not accepting deposits or transfers")
                }
                TokenError::ConfidentialTransferElGamalPubkeyMismatch => {
                    msg!("Error: ElGamal public key mismatch")
                }
                TokenError::ConfidentialTransferBalanceMismatch => {
                    msg!("Error: Balance mismatch")
                }
                TokenError::MintHasSupply => {
                    msg!("Error: Mint has non-zero supply. Burn all tokens before closing the mint")
                }
                TokenError::NoAuthorityExists => {
                    msg!("Error: No authority exists to perform the desired operation");
                }
                TokenError::TransferFeeExceedsMaximum => {
                    msg!("Error: Transfer fee exceeds maximum of 10,000 basis points");
                }
                TokenError::MintRequiredForTransfer => {
                    msg!("Mint required for this account to transfer tokens, use `transfer_checked` or `transfer_checked_with_fee`");
                }
                TokenError::FeeMismatch => {
                    msg!("Calculated fee does not match expected fee");
                }
                TokenError::FeeParametersMismatch => {
                    msg!("Fee parameters associated with zero-knowledge proofs do not match fee parameters in mint")
                }
                TokenError::ImmutableOwner => {
                    msg!("The owner authority cannot be changed");
                }
                TokenError::AccountHasWithheldTransferFees => {
                    msg!("Error: An account can only be closed if its withheld fee balance is zero, harvest fees to the mint and try again");
                }
                TokenError::NoMemo => {
                    msg!("Error: No memo in previous instruction; required for recipient to receive a transfer");
                }
                TokenError::NonTransferable => {
                    msg!("Transfer is disabled for this mint");
                }
                TokenError::NonTransferableNeedsImmutableOwnership => {
                    msg!("Non-transferable tokens can't be minted to an account without immutable ownership");
                }
                TokenError::MaximumPendingBalanceCreditCounterExceeded => {
                    msg!("The total number of `Deposit` and `Transfer` instructions to an account cannot exceed the associated `maximum_pending_balance_credit_counter`");
                }
                TokenError::MaximumDepositAmountExceeded => {
                    msg!("Deposit amount exceeds maximum limit")
                }
                TokenError::CpiGuardSettingsLocked => {
                    msg!("CPI Guard status cannot be changed in CPI")
                }
                TokenError::CpiGuardTransferBlocked => {
                    msg!("CPI Guard is enabled, and a program attempted to transfer user funds without using a delegate")
                }
                TokenError::CpiGuardBurnBlocked => {
                    msg!("CPI Guard is enabled, and a program attempted to burn user funds without using a delegate")
                }
                TokenError::CpiGuardCloseAccountBlocked => {
                    msg!("CPI Guard is enabled, and a program attempted to close an account without returning lamports to owner")
                }
                TokenError::CpiGuardApproveBlocked => {
                    msg!("CPI Guard is enabled, and a program attempted to approve a delegate")
                }
                TokenError::CpiGuardSetAuthorityBlocked => {
                    msg!("CPI Guard is enabled, and a program attempted to add or change an authority")
                }
                TokenError::CpiGuardOwnerChangeBlocked => {
                    msg!("Account ownership cannot be changed while CPI Guard is enabled")
                }
                TokenError::ExtensionNotFound => {
                    msg!("Extension not found in account data")
                }
                TokenError::NonConfidentialTransfersDisabled => {
                    msg!("Non-confidential transfers disabled")
                }
                TokenError::ConfidentialTransferFeeAccountHasWithheldFee => {
                    msg!("Account has non-zero confidential withheld fee")
                }
                TokenError::InvalidExtensionCombination => {
                    msg!("Mint or account is initialized to an invalid combination of extensions")
                }
                TokenError::InvalidLengthForAlloc => {
                    msg!("Extension allocation with overwrite must use the same length")
                }
                TokenError::AccountDecryption => {
                    msg!("Failed to decrypt a confidential transfer account")
                }
                TokenError::ProofGeneration => {
                    msg!("Failed to generate proof")
                }
                TokenError::InvalidProofInstructionOffset => {
                    msg!("An invalid proof instruction offset was provided")
                }
                TokenError::HarvestToMintDisabled => {
                    msg!("Harvest of withheld tokens to mint is disabled")
                }
                TokenError::SplitProofContextStateAccountsNotSupported => {
                    msg!("Split proof context state accounts not supported for instruction")
                }
                TokenError::NotEnoughProofContextStateAccounts => {
                    msg!("Not enough proof context state accounts provided")
                }
                TokenError::MalformedCiphertext => {
                    msg!("Ciphertext is malformed")
                }
                TokenError::CiphertextArithmeticFailed => {
                    msg!("Ciphertext arithmetic failed")
                }
            }
        }
    *)
    Definition print (τ : list Ty.t) (α : list Value.t) : M :=
      match τ, α with
      | [ E ], [ self ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          M.read (|
            M.match_operator (|
              self,
              [
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_function (| "solana_program::log::sol_log", [] |),
                        [
                          M.read (|
                            Value.String "Error: Lamport balance below rent-exempt threshold"
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_function (| "solana_program::log::sol_log", [] |),
                        [ M.read (| Value.String "Error: insufficient funds" |) ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_function (| "solana_program::log::sol_log", [] |),
                        [ M.read (| Value.String "Error: Invalid Mint" |) ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_function (| "solana_program::log::sol_log", [] |),
                        [ M.read (| Value.String "Error: Account not associated with this Mint" |) ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_function (| "solana_program::log::sol_log", [] |),
                        [ M.read (| Value.String "Error: owner does not match" |) ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_function (| "solana_program::log::sol_log", [] |),
                        [ M.read (| Value.String "Error: the total supply of this token is fixed" |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_function (| "solana_program::log::sol_log", [] |),
                        [ M.read (| Value.String "Error: account or token already in use" |) ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_function (| "solana_program::log::sol_log", [] |),
                        [ M.read (| Value.String "Error: Invalid number of provided signers" |) ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_function (| "solana_program::log::sol_log", [] |),
                        [ M.read (| Value.String "Error: Invalid number of required signers" |) ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_function (| "solana_program::log::sol_log", [] |),
                        [ M.read (| Value.String "Error: State is uninitialized" |) ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_function (| "solana_program::log::sol_log", [] |),
                        [
                          M.read (|
                            Value.String "Error: Instruction does not support native tokens"
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_function (| "solana_program::log::sol_log", [] |),
                        [
                          M.read (|
                            Value.String
                              "Error: Non-native account can only be closed if its balance is zero"
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_function (| "solana_program::log::sol_log", [] |),
                        [ M.read (| Value.String "Error: Invalid instruction" |) ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_function (| "solana_program::log::sol_log", [] |),
                        [ M.read (| Value.String "Error: Invalid account state for operation" |) ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_function (| "solana_program::log::sol_log", [] |),
                        [ M.read (| Value.String "Error: Operation overflowed" |) ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_function (| "solana_program::log::sol_log", [] |),
                        [
                          M.read (|
                            Value.String "Error: Account does not support specified authority type"
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_function (| "solana_program::log::sol_log", [] |),
                        [ M.read (| Value.String "Error: This token mint cannot freeze accounts" |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_function (| "solana_program::log::sol_log", [] |),
                        [ M.read (| Value.String "Error: Account is frozen" |) ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_function (| "solana_program::log::sol_log", [] |),
                        [
                          M.read (|
                            Value.String "Error: decimals different from the Mint decimals"
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_function (| "solana_program::log::sol_log", [] |),
                        [
                          M.read (|
                            Value.String "Error: Instruction does not support non-native tokens"
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_function (| "solana_program::log::sol_log", [] |),
                        [
                          M.read (|
                            Value.String
                              "Error: New extension type does not match already existing extensions"
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_function (| "solana_program::log::sol_log", [] |),
                        [
                          M.read (|
                            Value.String "Error: Extension does not match the base type provided"
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_function (| "solana_program::log::sol_log", [] |),
                        [
                          M.read (|
                            Value.String "Error: Extension already initialized on this account"
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_function (| "solana_program::log::sol_log", [] |),
                        [
                          M.read (|
                            Value.String
                              "Error: An account can only be closed if its confidential balance is zero"
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_function (| "solana_program::log::sol_log", [] |),
                        [
                          M.read (|
                            Value.String "Error: Account not approved for confidential transfers"
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_function (| "solana_program::log::sol_log", [] |),
                        [
                          M.read (|
                            Value.String "Error: Account not accepting deposits or transfers"
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_function (| "solana_program::log::sol_log", [] |),
                        [ M.read (| Value.String "Error: ElGamal public key mismatch" |) ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_function (| "solana_program::log::sol_log", [] |),
                        [ M.read (| Value.String "Error: Balance mismatch" |) ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_function (| "solana_program::log::sol_log", [] |),
                        [
                          M.read (|
                            Value.String
                              "Error: Mint has non-zero supply. Burn all tokens before closing the mint"
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.alloc (|
                        M.call_closure (|
                          M.get_function (| "solana_program::log::sol_log", [] |),
                          [
                            M.read (|
                              Value.String
                                "Error: No authority exists to perform the desired operation"
                            |)
                          ]
                        |)
                      |) in
                    M.alloc (| Value.Tuple [] |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.alloc (|
                        M.call_closure (|
                          M.get_function (| "solana_program::log::sol_log", [] |),
                          [
                            M.read (|
                              Value.String
                                "Error: Transfer fee exceeds maximum of 10,000 basis points"
                            |)
                          ]
                        |)
                      |) in
                    M.alloc (| Value.Tuple [] |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.alloc (|
                        M.call_closure (|
                          M.get_function (| "solana_program::log::sol_log", [] |),
                          [
                            M.read (|
                              Value.String
                                "Mint required for this account to transfer tokens, use `transfer_checked` or `transfer_checked_with_fee`"
                            |)
                          ]
                        |)
                      |) in
                    M.alloc (| Value.Tuple [] |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.alloc (|
                        M.call_closure (|
                          M.get_function (| "solana_program::log::sol_log", [] |),
                          [ M.read (| Value.String "Calculated fee does not match expected fee" |) ]
                        |)
                      |) in
                    M.alloc (| Value.Tuple [] |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_function (| "solana_program::log::sol_log", [] |),
                        [
                          M.read (|
                            Value.String
                              "Fee parameters associated with zero-knowledge proofs do not match fee parameters in mint"
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.alloc (|
                        M.call_closure (|
                          M.get_function (| "solana_program::log::sol_log", [] |),
                          [ M.read (| Value.String "The owner authority cannot be changed" |) ]
                        |)
                      |) in
                    M.alloc (| Value.Tuple [] |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.alloc (|
                        M.call_closure (|
                          M.get_function (| "solana_program::log::sol_log", [] |),
                          [
                            M.read (|
                              Value.String
                                "Error: An account can only be closed if its withheld fee balance is zero, harvest fees to the mint and try again"
                            |)
                          ]
                        |)
                      |) in
                    M.alloc (| Value.Tuple [] |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.alloc (|
                        M.call_closure (|
                          M.get_function (| "solana_program::log::sol_log", [] |),
                          [
                            M.read (|
                              Value.String
                                "Error: No memo in previous instruction; required for recipient to receive a transfer"
                            |)
                          ]
                        |)
                      |) in
                    M.alloc (| Value.Tuple [] |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.alloc (|
                        M.call_closure (|
                          M.get_function (| "solana_program::log::sol_log", [] |),
                          [ M.read (| Value.String "Transfer is disabled for this mint" |) ]
                        |)
                      |) in
                    M.alloc (| Value.Tuple [] |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.alloc (|
                        M.call_closure (|
                          M.get_function (| "solana_program::log::sol_log", [] |),
                          [
                            M.read (|
                              Value.String
                                "Non-transferable tokens can't be minted to an account without immutable ownership"
                            |)
                          ]
                        |)
                      |) in
                    M.alloc (| Value.Tuple [] |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.alloc (|
                        M.call_closure (|
                          M.get_function (| "solana_program::log::sol_log", [] |),
                          [
                            M.read (|
                              Value.String
                                "The total number of `Deposit` and `Transfer` instructions to an account cannot exceed the associated `maximum_pending_balance_credit_counter`"
                            |)
                          ]
                        |)
                      |) in
                    M.alloc (| Value.Tuple [] |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_function (| "solana_program::log::sol_log", [] |),
                        [ M.read (| Value.String "Deposit amount exceeds maximum limit" |) ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_function (| "solana_program::log::sol_log", [] |),
                        [ M.read (| Value.String "CPI Guard status cannot be changed in CPI" |) ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_function (| "solana_program::log::sol_log", [] |),
                        [
                          M.read (|
                            Value.String
                              "CPI Guard is enabled, and a program attempted to transfer user funds without using a delegate"
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_function (| "solana_program::log::sol_log", [] |),
                        [
                          M.read (|
                            Value.String
                              "CPI Guard is enabled, and a program attempted to burn user funds without using a delegate"
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_function (| "solana_program::log::sol_log", [] |),
                        [
                          M.read (|
                            Value.String
                              "CPI Guard is enabled, and a program attempted to close an account without returning lamports to owner"
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_function (| "solana_program::log::sol_log", [] |),
                        [
                          M.read (|
                            Value.String
                              "CPI Guard is enabled, and a program attempted to approve a delegate"
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_function (| "solana_program::log::sol_log", [] |),
                        [
                          M.read (|
                            Value.String
                              "CPI Guard is enabled, and a program attempted to add or change an authority"
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_function (| "solana_program::log::sol_log", [] |),
                        [
                          M.read (|
                            Value.String
                              "Account ownership cannot be changed while CPI Guard is enabled"
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_function (| "solana_program::log::sol_log", [] |),
                        [ M.read (| Value.String "Extension not found in account data" |) ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_function (| "solana_program::log::sol_log", [] |),
                        [ M.read (| Value.String "Non-confidential transfers disabled" |) ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_function (| "solana_program::log::sol_log", [] |),
                        [ M.read (| Value.String "Account has non-zero confidential withheld fee" |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_function (| "solana_program::log::sol_log", [] |),
                        [
                          M.read (|
                            Value.String
                              "Mint or account is initialized to an invalid combination of extensions"
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_function (| "solana_program::log::sol_log", [] |),
                        [
                          M.read (|
                            Value.String
                              "Extension allocation with overwrite must use the same length"
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_function (| "solana_program::log::sol_log", [] |),
                        [
                          M.read (|
                            Value.String "Failed to decrypt a confidential transfer account"
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_function (| "solana_program::log::sol_log", [] |),
                        [ M.read (| Value.String "Failed to generate proof" |) ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_function (| "solana_program::log::sol_log", [] |),
                        [
                          M.read (|
                            Value.String "An invalid proof instruction offset was provided"
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_function (| "solana_program::log::sol_log", [] |),
                        [ M.read (| Value.String "Harvest of withheld tokens to mint is disabled" |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_function (| "solana_program::log::sol_log", [] |),
                        [
                          M.read (|
                            Value.String
                              "Split proof context state accounts not supported for instruction"
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_function (| "solana_program::log::sol_log", [] |),
                        [
                          M.read (|
                            Value.String "Not enough proof context state accounts provided"
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_function (| "solana_program::log::sol_log", [] |),
                        [ M.read (| Value.String "Ciphertext is malformed" |) ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_function (| "solana_program::log::sol_log", [] |),
                        [ M.read (| Value.String "Ciphertext arithmetic failed" |) ]
                      |)
                    |)))
              ]
            |)
          |)))
      | _, _ => M.impossible
      end.
    
    Axiom Implements :
      M.IsTraitInstance
        "solana_program::program_error::PrintProgramError"
        Self
        (* Trait polymorphic types *) []
        (* Instance *) [ ("print", InstanceField.Method print) ].
  End Impl_solana_program_program_error_PrintProgramError_for_spl_token_2022_error_TokenError.
End error.
