#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 */

/* Variables and functions */
int dobldobl_Littlewood_Richardson_homotopies(int, int, int, int *, int, int,
                                              int, int, int, char *, int *,
                                              double *);
int /*<<< orphan*/ printf(char *, ...);
int quaddobl_Littlewood_Richardson_homotopies(int, int, int, int *, int, int,
                                              int, int, int, char *, int *,
                                              double *);
int /*<<< orphan*/ scanf(char *, char *);
int standard_Littlewood_Richardson_homotopies(int, int, int, int *, int, int,
                                              int, int, int, char *, int *,
                                              double *);
int strlen(char *);
int /*<<< orphan*/ write_results(int);
int call_Littlewood_Richardson_homotopies(int n, int k, int c, int *brackets,
                                          int precision, int verbose,
                                          int verify, int minrep, int tosquare,
                                          int size, int *r) {
  double flags[size];
  char ans, filename[80];
  int i, fail, nbname;
  scanf("%c", &ans);
  if (verify == 1) {
    ans = 'y';
    printf("\n");
  } else {
    printf("\nOutput to separate file ? (y/n) ? ");
    scanf("%c", &ans);
    scanf("%c", &ans);
  }
  if (ans != 'y') {
    nbname = 0;
    filename[0] = '\0';
  } else {
    printf("Give the name of the output file : ");
    scanf("%s", filename);
    nbname = strlen(filename);
  }
  printf("Number of characters in %s is %d\n", filename, nbname);
  if (precision == 0)
    fail = standard_Littlewood_Richardson_homotopies(
        n, k, c, brackets, verbose, verify, minrep, tosquare, nbname, filename,
        r, flags);
  if (precision == 1)
    fail = dobldobl_Littlewood_Richardson_homotopies(
        n, k, c, brackets, verbose, verify, minrep, tosquare, nbname, filename,
        r, flags);
  if (precision == 2)
    fail = quaddobl_Littlewood_Richardson_homotopies(
        n, k, c, brackets, verbose, verify, minrep, tosquare, nbname, filename,
        r, flags);
  printf("\nThe coefficients of the fixed flag :");
  for (i = 0; i < size; i++) {
    if (i % (2 * n) == 0)
      printf("\n");
    printf(" %+.1e", flags[i]);
  }
  printf("\n");
  if (nbname > 0)
    printf("See the file %s for the results.\n", filename);
  else
    write_results(precision);
  return fail;
}


