int check_lines(char board[(30 - 2)][(32 - 2)], int *score, int *lines) {
  char tmp_board[(30 - 2)][(32 - 2)];
  memset(tmp_board, 0, (30 - 2) * (32 - 2));
  char cont = 0;
  char lns = 0;
  int i, j;
  int ti = (30 - 2) - 1;
  for (i = (30 - 2) - 1; i >= 0; i--) {
    for (j = 0; j < (32 - 2); j++) {
      if (board[i][j]) {
        cont++;
      }
    }
    if (cont == (32 - 2)) {
      cont = 0;
      lns++;
    }
    if (cont != 0) {
      memcpy(tmp_board[ti--], board[i], (32 - 2));
      cont = 0;
    }
  }
  if (lns != 0) {
    memcpy(board, tmp_board, (30 - 2) * (32 - 2));
    *lines += lns;
    switch (lns) {
    case 1:
      *score += 10;
      break;
    case 2:
      *score += 10 * 2;
      break;
    case 3:
      *score += 10 * 5;
      break;
    case 4:
      *score += 10 * 8;
      break;
    default:
      *score += 10 * 8;
      break;
    }
  }
  return lns;
}


x86 assembly (clang, -O0):
<check_lines>:
push   %rbp
mov    %rsp,%rbp
sub    $0x380,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
lea    -0x360(%rbp),%rdi
xor    %esi,%esi
mov    $0x348,%edx
call   1030 <memset@plt>
movb   $0x0,-0x361(%rbp)
movb   $0x0,-0x362(%rbp)
movl   $0x1b,-0x370(%rbp)
movl   $0x1b,-0x368(%rbp)
cmpl   $0x0,-0x368(%rbp)
jl     1287 <check_lines+0x167>
movl   $0x0,-0x36c(%rbp)
cmpl   $0x1e,-0x36c(%rbp)
jge    11da <check_lines+0xba>
mov    -0x8(%rbp),%rax
movslq -0x368(%rbp),%rcx
imul   $0x1e,%rcx,%rcx
add    %rcx,%rax
movslq -0x36c(%rbp),%rcx
cmpb   $0x0,(%rax,%rcx,1)
je     11c1 <check_lines+0xa1>
mov    -0x361(%rbp),%al
add    $0x1,%al
mov    %al,-0x361(%rbp)
jmp    11c6 <check_lines+0xa6>
mov    -0x36c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x36c(%rbp)
jmp    1183 <check_lines+0x63>
movsbl -0x361(%rbp),%eax
cmp    $0x1e,%eax
jne    11ff <check_lines+0xdf>
movb   $0x0,-0x361(%rbp)
mov    -0x362(%rbp),%al
add    $0x1,%al
mov    %al,-0x362(%rbp)
movsbl -0x361(%rbp),%eax
cmp    $0x0,%eax
je     126e <check_lines+0x14e>
mov    -0x370(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x370(%rbp)
movslq %eax,%rcx
lea    -0x360(%rbp),%rax
imul   $0x1e,%rcx,%rcx
add    %rcx,%rax
mov    -0x8(%rbp),%rcx
movslq -0x368(%rbp),%rdx
imul   $0x1e,%rdx,%rdx
add    %rdx,%rcx
mov    (%rcx),%rdx
mov    %rdx,(%rax)
mov    0x8(%rcx),%rdx
mov    %rdx,0x8(%rax)
mov    0x10(%rcx),%rdx
mov    %rdx,0x10(%rax)
mov    0x18(%rcx),%edx
mov    %edx,0x18(%rax)
mov    0x1c(%rcx),%cx
mov    %cx,0x1c(%rax)
movb   $0x0,-0x361(%rbp)
jmp    1273 <check_lines+0x153>
mov    -0x368(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x368(%rbp)
jmp    116c <check_lines+0x4c>
movsbl -0x362(%rbp),%eax
cmp    $0x0,%eax
je     1340 <check_lines+0x220>
mov    -0x8(%rbp),%rdi
lea    -0x360(%rbp),%rsi
mov    $0x348,%edx
call   1040 <memcpy@plt>
movsbl -0x362(%rbp),%edx
mov    -0x18(%rbp),%rax
mov    (%rax),%ecx
add    %edx,%ecx
mov    %ecx,(%rax)
movsbl -0x362(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,%ecx
mov    %rcx,-0x378(%rbp)
sub    $0x3,%eax
ja     1330 <check_lines+0x210>
mov    -0x378(%rbp),%rax
lea    0xd19(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x10(%rbp),%rax
mov    (%rax),%ecx
add    $0xa,%ecx
mov    %ecx,(%rax)
jmp    133b <check_lines+0x21b>
mov    -0x10(%rbp),%rax
mov    (%rax),%ecx
add    $0x14,%ecx
mov    %ecx,(%rax)
jmp    133b <check_lines+0x21b>
mov    -0x10(%rbp),%rax
mov    (%rax),%ecx
add    $0x32,%ecx
mov    %ecx,(%rax)
jmp    133b <check_lines+0x21b>
mov    -0x10(%rbp),%rax
mov    (%rax),%ecx
add    $0x50,%ecx
mov    %ecx,(%rax)
jmp    133b <check_lines+0x21b>
mov    -0x10(%rbp),%rax
mov    (%rax),%ecx
add    $0x50,%ecx
mov    %ecx,(%rax)
jmp    1340 <check_lines+0x220>
movsbl -0x362(%rbp),%eax
add    $0x380,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<check_lines>:
push   %rbp
push   %r15
push   %r14
push   %r12
push   %rbx
sub    $0x350,%rsp
mov    %rdx,%r15
mov    %rsi,%r14
mov    %rdi,%rbx
mov    %rsp,%rdi
xor    %r12d,%r12d
mov    $0x348,%ebp
mov    $0x348,%edx
xor    %esi,%esi
call   1030 <memset@plt>
mov    $0x1b,%eax
pxor   %xmm0,%xmm0
pcmpeqd %xmm1,%xmm1
jmp    116d <check_lines+0x4d>
xchg   %ax,%ax
add    %cl,%r12b
add    $0xffffffffffffffe2,%rbp
je     124c <check_lines+0x12c>
movdqu -0x1e(%rbx,%rbp,1),%xmm2
pcmpeqb %xmm0,%xmm2
pmovmskb %xmm2,%ecx
not    %ecx
mov    %ecx,%edx
shr    %edx
and    $0x5555,%edx
sub    %edx,%ecx
mov    %ecx,%edx
and    $0x3333,%edx
shr    $0x2,%ecx
and    $0x3333,%ecx
add    %edx,%ecx
mov    %ecx,%edx
shr    $0x4,%edx
add    %ecx,%edx
and    $0xf0f,%edx
mov    %edx,%ecx
shl    $0x8,%ecx
add    %edx,%ecx
movzbl %ch,%ecx
movd   %ecx,%xmm2
movq   -0xe(%rbx,%rbp,1),%xmm3
pcmpeqb %xmm0,%xmm3
paddb  %xmm2,%xmm3
psubb  %xmm1,%xmm3
psadbw %xmm0,%xmm3
movd   %xmm3,%edx
cmpb   $0x1,-0x6(%rbx,%rbp,1)
sbb    $0xff,%dl
cmpb   $0x1,-0x5(%rbx,%rbp,1)
sbb    $0xff,%dl
cmpb   $0x1,-0x4(%rbx,%rbp,1)
sbb    $0xff,%dl
cmpb   $0x1,-0x3(%rbx,%rbp,1)
sbb    $0xff,%dl
cmpb   $0x1,-0x2(%rbx,%rbp,1)
sbb    $0xff,%dl
cmpb   $0x0,-0x1(%rbx,%rbp,1)
setne  %sil
lea    (%rdx,%rsi,1),%ecx
cmp    $0x1e,%cl
sete   %cl
add    %sil,%dl
je     1160 <check_lines+0x40>
cmp    $0x1e,%dl
je     1160 <check_lines+0x40>
movslq %eax,%rdx
add    $0xffffffff,%eax
mov    %rdx,%rsi
shl    $0x5,%rsi
sub    %rdx,%rsi
sub    %rdx,%rsi
movdqu -0x1e(%rbx,%rbp,1),%xmm2
movdqu -0x10(%rbx,%rbp,1),%xmm3
movdqu %xmm3,0xe(%rsp,%rsi,1)
movdqu %xmm2,(%rsp,%rsi,1)
jmp    1160 <check_lines+0x40>
movsbl %r12b,%r12d
test   %r12b,%r12b
je     1287 <check_lines+0x167>
mov    %rsp,%rsi
mov    $0x348,%edx
mov    %rbx,%rdi
call   1040 <memcpy@plt>
add    %r12d,(%r15)
lea    -0x1(%r12),%ecx
mov    $0x50,%eax
cmp    $0x3,%ecx
ja     1284 <check_lines+0x164>
movslq %ecx,%rax
lea    0xd7f(%rip),%rcx
mov    (%rcx,%rax,4),%eax
add    %eax,(%r14)
mov    %r12d,%eax
add    $0x350,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define i32 @check_lines([30 x i8]* %0, i32* %1, i32* %2) {
%4 = alloca [30 x i8]*
%5 = alloca i32*
%6 = alloca i32*
%7 = alloca [28 x [30 x i8]]
%8 = alloca i8
%9 = alloca i8
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
store [30 x i8]* %0, [30 x i8]** %4
store i32* %1, i32** %5
store i32* %2, i32** %6
%13 = getelementptr inbounds [28 x [30 x i8]], [28 x [30 x i8]]* %7, i64 0, i64 0
%14 = bitcast [30 x i8]* %13 to i8*
store i8 0, i8* %8
store i8 0, i8* %9
store i32 27, i32* %12
store i32 27, i32* %10
br label %15
15: ; preds = %62, %3
%16 = load i32, i32* %10
%17 = icmp sge i32 %16, 0
br i1 %17, label %18, label %65
18: ; preds = %15
store i32 0, i32* %11
br label %19
19: ; preds = %36, %18
%20 = load i32, i32* %11
%21 = icmp slt i32 %20, 30
br i1 %21, label %22, label %39
22: ; preds = %19
%23 = load [30 x i8]*, [30 x i8]** %4
%24 = load i32, i32* %10
%25 = sext i32 %24 to i64
%26 = getelementptr inbounds [30 x i8], [30 x i8]* %23, i64 %25
%27 = load i32, i32* %11
%28 = sext i32 %27 to i64
%29 = getelementptr inbounds [30 x i8], [30 x i8]* %26, i64 0, i64 %28
%30 = load i8, i8* %29
%31 = icmp ne i8 %30, 0
br i1 %31, label %32, label %35
32: ; preds = %22
%33 = load i8, i8* %8
%34 = add i8 %33, 1
store i8 %34, i8* %8
br label %35
35: ; preds = %32, %22
br label %36
36: ; preds = %35
%37 = load i32, i32* %11
%38 = add nsw i32 %37, 1
store i32 %38, i32* %11
br label %19
39: ; preds = %19
%40 = load i8, i8* %8
%41 = sext i8 %40 to i32
%42 = icmp eq i32 %41, 30
br i1 %42, label %43, label %46
43: ; preds = %39
store i8 0, i8* %8
%44 = load i8, i8* %9
%45 = add i8 %44, 1
store i8 %45, i8* %9
br label %46
46: ; preds = %43, %39
%47 = load i8, i8* %8
%48 = sext i8 %47 to i32
%49 = icmp ne i32 %48, 0
br i1 %49, label %50, label %61
50: ; preds = %46
%51 = load i32, i32* %12
%52 = add nsw i32 %51, -1
store i32 %52, i32* %12
%53 = sext i32 %51 to i64
%54 = getelementptr inbounds [28 x [30 x i8]], [28 x [30 x i8]]* %7, i64 0, i64 %53
%55 = getelementptr inbounds [30 x i8], [30 x i8]* %54, i64 0, i64 0
%56 = load [30 x i8]*, [30 x i8]** %4
%57 = load i32, i32* %10
%58 = sext i32 %57 to i64
%59 = getelementptr inbounds [30 x i8], [30 x i8]* %56, i64 %58
%60 = getelementptr inbounds [30 x i8], [30 x i8]* %59, i64 0, i64 0
store i8 0, i8* %8
br label %61
61: ; preds = %50, %46
br label %62
62: ; preds = %61
%63 = load i32, i32* %10
%64 = add nsw i32 %63, -1
store i32 %64, i32* %10
br label %15
65: ; preds = %15
%66 = load i8, i8* %9
%67 = sext i8 %66 to i32
%68 = icmp ne i32 %67, 0
br i1 %68, label %69, label %102
69: ; preds = %65
%70 = load [30 x i8]*, [30 x i8]** %4
%71 = bitcast [30 x i8]* %70 to i8*
%72 = getelementptr inbounds [28 x [30 x i8]], [28 x [30 x i8]]* %7, i64 0, i64 0
%73 = bitcast [30 x i8]* %72 to i8*
%74 = load i8, i8* %9
%75 = sext i8 %74 to i32
%76 = load i32*, i32** %6
%77 = load i32, i32* %76
%78 = add nsw i32 %77, %75
store i32 %78, i32* %76
%79 = load i8, i8* %9
%80 = sext i8 %79 to i32
switch i32 %80, label %97 [
i32 1, label %81
i32 2, label %85
i32 3, label %89
i32 4, label %93
]
81: ; preds = %69
%82 = load i32*, i32** %5
%83 = load i32, i32* %82
%84 = add nsw i32 %83, 10
store i32 %84, i32* %82
br label %101
85: ; preds = %69
%86 = load i32*, i32** %5
%87 = load i32, i32* %86
%88 = add nsw i32 %87, 20
store i32 %88, i32* %86
br label %101
89: ; preds = %69
%90 = load i32*, i32** %5
%91 = load i32, i32* %90
%92 = add nsw i32 %91, 50
store i32 %92, i32* %90
br label %101
93: ; preds = %69
%94 = load i32*, i32** %5
%95 = load i32, i32* %94
%96 = add nsw i32 %95, 80
store i32 %96, i32* %94
br label %101
97: ; preds = %69
%98 = load i32*, i32** %5
%99 = load i32, i32* %98
%100 = add nsw i32 %99, 80
store i32 %100, i32* %98
br label %101
101: ; preds = %97, %93, %89, %85, %81
br label %102
102: ; preds = %101, %65
%103 = load i8, i8* %9
%104 = sext i8 %103 to i32
ret i32 %104
}

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