void PlaceModule(unsigned char *modules, int mappingRows, int mappingCols,
                 int row, int col, unsigned char *codeword, int mask,
                 int moduleOnColor) {
  if (row < 0) {
    row += mappingRows;
    col += 4 - ((mappingRows + 4) % 8);
  }
  if (col < 0) {
    col += mappingCols;
    row += 4 - ((mappingCols + 4) % 8);
  }
  if ((modules[row * mappingCols + col] & 0x10) != 0) {
    if ((modules[row * mappingCols + col] & moduleOnColor) != 0)
      *codeword |= mask;
    else
      *codeword &= (0xff ^ mask);
  } else {
    if ((*codeword & mask) != 0x00)
      modules[row * mappingCols + col] |= moduleOnColor;
    modules[row * mappingCols + col] |= 0x10;
  }
  modules[row * mappingCols + col] |= 0x20;
}


x86 assembly (clang, -O0):
<PlaceModule>:
push   %rbp
mov    %rsp,%rbp
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%eax
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %ecx,-0x14(%rbp)
mov    %r8d,-0x18(%rbp)
mov    %r9,-0x20(%rbp)
cmpl   $0x0,-0x14(%rbp)
jge    114d <PlaceModule+0x4d>
mov    -0xc(%rbp),%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0xc(%rbp),%eax
add    $0x4,%eax
mov    $0x8,%ecx
cltd
idiv   %ecx
mov    $0x4,%eax
sub    %edx,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
cmpl   $0x0,-0x18(%rbp)
jge    117b <PlaceModule+0x7b>
mov    -0x10(%rbp),%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x10(%rbp),%eax
add    $0x4,%eax
mov    $0x8,%ecx
cltd
idiv   %ecx
mov    $0x4,%eax
sub    %edx,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
and    $0x10,%eax
cmp    $0x0,%eax
je     11e9 <PlaceModule+0xe9>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
and    0x18(%rbp),%eax
cmp    $0x0,%eax
je     11d0 <PlaceModule+0xd0>
mov    0x10(%rbp),%edx
mov    -0x20(%rbp),%rax
movzbl (%rax),%ecx
or     %edx,%ecx
mov    %cl,(%rax)
jmp    11e4 <PlaceModule+0xe4>
mov    0x10(%rbp),%edx
xor    $0xff,%edx
mov    -0x20(%rbp),%rax
movzbl (%rax),%ecx
and    %edx,%ecx
mov    %cl,(%rax)
jmp    1234 <PlaceModule+0x134>
mov    -0x20(%rbp),%rax
movzbl (%rax),%eax
and    0x10(%rbp),%eax
cmp    $0x0,%eax
je     1219 <PlaceModule+0x119>
mov    0x18(%rbp),%esi
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edx
or     %esi,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edx
or     $0x10,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edx
or     $0x20,%edx
mov    %dl,(%rax,%rcx,1)
pop    %rbp
ret

x86 assembly (clang, -O2):
<PlaceModule>:
test   %ecx,%ecx
js     114c <PlaceModule+0x4c>
test   %r8d,%r8d
js     116a <PlaceModule+0x6a>
mov    0x10(%rsp),%r10d
mov    0x8(%rsp),%esi
imul   %edx,%ecx
add    %r8d,%ecx
movslq %ecx,%rax
mov    (%rdi,%rax,1),%cl
test   $0x10,%cl
jne    113c <PlaceModule+0x3c>
movzbl (%r9),%edx
test   %esi,%edx
je     1131 <PlaceModule+0x31>
or     %r10b,%cl
mov    %cl,(%rdi,%rax,1)
or     $0x10,%cl
mov    %cl,(%rdi,%rax,1)
orb    $0x20,(%rdi,%rax,1)
ret
movzbl %cl,%edx
mov    (%r9),%cl
test   %r10d,%edx
je     1184 <PlaceModule+0x84>
or     %sil,%cl
jmp    118a <PlaceModule+0x8a>
add    %esi,%ecx
lea    0x4(%rsi),%eax
add    $0xb,%esi
test   %eax,%eax
cmovns %eax,%esi
and    $0xfffffff8,%esi
sub    %eax,%esi
add    %esi,%r8d
add    $0x4,%r8d
test   %r8d,%r8d
jns    1109 <PlaceModule+0x9>
add    %edx,%r8d
lea    0x4(%rdx),%eax
lea    0xb(%rdx),%esi
test   %eax,%eax
cmovns %eax,%esi
and    $0xfffffff8,%esi
sub    %eax,%esi
add    %esi,%ecx
add    $0x4,%ecx
jmp    1109 <PlaceModule+0x9>
not    %sil
and    %sil,%cl
mov    %cl,(%r9)
orb    $0x20,(%rdi,%rax,1)
ret

