From 9480c10ecf8baf362ef297e6830846ea7cac477f Mon Sep 17 00:00:00 2001 From: Christopher Di Bella Date: Mon, 27 Apr 2026 18:00:21 -0700 Subject: [PATCH] teaches arithmetic interfaces about C++ operators (#7123) --- toolchain/check/cpp/impl_lookup.cpp | 98 + toolchain/check/cpp/operators.cpp | 123 +- toolchain/check/cpp/operators.h | 10 + toolchain/check/custom_witness.cpp | 58 + toolchain/check/custom_witness.h | 3 + toolchain/check/function.cpp | 4 + toolchain/check/handle_interface.cpp | 14 + .../cpp/operators/arithmetic_operators.carbon | 3845 +++++++++++++++++ .../interop/cpp/operators/operators.carbon | 29 - toolchain/check/thunk.cpp | 8 +- toolchain/sem_ir/core_interface_kind.def | 13 + 11 files changed, 4160 insertions(+), 45 deletions(-) create mode 100644 toolchain/check/testdata/interop/cpp/operators/arithmetic_operators.carbon diff --git a/toolchain/check/cpp/impl_lookup.cpp b/toolchain/check/cpp/impl_lookup.cpp index f319bb1c184e..7da70ba8b03b 100644 --- a/toolchain/check/cpp/impl_lookup.cpp +++ b/toolchain/check/cpp/impl_lookup.cpp @@ -6,8 +6,10 @@ #include "clang/Sema/Sema.h" #include "toolchain/base/kind_switch.h" +#include "toolchain/check/core_identifier.h" #include "toolchain/check/cpp/import.h" #include "toolchain/check/cpp/location.h" +#include "toolchain/check/cpp/operators.h" #include "toolchain/check/cpp/overload_resolution.h" #include "toolchain/check/custom_witness.h" #include "toolchain/check/impl.h" @@ -231,6 +233,74 @@ static auto BuildDestroyWitness( query_specific_interface_id, {fn_id}); } +// Attempts to build a witness table entry for a C++ unary operator. +static auto BuildCppUnaryOperatorWitness( + Context& context, SemIR::LocId loc_id, SemIR::CoreInterface core_interface, + bool has_associated_result_type, SemIR::ConstantId query_self_const_id, + SemIR::SpecificInterfaceId query_specific_interface_id) -> SemIR::InstId { + auto self_type_id = + context.types().GetTypeIdForTypeConstantId(query_self_const_id); + auto fn_id = LookupCppOperator( + context, loc_id, {.interface_name = AsCoreIdentifier(core_interface)}, + {self_type_id}); + if (fn_id == SemIR::ErrorInst::InstId || fn_id == SemIR::InstId::None) { + return fn_id; + } + + if (has_associated_result_type) { + auto result_type_id = + context.functions() + .Get(context.insts().GetAs(fn_id).function_id) + .return_type_inst_id; + if (result_type_id == SemIR::ErrorInst::InstId) { + return SemIR::ErrorInst::InstId; + } + + return BuildCustomWitness(context, loc_id, query_self_const_id, + query_specific_interface_id, + {result_type_id, fn_id}); + } + return BuildCustomWitness(context, loc_id, query_self_const_id, + query_specific_interface_id, {fn_id}); +} + +// Attempts to build a witness table entry for a C++ binary operator. +static auto BuildCppBinaryOperatorWitness( + Context& context, SemIR::LocId loc_id, SemIR::CoreInterface core_interface, + bool has_associated_result_type, SemIR::ConstantId query_self_const_id, + SemIR::SpecificInterfaceId query_specific_interface_id) -> SemIR::InstId { + auto self_type_id = + context.types().GetTypeIdForTypeConstantId(query_self_const_id); + auto args = + context.inst_blocks().Get(context.specifics() + .Get(context.specific_interfaces() + .Get(query_specific_interface_id) + .specific_id) + .args_id); + CARBON_CHECK(args.size() == 1, "Binary operator missing an argument"); + auto arg_type_id = context.types().GetTypeIdForTypeInstId(args.front()); + auto fn_id = LookupCppOperator( + context, loc_id, {.interface_name = AsCoreIdentifier(core_interface)}, + {self_type_id, arg_type_id}); + if (fn_id == SemIR::ErrorInst::InstId || fn_id == SemIR::InstId::None) { + return fn_id; + } + if (has_associated_result_type) { + auto result_type_id = + context.functions() + .Get(context.insts().GetAs(fn_id).function_id) + .return_type_inst_id; + if (result_type_id == SemIR::ErrorInst::InstId) { + return SemIR::ErrorInst::InstId; + } + return BuildCustomWitness(context, loc_id, query_self_const_id, + query_specific_interface_id, + {result_type_id, fn_id}); + } + return BuildCustomWitness(context, loc_id, query_self_const_id, + query_specific_interface_id, {fn_id}); +} + auto LookupCppImpl(Context& context, SemIR::LocId loc_id, SemIR::CoreInterface core_interface, SemIR::ConstantId query_self_const_id, @@ -243,6 +313,34 @@ auto LookupCppImpl(Context& context, SemIR::LocId loc_id, static_cast(best_impl_loc_id); switch (core_interface) { + case SemIR::CoreInterface::Inc: + case SemIR::CoreInterface::Dec: + return BuildCppUnaryOperatorWitness(context, loc_id, core_interface, + /*has_associated_result_type=*/false, + query_self_const_id, + query_specific_interface_id); + case SemIR::CoreInterface::Negate: + return BuildCppUnaryOperatorWitness( + context, loc_id, core_interface, /*has_associated_result_type=*/true, + query_self_const_id, query_specific_interface_id); + case SemIR::CoreInterface::AddWith: + case SemIR::CoreInterface::SubWith: + case SemIR::CoreInterface::MulWith: + case SemIR::CoreInterface::DivWith: + case SemIR::CoreInterface::ModWith: + return BuildCppBinaryOperatorWitness(context, loc_id, core_interface, + /*has_associated_result_type=*/true, + query_self_const_id, + query_specific_interface_id); + case SemIR::CoreInterface::AddAssignWith: + case SemIR::CoreInterface::SubAssignWith: + case SemIR::CoreInterface::MulAssignWith: + case SemIR::CoreInterface::DivAssignWith: + case SemIR::CoreInterface::ModAssignWith: + return BuildCppBinaryOperatorWitness(context, loc_id, core_interface, + /*has_associated_result_type=*/false, + query_self_const_id, + query_specific_interface_id); case SemIR::CoreInterface::Copy: return BuildCopyWitness(context, loc_id, query_self_const_id, query_specific_interface_id); diff --git a/toolchain/check/cpp/operators.cpp b/toolchain/check/cpp/operators.cpp index efc01231f81d..a9697205acbd 100644 --- a/toolchain/check/cpp/operators.cpp +++ b/toolchain/check/cpp/operators.cpp @@ -453,6 +453,90 @@ static auto LookupCppConversion(Context& context, SemIR::LocId loc_id, return SemIR::InstId::None; } +static auto FindClangOperator(Context& context, SemIR::LocId loc_id, + clang::OverloadedOperatorKind op_kind, + llvm::ArrayRef arg_exprs) + -> SemIR::InstId; + +namespace { +struct DiagnoseIncompleteOperandTypeInCppOperatorLookup { + Context& context; + SemIR::TypeId arg_type_id; + SemIR::LocId loc_id; + + void operator()(auto& builder) const { + CARBON_DIAGNOSTIC( + IncompleteOperandTypeInCppOperatorLookup, Context, + "looking up a C++ operator with incomplete operand type {0}", + SemIR::TypeId); + builder.Context(loc_id, IncompleteOperandTypeInCppOperatorLookup, + arg_type_id); + } +}; +} // namespace + +auto LookupCppOperator(Context& context, SemIR::LocId loc_id, Operator op, + llvm::ArrayRef arg_type_ids) + -> SemIR::InstId { + // Register an annotation scope to flush any Clang diagnostics when we return. + // This is important to ensure that Clang diagnostics are properly interleaved + // with Carbon diagnostics. + Diagnostics::AnnotationScope annotate_diagnostics(&context.emitter(), + [](auto& /*builder*/) {}); + + if (op.interface_name == CoreIdentifier::ImplicitAs || + op.interface_name == CoreIdentifier::As) { + context.TODO(loc_id, "handle `as` operator when passed a type"); + return SemIR::ErrorInst::InstId; + } + + auto op_kind = + GetClangOperatorKind(context, loc_id, op.interface_name, op.op_name); + if (!op_kind) { + return SemIR::ErrorInst::InstId; + } + + for (SemIR::TypeId arg_type_id : arg_type_ids) { + if (!RequireCompleteType(context, arg_type_id, loc_id, + DiagnoseIncompleteOperandTypeInCppOperatorLookup{ + .context = context, + .arg_type_id = arg_type_id, + .loc_id = loc_id})) { + return SemIR::ErrorInst::InstId; + } + } + + struct Operand { + using enum clang::ExprValueKind; + explicit Operand(clang::QualType type) + : type(type), + expression({}, type, + type->isLValueReferenceType() ? VK_LValue + : type->isRValueReferenceType() ? VK_XValue + : VK_PRValue) {} + clang::QualType type; + clang::OpaqueValueExpr expression; + }; + + auto cpp_type = MapToCppType(context, arg_type_ids[0]); + if (cpp_type.isNull()) { + return SemIR::InstId::None; + } + auto arg0 = Operand(cpp_type); + if (arg_type_ids.size() == 1) { + return FindClangOperator(context, loc_id, *op_kind, {&arg0.expression}); + } + + CARBON_CHECK(arg_type_ids.size() == 2); + cpp_type = MapToCppType(context, arg_type_ids[1]); + if (cpp_type.isNull()) { + return SemIR::InstId::None; + } + auto arg1 = Operand(cpp_type); + return FindClangOperator(context, loc_id, *op_kind, + {&arg0.expression, &arg1.expression}); +} + auto LookupCppOperator(Context& context, SemIR::LocId loc_id, Operator op, llvm::ArrayRef arg_ids) -> SemIR::InstId { // Register an annotation scope to flush any Clang diagnostics when we return. @@ -461,6 +545,14 @@ auto LookupCppOperator(Context& context, SemIR::LocId loc_id, Operator op, Diagnostics::AnnotationScope annotate_diagnostics(&context.emitter(), [](auto& /*builder*/) {}); + // We can only handle concrete types in LookupCppOperator. + for (auto arg_id : arg_ids) { + auto type_id = context.insts().Get(arg_id).type_id(); + if (type_id.is_symbolic()) { + return SemIR::InstId::None; + } + } + // Handle `ImplicitAs` and `As`. if (op.interface_name == CoreIdentifier::ImplicitAs || op.interface_name == CoreIdentifier::As) { @@ -490,14 +582,11 @@ auto LookupCppOperator(Context& context, SemIR::LocId loc_id, Operator op, // Make sure all operands are complete before lookup. for (SemIR::InstId arg_id : arg_ids) { SemIR::TypeId arg_type_id = context.insts().Get(arg_id).type_id(); - if (!RequireCompleteType(context, arg_type_id, loc_id, [&](auto& builder) { - CARBON_DIAGNOSTIC( - IncompleteOperandTypeInCppOperatorLookup, Context, - "looking up a C++ operator with incomplete operand type {0}", - SemIR::TypeId); - builder.Context(loc_id, IncompleteOperandTypeInCppOperatorLookup, - arg_type_id); - })) { + if (!RequireCompleteType(context, arg_type_id, loc_id, + DiagnoseIncompleteOperandTypeInCppOperatorLookup{ + .context = context, + .arg_type_id = arg_type_id, + .loc_id = loc_id})) { return SemIR::ErrorInst::InstId; } } @@ -506,18 +595,24 @@ auto LookupCppOperator(Context& context, SemIR::LocId loc_id, Operator op, if (!maybe_arg_exprs.has_value()) { return SemIR::ErrorInst::InstId; } - auto& arg_exprs = *maybe_arg_exprs; + return FindClangOperator(context, loc_id, *op_kind, *maybe_arg_exprs); +} + +static auto FindClangOperator(Context& context, SemIR::LocId loc_id, + clang::OverloadedOperatorKind op_kind, + llvm::ArrayRef arg_exprs) + -> SemIR::InstId { clang::SourceLocation loc = GetCppLocation(context, loc_id); clang::OverloadCandidateSet::OperatorRewriteInfo operator_rewrite_info( - *op_kind, loc, /*AllowRewritten=*/true); + op_kind, loc, /*AllowRewritten=*/true); clang::OverloadCandidateSet candidate_set( loc, clang::OverloadCandidateSet::CSK_Operator, operator_rewrite_info); clang::Sema& sema = context.clang_sema(); // This works for both unary and binary operators. - sema.LookupOverloadedBinOp(candidate_set, *op_kind, clang::UnresolvedSet<0>{}, + sema.LookupOverloadedBinOp(candidate_set, op_kind, clang::UnresolvedSet<0>{}, arg_exprs); clang::OverloadCandidateSet::iterator best_viable_fn; @@ -540,7 +635,7 @@ auto LookupCppOperator(Context& context, SemIR::LocId loc_id, Operator op, sema.MarkFunctionReferenced(loc, best_viable_fn->Function); // If this is an operator method, the first arg will be used as self. - int32_t num_params = arg_ids.size(); + int32_t num_params = arg_exprs.size(); if (isa(best_viable_fn->Function)) { --num_params; } @@ -561,7 +656,7 @@ auto LookupCppOperator(Context& context, SemIR::LocId loc_id, Operator op, return SemIR::InstId::None; } case clang::OverloadingResult::OR_Ambiguous: { - const char* spelling = clang::getOperatorSpelling(*op_kind); + const char* spelling = clang::getOperatorSpelling(op_kind); candidate_set.NoteCandidates( clang::PartialDiagnosticAt( loc, sema.PDiag(clang::diag::err_ovl_ambiguous_oper_binary) @@ -571,7 +666,7 @@ auto LookupCppOperator(Context& context, SemIR::LocId loc_id, Operator op, return SemIR::ErrorInst::InstId; } case clang::OverloadingResult::OR_Deleted: - const char* spelling = clang::getOperatorSpelling(*op_kind); + const char* spelling = clang::getOperatorSpelling(op_kind); auto* message = best_viable_fn->Function->getDeletedMessage(); // The best viable function might be a different operator if the best // candidate is a rewritten candidate, so use the operator kind of the diff --git a/toolchain/check/cpp/operators.h b/toolchain/check/cpp/operators.h index 285ce2881f12..6fb67ac50d22 100644 --- a/toolchain/check/cpp/operators.h +++ b/toolchain/check/cpp/operators.h @@ -17,6 +17,16 @@ namespace Carbon::Check { auto LookupCppOperator(Context& context, SemIR::LocId loc_id, Operator op, llvm::ArrayRef arg_ids) -> SemIR::InstId; +// Looks up the given operator in the Clang AST generated when importing C++ +// code using argument dependent lookup (ADL) and return overload set +// instruction. +// +// This overload synthesises objects in an unevaluated context within the Clang +// AST based on the types it is provided. +auto LookupCppOperator(Context& context, SemIR::LocId loc_id, Operator op, + llvm::ArrayRef arg_type_ids) + -> SemIR::InstId; + // Returns whether the decl is an operator member function. auto IsCppOperatorMethodDecl(clang::Decl* decl) -> bool; diff --git a/toolchain/check/custom_witness.cpp b/toolchain/check/custom_witness.cpp index 7d494ecd090a..aeeee30d46d9 100644 --- a/toolchain/check/custom_witness.cpp +++ b/toolchain/check/custom_witness.cpp @@ -527,6 +527,51 @@ auto BuildCustomWitness(Context& context, SemIR::LocId loc_id, context.inst_blocks().Add(entries)); } +auto AsCoreIdentifier(SemIR::CoreInterface core_interface) -> CoreIdentifier { + using SemIR::CoreInterface; + switch (core_interface) { + case CoreInterface::AddAssignWith: + return CoreIdentifier::AddAssignWith; + case CoreInterface::AddWith: + return CoreIdentifier::AddWith; + case CoreInterface::Copy: + return CoreIdentifier::Copy; + case CoreInterface::CppUnsafeDeref: + return CoreIdentifier::CppUnsafeDeref; + case CoreInterface::Dec: + return CoreIdentifier::Dec; + case CoreInterface::Default: + return CoreIdentifier::Default; + case CoreInterface::Destroy: + return CoreIdentifier::Destroy; + case CoreInterface::DivAssignWith: + return CoreIdentifier::DivAssignWith; + case CoreInterface::DivWith: + return CoreIdentifier::DivWith; + case CoreInterface::Inc: + return CoreIdentifier::Inc; + case CoreInterface::IntFitsIn: + return CoreIdentifier::IntFitsIn; + case CoreInterface::ModAssignWith: + return CoreIdentifier::ModAssignWith; + case CoreInterface::ModWith: + return CoreIdentifier::ModWith; + case CoreInterface::MulAssignWith: + return CoreIdentifier::MulAssignWith; + case CoreInterface::MulWith: + return CoreIdentifier::MulWith; + case CoreInterface::Negate: + return CoreIdentifier::Negate; + case CoreInterface::SubAssignWith: + return CoreIdentifier::SubAssignWith; + case CoreInterface::SubWith: + return CoreIdentifier::SubWith; + case CoreInterface::Unknown: + CARBON_FATAL("{0} doesn't have a `CoreIdentifier` mapping", + core_interface); + } +} + auto GetCoreInterface(Context& context, SemIR::InterfaceId interface_id) -> SemIR::CoreInterface { const auto& interface = context.interfaces().Get(interface_id); @@ -665,9 +710,22 @@ auto LookupCustomWitness(Context& context, SemIR::LocId loc_id, case SemIR::CoreInterface::IntFitsIn: return MakeIntFitsInWitness(context, loc_id, query_self_const_id, query_specific_interface_id, build_witness); + case SemIR::CoreInterface::AddAssignWith: + case SemIR::CoreInterface::AddWith: case SemIR::CoreInterface::Copy: case SemIR::CoreInterface::CppUnsafeDeref: + case SemIR::CoreInterface::Dec: case SemIR::CoreInterface::Default: + case SemIR::CoreInterface::DivAssignWith: + case SemIR::CoreInterface::DivWith: + case SemIR::CoreInterface::Inc: + case SemIR::CoreInterface::ModAssignWith: + case SemIR::CoreInterface::ModWith: + case SemIR::CoreInterface::MulAssignWith: + case SemIR::CoreInterface::MulWith: + case SemIR::CoreInterface::Negate: + case SemIR::CoreInterface::SubAssignWith: + case SemIR::CoreInterface::SubWith: case SemIR::CoreInterface::Unknown: // TODO: Handle more interfaces, particularly copy, move, and conversion. return std::nullopt; diff --git a/toolchain/check/custom_witness.h b/toolchain/check/custom_witness.h index 24f1c516b203..e1821a227058 100644 --- a/toolchain/check/custom_witness.h +++ b/toolchain/check/custom_witness.h @@ -30,6 +30,9 @@ auto BuildPrimitiveCopyWitness( auto GetCoreInterface(Context& context, SemIR::InterfaceId interface_id) -> SemIR::CoreInterface; +// Maps a `CoreInterface` to its `CoreIdentifier` equivalent. +auto AsCoreIdentifier(SemIR::CoreInterface core_interface) -> CoreIdentifier; + // Returns a witness for a `CoreInterface` `CustomWitness`. A return value of // `None` indicates a non-final witness should be produced, while `std::nullopt` // indicates the query is final and no witness can be produced. diff --git a/toolchain/check/function.cpp b/toolchain/check/function.cpp index 9b57d405c5ee..442d2545fd0b 100644 --- a/toolchain/check/function.cpp +++ b/toolchain/check/function.cpp @@ -250,6 +250,10 @@ auto CheckFunctionReturnTypeMatches(Context& context, } if (!context.types().AreEqualAcrossDeclarations(new_return_type_id, prev_return_type_id)) { + if (new_function.name_id == SemIR::NameId::CppOperator && + !prev_return_type_id.has_value()) { + return true; + } if (!diagnose) { return false; } diff --git a/toolchain/check/handle_interface.cpp b/toolchain/check/handle_interface.cpp index ce2bc256789f..61311479e9f0 100644 --- a/toolchain/check/handle_interface.cpp +++ b/toolchain/check/handle_interface.cpp @@ -16,6 +16,7 @@ #include "toolchain/check/name_component.h" #include "toolchain/check/name_lookup.h" #include "toolchain/check/type.h" +#include "toolchain/sem_ir/core_interface.h" #include "toolchain/sem_ir/entity_with_params_base.h" #include "toolchain/sem_ir/ids.h" #include "toolchain/sem_ir/interface.h" @@ -92,11 +93,24 @@ static auto BuildInterfaceDecl(Context& context, auto name = context.names().GetIRBaseName(interface_info.name_id); interface_info.core_interface = llvm::StringSwitch(name) + .Case("AddAssignWith", SemIR::CoreInterface::AddAssignWith) + .Case("AddWith", SemIR::CoreInterface::AddWith) .Case("Copy", SemIR::CoreInterface::Copy) .Case("CppUnsafeDeref", SemIR::CoreInterface::CppUnsafeDeref) + .Case("Dec", SemIR::CoreInterface::Dec) .Case("Default", SemIR::CoreInterface::Default) .Case("Destroy", SemIR::CoreInterface::Destroy) + .Case("DivAssignWith", SemIR::CoreInterface::DivAssignWith) + .Case("DivWith", SemIR::CoreInterface::DivWith) + .Case("Inc", SemIR::CoreInterface::Inc) .Case("IntFitsIn", SemIR::CoreInterface::IntFitsIn) + .Case("ModAssignWith", SemIR::CoreInterface::ModAssignWith) + .Case("ModWith", SemIR::CoreInterface::ModWith) + .Case("MulAssignWith", SemIR::CoreInterface::MulAssignWith) + .Case("MulWith", SemIR::CoreInterface::MulWith) + .Case("Negate", SemIR::CoreInterface::Negate) + .Case("SubAssignWith", SemIR::CoreInterface::SubAssignWith) + .Case("SubWith", SemIR::CoreInterface::SubWith) .Default(SemIR::CoreInterface::Unknown); } interface_decl.interface_id = context.interfaces().Add(interface_info); diff --git a/toolchain/check/testdata/interop/cpp/operators/arithmetic_operators.carbon b/toolchain/check/testdata/interop/cpp/operators/arithmetic_operators.carbon new file mode 100644 index 000000000000..76ff9de38efe --- /dev/null +++ b/toolchain/check/testdata/interop/cpp/operators/arithmetic_operators.carbon @@ -0,0 +1,3845 @@ +// Part of the Carbon Language project, under the Apache License v2.0 with LLVM +// Exceptions. See /LICENSE for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +// INCLUDE-FILE: toolchain/testing/testdata/min_prelude/full.carbon +// EXTRA-ARGS: --target=x86_64-linux-gnu --clang-arg=-std=c++20 +// +// AUTOUPDATE +// TIP: To test this file alone, run: +// TIP: bazel test //toolchain/testing:file_test --test_arg=--file_tests=toolchain/check/testdata/interop/cpp/operators/arithmetic_operators.carbon +// TIP: To dump output, run: +// TIP: bazel run //toolchain/testing:file_test -- --dump_output --file_tests=toolchain/check/testdata/interop/cpp/operators/arithmetic_operators.carbon + +// TODO: test implicit conversions when supported + +library "[[@TEST_NAME]]"; +import Cpp inline '''c++ +class Int16; +class Int32; +class Int64; + +class Int16 { +public: + // TODO: support non-const qualified operators + auto operator+(Int32) const -> Int32; + auto operator-(Int32) const -> Int32; + auto operator*(Int32) const -> Int32; + auto operator/(Int32) const -> Int32; + auto operator%(Int32) const -> Int32; + + // Tests `class + builtin` works + auto operator+(short) const -> Int16; + auto operator-(short) const -> Int16; + auto operator*(short) const -> Int16; + auto operator/(short) const -> Int16; + auto operator%(short) const -> Int16; + + auto operator+=(short) const -> Int16&; + auto operator-=(short) const -> Int16&; + auto operator*=(short) const -> Int16&; + auto operator/=(short) const -> Int16&; + auto operator%=(short) const -> Int16&; + + auto operator-() const -> Int64; +}; + +auto operator+(short, Int16) -> Int16; +auto operator-(short, Int16) -> Int16; +auto operator*(short, Int16) -> Int16; +auto operator/(short, Int16) -> Int16; +auto operator%(short, Int16) -> Int16; + +class Int32 { +public: + // Intentionally not const-qualified + auto operator+(Int16) const -> Int32; + auto operator-(Int16) const -> Int32; + auto operator*(Int16) const -> Int32; + auto operator/(Int16) const -> Int32; + auto operator%(Int16) const -> Int32; + + auto operator+(Int32) const -> Int32; + auto operator-(Int32) const -> Int32; + auto operator*(Int32) const -> Int32; + auto operator/(Int32) const -> Int32; + auto operator%(Int32) const -> Int32; + + auto operator-() const -> Int32; + + auto operator++() -> void; + auto operator--() -> void; + + auto operator+=(Int32) -> void; + auto operator-=(Int32) -> void; + auto operator*=(Int32) -> void; + auto operator/=(Int32) -> void; + auto operator%=(Int32) -> void; +}; + +class Int64; +auto operator+(Int64, Int32) -> Int64; +auto operator-(Int64, Int32) -> Int64; +auto operator*(Int64, Int32) -> Int64; +auto operator/(Int64, Int32) -> Int64; +auto operator%(Int64, Int32) -> Int64; + +class Int64 { +public: + auto operator+=(Int32) -> void; + auto operator-=(Int32) -> void; + auto operator*=(Int32) -> void; + auto operator/=(Int32) -> void; + auto operator%=(Int32) -> void; + + // Tests hidden friends work + friend auto operator+(Int32 x, Int64 y) -> Int64 { + return y + x; + } + friend auto operator-(Int32 x, Int64 y) -> Int64 { + return y + x; + } + friend auto operator*(Int32 x, Int64 y) -> Int64 { + return y + x; + } + friend auto operator/(Int32 x, Int64 y) -> Int64 { + return y + x; + } + friend auto operator%(Int32 x, Int64 y) -> Int64 { + return y + x; + } +}; +'''; + +// TODO: Refactor when `.Result impls Core.Destroy` is possible. +// `Result` is a workaround for `.Result impls Core.Destroy`. This funciton +// ought to be defined as +// ``` +// AddWith[U:! type, T:! Core.AddWith(U) where .Result impls Core.Destroy](x: T, y: T) +// ``` +fn AddWith[ + Result:! Core.Destroy, + U:! Core.Destroy, + T:! Core.Destroy & Core.AddWith(U) where .Result = Result +](unused result: Result, x: T, y: U) { + //@dump-sem-ir-begin + x + y; + //@dump-sem-ir-end +} + +// TODO: Refactor when `.Result impls Core.Destroy` is possible. +fn SubWith[ + Result:! Core.Destroy, + U:! Core.Destroy, + T:! Core.Destroy & Core.SubWith(U) where .Result = Result +](unused result: Result, x: T, y: U) { + //@dump-sem-ir-begin + x - y; + //@dump-sem-ir-end +} + +// TODO: Refactor when `.Result impls Core.Destroy` is possible. +fn MulWith[ + Result:! Core.Destroy, + U:! Core.Destroy, + T:! Core.Destroy & Core.MulWith(U) where .Result = Result +](unused result: Result, x: T, y: U) { + //@dump-sem-ir-begin + x * y; + //@dump-sem-ir-end +} + +// TODO: Refactor when `.Result impls Core.Destroy` is possible. +fn DivWith[ + Result:! Core.Destroy, + U:! Core.Destroy, + T:! Core.Destroy & Core.DivWith(U) where .Result = Result +](unused result: Result, x: T, y: U) { + //@dump-sem-ir-begin + x / y; + //@dump-sem-ir-end +} + +// TODO: Refactor when `.Result impls Core.Destroy` is possible. +fn ModWith[ + Result:! Core.Destroy, + U:! Core.Destroy, + T:! Core.Destroy & Core.ModWith(U) where .Result = Result +](unused result: Result, x: T, y: U) { + //@dump-sem-ir-begin + x % y; + //@dump-sem-ir-end +} + +fn TestOpWith(a: Cpp.Int16, b: Cpp.Int32, c: Cpp.Int32, d: Cpp.Int64, x: i16) { + // i16 `op` Int16 + AddWith(Cpp.Int16.Int16(), x, a); + SubWith(Cpp.Int16.Int16(), x, a); + MulWith(Cpp.Int16.Int16(), x, a); + DivWith(Cpp.Int16.Int16(), x, a); + ModWith(Cpp.Int16.Int16(), x, a); + + // Int16 `op` i16 + AddWith(Cpp.Int16.Int16(), a, x); + SubWith(Cpp.Int16.Int16(), a, x); + MulWith(Cpp.Int16.Int16(), a, x); + DivWith(Cpp.Int16.Int16(), a, x); + ModWith(Cpp.Int16.Int16(), a, x); + + // Int16 `op` Int32 + AddWith(Cpp.Int32.Int32(), a, b); + SubWith(Cpp.Int32.Int32(), a, b); + MulWith(Cpp.Int32.Int32(), a, b); + DivWith(Cpp.Int32.Int32(), a, b); + ModWith(Cpp.Int32.Int32(), a, b); + + // Int32 `op` Int16 + AddWith(Cpp.Int32.Int32(), b, a); + SubWith(Cpp.Int32.Int32(), b, a); + MulWith(Cpp.Int32.Int32(), b, a); + DivWith(Cpp.Int32.Int32(), b, a); + ModWith(Cpp.Int32.Int32(), b, a); + + // Int32 `op` Int32 + AddWith(Cpp.Int32.Int32(), b, c); + SubWith(Cpp.Int32.Int32(), b, c); + MulWith(Cpp.Int32.Int32(), b, c); + DivWith(Cpp.Int32.Int32(), b, c); + ModWith(Cpp.Int32.Int32(), b, c); + + // Int32 `op` Int64 + AddWith(Cpp.Int64.Int64(), c, d); + SubWith(Cpp.Int64.Int64(), c, d); + MulWith(Cpp.Int64.Int64(), c, d); + DivWith(Cpp.Int64.Int64(), c, d); + ModWith(Cpp.Int64.Int64(), c, d); + + // Int64 `op` Int32 + AddWith(Cpp.Int64.Int64(), d, c); + SubWith(Cpp.Int64.Int64(), d, c); + MulWith(Cpp.Int64.Int64(), d, c); + DivWith(Cpp.Int64.Int64(), d, c); + ModWith(Cpp.Int64.Int64(), d, c); +} + +fn AddAssignWith[U:! type, T:! Core.AddAssignWith(U)](var x: T, y: U) { + //@dump-sem-ir-begin + x += y; + //@dump-sem-ir-end +} + +fn SubAssignWith[U:! type, T:! Core.SubAssignWith(U)](var x: T, y: U) { + //@dump-sem-ir-begin + x -= y; + //@dump-sem-ir-end +} + +fn MulAssignWith[U:! type, T:! Core.MulAssignWith(U)](var x: T, y: U) { + //@dump-sem-ir-begin + x *= y; + //@dump-sem-ir-end +} + +fn DivAssignWith[U:! type, T:! Core.DivAssignWith(U)](var x: T, y: U) { + //@dump-sem-ir-begin + x /= y; + //@dump-sem-ir-end +} + +fn ModAssignWith[U:! type, T:! Core.ModAssignWith(U)](var x: T, y: U) { + //@dump-sem-ir-begin + x %= y; + //@dump-sem-ir-end +} + +fn TestOpAssignWith(int16: Cpp.Int16, int32: Cpp.Int32, int64: Cpp.Int64, x: i16) { + // Int16 `op` i16 + AddAssignWith(int16, x); + SubAssignWith(int16, x); + MulAssignWith(int16, x); + DivAssignWith(int16, x); + ModAssignWith(int16, x); + + // Int32 `op` Int32 + AddAssignWith(int32, int32); + SubAssignWith(int32, int32); + MulAssignWith(int32, int32); + DivAssignWith(int32, int32); + ModAssignWith(int32, int32); + + // Int64 `op` Int32 + AddAssignWith(int64, int32); + SubAssignWith(int64, int32); + MulAssignWith(int64, int32); + DivAssignWith(int64, int32); + ModAssignWith(int64, int32); +} + +fn TestInc[T:! Core.Inc](var x: T) { + //@dump-sem-ir-begin + ++x; + //@dump-sem-ir-end +} + +fn TestDec[T:! Core.Dec](var x: T) { + //@dump-sem-ir-begin + --x; + //@dump-sem-ir-end +} + +// TODO: Refactor when `.Result impls Core.Destroy` is possible. +fn TestNegate[ + Result:! Core.Destroy, + T:! Core.Destroy & Core.Negate where .Result = Result +](unused y: Result, x: T) { + //@dump-sem-ir-begin + -x; + //@dump-sem-ir-end +} + +fn TestUnaryOperators(a: Cpp.Int16, b: Cpp.Int32) { + TestInc(b); + TestDec(b); + + TestNegate(Cpp.Int64.Int64(), a); + TestNegate(Cpp.Int32.Int32(), b); +} + +// CHECK:STDOUT: --- arithmetic_operators.carbon +// CHECK:STDOUT: +// CHECK:STDOUT: constants { +// CHECK:STDOUT: %empty_tuple.type: type = tuple_type () [concrete] +// CHECK:STDOUT: %Destroy.type: type = facet_type <@Destroy> [concrete] +// CHECK:STDOUT: %Result: %Destroy.type = symbolic_binding Result, 0 [symbolic] +// CHECK:STDOUT: %U.0bd: %Destroy.type = symbolic_binding U, 1 [symbolic] +// CHECK:STDOUT: %Other: type = symbolic_binding Other, 0 [symbolic] +// CHECK:STDOUT: %AddWith.type.6d9: type = facet_type <@AddWith.1, @AddWith.1(%Other)> [symbolic] +// CHECK:STDOUT: %Self.b7c: %AddWith.type.6d9 = symbolic_binding Self, 1 [symbolic] +// CHECK:STDOUT: %AddWith.assoc_type.b6a: type = assoc_entity_type @AddWith.1, @AddWith.1(%Other) [symbolic] +// CHECK:STDOUT: %AddWith.WithSelf.Op.type.08f: type = fn_type @AddWith.WithSelf.Op, @AddWith.WithSelf(%Other, %Self.b7c) [symbolic] +// CHECK:STDOUT: %AddWith.WithSelf.Op.fb8: %AddWith.WithSelf.Op.type.08f = struct_value () [symbolic] +// CHECK:STDOUT: %U.as_type.2b8: type = facet_access_type %U.0bd [symbolic] +// CHECK:STDOUT: %AddWith.type.07d: type = facet_type <@AddWith.1, @AddWith.1(%U.as_type.2b8)> [symbolic] +// CHECK:STDOUT: %facet_type.74d: type = facet_type <@Destroy & @AddWith.1, @AddWith.1(%U.as_type.2b8)> [symbolic] +// CHECK:STDOUT: %.Self.5c0: %facet_type.74d = symbolic_binding .Self [symbolic] +// CHECK:STDOUT: %AddWith.assoc_type.8c2: type = assoc_entity_type @AddWith.1, @AddWith.1(%U.as_type.2b8) [symbolic] +// CHECK:STDOUT: %assoc0.7d3: %AddWith.assoc_type.8c2 = assoc_entity element0, imports.%Core.import_ref.6e9 [symbolic] +// CHECK:STDOUT: %assoc1.0f4: %AddWith.assoc_type.8c2 = assoc_entity element1, imports.%Core.import_ref.1b1 [symbolic] +// CHECK:STDOUT: %require_complete.311: = require_complete_type %facet_type.74d [symbolic] +// CHECK:STDOUT: %.Self.as_type.f21: type = facet_access_type %.Self.5c0 [symbolic] +// CHECK:STDOUT: %AddWith.lookup_impl_witness.5a0: = lookup_impl_witness %.Self.5c0, @AddWith.1, @AddWith.1(%U.as_type.2b8) [symbolic] +// CHECK:STDOUT: %impl.elem0.08a: type = impl_witness_access %AddWith.lookup_impl_witness.5a0, element0 [symbolic] +// CHECK:STDOUT: %Result.as_type: type = facet_access_type %Result [symbolic] +// CHECK:STDOUT: %facet_type.024: type = facet_type <@Destroy & @AddWith.1, @AddWith.1(%U.as_type.2b8) where %impl.elem0.08a = %Result.as_type> [symbolic] +// CHECK:STDOUT: %pattern_type.077a: type = pattern_type %facet_type.024 [symbolic] +// CHECK:STDOUT: %T.25f: %facet_type.024 = symbolic_binding T, 2 [symbolic] +// CHECK:STDOUT: %pattern_type.eca0e4.2: type = pattern_type %Result.as_type [symbolic] +// CHECK:STDOUT: %T.as_type.ab9: type = facet_access_type %T.25f [symbolic] +// CHECK:STDOUT: %pattern_type.7bb: type = pattern_type %T.as_type.ab9 [symbolic] +// CHECK:STDOUT: %pattern_type.711: type = pattern_type %U.as_type.2b8 [symbolic] +// CHECK:STDOUT: %require_complete.8bd: = require_complete_type %AddWith.type.07d [symbolic] +// CHECK:STDOUT: %assoc1.4d4: %AddWith.assoc_type.b6a = assoc_entity element1, imports.%Core.import_ref.a84 [symbolic] +// CHECK:STDOUT: %AddWith.lookup_impl_witness.3c7: = lookup_impl_witness %T.25f, @AddWith.1, @AddWith.1(%U.as_type.2b8) [symbolic] +// CHECK:STDOUT: %AddWith.facet.570: %AddWith.type.07d = facet_value %T.as_type.ab9, (%AddWith.lookup_impl_witness.3c7) [symbolic] +// CHECK:STDOUT: %AddWith.WithSelf.Op.type.82f: type = fn_type @AddWith.WithSelf.Op, @AddWith.WithSelf(%U.as_type.2b8, %AddWith.facet.570) [symbolic] +// CHECK:STDOUT: %.97d: type = fn_type_with_self_type %AddWith.WithSelf.Op.type.82f, %AddWith.facet.570 [symbolic] +// CHECK:STDOUT: %impl.elem1.07a: %.97d = impl_witness_access %AddWith.lookup_impl_witness.3c7, element1 [symbolic] +// CHECK:STDOUT: %specific_impl_fn.dbc: = specific_impl_function %impl.elem1.07a, @AddWith.WithSelf.Op(%U.as_type.2b8, %AddWith.facet.570) [symbolic] +// CHECK:STDOUT: %Destroy.lookup_impl_witness.d86: = lookup_impl_witness %Result, @Destroy [symbolic] +// CHECK:STDOUT: %Destroy.WithSelf.Op.type.cb2e47.2: type = fn_type @Destroy.WithSelf.Op, @Destroy.WithSelf(%Result) [symbolic] +// CHECK:STDOUT: %.d5f: type = fn_type_with_self_type %Destroy.WithSelf.Op.type.cb2e47.2, %Result [symbolic] +// CHECK:STDOUT: %impl.elem0.a6b: %.d5f = impl_witness_access %Destroy.lookup_impl_witness.d86, element0 [symbolic] +// CHECK:STDOUT: %specific_impl_fn.761: = specific_impl_function %impl.elem0.a6b, @Destroy.WithSelf.Op(%Result) [symbolic] +// CHECK:STDOUT: %SubWith.type.99c: type = facet_type <@SubWith.1, @SubWith.1(%Other)> [symbolic] +// CHECK:STDOUT: %Self.ddf: %SubWith.type.99c = symbolic_binding Self, 1 [symbolic] +// CHECK:STDOUT: %SubWith.assoc_type.645: type = assoc_entity_type @SubWith.1, @SubWith.1(%Other) [symbolic] +// CHECK:STDOUT: %SubWith.WithSelf.Op.type.0bf: type = fn_type @SubWith.WithSelf.Op, @SubWith.WithSelf(%Other, %Self.ddf) [symbolic] +// CHECK:STDOUT: %SubWith.WithSelf.Op.bd9: %SubWith.WithSelf.Op.type.0bf = struct_value () [symbolic] +// CHECK:STDOUT: %SubWith.type.593: type = facet_type <@SubWith.1, @SubWith.1(%U.as_type.2b8)> [symbolic] +// CHECK:STDOUT: %facet_type.db3: type = facet_type <@Destroy & @SubWith.1, @SubWith.1(%U.as_type.2b8)> [symbolic] +// CHECK:STDOUT: %.Self.db3: %facet_type.db3 = symbolic_binding .Self [symbolic] +// CHECK:STDOUT: %SubWith.assoc_type.065: type = assoc_entity_type @SubWith.1, @SubWith.1(%U.as_type.2b8) [symbolic] +// CHECK:STDOUT: %assoc0.55d: %SubWith.assoc_type.065 = assoc_entity element0, imports.%Core.import_ref.7e5 [symbolic] +// CHECK:STDOUT: %assoc1.173: %SubWith.assoc_type.065 = assoc_entity element1, imports.%Core.import_ref.abb [symbolic] +// CHECK:STDOUT: %require_complete.b71: = require_complete_type %facet_type.db3 [symbolic] +// CHECK:STDOUT: %.Self.as_type.2a6: type = facet_access_type %.Self.db3 [symbolic] +// CHECK:STDOUT: %SubWith.lookup_impl_witness.98d: = lookup_impl_witness %.Self.db3, @SubWith.1, @SubWith.1(%U.as_type.2b8) [symbolic] +// CHECK:STDOUT: %impl.elem0.bbb: type = impl_witness_access %SubWith.lookup_impl_witness.98d, element0 [symbolic] +// CHECK:STDOUT: %facet_type.bea: type = facet_type <@Destroy & @SubWith.1, @SubWith.1(%U.as_type.2b8) where %impl.elem0.bbb = %Result.as_type> [symbolic] +// CHECK:STDOUT: %pattern_type.265: type = pattern_type %facet_type.bea [symbolic] +// CHECK:STDOUT: %T.970: %facet_type.bea = symbolic_binding T, 2 [symbolic] +// CHECK:STDOUT: %T.as_type.474: type = facet_access_type %T.970 [symbolic] +// CHECK:STDOUT: %pattern_type.b6a: type = pattern_type %T.as_type.474 [symbolic] +// CHECK:STDOUT: %require_complete.ae1: = require_complete_type %SubWith.type.593 [symbolic] +// CHECK:STDOUT: %assoc1.f09: %SubWith.assoc_type.645 = assoc_entity element1, imports.%Core.import_ref.e83 [symbolic] +// CHECK:STDOUT: %SubWith.lookup_impl_witness.db9: = lookup_impl_witness %T.970, @SubWith.1, @SubWith.1(%U.as_type.2b8) [symbolic] +// CHECK:STDOUT: %SubWith.facet.7f1: %SubWith.type.593 = facet_value %T.as_type.474, (%SubWith.lookup_impl_witness.db9) [symbolic] +// CHECK:STDOUT: %SubWith.WithSelf.Op.type.e59: type = fn_type @SubWith.WithSelf.Op, @SubWith.WithSelf(%U.as_type.2b8, %SubWith.facet.7f1) [symbolic] +// CHECK:STDOUT: %.4b6: type = fn_type_with_self_type %SubWith.WithSelf.Op.type.e59, %SubWith.facet.7f1 [symbolic] +// CHECK:STDOUT: %impl.elem1.6e4: %.4b6 = impl_witness_access %SubWith.lookup_impl_witness.db9, element1 [symbolic] +// CHECK:STDOUT: %specific_impl_fn.0d3: = specific_impl_function %impl.elem1.6e4, @SubWith.WithSelf.Op(%U.as_type.2b8, %SubWith.facet.7f1) [symbolic] +// CHECK:STDOUT: %MulWith.type.9a3: type = facet_type <@MulWith.1, @MulWith.1(%Other)> [symbolic] +// CHECK:STDOUT: %Self.9c4: %MulWith.type.9a3 = symbolic_binding Self, 1 [symbolic] +// CHECK:STDOUT: %MulWith.assoc_type.b5d: type = assoc_entity_type @MulWith.1, @MulWith.1(%Other) [symbolic] +// CHECK:STDOUT: %MulWith.WithSelf.Op.type.00c: type = fn_type @MulWith.WithSelf.Op, @MulWith.WithSelf(%Other, %Self.9c4) [symbolic] +// CHECK:STDOUT: %MulWith.WithSelf.Op.07a: %MulWith.WithSelf.Op.type.00c = struct_value () [symbolic] +// CHECK:STDOUT: %MulWith.type.9532: type = facet_type <@MulWith.1, @MulWith.1(%U.as_type.2b8)> [symbolic] +// CHECK:STDOUT: %facet_type.17c: type = facet_type <@Destroy & @MulWith.1, @MulWith.1(%U.as_type.2b8)> [symbolic] +// CHECK:STDOUT: %.Self.afa: %facet_type.17c = symbolic_binding .Self [symbolic] +// CHECK:STDOUT: %MulWith.assoc_type.97c: type = assoc_entity_type @MulWith.1, @MulWith.1(%U.as_type.2b8) [symbolic] +// CHECK:STDOUT: %assoc0.1354: %MulWith.assoc_type.97c = assoc_entity element0, imports.%Core.import_ref.d9b [symbolic] +// CHECK:STDOUT: %assoc1.496: %MulWith.assoc_type.97c = assoc_entity element1, imports.%Core.import_ref.abc [symbolic] +// CHECK:STDOUT: %require_complete.665: = require_complete_type %facet_type.17c [symbolic] +// CHECK:STDOUT: %.Self.as_type.9cb: type = facet_access_type %.Self.afa [symbolic] +// CHECK:STDOUT: %MulWith.lookup_impl_witness.05e: = lookup_impl_witness %.Self.afa, @MulWith.1, @MulWith.1(%U.as_type.2b8) [symbolic] +// CHECK:STDOUT: %impl.elem0.972: type = impl_witness_access %MulWith.lookup_impl_witness.05e, element0 [symbolic] +// CHECK:STDOUT: %facet_type.91e: type = facet_type <@Destroy & @MulWith.1, @MulWith.1(%U.as_type.2b8) where %impl.elem0.972 = %Result.as_type> [symbolic] +// CHECK:STDOUT: %pattern_type.b93: type = pattern_type %facet_type.91e [symbolic] +// CHECK:STDOUT: %T.438: %facet_type.91e = symbolic_binding T, 2 [symbolic] +// CHECK:STDOUT: %T.as_type.68f: type = facet_access_type %T.438 [symbolic] +// CHECK:STDOUT: %pattern_type.b74: type = pattern_type %T.as_type.68f [symbolic] +// CHECK:STDOUT: %require_complete.d9d: = require_complete_type %MulWith.type.9532 [symbolic] +// CHECK:STDOUT: %assoc1.ccf: %MulWith.assoc_type.b5d = assoc_entity element1, imports.%Core.import_ref.d5a [symbolic] +// CHECK:STDOUT: %MulWith.lookup_impl_witness.009: = lookup_impl_witness %T.438, @MulWith.1, @MulWith.1(%U.as_type.2b8) [symbolic] +// CHECK:STDOUT: %MulWith.facet.2d0: %MulWith.type.9532 = facet_value %T.as_type.68f, (%MulWith.lookup_impl_witness.009) [symbolic] +// CHECK:STDOUT: %MulWith.WithSelf.Op.type.283: type = fn_type @MulWith.WithSelf.Op, @MulWith.WithSelf(%U.as_type.2b8, %MulWith.facet.2d0) [symbolic] +// CHECK:STDOUT: %.978: type = fn_type_with_self_type %MulWith.WithSelf.Op.type.283, %MulWith.facet.2d0 [symbolic] +// CHECK:STDOUT: %impl.elem1.80d: %.978 = impl_witness_access %MulWith.lookup_impl_witness.009, element1 [symbolic] +// CHECK:STDOUT: %specific_impl_fn.889: = specific_impl_function %impl.elem1.80d, @MulWith.WithSelf.Op(%U.as_type.2b8, %MulWith.facet.2d0) [symbolic] +// CHECK:STDOUT: %DivWith.type.871d: type = facet_type <@DivWith.1, @DivWith.1(%Other)> [symbolic] +// CHECK:STDOUT: %Self.d71: %DivWith.type.871d = symbolic_binding Self, 1 [symbolic] +// CHECK:STDOUT: %DivWith.assoc_type.16c: type = assoc_entity_type @DivWith.1, @DivWith.1(%Other) [symbolic] +// CHECK:STDOUT: %DivWith.WithSelf.Op.type.8a1: type = fn_type @DivWith.WithSelf.Op, @DivWith.WithSelf(%Other, %Self.d71) [symbolic] +// CHECK:STDOUT: %DivWith.WithSelf.Op.0a9: %DivWith.WithSelf.Op.type.8a1 = struct_value () [symbolic] +// CHECK:STDOUT: %DivWith.type.0e2: type = facet_type <@DivWith.1, @DivWith.1(%U.as_type.2b8)> [symbolic] +// CHECK:STDOUT: %facet_type.94d: type = facet_type <@Destroy & @DivWith.1, @DivWith.1(%U.as_type.2b8)> [symbolic] +// CHECK:STDOUT: %.Self.5a5: %facet_type.94d = symbolic_binding .Self [symbolic] +// CHECK:STDOUT: %DivWith.assoc_type.06d: type = assoc_entity_type @DivWith.1, @DivWith.1(%U.as_type.2b8) [symbolic] +// CHECK:STDOUT: %assoc0.1db: %DivWith.assoc_type.06d = assoc_entity element0, imports.%Core.import_ref.14e [symbolic] +// CHECK:STDOUT: %assoc1.49b: %DivWith.assoc_type.06d = assoc_entity element1, imports.%Core.import_ref.bb2c [symbolic] +// CHECK:STDOUT: %require_complete.3a4: = require_complete_type %facet_type.94d [symbolic] +// CHECK:STDOUT: %.Self.as_type.dad: type = facet_access_type %.Self.5a5 [symbolic] +// CHECK:STDOUT: %DivWith.lookup_impl_witness.fbf: = lookup_impl_witness %.Self.5a5, @DivWith.1, @DivWith.1(%U.as_type.2b8) [symbolic] +// CHECK:STDOUT: %impl.elem0.409: type = impl_witness_access %DivWith.lookup_impl_witness.fbf, element0 [symbolic] +// CHECK:STDOUT: %facet_type.6e6: type = facet_type <@Destroy & @DivWith.1, @DivWith.1(%U.as_type.2b8) where %impl.elem0.409 = %Result.as_type> [symbolic] +// CHECK:STDOUT: %pattern_type.4ef: type = pattern_type %facet_type.6e6 [symbolic] +// CHECK:STDOUT: %T.30e: %facet_type.6e6 = symbolic_binding T, 2 [symbolic] +// CHECK:STDOUT: %T.as_type.cfe: type = facet_access_type %T.30e [symbolic] +// CHECK:STDOUT: %pattern_type.daa: type = pattern_type %T.as_type.cfe [symbolic] +// CHECK:STDOUT: %require_complete.9a1: = require_complete_type %DivWith.type.0e2 [symbolic] +// CHECK:STDOUT: %assoc1.b83: %DivWith.assoc_type.16c = assoc_entity element1, imports.%Core.import_ref.4c4 [symbolic] +// CHECK:STDOUT: %DivWith.lookup_impl_witness.b69: = lookup_impl_witness %T.30e, @DivWith.1, @DivWith.1(%U.as_type.2b8) [symbolic] +// CHECK:STDOUT: %DivWith.facet.490: %DivWith.type.0e2 = facet_value %T.as_type.cfe, (%DivWith.lookup_impl_witness.b69) [symbolic] +// CHECK:STDOUT: %DivWith.WithSelf.Op.type.2ad: type = fn_type @DivWith.WithSelf.Op, @DivWith.WithSelf(%U.as_type.2b8, %DivWith.facet.490) [symbolic] +// CHECK:STDOUT: %.0bf: type = fn_type_with_self_type %DivWith.WithSelf.Op.type.2ad, %DivWith.facet.490 [symbolic] +// CHECK:STDOUT: %impl.elem1.b07: %.0bf = impl_witness_access %DivWith.lookup_impl_witness.b69, element1 [symbolic] +// CHECK:STDOUT: %specific_impl_fn.dbd: = specific_impl_function %impl.elem1.b07, @DivWith.WithSelf.Op(%U.as_type.2b8, %DivWith.facet.490) [symbolic] +// CHECK:STDOUT: %ModWith.type.155: type = facet_type <@ModWith.1, @ModWith.1(%Other)> [symbolic] +// CHECK:STDOUT: %Self.797: %ModWith.type.155 = symbolic_binding Self, 1 [symbolic] +// CHECK:STDOUT: %ModWith.assoc_type.e6f: type = assoc_entity_type @ModWith.1, @ModWith.1(%Other) [symbolic] +// CHECK:STDOUT: %ModWith.WithSelf.Op.type.f61: type = fn_type @ModWith.WithSelf.Op, @ModWith.WithSelf(%Other, %Self.797) [symbolic] +// CHECK:STDOUT: %ModWith.WithSelf.Op.3ac: %ModWith.WithSelf.Op.type.f61 = struct_value () [symbolic] +// CHECK:STDOUT: %ModWith.type.c6f: type = facet_type <@ModWith.1, @ModWith.1(%U.as_type.2b8)> [symbolic] +// CHECK:STDOUT: %facet_type.428: type = facet_type <@Destroy & @ModWith.1, @ModWith.1(%U.as_type.2b8)> [symbolic] +// CHECK:STDOUT: %.Self.2d4: %facet_type.428 = symbolic_binding .Self [symbolic] +// CHECK:STDOUT: %ModWith.assoc_type.66e: type = assoc_entity_type @ModWith.1, @ModWith.1(%U.as_type.2b8) [symbolic] +// CHECK:STDOUT: %assoc0.fd6: %ModWith.assoc_type.66e = assoc_entity element0, imports.%Core.import_ref.a0d [symbolic] +// CHECK:STDOUT: %assoc1.3da: %ModWith.assoc_type.66e = assoc_entity element1, imports.%Core.import_ref.c05 [symbolic] +// CHECK:STDOUT: %require_complete.9441: = require_complete_type %facet_type.428 [symbolic] +// CHECK:STDOUT: %.Self.as_type.12a6: type = facet_access_type %.Self.2d4 [symbolic] +// CHECK:STDOUT: %ModWith.lookup_impl_witness.afa: = lookup_impl_witness %.Self.2d4, @ModWith.1, @ModWith.1(%U.as_type.2b8) [symbolic] +// CHECK:STDOUT: %impl.elem0.44b: type = impl_witness_access %ModWith.lookup_impl_witness.afa, element0 [symbolic] +// CHECK:STDOUT: %facet_type.3a6: type = facet_type <@Destroy & @ModWith.1, @ModWith.1(%U.as_type.2b8) where %impl.elem0.44b = %Result.as_type> [symbolic] +// CHECK:STDOUT: %pattern_type.50d: type = pattern_type %facet_type.3a6 [symbolic] +// CHECK:STDOUT: %T.a77: %facet_type.3a6 = symbolic_binding T, 2 [symbolic] +// CHECK:STDOUT: %T.as_type.10f: type = facet_access_type %T.a77 [symbolic] +// CHECK:STDOUT: %pattern_type.8db: type = pattern_type %T.as_type.10f [symbolic] +// CHECK:STDOUT: %require_complete.9b1: = require_complete_type %ModWith.type.c6f [symbolic] +// CHECK:STDOUT: %assoc1.e77: %ModWith.assoc_type.e6f = assoc_entity element1, imports.%Core.import_ref.7b7 [symbolic] +// CHECK:STDOUT: %ModWith.lookup_impl_witness.e3f: = lookup_impl_witness %T.a77, @ModWith.1, @ModWith.1(%U.as_type.2b8) [symbolic] +// CHECK:STDOUT: %ModWith.facet.430: %ModWith.type.c6f = facet_value %T.as_type.10f, (%ModWith.lookup_impl_witness.e3f) [symbolic] +// CHECK:STDOUT: %ModWith.WithSelf.Op.type.5b5: type = fn_type @ModWith.WithSelf.Op, @ModWith.WithSelf(%U.as_type.2b8, %ModWith.facet.430) [symbolic] +// CHECK:STDOUT: %.feb: type = fn_type_with_self_type %ModWith.WithSelf.Op.type.5b5, %ModWith.facet.430 [symbolic] +// CHECK:STDOUT: %impl.elem1.1af: %.feb = impl_witness_access %ModWith.lookup_impl_witness.e3f, element1 [symbolic] +// CHECK:STDOUT: %specific_impl_fn.772: = specific_impl_function %impl.elem1.1af, @ModWith.WithSelf.Op(%U.as_type.2b8, %ModWith.facet.430) [symbolic] +// CHECK:STDOUT: %Int16: type = class_type @Int16 [concrete] +// CHECK:STDOUT: %pattern_type.9a4: type = pattern_type %Int16 [concrete] +// CHECK:STDOUT: %Int32: type = class_type @Int32 [concrete] +// CHECK:STDOUT: %pattern_type.9c9: type = pattern_type %Int32 [concrete] +// CHECK:STDOUT: %Int64: type = class_type @Int64 [concrete] +// CHECK:STDOUT: %pattern_type.f42: type = pattern_type %Int64 [concrete] +// CHECK:STDOUT: %int_16: Core.IntLiteral = int_value 16 [concrete] +// CHECK:STDOUT: %i16: type = class_type @Int, @Int(%int_16) [concrete] +// CHECK:STDOUT: %pattern_type.2f8: type = pattern_type %i16 [concrete] +// CHECK:STDOUT: %empty_struct_type: type = struct_type {} [concrete] +// CHECK:STDOUT: %complete_type.357: = complete_type_witness %empty_struct_type [concrete] +// CHECK:STDOUT: %i16.builtin: type = int_type signed, %int_16 [concrete] +// CHECK:STDOUT: %complete_type.2da: = complete_type_witness %i16.builtin [concrete] +// CHECK:STDOUT: %Int16.Op.type.180c8b.1: type = fn_type @Int16.Op.1 [concrete] +// CHECK:STDOUT: %Int16.Op.c3e49c.1: %Int16.Op.type.180c8b.1 = struct_value () [concrete] +// CHECK:STDOUT: %custom_witness.e5b: = custom_witness (%Int16.Op.c3e49c.1), @Destroy [concrete] +// CHECK:STDOUT: %Destroy.facet.e06: %Destroy.type = facet_value %Int16, (%custom_witness.e5b) [concrete] +// CHECK:STDOUT: %facet_type.a81: type = facet_type <@Destroy & @AddWith.1, @AddWith.1(%Int16)> [concrete] +// CHECK:STDOUT: %.Self.0ae: %facet_type.a81 = symbolic_binding .Self [symbolic_self] +// CHECK:STDOUT: %AddWith.lookup_impl_witness.db4: = lookup_impl_witness %.Self.0ae, @AddWith.1, @AddWith.1(%Int16) [symbolic_self] +// CHECK:STDOUT: %impl.elem0.cdb: type = impl_witness_access %AddWith.lookup_impl_witness.db4, element0 [symbolic_self] +// CHECK:STDOUT: %facet_type.e97: type = facet_type <@Destroy & @AddWith.1, @AddWith.1(%Int16) where %impl.elem0.cdb = %Int16> [concrete] +// CHECK:STDOUT: %Destroy.Op.type.bae255.2: type = fn_type @Destroy.Op.loc176_34.2 [concrete] +// CHECK:STDOUT: %Destroy.Op.651ba6.2: %Destroy.Op.type.bae255.2 = struct_value () [concrete] +// CHECK:STDOUT: %custom_witness.8d7fae.2: = custom_witness (%Destroy.Op.651ba6.2), @Destroy [concrete] +// CHECK:STDOUT: %AddWith.type.344: type = facet_type <@AddWith.1, @AddWith.1(%Int16)> [concrete] +// CHECK:STDOUT: %AddWith.assoc_type.f75: type = assoc_entity_type @AddWith.1, @AddWith.1(%Int16) [concrete] +// CHECK:STDOUT: %assoc0.dc9: %AddWith.assoc_type.f75 = assoc_entity element0, imports.%Core.import_ref.6e9 [concrete] +// CHECK:STDOUT: %assoc1.646: %AddWith.assoc_type.f75 = assoc_entity element1, imports.%Core.import_ref.1b1 [concrete] +// CHECK:STDOUT: %Op.type.67547d.1: type = fn_type @Op.1 [concrete] +// CHECK:STDOUT: %Op.8fb557.1: %Op.type.67547d.1 = struct_value () [concrete] +// CHECK:STDOUT: %Destroy.facet.77e: %Destroy.type = facet_value %i16, (%custom_witness.8d7fae.2) [concrete] +// CHECK:STDOUT: %custom_witness.47f: = custom_witness (%Int16, %Op.8fb557.1), @AddWith.1, @AddWith.1(%Int16) [concrete] +// CHECK:STDOUT: %facet_value.c79: %facet_type.e97 = facet_value %i16, (%custom_witness.8d7fae.2, %custom_witness.47f) [concrete] +// CHECK:STDOUT: %complete_type.f61: = complete_type_witness %facet_type.a81 [concrete] +// CHECK:STDOUT: %.Self.as_type.12a0: type = facet_access_type %.Self.0ae [symbolic_self] +// CHECK:STDOUT: %pattern_type.690: type = pattern_type %facet_type.e97 [concrete] +// CHECK:STDOUT: %facet_type.b37: type = facet_type <@Destroy & @SubWith.1, @SubWith.1(%Int16)> [concrete] +// CHECK:STDOUT: %.Self.107: %facet_type.b37 = symbolic_binding .Self [symbolic_self] +// CHECK:STDOUT: %SubWith.lookup_impl_witness.a35: = lookup_impl_witness %.Self.107, @SubWith.1, @SubWith.1(%Int16) [symbolic_self] +// CHECK:STDOUT: %impl.elem0.345: type = impl_witness_access %SubWith.lookup_impl_witness.a35, element0 [symbolic_self] +// CHECK:STDOUT: %facet_type.281: type = facet_type <@Destroy & @SubWith.1, @SubWith.1(%Int16) where %impl.elem0.345 = %Int16> [concrete] +// CHECK:STDOUT: %SubWith.type.306: type = facet_type <@SubWith.1, @SubWith.1(%Int16)> [concrete] +// CHECK:STDOUT: %SubWith.assoc_type.7a2: type = assoc_entity_type @SubWith.1, @SubWith.1(%Int16) [concrete] +// CHECK:STDOUT: %assoc0.f42: %SubWith.assoc_type.7a2 = assoc_entity element0, imports.%Core.import_ref.7e5 [concrete] +// CHECK:STDOUT: %assoc1.2c3: %SubWith.assoc_type.7a2 = assoc_entity element1, imports.%Core.import_ref.abb [concrete] +// CHECK:STDOUT: %Op.type.67547d.2: type = fn_type @Op.2 [concrete] +// CHECK:STDOUT: %Op.8fb557.2: %Op.type.67547d.2 = struct_value () [concrete] +// CHECK:STDOUT: %custom_witness.a7b: = custom_witness (%Int16, %Op.8fb557.2), @SubWith.1, @SubWith.1(%Int16) [concrete] +// CHECK:STDOUT: %facet_value.501: %facet_type.281 = facet_value %i16, (%custom_witness.8d7fae.2, %custom_witness.a7b) [concrete] +// CHECK:STDOUT: %complete_type.5cf: = complete_type_witness %facet_type.b37 [concrete] +// CHECK:STDOUT: %.Self.as_type.e34: type = facet_access_type %.Self.107 [symbolic_self] +// CHECK:STDOUT: %pattern_type.926: type = pattern_type %facet_type.281 [concrete] +// CHECK:STDOUT: %facet_type.2dd: type = facet_type <@Destroy & @MulWith.1, @MulWith.1(%Int16)> [concrete] +// CHECK:STDOUT: %.Self.594: %facet_type.2dd = symbolic_binding .Self [symbolic_self] +// CHECK:STDOUT: %MulWith.lookup_impl_witness.834: = lookup_impl_witness %.Self.594, @MulWith.1, @MulWith.1(%Int16) [symbolic_self] +// CHECK:STDOUT: %impl.elem0.6fb: type = impl_witness_access %MulWith.lookup_impl_witness.834, element0 [symbolic_self] +// CHECK:STDOUT: %facet_type.b7c: type = facet_type <@Destroy & @MulWith.1, @MulWith.1(%Int16) where %impl.elem0.6fb = %Int16> [concrete] +// CHECK:STDOUT: %MulWith.type.0cd: type = facet_type <@MulWith.1, @MulWith.1(%Int16)> [concrete] +// CHECK:STDOUT: %MulWith.assoc_type.f1b: type = assoc_entity_type @MulWith.1, @MulWith.1(%Int16) [concrete] +// CHECK:STDOUT: %assoc0.3ee: %MulWith.assoc_type.f1b = assoc_entity element0, imports.%Core.import_ref.d9b [concrete] +// CHECK:STDOUT: %assoc1.988: %MulWith.assoc_type.f1b = assoc_entity element1, imports.%Core.import_ref.abc [concrete] +// CHECK:STDOUT: %Op.type.67547d.3: type = fn_type @Op.3 [concrete] +// CHECK:STDOUT: %Op.8fb557.3: %Op.type.67547d.3 = struct_value () [concrete] +// CHECK:STDOUT: %custom_witness.e40: = custom_witness (%Int16, %Op.8fb557.3), @MulWith.1, @MulWith.1(%Int16) [concrete] +// CHECK:STDOUT: %facet_value.86a: %facet_type.b7c = facet_value %i16, (%custom_witness.8d7fae.2, %custom_witness.e40) [concrete] +// CHECK:STDOUT: %complete_type.b32: = complete_type_witness %facet_type.2dd [concrete] +// CHECK:STDOUT: %.Self.as_type.674: type = facet_access_type %.Self.594 [symbolic_self] +// CHECK:STDOUT: %pattern_type.401: type = pattern_type %facet_type.b7c [concrete] +// CHECK:STDOUT: %facet_type.e82: type = facet_type <@Destroy & @DivWith.1, @DivWith.1(%Int16)> [concrete] +// CHECK:STDOUT: %.Self.c70: %facet_type.e82 = symbolic_binding .Self [symbolic_self] +// CHECK:STDOUT: %DivWith.lookup_impl_witness.dbb: = lookup_impl_witness %.Self.c70, @DivWith.1, @DivWith.1(%Int16) [symbolic_self] +// CHECK:STDOUT: %impl.elem0.e43: type = impl_witness_access %DivWith.lookup_impl_witness.dbb, element0 [symbolic_self] +// CHECK:STDOUT: %facet_type.a08: type = facet_type <@Destroy & @DivWith.1, @DivWith.1(%Int16) where %impl.elem0.e43 = %Int16> [concrete] +// CHECK:STDOUT: %DivWith.type.4c2: type = facet_type <@DivWith.1, @DivWith.1(%Int16)> [concrete] +// CHECK:STDOUT: %DivWith.assoc_type.9fa: type = assoc_entity_type @DivWith.1, @DivWith.1(%Int16) [concrete] +// CHECK:STDOUT: %assoc0.cf5: %DivWith.assoc_type.9fa = assoc_entity element0, imports.%Core.import_ref.14e [concrete] +// CHECK:STDOUT: %assoc1.cda: %DivWith.assoc_type.9fa = assoc_entity element1, imports.%Core.import_ref.bb2c [concrete] +// CHECK:STDOUT: %Op.type.67547d.4: type = fn_type @Op.4 [concrete] +// CHECK:STDOUT: %Op.8fb557.4: %Op.type.67547d.4 = struct_value () [concrete] +// CHECK:STDOUT: %custom_witness.fb3: = custom_witness (%Int16, %Op.8fb557.4), @DivWith.1, @DivWith.1(%Int16) [concrete] +// CHECK:STDOUT: %facet_value.018: %facet_type.a08 = facet_value %i16, (%custom_witness.8d7fae.2, %custom_witness.fb3) [concrete] +// CHECK:STDOUT: %complete_type.8b32: = complete_type_witness %facet_type.e82 [concrete] +// CHECK:STDOUT: %.Self.as_type.e0e: type = facet_access_type %.Self.c70 [symbolic_self] +// CHECK:STDOUT: %pattern_type.6c0: type = pattern_type %facet_type.a08 [concrete] +// CHECK:STDOUT: %facet_type.e1e: type = facet_type <@Destroy & @ModWith.1, @ModWith.1(%Int16)> [concrete] +// CHECK:STDOUT: %.Self.76e: %facet_type.e1e = symbolic_binding .Self [symbolic_self] +// CHECK:STDOUT: %ModWith.lookup_impl_witness.c6b: = lookup_impl_witness %.Self.76e, @ModWith.1, @ModWith.1(%Int16) [symbolic_self] +// CHECK:STDOUT: %impl.elem0.cba: type = impl_witness_access %ModWith.lookup_impl_witness.c6b, element0 [symbolic_self] +// CHECK:STDOUT: %facet_type.469: type = facet_type <@Destroy & @ModWith.1, @ModWith.1(%Int16) where %impl.elem0.cba = %Int16> [concrete] +// CHECK:STDOUT: %ModWith.type.009: type = facet_type <@ModWith.1, @ModWith.1(%Int16)> [concrete] +// CHECK:STDOUT: %ModWith.assoc_type.355: type = assoc_entity_type @ModWith.1, @ModWith.1(%Int16) [concrete] +// CHECK:STDOUT: %assoc0.0f7: %ModWith.assoc_type.355 = assoc_entity element0, imports.%Core.import_ref.a0d [concrete] +// CHECK:STDOUT: %assoc1.c82: %ModWith.assoc_type.355 = assoc_entity element1, imports.%Core.import_ref.c05 [concrete] +// CHECK:STDOUT: %Op.type.67547d.5: type = fn_type @Op.5 [concrete] +// CHECK:STDOUT: %Op.8fb557.5: %Op.type.67547d.5 = struct_value () [concrete] +// CHECK:STDOUT: %custom_witness.69e: = custom_witness (%Int16, %Op.8fb557.5), @ModWith.1, @ModWith.1(%Int16) [concrete] +// CHECK:STDOUT: %facet_value.ee6: %facet_type.469 = facet_value %i16, (%custom_witness.8d7fae.2, %custom_witness.69e) [concrete] +// CHECK:STDOUT: %complete_type.5b6: = complete_type_witness %facet_type.e1e [concrete] +// CHECK:STDOUT: %.Self.as_type.242: type = facet_access_type %.Self.76e [symbolic_self] +// CHECK:STDOUT: %pattern_type.13c: type = pattern_type %facet_type.469 [concrete] +// CHECK:STDOUT: %facet_type.8b1: type = facet_type <@Destroy & @AddWith.1, @AddWith.1(%i16)> [concrete] +// CHECK:STDOUT: %.Self.ba7: %facet_type.8b1 = symbolic_binding .Self [symbolic_self] +// CHECK:STDOUT: %AddWith.lookup_impl_witness.d8b: = lookup_impl_witness %.Self.ba7, @AddWith.1, @AddWith.1(%i16) [symbolic_self] +// CHECK:STDOUT: %impl.elem0.265: type = impl_witness_access %AddWith.lookup_impl_witness.d8b, element0 [symbolic_self] +// CHECK:STDOUT: %facet_type.731: type = facet_type <@Destroy & @AddWith.1, @AddWith.1(%i16) where %impl.elem0.265 = %Int16> [concrete] +// CHECK:STDOUT: %AddWith.type.a18: type = facet_type <@AddWith.1, @AddWith.1(%i16)> [concrete] +// CHECK:STDOUT: %AddWith.assoc_type.4f0: type = assoc_entity_type @AddWith.1, @AddWith.1(%i16) [concrete] +// CHECK:STDOUT: %assoc0.ba6: %AddWith.assoc_type.4f0 = assoc_entity element0, imports.%Core.import_ref.6e9 [concrete] +// CHECK:STDOUT: %assoc1.88d: %AddWith.assoc_type.4f0 = assoc_entity element1, imports.%Core.import_ref.1b1 [concrete] +// CHECK:STDOUT: %Int16.Op.type.180c8b.3: type = fn_type @Int16.Op.3 [concrete] +// CHECK:STDOUT: %Int16.Op.c3e49c.3: %Int16.Op.type.180c8b.3 = struct_value () [concrete] +// CHECK:STDOUT: %custom_witness.096: = custom_witness (%Int16, %Int16.Op.c3e49c.3), @AddWith.1, @AddWith.1(%i16) [concrete] +// CHECK:STDOUT: %facet_value.dd6: %facet_type.731 = facet_value %Int16, (%custom_witness.e5b, %custom_witness.096) [concrete] +// CHECK:STDOUT: %complete_type.59d: = complete_type_witness %facet_type.8b1 [concrete] +// CHECK:STDOUT: %.Self.as_type.f28: type = facet_access_type %.Self.ba7 [symbolic_self] +// CHECK:STDOUT: %pattern_type.336: type = pattern_type %facet_type.731 [concrete] +// CHECK:STDOUT: %facet_type.bd5: type = facet_type <@Destroy & @SubWith.1, @SubWith.1(%i16)> [concrete] +// CHECK:STDOUT: %.Self.d04: %facet_type.bd5 = symbolic_binding .Self [symbolic_self] +// CHECK:STDOUT: %SubWith.lookup_impl_witness.029: = lookup_impl_witness %.Self.d04, @SubWith.1, @SubWith.1(%i16) [symbolic_self] +// CHECK:STDOUT: %impl.elem0.e59: type = impl_witness_access %SubWith.lookup_impl_witness.029, element0 [symbolic_self] +// CHECK:STDOUT: %facet_type.257: type = facet_type <@Destroy & @SubWith.1, @SubWith.1(%i16) where %impl.elem0.e59 = %Int16> [concrete] +// CHECK:STDOUT: %SubWith.type.a1b: type = facet_type <@SubWith.1, @SubWith.1(%i16)> [concrete] +// CHECK:STDOUT: %SubWith.assoc_type.108: type = assoc_entity_type @SubWith.1, @SubWith.1(%i16) [concrete] +// CHECK:STDOUT: %assoc0.053: %SubWith.assoc_type.108 = assoc_entity element0, imports.%Core.import_ref.7e5 [concrete] +// CHECK:STDOUT: %assoc1.ef4: %SubWith.assoc_type.108 = assoc_entity element1, imports.%Core.import_ref.abb [concrete] +// CHECK:STDOUT: %Int16.Op.type.180c8b.4: type = fn_type @Int16.Op.4 [concrete] +// CHECK:STDOUT: %Int16.Op.c3e49c.4: %Int16.Op.type.180c8b.4 = struct_value () [concrete] +// CHECK:STDOUT: %custom_witness.ced: = custom_witness (%Int16, %Int16.Op.c3e49c.4), @SubWith.1, @SubWith.1(%i16) [concrete] +// CHECK:STDOUT: %facet_value.3f5: %facet_type.257 = facet_value %Int16, (%custom_witness.e5b, %custom_witness.ced) [concrete] +// CHECK:STDOUT: %complete_type.d4c: = complete_type_witness %facet_type.bd5 [concrete] +// CHECK:STDOUT: %.Self.as_type.d0c7: type = facet_access_type %.Self.d04 [symbolic_self] +// CHECK:STDOUT: %pattern_type.021: type = pattern_type %facet_type.257 [concrete] +// CHECK:STDOUT: %facet_type.5ca: type = facet_type <@Destroy & @MulWith.1, @MulWith.1(%i16)> [concrete] +// CHECK:STDOUT: %.Self.3cf: %facet_type.5ca = symbolic_binding .Self [symbolic_self] +// CHECK:STDOUT: %MulWith.lookup_impl_witness.aee: = lookup_impl_witness %.Self.3cf, @MulWith.1, @MulWith.1(%i16) [symbolic_self] +// CHECK:STDOUT: %impl.elem0.5d1: type = impl_witness_access %MulWith.lookup_impl_witness.aee, element0 [symbolic_self] +// CHECK:STDOUT: %facet_type.865: type = facet_type <@Destroy & @MulWith.1, @MulWith.1(%i16) where %impl.elem0.5d1 = %Int16> [concrete] +// CHECK:STDOUT: %MulWith.type.ee9: type = facet_type <@MulWith.1, @MulWith.1(%i16)> [concrete] +// CHECK:STDOUT: %MulWith.assoc_type.aae: type = assoc_entity_type @MulWith.1, @MulWith.1(%i16) [concrete] +// CHECK:STDOUT: %assoc0.4d95: %MulWith.assoc_type.aae = assoc_entity element0, imports.%Core.import_ref.d9b [concrete] +// CHECK:STDOUT: %assoc1.587: %MulWith.assoc_type.aae = assoc_entity element1, imports.%Core.import_ref.abc [concrete] +// CHECK:STDOUT: %Int16.Op.type.180c8b.5: type = fn_type @Int16.Op.5 [concrete] +// CHECK:STDOUT: %Int16.Op.c3e49c.5: %Int16.Op.type.180c8b.5 = struct_value () [concrete] +// CHECK:STDOUT: %custom_witness.270: = custom_witness (%Int16, %Int16.Op.c3e49c.5), @MulWith.1, @MulWith.1(%i16) [concrete] +// CHECK:STDOUT: %facet_value.4ca: %facet_type.865 = facet_value %Int16, (%custom_witness.e5b, %custom_witness.270) [concrete] +// CHECK:STDOUT: %complete_type.d8f: = complete_type_witness %facet_type.5ca [concrete] +// CHECK:STDOUT: %.Self.as_type.4dc: type = facet_access_type %.Self.3cf [symbolic_self] +// CHECK:STDOUT: %pattern_type.038: type = pattern_type %facet_type.865 [concrete] +// CHECK:STDOUT: %facet_type.014: type = facet_type <@Destroy & @DivWith.1, @DivWith.1(%i16)> [concrete] +// CHECK:STDOUT: %.Self.197: %facet_type.014 = symbolic_binding .Self [symbolic_self] +// CHECK:STDOUT: %DivWith.lookup_impl_witness.834: = lookup_impl_witness %.Self.197, @DivWith.1, @DivWith.1(%i16) [symbolic_self] +// CHECK:STDOUT: %impl.elem0.146: type = impl_witness_access %DivWith.lookup_impl_witness.834, element0 [symbolic_self] +// CHECK:STDOUT: %facet_type.c20: type = facet_type <@Destroy & @DivWith.1, @DivWith.1(%i16) where %impl.elem0.146 = %Int16> [concrete] +// CHECK:STDOUT: %DivWith.type.9ae: type = facet_type <@DivWith.1, @DivWith.1(%i16)> [concrete] +// CHECK:STDOUT: %DivWith.assoc_type.e80: type = assoc_entity_type @DivWith.1, @DivWith.1(%i16) [concrete] +// CHECK:STDOUT: %assoc0.75e: %DivWith.assoc_type.e80 = assoc_entity element0, imports.%Core.import_ref.14e [concrete] +// CHECK:STDOUT: %assoc1.9ae: %DivWith.assoc_type.e80 = assoc_entity element1, imports.%Core.import_ref.bb2c [concrete] +// CHECK:STDOUT: %Int16.Op.type.180c8b.6: type = fn_type @Int16.Op.6 [concrete] +// CHECK:STDOUT: %Int16.Op.c3e49c.6: %Int16.Op.type.180c8b.6 = struct_value () [concrete] +// CHECK:STDOUT: %custom_witness.462: = custom_witness (%Int16, %Int16.Op.c3e49c.6), @DivWith.1, @DivWith.1(%i16) [concrete] +// CHECK:STDOUT: %facet_value.ff9: %facet_type.c20 = facet_value %Int16, (%custom_witness.e5b, %custom_witness.462) [concrete] +// CHECK:STDOUT: %complete_type.b92: = complete_type_witness %facet_type.014 [concrete] +// CHECK:STDOUT: %.Self.as_type.2e1: type = facet_access_type %.Self.197 [symbolic_self] +// CHECK:STDOUT: %pattern_type.8c5: type = pattern_type %facet_type.c20 [concrete] +// CHECK:STDOUT: %facet_type.fe7: type = facet_type <@Destroy & @ModWith.1, @ModWith.1(%i16)> [concrete] +// CHECK:STDOUT: %.Self.7d0: %facet_type.fe7 = symbolic_binding .Self [symbolic_self] +// CHECK:STDOUT: %ModWith.lookup_impl_witness.ff6: = lookup_impl_witness %.Self.7d0, @ModWith.1, @ModWith.1(%i16) [symbolic_self] +// CHECK:STDOUT: %impl.elem0.f78: type = impl_witness_access %ModWith.lookup_impl_witness.ff6, element0 [symbolic_self] +// CHECK:STDOUT: %facet_type.a93: type = facet_type <@Destroy & @ModWith.1, @ModWith.1(%i16) where %impl.elem0.f78 = %Int16> [concrete] +// CHECK:STDOUT: %ModWith.type.406: type = facet_type <@ModWith.1, @ModWith.1(%i16)> [concrete] +// CHECK:STDOUT: %ModWith.assoc_type.ffe: type = assoc_entity_type @ModWith.1, @ModWith.1(%i16) [concrete] +// CHECK:STDOUT: %assoc0.b49: %ModWith.assoc_type.ffe = assoc_entity element0, imports.%Core.import_ref.a0d [concrete] +// CHECK:STDOUT: %assoc1.d40: %ModWith.assoc_type.ffe = assoc_entity element1, imports.%Core.import_ref.c05 [concrete] +// CHECK:STDOUT: %Int16.Op.type.180c8b.7: type = fn_type @Int16.Op.7 [concrete] +// CHECK:STDOUT: %Int16.Op.c3e49c.7: %Int16.Op.type.180c8b.7 = struct_value () [concrete] +// CHECK:STDOUT: %custom_witness.84d2: = custom_witness (%Int16, %Int16.Op.c3e49c.7), @ModWith.1, @ModWith.1(%i16) [concrete] +// CHECK:STDOUT: %facet_value.f56: %facet_type.a93 = facet_value %Int16, (%custom_witness.e5b, %custom_witness.84d2) [concrete] +// CHECK:STDOUT: %complete_type.dfc: = complete_type_witness %facet_type.fe7 [concrete] +// CHECK:STDOUT: %.Self.as_type.81b: type = facet_access_type %.Self.7d0 [symbolic_self] +// CHECK:STDOUT: %pattern_type.0e2: type = pattern_type %facet_type.a93 [concrete] +// CHECK:STDOUT: %Int32.Op.type.68b858.1: type = fn_type @Int32.Op.1 [concrete] +// CHECK:STDOUT: %Int32.Op.6afff1.1: %Int32.Op.type.68b858.1 = struct_value () [concrete] +// CHECK:STDOUT: %custom_witness.ce1: = custom_witness (%Int32.Op.6afff1.1), @Destroy [concrete] +// CHECK:STDOUT: %Destroy.facet.c06: %Destroy.type = facet_value %Int32, (%custom_witness.ce1) [concrete] +// CHECK:STDOUT: %facet_type.4a7: type = facet_type <@Destroy & @AddWith.1, @AddWith.1(%Int32)> [concrete] +// CHECK:STDOUT: %.Self.3d9: %facet_type.4a7 = symbolic_binding .Self [symbolic_self] +// CHECK:STDOUT: %AddWith.lookup_impl_witness.632: = lookup_impl_witness %.Self.3d9, @AddWith.1, @AddWith.1(%Int32) [symbolic_self] +// CHECK:STDOUT: %impl.elem0.cee: type = impl_witness_access %AddWith.lookup_impl_witness.632, element0 [symbolic_self] +// CHECK:STDOUT: %facet_type.14d: type = facet_type <@Destroy & @AddWith.1, @AddWith.1(%Int32) where %impl.elem0.cee = %Int32> [concrete] +// CHECK:STDOUT: %AddWith.type.e9e: type = facet_type <@AddWith.1, @AddWith.1(%Int32)> [concrete] +// CHECK:STDOUT: %AddWith.assoc_type.29a: type = assoc_entity_type @AddWith.1, @AddWith.1(%Int32) [concrete] +// CHECK:STDOUT: %assoc0.701: %AddWith.assoc_type.29a = assoc_entity element0, imports.%Core.import_ref.6e9 [concrete] +// CHECK:STDOUT: %assoc1.38b: %AddWith.assoc_type.29a = assoc_entity element1, imports.%Core.import_ref.1b1 [concrete] +// CHECK:STDOUT: %Int16.Op.type.180c8b.8: type = fn_type @Int16.Op.8 [concrete] +// CHECK:STDOUT: %Int16.Op.c3e49c.8: %Int16.Op.type.180c8b.8 = struct_value () [concrete] +// CHECK:STDOUT: %custom_witness.200: = custom_witness (%Int32, %Int16.Op.c3e49c.8), @AddWith.1, @AddWith.1(%Int32) [concrete] +// CHECK:STDOUT: %facet_value.2b7: %facet_type.14d = facet_value %Int16, (%custom_witness.e5b, %custom_witness.200) [concrete] +// CHECK:STDOUT: %complete_type.0d9: = complete_type_witness %facet_type.4a7 [concrete] +// CHECK:STDOUT: %.Self.as_type.7ba: type = facet_access_type %.Self.3d9 [symbolic_self] +// CHECK:STDOUT: %pattern_type.3f9: type = pattern_type %facet_type.14d [concrete] +// CHECK:STDOUT: %facet_type.e7a: type = facet_type <@Destroy & @SubWith.1, @SubWith.1(%Int32)> [concrete] +// CHECK:STDOUT: %.Self.384: %facet_type.e7a = symbolic_binding .Self [symbolic_self] +// CHECK:STDOUT: %SubWith.lookup_impl_witness.b61: = lookup_impl_witness %.Self.384, @SubWith.1, @SubWith.1(%Int32) [symbolic_self] +// CHECK:STDOUT: %impl.elem0.edd: type = impl_witness_access %SubWith.lookup_impl_witness.b61, element0 [symbolic_self] +// CHECK:STDOUT: %facet_type.f15: type = facet_type <@Destroy & @SubWith.1, @SubWith.1(%Int32) where %impl.elem0.edd = %Int32> [concrete] +// CHECK:STDOUT: %SubWith.type.84c: type = facet_type <@SubWith.1, @SubWith.1(%Int32)> [concrete] +// CHECK:STDOUT: %SubWith.assoc_type.0f9: type = assoc_entity_type @SubWith.1, @SubWith.1(%Int32) [concrete] +// CHECK:STDOUT: %assoc0.1e9: %SubWith.assoc_type.0f9 = assoc_entity element0, imports.%Core.import_ref.7e5 [concrete] +// CHECK:STDOUT: %assoc1.714: %SubWith.assoc_type.0f9 = assoc_entity element1, imports.%Core.import_ref.abb [concrete] +// CHECK:STDOUT: %Int16.Op.type.180c8b.9: type = fn_type @Int16.Op.9 [concrete] +// CHECK:STDOUT: %Int16.Op.c3e49c.9: %Int16.Op.type.180c8b.9 = struct_value () [concrete] +// CHECK:STDOUT: %custom_witness.103: = custom_witness (%Int32, %Int16.Op.c3e49c.9), @SubWith.1, @SubWith.1(%Int32) [concrete] +// CHECK:STDOUT: %facet_value.7d7: %facet_type.f15 = facet_value %Int16, (%custom_witness.e5b, %custom_witness.103) [concrete] +// CHECK:STDOUT: %complete_type.a34: = complete_type_witness %facet_type.e7a [concrete] +// CHECK:STDOUT: %.Self.as_type.45d: type = facet_access_type %.Self.384 [symbolic_self] +// CHECK:STDOUT: %pattern_type.56e: type = pattern_type %facet_type.f15 [concrete] +// CHECK:STDOUT: %facet_type.2e6: type = facet_type <@Destroy & @MulWith.1, @MulWith.1(%Int32)> [concrete] +// CHECK:STDOUT: %.Self.84b: %facet_type.2e6 = symbolic_binding .Self [symbolic_self] +// CHECK:STDOUT: %MulWith.lookup_impl_witness.539: = lookup_impl_witness %.Self.84b, @MulWith.1, @MulWith.1(%Int32) [symbolic_self] +// CHECK:STDOUT: %impl.elem0.e63: type = impl_witness_access %MulWith.lookup_impl_witness.539, element0 [symbolic_self] +// CHECK:STDOUT: %facet_type.c22: type = facet_type <@Destroy & @MulWith.1, @MulWith.1(%Int32) where %impl.elem0.e63 = %Int32> [concrete] +// CHECK:STDOUT: %MulWith.type.d1b: type = facet_type <@MulWith.1, @MulWith.1(%Int32)> [concrete] +// CHECK:STDOUT: %MulWith.assoc_type.8c6: type = assoc_entity_type @MulWith.1, @MulWith.1(%Int32) [concrete] +// CHECK:STDOUT: %assoc0.a8f: %MulWith.assoc_type.8c6 = assoc_entity element0, imports.%Core.import_ref.d9b [concrete] +// CHECK:STDOUT: %assoc1.6bc: %MulWith.assoc_type.8c6 = assoc_entity element1, imports.%Core.import_ref.abc [concrete] +// CHECK:STDOUT: %Int16.Op.type.180c8b.10: type = fn_type @Int16.Op.10 [concrete] +// CHECK:STDOUT: %Int16.Op.c3e49c.10: %Int16.Op.type.180c8b.10 = struct_value () [concrete] +// CHECK:STDOUT: %custom_witness.a6d: = custom_witness (%Int32, %Int16.Op.c3e49c.10), @MulWith.1, @MulWith.1(%Int32) [concrete] +// CHECK:STDOUT: %facet_value.75c: %facet_type.c22 = facet_value %Int16, (%custom_witness.e5b, %custom_witness.a6d) [concrete] +// CHECK:STDOUT: %complete_type.043: = complete_type_witness %facet_type.2e6 [concrete] +// CHECK:STDOUT: %.Self.as_type.d0cd: type = facet_access_type %.Self.84b [symbolic_self] +// CHECK:STDOUT: %pattern_type.965: type = pattern_type %facet_type.c22 [concrete] +// CHECK:STDOUT: %facet_type.eb5: type = facet_type <@Destroy & @DivWith.1, @DivWith.1(%Int32)> [concrete] +// CHECK:STDOUT: %.Self.203: %facet_type.eb5 = symbolic_binding .Self [symbolic_self] +// CHECK:STDOUT: %DivWith.lookup_impl_witness.512: = lookup_impl_witness %.Self.203, @DivWith.1, @DivWith.1(%Int32) [symbolic_self] +// CHECK:STDOUT: %impl.elem0.232: type = impl_witness_access %DivWith.lookup_impl_witness.512, element0 [symbolic_self] +// CHECK:STDOUT: %facet_type.529: type = facet_type <@Destroy & @DivWith.1, @DivWith.1(%Int32) where %impl.elem0.232 = %Int32> [concrete] +// CHECK:STDOUT: %DivWith.type.26e: type = facet_type <@DivWith.1, @DivWith.1(%Int32)> [concrete] +// CHECK:STDOUT: %DivWith.assoc_type.109: type = assoc_entity_type @DivWith.1, @DivWith.1(%Int32) [concrete] +// CHECK:STDOUT: %assoc0.d76: %DivWith.assoc_type.109 = assoc_entity element0, imports.%Core.import_ref.14e [concrete] +// CHECK:STDOUT: %assoc1.4a0: %DivWith.assoc_type.109 = assoc_entity element1, imports.%Core.import_ref.bb2c [concrete] +// CHECK:STDOUT: %Int16.Op.type.180c8b.11: type = fn_type @Int16.Op.11 [concrete] +// CHECK:STDOUT: %Int16.Op.c3e49c.11: %Int16.Op.type.180c8b.11 = struct_value () [concrete] +// CHECK:STDOUT: %custom_witness.510: = custom_witness (%Int32, %Int16.Op.c3e49c.11), @DivWith.1, @DivWith.1(%Int32) [concrete] +// CHECK:STDOUT: %facet_value.85a: %facet_type.529 = facet_value %Int16, (%custom_witness.e5b, %custom_witness.510) [concrete] +// CHECK:STDOUT: %complete_type.d76: = complete_type_witness %facet_type.eb5 [concrete] +// CHECK:STDOUT: %.Self.as_type.f8e: type = facet_access_type %.Self.203 [symbolic_self] +// CHECK:STDOUT: %pattern_type.04c: type = pattern_type %facet_type.529 [concrete] +// CHECK:STDOUT: %facet_type.1e6: type = facet_type <@Destroy & @ModWith.1, @ModWith.1(%Int32)> [concrete] +// CHECK:STDOUT: %.Self.0c5: %facet_type.1e6 = symbolic_binding .Self [symbolic_self] +// CHECK:STDOUT: %ModWith.lookup_impl_witness.9f7: = lookup_impl_witness %.Self.0c5, @ModWith.1, @ModWith.1(%Int32) [symbolic_self] +// CHECK:STDOUT: %impl.elem0.919: type = impl_witness_access %ModWith.lookup_impl_witness.9f7, element0 [symbolic_self] +// CHECK:STDOUT: %facet_type.422: type = facet_type <@Destroy & @ModWith.1, @ModWith.1(%Int32) where %impl.elem0.919 = %Int32> [concrete] +// CHECK:STDOUT: %ModWith.type.5c4: type = facet_type <@ModWith.1, @ModWith.1(%Int32)> [concrete] +// CHECK:STDOUT: %ModWith.assoc_type.1db: type = assoc_entity_type @ModWith.1, @ModWith.1(%Int32) [concrete] +// CHECK:STDOUT: %assoc0.8e2: %ModWith.assoc_type.1db = assoc_entity element0, imports.%Core.import_ref.a0d [concrete] +// CHECK:STDOUT: %assoc1.826: %ModWith.assoc_type.1db = assoc_entity element1, imports.%Core.import_ref.c05 [concrete] +// CHECK:STDOUT: %Int16.Op.type.180c8b.12: type = fn_type @Int16.Op.12 [concrete] +// CHECK:STDOUT: %Int16.Op.c3e49c.12: %Int16.Op.type.180c8b.12 = struct_value () [concrete] +// CHECK:STDOUT: %custom_witness.a62: = custom_witness (%Int32, %Int16.Op.c3e49c.12), @ModWith.1, @ModWith.1(%Int32) [concrete] +// CHECK:STDOUT: %facet_value.dd3: %facet_type.422 = facet_value %Int16, (%custom_witness.e5b, %custom_witness.a62) [concrete] +// CHECK:STDOUT: %complete_type.1bb: = complete_type_witness %facet_type.1e6 [concrete] +// CHECK:STDOUT: %.Self.as_type.ef1: type = facet_access_type %.Self.0c5 [symbolic_self] +// CHECK:STDOUT: %pattern_type.4d3: type = pattern_type %facet_type.422 [concrete] +// CHECK:STDOUT: %facet_type.b0a: type = facet_type <@Destroy & @AddWith.1, @AddWith.1(%Int16) where %impl.elem0.cdb = %Int32> [concrete] +// CHECK:STDOUT: %Int32.Op.type.68b858.2: type = fn_type @Int32.Op.2 [concrete] +// CHECK:STDOUT: %Int32.Op.6afff1.2: %Int32.Op.type.68b858.2 = struct_value () [concrete] +// CHECK:STDOUT: %custom_witness.116: = custom_witness (%Int32, %Int32.Op.6afff1.2), @AddWith.1, @AddWith.1(%Int16) [concrete] +// CHECK:STDOUT: %facet_value.741: %facet_type.b0a = facet_value %Int32, (%custom_witness.ce1, %custom_witness.116) [concrete] +// CHECK:STDOUT: %pattern_type.e21: type = pattern_type %facet_type.b0a [concrete] +// CHECK:STDOUT: %facet_type.afb: type = facet_type <@Destroy & @SubWith.1, @SubWith.1(%Int16) where %impl.elem0.345 = %Int32> [concrete] +// CHECK:STDOUT: %Int32.Op.type.68b858.3: type = fn_type @Int32.Op.3 [concrete] +// CHECK:STDOUT: %Int32.Op.6afff1.3: %Int32.Op.type.68b858.3 = struct_value () [concrete] +// CHECK:STDOUT: %custom_witness.904: = custom_witness (%Int32, %Int32.Op.6afff1.3), @SubWith.1, @SubWith.1(%Int16) [concrete] +// CHECK:STDOUT: %facet_value.f31: %facet_type.afb = facet_value %Int32, (%custom_witness.ce1, %custom_witness.904) [concrete] +// CHECK:STDOUT: %pattern_type.6ad: type = pattern_type %facet_type.afb [concrete] +// CHECK:STDOUT: %facet_type.bfe: type = facet_type <@Destroy & @MulWith.1, @MulWith.1(%Int16) where %impl.elem0.6fb = %Int32> [concrete] +// CHECK:STDOUT: %Int32.Op.type.68b858.4: type = fn_type @Int32.Op.4 [concrete] +// CHECK:STDOUT: %Int32.Op.6afff1.4: %Int32.Op.type.68b858.4 = struct_value () [concrete] +// CHECK:STDOUT: %custom_witness.04f: = custom_witness (%Int32, %Int32.Op.6afff1.4), @MulWith.1, @MulWith.1(%Int16) [concrete] +// CHECK:STDOUT: %facet_value.daa: %facet_type.bfe = facet_value %Int32, (%custom_witness.ce1, %custom_witness.04f) [concrete] +// CHECK:STDOUT: %pattern_type.8a2: type = pattern_type %facet_type.bfe [concrete] +// CHECK:STDOUT: %facet_type.917: type = facet_type <@Destroy & @DivWith.1, @DivWith.1(%Int16) where %impl.elem0.e43 = %Int32> [concrete] +// CHECK:STDOUT: %Int32.Op.type.68b858.5: type = fn_type @Int32.Op.5 [concrete] +// CHECK:STDOUT: %Int32.Op.6afff1.5: %Int32.Op.type.68b858.5 = struct_value () [concrete] +// CHECK:STDOUT: %custom_witness.53b: = custom_witness (%Int32, %Int32.Op.6afff1.5), @DivWith.1, @DivWith.1(%Int16) [concrete] +// CHECK:STDOUT: %facet_value.437: %facet_type.917 = facet_value %Int32, (%custom_witness.ce1, %custom_witness.53b) [concrete] +// CHECK:STDOUT: %pattern_type.b7f: type = pattern_type %facet_type.917 [concrete] +// CHECK:STDOUT: %facet_type.d08: type = facet_type <@Destroy & @ModWith.1, @ModWith.1(%Int16) where %impl.elem0.cba = %Int32> [concrete] +// CHECK:STDOUT: %Int32.Op.type.68b858.6: type = fn_type @Int32.Op.6 [concrete] +// CHECK:STDOUT: %Int32.Op.6afff1.6: %Int32.Op.type.68b858.6 = struct_value () [concrete] +// CHECK:STDOUT: %custom_witness.895: = custom_witness (%Int32, %Int32.Op.6afff1.6), @ModWith.1, @ModWith.1(%Int16) [concrete] +// CHECK:STDOUT: %facet_value.9f1: %facet_type.d08 = facet_value %Int32, (%custom_witness.ce1, %custom_witness.895) [concrete] +// CHECK:STDOUT: %pattern_type.a04: type = pattern_type %facet_type.d08 [concrete] +// CHECK:STDOUT: %Int32.Op.type.68b858.7: type = fn_type @Int32.Op.7 [concrete] +// CHECK:STDOUT: %Int32.Op.6afff1.7: %Int32.Op.type.68b858.7 = struct_value () [concrete] +// CHECK:STDOUT: %custom_witness.78d: = custom_witness (%Int32, %Int32.Op.6afff1.7), @AddWith.1, @AddWith.1(%Int32) [concrete] +// CHECK:STDOUT: %facet_value.fca: %facet_type.14d = facet_value %Int32, (%custom_witness.ce1, %custom_witness.78d) [concrete] +// CHECK:STDOUT: %Int32.Op.type.68b858.8: type = fn_type @Int32.Op.8 [concrete] +// CHECK:STDOUT: %Int32.Op.6afff1.8: %Int32.Op.type.68b858.8 = struct_value () [concrete] +// CHECK:STDOUT: %custom_witness.64d: = custom_witness (%Int32, %Int32.Op.6afff1.8), @SubWith.1, @SubWith.1(%Int32) [concrete] +// CHECK:STDOUT: %facet_value.9a9: %facet_type.f15 = facet_value %Int32, (%custom_witness.ce1, %custom_witness.64d) [concrete] +// CHECK:STDOUT: %Int32.Op.type.68b858.9: type = fn_type @Int32.Op.9 [concrete] +// CHECK:STDOUT: %Int32.Op.6afff1.9: %Int32.Op.type.68b858.9 = struct_value () [concrete] +// CHECK:STDOUT: %custom_witness.7b6d: = custom_witness (%Int32, %Int32.Op.6afff1.9), @MulWith.1, @MulWith.1(%Int32) [concrete] +// CHECK:STDOUT: %facet_value.03b: %facet_type.c22 = facet_value %Int32, (%custom_witness.ce1, %custom_witness.7b6d) [concrete] +// CHECK:STDOUT: %Int32.Op.type.68b858.10: type = fn_type @Int32.Op.10 [concrete] +// CHECK:STDOUT: %Int32.Op.6afff1.10: %Int32.Op.type.68b858.10 = struct_value () [concrete] +// CHECK:STDOUT: %custom_witness.db6: = custom_witness (%Int32, %Int32.Op.6afff1.10), @DivWith.1, @DivWith.1(%Int32) [concrete] +// CHECK:STDOUT: %facet_value.a2b: %facet_type.529 = facet_value %Int32, (%custom_witness.ce1, %custom_witness.db6) [concrete] +// CHECK:STDOUT: %Int32.Op.type.68b858.11: type = fn_type @Int32.Op.11 [concrete] +// CHECK:STDOUT: %Int32.Op.6afff1.11: %Int32.Op.type.68b858.11 = struct_value () [concrete] +// CHECK:STDOUT: %custom_witness.e01: = custom_witness (%Int32, %Int32.Op.6afff1.11), @ModWith.1, @ModWith.1(%Int32) [concrete] +// CHECK:STDOUT: %facet_value.a4c: %facet_type.422 = facet_value %Int32, (%custom_witness.ce1, %custom_witness.e01) [concrete] +// CHECK:STDOUT: %Int64.Op.type.445ce8.1: type = fn_type @Int64.Op.1 [concrete] +// CHECK:STDOUT: %Int64.Op.b941da.1: %Int64.Op.type.445ce8.1 = struct_value () [concrete] +// CHECK:STDOUT: %custom_witness.d7e: = custom_witness (%Int64.Op.b941da.1), @Destroy [concrete] +// CHECK:STDOUT: %Destroy.facet.b0a: %Destroy.type = facet_value %Int64, (%custom_witness.d7e) [concrete] +// CHECK:STDOUT: %facet_type.221: type = facet_type <@Destroy & @AddWith.1, @AddWith.1(%Int64)> [concrete] +// CHECK:STDOUT: %.Self.954: %facet_type.221 = symbolic_binding .Self [symbolic_self] +// CHECK:STDOUT: %AddWith.lookup_impl_witness.076: = lookup_impl_witness %.Self.954, @AddWith.1, @AddWith.1(%Int64) [symbolic_self] +// CHECK:STDOUT: %impl.elem0.d09: type = impl_witness_access %AddWith.lookup_impl_witness.076, element0 [symbolic_self] +// CHECK:STDOUT: %facet_type.7b1: type = facet_type <@Destroy & @AddWith.1, @AddWith.1(%Int64) where %impl.elem0.d09 = %Int64> [concrete] +// CHECK:STDOUT: %AddWith.type.ee5: type = facet_type <@AddWith.1, @AddWith.1(%Int64)> [concrete] +// CHECK:STDOUT: %AddWith.assoc_type.330: type = assoc_entity_type @AddWith.1, @AddWith.1(%Int64) [concrete] +// CHECK:STDOUT: %assoc0.1fe: %AddWith.assoc_type.330 = assoc_entity element0, imports.%Core.import_ref.6e9 [concrete] +// CHECK:STDOUT: %assoc1.cd6: %AddWith.assoc_type.330 = assoc_entity element1, imports.%Core.import_ref.1b1 [concrete] +// CHECK:STDOUT: %Op.type.67547d.6: type = fn_type @Op.6 [concrete] +// CHECK:STDOUT: %Op.8fb557.6: %Op.type.67547d.6 = struct_value () [concrete] +// CHECK:STDOUT: %custom_witness.1b7: = custom_witness (%Int64, %Op.8fb557.6), @AddWith.1, @AddWith.1(%Int64) [concrete] +// CHECK:STDOUT: %facet_value.054: %facet_type.7b1 = facet_value %Int32, (%custom_witness.ce1, %custom_witness.1b7) [concrete] +// CHECK:STDOUT: %complete_type.7fa: = complete_type_witness %facet_type.221 [concrete] +// CHECK:STDOUT: %.Self.as_type.083: type = facet_access_type %.Self.954 [symbolic_self] +// CHECK:STDOUT: %pattern_type.aa1: type = pattern_type %facet_type.7b1 [concrete] +// CHECK:STDOUT: %facet_type.660: type = facet_type <@Destroy & @SubWith.1, @SubWith.1(%Int64)> [concrete] +// CHECK:STDOUT: %.Self.ea7: %facet_type.660 = symbolic_binding .Self [symbolic_self] +// CHECK:STDOUT: %SubWith.lookup_impl_witness.894: = lookup_impl_witness %.Self.ea7, @SubWith.1, @SubWith.1(%Int64) [symbolic_self] +// CHECK:STDOUT: %impl.elem0.9dd: type = impl_witness_access %SubWith.lookup_impl_witness.894, element0 [symbolic_self] +// CHECK:STDOUT: %facet_type.17a: type = facet_type <@Destroy & @SubWith.1, @SubWith.1(%Int64) where %impl.elem0.9dd = %Int64> [concrete] +// CHECK:STDOUT: %SubWith.type.b41: type = facet_type <@SubWith.1, @SubWith.1(%Int64)> [concrete] +// CHECK:STDOUT: %SubWith.assoc_type.b7b: type = assoc_entity_type @SubWith.1, @SubWith.1(%Int64) [concrete] +// CHECK:STDOUT: %assoc0.979: %SubWith.assoc_type.b7b = assoc_entity element0, imports.%Core.import_ref.7e5 [concrete] +// CHECK:STDOUT: %assoc1.80d: %SubWith.assoc_type.b7b = assoc_entity element1, imports.%Core.import_ref.abb [concrete] +// CHECK:STDOUT: %Op.type.67547d.7: type = fn_type @Op.7 [concrete] +// CHECK:STDOUT: %Op.8fb557.7: %Op.type.67547d.7 = struct_value () [concrete] +// CHECK:STDOUT: %custom_witness.cab: = custom_witness (%Int64, %Op.8fb557.7), @SubWith.1, @SubWith.1(%Int64) [concrete] +// CHECK:STDOUT: %facet_value.f7f: %facet_type.17a = facet_value %Int32, (%custom_witness.ce1, %custom_witness.cab) [concrete] +// CHECK:STDOUT: %complete_type.6f3: = complete_type_witness %facet_type.660 [concrete] +// CHECK:STDOUT: %.Self.as_type.d4d: type = facet_access_type %.Self.ea7 [symbolic_self] +// CHECK:STDOUT: %pattern_type.30e: type = pattern_type %facet_type.17a [concrete] +// CHECK:STDOUT: %facet_type.60a: type = facet_type <@Destroy & @MulWith.1, @MulWith.1(%Int64)> [concrete] +// CHECK:STDOUT: %.Self.39e: %facet_type.60a = symbolic_binding .Self [symbolic_self] +// CHECK:STDOUT: %MulWith.lookup_impl_witness.a30: = lookup_impl_witness %.Self.39e, @MulWith.1, @MulWith.1(%Int64) [symbolic_self] +// CHECK:STDOUT: %impl.elem0.3f6: type = impl_witness_access %MulWith.lookup_impl_witness.a30, element0 [symbolic_self] +// CHECK:STDOUT: %facet_type.9d2: type = facet_type <@Destroy & @MulWith.1, @MulWith.1(%Int64) where %impl.elem0.3f6 = %Int64> [concrete] +// CHECK:STDOUT: %MulWith.type.166: type = facet_type <@MulWith.1, @MulWith.1(%Int64)> [concrete] +// CHECK:STDOUT: %MulWith.assoc_type.cbc: type = assoc_entity_type @MulWith.1, @MulWith.1(%Int64) [concrete] +// CHECK:STDOUT: %assoc0.c58: %MulWith.assoc_type.cbc = assoc_entity element0, imports.%Core.import_ref.d9b [concrete] +// CHECK:STDOUT: %assoc1.279: %MulWith.assoc_type.cbc = assoc_entity element1, imports.%Core.import_ref.abc [concrete] +// CHECK:STDOUT: %Op.type.67547d.8: type = fn_type @Op.8 [concrete] +// CHECK:STDOUT: %Op.8fb557.8: %Op.type.67547d.8 = struct_value () [concrete] +// CHECK:STDOUT: %custom_witness.f53: = custom_witness (%Int64, %Op.8fb557.8), @MulWith.1, @MulWith.1(%Int64) [concrete] +// CHECK:STDOUT: %facet_value.823: %facet_type.9d2 = facet_value %Int32, (%custom_witness.ce1, %custom_witness.f53) [concrete] +// CHECK:STDOUT: %complete_type.7a4: = complete_type_witness %facet_type.60a [concrete] +// CHECK:STDOUT: %.Self.as_type.604: type = facet_access_type %.Self.39e [symbolic_self] +// CHECK:STDOUT: %pattern_type.eb5: type = pattern_type %facet_type.9d2 [concrete] +// CHECK:STDOUT: %facet_type.f02: type = facet_type <@Destroy & @DivWith.1, @DivWith.1(%Int64)> [concrete] +// CHECK:STDOUT: %.Self.ad5: %facet_type.f02 = symbolic_binding .Self [symbolic_self] +// CHECK:STDOUT: %DivWith.lookup_impl_witness.cc2: = lookup_impl_witness %.Self.ad5, @DivWith.1, @DivWith.1(%Int64) [symbolic_self] +// CHECK:STDOUT: %impl.elem0.2d2: type = impl_witness_access %DivWith.lookup_impl_witness.cc2, element0 [symbolic_self] +// CHECK:STDOUT: %facet_type.6aa: type = facet_type <@Destroy & @DivWith.1, @DivWith.1(%Int64) where %impl.elem0.2d2 = %Int64> [concrete] +// CHECK:STDOUT: %DivWith.type.70f: type = facet_type <@DivWith.1, @DivWith.1(%Int64)> [concrete] +// CHECK:STDOUT: %DivWith.assoc_type.03e: type = assoc_entity_type @DivWith.1, @DivWith.1(%Int64) [concrete] +// CHECK:STDOUT: %assoc0.a25: %DivWith.assoc_type.03e = assoc_entity element0, imports.%Core.import_ref.14e [concrete] +// CHECK:STDOUT: %assoc1.f42: %DivWith.assoc_type.03e = assoc_entity element1, imports.%Core.import_ref.bb2c [concrete] +// CHECK:STDOUT: %Op.type.67547d.9: type = fn_type @Op.9 [concrete] +// CHECK:STDOUT: %Op.8fb557.9: %Op.type.67547d.9 = struct_value () [concrete] +// CHECK:STDOUT: %custom_witness.bca: = custom_witness (%Int64, %Op.8fb557.9), @DivWith.1, @DivWith.1(%Int64) [concrete] +// CHECK:STDOUT: %facet_value.cba: %facet_type.6aa = facet_value %Int32, (%custom_witness.ce1, %custom_witness.bca) [concrete] +// CHECK:STDOUT: %complete_type.e31: = complete_type_witness %facet_type.f02 [concrete] +// CHECK:STDOUT: %.Self.as_type.245: type = facet_access_type %.Self.ad5 [symbolic_self] +// CHECK:STDOUT: %pattern_type.c59: type = pattern_type %facet_type.6aa [concrete] +// CHECK:STDOUT: %facet_type.b13: type = facet_type <@Destroy & @ModWith.1, @ModWith.1(%Int64)> [concrete] +// CHECK:STDOUT: %.Self.856: %facet_type.b13 = symbolic_binding .Self [symbolic_self] +// CHECK:STDOUT: %ModWith.lookup_impl_witness.81f: = lookup_impl_witness %.Self.856, @ModWith.1, @ModWith.1(%Int64) [symbolic_self] +// CHECK:STDOUT: %impl.elem0.369: type = impl_witness_access %ModWith.lookup_impl_witness.81f, element0 [symbolic_self] +// CHECK:STDOUT: %facet_type.41c: type = facet_type <@Destroy & @ModWith.1, @ModWith.1(%Int64) where %impl.elem0.369 = %Int64> [concrete] +// CHECK:STDOUT: %ModWith.type.a92: type = facet_type <@ModWith.1, @ModWith.1(%Int64)> [concrete] +// CHECK:STDOUT: %ModWith.assoc_type.f50: type = assoc_entity_type @ModWith.1, @ModWith.1(%Int64) [concrete] +// CHECK:STDOUT: %assoc0.c89: %ModWith.assoc_type.f50 = assoc_entity element0, imports.%Core.import_ref.a0d [concrete] +// CHECK:STDOUT: %assoc1.a80: %ModWith.assoc_type.f50 = assoc_entity element1, imports.%Core.import_ref.c05 [concrete] +// CHECK:STDOUT: %Op.type.67547d.10: type = fn_type @Op.10 [concrete] +// CHECK:STDOUT: %Op.8fb557.10: %Op.type.67547d.10 = struct_value () [concrete] +// CHECK:STDOUT: %custom_witness.1b0: = custom_witness (%Int64, %Op.8fb557.10), @ModWith.1, @ModWith.1(%Int64) [concrete] +// CHECK:STDOUT: %facet_value.403: %facet_type.41c = facet_value %Int32, (%custom_witness.ce1, %custom_witness.1b0) [concrete] +// CHECK:STDOUT: %complete_type.780: = complete_type_witness %facet_type.b13 [concrete] +// CHECK:STDOUT: %.Self.as_type.6bd: type = facet_access_type %.Self.856 [symbolic_self] +// CHECK:STDOUT: %pattern_type.4ab: type = pattern_type %facet_type.41c [concrete] +// CHECK:STDOUT: %facet_type.a53: type = facet_type <@Destroy & @AddWith.1, @AddWith.1(%Int32) where %impl.elem0.cee = %Int64> [concrete] +// CHECK:STDOUT: %Op.type.67547d.11: type = fn_type @Op.11 [concrete] +// CHECK:STDOUT: %Op.8fb557.11: %Op.type.67547d.11 = struct_value () [concrete] +// CHECK:STDOUT: %custom_witness.fc1: = custom_witness (%Int64, %Op.8fb557.11), @AddWith.1, @AddWith.1(%Int32) [concrete] +// CHECK:STDOUT: %facet_value.8dc: %facet_type.a53 = facet_value %Int64, (%custom_witness.d7e, %custom_witness.fc1) [concrete] +// CHECK:STDOUT: %pattern_type.7f1: type = pattern_type %facet_type.a53 [concrete] +// CHECK:STDOUT: %facet_type.364: type = facet_type <@Destroy & @SubWith.1, @SubWith.1(%Int32) where %impl.elem0.edd = %Int64> [concrete] +// CHECK:STDOUT: %Op.type.67547d.12: type = fn_type @Op.12 [concrete] +// CHECK:STDOUT: %Op.8fb557.12: %Op.type.67547d.12 = struct_value () [concrete] +// CHECK:STDOUT: %custom_witness.31e: = custom_witness (%Int64, %Op.8fb557.12), @SubWith.1, @SubWith.1(%Int32) [concrete] +// CHECK:STDOUT: %facet_value.c40: %facet_type.364 = facet_value %Int64, (%custom_witness.d7e, %custom_witness.31e) [concrete] +// CHECK:STDOUT: %pattern_type.c45: type = pattern_type %facet_type.364 [concrete] +// CHECK:STDOUT: %facet_type.d7d: type = facet_type <@Destroy & @MulWith.1, @MulWith.1(%Int32) where %impl.elem0.e63 = %Int64> [concrete] +// CHECK:STDOUT: %Op.type.67547d.13: type = fn_type @Op.13 [concrete] +// CHECK:STDOUT: %Op.8fb557.13: %Op.type.67547d.13 = struct_value () [concrete] +// CHECK:STDOUT: %custom_witness.709: = custom_witness (%Int64, %Op.8fb557.13), @MulWith.1, @MulWith.1(%Int32) [concrete] +// CHECK:STDOUT: %facet_value.9d5: %facet_type.d7d = facet_value %Int64, (%custom_witness.d7e, %custom_witness.709) [concrete] +// CHECK:STDOUT: %pattern_type.450: type = pattern_type %facet_type.d7d [concrete] +// CHECK:STDOUT: %facet_type.a9f: type = facet_type <@Destroy & @DivWith.1, @DivWith.1(%Int32) where %impl.elem0.232 = %Int64> [concrete] +// CHECK:STDOUT: %Op.type.67547d.14: type = fn_type @Op.14 [concrete] +// CHECK:STDOUT: %Op.8fb557.14: %Op.type.67547d.14 = struct_value () [concrete] +// CHECK:STDOUT: %custom_witness.47b: = custom_witness (%Int64, %Op.8fb557.14), @DivWith.1, @DivWith.1(%Int32) [concrete] +// CHECK:STDOUT: %facet_value.c21: %facet_type.a9f = facet_value %Int64, (%custom_witness.d7e, %custom_witness.47b) [concrete] +// CHECK:STDOUT: %pattern_type.0b0: type = pattern_type %facet_type.a9f [concrete] +// CHECK:STDOUT: %facet_type.f0f: type = facet_type <@Destroy & @ModWith.1, @ModWith.1(%Int32) where %impl.elem0.919 = %Int64> [concrete] +// CHECK:STDOUT: %Op.type.67547d.15: type = fn_type @Op.15 [concrete] +// CHECK:STDOUT: %Op.8fb557.15: %Op.type.67547d.15 = struct_value () [concrete] +// CHECK:STDOUT: %custom_witness.ad6: = custom_witness (%Int64, %Op.8fb557.15), @ModWith.1, @ModWith.1(%Int32) [concrete] +// CHECK:STDOUT: %facet_value.766: %facet_type.f0f = facet_value %Int64, (%custom_witness.d7e, %custom_witness.ad6) [concrete] +// CHECK:STDOUT: %pattern_type.bd2: type = pattern_type %facet_type.f0f [concrete] +// CHECK:STDOUT: %Destroy.WithSelf.Op.type.f16: type = fn_type @Destroy.WithSelf.Op, @Destroy.WithSelf(%Destroy.facet.b0a) [concrete] +// CHECK:STDOUT: %.db1: type = fn_type_with_self_type %Destroy.WithSelf.Op.type.f16, %Destroy.facet.b0a [concrete] +// CHECK:STDOUT: %Destroy.WithSelf.Op.type.2e1: type = fn_type @Destroy.WithSelf.Op, @Destroy.WithSelf(%Destroy.facet.c06) [concrete] +// CHECK:STDOUT: %.e6c: type = fn_type_with_self_type %Destroy.WithSelf.Op.type.2e1, %Destroy.facet.c06 [concrete] +// CHECK:STDOUT: %Destroy.WithSelf.Op.type.833: type = fn_type @Destroy.WithSelf.Op, @Destroy.WithSelf(%Destroy.facet.e06) [concrete] +// CHECK:STDOUT: %.368: type = fn_type_with_self_type %Destroy.WithSelf.Op.type.833, %Destroy.facet.e06 [concrete] +// CHECK:STDOUT: %U.67d: type = symbolic_binding U, 0 [symbolic] +// CHECK:STDOUT: %AddAssignWith.type.4d3b38.1: type = facet_type <@AddAssignWith.1, @AddAssignWith.1(%Other)> [symbolic] +// CHECK:STDOUT: %Self.a00362.1: %AddAssignWith.type.4d3b38.1 = symbolic_binding Self, 1 [symbolic] +// CHECK:STDOUT: %AddAssignWith.assoc_type.ca2a80.1: type = assoc_entity_type @AddAssignWith.1, @AddAssignWith.1(%Other) [symbolic] +// CHECK:STDOUT: %AddAssignWith.WithSelf.Op.type.df0722.1: type = fn_type @AddAssignWith.WithSelf.Op, @AddAssignWith.WithSelf(%Other, %Self.a00362.1) [symbolic] +// CHECK:STDOUT: %AddAssignWith.WithSelf.Op.b33928.1: %AddAssignWith.WithSelf.Op.type.df0722.1 = struct_value () [symbolic] +// CHECK:STDOUT: %AddAssignWith.type.4d3b38.2: type = facet_type <@AddAssignWith.1, @AddAssignWith.1(%U.67d)> [symbolic] +// CHECK:STDOUT: %pattern_type.092: type = pattern_type %AddAssignWith.type.4d3b38.2 [symbolic] +// CHECK:STDOUT: %T.a00: %AddAssignWith.type.4d3b38.2 = symbolic_binding T, 1 [symbolic] +// CHECK:STDOUT: %AddAssignWith.assoc_type.ca2a80.2: type = assoc_entity_type @AddAssignWith.1, @AddAssignWith.1(%U.67d) [symbolic] +// CHECK:STDOUT: %assoc0.f6c0ab.2: %AddAssignWith.assoc_type.ca2a80.2 = assoc_entity element0, imports.%Core.import_ref.7e1 [symbolic] +// CHECK:STDOUT: %T.as_type.191: type = facet_access_type %T.a00 [symbolic] +// CHECK:STDOUT: %pattern_type.03496c.2: type = pattern_type %T.as_type.191 [symbolic] +// CHECK:STDOUT: %pattern_type.51d1c4.4: type = pattern_type %U.67d [symbolic] +// CHECK:STDOUT: %require_complete.cb0: = require_complete_type %AddAssignWith.type.4d3b38.2 [symbolic] +// CHECK:STDOUT: %assoc0.5d2: %AddAssignWith.assoc_type.ca2a80.1 = assoc_entity element0, imports.%Core.import_ref.f18 [symbolic] +// CHECK:STDOUT: %AddAssignWith.lookup_impl_witness: = lookup_impl_witness %T.a00, @AddAssignWith.1, @AddAssignWith.1(%U.67d) [symbolic] +// CHECK:STDOUT: %AddAssignWith.WithSelf.Op.type.df0722.3: type = fn_type @AddAssignWith.WithSelf.Op, @AddAssignWith.WithSelf(%U.67d, %T.a00) [symbolic] +// CHECK:STDOUT: %.8f6: type = fn_type_with_self_type %AddAssignWith.WithSelf.Op.type.df0722.3, %T.a00 [symbolic] +// CHECK:STDOUT: %impl.elem0.c7b: %.8f6 = impl_witness_access %AddAssignWith.lookup_impl_witness, element0 [symbolic] +// CHECK:STDOUT: %specific_impl_fn.fca: = specific_impl_function %impl.elem0.c7b, @AddAssignWith.WithSelf.Op(%U.67d, %T.a00) [symbolic] +// CHECK:STDOUT: %SubAssignWith.type.969cbb.1: type = facet_type <@SubAssignWith.1, @SubAssignWith.1(%Other)> [symbolic] +// CHECK:STDOUT: %Self.1de093.1: %SubAssignWith.type.969cbb.1 = symbolic_binding Self, 1 [symbolic] +// CHECK:STDOUT: %SubAssignWith.assoc_type.4cb9a1.1: type = assoc_entity_type @SubAssignWith.1, @SubAssignWith.1(%Other) [symbolic] +// CHECK:STDOUT: %SubAssignWith.WithSelf.Op.type.317c02.1: type = fn_type @SubAssignWith.WithSelf.Op, @SubAssignWith.WithSelf(%Other, %Self.1de093.1) [symbolic] +// CHECK:STDOUT: %SubAssignWith.WithSelf.Op.26e13f.1: %SubAssignWith.WithSelf.Op.type.317c02.1 = struct_value () [symbolic] +// CHECK:STDOUT: %SubAssignWith.type.969cbb.2: type = facet_type <@SubAssignWith.1, @SubAssignWith.1(%U.67d)> [symbolic] +// CHECK:STDOUT: %pattern_type.abb: type = pattern_type %SubAssignWith.type.969cbb.2 [symbolic] +// CHECK:STDOUT: %T.1de: %SubAssignWith.type.969cbb.2 = symbolic_binding T, 1 [symbolic] +// CHECK:STDOUT: %SubAssignWith.assoc_type.4cb9a1.2: type = assoc_entity_type @SubAssignWith.1, @SubAssignWith.1(%U.67d) [symbolic] +// CHECK:STDOUT: %assoc0.6115cc.2: %SubAssignWith.assoc_type.4cb9a1.2 = assoc_entity element0, imports.%Core.import_ref.5b4 [symbolic] +// CHECK:STDOUT: %T.as_type.b8f: type = facet_access_type %T.1de [symbolic] +// CHECK:STDOUT: %pattern_type.2f1979.2: type = pattern_type %T.as_type.b8f [symbolic] +// CHECK:STDOUT: %require_complete.22d3: = require_complete_type %SubAssignWith.type.969cbb.2 [symbolic] +// CHECK:STDOUT: %assoc0.fd1: %SubAssignWith.assoc_type.4cb9a1.1 = assoc_entity element0, imports.%Core.import_ref.a26 [symbolic] +// CHECK:STDOUT: %SubAssignWith.lookup_impl_witness: = lookup_impl_witness %T.1de, @SubAssignWith.1, @SubAssignWith.1(%U.67d) [symbolic] +// CHECK:STDOUT: %SubAssignWith.WithSelf.Op.type.317c02.3: type = fn_type @SubAssignWith.WithSelf.Op, @SubAssignWith.WithSelf(%U.67d, %T.1de) [symbolic] +// CHECK:STDOUT: %.307: type = fn_type_with_self_type %SubAssignWith.WithSelf.Op.type.317c02.3, %T.1de [symbolic] +// CHECK:STDOUT: %impl.elem0.e10: %.307 = impl_witness_access %SubAssignWith.lookup_impl_witness, element0 [symbolic] +// CHECK:STDOUT: %specific_impl_fn.c8d: = specific_impl_function %impl.elem0.e10, @SubAssignWith.WithSelf.Op(%U.67d, %T.1de) [symbolic] +// CHECK:STDOUT: %MulAssignWith.type.ccc9e0.1: type = facet_type <@MulAssignWith.1, @MulAssignWith.1(%Other)> [symbolic] +// CHECK:STDOUT: %Self.059e93.1: %MulAssignWith.type.ccc9e0.1 = symbolic_binding Self, 1 [symbolic] +// CHECK:STDOUT: %MulAssignWith.assoc_type.595561.1: type = assoc_entity_type @MulAssignWith.1, @MulAssignWith.1(%Other) [symbolic] +// CHECK:STDOUT: %MulAssignWith.WithSelf.Op.type.31cf70.1: type = fn_type @MulAssignWith.WithSelf.Op, @MulAssignWith.WithSelf(%Other, %Self.059e93.1) [symbolic] +// CHECK:STDOUT: %MulAssignWith.WithSelf.Op.cdf083.1: %MulAssignWith.WithSelf.Op.type.31cf70.1 = struct_value () [symbolic] +// CHECK:STDOUT: %MulAssignWith.type.ccc9e0.2: type = facet_type <@MulAssignWith.1, @MulAssignWith.1(%U.67d)> [symbolic] +// CHECK:STDOUT: %pattern_type.043: type = pattern_type %MulAssignWith.type.ccc9e0.2 [symbolic] +// CHECK:STDOUT: %T.059: %MulAssignWith.type.ccc9e0.2 = symbolic_binding T, 1 [symbolic] +// CHECK:STDOUT: %MulAssignWith.assoc_type.595561.2: type = assoc_entity_type @MulAssignWith.1, @MulAssignWith.1(%U.67d) [symbolic] +// CHECK:STDOUT: %assoc0.71e6fb.2: %MulAssignWith.assoc_type.595561.2 = assoc_entity element0, imports.%Core.import_ref.69b [symbolic] +// CHECK:STDOUT: %T.as_type.6a0: type = facet_access_type %T.059 [symbolic] +// CHECK:STDOUT: %pattern_type.587662.2: type = pattern_type %T.as_type.6a0 [symbolic] +// CHECK:STDOUT: %require_complete.6dc: = require_complete_type %MulAssignWith.type.ccc9e0.2 [symbolic] +// CHECK:STDOUT: %assoc0.fc1: %MulAssignWith.assoc_type.595561.1 = assoc_entity element0, imports.%Core.import_ref.2e6 [symbolic] +// CHECK:STDOUT: %MulAssignWith.lookup_impl_witness: = lookup_impl_witness %T.059, @MulAssignWith.1, @MulAssignWith.1(%U.67d) [symbolic] +// CHECK:STDOUT: %MulAssignWith.WithSelf.Op.type.31cf70.3: type = fn_type @MulAssignWith.WithSelf.Op, @MulAssignWith.WithSelf(%U.67d, %T.059) [symbolic] +// CHECK:STDOUT: %.1b8: type = fn_type_with_self_type %MulAssignWith.WithSelf.Op.type.31cf70.3, %T.059 [symbolic] +// CHECK:STDOUT: %impl.elem0.cd0: %.1b8 = impl_witness_access %MulAssignWith.lookup_impl_witness, element0 [symbolic] +// CHECK:STDOUT: %specific_impl_fn.397: = specific_impl_function %impl.elem0.cd0, @MulAssignWith.WithSelf.Op(%U.67d, %T.059) [symbolic] +// CHECK:STDOUT: %DivAssignWith.type.be08dd.1: type = facet_type <@DivAssignWith.1, @DivAssignWith.1(%Other)> [symbolic] +// CHECK:STDOUT: %Self.aa8835.1: %DivAssignWith.type.be08dd.1 = symbolic_binding Self, 1 [symbolic] +// CHECK:STDOUT: %DivAssignWith.assoc_type.8b4b5b.1: type = assoc_entity_type @DivAssignWith.1, @DivAssignWith.1(%Other) [symbolic] +// CHECK:STDOUT: %DivAssignWith.WithSelf.Op.type.ded5d7.1: type = fn_type @DivAssignWith.WithSelf.Op, @DivAssignWith.WithSelf(%Other, %Self.aa8835.1) [symbolic] +// CHECK:STDOUT: %DivAssignWith.WithSelf.Op.6f2821.1: %DivAssignWith.WithSelf.Op.type.ded5d7.1 = struct_value () [symbolic] +// CHECK:STDOUT: %DivAssignWith.type.be08dd.2: type = facet_type <@DivAssignWith.1, @DivAssignWith.1(%U.67d)> [symbolic] +// CHECK:STDOUT: %pattern_type.8e3: type = pattern_type %DivAssignWith.type.be08dd.2 [symbolic] +// CHECK:STDOUT: %T.aa8: %DivAssignWith.type.be08dd.2 = symbolic_binding T, 1 [symbolic] +// CHECK:STDOUT: %DivAssignWith.assoc_type.8b4b5b.2: type = assoc_entity_type @DivAssignWith.1, @DivAssignWith.1(%U.67d) [symbolic] +// CHECK:STDOUT: %assoc0.399004.2: %DivAssignWith.assoc_type.8b4b5b.2 = assoc_entity element0, imports.%Core.import_ref.799 [symbolic] +// CHECK:STDOUT: %T.as_type.efd: type = facet_access_type %T.aa8 [symbolic] +// CHECK:STDOUT: %pattern_type.593823.2: type = pattern_type %T.as_type.efd [symbolic] +// CHECK:STDOUT: %require_complete.542: = require_complete_type %DivAssignWith.type.be08dd.2 [symbolic] +// CHECK:STDOUT: %assoc0.b19: %DivAssignWith.assoc_type.8b4b5b.1 = assoc_entity element0, imports.%Core.import_ref.7f9 [symbolic] +// CHECK:STDOUT: %DivAssignWith.lookup_impl_witness: = lookup_impl_witness %T.aa8, @DivAssignWith.1, @DivAssignWith.1(%U.67d) [symbolic] +// CHECK:STDOUT: %DivAssignWith.WithSelf.Op.type.ded5d7.3: type = fn_type @DivAssignWith.WithSelf.Op, @DivAssignWith.WithSelf(%U.67d, %T.aa8) [symbolic] +// CHECK:STDOUT: %.607: type = fn_type_with_self_type %DivAssignWith.WithSelf.Op.type.ded5d7.3, %T.aa8 [symbolic] +// CHECK:STDOUT: %impl.elem0.46f: %.607 = impl_witness_access %DivAssignWith.lookup_impl_witness, element0 [symbolic] +// CHECK:STDOUT: %specific_impl_fn.666: = specific_impl_function %impl.elem0.46f, @DivAssignWith.WithSelf.Op(%U.67d, %T.aa8) [symbolic] +// CHECK:STDOUT: %ModAssignWith.type.c65b77.1: type = facet_type <@ModAssignWith.1, @ModAssignWith.1(%Other)> [symbolic] +// CHECK:STDOUT: %Self.d35c46.1: %ModAssignWith.type.c65b77.1 = symbolic_binding Self, 1 [symbolic] +// CHECK:STDOUT: %ModAssignWith.assoc_type.1462b9.1: type = assoc_entity_type @ModAssignWith.1, @ModAssignWith.1(%Other) [symbolic] +// CHECK:STDOUT: %ModAssignWith.WithSelf.Op.type.5452e9.1: type = fn_type @ModAssignWith.WithSelf.Op, @ModAssignWith.WithSelf(%Other, %Self.d35c46.1) [symbolic] +// CHECK:STDOUT: %ModAssignWith.WithSelf.Op.c5cc9b.1: %ModAssignWith.WithSelf.Op.type.5452e9.1 = struct_value () [symbolic] +// CHECK:STDOUT: %ModAssignWith.type.c65b77.2: type = facet_type <@ModAssignWith.1, @ModAssignWith.1(%U.67d)> [symbolic] +// CHECK:STDOUT: %pattern_type.26a: type = pattern_type %ModAssignWith.type.c65b77.2 [symbolic] +// CHECK:STDOUT: %T.d35: %ModAssignWith.type.c65b77.2 = symbolic_binding T, 1 [symbolic] +// CHECK:STDOUT: %ModAssignWith.assoc_type.1462b9.2: type = assoc_entity_type @ModAssignWith.1, @ModAssignWith.1(%U.67d) [symbolic] +// CHECK:STDOUT: %assoc0.378445.2: %ModAssignWith.assoc_type.1462b9.2 = assoc_entity element0, imports.%Core.import_ref.51c [symbolic] +// CHECK:STDOUT: %T.as_type.4c2: type = facet_access_type %T.d35 [symbolic] +// CHECK:STDOUT: %pattern_type.6ec6ce.2: type = pattern_type %T.as_type.4c2 [symbolic] +// CHECK:STDOUT: %require_complete.8bf: = require_complete_type %ModAssignWith.type.c65b77.2 [symbolic] +// CHECK:STDOUT: %assoc0.0e6: %ModAssignWith.assoc_type.1462b9.1 = assoc_entity element0, imports.%Core.import_ref.fa5 [symbolic] +// CHECK:STDOUT: %ModAssignWith.lookup_impl_witness: = lookup_impl_witness %T.d35, @ModAssignWith.1, @ModAssignWith.1(%U.67d) [symbolic] +// CHECK:STDOUT: %ModAssignWith.WithSelf.Op.type.5452e9.3: type = fn_type @ModAssignWith.WithSelf.Op, @ModAssignWith.WithSelf(%U.67d, %T.d35) [symbolic] +// CHECK:STDOUT: %.dfa: type = fn_type_with_self_type %ModAssignWith.WithSelf.Op.type.5452e9.3, %T.d35 [symbolic] +// CHECK:STDOUT: %impl.elem0.18c: %.dfa = impl_witness_access %ModAssignWith.lookup_impl_witness, element0 [symbolic] +// CHECK:STDOUT: %specific_impl_fn.28f: = specific_impl_function %impl.elem0.18c, @ModAssignWith.WithSelf.Op(%U.67d, %T.d35) [symbolic] +// CHECK:STDOUT: %AddAssignWith.type.704: type = facet_type <@AddAssignWith.1, @AddAssignWith.1(%i16)> [concrete] +// CHECK:STDOUT: %AddAssignWith.assoc_type.23b: type = assoc_entity_type @AddAssignWith.1, @AddAssignWith.1(%i16) [concrete] +// CHECK:STDOUT: %assoc0.08d: %AddAssignWith.assoc_type.23b = assoc_entity element0, imports.%Core.import_ref.7e1 [concrete] +// CHECK:STDOUT: %Int16.Op.type.180c8b.13: type = fn_type @Int16.Op.13 [concrete] +// CHECK:STDOUT: %Int16.Op.c3e49c.13: %Int16.Op.type.180c8b.13 = struct_value () [concrete] +// CHECK:STDOUT: %custom_witness.6da: = custom_witness (%Int16.Op.c3e49c.13), @AddAssignWith.1, @AddAssignWith.1(%i16) [concrete] +// CHECK:STDOUT: %AddAssignWith.facet.23f: %AddAssignWith.type.704 = facet_value %Int16, (%custom_witness.6da) [concrete] +// CHECK:STDOUT: %pattern_type.139: type = pattern_type %AddAssignWith.type.704 [concrete] +// CHECK:STDOUT: %SubAssignWith.type.fed: type = facet_type <@SubAssignWith.1, @SubAssignWith.1(%i16)> [concrete] +// CHECK:STDOUT: %SubAssignWith.assoc_type.81a: type = assoc_entity_type @SubAssignWith.1, @SubAssignWith.1(%i16) [concrete] +// CHECK:STDOUT: %assoc0.0a4: %SubAssignWith.assoc_type.81a = assoc_entity element0, imports.%Core.import_ref.5b4 [concrete] +// CHECK:STDOUT: %Int16.Op.type.180c8b.14: type = fn_type @Int16.Op.14 [concrete] +// CHECK:STDOUT: %Int16.Op.c3e49c.14: %Int16.Op.type.180c8b.14 = struct_value () [concrete] +// CHECK:STDOUT: %custom_witness.509: = custom_witness (%Int16.Op.c3e49c.14), @SubAssignWith.1, @SubAssignWith.1(%i16) [concrete] +// CHECK:STDOUT: %SubAssignWith.facet.3e7: %SubAssignWith.type.fed = facet_value %Int16, (%custom_witness.509) [concrete] +// CHECK:STDOUT: %pattern_type.912: type = pattern_type %SubAssignWith.type.fed [concrete] +// CHECK:STDOUT: %MulAssignWith.type.6c0: type = facet_type <@MulAssignWith.1, @MulAssignWith.1(%i16)> [concrete] +// CHECK:STDOUT: %MulAssignWith.assoc_type.af2: type = assoc_entity_type @MulAssignWith.1, @MulAssignWith.1(%i16) [concrete] +// CHECK:STDOUT: %assoc0.e50: %MulAssignWith.assoc_type.af2 = assoc_entity element0, imports.%Core.import_ref.69b [concrete] +// CHECK:STDOUT: %Int16.Op.type.180c8b.15: type = fn_type @Int16.Op.15 [concrete] +// CHECK:STDOUT: %Int16.Op.c3e49c.15: %Int16.Op.type.180c8b.15 = struct_value () [concrete] +// CHECK:STDOUT: %custom_witness.a1f: = custom_witness (%Int16.Op.c3e49c.15), @MulAssignWith.1, @MulAssignWith.1(%i16) [concrete] +// CHECK:STDOUT: %MulAssignWith.facet.78f: %MulAssignWith.type.6c0 = facet_value %Int16, (%custom_witness.a1f) [concrete] +// CHECK:STDOUT: %pattern_type.578: type = pattern_type %MulAssignWith.type.6c0 [concrete] +// CHECK:STDOUT: %DivAssignWith.type.527: type = facet_type <@DivAssignWith.1, @DivAssignWith.1(%i16)> [concrete] +// CHECK:STDOUT: %DivAssignWith.assoc_type.5b8: type = assoc_entity_type @DivAssignWith.1, @DivAssignWith.1(%i16) [concrete] +// CHECK:STDOUT: %assoc0.ced: %DivAssignWith.assoc_type.5b8 = assoc_entity element0, imports.%Core.import_ref.799 [concrete] +// CHECK:STDOUT: %Int16.Op.type.180c8b.16: type = fn_type @Int16.Op.16 [concrete] +// CHECK:STDOUT: %Int16.Op.c3e49c.16: %Int16.Op.type.180c8b.16 = struct_value () [concrete] +// CHECK:STDOUT: %custom_witness.deb: = custom_witness (%Int16.Op.c3e49c.16), @DivAssignWith.1, @DivAssignWith.1(%i16) [concrete] +// CHECK:STDOUT: %DivAssignWith.facet.b0d: %DivAssignWith.type.527 = facet_value %Int16, (%custom_witness.deb) [concrete] +// CHECK:STDOUT: %pattern_type.5f7: type = pattern_type %DivAssignWith.type.527 [concrete] +// CHECK:STDOUT: %ModAssignWith.type.ead: type = facet_type <@ModAssignWith.1, @ModAssignWith.1(%i16)> [concrete] +// CHECK:STDOUT: %ModAssignWith.assoc_type.556: type = assoc_entity_type @ModAssignWith.1, @ModAssignWith.1(%i16) [concrete] +// CHECK:STDOUT: %assoc0.b4c: %ModAssignWith.assoc_type.556 = assoc_entity element0, imports.%Core.import_ref.51c [concrete] +// CHECK:STDOUT: %Int16.Op.type.180c8b.17: type = fn_type @Int16.Op.17 [concrete] +// CHECK:STDOUT: %Int16.Op.c3e49c.17: %Int16.Op.type.180c8b.17 = struct_value () [concrete] +// CHECK:STDOUT: %custom_witness.c26: = custom_witness (%Int16.Op.c3e49c.17), @ModAssignWith.1, @ModAssignWith.1(%i16) [concrete] +// CHECK:STDOUT: %ModAssignWith.facet.ada: %ModAssignWith.type.ead = facet_value %Int16, (%custom_witness.c26) [concrete] +// CHECK:STDOUT: %pattern_type.bf6: type = pattern_type %ModAssignWith.type.ead [concrete] +// CHECK:STDOUT: %AddAssignWith.type.a71: type = facet_type <@AddAssignWith.1, @AddAssignWith.1(%Int32)> [concrete] +// CHECK:STDOUT: %AddAssignWith.assoc_type.b4b: type = assoc_entity_type @AddAssignWith.1, @AddAssignWith.1(%Int32) [concrete] +// CHECK:STDOUT: %assoc0.e09: %AddAssignWith.assoc_type.b4b = assoc_entity element0, imports.%Core.import_ref.7e1 [concrete] +// CHECK:STDOUT: %Int32.Op.type.68b858.12: type = fn_type @Int32.Op.12 [concrete] +// CHECK:STDOUT: %Int32.Op.6afff1.12: %Int32.Op.type.68b858.12 = struct_value () [concrete] +// CHECK:STDOUT: %custom_witness.c02: = custom_witness (%Int32.Op.6afff1.12), @AddAssignWith.1, @AddAssignWith.1(%Int32) [concrete] +// CHECK:STDOUT: %AddAssignWith.facet.d85: %AddAssignWith.type.a71 = facet_value %Int32, (%custom_witness.c02) [concrete] +// CHECK:STDOUT: %pattern_type.736: type = pattern_type %AddAssignWith.type.a71 [concrete] +// CHECK:STDOUT: %SubAssignWith.type.35f: type = facet_type <@SubAssignWith.1, @SubAssignWith.1(%Int32)> [concrete] +// CHECK:STDOUT: %SubAssignWith.assoc_type.867: type = assoc_entity_type @SubAssignWith.1, @SubAssignWith.1(%Int32) [concrete] +// CHECK:STDOUT: %assoc0.aa5: %SubAssignWith.assoc_type.867 = assoc_entity element0, imports.%Core.import_ref.5b4 [concrete] +// CHECK:STDOUT: %Int32.Op.type.68b858.14: type = fn_type @Int32.Op.14 [concrete] +// CHECK:STDOUT: %Int32.Op.6afff1.14: %Int32.Op.type.68b858.14 = struct_value () [concrete] +// CHECK:STDOUT: %custom_witness.062: = custom_witness (%Int32.Op.6afff1.14), @SubAssignWith.1, @SubAssignWith.1(%Int32) [concrete] +// CHECK:STDOUT: %SubAssignWith.facet.187: %SubAssignWith.type.35f = facet_value %Int32, (%custom_witness.062) [concrete] +// CHECK:STDOUT: %pattern_type.870: type = pattern_type %SubAssignWith.type.35f [concrete] +// CHECK:STDOUT: %MulAssignWith.type.dd2: type = facet_type <@MulAssignWith.1, @MulAssignWith.1(%Int32)> [concrete] +// CHECK:STDOUT: %MulAssignWith.assoc_type.5c3: type = assoc_entity_type @MulAssignWith.1, @MulAssignWith.1(%Int32) [concrete] +// CHECK:STDOUT: %assoc0.6d0: %MulAssignWith.assoc_type.5c3 = assoc_entity element0, imports.%Core.import_ref.69b [concrete] +// CHECK:STDOUT: %Int32.Op.type.68b858.15: type = fn_type @Int32.Op.15 [concrete] +// CHECK:STDOUT: %Int32.Op.6afff1.15: %Int32.Op.type.68b858.15 = struct_value () [concrete] +// CHECK:STDOUT: %custom_witness.03af: = custom_witness (%Int32.Op.6afff1.15), @MulAssignWith.1, @MulAssignWith.1(%Int32) [concrete] +// CHECK:STDOUT: %MulAssignWith.facet.775: %MulAssignWith.type.dd2 = facet_value %Int32, (%custom_witness.03af) [concrete] +// CHECK:STDOUT: %pattern_type.e94: type = pattern_type %MulAssignWith.type.dd2 [concrete] +// CHECK:STDOUT: %DivAssignWith.type.a38: type = facet_type <@DivAssignWith.1, @DivAssignWith.1(%Int32)> [concrete] +// CHECK:STDOUT: %DivAssignWith.assoc_type.86d: type = assoc_entity_type @DivAssignWith.1, @DivAssignWith.1(%Int32) [concrete] +// CHECK:STDOUT: %assoc0.b6e: %DivAssignWith.assoc_type.86d = assoc_entity element0, imports.%Core.import_ref.799 [concrete] +// CHECK:STDOUT: %Int32.Op.type.68b858.16: type = fn_type @Int32.Op.16 [concrete] +// CHECK:STDOUT: %Int32.Op.6afff1.16: %Int32.Op.type.68b858.16 = struct_value () [concrete] +// CHECK:STDOUT: %custom_witness.be6: = custom_witness (%Int32.Op.6afff1.16), @DivAssignWith.1, @DivAssignWith.1(%Int32) [concrete] +// CHECK:STDOUT: %DivAssignWith.facet.f5b: %DivAssignWith.type.a38 = facet_value %Int32, (%custom_witness.be6) [concrete] +// CHECK:STDOUT: %pattern_type.689: type = pattern_type %DivAssignWith.type.a38 [concrete] +// CHECK:STDOUT: %ModAssignWith.type.36f: type = facet_type <@ModAssignWith.1, @ModAssignWith.1(%Int32)> [concrete] +// CHECK:STDOUT: %ModAssignWith.assoc_type.1a5: type = assoc_entity_type @ModAssignWith.1, @ModAssignWith.1(%Int32) [concrete] +// CHECK:STDOUT: %assoc0.609: %ModAssignWith.assoc_type.1a5 = assoc_entity element0, imports.%Core.import_ref.51c [concrete] +// CHECK:STDOUT: %Int32.Op.type.68b858.17: type = fn_type @Int32.Op.17 [concrete] +// CHECK:STDOUT: %Int32.Op.6afff1.17: %Int32.Op.type.68b858.17 = struct_value () [concrete] +// CHECK:STDOUT: %custom_witness.203: = custom_witness (%Int32.Op.6afff1.17), @ModAssignWith.1, @ModAssignWith.1(%Int32) [concrete] +// CHECK:STDOUT: %ModAssignWith.facet.b82: %ModAssignWith.type.36f = facet_value %Int32, (%custom_witness.203) [concrete] +// CHECK:STDOUT: %pattern_type.ebe: type = pattern_type %ModAssignWith.type.36f [concrete] +// CHECK:STDOUT: %Int64.Op.type.445ce8.2: type = fn_type @Int64.Op.2 [concrete] +// CHECK:STDOUT: %Int64.Op.b941da.2: %Int64.Op.type.445ce8.2 = struct_value () [concrete] +// CHECK:STDOUT: %custom_witness.3a4: = custom_witness (%Int64.Op.b941da.2), @AddAssignWith.1, @AddAssignWith.1(%Int32) [concrete] +// CHECK:STDOUT: %AddAssignWith.facet.b70: %AddAssignWith.type.a71 = facet_value %Int64, (%custom_witness.3a4) [concrete] +// CHECK:STDOUT: %Int64.Op.type.445ce8.4: type = fn_type @Int64.Op.4 [concrete] +// CHECK:STDOUT: %Int64.Op.b941da.4: %Int64.Op.type.445ce8.4 = struct_value () [concrete] +// CHECK:STDOUT: %custom_witness.de3: = custom_witness (%Int64.Op.b941da.4), @SubAssignWith.1, @SubAssignWith.1(%Int32) [concrete] +// CHECK:STDOUT: %SubAssignWith.facet.bd0: %SubAssignWith.type.35f = facet_value %Int64, (%custom_witness.de3) [concrete] +// CHECK:STDOUT: %Int64.Op.type.445ce8.5: type = fn_type @Int64.Op.5 [concrete] +// CHECK:STDOUT: %Int64.Op.b941da.5: %Int64.Op.type.445ce8.5 = struct_value () [concrete] +// CHECK:STDOUT: %custom_witness.917: = custom_witness (%Int64.Op.b941da.5), @MulAssignWith.1, @MulAssignWith.1(%Int32) [concrete] +// CHECK:STDOUT: %MulAssignWith.facet.982: %MulAssignWith.type.dd2 = facet_value %Int64, (%custom_witness.917) [concrete] +// CHECK:STDOUT: %Int64.Op.type.445ce8.6: type = fn_type @Int64.Op.6 [concrete] +// CHECK:STDOUT: %Int64.Op.b941da.6: %Int64.Op.type.445ce8.6 = struct_value () [concrete] +// CHECK:STDOUT: %custom_witness.f47: = custom_witness (%Int64.Op.b941da.6), @DivAssignWith.1, @DivAssignWith.1(%Int32) [concrete] +// CHECK:STDOUT: %DivAssignWith.facet.d3b: %DivAssignWith.type.a38 = facet_value %Int64, (%custom_witness.f47) [concrete] +// CHECK:STDOUT: %Int64.Op.type.445ce8.7: type = fn_type @Int64.Op.7 [concrete] +// CHECK:STDOUT: %Int64.Op.b941da.7: %Int64.Op.type.445ce8.7 = struct_value () [concrete] +// CHECK:STDOUT: %custom_witness.ad7: = custom_witness (%Int64.Op.b941da.7), @ModAssignWith.1, @ModAssignWith.1(%Int32) [concrete] +// CHECK:STDOUT: %ModAssignWith.facet.1c6: %ModAssignWith.type.36f = facet_value %Int64, (%custom_witness.ad7) [concrete] +// CHECK:STDOUT: %Inc.type: type = facet_type <@Inc> [concrete] +// CHECK:STDOUT: %T.b7e: %Inc.type = symbolic_binding T, 0 [symbolic] +// CHECK:STDOUT: %T.as_type.3f5: type = facet_access_type %T.b7e [symbolic] +// CHECK:STDOUT: %pattern_type.fb5eac.2: type = pattern_type %T.as_type.3f5 [symbolic] +// CHECK:STDOUT: %Inc.lookup_impl_witness: = lookup_impl_witness %T.b7e, @Inc [symbolic] +// CHECK:STDOUT: %Inc.WithSelf.Op.type.623399.2: type = fn_type @Inc.WithSelf.Op, @Inc.WithSelf(%T.b7e) [symbolic] +// CHECK:STDOUT: %.ad4: type = fn_type_with_self_type %Inc.WithSelf.Op.type.623399.2, %T.b7e [symbolic] +// CHECK:STDOUT: %impl.elem0.489: %.ad4 = impl_witness_access %Inc.lookup_impl_witness, element0 [symbolic] +// CHECK:STDOUT: %specific_impl_fn.71c: = specific_impl_function %impl.elem0.489, @Inc.WithSelf.Op(%T.b7e) [symbolic] +// CHECK:STDOUT: %Dec.type: type = facet_type <@Dec> [concrete] +// CHECK:STDOUT: %T.ce1: %Dec.type = symbolic_binding T, 0 [symbolic] +// CHECK:STDOUT: %T.as_type.ead: type = facet_access_type %T.ce1 [symbolic] +// CHECK:STDOUT: %pattern_type.f51ad8.2: type = pattern_type %T.as_type.ead [symbolic] +// CHECK:STDOUT: %Dec.lookup_impl_witness: = lookup_impl_witness %T.ce1, @Dec [symbolic] +// CHECK:STDOUT: %Dec.WithSelf.Op.type.41adba.2: type = fn_type @Dec.WithSelf.Op, @Dec.WithSelf(%T.ce1) [symbolic] +// CHECK:STDOUT: %.41c: type = fn_type_with_self_type %Dec.WithSelf.Op.type.41adba.2, %T.ce1 [symbolic] +// CHECK:STDOUT: %impl.elem0.64b: %.41c = impl_witness_access %Dec.lookup_impl_witness, element0 [symbolic] +// CHECK:STDOUT: %specific_impl_fn.91c: = specific_impl_function %impl.elem0.64b, @Dec.WithSelf.Op(%T.ce1) [symbolic] +// CHECK:STDOUT: %Negate.type: type = facet_type <@Negate> [concrete] +// CHECK:STDOUT: %facet_type.86d: type = facet_type <@Destroy & @Negate> [concrete] +// CHECK:STDOUT: %.Self.c4b: %facet_type.86d = symbolic_binding .Self [symbolic_self] +// CHECK:STDOUT: %Negate.lookup_impl_witness.3a4: = lookup_impl_witness %.Self.c4b, @Negate [symbolic_self] +// CHECK:STDOUT: %impl.elem0.f00: type = impl_witness_access %Negate.lookup_impl_witness.3a4, element0 [symbolic_self] +// CHECK:STDOUT: %facet_type.0fc: type = facet_type <@Destroy & @Negate where %impl.elem0.f00 = %Result.as_type> [symbolic] +// CHECK:STDOUT: %pattern_type.5c4: type = pattern_type %facet_type.0fc [symbolic] +// CHECK:STDOUT: %T.abc: %facet_type.0fc = symbolic_binding T, 1 [symbolic] +// CHECK:STDOUT: %T.as_type.c82: type = facet_access_type %T.abc [symbolic] +// CHECK:STDOUT: %pattern_type.ece: type = pattern_type %T.as_type.c82 [symbolic] +// CHECK:STDOUT: %Negate.lookup_impl_witness.783: = lookup_impl_witness %T.abc, @Negate [symbolic] +// CHECK:STDOUT: %Negate.facet.758: %Negate.type = facet_value %T.as_type.c82, (%Negate.lookup_impl_witness.783) [symbolic] +// CHECK:STDOUT: %Negate.WithSelf.Op.type.899: type = fn_type @Negate.WithSelf.Op, @Negate.WithSelf(%Negate.facet.758) [symbolic] +// CHECK:STDOUT: %.0d7: type = fn_type_with_self_type %Negate.WithSelf.Op.type.899, %Negate.facet.758 [symbolic] +// CHECK:STDOUT: %impl.elem1.ec8: %.0d7 = impl_witness_access %Negate.lookup_impl_witness.783, element1 [symbolic] +// CHECK:STDOUT: %specific_impl_fn.f22: = specific_impl_function %impl.elem1.ec8, @Negate.WithSelf.Op(%Negate.facet.758) [symbolic] +// CHECK:STDOUT: %Int32.cpp_operator.type.49e401.16: type = fn_type @Int32.cpp_operator.16 [concrete] +// CHECK:STDOUT: %Int32.cpp_operator.0010d3.16: %Int32.cpp_operator.type.49e401.16 = struct_value () [concrete] +// CHECK:STDOUT: %custom_witness.934: = custom_witness (%Int32.cpp_operator.0010d3.16), @Inc [concrete] +// CHECK:STDOUT: %Inc.facet.390: %Inc.type = facet_value %Int32, (%custom_witness.934) [concrete] +// CHECK:STDOUT: %Int32.cpp_operator.type.49e401.17: type = fn_type @Int32.cpp_operator.17 [concrete] +// CHECK:STDOUT: %Int32.cpp_operator.0010d3.17: %Int32.cpp_operator.type.49e401.17 = struct_value () [concrete] +// CHECK:STDOUT: %custom_witness.99f: = custom_witness (%Int32.cpp_operator.0010d3.17), @Dec [concrete] +// CHECK:STDOUT: %Dec.facet.961: %Dec.type = facet_value %Int32, (%custom_witness.99f) [concrete] +// CHECK:STDOUT: %facet_type.89a: type = facet_type <@Destroy & @Negate where %impl.elem0.f00 = %Int64> [concrete] +// CHECK:STDOUT: %Int16.Op.type.180c8b.18: type = fn_type @Int16.Op.18 [concrete] +// CHECK:STDOUT: %Int16.Op.c3e49c.18: %Int16.Op.type.180c8b.18 = struct_value () [concrete] +// CHECK:STDOUT: %custom_witness.e58: = custom_witness (%Int64, %Int16.Op.c3e49c.18), @Negate [concrete] +// CHECK:STDOUT: %facet_value.70a: %facet_type.89a = facet_value %Int16, (%custom_witness.e5b, %custom_witness.e58) [concrete] +// CHECK:STDOUT: %pattern_type.c49: type = pattern_type %facet_type.89a [concrete] +// CHECK:STDOUT: %facet_type.d5d: type = facet_type <@Destroy & @Negate where %impl.elem0.f00 = %Int32> [concrete] +// CHECK:STDOUT: %Int32.Op.type.68b858.18: type = fn_type @Int32.Op.18 [concrete] +// CHECK:STDOUT: %Int32.Op.6afff1.18: %Int32.Op.type.68b858.18 = struct_value () [concrete] +// CHECK:STDOUT: %custom_witness.e8a: = custom_witness (%Int32, %Int32.Op.6afff1.18), @Negate [concrete] +// CHECK:STDOUT: %facet_value.396: %facet_type.d5d = facet_value %Int32, (%custom_witness.ce1, %custom_witness.e8a) [concrete] +// CHECK:STDOUT: %pattern_type.0ec: type = pattern_type %facet_type.d5d [concrete] +// CHECK:STDOUT: %complete_type.f1c: = complete_type_witness %AddWith.type.344 [concrete] +// CHECK:STDOUT: %AddWith.facet.ffe: %AddWith.type.344 = facet_value %i16, (%custom_witness.47f) [concrete] +// CHECK:STDOUT: %AddWith.WithSelf.Op.type.894: type = fn_type @AddWith.WithSelf.Op, @AddWith.WithSelf(%Int16, %AddWith.facet.ffe) [concrete] +// CHECK:STDOUT: %.b10: type = fn_type_with_self_type %AddWith.WithSelf.Op.type.894, %AddWith.facet.ffe [concrete] +// CHECK:STDOUT: %complete_type.9b3: = complete_type_witness %SubWith.type.306 [concrete] +// CHECK:STDOUT: %SubWith.facet.dd9: %SubWith.type.306 = facet_value %i16, (%custom_witness.a7b) [concrete] +// CHECK:STDOUT: %SubWith.WithSelf.Op.type.44d: type = fn_type @SubWith.WithSelf.Op, @SubWith.WithSelf(%Int16, %SubWith.facet.dd9) [concrete] +// CHECK:STDOUT: %.acf: type = fn_type_with_self_type %SubWith.WithSelf.Op.type.44d, %SubWith.facet.dd9 [concrete] +// CHECK:STDOUT: %complete_type.4d2: = complete_type_witness %MulWith.type.0cd [concrete] +// CHECK:STDOUT: %MulWith.facet.2a7: %MulWith.type.0cd = facet_value %i16, (%custom_witness.e40) [concrete] +// CHECK:STDOUT: %MulWith.WithSelf.Op.type.504: type = fn_type @MulWith.WithSelf.Op, @MulWith.WithSelf(%Int16, %MulWith.facet.2a7) [concrete] +// CHECK:STDOUT: %.20d: type = fn_type_with_self_type %MulWith.WithSelf.Op.type.504, %MulWith.facet.2a7 [concrete] +// CHECK:STDOUT: %complete_type.e42: = complete_type_witness %DivWith.type.4c2 [concrete] +// CHECK:STDOUT: %DivWith.facet.c60: %DivWith.type.4c2 = facet_value %i16, (%custom_witness.fb3) [concrete] +// CHECK:STDOUT: %DivWith.WithSelf.Op.type.7eb: type = fn_type @DivWith.WithSelf.Op, @DivWith.WithSelf(%Int16, %DivWith.facet.c60) [concrete] +// CHECK:STDOUT: %.411: type = fn_type_with_self_type %DivWith.WithSelf.Op.type.7eb, %DivWith.facet.c60 [concrete] +// CHECK:STDOUT: %complete_type.e9f: = complete_type_witness %ModWith.type.009 [concrete] +// CHECK:STDOUT: %ModWith.facet.0e3: %ModWith.type.009 = facet_value %i16, (%custom_witness.69e) [concrete] +// CHECK:STDOUT: %ModWith.WithSelf.Op.type.a02: type = fn_type @ModWith.WithSelf.Op, @ModWith.WithSelf(%Int16, %ModWith.facet.0e3) [concrete] +// CHECK:STDOUT: %.a0e: type = fn_type_with_self_type %ModWith.WithSelf.Op.type.a02, %ModWith.facet.0e3 [concrete] +// CHECK:STDOUT: %complete_type.e1b: = complete_type_witness %AddWith.type.a18 [concrete] +// CHECK:STDOUT: %AddWith.facet.c96: %AddWith.type.a18 = facet_value %Int16, (%custom_witness.096) [concrete] +// CHECK:STDOUT: %AddWith.WithSelf.Op.type.b73: type = fn_type @AddWith.WithSelf.Op, @AddWith.WithSelf(%i16, %AddWith.facet.c96) [concrete] +// CHECK:STDOUT: %.f80: type = fn_type_with_self_type %AddWith.WithSelf.Op.type.b73, %AddWith.facet.c96 [concrete] +// CHECK:STDOUT: %complete_type.6de: = complete_type_witness %SubWith.type.a1b [concrete] +// CHECK:STDOUT: %SubWith.facet.3c2: %SubWith.type.a1b = facet_value %Int16, (%custom_witness.ced) [concrete] +// CHECK:STDOUT: %SubWith.WithSelf.Op.type.9bf: type = fn_type @SubWith.WithSelf.Op, @SubWith.WithSelf(%i16, %SubWith.facet.3c2) [concrete] +// CHECK:STDOUT: %.90d: type = fn_type_with_self_type %SubWith.WithSelf.Op.type.9bf, %SubWith.facet.3c2 [concrete] +// CHECK:STDOUT: %complete_type.8b34: = complete_type_witness %MulWith.type.ee9 [concrete] +// CHECK:STDOUT: %MulWith.facet.0a1: %MulWith.type.ee9 = facet_value %Int16, (%custom_witness.270) [concrete] +// CHECK:STDOUT: %MulWith.WithSelf.Op.type.a45: type = fn_type @MulWith.WithSelf.Op, @MulWith.WithSelf(%i16, %MulWith.facet.0a1) [concrete] +// CHECK:STDOUT: %.70d: type = fn_type_with_self_type %MulWith.WithSelf.Op.type.a45, %MulWith.facet.0a1 [concrete] +// CHECK:STDOUT: %complete_type.fc5: = complete_type_witness %DivWith.type.9ae [concrete] +// CHECK:STDOUT: %DivWith.facet.915: %DivWith.type.9ae = facet_value %Int16, (%custom_witness.462) [concrete] +// CHECK:STDOUT: %DivWith.WithSelf.Op.type.e9d: type = fn_type @DivWith.WithSelf.Op, @DivWith.WithSelf(%i16, %DivWith.facet.915) [concrete] +// CHECK:STDOUT: %.d3f: type = fn_type_with_self_type %DivWith.WithSelf.Op.type.e9d, %DivWith.facet.915 [concrete] +// CHECK:STDOUT: %complete_type.78b: = complete_type_witness %ModWith.type.406 [concrete] +// CHECK:STDOUT: %ModWith.facet.6ed: %ModWith.type.406 = facet_value %Int16, (%custom_witness.84d2) [concrete] +// CHECK:STDOUT: %ModWith.WithSelf.Op.type.a5a: type = fn_type @ModWith.WithSelf.Op, @ModWith.WithSelf(%i16, %ModWith.facet.6ed) [concrete] +// CHECK:STDOUT: %.a4e: type = fn_type_with_self_type %ModWith.WithSelf.Op.type.a5a, %ModWith.facet.6ed [concrete] +// CHECK:STDOUT: %complete_type.03d: = complete_type_witness %AddWith.type.e9e [concrete] +// CHECK:STDOUT: %AddWith.facet.abd: %AddWith.type.e9e = facet_value %Int16, (%custom_witness.200) [concrete] +// CHECK:STDOUT: %AddWith.WithSelf.Op.type.708: type = fn_type @AddWith.WithSelf.Op, @AddWith.WithSelf(%Int32, %AddWith.facet.abd) [concrete] +// CHECK:STDOUT: %.0ff: type = fn_type_with_self_type %AddWith.WithSelf.Op.type.708, %AddWith.facet.abd [concrete] +// CHECK:STDOUT: %complete_type.9bf: = complete_type_witness %SubWith.type.84c [concrete] +// CHECK:STDOUT: %SubWith.facet.696: %SubWith.type.84c = facet_value %Int16, (%custom_witness.103) [concrete] +// CHECK:STDOUT: %SubWith.WithSelf.Op.type.e30: type = fn_type @SubWith.WithSelf.Op, @SubWith.WithSelf(%Int32, %SubWith.facet.696) [concrete] +// CHECK:STDOUT: %.a54: type = fn_type_with_self_type %SubWith.WithSelf.Op.type.e30, %SubWith.facet.696 [concrete] +// CHECK:STDOUT: %complete_type.a1f: = complete_type_witness %MulWith.type.d1b [concrete] +// CHECK:STDOUT: %MulWith.facet.6d1: %MulWith.type.d1b = facet_value %Int16, (%custom_witness.a6d) [concrete] +// CHECK:STDOUT: %MulWith.WithSelf.Op.type.61d: type = fn_type @MulWith.WithSelf.Op, @MulWith.WithSelf(%Int32, %MulWith.facet.6d1) [concrete] +// CHECK:STDOUT: %.3a1: type = fn_type_with_self_type %MulWith.WithSelf.Op.type.61d, %MulWith.facet.6d1 [concrete] +// CHECK:STDOUT: %complete_type.e49: = complete_type_witness %DivWith.type.26e [concrete] +// CHECK:STDOUT: %DivWith.facet.246: %DivWith.type.26e = facet_value %Int16, (%custom_witness.510) [concrete] +// CHECK:STDOUT: %DivWith.WithSelf.Op.type.623: type = fn_type @DivWith.WithSelf.Op, @DivWith.WithSelf(%Int32, %DivWith.facet.246) [concrete] +// CHECK:STDOUT: %.e6b: type = fn_type_with_self_type %DivWith.WithSelf.Op.type.623, %DivWith.facet.246 [concrete] +// CHECK:STDOUT: %complete_type.3ed: = complete_type_witness %ModWith.type.5c4 [concrete] +// CHECK:STDOUT: %ModWith.facet.76b: %ModWith.type.5c4 = facet_value %Int16, (%custom_witness.a62) [concrete] +// CHECK:STDOUT: %ModWith.WithSelf.Op.type.cfc: type = fn_type @ModWith.WithSelf.Op, @ModWith.WithSelf(%Int32, %ModWith.facet.76b) [concrete] +// CHECK:STDOUT: %.132: type = fn_type_with_self_type %ModWith.WithSelf.Op.type.cfc, %ModWith.facet.76b [concrete] +// CHECK:STDOUT: %AddWith.facet.fce: %AddWith.type.344 = facet_value %Int32, (%custom_witness.116) [concrete] +// CHECK:STDOUT: %AddWith.WithSelf.Op.type.523: type = fn_type @AddWith.WithSelf.Op, @AddWith.WithSelf(%Int16, %AddWith.facet.fce) [concrete] +// CHECK:STDOUT: %.a28: type = fn_type_with_self_type %AddWith.WithSelf.Op.type.523, %AddWith.facet.fce [concrete] +// CHECK:STDOUT: %SubWith.facet.099: %SubWith.type.306 = facet_value %Int32, (%custom_witness.904) [concrete] +// CHECK:STDOUT: %SubWith.WithSelf.Op.type.5d6: type = fn_type @SubWith.WithSelf.Op, @SubWith.WithSelf(%Int16, %SubWith.facet.099) [concrete] +// CHECK:STDOUT: %.43e: type = fn_type_with_self_type %SubWith.WithSelf.Op.type.5d6, %SubWith.facet.099 [concrete] +// CHECK:STDOUT: %MulWith.facet.aea: %MulWith.type.0cd = facet_value %Int32, (%custom_witness.04f) [concrete] +// CHECK:STDOUT: %MulWith.WithSelf.Op.type.f3c: type = fn_type @MulWith.WithSelf.Op, @MulWith.WithSelf(%Int16, %MulWith.facet.aea) [concrete] +// CHECK:STDOUT: %.a30: type = fn_type_with_self_type %MulWith.WithSelf.Op.type.f3c, %MulWith.facet.aea [concrete] +// CHECK:STDOUT: %DivWith.facet.687: %DivWith.type.4c2 = facet_value %Int32, (%custom_witness.53b) [concrete] +// CHECK:STDOUT: %DivWith.WithSelf.Op.type.b6a: type = fn_type @DivWith.WithSelf.Op, @DivWith.WithSelf(%Int16, %DivWith.facet.687) [concrete] +// CHECK:STDOUT: %.c6a: type = fn_type_with_self_type %DivWith.WithSelf.Op.type.b6a, %DivWith.facet.687 [concrete] +// CHECK:STDOUT: %ModWith.facet.7e6: %ModWith.type.009 = facet_value %Int32, (%custom_witness.895) [concrete] +// CHECK:STDOUT: %ModWith.WithSelf.Op.type.55e: type = fn_type @ModWith.WithSelf.Op, @ModWith.WithSelf(%Int16, %ModWith.facet.7e6) [concrete] +// CHECK:STDOUT: %.274: type = fn_type_with_self_type %ModWith.WithSelf.Op.type.55e, %ModWith.facet.7e6 [concrete] +// CHECK:STDOUT: %AddWith.facet.e5b: %AddWith.type.e9e = facet_value %Int32, (%custom_witness.78d) [concrete] +// CHECK:STDOUT: %AddWith.WithSelf.Op.type.13e: type = fn_type @AddWith.WithSelf.Op, @AddWith.WithSelf(%Int32, %AddWith.facet.e5b) [concrete] +// CHECK:STDOUT: %.56e: type = fn_type_with_self_type %AddWith.WithSelf.Op.type.13e, %AddWith.facet.e5b [concrete] +// CHECK:STDOUT: %SubWith.facet.e26: %SubWith.type.84c = facet_value %Int32, (%custom_witness.64d) [concrete] +// CHECK:STDOUT: %SubWith.WithSelf.Op.type.d8a: type = fn_type @SubWith.WithSelf.Op, @SubWith.WithSelf(%Int32, %SubWith.facet.e26) [concrete] +// CHECK:STDOUT: %.cb1: type = fn_type_with_self_type %SubWith.WithSelf.Op.type.d8a, %SubWith.facet.e26 [concrete] +// CHECK:STDOUT: %MulWith.facet.b74: %MulWith.type.d1b = facet_value %Int32, (%custom_witness.7b6d) [concrete] +// CHECK:STDOUT: %MulWith.WithSelf.Op.type.25b: type = fn_type @MulWith.WithSelf.Op, @MulWith.WithSelf(%Int32, %MulWith.facet.b74) [concrete] +// CHECK:STDOUT: %.e42: type = fn_type_with_self_type %MulWith.WithSelf.Op.type.25b, %MulWith.facet.b74 [concrete] +// CHECK:STDOUT: %DivWith.facet.8b3: %DivWith.type.26e = facet_value %Int32, (%custom_witness.db6) [concrete] +// CHECK:STDOUT: %DivWith.WithSelf.Op.type.f6d: type = fn_type @DivWith.WithSelf.Op, @DivWith.WithSelf(%Int32, %DivWith.facet.8b3) [concrete] +// CHECK:STDOUT: %.c6f: type = fn_type_with_self_type %DivWith.WithSelf.Op.type.f6d, %DivWith.facet.8b3 [concrete] +// CHECK:STDOUT: %ModWith.facet.c6b: %ModWith.type.5c4 = facet_value %Int32, (%custom_witness.e01) [concrete] +// CHECK:STDOUT: %ModWith.WithSelf.Op.type.b72: type = fn_type @ModWith.WithSelf.Op, @ModWith.WithSelf(%Int32, %ModWith.facet.c6b) [concrete] +// CHECK:STDOUT: %.a97: type = fn_type_with_self_type %ModWith.WithSelf.Op.type.b72, %ModWith.facet.c6b [concrete] +// CHECK:STDOUT: %complete_type.d2d: = complete_type_witness %AddWith.type.ee5 [concrete] +// CHECK:STDOUT: %AddWith.facet.484: %AddWith.type.ee5 = facet_value %Int32, (%custom_witness.1b7) [concrete] +// CHECK:STDOUT: %AddWith.WithSelf.Op.type.24f: type = fn_type @AddWith.WithSelf.Op, @AddWith.WithSelf(%Int64, %AddWith.facet.484) [concrete] +// CHECK:STDOUT: %.442: type = fn_type_with_self_type %AddWith.WithSelf.Op.type.24f, %AddWith.facet.484 [concrete] +// CHECK:STDOUT: %complete_type.c98: = complete_type_witness %SubWith.type.b41 [concrete] +// CHECK:STDOUT: %SubWith.facet.80e: %SubWith.type.b41 = facet_value %Int32, (%custom_witness.cab) [concrete] +// CHECK:STDOUT: %SubWith.WithSelf.Op.type.c99: type = fn_type @SubWith.WithSelf.Op, @SubWith.WithSelf(%Int64, %SubWith.facet.80e) [concrete] +// CHECK:STDOUT: %.9c9: type = fn_type_with_self_type %SubWith.WithSelf.Op.type.c99, %SubWith.facet.80e [concrete] +// CHECK:STDOUT: %complete_type.b09: = complete_type_witness %MulWith.type.166 [concrete] +// CHECK:STDOUT: %MulWith.facet.0d5: %MulWith.type.166 = facet_value %Int32, (%custom_witness.f53) [concrete] +// CHECK:STDOUT: %MulWith.WithSelf.Op.type.97b: type = fn_type @MulWith.WithSelf.Op, @MulWith.WithSelf(%Int64, %MulWith.facet.0d5) [concrete] +// CHECK:STDOUT: %.07b: type = fn_type_with_self_type %MulWith.WithSelf.Op.type.97b, %MulWith.facet.0d5 [concrete] +// CHECK:STDOUT: %complete_type.09b: = complete_type_witness %DivWith.type.70f [concrete] +// CHECK:STDOUT: %DivWith.facet.22c: %DivWith.type.70f = facet_value %Int32, (%custom_witness.bca) [concrete] +// CHECK:STDOUT: %DivWith.WithSelf.Op.type.565: type = fn_type @DivWith.WithSelf.Op, @DivWith.WithSelf(%Int64, %DivWith.facet.22c) [concrete] +// CHECK:STDOUT: %.b72: type = fn_type_with_self_type %DivWith.WithSelf.Op.type.565, %DivWith.facet.22c [concrete] +// CHECK:STDOUT: %complete_type.6fa: = complete_type_witness %ModWith.type.a92 [concrete] +// CHECK:STDOUT: %ModWith.facet.570: %ModWith.type.a92 = facet_value %Int32, (%custom_witness.1b0) [concrete] +// CHECK:STDOUT: %ModWith.WithSelf.Op.type.2b2: type = fn_type @ModWith.WithSelf.Op, @ModWith.WithSelf(%Int64, %ModWith.facet.570) [concrete] +// CHECK:STDOUT: %.16c: type = fn_type_with_self_type %ModWith.WithSelf.Op.type.2b2, %ModWith.facet.570 [concrete] +// CHECK:STDOUT: %AddWith.facet.66c: %AddWith.type.e9e = facet_value %Int64, (%custom_witness.fc1) [concrete] +// CHECK:STDOUT: %AddWith.WithSelf.Op.type.e16: type = fn_type @AddWith.WithSelf.Op, @AddWith.WithSelf(%Int32, %AddWith.facet.66c) [concrete] +// CHECK:STDOUT: %.41b: type = fn_type_with_self_type %AddWith.WithSelf.Op.type.e16, %AddWith.facet.66c [concrete] +// CHECK:STDOUT: %SubWith.facet.494: %SubWith.type.84c = facet_value %Int64, (%custom_witness.31e) [concrete] +// CHECK:STDOUT: %SubWith.WithSelf.Op.type.0e3: type = fn_type @SubWith.WithSelf.Op, @SubWith.WithSelf(%Int32, %SubWith.facet.494) [concrete] +// CHECK:STDOUT: %.936: type = fn_type_with_self_type %SubWith.WithSelf.Op.type.0e3, %SubWith.facet.494 [concrete] +// CHECK:STDOUT: %MulWith.facet.dab: %MulWith.type.d1b = facet_value %Int64, (%custom_witness.709) [concrete] +// CHECK:STDOUT: %MulWith.WithSelf.Op.type.549: type = fn_type @MulWith.WithSelf.Op, @MulWith.WithSelf(%Int32, %MulWith.facet.dab) [concrete] +// CHECK:STDOUT: %.dc0: type = fn_type_with_self_type %MulWith.WithSelf.Op.type.549, %MulWith.facet.dab [concrete] +// CHECK:STDOUT: %DivWith.facet.9ad: %DivWith.type.26e = facet_value %Int64, (%custom_witness.47b) [concrete] +// CHECK:STDOUT: %DivWith.WithSelf.Op.type.596: type = fn_type @DivWith.WithSelf.Op, @DivWith.WithSelf(%Int32, %DivWith.facet.9ad) [concrete] +// CHECK:STDOUT: %.def: type = fn_type_with_self_type %DivWith.WithSelf.Op.type.596, %DivWith.facet.9ad [concrete] +// CHECK:STDOUT: %ModWith.facet.325: %ModWith.type.5c4 = facet_value %Int64, (%custom_witness.ad6) [concrete] +// CHECK:STDOUT: %ModWith.WithSelf.Op.type.efe: type = fn_type @ModWith.WithSelf.Op, @ModWith.WithSelf(%Int32, %ModWith.facet.325) [concrete] +// CHECK:STDOUT: %.ef4: type = fn_type_with_self_type %ModWith.WithSelf.Op.type.efe, %ModWith.facet.325 [concrete] +// CHECK:STDOUT: %complete_type.901: = complete_type_witness %AddAssignWith.type.704 [concrete] +// CHECK:STDOUT: %AddAssignWith.WithSelf.Op.type.2c7: type = fn_type @AddAssignWith.WithSelf.Op, @AddAssignWith.WithSelf(%i16, %AddAssignWith.facet.23f) [concrete] +// CHECK:STDOUT: %.122: type = fn_type_with_self_type %AddAssignWith.WithSelf.Op.type.2c7, %AddAssignWith.facet.23f [concrete] +// CHECK:STDOUT: %complete_type.f45: = complete_type_witness %SubAssignWith.type.fed [concrete] +// CHECK:STDOUT: %SubAssignWith.WithSelf.Op.type.71a: type = fn_type @SubAssignWith.WithSelf.Op, @SubAssignWith.WithSelf(%i16, %SubAssignWith.facet.3e7) [concrete] +// CHECK:STDOUT: %.697: type = fn_type_with_self_type %SubAssignWith.WithSelf.Op.type.71a, %SubAssignWith.facet.3e7 [concrete] +// CHECK:STDOUT: %complete_type.a71: = complete_type_witness %MulAssignWith.type.6c0 [concrete] +// CHECK:STDOUT: %MulAssignWith.WithSelf.Op.type.dca: type = fn_type @MulAssignWith.WithSelf.Op, @MulAssignWith.WithSelf(%i16, %MulAssignWith.facet.78f) [concrete] +// CHECK:STDOUT: %.bb2: type = fn_type_with_self_type %MulAssignWith.WithSelf.Op.type.dca, %MulAssignWith.facet.78f [concrete] +// CHECK:STDOUT: %complete_type.620: = complete_type_witness %DivAssignWith.type.527 [concrete] +// CHECK:STDOUT: %DivAssignWith.WithSelf.Op.type.76f: type = fn_type @DivAssignWith.WithSelf.Op, @DivAssignWith.WithSelf(%i16, %DivAssignWith.facet.b0d) [concrete] +// CHECK:STDOUT: %.32e: type = fn_type_with_self_type %DivAssignWith.WithSelf.Op.type.76f, %DivAssignWith.facet.b0d [concrete] +// CHECK:STDOUT: %complete_type.422: = complete_type_witness %ModAssignWith.type.ead [concrete] +// CHECK:STDOUT: %ModAssignWith.WithSelf.Op.type.bea: type = fn_type @ModAssignWith.WithSelf.Op, @ModAssignWith.WithSelf(%i16, %ModAssignWith.facet.ada) [concrete] +// CHECK:STDOUT: %.51a: type = fn_type_with_self_type %ModAssignWith.WithSelf.Op.type.bea, %ModAssignWith.facet.ada [concrete] +// CHECK:STDOUT: %complete_type.2ec: = complete_type_witness %AddAssignWith.type.a71 [concrete] +// CHECK:STDOUT: %AddAssignWith.WithSelf.Op.type.181: type = fn_type @AddAssignWith.WithSelf.Op, @AddAssignWith.WithSelf(%Int32, %AddAssignWith.facet.d85) [concrete] +// CHECK:STDOUT: %.e44: type = fn_type_with_self_type %AddAssignWith.WithSelf.Op.type.181, %AddAssignWith.facet.d85 [concrete] +// CHECK:STDOUT: %complete_type.1ca: = complete_type_witness %SubAssignWith.type.35f [concrete] +// CHECK:STDOUT: %SubAssignWith.WithSelf.Op.type.e51: type = fn_type @SubAssignWith.WithSelf.Op, @SubAssignWith.WithSelf(%Int32, %SubAssignWith.facet.187) [concrete] +// CHECK:STDOUT: %.34b: type = fn_type_with_self_type %SubAssignWith.WithSelf.Op.type.e51, %SubAssignWith.facet.187 [concrete] +// CHECK:STDOUT: %complete_type.a19: = complete_type_witness %MulAssignWith.type.dd2 [concrete] +// CHECK:STDOUT: %MulAssignWith.WithSelf.Op.type.89d: type = fn_type @MulAssignWith.WithSelf.Op, @MulAssignWith.WithSelf(%Int32, %MulAssignWith.facet.775) [concrete] +// CHECK:STDOUT: %.263: type = fn_type_with_self_type %MulAssignWith.WithSelf.Op.type.89d, %MulAssignWith.facet.775 [concrete] +// CHECK:STDOUT: %complete_type.136: = complete_type_witness %DivAssignWith.type.a38 [concrete] +// CHECK:STDOUT: %DivAssignWith.WithSelf.Op.type.593: type = fn_type @DivAssignWith.WithSelf.Op, @DivAssignWith.WithSelf(%Int32, %DivAssignWith.facet.f5b) [concrete] +// CHECK:STDOUT: %.c99: type = fn_type_with_self_type %DivAssignWith.WithSelf.Op.type.593, %DivAssignWith.facet.f5b [concrete] +// CHECK:STDOUT: %complete_type.ca8: = complete_type_witness %ModAssignWith.type.36f [concrete] +// CHECK:STDOUT: %ModAssignWith.WithSelf.Op.type.f83: type = fn_type @ModAssignWith.WithSelf.Op, @ModAssignWith.WithSelf(%Int32, %ModAssignWith.facet.b82) [concrete] +// CHECK:STDOUT: %.146: type = fn_type_with_self_type %ModAssignWith.WithSelf.Op.type.f83, %ModAssignWith.facet.b82 [concrete] +// CHECK:STDOUT: %AddAssignWith.WithSelf.Op.type.750: type = fn_type @AddAssignWith.WithSelf.Op, @AddAssignWith.WithSelf(%Int32, %AddAssignWith.facet.b70) [concrete] +// CHECK:STDOUT: %.5d8: type = fn_type_with_self_type %AddAssignWith.WithSelf.Op.type.750, %AddAssignWith.facet.b70 [concrete] +// CHECK:STDOUT: %SubAssignWith.WithSelf.Op.type.792: type = fn_type @SubAssignWith.WithSelf.Op, @SubAssignWith.WithSelf(%Int32, %SubAssignWith.facet.bd0) [concrete] +// CHECK:STDOUT: %.827: type = fn_type_with_self_type %SubAssignWith.WithSelf.Op.type.792, %SubAssignWith.facet.bd0 [concrete] +// CHECK:STDOUT: %MulAssignWith.WithSelf.Op.type.788: type = fn_type @MulAssignWith.WithSelf.Op, @MulAssignWith.WithSelf(%Int32, %MulAssignWith.facet.982) [concrete] +// CHECK:STDOUT: %.4a3: type = fn_type_with_self_type %MulAssignWith.WithSelf.Op.type.788, %MulAssignWith.facet.982 [concrete] +// CHECK:STDOUT: %DivAssignWith.WithSelf.Op.type.646: type = fn_type @DivAssignWith.WithSelf.Op, @DivAssignWith.WithSelf(%Int32, %DivAssignWith.facet.d3b) [concrete] +// CHECK:STDOUT: %.384: type = fn_type_with_self_type %DivAssignWith.WithSelf.Op.type.646, %DivAssignWith.facet.d3b [concrete] +// CHECK:STDOUT: %ModAssignWith.WithSelf.Op.type.a34: type = fn_type @ModAssignWith.WithSelf.Op, @ModAssignWith.WithSelf(%Int32, %ModAssignWith.facet.1c6) [concrete] +// CHECK:STDOUT: %.ee0: type = fn_type_with_self_type %ModAssignWith.WithSelf.Op.type.a34, %ModAssignWith.facet.1c6 [concrete] +// CHECK:STDOUT: %Inc.WithSelf.Op.type.eaa: type = fn_type @Inc.WithSelf.Op, @Inc.WithSelf(%Inc.facet.390) [concrete] +// CHECK:STDOUT: %.696: type = fn_type_with_self_type %Inc.WithSelf.Op.type.eaa, %Inc.facet.390 [concrete] +// CHECK:STDOUT: %Dec.WithSelf.Op.type.6fb: type = fn_type @Dec.WithSelf.Op, @Dec.WithSelf(%Dec.facet.961) [concrete] +// CHECK:STDOUT: %.cdd: type = fn_type_with_self_type %Dec.WithSelf.Op.type.6fb, %Dec.facet.961 [concrete] +// CHECK:STDOUT: %Negate.facet.0a5: %Negate.type = facet_value %Int16, (%custom_witness.e58) [concrete] +// CHECK:STDOUT: %Negate.WithSelf.Op.type.d7d: type = fn_type @Negate.WithSelf.Op, @Negate.WithSelf(%Negate.facet.0a5) [concrete] +// CHECK:STDOUT: %.3e7: type = fn_type_with_self_type %Negate.WithSelf.Op.type.d7d, %Negate.facet.0a5 [concrete] +// CHECK:STDOUT: %Negate.facet.3c9: %Negate.type = facet_value %Int32, (%custom_witness.e8a) [concrete] +// CHECK:STDOUT: %Negate.WithSelf.Op.type.1bc: type = fn_type @Negate.WithSelf.Op, @Negate.WithSelf(%Negate.facet.3c9) [concrete] +// CHECK:STDOUT: %.19b: type = fn_type_with_self_type %Negate.WithSelf.Op.type.1bc, %Negate.facet.3c9 [concrete] +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: imports { +// CHECK:STDOUT: %Core.import_ref.037: @AddWith.WithSelf.%AddWith.assoc_type (%AddWith.assoc_type.b6a) = import_ref Core//prelude/operators/arithmetic, loc{{\d+_\d+}}, loaded [symbolic = @AddWith.WithSelf.%assoc1 (constants.%assoc1.4d4)] +// CHECK:STDOUT: %Core.import_ref.1b1: @AddWith.WithSelf.%AddWith.WithSelf.Op.type (%AddWith.WithSelf.Op.type.08f) = import_ref Core//prelude/operators/arithmetic, loc{{\d+_\d+}}, loaded [symbolic = @AddWith.WithSelf.%AddWith.WithSelf.Op (constants.%AddWith.WithSelf.Op.fb8)] +// CHECK:STDOUT: %Core.import_ref.6e9: type = import_ref Core//prelude/operators/arithmetic, loc{{\d+_\d+}}, loaded [concrete = %Result.559] +// CHECK:STDOUT: %Result.559: type = assoc_const_decl @Result.1 [concrete] {} +// CHECK:STDOUT: %Core.import_ref.a84 = import_ref Core//prelude/operators/arithmetic, loc{{\d+_\d+}}, unloaded +// CHECK:STDOUT: %Core.import_ref.413: @SubWith.WithSelf.%SubWith.assoc_type (%SubWith.assoc_type.645) = import_ref Core//prelude/operators/arithmetic, loc{{\d+_\d+}}, loaded [symbolic = @SubWith.WithSelf.%assoc1 (constants.%assoc1.f09)] +// CHECK:STDOUT: %Core.import_ref.abb: @SubWith.WithSelf.%SubWith.WithSelf.Op.type (%SubWith.WithSelf.Op.type.0bf) = import_ref Core//prelude/operators/arithmetic, loc{{\d+_\d+}}, loaded [symbolic = @SubWith.WithSelf.%SubWith.WithSelf.Op (constants.%SubWith.WithSelf.Op.bd9)] +// CHECK:STDOUT: %Core.import_ref.7e5: type = import_ref Core//prelude/operators/arithmetic, loc{{\d+_\d+}}, loaded [concrete = %Result.757] +// CHECK:STDOUT: %Result.757: type = assoc_const_decl @Result.2 [concrete] {} +// CHECK:STDOUT: %Core.import_ref.e83 = import_ref Core//prelude/operators/arithmetic, loc{{\d+_\d+}}, unloaded +// CHECK:STDOUT: %Core.import_ref.a1b: @MulWith.WithSelf.%MulWith.assoc_type (%MulWith.assoc_type.b5d) = import_ref Core//prelude/operators/arithmetic, loc{{\d+_\d+}}, loaded [symbolic = @MulWith.WithSelf.%assoc1 (constants.%assoc1.ccf)] +// CHECK:STDOUT: %Core.import_ref.abc: @MulWith.WithSelf.%MulWith.WithSelf.Op.type (%MulWith.WithSelf.Op.type.00c) = import_ref Core//prelude/operators/arithmetic, loc{{\d+_\d+}}, loaded [symbolic = @MulWith.WithSelf.%MulWith.WithSelf.Op (constants.%MulWith.WithSelf.Op.07a)] +// CHECK:STDOUT: %Core.import_ref.d9b: type = import_ref Core//prelude/operators/arithmetic, loc{{\d+_\d+}}, loaded [concrete = %Result.4ff] +// CHECK:STDOUT: %Result.4ff: type = assoc_const_decl @Result.3 [concrete] {} +// CHECK:STDOUT: %Core.import_ref.d5a = import_ref Core//prelude/operators/arithmetic, loc{{\d+_\d+}}, unloaded +// CHECK:STDOUT: %Core.import_ref.beb: @DivWith.WithSelf.%DivWith.assoc_type (%DivWith.assoc_type.16c) = import_ref Core//prelude/operators/arithmetic, loc{{\d+_\d+}}, loaded [symbolic = @DivWith.WithSelf.%assoc1 (constants.%assoc1.b83)] +// CHECK:STDOUT: %Core.import_ref.bb2c: @DivWith.WithSelf.%DivWith.WithSelf.Op.type (%DivWith.WithSelf.Op.type.8a1) = import_ref Core//prelude/operators/arithmetic, loc{{\d+_\d+}}, loaded [symbolic = @DivWith.WithSelf.%DivWith.WithSelf.Op (constants.%DivWith.WithSelf.Op.0a9)] +// CHECK:STDOUT: %Core.import_ref.14e: type = import_ref Core//prelude/operators/arithmetic, loc{{\d+_\d+}}, loaded [concrete = %Result.e26] +// CHECK:STDOUT: %Result.e26: type = assoc_const_decl @Result.4 [concrete] {} +// CHECK:STDOUT: %Core.import_ref.4c4 = import_ref Core//prelude/operators/arithmetic, loc{{\d+_\d+}}, unloaded +// CHECK:STDOUT: %Core.import_ref.fcf: @ModWith.WithSelf.%ModWith.assoc_type (%ModWith.assoc_type.e6f) = import_ref Core//prelude/operators/arithmetic, loc{{\d+_\d+}}, loaded [symbolic = @ModWith.WithSelf.%assoc1 (constants.%assoc1.e77)] +// CHECK:STDOUT: %Core.import_ref.c05: @ModWith.WithSelf.%ModWith.WithSelf.Op.type (%ModWith.WithSelf.Op.type.f61) = import_ref Core//prelude/operators/arithmetic, loc{{\d+_\d+}}, loaded [symbolic = @ModWith.WithSelf.%ModWith.WithSelf.Op (constants.%ModWith.WithSelf.Op.3ac)] +// CHECK:STDOUT: %Core.import_ref.a0d: type = import_ref Core//prelude/operators/arithmetic, loc{{\d+_\d+}}, loaded [concrete = %Result.044] +// CHECK:STDOUT: %Result.044: type = assoc_const_decl @Result.5 [concrete] {} +// CHECK:STDOUT: %Core.import_ref.7b7 = import_ref Core//prelude/operators/arithmetic, loc{{\d+_\d+}}, unloaded +// CHECK:STDOUT: %Core.import_ref.016: @AddAssignWith.WithSelf.%AddAssignWith.assoc_type (%AddAssignWith.assoc_type.ca2a80.1) = import_ref Core//prelude/operators/arithmetic, loc{{\d+_\d+}}, loaded [symbolic = @AddAssignWith.WithSelf.%assoc0 (constants.%assoc0.5d2)] +// CHECK:STDOUT: %Core.import_ref.7e1: @AddAssignWith.WithSelf.%AddAssignWith.WithSelf.Op.type (%AddAssignWith.WithSelf.Op.type.df0722.1) = import_ref Core//prelude/operators/arithmetic, loc{{\d+_\d+}}, loaded [symbolic = @AddAssignWith.WithSelf.%AddAssignWith.WithSelf.Op (constants.%AddAssignWith.WithSelf.Op.b33928.1)] +// CHECK:STDOUT: %Core.import_ref.f18 = import_ref Core//prelude/operators/arithmetic, loc{{\d+_\d+}}, unloaded +// CHECK:STDOUT: %Core.import_ref.405: @SubAssignWith.WithSelf.%SubAssignWith.assoc_type (%SubAssignWith.assoc_type.4cb9a1.1) = import_ref Core//prelude/operators/arithmetic, loc{{\d+_\d+}}, loaded [symbolic = @SubAssignWith.WithSelf.%assoc0 (constants.%assoc0.fd1)] +// CHECK:STDOUT: %Core.import_ref.5b4: @SubAssignWith.WithSelf.%SubAssignWith.WithSelf.Op.type (%SubAssignWith.WithSelf.Op.type.317c02.1) = import_ref Core//prelude/operators/arithmetic, loc{{\d+_\d+}}, loaded [symbolic = @SubAssignWith.WithSelf.%SubAssignWith.WithSelf.Op (constants.%SubAssignWith.WithSelf.Op.26e13f.1)] +// CHECK:STDOUT: %Core.import_ref.a26 = import_ref Core//prelude/operators/arithmetic, loc{{\d+_\d+}}, unloaded +// CHECK:STDOUT: %Core.import_ref.257: @MulAssignWith.WithSelf.%MulAssignWith.assoc_type (%MulAssignWith.assoc_type.595561.1) = import_ref Core//prelude/operators/arithmetic, loc{{\d+_\d+}}, loaded [symbolic = @MulAssignWith.WithSelf.%assoc0 (constants.%assoc0.fc1)] +// CHECK:STDOUT: %Core.import_ref.69b: @MulAssignWith.WithSelf.%MulAssignWith.WithSelf.Op.type (%MulAssignWith.WithSelf.Op.type.31cf70.1) = import_ref Core//prelude/operators/arithmetic, loc{{\d+_\d+}}, loaded [symbolic = @MulAssignWith.WithSelf.%MulAssignWith.WithSelf.Op (constants.%MulAssignWith.WithSelf.Op.cdf083.1)] +// CHECK:STDOUT: %Core.import_ref.2e6 = import_ref Core//prelude/operators/arithmetic, loc{{\d+_\d+}}, unloaded +// CHECK:STDOUT: %Core.import_ref.b1f: @DivAssignWith.WithSelf.%DivAssignWith.assoc_type (%DivAssignWith.assoc_type.8b4b5b.1) = import_ref Core//prelude/operators/arithmetic, loc{{\d+_\d+}}, loaded [symbolic = @DivAssignWith.WithSelf.%assoc0 (constants.%assoc0.b19)] +// CHECK:STDOUT: %Core.import_ref.799: @DivAssignWith.WithSelf.%DivAssignWith.WithSelf.Op.type (%DivAssignWith.WithSelf.Op.type.ded5d7.1) = import_ref Core//prelude/operators/arithmetic, loc{{\d+_\d+}}, loaded [symbolic = @DivAssignWith.WithSelf.%DivAssignWith.WithSelf.Op (constants.%DivAssignWith.WithSelf.Op.6f2821.1)] +// CHECK:STDOUT: %Core.import_ref.7f9 = import_ref Core//prelude/operators/arithmetic, loc{{\d+_\d+}}, unloaded +// CHECK:STDOUT: %Core.import_ref.b81: @ModAssignWith.WithSelf.%ModAssignWith.assoc_type (%ModAssignWith.assoc_type.1462b9.1) = import_ref Core//prelude/operators/arithmetic, loc{{\d+_\d+}}, loaded [symbolic = @ModAssignWith.WithSelf.%assoc0 (constants.%assoc0.0e6)] +// CHECK:STDOUT: %Core.import_ref.51c: @ModAssignWith.WithSelf.%ModAssignWith.WithSelf.Op.type (%ModAssignWith.WithSelf.Op.type.5452e9.1) = import_ref Core//prelude/operators/arithmetic, loc{{\d+_\d+}}, loaded [symbolic = @ModAssignWith.WithSelf.%ModAssignWith.WithSelf.Op (constants.%ModAssignWith.WithSelf.Op.c5cc9b.1)] +// CHECK:STDOUT: %Core.import_ref.fa5 = import_ref Core//prelude/operators/arithmetic, loc{{\d+_\d+}}, unloaded +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: generic fn @AddWith.loc124(%Result.loc121_9.2: %Destroy.type, %U.loc122_4.2: %Destroy.type, %T.loc123_4.2: @AddWith.loc124.%facet_type.loc123_38 (%facet_type.024)) { +// CHECK:STDOUT: +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: +// CHECK:STDOUT: %require_complete.loc126: = require_complete_type %AddWith.type.loc123_36.1 [symbolic = %require_complete.loc126 (constants.%require_complete.8bd)] +// CHECK:STDOUT: %assoc1: @AddWith.loc124.%AddWith.assoc_type (%AddWith.assoc_type.8c2) = assoc_entity element1, imports.%Core.import_ref.1b1 [symbolic = %assoc1 (constants.%assoc1.0f4)] +// CHECK:STDOUT: %AddWith.lookup_impl_witness.loc126: = lookup_impl_witness %T.loc123_4.1, @AddWith.1, @AddWith.1(%U.as_type.loc123_36.1) [symbolic = %AddWith.lookup_impl_witness.loc126 (constants.%AddWith.lookup_impl_witness.3c7)] +// CHECK:STDOUT: %AddWith.facet: @AddWith.loc124.%AddWith.type.loc123_36.1 (%AddWith.type.07d) = facet_value %T.as_type.loc124_29.1, (%AddWith.lookup_impl_witness.loc126) [symbolic = %AddWith.facet (constants.%AddWith.facet.570)] +// CHECK:STDOUT: %AddWith.WithSelf.Op.type: type = fn_type @AddWith.WithSelf.Op, @AddWith.WithSelf(%U.as_type.loc123_36.1, %AddWith.facet) [symbolic = %AddWith.WithSelf.Op.type (constants.%AddWith.WithSelf.Op.type.82f)] +// CHECK:STDOUT: %.loc126_5.4: type = fn_type_with_self_type %AddWith.WithSelf.Op.type, %AddWith.facet [symbolic = %.loc126_5.4 (constants.%.97d)] +// CHECK:STDOUT: %impl.elem1.loc126_5.2: @AddWith.loc124.%.loc126_5.4 (%.97d) = impl_witness_access %AddWith.lookup_impl_witness.loc126, element1 [symbolic = %impl.elem1.loc126_5.2 (constants.%impl.elem1.07a)] +// CHECK:STDOUT: %specific_impl_fn.loc126_5.3: = specific_impl_function %impl.elem1.loc126_5.2, @AddWith.WithSelf.Op(%U.as_type.loc123_36.1, %AddWith.facet) [symbolic = %specific_impl_fn.loc126_5.3 (constants.%specific_impl_fn.dbc)] +// CHECK:STDOUT: %Destroy.WithSelf.Op.type: type = fn_type @Destroy.WithSelf.Op, @Destroy.WithSelf(%Result.loc121_9.1) [symbolic = %Destroy.WithSelf.Op.type (constants.%Destroy.WithSelf.Op.type.cb2e47.2)] +// CHECK:STDOUT: %.loc126_5.5: type = fn_type_with_self_type %Destroy.WithSelf.Op.type, %Result.loc121_9.1 [symbolic = %.loc126_5.5 (constants.%.d5f)] +// CHECK:STDOUT: %Destroy.lookup_impl_witness: = lookup_impl_witness %Result.loc121_9.1, @Destroy [symbolic = %Destroy.lookup_impl_witness (constants.%Destroy.lookup_impl_witness.d86)] +// CHECK:STDOUT: %impl.elem0.loc126_5.2: @AddWith.loc124.%.loc126_5.5 (%.d5f) = impl_witness_access %Destroy.lookup_impl_witness, element0 [symbolic = %impl.elem0.loc126_5.2 (constants.%impl.elem0.a6b)] +// CHECK:STDOUT: %specific_impl_fn.loc126_5.4: = specific_impl_function %impl.elem0.loc126_5.2, @Destroy.WithSelf.Op(%Result.loc121_9.1) [symbolic = %specific_impl_fn.loc126_5.4 (constants.%specific_impl_fn.761)] +// CHECK:STDOUT: +// CHECK:STDOUT: fn(%result.param: @AddWith.loc124.%Result.as_type.loc123_54.1 (%Result.as_type), %x.param: @AddWith.loc124.%T.as_type.loc124_29.1 (%T.as_type.ab9), %y.param: @AddWith.loc124.%U.as_type.loc123_36.1 (%U.as_type.2b8)) { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %x.ref: @AddWith.loc124.%T.as_type.loc124_29.1 (%T.as_type.ab9) = name_ref x, %x +// CHECK:STDOUT: %y.ref: @AddWith.loc124.%U.as_type.loc123_36.1 (%U.as_type.2b8) = name_ref y, %y +// CHECK:STDOUT: %AddWith.type.loc126: type = facet_type <@AddWith.1, @AddWith.1(constants.%U.as_type.2b8)> [symbolic = %AddWith.type.loc123_36.1 (constants.%AddWith.type.07d)] +// CHECK:STDOUT: %.loc126_5.1: @AddWith.loc124.%AddWith.assoc_type (%AddWith.assoc_type.8c2) = specific_constant imports.%Core.import_ref.037, @AddWith.WithSelf(constants.%U.as_type.2b8, constants.%Self.b7c) [symbolic = %assoc1 (constants.%assoc1.0f4)] +// CHECK:STDOUT: %Op.ref: @AddWith.loc124.%AddWith.assoc_type (%AddWith.assoc_type.8c2) = name_ref Op, %.loc126_5.1 [symbolic = %assoc1 (constants.%assoc1.0f4)] +// CHECK:STDOUT: %impl.elem1.loc126_5.1: @AddWith.loc124.%.loc126_5.4 (%.97d) = impl_witness_access constants.%AddWith.lookup_impl_witness.3c7, element1 [symbolic = %impl.elem1.loc126_5.2 (constants.%impl.elem1.07a)] +// CHECK:STDOUT: %bound_method.loc126_5.1: = bound_method %x.ref, %impl.elem1.loc126_5.1 +// CHECK:STDOUT: %specific_impl_fn.loc126_5.1: = specific_impl_function %impl.elem1.loc126_5.1, @AddWith.WithSelf.Op(constants.%U.as_type.2b8, constants.%AddWith.facet.570) [symbolic = %specific_impl_fn.loc126_5.3 (constants.%specific_impl_fn.dbc)] +// CHECK:STDOUT: %bound_method.loc126_5.2: = bound_method %x.ref, %specific_impl_fn.loc126_5.1 +// CHECK:STDOUT: %.loc126_5.2: ref @AddWith.loc124.%Result.as_type.loc123_54.1 (%Result.as_type) = temporary_storage +// CHECK:STDOUT: %AddWith.WithSelf.Op.call: init @AddWith.loc124.%Result.as_type.loc123_54.1 (%Result.as_type) to %.loc126_5.2 = call %bound_method.loc126_5.2(%x.ref, %y.ref) +// CHECK:STDOUT: %.loc126_5.3: ref @AddWith.loc124.%Result.as_type.loc123_54.1 (%Result.as_type) = temporary %.loc126_5.2, %AddWith.WithSelf.Op.call +// CHECK:STDOUT: %impl.elem0.loc126_5.1: @AddWith.loc124.%.loc126_5.5 (%.d5f) = impl_witness_access constants.%Destroy.lookup_impl_witness.d86, element0 [symbolic = %impl.elem0.loc126_5.2 (constants.%impl.elem0.a6b)] +// CHECK:STDOUT: %bound_method.loc126_5.3: = bound_method %.loc126_5.3, %impl.elem0.loc126_5.1 +// CHECK:STDOUT: %specific_impl_fn.loc126_5.2: = specific_impl_function %impl.elem0.loc126_5.1, @Destroy.WithSelf.Op(constants.%Result) [symbolic = %specific_impl_fn.loc126_5.4 (constants.%specific_impl_fn.761)] +// CHECK:STDOUT: %bound_method.loc126_5.4: = bound_method %.loc126_5.3, %specific_impl_fn.loc126_5.2 +// CHECK:STDOUT: %Destroy.WithSelf.Op.call: init %empty_tuple.type = call %bound_method.loc126_5.4(%.loc126_5.3) +// CHECK:STDOUT: +// CHECK:STDOUT: } +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: generic fn @SubWith.loc135(%Result.loc132_9.2: %Destroy.type, %U.loc133_4.2: %Destroy.type, %T.loc134_4.2: @SubWith.loc135.%facet_type.loc134_38 (%facet_type.bea)) { +// CHECK:STDOUT: +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: +// CHECK:STDOUT: %require_complete.loc137: = require_complete_type %SubWith.type.loc134_36.1 [symbolic = %require_complete.loc137 (constants.%require_complete.ae1)] +// CHECK:STDOUT: %assoc1: @SubWith.loc135.%SubWith.assoc_type (%SubWith.assoc_type.065) = assoc_entity element1, imports.%Core.import_ref.abb [symbolic = %assoc1 (constants.%assoc1.173)] +// CHECK:STDOUT: %SubWith.lookup_impl_witness.loc137: = lookup_impl_witness %T.loc134_4.1, @SubWith.1, @SubWith.1(%U.as_type.loc134_36.1) [symbolic = %SubWith.lookup_impl_witness.loc137 (constants.%SubWith.lookup_impl_witness.db9)] +// CHECK:STDOUT: %SubWith.facet: @SubWith.loc135.%SubWith.type.loc134_36.1 (%SubWith.type.593) = facet_value %T.as_type.loc135_29.1, (%SubWith.lookup_impl_witness.loc137) [symbolic = %SubWith.facet (constants.%SubWith.facet.7f1)] +// CHECK:STDOUT: %SubWith.WithSelf.Op.type: type = fn_type @SubWith.WithSelf.Op, @SubWith.WithSelf(%U.as_type.loc134_36.1, %SubWith.facet) [symbolic = %SubWith.WithSelf.Op.type (constants.%SubWith.WithSelf.Op.type.e59)] +// CHECK:STDOUT: %.loc137_5.4: type = fn_type_with_self_type %SubWith.WithSelf.Op.type, %SubWith.facet [symbolic = %.loc137_5.4 (constants.%.4b6)] +// CHECK:STDOUT: %impl.elem1.loc137_5.2: @SubWith.loc135.%.loc137_5.4 (%.4b6) = impl_witness_access %SubWith.lookup_impl_witness.loc137, element1 [symbolic = %impl.elem1.loc137_5.2 (constants.%impl.elem1.6e4)] +// CHECK:STDOUT: %specific_impl_fn.loc137_5.3: = specific_impl_function %impl.elem1.loc137_5.2, @SubWith.WithSelf.Op(%U.as_type.loc134_36.1, %SubWith.facet) [symbolic = %specific_impl_fn.loc137_5.3 (constants.%specific_impl_fn.0d3)] +// CHECK:STDOUT: %Destroy.WithSelf.Op.type: type = fn_type @Destroy.WithSelf.Op, @Destroy.WithSelf(%Result.loc132_9.1) [symbolic = %Destroy.WithSelf.Op.type (constants.%Destroy.WithSelf.Op.type.cb2e47.2)] +// CHECK:STDOUT: %.loc137_5.5: type = fn_type_with_self_type %Destroy.WithSelf.Op.type, %Result.loc132_9.1 [symbolic = %.loc137_5.5 (constants.%.d5f)] +// CHECK:STDOUT: %Destroy.lookup_impl_witness: = lookup_impl_witness %Result.loc132_9.1, @Destroy [symbolic = %Destroy.lookup_impl_witness (constants.%Destroy.lookup_impl_witness.d86)] +// CHECK:STDOUT: %impl.elem0.loc137_5.2: @SubWith.loc135.%.loc137_5.5 (%.d5f) = impl_witness_access %Destroy.lookup_impl_witness, element0 [symbolic = %impl.elem0.loc137_5.2 (constants.%impl.elem0.a6b)] +// CHECK:STDOUT: %specific_impl_fn.loc137_5.4: = specific_impl_function %impl.elem0.loc137_5.2, @Destroy.WithSelf.Op(%Result.loc132_9.1) [symbolic = %specific_impl_fn.loc137_5.4 (constants.%specific_impl_fn.761)] +// CHECK:STDOUT: +// CHECK:STDOUT: fn(%result.param: @SubWith.loc135.%Result.as_type.loc134_54.1 (%Result.as_type), %x.param: @SubWith.loc135.%T.as_type.loc135_29.1 (%T.as_type.474), %y.param: @SubWith.loc135.%U.as_type.loc134_36.1 (%U.as_type.2b8)) { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %x.ref: @SubWith.loc135.%T.as_type.loc135_29.1 (%T.as_type.474) = name_ref x, %x +// CHECK:STDOUT: %y.ref: @SubWith.loc135.%U.as_type.loc134_36.1 (%U.as_type.2b8) = name_ref y, %y +// CHECK:STDOUT: %SubWith.type.loc137: type = facet_type <@SubWith.1, @SubWith.1(constants.%U.as_type.2b8)> [symbolic = %SubWith.type.loc134_36.1 (constants.%SubWith.type.593)] +// CHECK:STDOUT: %.loc137_5.1: @SubWith.loc135.%SubWith.assoc_type (%SubWith.assoc_type.065) = specific_constant imports.%Core.import_ref.413, @SubWith.WithSelf(constants.%U.as_type.2b8, constants.%Self.ddf) [symbolic = %assoc1 (constants.%assoc1.173)] +// CHECK:STDOUT: %Op.ref: @SubWith.loc135.%SubWith.assoc_type (%SubWith.assoc_type.065) = name_ref Op, %.loc137_5.1 [symbolic = %assoc1 (constants.%assoc1.173)] +// CHECK:STDOUT: %impl.elem1.loc137_5.1: @SubWith.loc135.%.loc137_5.4 (%.4b6) = impl_witness_access constants.%SubWith.lookup_impl_witness.db9, element1 [symbolic = %impl.elem1.loc137_5.2 (constants.%impl.elem1.6e4)] +// CHECK:STDOUT: %bound_method.loc137_5.1: = bound_method %x.ref, %impl.elem1.loc137_5.1 +// CHECK:STDOUT: %specific_impl_fn.loc137_5.1: = specific_impl_function %impl.elem1.loc137_5.1, @SubWith.WithSelf.Op(constants.%U.as_type.2b8, constants.%SubWith.facet.7f1) [symbolic = %specific_impl_fn.loc137_5.3 (constants.%specific_impl_fn.0d3)] +// CHECK:STDOUT: %bound_method.loc137_5.2: = bound_method %x.ref, %specific_impl_fn.loc137_5.1 +// CHECK:STDOUT: %.loc137_5.2: ref @SubWith.loc135.%Result.as_type.loc134_54.1 (%Result.as_type) = temporary_storage +// CHECK:STDOUT: %SubWith.WithSelf.Op.call: init @SubWith.loc135.%Result.as_type.loc134_54.1 (%Result.as_type) to %.loc137_5.2 = call %bound_method.loc137_5.2(%x.ref, %y.ref) +// CHECK:STDOUT: %.loc137_5.3: ref @SubWith.loc135.%Result.as_type.loc134_54.1 (%Result.as_type) = temporary %.loc137_5.2, %SubWith.WithSelf.Op.call +// CHECK:STDOUT: %impl.elem0.loc137_5.1: @SubWith.loc135.%.loc137_5.5 (%.d5f) = impl_witness_access constants.%Destroy.lookup_impl_witness.d86, element0 [symbolic = %impl.elem0.loc137_5.2 (constants.%impl.elem0.a6b)] +// CHECK:STDOUT: %bound_method.loc137_5.3: = bound_method %.loc137_5.3, %impl.elem0.loc137_5.1 +// CHECK:STDOUT: %specific_impl_fn.loc137_5.2: = specific_impl_function %impl.elem0.loc137_5.1, @Destroy.WithSelf.Op(constants.%Result) [symbolic = %specific_impl_fn.loc137_5.4 (constants.%specific_impl_fn.761)] +// CHECK:STDOUT: %bound_method.loc137_5.4: = bound_method %.loc137_5.3, %specific_impl_fn.loc137_5.2 +// CHECK:STDOUT: %Destroy.WithSelf.Op.call: init %empty_tuple.type = call %bound_method.loc137_5.4(%.loc137_5.3) +// CHECK:STDOUT: +// CHECK:STDOUT: } +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: generic fn @MulWith.loc146(%Result.loc143_9.2: %Destroy.type, %U.loc144_4.2: %Destroy.type, %T.loc145_4.2: @MulWith.loc146.%facet_type.loc145_38 (%facet_type.91e)) { +// CHECK:STDOUT: +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: +// CHECK:STDOUT: %require_complete.loc148: = require_complete_type %MulWith.type.loc145_36.1 [symbolic = %require_complete.loc148 (constants.%require_complete.d9d)] +// CHECK:STDOUT: %assoc1: @MulWith.loc146.%MulWith.assoc_type (%MulWith.assoc_type.97c) = assoc_entity element1, imports.%Core.import_ref.abc [symbolic = %assoc1 (constants.%assoc1.496)] +// CHECK:STDOUT: %MulWith.lookup_impl_witness.loc148: = lookup_impl_witness %T.loc145_4.1, @MulWith.1, @MulWith.1(%U.as_type.loc145_36.1) [symbolic = %MulWith.lookup_impl_witness.loc148 (constants.%MulWith.lookup_impl_witness.009)] +// CHECK:STDOUT: %MulWith.facet: @MulWith.loc146.%MulWith.type.loc145_36.1 (%MulWith.type.9532) = facet_value %T.as_type.loc146_29.1, (%MulWith.lookup_impl_witness.loc148) [symbolic = %MulWith.facet (constants.%MulWith.facet.2d0)] +// CHECK:STDOUT: %MulWith.WithSelf.Op.type: type = fn_type @MulWith.WithSelf.Op, @MulWith.WithSelf(%U.as_type.loc145_36.1, %MulWith.facet) [symbolic = %MulWith.WithSelf.Op.type (constants.%MulWith.WithSelf.Op.type.283)] +// CHECK:STDOUT: %.loc148_5.4: type = fn_type_with_self_type %MulWith.WithSelf.Op.type, %MulWith.facet [symbolic = %.loc148_5.4 (constants.%.978)] +// CHECK:STDOUT: %impl.elem1.loc148_5.2: @MulWith.loc146.%.loc148_5.4 (%.978) = impl_witness_access %MulWith.lookup_impl_witness.loc148, element1 [symbolic = %impl.elem1.loc148_5.2 (constants.%impl.elem1.80d)] +// CHECK:STDOUT: %specific_impl_fn.loc148_5.3: = specific_impl_function %impl.elem1.loc148_5.2, @MulWith.WithSelf.Op(%U.as_type.loc145_36.1, %MulWith.facet) [symbolic = %specific_impl_fn.loc148_5.3 (constants.%specific_impl_fn.889)] +// CHECK:STDOUT: %Destroy.WithSelf.Op.type: type = fn_type @Destroy.WithSelf.Op, @Destroy.WithSelf(%Result.loc143_9.1) [symbolic = %Destroy.WithSelf.Op.type (constants.%Destroy.WithSelf.Op.type.cb2e47.2)] +// CHECK:STDOUT: %.loc148_5.5: type = fn_type_with_self_type %Destroy.WithSelf.Op.type, %Result.loc143_9.1 [symbolic = %.loc148_5.5 (constants.%.d5f)] +// CHECK:STDOUT: %Destroy.lookup_impl_witness: = lookup_impl_witness %Result.loc143_9.1, @Destroy [symbolic = %Destroy.lookup_impl_witness (constants.%Destroy.lookup_impl_witness.d86)] +// CHECK:STDOUT: %impl.elem0.loc148_5.2: @MulWith.loc146.%.loc148_5.5 (%.d5f) = impl_witness_access %Destroy.lookup_impl_witness, element0 [symbolic = %impl.elem0.loc148_5.2 (constants.%impl.elem0.a6b)] +// CHECK:STDOUT: %specific_impl_fn.loc148_5.4: = specific_impl_function %impl.elem0.loc148_5.2, @Destroy.WithSelf.Op(%Result.loc143_9.1) [symbolic = %specific_impl_fn.loc148_5.4 (constants.%specific_impl_fn.761)] +// CHECK:STDOUT: +// CHECK:STDOUT: fn(%result.param: @MulWith.loc146.%Result.as_type.loc145_54.1 (%Result.as_type), %x.param: @MulWith.loc146.%T.as_type.loc146_29.1 (%T.as_type.68f), %y.param: @MulWith.loc146.%U.as_type.loc145_36.1 (%U.as_type.2b8)) { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %x.ref: @MulWith.loc146.%T.as_type.loc146_29.1 (%T.as_type.68f) = name_ref x, %x +// CHECK:STDOUT: %y.ref: @MulWith.loc146.%U.as_type.loc145_36.1 (%U.as_type.2b8) = name_ref y, %y +// CHECK:STDOUT: %MulWith.type.loc148: type = facet_type <@MulWith.1, @MulWith.1(constants.%U.as_type.2b8)> [symbolic = %MulWith.type.loc145_36.1 (constants.%MulWith.type.9532)] +// CHECK:STDOUT: %.loc148_5.1: @MulWith.loc146.%MulWith.assoc_type (%MulWith.assoc_type.97c) = specific_constant imports.%Core.import_ref.a1b, @MulWith.WithSelf(constants.%U.as_type.2b8, constants.%Self.9c4) [symbolic = %assoc1 (constants.%assoc1.496)] +// CHECK:STDOUT: %Op.ref: @MulWith.loc146.%MulWith.assoc_type (%MulWith.assoc_type.97c) = name_ref Op, %.loc148_5.1 [symbolic = %assoc1 (constants.%assoc1.496)] +// CHECK:STDOUT: %impl.elem1.loc148_5.1: @MulWith.loc146.%.loc148_5.4 (%.978) = impl_witness_access constants.%MulWith.lookup_impl_witness.009, element1 [symbolic = %impl.elem1.loc148_5.2 (constants.%impl.elem1.80d)] +// CHECK:STDOUT: %bound_method.loc148_5.1: = bound_method %x.ref, %impl.elem1.loc148_5.1 +// CHECK:STDOUT: %specific_impl_fn.loc148_5.1: = specific_impl_function %impl.elem1.loc148_5.1, @MulWith.WithSelf.Op(constants.%U.as_type.2b8, constants.%MulWith.facet.2d0) [symbolic = %specific_impl_fn.loc148_5.3 (constants.%specific_impl_fn.889)] +// CHECK:STDOUT: %bound_method.loc148_5.2: = bound_method %x.ref, %specific_impl_fn.loc148_5.1 +// CHECK:STDOUT: %.loc148_5.2: ref @MulWith.loc146.%Result.as_type.loc145_54.1 (%Result.as_type) = temporary_storage +// CHECK:STDOUT: %MulWith.WithSelf.Op.call: init @MulWith.loc146.%Result.as_type.loc145_54.1 (%Result.as_type) to %.loc148_5.2 = call %bound_method.loc148_5.2(%x.ref, %y.ref) +// CHECK:STDOUT: %.loc148_5.3: ref @MulWith.loc146.%Result.as_type.loc145_54.1 (%Result.as_type) = temporary %.loc148_5.2, %MulWith.WithSelf.Op.call +// CHECK:STDOUT: %impl.elem0.loc148_5.1: @MulWith.loc146.%.loc148_5.5 (%.d5f) = impl_witness_access constants.%Destroy.lookup_impl_witness.d86, element0 [symbolic = %impl.elem0.loc148_5.2 (constants.%impl.elem0.a6b)] +// CHECK:STDOUT: %bound_method.loc148_5.3: = bound_method %.loc148_5.3, %impl.elem0.loc148_5.1 +// CHECK:STDOUT: %specific_impl_fn.loc148_5.2: = specific_impl_function %impl.elem0.loc148_5.1, @Destroy.WithSelf.Op(constants.%Result) [symbolic = %specific_impl_fn.loc148_5.4 (constants.%specific_impl_fn.761)] +// CHECK:STDOUT: %bound_method.loc148_5.4: = bound_method %.loc148_5.3, %specific_impl_fn.loc148_5.2 +// CHECK:STDOUT: %Destroy.WithSelf.Op.call: init %empty_tuple.type = call %bound_method.loc148_5.4(%.loc148_5.3) +// CHECK:STDOUT: +// CHECK:STDOUT: } +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: generic fn @DivWith.loc157(%Result.loc154_9.2: %Destroy.type, %U.loc155_4.2: %Destroy.type, %T.loc156_4.2: @DivWith.loc157.%facet_type.loc156_38 (%facet_type.6e6)) { +// CHECK:STDOUT: +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: +// CHECK:STDOUT: %require_complete.loc159: = require_complete_type %DivWith.type.loc156_36.1 [symbolic = %require_complete.loc159 (constants.%require_complete.9a1)] +// CHECK:STDOUT: %assoc1: @DivWith.loc157.%DivWith.assoc_type (%DivWith.assoc_type.06d) = assoc_entity element1, imports.%Core.import_ref.bb2c [symbolic = %assoc1 (constants.%assoc1.49b)] +// CHECK:STDOUT: %DivWith.lookup_impl_witness.loc159: = lookup_impl_witness %T.loc156_4.1, @DivWith.1, @DivWith.1(%U.as_type.loc156_36.1) [symbolic = %DivWith.lookup_impl_witness.loc159 (constants.%DivWith.lookup_impl_witness.b69)] +// CHECK:STDOUT: %DivWith.facet: @DivWith.loc157.%DivWith.type.loc156_36.1 (%DivWith.type.0e2) = facet_value %T.as_type.loc157_29.1, (%DivWith.lookup_impl_witness.loc159) [symbolic = %DivWith.facet (constants.%DivWith.facet.490)] +// CHECK:STDOUT: %DivWith.WithSelf.Op.type: type = fn_type @DivWith.WithSelf.Op, @DivWith.WithSelf(%U.as_type.loc156_36.1, %DivWith.facet) [symbolic = %DivWith.WithSelf.Op.type (constants.%DivWith.WithSelf.Op.type.2ad)] +// CHECK:STDOUT: %.loc159_5.4: type = fn_type_with_self_type %DivWith.WithSelf.Op.type, %DivWith.facet [symbolic = %.loc159_5.4 (constants.%.0bf)] +// CHECK:STDOUT: %impl.elem1.loc159_5.2: @DivWith.loc157.%.loc159_5.4 (%.0bf) = impl_witness_access %DivWith.lookup_impl_witness.loc159, element1 [symbolic = %impl.elem1.loc159_5.2 (constants.%impl.elem1.b07)] +// CHECK:STDOUT: %specific_impl_fn.loc159_5.3: = specific_impl_function %impl.elem1.loc159_5.2, @DivWith.WithSelf.Op(%U.as_type.loc156_36.1, %DivWith.facet) [symbolic = %specific_impl_fn.loc159_5.3 (constants.%specific_impl_fn.dbd)] +// CHECK:STDOUT: %Destroy.WithSelf.Op.type: type = fn_type @Destroy.WithSelf.Op, @Destroy.WithSelf(%Result.loc154_9.1) [symbolic = %Destroy.WithSelf.Op.type (constants.%Destroy.WithSelf.Op.type.cb2e47.2)] +// CHECK:STDOUT: %.loc159_5.5: type = fn_type_with_self_type %Destroy.WithSelf.Op.type, %Result.loc154_9.1 [symbolic = %.loc159_5.5 (constants.%.d5f)] +// CHECK:STDOUT: %Destroy.lookup_impl_witness: = lookup_impl_witness %Result.loc154_9.1, @Destroy [symbolic = %Destroy.lookup_impl_witness (constants.%Destroy.lookup_impl_witness.d86)] +// CHECK:STDOUT: %impl.elem0.loc159_5.2: @DivWith.loc157.%.loc159_5.5 (%.d5f) = impl_witness_access %Destroy.lookup_impl_witness, element0 [symbolic = %impl.elem0.loc159_5.2 (constants.%impl.elem0.a6b)] +// CHECK:STDOUT: %specific_impl_fn.loc159_5.4: = specific_impl_function %impl.elem0.loc159_5.2, @Destroy.WithSelf.Op(%Result.loc154_9.1) [symbolic = %specific_impl_fn.loc159_5.4 (constants.%specific_impl_fn.761)] +// CHECK:STDOUT: +// CHECK:STDOUT: fn(%result.param: @DivWith.loc157.%Result.as_type.loc156_54.1 (%Result.as_type), %x.param: @DivWith.loc157.%T.as_type.loc157_29.1 (%T.as_type.cfe), %y.param: @DivWith.loc157.%U.as_type.loc156_36.1 (%U.as_type.2b8)) { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %x.ref: @DivWith.loc157.%T.as_type.loc157_29.1 (%T.as_type.cfe) = name_ref x, %x +// CHECK:STDOUT: %y.ref: @DivWith.loc157.%U.as_type.loc156_36.1 (%U.as_type.2b8) = name_ref y, %y +// CHECK:STDOUT: %DivWith.type.loc159: type = facet_type <@DivWith.1, @DivWith.1(constants.%U.as_type.2b8)> [symbolic = %DivWith.type.loc156_36.1 (constants.%DivWith.type.0e2)] +// CHECK:STDOUT: %.loc159_5.1: @DivWith.loc157.%DivWith.assoc_type (%DivWith.assoc_type.06d) = specific_constant imports.%Core.import_ref.beb, @DivWith.WithSelf(constants.%U.as_type.2b8, constants.%Self.d71) [symbolic = %assoc1 (constants.%assoc1.49b)] +// CHECK:STDOUT: %Op.ref: @DivWith.loc157.%DivWith.assoc_type (%DivWith.assoc_type.06d) = name_ref Op, %.loc159_5.1 [symbolic = %assoc1 (constants.%assoc1.49b)] +// CHECK:STDOUT: %impl.elem1.loc159_5.1: @DivWith.loc157.%.loc159_5.4 (%.0bf) = impl_witness_access constants.%DivWith.lookup_impl_witness.b69, element1 [symbolic = %impl.elem1.loc159_5.2 (constants.%impl.elem1.b07)] +// CHECK:STDOUT: %bound_method.loc159_5.1: = bound_method %x.ref, %impl.elem1.loc159_5.1 +// CHECK:STDOUT: %specific_impl_fn.loc159_5.1: = specific_impl_function %impl.elem1.loc159_5.1, @DivWith.WithSelf.Op(constants.%U.as_type.2b8, constants.%DivWith.facet.490) [symbolic = %specific_impl_fn.loc159_5.3 (constants.%specific_impl_fn.dbd)] +// CHECK:STDOUT: %bound_method.loc159_5.2: = bound_method %x.ref, %specific_impl_fn.loc159_5.1 +// CHECK:STDOUT: %.loc159_5.2: ref @DivWith.loc157.%Result.as_type.loc156_54.1 (%Result.as_type) = temporary_storage +// CHECK:STDOUT: %DivWith.WithSelf.Op.call: init @DivWith.loc157.%Result.as_type.loc156_54.1 (%Result.as_type) to %.loc159_5.2 = call %bound_method.loc159_5.2(%x.ref, %y.ref) +// CHECK:STDOUT: %.loc159_5.3: ref @DivWith.loc157.%Result.as_type.loc156_54.1 (%Result.as_type) = temporary %.loc159_5.2, %DivWith.WithSelf.Op.call +// CHECK:STDOUT: %impl.elem0.loc159_5.1: @DivWith.loc157.%.loc159_5.5 (%.d5f) = impl_witness_access constants.%Destroy.lookup_impl_witness.d86, element0 [symbolic = %impl.elem0.loc159_5.2 (constants.%impl.elem0.a6b)] +// CHECK:STDOUT: %bound_method.loc159_5.3: = bound_method %.loc159_5.3, %impl.elem0.loc159_5.1 +// CHECK:STDOUT: %specific_impl_fn.loc159_5.2: = specific_impl_function %impl.elem0.loc159_5.1, @Destroy.WithSelf.Op(constants.%Result) [symbolic = %specific_impl_fn.loc159_5.4 (constants.%specific_impl_fn.761)] +// CHECK:STDOUT: %bound_method.loc159_5.4: = bound_method %.loc159_5.3, %specific_impl_fn.loc159_5.2 +// CHECK:STDOUT: %Destroy.WithSelf.Op.call: init %empty_tuple.type = call %bound_method.loc159_5.4(%.loc159_5.3) +// CHECK:STDOUT: +// CHECK:STDOUT: } +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: generic fn @ModWith.loc168(%Result.loc165_9.2: %Destroy.type, %U.loc166_4.2: %Destroy.type, %T.loc167_4.2: @ModWith.loc168.%facet_type.loc167_38 (%facet_type.3a6)) { +// CHECK:STDOUT: +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: +// CHECK:STDOUT: %require_complete.loc170: = require_complete_type %ModWith.type.loc167_36.1 [symbolic = %require_complete.loc170 (constants.%require_complete.9b1)] +// CHECK:STDOUT: %assoc1: @ModWith.loc168.%ModWith.assoc_type (%ModWith.assoc_type.66e) = assoc_entity element1, imports.%Core.import_ref.c05 [symbolic = %assoc1 (constants.%assoc1.3da)] +// CHECK:STDOUT: %ModWith.lookup_impl_witness.loc170: = lookup_impl_witness %T.loc167_4.1, @ModWith.1, @ModWith.1(%U.as_type.loc167_36.1) [symbolic = %ModWith.lookup_impl_witness.loc170 (constants.%ModWith.lookup_impl_witness.e3f)] +// CHECK:STDOUT: %ModWith.facet: @ModWith.loc168.%ModWith.type.loc167_36.1 (%ModWith.type.c6f) = facet_value %T.as_type.loc168_29.1, (%ModWith.lookup_impl_witness.loc170) [symbolic = %ModWith.facet (constants.%ModWith.facet.430)] +// CHECK:STDOUT: %ModWith.WithSelf.Op.type: type = fn_type @ModWith.WithSelf.Op, @ModWith.WithSelf(%U.as_type.loc167_36.1, %ModWith.facet) [symbolic = %ModWith.WithSelf.Op.type (constants.%ModWith.WithSelf.Op.type.5b5)] +// CHECK:STDOUT: %.loc170_5.4: type = fn_type_with_self_type %ModWith.WithSelf.Op.type, %ModWith.facet [symbolic = %.loc170_5.4 (constants.%.feb)] +// CHECK:STDOUT: %impl.elem1.loc170_5.2: @ModWith.loc168.%.loc170_5.4 (%.feb) = impl_witness_access %ModWith.lookup_impl_witness.loc170, element1 [symbolic = %impl.elem1.loc170_5.2 (constants.%impl.elem1.1af)] +// CHECK:STDOUT: %specific_impl_fn.loc170_5.3: = specific_impl_function %impl.elem1.loc170_5.2, @ModWith.WithSelf.Op(%U.as_type.loc167_36.1, %ModWith.facet) [symbolic = %specific_impl_fn.loc170_5.3 (constants.%specific_impl_fn.772)] +// CHECK:STDOUT: %Destroy.WithSelf.Op.type: type = fn_type @Destroy.WithSelf.Op, @Destroy.WithSelf(%Result.loc165_9.1) [symbolic = %Destroy.WithSelf.Op.type (constants.%Destroy.WithSelf.Op.type.cb2e47.2)] +// CHECK:STDOUT: %.loc170_5.5: type = fn_type_with_self_type %Destroy.WithSelf.Op.type, %Result.loc165_9.1 [symbolic = %.loc170_5.5 (constants.%.d5f)] +// CHECK:STDOUT: %Destroy.lookup_impl_witness: = lookup_impl_witness %Result.loc165_9.1, @Destroy [symbolic = %Destroy.lookup_impl_witness (constants.%Destroy.lookup_impl_witness.d86)] +// CHECK:STDOUT: %impl.elem0.loc170_5.2: @ModWith.loc168.%.loc170_5.5 (%.d5f) = impl_witness_access %Destroy.lookup_impl_witness, element0 [symbolic = %impl.elem0.loc170_5.2 (constants.%impl.elem0.a6b)] +// CHECK:STDOUT: %specific_impl_fn.loc170_5.4: = specific_impl_function %impl.elem0.loc170_5.2, @Destroy.WithSelf.Op(%Result.loc165_9.1) [symbolic = %specific_impl_fn.loc170_5.4 (constants.%specific_impl_fn.761)] +// CHECK:STDOUT: +// CHECK:STDOUT: fn(%result.param: @ModWith.loc168.%Result.as_type.loc167_54.1 (%Result.as_type), %x.param: @ModWith.loc168.%T.as_type.loc168_29.1 (%T.as_type.10f), %y.param: @ModWith.loc168.%U.as_type.loc167_36.1 (%U.as_type.2b8)) { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %x.ref: @ModWith.loc168.%T.as_type.loc168_29.1 (%T.as_type.10f) = name_ref x, %x +// CHECK:STDOUT: %y.ref: @ModWith.loc168.%U.as_type.loc167_36.1 (%U.as_type.2b8) = name_ref y, %y +// CHECK:STDOUT: %ModWith.type.loc170: type = facet_type <@ModWith.1, @ModWith.1(constants.%U.as_type.2b8)> [symbolic = %ModWith.type.loc167_36.1 (constants.%ModWith.type.c6f)] +// CHECK:STDOUT: %.loc170_5.1: @ModWith.loc168.%ModWith.assoc_type (%ModWith.assoc_type.66e) = specific_constant imports.%Core.import_ref.fcf, @ModWith.WithSelf(constants.%U.as_type.2b8, constants.%Self.797) [symbolic = %assoc1 (constants.%assoc1.3da)] +// CHECK:STDOUT: %Op.ref: @ModWith.loc168.%ModWith.assoc_type (%ModWith.assoc_type.66e) = name_ref Op, %.loc170_5.1 [symbolic = %assoc1 (constants.%assoc1.3da)] +// CHECK:STDOUT: %impl.elem1.loc170_5.1: @ModWith.loc168.%.loc170_5.4 (%.feb) = impl_witness_access constants.%ModWith.lookup_impl_witness.e3f, element1 [symbolic = %impl.elem1.loc170_5.2 (constants.%impl.elem1.1af)] +// CHECK:STDOUT: %bound_method.loc170_5.1: = bound_method %x.ref, %impl.elem1.loc170_5.1 +// CHECK:STDOUT: %specific_impl_fn.loc170_5.1: = specific_impl_function %impl.elem1.loc170_5.1, @ModWith.WithSelf.Op(constants.%U.as_type.2b8, constants.%ModWith.facet.430) [symbolic = %specific_impl_fn.loc170_5.3 (constants.%specific_impl_fn.772)] +// CHECK:STDOUT: %bound_method.loc170_5.2: = bound_method %x.ref, %specific_impl_fn.loc170_5.1 +// CHECK:STDOUT: %.loc170_5.2: ref @ModWith.loc168.%Result.as_type.loc167_54.1 (%Result.as_type) = temporary_storage +// CHECK:STDOUT: %ModWith.WithSelf.Op.call: init @ModWith.loc168.%Result.as_type.loc167_54.1 (%Result.as_type) to %.loc170_5.2 = call %bound_method.loc170_5.2(%x.ref, %y.ref) +// CHECK:STDOUT: %.loc170_5.3: ref @ModWith.loc168.%Result.as_type.loc167_54.1 (%Result.as_type) = temporary %.loc170_5.2, %ModWith.WithSelf.Op.call +// CHECK:STDOUT: %impl.elem0.loc170_5.1: @ModWith.loc168.%.loc170_5.5 (%.d5f) = impl_witness_access constants.%Destroy.lookup_impl_witness.d86, element0 [symbolic = %impl.elem0.loc170_5.2 (constants.%impl.elem0.a6b)] +// CHECK:STDOUT: %bound_method.loc170_5.3: = bound_method %.loc170_5.3, %impl.elem0.loc170_5.1 +// CHECK:STDOUT: %specific_impl_fn.loc170_5.2: = specific_impl_function %impl.elem0.loc170_5.1, @Destroy.WithSelf.Op(constants.%Result) [symbolic = %specific_impl_fn.loc170_5.4 (constants.%specific_impl_fn.761)] +// CHECK:STDOUT: %bound_method.loc170_5.4: = bound_method %.loc170_5.3, %specific_impl_fn.loc170_5.2 +// CHECK:STDOUT: %Destroy.WithSelf.Op.call: init %empty_tuple.type = call %bound_method.loc170_5.4(%.loc170_5.3) +// CHECK:STDOUT: +// CHECK:STDOUT: } +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: generic fn @AddAssignWith.loc225(%U.loc225_19.2: type, %T.loc225_29.2: @AddAssignWith.loc225.%AddAssignWith.type.loc225_52.1 (%AddAssignWith.type.4d3b38.2)) { +// CHECK:STDOUT: +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: +// CHECK:STDOUT: %require_complete.loc227: = require_complete_type %AddAssignWith.type.loc225_52.1 [symbolic = %require_complete.loc227 (constants.%require_complete.cb0)] +// CHECK:STDOUT: %AddAssignWith.assoc_type: type = assoc_entity_type @AddAssignWith.1, @AddAssignWith.1(%U.loc225_19.1) [symbolic = %AddAssignWith.assoc_type (constants.%AddAssignWith.assoc_type.ca2a80.2)] +// CHECK:STDOUT: %assoc0: @AddAssignWith.loc225.%AddAssignWith.assoc_type (%AddAssignWith.assoc_type.ca2a80.2) = assoc_entity element0, imports.%Core.import_ref.7e1 [symbolic = %assoc0 (constants.%assoc0.f6c0ab.2)] +// CHECK:STDOUT: %AddAssignWith.WithSelf.Op.type: type = fn_type @AddAssignWith.WithSelf.Op, @AddAssignWith.WithSelf(%U.loc225_19.1, %T.loc225_29.1) [symbolic = %AddAssignWith.WithSelf.Op.type (constants.%AddAssignWith.WithSelf.Op.type.df0722.3)] +// CHECK:STDOUT: %.loc227_5.2: type = fn_type_with_self_type %AddAssignWith.WithSelf.Op.type, %T.loc225_29.1 [symbolic = %.loc227_5.2 (constants.%.8f6)] +// CHECK:STDOUT: %AddAssignWith.lookup_impl_witness: = lookup_impl_witness %T.loc225_29.1, @AddAssignWith.1, @AddAssignWith.1(%U.loc225_19.1) [symbolic = %AddAssignWith.lookup_impl_witness (constants.%AddAssignWith.lookup_impl_witness)] +// CHECK:STDOUT: %impl.elem0.loc227_5.2: @AddAssignWith.loc225.%.loc227_5.2 (%.8f6) = impl_witness_access %AddAssignWith.lookup_impl_witness, element0 [symbolic = %impl.elem0.loc227_5.2 (constants.%impl.elem0.c7b)] +// CHECK:STDOUT: %specific_impl_fn.loc227_5.2: = specific_impl_function %impl.elem0.loc227_5.2, @AddAssignWith.WithSelf.Op(%U.loc225_19.1, %T.loc225_29.1) [symbolic = %specific_impl_fn.loc227_5.2 (constants.%specific_impl_fn.fca)] +// CHECK:STDOUT: +// CHECK:STDOUT: fn(%x.param: ref @AddAssignWith.loc225.%T.as_type.loc225_62.1 (%T.as_type.191), %y.param: @AddAssignWith.loc225.%U.loc225_19.1 (%U.67d)) { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %x.ref: ref @AddAssignWith.loc225.%T.as_type.loc225_62.1 (%T.as_type.191) = name_ref x, %x +// CHECK:STDOUT: %y.ref: @AddAssignWith.loc225.%U.loc225_19.1 (%U.67d) = name_ref y, %y +// CHECK:STDOUT: %AddAssignWith.type.loc227: type = facet_type <@AddAssignWith.1, @AddAssignWith.1(constants.%U.67d)> [symbolic = %AddAssignWith.type.loc225_52.1 (constants.%AddAssignWith.type.4d3b38.2)] +// CHECK:STDOUT: %.loc227_5.1: @AddAssignWith.loc225.%AddAssignWith.assoc_type (%AddAssignWith.assoc_type.ca2a80.2) = specific_constant imports.%Core.import_ref.016, @AddAssignWith.WithSelf(constants.%U.67d, constants.%Self.a00362.1) [symbolic = %assoc0 (constants.%assoc0.f6c0ab.2)] +// CHECK:STDOUT: %Op.ref: @AddAssignWith.loc225.%AddAssignWith.assoc_type (%AddAssignWith.assoc_type.ca2a80.2) = name_ref Op, %.loc227_5.1 [symbolic = %assoc0 (constants.%assoc0.f6c0ab.2)] +// CHECK:STDOUT: %impl.elem0.loc227_5.1: @AddAssignWith.loc225.%.loc227_5.2 (%.8f6) = impl_witness_access constants.%AddAssignWith.lookup_impl_witness, element0 [symbolic = %impl.elem0.loc227_5.2 (constants.%impl.elem0.c7b)] +// CHECK:STDOUT: %bound_method.loc227_5.1: = bound_method %x.ref, %impl.elem0.loc227_5.1 +// CHECK:STDOUT: %specific_impl_fn.loc227_5.1: = specific_impl_function %impl.elem0.loc227_5.1, @AddAssignWith.WithSelf.Op(constants.%U.67d, constants.%T.a00) [symbolic = %specific_impl_fn.loc227_5.2 (constants.%specific_impl_fn.fca)] +// CHECK:STDOUT: %bound_method.loc227_5.2: = bound_method %x.ref, %specific_impl_fn.loc227_5.1 +// CHECK:STDOUT: %AddAssignWith.WithSelf.Op.call: init %empty_tuple.type = call %bound_method.loc227_5.2(%x.ref, %y.ref) +// CHECK:STDOUT: +// CHECK:STDOUT: } +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: generic fn @SubAssignWith.loc231(%U.loc231_19.2: type, %T.loc231_29.2: @SubAssignWith.loc231.%SubAssignWith.type.loc231_52.1 (%SubAssignWith.type.969cbb.2)) { +// CHECK:STDOUT: +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: +// CHECK:STDOUT: %require_complete.loc233: = require_complete_type %SubAssignWith.type.loc231_52.1 [symbolic = %require_complete.loc233 (constants.%require_complete.22d3)] +// CHECK:STDOUT: %SubAssignWith.assoc_type: type = assoc_entity_type @SubAssignWith.1, @SubAssignWith.1(%U.loc231_19.1) [symbolic = %SubAssignWith.assoc_type (constants.%SubAssignWith.assoc_type.4cb9a1.2)] +// CHECK:STDOUT: %assoc0: @SubAssignWith.loc231.%SubAssignWith.assoc_type (%SubAssignWith.assoc_type.4cb9a1.2) = assoc_entity element0, imports.%Core.import_ref.5b4 [symbolic = %assoc0 (constants.%assoc0.6115cc.2)] +// CHECK:STDOUT: %SubAssignWith.WithSelf.Op.type: type = fn_type @SubAssignWith.WithSelf.Op, @SubAssignWith.WithSelf(%U.loc231_19.1, %T.loc231_29.1) [symbolic = %SubAssignWith.WithSelf.Op.type (constants.%SubAssignWith.WithSelf.Op.type.317c02.3)] +// CHECK:STDOUT: %.loc233_5.2: type = fn_type_with_self_type %SubAssignWith.WithSelf.Op.type, %T.loc231_29.1 [symbolic = %.loc233_5.2 (constants.%.307)] +// CHECK:STDOUT: %SubAssignWith.lookup_impl_witness: = lookup_impl_witness %T.loc231_29.1, @SubAssignWith.1, @SubAssignWith.1(%U.loc231_19.1) [symbolic = %SubAssignWith.lookup_impl_witness (constants.%SubAssignWith.lookup_impl_witness)] +// CHECK:STDOUT: %impl.elem0.loc233_5.2: @SubAssignWith.loc231.%.loc233_5.2 (%.307) = impl_witness_access %SubAssignWith.lookup_impl_witness, element0 [symbolic = %impl.elem0.loc233_5.2 (constants.%impl.elem0.e10)] +// CHECK:STDOUT: %specific_impl_fn.loc233_5.2: = specific_impl_function %impl.elem0.loc233_5.2, @SubAssignWith.WithSelf.Op(%U.loc231_19.1, %T.loc231_29.1) [symbolic = %specific_impl_fn.loc233_5.2 (constants.%specific_impl_fn.c8d)] +// CHECK:STDOUT: +// CHECK:STDOUT: fn(%x.param: ref @SubAssignWith.loc231.%T.as_type.loc231_62.1 (%T.as_type.b8f), %y.param: @SubAssignWith.loc231.%U.loc231_19.1 (%U.67d)) { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %x.ref: ref @SubAssignWith.loc231.%T.as_type.loc231_62.1 (%T.as_type.b8f) = name_ref x, %x +// CHECK:STDOUT: %y.ref: @SubAssignWith.loc231.%U.loc231_19.1 (%U.67d) = name_ref y, %y +// CHECK:STDOUT: %SubAssignWith.type.loc233: type = facet_type <@SubAssignWith.1, @SubAssignWith.1(constants.%U.67d)> [symbolic = %SubAssignWith.type.loc231_52.1 (constants.%SubAssignWith.type.969cbb.2)] +// CHECK:STDOUT: %.loc233_5.1: @SubAssignWith.loc231.%SubAssignWith.assoc_type (%SubAssignWith.assoc_type.4cb9a1.2) = specific_constant imports.%Core.import_ref.405, @SubAssignWith.WithSelf(constants.%U.67d, constants.%Self.1de093.1) [symbolic = %assoc0 (constants.%assoc0.6115cc.2)] +// CHECK:STDOUT: %Op.ref: @SubAssignWith.loc231.%SubAssignWith.assoc_type (%SubAssignWith.assoc_type.4cb9a1.2) = name_ref Op, %.loc233_5.1 [symbolic = %assoc0 (constants.%assoc0.6115cc.2)] +// CHECK:STDOUT: %impl.elem0.loc233_5.1: @SubAssignWith.loc231.%.loc233_5.2 (%.307) = impl_witness_access constants.%SubAssignWith.lookup_impl_witness, element0 [symbolic = %impl.elem0.loc233_5.2 (constants.%impl.elem0.e10)] +// CHECK:STDOUT: %bound_method.loc233_5.1: = bound_method %x.ref, %impl.elem0.loc233_5.1 +// CHECK:STDOUT: %specific_impl_fn.loc233_5.1: = specific_impl_function %impl.elem0.loc233_5.1, @SubAssignWith.WithSelf.Op(constants.%U.67d, constants.%T.1de) [symbolic = %specific_impl_fn.loc233_5.2 (constants.%specific_impl_fn.c8d)] +// CHECK:STDOUT: %bound_method.loc233_5.2: = bound_method %x.ref, %specific_impl_fn.loc233_5.1 +// CHECK:STDOUT: %SubAssignWith.WithSelf.Op.call: init %empty_tuple.type = call %bound_method.loc233_5.2(%x.ref, %y.ref) +// CHECK:STDOUT: +// CHECK:STDOUT: } +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: generic fn @MulAssignWith.loc237(%U.loc237_19.2: type, %T.loc237_29.2: @MulAssignWith.loc237.%MulAssignWith.type.loc237_52.1 (%MulAssignWith.type.ccc9e0.2)) { +// CHECK:STDOUT: +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: +// CHECK:STDOUT: %require_complete.loc239: = require_complete_type %MulAssignWith.type.loc237_52.1 [symbolic = %require_complete.loc239 (constants.%require_complete.6dc)] +// CHECK:STDOUT: %MulAssignWith.assoc_type: type = assoc_entity_type @MulAssignWith.1, @MulAssignWith.1(%U.loc237_19.1) [symbolic = %MulAssignWith.assoc_type (constants.%MulAssignWith.assoc_type.595561.2)] +// CHECK:STDOUT: %assoc0: @MulAssignWith.loc237.%MulAssignWith.assoc_type (%MulAssignWith.assoc_type.595561.2) = assoc_entity element0, imports.%Core.import_ref.69b [symbolic = %assoc0 (constants.%assoc0.71e6fb.2)] +// CHECK:STDOUT: %MulAssignWith.WithSelf.Op.type: type = fn_type @MulAssignWith.WithSelf.Op, @MulAssignWith.WithSelf(%U.loc237_19.1, %T.loc237_29.1) [symbolic = %MulAssignWith.WithSelf.Op.type (constants.%MulAssignWith.WithSelf.Op.type.31cf70.3)] +// CHECK:STDOUT: %.loc239_5.2: type = fn_type_with_self_type %MulAssignWith.WithSelf.Op.type, %T.loc237_29.1 [symbolic = %.loc239_5.2 (constants.%.1b8)] +// CHECK:STDOUT: %MulAssignWith.lookup_impl_witness: = lookup_impl_witness %T.loc237_29.1, @MulAssignWith.1, @MulAssignWith.1(%U.loc237_19.1) [symbolic = %MulAssignWith.lookup_impl_witness (constants.%MulAssignWith.lookup_impl_witness)] +// CHECK:STDOUT: %impl.elem0.loc239_5.2: @MulAssignWith.loc237.%.loc239_5.2 (%.1b8) = impl_witness_access %MulAssignWith.lookup_impl_witness, element0 [symbolic = %impl.elem0.loc239_5.2 (constants.%impl.elem0.cd0)] +// CHECK:STDOUT: %specific_impl_fn.loc239_5.2: = specific_impl_function %impl.elem0.loc239_5.2, @MulAssignWith.WithSelf.Op(%U.loc237_19.1, %T.loc237_29.1) [symbolic = %specific_impl_fn.loc239_5.2 (constants.%specific_impl_fn.397)] +// CHECK:STDOUT: +// CHECK:STDOUT: fn(%x.param: ref @MulAssignWith.loc237.%T.as_type.loc237_62.1 (%T.as_type.6a0), %y.param: @MulAssignWith.loc237.%U.loc237_19.1 (%U.67d)) { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %x.ref: ref @MulAssignWith.loc237.%T.as_type.loc237_62.1 (%T.as_type.6a0) = name_ref x, %x +// CHECK:STDOUT: %y.ref: @MulAssignWith.loc237.%U.loc237_19.1 (%U.67d) = name_ref y, %y +// CHECK:STDOUT: %MulAssignWith.type.loc239: type = facet_type <@MulAssignWith.1, @MulAssignWith.1(constants.%U.67d)> [symbolic = %MulAssignWith.type.loc237_52.1 (constants.%MulAssignWith.type.ccc9e0.2)] +// CHECK:STDOUT: %.loc239_5.1: @MulAssignWith.loc237.%MulAssignWith.assoc_type (%MulAssignWith.assoc_type.595561.2) = specific_constant imports.%Core.import_ref.257, @MulAssignWith.WithSelf(constants.%U.67d, constants.%Self.059e93.1) [symbolic = %assoc0 (constants.%assoc0.71e6fb.2)] +// CHECK:STDOUT: %Op.ref: @MulAssignWith.loc237.%MulAssignWith.assoc_type (%MulAssignWith.assoc_type.595561.2) = name_ref Op, %.loc239_5.1 [symbolic = %assoc0 (constants.%assoc0.71e6fb.2)] +// CHECK:STDOUT: %impl.elem0.loc239_5.1: @MulAssignWith.loc237.%.loc239_5.2 (%.1b8) = impl_witness_access constants.%MulAssignWith.lookup_impl_witness, element0 [symbolic = %impl.elem0.loc239_5.2 (constants.%impl.elem0.cd0)] +// CHECK:STDOUT: %bound_method.loc239_5.1: = bound_method %x.ref, %impl.elem0.loc239_5.1 +// CHECK:STDOUT: %specific_impl_fn.loc239_5.1: = specific_impl_function %impl.elem0.loc239_5.1, @MulAssignWith.WithSelf.Op(constants.%U.67d, constants.%T.059) [symbolic = %specific_impl_fn.loc239_5.2 (constants.%specific_impl_fn.397)] +// CHECK:STDOUT: %bound_method.loc239_5.2: = bound_method %x.ref, %specific_impl_fn.loc239_5.1 +// CHECK:STDOUT: %MulAssignWith.WithSelf.Op.call: init %empty_tuple.type = call %bound_method.loc239_5.2(%x.ref, %y.ref) +// CHECK:STDOUT: +// CHECK:STDOUT: } +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: generic fn @DivAssignWith.loc243(%U.loc243_19.2: type, %T.loc243_29.2: @DivAssignWith.loc243.%DivAssignWith.type.loc243_52.1 (%DivAssignWith.type.be08dd.2)) { +// CHECK:STDOUT: +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: +// CHECK:STDOUT: %require_complete.loc245: = require_complete_type %DivAssignWith.type.loc243_52.1 [symbolic = %require_complete.loc245 (constants.%require_complete.542)] +// CHECK:STDOUT: %DivAssignWith.assoc_type: type = assoc_entity_type @DivAssignWith.1, @DivAssignWith.1(%U.loc243_19.1) [symbolic = %DivAssignWith.assoc_type (constants.%DivAssignWith.assoc_type.8b4b5b.2)] +// CHECK:STDOUT: %assoc0: @DivAssignWith.loc243.%DivAssignWith.assoc_type (%DivAssignWith.assoc_type.8b4b5b.2) = assoc_entity element0, imports.%Core.import_ref.799 [symbolic = %assoc0 (constants.%assoc0.399004.2)] +// CHECK:STDOUT: %DivAssignWith.WithSelf.Op.type: type = fn_type @DivAssignWith.WithSelf.Op, @DivAssignWith.WithSelf(%U.loc243_19.1, %T.loc243_29.1) [symbolic = %DivAssignWith.WithSelf.Op.type (constants.%DivAssignWith.WithSelf.Op.type.ded5d7.3)] +// CHECK:STDOUT: %.loc245_5.2: type = fn_type_with_self_type %DivAssignWith.WithSelf.Op.type, %T.loc243_29.1 [symbolic = %.loc245_5.2 (constants.%.607)] +// CHECK:STDOUT: %DivAssignWith.lookup_impl_witness: = lookup_impl_witness %T.loc243_29.1, @DivAssignWith.1, @DivAssignWith.1(%U.loc243_19.1) [symbolic = %DivAssignWith.lookup_impl_witness (constants.%DivAssignWith.lookup_impl_witness)] +// CHECK:STDOUT: %impl.elem0.loc245_5.2: @DivAssignWith.loc243.%.loc245_5.2 (%.607) = impl_witness_access %DivAssignWith.lookup_impl_witness, element0 [symbolic = %impl.elem0.loc245_5.2 (constants.%impl.elem0.46f)] +// CHECK:STDOUT: %specific_impl_fn.loc245_5.2: = specific_impl_function %impl.elem0.loc245_5.2, @DivAssignWith.WithSelf.Op(%U.loc243_19.1, %T.loc243_29.1) [symbolic = %specific_impl_fn.loc245_5.2 (constants.%specific_impl_fn.666)] +// CHECK:STDOUT: +// CHECK:STDOUT: fn(%x.param: ref @DivAssignWith.loc243.%T.as_type.loc243_62.1 (%T.as_type.efd), %y.param: @DivAssignWith.loc243.%U.loc243_19.1 (%U.67d)) { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %x.ref: ref @DivAssignWith.loc243.%T.as_type.loc243_62.1 (%T.as_type.efd) = name_ref x, %x +// CHECK:STDOUT: %y.ref: @DivAssignWith.loc243.%U.loc243_19.1 (%U.67d) = name_ref y, %y +// CHECK:STDOUT: %DivAssignWith.type.loc245: type = facet_type <@DivAssignWith.1, @DivAssignWith.1(constants.%U.67d)> [symbolic = %DivAssignWith.type.loc243_52.1 (constants.%DivAssignWith.type.be08dd.2)] +// CHECK:STDOUT: %.loc245_5.1: @DivAssignWith.loc243.%DivAssignWith.assoc_type (%DivAssignWith.assoc_type.8b4b5b.2) = specific_constant imports.%Core.import_ref.b1f, @DivAssignWith.WithSelf(constants.%U.67d, constants.%Self.aa8835.1) [symbolic = %assoc0 (constants.%assoc0.399004.2)] +// CHECK:STDOUT: %Op.ref: @DivAssignWith.loc243.%DivAssignWith.assoc_type (%DivAssignWith.assoc_type.8b4b5b.2) = name_ref Op, %.loc245_5.1 [symbolic = %assoc0 (constants.%assoc0.399004.2)] +// CHECK:STDOUT: %impl.elem0.loc245_5.1: @DivAssignWith.loc243.%.loc245_5.2 (%.607) = impl_witness_access constants.%DivAssignWith.lookup_impl_witness, element0 [symbolic = %impl.elem0.loc245_5.2 (constants.%impl.elem0.46f)] +// CHECK:STDOUT: %bound_method.loc245_5.1: = bound_method %x.ref, %impl.elem0.loc245_5.1 +// CHECK:STDOUT: %specific_impl_fn.loc245_5.1: = specific_impl_function %impl.elem0.loc245_5.1, @DivAssignWith.WithSelf.Op(constants.%U.67d, constants.%T.aa8) [symbolic = %specific_impl_fn.loc245_5.2 (constants.%specific_impl_fn.666)] +// CHECK:STDOUT: %bound_method.loc245_5.2: = bound_method %x.ref, %specific_impl_fn.loc245_5.1 +// CHECK:STDOUT: %DivAssignWith.WithSelf.Op.call: init %empty_tuple.type = call %bound_method.loc245_5.2(%x.ref, %y.ref) +// CHECK:STDOUT: +// CHECK:STDOUT: } +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: generic fn @ModAssignWith.loc249(%U.loc249_19.2: type, %T.loc249_29.2: @ModAssignWith.loc249.%ModAssignWith.type.loc249_52.1 (%ModAssignWith.type.c65b77.2)) { +// CHECK:STDOUT: +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: +// CHECK:STDOUT: %require_complete.loc251: = require_complete_type %ModAssignWith.type.loc249_52.1 [symbolic = %require_complete.loc251 (constants.%require_complete.8bf)] +// CHECK:STDOUT: %ModAssignWith.assoc_type: type = assoc_entity_type @ModAssignWith.1, @ModAssignWith.1(%U.loc249_19.1) [symbolic = %ModAssignWith.assoc_type (constants.%ModAssignWith.assoc_type.1462b9.2)] +// CHECK:STDOUT: %assoc0: @ModAssignWith.loc249.%ModAssignWith.assoc_type (%ModAssignWith.assoc_type.1462b9.2) = assoc_entity element0, imports.%Core.import_ref.51c [symbolic = %assoc0 (constants.%assoc0.378445.2)] +// CHECK:STDOUT: %ModAssignWith.WithSelf.Op.type: type = fn_type @ModAssignWith.WithSelf.Op, @ModAssignWith.WithSelf(%U.loc249_19.1, %T.loc249_29.1) [symbolic = %ModAssignWith.WithSelf.Op.type (constants.%ModAssignWith.WithSelf.Op.type.5452e9.3)] +// CHECK:STDOUT: %.loc251_5.2: type = fn_type_with_self_type %ModAssignWith.WithSelf.Op.type, %T.loc249_29.1 [symbolic = %.loc251_5.2 (constants.%.dfa)] +// CHECK:STDOUT: %ModAssignWith.lookup_impl_witness: = lookup_impl_witness %T.loc249_29.1, @ModAssignWith.1, @ModAssignWith.1(%U.loc249_19.1) [symbolic = %ModAssignWith.lookup_impl_witness (constants.%ModAssignWith.lookup_impl_witness)] +// CHECK:STDOUT: %impl.elem0.loc251_5.2: @ModAssignWith.loc249.%.loc251_5.2 (%.dfa) = impl_witness_access %ModAssignWith.lookup_impl_witness, element0 [symbolic = %impl.elem0.loc251_5.2 (constants.%impl.elem0.18c)] +// CHECK:STDOUT: %specific_impl_fn.loc251_5.2: = specific_impl_function %impl.elem0.loc251_5.2, @ModAssignWith.WithSelf.Op(%U.loc249_19.1, %T.loc249_29.1) [symbolic = %specific_impl_fn.loc251_5.2 (constants.%specific_impl_fn.28f)] +// CHECK:STDOUT: +// CHECK:STDOUT: fn(%x.param: ref @ModAssignWith.loc249.%T.as_type.loc249_62.1 (%T.as_type.4c2), %y.param: @ModAssignWith.loc249.%U.loc249_19.1 (%U.67d)) { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %x.ref: ref @ModAssignWith.loc249.%T.as_type.loc249_62.1 (%T.as_type.4c2) = name_ref x, %x +// CHECK:STDOUT: %y.ref: @ModAssignWith.loc249.%U.loc249_19.1 (%U.67d) = name_ref y, %y +// CHECK:STDOUT: %ModAssignWith.type.loc251: type = facet_type <@ModAssignWith.1, @ModAssignWith.1(constants.%U.67d)> [symbolic = %ModAssignWith.type.loc249_52.1 (constants.%ModAssignWith.type.c65b77.2)] +// CHECK:STDOUT: %.loc251_5.1: @ModAssignWith.loc249.%ModAssignWith.assoc_type (%ModAssignWith.assoc_type.1462b9.2) = specific_constant imports.%Core.import_ref.b81, @ModAssignWith.WithSelf(constants.%U.67d, constants.%Self.d35c46.1) [symbolic = %assoc0 (constants.%assoc0.378445.2)] +// CHECK:STDOUT: %Op.ref: @ModAssignWith.loc249.%ModAssignWith.assoc_type (%ModAssignWith.assoc_type.1462b9.2) = name_ref Op, %.loc251_5.1 [symbolic = %assoc0 (constants.%assoc0.378445.2)] +// CHECK:STDOUT: %impl.elem0.loc251_5.1: @ModAssignWith.loc249.%.loc251_5.2 (%.dfa) = impl_witness_access constants.%ModAssignWith.lookup_impl_witness, element0 [symbolic = %impl.elem0.loc251_5.2 (constants.%impl.elem0.18c)] +// CHECK:STDOUT: %bound_method.loc251_5.1: = bound_method %x.ref, %impl.elem0.loc251_5.1 +// CHECK:STDOUT: %specific_impl_fn.loc251_5.1: = specific_impl_function %impl.elem0.loc251_5.1, @ModAssignWith.WithSelf.Op(constants.%U.67d, constants.%T.d35) [symbolic = %specific_impl_fn.loc251_5.2 (constants.%specific_impl_fn.28f)] +// CHECK:STDOUT: %bound_method.loc251_5.2: = bound_method %x.ref, %specific_impl_fn.loc251_5.1 +// CHECK:STDOUT: %ModAssignWith.WithSelf.Op.call: init %empty_tuple.type = call %bound_method.loc251_5.2(%x.ref, %y.ref) +// CHECK:STDOUT: +// CHECK:STDOUT: } +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: generic fn @TestInc(%T.loc278_13.2: %Inc.type) { +// CHECK:STDOUT: +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: +// CHECK:STDOUT: %Inc.WithSelf.Op.type: type = fn_type @Inc.WithSelf.Op, @Inc.WithSelf(%T.loc278_13.1) [symbolic = %Inc.WithSelf.Op.type (constants.%Inc.WithSelf.Op.type.623399.2)] +// CHECK:STDOUT: %.loc280: type = fn_type_with_self_type %Inc.WithSelf.Op.type, %T.loc278_13.1 [symbolic = %.loc280 (constants.%.ad4)] +// CHECK:STDOUT: %Inc.lookup_impl_witness: = lookup_impl_witness %T.loc278_13.1, @Inc [symbolic = %Inc.lookup_impl_witness (constants.%Inc.lookup_impl_witness)] +// CHECK:STDOUT: %impl.elem0.loc280_3.2: @TestInc.%.loc280 (%.ad4) = impl_witness_access %Inc.lookup_impl_witness, element0 [symbolic = %impl.elem0.loc280_3.2 (constants.%impl.elem0.489)] +// CHECK:STDOUT: %specific_impl_fn.loc280_3.2: = specific_impl_function %impl.elem0.loc280_3.2, @Inc.WithSelf.Op(%T.loc278_13.1) [symbolic = %specific_impl_fn.loc280_3.2 (constants.%specific_impl_fn.71c)] +// CHECK:STDOUT: +// CHECK:STDOUT: fn(%x.param: ref @TestInc.%T.as_type.loc278_33.1 (%T.as_type.3f5)) { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %x.ref: ref @TestInc.%T.as_type.loc278_33.1 (%T.as_type.3f5) = name_ref x, %x +// CHECK:STDOUT: %impl.elem0.loc280_3.1: @TestInc.%.loc280 (%.ad4) = impl_witness_access constants.%Inc.lookup_impl_witness, element0 [symbolic = %impl.elem0.loc280_3.2 (constants.%impl.elem0.489)] +// CHECK:STDOUT: %bound_method.loc280_3.1: = bound_method %x.ref, %impl.elem0.loc280_3.1 +// CHECK:STDOUT: %specific_impl_fn.loc280_3.1: = specific_impl_function %impl.elem0.loc280_3.1, @Inc.WithSelf.Op(constants.%T.b7e) [symbolic = %specific_impl_fn.loc280_3.2 (constants.%specific_impl_fn.71c)] +// CHECK:STDOUT: %bound_method.loc280_3.2: = bound_method %x.ref, %specific_impl_fn.loc280_3.1 +// CHECK:STDOUT: %Inc.WithSelf.Op.call: init %empty_tuple.type = call %bound_method.loc280_3.2(%x.ref) +// CHECK:STDOUT: +// CHECK:STDOUT: } +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: generic fn @TestDec(%T.loc284_13.2: %Dec.type) { +// CHECK:STDOUT: +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: +// CHECK:STDOUT: %Dec.WithSelf.Op.type: type = fn_type @Dec.WithSelf.Op, @Dec.WithSelf(%T.loc284_13.1) [symbolic = %Dec.WithSelf.Op.type (constants.%Dec.WithSelf.Op.type.41adba.2)] +// CHECK:STDOUT: %.loc286: type = fn_type_with_self_type %Dec.WithSelf.Op.type, %T.loc284_13.1 [symbolic = %.loc286 (constants.%.41c)] +// CHECK:STDOUT: %Dec.lookup_impl_witness: = lookup_impl_witness %T.loc284_13.1, @Dec [symbolic = %Dec.lookup_impl_witness (constants.%Dec.lookup_impl_witness)] +// CHECK:STDOUT: %impl.elem0.loc286_3.2: @TestDec.%.loc286 (%.41c) = impl_witness_access %Dec.lookup_impl_witness, element0 [symbolic = %impl.elem0.loc286_3.2 (constants.%impl.elem0.64b)] +// CHECK:STDOUT: %specific_impl_fn.loc286_3.2: = specific_impl_function %impl.elem0.loc286_3.2, @Dec.WithSelf.Op(%T.loc284_13.1) [symbolic = %specific_impl_fn.loc286_3.2 (constants.%specific_impl_fn.91c)] +// CHECK:STDOUT: +// CHECK:STDOUT: fn(%x.param: ref @TestDec.%T.as_type.loc284_33.1 (%T.as_type.ead)) { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %x.ref: ref @TestDec.%T.as_type.loc284_33.1 (%T.as_type.ead) = name_ref x, %x +// CHECK:STDOUT: %impl.elem0.loc286_3.1: @TestDec.%.loc286 (%.41c) = impl_witness_access constants.%Dec.lookup_impl_witness, element0 [symbolic = %impl.elem0.loc286_3.2 (constants.%impl.elem0.64b)] +// CHECK:STDOUT: %bound_method.loc286_3.1: = bound_method %x.ref, %impl.elem0.loc286_3.1 +// CHECK:STDOUT: %specific_impl_fn.loc286_3.1: = specific_impl_function %impl.elem0.loc286_3.1, @Dec.WithSelf.Op(constants.%T.ce1) [symbolic = %specific_impl_fn.loc286_3.2 (constants.%specific_impl_fn.91c)] +// CHECK:STDOUT: %bound_method.loc286_3.2: = bound_method %x.ref, %specific_impl_fn.loc286_3.1 +// CHECK:STDOUT: %Dec.WithSelf.Op.call: init %empty_tuple.type = call %bound_method.loc286_3.2(%x.ref) +// CHECK:STDOUT: +// CHECK:STDOUT: } +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: generic fn @TestNegate(%Result.loc292_9.2: %Destroy.type, %T.loc293_4.2: @TestNegate.%facet_type (%facet_type.0fc)) { +// CHECK:STDOUT: +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: +// CHECK:STDOUT: %Negate.lookup_impl_witness: = lookup_impl_witness %T.loc293_4.1, @Negate [symbolic = %Negate.lookup_impl_witness (constants.%Negate.lookup_impl_witness.783)] +// CHECK:STDOUT: %Negate.facet: %Negate.type = facet_value %T.as_type.loc294_24.1, (%Negate.lookup_impl_witness) [symbolic = %Negate.facet (constants.%Negate.facet.758)] +// CHECK:STDOUT: %Negate.WithSelf.Op.type: type = fn_type @Negate.WithSelf.Op, @Negate.WithSelf(%Negate.facet) [symbolic = %Negate.WithSelf.Op.type (constants.%Negate.WithSelf.Op.type.899)] +// CHECK:STDOUT: %.loc296_3.3: type = fn_type_with_self_type %Negate.WithSelf.Op.type, %Negate.facet [symbolic = %.loc296_3.3 (constants.%.0d7)] +// CHECK:STDOUT: %impl.elem1.loc296_3.2: @TestNegate.%.loc296_3.3 (%.0d7) = impl_witness_access %Negate.lookup_impl_witness, element1 [symbolic = %impl.elem1.loc296_3.2 (constants.%impl.elem1.ec8)] +// CHECK:STDOUT: %specific_impl_fn.loc296_3.3: = specific_impl_function %impl.elem1.loc296_3.2, @Negate.WithSelf.Op(%Negate.facet) [symbolic = %specific_impl_fn.loc296_3.3 (constants.%specific_impl_fn.f22)] +// CHECK:STDOUT: %Destroy.WithSelf.Op.type: type = fn_type @Destroy.WithSelf.Op, @Destroy.WithSelf(%Result.loc292_9.1) [symbolic = %Destroy.WithSelf.Op.type (constants.%Destroy.WithSelf.Op.type.cb2e47.2)] +// CHECK:STDOUT: %.loc296_3.4: type = fn_type_with_self_type %Destroy.WithSelf.Op.type, %Result.loc292_9.1 [symbolic = %.loc296_3.4 (constants.%.d5f)] +// CHECK:STDOUT: %Destroy.lookup_impl_witness: = lookup_impl_witness %Result.loc292_9.1, @Destroy [symbolic = %Destroy.lookup_impl_witness (constants.%Destroy.lookup_impl_witness.d86)] +// CHECK:STDOUT: %impl.elem0.loc296_3.2: @TestNegate.%.loc296_3.4 (%.d5f) = impl_witness_access %Destroy.lookup_impl_witness, element0 [symbolic = %impl.elem0.loc296_3.2 (constants.%impl.elem0.a6b)] +// CHECK:STDOUT: %specific_impl_fn.loc296_3.4: = specific_impl_function %impl.elem0.loc296_3.2, @Destroy.WithSelf.Op(%Result.loc292_9.1) [symbolic = %specific_impl_fn.loc296_3.4 (constants.%specific_impl_fn.761)] +// CHECK:STDOUT: +// CHECK:STDOUT: fn(%y.param: @TestNegate.%Result.as_type.loc293_50.1 (%Result.as_type), %x.param: @TestNegate.%T.as_type.loc294_24.1 (%T.as_type.c82)) { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %x.ref: @TestNegate.%T.as_type.loc294_24.1 (%T.as_type.c82) = name_ref x, %x +// CHECK:STDOUT: %impl.elem1.loc296_3.1: @TestNegate.%.loc296_3.3 (%.0d7) = impl_witness_access constants.%Negate.lookup_impl_witness.783, element1 [symbolic = %impl.elem1.loc296_3.2 (constants.%impl.elem1.ec8)] +// CHECK:STDOUT: %bound_method.loc296_3.1: = bound_method %x.ref, %impl.elem1.loc296_3.1 +// CHECK:STDOUT: %specific_impl_fn.loc296_3.1: = specific_impl_function %impl.elem1.loc296_3.1, @Negate.WithSelf.Op(constants.%Negate.facet.758) [symbolic = %specific_impl_fn.loc296_3.3 (constants.%specific_impl_fn.f22)] +// CHECK:STDOUT: %bound_method.loc296_3.2: = bound_method %x.ref, %specific_impl_fn.loc296_3.1 +// CHECK:STDOUT: %.loc296_3.1: ref @TestNegate.%Result.as_type.loc293_50.1 (%Result.as_type) = temporary_storage +// CHECK:STDOUT: %Negate.WithSelf.Op.call: init @TestNegate.%Result.as_type.loc293_50.1 (%Result.as_type) to %.loc296_3.1 = call %bound_method.loc296_3.2(%x.ref) +// CHECK:STDOUT: %.loc296_3.2: ref @TestNegate.%Result.as_type.loc293_50.1 (%Result.as_type) = temporary %.loc296_3.1, %Negate.WithSelf.Op.call +// CHECK:STDOUT: %impl.elem0.loc296_3.1: @TestNegate.%.loc296_3.4 (%.d5f) = impl_witness_access constants.%Destroy.lookup_impl_witness.d86, element0 [symbolic = %impl.elem0.loc296_3.2 (constants.%impl.elem0.a6b)] +// CHECK:STDOUT: %bound_method.loc296_3.3: = bound_method %.loc296_3.2, %impl.elem0.loc296_3.1 +// CHECK:STDOUT: %specific_impl_fn.loc296_3.2: = specific_impl_function %impl.elem0.loc296_3.1, @Destroy.WithSelf.Op(constants.%Result) [symbolic = %specific_impl_fn.loc296_3.4 (constants.%specific_impl_fn.761)] +// CHECK:STDOUT: %bound_method.loc296_3.4: = bound_method %.loc296_3.2, %specific_impl_fn.loc296_3.2 +// CHECK:STDOUT: %Destroy.WithSelf.Op.call: init %empty_tuple.type = call %bound_method.loc296_3.4(%.loc296_3.2) +// CHECK:STDOUT: +// CHECK:STDOUT: } +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @AddWith.loc124(constants.%Result, constants.%U.0bd, constants.%T.25f) { +// CHECK:STDOUT: %Result.loc121_9.1 => constants.%Result +// CHECK:STDOUT: %U.loc122_4.1 => constants.%U.0bd +// CHECK:STDOUT: %U.as_type.loc123_36.1 => constants.%U.as_type.2b8 +// CHECK:STDOUT: %AddWith.type.loc123_36.1 => constants.%AddWith.type.07d +// CHECK:STDOUT: %facet_type.loc123_20 => constants.%facet_type.74d +// CHECK:STDOUT: %.Self.1 => constants.%.Self.5c0 +// CHECK:STDOUT: %require_complete.loc123 => constants.%require_complete.311 +// CHECK:STDOUT: %.Self.as_type.loc123_44.1 => constants.%.Self.as_type.f21 +// CHECK:STDOUT: %AddWith.assoc_type => constants.%AddWith.assoc_type.8c2 +// CHECK:STDOUT: %assoc0 => constants.%assoc0.7d3 +// CHECK:STDOUT: %AddWith.lookup_impl_witness.loc123 => constants.%AddWith.lookup_impl_witness.5a0 +// CHECK:STDOUT: %impl.elem0.loc123_44.1 => constants.%impl.elem0.08a +// CHECK:STDOUT: %Result.as_type.loc123_54.1 => constants.%Result.as_type +// CHECK:STDOUT: %facet_type.loc123_38 => constants.%facet_type.024 +// CHECK:STDOUT: %T.loc123_4.1 => constants.%T.25f +// CHECK:STDOUT: %pattern_type.loc123 => constants.%pattern_type.077a +// CHECK:STDOUT: %pattern_type.loc124_16 => constants.%pattern_type.eca0e4.2 +// CHECK:STDOUT: %T.as_type.loc124_29.1 => constants.%T.as_type.ab9 +// CHECK:STDOUT: %pattern_type.loc124_27 => constants.%pattern_type.7bb +// CHECK:STDOUT: %pattern_type.loc124_33 => constants.%pattern_type.711 +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @SubWith.loc135(constants.%Result, constants.%U.0bd, constants.%T.970) { +// CHECK:STDOUT: %Result.loc132_9.1 => constants.%Result +// CHECK:STDOUT: %U.loc133_4.1 => constants.%U.0bd +// CHECK:STDOUT: %U.as_type.loc134_36.1 => constants.%U.as_type.2b8 +// CHECK:STDOUT: %SubWith.type.loc134_36.1 => constants.%SubWith.type.593 +// CHECK:STDOUT: %facet_type.loc134_20 => constants.%facet_type.db3 +// CHECK:STDOUT: %.Self.1 => constants.%.Self.db3 +// CHECK:STDOUT: %require_complete.loc134 => constants.%require_complete.b71 +// CHECK:STDOUT: %.Self.as_type.loc134_44.1 => constants.%.Self.as_type.2a6 +// CHECK:STDOUT: %SubWith.assoc_type => constants.%SubWith.assoc_type.065 +// CHECK:STDOUT: %assoc0 => constants.%assoc0.55d +// CHECK:STDOUT: %SubWith.lookup_impl_witness.loc134 => constants.%SubWith.lookup_impl_witness.98d +// CHECK:STDOUT: %impl.elem0.loc134_44.1 => constants.%impl.elem0.bbb +// CHECK:STDOUT: %Result.as_type.loc134_54.1 => constants.%Result.as_type +// CHECK:STDOUT: %facet_type.loc134_38 => constants.%facet_type.bea +// CHECK:STDOUT: %T.loc134_4.1 => constants.%T.970 +// CHECK:STDOUT: %pattern_type.loc134 => constants.%pattern_type.265 +// CHECK:STDOUT: %pattern_type.loc135_16 => constants.%pattern_type.eca0e4.2 +// CHECK:STDOUT: %T.as_type.loc135_29.1 => constants.%T.as_type.474 +// CHECK:STDOUT: %pattern_type.loc135_27 => constants.%pattern_type.b6a +// CHECK:STDOUT: %pattern_type.loc135_33 => constants.%pattern_type.711 +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @MulWith.loc146(constants.%Result, constants.%U.0bd, constants.%T.438) { +// CHECK:STDOUT: %Result.loc143_9.1 => constants.%Result +// CHECK:STDOUT: %U.loc144_4.1 => constants.%U.0bd +// CHECK:STDOUT: %U.as_type.loc145_36.1 => constants.%U.as_type.2b8 +// CHECK:STDOUT: %MulWith.type.loc145_36.1 => constants.%MulWith.type.9532 +// CHECK:STDOUT: %facet_type.loc145_20 => constants.%facet_type.17c +// CHECK:STDOUT: %.Self.1 => constants.%.Self.afa +// CHECK:STDOUT: %require_complete.loc145 => constants.%require_complete.665 +// CHECK:STDOUT: %.Self.as_type.loc145_44.1 => constants.%.Self.as_type.9cb +// CHECK:STDOUT: %MulWith.assoc_type => constants.%MulWith.assoc_type.97c +// CHECK:STDOUT: %assoc0 => constants.%assoc0.1354 +// CHECK:STDOUT: %MulWith.lookup_impl_witness.loc145 => constants.%MulWith.lookup_impl_witness.05e +// CHECK:STDOUT: %impl.elem0.loc145_44.1 => constants.%impl.elem0.972 +// CHECK:STDOUT: %Result.as_type.loc145_54.1 => constants.%Result.as_type +// CHECK:STDOUT: %facet_type.loc145_38 => constants.%facet_type.91e +// CHECK:STDOUT: %T.loc145_4.1 => constants.%T.438 +// CHECK:STDOUT: %pattern_type.loc145 => constants.%pattern_type.b93 +// CHECK:STDOUT: %pattern_type.loc146_16 => constants.%pattern_type.eca0e4.2 +// CHECK:STDOUT: %T.as_type.loc146_29.1 => constants.%T.as_type.68f +// CHECK:STDOUT: %pattern_type.loc146_27 => constants.%pattern_type.b74 +// CHECK:STDOUT: %pattern_type.loc146_33 => constants.%pattern_type.711 +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @DivWith.loc157(constants.%Result, constants.%U.0bd, constants.%T.30e) { +// CHECK:STDOUT: %Result.loc154_9.1 => constants.%Result +// CHECK:STDOUT: %U.loc155_4.1 => constants.%U.0bd +// CHECK:STDOUT: %U.as_type.loc156_36.1 => constants.%U.as_type.2b8 +// CHECK:STDOUT: %DivWith.type.loc156_36.1 => constants.%DivWith.type.0e2 +// CHECK:STDOUT: %facet_type.loc156_20 => constants.%facet_type.94d +// CHECK:STDOUT: %.Self.1 => constants.%.Self.5a5 +// CHECK:STDOUT: %require_complete.loc156 => constants.%require_complete.3a4 +// CHECK:STDOUT: %.Self.as_type.loc156_44.1 => constants.%.Self.as_type.dad +// CHECK:STDOUT: %DivWith.assoc_type => constants.%DivWith.assoc_type.06d +// CHECK:STDOUT: %assoc0 => constants.%assoc0.1db +// CHECK:STDOUT: %DivWith.lookup_impl_witness.loc156 => constants.%DivWith.lookup_impl_witness.fbf +// CHECK:STDOUT: %impl.elem0.loc156_44.1 => constants.%impl.elem0.409 +// CHECK:STDOUT: %Result.as_type.loc156_54.1 => constants.%Result.as_type +// CHECK:STDOUT: %facet_type.loc156_38 => constants.%facet_type.6e6 +// CHECK:STDOUT: %T.loc156_4.1 => constants.%T.30e +// CHECK:STDOUT: %pattern_type.loc156 => constants.%pattern_type.4ef +// CHECK:STDOUT: %pattern_type.loc157_16 => constants.%pattern_type.eca0e4.2 +// CHECK:STDOUT: %T.as_type.loc157_29.1 => constants.%T.as_type.cfe +// CHECK:STDOUT: %pattern_type.loc157_27 => constants.%pattern_type.daa +// CHECK:STDOUT: %pattern_type.loc157_33 => constants.%pattern_type.711 +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @ModWith.loc168(constants.%Result, constants.%U.0bd, constants.%T.a77) { +// CHECK:STDOUT: %Result.loc165_9.1 => constants.%Result +// CHECK:STDOUT: %U.loc166_4.1 => constants.%U.0bd +// CHECK:STDOUT: %U.as_type.loc167_36.1 => constants.%U.as_type.2b8 +// CHECK:STDOUT: %ModWith.type.loc167_36.1 => constants.%ModWith.type.c6f +// CHECK:STDOUT: %facet_type.loc167_20 => constants.%facet_type.428 +// CHECK:STDOUT: %.Self.1 => constants.%.Self.2d4 +// CHECK:STDOUT: %require_complete.loc167 => constants.%require_complete.9441 +// CHECK:STDOUT: %.Self.as_type.loc167_44.1 => constants.%.Self.as_type.12a6 +// CHECK:STDOUT: %ModWith.assoc_type => constants.%ModWith.assoc_type.66e +// CHECK:STDOUT: %assoc0 => constants.%assoc0.fd6 +// CHECK:STDOUT: %ModWith.lookup_impl_witness.loc167 => constants.%ModWith.lookup_impl_witness.afa +// CHECK:STDOUT: %impl.elem0.loc167_44.1 => constants.%impl.elem0.44b +// CHECK:STDOUT: %Result.as_type.loc167_54.1 => constants.%Result.as_type +// CHECK:STDOUT: %facet_type.loc167_38 => constants.%facet_type.3a6 +// CHECK:STDOUT: %T.loc167_4.1 => constants.%T.a77 +// CHECK:STDOUT: %pattern_type.loc167 => constants.%pattern_type.50d +// CHECK:STDOUT: %pattern_type.loc168_16 => constants.%pattern_type.eca0e4.2 +// CHECK:STDOUT: %T.as_type.loc168_29.1 => constants.%T.as_type.10f +// CHECK:STDOUT: %pattern_type.loc168_27 => constants.%pattern_type.8db +// CHECK:STDOUT: %pattern_type.loc168_33 => constants.%pattern_type.711 +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @AddWith.loc124(constants.%Destroy.facet.e06, constants.%Destroy.facet.e06, constants.%facet_value.c79) { +// CHECK:STDOUT: %Result.loc121_9.1 => constants.%Destroy.facet.e06 +// CHECK:STDOUT: %U.loc122_4.1 => constants.%Destroy.facet.e06 +// CHECK:STDOUT: %U.as_type.loc123_36.1 => constants.%Int16 +// CHECK:STDOUT: %AddWith.type.loc123_36.1 => constants.%AddWith.type.344 +// CHECK:STDOUT: %facet_type.loc123_20 => constants.%facet_type.a81 +// CHECK:STDOUT: %.Self.1 => constants.%.Self.0ae +// CHECK:STDOUT: %require_complete.loc123 => constants.%complete_type.f61 +// CHECK:STDOUT: %.Self.as_type.loc123_44.1 => constants.%.Self.as_type.12a0 +// CHECK:STDOUT: %AddWith.assoc_type => constants.%AddWith.assoc_type.f75 +// CHECK:STDOUT: %assoc0 => constants.%assoc0.dc9 +// CHECK:STDOUT: %AddWith.lookup_impl_witness.loc123 => constants.%AddWith.lookup_impl_witness.db4 +// CHECK:STDOUT: %impl.elem0.loc123_44.1 => constants.%impl.elem0.cdb +// CHECK:STDOUT: %Result.as_type.loc123_54.1 => constants.%Int16 +// CHECK:STDOUT: %facet_type.loc123_38 => constants.%facet_type.e97 +// CHECK:STDOUT: %T.loc123_4.1 => constants.%facet_value.c79 +// CHECK:STDOUT: %pattern_type.loc123 => constants.%pattern_type.690 +// CHECK:STDOUT: %pattern_type.loc124_16 => constants.%pattern_type.9a4 +// CHECK:STDOUT: %T.as_type.loc124_29.1 => constants.%i16 +// CHECK:STDOUT: %pattern_type.loc124_27 => constants.%pattern_type.2f8 +// CHECK:STDOUT: %pattern_type.loc124_33 => constants.%pattern_type.9a4 +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc124_16 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc124_27 => constants.%complete_type.2da +// CHECK:STDOUT: %require_complete.loc124_33 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc126 => constants.%complete_type.f1c +// CHECK:STDOUT: %assoc1 => constants.%assoc1.646 +// CHECK:STDOUT: %AddWith.lookup_impl_witness.loc126 => constants.%custom_witness.47f +// CHECK:STDOUT: %AddWith.facet => constants.%AddWith.facet.ffe +// CHECK:STDOUT: %AddWith.WithSelf.Op.type => constants.%AddWith.WithSelf.Op.type.894 +// CHECK:STDOUT: %.loc126_5.4 => constants.%.b10 +// CHECK:STDOUT: %impl.elem1.loc126_5.2 => constants.%Op.8fb557.1 +// CHECK:STDOUT: %specific_impl_fn.loc126_5.3 => constants.%Op.8fb557.1 +// CHECK:STDOUT: %Destroy.WithSelf.Op.type => constants.%Destroy.WithSelf.Op.type.833 +// CHECK:STDOUT: %.loc126_5.5 => constants.%.368 +// CHECK:STDOUT: %Destroy.lookup_impl_witness => constants.%custom_witness.e5b +// CHECK:STDOUT: %impl.elem0.loc126_5.2 => constants.%Int16.Op.c3e49c.1 +// CHECK:STDOUT: %specific_impl_fn.loc126_5.4 => constants.%Int16.Op.c3e49c.1 +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @SubWith.loc135(constants.%Destroy.facet.e06, constants.%Destroy.facet.e06, constants.%facet_value.501) { +// CHECK:STDOUT: %Result.loc132_9.1 => constants.%Destroy.facet.e06 +// CHECK:STDOUT: %U.loc133_4.1 => constants.%Destroy.facet.e06 +// CHECK:STDOUT: %U.as_type.loc134_36.1 => constants.%Int16 +// CHECK:STDOUT: %SubWith.type.loc134_36.1 => constants.%SubWith.type.306 +// CHECK:STDOUT: %facet_type.loc134_20 => constants.%facet_type.b37 +// CHECK:STDOUT: %.Self.1 => constants.%.Self.107 +// CHECK:STDOUT: %require_complete.loc134 => constants.%complete_type.5cf +// CHECK:STDOUT: %.Self.as_type.loc134_44.1 => constants.%.Self.as_type.e34 +// CHECK:STDOUT: %SubWith.assoc_type => constants.%SubWith.assoc_type.7a2 +// CHECK:STDOUT: %assoc0 => constants.%assoc0.f42 +// CHECK:STDOUT: %SubWith.lookup_impl_witness.loc134 => constants.%SubWith.lookup_impl_witness.a35 +// CHECK:STDOUT: %impl.elem0.loc134_44.1 => constants.%impl.elem0.345 +// CHECK:STDOUT: %Result.as_type.loc134_54.1 => constants.%Int16 +// CHECK:STDOUT: %facet_type.loc134_38 => constants.%facet_type.281 +// CHECK:STDOUT: %T.loc134_4.1 => constants.%facet_value.501 +// CHECK:STDOUT: %pattern_type.loc134 => constants.%pattern_type.926 +// CHECK:STDOUT: %pattern_type.loc135_16 => constants.%pattern_type.9a4 +// CHECK:STDOUT: %T.as_type.loc135_29.1 => constants.%i16 +// CHECK:STDOUT: %pattern_type.loc135_27 => constants.%pattern_type.2f8 +// CHECK:STDOUT: %pattern_type.loc135_33 => constants.%pattern_type.9a4 +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc135_16 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc135_27 => constants.%complete_type.2da +// CHECK:STDOUT: %require_complete.loc135_33 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc137 => constants.%complete_type.9b3 +// CHECK:STDOUT: %assoc1 => constants.%assoc1.2c3 +// CHECK:STDOUT: %SubWith.lookup_impl_witness.loc137 => constants.%custom_witness.a7b +// CHECK:STDOUT: %SubWith.facet => constants.%SubWith.facet.dd9 +// CHECK:STDOUT: %SubWith.WithSelf.Op.type => constants.%SubWith.WithSelf.Op.type.44d +// CHECK:STDOUT: %.loc137_5.4 => constants.%.acf +// CHECK:STDOUT: %impl.elem1.loc137_5.2 => constants.%Op.8fb557.2 +// CHECK:STDOUT: %specific_impl_fn.loc137_5.3 => constants.%Op.8fb557.2 +// CHECK:STDOUT: %Destroy.WithSelf.Op.type => constants.%Destroy.WithSelf.Op.type.833 +// CHECK:STDOUT: %.loc137_5.5 => constants.%.368 +// CHECK:STDOUT: %Destroy.lookup_impl_witness => constants.%custom_witness.e5b +// CHECK:STDOUT: %impl.elem0.loc137_5.2 => constants.%Int16.Op.c3e49c.1 +// CHECK:STDOUT: %specific_impl_fn.loc137_5.4 => constants.%Int16.Op.c3e49c.1 +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @MulWith.loc146(constants.%Destroy.facet.e06, constants.%Destroy.facet.e06, constants.%facet_value.86a) { +// CHECK:STDOUT: %Result.loc143_9.1 => constants.%Destroy.facet.e06 +// CHECK:STDOUT: %U.loc144_4.1 => constants.%Destroy.facet.e06 +// CHECK:STDOUT: %U.as_type.loc145_36.1 => constants.%Int16 +// CHECK:STDOUT: %MulWith.type.loc145_36.1 => constants.%MulWith.type.0cd +// CHECK:STDOUT: %facet_type.loc145_20 => constants.%facet_type.2dd +// CHECK:STDOUT: %.Self.1 => constants.%.Self.594 +// CHECK:STDOUT: %require_complete.loc145 => constants.%complete_type.b32 +// CHECK:STDOUT: %.Self.as_type.loc145_44.1 => constants.%.Self.as_type.674 +// CHECK:STDOUT: %MulWith.assoc_type => constants.%MulWith.assoc_type.f1b +// CHECK:STDOUT: %assoc0 => constants.%assoc0.3ee +// CHECK:STDOUT: %MulWith.lookup_impl_witness.loc145 => constants.%MulWith.lookup_impl_witness.834 +// CHECK:STDOUT: %impl.elem0.loc145_44.1 => constants.%impl.elem0.6fb +// CHECK:STDOUT: %Result.as_type.loc145_54.1 => constants.%Int16 +// CHECK:STDOUT: %facet_type.loc145_38 => constants.%facet_type.b7c +// CHECK:STDOUT: %T.loc145_4.1 => constants.%facet_value.86a +// CHECK:STDOUT: %pattern_type.loc145 => constants.%pattern_type.401 +// CHECK:STDOUT: %pattern_type.loc146_16 => constants.%pattern_type.9a4 +// CHECK:STDOUT: %T.as_type.loc146_29.1 => constants.%i16 +// CHECK:STDOUT: %pattern_type.loc146_27 => constants.%pattern_type.2f8 +// CHECK:STDOUT: %pattern_type.loc146_33 => constants.%pattern_type.9a4 +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc146_16 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc146_27 => constants.%complete_type.2da +// CHECK:STDOUT: %require_complete.loc146_33 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc148 => constants.%complete_type.4d2 +// CHECK:STDOUT: %assoc1 => constants.%assoc1.988 +// CHECK:STDOUT: %MulWith.lookup_impl_witness.loc148 => constants.%custom_witness.e40 +// CHECK:STDOUT: %MulWith.facet => constants.%MulWith.facet.2a7 +// CHECK:STDOUT: %MulWith.WithSelf.Op.type => constants.%MulWith.WithSelf.Op.type.504 +// CHECK:STDOUT: %.loc148_5.4 => constants.%.20d +// CHECK:STDOUT: %impl.elem1.loc148_5.2 => constants.%Op.8fb557.3 +// CHECK:STDOUT: %specific_impl_fn.loc148_5.3 => constants.%Op.8fb557.3 +// CHECK:STDOUT: %Destroy.WithSelf.Op.type => constants.%Destroy.WithSelf.Op.type.833 +// CHECK:STDOUT: %.loc148_5.5 => constants.%.368 +// CHECK:STDOUT: %Destroy.lookup_impl_witness => constants.%custom_witness.e5b +// CHECK:STDOUT: %impl.elem0.loc148_5.2 => constants.%Int16.Op.c3e49c.1 +// CHECK:STDOUT: %specific_impl_fn.loc148_5.4 => constants.%Int16.Op.c3e49c.1 +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @DivWith.loc157(constants.%Destroy.facet.e06, constants.%Destroy.facet.e06, constants.%facet_value.018) { +// CHECK:STDOUT: %Result.loc154_9.1 => constants.%Destroy.facet.e06 +// CHECK:STDOUT: %U.loc155_4.1 => constants.%Destroy.facet.e06 +// CHECK:STDOUT: %U.as_type.loc156_36.1 => constants.%Int16 +// CHECK:STDOUT: %DivWith.type.loc156_36.1 => constants.%DivWith.type.4c2 +// CHECK:STDOUT: %facet_type.loc156_20 => constants.%facet_type.e82 +// CHECK:STDOUT: %.Self.1 => constants.%.Self.c70 +// CHECK:STDOUT: %require_complete.loc156 => constants.%complete_type.8b32 +// CHECK:STDOUT: %.Self.as_type.loc156_44.1 => constants.%.Self.as_type.e0e +// CHECK:STDOUT: %DivWith.assoc_type => constants.%DivWith.assoc_type.9fa +// CHECK:STDOUT: %assoc0 => constants.%assoc0.cf5 +// CHECK:STDOUT: %DivWith.lookup_impl_witness.loc156 => constants.%DivWith.lookup_impl_witness.dbb +// CHECK:STDOUT: %impl.elem0.loc156_44.1 => constants.%impl.elem0.e43 +// CHECK:STDOUT: %Result.as_type.loc156_54.1 => constants.%Int16 +// CHECK:STDOUT: %facet_type.loc156_38 => constants.%facet_type.a08 +// CHECK:STDOUT: %T.loc156_4.1 => constants.%facet_value.018 +// CHECK:STDOUT: %pattern_type.loc156 => constants.%pattern_type.6c0 +// CHECK:STDOUT: %pattern_type.loc157_16 => constants.%pattern_type.9a4 +// CHECK:STDOUT: %T.as_type.loc157_29.1 => constants.%i16 +// CHECK:STDOUT: %pattern_type.loc157_27 => constants.%pattern_type.2f8 +// CHECK:STDOUT: %pattern_type.loc157_33 => constants.%pattern_type.9a4 +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc157_16 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc157_27 => constants.%complete_type.2da +// CHECK:STDOUT: %require_complete.loc157_33 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc159 => constants.%complete_type.e42 +// CHECK:STDOUT: %assoc1 => constants.%assoc1.cda +// CHECK:STDOUT: %DivWith.lookup_impl_witness.loc159 => constants.%custom_witness.fb3 +// CHECK:STDOUT: %DivWith.facet => constants.%DivWith.facet.c60 +// CHECK:STDOUT: %DivWith.WithSelf.Op.type => constants.%DivWith.WithSelf.Op.type.7eb +// CHECK:STDOUT: %.loc159_5.4 => constants.%.411 +// CHECK:STDOUT: %impl.elem1.loc159_5.2 => constants.%Op.8fb557.4 +// CHECK:STDOUT: %specific_impl_fn.loc159_5.3 => constants.%Op.8fb557.4 +// CHECK:STDOUT: %Destroy.WithSelf.Op.type => constants.%Destroy.WithSelf.Op.type.833 +// CHECK:STDOUT: %.loc159_5.5 => constants.%.368 +// CHECK:STDOUT: %Destroy.lookup_impl_witness => constants.%custom_witness.e5b +// CHECK:STDOUT: %impl.elem0.loc159_5.2 => constants.%Int16.Op.c3e49c.1 +// CHECK:STDOUT: %specific_impl_fn.loc159_5.4 => constants.%Int16.Op.c3e49c.1 +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @ModWith.loc168(constants.%Destroy.facet.e06, constants.%Destroy.facet.e06, constants.%facet_value.ee6) { +// CHECK:STDOUT: %Result.loc165_9.1 => constants.%Destroy.facet.e06 +// CHECK:STDOUT: %U.loc166_4.1 => constants.%Destroy.facet.e06 +// CHECK:STDOUT: %U.as_type.loc167_36.1 => constants.%Int16 +// CHECK:STDOUT: %ModWith.type.loc167_36.1 => constants.%ModWith.type.009 +// CHECK:STDOUT: %facet_type.loc167_20 => constants.%facet_type.e1e +// CHECK:STDOUT: %.Self.1 => constants.%.Self.76e +// CHECK:STDOUT: %require_complete.loc167 => constants.%complete_type.5b6 +// CHECK:STDOUT: %.Self.as_type.loc167_44.1 => constants.%.Self.as_type.242 +// CHECK:STDOUT: %ModWith.assoc_type => constants.%ModWith.assoc_type.355 +// CHECK:STDOUT: %assoc0 => constants.%assoc0.0f7 +// CHECK:STDOUT: %ModWith.lookup_impl_witness.loc167 => constants.%ModWith.lookup_impl_witness.c6b +// CHECK:STDOUT: %impl.elem0.loc167_44.1 => constants.%impl.elem0.cba +// CHECK:STDOUT: %Result.as_type.loc167_54.1 => constants.%Int16 +// CHECK:STDOUT: %facet_type.loc167_38 => constants.%facet_type.469 +// CHECK:STDOUT: %T.loc167_4.1 => constants.%facet_value.ee6 +// CHECK:STDOUT: %pattern_type.loc167 => constants.%pattern_type.13c +// CHECK:STDOUT: %pattern_type.loc168_16 => constants.%pattern_type.9a4 +// CHECK:STDOUT: %T.as_type.loc168_29.1 => constants.%i16 +// CHECK:STDOUT: %pattern_type.loc168_27 => constants.%pattern_type.2f8 +// CHECK:STDOUT: %pattern_type.loc168_33 => constants.%pattern_type.9a4 +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc168_16 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc168_27 => constants.%complete_type.2da +// CHECK:STDOUT: %require_complete.loc168_33 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc170 => constants.%complete_type.e9f +// CHECK:STDOUT: %assoc1 => constants.%assoc1.c82 +// CHECK:STDOUT: %ModWith.lookup_impl_witness.loc170 => constants.%custom_witness.69e +// CHECK:STDOUT: %ModWith.facet => constants.%ModWith.facet.0e3 +// CHECK:STDOUT: %ModWith.WithSelf.Op.type => constants.%ModWith.WithSelf.Op.type.a02 +// CHECK:STDOUT: %.loc170_5.4 => constants.%.a0e +// CHECK:STDOUT: %impl.elem1.loc170_5.2 => constants.%Op.8fb557.5 +// CHECK:STDOUT: %specific_impl_fn.loc170_5.3 => constants.%Op.8fb557.5 +// CHECK:STDOUT: %Destroy.WithSelf.Op.type => constants.%Destroy.WithSelf.Op.type.833 +// CHECK:STDOUT: %.loc170_5.5 => constants.%.368 +// CHECK:STDOUT: %Destroy.lookup_impl_witness => constants.%custom_witness.e5b +// CHECK:STDOUT: %impl.elem0.loc170_5.2 => constants.%Int16.Op.c3e49c.1 +// CHECK:STDOUT: %specific_impl_fn.loc170_5.4 => constants.%Int16.Op.c3e49c.1 +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @AddWith.loc124(constants.%Destroy.facet.e06, constants.%Destroy.facet.77e, constants.%facet_value.dd6) { +// CHECK:STDOUT: %Result.loc121_9.1 => constants.%Destroy.facet.e06 +// CHECK:STDOUT: %U.loc122_4.1 => constants.%Destroy.facet.77e +// CHECK:STDOUT: %U.as_type.loc123_36.1 => constants.%i16 +// CHECK:STDOUT: %AddWith.type.loc123_36.1 => constants.%AddWith.type.a18 +// CHECK:STDOUT: %facet_type.loc123_20 => constants.%facet_type.8b1 +// CHECK:STDOUT: %.Self.1 => constants.%.Self.ba7 +// CHECK:STDOUT: %require_complete.loc123 => constants.%complete_type.59d +// CHECK:STDOUT: %.Self.as_type.loc123_44.1 => constants.%.Self.as_type.f28 +// CHECK:STDOUT: %AddWith.assoc_type => constants.%AddWith.assoc_type.4f0 +// CHECK:STDOUT: %assoc0 => constants.%assoc0.ba6 +// CHECK:STDOUT: %AddWith.lookup_impl_witness.loc123 => constants.%AddWith.lookup_impl_witness.d8b +// CHECK:STDOUT: %impl.elem0.loc123_44.1 => constants.%impl.elem0.265 +// CHECK:STDOUT: %Result.as_type.loc123_54.1 => constants.%Int16 +// CHECK:STDOUT: %facet_type.loc123_38 => constants.%facet_type.731 +// CHECK:STDOUT: %T.loc123_4.1 => constants.%facet_value.dd6 +// CHECK:STDOUT: %pattern_type.loc123 => constants.%pattern_type.336 +// CHECK:STDOUT: %pattern_type.loc124_16 => constants.%pattern_type.9a4 +// CHECK:STDOUT: %T.as_type.loc124_29.1 => constants.%Int16 +// CHECK:STDOUT: %pattern_type.loc124_27 => constants.%pattern_type.9a4 +// CHECK:STDOUT: %pattern_type.loc124_33 => constants.%pattern_type.2f8 +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc124_16 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc124_27 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc124_33 => constants.%complete_type.2da +// CHECK:STDOUT: %require_complete.loc126 => constants.%complete_type.e1b +// CHECK:STDOUT: %assoc1 => constants.%assoc1.88d +// CHECK:STDOUT: %AddWith.lookup_impl_witness.loc126 => constants.%custom_witness.096 +// CHECK:STDOUT: %AddWith.facet => constants.%AddWith.facet.c96 +// CHECK:STDOUT: %AddWith.WithSelf.Op.type => constants.%AddWith.WithSelf.Op.type.b73 +// CHECK:STDOUT: %.loc126_5.4 => constants.%.f80 +// CHECK:STDOUT: %impl.elem1.loc126_5.2 => constants.%Int16.Op.c3e49c.3 +// CHECK:STDOUT: %specific_impl_fn.loc126_5.3 => constants.%Int16.Op.c3e49c.3 +// CHECK:STDOUT: %Destroy.WithSelf.Op.type => constants.%Destroy.WithSelf.Op.type.833 +// CHECK:STDOUT: %.loc126_5.5 => constants.%.368 +// CHECK:STDOUT: %Destroy.lookup_impl_witness => constants.%custom_witness.e5b +// CHECK:STDOUT: %impl.elem0.loc126_5.2 => constants.%Int16.Op.c3e49c.1 +// CHECK:STDOUT: %specific_impl_fn.loc126_5.4 => constants.%Int16.Op.c3e49c.1 +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @SubWith.loc135(constants.%Destroy.facet.e06, constants.%Destroy.facet.77e, constants.%facet_value.3f5) { +// CHECK:STDOUT: %Result.loc132_9.1 => constants.%Destroy.facet.e06 +// CHECK:STDOUT: %U.loc133_4.1 => constants.%Destroy.facet.77e +// CHECK:STDOUT: %U.as_type.loc134_36.1 => constants.%i16 +// CHECK:STDOUT: %SubWith.type.loc134_36.1 => constants.%SubWith.type.a1b +// CHECK:STDOUT: %facet_type.loc134_20 => constants.%facet_type.bd5 +// CHECK:STDOUT: %.Self.1 => constants.%.Self.d04 +// CHECK:STDOUT: %require_complete.loc134 => constants.%complete_type.d4c +// CHECK:STDOUT: %.Self.as_type.loc134_44.1 => constants.%.Self.as_type.d0c7 +// CHECK:STDOUT: %SubWith.assoc_type => constants.%SubWith.assoc_type.108 +// CHECK:STDOUT: %assoc0 => constants.%assoc0.053 +// CHECK:STDOUT: %SubWith.lookup_impl_witness.loc134 => constants.%SubWith.lookup_impl_witness.029 +// CHECK:STDOUT: %impl.elem0.loc134_44.1 => constants.%impl.elem0.e59 +// CHECK:STDOUT: %Result.as_type.loc134_54.1 => constants.%Int16 +// CHECK:STDOUT: %facet_type.loc134_38 => constants.%facet_type.257 +// CHECK:STDOUT: %T.loc134_4.1 => constants.%facet_value.3f5 +// CHECK:STDOUT: %pattern_type.loc134 => constants.%pattern_type.021 +// CHECK:STDOUT: %pattern_type.loc135_16 => constants.%pattern_type.9a4 +// CHECK:STDOUT: %T.as_type.loc135_29.1 => constants.%Int16 +// CHECK:STDOUT: %pattern_type.loc135_27 => constants.%pattern_type.9a4 +// CHECK:STDOUT: %pattern_type.loc135_33 => constants.%pattern_type.2f8 +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc135_16 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc135_27 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc135_33 => constants.%complete_type.2da +// CHECK:STDOUT: %require_complete.loc137 => constants.%complete_type.6de +// CHECK:STDOUT: %assoc1 => constants.%assoc1.ef4 +// CHECK:STDOUT: %SubWith.lookup_impl_witness.loc137 => constants.%custom_witness.ced +// CHECK:STDOUT: %SubWith.facet => constants.%SubWith.facet.3c2 +// CHECK:STDOUT: %SubWith.WithSelf.Op.type => constants.%SubWith.WithSelf.Op.type.9bf +// CHECK:STDOUT: %.loc137_5.4 => constants.%.90d +// CHECK:STDOUT: %impl.elem1.loc137_5.2 => constants.%Int16.Op.c3e49c.4 +// CHECK:STDOUT: %specific_impl_fn.loc137_5.3 => constants.%Int16.Op.c3e49c.4 +// CHECK:STDOUT: %Destroy.WithSelf.Op.type => constants.%Destroy.WithSelf.Op.type.833 +// CHECK:STDOUT: %.loc137_5.5 => constants.%.368 +// CHECK:STDOUT: %Destroy.lookup_impl_witness => constants.%custom_witness.e5b +// CHECK:STDOUT: %impl.elem0.loc137_5.2 => constants.%Int16.Op.c3e49c.1 +// CHECK:STDOUT: %specific_impl_fn.loc137_5.4 => constants.%Int16.Op.c3e49c.1 +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @MulWith.loc146(constants.%Destroy.facet.e06, constants.%Destroy.facet.77e, constants.%facet_value.4ca) { +// CHECK:STDOUT: %Result.loc143_9.1 => constants.%Destroy.facet.e06 +// CHECK:STDOUT: %U.loc144_4.1 => constants.%Destroy.facet.77e +// CHECK:STDOUT: %U.as_type.loc145_36.1 => constants.%i16 +// CHECK:STDOUT: %MulWith.type.loc145_36.1 => constants.%MulWith.type.ee9 +// CHECK:STDOUT: %facet_type.loc145_20 => constants.%facet_type.5ca +// CHECK:STDOUT: %.Self.1 => constants.%.Self.3cf +// CHECK:STDOUT: %require_complete.loc145 => constants.%complete_type.d8f +// CHECK:STDOUT: %.Self.as_type.loc145_44.1 => constants.%.Self.as_type.4dc +// CHECK:STDOUT: %MulWith.assoc_type => constants.%MulWith.assoc_type.aae +// CHECK:STDOUT: %assoc0 => constants.%assoc0.4d95 +// CHECK:STDOUT: %MulWith.lookup_impl_witness.loc145 => constants.%MulWith.lookup_impl_witness.aee +// CHECK:STDOUT: %impl.elem0.loc145_44.1 => constants.%impl.elem0.5d1 +// CHECK:STDOUT: %Result.as_type.loc145_54.1 => constants.%Int16 +// CHECK:STDOUT: %facet_type.loc145_38 => constants.%facet_type.865 +// CHECK:STDOUT: %T.loc145_4.1 => constants.%facet_value.4ca +// CHECK:STDOUT: %pattern_type.loc145 => constants.%pattern_type.038 +// CHECK:STDOUT: %pattern_type.loc146_16 => constants.%pattern_type.9a4 +// CHECK:STDOUT: %T.as_type.loc146_29.1 => constants.%Int16 +// CHECK:STDOUT: %pattern_type.loc146_27 => constants.%pattern_type.9a4 +// CHECK:STDOUT: %pattern_type.loc146_33 => constants.%pattern_type.2f8 +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc146_16 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc146_27 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc146_33 => constants.%complete_type.2da +// CHECK:STDOUT: %require_complete.loc148 => constants.%complete_type.8b34 +// CHECK:STDOUT: %assoc1 => constants.%assoc1.587 +// CHECK:STDOUT: %MulWith.lookup_impl_witness.loc148 => constants.%custom_witness.270 +// CHECK:STDOUT: %MulWith.facet => constants.%MulWith.facet.0a1 +// CHECK:STDOUT: %MulWith.WithSelf.Op.type => constants.%MulWith.WithSelf.Op.type.a45 +// CHECK:STDOUT: %.loc148_5.4 => constants.%.70d +// CHECK:STDOUT: %impl.elem1.loc148_5.2 => constants.%Int16.Op.c3e49c.5 +// CHECK:STDOUT: %specific_impl_fn.loc148_5.3 => constants.%Int16.Op.c3e49c.5 +// CHECK:STDOUT: %Destroy.WithSelf.Op.type => constants.%Destroy.WithSelf.Op.type.833 +// CHECK:STDOUT: %.loc148_5.5 => constants.%.368 +// CHECK:STDOUT: %Destroy.lookup_impl_witness => constants.%custom_witness.e5b +// CHECK:STDOUT: %impl.elem0.loc148_5.2 => constants.%Int16.Op.c3e49c.1 +// CHECK:STDOUT: %specific_impl_fn.loc148_5.4 => constants.%Int16.Op.c3e49c.1 +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @DivWith.loc157(constants.%Destroy.facet.e06, constants.%Destroy.facet.77e, constants.%facet_value.ff9) { +// CHECK:STDOUT: %Result.loc154_9.1 => constants.%Destroy.facet.e06 +// CHECK:STDOUT: %U.loc155_4.1 => constants.%Destroy.facet.77e +// CHECK:STDOUT: %U.as_type.loc156_36.1 => constants.%i16 +// CHECK:STDOUT: %DivWith.type.loc156_36.1 => constants.%DivWith.type.9ae +// CHECK:STDOUT: %facet_type.loc156_20 => constants.%facet_type.014 +// CHECK:STDOUT: %.Self.1 => constants.%.Self.197 +// CHECK:STDOUT: %require_complete.loc156 => constants.%complete_type.b92 +// CHECK:STDOUT: %.Self.as_type.loc156_44.1 => constants.%.Self.as_type.2e1 +// CHECK:STDOUT: %DivWith.assoc_type => constants.%DivWith.assoc_type.e80 +// CHECK:STDOUT: %assoc0 => constants.%assoc0.75e +// CHECK:STDOUT: %DivWith.lookup_impl_witness.loc156 => constants.%DivWith.lookup_impl_witness.834 +// CHECK:STDOUT: %impl.elem0.loc156_44.1 => constants.%impl.elem0.146 +// CHECK:STDOUT: %Result.as_type.loc156_54.1 => constants.%Int16 +// CHECK:STDOUT: %facet_type.loc156_38 => constants.%facet_type.c20 +// CHECK:STDOUT: %T.loc156_4.1 => constants.%facet_value.ff9 +// CHECK:STDOUT: %pattern_type.loc156 => constants.%pattern_type.8c5 +// CHECK:STDOUT: %pattern_type.loc157_16 => constants.%pattern_type.9a4 +// CHECK:STDOUT: %T.as_type.loc157_29.1 => constants.%Int16 +// CHECK:STDOUT: %pattern_type.loc157_27 => constants.%pattern_type.9a4 +// CHECK:STDOUT: %pattern_type.loc157_33 => constants.%pattern_type.2f8 +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc157_16 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc157_27 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc157_33 => constants.%complete_type.2da +// CHECK:STDOUT: %require_complete.loc159 => constants.%complete_type.fc5 +// CHECK:STDOUT: %assoc1 => constants.%assoc1.9ae +// CHECK:STDOUT: %DivWith.lookup_impl_witness.loc159 => constants.%custom_witness.462 +// CHECK:STDOUT: %DivWith.facet => constants.%DivWith.facet.915 +// CHECK:STDOUT: %DivWith.WithSelf.Op.type => constants.%DivWith.WithSelf.Op.type.e9d +// CHECK:STDOUT: %.loc159_5.4 => constants.%.d3f +// CHECK:STDOUT: %impl.elem1.loc159_5.2 => constants.%Int16.Op.c3e49c.6 +// CHECK:STDOUT: %specific_impl_fn.loc159_5.3 => constants.%Int16.Op.c3e49c.6 +// CHECK:STDOUT: %Destroy.WithSelf.Op.type => constants.%Destroy.WithSelf.Op.type.833 +// CHECK:STDOUT: %.loc159_5.5 => constants.%.368 +// CHECK:STDOUT: %Destroy.lookup_impl_witness => constants.%custom_witness.e5b +// CHECK:STDOUT: %impl.elem0.loc159_5.2 => constants.%Int16.Op.c3e49c.1 +// CHECK:STDOUT: %specific_impl_fn.loc159_5.4 => constants.%Int16.Op.c3e49c.1 +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @ModWith.loc168(constants.%Destroy.facet.e06, constants.%Destroy.facet.77e, constants.%facet_value.f56) { +// CHECK:STDOUT: %Result.loc165_9.1 => constants.%Destroy.facet.e06 +// CHECK:STDOUT: %U.loc166_4.1 => constants.%Destroy.facet.77e +// CHECK:STDOUT: %U.as_type.loc167_36.1 => constants.%i16 +// CHECK:STDOUT: %ModWith.type.loc167_36.1 => constants.%ModWith.type.406 +// CHECK:STDOUT: %facet_type.loc167_20 => constants.%facet_type.fe7 +// CHECK:STDOUT: %.Self.1 => constants.%.Self.7d0 +// CHECK:STDOUT: %require_complete.loc167 => constants.%complete_type.dfc +// CHECK:STDOUT: %.Self.as_type.loc167_44.1 => constants.%.Self.as_type.81b +// CHECK:STDOUT: %ModWith.assoc_type => constants.%ModWith.assoc_type.ffe +// CHECK:STDOUT: %assoc0 => constants.%assoc0.b49 +// CHECK:STDOUT: %ModWith.lookup_impl_witness.loc167 => constants.%ModWith.lookup_impl_witness.ff6 +// CHECK:STDOUT: %impl.elem0.loc167_44.1 => constants.%impl.elem0.f78 +// CHECK:STDOUT: %Result.as_type.loc167_54.1 => constants.%Int16 +// CHECK:STDOUT: %facet_type.loc167_38 => constants.%facet_type.a93 +// CHECK:STDOUT: %T.loc167_4.1 => constants.%facet_value.f56 +// CHECK:STDOUT: %pattern_type.loc167 => constants.%pattern_type.0e2 +// CHECK:STDOUT: %pattern_type.loc168_16 => constants.%pattern_type.9a4 +// CHECK:STDOUT: %T.as_type.loc168_29.1 => constants.%Int16 +// CHECK:STDOUT: %pattern_type.loc168_27 => constants.%pattern_type.9a4 +// CHECK:STDOUT: %pattern_type.loc168_33 => constants.%pattern_type.2f8 +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc168_16 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc168_27 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc168_33 => constants.%complete_type.2da +// CHECK:STDOUT: %require_complete.loc170 => constants.%complete_type.78b +// CHECK:STDOUT: %assoc1 => constants.%assoc1.d40 +// CHECK:STDOUT: %ModWith.lookup_impl_witness.loc170 => constants.%custom_witness.84d2 +// CHECK:STDOUT: %ModWith.facet => constants.%ModWith.facet.6ed +// CHECK:STDOUT: %ModWith.WithSelf.Op.type => constants.%ModWith.WithSelf.Op.type.a5a +// CHECK:STDOUT: %.loc170_5.4 => constants.%.a4e +// CHECK:STDOUT: %impl.elem1.loc170_5.2 => constants.%Int16.Op.c3e49c.7 +// CHECK:STDOUT: %specific_impl_fn.loc170_5.3 => constants.%Int16.Op.c3e49c.7 +// CHECK:STDOUT: %Destroy.WithSelf.Op.type => constants.%Destroy.WithSelf.Op.type.833 +// CHECK:STDOUT: %.loc170_5.5 => constants.%.368 +// CHECK:STDOUT: %Destroy.lookup_impl_witness => constants.%custom_witness.e5b +// CHECK:STDOUT: %impl.elem0.loc170_5.2 => constants.%Int16.Op.c3e49c.1 +// CHECK:STDOUT: %specific_impl_fn.loc170_5.4 => constants.%Int16.Op.c3e49c.1 +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @AddWith.loc124(constants.%Destroy.facet.c06, constants.%Destroy.facet.c06, constants.%facet_value.2b7) { +// CHECK:STDOUT: %Result.loc121_9.1 => constants.%Destroy.facet.c06 +// CHECK:STDOUT: %U.loc122_4.1 => constants.%Destroy.facet.c06 +// CHECK:STDOUT: %U.as_type.loc123_36.1 => constants.%Int32 +// CHECK:STDOUT: %AddWith.type.loc123_36.1 => constants.%AddWith.type.e9e +// CHECK:STDOUT: %facet_type.loc123_20 => constants.%facet_type.4a7 +// CHECK:STDOUT: %.Self.1 => constants.%.Self.3d9 +// CHECK:STDOUT: %require_complete.loc123 => constants.%complete_type.0d9 +// CHECK:STDOUT: %.Self.as_type.loc123_44.1 => constants.%.Self.as_type.7ba +// CHECK:STDOUT: %AddWith.assoc_type => constants.%AddWith.assoc_type.29a +// CHECK:STDOUT: %assoc0 => constants.%assoc0.701 +// CHECK:STDOUT: %AddWith.lookup_impl_witness.loc123 => constants.%AddWith.lookup_impl_witness.632 +// CHECK:STDOUT: %impl.elem0.loc123_44.1 => constants.%impl.elem0.cee +// CHECK:STDOUT: %Result.as_type.loc123_54.1 => constants.%Int32 +// CHECK:STDOUT: %facet_type.loc123_38 => constants.%facet_type.14d +// CHECK:STDOUT: %T.loc123_4.1 => constants.%facet_value.2b7 +// CHECK:STDOUT: %pattern_type.loc123 => constants.%pattern_type.3f9 +// CHECK:STDOUT: %pattern_type.loc124_16 => constants.%pattern_type.9c9 +// CHECK:STDOUT: %T.as_type.loc124_29.1 => constants.%Int16 +// CHECK:STDOUT: %pattern_type.loc124_27 => constants.%pattern_type.9a4 +// CHECK:STDOUT: %pattern_type.loc124_33 => constants.%pattern_type.9c9 +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc124_16 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc124_27 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc124_33 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc126 => constants.%complete_type.03d +// CHECK:STDOUT: %assoc1 => constants.%assoc1.38b +// CHECK:STDOUT: %AddWith.lookup_impl_witness.loc126 => constants.%custom_witness.200 +// CHECK:STDOUT: %AddWith.facet => constants.%AddWith.facet.abd +// CHECK:STDOUT: %AddWith.WithSelf.Op.type => constants.%AddWith.WithSelf.Op.type.708 +// CHECK:STDOUT: %.loc126_5.4 => constants.%.0ff +// CHECK:STDOUT: %impl.elem1.loc126_5.2 => constants.%Int16.Op.c3e49c.8 +// CHECK:STDOUT: %specific_impl_fn.loc126_5.3 => constants.%Int16.Op.c3e49c.8 +// CHECK:STDOUT: %Destroy.WithSelf.Op.type => constants.%Destroy.WithSelf.Op.type.2e1 +// CHECK:STDOUT: %.loc126_5.5 => constants.%.e6c +// CHECK:STDOUT: %Destroy.lookup_impl_witness => constants.%custom_witness.ce1 +// CHECK:STDOUT: %impl.elem0.loc126_5.2 => constants.%Int32.Op.6afff1.1 +// CHECK:STDOUT: %specific_impl_fn.loc126_5.4 => constants.%Int32.Op.6afff1.1 +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @SubWith.loc135(constants.%Destroy.facet.c06, constants.%Destroy.facet.c06, constants.%facet_value.7d7) { +// CHECK:STDOUT: %Result.loc132_9.1 => constants.%Destroy.facet.c06 +// CHECK:STDOUT: %U.loc133_4.1 => constants.%Destroy.facet.c06 +// CHECK:STDOUT: %U.as_type.loc134_36.1 => constants.%Int32 +// CHECK:STDOUT: %SubWith.type.loc134_36.1 => constants.%SubWith.type.84c +// CHECK:STDOUT: %facet_type.loc134_20 => constants.%facet_type.e7a +// CHECK:STDOUT: %.Self.1 => constants.%.Self.384 +// CHECK:STDOUT: %require_complete.loc134 => constants.%complete_type.a34 +// CHECK:STDOUT: %.Self.as_type.loc134_44.1 => constants.%.Self.as_type.45d +// CHECK:STDOUT: %SubWith.assoc_type => constants.%SubWith.assoc_type.0f9 +// CHECK:STDOUT: %assoc0 => constants.%assoc0.1e9 +// CHECK:STDOUT: %SubWith.lookup_impl_witness.loc134 => constants.%SubWith.lookup_impl_witness.b61 +// CHECK:STDOUT: %impl.elem0.loc134_44.1 => constants.%impl.elem0.edd +// CHECK:STDOUT: %Result.as_type.loc134_54.1 => constants.%Int32 +// CHECK:STDOUT: %facet_type.loc134_38 => constants.%facet_type.f15 +// CHECK:STDOUT: %T.loc134_4.1 => constants.%facet_value.7d7 +// CHECK:STDOUT: %pattern_type.loc134 => constants.%pattern_type.56e +// CHECK:STDOUT: %pattern_type.loc135_16 => constants.%pattern_type.9c9 +// CHECK:STDOUT: %T.as_type.loc135_29.1 => constants.%Int16 +// CHECK:STDOUT: %pattern_type.loc135_27 => constants.%pattern_type.9a4 +// CHECK:STDOUT: %pattern_type.loc135_33 => constants.%pattern_type.9c9 +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc135_16 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc135_27 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc135_33 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc137 => constants.%complete_type.9bf +// CHECK:STDOUT: %assoc1 => constants.%assoc1.714 +// CHECK:STDOUT: %SubWith.lookup_impl_witness.loc137 => constants.%custom_witness.103 +// CHECK:STDOUT: %SubWith.facet => constants.%SubWith.facet.696 +// CHECK:STDOUT: %SubWith.WithSelf.Op.type => constants.%SubWith.WithSelf.Op.type.e30 +// CHECK:STDOUT: %.loc137_5.4 => constants.%.a54 +// CHECK:STDOUT: %impl.elem1.loc137_5.2 => constants.%Int16.Op.c3e49c.9 +// CHECK:STDOUT: %specific_impl_fn.loc137_5.3 => constants.%Int16.Op.c3e49c.9 +// CHECK:STDOUT: %Destroy.WithSelf.Op.type => constants.%Destroy.WithSelf.Op.type.2e1 +// CHECK:STDOUT: %.loc137_5.5 => constants.%.e6c +// CHECK:STDOUT: %Destroy.lookup_impl_witness => constants.%custom_witness.ce1 +// CHECK:STDOUT: %impl.elem0.loc137_5.2 => constants.%Int32.Op.6afff1.1 +// CHECK:STDOUT: %specific_impl_fn.loc137_5.4 => constants.%Int32.Op.6afff1.1 +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @MulWith.loc146(constants.%Destroy.facet.c06, constants.%Destroy.facet.c06, constants.%facet_value.75c) { +// CHECK:STDOUT: %Result.loc143_9.1 => constants.%Destroy.facet.c06 +// CHECK:STDOUT: %U.loc144_4.1 => constants.%Destroy.facet.c06 +// CHECK:STDOUT: %U.as_type.loc145_36.1 => constants.%Int32 +// CHECK:STDOUT: %MulWith.type.loc145_36.1 => constants.%MulWith.type.d1b +// CHECK:STDOUT: %facet_type.loc145_20 => constants.%facet_type.2e6 +// CHECK:STDOUT: %.Self.1 => constants.%.Self.84b +// CHECK:STDOUT: %require_complete.loc145 => constants.%complete_type.043 +// CHECK:STDOUT: %.Self.as_type.loc145_44.1 => constants.%.Self.as_type.d0cd +// CHECK:STDOUT: %MulWith.assoc_type => constants.%MulWith.assoc_type.8c6 +// CHECK:STDOUT: %assoc0 => constants.%assoc0.a8f +// CHECK:STDOUT: %MulWith.lookup_impl_witness.loc145 => constants.%MulWith.lookup_impl_witness.539 +// CHECK:STDOUT: %impl.elem0.loc145_44.1 => constants.%impl.elem0.e63 +// CHECK:STDOUT: %Result.as_type.loc145_54.1 => constants.%Int32 +// CHECK:STDOUT: %facet_type.loc145_38 => constants.%facet_type.c22 +// CHECK:STDOUT: %T.loc145_4.1 => constants.%facet_value.75c +// CHECK:STDOUT: %pattern_type.loc145 => constants.%pattern_type.965 +// CHECK:STDOUT: %pattern_type.loc146_16 => constants.%pattern_type.9c9 +// CHECK:STDOUT: %T.as_type.loc146_29.1 => constants.%Int16 +// CHECK:STDOUT: %pattern_type.loc146_27 => constants.%pattern_type.9a4 +// CHECK:STDOUT: %pattern_type.loc146_33 => constants.%pattern_type.9c9 +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc146_16 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc146_27 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc146_33 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc148 => constants.%complete_type.a1f +// CHECK:STDOUT: %assoc1 => constants.%assoc1.6bc +// CHECK:STDOUT: %MulWith.lookup_impl_witness.loc148 => constants.%custom_witness.a6d +// CHECK:STDOUT: %MulWith.facet => constants.%MulWith.facet.6d1 +// CHECK:STDOUT: %MulWith.WithSelf.Op.type => constants.%MulWith.WithSelf.Op.type.61d +// CHECK:STDOUT: %.loc148_5.4 => constants.%.3a1 +// CHECK:STDOUT: %impl.elem1.loc148_5.2 => constants.%Int16.Op.c3e49c.10 +// CHECK:STDOUT: %specific_impl_fn.loc148_5.3 => constants.%Int16.Op.c3e49c.10 +// CHECK:STDOUT: %Destroy.WithSelf.Op.type => constants.%Destroy.WithSelf.Op.type.2e1 +// CHECK:STDOUT: %.loc148_5.5 => constants.%.e6c +// CHECK:STDOUT: %Destroy.lookup_impl_witness => constants.%custom_witness.ce1 +// CHECK:STDOUT: %impl.elem0.loc148_5.2 => constants.%Int32.Op.6afff1.1 +// CHECK:STDOUT: %specific_impl_fn.loc148_5.4 => constants.%Int32.Op.6afff1.1 +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @DivWith.loc157(constants.%Destroy.facet.c06, constants.%Destroy.facet.c06, constants.%facet_value.85a) { +// CHECK:STDOUT: %Result.loc154_9.1 => constants.%Destroy.facet.c06 +// CHECK:STDOUT: %U.loc155_4.1 => constants.%Destroy.facet.c06 +// CHECK:STDOUT: %U.as_type.loc156_36.1 => constants.%Int32 +// CHECK:STDOUT: %DivWith.type.loc156_36.1 => constants.%DivWith.type.26e +// CHECK:STDOUT: %facet_type.loc156_20 => constants.%facet_type.eb5 +// CHECK:STDOUT: %.Self.1 => constants.%.Self.203 +// CHECK:STDOUT: %require_complete.loc156 => constants.%complete_type.d76 +// CHECK:STDOUT: %.Self.as_type.loc156_44.1 => constants.%.Self.as_type.f8e +// CHECK:STDOUT: %DivWith.assoc_type => constants.%DivWith.assoc_type.109 +// CHECK:STDOUT: %assoc0 => constants.%assoc0.d76 +// CHECK:STDOUT: %DivWith.lookup_impl_witness.loc156 => constants.%DivWith.lookup_impl_witness.512 +// CHECK:STDOUT: %impl.elem0.loc156_44.1 => constants.%impl.elem0.232 +// CHECK:STDOUT: %Result.as_type.loc156_54.1 => constants.%Int32 +// CHECK:STDOUT: %facet_type.loc156_38 => constants.%facet_type.529 +// CHECK:STDOUT: %T.loc156_4.1 => constants.%facet_value.85a +// CHECK:STDOUT: %pattern_type.loc156 => constants.%pattern_type.04c +// CHECK:STDOUT: %pattern_type.loc157_16 => constants.%pattern_type.9c9 +// CHECK:STDOUT: %T.as_type.loc157_29.1 => constants.%Int16 +// CHECK:STDOUT: %pattern_type.loc157_27 => constants.%pattern_type.9a4 +// CHECK:STDOUT: %pattern_type.loc157_33 => constants.%pattern_type.9c9 +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc157_16 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc157_27 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc157_33 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc159 => constants.%complete_type.e49 +// CHECK:STDOUT: %assoc1 => constants.%assoc1.4a0 +// CHECK:STDOUT: %DivWith.lookup_impl_witness.loc159 => constants.%custom_witness.510 +// CHECK:STDOUT: %DivWith.facet => constants.%DivWith.facet.246 +// CHECK:STDOUT: %DivWith.WithSelf.Op.type => constants.%DivWith.WithSelf.Op.type.623 +// CHECK:STDOUT: %.loc159_5.4 => constants.%.e6b +// CHECK:STDOUT: %impl.elem1.loc159_5.2 => constants.%Int16.Op.c3e49c.11 +// CHECK:STDOUT: %specific_impl_fn.loc159_5.3 => constants.%Int16.Op.c3e49c.11 +// CHECK:STDOUT: %Destroy.WithSelf.Op.type => constants.%Destroy.WithSelf.Op.type.2e1 +// CHECK:STDOUT: %.loc159_5.5 => constants.%.e6c +// CHECK:STDOUT: %Destroy.lookup_impl_witness => constants.%custom_witness.ce1 +// CHECK:STDOUT: %impl.elem0.loc159_5.2 => constants.%Int32.Op.6afff1.1 +// CHECK:STDOUT: %specific_impl_fn.loc159_5.4 => constants.%Int32.Op.6afff1.1 +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @ModWith.loc168(constants.%Destroy.facet.c06, constants.%Destroy.facet.c06, constants.%facet_value.dd3) { +// CHECK:STDOUT: %Result.loc165_9.1 => constants.%Destroy.facet.c06 +// CHECK:STDOUT: %U.loc166_4.1 => constants.%Destroy.facet.c06 +// CHECK:STDOUT: %U.as_type.loc167_36.1 => constants.%Int32 +// CHECK:STDOUT: %ModWith.type.loc167_36.1 => constants.%ModWith.type.5c4 +// CHECK:STDOUT: %facet_type.loc167_20 => constants.%facet_type.1e6 +// CHECK:STDOUT: %.Self.1 => constants.%.Self.0c5 +// CHECK:STDOUT: %require_complete.loc167 => constants.%complete_type.1bb +// CHECK:STDOUT: %.Self.as_type.loc167_44.1 => constants.%.Self.as_type.ef1 +// CHECK:STDOUT: %ModWith.assoc_type => constants.%ModWith.assoc_type.1db +// CHECK:STDOUT: %assoc0 => constants.%assoc0.8e2 +// CHECK:STDOUT: %ModWith.lookup_impl_witness.loc167 => constants.%ModWith.lookup_impl_witness.9f7 +// CHECK:STDOUT: %impl.elem0.loc167_44.1 => constants.%impl.elem0.919 +// CHECK:STDOUT: %Result.as_type.loc167_54.1 => constants.%Int32 +// CHECK:STDOUT: %facet_type.loc167_38 => constants.%facet_type.422 +// CHECK:STDOUT: %T.loc167_4.1 => constants.%facet_value.dd3 +// CHECK:STDOUT: %pattern_type.loc167 => constants.%pattern_type.4d3 +// CHECK:STDOUT: %pattern_type.loc168_16 => constants.%pattern_type.9c9 +// CHECK:STDOUT: %T.as_type.loc168_29.1 => constants.%Int16 +// CHECK:STDOUT: %pattern_type.loc168_27 => constants.%pattern_type.9a4 +// CHECK:STDOUT: %pattern_type.loc168_33 => constants.%pattern_type.9c9 +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc168_16 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc168_27 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc168_33 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc170 => constants.%complete_type.3ed +// CHECK:STDOUT: %assoc1 => constants.%assoc1.826 +// CHECK:STDOUT: %ModWith.lookup_impl_witness.loc170 => constants.%custom_witness.a62 +// CHECK:STDOUT: %ModWith.facet => constants.%ModWith.facet.76b +// CHECK:STDOUT: %ModWith.WithSelf.Op.type => constants.%ModWith.WithSelf.Op.type.cfc +// CHECK:STDOUT: %.loc170_5.4 => constants.%.132 +// CHECK:STDOUT: %impl.elem1.loc170_5.2 => constants.%Int16.Op.c3e49c.12 +// CHECK:STDOUT: %specific_impl_fn.loc170_5.3 => constants.%Int16.Op.c3e49c.12 +// CHECK:STDOUT: %Destroy.WithSelf.Op.type => constants.%Destroy.WithSelf.Op.type.2e1 +// CHECK:STDOUT: %.loc170_5.5 => constants.%.e6c +// CHECK:STDOUT: %Destroy.lookup_impl_witness => constants.%custom_witness.ce1 +// CHECK:STDOUT: %impl.elem0.loc170_5.2 => constants.%Int32.Op.6afff1.1 +// CHECK:STDOUT: %specific_impl_fn.loc170_5.4 => constants.%Int32.Op.6afff1.1 +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @AddWith.loc124(constants.%Destroy.facet.c06, constants.%Destroy.facet.e06, constants.%facet_value.741) { +// CHECK:STDOUT: %Result.loc121_9.1 => constants.%Destroy.facet.c06 +// CHECK:STDOUT: %U.loc122_4.1 => constants.%Destroy.facet.e06 +// CHECK:STDOUT: %U.as_type.loc123_36.1 => constants.%Int16 +// CHECK:STDOUT: %AddWith.type.loc123_36.1 => constants.%AddWith.type.344 +// CHECK:STDOUT: %facet_type.loc123_20 => constants.%facet_type.a81 +// CHECK:STDOUT: %.Self.1 => constants.%.Self.0ae +// CHECK:STDOUT: %require_complete.loc123 => constants.%complete_type.f61 +// CHECK:STDOUT: %.Self.as_type.loc123_44.1 => constants.%.Self.as_type.12a0 +// CHECK:STDOUT: %AddWith.assoc_type => constants.%AddWith.assoc_type.f75 +// CHECK:STDOUT: %assoc0 => constants.%assoc0.dc9 +// CHECK:STDOUT: %AddWith.lookup_impl_witness.loc123 => constants.%AddWith.lookup_impl_witness.db4 +// CHECK:STDOUT: %impl.elem0.loc123_44.1 => constants.%impl.elem0.cdb +// CHECK:STDOUT: %Result.as_type.loc123_54.1 => constants.%Int32 +// CHECK:STDOUT: %facet_type.loc123_38 => constants.%facet_type.b0a +// CHECK:STDOUT: %T.loc123_4.1 => constants.%facet_value.741 +// CHECK:STDOUT: %pattern_type.loc123 => constants.%pattern_type.e21 +// CHECK:STDOUT: %pattern_type.loc124_16 => constants.%pattern_type.9c9 +// CHECK:STDOUT: %T.as_type.loc124_29.1 => constants.%Int32 +// CHECK:STDOUT: %pattern_type.loc124_27 => constants.%pattern_type.9c9 +// CHECK:STDOUT: %pattern_type.loc124_33 => constants.%pattern_type.9a4 +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc124_16 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc124_27 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc124_33 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc126 => constants.%complete_type.f1c +// CHECK:STDOUT: %assoc1 => constants.%assoc1.646 +// CHECK:STDOUT: %AddWith.lookup_impl_witness.loc126 => constants.%custom_witness.116 +// CHECK:STDOUT: %AddWith.facet => constants.%AddWith.facet.fce +// CHECK:STDOUT: %AddWith.WithSelf.Op.type => constants.%AddWith.WithSelf.Op.type.523 +// CHECK:STDOUT: %.loc126_5.4 => constants.%.a28 +// CHECK:STDOUT: %impl.elem1.loc126_5.2 => constants.%Int32.Op.6afff1.2 +// CHECK:STDOUT: %specific_impl_fn.loc126_5.3 => constants.%Int32.Op.6afff1.2 +// CHECK:STDOUT: %Destroy.WithSelf.Op.type => constants.%Destroy.WithSelf.Op.type.2e1 +// CHECK:STDOUT: %.loc126_5.5 => constants.%.e6c +// CHECK:STDOUT: %Destroy.lookup_impl_witness => constants.%custom_witness.ce1 +// CHECK:STDOUT: %impl.elem0.loc126_5.2 => constants.%Int32.Op.6afff1.1 +// CHECK:STDOUT: %specific_impl_fn.loc126_5.4 => constants.%Int32.Op.6afff1.1 +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @SubWith.loc135(constants.%Destroy.facet.c06, constants.%Destroy.facet.e06, constants.%facet_value.f31) { +// CHECK:STDOUT: %Result.loc132_9.1 => constants.%Destroy.facet.c06 +// CHECK:STDOUT: %U.loc133_4.1 => constants.%Destroy.facet.e06 +// CHECK:STDOUT: %U.as_type.loc134_36.1 => constants.%Int16 +// CHECK:STDOUT: %SubWith.type.loc134_36.1 => constants.%SubWith.type.306 +// CHECK:STDOUT: %facet_type.loc134_20 => constants.%facet_type.b37 +// CHECK:STDOUT: %.Self.1 => constants.%.Self.107 +// CHECK:STDOUT: %require_complete.loc134 => constants.%complete_type.5cf +// CHECK:STDOUT: %.Self.as_type.loc134_44.1 => constants.%.Self.as_type.e34 +// CHECK:STDOUT: %SubWith.assoc_type => constants.%SubWith.assoc_type.7a2 +// CHECK:STDOUT: %assoc0 => constants.%assoc0.f42 +// CHECK:STDOUT: %SubWith.lookup_impl_witness.loc134 => constants.%SubWith.lookup_impl_witness.a35 +// CHECK:STDOUT: %impl.elem0.loc134_44.1 => constants.%impl.elem0.345 +// CHECK:STDOUT: %Result.as_type.loc134_54.1 => constants.%Int32 +// CHECK:STDOUT: %facet_type.loc134_38 => constants.%facet_type.afb +// CHECK:STDOUT: %T.loc134_4.1 => constants.%facet_value.f31 +// CHECK:STDOUT: %pattern_type.loc134 => constants.%pattern_type.6ad +// CHECK:STDOUT: %pattern_type.loc135_16 => constants.%pattern_type.9c9 +// CHECK:STDOUT: %T.as_type.loc135_29.1 => constants.%Int32 +// CHECK:STDOUT: %pattern_type.loc135_27 => constants.%pattern_type.9c9 +// CHECK:STDOUT: %pattern_type.loc135_33 => constants.%pattern_type.9a4 +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc135_16 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc135_27 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc135_33 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc137 => constants.%complete_type.9b3 +// CHECK:STDOUT: %assoc1 => constants.%assoc1.2c3 +// CHECK:STDOUT: %SubWith.lookup_impl_witness.loc137 => constants.%custom_witness.904 +// CHECK:STDOUT: %SubWith.facet => constants.%SubWith.facet.099 +// CHECK:STDOUT: %SubWith.WithSelf.Op.type => constants.%SubWith.WithSelf.Op.type.5d6 +// CHECK:STDOUT: %.loc137_5.4 => constants.%.43e +// CHECK:STDOUT: %impl.elem1.loc137_5.2 => constants.%Int32.Op.6afff1.3 +// CHECK:STDOUT: %specific_impl_fn.loc137_5.3 => constants.%Int32.Op.6afff1.3 +// CHECK:STDOUT: %Destroy.WithSelf.Op.type => constants.%Destroy.WithSelf.Op.type.2e1 +// CHECK:STDOUT: %.loc137_5.5 => constants.%.e6c +// CHECK:STDOUT: %Destroy.lookup_impl_witness => constants.%custom_witness.ce1 +// CHECK:STDOUT: %impl.elem0.loc137_5.2 => constants.%Int32.Op.6afff1.1 +// CHECK:STDOUT: %specific_impl_fn.loc137_5.4 => constants.%Int32.Op.6afff1.1 +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @MulWith.loc146(constants.%Destroy.facet.c06, constants.%Destroy.facet.e06, constants.%facet_value.daa) { +// CHECK:STDOUT: %Result.loc143_9.1 => constants.%Destroy.facet.c06 +// CHECK:STDOUT: %U.loc144_4.1 => constants.%Destroy.facet.e06 +// CHECK:STDOUT: %U.as_type.loc145_36.1 => constants.%Int16 +// CHECK:STDOUT: %MulWith.type.loc145_36.1 => constants.%MulWith.type.0cd +// CHECK:STDOUT: %facet_type.loc145_20 => constants.%facet_type.2dd +// CHECK:STDOUT: %.Self.1 => constants.%.Self.594 +// CHECK:STDOUT: %require_complete.loc145 => constants.%complete_type.b32 +// CHECK:STDOUT: %.Self.as_type.loc145_44.1 => constants.%.Self.as_type.674 +// CHECK:STDOUT: %MulWith.assoc_type => constants.%MulWith.assoc_type.f1b +// CHECK:STDOUT: %assoc0 => constants.%assoc0.3ee +// CHECK:STDOUT: %MulWith.lookup_impl_witness.loc145 => constants.%MulWith.lookup_impl_witness.834 +// CHECK:STDOUT: %impl.elem0.loc145_44.1 => constants.%impl.elem0.6fb +// CHECK:STDOUT: %Result.as_type.loc145_54.1 => constants.%Int32 +// CHECK:STDOUT: %facet_type.loc145_38 => constants.%facet_type.bfe +// CHECK:STDOUT: %T.loc145_4.1 => constants.%facet_value.daa +// CHECK:STDOUT: %pattern_type.loc145 => constants.%pattern_type.8a2 +// CHECK:STDOUT: %pattern_type.loc146_16 => constants.%pattern_type.9c9 +// CHECK:STDOUT: %T.as_type.loc146_29.1 => constants.%Int32 +// CHECK:STDOUT: %pattern_type.loc146_27 => constants.%pattern_type.9c9 +// CHECK:STDOUT: %pattern_type.loc146_33 => constants.%pattern_type.9a4 +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc146_16 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc146_27 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc146_33 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc148 => constants.%complete_type.4d2 +// CHECK:STDOUT: %assoc1 => constants.%assoc1.988 +// CHECK:STDOUT: %MulWith.lookup_impl_witness.loc148 => constants.%custom_witness.04f +// CHECK:STDOUT: %MulWith.facet => constants.%MulWith.facet.aea +// CHECK:STDOUT: %MulWith.WithSelf.Op.type => constants.%MulWith.WithSelf.Op.type.f3c +// CHECK:STDOUT: %.loc148_5.4 => constants.%.a30 +// CHECK:STDOUT: %impl.elem1.loc148_5.2 => constants.%Int32.Op.6afff1.4 +// CHECK:STDOUT: %specific_impl_fn.loc148_5.3 => constants.%Int32.Op.6afff1.4 +// CHECK:STDOUT: %Destroy.WithSelf.Op.type => constants.%Destroy.WithSelf.Op.type.2e1 +// CHECK:STDOUT: %.loc148_5.5 => constants.%.e6c +// CHECK:STDOUT: %Destroy.lookup_impl_witness => constants.%custom_witness.ce1 +// CHECK:STDOUT: %impl.elem0.loc148_5.2 => constants.%Int32.Op.6afff1.1 +// CHECK:STDOUT: %specific_impl_fn.loc148_5.4 => constants.%Int32.Op.6afff1.1 +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @DivWith.loc157(constants.%Destroy.facet.c06, constants.%Destroy.facet.e06, constants.%facet_value.437) { +// CHECK:STDOUT: %Result.loc154_9.1 => constants.%Destroy.facet.c06 +// CHECK:STDOUT: %U.loc155_4.1 => constants.%Destroy.facet.e06 +// CHECK:STDOUT: %U.as_type.loc156_36.1 => constants.%Int16 +// CHECK:STDOUT: %DivWith.type.loc156_36.1 => constants.%DivWith.type.4c2 +// CHECK:STDOUT: %facet_type.loc156_20 => constants.%facet_type.e82 +// CHECK:STDOUT: %.Self.1 => constants.%.Self.c70 +// CHECK:STDOUT: %require_complete.loc156 => constants.%complete_type.8b32 +// CHECK:STDOUT: %.Self.as_type.loc156_44.1 => constants.%.Self.as_type.e0e +// CHECK:STDOUT: %DivWith.assoc_type => constants.%DivWith.assoc_type.9fa +// CHECK:STDOUT: %assoc0 => constants.%assoc0.cf5 +// CHECK:STDOUT: %DivWith.lookup_impl_witness.loc156 => constants.%DivWith.lookup_impl_witness.dbb +// CHECK:STDOUT: %impl.elem0.loc156_44.1 => constants.%impl.elem0.e43 +// CHECK:STDOUT: %Result.as_type.loc156_54.1 => constants.%Int32 +// CHECK:STDOUT: %facet_type.loc156_38 => constants.%facet_type.917 +// CHECK:STDOUT: %T.loc156_4.1 => constants.%facet_value.437 +// CHECK:STDOUT: %pattern_type.loc156 => constants.%pattern_type.b7f +// CHECK:STDOUT: %pattern_type.loc157_16 => constants.%pattern_type.9c9 +// CHECK:STDOUT: %T.as_type.loc157_29.1 => constants.%Int32 +// CHECK:STDOUT: %pattern_type.loc157_27 => constants.%pattern_type.9c9 +// CHECK:STDOUT: %pattern_type.loc157_33 => constants.%pattern_type.9a4 +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc157_16 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc157_27 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc157_33 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc159 => constants.%complete_type.e42 +// CHECK:STDOUT: %assoc1 => constants.%assoc1.cda +// CHECK:STDOUT: %DivWith.lookup_impl_witness.loc159 => constants.%custom_witness.53b +// CHECK:STDOUT: %DivWith.facet => constants.%DivWith.facet.687 +// CHECK:STDOUT: %DivWith.WithSelf.Op.type => constants.%DivWith.WithSelf.Op.type.b6a +// CHECK:STDOUT: %.loc159_5.4 => constants.%.c6a +// CHECK:STDOUT: %impl.elem1.loc159_5.2 => constants.%Int32.Op.6afff1.5 +// CHECK:STDOUT: %specific_impl_fn.loc159_5.3 => constants.%Int32.Op.6afff1.5 +// CHECK:STDOUT: %Destroy.WithSelf.Op.type => constants.%Destroy.WithSelf.Op.type.2e1 +// CHECK:STDOUT: %.loc159_5.5 => constants.%.e6c +// CHECK:STDOUT: %Destroy.lookup_impl_witness => constants.%custom_witness.ce1 +// CHECK:STDOUT: %impl.elem0.loc159_5.2 => constants.%Int32.Op.6afff1.1 +// CHECK:STDOUT: %specific_impl_fn.loc159_5.4 => constants.%Int32.Op.6afff1.1 +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @ModWith.loc168(constants.%Destroy.facet.c06, constants.%Destroy.facet.e06, constants.%facet_value.9f1) { +// CHECK:STDOUT: %Result.loc165_9.1 => constants.%Destroy.facet.c06 +// CHECK:STDOUT: %U.loc166_4.1 => constants.%Destroy.facet.e06 +// CHECK:STDOUT: %U.as_type.loc167_36.1 => constants.%Int16 +// CHECK:STDOUT: %ModWith.type.loc167_36.1 => constants.%ModWith.type.009 +// CHECK:STDOUT: %facet_type.loc167_20 => constants.%facet_type.e1e +// CHECK:STDOUT: %.Self.1 => constants.%.Self.76e +// CHECK:STDOUT: %require_complete.loc167 => constants.%complete_type.5b6 +// CHECK:STDOUT: %.Self.as_type.loc167_44.1 => constants.%.Self.as_type.242 +// CHECK:STDOUT: %ModWith.assoc_type => constants.%ModWith.assoc_type.355 +// CHECK:STDOUT: %assoc0 => constants.%assoc0.0f7 +// CHECK:STDOUT: %ModWith.lookup_impl_witness.loc167 => constants.%ModWith.lookup_impl_witness.c6b +// CHECK:STDOUT: %impl.elem0.loc167_44.1 => constants.%impl.elem0.cba +// CHECK:STDOUT: %Result.as_type.loc167_54.1 => constants.%Int32 +// CHECK:STDOUT: %facet_type.loc167_38 => constants.%facet_type.d08 +// CHECK:STDOUT: %T.loc167_4.1 => constants.%facet_value.9f1 +// CHECK:STDOUT: %pattern_type.loc167 => constants.%pattern_type.a04 +// CHECK:STDOUT: %pattern_type.loc168_16 => constants.%pattern_type.9c9 +// CHECK:STDOUT: %T.as_type.loc168_29.1 => constants.%Int32 +// CHECK:STDOUT: %pattern_type.loc168_27 => constants.%pattern_type.9c9 +// CHECK:STDOUT: %pattern_type.loc168_33 => constants.%pattern_type.9a4 +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc168_16 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc168_27 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc168_33 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc170 => constants.%complete_type.e9f +// CHECK:STDOUT: %assoc1 => constants.%assoc1.c82 +// CHECK:STDOUT: %ModWith.lookup_impl_witness.loc170 => constants.%custom_witness.895 +// CHECK:STDOUT: %ModWith.facet => constants.%ModWith.facet.7e6 +// CHECK:STDOUT: %ModWith.WithSelf.Op.type => constants.%ModWith.WithSelf.Op.type.55e +// CHECK:STDOUT: %.loc170_5.4 => constants.%.274 +// CHECK:STDOUT: %impl.elem1.loc170_5.2 => constants.%Int32.Op.6afff1.6 +// CHECK:STDOUT: %specific_impl_fn.loc170_5.3 => constants.%Int32.Op.6afff1.6 +// CHECK:STDOUT: %Destroy.WithSelf.Op.type => constants.%Destroy.WithSelf.Op.type.2e1 +// CHECK:STDOUT: %.loc170_5.5 => constants.%.e6c +// CHECK:STDOUT: %Destroy.lookup_impl_witness => constants.%custom_witness.ce1 +// CHECK:STDOUT: %impl.elem0.loc170_5.2 => constants.%Int32.Op.6afff1.1 +// CHECK:STDOUT: %specific_impl_fn.loc170_5.4 => constants.%Int32.Op.6afff1.1 +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @AddWith.loc124(constants.%Destroy.facet.c06, constants.%Destroy.facet.c06, constants.%facet_value.fca) { +// CHECK:STDOUT: %Result.loc121_9.1 => constants.%Destroy.facet.c06 +// CHECK:STDOUT: %U.loc122_4.1 => constants.%Destroy.facet.c06 +// CHECK:STDOUT: %U.as_type.loc123_36.1 => constants.%Int32 +// CHECK:STDOUT: %AddWith.type.loc123_36.1 => constants.%AddWith.type.e9e +// CHECK:STDOUT: %facet_type.loc123_20 => constants.%facet_type.4a7 +// CHECK:STDOUT: %.Self.1 => constants.%.Self.3d9 +// CHECK:STDOUT: %require_complete.loc123 => constants.%complete_type.0d9 +// CHECK:STDOUT: %.Self.as_type.loc123_44.1 => constants.%.Self.as_type.7ba +// CHECK:STDOUT: %AddWith.assoc_type => constants.%AddWith.assoc_type.29a +// CHECK:STDOUT: %assoc0 => constants.%assoc0.701 +// CHECK:STDOUT: %AddWith.lookup_impl_witness.loc123 => constants.%AddWith.lookup_impl_witness.632 +// CHECK:STDOUT: %impl.elem0.loc123_44.1 => constants.%impl.elem0.cee +// CHECK:STDOUT: %Result.as_type.loc123_54.1 => constants.%Int32 +// CHECK:STDOUT: %facet_type.loc123_38 => constants.%facet_type.14d +// CHECK:STDOUT: %T.loc123_4.1 => constants.%facet_value.fca +// CHECK:STDOUT: %pattern_type.loc123 => constants.%pattern_type.3f9 +// CHECK:STDOUT: %pattern_type.loc124_16 => constants.%pattern_type.9c9 +// CHECK:STDOUT: %T.as_type.loc124_29.1 => constants.%Int32 +// CHECK:STDOUT: %pattern_type.loc124_27 => constants.%pattern_type.9c9 +// CHECK:STDOUT: %pattern_type.loc124_33 => constants.%pattern_type.9c9 +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc124_16 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc124_27 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc124_33 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc126 => constants.%complete_type.03d +// CHECK:STDOUT: %assoc1 => constants.%assoc1.38b +// CHECK:STDOUT: %AddWith.lookup_impl_witness.loc126 => constants.%custom_witness.78d +// CHECK:STDOUT: %AddWith.facet => constants.%AddWith.facet.e5b +// CHECK:STDOUT: %AddWith.WithSelf.Op.type => constants.%AddWith.WithSelf.Op.type.13e +// CHECK:STDOUT: %.loc126_5.4 => constants.%.56e +// CHECK:STDOUT: %impl.elem1.loc126_5.2 => constants.%Int32.Op.6afff1.7 +// CHECK:STDOUT: %specific_impl_fn.loc126_5.3 => constants.%Int32.Op.6afff1.7 +// CHECK:STDOUT: %Destroy.WithSelf.Op.type => constants.%Destroy.WithSelf.Op.type.2e1 +// CHECK:STDOUT: %.loc126_5.5 => constants.%.e6c +// CHECK:STDOUT: %Destroy.lookup_impl_witness => constants.%custom_witness.ce1 +// CHECK:STDOUT: %impl.elem0.loc126_5.2 => constants.%Int32.Op.6afff1.1 +// CHECK:STDOUT: %specific_impl_fn.loc126_5.4 => constants.%Int32.Op.6afff1.1 +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @SubWith.loc135(constants.%Destroy.facet.c06, constants.%Destroy.facet.c06, constants.%facet_value.9a9) { +// CHECK:STDOUT: %Result.loc132_9.1 => constants.%Destroy.facet.c06 +// CHECK:STDOUT: %U.loc133_4.1 => constants.%Destroy.facet.c06 +// CHECK:STDOUT: %U.as_type.loc134_36.1 => constants.%Int32 +// CHECK:STDOUT: %SubWith.type.loc134_36.1 => constants.%SubWith.type.84c +// CHECK:STDOUT: %facet_type.loc134_20 => constants.%facet_type.e7a +// CHECK:STDOUT: %.Self.1 => constants.%.Self.384 +// CHECK:STDOUT: %require_complete.loc134 => constants.%complete_type.a34 +// CHECK:STDOUT: %.Self.as_type.loc134_44.1 => constants.%.Self.as_type.45d +// CHECK:STDOUT: %SubWith.assoc_type => constants.%SubWith.assoc_type.0f9 +// CHECK:STDOUT: %assoc0 => constants.%assoc0.1e9 +// CHECK:STDOUT: %SubWith.lookup_impl_witness.loc134 => constants.%SubWith.lookup_impl_witness.b61 +// CHECK:STDOUT: %impl.elem0.loc134_44.1 => constants.%impl.elem0.edd +// CHECK:STDOUT: %Result.as_type.loc134_54.1 => constants.%Int32 +// CHECK:STDOUT: %facet_type.loc134_38 => constants.%facet_type.f15 +// CHECK:STDOUT: %T.loc134_4.1 => constants.%facet_value.9a9 +// CHECK:STDOUT: %pattern_type.loc134 => constants.%pattern_type.56e +// CHECK:STDOUT: %pattern_type.loc135_16 => constants.%pattern_type.9c9 +// CHECK:STDOUT: %T.as_type.loc135_29.1 => constants.%Int32 +// CHECK:STDOUT: %pattern_type.loc135_27 => constants.%pattern_type.9c9 +// CHECK:STDOUT: %pattern_type.loc135_33 => constants.%pattern_type.9c9 +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc135_16 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc135_27 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc135_33 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc137 => constants.%complete_type.9bf +// CHECK:STDOUT: %assoc1 => constants.%assoc1.714 +// CHECK:STDOUT: %SubWith.lookup_impl_witness.loc137 => constants.%custom_witness.64d +// CHECK:STDOUT: %SubWith.facet => constants.%SubWith.facet.e26 +// CHECK:STDOUT: %SubWith.WithSelf.Op.type => constants.%SubWith.WithSelf.Op.type.d8a +// CHECK:STDOUT: %.loc137_5.4 => constants.%.cb1 +// CHECK:STDOUT: %impl.elem1.loc137_5.2 => constants.%Int32.Op.6afff1.8 +// CHECK:STDOUT: %specific_impl_fn.loc137_5.3 => constants.%Int32.Op.6afff1.8 +// CHECK:STDOUT: %Destroy.WithSelf.Op.type => constants.%Destroy.WithSelf.Op.type.2e1 +// CHECK:STDOUT: %.loc137_5.5 => constants.%.e6c +// CHECK:STDOUT: %Destroy.lookup_impl_witness => constants.%custom_witness.ce1 +// CHECK:STDOUT: %impl.elem0.loc137_5.2 => constants.%Int32.Op.6afff1.1 +// CHECK:STDOUT: %specific_impl_fn.loc137_5.4 => constants.%Int32.Op.6afff1.1 +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @MulWith.loc146(constants.%Destroy.facet.c06, constants.%Destroy.facet.c06, constants.%facet_value.03b) { +// CHECK:STDOUT: %Result.loc143_9.1 => constants.%Destroy.facet.c06 +// CHECK:STDOUT: %U.loc144_4.1 => constants.%Destroy.facet.c06 +// CHECK:STDOUT: %U.as_type.loc145_36.1 => constants.%Int32 +// CHECK:STDOUT: %MulWith.type.loc145_36.1 => constants.%MulWith.type.d1b +// CHECK:STDOUT: %facet_type.loc145_20 => constants.%facet_type.2e6 +// CHECK:STDOUT: %.Self.1 => constants.%.Self.84b +// CHECK:STDOUT: %require_complete.loc145 => constants.%complete_type.043 +// CHECK:STDOUT: %.Self.as_type.loc145_44.1 => constants.%.Self.as_type.d0cd +// CHECK:STDOUT: %MulWith.assoc_type => constants.%MulWith.assoc_type.8c6 +// CHECK:STDOUT: %assoc0 => constants.%assoc0.a8f +// CHECK:STDOUT: %MulWith.lookup_impl_witness.loc145 => constants.%MulWith.lookup_impl_witness.539 +// CHECK:STDOUT: %impl.elem0.loc145_44.1 => constants.%impl.elem0.e63 +// CHECK:STDOUT: %Result.as_type.loc145_54.1 => constants.%Int32 +// CHECK:STDOUT: %facet_type.loc145_38 => constants.%facet_type.c22 +// CHECK:STDOUT: %T.loc145_4.1 => constants.%facet_value.03b +// CHECK:STDOUT: %pattern_type.loc145 => constants.%pattern_type.965 +// CHECK:STDOUT: %pattern_type.loc146_16 => constants.%pattern_type.9c9 +// CHECK:STDOUT: %T.as_type.loc146_29.1 => constants.%Int32 +// CHECK:STDOUT: %pattern_type.loc146_27 => constants.%pattern_type.9c9 +// CHECK:STDOUT: %pattern_type.loc146_33 => constants.%pattern_type.9c9 +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc146_16 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc146_27 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc146_33 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc148 => constants.%complete_type.a1f +// CHECK:STDOUT: %assoc1 => constants.%assoc1.6bc +// CHECK:STDOUT: %MulWith.lookup_impl_witness.loc148 => constants.%custom_witness.7b6d +// CHECK:STDOUT: %MulWith.facet => constants.%MulWith.facet.b74 +// CHECK:STDOUT: %MulWith.WithSelf.Op.type => constants.%MulWith.WithSelf.Op.type.25b +// CHECK:STDOUT: %.loc148_5.4 => constants.%.e42 +// CHECK:STDOUT: %impl.elem1.loc148_5.2 => constants.%Int32.Op.6afff1.9 +// CHECK:STDOUT: %specific_impl_fn.loc148_5.3 => constants.%Int32.Op.6afff1.9 +// CHECK:STDOUT: %Destroy.WithSelf.Op.type => constants.%Destroy.WithSelf.Op.type.2e1 +// CHECK:STDOUT: %.loc148_5.5 => constants.%.e6c +// CHECK:STDOUT: %Destroy.lookup_impl_witness => constants.%custom_witness.ce1 +// CHECK:STDOUT: %impl.elem0.loc148_5.2 => constants.%Int32.Op.6afff1.1 +// CHECK:STDOUT: %specific_impl_fn.loc148_5.4 => constants.%Int32.Op.6afff1.1 +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @DivWith.loc157(constants.%Destroy.facet.c06, constants.%Destroy.facet.c06, constants.%facet_value.a2b) { +// CHECK:STDOUT: %Result.loc154_9.1 => constants.%Destroy.facet.c06 +// CHECK:STDOUT: %U.loc155_4.1 => constants.%Destroy.facet.c06 +// CHECK:STDOUT: %U.as_type.loc156_36.1 => constants.%Int32 +// CHECK:STDOUT: %DivWith.type.loc156_36.1 => constants.%DivWith.type.26e +// CHECK:STDOUT: %facet_type.loc156_20 => constants.%facet_type.eb5 +// CHECK:STDOUT: %.Self.1 => constants.%.Self.203 +// CHECK:STDOUT: %require_complete.loc156 => constants.%complete_type.d76 +// CHECK:STDOUT: %.Self.as_type.loc156_44.1 => constants.%.Self.as_type.f8e +// CHECK:STDOUT: %DivWith.assoc_type => constants.%DivWith.assoc_type.109 +// CHECK:STDOUT: %assoc0 => constants.%assoc0.d76 +// CHECK:STDOUT: %DivWith.lookup_impl_witness.loc156 => constants.%DivWith.lookup_impl_witness.512 +// CHECK:STDOUT: %impl.elem0.loc156_44.1 => constants.%impl.elem0.232 +// CHECK:STDOUT: %Result.as_type.loc156_54.1 => constants.%Int32 +// CHECK:STDOUT: %facet_type.loc156_38 => constants.%facet_type.529 +// CHECK:STDOUT: %T.loc156_4.1 => constants.%facet_value.a2b +// CHECK:STDOUT: %pattern_type.loc156 => constants.%pattern_type.04c +// CHECK:STDOUT: %pattern_type.loc157_16 => constants.%pattern_type.9c9 +// CHECK:STDOUT: %T.as_type.loc157_29.1 => constants.%Int32 +// CHECK:STDOUT: %pattern_type.loc157_27 => constants.%pattern_type.9c9 +// CHECK:STDOUT: %pattern_type.loc157_33 => constants.%pattern_type.9c9 +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc157_16 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc157_27 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc157_33 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc159 => constants.%complete_type.e49 +// CHECK:STDOUT: %assoc1 => constants.%assoc1.4a0 +// CHECK:STDOUT: %DivWith.lookup_impl_witness.loc159 => constants.%custom_witness.db6 +// CHECK:STDOUT: %DivWith.facet => constants.%DivWith.facet.8b3 +// CHECK:STDOUT: %DivWith.WithSelf.Op.type => constants.%DivWith.WithSelf.Op.type.f6d +// CHECK:STDOUT: %.loc159_5.4 => constants.%.c6f +// CHECK:STDOUT: %impl.elem1.loc159_5.2 => constants.%Int32.Op.6afff1.10 +// CHECK:STDOUT: %specific_impl_fn.loc159_5.3 => constants.%Int32.Op.6afff1.10 +// CHECK:STDOUT: %Destroy.WithSelf.Op.type => constants.%Destroy.WithSelf.Op.type.2e1 +// CHECK:STDOUT: %.loc159_5.5 => constants.%.e6c +// CHECK:STDOUT: %Destroy.lookup_impl_witness => constants.%custom_witness.ce1 +// CHECK:STDOUT: %impl.elem0.loc159_5.2 => constants.%Int32.Op.6afff1.1 +// CHECK:STDOUT: %specific_impl_fn.loc159_5.4 => constants.%Int32.Op.6afff1.1 +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @ModWith.loc168(constants.%Destroy.facet.c06, constants.%Destroy.facet.c06, constants.%facet_value.a4c) { +// CHECK:STDOUT: %Result.loc165_9.1 => constants.%Destroy.facet.c06 +// CHECK:STDOUT: %U.loc166_4.1 => constants.%Destroy.facet.c06 +// CHECK:STDOUT: %U.as_type.loc167_36.1 => constants.%Int32 +// CHECK:STDOUT: %ModWith.type.loc167_36.1 => constants.%ModWith.type.5c4 +// CHECK:STDOUT: %facet_type.loc167_20 => constants.%facet_type.1e6 +// CHECK:STDOUT: %.Self.1 => constants.%.Self.0c5 +// CHECK:STDOUT: %require_complete.loc167 => constants.%complete_type.1bb +// CHECK:STDOUT: %.Self.as_type.loc167_44.1 => constants.%.Self.as_type.ef1 +// CHECK:STDOUT: %ModWith.assoc_type => constants.%ModWith.assoc_type.1db +// CHECK:STDOUT: %assoc0 => constants.%assoc0.8e2 +// CHECK:STDOUT: %ModWith.lookup_impl_witness.loc167 => constants.%ModWith.lookup_impl_witness.9f7 +// CHECK:STDOUT: %impl.elem0.loc167_44.1 => constants.%impl.elem0.919 +// CHECK:STDOUT: %Result.as_type.loc167_54.1 => constants.%Int32 +// CHECK:STDOUT: %facet_type.loc167_38 => constants.%facet_type.422 +// CHECK:STDOUT: %T.loc167_4.1 => constants.%facet_value.a4c +// CHECK:STDOUT: %pattern_type.loc167 => constants.%pattern_type.4d3 +// CHECK:STDOUT: %pattern_type.loc168_16 => constants.%pattern_type.9c9 +// CHECK:STDOUT: %T.as_type.loc168_29.1 => constants.%Int32 +// CHECK:STDOUT: %pattern_type.loc168_27 => constants.%pattern_type.9c9 +// CHECK:STDOUT: %pattern_type.loc168_33 => constants.%pattern_type.9c9 +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc168_16 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc168_27 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc168_33 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc170 => constants.%complete_type.3ed +// CHECK:STDOUT: %assoc1 => constants.%assoc1.826 +// CHECK:STDOUT: %ModWith.lookup_impl_witness.loc170 => constants.%custom_witness.e01 +// CHECK:STDOUT: %ModWith.facet => constants.%ModWith.facet.c6b +// CHECK:STDOUT: %ModWith.WithSelf.Op.type => constants.%ModWith.WithSelf.Op.type.b72 +// CHECK:STDOUT: %.loc170_5.4 => constants.%.a97 +// CHECK:STDOUT: %impl.elem1.loc170_5.2 => constants.%Int32.Op.6afff1.11 +// CHECK:STDOUT: %specific_impl_fn.loc170_5.3 => constants.%Int32.Op.6afff1.11 +// CHECK:STDOUT: %Destroy.WithSelf.Op.type => constants.%Destroy.WithSelf.Op.type.2e1 +// CHECK:STDOUT: %.loc170_5.5 => constants.%.e6c +// CHECK:STDOUT: %Destroy.lookup_impl_witness => constants.%custom_witness.ce1 +// CHECK:STDOUT: %impl.elem0.loc170_5.2 => constants.%Int32.Op.6afff1.1 +// CHECK:STDOUT: %specific_impl_fn.loc170_5.4 => constants.%Int32.Op.6afff1.1 +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @AddWith.loc124(constants.%Destroy.facet.b0a, constants.%Destroy.facet.b0a, constants.%facet_value.054) { +// CHECK:STDOUT: %Result.loc121_9.1 => constants.%Destroy.facet.b0a +// CHECK:STDOUT: %U.loc122_4.1 => constants.%Destroy.facet.b0a +// CHECK:STDOUT: %U.as_type.loc123_36.1 => constants.%Int64 +// CHECK:STDOUT: %AddWith.type.loc123_36.1 => constants.%AddWith.type.ee5 +// CHECK:STDOUT: %facet_type.loc123_20 => constants.%facet_type.221 +// CHECK:STDOUT: %.Self.1 => constants.%.Self.954 +// CHECK:STDOUT: %require_complete.loc123 => constants.%complete_type.7fa +// CHECK:STDOUT: %.Self.as_type.loc123_44.1 => constants.%.Self.as_type.083 +// CHECK:STDOUT: %AddWith.assoc_type => constants.%AddWith.assoc_type.330 +// CHECK:STDOUT: %assoc0 => constants.%assoc0.1fe +// CHECK:STDOUT: %AddWith.lookup_impl_witness.loc123 => constants.%AddWith.lookup_impl_witness.076 +// CHECK:STDOUT: %impl.elem0.loc123_44.1 => constants.%impl.elem0.d09 +// CHECK:STDOUT: %Result.as_type.loc123_54.1 => constants.%Int64 +// CHECK:STDOUT: %facet_type.loc123_38 => constants.%facet_type.7b1 +// CHECK:STDOUT: %T.loc123_4.1 => constants.%facet_value.054 +// CHECK:STDOUT: %pattern_type.loc123 => constants.%pattern_type.aa1 +// CHECK:STDOUT: %pattern_type.loc124_16 => constants.%pattern_type.f42 +// CHECK:STDOUT: %T.as_type.loc124_29.1 => constants.%Int32 +// CHECK:STDOUT: %pattern_type.loc124_27 => constants.%pattern_type.9c9 +// CHECK:STDOUT: %pattern_type.loc124_33 => constants.%pattern_type.f42 +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc124_16 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc124_27 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc124_33 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc126 => constants.%complete_type.d2d +// CHECK:STDOUT: %assoc1 => constants.%assoc1.cd6 +// CHECK:STDOUT: %AddWith.lookup_impl_witness.loc126 => constants.%custom_witness.1b7 +// CHECK:STDOUT: %AddWith.facet => constants.%AddWith.facet.484 +// CHECK:STDOUT: %AddWith.WithSelf.Op.type => constants.%AddWith.WithSelf.Op.type.24f +// CHECK:STDOUT: %.loc126_5.4 => constants.%.442 +// CHECK:STDOUT: %impl.elem1.loc126_5.2 => constants.%Op.8fb557.6 +// CHECK:STDOUT: %specific_impl_fn.loc126_5.3 => constants.%Op.8fb557.6 +// CHECK:STDOUT: %Destroy.WithSelf.Op.type => constants.%Destroy.WithSelf.Op.type.f16 +// CHECK:STDOUT: %.loc126_5.5 => constants.%.db1 +// CHECK:STDOUT: %Destroy.lookup_impl_witness => constants.%custom_witness.d7e +// CHECK:STDOUT: %impl.elem0.loc126_5.2 => constants.%Int64.Op.b941da.1 +// CHECK:STDOUT: %specific_impl_fn.loc126_5.4 => constants.%Int64.Op.b941da.1 +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @SubWith.loc135(constants.%Destroy.facet.b0a, constants.%Destroy.facet.b0a, constants.%facet_value.f7f) { +// CHECK:STDOUT: %Result.loc132_9.1 => constants.%Destroy.facet.b0a +// CHECK:STDOUT: %U.loc133_4.1 => constants.%Destroy.facet.b0a +// CHECK:STDOUT: %U.as_type.loc134_36.1 => constants.%Int64 +// CHECK:STDOUT: %SubWith.type.loc134_36.1 => constants.%SubWith.type.b41 +// CHECK:STDOUT: %facet_type.loc134_20 => constants.%facet_type.660 +// CHECK:STDOUT: %.Self.1 => constants.%.Self.ea7 +// CHECK:STDOUT: %require_complete.loc134 => constants.%complete_type.6f3 +// CHECK:STDOUT: %.Self.as_type.loc134_44.1 => constants.%.Self.as_type.d4d +// CHECK:STDOUT: %SubWith.assoc_type => constants.%SubWith.assoc_type.b7b +// CHECK:STDOUT: %assoc0 => constants.%assoc0.979 +// CHECK:STDOUT: %SubWith.lookup_impl_witness.loc134 => constants.%SubWith.lookup_impl_witness.894 +// CHECK:STDOUT: %impl.elem0.loc134_44.1 => constants.%impl.elem0.9dd +// CHECK:STDOUT: %Result.as_type.loc134_54.1 => constants.%Int64 +// CHECK:STDOUT: %facet_type.loc134_38 => constants.%facet_type.17a +// CHECK:STDOUT: %T.loc134_4.1 => constants.%facet_value.f7f +// CHECK:STDOUT: %pattern_type.loc134 => constants.%pattern_type.30e +// CHECK:STDOUT: %pattern_type.loc135_16 => constants.%pattern_type.f42 +// CHECK:STDOUT: %T.as_type.loc135_29.1 => constants.%Int32 +// CHECK:STDOUT: %pattern_type.loc135_27 => constants.%pattern_type.9c9 +// CHECK:STDOUT: %pattern_type.loc135_33 => constants.%pattern_type.f42 +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc135_16 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc135_27 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc135_33 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc137 => constants.%complete_type.c98 +// CHECK:STDOUT: %assoc1 => constants.%assoc1.80d +// CHECK:STDOUT: %SubWith.lookup_impl_witness.loc137 => constants.%custom_witness.cab +// CHECK:STDOUT: %SubWith.facet => constants.%SubWith.facet.80e +// CHECK:STDOUT: %SubWith.WithSelf.Op.type => constants.%SubWith.WithSelf.Op.type.c99 +// CHECK:STDOUT: %.loc137_5.4 => constants.%.9c9 +// CHECK:STDOUT: %impl.elem1.loc137_5.2 => constants.%Op.8fb557.7 +// CHECK:STDOUT: %specific_impl_fn.loc137_5.3 => constants.%Op.8fb557.7 +// CHECK:STDOUT: %Destroy.WithSelf.Op.type => constants.%Destroy.WithSelf.Op.type.f16 +// CHECK:STDOUT: %.loc137_5.5 => constants.%.db1 +// CHECK:STDOUT: %Destroy.lookup_impl_witness => constants.%custom_witness.d7e +// CHECK:STDOUT: %impl.elem0.loc137_5.2 => constants.%Int64.Op.b941da.1 +// CHECK:STDOUT: %specific_impl_fn.loc137_5.4 => constants.%Int64.Op.b941da.1 +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @MulWith.loc146(constants.%Destroy.facet.b0a, constants.%Destroy.facet.b0a, constants.%facet_value.823) { +// CHECK:STDOUT: %Result.loc143_9.1 => constants.%Destroy.facet.b0a +// CHECK:STDOUT: %U.loc144_4.1 => constants.%Destroy.facet.b0a +// CHECK:STDOUT: %U.as_type.loc145_36.1 => constants.%Int64 +// CHECK:STDOUT: %MulWith.type.loc145_36.1 => constants.%MulWith.type.166 +// CHECK:STDOUT: %facet_type.loc145_20 => constants.%facet_type.60a +// CHECK:STDOUT: %.Self.1 => constants.%.Self.39e +// CHECK:STDOUT: %require_complete.loc145 => constants.%complete_type.7a4 +// CHECK:STDOUT: %.Self.as_type.loc145_44.1 => constants.%.Self.as_type.604 +// CHECK:STDOUT: %MulWith.assoc_type => constants.%MulWith.assoc_type.cbc +// CHECK:STDOUT: %assoc0 => constants.%assoc0.c58 +// CHECK:STDOUT: %MulWith.lookup_impl_witness.loc145 => constants.%MulWith.lookup_impl_witness.a30 +// CHECK:STDOUT: %impl.elem0.loc145_44.1 => constants.%impl.elem0.3f6 +// CHECK:STDOUT: %Result.as_type.loc145_54.1 => constants.%Int64 +// CHECK:STDOUT: %facet_type.loc145_38 => constants.%facet_type.9d2 +// CHECK:STDOUT: %T.loc145_4.1 => constants.%facet_value.823 +// CHECK:STDOUT: %pattern_type.loc145 => constants.%pattern_type.eb5 +// CHECK:STDOUT: %pattern_type.loc146_16 => constants.%pattern_type.f42 +// CHECK:STDOUT: %T.as_type.loc146_29.1 => constants.%Int32 +// CHECK:STDOUT: %pattern_type.loc146_27 => constants.%pattern_type.9c9 +// CHECK:STDOUT: %pattern_type.loc146_33 => constants.%pattern_type.f42 +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc146_16 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc146_27 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc146_33 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc148 => constants.%complete_type.b09 +// CHECK:STDOUT: %assoc1 => constants.%assoc1.279 +// CHECK:STDOUT: %MulWith.lookup_impl_witness.loc148 => constants.%custom_witness.f53 +// CHECK:STDOUT: %MulWith.facet => constants.%MulWith.facet.0d5 +// CHECK:STDOUT: %MulWith.WithSelf.Op.type => constants.%MulWith.WithSelf.Op.type.97b +// CHECK:STDOUT: %.loc148_5.4 => constants.%.07b +// CHECK:STDOUT: %impl.elem1.loc148_5.2 => constants.%Op.8fb557.8 +// CHECK:STDOUT: %specific_impl_fn.loc148_5.3 => constants.%Op.8fb557.8 +// CHECK:STDOUT: %Destroy.WithSelf.Op.type => constants.%Destroy.WithSelf.Op.type.f16 +// CHECK:STDOUT: %.loc148_5.5 => constants.%.db1 +// CHECK:STDOUT: %Destroy.lookup_impl_witness => constants.%custom_witness.d7e +// CHECK:STDOUT: %impl.elem0.loc148_5.2 => constants.%Int64.Op.b941da.1 +// CHECK:STDOUT: %specific_impl_fn.loc148_5.4 => constants.%Int64.Op.b941da.1 +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @DivWith.loc157(constants.%Destroy.facet.b0a, constants.%Destroy.facet.b0a, constants.%facet_value.cba) { +// CHECK:STDOUT: %Result.loc154_9.1 => constants.%Destroy.facet.b0a +// CHECK:STDOUT: %U.loc155_4.1 => constants.%Destroy.facet.b0a +// CHECK:STDOUT: %U.as_type.loc156_36.1 => constants.%Int64 +// CHECK:STDOUT: %DivWith.type.loc156_36.1 => constants.%DivWith.type.70f +// CHECK:STDOUT: %facet_type.loc156_20 => constants.%facet_type.f02 +// CHECK:STDOUT: %.Self.1 => constants.%.Self.ad5 +// CHECK:STDOUT: %require_complete.loc156 => constants.%complete_type.e31 +// CHECK:STDOUT: %.Self.as_type.loc156_44.1 => constants.%.Self.as_type.245 +// CHECK:STDOUT: %DivWith.assoc_type => constants.%DivWith.assoc_type.03e +// CHECK:STDOUT: %assoc0 => constants.%assoc0.a25 +// CHECK:STDOUT: %DivWith.lookup_impl_witness.loc156 => constants.%DivWith.lookup_impl_witness.cc2 +// CHECK:STDOUT: %impl.elem0.loc156_44.1 => constants.%impl.elem0.2d2 +// CHECK:STDOUT: %Result.as_type.loc156_54.1 => constants.%Int64 +// CHECK:STDOUT: %facet_type.loc156_38 => constants.%facet_type.6aa +// CHECK:STDOUT: %T.loc156_4.1 => constants.%facet_value.cba +// CHECK:STDOUT: %pattern_type.loc156 => constants.%pattern_type.c59 +// CHECK:STDOUT: %pattern_type.loc157_16 => constants.%pattern_type.f42 +// CHECK:STDOUT: %T.as_type.loc157_29.1 => constants.%Int32 +// CHECK:STDOUT: %pattern_type.loc157_27 => constants.%pattern_type.9c9 +// CHECK:STDOUT: %pattern_type.loc157_33 => constants.%pattern_type.f42 +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc157_16 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc157_27 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc157_33 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc159 => constants.%complete_type.09b +// CHECK:STDOUT: %assoc1 => constants.%assoc1.f42 +// CHECK:STDOUT: %DivWith.lookup_impl_witness.loc159 => constants.%custom_witness.bca +// CHECK:STDOUT: %DivWith.facet => constants.%DivWith.facet.22c +// CHECK:STDOUT: %DivWith.WithSelf.Op.type => constants.%DivWith.WithSelf.Op.type.565 +// CHECK:STDOUT: %.loc159_5.4 => constants.%.b72 +// CHECK:STDOUT: %impl.elem1.loc159_5.2 => constants.%Op.8fb557.9 +// CHECK:STDOUT: %specific_impl_fn.loc159_5.3 => constants.%Op.8fb557.9 +// CHECK:STDOUT: %Destroy.WithSelf.Op.type => constants.%Destroy.WithSelf.Op.type.f16 +// CHECK:STDOUT: %.loc159_5.5 => constants.%.db1 +// CHECK:STDOUT: %Destroy.lookup_impl_witness => constants.%custom_witness.d7e +// CHECK:STDOUT: %impl.elem0.loc159_5.2 => constants.%Int64.Op.b941da.1 +// CHECK:STDOUT: %specific_impl_fn.loc159_5.4 => constants.%Int64.Op.b941da.1 +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @ModWith.loc168(constants.%Destroy.facet.b0a, constants.%Destroy.facet.b0a, constants.%facet_value.403) { +// CHECK:STDOUT: %Result.loc165_9.1 => constants.%Destroy.facet.b0a +// CHECK:STDOUT: %U.loc166_4.1 => constants.%Destroy.facet.b0a +// CHECK:STDOUT: %U.as_type.loc167_36.1 => constants.%Int64 +// CHECK:STDOUT: %ModWith.type.loc167_36.1 => constants.%ModWith.type.a92 +// CHECK:STDOUT: %facet_type.loc167_20 => constants.%facet_type.b13 +// CHECK:STDOUT: %.Self.1 => constants.%.Self.856 +// CHECK:STDOUT: %require_complete.loc167 => constants.%complete_type.780 +// CHECK:STDOUT: %.Self.as_type.loc167_44.1 => constants.%.Self.as_type.6bd +// CHECK:STDOUT: %ModWith.assoc_type => constants.%ModWith.assoc_type.f50 +// CHECK:STDOUT: %assoc0 => constants.%assoc0.c89 +// CHECK:STDOUT: %ModWith.lookup_impl_witness.loc167 => constants.%ModWith.lookup_impl_witness.81f +// CHECK:STDOUT: %impl.elem0.loc167_44.1 => constants.%impl.elem0.369 +// CHECK:STDOUT: %Result.as_type.loc167_54.1 => constants.%Int64 +// CHECK:STDOUT: %facet_type.loc167_38 => constants.%facet_type.41c +// CHECK:STDOUT: %T.loc167_4.1 => constants.%facet_value.403 +// CHECK:STDOUT: %pattern_type.loc167 => constants.%pattern_type.4ab +// CHECK:STDOUT: %pattern_type.loc168_16 => constants.%pattern_type.f42 +// CHECK:STDOUT: %T.as_type.loc168_29.1 => constants.%Int32 +// CHECK:STDOUT: %pattern_type.loc168_27 => constants.%pattern_type.9c9 +// CHECK:STDOUT: %pattern_type.loc168_33 => constants.%pattern_type.f42 +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc168_16 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc168_27 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc168_33 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc170 => constants.%complete_type.6fa +// CHECK:STDOUT: %assoc1 => constants.%assoc1.a80 +// CHECK:STDOUT: %ModWith.lookup_impl_witness.loc170 => constants.%custom_witness.1b0 +// CHECK:STDOUT: %ModWith.facet => constants.%ModWith.facet.570 +// CHECK:STDOUT: %ModWith.WithSelf.Op.type => constants.%ModWith.WithSelf.Op.type.2b2 +// CHECK:STDOUT: %.loc170_5.4 => constants.%.16c +// CHECK:STDOUT: %impl.elem1.loc170_5.2 => constants.%Op.8fb557.10 +// CHECK:STDOUT: %specific_impl_fn.loc170_5.3 => constants.%Op.8fb557.10 +// CHECK:STDOUT: %Destroy.WithSelf.Op.type => constants.%Destroy.WithSelf.Op.type.f16 +// CHECK:STDOUT: %.loc170_5.5 => constants.%.db1 +// CHECK:STDOUT: %Destroy.lookup_impl_witness => constants.%custom_witness.d7e +// CHECK:STDOUT: %impl.elem0.loc170_5.2 => constants.%Int64.Op.b941da.1 +// CHECK:STDOUT: %specific_impl_fn.loc170_5.4 => constants.%Int64.Op.b941da.1 +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @AddWith.loc124(constants.%Destroy.facet.b0a, constants.%Destroy.facet.c06, constants.%facet_value.8dc) { +// CHECK:STDOUT: %Result.loc121_9.1 => constants.%Destroy.facet.b0a +// CHECK:STDOUT: %U.loc122_4.1 => constants.%Destroy.facet.c06 +// CHECK:STDOUT: %U.as_type.loc123_36.1 => constants.%Int32 +// CHECK:STDOUT: %AddWith.type.loc123_36.1 => constants.%AddWith.type.e9e +// CHECK:STDOUT: %facet_type.loc123_20 => constants.%facet_type.4a7 +// CHECK:STDOUT: %.Self.1 => constants.%.Self.3d9 +// CHECK:STDOUT: %require_complete.loc123 => constants.%complete_type.0d9 +// CHECK:STDOUT: %.Self.as_type.loc123_44.1 => constants.%.Self.as_type.7ba +// CHECK:STDOUT: %AddWith.assoc_type => constants.%AddWith.assoc_type.29a +// CHECK:STDOUT: %assoc0 => constants.%assoc0.701 +// CHECK:STDOUT: %AddWith.lookup_impl_witness.loc123 => constants.%AddWith.lookup_impl_witness.632 +// CHECK:STDOUT: %impl.elem0.loc123_44.1 => constants.%impl.elem0.cee +// CHECK:STDOUT: %Result.as_type.loc123_54.1 => constants.%Int64 +// CHECK:STDOUT: %facet_type.loc123_38 => constants.%facet_type.a53 +// CHECK:STDOUT: %T.loc123_4.1 => constants.%facet_value.8dc +// CHECK:STDOUT: %pattern_type.loc123 => constants.%pattern_type.7f1 +// CHECK:STDOUT: %pattern_type.loc124_16 => constants.%pattern_type.f42 +// CHECK:STDOUT: %T.as_type.loc124_29.1 => constants.%Int64 +// CHECK:STDOUT: %pattern_type.loc124_27 => constants.%pattern_type.f42 +// CHECK:STDOUT: %pattern_type.loc124_33 => constants.%pattern_type.9c9 +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc124_16 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc124_27 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc124_33 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc126 => constants.%complete_type.03d +// CHECK:STDOUT: %assoc1 => constants.%assoc1.38b +// CHECK:STDOUT: %AddWith.lookup_impl_witness.loc126 => constants.%custom_witness.fc1 +// CHECK:STDOUT: %AddWith.facet => constants.%AddWith.facet.66c +// CHECK:STDOUT: %AddWith.WithSelf.Op.type => constants.%AddWith.WithSelf.Op.type.e16 +// CHECK:STDOUT: %.loc126_5.4 => constants.%.41b +// CHECK:STDOUT: %impl.elem1.loc126_5.2 => constants.%Op.8fb557.11 +// CHECK:STDOUT: %specific_impl_fn.loc126_5.3 => constants.%Op.8fb557.11 +// CHECK:STDOUT: %Destroy.WithSelf.Op.type => constants.%Destroy.WithSelf.Op.type.f16 +// CHECK:STDOUT: %.loc126_5.5 => constants.%.db1 +// CHECK:STDOUT: %Destroy.lookup_impl_witness => constants.%custom_witness.d7e +// CHECK:STDOUT: %impl.elem0.loc126_5.2 => constants.%Int64.Op.b941da.1 +// CHECK:STDOUT: %specific_impl_fn.loc126_5.4 => constants.%Int64.Op.b941da.1 +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @SubWith.loc135(constants.%Destroy.facet.b0a, constants.%Destroy.facet.c06, constants.%facet_value.c40) { +// CHECK:STDOUT: %Result.loc132_9.1 => constants.%Destroy.facet.b0a +// CHECK:STDOUT: %U.loc133_4.1 => constants.%Destroy.facet.c06 +// CHECK:STDOUT: %U.as_type.loc134_36.1 => constants.%Int32 +// CHECK:STDOUT: %SubWith.type.loc134_36.1 => constants.%SubWith.type.84c +// CHECK:STDOUT: %facet_type.loc134_20 => constants.%facet_type.e7a +// CHECK:STDOUT: %.Self.1 => constants.%.Self.384 +// CHECK:STDOUT: %require_complete.loc134 => constants.%complete_type.a34 +// CHECK:STDOUT: %.Self.as_type.loc134_44.1 => constants.%.Self.as_type.45d +// CHECK:STDOUT: %SubWith.assoc_type => constants.%SubWith.assoc_type.0f9 +// CHECK:STDOUT: %assoc0 => constants.%assoc0.1e9 +// CHECK:STDOUT: %SubWith.lookup_impl_witness.loc134 => constants.%SubWith.lookup_impl_witness.b61 +// CHECK:STDOUT: %impl.elem0.loc134_44.1 => constants.%impl.elem0.edd +// CHECK:STDOUT: %Result.as_type.loc134_54.1 => constants.%Int64 +// CHECK:STDOUT: %facet_type.loc134_38 => constants.%facet_type.364 +// CHECK:STDOUT: %T.loc134_4.1 => constants.%facet_value.c40 +// CHECK:STDOUT: %pattern_type.loc134 => constants.%pattern_type.c45 +// CHECK:STDOUT: %pattern_type.loc135_16 => constants.%pattern_type.f42 +// CHECK:STDOUT: %T.as_type.loc135_29.1 => constants.%Int64 +// CHECK:STDOUT: %pattern_type.loc135_27 => constants.%pattern_type.f42 +// CHECK:STDOUT: %pattern_type.loc135_33 => constants.%pattern_type.9c9 +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc135_16 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc135_27 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc135_33 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc137 => constants.%complete_type.9bf +// CHECK:STDOUT: %assoc1 => constants.%assoc1.714 +// CHECK:STDOUT: %SubWith.lookup_impl_witness.loc137 => constants.%custom_witness.31e +// CHECK:STDOUT: %SubWith.facet => constants.%SubWith.facet.494 +// CHECK:STDOUT: %SubWith.WithSelf.Op.type => constants.%SubWith.WithSelf.Op.type.0e3 +// CHECK:STDOUT: %.loc137_5.4 => constants.%.936 +// CHECK:STDOUT: %impl.elem1.loc137_5.2 => constants.%Op.8fb557.12 +// CHECK:STDOUT: %specific_impl_fn.loc137_5.3 => constants.%Op.8fb557.12 +// CHECK:STDOUT: %Destroy.WithSelf.Op.type => constants.%Destroy.WithSelf.Op.type.f16 +// CHECK:STDOUT: %.loc137_5.5 => constants.%.db1 +// CHECK:STDOUT: %Destroy.lookup_impl_witness => constants.%custom_witness.d7e +// CHECK:STDOUT: %impl.elem0.loc137_5.2 => constants.%Int64.Op.b941da.1 +// CHECK:STDOUT: %specific_impl_fn.loc137_5.4 => constants.%Int64.Op.b941da.1 +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @MulWith.loc146(constants.%Destroy.facet.b0a, constants.%Destroy.facet.c06, constants.%facet_value.9d5) { +// CHECK:STDOUT: %Result.loc143_9.1 => constants.%Destroy.facet.b0a +// CHECK:STDOUT: %U.loc144_4.1 => constants.%Destroy.facet.c06 +// CHECK:STDOUT: %U.as_type.loc145_36.1 => constants.%Int32 +// CHECK:STDOUT: %MulWith.type.loc145_36.1 => constants.%MulWith.type.d1b +// CHECK:STDOUT: %facet_type.loc145_20 => constants.%facet_type.2e6 +// CHECK:STDOUT: %.Self.1 => constants.%.Self.84b +// CHECK:STDOUT: %require_complete.loc145 => constants.%complete_type.043 +// CHECK:STDOUT: %.Self.as_type.loc145_44.1 => constants.%.Self.as_type.d0cd +// CHECK:STDOUT: %MulWith.assoc_type => constants.%MulWith.assoc_type.8c6 +// CHECK:STDOUT: %assoc0 => constants.%assoc0.a8f +// CHECK:STDOUT: %MulWith.lookup_impl_witness.loc145 => constants.%MulWith.lookup_impl_witness.539 +// CHECK:STDOUT: %impl.elem0.loc145_44.1 => constants.%impl.elem0.e63 +// CHECK:STDOUT: %Result.as_type.loc145_54.1 => constants.%Int64 +// CHECK:STDOUT: %facet_type.loc145_38 => constants.%facet_type.d7d +// CHECK:STDOUT: %T.loc145_4.1 => constants.%facet_value.9d5 +// CHECK:STDOUT: %pattern_type.loc145 => constants.%pattern_type.450 +// CHECK:STDOUT: %pattern_type.loc146_16 => constants.%pattern_type.f42 +// CHECK:STDOUT: %T.as_type.loc146_29.1 => constants.%Int64 +// CHECK:STDOUT: %pattern_type.loc146_27 => constants.%pattern_type.f42 +// CHECK:STDOUT: %pattern_type.loc146_33 => constants.%pattern_type.9c9 +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc146_16 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc146_27 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc146_33 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc148 => constants.%complete_type.a1f +// CHECK:STDOUT: %assoc1 => constants.%assoc1.6bc +// CHECK:STDOUT: %MulWith.lookup_impl_witness.loc148 => constants.%custom_witness.709 +// CHECK:STDOUT: %MulWith.facet => constants.%MulWith.facet.dab +// CHECK:STDOUT: %MulWith.WithSelf.Op.type => constants.%MulWith.WithSelf.Op.type.549 +// CHECK:STDOUT: %.loc148_5.4 => constants.%.dc0 +// CHECK:STDOUT: %impl.elem1.loc148_5.2 => constants.%Op.8fb557.13 +// CHECK:STDOUT: %specific_impl_fn.loc148_5.3 => constants.%Op.8fb557.13 +// CHECK:STDOUT: %Destroy.WithSelf.Op.type => constants.%Destroy.WithSelf.Op.type.f16 +// CHECK:STDOUT: %.loc148_5.5 => constants.%.db1 +// CHECK:STDOUT: %Destroy.lookup_impl_witness => constants.%custom_witness.d7e +// CHECK:STDOUT: %impl.elem0.loc148_5.2 => constants.%Int64.Op.b941da.1 +// CHECK:STDOUT: %specific_impl_fn.loc148_5.4 => constants.%Int64.Op.b941da.1 +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @DivWith.loc157(constants.%Destroy.facet.b0a, constants.%Destroy.facet.c06, constants.%facet_value.c21) { +// CHECK:STDOUT: %Result.loc154_9.1 => constants.%Destroy.facet.b0a +// CHECK:STDOUT: %U.loc155_4.1 => constants.%Destroy.facet.c06 +// CHECK:STDOUT: %U.as_type.loc156_36.1 => constants.%Int32 +// CHECK:STDOUT: %DivWith.type.loc156_36.1 => constants.%DivWith.type.26e +// CHECK:STDOUT: %facet_type.loc156_20 => constants.%facet_type.eb5 +// CHECK:STDOUT: %.Self.1 => constants.%.Self.203 +// CHECK:STDOUT: %require_complete.loc156 => constants.%complete_type.d76 +// CHECK:STDOUT: %.Self.as_type.loc156_44.1 => constants.%.Self.as_type.f8e +// CHECK:STDOUT: %DivWith.assoc_type => constants.%DivWith.assoc_type.109 +// CHECK:STDOUT: %assoc0 => constants.%assoc0.d76 +// CHECK:STDOUT: %DivWith.lookup_impl_witness.loc156 => constants.%DivWith.lookup_impl_witness.512 +// CHECK:STDOUT: %impl.elem0.loc156_44.1 => constants.%impl.elem0.232 +// CHECK:STDOUT: %Result.as_type.loc156_54.1 => constants.%Int64 +// CHECK:STDOUT: %facet_type.loc156_38 => constants.%facet_type.a9f +// CHECK:STDOUT: %T.loc156_4.1 => constants.%facet_value.c21 +// CHECK:STDOUT: %pattern_type.loc156 => constants.%pattern_type.0b0 +// CHECK:STDOUT: %pattern_type.loc157_16 => constants.%pattern_type.f42 +// CHECK:STDOUT: %T.as_type.loc157_29.1 => constants.%Int64 +// CHECK:STDOUT: %pattern_type.loc157_27 => constants.%pattern_type.f42 +// CHECK:STDOUT: %pattern_type.loc157_33 => constants.%pattern_type.9c9 +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc157_16 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc157_27 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc157_33 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc159 => constants.%complete_type.e49 +// CHECK:STDOUT: %assoc1 => constants.%assoc1.4a0 +// CHECK:STDOUT: %DivWith.lookup_impl_witness.loc159 => constants.%custom_witness.47b +// CHECK:STDOUT: %DivWith.facet => constants.%DivWith.facet.9ad +// CHECK:STDOUT: %DivWith.WithSelf.Op.type => constants.%DivWith.WithSelf.Op.type.596 +// CHECK:STDOUT: %.loc159_5.4 => constants.%.def +// CHECK:STDOUT: %impl.elem1.loc159_5.2 => constants.%Op.8fb557.14 +// CHECK:STDOUT: %specific_impl_fn.loc159_5.3 => constants.%Op.8fb557.14 +// CHECK:STDOUT: %Destroy.WithSelf.Op.type => constants.%Destroy.WithSelf.Op.type.f16 +// CHECK:STDOUT: %.loc159_5.5 => constants.%.db1 +// CHECK:STDOUT: %Destroy.lookup_impl_witness => constants.%custom_witness.d7e +// CHECK:STDOUT: %impl.elem0.loc159_5.2 => constants.%Int64.Op.b941da.1 +// CHECK:STDOUT: %specific_impl_fn.loc159_5.4 => constants.%Int64.Op.b941da.1 +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @ModWith.loc168(constants.%Destroy.facet.b0a, constants.%Destroy.facet.c06, constants.%facet_value.766) { +// CHECK:STDOUT: %Result.loc165_9.1 => constants.%Destroy.facet.b0a +// CHECK:STDOUT: %U.loc166_4.1 => constants.%Destroy.facet.c06 +// CHECK:STDOUT: %U.as_type.loc167_36.1 => constants.%Int32 +// CHECK:STDOUT: %ModWith.type.loc167_36.1 => constants.%ModWith.type.5c4 +// CHECK:STDOUT: %facet_type.loc167_20 => constants.%facet_type.1e6 +// CHECK:STDOUT: %.Self.1 => constants.%.Self.0c5 +// CHECK:STDOUT: %require_complete.loc167 => constants.%complete_type.1bb +// CHECK:STDOUT: %.Self.as_type.loc167_44.1 => constants.%.Self.as_type.ef1 +// CHECK:STDOUT: %ModWith.assoc_type => constants.%ModWith.assoc_type.1db +// CHECK:STDOUT: %assoc0 => constants.%assoc0.8e2 +// CHECK:STDOUT: %ModWith.lookup_impl_witness.loc167 => constants.%ModWith.lookup_impl_witness.9f7 +// CHECK:STDOUT: %impl.elem0.loc167_44.1 => constants.%impl.elem0.919 +// CHECK:STDOUT: %Result.as_type.loc167_54.1 => constants.%Int64 +// CHECK:STDOUT: %facet_type.loc167_38 => constants.%facet_type.f0f +// CHECK:STDOUT: %T.loc167_4.1 => constants.%facet_value.766 +// CHECK:STDOUT: %pattern_type.loc167 => constants.%pattern_type.bd2 +// CHECK:STDOUT: %pattern_type.loc168_16 => constants.%pattern_type.f42 +// CHECK:STDOUT: %T.as_type.loc168_29.1 => constants.%Int64 +// CHECK:STDOUT: %pattern_type.loc168_27 => constants.%pattern_type.f42 +// CHECK:STDOUT: %pattern_type.loc168_33 => constants.%pattern_type.9c9 +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc168_16 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc168_27 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc168_33 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc170 => constants.%complete_type.3ed +// CHECK:STDOUT: %assoc1 => constants.%assoc1.826 +// CHECK:STDOUT: %ModWith.lookup_impl_witness.loc170 => constants.%custom_witness.ad6 +// CHECK:STDOUT: %ModWith.facet => constants.%ModWith.facet.325 +// CHECK:STDOUT: %ModWith.WithSelf.Op.type => constants.%ModWith.WithSelf.Op.type.efe +// CHECK:STDOUT: %.loc170_5.4 => constants.%.ef4 +// CHECK:STDOUT: %impl.elem1.loc170_5.2 => constants.%Op.8fb557.15 +// CHECK:STDOUT: %specific_impl_fn.loc170_5.3 => constants.%Op.8fb557.15 +// CHECK:STDOUT: %Destroy.WithSelf.Op.type => constants.%Destroy.WithSelf.Op.type.f16 +// CHECK:STDOUT: %.loc170_5.5 => constants.%.db1 +// CHECK:STDOUT: %Destroy.lookup_impl_witness => constants.%custom_witness.d7e +// CHECK:STDOUT: %impl.elem0.loc170_5.2 => constants.%Int64.Op.b941da.1 +// CHECK:STDOUT: %specific_impl_fn.loc170_5.4 => constants.%Int64.Op.b941da.1 +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @AddAssignWith.loc225(constants.%U.67d, constants.%T.a00) { +// CHECK:STDOUT: %U.loc225_19.1 => constants.%U.67d +// CHECK:STDOUT: %AddAssignWith.type.loc225_52.1 => constants.%AddAssignWith.type.4d3b38.2 +// CHECK:STDOUT: %T.loc225_29.1 => constants.%T.a00 +// CHECK:STDOUT: %pattern_type.loc225_29 => constants.%pattern_type.092 +// CHECK:STDOUT: %T.as_type.loc225_62.1 => constants.%T.as_type.191 +// CHECK:STDOUT: %pattern_type.loc225_60 => constants.%pattern_type.03496c.2 +// CHECK:STDOUT: %pattern_type.loc225_66 => constants.%pattern_type.51d1c4.4 +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @SubAssignWith.loc231(constants.%U.67d, constants.%T.1de) { +// CHECK:STDOUT: %U.loc231_19.1 => constants.%U.67d +// CHECK:STDOUT: %SubAssignWith.type.loc231_52.1 => constants.%SubAssignWith.type.969cbb.2 +// CHECK:STDOUT: %T.loc231_29.1 => constants.%T.1de +// CHECK:STDOUT: %pattern_type.loc231_29 => constants.%pattern_type.abb +// CHECK:STDOUT: %T.as_type.loc231_62.1 => constants.%T.as_type.b8f +// CHECK:STDOUT: %pattern_type.loc231_60 => constants.%pattern_type.2f1979.2 +// CHECK:STDOUT: %pattern_type.loc231_66 => constants.%pattern_type.51d1c4.4 +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @MulAssignWith.loc237(constants.%U.67d, constants.%T.059) { +// CHECK:STDOUT: %U.loc237_19.1 => constants.%U.67d +// CHECK:STDOUT: %MulAssignWith.type.loc237_52.1 => constants.%MulAssignWith.type.ccc9e0.2 +// CHECK:STDOUT: %T.loc237_29.1 => constants.%T.059 +// CHECK:STDOUT: %pattern_type.loc237_29 => constants.%pattern_type.043 +// CHECK:STDOUT: %T.as_type.loc237_62.1 => constants.%T.as_type.6a0 +// CHECK:STDOUT: %pattern_type.loc237_60 => constants.%pattern_type.587662.2 +// CHECK:STDOUT: %pattern_type.loc237_66 => constants.%pattern_type.51d1c4.4 +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @DivAssignWith.loc243(constants.%U.67d, constants.%T.aa8) { +// CHECK:STDOUT: %U.loc243_19.1 => constants.%U.67d +// CHECK:STDOUT: %DivAssignWith.type.loc243_52.1 => constants.%DivAssignWith.type.be08dd.2 +// CHECK:STDOUT: %T.loc243_29.1 => constants.%T.aa8 +// CHECK:STDOUT: %pattern_type.loc243_29 => constants.%pattern_type.8e3 +// CHECK:STDOUT: %T.as_type.loc243_62.1 => constants.%T.as_type.efd +// CHECK:STDOUT: %pattern_type.loc243_60 => constants.%pattern_type.593823.2 +// CHECK:STDOUT: %pattern_type.loc243_66 => constants.%pattern_type.51d1c4.4 +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @ModAssignWith.loc249(constants.%U.67d, constants.%T.d35) { +// CHECK:STDOUT: %U.loc249_19.1 => constants.%U.67d +// CHECK:STDOUT: %ModAssignWith.type.loc249_52.1 => constants.%ModAssignWith.type.c65b77.2 +// CHECK:STDOUT: %T.loc249_29.1 => constants.%T.d35 +// CHECK:STDOUT: %pattern_type.loc249_29 => constants.%pattern_type.26a +// CHECK:STDOUT: %T.as_type.loc249_62.1 => constants.%T.as_type.4c2 +// CHECK:STDOUT: %pattern_type.loc249_60 => constants.%pattern_type.6ec6ce.2 +// CHECK:STDOUT: %pattern_type.loc249_66 => constants.%pattern_type.51d1c4.4 +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @AddAssignWith.loc225(constants.%i16, constants.%AddAssignWith.facet.23f) { +// CHECK:STDOUT: %U.loc225_19.1 => constants.%i16 +// CHECK:STDOUT: %AddAssignWith.type.loc225_52.1 => constants.%AddAssignWith.type.704 +// CHECK:STDOUT: %T.loc225_29.1 => constants.%AddAssignWith.facet.23f +// CHECK:STDOUT: %pattern_type.loc225_29 => constants.%pattern_type.139 +// CHECK:STDOUT: %T.as_type.loc225_62.1 => constants.%Int16 +// CHECK:STDOUT: %pattern_type.loc225_60 => constants.%pattern_type.9a4 +// CHECK:STDOUT: %pattern_type.loc225_66 => constants.%pattern_type.2f8 +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc225_55 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc225_66 => constants.%complete_type.2da +// CHECK:STDOUT: %require_complete.loc227 => constants.%complete_type.901 +// CHECK:STDOUT: %AddAssignWith.assoc_type => constants.%AddAssignWith.assoc_type.23b +// CHECK:STDOUT: %assoc0 => constants.%assoc0.08d +// CHECK:STDOUT: %AddAssignWith.WithSelf.Op.type => constants.%AddAssignWith.WithSelf.Op.type.2c7 +// CHECK:STDOUT: %.loc227_5.2 => constants.%.122 +// CHECK:STDOUT: %AddAssignWith.lookup_impl_witness => constants.%custom_witness.6da +// CHECK:STDOUT: %impl.elem0.loc227_5.2 => constants.%Int16.Op.c3e49c.13 +// CHECK:STDOUT: %specific_impl_fn.loc227_5.2 => constants.%Int16.Op.c3e49c.13 +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @SubAssignWith.loc231(constants.%i16, constants.%SubAssignWith.facet.3e7) { +// CHECK:STDOUT: %U.loc231_19.1 => constants.%i16 +// CHECK:STDOUT: %SubAssignWith.type.loc231_52.1 => constants.%SubAssignWith.type.fed +// CHECK:STDOUT: %T.loc231_29.1 => constants.%SubAssignWith.facet.3e7 +// CHECK:STDOUT: %pattern_type.loc231_29 => constants.%pattern_type.912 +// CHECK:STDOUT: %T.as_type.loc231_62.1 => constants.%Int16 +// CHECK:STDOUT: %pattern_type.loc231_60 => constants.%pattern_type.9a4 +// CHECK:STDOUT: %pattern_type.loc231_66 => constants.%pattern_type.2f8 +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc231_55 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc231_66 => constants.%complete_type.2da +// CHECK:STDOUT: %require_complete.loc233 => constants.%complete_type.f45 +// CHECK:STDOUT: %SubAssignWith.assoc_type => constants.%SubAssignWith.assoc_type.81a +// CHECK:STDOUT: %assoc0 => constants.%assoc0.0a4 +// CHECK:STDOUT: %SubAssignWith.WithSelf.Op.type => constants.%SubAssignWith.WithSelf.Op.type.71a +// CHECK:STDOUT: %.loc233_5.2 => constants.%.697 +// CHECK:STDOUT: %SubAssignWith.lookup_impl_witness => constants.%custom_witness.509 +// CHECK:STDOUT: %impl.elem0.loc233_5.2 => constants.%Int16.Op.c3e49c.14 +// CHECK:STDOUT: %specific_impl_fn.loc233_5.2 => constants.%Int16.Op.c3e49c.14 +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @MulAssignWith.loc237(constants.%i16, constants.%MulAssignWith.facet.78f) { +// CHECK:STDOUT: %U.loc237_19.1 => constants.%i16 +// CHECK:STDOUT: %MulAssignWith.type.loc237_52.1 => constants.%MulAssignWith.type.6c0 +// CHECK:STDOUT: %T.loc237_29.1 => constants.%MulAssignWith.facet.78f +// CHECK:STDOUT: %pattern_type.loc237_29 => constants.%pattern_type.578 +// CHECK:STDOUT: %T.as_type.loc237_62.1 => constants.%Int16 +// CHECK:STDOUT: %pattern_type.loc237_60 => constants.%pattern_type.9a4 +// CHECK:STDOUT: %pattern_type.loc237_66 => constants.%pattern_type.2f8 +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc237_55 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc237_66 => constants.%complete_type.2da +// CHECK:STDOUT: %require_complete.loc239 => constants.%complete_type.a71 +// CHECK:STDOUT: %MulAssignWith.assoc_type => constants.%MulAssignWith.assoc_type.af2 +// CHECK:STDOUT: %assoc0 => constants.%assoc0.e50 +// CHECK:STDOUT: %MulAssignWith.WithSelf.Op.type => constants.%MulAssignWith.WithSelf.Op.type.dca +// CHECK:STDOUT: %.loc239_5.2 => constants.%.bb2 +// CHECK:STDOUT: %MulAssignWith.lookup_impl_witness => constants.%custom_witness.a1f +// CHECK:STDOUT: %impl.elem0.loc239_5.2 => constants.%Int16.Op.c3e49c.15 +// CHECK:STDOUT: %specific_impl_fn.loc239_5.2 => constants.%Int16.Op.c3e49c.15 +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @DivAssignWith.loc243(constants.%i16, constants.%DivAssignWith.facet.b0d) { +// CHECK:STDOUT: %U.loc243_19.1 => constants.%i16 +// CHECK:STDOUT: %DivAssignWith.type.loc243_52.1 => constants.%DivAssignWith.type.527 +// CHECK:STDOUT: %T.loc243_29.1 => constants.%DivAssignWith.facet.b0d +// CHECK:STDOUT: %pattern_type.loc243_29 => constants.%pattern_type.5f7 +// CHECK:STDOUT: %T.as_type.loc243_62.1 => constants.%Int16 +// CHECK:STDOUT: %pattern_type.loc243_60 => constants.%pattern_type.9a4 +// CHECK:STDOUT: %pattern_type.loc243_66 => constants.%pattern_type.2f8 +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc243_55 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc243_66 => constants.%complete_type.2da +// CHECK:STDOUT: %require_complete.loc245 => constants.%complete_type.620 +// CHECK:STDOUT: %DivAssignWith.assoc_type => constants.%DivAssignWith.assoc_type.5b8 +// CHECK:STDOUT: %assoc0 => constants.%assoc0.ced +// CHECK:STDOUT: %DivAssignWith.WithSelf.Op.type => constants.%DivAssignWith.WithSelf.Op.type.76f +// CHECK:STDOUT: %.loc245_5.2 => constants.%.32e +// CHECK:STDOUT: %DivAssignWith.lookup_impl_witness => constants.%custom_witness.deb +// CHECK:STDOUT: %impl.elem0.loc245_5.2 => constants.%Int16.Op.c3e49c.16 +// CHECK:STDOUT: %specific_impl_fn.loc245_5.2 => constants.%Int16.Op.c3e49c.16 +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @ModAssignWith.loc249(constants.%i16, constants.%ModAssignWith.facet.ada) { +// CHECK:STDOUT: %U.loc249_19.1 => constants.%i16 +// CHECK:STDOUT: %ModAssignWith.type.loc249_52.1 => constants.%ModAssignWith.type.ead +// CHECK:STDOUT: %T.loc249_29.1 => constants.%ModAssignWith.facet.ada +// CHECK:STDOUT: %pattern_type.loc249_29 => constants.%pattern_type.bf6 +// CHECK:STDOUT: %T.as_type.loc249_62.1 => constants.%Int16 +// CHECK:STDOUT: %pattern_type.loc249_60 => constants.%pattern_type.9a4 +// CHECK:STDOUT: %pattern_type.loc249_66 => constants.%pattern_type.2f8 +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc249_55 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc249_66 => constants.%complete_type.2da +// CHECK:STDOUT: %require_complete.loc251 => constants.%complete_type.422 +// CHECK:STDOUT: %ModAssignWith.assoc_type => constants.%ModAssignWith.assoc_type.556 +// CHECK:STDOUT: %assoc0 => constants.%assoc0.b4c +// CHECK:STDOUT: %ModAssignWith.WithSelf.Op.type => constants.%ModAssignWith.WithSelf.Op.type.bea +// CHECK:STDOUT: %.loc251_5.2 => constants.%.51a +// CHECK:STDOUT: %ModAssignWith.lookup_impl_witness => constants.%custom_witness.c26 +// CHECK:STDOUT: %impl.elem0.loc251_5.2 => constants.%Int16.Op.c3e49c.17 +// CHECK:STDOUT: %specific_impl_fn.loc251_5.2 => constants.%Int16.Op.c3e49c.17 +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @AddAssignWith.loc225(constants.%Int32, constants.%AddAssignWith.facet.d85) { +// CHECK:STDOUT: %U.loc225_19.1 => constants.%Int32 +// CHECK:STDOUT: %AddAssignWith.type.loc225_52.1 => constants.%AddAssignWith.type.a71 +// CHECK:STDOUT: %T.loc225_29.1 => constants.%AddAssignWith.facet.d85 +// CHECK:STDOUT: %pattern_type.loc225_29 => constants.%pattern_type.736 +// CHECK:STDOUT: %T.as_type.loc225_62.1 => constants.%Int32 +// CHECK:STDOUT: %pattern_type.loc225_60 => constants.%pattern_type.9c9 +// CHECK:STDOUT: %pattern_type.loc225_66 => constants.%pattern_type.9c9 +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc225_55 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc225_66 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc227 => constants.%complete_type.2ec +// CHECK:STDOUT: %AddAssignWith.assoc_type => constants.%AddAssignWith.assoc_type.b4b +// CHECK:STDOUT: %assoc0 => constants.%assoc0.e09 +// CHECK:STDOUT: %AddAssignWith.WithSelf.Op.type => constants.%AddAssignWith.WithSelf.Op.type.181 +// CHECK:STDOUT: %.loc227_5.2 => constants.%.e44 +// CHECK:STDOUT: %AddAssignWith.lookup_impl_witness => constants.%custom_witness.c02 +// CHECK:STDOUT: %impl.elem0.loc227_5.2 => constants.%Int32.Op.6afff1.12 +// CHECK:STDOUT: %specific_impl_fn.loc227_5.2 => constants.%Int32.Op.6afff1.12 +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @SubAssignWith.loc231(constants.%Int32, constants.%SubAssignWith.facet.187) { +// CHECK:STDOUT: %U.loc231_19.1 => constants.%Int32 +// CHECK:STDOUT: %SubAssignWith.type.loc231_52.1 => constants.%SubAssignWith.type.35f +// CHECK:STDOUT: %T.loc231_29.1 => constants.%SubAssignWith.facet.187 +// CHECK:STDOUT: %pattern_type.loc231_29 => constants.%pattern_type.870 +// CHECK:STDOUT: %T.as_type.loc231_62.1 => constants.%Int32 +// CHECK:STDOUT: %pattern_type.loc231_60 => constants.%pattern_type.9c9 +// CHECK:STDOUT: %pattern_type.loc231_66 => constants.%pattern_type.9c9 +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc231_55 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc231_66 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc233 => constants.%complete_type.1ca +// CHECK:STDOUT: %SubAssignWith.assoc_type => constants.%SubAssignWith.assoc_type.867 +// CHECK:STDOUT: %assoc0 => constants.%assoc0.aa5 +// CHECK:STDOUT: %SubAssignWith.WithSelf.Op.type => constants.%SubAssignWith.WithSelf.Op.type.e51 +// CHECK:STDOUT: %.loc233_5.2 => constants.%.34b +// CHECK:STDOUT: %SubAssignWith.lookup_impl_witness => constants.%custom_witness.062 +// CHECK:STDOUT: %impl.elem0.loc233_5.2 => constants.%Int32.Op.6afff1.14 +// CHECK:STDOUT: %specific_impl_fn.loc233_5.2 => constants.%Int32.Op.6afff1.14 +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @MulAssignWith.loc237(constants.%Int32, constants.%MulAssignWith.facet.775) { +// CHECK:STDOUT: %U.loc237_19.1 => constants.%Int32 +// CHECK:STDOUT: %MulAssignWith.type.loc237_52.1 => constants.%MulAssignWith.type.dd2 +// CHECK:STDOUT: %T.loc237_29.1 => constants.%MulAssignWith.facet.775 +// CHECK:STDOUT: %pattern_type.loc237_29 => constants.%pattern_type.e94 +// CHECK:STDOUT: %T.as_type.loc237_62.1 => constants.%Int32 +// CHECK:STDOUT: %pattern_type.loc237_60 => constants.%pattern_type.9c9 +// CHECK:STDOUT: %pattern_type.loc237_66 => constants.%pattern_type.9c9 +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc237_55 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc237_66 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc239 => constants.%complete_type.a19 +// CHECK:STDOUT: %MulAssignWith.assoc_type => constants.%MulAssignWith.assoc_type.5c3 +// CHECK:STDOUT: %assoc0 => constants.%assoc0.6d0 +// CHECK:STDOUT: %MulAssignWith.WithSelf.Op.type => constants.%MulAssignWith.WithSelf.Op.type.89d +// CHECK:STDOUT: %.loc239_5.2 => constants.%.263 +// CHECK:STDOUT: %MulAssignWith.lookup_impl_witness => constants.%custom_witness.03af +// CHECK:STDOUT: %impl.elem0.loc239_5.2 => constants.%Int32.Op.6afff1.15 +// CHECK:STDOUT: %specific_impl_fn.loc239_5.2 => constants.%Int32.Op.6afff1.15 +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @DivAssignWith.loc243(constants.%Int32, constants.%DivAssignWith.facet.f5b) { +// CHECK:STDOUT: %U.loc243_19.1 => constants.%Int32 +// CHECK:STDOUT: %DivAssignWith.type.loc243_52.1 => constants.%DivAssignWith.type.a38 +// CHECK:STDOUT: %T.loc243_29.1 => constants.%DivAssignWith.facet.f5b +// CHECK:STDOUT: %pattern_type.loc243_29 => constants.%pattern_type.689 +// CHECK:STDOUT: %T.as_type.loc243_62.1 => constants.%Int32 +// CHECK:STDOUT: %pattern_type.loc243_60 => constants.%pattern_type.9c9 +// CHECK:STDOUT: %pattern_type.loc243_66 => constants.%pattern_type.9c9 +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc243_55 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc243_66 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc245 => constants.%complete_type.136 +// CHECK:STDOUT: %DivAssignWith.assoc_type => constants.%DivAssignWith.assoc_type.86d +// CHECK:STDOUT: %assoc0 => constants.%assoc0.b6e +// CHECK:STDOUT: %DivAssignWith.WithSelf.Op.type => constants.%DivAssignWith.WithSelf.Op.type.593 +// CHECK:STDOUT: %.loc245_5.2 => constants.%.c99 +// CHECK:STDOUT: %DivAssignWith.lookup_impl_witness => constants.%custom_witness.be6 +// CHECK:STDOUT: %impl.elem0.loc245_5.2 => constants.%Int32.Op.6afff1.16 +// CHECK:STDOUT: %specific_impl_fn.loc245_5.2 => constants.%Int32.Op.6afff1.16 +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @ModAssignWith.loc249(constants.%Int32, constants.%ModAssignWith.facet.b82) { +// CHECK:STDOUT: %U.loc249_19.1 => constants.%Int32 +// CHECK:STDOUT: %ModAssignWith.type.loc249_52.1 => constants.%ModAssignWith.type.36f +// CHECK:STDOUT: %T.loc249_29.1 => constants.%ModAssignWith.facet.b82 +// CHECK:STDOUT: %pattern_type.loc249_29 => constants.%pattern_type.ebe +// CHECK:STDOUT: %T.as_type.loc249_62.1 => constants.%Int32 +// CHECK:STDOUT: %pattern_type.loc249_60 => constants.%pattern_type.9c9 +// CHECK:STDOUT: %pattern_type.loc249_66 => constants.%pattern_type.9c9 +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc249_55 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc249_66 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc251 => constants.%complete_type.ca8 +// CHECK:STDOUT: %ModAssignWith.assoc_type => constants.%ModAssignWith.assoc_type.1a5 +// CHECK:STDOUT: %assoc0 => constants.%assoc0.609 +// CHECK:STDOUT: %ModAssignWith.WithSelf.Op.type => constants.%ModAssignWith.WithSelf.Op.type.f83 +// CHECK:STDOUT: %.loc251_5.2 => constants.%.146 +// CHECK:STDOUT: %ModAssignWith.lookup_impl_witness => constants.%custom_witness.203 +// CHECK:STDOUT: %impl.elem0.loc251_5.2 => constants.%Int32.Op.6afff1.17 +// CHECK:STDOUT: %specific_impl_fn.loc251_5.2 => constants.%Int32.Op.6afff1.17 +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @AddAssignWith.loc225(constants.%Int32, constants.%AddAssignWith.facet.b70) { +// CHECK:STDOUT: %U.loc225_19.1 => constants.%Int32 +// CHECK:STDOUT: %AddAssignWith.type.loc225_52.1 => constants.%AddAssignWith.type.a71 +// CHECK:STDOUT: %T.loc225_29.1 => constants.%AddAssignWith.facet.b70 +// CHECK:STDOUT: %pattern_type.loc225_29 => constants.%pattern_type.736 +// CHECK:STDOUT: %T.as_type.loc225_62.1 => constants.%Int64 +// CHECK:STDOUT: %pattern_type.loc225_60 => constants.%pattern_type.f42 +// CHECK:STDOUT: %pattern_type.loc225_66 => constants.%pattern_type.9c9 +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc225_55 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc225_66 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc227 => constants.%complete_type.2ec +// CHECK:STDOUT: %AddAssignWith.assoc_type => constants.%AddAssignWith.assoc_type.b4b +// CHECK:STDOUT: %assoc0 => constants.%assoc0.e09 +// CHECK:STDOUT: %AddAssignWith.WithSelf.Op.type => constants.%AddAssignWith.WithSelf.Op.type.750 +// CHECK:STDOUT: %.loc227_5.2 => constants.%.5d8 +// CHECK:STDOUT: %AddAssignWith.lookup_impl_witness => constants.%custom_witness.3a4 +// CHECK:STDOUT: %impl.elem0.loc227_5.2 => constants.%Int64.Op.b941da.2 +// CHECK:STDOUT: %specific_impl_fn.loc227_5.2 => constants.%Int64.Op.b941da.2 +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @SubAssignWith.loc231(constants.%Int32, constants.%SubAssignWith.facet.bd0) { +// CHECK:STDOUT: %U.loc231_19.1 => constants.%Int32 +// CHECK:STDOUT: %SubAssignWith.type.loc231_52.1 => constants.%SubAssignWith.type.35f +// CHECK:STDOUT: %T.loc231_29.1 => constants.%SubAssignWith.facet.bd0 +// CHECK:STDOUT: %pattern_type.loc231_29 => constants.%pattern_type.870 +// CHECK:STDOUT: %T.as_type.loc231_62.1 => constants.%Int64 +// CHECK:STDOUT: %pattern_type.loc231_60 => constants.%pattern_type.f42 +// CHECK:STDOUT: %pattern_type.loc231_66 => constants.%pattern_type.9c9 +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc231_55 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc231_66 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc233 => constants.%complete_type.1ca +// CHECK:STDOUT: %SubAssignWith.assoc_type => constants.%SubAssignWith.assoc_type.867 +// CHECK:STDOUT: %assoc0 => constants.%assoc0.aa5 +// CHECK:STDOUT: %SubAssignWith.WithSelf.Op.type => constants.%SubAssignWith.WithSelf.Op.type.792 +// CHECK:STDOUT: %.loc233_5.2 => constants.%.827 +// CHECK:STDOUT: %SubAssignWith.lookup_impl_witness => constants.%custom_witness.de3 +// CHECK:STDOUT: %impl.elem0.loc233_5.2 => constants.%Int64.Op.b941da.4 +// CHECK:STDOUT: %specific_impl_fn.loc233_5.2 => constants.%Int64.Op.b941da.4 +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @MulAssignWith.loc237(constants.%Int32, constants.%MulAssignWith.facet.982) { +// CHECK:STDOUT: %U.loc237_19.1 => constants.%Int32 +// CHECK:STDOUT: %MulAssignWith.type.loc237_52.1 => constants.%MulAssignWith.type.dd2 +// CHECK:STDOUT: %T.loc237_29.1 => constants.%MulAssignWith.facet.982 +// CHECK:STDOUT: %pattern_type.loc237_29 => constants.%pattern_type.e94 +// CHECK:STDOUT: %T.as_type.loc237_62.1 => constants.%Int64 +// CHECK:STDOUT: %pattern_type.loc237_60 => constants.%pattern_type.f42 +// CHECK:STDOUT: %pattern_type.loc237_66 => constants.%pattern_type.9c9 +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc237_55 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc237_66 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc239 => constants.%complete_type.a19 +// CHECK:STDOUT: %MulAssignWith.assoc_type => constants.%MulAssignWith.assoc_type.5c3 +// CHECK:STDOUT: %assoc0 => constants.%assoc0.6d0 +// CHECK:STDOUT: %MulAssignWith.WithSelf.Op.type => constants.%MulAssignWith.WithSelf.Op.type.788 +// CHECK:STDOUT: %.loc239_5.2 => constants.%.4a3 +// CHECK:STDOUT: %MulAssignWith.lookup_impl_witness => constants.%custom_witness.917 +// CHECK:STDOUT: %impl.elem0.loc239_5.2 => constants.%Int64.Op.b941da.5 +// CHECK:STDOUT: %specific_impl_fn.loc239_5.2 => constants.%Int64.Op.b941da.5 +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @DivAssignWith.loc243(constants.%Int32, constants.%DivAssignWith.facet.d3b) { +// CHECK:STDOUT: %U.loc243_19.1 => constants.%Int32 +// CHECK:STDOUT: %DivAssignWith.type.loc243_52.1 => constants.%DivAssignWith.type.a38 +// CHECK:STDOUT: %T.loc243_29.1 => constants.%DivAssignWith.facet.d3b +// CHECK:STDOUT: %pattern_type.loc243_29 => constants.%pattern_type.689 +// CHECK:STDOUT: %T.as_type.loc243_62.1 => constants.%Int64 +// CHECK:STDOUT: %pattern_type.loc243_60 => constants.%pattern_type.f42 +// CHECK:STDOUT: %pattern_type.loc243_66 => constants.%pattern_type.9c9 +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc243_55 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc243_66 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc245 => constants.%complete_type.136 +// CHECK:STDOUT: %DivAssignWith.assoc_type => constants.%DivAssignWith.assoc_type.86d +// CHECK:STDOUT: %assoc0 => constants.%assoc0.b6e +// CHECK:STDOUT: %DivAssignWith.WithSelf.Op.type => constants.%DivAssignWith.WithSelf.Op.type.646 +// CHECK:STDOUT: %.loc245_5.2 => constants.%.384 +// CHECK:STDOUT: %DivAssignWith.lookup_impl_witness => constants.%custom_witness.f47 +// CHECK:STDOUT: %impl.elem0.loc245_5.2 => constants.%Int64.Op.b941da.6 +// CHECK:STDOUT: %specific_impl_fn.loc245_5.2 => constants.%Int64.Op.b941da.6 +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @ModAssignWith.loc249(constants.%Int32, constants.%ModAssignWith.facet.1c6) { +// CHECK:STDOUT: %U.loc249_19.1 => constants.%Int32 +// CHECK:STDOUT: %ModAssignWith.type.loc249_52.1 => constants.%ModAssignWith.type.36f +// CHECK:STDOUT: %T.loc249_29.1 => constants.%ModAssignWith.facet.1c6 +// CHECK:STDOUT: %pattern_type.loc249_29 => constants.%pattern_type.ebe +// CHECK:STDOUT: %T.as_type.loc249_62.1 => constants.%Int64 +// CHECK:STDOUT: %pattern_type.loc249_60 => constants.%pattern_type.f42 +// CHECK:STDOUT: %pattern_type.loc249_66 => constants.%pattern_type.9c9 +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc249_55 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc249_66 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc251 => constants.%complete_type.ca8 +// CHECK:STDOUT: %ModAssignWith.assoc_type => constants.%ModAssignWith.assoc_type.1a5 +// CHECK:STDOUT: %assoc0 => constants.%assoc0.609 +// CHECK:STDOUT: %ModAssignWith.WithSelf.Op.type => constants.%ModAssignWith.WithSelf.Op.type.a34 +// CHECK:STDOUT: %.loc251_5.2 => constants.%.ee0 +// CHECK:STDOUT: %ModAssignWith.lookup_impl_witness => constants.%custom_witness.ad7 +// CHECK:STDOUT: %impl.elem0.loc251_5.2 => constants.%Int64.Op.b941da.7 +// CHECK:STDOUT: %specific_impl_fn.loc251_5.2 => constants.%Int64.Op.b941da.7 +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @TestInc(constants.%T.b7e) { +// CHECK:STDOUT: %T.loc278_13.1 => constants.%T.b7e +// CHECK:STDOUT: %T.as_type.loc278_33.1 => constants.%T.as_type.3f5 +// CHECK:STDOUT: %pattern_type => constants.%pattern_type.fb5eac.2 +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @TestDec(constants.%T.ce1) { +// CHECK:STDOUT: %T.loc284_13.1 => constants.%T.ce1 +// CHECK:STDOUT: %T.as_type.loc284_33.1 => constants.%T.as_type.ead +// CHECK:STDOUT: %pattern_type => constants.%pattern_type.f51ad8.2 +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @TestNegate(constants.%Result, constants.%T.abc) { +// CHECK:STDOUT: %Result.loc292_9.1 => constants.%Result +// CHECK:STDOUT: %Result.as_type.loc293_50.1 => constants.%Result.as_type +// CHECK:STDOUT: %facet_type => constants.%facet_type.0fc +// CHECK:STDOUT: %T.loc293_4.1 => constants.%T.abc +// CHECK:STDOUT: %pattern_type.loc293 => constants.%pattern_type.5c4 +// CHECK:STDOUT: %pattern_type.loc294_11 => constants.%pattern_type.eca0e4.2 +// CHECK:STDOUT: %T.as_type.loc294_24.1 => constants.%T.as_type.c82 +// CHECK:STDOUT: %pattern_type.loc294_22 => constants.%pattern_type.ece +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @TestInc(constants.%Inc.facet.390) { +// CHECK:STDOUT: %T.loc278_13.1 => constants.%Inc.facet.390 +// CHECK:STDOUT: %T.as_type.loc278_33.1 => constants.%Int32 +// CHECK:STDOUT: %pattern_type => constants.%pattern_type.9c9 +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete => constants.%complete_type.357 +// CHECK:STDOUT: %Inc.WithSelf.Op.type => constants.%Inc.WithSelf.Op.type.eaa +// CHECK:STDOUT: %.loc280 => constants.%.696 +// CHECK:STDOUT: %Inc.lookup_impl_witness => constants.%custom_witness.934 +// CHECK:STDOUT: %impl.elem0.loc280_3.2 => constants.%Int32.cpp_operator.0010d3.16 +// CHECK:STDOUT: %specific_impl_fn.loc280_3.2 => constants.%Int32.cpp_operator.0010d3.16 +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @TestDec(constants.%Dec.facet.961) { +// CHECK:STDOUT: %T.loc284_13.1 => constants.%Dec.facet.961 +// CHECK:STDOUT: %T.as_type.loc284_33.1 => constants.%Int32 +// CHECK:STDOUT: %pattern_type => constants.%pattern_type.9c9 +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete => constants.%complete_type.357 +// CHECK:STDOUT: %Dec.WithSelf.Op.type => constants.%Dec.WithSelf.Op.type.6fb +// CHECK:STDOUT: %.loc286 => constants.%.cdd +// CHECK:STDOUT: %Dec.lookup_impl_witness => constants.%custom_witness.99f +// CHECK:STDOUT: %impl.elem0.loc286_3.2 => constants.%Int32.cpp_operator.0010d3.17 +// CHECK:STDOUT: %specific_impl_fn.loc286_3.2 => constants.%Int32.cpp_operator.0010d3.17 +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @TestNegate(constants.%Destroy.facet.b0a, constants.%facet_value.70a) { +// CHECK:STDOUT: %Result.loc292_9.1 => constants.%Destroy.facet.b0a +// CHECK:STDOUT: %Result.as_type.loc293_50.1 => constants.%Int64 +// CHECK:STDOUT: %facet_type => constants.%facet_type.89a +// CHECK:STDOUT: %T.loc293_4.1 => constants.%facet_value.70a +// CHECK:STDOUT: %pattern_type.loc293 => constants.%pattern_type.c49 +// CHECK:STDOUT: %pattern_type.loc294_11 => constants.%pattern_type.f42 +// CHECK:STDOUT: %T.as_type.loc294_24.1 => constants.%Int16 +// CHECK:STDOUT: %pattern_type.loc294_22 => constants.%pattern_type.9a4 +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc294_11 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc294_22 => constants.%complete_type.357 +// CHECK:STDOUT: %Negate.lookup_impl_witness => constants.%custom_witness.e58 +// CHECK:STDOUT: %Negate.facet => constants.%Negate.facet.0a5 +// CHECK:STDOUT: %Negate.WithSelf.Op.type => constants.%Negate.WithSelf.Op.type.d7d +// CHECK:STDOUT: %.loc296_3.3 => constants.%.3e7 +// CHECK:STDOUT: %impl.elem1.loc296_3.2 => constants.%Int16.Op.c3e49c.18 +// CHECK:STDOUT: %specific_impl_fn.loc296_3.3 => constants.%Int16.Op.c3e49c.18 +// CHECK:STDOUT: %Destroy.WithSelf.Op.type => constants.%Destroy.WithSelf.Op.type.f16 +// CHECK:STDOUT: %.loc296_3.4 => constants.%.db1 +// CHECK:STDOUT: %Destroy.lookup_impl_witness => constants.%custom_witness.d7e +// CHECK:STDOUT: %impl.elem0.loc296_3.2 => constants.%Int64.Op.b941da.1 +// CHECK:STDOUT: %specific_impl_fn.loc296_3.4 => constants.%Int64.Op.b941da.1 +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @TestNegate(constants.%Destroy.facet.c06, constants.%facet_value.396) { +// CHECK:STDOUT: %Result.loc292_9.1 => constants.%Destroy.facet.c06 +// CHECK:STDOUT: %Result.as_type.loc293_50.1 => constants.%Int32 +// CHECK:STDOUT: %facet_type => constants.%facet_type.d5d +// CHECK:STDOUT: %T.loc293_4.1 => constants.%facet_value.396 +// CHECK:STDOUT: %pattern_type.loc293 => constants.%pattern_type.0ec +// CHECK:STDOUT: %pattern_type.loc294_11 => constants.%pattern_type.9c9 +// CHECK:STDOUT: %T.as_type.loc294_24.1 => constants.%Int32 +// CHECK:STDOUT: %pattern_type.loc294_22 => constants.%pattern_type.9c9 +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc294_11 => constants.%complete_type.357 +// CHECK:STDOUT: %require_complete.loc294_22 => constants.%complete_type.357 +// CHECK:STDOUT: %Negate.lookup_impl_witness => constants.%custom_witness.e8a +// CHECK:STDOUT: %Negate.facet => constants.%Negate.facet.3c9 +// CHECK:STDOUT: %Negate.WithSelf.Op.type => constants.%Negate.WithSelf.Op.type.1bc +// CHECK:STDOUT: %.loc296_3.3 => constants.%.19b +// CHECK:STDOUT: %impl.elem1.loc296_3.2 => constants.%Int32.Op.6afff1.18 +// CHECK:STDOUT: %specific_impl_fn.loc296_3.3 => constants.%Int32.Op.6afff1.18 +// CHECK:STDOUT: %Destroy.WithSelf.Op.type => constants.%Destroy.WithSelf.Op.type.2e1 +// CHECK:STDOUT: %.loc296_3.4 => constants.%.e6c +// CHECK:STDOUT: %Destroy.lookup_impl_witness => constants.%custom_witness.ce1 +// CHECK:STDOUT: %impl.elem0.loc296_3.2 => constants.%Int32.Op.6afff1.1 +// CHECK:STDOUT: %specific_impl_fn.loc296_3.4 => constants.%Int32.Op.6afff1.1 +// CHECK:STDOUT: } +// CHECK:STDOUT: diff --git a/toolchain/check/testdata/interop/cpp/operators/operators.carbon b/toolchain/check/testdata/interop/cpp/operators/operators.carbon index 55d493fc05fc..d82797cd0ba5 100644 --- a/toolchain/check/testdata/interop/cpp/operators/operators.carbon +++ b/toolchain/check/testdata/interop/cpp/operators/operators.carbon @@ -822,35 +822,6 @@ fn F() { //@dump-sem-ir-end } -// ============================================================================ -// Satisfying constraints -// ============================================================================ - -// --- fail_todo_constraints.carbon - -library "[[@TEST_NAME]]"; - -import Cpp inline ''' -class X {}; -X operator+(X, X); -'''; - -// TODO: Use Core.Add() when it is available. -// TODO: `Sum()` should be declared this way when generics implementation is ready for that: -// fn Sum[T:! Core.AddWith(.Self) where .Result = .Self](a: T, b: T) -> T -fn Sum[U:! type, T:! Core.AddWith(U) where .Result = U](a: T, b: U) -> U { - return a + b; -} -fn Call(x: Cpp.X) -> Cpp.X { - // CHECK:STDERR: fail_todo_constraints.carbon:[[@LINE+7]]:10: error: cannot convert type `Cpp.X` into type implementing `Core.AddWith(Cpp.X) where .(Core.AddWith(Cpp.X).Result) = Cpp.X` [ConversionFailureTypeToFacet] - // CHECK:STDERR: return Sum(x, x); - // CHECK:STDERR: ^~~~~~~~~ - // CHECK:STDERR: fail_todo_constraints.carbon:[[@LINE-7]]:1: note: while deducing parameters of generic declared here [DeductionGenericHere] - // CHECK:STDERR: fn Sum[U:! type, T:! Core.AddWith(U) where .Result = U](a: T, b: U) -> U { - // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - // CHECK:STDERR: - return Sum(x, x); -} // ============================================================================ // Operator not found diff --git a/toolchain/check/thunk.cpp b/toolchain/check/thunk.cpp index f12d56983807..6c6cf0e17421 100644 --- a/toolchain/check/thunk.cpp +++ b/toolchain/check/thunk.cpp @@ -472,7 +472,9 @@ auto BuildThunk(Context& context, SemIR::FunctionId signature_id, // TODO: For virtual functions, we want different rules for checking `self`. // TODO: This is too strict; for example, we should not compare parameter // names here. - if (CheckFunctionTypeMatches( + if (context.functions().Get(callee.function_id).special_function_kind != + SemIR::Function::SpecialFunctionKind::HasCppThunk && + CheckFunctionTypeMatches( context, context.functions().Get(callee.function_id), context.functions().Get(signature_id), signature_specific_id, /*check_syntax=*/false, /*check_self=*/true, /*diagnose=*/false)) { @@ -489,7 +491,9 @@ auto BuildThunk(Context& context, SemIR::FunctionId signature_id, // thunk, and always convert the result of the wrapped call to the return type // of the thunk. if (!HasDeclaredReturnType(context, signature_id) && - HasDeclaredReturnType(context, callee.function_id)) { + HasDeclaredReturnType(context, callee.function_id) && + context.functions().Get(callee.function_id).name_id != + SemIR::NameId::CppOperator) { bool success = CheckFunctionReturnTypeMatches( context, context.functions().Get(callee.function_id), context.functions().Get(signature_id), signature_specific_id); diff --git a/toolchain/sem_ir/core_interface_kind.def b/toolchain/sem_ir/core_interface_kind.def index 5dac767fbfd5..bee6546beea8 100644 --- a/toolchain/sem_ir/core_interface_kind.def +++ b/toolchain/sem_ir/core_interface_kind.def @@ -16,11 +16,24 @@ #define CARBON_SEM_IR_CORE_INTERFACE_KIND(Name) #endif +CARBON_SEM_IR_CORE_INTERFACE_KIND(AddAssignWith) +CARBON_SEM_IR_CORE_INTERFACE_KIND(AddWith) CARBON_SEM_IR_CORE_INTERFACE_KIND(Copy) CARBON_SEM_IR_CORE_INTERFACE_KIND(CppUnsafeDeref) +CARBON_SEM_IR_CORE_INTERFACE_KIND(Dec) CARBON_SEM_IR_CORE_INTERFACE_KIND(Default) CARBON_SEM_IR_CORE_INTERFACE_KIND(Destroy) +CARBON_SEM_IR_CORE_INTERFACE_KIND(DivAssignWith) +CARBON_SEM_IR_CORE_INTERFACE_KIND(DivWith) +CARBON_SEM_IR_CORE_INTERFACE_KIND(Inc) CARBON_SEM_IR_CORE_INTERFACE_KIND(IntFitsIn) +CARBON_SEM_IR_CORE_INTERFACE_KIND(ModAssignWith) +CARBON_SEM_IR_CORE_INTERFACE_KIND(ModWith) +CARBON_SEM_IR_CORE_INTERFACE_KIND(MulAssignWith) +CARBON_SEM_IR_CORE_INTERFACE_KIND(MulWith) +CARBON_SEM_IR_CORE_INTERFACE_KIND(Negate) +CARBON_SEM_IR_CORE_INTERFACE_KIND(SubAssignWith) +CARBON_SEM_IR_CORE_INTERFACE_KIND(SubWith) CARBON_SEM_IR_CORE_INTERFACE_KIND(Unknown)