#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */
typedef int /*<<< orphan*/ const int64_t;

/* Variables and functions */
int /*<<< orphan*/ fdifference(int /*<<< orphan*/ const *,
                               int /*<<< orphan*/ const *);
int /*<<< orphan*/ fproduct(int /*<<< orphan*/ const *,
                            int /*<<< orphan*/ const *,
                            int /*<<< orphan*/ const *);
int /*<<< orphan*/ freduce_coefficients(int /*<<< orphan*/ const *);
int /*<<< orphan*/ freduce_degree(int /*<<< orphan*/ const *);
int /*<<< orphan*/ fscalar_product(int /*<<< orphan*/ const *,
                                   int /*<<< orphan*/ const *, int);
int /*<<< orphan*/ fsquare(int /*<<< orphan*/ const *,
                           int /*<<< orphan*/ const *);
int /*<<< orphan*/ fsum(int /*<<< orphan*/ const *, int /*<<< orphan*/ const *);
int /*<<< orphan*/ memcpy(int /*<<< orphan*/ const *,
                          int /*<<< orphan*/ const *, int);
int /*<<< orphan*/ memset(int /*<<< orphan*/ const *, int /*<<< orphan*/, int);
void fmonty(int64_t *x2, int64_t *z2, int64_t *x3, int64_t *z3, int64_t *x,
            int64_t *z, int64_t *xprime, int64_t *zprime, const int64_t *qmqp) {
  int64_t origx[10], origxprime[10], zzz[19], xx[19], zz[19], xxprime[19],
      zzprime[19], zzzprime[19], xxxprime[19];
  memcpy(origx, x, 10 * sizeof(int64_t));
  fsum(x, z);
  fdifference(z, origx);
  memcpy(origxprime, xprime, sizeof(int64_t) * 10);
  fsum(xprime, zprime);
  fdifference(zprime, origxprime);
  fproduct(xxprime, xprime, z);
  fproduct(zzprime, x, zprime);
  freduce_degree(xxprime);
  freduce_coefficients(xxprime);
  freduce_degree(zzprime);
  freduce_coefficients(zzprime);
  memcpy(origxprime, xxprime, sizeof(int64_t) * 10);
  fsum(xxprime, zzprime);
  fdifference(zzprime, origxprime);
  fsquare(xxxprime, xxprime);
  fsquare(zzzprime, zzprime);
  fproduct(zzprime, zzzprime, qmqp);
  freduce_degree(zzprime);
  freduce_coefficients(zzprime);
  memcpy(x3, xxxprime, sizeof(int64_t) * 10);
  memcpy(z3, zzprime, sizeof(int64_t) * 10);
  fsquare(xx, x);
  fsquare(zz, z);
  fproduct(x2, xx, zz);
  freduce_degree(x2);
  freduce_coefficients(x2);
  fdifference(zz, xx);
  memset(zzz + 10, 0, sizeof(int64_t) * 9);
  fscalar_product(zzz, zz, 121665);
  freduce_coefficients(zzz);
  fsum(zzz, xx);
  fproduct(z2, zz, zzz);
  freduce_degree(z2);
  freduce_coefficients(z2);
}