LLVM IR (-O0):
define void @PlaceModule(i8* %0, i32 %1, i32 %2, i32 %3, i32 %4, i8* %5, i32 %6, i32 %7) {
%9 = alloca i8*
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca i8*
%15 = alloca i32
%16 = alloca i32
store i8* %0, i8** %9
store i32 %1, i32* %10
store i32 %2, i32* %11
store i32 %3, i32* %12
store i32 %4, i32* %13
store i8* %5, i8** %14
store i32 %6, i32* %15
store i32 %7, i32* %16
%17 = load i32, i32* %12
%18 = icmp slt i32 %17, 0
br i1 %18, label %19, label %29
19: ; preds = %8
%20 = load i32, i32* %10
%21 = load i32, i32* %12
%22 = add nsw i32 %21, %20
store i32 %22, i32* %12
%23 = load i32, i32* %10
%24 = add nsw i32 %23, 4
%25 = srem i32 %24, 8
%26 = sub nsw i32 4, %25
%27 = load i32, i32* %13
%28 = add nsw i32 %27, %26
store i32 %28, i32* %13
br label %29
29: ; preds = %19, %8
%30 = load i32, i32* %13
%31 = icmp slt i32 %30, 0
br i1 %31, label %32, label %42
32: ; preds = %29
%33 = load i32, i32* %11
%34 = load i32, i32* %13
%35 = add nsw i32 %34, %33
store i32 %35, i32* %13
%36 = load i32, i32* %11
%37 = add nsw i32 %36, 4
%38 = srem i32 %37, 8
%39 = sub nsw i32 4, %38
%40 = load i32, i32* %12
%41 = add nsw i32 %40, %39
store i32 %41, i32* %12
br label %42
42: ; preds = %32, %29
%43 = load i8*, i8** %9
%44 = load i32, i32* %12
%45 = load i32, i32* %11
%46 = mul nsw i32 %44, %45
%47 = load i32, i32* %13
%48 = add nsw i32 %46, %47
%49 = sext i32 %48 to i64
%50 = getelementptr inbounds i8, i8* %43, i64 %49
%51 = load i8, i8* %50
%52 = zext i8 %51 to i32
%53 = and i32 %52, 16
%54 = icmp ne i32 %53, 0
br i1 %54, label %55, label %85
55: ; preds = %42
%56 = load i8*, i8** %9
%57 = load i32, i32* %12
%58 = load i32, i32* %11
%59 = mul nsw i32 %57, %58
%60 = load i32, i32* %13
%61 = add nsw i32 %59, %60
%62 = sext i32 %61 to i64
%63 = getelementptr inbounds i8, i8* %56, i64 %62
%64 = load i8, i8* %63
%65 = zext i8 %64 to i32
%66 = load i32, i32* %16
%67 = and i32 %65, %66
%68 = icmp ne i32 %67, 0
br i1 %68, label %69, label %76
69: ; preds = %55
%70 = load i32, i32* %15
%71 = load i8*, i8** %14
%72 = load i8, i8* %71
%73 = zext i8 %72 to i32
%74 = or i32 %73, %70
%75 = trunc i32 %74 to i8
store i8 %75, i8* %71
br label %84
76: ; preds = %55
%77 = load i32, i32* %15
%78 = xor i32 255, %77
%79 = load i8*, i8** %14
%80 = load i8, i8* %79
%81 = zext i8 %80 to i32
%82 = and i32 %81, %78
%83 = trunc i32 %82 to i8
store i8 %83, i8* %79
br label %84
84: ; preds = %76, %69
br label %119
85: ; preds = %42
%86 = load i8*, i8** %14
%87 = load i8, i8* %86
%88 = zext i8 %87 to i32
%89 = load i32, i32* %15
%90 = and i32 %88, %89
%91 = icmp ne i32 %90, 0
br i1 %91, label %92, label %106
92: ; preds = %85
%93 = load i32, i32* %16
%94 = load i8*, i8** %9
%95 = load i32, i32* %12
%96 = load i32, i32* %11
%97 = mul nsw i32 %95, %96
%98 = load i32, i32* %13
%99 = add nsw i32 %97, %98
%100 = sext i32 %99 to i64
%101 = getelementptr inbounds i8, i8* %94, i64 %100
%102 = load i8, i8* %101
%103 = zext i8 %102 to i32
%104 = or i32 %103, %93
%105 = trunc i32 %104 to i8
store i8 %105, i8* %101
br label %106
106: ; preds = %92, %85
%107 = load i8*, i8** %9
%108 = load i32, i32* %12
%109 = load i32, i32* %11
%110 = mul nsw i32 %108, %109
%111 = load i32, i32* %13
%112 = add nsw i32 %110, %111
%113 = sext i32 %112 to i64
%114 = getelementptr inbounds i8, i8* %107, i64 %113
%115 = load i8, i8* %114
%116 = zext i8 %115 to i32
%117 = or i32 %116, 16
%118 = trunc i32 %117 to i8
store i8 %118, i8* %114
br label %119
119: ; preds = %106, %84
%120 = load i8*, i8** %9
%121 = load i32, i32* %12
%122 = load i32, i32* %11
%123 = mul nsw i32 %121, %122
%124 = load i32, i32* %13
%125 = add nsw i32 %123, %124
%126 = sext i32 %125 to i64
%127 = getelementptr inbounds i8, i8* %120, i64 %126
%128 = load i8, i8* %127
%129 = zext i8 %128 to i32
%130 = or i32 %129, 32
%131 = trunc i32 %130 to i8
store i8 %131, i8* %127
ret void
}