x86 assembly (clang, -O0):
<call_Littlewood_Richardson_homotopies>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %rbx
sub    $0xa8,%rsp
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%eax
mov    0x20(%rbp),%eax
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%eax
mov    %edi,-0x1c(%rbp)
mov    %esi,-0x20(%rbp)
mov    %edx,-0x24(%rbp)
mov    %rcx,-0x30(%rbp)
mov    %r8d,-0x34(%rbp)
mov    %r9d,-0x38(%rbp)
mov    0x28(%rbp),%eax
mov    %rsp,%rcx
mov    %rcx,-0x40(%rbp)
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0xb8(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x48(%rbp)
lea    0xe2a(%rip),%rdi
lea    -0x49(%rbp),%rsi
call   1080 <scanf@plt>
cmpl   $0x1,0x10(%rbp)
jne    1200 <call_Littlewood_Richardson_homotopies+0x90>
movb   $0x79,-0x49(%rbp)
lea    0xec9(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    122e <call_Littlewood_Richardson_homotopies+0xbe>
lea    0xdfc(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0xdeb(%rip),%rdi
lea    -0x49(%rbp),%rsi
call   1080 <scanf@plt>
lea    0xddb(%rip),%rdi
lea    -0x49(%rbp),%rsi
call   1080 <scanf@plt>
movsbl -0x49(%rbp),%eax
cmp    $0x79,%eax
je     1251 <call_Littlewood_Richardson_homotopies+0xe1>
movl   $0x0,-0xac(%rbp)
movb   $0x0,-0xa0(%rbp)
jmp    1284 <call_Littlewood_Richardson_homotopies+0x114>
lea    0xdcf(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    -0xa0(%rbp),%rsi
lea    0xdde(%rip),%rdi
call   1080 <scanf@plt>
lea    -0xa0(%rbp),%rdi
call   1040 <strlen@plt>
mov    %eax,-0xac(%rbp)
lea    -0xa0(%rbp),%rsi
mov    -0xac(%rbp),%edx
lea    0xdb6(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
cmpl   $0x0,-0x34(%rbp)
jne    130d <call_Littlewood_Richardson_homotopies+0x19d>
mov    -0xb8(%rbp),%rax
mov    -0x1c(%rbp),%edi
mov    -0x20(%rbp),%esi
mov    -0x24(%rbp),%edx
mov    -0x30(%rbp),%rcx
mov    -0x38(%rbp),%r8d
mov    0x10(%rbp),%r9d
mov    0x18(%rbp),%r15d
mov    0x20(%rbp),%r14d
mov    -0xac(%rbp),%ebx
lea    -0xa0(%rbp),%r11
mov    0x30(%rbp),%r10
sub    $0x30,%rsp
mov    %r15d,(%rsp)
mov    %r14d,0x8(%rsp)
mov    %ebx,0x10(%rsp)
mov    %r11,0x18(%rsp)
mov    %r10,0x20(%rsp)
mov    %rax,0x28(%rsp)
call   1060 <standard_Littlewood_Richardson_homotopies@plt>
add    $0x30,%rsp
mov    %eax,-0xa8(%rbp)
cmpl   $0x1,-0x34(%rbp)
jne    137b <call_Littlewood_Richardson_homotopies+0x20b>
mov    -0xb8(%rbp),%rax
mov    -0x1c(%rbp),%edi
mov    -0x20(%rbp),%esi
mov    -0x24(%rbp),%edx
mov    -0x30(%rbp),%rcx
mov    -0x38(%rbp),%r8d
mov    0x10(%rbp),%r9d
mov    0x18(%rbp),%r15d
mov    0x20(%rbp),%r14d
mov    -0xac(%rbp),%ebx
lea    -0xa0(%rbp),%r11
mov    0x30(%rbp),%r10
sub    $0x30,%rsp
mov    %r15d,(%rsp)
mov    %r14d,0x8(%rsp)
mov    %ebx,0x10(%rsp)
mov    %r11,0x18(%rsp)
mov    %r10,0x20(%rsp)
mov    %rax,0x28(%rsp)
call   1030 <dobldobl_Littlewood_Richardson_homotopies@plt>
add    $0x30,%rsp
mov    %eax,-0xa8(%rbp)
cmpl   $0x2,-0x34(%rbp)
jne    13e9 <call_Littlewood_Richardson_homotopies+0x279>
mov    -0xb8(%rbp),%rax
mov    -0x1c(%rbp),%edi
mov    -0x20(%rbp),%esi
mov    -0x24(%rbp),%edx
mov    -0x30(%rbp),%rcx
mov    -0x38(%rbp),%r8d
mov    0x10(%rbp),%r9d
mov    0x18(%rbp),%r15d
mov    0x20(%rbp),%r14d
mov    -0xac(%rbp),%ebx
lea    -0xa0(%rbp),%r11
mov    0x30(%rbp),%r10
sub    $0x30,%rsp
mov    %r15d,(%rsp)
mov    %r14d,0x8(%rsp)
mov    %ebx,0x10(%rsp)
mov    %r11,0x18(%rsp)
mov    %r10,0x20(%rsp)
mov    %rax,0x28(%rsp)
call   1070 <quaddobl_Littlewood_Richardson_homotopies@plt>
add    $0x30,%rsp
mov    %eax,-0xa8(%rbp)
lea    0xc80(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movl   $0x0,-0xa4(%rbp)
mov    -0xa4(%rbp),%eax
cmp    0x28(%rbp),%eax
jge    146b <call_Littlewood_Richardson_homotopies+0x2fb>
mov    -0xa4(%rbp),%eax
mov    -0x1c(%rbp),%ecx
shl    $0x1,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    1436 <call_Littlewood_Richardson_homotopies+0x2c6>
lea    0xc8e(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0xb8(%rbp),%rax
movslq -0xa4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
lea    0xc46(%rip),%rdi
mov    $0x1,%al
call   1050 <printf@plt>
mov    -0xa4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa4(%rbp)
jmp    1401 <call_Littlewood_Richardson_homotopies+0x291>
lea    0xc4b(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
cmpl   $0x0,-0xac(%rbp)
jle    14a0 <call_Littlewood_Richardson_homotopies+0x330>
lea    -0xa0(%rbp),%rsi
lea    0xc09(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    14a8 <call_Littlewood_Richardson_homotopies+0x338>
mov    -0x34(%rbp),%edi
call   1090 <write_results@plt>
mov    -0xa8(%rbp),%eax
mov    -0x40(%rbp),%rcx
mov    %rcx,%rsp
lea    -0x18(%rbp),%rsp
pop    %rbx
pop    %r14
pop    %r15
pop    %rbp
ret

x86 assembly (clang, -O2):
<call_Littlewood_Richardson_homotopies>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x78,%rsp
mov    %r9d,-0x3c(%rbp)
mov    %r8d,-0x40(%rbp)
mov    %rcx,-0x50(%rbp)
mov    %edx,-0x38(%rbp)
mov    %esi,-0x34(%rbp)
mov    %edi,%r14d
mov    0x28(%rbp),%r12d
mov    %rsp,%r15
lea    0xf(,%r12,8),%rax
and    $0xfffffffffffffff0,%rax
sub    %rax,%r15
mov    %r15,%rsp
lea    0xe3a(%rip),%rdi
lea    -0x29(%rbp),%rsi
call   1090 <scanf@plt>
cmpl   $0x1,0x10(%rbp)
jne    11f4 <call_Littlewood_Richardson_homotopies+0x74>
movb   $0x79,-0x29(%rbp)
mov    $0xa,%edi
call   1040 <putchar@plt>
cmpb   $0x79,-0x29(%rbp)
je     1229 <call_Littlewood_Richardson_homotopies+0xa9>
movb   $0x0,-0xa0(%rbp)
xor    %eax,%eax
jmp    1255 <call_Littlewood_Richardson_homotopies+0xd5>
lea    0xe08(%rip),%rdi
xor    %eax,%eax
call   1060 <printf@plt>
lea    0xdf7(%rip),%rbx
lea    -0x29(%rbp),%r13
mov    %rbx,%rdi
mov    %r13,%rsi
call   1090 <scanf@plt>
mov    %rbx,%rdi
mov    %r13,%rsi
call   1090 <scanf@plt>
cmpb   $0x79,-0x29(%rbp)
jne    11e9 <call_Littlewood_Richardson_homotopies+0x69>
lea    0xdf7(%rip),%rdi
xor    %eax,%eax
call   1060 <printf@plt>
lea    0xe0d(%rip),%rdi
lea    -0xa0(%rbp),%rbx
mov    %rbx,%rsi
call   1090 <scanf@plt>
mov    %rbx,%rdi
call   1050 <strlen@plt>
mov    0x30(%rbp),%rbx
lea    0xdee(%rip),%rdi
lea    -0xa0(%rbp),%r13
mov    %r13,%rsi
mov    %rax,-0x48(%rbp)
mov    %rax,%rdx
xor    %eax,%eax
call   1060 <printf@plt>
mov    -0x40(%rbp),%eax
cmp    $0x2,%eax
je     12b9 <call_Littlewood_Richardson_homotopies+0x139>
cmp    $0x1,%eax
je     12e5 <call_Littlewood_Richardson_homotopies+0x165>
test   %eax,%eax
jne    1316 <call_Littlewood_Richardson_homotopies+0x196>
mov    %r14d,%edi
mov    -0x34(%rbp),%esi
mov    -0x38(%rbp),%edx
mov    -0x50(%rbp),%rcx
mov    -0x3c(%rbp),%r8d
mov    0x10(%rbp),%r9d
push   %r15
push   %rbx
push   %r13
push   -0x48(%rbp)
mov    0x20(%rbp),%eax
push   %rax
mov    0x18(%rbp),%eax
push   %rax
call   1070 <standard_Littlewood_Richardson_homotopies@plt>
jmp    130f <call_Littlewood_Richardson_homotopies+0x18f>
mov    %r14d,%edi
mov    -0x34(%rbp),%esi
mov    -0x38(%rbp),%edx
mov    -0x50(%rbp),%rcx
mov    -0x3c(%rbp),%r8d
mov    0x10(%rbp),%r9d
push   %r15
push   %rbx
push   %r13
push   -0x48(%rbp)
mov    0x20(%rbp),%eax
push   %rax
mov    0x18(%rbp),%eax
push   %rax
call   1080 <quaddobl_Littlewood_Richardson_homotopies@plt>
jmp    130f <call_Littlewood_Richardson_homotopies+0x18f>
mov    %r14d,%edi
mov    -0x34(%rbp),%esi
mov    -0x38(%rbp),%edx
mov    -0x50(%rbp),%rcx
mov    -0x3c(%rbp),%r8d
mov    0x10(%rbp),%r9d
push   %r15
push   %rbx
push   %r13
push   -0x48(%rbp)
mov    0x20(%rbp),%eax
push   %rax
mov    0x18(%rbp),%eax
push   %rax
call   1030 <dobldobl_Littlewood_Richardson_homotopies@plt>
add    $0x30,%rsp
mov    %eax,-0x30(%rbp)
lea    0xd53(%rip),%rdi
xor    %eax,%eax
call   1060 <printf@plt>
test   %r12d,%r12d
jle    136f <call_Littlewood_Richardson_homotopies+0x1ef>
add    %r14d,%r14d
xor    %ebx,%ebx
lea    0xd61(%rip),%r13
jmp    1359 <call_Littlewood_Richardson_homotopies+0x1d9>
nopw   0x0(%rax,%rax,1)
movsd  (%r15,%rbx,8),%xmm0
mov    %r13,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
add    $0x1,%rbx
cmp    %rbx,%r12
je     136f <call_Littlewood_Richardson_homotopies+0x1ef>
mov    %ebx,%eax
cltd
idiv   %r14d
test   %edx,%edx
jne    1340 <call_Littlewood_Richardson_homotopies+0x1c0>
mov    $0xa,%edi
call   1040 <putchar@plt>
jmp    1340 <call_Littlewood_Richardson_homotopies+0x1c0>
mov    $0xa,%edi
call   1040 <putchar@plt>
cmpl   $0x0,-0x48(%rbp)
jle    1396 <call_Littlewood_Richardson_homotopies+0x216>
lea    0xd17(%rip),%rdi
lea    -0xa0(%rbp),%rsi
xor    %eax,%eax
call   1060 <printf@plt>
jmp    139e <call_Littlewood_Richardson_homotopies+0x21e>
mov    -0x40(%rbp),%edi
call   10a0 <write_results@plt>
mov    -0x30(%rbp),%eax
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [3 x i8] c"%c\00"
@.str.1 = [2 x i8] c"\0A\00"
@.str.2 = [36 x i8] c"\0AOutput to separate file ? (y/n) ? \00"
@.str.3 = [36 x i8] c"Give the name of the output file : \00"
@.str.4 = [3 x i8] c"%s\00"
@.str.5 = [34 x i8] c"Number of characters in %s is %d\0A\00"
@.str.6 = [38 x i8] c"\0AThe coefficients of the fixed flag :\00"
@.str.7 = [7 x i8] c" %+.1e\00"
@.str.8 = [34 x i8] c"See the file %s for the results.\0A\00"
define i32 @call_Littlewood_Richardson_homotopies(i32 %0, i32 %1, i32 %2, i32* %3, i32 %4, i32 %5, i32 %6, i32 %7, i32 %8, i32 %9, i32* %10) {
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32*
%16 = alloca i32
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
%20 = alloca i32
%21 = alloca i32
%22 = alloca i32*
%23 = alloca i8*
%24 = alloca i64
%25 = alloca i8
%26 = alloca [80 x i8]
%27 = alloca i32
%28 = alloca i32
%29 = alloca i32
store i32 %0, i32* %12
store i32 %1, i32* %13
store i32 %2, i32* %14
store i32* %3, i32** %15
store i32 %4, i32* %16
store i32 %5, i32* %17
store i32 %6, i32* %18
store i32 %7, i32* %19
store i32 %8, i32* %20
store i32 %9, i32* %21
store i32* %10, i32** %22
%30 = load i32, i32* %21
%31 = zext i32 %30 to i64
%32 = call i8* @llvm.stacksave()
store i8* %32, i8** %23
%33 = alloca double, i64 %31
store i64 %31, i64* %24
%34 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i8* %25)
%35 = load i32, i32* %18
%36 = icmp eq i32 %35, 1
br i1 %36, label %37, label %39
37: ; preds = %11
store i8 121, i8* %25
%38 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
br label %43
39: ; preds = %11
%40 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([36 x i8], [36 x i8]* @.str.2, i64 0, i64 0))
%41 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i8* %25)
%42 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i8* %25)
br label %43
43: ; preds = %39, %37
%44 = load i8, i8* %25
%45 = sext i8 %44 to i32
%46 = icmp ne i32 %45, 121
br i1 %46, label %47, label %49
47: ; preds = %43
store i32 0, i32* %29
%48 = getelementptr inbounds [80 x i8], [80 x i8]* %26, i64 0, i64 0
store i8 0, i8* %48
br label %55
49: ; preds = %43
%50 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([36 x i8], [36 x i8]* @.str.3, i64 0, i64 0))
%51 = getelementptr inbounds [80 x i8], [80 x i8]* %26, i64 0, i64 0
%52 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.4, i64 0, i64 0), i8* %51)
%53 = getelementptr inbounds [80 x i8], [80 x i8]* %26, i64 0, i64 0
%54 = call i32 @strlen(i8* %53)
store i32 %54, i32* %29
br label %55
55: ; preds = %49, %47
%56 = getelementptr inbounds [80 x i8], [80 x i8]* %26, i64 0, i64 0
%57 = load i32, i32* %29
%58 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.5, i64 0, i64 0), i8* %56, i32 %57)
%59 = load i32, i32* %16
%60 = icmp eq i32 %59, 0
br i1 %60, label %61, label %74
61: ; preds = %55
%62 = load i32, i32* %12
%63 = load i32, i32* %13
%64 = load i32, i32* %14
%65 = load i32*, i32** %15
%66 = load i32, i32* %17
%67 = load i32, i32* %18
%68 = load i32, i32* %19
%69 = load i32, i32* %20
%70 = load i32, i32* %29
%71 = getelementptr inbounds [80 x i8], [80 x i8]* %26, i64 0, i64 0
%72 = load i32*, i32** %22
%73 = call i32 @standard_Littlewood_Richardson_homotopies(i32 %62, i32 %63, i32 %64, i32* %65, i32 %66, i32 %67, i32 %68, i32 %69, i32 %70, i8* %71, i32* %72, double* %33)
store i32 %73, i32* %28
br label %74
74: ; preds = %61, %55
%75 = load i32, i32* %16
%76 = icmp eq i32 %75, 1
br i1 %76, label %77, label %90
77: ; preds = %74
%78 = load i32, i32* %12
%79 = load i32, i32* %13
%80 = load i32, i32* %14
%81 = load i32*, i32** %15
%82 = load i32, i32* %17
%83 = load i32, i32* %18
%84 = load i32, i32* %19
%85 = load i32, i32* %20
%86 = load i32, i32* %29
%87 = getelementptr inbounds [80 x i8], [80 x i8]* %26, i64 0, i64 0
%88 = load i32*, i32** %22
%89 = call i32 @dobldobl_Littlewood_Richardson_homotopies(i32 %78, i32 %79, i32 %80, i32* %81, i32 %82, i32 %83, i32 %84, i32 %85, i32 %86, i8* %87, i32* %88, double* %33)
store i32 %89, i32* %28
br label %90
90: ; preds = %77, %74
%91 = load i32, i32* %16
%92 = icmp eq i32 %91, 2
br i1 %92, label %93, label %106
93: ; preds = %90
%94 = load i32, i32* %12
%95 = load i32, i32* %13
%96 = load i32, i32* %14
%97 = load i32*, i32** %15
%98 = load i32, i32* %17
%99 = load i32, i32* %18
%100 = load i32, i32* %19
%101 = load i32, i32* %20
%102 = load i32, i32* %29
%103 = getelementptr inbounds [80 x i8], [80 x i8]* %26, i64 0, i64 0
%104 = load i32*, i32** %22
%105 = call i32 @quaddobl_Littlewood_Richardson_homotopies(i32 %94, i32 %95, i32 %96, i32* %97, i32 %98, i32 %99, i32 %100, i32 %101, i32 %102, i8* %103, i32* %104, double* %33)
store i32 %105, i32* %28
br label %106
106: ; preds = %93, %90
%107 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([38 x i8], [38 x i8]* @.str.6, i64 0, i64 0))
store i32 0, i32* %27
br label %108
108: ; preds = %126, %106
%109 = load i32, i32* %27
%110 = load i32, i32* %21
%111 = icmp slt i32 %109, %110
br i1 %111, label %112, label %129
112: ; preds = %108
%113 = load i32, i32* %27
%114 = load i32, i32* %12
%115 = mul nsw i32 2, %114
%116 = srem i32 %113, %115
%117 = icmp eq i32 %116, 0
br i1 %117, label %118, label %120
118: ; preds = %112
%119 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
br label %120
120: ; preds = %118, %112
%121 = load i32, i32* %27
%122 = sext i32 %121 to i64
%123 = getelementptr inbounds double, double* %33, i64 %122
%124 = load double, double* %123
%125 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.7, i64 0, i64 0), double %124)
br label %126
126: ; preds = %120
%127 = load i32, i32* %27
%128 = add nsw i32 %127, 1
store i32 %128, i32* %27
br label %108
129: ; preds = %108
%130 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%131 = load i32, i32* %29
%132 = icmp sgt i32 %131, 0
br i1 %132, label %133, label %136
133: ; preds = %129
%134 = getelementptr inbounds [80 x i8], [80 x i8]* %26, i64 0, i64 0
%135 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.8, i64 0, i64 0), i8* %134)
br label %139
136: ; preds = %129
%137 = load i32, i32* %16
%138 = call i32 @write_results(i32 %137)
br label %139
139: ; preds = %136, %133
%140 = load i32, i32* %28
%141 = load i8*, i8** %23
ret i32 %140
}

