void filtre_1(char *data, int largeur, int hauteur, char *data_sortie) {
  int cpt_out, tmp_i;
  int x, y;
  unsigned char p0, p1, p2, p3, p4, p5, p6, p7, p8;
  int coef[9];
  int alpha, beta;
  coef[0] = -1;
  coef[1] = -1;
  coef[2] = 0;
  coef[3] = -1;
  coef[4] = 0;
  coef[5] = +1;
  coef[6] = 0;
  coef[7] = +1;
  coef[8] = +1;
  alpha = 1;
  beta = 128;
  cpt_out = 0;
  for (y = 1; y < hauteur - 1; y++) {
    for (x = 1; x < largeur - 1; x++) {
      p0 = data[(y - 1) * largeur + x - 1];
      p1 = data[(y - 1) * largeur + x];
      p2 = data[(y - 1) * largeur + x + 1];
      p3 = data[y * largeur + x - 1];
      p4 = data[y * largeur + x];
      p5 = data[y * largeur + x + 1];
      p6 = data[(y + 1) * largeur + x - 1];
      p7 = data[(y + 1) * largeur + x];
      p8 = data[(y + 1) * largeur + x + 1];
      tmp_i = coef[0] * p0 + coef[1] * p1 + coef[2] * p2 + coef[3] * p3 +
              coef[4] * p4 + coef[5] * p5 + coef[6] * p6 + coef[7] * p7 +
              coef[8] * p8;
      tmp_i = alpha * (tmp_i + beta);
      if (tmp_i > 255) {
        data_sortie[cpt_out] = 255;
      } else if (tmp_i < 0) {
        data_sortie[cpt_out] = 0;
      } else {
        data_sortie[cpt_out] = (unsigned char)tmp_i;
      }
      cpt_out++;
    }
  }
}