x86 assembly (clang, -O0):
<fmonty>:
push   %rbp
mov    %rsp,%rbp
sub    $0x2c0,%rsp
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
lea    -0x60(%rbp),%rdi
mov    -0x28(%rbp),%rsi
mov    $0x28,%edx
call   1060 <memcpy@plt>
mov    -0x28(%rbp),%rdi
mov    -0x30(%rbp),%rsi
call   10a0 <fsum@plt>
mov    -0x30(%rbp),%rdi
lea    -0x60(%rbp),%rsi
call   1070 <fdifference@plt>
lea    -0x90(%rbp),%rdi
mov    0x10(%rbp),%rsi
mov    $0x28,%edx
call   1060 <memcpy@plt>
mov    0x10(%rbp),%rdi
mov    0x18(%rbp),%rsi
call   10a0 <fsum@plt>
mov    0x18(%rbp),%rdi
lea    -0x90(%rbp),%rsi
call   1070 <fdifference@plt>
lea    -0x1d0(%rbp),%rdi
mov    0x10(%rbp),%rsi
mov    -0x30(%rbp),%rdx
call   1030 <fproduct@plt>
lea    -0x220(%rbp),%rdi
mov    -0x28(%rbp),%rsi
mov    0x18(%rbp),%rdx
call   1030 <fproduct@plt>
lea    -0x1d0(%rbp),%rdi
call   1080 <freduce_degree@plt>
lea    -0x1d0(%rbp),%rdi
call   1050 <freduce_coefficients@plt>
lea    -0x220(%rbp),%rdi
call   1080 <freduce_degree@plt>
lea    -0x220(%rbp),%rdi
call   1050 <freduce_coefficients@plt>
lea    -0x90(%rbp),%rdi
lea    -0x1d0(%rbp),%rsi
mov    $0x28,%edx
call   1060 <memcpy@plt>
lea    -0x1d0(%rbp),%rdi
lea    -0x220(%rbp),%rsi
call   10a0 <fsum@plt>
lea    -0x220(%rbp),%rdi
lea    -0x90(%rbp),%rsi
call   1070 <fdifference@plt>
lea    -0x2c0(%rbp),%rdi
lea    -0x1d0(%rbp),%rsi
call   1090 <fsquare@plt>
lea    -0x270(%rbp),%rdi
lea    -0x220(%rbp),%rsi
call   1090 <fsquare@plt>
lea    -0x220(%rbp),%rdi
lea    -0x270(%rbp),%rsi
mov    0x20(%rbp),%rdx
call   1030 <fproduct@plt>
lea    -0x220(%rbp),%rdi
call   1080 <freduce_degree@plt>
lea    -0x220(%rbp),%rdi
call   1050 <freduce_coefficients@plt>
mov    -0x18(%rbp),%rdi
lea    -0x2c0(%rbp),%rsi
mov    $0x28,%edx
call   1060 <memcpy@plt>
mov    -0x20(%rbp),%rdi
lea    -0x220(%rbp),%rsi
mov    $0x28,%edx
call   1060 <memcpy@plt>
lea    -0x130(%rbp),%rdi
mov    -0x28(%rbp),%rsi
call   1090 <fsquare@plt>
lea    -0x180(%rbp),%rdi
mov    -0x30(%rbp),%rsi
call   1090 <fsquare@plt>
mov    -0x8(%rbp),%rdi
lea    -0x130(%rbp),%rsi
lea    -0x180(%rbp),%rdx
call   1030 <fproduct@plt>
mov    -0x8(%rbp),%rdi
call   1080 <freduce_degree@plt>
mov    -0x8(%rbp),%rdi
call   1050 <freduce_coefficients@plt>
lea    -0x180(%rbp),%rdi
lea    -0x130(%rbp),%rsi
call   1070 <fdifference@plt>
lea    -0xe0(%rbp),%rdi
add    $0x28,%rdi
xor    %esi,%esi
mov    $0x24,%edx
call   1040 <memset@plt>
lea    -0xe0(%rbp),%rdi
lea    -0x180(%rbp),%rsi
mov    $0x1db41,%edx
call   10b0 <fscalar_product@plt>
lea    -0xe0(%rbp),%rdi
call   1050 <freduce_coefficients@plt>
lea    -0xe0(%rbp),%rdi
lea    -0x130(%rbp),%rsi
call   10a0 <fsum@plt>
mov    -0x10(%rbp),%rdi
lea    -0x180(%rbp),%rsi
lea    -0xe0(%rbp),%rdx
call   1030 <fproduct@plt>
mov    -0x10(%rbp),%rdi
call   1080 <freduce_degree@plt>
mov    -0x10(%rbp),%rdi
call   1050 <freduce_coefficients@plt>
add    $0x2c0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<fmonty>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x2b8,%rsp
mov    %r9,%rbx
mov    %r8,%r12
mov    %rcx,0x8(%rsp)
mov    %rdx,(%rsp)
mov    %rsi,0x18(%rsp)
mov    %rdi,0x10(%rsp)
mov    0x2f8(%rsp),%r15
mov    0x2f0(%rsp),%r13
lea    0xa0(%rsp),%rbp
mov    %rbp,%rdi
mov    %r8,%rsi
mov    $0x28,%edx
call   1060 <memcpy@plt>
mov    %r12,%rdi
mov    %rbx,%rsi
call   10a0 <fsum@plt>
mov    %rbx,%rdi
mov    %rbp,%rsi
call   1070 <fdifference@plt>
lea    0x70(%rsp),%r14
mov    %r14,%rdi
mov    %r13,%rsi
mov    $0x28,%edx
call   1060 <memcpy@plt>
mov    %r13,%rdi
mov    %r15,%rsi
call   10a0 <fsum@plt>
mov    %r15,%rdi
mov    %r15,%rbp
mov    %r14,%rsi
call   1070 <fdifference@plt>
lea    0x1c0(%rsp),%r15
mov    %r15,%rdi
mov    %r13,%rsi
mov    %rbx,%rdx
call   1030 <fproduct@plt>
lea    0x170(%rsp),%r13
mov    %r13,%rdi
mov    %r12,%rsi
mov    %rbp,%rdx
call   1030 <fproduct@plt>
mov    %r15,%rdi
call   1080 <freduce_degree@plt>
mov    %r15,%rdi
call   1050 <freduce_coefficients@plt>
mov    %r13,%rdi
call   1080 <freduce_degree@plt>
mov    %r13,%rdi
call   1050 <freduce_coefficients@plt>
mov    %r14,%rdi
mov    %r15,%rsi
mov    $0x28,%edx
call   1060 <memcpy@plt>
mov    %r15,%rdi
mov    %r13,%rsi
call   10a0 <fsum@plt>
mov    %r13,%rdi
mov    %r14,%rsi
call   1070 <fdifference@plt>
lea    0xd0(%rsp),%r14
mov    %r14,%rdi
mov    %r15,%rsi
call   1090 <fsquare@plt>
lea    0x120(%rsp),%rbp
mov    %rbp,%rdi
mov    %r13,%rsi
call   1090 <fsquare@plt>
mov    %r13,%rdi
mov    %rbp,%rsi
mov    0x300(%rsp),%rdx
call   1030 <fproduct@plt>
mov    %r13,%rdi
call   1080 <freduce_degree@plt>
mov    %r13,%rdi
call   1050 <freduce_coefficients@plt>
mov    (%rsp),%rdi
mov    %r14,%rsi
mov    $0x28,%edx
call   1060 <memcpy@plt>
mov    0x8(%rsp),%rdi
mov    %r13,%rsi
mov    $0x28,%edx
call   1060 <memcpy@plt>
lea    0x260(%rsp),%r14
mov    %r14,%rdi
mov    %r12,%rsi
call   1090 <fsquare@plt>
lea    0x210(%rsp),%r15
mov    %r15,%rdi
mov    %rbx,%rsi
call   1090 <fsquare@plt>
mov    0x10(%rsp),%rbx
mov    %rbx,%rdi
mov    %r14,%rsi
mov    %r15,%rdx
call   1030 <fproduct@plt>
mov    %rbx,%rdi
call   1080 <freduce_degree@plt>
mov    %rbx,%rdi
call   1050 <freduce_coefficients@plt>
mov    %r15,%rdi
mov    %r14,%rsi
call   1070 <fdifference@plt>
lea    0x48(%rsp),%rdi
xor    %esi,%esi
mov    $0x24,%edx
call   1040 <memset@plt>
lea    0x20(%rsp),%rbp
mov    %rbp,%rdi
mov    %r15,%rsi
mov    $0x1db41,%edx
call   10b0 <fscalar_product@plt>
mov    %rbp,%rdi
call   1050 <freduce_coefficients@plt>
mov    %rbp,%rdi
mov    %r14,%rsi
call   10a0 <fsum@plt>
mov    0x18(%rsp),%rbx
mov    %rbx,%rdi
mov    %r15,%rsi
mov    %rbp,%rdx
call   1030 <fproduct@plt>
mov    %rbx,%rdi
call   1080 <freduce_degree@plt>
mov    %rbx,%rdi
call   1050 <freduce_coefficients@plt>
add    $0x2b8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @fmonty(i32* %0, i32* %1, i32* %2, i32* %3, i32* %4, i32* %5, i32* %6, i32* %7, i32* %8) {
%10 = alloca i32*
%11 = alloca i32*
%12 = alloca i32*
%13 = alloca i32*
%14 = alloca i32*
%15 = alloca i32*
%16 = alloca i32*
%17 = alloca i32*
%18 = alloca i32*
%19 = alloca [10 x i32]
%20 = alloca [10 x i32]
%21 = alloca [19 x i32]
%22 = alloca [19 x i32]
%23 = alloca [19 x i32]
%24 = alloca [19 x i32]
%25 = alloca [19 x i32]
%26 = alloca [19 x i32]
%27 = alloca [19 x i32]
store i32* %0, i32** %10
store i32* %1, i32** %11
store i32* %2, i32** %12
store i32* %3, i32** %13
store i32* %4, i32** %14
store i32* %5, i32** %15
store i32* %6, i32** %16
store i32* %7, i32** %17
store i32* %8, i32** %18
%28 = getelementptr inbounds [10 x i32], [10 x i32]* %19, i64 0, i64 0
%29 = load i32*, i32** %14
%30 = call i32 @memcpy(i32* %28, i32* %29, i32 40)
%31 = load i32*, i32** %14
%32 = load i32*, i32** %15
%33 = call i32 @fsum(i32* %31, i32* %32)
%34 = load i32*, i32** %15
%35 = getelementptr inbounds [10 x i32], [10 x i32]* %19, i64 0, i64 0
%36 = call i32 @fdifference(i32* %34, i32* %35)
%37 = getelementptr inbounds [10 x i32], [10 x i32]* %20, i64 0, i64 0
%38 = load i32*, i32** %16
%39 = call i32 @memcpy(i32* %37, i32* %38, i32 40)
%40 = load i32*, i32** %16
%41 = load i32*, i32** %17
%42 = call i32 @fsum(i32* %40, i32* %41)
%43 = load i32*, i32** %17
%44 = getelementptr inbounds [10 x i32], [10 x i32]* %20, i64 0, i64 0
%45 = call i32 @fdifference(i32* %43, i32* %44)
%46 = getelementptr inbounds [19 x i32], [19 x i32]* %24, i64 0, i64 0
%47 = load i32*, i32** %16
%48 = load i32*, i32** %15
%49 = call i32 @fproduct(i32* %46, i32* %47, i32* %48)
%50 = getelementptr inbounds [19 x i32], [19 x i32]* %25, i64 0, i64 0
%51 = load i32*, i32** %14
%52 = load i32*, i32** %17
%53 = call i32 @fproduct(i32* %50, i32* %51, i32* %52)
%54 = getelementptr inbounds [19 x i32], [19 x i32]* %24, i64 0, i64 0
%55 = call i32 @freduce_degree(i32* %54)
%56 = getelementptr inbounds [19 x i32], [19 x i32]* %24, i64 0, i64 0
%57 = call i32 @freduce_coefficients(i32* %56)
%58 = getelementptr inbounds [19 x i32], [19 x i32]* %25, i64 0, i64 0
%59 = call i32 @freduce_degree(i32* %58)
%60 = getelementptr inbounds [19 x i32], [19 x i32]* %25, i64 0, i64 0
%61 = call i32 @freduce_coefficients(i32* %60)
%62 = getelementptr inbounds [10 x i32], [10 x i32]* %20, i64 0, i64 0
%63 = getelementptr inbounds [19 x i32], [19 x i32]* %24, i64 0, i64 0
%64 = call i32 @memcpy(i32* %62, i32* %63, i32 40)
%65 = getelementptr inbounds [19 x i32], [19 x i32]* %24, i64 0, i64 0
%66 = getelementptr inbounds [19 x i32], [19 x i32]* %25, i64 0, i64 0
%67 = call i32 @fsum(i32* %65, i32* %66)
%68 = getelementptr inbounds [19 x i32], [19 x i32]* %25, i64 0, i64 0
%69 = getelementptr inbounds [10 x i32], [10 x i32]* %20, i64 0, i64 0
%70 = call i32 @fdifference(i32* %68, i32* %69)
%71 = getelementptr inbounds [19 x i32], [19 x i32]* %27, i64 0, i64 0
%72 = getelementptr inbounds [19 x i32], [19 x i32]* %24, i64 0, i64 0
%73 = call i32 @fsquare(i32* %71, i32* %72)
%74 = getelementptr inbounds [19 x i32], [19 x i32]* %26, i64 0, i64 0
%75 = getelementptr inbounds [19 x i32], [19 x i32]* %25, i64 0, i64 0
%76 = call i32 @fsquare(i32* %74, i32* %75)
%77 = getelementptr inbounds [19 x i32], [19 x i32]* %25, i64 0, i64 0
%78 = getelementptr inbounds [19 x i32], [19 x i32]* %26, i64 0, i64 0
%79 = load i32*, i32** %18
%80 = call i32 @fproduct(i32* %77, i32* %78, i32* %79)
%81 = getelementptr inbounds [19 x i32], [19 x i32]* %25, i64 0, i64 0
%82 = call i32 @freduce_degree(i32* %81)
%83 = getelementptr inbounds [19 x i32], [19 x i32]* %25, i64 0, i64 0
%84 = call i32 @freduce_coefficients(i32* %83)
%85 = load i32*, i32** %12
%86 = getelementptr inbounds [19 x i32], [19 x i32]* %27, i64 0, i64 0
%87 = call i32 @memcpy(i32* %85, i32* %86, i32 40)
%88 = load i32*, i32** %13
%89 = getelementptr inbounds [19 x i32], [19 x i32]* %25, i64 0, i64 0
%90 = call i32 @memcpy(i32* %88, i32* %89, i32 40)
%91 = getelementptr inbounds [19 x i32], [19 x i32]* %22, i64 0, i64 0
%92 = load i32*, i32** %14
%93 = call i32 @fsquare(i32* %91, i32* %92)
%94 = getelementptr inbounds [19 x i32], [19 x i32]* %23, i64 0, i64 0
%95 = load i32*, i32** %15
%96 = call i32 @fsquare(i32* %94, i32* %95)
%97 = load i32*, i32** %10
%98 = getelementptr inbounds [19 x i32], [19 x i32]* %22, i64 0, i64 0
%99 = getelementptr inbounds [19 x i32], [19 x i32]* %23, i64 0, i64 0
%100 = call i32 @fproduct(i32* %97, i32* %98, i32* %99)
%101 = load i32*, i32** %10
%102 = call i32 @freduce_degree(i32* %101)
%103 = load i32*, i32** %10
%104 = call i32 @freduce_coefficients(i32* %103)
%105 = getelementptr inbounds [19 x i32], [19 x i32]* %23, i64 0, i64 0
%106 = getelementptr inbounds [19 x i32], [19 x i32]* %22, i64 0, i64 0
%107 = call i32 @fdifference(i32* %105, i32* %106)
%108 = getelementptr inbounds [19 x i32], [19 x i32]* %21, i64 0, i64 0
%109 = getelementptr inbounds i32, i32* %108, i64 10
%110 = call i32 @memset(i32* %109, i32 0, i32 36)
%111 = getelementptr inbounds [19 x i32], [19 x i32]* %21, i64 0, i64 0
%112 = getelementptr inbounds [19 x i32], [19 x i32]* %23, i64 0, i64 0
%113 = call i32 @fscalar_product(i32* %111, i32* %112, i32 121665)
%114 = getelementptr inbounds [19 x i32], [19 x i32]* %21, i64 0, i64 0
%115 = call i32 @freduce_coefficients(i32* %114)
%116 = getelementptr inbounds [19 x i32], [19 x i32]* %21, i64 0, i64 0
%117 = getelementptr inbounds [19 x i32], [19 x i32]* %22, i64 0, i64 0
%118 = call i32 @fsum(i32* %116, i32* %117)
%119 = load i32*, i32** %11
%120 = getelementptr inbounds [19 x i32], [19 x i32]* %23, i64 0, i64 0
%121 = getelementptr inbounds [19 x i32], [19 x i32]* %21, i64 0, i64 0
%122 = call i32 @fproduct(i32* %119, i32* %120, i32* %121)
%123 = load i32*, i32** %11
%124 = call i32 @freduce_degree(i32* %123)
%125 = load i32*, i32** %11
%126 = call i32 @freduce_coefficients(i32* %125)
ret void
}