LLVM IR (-O2):
@.str = [3 x i8] c"%c\00"
@.str.2 = [36 x i8] c"\0AOutput to separate file ? (y/n) ? \00"
@.str.3 = [36 x i8] c"Give the name of the output file : \00"
@.str.4 = [3 x i8] c"%s\00"
@.str.5 = [34 x i8] c"Number of characters in %s is %d\0A\00"
@.str.6 = [38 x i8] c"\0AThe coefficients of the fixed flag :\00"
@.str.7 = [7 x i8] c" %+.1e\00"
@.str.8 = [34 x i8] c"See the file %s for the results.\0A\00"
define i32 @call_Littlewood_Richardson_homotopies(i32 %0, i32 %1, i32 %2, i32* %3, i32 %4, i32 %5, i32 %6, i32 %7, i32 %8, i32 %9, i32* %10) {
%12 = alloca i8
%13 = alloca [80 x i8]
%14 = zext i32 %9 to i64
%15 = alloca double, i64 %14
%16 = getelementptr inbounds [80 x i8], [80 x i8]* %13, i64 0, i64 0
%17 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i8* %12)
%18 = icmp eq i32 %6, 1
br i1 %18, label %19, label %21
19: ; preds = %11
store i8 121, i8* %12
%20 = call i32 @putchar(i32 10)
br label %25
21: ; preds = %11
%22 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([36 x i8], [36 x i8]* @.str.2, i64 0, i64 0))
%23 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i8* %12)
%24 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i8* %12)
br label %25
25: ; preds = %21, %19
%26 = load i8, i8* %12
%27 = icmp eq i8 %26, 121
br i1 %27, label %29, label %28
28: ; preds = %25
store i8 0, i8* %16
br label %33
29: ; preds = %25
%30 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([36 x i8], [36 x i8]* @.str.3, i64 0, i64 0))
%31 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.4, i64 0, i64 0), i8* %16)
%32 = call i32 @strlen(i8* %16)
br label %33
33: ; preds = %29, %28
%34 = phi i32 [ 0, %28 ], [ %32, %29 ]
%35 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([34 x i8], [34 x i8]* @.str.5, i64 0, i64 0), i8* %16, i32 %34)
switch i32 %4, label %42 [
i32 0, label %36
i32 1, label %38
i32 2, label %40
]
36: ; preds = %33
%37 = call i32 @standard_Littlewood_Richardson_homotopies(i32 %0, i32 %1, i32 %2, i32* %3, i32 %5, i32 %6, i32 %7, i32 %8, i32 %34, i8* %16, i32* %10, double* %15)
br label %42
38: ; preds = %33
%39 = call i32 @dobldobl_Littlewood_Richardson_homotopies(i32 %0, i32 %1, i32 %2, i32* %3, i32 %5, i32 %6, i32 %7, i32 %8, i32 %34, i8* %16, i32* %10, double* %15)
br label %42
40: ; preds = %33
%41 = call i32 @quaddobl_Littlewood_Richardson_homotopies(i32 %0, i32 %1, i32 %2, i32* %3, i32 %5, i32 %6, i32 %7, i32 %8, i32 %34, i8* %16, i32* %10, double* %15)
br label %42
42: ; preds = %33, %38, %36, %40
%43 = phi i32 [ %41, %40 ], [ %37, %36 ], [ %39, %38 ], [ undef, %33 ]
%44 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([38 x i8], [38 x i8]* @.str.6, i64 0, i64 0))
%45 = icmp sgt i32 %9, 0
br i1 %45, label %46, label %61
46: ; preds = %42
%47 = shl nsw i32 %0, 1
br label %48
48: ; preds = %46, %55
%49 = phi i64 [ 0, %46 ], [ %59, %55 ]
%50 = trunc i64 %49 to i32
%51 = srem i32 %50, %47
%52 = icmp eq i32 %51, 0
br i1 %52, label %53, label %55
53: ; preds = %48
%54 = call i32 @putchar(i32 10)
br label %55
55: ; preds = %53, %48
%56 = getelementptr inbounds double, double* %15, i64 %49
%57 = load double, double* %56
%58 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.7, i64 0, i64 0), double %57)
%59 = add nuw nsw i64 %49, 1
%60 = icmp eq i64 %59, %14
br i1 %60, label %61, label %48
61: ; preds = %55, %42
%62 = call i32 @putchar(i32 10)
%63 = icmp sgt i32 %34, 0
br i1 %63, label %64, label %66
64: ; preds = %61
%65 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([34 x i8], [34 x i8]* @.str.8, i64 0, i64 0), i8* %16)
br label %68
66: ; preds = %61
%67 = call i32 @write_results(i32 %4)
br label %68
68: ; preds = %66, %64
ret i32 %43
}