int setNumber(int int_x, int int_y, int int_largeur, int int_hauteur,
              int **int_pixels, int **mat_filtre, int int_taille,
              int int_decalage, int bool_normalisation) {
  int int_i;
  int int_j;
  int int_result;
  int_result = 0;
  for (int_i = 0; int_i < int_taille; int_i += 1) {
    for (int_j = 0; int_j < int_taille; int_j += 1) {
      int_result += mat_filtre[int_i][int_j] *
                    int_pixels[int_x - int_decalage + int_i]
                              [int_y - int_decalage + int_i];
    }
  }
  if (bool_normalisation == 0) {
    if (int_result < 0)
      return (0);
    else if (int_result > 255)
      return (255);
    else
      return (int_result);
  } else
    return (int_result);
}


x86 assembly (clang, -O0):
<setNumber>:
push   %rbp
mov    %rsp,%rbp
mov    0x20(%rbp),%eax
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%eax
mov    %edi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %ecx,-0x14(%rbp)
mov    %r8,-0x20(%rbp)
mov    %r9,-0x28(%rbp)
movl   $0x0,-0x34(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    11ac <setNumber+0xac>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    1199 <setNumber+0x99>
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x20(%rbp),%rcx
mov    -0x8(%rbp),%edx
sub    0x18(%rbp),%edx
add    -0x2c(%rbp),%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,8),%rcx
mov    -0xc(%rbp),%edx
sub    0x18(%rbp),%edx
add    -0x2c(%rbp),%edx
movslq %edx,%rdx
imul   (%rcx,%rdx,4),%eax
add    -0x34(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1142 <setNumber+0x42>
jmp    119e <setNumber+0x9e>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    112f <setNumber+0x2f>
cmpl   $0x0,0x20(%rbp)
jne    11f0 <setNumber+0xf0>
cmpl   $0x0,-0x34(%rbp)
jge    11cc <setNumber+0xcc>
movl   $0x0,-0x4(%rbp)
jmp    11f6 <setNumber+0xf6>
cmpl   $0xff,-0x34(%rbp)
jle    11e5 <setNumber+0xe5>
movl   $0xff,-0x4(%rbp)
jmp    11f6 <setNumber+0xf6>
mov    -0x34(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    11f6 <setNumber+0xf6>
mov    -0x34(%rbp),%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<setNumber>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    0x38(%rsp),%r14d
test   %r14d,%r14d
jle    133e <setNumber+0x23e>
mov    0x40(%rsp),%eax
sub    %eax,%edi
sub    %eax,%esi
movslq %edi,%r13
movslq %esi,%r11
mov    %r14d,%edi
mov    %edi,%r10d
and    $0xfffffff8,%r10d
lea    -0x8(%r10),%r15
mov    %r15,%r12
shr    $0x3,%r12
add    $0x1,%r12
mov    %r12,%rax
and    $0xfffffffffffffffe,%rax
mov    %rax,-0x8(%rsp)
xor    %eax,%eax
xor    %edx,%edx
jmp    116d <setNumber+0x6d>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%rax
cmp    %rdi,%rax
je     1324 <setNumber+0x224>
lea    (%rax,%r13,1),%rcx
lea    (%rax,%r11,1),%rbp
mov    (%r9,%rax,8),%rbx
mov    (%r8,%rcx,8),%rcx
mov    (%rcx,%rbp,4),%ebp
cmp    $0x8,%r14d
jae    1190 <setNumber+0x90>
xor    %ecx,%ecx
jmp    1300 <setNumber+0x200>
nopl   (%rax)
movd   %edx,%xmm0
movd   %ebp,%xmm1
pshufd $0x0,%xmm1,%xmm1
pshufd $0xf5,%xmm1,%xmm8
pxor   %xmm3,%xmm3
test   %r15,%r15
je     1316 <setNumber+0x216>
mov    -0x8(%rsp),%r14
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movdqu (%rbx,%rdx,4),%xmm5
movdqu 0x10(%rbx,%rdx,4),%xmm6
movdqu 0x20(%rbx,%rdx,4),%xmm7
movdqu 0x30(%rbx,%rdx,4),%xmm4
movdqa %xmm1,%xmm2
pmuludq %xmm5,%xmm2
pshufd $0xe8,%xmm2,%xmm2
pshufd $0xf5,%xmm5,%xmm5
pmuludq %xmm8,%xmm5
pshufd $0xe8,%xmm5,%xmm5
punpckldq %xmm5,%xmm2
paddd  %xmm0,%xmm2
movdqa %xmm1,%xmm0
pmuludq %xmm6,%xmm0
pshufd $0xe8,%xmm0,%xmm5
pshufd $0xf5,%xmm6,%xmm0
pmuludq %xmm8,%xmm0
pshufd $0xe8,%xmm0,%xmm0
punpckldq %xmm0,%xmm5
paddd  %xmm3,%xmm5
movdqa %xmm1,%xmm0
pmuludq %xmm7,%xmm0
pshufd $0xe8,%xmm0,%xmm0
pshufd $0xf5,%xmm7,%xmm3
pmuludq %xmm8,%xmm3
pshufd $0xe8,%xmm3,%xmm3
punpckldq %xmm3,%xmm0
paddd  %xmm2,%xmm0
movdqa %xmm1,%xmm2
pmuludq %xmm4,%xmm2
pshufd $0xe8,%xmm2,%xmm3
pshufd $0xf5,%xmm4,%xmm2
pmuludq %xmm8,%xmm2
pshufd $0xe8,%xmm2,%xmm2
punpckldq %xmm2,%xmm3
paddd  %xmm5,%xmm3
add    $0x10,%rdx
add    $0xfffffffffffffffe,%r14
jne    11c0 <setNumber+0xc0>
test   $0x1,%r12b
je     12ca <setNumber+0x1ca>
movdqu (%rbx,%rdx,4),%xmm2
movdqu 0x10(%rbx,%rdx,4),%xmm4
movdqa %xmm1,%xmm5
pmuludq %xmm2,%xmm5
pshufd $0xe8,%xmm5,%xmm5
pshufd $0xf5,%xmm2,%xmm2
pmuludq %xmm8,%xmm2
pshufd $0xe8,%xmm2,%xmm2
punpckldq %xmm2,%xmm5
paddd  %xmm5,%xmm0
pmuludq %xmm4,%xmm1
pshufd $0xe8,%xmm1,%xmm1
pshufd $0xf5,%xmm4,%xmm2
pmuludq %xmm8,%xmm2
pshufd $0xe8,%xmm2,%xmm2
punpckldq %xmm2,%xmm1
paddd  %xmm1,%xmm3
paddd  %xmm3,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%edx
mov    %r10,%rcx
cmp    %rdi,%r10
mov    0x38(%rsp),%r14d
je     1160 <setNumber+0x60>
cs nopw 0x0(%rax,%rax,1)
nop
mov    (%rbx,%rcx,4),%esi
imul   %ebp,%esi
add    %esi,%edx
add    $0x1,%rcx
cmp    %rcx,%rdi
jne    1300 <setNumber+0x200>
jmp    1160 <setNumber+0x60>
xor    %edx,%edx
test   $0x1,%r12b
jne    127b <setNumber+0x17b>
jmp    12ca <setNumber+0x1ca>
cmpl   $0x0,0x48(%rsp)
jne    134c <setNumber+0x24c>
test   %edx,%edx
js     1359 <setNumber+0x259>
mov    $0xff,%eax
cmp    $0xfe,%edx
jbe    134c <setNumber+0x24c>
jmp    134e <setNumber+0x24e>
xor    %edx,%edx
mov    $0x0,%eax
cmpl   $0x0,0x48(%rsp)
jne    134e <setNumber+0x24e>
mov    %edx,%eax
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %eax,%eax
jmp    134e <setNumber+0x24e>

LLVM IR (-O0):
define i32 @setNumber(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 i32
%20 = alloca i32
%21 = alloca i32
%22 = alloca i32
store i32 %0, i32* %11
store i32 %1, i32* %12
store i32 %2, i32* %13
store i32 %3, i32* %14
store i32** %4, i32*** %15
store i32** %5, i32*** %16
store i32 %6, i32* %17
store i32 %7, i32* %18
store i32 %8, i32* %19
store i32 0, i32* %22
store i32 0, i32* %20
br label %23
23: ; preds = %66, %9
%24 = load i32, i32* %20
%25 = load i32, i32* %17
%26 = icmp slt i32 %24, %25
br i1 %26, label %27, label %69
27: ; preds = %23
store i32 0, i32* %21
br label %28
28: ; preds = %62, %27
%29 = load i32, i32* %21
%30 = load i32, i32* %17
%31 = icmp slt i32 %29, %30
br i1 %31, label %32, label %65
32: ; preds = %28
%33 = load i32**, i32*** %16
%34 = load i32, i32* %20
%35 = sext i32 %34 to i64
%36 = getelementptr inbounds i32*, i32** %33, i64 %35
%37 = load i32*, i32** %36
%38 = load i32, i32* %21
%39 = sext i32 %38 to i64
%40 = getelementptr inbounds i32, i32* %37, i64 %39
%41 = load i32, i32* %40
%42 = load i32**, i32*** %15
%43 = load i32, i32* %11
%44 = load i32, i32* %18
%45 = sub nsw i32 %43, %44
%46 = load i32, i32* %20
%47 = add nsw i32 %45, %46
%48 = sext i32 %47 to i64
%49 = getelementptr inbounds i32*, i32** %42, i64 %48
%50 = load i32*, i32** %49
%51 = load i32, i32* %12
%52 = load i32, i32* %18
%53 = sub nsw i32 %51, %52
%54 = load i32, i32* %20
%55 = add nsw i32 %53, %54
%56 = sext i32 %55 to i64
%57 = getelementptr inbounds i32, i32* %50, i64 %56
%58 = load i32, i32* %57
%59 = mul nsw i32 %41, %58
%60 = load i32, i32* %22
%61 = add nsw i32 %60, %59
store i32 %61, i32* %22
br label %62
62: ; preds = %32
%63 = load i32, i32* %21
%64 = add nsw i32 %63, 1
store i32 %64, i32* %21
br label %28
65: ; preds = %28
br label %66
66: ; preds = %65
%67 = load i32, i32* %20
%68 = add nsw i32 %67, 1
store i32 %68, i32* %20
br label %23
69: ; preds = %23
%70 = load i32, i32* %19
%71 = icmp eq i32 %70, 0
br i1 %71, label %72, label %82
72: ; preds = %69
%73 = load i32, i32* %22
%74 = icmp slt i32 %73, 0
br i1 %74, label %75, label %76
75: ; preds = %72
store i32 0, i32* %10
br label %84
76: ; preds = %72
%77 = load i32, i32* %22
%78 = icmp sgt i32 %77, 255
br i1 %78, label %79, label %80
79: ; preds = %76
store i32 255, i32* %10
br label %84
80: ; preds = %76
%81 = load i32, i32* %22
store i32 %81, i32* %10
br label %84
82: ; preds = %69
%83 = load i32, i32* %22
store i32 %83, i32* %10
br label %84
84: ; preds = %82, %80, %79, %75
%85 = load i32, i32* %10
ret i32 %85
}

LLVM IR (-O2):
define i32 @setNumber(i32 %0, i32 %1, i32 %2, i32 %3, i32** nocapture %4, i32** nocapture %5, i32 %6, i32 %7, i32 %8) {
%10 = icmp sgt i32 %6, 0
br i1 %10, label %11, label %114
11: ; preds = %9
%12 = sub i32 %0, %7
%13 = sub i32 %1, %7
%14 = sext i32 %12 to i64
%15 = sext i32 %13 to i64
%16 = zext i32 %6 to i64
%17 = and i64 %16, 4294967288
%18 = add nsw i64 %17, -8
%19 = lshr exact i64 %18, 3
%20 = add nuw nsw i64 %19, 1
%21 = icmp ult i32 %6, 8
%22 = and i64 %16, 4294967288
%23 = and i64 %20, 1
%24 = icmp eq i64 %18, 0
%25 = and i64 %20, 4611686018427387902
%26 = icmp eq i64 %23, 0
%27 = icmp eq i64 %22, %16
br label %28
28: ; preds = %108, %11
%29 = phi i64 [ 0, %11 ], [ %110, %108 ]
%30 = phi i32 [ 0, %11 ], [ %109, %108 ]
%31 = getelementptr inbounds i32*, i32** %5, i64 %29
%32 = load i32*, i32** %31
%33 = add nsw i64 %29, %14
%34 = getelementptr inbounds i32*, i32** %4, i64 %33
%35 = load i32*, i32** %34
%36 = add nsw i64 %29, %15
%37 = getelementptr inbounds i32, i32* %35, i64 %36
%38 = load i32, i32* %37
br i1 %21, label %96, label %39
39: ; preds = %28
%40 = insertelement <4 x i32> <i32 poison, i32 0, i32 0, i32 0>, i32 %30, i64 0
%41 = insertelement <4 x i32> poison, i32 %38, i64 0
%42 = shufflevector <4 x i32> %41, <4 x i32> poison, <4 x i32> zeroinitializer
%43 = insertelement <4 x i32> poison, i32 %38, i64 0
%44 = shufflevector <4 x i32> %43, <4 x i32> poison, <4 x i32> zeroinitializer
br i1 %24, label %74, label %45
45: ; preds = %39, %45
%46 = phi i64 [ %71, %45 ], [ 0, %39 ]
%47 = phi <4 x i32> [ %69, %45 ], [ %40, %39 ]
%48 = phi <4 x i32> [ %70, %45 ], [ zeroinitializer, %39 ]
%49 = phi i64 [ %72, %45 ], [ 0, %39 ]
%50 = getelementptr inbounds i32, i32* %32, i64 %46
%51 = bitcast i32* %50 to <4 x i32>*
%52 = load <4 x i32>, <4 x i32>* %51
%53 = getelementptr inbounds i32, i32* %50, i64 4
%54 = bitcast i32* %53 to <4 x i32>*
%55 = load <4 x i32>, <4 x i32>* %54
%56 = mul nsw <4 x i32> %42, %52
%57 = mul nsw <4 x i32> %44, %55
%58 = add <4 x i32> %56, %47
%59 = add <4 x i32> %57, %48
%60 = or i64 %46, 8
%61 = getelementptr inbounds i32, i32* %32, i64 %60
%62 = bitcast i32* %61 to <4 x i32>*
%63 = load <4 x i32>, <4 x i32>* %62
%64 = getelementptr inbounds i32, i32* %61, i64 4
%65 = bitcast i32* %64 to <4 x i32>*
%66 = load <4 x i32>, <4 x i32>* %65
%67 = mul nsw <4 x i32> %42, %63
%68 = mul nsw <4 x i32> %44, %66
%69 = add <4 x i32> %67, %58
%70 = add <4 x i32> %68, %59
%71 = add nuw i64 %46, 16
%72 = add i64 %49, 2
%73 = icmp eq i64 %72, %25
br i1 %73, label %74, label %45
74: ; preds = %45, %39
%75 = phi <4 x i32> [ undef, %39 ], [ %69, %45 ]
%76 = phi <4 x i32> [ undef, %39 ], [ %70, %45 ]
%77 = phi i64 [ 0, %39 ], [ %71, %45 ]
%78 = phi <4 x i32> [ %40, %39 ], [ %69, %45 ]
%79 = phi <4 x i32> [ zeroinitializer, %39 ], [ %70, %45 ]
br i1 %26, label %91, label %80
80: ; preds = %74
%81 = getelementptr inbounds i32, i32* %32, i64 %77
%82 = bitcast i32* %81 to <4 x i32>*
%83 = load <4 x i32>, <4 x i32>* %82
%84 = getelementptr inbounds i32, i32* %81, i64 4
%85 = bitcast i32* %84 to <4 x i32>*
%86 = load <4 x i32>, <4 x i32>* %85
%87 = mul nsw <4 x i32> %42, %83
%88 = mul nsw <4 x i32> %44, %86
%89 = add <4 x i32> %87, %78
%90 = add <4 x i32> %88, %79
br label %91
91: ; preds = %74, %80
%92 = phi <4 x i32> [ %75, %74 ], [ %89, %80 ]
%93 = phi <4 x i32> [ %76, %74 ], [ %90, %80 ]
%94 = add <4 x i32> %93, %92
%95 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %94)
br i1 %27, label %108, label %96
96: ; preds = %28, %91
%97 = phi i64 [ 0, %28 ], [ %22, %91 ]
%98 = phi i32 [ %30, %28 ], [ %95, %91 ]
br label %99
99: ; preds = %96, %99
%100 = phi i64 [ %106, %99 ], [ %97, %96 ]
%101 = phi i32 [ %105, %99 ], [ %98, %96 ]
%102 = getelementptr inbounds i32, i32* %32, i64 %100
%103 = load i32, i32* %102
%104 = mul nsw i32 %38, %103
%105 = add nsw i32 %104, %101
%106 = add nuw nsw i64 %100, 1
%107 = icmp eq i64 %106, %16
br i1 %107, label %108, label %99
108: ; preds = %99, %91
%109 = phi i32 [ %95, %91 ], [ %105, %99 ]
%110 = add nuw nsw i64 %29, 1
%111 = icmp eq i64 %110, %16
br i1 %111, label %112, label %28
112: ; preds = %108
%113 = icmp eq i32 %8, 0
br i1 %113, label %116, label %122
114: ; preds = %9
%115 = icmp eq i32 %8, 0
br i1 %115, label %120, label %122
116: ; preds = %112
%117 = icmp slt i32 %109, 0
br i1 %117, label %122, label %118
118: ; preds = %116
%119 = icmp ult i32 %109, 255
br i1 %119, label %120, label %122
120: ; preds = %114, %118
%121 = phi i32 [ %109, %118 ], [ 0, %114 ]
br label %122
122: ; preds = %120, %118, %114, %112, %116
%123 = phi i32 [ 0, %116 ], [ %109, %112 ], [ 0, %114 ], [ %121, %120 ], [ 255, %118 ]
ret i32 %123
}