#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 /*<<< orphan*/ assert(int);
void gall_laplace_sym(size_t m, size_t n, size_t *IA, size_t *JA, double *AN,
                      double *AD) {
  size_t i, j, k, l, N, nz;
  N = n * m;
  nz = 2 * N - (m + n);
  for (i = 0, k = 0, l = 0; i < m; i++)
    for (j = 0; j < n; j++, k++) {
      IA[k] = l;
      AD[k] = 4.;
      if (j < n - 1) {
        AN[l] = -1.;
        JA[l] = k + 1;
        l++;
      }
      if (i < m - 1) {
        AN[l] = -1.;
        JA[l] = k + n;
        l++;
      }
    }
  assert(nz == l);
  IA[N] = nz;
}


x86 assembly (clang, -O0):
<gall_laplace_sym>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
mov    -0x10(%rbp),%rax
imul   -0x8(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x58(%rbp),%rax
shl    $0x1,%rax
mov    -0x8(%rbp),%rcx
add    -0x10(%rbp),%rcx
sub    %rcx,%rax
mov    %rax,-0x60(%rbp)
movq   $0x0,-0x38(%rbp)
movq   $0x0,-0x48(%rbp)
movq   $0x0,-0x50(%rbp)
mov    -0x38(%rbp),%rax
cmp    -0x8(%rbp),%rax
jae    1281 <gall_laplace_sym+0x171>
movq   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%rax
cmp    -0x10(%rbp),%rax
jae    126b <gall_laplace_sym+0x15b>
mov    -0x50(%rbp),%rdx
mov    -0x18(%rbp),%rax
mov    -0x48(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
mov    -0x48(%rbp),%rcx
movsd  0xe50(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%rax
mov    -0x10(%rbp),%rcx
sub    $0x1,%rcx
cmp    %rcx,%rax
jae    11ff <gall_laplace_sym+0xef>
mov    -0x28(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  0xe2e(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x48(%rbp),%rdx
add    $0x1,%rdx
mov    -0x20(%rbp),%rax
mov    -0x50(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
mov    -0x38(%rbp),%rax
mov    -0x8(%rbp),%rcx
sub    $0x1,%rcx
cmp    %rcx,%rax
jae    1249 <gall_laplace_sym+0x139>
mov    -0x28(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  0xde4(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x48(%rbp),%rdx
add    -0x10(%rbp),%rdx
mov    -0x20(%rbp),%rax
mov    -0x50(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
jmp    124e <gall_laplace_sym+0x13e>
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
mov    -0x48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x48(%rbp)
jmp    1182 <gall_laplace_sym+0x72>
jmp    1270 <gall_laplace_sym+0x160>
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    116c <gall_laplace_sym+0x5c>
mov    -0x60(%rbp),%rax
cmp    -0x50(%rbp),%rax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
mov    -0x60(%rbp),%rdx
mov    -0x18(%rbp),%rax
mov    -0x58(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<gall_laplace_sym>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    %rdx,%r12
mov    %rsi,%rax
imul   %rdi,%rax
mov    %rax,0x8(%rsp)
lea    (%rax,%rax,1),%rdx
sub    %rsi,%rdx
sub    %rdi,%rdx
mov    %rdx,(%rsp)
test   %rdi,%rdi
je     11e1 <gall_laplace_sym+0xd1>
mov    %rdi,%rbx
lea    -0x1(%rsi),%r10
lea    -0x1(%rdi),%r11
xor    %r13d,%r13d
movabs $0x4010000000000000,%rax
movabs $0xbff0000000000000,%rdi
xor    %edx,%edx
xor    %ebp,%ebp
mov    %rbx,0x10(%rsp)
jmp    118b <gall_laplace_sym+0x7b>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%r13
cmp    0x10(%rsp),%r13
je     11e3 <gall_laplace_sym+0xd3>
test   %rsi,%rsi
je     1180 <gall_laplace_sym+0x70>
xor    %r14d,%r14d
jmp    11ad <gall_laplace_sym+0x9d>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%r14
add    $0x1,%rbp
cmp    %rsi,%r14
je     1180 <gall_laplace_sym+0x70>
mov    %rdx,(%r12,%rbp,8)
mov    %rax,(%r9,%rbp,8)
cmp    %r10,%r14
jae    11ca <gall_laplace_sym+0xba>
mov    %rdi,(%r8,%rdx,8)
lea    0x1(%rbp),%r15
mov    %r15,(%rcx,%rdx,8)
add    $0x1,%rdx
cmp    %r11,%r13
jae    11a0 <gall_laplace_sym+0x90>
mov    %rdi,(%r8,%rdx,8)
lea    (%rsi,%rbp,1),%rbx
mov    %rbx,(%rcx,%rdx,8)
add    $0x1,%rdx
jmp    11a0 <gall_laplace_sym+0x90>
xor    %edx,%edx
xor    %edi,%edi
mov    (%rsp),%rbx
cmp    %rdx,%rbx
sete   %dil
call   1030 <assert@plt>
mov    0x8(%rsp),%rax
mov    %rbx,(%r12,%rax,8)
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @gall_laplace_sym(i64 %0, i64 %1, i64* %2, i64* %3, double* %4, double* %5) {
%7 = alloca i64
%8 = alloca i64
%9 = alloca i64*
%10 = alloca i64*
%11 = alloca double*
%12 = alloca double*
%13 = alloca i64
%14 = alloca i64
%15 = alloca i64
%16 = alloca i64
%17 = alloca i64
%18 = alloca i64
store i64 %0, i64* %7
store i64 %1, i64* %8
store i64* %2, i64** %9
store i64* %3, i64** %10
store double* %4, double** %11
store double* %5, double** %12
%19 = load i64, i64* %8
%20 = load i64, i64* %7
%21 = mul i64 %19, %20
store i64 %21, i64* %17
%22 = load i64, i64* %17
%23 = mul i64 2, %22
%24 = load i64, i64* %7
%25 = load i64, i64* %8
%26 = add i64 %24, %25
%27 = sub i64 %23, %26
store i64 %27, i64* %18
store i64 0, i64* %13
store i64 0, i64* %15
store i64 0, i64* %16
br label %28
28: ; preds = %84, %6
%29 = load i64, i64* %13
%30 = load i64, i64* %7
%31 = icmp ult i64 %29, %30
br i1 %31, label %32, label %87
32: ; preds = %28
store i64 0, i64* %14
br label %33
33: ; preds = %78, %32
%34 = load i64, i64* %14
%35 = load i64, i64* %8
%36 = icmp ult i64 %34, %35
br i1 %36, label %37, label %83
37: ; preds = %33
%38 = load i64, i64* %16
%39 = load i64*, i64** %9
%40 = load i64, i64* %15
%41 = getelementptr inbounds i64, i64* %39, i64 %40
store i64 %38, i64* %41
%42 = load double*, double** %12
%43 = load i64, i64* %15
%44 = getelementptr inbounds double, double* %42, i64 %43
store double 4.000000e+00, double* %44
%45 = load i64, i64* %14
%46 = load i64, i64* %8
%47 = sub i64 %46, 1
%48 = icmp ult i64 %45, %47
br i1 %48, label %49, label %60
49: ; preds = %37
%50 = load double*, double** %11
%51 = load i64, i64* %16
%52 = getelementptr inbounds double, double* %50, i64 %51
store double -1.000000e+00, double* %52
%53 = load i64, i64* %15
%54 = add i64 %53, 1
%55 = load i64*, i64** %10
%56 = load i64, i64* %16
%57 = getelementptr inbounds i64, i64* %55, i64 %56
store i64 %54, i64* %57
%58 = load i64, i64* %16
%59 = add i64 %58, 1
store i64 %59, i64* %16
br label %60
60: ; preds = %49, %37
%61 = load i64, i64* %13
%62 = load i64, i64* %7
%63 = sub i64 %62, 1
%64 = icmp ult i64 %61, %63
br i1 %64, label %65, label %77
65: ; preds = %60
%66 = load double*, double** %11
%67 = load i64, i64* %16
%68 = getelementptr inbounds double, double* %66, i64 %67
store double -1.000000e+00, double* %68
%69 = load i64, i64* %15
%70 = load i64, i64* %8
%71 = add i64 %69, %70
%72 = load i64*, i64** %10
%73 = load i64, i64* %16
%74 = getelementptr inbounds i64, i64* %72, i64 %73
store i64 %71, i64* %74
%75 = load i64, i64* %16
%76 = add i64 %75, 1
store i64 %76, i64* %16
br label %77
77: ; preds = %65, %60
br label %78
78: ; preds = %77
%79 = load i64, i64* %14
%80 = add i64 %79, 1
store i64 %80, i64* %14
%81 = load i64, i64* %15
%82 = add i64 %81, 1
store i64 %82, i64* %15
br label %33
83: ; preds = %33
br label %84
84: ; preds = %83
%85 = load i64, i64* %13
%86 = add i64 %85, 1
store i64 %86, i64* %13
br label %28
87: ; preds = %28
%88 = load i64, i64* %18
%89 = load i64, i64* %16
%90 = icmp eq i64 %88, %89
%91 = zext i1 %90 to i32
%92 = call i32 @assert(i32 %91)
%93 = load i64, i64* %18
%94 = load i64*, i64** %9
%95 = load i64, i64* %17
%96 = getelementptr inbounds i64, i64* %94, i64 %95
store i64 %93, i64* %96
ret void
}

LLVM IR (-O2):
define void @gall_laplace_sym(i64 %0, i64 %1, i64* nocapture writeonly %2, i64* nocapture writeonly %3, double* nocapture writeonly %4, double* nocapture writeonly %5) {
%7 = mul i64 %1, %0
%8 = shl i64 %7, 1
%9 = add i64 %1, %0
%10 = sub i64 %8, %9
%11 = icmp eq i64 %0, 0
br i1 %11, label %51, label %12
12: ; preds = %6
%13 = icmp eq i64 %1, 0
%14 = add i64 %1, -1
%15 = add i64 %0, -1
br label %16
16: ; preds = %12, %46
%17 = phi i64 [ 0, %12 ], [ %49, %46 ]
%18 = phi i64 [ 0, %12 ], [ %48, %46 ]
%19 = phi i64 [ 0, %12 ], [ %47, %46 ]
br i1 %13, label %46, label %20
20: ; preds = %16
%21 = icmp ult i64 %17, %15
br label %22
22: ; preds = %20, %41
%23 = phi i64 [ 0, %20 ], [ %43, %41 ]
%24 = phi i64 [ %18, %20 ], [ %42, %41 ]
%25 = phi i64 [ %19, %20 ], [ %44, %41 ]
%26 = getelementptr inbounds i64, i64* %2, i64 %25
store i64 %24, i64* %26
%27 = getelementptr inbounds double, double* %5, i64 %25
store double 4.000000e+00, double* %27
%28 = icmp ult i64 %23, %14
br i1 %28, label %29, label %34
29: ; preds = %22
%30 = getelementptr inbounds double, double* %4, i64 %24
store double -1.000000e+00, double* %30
%31 = add i64 %25, 1
%32 = getelementptr inbounds i64, i64* %3, i64 %24
store i64 %31, i64* %32
%33 = add i64 %24, 1
br label %34
34: ; preds = %29, %22
%35 = phi i64 [ %33, %29 ], [ %24, %22 ]
br i1 %21, label %36, label %41
36: ; preds = %34
%37 = getelementptr inbounds double, double* %4, i64 %35
store double -1.000000e+00, double* %37
%38 = add i64 %25, %1
%39 = getelementptr inbounds i64, i64* %3, i64 %35
store i64 %38, i64* %39
%40 = add i64 %35, 1
br label %41
41: ; preds = %34, %36
%42 = phi i64 [ %40, %36 ], [ %35, %34 ]
%43 = add nuw i64 %23, 1
%44 = add i64 %25, 1
%45 = icmp eq i64 %43, %1
br i1 %45, label %46, label %22
46: ; preds = %41, %16
%47 = phi i64 [ %19, %16 ], [ %44, %41 ]
%48 = phi i64 [ %18, %16 ], [ %42, %41 ]
%49 = add nuw i64 %17, 1
%50 = icmp eq i64 %49, %0
br i1 %50, label %51, label %16
51: ; preds = %46, %6
%52 = phi i64 [ 0, %6 ], [ %48, %46 ]
%53 = icmp eq i64 %10, %52
%54 = zext i1 %53 to i32
%55 = tail call i32 @assert(i32 %54)
%56 = getelementptr inbounds i64, i64* %2, i64 %7
store i64 %10, i64* %56
ret void
}