void invertGrid(short **grid) {
  short i, j;
  for (i = 0; i < (100 - 20 - 1); i++) {
    for (j = 0; j < ((31 + 3) - 3 - 2); j++) {
      grid[i][j] = !grid[i][j];
    }
  }
}


x86 assembly (clang, -O0):
<invertGrid>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
movw   $0x0,-0xa(%rbp)
movswl -0xa(%rbp),%eax
cmp    $0x4f,%eax
jge    118f <invertGrid+0x8f>
movw   $0x0,-0xc(%rbp)
movswl -0xc(%rbp),%eax
cmp    $0x1d,%eax
jge    1179 <invertGrid+0x79>
mov    -0x8(%rbp),%rax
movswq -0xa(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movswq -0xc(%rbp),%rcx
cmpw   $0x0,(%rax,%rcx,2)
setne  %al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%eax
mov    %ax,%dx
mov    -0x8(%rbp),%rax
movswq -0xa(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movswq -0xc(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
mov    -0xc(%rbp),%ax
add    $0x1,%ax
mov    %ax,-0xc(%rbp)
jmp    1121 <invertGrid+0x21>
jmp    117e <invertGrid+0x7e>
mov    -0xa(%rbp),%ax
add    $0x1,%ax
mov    %ax,-0xa(%rbp)
jmp    110e <invertGrid+0xe>
pop    %rbp
ret

x86 assembly (clang, -O2):
<invertGrid>:
xor    %eax,%eax
pxor   %xmm0,%xmm0
cs nopw 0x0(%rax,%rax,1)
mov    (%rdi,%rax,8),%rcx
movdqu (%rcx),%xmm1
movdqu 0x10(%rcx),%xmm2
movdqu 0x20(%rcx),%xmm3
pcmpeqw %xmm0,%xmm1
psrlw  $0xf,%xmm1
movdqu %xmm1,(%rcx)
pcmpeqw %xmm0,%xmm2
psrlw  $0xf,%xmm2
movdqu %xmm2,0x10(%rcx)
pcmpeqw %xmm0,%xmm3
psrlw  $0xf,%xmm3
movdqu %xmm3,0x20(%rcx)
xor    %edx,%edx
cmpw   $0x0,0x30(%rcx)
sete   %dl
mov    %dx,0x30(%rcx)
xor    %edx,%edx
cmpw   $0x0,0x32(%rcx)
sete   %dl
mov    %dx,0x32(%rcx)
xor    %edx,%edx
cmpw   $0x0,0x34(%rcx)
sete   %dl
mov    %dx,0x34(%rcx)
xor    %edx,%edx
cmpw   $0x0,0x36(%rcx)
sete   %dl
mov    %dx,0x36(%rcx)
xor    %edx,%edx
cmpw   $0x0,0x38(%rcx)
sete   %dl
mov    %dx,0x38(%rcx)
add    $0x1,%rax
cmp    $0x4f,%rax
jne    1110 <invertGrid+0x10>
ret

LLVM IR (-O0):
define void @invertGrid(i16** %0) {
%2 = alloca i16**
%3 = alloca i16
%4 = alloca i16
store i16** %0, i16*** %2
store i16 0, i16* %3
br label %5
5: ; preds = %40, %1
%6 = load i16, i16* %3
%7 = sext i16 %6 to i32
%8 = icmp slt i32 %7, 79
br i1 %8, label %9, label %43
9: ; preds = %5
store i16 0, i16* %4
br label %10
10: ; preds = %36, %9
%11 = load i16, i16* %4
%12 = sext i16 %11 to i32
%13 = icmp slt i32 %12, 29
br i1 %13, label %14, label %39
14: ; preds = %10
%15 = load i16**, i16*** %2
%16 = load i16, i16* %3
%17 = sext i16 %16 to i64
%18 = getelementptr inbounds i16*, i16** %15, i64 %17
%19 = load i16*, i16** %18
%20 = load i16, i16* %4
%21 = sext i16 %20 to i64
%22 = getelementptr inbounds i16, i16* %19, i64 %21
%23 = load i16, i16* %22
%24 = icmp ne i16 %23, 0
%25 = xor i1 %24, true
%26 = zext i1 %25 to i32
%27 = trunc i32 %26 to i16
%28 = load i16**, i16*** %2
%29 = load i16, i16* %3
%30 = sext i16 %29 to i64
%31 = getelementptr inbounds i16*, i16** %28, i64 %30
%32 = load i16*, i16** %31
%33 = load i16, i16* %4
%34 = sext i16 %33 to i64
%35 = getelementptr inbounds i16, i16* %32, i64 %34
store i16 %27, i16* %35
br label %36
36: ; preds = %14
%37 = load i16, i16* %4
%38 = add i16 %37, 1
store i16 %38, i16* %4
br label %10
39: ; preds = %10
br label %40
40: ; preds = %39
%41 = load i16, i16* %3
%42 = add i16 %41, 1
store i16 %42, i16* %3
br label %5
43: ; preds = %5
ret void
}

LLVM IR (-O2):
define void @invertGrid(i16** nocapture %0) {
br label %2
2: ; preds = %1, %2
%3 = phi i64 [ 0, %1 ], [ %43, %2 ]
%4 = getelementptr inbounds i16*, i16** %0, i64 %3
%5 = load i16*, i16** %4
%6 = bitcast i16* %5 to <8 x i16>*
%7 = load <8 x i16>, <8 x i16>* %6
%8 = icmp eq <8 x i16> %7, zeroinitializer
%9 = zext <8 x i1> %8 to <8 x i16>
%10 = bitcast i16* %5 to <8 x i16>*
store <8 x i16> %9, <8 x i16>* %10
%11 = getelementptr inbounds i16, i16* %5, i64 8
%12 = bitcast i16* %11 to <8 x i16>*
%13 = load <8 x i16>, <8 x i16>* %12
%14 = icmp eq <8 x i16> %13, zeroinitializer
%15 = zext <8 x i1> %14 to <8 x i16>
%16 = bitcast i16* %11 to <8 x i16>*
store <8 x i16> %15, <8 x i16>* %16
%17 = getelementptr inbounds i16, i16* %5, i64 16
%18 = bitcast i16* %17 to <8 x i16>*
%19 = load <8 x i16>, <8 x i16>* %18
%20 = icmp eq <8 x i16> %19, zeroinitializer
%21 = zext <8 x i1> %20 to <8 x i16>
%22 = bitcast i16* %17 to <8 x i16>*
store <8 x i16> %21, <8 x i16>* %22
%23 = getelementptr inbounds i16, i16* %5, i64 24
%24 = load i16, i16* %23
%25 = icmp eq i16 %24, 0
%26 = zext i1 %25 to i16
store i16 %26, i16* %23
%27 = getelementptr inbounds i16, i16* %5, i64 25
%28 = load i16, i16* %27
%29 = icmp eq i16 %28, 0
%30 = zext i1 %29 to i16
store i16 %30, i16* %27
%31 = getelementptr inbounds i16, i16* %5, i64 26
%32 = load i16, i16* %31
%33 = icmp eq i16 %32, 0
%34 = zext i1 %33 to i16
store i16 %34, i16* %31
%35 = getelementptr inbounds i16, i16* %5, i64 27
%36 = load i16, i16* %35
%37 = icmp eq i16 %36, 0
%38 = zext i1 %37 to i16
store i16 %38, i16* %35
%39 = getelementptr inbounds i16, i16* %5, i64 28
%40 = load i16, i16* %39
%41 = icmp eq i16 %40, 0
%42 = zext i1 %41 to i16
store i16 %42, i16* %39
%43 = add nuw nsw i64 %3, 1
%44 = icmp eq i64 %43, 79
br i1 %44, label %45, label %2
45: ; preds = %2
ret void
}