LLVM IR (-O2):
define void @fmonty(i32* %0, i32* %1, i32* %2, i32* %3, i32* %4, i32* %5, i32* %6, i32* %7, i32* %8) {
%10 = alloca [10 x i32]
%11 = alloca [10 x i32]
%12 = alloca [19 x i32]
%13 = alloca [19 x i32]
%14 = alloca [19 x i32]
%15 = alloca [19 x i32]
%16 = alloca [19 x i32]
%17 = alloca [19 x i32]
%18 = alloca [19 x i32]
%19 = bitcast [10 x i32]* %10 to i8*
%20 = bitcast [10 x i32]* %11 to i8*
%21 = bitcast [19 x i32]* %12 to i8*
%22 = bitcast [19 x i32]* %13 to i8*
%23 = bitcast [19 x i32]* %14 to i8*
%24 = bitcast [19 x i32]* %15 to i8*
%25 = bitcast [19 x i32]* %16 to i8*
%26 = bitcast [19 x i32]* %17 to i8*
%27 = bitcast [19 x i32]* %18 to i8*
%28 = getelementptr inbounds [10 x i32], [10 x i32]* %10, i64 0, i64 0
%29 = call i32 @memcpy(i32* %28, i32* %4, i32 40)
%30 = call i32 @fsum(i32* %4, i32* %5)
%31 = call i32 @fdifference(i32* %5, i32* %28)
%32 = getelementptr inbounds [10 x i32], [10 x i32]* %11, i64 0, i64 0
%33 = call i32 @memcpy(i32* %32, i32* %6, i32 40)
%34 = call i32 @fsum(i32* %6, i32* %7)
%35 = call i32 @fdifference(i32* %7, i32* %32)
%36 = getelementptr inbounds [19 x i32], [19 x i32]* %15, i64 0, i64 0
%37 = call i32 @fproduct(i32* %36, i32* %6, i32* %5)
%38 = getelementptr inbounds [19 x i32], [19 x i32]* %16, i64 0, i64 0
%39 = call i32 @fproduct(i32* %38, i32* %4, i32* %7)
%40 = call i32 @freduce_degree(i32* %36)
%41 = call i32 @freduce_coefficients(i32* %36)
%42 = call i32 @freduce_degree(i32* %38)
%43 = call i32 @freduce_coefficients(i32* %38)
%44 = call i32 @memcpy(i32* %32, i32* %36, i32 40)
%45 = call i32 @fsum(i32* %36, i32* %38)
%46 = call i32 @fdifference(i32* %38, i32* %32)
%47 = getelementptr inbounds [19 x i32], [19 x i32]* %18, i64 0, i64 0
%48 = call i32 @fsquare(i32* %47, i32* %36)
%49 = getelementptr inbounds [19 x i32], [19 x i32]* %17, i64 0, i64 0
%50 = call i32 @fsquare(i32* %49, i32* %38)
%51 = call i32 @fproduct(i32* %38, i32* %49, i32* %8)
%52 = call i32 @freduce_degree(i32* %38)
%53 = call i32 @freduce_coefficients(i32* %38)
%54 = call i32 @memcpy(i32* %2, i32* %47, i32 40)
%55 = call i32 @memcpy(i32* %3, i32* %38, i32 40)
%56 = getelementptr inbounds [19 x i32], [19 x i32]* %13, i64 0, i64 0
%57 = call i32 @fsquare(i32* %56, i32* %4)
%58 = getelementptr inbounds [19 x i32], [19 x i32]* %14, i64 0, i64 0
%59 = call i32 @fsquare(i32* %58, i32* %5)
%60 = call i32 @fproduct(i32* %0, i32* %56, i32* %58)
%61 = call i32 @freduce_degree(i32* %0)
%62 = call i32 @freduce_coefficients(i32* %0)
%63 = call i32 @fdifference(i32* %58, i32* %56)
%64 = getelementptr inbounds [19 x i32], [19 x i32]* %12, i64 0, i64 0
%65 = getelementptr inbounds [19 x i32], [19 x i32]* %12, i64 0, i64 10
%66 = call i32 @memset(i32* %65, i32 0, i32 36)
%67 = call i32 @fscalar_product(i32* %64, i32* %58, i32 121665)
%68 = call i32 @freduce_coefficients(i32* %64)
%69 = call i32 @fsum(i32* %64, i32* %56)
%70 = call i32 @fproduct(i32* %1, i32* %58, i32* %64)
%71 = call i32 @freduce_degree(i32* %1)
%72 = call i32 @freduce_coefficients(i32* %1)
ret void
}