x86 assembly (clang, -O0):
<filtre_1>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
movl   $0xffffffff,-0x60(%rbp)
movl   $0xffffffff,-0x5c(%rbp)
movl   $0x0,-0x58(%rbp)
movl   $0xffffffff,-0x54(%rbp)
movl   $0x0,-0x50(%rbp)
movl   $0x1,-0x4c(%rbp)
movl   $0x0,-0x48(%rbp)
movl   $0x1,-0x44(%rbp)
movl   $0x1,-0x40(%rbp)
movl   $0x1,-0x64(%rbp)
movl   $0x80,-0x68(%rbp)
movl   $0x0,-0x1c(%rbp)
movl   $0x1,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    137d <filtre_1+0x27d>
movl   $0x1,-0x24(%rbp)
mov    -0x24(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    136a <filtre_1+0x26a>
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
imul   -0xc(%rbp),%ecx
add    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x29(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
imul   -0xc(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x2a(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
imul   -0xc(%rbp),%ecx
add    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x2b(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x2c(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x2d(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x2e(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
imul   -0xc(%rbp),%ecx
add    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x2f(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
imul   -0xc(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x30(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
imul   -0xc(%rbp),%ecx
add    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x31(%rbp)
mov    -0x60(%rbp),%eax
movzbl -0x29(%rbp),%ecx
imul   %ecx,%eax
mov    -0x5c(%rbp),%ecx
movzbl -0x2a(%rbp),%edx
imul   %edx,%ecx
add    %ecx,%eax
mov    -0x58(%rbp),%ecx
movzbl -0x2b(%rbp),%edx
imul   %edx,%ecx
add    %ecx,%eax
mov    -0x54(%rbp),%ecx
movzbl -0x2c(%rbp),%edx
imul   %edx,%ecx
add    %ecx,%eax
mov    -0x50(%rbp),%ecx
movzbl -0x2d(%rbp),%edx
imul   %edx,%ecx
add    %ecx,%eax
mov    -0x4c(%rbp),%ecx
movzbl -0x2e(%rbp),%edx
imul   %edx,%ecx
add    %ecx,%eax
mov    -0x48(%rbp),%ecx
movzbl -0x2f(%rbp),%edx
imul   %edx,%ecx
add    %ecx,%eax
mov    -0x44(%rbp),%ecx
movzbl -0x30(%rbp),%edx
imul   %edx,%ecx
add    %ecx,%eax
mov    -0x40(%rbp),%ecx
movzbl -0x31(%rbp),%edx
imul   %edx,%ecx
add    %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x64(%rbp),%eax
mov    -0x20(%rbp),%ecx
add    -0x68(%rbp),%ecx
imul   %ecx,%eax
mov    %eax,-0x20(%rbp)
cmpl   $0xff,-0x20(%rbp)
jle    1323 <filtre_1+0x223>
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movb   $0xff,(%rax,%rcx,1)
jmp    1353 <filtre_1+0x253>
cmpl   $0x0,-0x20(%rbp)
jge    133e <filtre_1+0x23e>
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
jmp    134e <filtre_1+0x24e>
mov    -0x20(%rbp),%eax
mov    %al,%dl
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
jmp    1353 <filtre_1+0x253>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1185 <filtre_1+0x85>
jmp    136f <filtre_1+0x26f>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    116d <filtre_1+0x6d>
pop    %rbp
ret

x86 assembly (clang, -O2):
<filtre_1>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %rcx,-0x48(%rsp)
mov    %rdi,-0x50(%rsp)
cmp    $0x3,%edx
jl     15b8 <filtre_1+0x4b8>
add    $0xffffffff,%edx
lea    -0x1(%rsi),%eax
movslq %esi,%r15
lea    -0x1(%rax),%r11
mov    -0x48(%rsp),%rcx
lea    -0x1(%rcx,%rax,1),%rcx
mov    %rcx,-0x10(%rsp)
mov    -0x50(%rsp),%rdi
lea    0x1(%rdi),%rcx
mov    %rcx,-0x40(%rsp)
lea    0x1(%rdi,%rax,1),%rcx
mov    %rcx,-0x18(%rsp)
mov    %rax,-0x8(%rsp)
add    %rdi,%rax
mov    %rax,-0x20(%rsp)
mov    %r11,%rax
and    $0xfffffffffffffff0,%rax
lea    0x1(%rax),%rcx
mov    %rcx,-0x30(%rsp)
lea    0x2(%rdi),%rcx
mov    %rcx,-0x38(%rsp)
xor    %edi,%edi
mov    $0x1,%r9d
pxor   %xmm12,%xmm12
movdqa 0xe73(%rip),%xmm8
movdqa 0xe7a(%rip),%xmm9
movdqa 0xe81(%rip),%xmm11
mov    %rsi,-0x60(%rsp)
mov    %r15,-0x68(%rsp)
mov    %r11,-0x70(%rsp)
mov    %rax,-0x28(%rsp)
jmp    11cd <filtre_1+0xcd>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%r9
cmp    %rdx,%r9
je     15b8 <filtre_1+0x4b8>
cmp    $0x2,%esi
jle    11c0 <filtre_1+0xc0>
lea    -0x1(%r9),%r10
imul   %r15,%r10
mov    %r9,%r12
imul   %r15,%r12
add    $0x1,%r9
mov    %r9,%r14
imul   %r15,%r14
movslq %edi,%rdi
mov    $0x1,%r13d
cmp    $0x10,%r11
jb     1523 <filtre_1+0x423>
mov    %r9,-0x58(%rsp)
mov    -0x48(%rsp),%rax
lea    (%rax,%rdi,1),%r15
mov    -0x10(%rsp),%rax
mov    %rdi,-0x78(%rsp)
lea    (%rax,%rdi,1),%rsi
mov    -0x40(%rsp),%rax
add    %r14,%rax
mov    -0x18(%rsp),%rcx
lea    (%rcx,%r14,1),%rbx
mov    -0x50(%rsp),%rdi
lea    (%rdi,%r12,1),%rbp
cmp    %rbx,%r15
lea    (%rcx,%r12,1),%rbx
setb   %r8b
cmp    %rsi,%rax
setb   %r11b
cmp    %rbx,%r15
mov    -0x20(%rsp),%rax
lea    (%rax,%r10,1),%rbx
setb   %al
cmp    %rsi,%rbp
mov    %rdi,%rcx
setb   %r9b
cmp    %rbx,%r15
lea    (%rdi,%r10,1),%rbp
setb   %bl
cmp    %rsi,%rbp
setb   %sil
test   %r11b,%r8b
jne    150a <filtre_1+0x40a>
and    %r9b,%al
jne    150a <filtre_1+0x40a>
and    %sil,%bl
jne    150a <filtre_1+0x40a>
mov    -0x28(%rsp),%rbx
add    %rbx,-0x78(%rsp)
mov    -0x40(%rsp),%rcx
lea    (%rcx,%r10,1),%r8
mov    -0x38(%rsp),%rcx
lea    (%rcx,%r12,1),%r9
lea    (%rcx,%r14,1),%r11
xor    %ecx,%ecx
xchg   %ax,%ax
movdqu -0x1(%r8,%rcx,1),%xmm3
movdqu (%r8,%rcx,1),%xmm1
movdqu -0x2(%r9,%rcx,1),%xmm2
movdqu (%r9,%rcx,1),%xmm14
movdqu -0x1(%r11,%rcx,1),%xmm13
movdqu (%r11,%rcx,1),%xmm4
movdqa %xmm3,%xmm0
punpckhbw %xmm12,%xmm0
movdqa %xmm0,%xmm5
punpckhwd %xmm12,%xmm5
punpcklwd %xmm12,%xmm0
punpcklbw %xmm12,%xmm3
movdqa %xmm3,%xmm15
punpckhwd %xmm12,%xmm15
punpcklwd %xmm12,%xmm3
movdqa %xmm1,%xmm7
punpckhbw %xmm12,%xmm7
movdqa %xmm7,%xmm6
punpckhwd %xmm12,%xmm6
paddd  %xmm5,%xmm6
punpcklwd %xmm12,%xmm7
paddd  %xmm0,%xmm7
punpcklbw %xmm12,%xmm1
movdqa %xmm8,%xmm10
movdqa %xmm1,%xmm8
punpckhwd %xmm12,%xmm8
paddd  %xmm15,%xmm8
punpcklwd %xmm12,%xmm1
paddd  %xmm3,%xmm1
movdqa %xmm2,%xmm5
punpcklbw %xmm12,%xmm5
movdqa %xmm5,%xmm0
punpcklwd %xmm12,%xmm0
paddd  %xmm1,%xmm0
punpckhwd %xmm12,%xmm5
paddd  %xmm8,%xmm5
punpckhbw %xmm12,%xmm2
movdqa %xmm2,%xmm1
punpcklwd %xmm12,%xmm1
paddd  %xmm7,%xmm1
punpckhwd %xmm12,%xmm2
paddd  %xmm6,%xmm2
movdqa %xmm14,%xmm6
punpckhbw %xmm12,%xmm6
movdqa %xmm6,%xmm7
punpckhwd %xmm12,%xmm7
psubd  %xmm2,%xmm7
punpcklwd %xmm12,%xmm6
psubd  %xmm1,%xmm6
punpcklbw %xmm12,%xmm14
movdqa %xmm14,%xmm3
punpckhwd %xmm12,%xmm3
psubd  %xmm5,%xmm3
punpcklwd %xmm12,%xmm14
psubd  %xmm0,%xmm14
movdqa %xmm13,%xmm2
punpcklbw %xmm12,%xmm2
movdqa %xmm2,%xmm8
punpcklwd %xmm12,%xmm8
punpckhwd %xmm12,%xmm2
punpckhbw %xmm12,%xmm13
movdqa %xmm13,%xmm0
punpcklwd %xmm12,%xmm0
punpckhwd %xmm12,%xmm13
movdqa %xmm4,%xmm5
punpckhbw %xmm12,%xmm5
movdqa %xmm5,%xmm1
punpckhwd %xmm12,%xmm1
paddd  %xmm13,%xmm1
paddd  %xmm7,%xmm1
punpcklwd %xmm12,%xmm5
paddd  %xmm0,%xmm5
paddd  %xmm6,%xmm5
punpcklbw %xmm12,%xmm4
movdqa %xmm4,%xmm7
punpckhwd %xmm12,%xmm7
paddd  %xmm2,%xmm7
paddd  %xmm3,%xmm7
punpcklwd %xmm12,%xmm4
paddd  %xmm8,%xmm4
movdqa %xmm10,%xmm8
paddd  %xmm14,%xmm4
movdqa %xmm1,%xmm0
pcmpgtd %xmm10,%xmm0
movdqa %xmm5,%xmm2
pcmpgtd %xmm10,%xmm2
packssdw %xmm0,%xmm2
movdqa %xmm7,%xmm3
pcmpgtd %xmm10,%xmm3
movdqa %xmm4,%xmm0
pcmpgtd %xmm10,%xmm0
packssdw %xmm3,%xmm0
packsswb %xmm2,%xmm0
movdqa %xmm9,%xmm2
pcmpgtd %xmm1,%xmm2
movdqa %xmm9,%xmm3
pcmpgtd %xmm5,%xmm3
packssdw %xmm2,%xmm3
movdqa %xmm9,%xmm2
pcmpgtd %xmm7,%xmm2
movdqa %xmm9,%xmm6
pcmpgtd %xmm4,%xmm6
packssdw %xmm2,%xmm6
packsswb %xmm3,%xmm6
pand   %xmm11,%xmm1
pand   %xmm11,%xmm5
packuswb %xmm1,%xmm5
movdqa 0xb80(%rip),%xmm1
pand   %xmm11,%xmm7
pand   %xmm11,%xmm4
packuswb %xmm7,%xmm4
packuswb %xmm5,%xmm4
pxor   %xmm1,%xmm4
por    %xmm0,%xmm4
pandn  %xmm4,%xmm6
movdqu %xmm6,(%r15,%rcx,1)
add    $0x10,%rcx
cmp    %rcx,%rbx
jne    12b0 <filtre_1+0x1b0>
mov    -0x30(%rsp),%r13
mov    -0x70(%rsp),%r11
cmp    %rbx,%r11
mov    -0x60(%rsp),%rsi
mov    -0x68(%rsp),%r15
mov    -0x78(%rsp),%rdi
mov    -0x58(%rsp),%r9
je     11c4 <filtre_1+0xc4>
jmp    1523 <filtre_1+0x423>
mov    -0x60(%rsp),%rsi
mov    -0x68(%rsp),%r15
mov    -0x70(%rsp),%r11
mov    -0x78(%rsp),%rdi
mov    -0x58(%rsp),%r9
add    %r13,%r14
mov    -0x40(%rsp),%rax
add    %rax,%r14
add    %r13,%r12
add    %rax,%r12
add    %r13,%r10
add    -0x50(%rsp),%r10
mov    -0x8(%rsp),%rcx
sub    %r13,%rcx
mov    -0x48(%rsp),%rax
lea    (%rax,%rdi,1),%r8
xor    %ebp,%ebp
jmp    1572 <filtre_1+0x472>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
xor    $0x80,%bl
mov    %ebx,%eax
mov    %al,(%r8,%rbp,1)
add    $0x1,%rbp
cmp    %rbp,%rcx
je     15b0 <filtre_1+0x4b0>
movzbl -0x1(%r10,%rbp,1),%eax
movzbl (%r10,%rbp,1),%ebx
add    %eax,%ebx
movzbl -0x2(%r12,%rbp,1),%eax
add    %ebx,%eax
movzbl (%r12,%rbp,1),%ebx
sub    %eax,%ebx
movzbl -0x1(%r14,%rbp,1),%eax
add    %ebx,%eax
movzbl (%r14,%rbp,1),%ebx
add    %eax,%ebx
mov    $0xff,%al
cmp    $0x7f,%ebx
jg     1565 <filtre_1+0x465>
cmp    $0xffffff80,%ebx
jge    1560 <filtre_1+0x460>
xor    %eax,%eax
jmp    1565 <filtre_1+0x465>
nopl   (%rax)
add    %rbp,%rdi
jmp    11c4 <filtre_1+0xc4>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @filtre_1(i8* %0, i32 %1, i32 %2, i8* %3) {
%5 = alloca i8*
%6 = alloca i32
%7 = alloca i32
%8 = alloca i8*
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i8
%14 = alloca i8
%15 = alloca i8
%16 = alloca i8
%17 = alloca i8
%18 = alloca i8
%19 = alloca i8
%20 = alloca i8
%21 = alloca i8
%22 = alloca [9 x i32]
%23 = alloca i32
%24 = alloca i32
store i8* %0, i8** %5
store i32 %1, i32* %6
store i32 %2, i32* %7
store i8* %3, i8** %8
%25 = getelementptr inbounds [9 x i32], [9 x i32]* %22, i64 0, i64 0
store i32 -1, i32* %25
%26 = getelementptr inbounds [9 x i32], [9 x i32]* %22, i64 0, i64 1
store i32 -1, i32* %26
%27 = getelementptr inbounds [9 x i32], [9 x i32]* %22, i64 0, i64 2
store i32 0, i32* %27
%28 = getelementptr inbounds [9 x i32], [9 x i32]* %22, i64 0, i64 3
store i32 -1, i32* %28
%29 = getelementptr inbounds [9 x i32], [9 x i32]* %22, i64 0, i64 4
store i32 0, i32* %29
%30 = getelementptr inbounds [9 x i32], [9 x i32]* %22, i64 0, i64 5
store i32 1, i32* %30
%31 = getelementptr inbounds [9 x i32], [9 x i32]* %22, i64 0, i64 6
store i32 0, i32* %31
%32 = getelementptr inbounds [9 x i32], [9 x i32]* %22, i64 0, i64 7
store i32 1, i32* %32
%33 = getelementptr inbounds [9 x i32], [9 x i32]* %22, i64 0, i64 8
store i32 1, i32* %33
store i32 1, i32* %23
store i32 128, i32* %24
store i32 0, i32* %9
store i32 1, i32* %12
br label %34
34: ; preds = %227, %4
%35 = load i32, i32* %12
%36 = load i32, i32* %7
%37 = sub nsw i32 %36, 1
%38 = icmp slt i32 %35, %37
br i1 %38, label %39, label %230
39: ; preds = %34
store i32 1, i32* %11
br label %40
40: ; preds = %223, %39
%41 = load i32, i32* %11
%42 = load i32, i32* %6
%43 = sub nsw i32 %42, 1
%44 = icmp slt i32 %41, %43
br i1 %44, label %45, label %226
45: ; preds = %40
%46 = load i8*, i8** %5
%47 = load i32, i32* %12
%48 = sub nsw i32 %47, 1
%49 = load i32, i32* %6
%50 = mul nsw i32 %48, %49
%51 = load i32, i32* %11
%52 = add nsw i32 %50, %51
%53 = sub nsw i32 %52, 1
%54 = sext i32 %53 to i64
%55 = getelementptr inbounds i8, i8* %46, i64 %54
%56 = load i8, i8* %55
store i8 %56, i8* %13
%57 = load i8*, i8** %5
%58 = load i32, i32* %12
%59 = sub nsw i32 %58, 1
%60 = load i32, i32* %6
%61 = mul nsw i32 %59, %60
%62 = load i32, i32* %11
%63 = add nsw i32 %61, %62
%64 = sext i32 %63 to i64
%65 = getelementptr inbounds i8, i8* %57, i64 %64
%66 = load i8, i8* %65
store i8 %66, i8* %14
%67 = load i8*, i8** %5
%68 = load i32, i32* %12
%69 = sub nsw i32 %68, 1
%70 = load i32, i32* %6
%71 = mul nsw i32 %69, %70
%72 = load i32, i32* %11
%73 = add nsw i32 %71, %72
%74 = add nsw i32 %73, 1
%75 = sext i32 %74 to i64
%76 = getelementptr inbounds i8, i8* %67, i64 %75
%77 = load i8, i8* %76
store i8 %77, i8* %15
%78 = load i8*, i8** %5
%79 = load i32, i32* %12
%80 = load i32, i32* %6
%81 = mul nsw i32 %79, %80
%82 = load i32, i32* %11
%83 = add nsw i32 %81, %82
%84 = sub nsw i32 %83, 1
%85 = sext i32 %84 to i64
%86 = getelementptr inbounds i8, i8* %78, i64 %85
%87 = load i8, i8* %86
store i8 %87, i8* %16
%88 = load i8*, i8** %5
%89 = load i32, i32* %12
%90 = load i32, i32* %6
%91 = mul nsw i32 %89, %90
%92 = load i32, i32* %11
%93 = add nsw i32 %91, %92
%94 = sext i32 %93 to i64
%95 = getelementptr inbounds i8, i8* %88, i64 %94
%96 = load i8, i8* %95
store i8 %96, i8* %17
%97 = load i8*, i8** %5
%98 = load i32, i32* %12
%99 = load i32, i32* %6
%100 = mul nsw i32 %98, %99
%101 = load i32, i32* %11
%102 = add nsw i32 %100, %101
%103 = add nsw i32 %102, 1
%104 = sext i32 %103 to i64
%105 = getelementptr inbounds i8, i8* %97, i64 %104
%106 = load i8, i8* %105
store i8 %106, i8* %18
%107 = load i8*, i8** %5
%108 = load i32, i32* %12
%109 = add nsw i32 %108, 1
%110 = load i32, i32* %6
%111 = mul nsw i32 %109, %110
%112 = load i32, i32* %11
%113 = add nsw i32 %111, %112
%114 = sub nsw i32 %113, 1
%115 = sext i32 %114 to i64
%116 = getelementptr inbounds i8, i8* %107, i64 %115
%117 = load i8, i8* %116
store i8 %117, i8* %19
%118 = load i8*, i8** %5
%119 = load i32, i32* %12
%120 = add nsw i32 %119, 1
%121 = load i32, i32* %6
%122 = mul nsw i32 %120, %121
%123 = load i32, i32* %11
%124 = add nsw i32 %122, %123
%125 = sext i32 %124 to i64
%126 = getelementptr inbounds i8, i8* %118, i64 %125
%127 = load i8, i8* %126
store i8 %127, i8* %20
%128 = load i8*, i8** %5
%129 = load i32, i32* %12
%130 = add nsw i32 %129, 1
%131 = load i32, i32* %6
%132 = mul nsw i32 %130, %131
%133 = load i32, i32* %11
%134 = add nsw i32 %132, %133
%135 = add nsw i32 %134, 1
%136 = sext i32 %135 to i64
%137 = getelementptr inbounds i8, i8* %128, i64 %136
%138 = load i8, i8* %137
store i8 %138, i8* %21
%139 = getelementptr inbounds [9 x i32], [9 x i32]* %22, i64 0, i64 0
%140 = load i32, i32* %139
%141 = load i8, i8* %13
%142 = zext i8 %141 to i32
%143 = mul nsw i32 %140, %142
%144 = getelementptr inbounds [9 x i32], [9 x i32]* %22, i64 0, i64 1
%145 = load i32, i32* %144
%146 = load i8, i8* %14
%147 = zext i8 %146 to i32
%148 = mul nsw i32 %145, %147
%149 = add nsw i32 %143, %148
%150 = getelementptr inbounds [9 x i32], [9 x i32]* %22, i64 0, i64 2
%151 = load i32, i32* %150
%152 = load i8, i8* %15
%153 = zext i8 %152 to i32
%154 = mul nsw i32 %151, %153
%155 = add nsw i32 %149, %154
%156 = getelementptr inbounds [9 x i32], [9 x i32]* %22, i64 0, i64 3
%157 = load i32, i32* %156
%158 = load i8, i8* %16
%159 = zext i8 %158 to i32
%160 = mul nsw i32 %157, %159
%161 = add nsw i32 %155, %160
%162 = getelementptr inbounds [9 x i32], [9 x i32]* %22, i64 0, i64 4
%163 = load i32, i32* %162
%164 = load i8, i8* %17
%165 = zext i8 %164 to i32
%166 = mul nsw i32 %163, %165
%167 = add nsw i32 %161, %166
%168 = getelementptr inbounds [9 x i32], [9 x i32]* %22, i64 0, i64 5
%169 = load i32, i32* %168
%170 = load i8, i8* %18
%171 = zext i8 %170 to i32
%172 = mul nsw i32 %169, %171
%173 = add nsw i32 %167, %172
%174 = getelementptr inbounds [9 x i32], [9 x i32]* %22, i64 0, i64 6
%175 = load i32, i32* %174
%176 = load i8, i8* %19
%177 = zext i8 %176 to i32
%178 = mul nsw i32 %175, %177
%179 = add nsw i32 %173, %178
%180 = getelementptr inbounds [9 x i32], [9 x i32]* %22, i64 0, i64 7
%181 = load i32, i32* %180
%182 = load i8, i8* %20
%183 = zext i8 %182 to i32
%184 = mul nsw i32 %181, %183
%185 = add nsw i32 %179, %184
%186 = getelementptr inbounds [9 x i32], [9 x i32]* %22, i64 0, i64 8
%187 = load i32, i32* %186
%188 = load i8, i8* %21
%189 = zext i8 %188 to i32
%190 = mul nsw i32 %187, %189
%191 = add nsw i32 %185, %190
store i32 %191, i32* %10
%192 = load i32, i32* %23
%193 = load i32, i32* %10
%194 = load i32, i32* %24
%195 = add nsw i32 %193, %194
%196 = mul nsw i32 %192, %195
store i32 %196, i32* %10
%197 = load i32, i32* %10
%198 = icmp sgt i32 %197, 255
br i1 %198, label %199, label %204
199: ; preds = %45
%200 = load i8*, i8** %8
%201 = load i32, i32* %9
%202 = sext i32 %201 to i64
%203 = getelementptr inbounds i8, i8* %200, i64 %202
store i8 -1, i8* %203
br label %220
204: ; preds = %45
%205 = load i32, i32* %10
%206 = icmp slt i32 %205, 0
br i1 %206, label %207, label %212
207: ; preds = %204
%208 = load i8*, i8** %8
%209 = load i32, i32* %9
%210 = sext i32 %209 to i64
%211 = getelementptr inbounds i8, i8* %208, i64 %210
store i8 0, i8* %211
br label %219
212: ; preds = %204
%213 = load i32, i32* %10
%214 = trunc i32 %213 to i8
%215 = load i8*, i8** %8
%216 = load i32, i32* %9
%217 = sext i32 %216 to i64
%218 = getelementptr inbounds i8, i8* %215, i64 %217
store i8 %214, i8* %218
br label %219
219: ; preds = %212, %207
br label %220
220: ; preds = %219, %199
%221 = load i32, i32* %9
%222 = add nsw i32 %221, 1
store i32 %222, i32* %9
br label %223
223: ; preds = %220
%224 = load i32, i32* %11
%225 = add nsw i32 %224, 1
store i32 %225, i32* %11
br label %40
226: ; preds = %40
br label %227
227: ; preds = %226
%228 = load i32, i32* %12
%229 = add nsw i32 %228, 1
store i32 %229, i32* %12
br label %34
230: ; preds = %34
ret void
}

LLVM IR (-O2):
define void @filtre_1(i8* nocapture %0, i32 %1, i32 %2, i8* nocapture writeonly %3) {
%5 = icmp sgt i32 %2, 2
br i1 %5, label %6, label %165
6: ; preds = %4
%7 = add nsw i32 %2, -1
%8 = add i32 %1, -1
%9 = icmp sgt i32 %1, 2
%10 = sext i32 %1 to i64
%11 = zext i32 %7 to i64
%12 = zext i32 %8 to i64
%13 = add nsw i64 %12, -1
%14 = getelementptr i8, i8* %3, i64 %13
%15 = getelementptr i8, i8* %0, i64 1
%16 = add nuw nsw i64 %12, 1
%17 = getelementptr i8, i8* %0, i64 %16
%18 = getelementptr i8, i8* %0, i64 %16
%19 = getelementptr i8, i8* %0, i64 %12
%20 = add nsw i64 %12, -1
%21 = icmp ult i64 %20, 16
%22 = and i64 %20, -16
%23 = or i64 %22, 1
%24 = icmp eq i64 %20, %22
br label %25
25: ; preds = %6, %161
%26 = phi i64 [ 1, %6 ], [ %162, %161 ]
%27 = phi i32 [ 0, %6 ], [ %163, %161 ]
br i1 %9, label %30, label %28
28: ; preds = %25
%29 = add nuw nsw i64 %26, 1
br label %161
30: ; preds = %25
%31 = add nsw i64 %26, -1
%32 = mul nsw i64 %31, %10
%33 = mul nsw i64 %26, %10
%34 = add nuw nsw i64 %26, 1
%35 = mul nsw i64 %34, %10
%36 = sext i32 %27 to i64
br i1 %21, label %110, label %37
37: ; preds = %30
%38 = getelementptr i8, i8* %3, i64 %36
%39 = getelementptr i8, i8* %14, i64 %36
%40 = getelementptr i8, i8* %15, i64 %35
%41 = getelementptr i8, i8* %17, i64 %35
%42 = getelementptr i8, i8* %0, i64 %33
%43 = getelementptr i8, i8* %18, i64 %33
%44 = getelementptr i8, i8* %0, i64 %32
%45 = getelementptr i8, i8* %19, i64 %32
%46 = icmp ult i8* %38, %41
%47 = icmp ult i8* %40, %39
%48 = and i1 %46, %47
%49 = icmp ult i8* %38, %43
%50 = icmp ult i8* %42, %39
%51 = and i1 %49, %50
%52 = or i1 %48, %51
%53 = icmp ult i8* %38, %45
%54 = icmp ult i8* %44, %39
%55 = and i1 %53, %54
%56 = or i1 %52, %55
br i1 %56, label %110, label %57
57: ; preds = %37
%58 = add nsw i64 %22, %36
br label %59
59: ; preds = %59, %57
%60 = phi i64 [ 0, %57 ], [ %107, %59 ]
%61 = or i64 %60, 1
%62 = add i64 %60, %36
%63 = add nsw i64 %61, %32
%64 = add nsw i64 %63, -1
%65 = getelementptr inbounds i8, i8* %0, i64 %64
%66 = bitcast i8* %65 to <16 x i8>*
%67 = load <16 x i8>, <16 x i8>* %66
%68 = getelementptr inbounds i8, i8* %0, i64 %63
%69 = bitcast i8* %68 to <16 x i8>*
%70 = load <16 x i8>, <16 x i8>* %69
%71 = add nsw i64 %61, %33
%72 = add nsw i64 %71, -1
%73 = getelementptr inbounds i8, i8* %0, i64 %72
%74 = bitcast i8* %73 to <16 x i8>*
%75 = load <16 x i8>, <16 x i8>* %74
%76 = add nsw i64 %71, 1
%77 = getelementptr inbounds i8, i8* %0, i64 %76
%78 = bitcast i8* %77 to <16 x i8>*
%79 = load <16 x i8>, <16 x i8>* %78
%80 = add nsw i64 %61, %35
%81 = getelementptr inbounds i8, i8* %0, i64 %80
%82 = bitcast i8* %81 to <16 x i8>*
%83 = load <16 x i8>, <16 x i8>* %82
%84 = add nsw i64 %80, 1
%85 = getelementptr inbounds i8, i8* %0, i64 %84
%86 = bitcast i8* %85 to <16 x i8>*
%87 = load <16 x i8>, <16 x i8>* %86
%88 = zext <16 x i8> %67 to <16 x i32>
%89 = zext <16 x i8> %70 to <16 x i32>
%90 = zext <16 x i8> %75 to <16 x i32>
%91 = zext <16 x i8> %79 to <16 x i32>
%92 = add nuw nsw <16 x i32> %89, %88
%93 = add nuw nsw <16 x i32> %92, %90
%94 = sub nsw <16 x i32> %91, %93
%95 = zext <16 x i8> %83 to <16 x i32>
%96 = add nsw <16 x i32> %94, %95
%97 = zext <16 x i8> %87 to <16 x i32>
%98 = add nsw <16 x i32> %96, %97
%99 = icmp sgt <16 x i32> %98, <i32 127, i32 127, i32 127, i32 127, i32 127, i32 127, i32 127, i32 127, i32 127, i32 127, i32 127, i32 127, i32 127, i32 127, i32 127, i32 127>
%100 = icmp slt <16 x i32> %98, <i32 -128, i32 -128, i32 -128, i32 -128, i32 -128, i32 -128, i32 -128, i32 -128, i32 -128, i32 -128, i32 -128, i32 -128, i32 -128, i32 -128, i32 -128, i32 -128>
%101 = trunc <16 x i32> %98 to <16 x i8>
%102 = xor <16 x i8> %101, <i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128>
%103 = select <16 x i1> %99, <16 x i8> <i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1>, <16 x i8> %102
%104 = select <16 x i1> %100, <16 x i8> zeroinitializer, <16 x i8> %103
%105 = getelementptr inbounds i8, i8* %3, i64 %62
%106 = bitcast i8* %105 to <16 x i8>*
store <16 x i8> %104, <16 x i8>* %106
%107 = add nuw i64 %60, 16
%108 = icmp eq i64 %107, %22
br i1 %108, label %109, label %59
109: ; preds = %59
br i1 %24, label %158, label %110
110: ; preds = %37, %30, %109
%111 = phi i64 [ 1, %37 ], [ 1, %30 ], [ %23, %109 ]
%112 = phi i64 [ %36, %37 ], [ %36, %30 ], [ %58, %109 ]
br label %113
113: ; preds = %110, %152
%114 = phi i64 [ %156, %152 ], [ %111, %110 ]
%115 = phi i64 [ %155, %152 ], [ %112, %110 ]
%116 = add nsw i64 %114, %32
%117 = add nsw i64 %116, -1
%118 = getelementptr inbounds i8, i8* %0, i64 %117
%119 = load i8, i8* %118
%120 = getelementptr inbounds i8, i8* %0, i64 %116
%121 = load i8, i8* %120
%122 = add nsw i64 %114, %33
%123 = add nsw i64 %122, -1
%124 = getelementptr inbounds i8, i8* %0, i64 %123
%125 = load i8, i8* %124
%126 = add nsw i64 %122, 1
%127 = getelementptr inbounds i8, i8* %0, i64 %126
%128 = load i8, i8* %127
%129 = add nsw i64 %114, %35
%130 = getelementptr inbounds i8, i8* %0, i64 %129
%131 = load i8, i8* %130
%132 = add nsw i64 %129, 1
%133 = getelementptr inbounds i8, i8* %0, i64 %132
%134 = load i8, i8* %133
%135 = zext i8 %119 to i32
%136 = zext i8 %121 to i32
%137 = zext i8 %125 to i32
%138 = zext i8 %128 to i32
%139 = add nuw nsw i32 %136, %135
%140 = add nuw nsw i32 %139, %137
%141 = sub nsw i32 %138, %140
%142 = zext i8 %131 to i32
%143 = add nsw i32 %141, %142
%144 = zext i8 %134 to i32
%145 = add nsw i32 %143, %144
%146 = icmp sgt i32 %145, 127
br i1 %146, label %152, label %147
147: ; preds = %113
%148 = icmp slt i32 %145, -128
br i1 %148, label %152, label %149
149: ; preds = %147
%150 = trunc i32 %145 to i8
%151 = xor i8 %150, -128
br label %152
152: ; preds = %147, %113, %149
%153 = phi i8 [ %151, %149 ], [ -1, %113 ], [ 0, %147 ]
%154 = getelementptr inbounds i8, i8* %3, i64 %115
store i8 %153, i8* %154
%155 = add nsw i64 %115, 1
%156 = add nuw nsw i64 %114, 1
%157 = icmp eq i64 %156, %12
br i1 %157, label %158, label %113
158: ; preds = %152, %109
%159 = phi i64 [ %58, %109 ], [ %155, %152 ]
%160 = trunc i64 %159 to i32
br label %161
161: ; preds = %28, %158
%162 = phi i64 [ %29, %28 ], [ %34, %158 ]
%163 = phi i32 [ %27, %28 ], [ %160, %158 ]
%164 = icmp eq i64 %162, %11
br i1 %164, label %165, label %25
165: ; preds = %161, %4
ret void
}