#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 */
void scale(size_t r, size_t c, double X[r][c], double s) {
  size_t i, j;
  for (i = 0; i < r; i++) {
    for (j = 0; j < c; j++)
      X[i][j] *= s;
  }
}


x86 assembly (clang, -O0):
<scale>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
movsd  %xmm0,-0x20(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x38(%rbp)
movq   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%rax
cmp    -0x8(%rbp),%rax
jae    1197 <scale+0x97>
movq   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%rax
cmp    -0x10(%rbp),%rax
jae    1181 <scale+0x81>
mov    -0x38(%rbp),%rcx
movsd  -0x20(%rbp),%xmm0
mov    -0x18(%rbp),%rax
imul   -0x28(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    -0x30(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    113b <scale+0x3b>
jmp    1186 <scale+0x86>
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
jmp    1125 <scale+0x25>
pop    %rbp
ret

x86 assembly (clang, -O2):
<scale>:
push   %r15
push   %r14
push   %r12
push   %rbx
test   %rdi,%rdi
je     123e <scale+0x13e>
lea    -0x4(%rsi),%r8
mov    %r8,%r10
shr    $0x2,%r10
add    $0x1,%r10
mov    %rsi,%r11
and    $0xfffffffffffffffc,%r11
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
mov    %r10,%r9
and    $0xfffffffffffffffe,%r9
lea    0x30(%rdx),%rcx
lea    0x0(,%rsi,8),%r14
xor    %r15d,%r15d
mov    %rdx,%r12
jmp    1163 <scale+0x63>
nopl   0x0(%rax)
add    $0x1,%r15
add    %r14,%rcx
add    %r14,%r12
cmp    %rdi,%r15
je     123e <scale+0x13e>
test   %rsi,%rsi
je     1150 <scale+0x50>
cmp    $0x4,%rsi
jae    1180 <scale+0x80>
xor    %eax,%eax
jmp    1220 <scale+0x120>
cs nopw 0x0(%rax,%rax,1)
nop
cmp    $0x4,%r8
jae    118a <scale+0x8a>
xor    %ebx,%ebx
jmp    11d8 <scale+0xd8>
mov    %r9,%rax
xor    %ebx,%ebx
nop
movupd -0x30(%rcx,%rbx,8),%xmm2
movupd -0x20(%rcx,%rbx,8),%xmm3
movupd -0x10(%rcx,%rbx,8),%xmm4
movupd (%rcx,%rbx,8),%xmm5
mulpd  %xmm1,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,-0x30(%rcx,%rbx,8)
movupd %xmm3,-0x20(%rcx,%rbx,8)
mulpd  %xmm1,%xmm4
mulpd  %xmm1,%xmm5
movupd %xmm4,-0x10(%rcx,%rbx,8)
movupd %xmm5,(%rcx,%rbx,8)
add    $0x8,%rbx
add    $0xfffffffffffffffe,%rax
jne    1190 <scale+0x90>
test   $0x1,%r10b
je     1207 <scale+0x107>
mov    %r15,%rax
imul   %rsi,%rax
lea    (%rdx,%rax,8),%rax
movupd (%rax,%rbx,8),%xmm2
movupd 0x10(%rax,%rbx,8),%xmm3
mulpd  %xmm1,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,(%rax,%rbx,8)
movupd %xmm3,0x10(%rax,%rbx,8)
mov    %r11,%rax
cmp    %rsi,%r11
je     1150 <scale+0x50>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%r12,%rax,8),%xmm2
mulsd  %xmm0,%xmm2
movsd  %xmm2,(%r12,%rax,8)
add    $0x1,%rax
cmp    %rax,%rsi
jne    1220 <scale+0x120>
jmp    1150 <scale+0x50>
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
ret

LLVM IR (-O0):
define void @scale(i64 %0, i64 %1, double* %2, double %3) {
%5 = alloca i64
%6 = alloca i64
%7 = alloca double*
%8 = alloca double
%9 = alloca i64
%10 = alloca i64
store i64 %0, i64* %5
store i64 %1, i64* %6
store double* %2, double** %7
store double %3, double* %8
%11 = load i64, i64* %5
%12 = load i64, i64* %6
store i64 0, i64* %9
br label %13
13: ; preds = %36, %4
%14 = load i64, i64* %9
%15 = load i64, i64* %5
%16 = icmp ult i64 %14, %15
br i1 %16, label %17, label %39
17: ; preds = %13
store i64 0, i64* %10
br label %18
18: ; preds = %32, %17
%19 = load i64, i64* %10
%20 = load i64, i64* %6
%21 = icmp ult i64 %19, %20
br i1 %21, label %22, label %35
22: ; preds = %18
%23 = load double, double* %8
%24 = load double*, double** %7
%25 = load i64, i64* %9
%26 = mul nsw i64 %25, %12
%27 = getelementptr inbounds double, double* %24, i64 %26
%28 = load i64, i64* %10
%29 = getelementptr inbounds double, double* %27, i64 %28
%30 = load double, double* %29
%31 = fmul double %30, %23
store double %31, double* %29
br label %32
32: ; preds = %22
%33 = load i64, i64* %10
%34 = add i64 %33, 1
store i64 %34, i64* %10
br label %18
35: ; preds = %18
br label %36
36: ; preds = %35
%37 = load i64, i64* %9
%38 = add i64 %37, 1
store i64 %38, i64* %9
br label %13
39: ; preds = %13
ret void
}

LLVM IR (-O2):
define void @scale(i64 %0, i64 %1, double* nocapture %2, double %3) {
%5 = icmp eq i64 %0, 0
br i1 %5, label %81, label %6
6: ; preds = %4
%7 = icmp eq i64 %1, 0
%8 = add i64 %1, -4
%9 = lshr i64 %8, 2
%10 = add nuw nsw i64 %9, 1
%11 = icmp ult i64 %1, 4
%12 = and i64 %1, -4
%13 = insertelement <2 x double> poison, double %3, i64 0
%14 = shufflevector <2 x double> %13, <2 x double> poison, <2 x i32> zeroinitializer
%15 = insertelement <2 x double> poison, double %3, i64 0
%16 = shufflevector <2 x double> %15, <2 x double> poison, <2 x i32> zeroinitializer
%17 = and i64 %10, 1
%18 = icmp ult i64 %8, 4
%19 = and i64 %10, 9223372036854775806
%20 = icmp eq i64 %17, 0
%21 = icmp eq i64 %12, %1
br label %22
22: ; preds = %6, %78
%23 = phi i64 [ 0, %6 ], [ %79, %78 ]
br i1 %7, label %78, label %24
24: ; preds = %22
%25 = mul nsw i64 %23, %1
%26 = getelementptr inbounds double, double* %2, i64 %25
br i1 %11, label %69, label %27
27: ; preds = %24
br i1 %18, label %55, label %28
28: ; preds = %27, %28
%29 = phi i64 [ %52, %28 ], [ 0, %27 ]
%30 = phi i64 [ %53, %28 ], [ 0, %27 ]
%31 = getelementptr inbounds double, double* %26, i64 %29
%32 = bitcast double* %31 to <2 x double>*
%33 = load <2 x double>, <2 x double>* %32
%34 = getelementptr inbounds double, double* %31, i64 2
%35 = bitcast double* %34 to <2 x double>*
%36 = load <2 x double>, <2 x double>* %35
%37 = fmul <2 x double> %33, %14
%38 = fmul <2 x double> %36, %16
%39 = bitcast double* %31 to <2 x double>*
store <2 x double> %37, <2 x double>* %39
%40 = bitcast double* %34 to <2 x double>*
store <2 x double> %38, <2 x double>* %40
%41 = or i64 %29, 4
%42 = getelementptr inbounds double, double* %26, i64 %41
%43 = bitcast double* %42 to <2 x double>*
%44 = load <2 x double>, <2 x double>* %43
%45 = getelementptr inbounds double, double* %42, i64 2
%46 = bitcast double* %45 to <2 x double>*
%47 = load <2 x double>, <2 x double>* %46
%48 = fmul <2 x double> %44, %14
%49 = fmul <2 x double> %47, %16
%50 = bitcast double* %42 to <2 x double>*
store <2 x double> %48, <2 x double>* %50
%51 = bitcast double* %45 to <2 x double>*
store <2 x double> %49, <2 x double>* %51
%52 = add nuw i64 %29, 8
%53 = add i64 %30, 2
%54 = icmp eq i64 %53, %19
br i1 %54, label %55, label %28
55: ; preds = %28, %27
%56 = phi i64 [ 0, %27 ], [ %52, %28 ]
br i1 %20, label %68, label %57
57: ; preds = %55
%58 = getelementptr inbounds double, double* %26, i64 %56
%59 = bitcast double* %58 to <2 x double>*
%60 = load <2 x double>, <2 x double>* %59
%61 = getelementptr inbounds double, double* %58, i64 2
%62 = bitcast double* %61 to <2 x double>*
%63 = load <2 x double>, <2 x double>* %62
%64 = fmul <2 x double> %60, %14
%65 = fmul <2 x double> %63, %16
%66 = bitcast double* %58 to <2 x double>*
store <2 x double> %64, <2 x double>* %66
%67 = bitcast double* %61 to <2 x double>*
store <2 x double> %65, <2 x double>* %67
br label %68
68: ; preds = %55, %57
br i1 %21, label %78, label %69
69: ; preds = %24, %68
%70 = phi i64 [ 0, %24 ], [ %12, %68 ]
br label %71
71: ; preds = %69, %71
%72 = phi i64 [ %76, %71 ], [ %70, %69 ]
%73 = getelementptr inbounds double, double* %26, i64 %72
%74 = load double, double* %73
%75 = fmul double %74, %3
store double %75, double* %73
%76 = add nuw i64 %72, 1
%77 = icmp eq i64 %76, %1
br i1 %77, label %78, label %71
78: ; preds = %71, %68, %22
%79 = add nuw i64 %23, 1
%80 = icmp eq i64 %79, %0
br i1 %80, label %81, label %22
81: ; preds = %78, %4
ret void
}