[AMDGPU] Modify adjustInliningThreshold to also consider the cost of passing function arguments through the stack

[JanekvO]

Summary

A regression from when new PM got enabled as default. Functions with a big number of instructions will elide getting inlined but do not consider the cost of passing arguments over stack if there are a lot of function arguments. This patch attempts to add a heuristic for AMDGPU's function calling convention that also considers function arguments passed through the stack.

[JanekvO]

llvm/lib/Target/AMDGPU/AMDGPUTargetTransformInfo.cpp

1203

I added function passing through SGPRs as it was described for non-kernel functions in the AMDGPU backend user guide but the calling convention tablegen file for AMDGPU seems to only use VGPRs for passing arguments. Not sure if the aim is to add function argument passing through SGPRs and I should keep it in or whether to remove this.

[arsenm]

llvm/lib/Analysis/InlineCost.cpp

164–166

Not sure why you're adding this but it doesn't belong in this patch

llvm/lib/Target/AMDGPU/AMDGPUTargetTransformInfo.cpp

86–88

Should be able to compute this directly from the existing costs for stack stores

1189–1191

No reason to specially consider them?

1198

Raw argument counts don't correspond to register counts, need to get the type legalized register size

1234

Typo tInlinig

llvm/test/Transforms/Inline/AMDGPU/amdgpu-inline-stack-argument.ll

18–21

Should use pass arguments or flags to set the thresholds to avoid having so many instructions in the test

2027

Don't use anonymous values in tests

[scchan]

llvm/lib/Target/AMDGPU/AMDGPUTargetTransformInfo.cpp

1204

I guess it's subtracting the number of clobbered registers - instead of a hardcoded value, could that be replaced by something more meaningful like a const variable or a getter?

Also shouldn't VGPRs have a higher penalty relative to SGPRs since they'd occupy more stack space?

[arsenm]

llvm/lib/Target/AMDGPU/AMDGPUTargetTransformInfo.cpp

1204

We only sort of handle SGPR arguments today, and not for compute. We also do not currently implement the optimization of packing SGPRs into a VGPR for the argument spill

[scchan]

llvm/lib/Target/AMDGPU/AMDGPUTargetTransformInfo.cpp

1204

I wasn't paying attention to the comments for ArgStackInlinePenalty. The cost model is only based on the number of instructions and it doesn't take storage into account.

[JanekvO]

• Address comments
• Rebase

llvm/lib/Target/AMDGPU/AMDGPUTargetTransformInfo.cpp

86–88

Sorry, I couldn't find any constant or cl option for stack store costs. Did you have anything in mind to replace this cl option?

1189–1191

Removed as inlining will never call kernel functions as callee.

1204

I couldn't infer what measurement unit the inliner cost/threshold uses so I took a cost model relative from the cost of a single instruction. Do let me know if the storage cost should be considered (and possibly with what amount).

[arsenm]

llvm/lib/Target/AMDGPU/AMDGPUTargetTransformInfo.cpp

86–88