LLVM IR (-O2):
define void @PlaceModule(i8* nocapture %0, i32 %1, i32 %2, i32 %3, i32 %4, i8* nocapture %5, i32 %6, i32 %7) {
%9 = icmp slt i32 %3, 0
br i1 %9, label %10, label %16
10: ; preds = %8
%11 = add nsw i32 %3, %1
%12 = add nsw i32 %1, 4
%13 = srem i32 %12, 8
%14 = sub nsw i32 4, %13
%15 = add nsw i32 %14, %4
br label %16
16: ; preds = %10, %8
%17 = phi i32 [ %15, %10 ], [ %4, %8 ]
%18 = phi i32 [ %11, %10 ], [ %3, %8 ]
%19 = icmp slt i32 %17, 0
br i1 %19, label %20, label %26
20: ; preds = %16
%21 = add nsw i32 %17, %2
%22 = add nsw i32 %2, 4
%23 = srem i32 %22, 8
%24 = sub nsw i32 4, %23
%25 = add nsw i32 %24, %18
br label %26
26: ; preds = %20, %16
%27 = phi i32 [ %21, %20 ], [ %17, %16 ]
%28 = phi i32 [ %25, %20 ], [ %18, %16 ]
%29 = mul nsw i32 %28, %2
%30 = add nsw i32 %29, %27
%31 = sext i32 %30 to i64
%32 = getelementptr inbounds i8, i8* %0, i64 %31
%33 = load i8, i8* %32
%34 = zext i8 %33 to i32
%35 = and i32 %34, 16
%36 = icmp eq i32 %35, 0
br i1 %36, label %47, label %37
37: ; preds = %26
%38 = and i32 %34, %7
%39 = icmp eq i32 %38, 0
%40 = load i8, i8* %5
%41 = trunc i32 %6 to i8
br i1 %39, label %44, label %42
42: ; preds = %37
%43 = or i8 %40, %41
store i8 %43, i8* %5
br label %58
44: ; preds = %37
%45 = xor i8 %41, -1
%46 = and i8 %40, %45
store i8 %46, i8* %5
br label %58
47: ; preds = %26
%48 = load i8, i8* %5
%49 = zext i8 %48 to i32
%50 = and i32 %49, %6
%51 = icmp eq i32 %50, 0
br i1 %51, label %55, label %52
52: ; preds = %47
%53 = trunc i32 %7 to i8
%54 = or i8 %33, %53
store i8 %54, i8* %32
br label %55
55: ; preds = %52, %47
%56 = phi i8 [ %54, %52 ], [ %33, %47 ]
%57 = or i8 %56, 16
store i8 %57, i8* %32
br label %58
58: ; preds = %42, %44, %55
%59 = load i8, i8* %32
%60 = or i8 %59, 32
store i8 %60, i8* %32
ret void
}