#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 _ada_use_c2phc(int, int *, int *, double *);
int m_homogeneous_Bezout_number(int *bzn, int *ncp, char *partition) {
  int fail, i;
  int sc[2];
  int sv[256];
  double *c;
  fail = _ada_use_c2phc(530, sc, sv, c);
  *bzn = sc[0];
  *ncp = sc[1] + 1;
  for (i = 0; i < sc[1]; i++)
    partition[i] = (char)sv[i];
  partition[sc[1]] = '\0';
  return fail;
}


x86 assembly (clang, -O0):
<m_homogeneous_Bezout_number>:
push   %rbp
mov    %rsp,%rbp
sub    $0x440,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
lea    -0x28(%rbp),%rsi
lea    -0x430(%rbp),%rdx
mov    -0x438(%rbp),%rcx
mov    $0x212,%edi
call   1030 <_ada_use_c2phc@plt>
mov    %eax,-0x1c(%rbp)
mov    -0x28(%rbp),%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
mov    -0x10(%rbp),%rax
mov    %ecx,(%rax)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1194 <m_homogeneous_Bezout_number+0x84>
movslq -0x20(%rbp),%rax
mov    -0x430(%rbp,%rax,4),%eax
mov    %al,%dl
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1162 <m_homogeneous_Bezout_number+0x52>
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x1c(%rbp),%eax
add    $0x440,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<m_homogeneous_Bezout_number>:
push   %r15
push   %r14
push   %rbx
sub    $0x410,%rsp
mov    %rdx,%rbx
mov    %rsi,%r14
mov    %rdi,%r15
lea    0x8(%rsp),%rsi
lea    0x10(%rsp),%rdx
mov    $0x212,%edi
call   1030 <_ada_use_c2phc@plt>
mov    0x8(%rsp),%ecx
mov    %ecx,(%r15)
movslq 0xc(%rsp),%r9
lea    0x1(%r9),%ecx
mov    %ecx,(%r14)
test   %r9,%r9
jle    1261 <m_homogeneous_Bezout_number+0x151>
mov    %r9d,%edx
cmp    $0x8,%edx
jae    1164 <m_homogeneous_Bezout_number+0x54>
xor    %esi,%esi
jmp    1250 <m_homogeneous_Bezout_number+0x140>
mov    %edx,%esi
and    $0xfffffff8,%esi
lea    -0x8(%rsi),%rcx
mov    %rcx,%r8
shr    $0x3,%r8
add    $0x1,%r8
test   %rcx,%rcx
je     1273 <m_homogeneous_Bezout_number+0x163>
mov    %r8,%rcx
and    $0xfffffffffffffffe,%rcx
xor    %edi,%edi
movdqa 0xe6e(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movdqa 0x10(%rsp,%rdi,4),%xmm1
pand   %xmm0,%xmm1
packuswb %xmm1,%xmm1
packuswb %xmm1,%xmm1
movdqa 0x20(%rsp,%rdi,4),%xmm2
pand   %xmm0,%xmm2
packuswb %xmm2,%xmm2
packuswb %xmm2,%xmm2
movd   %xmm1,(%rbx,%rdi,1)
movd   %xmm2,0x4(%rbx,%rdi,1)
movdqa 0x30(%rsp,%rdi,4),%xmm1
pand   %xmm0,%xmm1
packuswb %xmm1,%xmm1
packuswb %xmm1,%xmm1
movdqa 0x40(%rsp,%rdi,4),%xmm2
pand   %xmm0,%xmm2
packuswb %xmm2,%xmm2
packuswb %xmm2,%xmm2
movd   %xmm1,0x8(%rbx,%rdi,1)
movd   %xmm2,0xc(%rbx,%rdi,1)
add    $0x10,%rdi
add    $0xfffffffffffffffe,%rcx
jne    11a0 <m_homogeneous_Bezout_number+0x90>
test   $0x1,%r8b
je     1242 <m_homogeneous_Bezout_number+0x132>
movdqa 0xde9(%rip),%xmm0
movdqa 0x10(%rsp,%rdi,4),%xmm1
pand   %xmm0,%xmm1
packuswb %xmm1,%xmm1
packuswb %xmm1,%xmm1
pand   0x20(%rsp,%rdi,4),%xmm0
packuswb %xmm0,%xmm0
packuswb %xmm0,%xmm0
movd   %xmm1,(%rbx,%rdi,1)
movd   %xmm0,0x4(%rbx,%rdi,1)
cmp    %rdx,%rsi
je     1261 <m_homogeneous_Bezout_number+0x151>
nopw   0x0(%rax,%rax,1)
movzbl 0x10(%rsp,%rsi,4),%ecx
mov    %cl,(%rbx,%rsi,1)
add    $0x1,%rsi
cmp    %rsi,%rdx
jne    1250 <m_homogeneous_Bezout_number+0x140>
movb   $0x0,(%rbx,%r9,1)
add    $0x410,%rsp
pop    %rbx
pop    %r14
pop    %r15
ret
xor    %edi,%edi
test   $0x1,%r8b
jne    120f <m_homogeneous_Bezout_number+0xff>
jmp    1242 <m_homogeneous_Bezout_number+0x132>

LLVM IR (-O0):
define i32 @m_homogeneous_Bezout_number(i32* %0, i32* %1, i8* %2) {
%4 = alloca i32*
%5 = alloca i32*
%6 = alloca i8*
%7 = alloca i32
%8 = alloca i32
%9 = alloca [2 x i32]
%10 = alloca [256 x i32]
%11 = alloca double*
store i32* %0, i32** %4
store i32* %1, i32** %5
store i8* %2, i8** %6
%12 = getelementptr inbounds [2 x i32], [2 x i32]* %9, i64 0, i64 0
%13 = getelementptr inbounds [256 x i32], [256 x i32]* %10, i64 0, i64 0
%14 = load double*, double** %11
%15 = call i32 @_ada_use_c2phc(i32 530, i32* %12, i32* %13, double* %14)
store i32 %15, i32* %7
%16 = getelementptr inbounds [2 x i32], [2 x i32]* %9, i64 0, i64 0
%17 = load i32, i32* %16
%18 = load i32*, i32** %4
store i32 %17, i32* %18
%19 = getelementptr inbounds [2 x i32], [2 x i32]* %9, i64 0, i64 1
%20 = load i32, i32* %19
%21 = add nsw i32 %20, 1
%22 = load i32*, i32** %5
store i32 %21, i32* %22
store i32 0, i32* %8
br label %23
23: ; preds = %38, %3
%24 = load i32, i32* %8
%25 = getelementptr inbounds [2 x i32], [2 x i32]* %9, i64 0, i64 1
%26 = load i32, i32* %25
%27 = icmp slt i32 %24, %26
br i1 %27, label %28, label %41
28: ; preds = %23
%29 = load i32, i32* %8
%30 = sext i32 %29 to i64
%31 = getelementptr inbounds [256 x i32], [256 x i32]* %10, i64 0, i64 %30
%32 = load i32, i32* %31
%33 = trunc i32 %32 to i8
%34 = load i8*, i8** %6
%35 = load i32, i32* %8
%36 = sext i32 %35 to i64
%37 = getelementptr inbounds i8, i8* %34, i64 %36
store i8 %33, i8* %37
br label %38
38: ; preds = %28
%39 = load i32, i32* %8
%40 = add nsw i32 %39, 1
store i32 %40, i32* %8
br label %23
41: ; preds = %23
%42 = load i8*, i8** %6
%43 = getelementptr inbounds [2 x i32], [2 x i32]* %9, i64 0, i64 1
%44 = load i32, i32* %43
%45 = sext i32 %44 to i64
%46 = getelementptr inbounds i8, i8* %42, i64 %45
store i8 0, i8* %46
%47 = load i32, i32* %7
ret i32 %47
}

LLVM IR (-O2):
define i32 @m_homogeneous_Bezout_number(i32* nocapture writeonly %0, i32* nocapture writeonly %1, i8* nocapture writeonly %2) {
%4 = alloca [2 x i32]
%5 = alloca [256 x i32]
%6 = bitcast [2 x i32]* %4 to i8*
%7 = bitcast [256 x i32]* %5 to i8*
%8 = getelementptr inbounds [2 x i32], [2 x i32]* %4, i64 0, i64 0
%9 = getelementptr inbounds [256 x i32], [256 x i32]* %5, i64 0, i64 0
%10 = call i32 @_ada_use_c2phc(i32 530, i32* %8, i32* %9, double* undef)
%11 = load i32, i32* %8
store i32 %11, i32* %0
%12 = getelementptr inbounds [2 x i32], [2 x i32]* %4, i64 0, i64 1
%13 = load i32, i32* %12
%14 = add nsw i32 %13, 1
store i32 %14, i32* %1
%15 = icmp sgt i32 %13, 0
br i1 %15, label %16, label %87
16: ; preds = %3
%17 = zext i32 %13 to i64
%18 = icmp ult i32 %13, 8
br i1 %18, label %77, label %19
19: ; preds = %16
%20 = and i64 %17, 4294967288
%21 = add nsw i64 %20, -8
%22 = lshr exact i64 %21, 3
%23 = add nuw nsw i64 %22, 1
%24 = and i64 %23, 1
%25 = icmp eq i64 %21, 0
br i1 %25, label %59, label %26
26: ; preds = %19
%27 = and i64 %23, 4611686018427387902
br label %28
28: ; preds = %28, %26
%29 = phi i64 [ 0, %26 ], [ %56, %28 ]
%30 = phi i64 [ 0, %26 ], [ %57, %28 ]
%31 = getelementptr inbounds [256 x i32], [256 x i32]* %5, i64 0, i64 %29
%32 = bitcast i32* %31 to <4 x i32>*
%33 = load <4 x i32>, <4 x i32>* %32
%34 = getelementptr inbounds i32, i32* %31, i64 4
%35 = bitcast i32* %34 to <4 x i32>*
%36 = load <4 x i32>, <4 x i32>* %35
%37 = trunc <4 x i32> %33 to <4 x i8>
%38 = trunc <4 x i32> %36 to <4 x i8>
%39 = getelementptr inbounds i8, i8* %2, i64 %29
%40 = bitcast i8* %39 to <4 x i8>*
store <4 x i8> %37, <4 x i8>* %40
%41 = getelementptr inbounds i8, i8* %39, i64 4
%42 = bitcast i8* %41 to <4 x i8>*
store <4 x i8> %38, <4 x i8>* %42
%43 = or i64 %29, 8
%44 = getelementptr inbounds [256 x i32], [256 x i32]* %5, i64 0, i64 %43
%45 = bitcast i32* %44 to <4 x i32>*
%46 = load <4 x i32>, <4 x i32>* %45
%47 = getelementptr inbounds i32, i32* %44, i64 4
%48 = bitcast i32* %47 to <4 x i32>*
%49 = load <4 x i32>, <4 x i32>* %48
%50 = trunc <4 x i32> %46 to <4 x i8>
%51 = trunc <4 x i32> %49 to <4 x i8>
%52 = getelementptr inbounds i8, i8* %2, i64 %43
%53 = bitcast i8* %52 to <4 x i8>*
store <4 x i8> %50, <4 x i8>* %53
%54 = getelementptr inbounds i8, i8* %52, i64 4
%55 = bitcast i8* %54 to <4 x i8>*
store <4 x i8> %51, <4 x i8>* %55
%56 = add nuw i64 %29, 16
%57 = add i64 %30, 2
%58 = icmp eq i64 %57, %27
br i1 %58, label %59, label %28
59: ; preds = %28, %19
%60 = phi i64 [ 0, %19 ], [ %56, %28 ]
%61 = icmp eq i64 %24, 0
br i1 %61, label %75, label %62
62: ; preds = %59
%63 = getelementptr inbounds [256 x i32], [256 x i32]* %5, i64 0, i64 %60
%64 = bitcast i32* %63 to <4 x i32>*
%65 = load <4 x i32>, <4 x i32>* %64
%66 = getelementptr inbounds i32, i32* %63, i64 4
%67 = bitcast i32* %66 to <4 x i32>*
%68 = load <4 x i32>, <4 x i32>* %67
%69 = trunc <4 x i32> %65 to <4 x i8>
%70 = trunc <4 x i32> %68 to <4 x i8>
%71 = getelementptr inbounds i8, i8* %2, i64 %60
%72 = bitcast i8* %71 to <4 x i8>*
store <4 x i8> %69, <4 x i8>* %72
%73 = getelementptr inbounds i8, i8* %71, i64 4
%74 = bitcast i8* %73 to <4 x i8>*
store <4 x i8> %70, <4 x i8>* %74
br label %75
75: ; preds = %59, %62
%76 = icmp eq i64 %20, %17
br i1 %76, label %87, label %77
77: ; preds = %16, %75
%78 = phi i64 [ 0, %16 ], [ %20, %75 ]
br label %79
79: ; preds = %77, %79
%80 = phi i64 [ %85, %79 ], [ %78, %77 ]
%81 = getelementptr inbounds [256 x i32], [256 x i32]* %5, i64 0, i64 %80
%82 = load i32, i32* %81
%83 = trunc i32 %82 to i8
%84 = getelementptr inbounds i8, i8* %2, i64 %80
store i8 %83, i8* %84
%85 = add nuw nsw i64 %80, 1
%86 = icmp eq i64 %85, %17
br i1 %86, label %87, label %79
87: ; preds = %79, %75, %3
%88 = sext i32 %13 to i64
%89 = getelementptr inbounds i8, i8* %2, i64 %88
store i8 0, i8* %89
ret i32 %10
}