I mean TargetTransformInfo::getMemoryOpCost (looking now and I don't think we ever implemented this. I know I tried to implement at one point but I guess never pushed it. We should implement this too)

1198

Get getPrimitiveSizeInBits doesn't work for pointers. You're also going to be repeating a lot of legalization logic. You're better off using getRegisterTypeForCallingConv and getNumRegistersForCallingConv

[scchan]

llvm/lib/Target/AMDGPU/AMDGPUTargetTransformInfo.cpp

1204

I was thinking about the contribution of a stack's size to the overall size of the scratch since that may add penalty to the launch overhead. A VGPR store would take more stack space than a SGPR store and therefore has a higher cost (relatively speaking)? I don't know how to model it at the moment but just suggesting that would be something to consider.

[JanekvO]

• Address feedback, add tests for ptr and different arg types

[JanekvO]

• Rebase

[arsenm]

llvm/lib/Target/AMDGPU/AMDGPUTargetTransformInfo.cpp

1199–1200

Can you just go through EVT? This is going to not work for vectors of pointers. You shouldn't have to consider any of these details

1228

assign DL to variable above?

1232–1234

This isn't actually true today, we don't implement SGPR argument packing

1240

Don't refer to this as a spill, it's a stack cost

[JanekvO]

• Review comments

[JanekvO]

llvm/lib/Target/AMDGPU/AMDGPUTargetTransformInfo.cpp

1199–1200

This is going to not work for vectors of pointers.

Sorry, is there a way to get vector of pointers working with EVT that I'm missing?

[arsenm]

llvm/lib/Target/AMDGPU/AMDGPUTargetTransformInfo.cpp

1199–1200

You should be performing no logic on the type. You should pass the raw type to getEVT (i.e. remove the isPointerTy check, that doesn't cover vectors of pointers)

[JanekvO]

llvm/lib/Target/AMDGPU/AMDGPUTargetTransformInfo.cpp

1199–1200

Ah, the reason I put some type logic here is because getNumRegistersForCallingConv calls EVT::getSizeInBits which is target dependent and will hit an unreachable error (EVT::getEVT also doesn't allow vector of pointers).

[arsenm]

llvm/lib/Target/AMDGPU/AMDGPUTargetTransformInfo.cpp

1199–1200

I forgot this API was bad. You probably want getValueType (which is what TTI::getRegUsageForType uses, and also won't work correctly for aggregates). The most correct thing would be to call ComputeValueVTs to cover all aggregates correctly, but that feels a bit heavy. I'd go with getTLI()->getValueType(), and add a test with an array and a struct argument just to make sure those don't break too badly

[arsenm]

llvm/lib/Target/AMDGPU/AMDGPUTargetTransformInfo.cpp

1199–1200

Actually, we kind of care a lot about getting aggregates correct. We generate a number of them for the basic HIP ABI and should be emitting more of them.

[JanekvO]

• Use ComputeValueVTs for argument EVT retrieval.
• Rebase

[arsenm]

llvm/lib/Target/AMDGPU/AMDGPUTargetTransformInfo.cpp

1221

Hardcoding 4 for the alignment would be fine (not that this argument will do anything)

llvm/test/Transforms/Inline/AMDGPU/amdgpu-inline-stack-ptr-argument.ll

2 ↗

(On Diff #493907)

REQUIRES should be the first line

[JanekvO]

• Hardcore alignment, switch REQUIRES statement in tests

[JanekvO]

• Format fix

[JanekvO]

Windows failure seems to be unrelated.
@scchan I'm not sure if I've addressed your comments sufficiently, let me know if not.

[arsenm]

You don't need to re-post the review for every minor formatting fix

The SGPR argument thing doesn't really matter now, it's not an optimization we perform for arguments

llvm/lib/Target/AMDGPU/AMDGPUTargetTransformInfo.cpp

1222

Align(4), not MaybeAlign

[ronlieb]

Hi Janek, seeing buildbot failures: https://lab.llvm.org/buildbot/#/builders/193/builds/26047

0. Program arguments: /home/omp-vega20-0/bbot/openmp-offload-amdgpu-runtime/llvm.build/./bin/clang-linker-wrapper --host-triple=x86_64-unknown-linux-gnu --linker-path=/home/omp-vega20-0/bbot/openmp-offload-amdgpu-runtime/llvm.build/./bin/ld.lld -- -pie -z relro --hash-style=gnu --eh-frame-hdr -m elf_x86_64 -dynamic-linker /lib64/ld-linux-x86-64.so.2 -o /home/omp-vega20-0/bbot/openmp-offload-amdgpu-runtime/llvm.build/runtimes/runtimes-bins/openmp/libomptarget/test/amdgcn-amd-amdhsa/offloading/Output/bug49021.cpp.tmp /lib/x86_64-linux-gnu/Scrt1.o /lib/x86_64-linux-gnu/crti.o /usr/lib/gcc/x86_64-linux-gnu/9/crtbeginS.o -L/home/omp-vega20-0/bbot/openmp-offload-amdgpu-runtime/llvm.build/runtimes/runtimes-bins/openmp/libomptarget -L/home/omp-vega20-0/bbot/openmp-offload-amdgpu-runtime/llvm.build/runtimes/runtimes-bins/openmp/runtime/src -L/usr/lib/gcc/x86_64-linux-gnu/9 -L/usr/lib/gcc/x86_64-linux-gnu/9/../../../../lib64 -L/lib/x86_64-linux-gnu -L/lib/../lib64 -L/usr/lib/x86_64-linux-gnu -L/usr/lib/../lib64 -L/lib -L/usr/lib -rpath /home/omp-vega20-0/bbot/openmp-offload-amdgpu-runtime/llvm.build/runtimes/runtimes-bins/openmp/libomptarget -rpath /home/omp-vega20-0/bbot/openmp-offload-amdgpu-runtime/llvm.build/runtimes/runtimes-bins/openmp/runtime/src -rpath /home/omp-vega20-0/bbot/openmp-offload-amdgpu-runtime/llvm.build/./lib /tmp/lit-tmp-g5sdw5re/bug49021-57cfcf.o -lstdc++ -lm -lomp -lomptarget -lomptarget.devicertl -L/home/omp-vega20-0/bbot/openmp-offload-amdgpu-runtime/llvm.build/lib -lgcc_s -lgcc -lpthread -lc -lgcc_s -lgcc /usr/lib/gcc/x86_64-linux-gnu/9/crtendS.o /lib/x86_64-linux-gnu/crtn.o
#0 0x000055aaa775a69f llvm::sys::PrintStackTrace(llvm::raw_ostream&, int) (/home/omp-vega20-0/bbot/openmp-offload-amdgpu-runtime/llvm.build/./bin/clang-linker-wrapper+0x150a69f)
#1 0x000055aaa7758324 SignalHandler(int) Signals.cpp:0:0
#2 0x00007f4ad77ff420 __restore_rt (/lib/x86_64-linux-gnu/libpthread.so.0+0x14420)
#3 0x000055aaa661d96a llvm::GCNTTIImpl::adjustInliningThreshold(llvm::CallBase const*) const (.cold) AMDGPUTargetTransformInfo.cpp:0:0
#4 0x000055aaa73dcf01 (anonymous namespace)::InlineCostCallAnalyzer::updateThreshold(llvm::CallBase&, llvm::Function&) InlineCost.cpp:0:0
#5 0x000055aaa73de0ab (anonymous namespace)::InlineCostCallAnalyzer::onAnalysisStart() InlineCost.cpp:0:0

llvm/lib/Analysis/InlineCost.cpp

static cl::opt<bool> InlineCallerSupersetNoBuiltin(
     "inline-caller-superset-nobuiltin", cl::Hidden, cl::init(true),
     cl::desc("Allow inlining when caller has a superset of callee's nobuiltin "
              "attributes."));
 
 static cl::opt<bool> DisableGEPConstOperand(
     "disable-gep-const-evaluation", cl::Hidden, cl::init(false),
     cl::desc("Disables evaluation of GetElementPtr with constant operands"));
 
+static cl::opt<bool> DisableInlineSimplification(
+    "inline-disable-simplification", cl::Hidden, cl::init(false),
+    cl::desc("Disables instruction simplification during inlining"));
+
 namespace llvm {
 std::optional<int> getStringFnAttrAsInt(const Attribute &Attr) {
   if (Attr.isValid()) {
     int AttrValue = 0;
     if (!Attr.getValueAsString().getAsInteger(10, AttrValue))
       return AttrValue;
   }
   return std::nullopt;
for (Instruction &I : *BB) {
 
     // If the instruction simplified to a constant, there is no cost to this
     // instruction. Visit the instructions using our InstVisitor to account for
     // all of the per-instruction logic. The visit tree returns true if we
     // consumed the instruction in any way, and false if the instruction's base
     // cost should count against inlining.
     onInstructionAnalysisStart(&I);
 
-    if (Base::visit(&I))
+    if (!DisableInlineSimplification && Base::visit(&I))
       ++NumInstructionsSimplified;
     else
       onMissedSimplification();
 
     onInstructionAnalysisFinish(&I);
     using namespace ore;
     // If the visit this instruction detected an uninlinable pattern, abort.
     InlineResult IR = InlineResult::success();

llvm/lib/Target/AMDGPU/AMDGPUTargetTransformInfo.cpp

ArgAllocaCutoff("amdgpu-inline-arg-alloca-cutoff", cl::Hidden,
                     cl::desc("Maximum alloca size to use for inline cost"));
 
 // Inliner constraint to achieve reasonable compilation time.
 static cl::opt<size_t> InlineMaxBB(
     "amdgpu-inline-max-bb", cl::Hidden, cl::init(1100),
     cl::desc("Maximum number of BBs allowed in a function after inlining"
              " (compile time constraint)"));
 
+// The cost of passing function arguments through the stack (assuming +5 for
+// each instruction):
+//  1 instruction to put a function argument on the stack in the caller.
+//  1 instruction to take a function argument from the stack in callee.
+//  1 instruction is explicitly take care of data dependencies in callee
+//  function.
+static cl::opt<unsigned> ArgStackInlinePenalty(
+    "amdgpu-inline-arg-stack-cost", cl::Hidden, cl::init(15),
+    cl::desc("Cost per argument for function arguments passed through stack"));
+
 static bool dependsOnLocalPhi(const Loop *L, const Value *Cond,
                               unsigned Depth = 0) {
   const Instruction *I = dyn_cast<Instruction>(Cond);
   if (!I)
     return false;
 
   for (const Value *V : I->operand_values()) {
     if (!L->contains(I))
if (Callee->size() == 1)
       return true;
     size_t BBSize = Caller->size() + Callee->size() - 1;
     return BBSize <= InlineMaxBB;
   }
 
   return true;
 }
 
+static unsigned adjustInlinigThresholdUsingCallee(const Function *Callee) {
+  // Outer kernel functions can't be inlined.
+  if (llvm::AMDGPU::isKernelCC(Callee))
+    return 0;
+
+  unsigned adjustThreshold = 0;
+  int SGPRsInUse = 0;
+  int VGPRsInUse = 0;
+  for (const Argument &A : Callee->args()) {
+    if (AMDGPU::isArgPassedInSGPR(&A))
+      SGPRsInUse++;
+    else
+      VGPRsInUse++;
+  }
+
+  adjustThreshold += std::max(0, SGPRsInUse - 26) * ArgStackInlinePenalty;
+  adjustThreshold += std::max(0, VGPRsInUse - 32) * ArgStackInlinePenalty;
+  return adjustThreshold;
+}
+
 unsigned GCNTTIImpl::adjustInliningThreshold(const CallBase *CB) const {
   // If we have a pointer to private array passed into a function
   // it will not be optimized out, leaving scratch usage.
   // Increase the inline threshold to allow inlining in this case.
+  unsigned adjustThreshold = 0;
   uint64_t AllocaSize = 0;
   SmallPtrSet<const AllocaInst *, 8> AIVisited;
   for (Value *PtrArg : CB->args()) {
     PointerType *Ty = dyn_cast<PointerType>(PtrArg->getType());
     if (!Ty || (Ty->getAddressSpace() != AMDGPUAS::PRIVATE_ADDRESS &&
                 Ty->getAddressSpace() != AMDGPUAS::FLAT_ADDRESS))
       continue;
 
     PtrArg = getUnderlyingObject(PtrArg);
     if (const AllocaInst *AI = dyn_cast<AllocaInst>(PtrArg)) {
       if (!AI->isStaticAlloca() || !AIVisited.insert(AI).second)
         continue;
       AllocaSize += DL.getTypeAllocSize(AI->getAllocatedType());
       // If the amount of stack memory is excessive we will not be able
       // to get rid of the scratch anyway, bail out.
       if (AllocaSize > ArgAllocaCutoff) {
         AllocaSize = 0;
         break;
       }
     }
   }
-  if (AllocaSize)
-    return ArgAllocaCost;
-  return 0;
+  adjustThreshold += adjustInlinigThresholdUsingCallee(CB->getCalledFunction());
+  adjustThreshold += AllocaSize ? ArgAllocaCost : AllocaSize;
+  return adjustThreshold;
 }
 
 void GCNTTIImpl::getUnrollingPreferences(Loop *L, ScalarEvolution &SE,
                                          TTI::UnrollingPreferences &UP,
                                          OptimizationRemarkEmitter *ORE) {
   CommonTTI.getUnrollingPreferences(L, SE, UP, ORE);
 }
 
 void GCNTTIImpl::getPeelingPreferences(Loop *L, ScalarEvolution &SE,
                                        TTI::PeelingPreferences &PP) {
   CommonTTI.getPeelingPreferences(L, SE, PP);
 }

llvm/test/Transforms/Inline/AMDGPU/amdgpu-inline-stack-argument.ll

+; RUN: opt -mtriple=amdgcn-amd-amdhsa -S -passes=inline -inline-disable-simplification=true -inline-cost-full=true -debug-only=inline < %s 2>&1 | FileCheck %s
+; REQUIRES: asserts
+
+; Both inlining_call and non_inlining_call have the same (generated)
+; instructions. The only differences are the number of arguments and the arg
+; uses in said instructions.
+
+; CHECK: NOT Inlining (cost={{[0-9]+}}, threshold={{[0-9]+}}), Call:   %call = call noundef i32 @non_inlining_call
+; CHECK: NOT Inlining (cost={{[0-9]+}}, threshold={{[0-9]+}}), Call:   %call64 = call noundef i32 @non_inlining_call
+; CHECK: Inlining (cost={{[0-9]+}}, threshold={{[0-9]+}}), Call:   %call118 = call noundef i32 @inlining_call
+; CHECK: Inlining (cost={{[0-9]+}}, threshold={{[0-9]+}}), Call:   %call172 = call noundef i32 @inlining_call
+
+define noundef i32 @non_inlining_call(i32 noundef %a0, i32 noundef %b0, i32 noundef %c0, i32 noundef %d0, i32 noundef %e0, i32 noundef %f0, i32 noundef %g0, i32 noundef %h0, i32 noundef %i0, i32 noundef %j0, i32 noundef %k0, i32 noundef %l0, i32 noundef %m0, i32 noundef %n0, i32 noundef %o0, i32 noundef %p0, i32 noundef %q0, i32 noundef %r0, i32 noundef %s0, i32 noundef %t0, i32 noundef %u0, i32 noundef %v0, i32 noundef %w0, i32 noundef %x0, i32 noundef %y0, i32 noundef %z0, i32 noundef %a1, i32 noundef %b1, i32 noundef %c1, i32 noundef %d1, i32 noundef %e1, i32 noundef %f1) {
+entry:
+  %add = add i32 %c0, %q0
+  %shr = lshr i32 %a1, %add
+  %shl = shl i32 %f1, %z0
+  %and = and i32 %shr, %shl
+  %shr1 = lshr i32 %y0, %and
+  %shr2 = lshr i32 %shr1, %t0
+  %shl3 = shl i32 %e1, %w0
+  %and4 = and i32 %shr2, %shl3
+  %xor = xor i32 %and4, %n0
+  %and5 = and i32 %s0, %i0
+  %mul = mul i32 %i0, %and5
+  %sub = sub i32 %g0, %q0
+  %and6 = and i32 %sub, %j0
+  %sub7 = sub i32 %g0, %e0
+  %and8 = and i32 %t0, %sub7
+  %mul9 = mul i32 %and6, %and8
+  %mul10 = mul i32 %mul, %mul9
+  %sub11 = sub i32 %mul10, %v0
+  %sub12 = sub i32 %g0, %w0
+  %xor13 = xor i32 %sub12, %b1
+  %and14 = and i32 %q0, %d0
+  %add15 = add i32 %and14, %a0
+  %add16 = add i32 %add15, %f0
+  %shr17 = lshr i32 %z0, %a0
+  %sub18 = sub i32 %add16, %shr17
+  %shl19 = shl i32 %c1, %sub18
+  %add20 = add i32 %shl19, %f1
+  %xor21 = xor i32 %v0, %p0
+  %sub22 = sub i32 %e0, %m0
+  %xor23 = xor i32 %u0, %sub22
+  %or = or i32 %xor21, %xor23
+  %or24 = or i32 %or, %o0
+  %or25 = or i32 %or24, %p0
+  %mul26 = mul i32 %j0, %c1
+  %sub27 = sub i32 %g0, %t0
+  %and28 = and i32 %sub27, %s0
+  %shl29 = shl i32 %f1, %and28
+  %shl30 = shl i32 %c1, %f0
+  %and31 = and i32 %s0, %shl30
+  %sub32 = sub i32 %and31, %y0
+  %xor33 = xor i32 %u0, %p0
+  %mul34 = mul i32 %l0, %m0
+  %or35 = or i32 %mul34, %l0
+  %add36 = add i32 %c0, %q0
+  %and37 = and i32 %add36, %e1
+  %mul38 = mul i32 %or35, %and37
+  %sub39 = sub i32 %e0, %f0
+  %sub40 = sub i32 %sub39, %i0
+  %mul41 = mul i32 %sub40, %j0
+  %mul42 = mul i32 %mul41, %c0
+  %shl43 = shl i32 %mul38, %mul42
+  %shr44 = lshr i32 %z0, %r0
+  %sub45 = sub i32 %f0, %shr44
+  %add46 = add i32 %shl43, %sub45
+  %and47 = and i32 %s0, %add46
+  %or48 = or i32 %p0, %n0
+  %shr49 = lshr i32 %a1, %r0
+  %and50 = and i32 %shr49, %c1
+  %or51 = or i32 %or48, %and50
+  %shl52 = shl i32 %f1, %w0
+  %shl53 = shl i32 %or51, %shl52
+  %and54 = and i32 %and47, %shl53
+  %or55 = or i32 %xor33, %and54
+  %shr56 = lshr i32 %sub32, %or55
+  %or57 = or i32 %n0, %shr56
+  %xor58 = xor i32 %v0, %or57
+  %sub59 = sub i32 %h0, %f1
+  %shl60 = shl i32 %sub59, %v0
+  %xor61 = xor i32 %u0, %shl60
+  %sub62 = sub i32 %f0, %xor61
+  %xor63 = xor i32 %xor58, %sub62
+  %xor64 = xor i32 %xor63, %m0
+  %and65 = and i32 %r0, %h0
+  %sub66 = sub i32 %and65, %o0
+  %mul67 = mul i32 %k0, %v0
+  %xor68 = xor i32 %x0, %mul67
+  %or69 = or i32 %sub66, %xor68
+  %add70 = add i32 %d0, %g0
+  %add71 = add i32 %c0, %e0
+  %sub72 = sub i32 %add71, %b0
+  %add73 = add i32 %sub72, %h0
+  %sub74 = sub i32 %add73, %m0
+  %or75 = or i32 %o0, %sub74
+  %sub76 = sub i32 %h0, %z0
+  %or77 = or i32 %or75, %sub76
+  %mul78 = mul i32 %j0, %or77
+  %sub79 = sub i32 %add70, %mul78
+  %shr80 = lshr i32 %sub79, %f0
+  %sub81 = sub i32 %h0, %c0
+  %add82 = add i32 %sub81, %b0
+  %xor83 = xor i32 %x0, %add82
+  %sub84 = sub i32 %shr80, %xor83
+  %add85 = add i32 %sub84, %m0
+  %shr86 = lshr i32 %b1, %add85
+  %xor87 = xor i32 %or69, %shr86
+  %add88 = add i32 %b0, %xor87
+  %or89 = or i32 %p0, %add88
+  %or90 = or i32 %xor64, %or89
+  %or91 = or i32 %or90, %l0
+  %mul92 = mul i32 %or91, %h0
+  %sub93 = sub i32 %mul92, %e1
+  %shl94 = shl i32 %sub93, %n0
+  %add95 = add i32 %d0, %b0
+  %shr96 = lshr i32 %b1, %g0
+  %add97 = add i32 %add95, %shr96
+  %or98 = or i32 %shl94, %add97
+  %sub99 = sub i32 %h0, %or98
+  %and100 = and i32 %shl29, %sub99
+  %xor101 = xor i32 %u0, %and100
+  %sub102 = sub i32 %f0, %xor101
+  %sub103 = sub i32 %e0, %o0
+  %sub104 = sub i32 %e0, %t0
+  %and105 = and i32 %sub104, %w0
+  %mul106 = mul i32 %l0, %d0
+  %add107 = add i32 %mul106, %d1
+  %shr108 = lshr i32 %b1, %add107
+  %sub109 = sub i32 %g0, %z0
+  %add110 = add i32 %c0, %sub109
+  %shl111 = shl i32 %shr108, %add110
+  %shr112 = lshr i32 %shl111, %m0
+  %xor113 = xor i32 %and105, %shr112
+  %or114 = or i32 %xor113, %q0
+  %and115 = and i32 %or114, %w0
+  %shl116 = shl i32 %e1, %k0
+  %xor117 = xor i32 %and115, %shl116
+  %mul118 = mul i32 %k0, %v0
+  %mul119 = mul i32 %l0, %a0
+  %shl120 = shl i32 %c1, %mul119
+  %sub121 = sub i32 %h0, %shl120
+  %shl122 = shl i32 %e1, %a1
+  %and123 = and i32 %t0, %w0
+  %shr124 = lshr i32 %shl122, %and123
+  %add125 = add i32 %sub121, %shr124
+  %and126 = and i32 %q0, %add125
+  %xor127 = xor i32 %mul118, %and126
+  %and128 = and i32 %q0, %j0
+  %mul129 = mul i32 %and128, %a0
+  %add130 = add i32 %mul129, %d1
+  %shl131 = shl i32 %add130, %f0
+  %shr132 = lshr i32 %y0, %shl131
+  %xor133 = xor i32 %xor127, %shr132
+  %mul134 = mul i32 %k0, %xor133
+  %add135 = add i32 %d0, %mul134
+  %sub136 = sub i32 %add135, %v0
+  %add137 = add i32 %c0, %r0
+  %mul138 = mul i32 %i0, %p0
+  %shl139 = shl i32 %e1, %w0
+  %or140 = or i32 %mul138, %shl139
+  %and141 = and i32 %add137, %or140
+  %mul142 = mul i32 %i0, %t0
+  %shr143 = lshr i32 %y0, %a1
+  %and144 = and i32 %mul142, %shr143
+  %sub145 = sub i32 %f0, %a0
+  %mul146 = mul i32 %k0, %p0
+  %xor147 = xor i32 %v0, %mul146
+  %or148 = or i32 %m0, %xor147
+  %shl149 = shl i32 %c1, %y0
+  %add150 = add i32 %c0, %z0
+  %shr151 = lshr i32 %a1, %add150
+  %shr152 = lshr i32 %shl149, %shr151
+  %shr153 = lshr i32 %shr152, %a1
+  %or154 = or i32 %o0, %shr153
+  %or155 = or i32 %or148, %or154
+  %shr156 = lshr i32 %or155, %c0
+  %add157 = add i32 %sub145, %shr156
+  %shr158 = lshr i32 %and144, %add157
+  %mul159 = mul i32 %k0, %c1
+  %add160 = add i32 %shr158, %mul159
+  %sub161 = sub i32 %e0, %q0
+  %shl162 = shl i32 %add160, %sub161
+  %shl163 = shl i32 %c1, %f1
+  %add164 = add i32 %a0, %c0
+  %shl165 = shl i32 %shl163, %add164
+  %mul166 = mul i32 %k0, %shl165
+  %shl167 = shl i32 %f1, %u0
+  %and168 = and i32 %t0, %d1
+  %xor169 = xor i32 %shl167, %and168
+  %add170 = add i32 %mul166, %xor169
+  %and171 = and i32 %shl162, %add170
+  %xor172 = xor i32 %w0, %and171
+  %and173 = and i32 %s0, %xor172
+  %xor174 = xor i32 %and141, %and173
+  %xor175 = xor i32 %sub136, %xor174
+  %add176 = add i32 %d0, %a1
+  %shl177 = shl i32 %xor175, %add176
+  %or178 = or i32 %n0, %shl177
+  %mul179 = mul i32 %xor117, %or178
+  %or180 = or i32 %sub103, %mul179
+  %mul181 = mul i32 %i0, %a0
+  %sub182 = sub i32 %f0, %mul181
+  %add183 = add i32 %sub182, %z0
+  %shr184 = lshr i32 %a1, %u0
+  %xor185 = xor i32 %shr184, %a0
+  %add186 = add i32 %xor185, %n0
+  %shr187 = lshr i32 %add183, %add186
+  %or188 = or i32 %m0, %shr187
+  %or189 = or i32 %or188, %a0
+  %add190 = add i32 %or189, %a0
+  %sub191 = sub i32 %g0, %m0
+  %add192 = add i32 %add190, %sub191
+  %shr193 = lshr i32 %or180, %add192
+  %sub194 = sub i32 %h0, %m0
+  %and195 = and i32 %t0, %r0
+  %or196 = or i32 %sub194, %and195
+  %mul197 = mul i32 %l0, %g0
+  %shl198 = shl i32 %e1, %z0
+  %sub199 = sub i32 %mul197, %shl198
+  %and200 = and i32 %or196, %sub199
+  %or201 = or i32 %shr193, %and200
+  %add202 = add i32 %b0, %r0
+  %sub203 = sub i32 %h0, %q0
+  %and204 = and i32 %sub203, %i0
+  %mul205 = mul i32 %and204, %w0
+  %shl206 = shl i32 %c1, %mul205
+  %mul207 = mul i32 %j0, %r0
+  %sub208 = sub i32 %h0, %mul207
+  %xor209 = xor i32 %shl206, %sub208
+  %and210 = and i32 %add202, %xor209
+  %and211 = and i32 %and210, %b0
+  %sub212 = sub i32 %f0, %and211
+  %shr213 = lshr i32 %or201, %sub212
+  %and214 = and i32 %q0, %shr213
+  %add215 = add i32 %c0, %n0
+  %add216 = add i32 %c0, %add215
+  %and217 = and i32 %q0, %u0
+  %add218 = add i32 %c0, %f1
+  %xor219 = xor i32 %x0, %add218
+  %shl220 = shl i32 %xor219, %d1
+  %shl221 = shl i32 %shl220, %b1
+  %shr222 = lshr i32 %shl221, %x0
+  %xor223 = xor i32 %and217, %shr222
+  %or224 = or i32 %n0, %y0
+  %mul225 = mul i32 %l0, %or224
+  %shr226 = lshr i32 %mul225, %s0
+  %add227 = add i32 %a0, %i0
+  %mul228 = mul i32 %add227, %j0
+  %mul229 = mul i32 %mul228, %r0
+  %and230 = and i32 %shr226, %mul229
+  %and231 = and i32 %and230, %v0
+  %xor232 = xor i32 %xor223, %and231
+  %xor233 = xor i32 %xor232, %v0
+  %or234 = or i32 %add216, %xor233
+  %xor235 = xor i32 %or234, %x0
+  %xor236 = xor i32 %xor235, %f0
+  %add237 = add i32 %and214, %xor236
+  %sub238 = sub i32 %add237, %v0
+  %sub239 = sub i32 %sub102, %sub238
+  %sub240 = sub i32 %f0, %sub239
+  %shl241 = shl i32 %mul26, %sub240
+  %add242 = add i32 %c0, %c0
+  %mul243 = mul i32 %k0, %j0
+  %and244 = and i32 %r0, %mul243
+  %and245 = and i32 %s0, %x0
+  %shr246 = lshr i32 %z0, %i0
+  %xor247 = xor i32 %and245, %shr246
+  %mul248 = mul i32 %and244, %xor247
+  %add249 = add i32 %add242, %mul248
+  %xor250 = xor i32 %shl241, %add249
+  %or251 = or i32 %or25, %xor250
+  %mul252 = mul i32 %or251, %s0
+  %shl253 = shl i32 %add20, %mul252
+  %and254 = and i32 %shl253, %h0
+  %shl255 = shl i32 %e1, %p0
+  %add256 = add i32 %d0, %t0
+  %or257 = or i32 %shl255, %add256
+  %sub258 = sub i32 %and254, %or257
+  %sub259 = sub i32 %e0, %t0
+  %xor260 = xor i32 %v0, %v0
+  %shl261 = shl i32 %e1, %xor260
+  %sub262 = sub i32 %h0, %e1
+  %shl263 = shl i32 %sub262, %h0
+  %shl264 = shl i32 %f1, %b1
+  %shr265 = lshr i32 %shl264, %c0
+  %and266 = and i32 %t0, %v0
+  %mul267 = mul i32 %j0, %k0
+  %xor268 = xor i32 %and266, %mul267
+  %shr269 = lshr i32 %y0, %f0
+  %mul270 = mul i32 %xor268, %shr269
+  %add271 = add i32 %shr265, %mul270
+  %sub272 = sub i32 %add271, %e0
+  %sub273 = sub i32 %sub272, %f0
+  %sub274 = sub i32 %sub273, %m0
+  %or275 = or i32 %sub274, %o0
+  %sub276 = sub i32 %shl263, %or275
+  %xor277 = xor i32 %shl261, %sub276
+  %or278 = or i32 %xor277, %d0
+  %add279 = add i32 %or278, %y0
+  %shl280 = shl i32 %e1, %add279
+  %sub281 = sub i32 %g0, %shl280
+  %sub282 = sub i32 %g0, %sub281
+  %add283 = add i32 %a0, %g0
+  %sub284 = sub i32 %add283, %z0
+  %shr285 = lshr i32 %sub282, %sub284
+  %shr286 = lshr i32 %shr285, %s0
+  %shr287 = lshr i32 %a1, %shr286
+  %and288 = and i32 %shr287, %c1
+  %shl289 = shl i32 %and288, %f1
+  %shl290 = shl i32 %shl289, %n0
+  %and291 = and i32 %t0, %shl290
+  %xor292 = xor i32 %v0, %and291
+  %shr293 = lshr i32 %z0, %xor292
+  %and294 = and i32 %sub259, %shr293
+  %mul295 = mul i32 %l0, %and294
+  %and296 = and i32 %sub258, %mul295
+  %sub297 = sub i32 %f0, %x0
+  %xor298 = xor i32 %sub297, %o0
+  %or299 = or i32 %xor298, %q0
+  %and300 = and i32 %or299, %k0
+  %shr301 = lshr i32 %b1, %and300
+  %shr302 = lshr i32 %b1, %m0
+  %mul303 = mul i32 %shr301, %shr302
+  %or304 = or i32 %and296, %mul303
+  %or305 = or i32 %or304, %w0
+  %shl306 = shl i32 %e1, %or305
+  %xor307 = xor i32 %shl306, %h0
+  %sub308 = sub i32 %xor307, %e0
+  %or309 = or i32 %n0, %sub308
+  %sub310 = sub i32 %or309, %b0
+  %xor311 = xor i32 %u0, %sub310
+  %or312 = or i32 %m0, %h0
+  %sub313 = sub i32 %or312, %f1
+  %shl314 = shl i32 %c1, %sub313
+  %shl315 = shl i32 %shl314, %z0
+  %add316 = add i32 %xor311, %shl315
+  %shr317 = lshr i32 %xor13, %add316
+  %shl318 = shl i32 %e1, %shr317
+  %and319 = and i32 %q0, %n0
+  %shr320 = lshr i32 %shl318, %and319
+  %or321 = or i32 %shr320, %c0
+  %add322 = add i32 %or321, %n0
+  %mul323 = mul i32 %j0, %g0
+  %or324 = or i32 %add322, %mul323
+  %sub325 = sub i32 %or324, %m0
+  %xor326 = xor i32 %sub11, %sub325
+  %or327 = or i32 %xor, %xor326
+  %shl328 = shl i32 %d1, %y0
+  %shr329 = lshr i32 %shl328, %x0
+  %sub330 = sub i32 %g0, %f1
+  %mul331 = mul i32 %j0, %sub330
+  %mul332 = mul i32 %j0, %z0
+  %shr333 = lshr i32 %mul332, %b1
+  %shl334 = shl i32 %mul331, %shr333
+  %shl335 = shl i32 %f1, %u0
+  %add336 = add i32 %a0, %v0
+  %xor337 = xor i32 %add336, %u0
+  %or338 = or i32 %o0, %xor337
+  %or339 = or i32 %m0, %or338
+  %shl340 = shl i32 %f1, %or339
+  %shl341 = shl i32 %f1, %shl340
+  %xor342 = xor i32 %shl335, %shl341
+  %xor343 = xor i32 %xor342, %u0
+  %shr344 = lshr i32 %shl334, %xor343
+  %xor345 = xor i32 %shr329, %shr344
+  %add346 = add i32 %c0, %j0
+  %mul347 = mul i32 %add346, %q0
+  %shr348 = lshr i32 %y0, %s0
+  %sub349 = sub i32 %e0, %f0
+  %shl350 = shl i32 %e1, %sub349
+  %sub351 = sub i32 %shl350, %c0
+  %add352 = add i32 %sub351, %e0
+  %sub353 = sub i32 %add352, %o0
+  %and354 = and i32 %shr348, %sub353
+  %mul355 = mul i32 %i0, %c0
+  %add356 = add i32 %mul355, %t0
+  %mul357 = mul i32 %k0, %j0
+  %xor358 = xor i32 %v0, %mul357
+  %mul359 = mul i32 %xor358, %d1
+  %xor360 = xor i32 %x0, %y0
+  %shl361 = shl i32 %mul359, %xor360
+  %shr362 = lshr i32 %shl361, %c0
+  %add363 = add i32 %shr362, %f0
+  %sub364 = sub i32 %e0, %b1
+  %or365 = or i32 %n0, %s0
+  %shr366 = lshr i32 %a1, %e1
+  %shl367 = shl i32 %shr366, %y0
+  %mul368 = mul i32 %l0, %t0
+  %and369 = and i32 %q0, %v0
+  %and370 = and i32 %mul368, %and369
+  %sub371 = sub i32 %e0, %f1
+  %and372 = and i32 %q0, %t0
+  %shl373 = shl i32 %sub371, %and372
+  %and374 = and i32 %shl373, %a1
+  %xor375 = xor i32 %and370, %and374
+  %shr376 = lshr i32 %xor375, %y0
+  %add377 = add i32 %a0, %shr376
+  %shr378 = lshr i32 %add377, %y0
+  %mul379 = mul i32 %k0, %i0
+  %mul380 = mul i32 %mul379, %p0
+  %add381 = add i32 %d0, %mul380
+  %shr382 = lshr i32 %shr378, %add381
+  %add383 = add i32 %b0, %shr382
+  %or384 = or i32 %o0, %add383
+  %shr385 = lshr i32 %shl367, %or384
+  %and386 = and i32 %or365, %shr385
+  %or387 = or i32 %and386, %s0
+  %shr388 = lshr i32 %sub364, %or387
+  %and389 = and i32 %shr388, %v0
+  %add390 = add i32 %d0, %c0
+  %add391 = add i32 %add390, %e1
+  %xor392 = xor i32 %and389, %add391
+  %sub393 = sub i32 %add363, %xor392
+  %shl394 = shl i32 %sub393, %a1
+  %shl395 = shl i32 %f1, %f0
+  %mul396 = mul i32 %j0, %shl395
+  %mul397 = mul i32 %j0, %w0
+  %add398 = add i32 %c0, %d1
+  %shl399 = shl i32 %add398, %y0
+  %shr400 = lshr i32 %shl399, %d1
+  %shl401 = shl i32 %shr400, %d0
+  %add402 = add i32 %shl401, %g0
+  %shr403 = lshr i32 %a1, %add402
+  %xor404 = xor i32 %mul397, %shr403
+  %sub405 = sub i32 %mul396, %xor404
+  %sub406 = sub i32 %sub405, %e1
+  %shr407 = lshr i32 %shl394, %sub406
+  %mul408 = mul i32 %j0, %b0
+  %shl409 = shl i32 %shr407, %mul408
+  %add410 = add i32 %shl409, %c0
+  %shl411 = shl i32 %c1, %add410
+  %add412 = add i32 %a0, %shl411
+  %and413 = and i32 %add356, %add412
+  %or414 = or i32 %and354, %and413
+  %mul415 = mul i32 %j0, %or414
+  %mul416 = mul i32 %i0, %u0
+  %sub417 = sub i32 %g0, %w0
+  %xor418 = xor i32 %sub417, %m0
+  %or419 = or i32 %xor418, %y0
+  %xor420 = xor i32 %mul416, %or419
+  %add421 = add i32 %mul415, %xor420
+  %shr422 = lshr i32 %add421, %f1
+  %sub423 = sub i32 %h0, %d0
+  %xor424 = xor i32 %v0, %h0
+  %and425 = and i32 %s0, %i0
+  %sub426 = sub i32 %xor424, %and425
+  %shl427 = shl i32 %d1, %sub426
+  %sub428 = sub i32 %h0, %m0
+  %and429 = and i32 %s0, %sub428
+  %shr430 = lshr i32 %z0, %c1
+  %shl431 = shl i32 %shr430, %x0
+  %add432 = add i32 %c0, %shl431
+  %or433 = or i32 %m0, %d1
+  %shl434 = shl i32 %or433, %w0
+  %add435 = add i32 %c0, %c0
+  %add436 = add i32 %add435, %f1
+  %sub437 = sub i32 %e0, %add436
+  %xor438 = xor i32 %shl434, %sub437
+  %shl439 = shl i32 %xor438, %q0
+  %xor440 = xor i32 %add432, %shl439
+  %or441 = or i32 %o0, %f0
+  %sub442 = sub i32 %or441, %a1
+  %shr443 = lshr i32 %b1, %b1
+  %shr444 = lshr i32 %shr443, %f0
+  %mul445 = mul i32 %j0, %shr444
+  %sub446 = sub i32 %h0, %mul445
+  %sub447 = sub i32 %g0, %a1
+  %sub448 = sub i32 %sub446, %sub447
+  %and449 = and i32 %t0, %sub448
+  %shr450 = lshr i32 %sub442, %and449
+  %sub451 = sub i32 %e0, %g0
+  %sub452 = sub i32 %sub451, %a1
+  %shr453 = lshr i32 %shr450, %sub452
+  %shr454 = lshr i32 %shr453, %j0
+  %mul455 = mul i32 %shr454, %b0
+  %or456 = or i32 %n0, %mul455
+  %add457 = add i32 %b0, %or456
+  %and458 = and i32 %xor440, %add457
+  %or459 = or i32 %and429, %and458
+  %add460 = add i32 %or459, %c1
+  %shr461 = lshr i32 %y0, %add460
+  %mul462 = mul i32 %shl427, %shr461
+  %add463 = add i32 %sub423, %mul462
+  %shl464 = shl i32 %shr422, %add463
+  %shl465 = shl i32 %shl464, %b1
+  %shr466 = lshr i32 %shl465, %a1
+  %shl467 = shl i32 %f1, %u0
+  %and468 = and i32 %q0, %f0
+  %xor469 = xor i32 %shl467, %and468
+  %add470 = add i32 %b0, %xor469
+  %sub471 = sub i32 %add470, %w0
+  %shr472 = lshr i32 %shr466, %sub471
+  %and473 = and i32 %mul347, %shr472
+  %xor474 = xor i32 %xor345, %and473
+  %sub475 = sub i32 %e0, %h0
+  %add476 = add i32 %b0, %w0
+  %xor477 = xor i32 %w0, %add476
+  %xor478 = xor i32 %xor477, %w0
+  %sub479 = sub i32 %sub475, %xor478
+  %xor480 = xor i32 %xor474, %sub479
+  %mul481 = mul i32 %l0, %a0
+  %add482 = add i32 %mul481, %o0
+  %or483 = or i32 %add482, %x0
+  %xor484 = xor i32 %xor480, %or483
+  %sub485 = sub i32 %e0, %j0
+  %mul486 = mul i32 %sub485, %n0
+  %xor487 = xor i32 %xor484, %mul486
+  %or488 = or i32 %or327, %xor487
+  %sub489 = sub i32 %h0, %a0
+  %and490 = and i32 %s0, %x0
+  %add491 = add i32 %b0, %o0
+  %xor492 = xor i32 %and490, %add491
+  %mul493 = mul i32 %l0, %d1
+  %shl494 = shl i32 %e1, %w0
+  %xor495 = xor i32 %shl494, %q0
+  %sub496 = sub i32 %h0, %xor495
+  %shl497 = shl i32 %mul493, %sub496
+  %mul498 = mul i32 %j0, %shl497
+  %mul499 = mul i32 %i0, %b0
+  %add500 = add i32 %mul499, %n0
+  %and501 = and i32 %mul498, %add500
+  %or502 = or i32 %xor492, %and501
+  %add503 = add i32 %sub489, %or502
+  %or504 = or i32 %n0, %add503
+  %or505 = or i32 %or504, %x0
+  %add506 = add i32 %a0, %or505
+  %xor507 = xor i32 %add506, %v0
+  %shl508 = shl i32 %e1, %s0
+  %and509 = and i32 %shl508, %s0
+  %and510 = and i32 %and509, %u0
+  %xor511 = xor i32 %xor507, %and510
+  %mul512 = mul i32 %l0, %f0
+  %sub513 = sub i32 %mul512, %g0
+  %sub514 = sub i32 %sub513, %t0
+  %mul515 = mul i32 %k0, %y0
+  %mul516 = mul i32 %j0, %i0
+  %mul517 = mul i32 %mul516, %o0
+  %shr518 = lshr i32 %mul515, %mul517
+  %and519 = and i32 %sub514, %shr518
+  %xor520 = xor i32 %xor511, %and519
+  %or521 = or i32 %or488, %xor520
+  %or522 = or i32 %p0, %p0
+  %xor523 = xor i32 %u0, %or522
+  %mul524 = mul i32 %l0, %s0
+  %and525 = and i32 %mul524, %x0
+  %add526 = add i32 %c0, %i0
+  %shr527 = lshr i32 %a1, %add526
+  %xor528 = xor i32 %and525, %shr527
+  %mul529 = mul i32 %xor528, %b0
+  %add530 = add i32 %mul529, %z0
+  %sub531 = sub i32 %e0, %e0
+  %mul532 = mul i32 %i0, %a1
+  %shr533 = lshr i32 %mul532, %t0
+  %mul534 = mul i32 %j0, %b1
+  %shr535 = lshr i32 %a1, %mul534
+  %sub536 = sub i32 %f0, %p0
+  %xor537 = xor i32 %w0, %sub536
+  %shl538 = shl i32 %c1, %x0
+  %or539 = or i32 %xor537, %shl538
+  %shr540 = lshr i32 %y0, %a1
+  %add541 = add i32 %d0, %shr540
+  %xor542 = xor i32 %or539, %add541
+  %and543 = and i32 %t0, %xor542
+  %add544 = add i32 %a0, %a1
+  %shr545 = lshr i32 %and543, %add544
+  %shr546 = lshr i32 %shr545, %u0
+  %shl547 = shl i32 %e1, %f0
+  %and548 = and i32 %s0, %shl547
+  %sub549 = sub i32 %and548, %l0
+  %xor550 = xor i32 %x0, %sub549
+  %or551 = or i32 %n0, %xor550
+  %mul552 = mul i32 %or551, %g0
+  %and553 = and i32 %r0, %h0
+  %sub554 = sub i32 %mul552, %and553
+  %sub555 = sub i32 %sub554, %j0
+  %shl556 = shl i32 %c1, %sub555
+  %shl557 = shl i32 %c1, %z0
+  %mul558 = mul i32 %l0, %a1
+  %shr559 = lshr i32 %shl557, %mul558
+  %shr560 = lshr i32 %shr559, %b1
+  %mul561 = mul i32 %l0, %p0
+  %shl562 = shl i32 %d1, %v0
+  %or563 = or i32 %mul561, %shl562
+  %mul564 = mul i32 %j0, %w0
+  %sub565 = sub i32 %f0, %e1
+  %shl566 = shl i32 %d1, %sub565
+  %xor567 = xor i32 %mul564, %shl566
+  %shl568 = shl i32 %xor567, %n0
+  %xor569 = xor i32 %or563, %shl568
+  %shr570 = lshr i32 %shr560, %xor569
+  %mul571 = mul i32 %shl556, %shr570
+  %xor572 = xor i32 %shr546, %mul571
+  %shr573 = lshr i32 %shr535, %xor572
+  %and574 = and i32 %s0, %a0
+  %or575 = or i32 %shr573, %and574
+  %shl576 = shl i32 %c1, %d1
+  %add577 = add i32 %a0, %n0
+  %and578 = and i32 %t0, %h0
+  %or579 = or i32 %add577, %and578
+  %sub580 = sub i32 %or579, %t0
+  %shr581 = lshr i32 %b1, %e1
+  %mul582 = mul i32 %j0, %shr581
+  %shl583 = shl i32 %f1, %o0
+  %shr584 = lshr i32 %z0, %r0
+  %or585 = or i32 %shl583, %shr584
+  %add586 = add i32 %b0, %h0
+  %add587 = add i32 %c0, %a0
+  %add588 = add i32 %add587, %q0
+  %and589 = and i32 %add588, %z0
+  %shr590 = lshr i32 %and589, %z0
+  %sub591 = sub i32 %g0, %q0
+  %and592 = and i32 %sub591, %w0
+  %shl593 = shl i32 %c1, %and592
+  %xor594 = xor i32 %shl593, %s0
+  %or595 = or i32 %m0, %f0
+  %sub596 = sub i32 %or595, %c0
+  %sub597 = sub i32 %e0, %q0
+  %mul598 = mul i32 %k0, %e0
+  %shr599 = lshr i32 %a1, %s0
+  %and600 = and i32 %shr599, %s0
+  %sub601 = sub i32 %mul598, %and600
+  %mul602 = mul i32 %i0, %n0
+  %sub603 = sub i32 %g0, %a1
+  %shr604 = lshr i32 %sub603, %z0
+  %shr605 = lshr i32 %shr604, %r0
+  %or606 = or i32 %mul602, %shr605
+  %and607 = and i32 %sub601, %or606
+  %or608 = or i32 %p0, %and607
+  %and609 = and i32 %or608, %s0
+  %and610 = and i32 %and609, %c1
+  %sub611 = sub i32 %h0, %and610
+  %shl612 = shl i32 %sub611, %x0
+  %mul613 = mul i32 %k0, %h0
+  %shr614 = lshr i32 %y0, %z0
+  %sub615 = sub i32 %h0, %shr614
+  %sub616 = sub i32 %mul613, %sub615
+  %mul617 = mul i32 %i0, %sub616
+  %mul618 = mul i32 %i0, %t0
+  %shr619 = lshr i32 %a1, %n0
+  %or620 = or i32 %shr619, %e1
+  %shl621 = shl i32 %e1, %or620
+  %shl622 = shl i32 %shl621, %f1
+  %shl623 = shl i32 %f1, %d0
+  %xor624 = xor i32 %u0, %shl623
+  %shl625 = shl i32 %shl622, %xor624
+  %shl626 = shl i32 %c1, %t0
+  %mul627 = mul i32 %j0, %f1
+  %and628 = and i32 %shl626, %mul627
+  %add629 = add i32 %d0, %n0
+  %shl630 = shl i32 %e1, %z0
+  %add631 = add i32 %a0, %e0
+  %sub632 = sub i32 %add631, %f0
+  %shr633 = lshr i32 %shl630, %sub632
+  %sub634 = sub i32 %shr633, %z0
+  %shr635 = lshr i32 %sub634, %a0
+  %add636 = add i32 %shr635, %x0
+  %xor637 = xor i32 %w0, %add636
+  %add638 = add i32 %b0, %xor637
+  %add639 = add i32 %c0, %h0
+  %sub640 = sub i32 %add639, %a0
+  %add641 = add i32 %sub640, %r0
+  %and642 = and i32 %add641, %s0
+  %xor643 = xor i32 %add638, %and642
+  %or644 = or i32 %add629, %xor643
+  %shl645 = shl i32 %and628, %or644
+  %and646 = and i32 %shl645, %o0
+  %add647 = add i32 %shl625, %and646
+  %xor648 = xor i32 %w0, %add647
+  %and649 = and i32 %s0, %m0
+  %mul650 = mul i32 %j0, %and649
+  %or651 = or i32 %xor648, %mul650
+  %and652 = and i32 %mul618, %or651
+  %sub653 = sub i32 %g0, %b1
+  %shl654 = shl i32 %d1, %v0
+  %shr655 = lshr i32 %sub653, %shl654
+  %mul656 = mul i32 %k0, %v0
+  %shr657 = lshr i32 %a1, %b1
+  %mul658 = mul i32 %j0, %c1
+  %shr659 = lshr i32 %shr657, %mul658
+  %mul660 = mul i32 %i0, %n0
+  %xor661 = xor i32 %u0, %mul660
+  %mul662 = mul i32 %l0, %c1
+  %shl663 = shl i32 %mul662, %w0
+  %xor664 = xor i32 %shl663, %y0
+  %or665 = or i32 %xor661, %xor664
+  %mul666 = mul i32 %j0, %or665
+  %shl667 = shl i32 %shr659, %mul666
+  %shr668 = lshr i32 %shl667, %b1
+  %shr669 = lshr i32 %shr668, %f1
+  %xor670 = xor i32 %mul656, %shr669
+  %shr671 = lshr i32 %y0, %xor670
+  %shl672 = shl i32 %shr671, %y0
+  %xor673 = xor i32 %shr655, %shl672
+  %or674 = or i32 %and652, %xor673
+  %shl675 = shl i32 %d1, %or674
+  %shr676 = lshr i32 %shl675, %o0
+  %or677 = or i32 %shr676, %m0
+  %shr678 = lshr i32 %mul617, %or677
+  %xor679 = xor i32 %shl612, %shr678
+  %shl680 = shl i32 %c1, %n0
+  %or681 = or i32 %shl680, %d0
+  %add682 = add i32 %or681, %y0
+  %add683 = add i32 %c0, %o0
+  %shr684 = lshr i32 %add682, %add683
+  %or685 = or i32 %shr684, %f0
+  %mul686 = mul i32 %l0, %x0
+  %sub687 = sub i32 %or685, %mul686
+  %or688 = or i32 %xor679, %sub687
+  %xor689 = xor i32 %v0, %or688
+  %and690 = and i32 %t0, %xor689
+  %xor691 = xor i32 %and690, %d0
+  %and692 = and i32 %sub597, %xor691
+  %add693 = add i32 %and692, %l0
+  %add694 = add i32 %sub596, %add693
+  %and695 = and i32 %xor594, %add694
+  %shr696 = lshr i32 %shr590, %and695
+  %mul697 = mul i32 %shr696, %o0
+  %and698 = and i32 %r0, %mul697
+  %sub699 = sub i32 %add586, %and698
+  %and700 = and i32 %or585, %sub699
+  %sub701 = sub i32 %f0, %and700
+  %shl702 = shl i32 %mul582, %sub701
+  %and703 = and i32 %sub580, %shl702
+  %shl704 = shl i32 %shl576, %and703
+  %and705 = and i32 %s0, %w0
+  %xor706 = xor i32 %and705, %a1
+  %sub707 = sub i32 %f0, %xor706
+  %and708 = and i32 %t0, %sub707
+  %or709 = or i32 %shl704, %and708
+  %shl710 = shl i32 %d1, %f1
+  %shr711 = lshr i32 %b1, %shl710
+  %shl712 = shl i32 %shr711, %q0
+  %add713 = add i32 %d0, %shl712
+  %shl714 = shl i32 %e1, %n0
+  %and715 = and i32 %add713, %shl714
+  %add716 = add i32 %c0, %c0
+  %add717 = add i32 %add716, %d0
+  %and718 = and i32 %r0, %add717
+  %xor719 = xor i32 %v0, %and718
+  %or720 = or i32 %and715, %xor719
+  %mul721 = mul i32 %k0, %w0
+  %add722 = add i32 %or720, %mul721
+  %shl723 = shl i32 %d1, %add722
+  %xor724 = xor i32 %shl723, %a0
+  %add725 = add i32 %xor724, %s0
+  %mul726 = mul i32 %i0, %e0
+  %shr727 = lshr i32 %b1, %o0
+  %sub728 = sub i32 %mul726, %shr727
+  %shr729 = lshr i32 %z0, %o0
+  %or730 = or i32 %sub728, %shr729
+  %add731 = add i32 %a0, %or730
+  %and732 = and i32 %add725, %add731
+  %shl733 = shl i32 %d1, %m0
+  %sub734 = sub i32 %f0, %u0
+  %xor735 = xor i32 %sub734, %u0
+  %shl736 = shl i32 %d1, %u0
+  %xor737 = xor i32 %xor735, %shl736
+  %add738 = add i32 %b0, %c0
+  %add739 = add i32 %add738, %m0
+  %xor740 = xor i32 %x0, %f0
+  %or741 = or i32 %add739, %xor740
+  %and742 = and i32 %q0, %or741
+  %or743 = or i32 %n0, %w0
+  %sub744 = sub i32 %and742, %or743
+  %xor745 = xor i32 %xor737, %sub744
+  %xor746 = xor i32 %xor745, %m0
+  %or747 = or i32 %xor746, %m0
+  %sub748 = sub i32 %g0, %or747
+  %xor749 = xor i32 %v0, %sub748
+  %or750 = or i32 %shl733, %xor749
+  %and751 = and i32 %q0, %t0
+  %or752 = or i32 %or750, %and751
+  %or753 = or i32 %and732, %or752
+  %shr754 = lshr i32 %or709, %or753
+  %add755 = add i32 %or575, %shr754
+  %and756 = and i32 %shr533, %add755
+  %shl757 = shl i32 %e1, %w0
+  %and758 = and i32 %q0, %shl757
+  %shr759 = lshr i32 %y0, %and758
+  %xor760 = xor i32 %shr759, %p0
+  %add761 = add i32 %c0, %t0
+  %sub762 = sub i32 %e0, %a0
+  %add763 = add i32 %sub762, %d1
+  %and764 = and i32 %add761, %add763
+  %or765 = or i32 %xor760, %and764
+  %shl766 = shl i32 %or765, %f1
+  %add767 = add i32 %d0, %a1
+  %shl768 = shl i32 %c1, %add767
+  %shl769 = shl i32 %f1, %d1
+  %shr770 = lshr i32 %shl768, %shl769
+  %shl771 = shl i32 %shr770, %c1
+  %shl772 = shl i32 %shl766, %shl771
+  %sub773 = sub i32 %f0, %f0
+  %sub774 = sub i32 %sub773, %p0
+  %sub775 = sub i32 %h0, %sub774
+  %mul776 = mul i32 %j0, %a1
+  %sub777 = sub i32 %e0, %b1
+  %shl778 = shl i32 %c1, %sub777
+  %shr779 = lshr i32 %shl778, %z0
+  %or780 = or i32 %n0, %shr779
+  %shr781 = lshr i32 %or780, %c0
+  %mul782 = mul i32 %l0, %p0
+  %add783 = add i32 %shr781, %mul782
+  %or784 = or i32 %add783, %f1
+  %shr785 = lshr i32 %mul776, %or784
+  %sub786 = sub i32 %g0, %shr785
+  %shl787 = shl i32 %sub786, %o0
+  %or788 = or i32 %sub775, %shl787
+  %shl789 = shl i32 %shl772, %or788
+  %or790 = or i32 %shl789, %i0
+  %mul791 = mul i32 %or790, %r0
+  %and792 = and i32 %t0, %mul791
+  %and793 = and i32 %and792, %w0
+  %xor794 = xor i32 %and793, %u0
+  %sub795 = sub i32 %g0, %s0
+  %and796 = and i32 %sub795, %m0
+  %or797 = or i32 %and796, %s0
+  %shr798 = lshr i32 %b1, %or797
+  %shl799 = shl i32 %d1, %q0
+  %and800 = and i32 %shl799, %r0
+  %and801 = and i32 %and800, %o0
+  %shl802 = shl i32 %c1, %and801
+  %add803 = add i32 %b0, %h0
+  %sub804 = sub i32 %add803, %g0
+  %mul805 = mul i32 %l0, %a1
+  %sub806 = sub i32 %sub804, %mul805
+  %shr807 = lshr i32 %sub806, %p0
+  %or808 = or i32 %shl802, %shr807
+  %or809 = or i32 %or808, %n0
+  %or810 = or i32 %or809, %s0
+  %add811 = add i32 %a0, %b1
+  %and812 = and i32 %or810, %add811
+  %add813 = add i32 %d0, %h0
+  %and814 = and i32 %r0, %h0
+  %sub815 = sub i32 %and814, %w0
+  %shr816 = lshr i32 %y0, %sub815
+  %or817 = or i32 %o0, %s0
+  %and818 = and i32 %or817, %o0
+  %sub819 = sub i32 %e0, %t0
+  %and820 = and i32 %sub819, %u0
+  %xor821 = xor i32 %and820, %o0
+  %or822 = or i32 %xor821, %x0
+  %or823 = or i32 %p0, %or822
+  %xor824 = xor i32 %or823, %e1
+  %or825 = or i32 %and818, %xor824
+  %shl826 = shl i32 %or825, %s0
+  %xor827 = xor i32 %shr816, %shl826
+  %mul828 = mul i32 %k0, %i0
+  %and829 = and i32 %xor827, %mul828
+  %mul830 = mul i32 %and829, %a0
+  %add831 = add i32 %mul830, %u0
+  %add832 = add i32 %b0, %i0
+  %xor833 = xor i32 %x0, %add832
+  %xor834 = xor i32 %add831, %xor833
+  %mul835 = mul i32 %xor834, %z0
+  %shr836 = lshr i32 %mul835, %j0
+  %mul837 = mul i32 %l0, %e0
+  %mul838 = mul i32 %i0, %n0
+  %sub839 = sub i32 %mul837, %mul838
+  %shl840 = shl i32 %f1, %n0
+  %or841 = or i32 %sub839, %shl840
+  %or842 = or i32 %or841, %p0
+  %or843 = or i32 %or842, %i0
+  %mul844 = mul i32 %shr836, %or843
+  %shr845 = lshr i32 %y0, %w0
+  %or846 = or i32 %o0, %shr845
+  %xor847 = xor i32 %or846, %i0
+  %mul848 = mul i32 %mul844, %xor847
+  %sub849 = sub i32 %add813, %mul848
+  %mul850 = mul i32 %sub849, %f1
+  %shr851 = lshr i32 %and812, %mul850
+  %and852 = and i32 %shr798, %shr851
+  %shl853 = shl i32 %and852, %g0
+  %xor854 = xor i32 %xor794, %shl853
+  %xor855 = xor i32 %w0, %f1
+  %add856 = add i32 %b0, %xor855
+  %and857 = and i32 %t0, %a0
+  %add858 = add i32 %and857, %o0
+  %shl859 = shl i32 %d1, %add858
+  %shl860 = shl i32 %add856, %shl859
+  %mul861 = mul i32 %k0, %f1
+  %shl862 = shl i32 %mul861, %e1
+  %or863 = or i32 %shl860, %shl862
+  %shl864 = shl i32 %or863, %u0
+  %sub865 = sub i32 %xor854, %shl864
+  %and866 = and i32 %and756, %sub865
+  %sub867 = sub i32 %sub531, %and866
+  %shr868 = lshr i32 %add530, %sub867
+  %or869 = or i32 %xor523, %shr868
+  %sub870 = sub i32 %f0, %q0
+  %mul871 = mul i32 %i0, %z0
+  %shr872 = lshr i32 %mul871, %m0
+  %and873 = and i32 %sub870, %shr872
+  %xor874 = xor i32 %or869, %and873
+  %or875 = or i32 %or521, %xor874
+  %add876 = add i32 %d0, %n0
+  %add877 = add i32 %c0, %u0
+  %or878 = or i32 %add876, %add877
+  %xor879 = xor i32 %or878, %p0
+  %shr880 = lshr i32 %y0, %xor879
+  %and881 = and i32 %s0, %shr880
+  %or882 = or i32 %and881, %v0
+  %xor883 = xor i32 %u0, %or882
+  %or884 = or i32 %o0, %q0
+  %shl885 = shl i32 %c1, %or884
+  %and886 = and i32 %shl885, %w0
+  %xor887 = xor i32 %xor883, %and886
+  %mul888 = mul i32 %k0, %t0
+  %add889 = add i32 %b0, %w0
+  %add890 = add i32 %d0, %j0
+  %xor891 = xor i32 %add889, %add890
+  %shl892 = shl i32 %f1, %d0
+  %add893 = add i32 %b0, %shl892
+  %add894 = add i32 %add893, %b0
+  %xor895 = xor i32 %w0, %add894
+  %add896 = add i32 %xor895, %p0
+  %mul897 = mul i32 %xor891, %add896
+  %and898 = and i32 %mul888, %mul897
+  %xor899 = xor i32 %xor887, %and898
+  %or900 = or i32 %or875, %xor899
+  %add901 = add i32 %a0, %o0
+  %or902 = or i32 %add901, %u0
+  %add903 = add i32 %c0, %or902
+  %add904 = add i32 %d0, %w0
+  %mul905 = mul i32 %i0, %n0
+  %shr906 = lshr i32 %b1, %mul905
+  %xor907 = xor i32 %add904, %shr906
+  %sub908 = sub i32 %e0, %xor907
+  %xor909 = xor i32 %add903, %sub908
+  %or910 = or i32 %or900, %xor909
+  %shl911 = shl i32 %c1, %b1
+  %mul912 = mul i32 %j0, %w0
+  %shr913 = lshr i32 %shl911, %mul912
+  %and914 = and i32 %t0, %l0
+  %mul915 = mul i32 %and914, %v0
+  %xor916 = xor i32 %mul915, %a1
+  %shr917 = lshr i32 %xor916, %y0
+  %shr918 = lshr i32 %shr917, %a0
+  %add919 = add i32 %shr918, %a1
+  %shr920 = lshr i32 %add919, %q0
+  %sub921 = sub i32 %h0, %a1
+  %shr922 = lshr i32 %sub921, %y0
+  %add923 = add i32 %c0, %shr922
+  %shl924 = shl i32 %d1, %add923
+  %mul925 = mul i32 %k0, %a0
+  %mul926 = mul i32 %j0, %f0
+  %mul927 = mul i32 %i0, %mul926
+  %add928 = add i32 %mul925, %mul927
+  %sub929 = sub i32 %add928, %v0
+  %shr930 = lshr i32 %shl924, %sub929
+  %and931 = and i32 %shr920, %shr930
+  %xor932 = xor i32 %shr913, %and931
+  %mul933 = mul i32 %l0, %p0
+  %add934 = add i32 %b0, %k0
+  %or935 = or i32 %mul933, %add934
+  %or936 = or i32 %p0, %or935
+  %mul937 = mul i32 %or936, %k0
+  %sub938 = sub i32 %f0, %b1
+  %mul939 = mul i32 %j0, %c0
+  %shl940 = shl i32 %d1, %mul939
+  %add941 = add i32 %shl940, %q0
+  %and942 = and i32 %add941, %v0
+  %add943 = add i32 %b0, %c0
+  %add944 = add i32 %add943, %f1
+  %shr945 = lshr i32 %y0, %add944
+  %shl946 = shl i32 %shr945, %f0
+  %xor947 = xor i32 %and942, %shl946
+  %sub948 = sub i32 %xor947, %w0
+  %mul949 = mul i32 %j0, %d1
+  %xor950 = xor i32 %w0, %k0
+  %or951 = or i32 %p0, %xor950
+  %mul952 = mul i32 %or951, %z0
+  %shl953 = shl i32 %mul949, %mul952
+  %shr954 = lshr i32 %shl953, %v0
+  %and955 = and i32 %s0, %shr954
+  %shl956 = shl i32 %f1, %z0
+  %add957 = add i32 %a0, %t0
+  %add958 = add i32 %c0, %q0
+  %shl959 = shl i32 %d1, %z0
+  %shr960 = lshr i32 %shl959, %h0
+  %add961 = add i32 %c0, %shr960
+  %shr962 = lshr i32 %z0, %w0
+  %add963 = add i32 %d0, %b0
+  %shl964 = shl i32 %f1, %add963
+  %add965 = add i32 %shl964, %r0
+  %add966 = add i32 %c0, %q0
+  %and967 = and i32 %add966, %s0
+  %and968 = and i32 %add965, %and967
+  %xor969 = xor i32 %shr962, %and968
+  %sub970 = sub i32 %add961, %xor969
+  %and971 = and i32 %add958, %sub970
+  %sub972 = sub i32 %h0, %v0
+  %or973 = or i32 %n0, %sub972
+  %and974 = and i32 %q0, %or973
+  %shr975 = lshr i32 %y0, %and974
+  %xor976 = xor i32 %v0, %shr975
+  %or977 = or i32 %p0, %w0
+  %xor978 = xor i32 %xor976, %or977
+  %or979 = or i32 %n0, %xor978
+  %and980 = and i32 %and971, %or979
+  %shl981 = shl i32 %e1, %and980
+  %and982 = and i32 %s0, %shl981
+  %and983 = and i32 %add957, %and982
+  %shr984 = lshr i32 %shl956, %and983
+  %and985 = and i32 %r0, %shr984
+  %xor986 = xor i32 %and955, %and985
+  %xor987 = xor i32 %sub948, %xor986
+  %sub988 = sub i32 %g0, %xor987
+  %shr989 = lshr i32 %sub938, %sub988
+  %mul990 = mul i32 %mul937, %shr989
+  %xor991 = xor i32 %xor932, %mul990
+  %or992 = or i32 %or910, %xor991
+  ret i32 %or992
+}
+
+define noundef i32 @inlining_call(i32 noundef %a0, i32 noundef %b0, i32 noundef %c0, i32 noundef %d0, i32 noundef %e0, i32 noundef %f0, i32 noundef %g0, i32 noundef %h0, i32 noundef %i0, i32 noundef %j0, i32 noundef %k0, i32 noundef %l0, i32 noundef %m0, i32 noundef %n0, i32 noundef %o0, i32 noundef %p0, i32 noundef %q0, i32 noundef %r0, i32 noundef %s0, i32 noundef %t0, i32 noundef %u0, i32 noundef %v0, i32 noundef %w0, i32 noundef %x0, i32 noundef %y0, i32 noundef %z0, i32 noundef %a1, i32 noundef %b1, i32 noundef %c1, i32 noundef %d1, i32 noundef %e1, i32 noundef %f1, i32 noundef %g1, i32 noundef %h1, i32 noundef %i1, i32 noundef %j1, i32 noundef %k1, i32 noundef %l1, i32 noundef %m1, i32 noundef %n1, i32 noundef %o1, i32 noundef %p1, i32 noundef %q1, i32 noundef %r1, i32 noundef %s1, i32 noundef %t1, i32 noundef %u1, i32 noundef %v1, i32 noundef %w1, i32 noundef %x1, i32 noundef %y1, i32 noundef %z1) {
+entry:
+  %add = add i32 %a1, %c0
+  %shr = lshr i32 %w1, %add
+  %shl = shl i32 %q0, %g1
+  %and = and i32 %shr, %shl
+  %shr1 = lshr i32 %y0, %and
+  %shr2 = lshr i32 %shr1, %f1
+  %shl3 = shl i32 %z0, %y1
+  %and4 = and i32 %shr2, %shl3
+  %xor = xor i32 %and4, %t0
+  %and5 = and i32 %w0, %l1
+  %mul = mul i32 %e1, %and5
+  %sub = sub i32 %n0, %g1
+  %and6 = and i32 %sub, %i0
+  %sub7 = sub i32 %i0, %w1
+  %and8 = and i32 %s0, %sub7
+  %mul9 = mul i32 %and6, %and8
+  %mul10 = mul i32 %mul, %mul9
+  %sub11 = sub i32 %mul10, %g0
+  %sub12 = sub i32 %z1, %q0
+  %xor13 = xor i32 %sub12, %i1
+  %and14 = and i32 %t0, %g0
+  %add15 = add i32 %and14, %u1
+  %add16 = add i32 %add15, %e0
+  %shr17 = lshr i32 %r1, %v0
+  %sub18 = sub i32 %add16, %shr17
+  %shl19 = shl i32 %j0, %sub18
+  %add20 = add i32 %shl19, %e1
+  %xor21 = xor i32 %j1, %g0
+  %sub22 = sub i32 %b1, %u0
+  %xor23 = xor i32 %w0, %sub22
+  %or = or i32 %xor21, %xor23
+  %or24 = or i32 %or, %n1
+  %or25 = or i32 %or24, %o1
+  %mul26 = mul i32 %n0, %j1
+  %sub27 = sub i32 %d0, %z1
+  %and28 = and i32 %sub27, %j1
+  %shl29 = shl i32 %q0, %and28
+  %shl30 = shl i32 %t1, %y1
+  %and31 = and i32 %z0, %shl30
+  %sub32 = sub i32 %and31, %q1
+  %xor33 = xor i32 %o1, %a0
+  %mul34 = mul i32 %f1, %v0
+  %or35 = or i32 %mul34, %p0
+  %add36 = add i32 %u1, %u0
+  %and37 = and i32 %add36, %t1
+  %mul38 = mul i32 %or35, %and37
+  %sub39 = sub i32 %e0, %m0
+  %sub40 = sub i32 %sub39, %k1
+  %mul41 = mul i32 %sub40, %o0
+  %mul42 = mul i32 %mul41, %p0
+  %shl43 = shl i32 %mul38, %mul42
+  %shr44 = lshr i32 %j0, %z1
+  %sub45 = sub i32 %z1, %shr44
+  %add46 = add i32 %shl43, %sub45
+  %and47 = and i32 %n1, %add46
+  %or48 = or i32 %i1, %c1
+  %shr49 = lshr i32 %f0, %f0
+  %and50 = and i32 %shr49, %u0
+  %or51 = or i32 %or48, %and50
+  %shl52 = shl i32 %g1, %f1
+  %shl53 = shl i32 %or51, %shl52
+  %and54 = and i32 %and47, %shl53
+  %or55 = or i32 %xor33, %and54
+  %shr56 = lshr i32 %sub32, %or55
+  %or57 = or i32 %u1, %shr56
+  %xor58 = xor i32 %f0, %or57
+  %sub59 = sub i32 %j1, %s0
+  %shl60 = shl i32 %sub59, %t1
+  %xor61 = xor i32 %t0, %shl60
+  %sub62 = sub i32 %g0, %xor61
+  %xor63 = xor i32 %xor58, %sub62
+  %xor64 = xor i32 %xor63, %h0
+  %and65 = and i32 %i1, %n0
+  %sub66 = sub i32 %and65, %z1
+  %mul67 = mul i32 %j1, %l1
+  %xor68 = xor i32 %m1, %mul67
+  %or69 = or i32 %sub66, %xor68
+  %add70 = add i32 %c1, %f0
+  %add71 = add i32 %y0, %u0
+  %sub72 = sub i32 %add71, %k1
+  %add73 = add i32 %sub72, %p0
+  %sub74 = sub i32 %add73, %s0
+  %or75 = or i32 %z1, %sub74
+  %sub76 = sub i32 %l0, %m0
+  %or77 = or i32 %or75, %sub76
+  %mul78 = mul i32 %m1, %or77
+  %sub79 = sub i32 %add70, %mul78
+  %shr80 = lshr i32 %sub79, %l0
+  %sub81 = sub i32 %n1, %q1
+  %add82 = add i32 %sub81, %q0
+  %xor83 = xor i32 %c0, %add82
+  %sub84 = sub i32 %shr80, %xor83
+  %add85 = add i32 %sub84, %e1
+  %shr86 = lshr i32 %s0, %add85
+  %xor87 = xor i32 %or69, %shr86
+  %add88 = add i32 %v0, %xor87
+  %or89 = or i32 %j1, %add88
+  %or90 = or i32 %xor64, %or89
+  %or91 = or i32 %or90, %e0
+  %mul92 = mul i32 %or91, %f0
+  %sub93 = sub i32 %mul92, %r1
+  %shl94 = shl i32 %sub93, %w1
+  %add95 = add i32 %i0, %j0
+  %shr96 = lshr i32 %c0, %f0
+  %add97 = add i32 %add95, %shr96
+  %or98 = or i32 %shl94, %add97
+  %sub99 = sub i32 %a0, %or98
+  %and100 = and i32 %shl29, %sub99
+  %xor101 = xor i32 %h1, %and100
+  %sub102 = sub i32 %c1, %xor101
+  %sub103 = sub i32 %i1, %r1
+  %sub104 = sub i32 %z0, %t1
+  %and105 = and i32 %sub104, %h1
+  %mul106 = mul i32 %h1, %z1
+  %add107 = add i32 %mul106, %p0
+  %shr108 = lshr i32 %r0, %add107
+  %sub109 = sub i32 %r1, %l1
+  %add110 = add i32 %n0, %sub109
+  %shl111 = shl i32 %shr108, %add110
+  %shr112 = lshr i32 %shl111, %a1
+  %xor113 = xor i32 %and105, %shr112
+  %or114 = or i32 %xor113, %l1
+  %and115 = and i32 %or114, %r0
+  %shl116 = shl i32 %c1, %f1
+  %xor117 = xor i32 %and115, %shl116
+  %mul118 = mul i32 %y1, %w0
+  %mul119 = mul i32 %h0, %f1
+  %shl120 = shl i32 %n1, %mul119
+  %sub121 = sub i32 %u0, %shl120
+  %shl122 = shl i32 %l1, %o1
+  %and123 = and i32 %v0, %m0
+  %shr124 = lshr i32 %shl122, %and123
+  %add125 = add i32 %sub121, %shr124
+  %and126 = and i32 %f0, %add125
+  %xor127 = xor i32 %mul118, %and126
+  %and128 = and i32 %b0, %u1
+  %mul129 = mul i32 %and128, %r0
+  %add130 = add i32 %mul129, %h0
+  %shl131 = shl i32 %add130, %t1
+  %shr132 = lshr i32 %p0, %shl131
+  %xor133 = xor i32 %xor127, %shr132
+  %mul134 = mul i32 %s1, %xor133
+  %add135 = add i32 %p1, %mul134
+  %sub136 = sub i32 %add135, %o0
+  %add137 = add i32 %x0, %y1
+  %mul138 = mul i32 %k0, %v0
+  %shl139 = shl i32 %b1, %d0
+  %or140 = or i32 %mul138, %shl139
+  %and141 = and i32 %add137, %or140
+  %mul142 = mul i32 %j0, %s1
+  %shr143 = lshr i32 %o0, %c0
+  %and144 = and i32 %mul142, %shr143
+  %sub145 = sub i32 %k1, %o1
+  %mul146 = mul i32 %r1, %e0
+  %xor147 = xor i32 %m1, %mul146
+  %or148 = or i32 %i1, %xor147
+  %shl149 = shl i32 %h0, %o1
+  %add150 = add i32 %m1, %k1
+  %shr151 = lshr i32 %m0, %add150
+  %shr152 = lshr i32 %shl149, %shr151
+  %shr153 = lshr i32 %shr152, %h0
+  %or154 = or i32 %b0, %shr153
+  %or155 = or i32 %or148, %or154
+  %shr156 = lshr i32 %or155, %z0
+  %add157 = add i32 %sub145, %shr156
+  %shr158 = lshr i32 %and144, %add157
+  %mul159 = mul i32 %f0, %x0
+  %add160 = add i32 %shr158, %mul159
+  %sub161 = sub i32 %h0, %c0
+  %shl162 = shl i32 %add160, %sub161
+  %shl163 = shl i32 %b0, %m0
+  %add164 = add i32 %l0, %t1
+  %shl165 = shl i32 %shl163, %add164
+  %mul166 = mul i32 %m1, %shl165
+  %shl167 = shl i32 %h0, %e1
+  %and168 = and i32 %n0, %u1
+  %xor169 = xor i32 %shl167, %and168
+  %add170 = add i32 %mul166, %xor169
+  %and171 = and i32 %shl162, %add170
+  %xor172 = xor i32 %y1, %and171
+  %and173 = and i32 %g0, %xor172
+  %xor174 = xor i32 %and141, %and173
+  %xor175 = xor i32 %sub136, %xor174
+  %add176 = add i32 %z1, %d0
+  %shl177 = shl i32 %xor175, %add176
+  %or178 = or i32 %q1, %shl177
+  %mul179 = mul i32 %xor117, %or178
+  %or180 = or i32 %sub103, %mul179
+  %mul181 = mul i32 %i1, %b1
+  %sub182 = sub i32 %b0, %mul181
+  %add183 = add i32 %sub182, %n1
+  %shr184 = lshr i32 %g0, %q0
+  %xor185 = xor i32 %shr184, %e0
+  %add186 = add i32 %xor185, %o0
+  %shr187 = lshr i32 %add183, %add186
+  %or188 = or i32 %r1, %shr187
+  %or189 = or i32 %or188, %e0
+  %add190 = add i32 %or189, %p1
+  %sub191 = sub i32 %t0, %w0
+  %add192 = add i32 %add190, %sub191
+  %shr193 = lshr i32 %or180, %add192
+  %sub194 = sub i32 %b1, %l0
+  %and195 = and i32 %d0, %g1
+  %or196 = or i32 %sub194, %and195
+  %mul197 = mul i32 %d1, %c0
+  %shl198 = shl i32 %m1, %g0
+  %sub199 = sub i32 %mul197, %shl198
+  %and200 = and i32 %or196, %sub199
+  %or201 = or i32 %shr193, %and200
+  %add202 = add i32 %z0, %m0
+  %sub203 = sub i32 %w0, %u1
+  %and204 = and i32 %sub203, %e1
+  %mul205 = mul i32 %and204, %k1
+  %shl206 = shl i32 %q0, %mul205
+  %mul207 = mul i32 %s1, %r1
+  %sub208 = sub i32 %k0, %mul207
+  %xor209 = xor i32 %shl206, %sub208
+  %and210 = and i32 %add202, %xor209
+  %and211 = and i32 %and210, %n0
+  %sub212 = sub i32 %s1, %and211
+  %shr213 = lshr i32 %or201, %sub212
+  %and214 = and i32 %s1, %shr213
+  %add215 = add i32 %d0, %y1
+  %add216 = add i32 %x1, %add215
+  %and217 = and i32 %r1, %k0
+  %add218 = add i32 %v0, %h1
+  %xor219 = xor i32 %k0, %add218
+  %shl220 = shl i32 %xor219, %q0
+  %shl221 = shl i32 %shl220, %h0
+  %shr222 = lshr i32 %shl221, %m1
+  %xor223 = xor i32 %and217, %shr222
+  %or224 = or i32 %q1, %l0
+  %mul225 = mul i32 %c1, %or224
+  %shr226 = lshr i32 %mul225, %a0
+  %add227 = add i32 %e1, %r1
+  %mul228 = mul i32 %add227, %a1
+  %mul229 = mul i32 %mul228, %k1
+  %and230 = and i32 %shr226, %mul229
+  %and231 = and i32 %and230, %g1
+  %xor232 = xor i32 %xor223, %and231
+  %xor233 = xor i32 %xor232, %t0
+  %or234 = or i32 %add216, %xor233
+  %xor235 = xor i32 %or234, %p1
+  %xor236 = xor i32 %xor235, %w0
+  %add237 = add i32 %and214, %xor236
+  %sub238 = sub i32 %add237, %y0
+  %sub239 = sub i32 %sub102, %sub238
+  %sub240 = sub i32 %e1, %sub239
+  %shl241 = shl i32 %mul26, %sub240
+  %add242 = add i32 %q1, %q0
+  %mul243 = mul i32 %j1, %s1
+  %and244 = and i32 %j0, %mul243
+  %and245 = and i32 %a0, %d1
+  %shr246 = lshr i32 %v1, %f0
+  %xor247 = xor i32 %and245, %shr246
+  %mul248 = mul i32 %and244, %xor247
+  %add249 = add i32 %add242, %mul248
+  %xor250 = xor i32 %shl241, %add249
+  %or251 = or i32 %or25, %xor250
+  %mul252 = mul i32 %or251, %v0
+  %shl253 = shl i32 %add20, %mul252
+  %and254 = and i32 %shl253, %v1
+  %shl255 = shl i32 %c0, %i1
+  %add256 = add i32 %r0, %i0
+  %or257 = or i32 %shl255, %add256
+  %sub258 = sub i32 %and254, %or257
+  %sub259 = sub i32 %w1, %e1
+  %xor260 = xor i32 %i0, %t1
+  %shl261 = shl i32 %n1, %xor260
+  %sub262 = sub i32 %t0, %y0
+  %shl263 = shl i32 %sub262, %v1
+  %shl264 = shl i32 %a1, %p1
+  %shr265 = lshr i32 %shl264, %f0
+  %and266 = and i32 %a0, %m1
+  %mul267 = mul i32 %m0, %s1
+  %xor268 = xor i32 %and266, %mul267
+  %shr269 = lshr i32 %v0, %k0
+  %mul270 = mul i32 %xor268, %shr269
+  %add271 = add i32 %shr265, %mul270
+  %sub272 = sub i32 %add271, %p0
+  %sub273 = sub i32 %sub272, %o0
+  %sub274 = sub i32 %sub273, %o1
+  %or275 = or i32 %sub274, %c1
+  %sub276 = sub i32 %shl263, %or275
+  %xor277 = xor i32 %shl261, %sub276
+  %or278 = or i32 %xor277, %y0
+  %add279 = add i32 %or278, %t1
+  %shl280 = shl i32 %o1, %add279
+  %sub281 = sub i32 %l1, %shl280
+  %sub282 = sub i32 %w0, %sub281
+  %add283 = add i32 %r1, %k1
+  %sub284 = sub i32 %add283, %a1
+  %shr285 = lshr i32 %sub282, %sub284
+  %shr286 = lshr i32 %shr285, %c0
+  %shr287 = lshr i32 %r1, %shr286
+  %and288 = and i32 %shr287, %z0
+  %shl289 = shl i32 %and288, %s1
+  %shl290 = shl i32 %shl289, %k1
+  %and291 = and i32 %s0, %shl290
+  %xor292 = xor i32 %n1, %and291
+  %shr293 = lshr i32 %w0, %xor292
+  %and294 = and i32 %sub259, %shr293
+  %mul295 = mul i32 %p0, %and294
+  %and296 = and i32 %sub258, %mul295
+  %sub297 = sub i32 %x1, %q1
+  %xor298 = xor i32 %sub297, %t1
+  %or299 = or i32 %xor298, %c0
+  %and300 = and i32 %or299, %k0
+  %shr301 = lshr i32 %a1, %and300
+  %shr302 = lshr i32 %c1, %e0
+  %mul303 = mul i32 %shr301, %shr302
+  %or304 = or i32 %and296, %mul303
+  %or305 = or i32 %or304, %q0
+  %shl306 = shl i32 %m1, %or305
+  %xor307 = xor i32 %shl306, %s1
+  %sub308 = sub i32 %xor307, %k0
+  %or309 = or i32 %z1, %sub308
+  %sub310 = sub i32 %or309, %c1
+  %xor311 = xor i32 %t1, %sub310
+  %or312 = or i32 %f1, %j1
+  %sub313 = sub i32 %or312, %m1
+  %shl314 = shl i32 %h1, %sub313
+  %shl315 = shl i32 %shl314, %w1
+  %add316 = add i32 %xor311, %shl315
+  %shr317 = lshr i32 %xor13, %add316
+  %shl318 = shl i32 %n1, %shr317
+  %and319 = and i32 %a0, %c0
+  %shr320 = lshr i32 %shl318, %and319
+  %or321 = or i32 %shr320, %f1
+  %add322 = add i32 %or321, %u0
+  %mul323 = mul i32 %t0, %d1
+  %or324 = or i32 %add322, %mul323
+  %sub325 = sub i32 %or324, %d0
+  %xor326 = xor i32 %sub11, %sub325
+  %or327 = or i32 %xor, %xor326
+  %shl328 = shl i32 %z1, %z1
+  %shr329 = lshr i32 %shl328, %a1
+  %sub330 = sub i32 %j1, %o1
+  %mul331 = mul i32 %m0, %sub330
+  %mul332 = mul i32 %f0, %u1
+  %shr333 = lshr i32 %mul332, %i0
+  %shl334 = shl i32 %mul331, %shr333
+  %shl335 = shl i32 %a0, %z0
+  %add336 = add i32 %n0, %a0
+  %xor337 = xor i32 %add336, %t1
+  %or338 = or i32 %a0, %xor337
+  %or339 = or i32 %u0, %or338
+  %shl340 = shl i32 %a1, %or339
+  %shl341 = shl i32 %r1, %shl340
+  %xor342 = xor i32 %shl335, %shl341
+  %xor343 = xor i32 %xor342, %w1
+  %shr344 = lshr i32 %shl334, %xor343
+  %xor345 = xor i32 %shr329, %shr344
+  %add346 = add i32 %a0, %r1
+  %mul347 = mul i32 %add346, %h1
+  %shr348 = lshr i32 %g0, %m0
+  %sub349 = sub i32 %m1, %p1
+  %shl350 = shl i32 %h0, %sub349
+  %sub351 = sub i32 %shl350, %m0
+  %add352 = add i32 %sub351, %t0
+  %sub353 = sub i32 %add352, %r0
+  %and354 = and i32 %shr348, %sub353
+  %mul355 = mul i32 %s1, %l0
+  %add356 = add i32 %mul355, %g0
+  %mul357 = mul i32 %f0, %b0
+  %xor358 = xor i32 %o1, %mul357
+  %mul359 = mul i32 %xor358, %r0
+  %xor360 = xor i32 %c1, %z1
+  %shl361 = shl i32 %mul359, %xor360
+  %shr362 = lshr i32 %shl361, %y1
+  %add363 = add i32 %shr362, %h0
+  %sub364 = sub i32 %q0, %i0
+  %or365 = or i32 %p1, %h1
+  %shr366 = lshr i32 %p1, %p1
+  %shl367 = shl i32 %shr366, %w0
+  %mul368 = mul i32 %b0, %c0
+  %and369 = and i32 %c0, %n0
+  %and370 = and i32 %mul368, %and369
+  %sub371 = sub i32 %r1, %q0
+  %and372 = and i32 %j1, %u0
+  %shl373 = shl i32 %sub371, %and372
+  %and374 = and i32 %shl373, %x0
+  %xor375 = xor i32 %and370, %and374
+  %shr376 = lshr i32 %xor375, %k1
+  %add377 = add i32 %r0, %shr376
+  %shr378 = lshr i32 %add377, %c0
+  %mul379 = mul i32 %s1, %m1
+  %mul380 = mul i32 %mul379, %p1
+  %add381 = add i32 %v1, %mul380
+  %shr382 = lshr i32 %shr378, %add381
+  %add383 = add i32 %j0, %shr382
+  %or384 = or i32 %h0, %add383
+  %shr385 = lshr i32 %shl367, %or384
+  %and386 = and i32 %or365, %shr385
+  %or387 = or i32 %and386, %f1
+  %shr388 = lshr i32 %sub364, %or387
+  %and389 = and i32 %shr388, %t1
+  %add390 = add i32 %p1, %d1
+  %add391 = add i32 %add390, %o1
+  %xor392 = xor i32 %and389, %add391
+  %sub393 = sub i32 %add363, %xor392
+  %shl394 = shl i32 %sub393, %b1
+  %shl395 = shl i32 %i1, %l0
+  %mul396 = mul i32 %x0, %shl395
+  %mul397 = mul i32 %n0, %y0
+  %add398 = add i32 %s0, %a0
+  %shl399 = shl i32 %add398, %i0
+  %shr400 = lshr i32 %shl399, %j0
+  %shl401 = shl i32 %shr400, %r0
+  %add402 = add i32 %shl401, %v0
+  %shr403 = lshr i32 %l1, %add402
+  %xor404 = xor i32 %mul397, %shr403
+  %sub405 = sub i32 %mul396, %xor404
+  %sub406 = sub i32 %sub405, %v0
+  %shr407 = lshr i32 %shl394, %sub406
+  %mul408 = mul i32 %y1, %x0
+  %shl409 = shl i32 %shr407, %mul408
+  %add410 = add i32 %shl409, %t1
+  %shl411 = shl i32 %z0, %add410
+  %add412 = add i32 %e1, %shl411
+  %and413 = and i32 %add356, %add412
+  %or414 = or i32 %and354, %and413
+  %mul415 = mul i32 %n1, %or414
+  %mul416 = mul i32 %f0, %v0
+  %sub417 = sub i32 %x1, %n1
+  %xor418 = xor i32 %sub417, %c0
+  %or419 = or i32 %xor418, %c0
+  %xor420 = xor i32 %mul416, %or419
+  %add421 = add i32 %mul415, %xor420
+  %shr422 = lshr i32 %add421, %r0
+  %sub423 = sub i32 %k0, %j0
+  %xor424 = xor i32 %s0, %x0
+  %and425 = and i32 %z0, %j1
+  %sub426 = sub i32 %xor424, %and425
+  %shl427 = shl i32 %l1, %sub426
+  %sub428 = sub i32 %h0, %e1
+  %and429 = and i32 %s0, %sub428
+  %shr430 = lshr i32 %p0, %d0
+  %shl431 = shl i32 %shr430, %t0
+  %add432 = add i32 %u1, %shl431
+  %or433 = or i32 %l0, %h1
+  %shl434 = shl i32 %or433, %u1
+  %add435 = add i32 %t0, %z0
+  %add436 = add i32 %add435, %v0
+  %sub437 = sub i32 %e0, %add436
+  %xor438 = xor i32 %shl434, %sub437
+  %shl439 = shl i32 %xor438, %t0
+  %xor440 = xor i32 %add432, %shl439
+  %or441 = or i32 %g0, %j1
+  %sub442 = sub i32 %or441, %e1
+  %shr443 = lshr i32 %z1, %v0
+  %shr444 = lshr i32 %shr443, %h0
+  %mul445 = mul i32 %z1, %shr444
+  %sub446 = sub i32 %v0, %mul445
+  %sub447 = sub i32 %e1, %h0
+  %sub448 = sub i32 %sub446, %sub447
+  %and449 = and i32 %e1, %sub448
+  %shr450 = lshr i32 %sub442, %and449
+  %sub451 = sub i32 %s1, %f1
+  %sub452 = sub i32 %sub451, %b1
+  %shr453 = lshr i32 %shr450, %sub452
+  %shr454 = lshr i32 %shr453, %c0
+  %mul455 = mul i32 %shr454, %t0
+  %or456 = or i32 %g0, %mul455
+  %add457 = add i32 %a1, %or456
+  %and458 = and i32 %xor440, %add457
+  %or459 = or i32 %and429, %and458
+  %add460 = add i32 %or459, %v0
+  %shr461 = lshr i32 %i0, %add460
+  %mul462 = mul i32 %shl427, %shr461
+  %add463 = add i32 %sub423, %mul462
+  %shl464 = shl i32 %shr422, %add463
+  %shl465 = shl i32 %shl464, %v1
+  %shr466 = lshr i32 %shl465, %r1
+  %shl467 = shl i32 %k0, %o1
+  %and468 = and i32 %k1, %y0
+  %xor469 = xor i32 %shl467, %and468
+  %add470 = add i32 %j0, %xor469
+  %sub471 = sub i32 %add470, %z1
+  %shr472 = lshr i32 %shr466, %sub471
+  %and473 = and i32 %mul347, %shr472
+  %xor474 = xor i32 %xor345, %and473
+  %sub475 = sub i32 %o1, %f0
+  %add476 = add i32 %z1, %f0
+  %xor477 = xor i32 %e0, %add476
+  %xor478 = xor i32 %xor477, %m0
+  %sub479 = sub i32 %sub475, %xor478
+  %xor480 = xor i32 %xor474, %sub479
+  %mul481 = mul i32 %v1, %o0
+  %add482 = add i32 %mul481, %d0
+  %or483 = or i32 %add482, %y0
+  %xor484 = xor i32 %xor480, %or483
+  %sub485 = sub i32 %a0, %g0
+  %mul486 = mul i32 %sub485, %z0
+  %xor487 = xor i32 %xor484, %mul486
+  %or488 = or i32 %or327, %xor487
+  %sub489 = sub i32 %s0, %c1
+  %and490 = and i32 %f1, %y1
+  %add491 = add i32 %l1, %t1
+  %xor492 = xor i32 %and490, %add491
+  %mul493 = mul i32 %n0, %b1
+  %shl494 = shl i32 %x0, %o0
+  %xor495 = xor i32 %shl494, %q0
+  %sub496 = sub i32 %f0, %xor495
+  %shl497 = shl i32 %mul493, %sub496
+  %mul498 = mul i32 %r1, %shl497
+  %mul499 = mul i32 %l1, %x1
+  %add500 = add i32 %mul499, %k0
+  %and501 = and i32 %mul498, %add500
+  %or502 = or i32 %xor492, %and501
+  %add503 = add i32 %sub489, %or502
+  %or504 = or i32 %h1, %add503
+  %or505 = or i32 %or504, %b1
+  %add506 = add i32 %j1, %or505
+  %xor507 = xor i32 %add506, %m0
+  %shl508 = shl i32 %w0, %h0
+  %and509 = and i32 %shl508, %e0
+  %and510 = and i32 %and509, %s1
+  %xor511 = xor i32 %xor507, %and510
+  %mul512 = mul i32 %b0, %h1
+  %sub513 = sub i32 %mul512, %c1
+  %sub514 = sub i32 %sub513, %w1
+  %mul515 = mul i32 %r1, %m0
+  %mul516 = mul i32 %h0, %f1
+  %mul517 = mul i32 %mul516, %z0
+  %shr518 = lshr i32 %mul515, %mul517
+  %and519 = and i32 %sub514, %shr518
+  %xor520 = xor i32 %xor511, %and519
+  %or521 = or i32 %or488, %xor520
+  %or522 = or i32 %n0, %p1
+  %xor523 = xor i32 %q0, %or522
+  %mul524 = mul i32 %c0, %z1
+  %and525 = and i32 %mul524, %n0
+  %add526 = add i32 %j0, %g0
+  %shr527 = lshr i32 %n1, %add526
+  %xor528 = xor i32 %and525, %shr527
+  %mul529 = mul i32 %xor528, %m0
+  %add530 = add i32 %mul529, %d1
+  %sub531 = sub i32 %y0, %x0
+  %mul532 = mul i32 %i1, %j0
+  %shr533 = lshr i32 %mul532, %g0
+  %mul534 = mul i32 %f1, %j0
+  %shr535 = lshr i32 %m1, %mul534
+  %sub536 = sub i32 %o1, %r1
+  %xor537 = xor i32 %z0, %sub536
+  %shl538 = shl i32 %b1, %h1
+  %or539 = or i32 %xor537, %shl538
+  %shr540 = lshr i32 %r1, %u0
+  %add541 = add i32 %f1, %shr540
+  %xor542 = xor i32 %or539, %add541
+  %and543 = and i32 %k1, %xor542
+  %add544 = add i32 %f1, %f1
+  %shr545 = lshr i32 %and543, %add544
+  %shr546 = lshr i32 %shr545, %o1
+  %shl547 = shl i32 %o0, %a0
+  %and548 = and i32 %n1, %shl547
+  %sub549 = sub i32 %and548, %v0
+  %xor550 = xor i32 %i1, %sub549
+  %or551 = or i32 %m0, %xor550
+  %mul552 = mul i32 %or551, %t1
+  %and553 = and i32 %v1, %u0
+  %sub554 = sub i32 %mul552, %and553
+  %sub555 = sub i32 %sub554, %u0
+  %shl556 = shl i32 %q1, %sub555
+  %shl557 = shl i32 %c0, %h1
+  %mul558 = mul i32 %j0, %q0
+  %shr559 = lshr i32 %shl557, %mul558
+  %shr560 = lshr i32 %shr559, %m1
+  %mul561 = mul i32 %y1, %j0
+  %shl562 = shl i32 %y0, %l1
+  %or563 = or i32 %mul561, %shl562
+  %mul564 = mul i32 %s0, %t1
+  %sub565 = sub i32 %z1, %e1
+  %shl566 = shl i32 %t1, %sub565
+  %xor567 = xor i32 %mul564, %shl566
+  %shl568 = shl i32 %xor567, %e0
+  %xor569 = xor i32 %or563, %shl568
+  %shr570 = lshr i32 %shr560, %xor569
+  %mul571 = mul i32 %shl556, %shr570
+  %xor572 = xor i32 %shr546, %mul571
+  %shr573 = lshr i32 %shr535, %xor572
+  %and574 = and i32 %z1, %f0
+  %or575 = or i32 %shr573, %and574
+  %shl576 = shl i32 %h1, %c0
+  %add577 = add i32 %e0, %o0
+  %and578 = and i32 %i0, %c0
+  %or579 = or i32 %add577, %and578
+  %sub580 = sub i32 %or579, %t0
+  %shr581 = lshr i32 %w1, %c1
+  %mul582 = mul i32 %a0, %shr581
+  %shl583 = shl i32 %k0, %z1
+  %shr584 = lshr i32 %j0, %p1
+  %or585 = or i32 %shl583, %shr584
+  %add586 = add i32 %d1, %x0
+  %add587 = add i32 %y0, %h1
+  %add588 = add i32 %add587, %g1
+  %and589 = and i32 %add588, %c0
+  %shr590 = lshr i32 %and589, %k1
+  %sub591 = sub i32 %r1, %y1
+  %and592 = and i32 %sub591, %z1
+  %shl593 = shl i32 %f0, %and592
+  %xor594 = xor i32 %shl593, %h1
+  %or595 = or i32 %w1, %m1
+  %sub596 = sub i32 %or595, %e0
+  %sub597 = sub i32 %v1, %b1
+  %mul598 = mul i32 %m1, %a1
+  %shr599 = lshr i32 %e1, %y1
+  %and600 = and i32 %shr599, %y0
+  %sub601 = sub i32 %mul598, %and600
+  %mul602 = mul i32 %m1, %l1
+  %sub603 = sub i32 %o0, %z1
+  %shr604 = lshr i32 %sub603, %b0
+  %shr605 = lshr i32 %shr604, %q1
+  %or606 = or i32 %mul602, %shr605
+  %and607 = and i32 %sub601, %or606
+  %or608 = or i32 %i1, %and607
+  %and609 = and i32 %or608, %a0
+  %and610 = and i32 %and609, %v1
+  %sub611 = sub i32 %s0, %and610
+  %shl612 = shl i32 %sub611, %l0
+  %mul613 = mul i32 %g1, %k1
+  %shr614 = lshr i32 %v0, %e0
+  %sub615 = sub i32 %q0, %shr614
+  %sub616 = sub i32 %mul613, %sub615
+  %mul617 = mul i32 %t0, %sub616
+  %mul618 = mul i32 %q0, %t0
+  %shr619 = lshr i32 %y0, %z1
+  %or620 = or i32 %shr619, %y0
+  %shl621 = shl i32 %a1, %or620
+  %shl622 = shl i32 %shl621, %d0
+  %shl623 = shl i32 %p1, %i0
+  %xor624 = xor i32 %k0, %shl623
+  %shl625 = shl i32 %shl622, %xor624
+  %shl626 = shl i32 %p0, %s0
+  %mul627 = mul i32 %u1, %v0
+  %and628 = and i32 %shl626, %mul627
+  %add629 = add i32 %d0, %c0
+  %shl630 = shl i32 %j0, %f1
+  %add631 = add i32 %m1, %t1
+  %sub632 = sub i32 %add631, %f0
+  %shr633 = lshr i32 %shl630, %sub632
+  %sub634 = sub i32 %shr633, %r1
+  %shr635 = lshr i32 %sub634, %s1
+  %add636 = add i32 %shr635, %j0
+  %xor637 = xor i32 %a1, %add636
+  %add638 = add i32 %e1, %xor637
+  %add639 = add i32 %z1, %w0
+  %sub640 = sub i32 %add639, %a1
+  %add641 = add i32 %sub640, %c0
+  %and642 = and i32 %add641, %n1
+  %xor643 = xor i32 %add638, %and642
+  %or644 = or i32 %add629, %xor643
+  %shl645 = shl i32 %and628, %or644
+  %and646 = and i32 %shl645, %d1
+  %add647 = add i32 %shl625, %and646
+  %xor648 = xor i32 %x1, %add647
+  %and649 = and i32 %d1, %d0
+  %mul650 = mul i32 %y0, %and649
+  %or651 = or i32 %xor648, %mul650
+  %and652 = and i32 %mul618, %or651
+  %sub653 = sub i32 %g0, %e1
+  %shl654 = shl i32 %x1, %j0
+  %shr655 = lshr i32 %sub653, %shl654
+  %mul656 = mul i32 %c0, %m1
+  %shr657 = lshr i32 %n1, %i0
+  %mul658 = mul i32 %o1, %u0
+  %shr659 = lshr i32 %shr657, %mul658
+  %mul660 = mul i32 %j1, %p1
+  %xor661 = xor i32 %s1, %mul660
+  %mul662 = mul i32 %w0, %m0
+  %shl663 = shl i32 %mul662, %y0
+  %xor664 = xor i32 %shl663, %y1
+  %or665 = or i32 %xor661, %xor664
+  %mul666 = mul i32 %g0, %or665
+  %shl667 = shl i32 %shr659, %mul666
+  %shr668 = lshr i32 %shl667, %x1
+  %shr669 = lshr i32 %shr668, %x1
+  %xor670 = xor i32 %mul656, %shr669
+  %shr671 = lshr i32 %b0, %xor670
+  %shl672 = shl i32 %shr671, %f1
+  %xor673 = xor i32 %shr655, %shl672
+  %or674 = or i32 %and652, %xor673
+  %shl675 = shl i32 %f1, %or674
+  %shr676 = lshr i32 %shl675, %h0
+  %or677 = or i32 %shr676, %d0
+  %shr678 = lshr i32 %mul617, %or677
+  %xor679 = xor i32 %shl612, %shr678
+  %shl680 = shl i32 %n1, %s1
+  %or681 = or i32 %shl680, %d1
+  %add682 = add i32 %or681, %n1
+  %add683 = add i32 %o1, %v0
+  %shr684 = lshr i32 %add682, %add683
+  %or685 = or i32 %shr684, %p1
+  %mul686 = mul i32 %h0, %r1
+  %sub687 = sub i32 %or685, %mul686
+  %or688 = or i32 %xor679, %sub687
+  %xor689 = xor i32 %n0, %or688
+  %and690 = and i32 %w1, %xor689
+  %xor691 = xor i32 %and690, %t1
+  %and692 = and i32 %sub597, %xor691
+  %add693 = add i32 %and692, %n1
+  %add694 = add i32 %sub596, %add693
+  %and695 = and i32 %xor594, %add694
+  %shr696 = lshr i32 %shr590, %and695
+  %mul697 = mul i32 %shr696, %s0
+  %and698 = and i32 %g1, %mul697
+  %sub699 = sub i32 %add586, %and698
+  %and700 = and i32 %or585, %sub699
+  %sub701 = sub i32 %v0, %and700
+  %shl702 = shl i32 %mul582, %sub701
+  %and703 = and i32 %sub580, %shl702
+  %shl704 = shl i32 %shl576, %and703
+  %and705 = and i32 %y0, %z1
+  %xor706 = xor i32 %and705, %s0
+  %sub707 = sub i32 %i0, %xor706
+  %and708 = and i32 %y1, %sub707
+  %or709 = or i32 %shl704, %and708
+  %shl710 = shl i32 %h0, %h1
+  %shr711 = lshr i32 %z1, %shl710
+  %shl712 = shl i32 %shr711, %y1
+  %add713 = add i32 %r1, %shl712
+  %shl714 = shl i32 %m0, %c0
+  %and715 = and i32 %add713, %shl714
+  %add716 = add i32 %c1, %x0
+  %add717 = add i32 %add716, %w1
+  %and718 = and i32 %z0, %add717
+  %xor719 = xor i32 %y1, %and718
+  %or720 = or i32 %and715, %xor719
+  %mul721 = mul i32 %m0, %d1
+  %add722 = add i32 %or720, %mul721
+  %shl723 = shl i32 %v1, %add722
+  %xor724 = xor i32 %shl723, %w0
+  %add725 = add i32 %xor724, %y1
+  %mul726 = mul i32 %e0, %c0
+  %shr727 = lshr i32 %c0, %f1
+  %sub728 = sub i32 %mul726, %shr727
+  %shr729 = lshr i32 %q0, %b0
+  %or730 = or i32 %sub728, %shr729
+  %add731 = add i32 %o1, %or730
+  %and732 = and i32 %add725, %add731
+  %shl733 = shl i32 %h1, %q1
+  %sub734 = sub i32 %n0, %o0
+  %xor735 = xor i32 %sub734, %f0
+  %shl736 = shl i32 %x1, %o1
+  %xor737 = xor i32 %xor735, %shl736
+  %add738 = add i32 %g1, %s1
+  %add739 = add i32 %add738, %h1
+  %xor740 = xor i32 %a1, %g1
+  %or741 = or i32 %add739, %xor740
+  %and742 = and i32 %x1, %or741
+  %or743 = or i32 %t0, %h0
+  %sub744 = sub i32 %and742, %or743
+  %xor745 = xor i32 %xor737, %sub744
+  %xor746 = xor i32 %xor745, %j0
+  %or747 = or i32 %xor746, %b1
+  %sub748 = sub i32 %k1, %or747
+  %xor749 = xor i32 %k1, %sub748
+  %or750 = or i32 %shl733, %xor749
+  %and751 = and i32 %k1, %b1
+  %or752 = or i32 %or750, %and751
+  %or753 = or i32 %and732, %or752
+  %shr754 = lshr i32 %or709, %or753
+  %add755 = add i32 %or575, %shr754
+  %and756 = and i32 %shr533, %add755
+  %shl757 = shl i32 %e0, %g0
+  %and758 = and i32 %a1, %shl757
+  %shr759 = lshr i32 %g0, %and758
+  %xor760 = xor i32 %shr759, %a1
+  %add761 = add i32 %x1, %j0
+  %sub762 = sub i32 %u1, %b0
+  %add763 = add i32 %sub762, %y1
+  %and764 = and i32 %add761, %add763
+  %or765 = or i32 %xor760, %and764
+  %shl766 = shl i32 %or765, %c1
+  %add767 = add i32 %r1, %a1
+  %shl768 = shl i32 %b1, %add767
+  %shl769 = shl i32 %b0, %f1
+  %shr770 = lshr i32 %shl768, %shl769
+  %shl771 = shl i32 %shr770, %u0
+  %shl772 = shl i32 %shl766, %shl771
+  %sub773 = sub i32 %q0, %f0
+  %sub774 = sub i32 %sub773, %w0
+  %sub775 = sub i32 %u1, %sub774
+  %mul776 = mul i32 %h0, %w0
+  %sub777 = sub i32 %w0, %w0
+  %shl778 = shl i32 %b0, %sub777
+  %shr779 = lshr i32 %shl778, %l0
+  %or780 = or i32 %s1, %shr779
+  %shr781 = lshr i32 %or780, %a0
+  %mul782 = mul i32 %o0, %x0
+  %add783 = add i32 %shr781, %mul782
+  %or784 = or i32 %add783, %e0
+  %shr785 = lshr i32 %mul776, %or784
+  %sub786 = sub i32 %e0, %shr785
+  %shl787 = shl i32 %sub786, %m1
+  %or788 = or i32 %sub775, %shl787
+  %shl789 = shl i32 %shl772, %or788
+  %or790 = or i32 %shl789, %j0
+  %mul791 = mul i32 %or790, %n0
+  %and792 = and i32 %f0, %mul791
+  %and793 = and i32 %and792, %a0
+  %xor794 = xor i32 %and793, %n0
+  %sub795 = sub i32 %r1, %u1
+  %and796 = and i32 %sub795, %h0
+  %or797 = or i32 %and796, %v1
+  %shr798 = lshr i32 %q1, %or797
+  %shl799 = shl i32 %s0, %x0
+  %and800 = and i32 %shl799, %s1
+  %and801 = and i32 %and800, %b0
+  %shl802 = shl i32 %a0, %and801
+  %add803 = add i32 %m1, %o0
+  %sub804 = sub i32 %add803, %j0
+  %mul805 = mul i32 %l0, %d1
+  %sub806 = sub i32 %sub804, %mul805
+  %shr807 = lshr i32 %sub806, %h0
+  %or808 = or i32 %shl802, %shr807
+  %or809 = or i32 %or808, %e1
+  %or810 = or i32 %or809, %w0
+  %add811 = add i32 %t1, %q0
+  %and812 = and i32 %or810, %add811
+  %add813 = add i32 %i0, %b0
+  %and814 = and i32 %x0, %v0
+  %sub815 = sub i32 %and814, %e1
+  %shr816 = lshr i32 %n0, %sub815
+  %or817 = or i32 %s0, %s0
+  %and818 = and i32 %or817, %j1
+  %sub819 = sub i32 %u0, %l0
+  %and820 = and i32 %sub819, %l1
+  %xor821 = xor i32 %and820, %f0
+  %or822 = or i32 %xor821, %g0
+  %or823 = or i32 %o1, %or822
+  %xor824 = xor i32 %or823, %i1
+  %or825 = or i32 %and818, %xor824
+  %shl826 = shl i32 %or825, %l1
+  %xor827 = xor i32 %shr816, %shl826
+  %mul828 = mul i32 %t0, %k0
+  %and829 = and i32 %xor827, %mul828
+  %mul830 = mul i32 %and829, %y0
+  %add831 = add i32 %mul830, %j0
+  %add832 = add i32 %z1, %o0
+  %xor833 = xor i32 %i0, %add832
+  %xor834 = xor i32 %add831, %xor833
+  %mul835 = mul i32 %xor834, %u0
+  %shr836 = lshr i32 %mul835, %g1
+  %mul837 = mul i32 %p0, %p0
+  %mul838 = mul i32 %w1, %l0
+  %sub839 = sub i32 %mul837, %mul838
+  %shl840 = shl i32 %s0, %x0
+  %or841 = or i32 %sub839, %shl840
+  %or842 = or i32 %or841, %a1
+  %or843 = or i32 %or842, %q1
+  %mul844 = mul i32 %shr836, %or843
+  %shr845 = lshr i32 %i0, %m1
+  %or846 = or i32 %c0, %shr845
+  %xor847 = xor i32 %or846, %b0
+  %mul848 = mul i32 %mul844, %xor847
+  %sub849 = sub i32 %add813, %mul848
+  %mul850 = mul i32 %sub849, %z0
+  %shr851 = lshr i32 %and812, %mul850
+  %and852 = and i32 %shr798, %shr851
+  %shl853 = shl i32 %and852, %e0
+  %xor854 = xor i32 %xor794, %shl853
+  %xor855 = xor i32 %e0, %i0
+  %add856 = add i32 %s1, %xor855
+  %and857 = and i32 %t0, %j1
+  %add858 = add i32 %and857, %a1
+  %shl859 = shl i32 %a1, %add858
+  %shl860 = shl i32 %add856, %shl859
+  %mul861 = mul i32 %v1, %j0
+  %shl862 = shl i32 %mul861, %l1
+  %or863 = or i32 %shl860, %shl862
+  %shl864 = shl i32 %or863, %b1
+  %sub865 = sub i32 %xor854, %shl864
+  %and866 = and i32 %and756, %sub865
+  %sub867 = sub i32 %sub531, %and866
+  %shr868 = lshr i32 %add530, %sub867
+  %or869 = or i32 %xor523, %shr868
+  %sub870 = sub i32 %t0, %o1
+  %mul871 = mul i32 %w0, %f0
+  %shr872 = lshr i32 %mul871, %p0
+  %and873 = and i32 %sub870, %shr872
+  %xor874 = xor i32 %or869, %and873
+  %or875 = or i32 %or521, %xor874
+  %add876 = add i32 %o1, %h1
+  %add877 = add i32 %d0, %y0
+  %or878 = or i32 %add876, %add877
+  %xor879 = xor i32 %or878, %a1
+  %shr880 = lshr i32 %x0, %xor879
+  %and881 = and i32 %o1, %shr880
+  %or882 = or i32 %and881, %a0
+  %xor883 = xor i32 %c1, %or882
+  %or884 = or i32 %u1, %u0
+  %shl885 = shl i32 %a1, %or884
+  %and886 = and i32 %shl885, %c1
+  %xor887 = xor i32 %xor883, %and886
+  %mul888 = mul i32 %n0, %x0
+  %add889 = add i32 %s0, %e1
+  %add890 = add i32 %f0, %l0
+  %xor891 = xor i32 %add889, %add890
+  %shl892 = shl i32 %r0, %h0
+  %add893 = add i32 %g0, %shl892
+  %add894 = add i32 %add893, %j1
+  %xor895 = xor i32 %y1, %add894
+  %add896 = add i32 %xor895, %m1
+  %mul897 = mul i32 %xor891, %add896
+  %and898 = and i32 %mul888, %mul897
+  %xor899 = xor i32 %xor887, %and898
+  %or900 = or i32 %or875, %xor899
+  %add901 = add i32 %j0, %y1
+  %or902 = or i32 %add901, %s1
+  %add903 = add i32 %s1, %or902
+  %add904 = add i32 %z0, %l0
+  %mul905 = mul i32 %a1, %b1
+  %shr906 = lshr i32 %x1, %mul905
+  %xor907 = xor i32 %add904, %shr906
+  %sub908 = sub i32 %c1, %xor907
+  %xor909 = xor i32 %add903, %sub908
+  %or910 = or i32 %or900, %xor909
+  %shl911 = shl i32 %l0, %p0
+  %mul912 = mul i32 %d1, %v0
+  %shr913 = lshr i32 %shl911, %mul912
+  %and914 = and i32 %h1, %j0
+  %mul915 = mul i32 %and914, %w0
+  %xor916 = xor i32 %mul915, %d1
+  %shr917 = lshr i32 %xor916, %o1
+  %shr918 = lshr i32 %shr917, %o1
+  %add919 = add i32 %shr918, %f0
+  %shr920 = lshr i32 %add919, %e1
+  %sub921 = sub i32 %s0, %a0
+  %shr922 = lshr i32 %sub921, %s1
+  %add923 = add i32 %n0, %shr922
+  %shl924 = shl i32 %w1, %add923
+  %mul925 = mul i32 %c1, %n1
+  %mul926 = mul i32 %a0, %n0
+  %mul927 = mul i32 %d1, %mul926
+  %add928 = add i32 %mul925, %mul927
+  %sub929 = sub i32 %add928, %t0
+  %shr930 = lshr i32 %shl924, %sub929
+  %and931 = and i32 %shr920, %shr930
+  %xor932 = xor i32 %shr913, %and931
+  %mul933 = mul i32 %x1, %o1
+  %add934 = add i32 %t0, %i1
+  %or935 = or i32 %mul933, %add934
+  %or936 = or i32 %h0, %or935
+  %mul937 = mul i32 %or936, %m1
+  %sub938 = sub i32 %j0, %b1
+  %mul939 = mul i32 %e1, %f0
+  %shl940 = shl i32 %w1, %mul939
+  %add941 = add i32 %shl940, %r1
+  %and942 = and i32 %add941, %f1
+  %add943 = add i32 %o0, %i1
+  %add944 = add i32 %add943, %w1
+  %shr945 = lshr i32 %w1, %add944
+  %shl946 = shl i32 %shr945, %z0
+  %xor947 = xor i32 %and942, %shl946
+  %sub948 = sub i32 %xor947, %r0
+  %mul949 = mul i32 %b0, %h0
+  %xor950 = xor i32 %q1, %c0
+  %or951 = or i32 %r0, %xor950
+  %mul952 = mul i32 %or951, %a0
+  %shl953 = shl i32 %mul949, %mul952
+  %shr954 = lshr i32 %shl953, %q0
+  %and955 = and i32 %o1, %shr954
+  %shl956 = shl i32 %h1, %l1
+  %add957 = add i32 %t1, %z0
+  %add958 = add i32 %v1, %q0
+  %shl959 = shl i32 %s0, %w1
+  %shr960 = lshr i32 %shl959, %r1
+  %add961 = add i32 %w0, %shr960
+  %shr962 = lshr i32 %m0, %m1
+  %add963 = add i32 %c0, %e0
+  %shl964 = shl i32 %f0, %add963
+  %add965 = add i32 %shl964, %y1
+  %add966 = add i32 %q0, %t0
+  %and967 = and i32 %add966, %i1
+  %and968 = and i32 %add965, %and967
+  %xor969 = xor i32 %shr962, %and968
+  %sub970 = sub i32 %add961, %xor969
+  %and971 = and i32 %add958, %sub970
+  %sub972 = sub i32 %k0, %e0
+  %or973 = or i32 %w1, %sub972
+  %and974 = and i32 %p0, %or973
+  %shr975 = lshr i32 %h1, %and974
+  %xor976 = xor i32 %h0, %shr975
+  %or977 = or i32 %a1, %s0
+  %xor978 = xor i32 %xor976, %or977
+  %or979 = or i32 %v0, %xor978
+  %and980 = and i32 %and971, %or979
+  %shl981 = shl i32 %g0, %and980
+  %and982 = and i32 %c1, %shl981
+  %and983 = and i32 %add957, %and982
+  %shr984 = lshr i32 %shl956, %and983
+  %and985 = and i32 %z0, %shr984
+  %xor986 = xor i32 %and955, %and985
+  %xor987 = xor i32 %sub948, %xor986
+  %sub988 = sub i32 %t1, %xor987
+  %shr989 = lshr i32 %sub938, %sub988
+  %mul990 = mul i32 %mul937, %shr989
+  %xor991 = xor i32 %xor932, %mul990
+  %or992 = or i32 %or910, %xor991
+  ret i32 %or992
+}
+
+; Calling each (non-)inlining function twice to make sure they won't get the sole call inlining cost bonus. 
+define i32 @Caller(ptr noundef %in, ptr noundef %in2) {
+entry:
+  %arrayidx = getelementptr inbounds i32, ptr %in, i64 0
+  %0 = load i32, ptr %arrayidx, align 4
+  %arrayidx1 = getelementptr inbounds i32, ptr %in, i64 1
+  %1 = load i32, ptr %arrayidx1, align 4
+  %arrayidx2 = getelementptr inbounds i32, ptr %in, i64 2
+  %2 = load i32, ptr %arrayidx2, align 4
+  %arrayidx3 = getelementptr inbounds i32, ptr %in, i64 3
+  %3 = load i32, ptr %arrayidx3, align 4
+  %arrayidx4 = getelementptr inbounds i32, ptr %in, i64 4
+  %4 = load i32, ptr %arrayidx4, align 4
+  %arrayidx5 = getelementptr inbounds i32, ptr %in, i64 5
+  %5 = load i32, ptr %arrayidx5, align 4
+  %arrayidx6 = getelementptr inbounds i32, ptr %in, i64 6
+  %6 = load i32, ptr %arrayidx6, align 4
+  %arrayidx7 = getelementptr inbounds i32, ptr %in, i64 7
+  %7 = load i32, ptr %arrayidx7, align 4
+  %arrayidx8 = getelementptr inbounds i32, ptr %in, i64 8
+  %8 = load i32, ptr %arrayidx8, align 4
+  %arrayidx9 = getelementptr inbounds i32, ptr %in, i64 9
+  %9 = load i32, ptr %arrayidx9, align 4
+  %arrayidx10 = getelementptr inbounds i32, ptr %in, i64 10
+  %10 = load i32, ptr %arrayidx10, align 4
+  %arrayidx11 = getelementptr inbounds i32, ptr %in, i64 11
+  %11 = load i32, ptr %arrayidx11, align 4
+  %arrayidx12 = getelementptr inbounds i32, ptr %in, i64 12
+  %12 = load i32, ptr %arrayidx12, align 4
+  %arrayidx13 = getelementptr inbounds i32, ptr %in, i64 13
+  %13 = load i32, ptr %arrayidx13, align 4
+  %arrayidx14 = getelementptr inbounds i32, ptr %in, i64 14
+  %14 = load i32, ptr %arrayidx14, align 4
+  %arrayidx15 = getelementptr inbounds i32, ptr %in, i64 15
+  %15 = load i32, ptr %arrayidx15, align 4
+  %arrayidx16 = getelementptr inbounds i32, ptr %in, i64 16
+  %16 = load i32, ptr %arrayidx16, align 4
+  %arrayidx17 = getelementptr inbounds i32, ptr %in, i64 17
+  %17 = load i32, ptr %arrayidx17, align 4
+  %arrayidx18 = getelementptr inbounds i32, ptr %in, i64 18
+  %18 = load i32, ptr %arrayidx18, align 4
+  %arrayidx19 = getelementptr inbounds i32, ptr %in, i64 19
+  %19 = load i32, ptr %arrayidx19, align 4
+  %arrayidx20 = getelementptr inbounds i32, ptr %in, i64 20
+  %20 = load i32, ptr %arrayidx20, align 4
+  %arrayidx21 = getelementptr inbounds i32, ptr %in, i64 21
+  %21 = load i32, ptr %arrayidx21, align 4
+  %arrayidx22 = getelementptr inbounds i32, ptr %in, i64 22
+  %22 = load i32, ptr %arrayidx22, align 4
+  %arrayidx23 = getelementptr inbounds i32, ptr %in, i64 23
+  %23 = load i32, ptr %arrayidx23, align 4
+  %arrayidx24 = getelementptr inbounds i32, ptr %in, i64 24
+  %24 = load i32, ptr %arrayidx24, align 4
+  %arrayidx25 = getelementptr inbounds i32, ptr %in, i64 25
+  %25 = load i32, ptr %arrayidx25, align 4
+  %arrayidx26 = getelementptr inbounds i32, ptr %in, i64 26
+  %26 = load i32, ptr %arrayidx26, align 4
+  %arrayidx27 = getelementptr inbounds i32, ptr %in, i64 27
+  %27 = load i32, ptr %arrayidx27, align 4
+  %arrayidx28 = getelementptr inbounds i32, ptr %in, i64 28
+  %28 = load i32, ptr %arrayidx28, align 4
+  %arrayidx29 = getelementptr inbounds i32, ptr %in, i64 29
+  %29 = load i32, ptr %arrayidx29, align 4
+  %arrayidx30 = getelementptr inbounds i32, ptr %in, i64 30
+  %30 = load i32, ptr %arrayidx30, align 4
+  %arrayidx31 = getelementptr inbounds i32, ptr %in, i64 31
+  %31 = load i32, ptr %arrayidx31, align 4
+  %call = call noundef i32 @non_inlining_call(i32 noundef %0, i32 noundef %1, i32 noundef %2, i32 noundef %3, i32 noundef %4, i32 noundef %5, i32 noundef %6, i32 noundef %7, i32 noundef %8, i32 noundef %9, i32 noundef %10, i32 noundef %11, i32 noundef %12, i32 noundef %13, i32 noundef %14, i32 noundef %15, i32 noundef %16, i32 noundef %17, i32 noundef %18, i32 noundef %19, i32 noundef %20, i32 noundef %21, i32 noundef %22, i32 noundef %23, i32 noundef %24, i32 noundef %25, i32 noundef %26, i32 noundef %27, i32 noundef %28, i32 noundef %29, i32 noundef %30, i32 noundef %31)
+  %add = add i32 0, %call
+  %arrayidx32 = getelementptr inbounds i32, ptr %in2, i64 0
+  %32 = load i32, ptr %arrayidx32, align 4
+  %arrayidx33 = getelementptr inbounds i32, ptr %in2, i64 1
+  %33 = load i32, ptr %arrayidx33, align 4
+  %arrayidx34 = getelementptr inbounds i32, ptr %in2, i64 2
+  %34 = load i32, ptr %arrayidx34, align 4
+  %arrayidx35 = getelementptr inbounds i32, ptr %in2, i64 3
+  %35 = load i32, ptr %arrayidx35, align 4
+  %arrayidx36 = getelementptr inbounds i32, ptr %in2, i64 4
+  %36 = load i32, ptr %arrayidx36, align 4
+  %arrayidx37 = getelementptr inbounds i32, ptr %in2, i64 5
+  %37 = load i32, ptr %arrayidx37, align 4
+  %arrayidx38 = getelementptr inbounds i32, ptr %in2, i64 6
+  %38 = load i32, ptr %arrayidx38, align 4
+  %arrayidx39 = getelementptr inbounds i32, ptr %in2, i64 7
+  %39 = load i32, ptr %arrayidx39, align 4
+  %arrayidx40 = getelementptr inbounds i32, ptr %in2, i64 8
+  %40 = load i32, ptr %arrayidx40, align 4
+  %arrayidx41 = getelementptr inbounds i32, ptr %in2, i64 9
+  %41 = load i32, ptr %arrayidx41, align 4
+  %arrayidx42 = getelementptr inbounds i32, ptr %in2, i64 10
+  %42 = load i32, ptr %arrayidx42, align 4
+  %arrayidx43 = getelementptr inbounds i32, ptr %in2, i64 11
+  %43 = load i32, ptr %arrayidx43, align 4
+  %arrayidx44 = getelementptr inbounds i32, ptr %in2, i64 12
+  %44 = load i32, ptr %arrayidx44, align 4
+  %arrayidx45 = getelementptr inbounds i32, ptr %in2, i64 13
+  %45 = load i32, ptr %arrayidx45, align 4
+  %arrayidx46 = getelementptr inbounds i32, ptr %in2, i64 14
+  %46 = load i32, ptr %arrayidx46, align 4
+  %arrayidx47 = getelementptr inbounds i32, ptr %in2, i64 15
+  %47 = load i32, ptr %arrayidx47, align 4
+  %arrayidx48 = getelementptr inbounds i32, ptr %in2, i64 16
+  %48 = load i32, ptr %arrayidx48, align 4
+  %arrayidx49 = getelementptr inbounds i32, ptr %in2, i64 17
+  %49 = load i32, ptr %arrayidx49, align 4
+  %arrayidx50 = getelementptr inbounds i32, ptr %in2, i64 18
+  %50 = load i32, ptr %arrayidx50, align 4
+  %arrayidx51 = getelementptr inbounds i32, ptr %in2, i64 19
+  %51 = load i32, ptr %arrayidx51, align 4
+  %arrayidx52 = getelementptr inbounds i32, ptr %in2, i64 20
+  %52 = load i32, ptr %arrayidx52, align 4
+  %arrayidx53 = getelementptr inbounds i32, ptr %in2, i64 21
+  %53 = load i32, ptr %arrayidx53, align 4
+  %arrayidx54 = getelementptr inbounds i32, ptr %in2, i64 22
+  %54 = load i32, ptr %arrayidx54, align 4
+  %arrayidx55 = getelementptr inbounds i32, ptr %in2, i64 23
+  %55 = load i32, ptr %arrayidx55, align 4
+  %arrayidx56 = getelementptr inbounds i32, ptr %in2, i64 24
+  %56 = load i32, ptr %arrayidx56, align 4
+  %arrayidx57 = getelementptr inbounds i32, ptr %in2, i64 25
+  %57 = load i32, ptr %arrayidx57, align 4
+  %arrayidx58 = getelementptr inbounds i32, ptr %in2, i64 26
+  %58 = load i32, ptr %arrayidx58, align 4
+  %arrayidx59 = getelementptr inbounds i32, ptr %in2, i64 27
+  %59 = load i32, ptr %arrayidx59, align 4
+  %arrayidx60 = getelementptr inbounds i32, ptr %in2, i64 28
+  %60 = load i32, ptr %arrayidx60, align 4
+  %arrayidx61 = getelementptr inbounds i32, ptr %in2, i64 29
+  %61 = load i32, ptr %arrayidx61, align 4
+  %arrayidx62 = getelementptr inbounds i32, ptr %in2, i64 30
+  %62 = load i32, ptr %arrayidx62, align 4
+  %arrayidx63 = getelementptr inbounds i32, ptr %in2, i64 31
+  %63 = load i32, ptr %arrayidx63, align 4
+  %call64 = call noundef i32 @non_inlining_call(i32 noundef %32, i32 noundef %33, i32 noundef %34, i32 noundef %35, i32 noundef %36, i32 noundef %37, i32 noundef %38, i32 noundef %39, i32 noundef %40, i32 noundef %41, i32 noundef %42, i32 noundef %43, i32 noundef %44, i32 noundef %45, i32 noundef %46, i32 noundef %47, i32 noundef %48, i32 noundef %49, i32 noundef %50, i32 noundef %51, i32 noundef %52, i32 noundef %53, i32 noundef %54, i32 noundef %55, i32 noundef %56, i32 noundef %57, i32 noundef %58, i32 noundef %59, i32 noundef %60, i32 noundef %61, i32 noundef %62, i32 noundef %63)
+  %add65 = add i32 %add, %call64
+  %arrayidx66 = getelementptr inbounds i32, ptr %in, i64 0
+  %64 = load i32, ptr %arrayidx66, align 4
+  %arrayidx67 = getelementptr inbounds i32, ptr %in, i64 1
+  %65 = load i32, ptr %arrayidx67, align 4
+  %arrayidx68 = getelementptr inbounds i32, ptr %in, i64 2
+  %66 = load i32, ptr %arrayidx68, align 4
+  %arrayidx69 = getelementptr inbounds i32, ptr %in, i64 3
+  %67 = load i32, ptr %arrayidx69, align 4
+  %arrayidx70 = getelementptr inbounds i32, ptr %in, i64 4
+  %68 = load i32, ptr %arrayidx70, align 4
+  %arrayidx71 = getelementptr inbounds i32, ptr %in, i64 5
+  %69 = load i32, ptr %arrayidx71, align 4
+  %arrayidx72 = getelementptr inbounds i32, ptr %in, i64 6
+  %70 = load i32, ptr %arrayidx72, align 4
+  %arrayidx73 = getelementptr inbounds i32, ptr %in, i64 7
+  %71 = load i32, ptr %arrayidx73, align 4
+  %arrayidx74 = getelementptr inbounds i32, ptr %in, i64 8
+  %72 = load i32, ptr %arrayidx74, align 4
+  %arrayidx75 = getelementptr inbounds i32, ptr %in, i64 9
+  %73 = load i32, ptr %arrayidx75, align 4
+  %arrayidx76 = getelementptr inbounds i32, ptr %in, i64 10
+  %74 = load i32, ptr %arrayidx76, align 4
+  %arrayidx77 = getelementptr inbounds i32, ptr %in, i64 11
+  %75 = load i32, ptr %arrayidx77, align 4
+  %arrayidx78 = getelementptr inbounds i32, ptr %in, i64 12
+  %76 = load i32, ptr %arrayidx78, align 4
+  %arrayidx79 = getelementptr inbounds i32, ptr %in, i64 13
+  %77 = load i32, ptr %arrayidx79, align 4
+  %arrayidx80 = getelementptr inbounds i32, ptr %in, i64 14
+  %78 = load i32, ptr %arrayidx80, align 4
+  %arrayidx81 = getelementptr inbounds i32, ptr %in, i64 15
+  %79 = load i32, ptr %arrayidx81, align 4
+  %arrayidx82 = getelementptr inbounds i32, ptr %in, i64 16
+  %80 = load i32, ptr %arrayidx82, align 4
+  %arrayidx83 = getelementptr inbounds i32, ptr %in, i64 17
+  %81 = load i32, ptr %arrayidx83, align 4
+  %arrayidx84 = getelementptr inbounds i32, ptr %in, i64 18
+  %82 = load i32, ptr %arrayidx84, align 4
+  %arrayidx85 = getelementptr inbounds i32, ptr %in, i64 19
+  %83 = load i32, ptr %arrayidx85, align 4
+  %arrayidx86 = getelementptr inbounds i32, ptr %in, i64 20
+  %84 = load i32, ptr %arrayidx86, align 4
+  %arrayidx87 = getelementptr inbounds i32, ptr %in, i64 21
+  %85 = load i32, ptr %arrayidx87, align 4
+  %arrayidx88 = getelementptr inbounds i32, ptr %in, i64 22
+  %86 = load i32, ptr %arrayidx88, align 4
+  %arrayidx89 = getelementptr inbounds i32, ptr %in, i64 23
+  %87 = load i32, ptr %arrayidx89, align 4
+  %arrayidx90 = getelementptr inbounds i32, ptr %in, i64 24
+  %88 = load i32, ptr %arrayidx90, align 4
+  %arrayidx91 = getelementptr inbounds i32, ptr %in, i64 25
+  %89 = load i32, ptr %arrayidx91, align 4
+  %arrayidx92 = getelementptr inbounds i32, ptr %in, i64 26
+  %90 = load i32, ptr %arrayidx92, align 4
+  %arrayidx93 = getelementptr inbounds i32, ptr %in, i64 27
+  %91 = load i32, ptr %arrayidx93, align 4
+  %arrayidx94 = getelementptr inbounds i32, ptr %in, i64 28
+  %92 = load i32, ptr %arrayidx94, align 4
+  %arrayidx95 = getelementptr inbounds i32, ptr %in, i64 29
+  %93 = load i32, ptr %arrayidx95, align 4
+  %arrayidx96 = getelementptr inbounds i32, ptr %in, i64 30
+  %94 = load i32, ptr %arrayidx96, align 4
+  %arrayidx97 = getelementptr inbounds i32, ptr %in, i64 31
+  %95 = load i32, ptr %arrayidx97, align 4
+  %arrayidx98 = getelementptr inbounds i32, ptr %in, i64 32
+  %96 = load i32, ptr %arrayidx98, align 4
+  %arrayidx99 = getelementptr inbounds i32, ptr %in, i64 33
+  %97 = load i32, ptr %arrayidx99, align 4
+  %arrayidx100 = getelementptr inbounds i32, ptr %in, i64 34
+  %98 = load i32, ptr %arrayidx100, align 4
+  %arrayidx101 = getelementptr inbounds i32, ptr %in, i64 35
+  %99 = load i32, ptr %arrayidx101, align 4
+  %arrayidx102 = getelementptr inbounds i32, ptr %in, i64 36
+  %100 = load i32, ptr %arrayidx102, align 4
+  %arrayidx103 = getelementptr inbounds i32, ptr %in, i64 37
+  %101 = load i32, ptr %arrayidx103, align 4
+  %arrayidx104 = getelementptr inbounds i32, ptr %in, i64 38
+  %102 = load i32, ptr %arrayidx104, align 4
+  %arrayidx105 = getelementptr inbounds i32, ptr %in, i64 39
+  %103 = load i32, ptr %arrayidx105, align 4
+  %arrayidx106 = getelementptr inbounds i32, ptr %in, i64 40
+  %104 = load i32, ptr %arrayidx106, align 4
+  %arrayidx107 = getelementptr inbounds i32, ptr %in, i64 41
+  %105 = load i32, ptr %arrayidx107, align 4
+  %arrayidx108 = getelementptr inbounds i32, ptr %in, i64 42
+  %106 = load i32, ptr %arrayidx108, align 4
+  %arrayidx109 = getelementptr inbounds i32, ptr %in, i64 43
+  %107 = load i32, ptr %arrayidx109, align 4
+  %arrayidx110 = getelementptr inbounds i32, ptr %in, i64 44
+  %108 = load i32, ptr %arrayidx110, align 4
+  %arrayidx111 = getelementptr inbounds i32, ptr %in, i64 45
+  %109 = load i32, ptr %arrayidx111, align 4
+  %arrayidx112 = getelementptr inbounds i32, ptr %in, i64 46
+  %110 = load i32, ptr %arrayidx112, align 4
+  %arrayidx113 = getelementptr inbounds i32, ptr %in, i64 47
+  %111 = load i32, ptr %arrayidx113, align 4
+  %arrayidx114 = getelementptr inbounds i32, ptr %in, i64 48
+  %112 = load i32, ptr %arrayidx114, align 4
+  %arrayidx115 = getelementptr inbounds i32, ptr %in, i64 49
+  %113 = load i32, ptr %arrayidx115, align 4
+  %arrayidx116 = getelementptr inbounds i32, ptr %in, i64 50
+  %114 = load i32, ptr %arrayidx116, align 4
+  %arrayidx117 = getelementptr inbounds i32, ptr %in, i64 51
+  %115 = load i32, ptr %arrayidx117, align 4
+  %call118 = call noundef i32 @inlining_call(i32 noundef %64, i32 noundef %65, i32 noundef %66, i32 noundef %67, i32 noundef %68, i32 noundef %69, i32 noundef %70, i32 noundef %71, i32 noundef %72, i32 noundef %73, i32 noundef %74, i32 noundef %75, i32 noundef %76, i32 noundef %77, i32 noundef %78, i32 noundef %79, i32 noundef %80, i32 noundef %81, i32 noundef %82, i32 noundef %83, i32 noundef %84, i32 noundef %85, i32 noundef %86, i32 noundef %87, i32 noundef %88, i32 noundef %89, i32 noundef %90, i32 noundef %91, i32 noundef %92, i32 noundef %93, i32 noundef %94, i32 noundef %95, i32 noundef %96, i32 noundef %97, i32 noundef %98, i32 noundef %99, i32 noundef %100, i32 noundef %101, i32 noundef %102, i32 noundef %103, i32 noundef %104, i32 noundef %105, i32 noundef %106, i32 noundef %107, i32 noundef %108, i32 noundef %109, i32 noundef %110, i32 noundef %111, i32 noundef %112, i32 noundef %113, i32 noundef %114, i32 noundef %115)
+  %add119 = add i32 %add65, %call118
+  %arrayidx120 = getelementptr inbounds i32, ptr %in2, i64 0
+  %116 = load i32, ptr %arrayidx120, align 4
+  %arrayidx121 = getelementptr inbounds i32, ptr %in2, i64 1
+  %117 = load i32, ptr %arrayidx121, align 4
+  %arrayidx122 = getelementptr inbounds i32, ptr %in2, i64 2
+  %118 = load i32, ptr %arrayidx122, align 4
+  %arrayidx123 = getelementptr inbounds i32, ptr %in2, i64 3
+  %119 = load i32, ptr %arrayidx123, align 4
+  %arrayidx124 = getelementptr inbounds i32, ptr %in2, i64 4
+  %120 = load i32, ptr %arrayidx124, align 4
+  %arrayidx125 = getelementptr inbounds i32, ptr %in2, i64 5
+  %121 = load i32, ptr %arrayidx125, align 4
+  %arrayidx126 = getelementptr inbounds i32, ptr %in2, i64 6
+  %122 = load i32, ptr %arrayidx126, align 4
+  %arrayidx127 = getelementptr inbounds i32, ptr %in2, i64 7
+  %123 = load i32, ptr %arrayidx127, align 4
+  %arrayidx128 = getelementptr inbounds i32, ptr %in2, i64 8
+  %124 = load i32, ptr %arrayidx128, align 4
+  %arrayidx129 = getelementptr inbounds i32, ptr %in2, i64 9
+  %125 = load i32, ptr %arrayidx129, align 4
+  %arrayidx130 = getelementptr inbounds i32, ptr %in2, i64 10
+  %126 = load i32, ptr %arrayidx130, align 4
+  %arrayidx131 = getelementptr inbounds i32, ptr %in2, i64 11
+  %127 = load i32, ptr %arrayidx131, align 4
+  %arrayidx132 = getelementptr inbounds i32, ptr %in2, i64 12
+  %128 = load i32, ptr %arrayidx132, align 4
+  %arrayidx133 = getelementptr inbounds i32, ptr %in2, i64 13
+  %129 = load i32, ptr %arrayidx133, align 4
+  %arrayidx134 = getelementptr inbounds i32, ptr %in2, i64 14
+  %130 = load i32, ptr %arrayidx134, align 4
+  %arrayidx135 = getelementptr inbounds i32, ptr %in2, i64 15
+  %131 = load i32, ptr %arrayidx135, align 4
+  %arrayidx136 = getelementptr inbounds i32, ptr %in2, i64 16
+  %132 = load i32, ptr %arrayidx136, align 4
+  %arrayidx137 = getelementptr inbounds i32, ptr %in2, i64 17
+  %133 = load i32, ptr %arrayidx137, align 4
+  %arrayidx138 = getelementptr inbounds i32, ptr %in2, i64 18
+  %134 = load i32, ptr %arrayidx138, align 4
+  %arrayidx139 = getelementptr inbounds i32, ptr %in2, i64 19
+  %135 = load i32, ptr %arrayidx139, align 4
+  %arrayidx140 = getelementptr inbounds i32, ptr %in2, i64 20
+  %136 = load i32, ptr %arrayidx140, align 4
+  %arrayidx141 = getelementptr inbounds i32, ptr %in2, i64 21
+  %137 = load i32, ptr %arrayidx141, align 4
+  %arrayidx142 = getelementptr inbounds i32, ptr %in2, i64 22
+  %138 = load i32, ptr %arrayidx142, align 4
+  %arrayidx143 = getelementptr inbounds i32, ptr %in2, i64 23
+  %139 = load i32, ptr %arrayidx143, align 4
+  %arrayidx144 = getelementptr inbounds i32, ptr %in2, i64 24
+  %140 = load i32, ptr %arrayidx144, align 4
+  %arrayidx145 = getelementptr inbounds i32, ptr %in2, i64 25
+  %141 = load i32, ptr %arrayidx145, align 4
+  %arrayidx146 = getelementptr inbounds i32, ptr %in2, i64 26
+  %142 = load i32, ptr %arrayidx146, align 4
+  %arrayidx147 = getelementptr inbounds i32, ptr %in2, i64 27
+  %143 = load i32, ptr %arrayidx147, align 4
+  %arrayidx148 = getelementptr inbounds i32, ptr %in2, i64 28
+  %144 = load i32, ptr %arrayidx148, align 4
+  %arrayidx149 = getelementptr inbounds i32, ptr %in2, i64 29
+  %145 = load i32, ptr %arrayidx149, align 4
+  %arrayidx150 = getelementptr inbounds i32, ptr %in2, i64 30
+  %146 = load i32, ptr %arrayidx150, align 4
+  %arrayidx151 = getelementptr inbounds i32, ptr %in2, i64 31
+  %147 = load i32, ptr %arrayidx151, align 4
+  %arrayidx152 = getelementptr inbounds i32, ptr %in2, i64 32
+  %148 = load i32, ptr %arrayidx152, align 4
+  %arrayidx153 = getelementptr inbounds i32, ptr %in2, i64 33
+  %149 = load i32, ptr %arrayidx153, align 4
+  %arrayidx154 = getelementptr inbounds i32, ptr %in2, i64 34
+  %150 = load i32, ptr %arrayidx154, align 4
+  %arrayidx155 = getelementptr inbounds i32, ptr %in2, i64 35
+  %151 = load i32, ptr %arrayidx155, align 4
+  %arrayidx156 = getelementptr inbounds i32, ptr %in2, i64 36
+  %152 = load i32, ptr %arrayidx156, align 4
+  %arrayidx157 = getelementptr inbounds i32, ptr %in2, i64 37
+  %153 = load i32, ptr %arrayidx157, align 4
+  %arrayidx158 = getelementptr inbounds i32, ptr %in2, i64 38
+  %154 = load i32, ptr %arrayidx158, align 4
+  %arrayidx159 = getelementptr inbounds i32, ptr %in2, i64 39
+  %155 = load i32, ptr %arrayidx159, align 4
+  %arrayidx160 = getelementptr inbounds i32, ptr %in2, i64 40
+  %156 = load i32, ptr %arrayidx160, align 4
+  %arrayidx161 = getelementptr inbounds i32, ptr %in2, i64 41
+  %157 = load i32, ptr %arrayidx161, align 4
+  %arrayidx162 = getelementptr inbounds i32, ptr %in2, i64 42
+  %158 = load i32, ptr %arrayidx162, align 4
+  %arrayidx163 = getelementptr inbounds i32, ptr %in2, i64 43
+  %159 = load i32, ptr %arrayidx163, align 4
+  %arrayidx164 = getelementptr inbounds i32, ptr %in2, i64 44
+  %160 = load i32, ptr %arrayidx164, align 4
+  %arrayidx165 = getelementptr inbounds i32, ptr %in2, i64 45
+  %161 = load i32, ptr %arrayidx165, align 4
+  %arrayidx166 = getelementptr inbounds i32, ptr %in2, i64 46
+  %162 = load i32, ptr %arrayidx166, align 4
+  %arrayidx167 = getelementptr inbounds i32, ptr %in2, i64 47
+  %163 = load i32, ptr %arrayidx167, align 4
+  %arrayidx168 = getelementptr inbounds i32, ptr %in2, i64 48
+  %164 = load i32, ptr %arrayidx168, align 4
+  %arrayidx169 = getelementptr inbounds i32, ptr %in2, i64 49
+  %165 = load i32, ptr %arrayidx169, align 4
+  %arrayidx170 = getelementptr inbounds i32, ptr %in2, i64 50
+  %166 = load i32, ptr %arrayidx170, align 4
+  %arrayidx171 = getelementptr inbounds i32, ptr %in2, i64 51
+  %167 = load i32, ptr %arrayidx171, align 4
+  %call172 = call noundef i32 @inlining_call(i32 noundef %116, i32 noundef %117, i32 noundef %118, i32 noundef %119, i32 noundef %120, i32 noundef %121, i32 noundef %122, i32 noundef %123, i32 noundef %124, i32 noundef %125, i32 noundef %126, i32 noundef %127, i32 noundef %128, i32 noundef %129, i32 noundef %130, i32 noundef %131, i32 noundef %132, i32 noundef %133, i32 noundef %134, i32 noundef %135, i32 noundef %136, i32 noundef %137, i32 noundef %138, i32 noundef %139, i32 noundef %140, i32 noundef %141, i32 noundef %142, i32 noundef %143, i32 noundef %144, i32 noundef %145, i32 noundef %146, i32 noundef %147, i32 noundef %148, i32 noundef %149, i32 noundef %150, i32 noundef %151, i32 noundef %152, i32 noundef %153, i32 noundef %154, i32 noundef %155, i32 noundef %156, i32 noundef %157, i32 noundef %158, i32 noundef %159, i32 noundef %160, i32 noundef %161, i32 noundef %162, i32 noundef %163, i32 noundef %164, i32 noundef %165, i32 noundef %166, i32 noundef %167)
+  %add173 = add i32 %add119, %call172
+  ret i32 %add173
+}