int FS460_decode_bitmap_from_alpha_masks(
    unsigned char *p_alpha_values, long *p_alpha_value_size,
    const unsigned short *p_alpha_mask_odd, int mask_size_odd,
    const unsigned short *p_alpha_mask_even, int mask_size_even) {
  long alpha_value_size;
  unsigned char *p_a;
  const unsigned short *p_mo, *p_me;
  unsigned char alpha;
  int count, remainder, i;
  int is_odd;
  if ((mask_size_odd > 0x10000) || (mask_size_odd < 2) ||
      (mask_size_even > 0x10000) || (mask_size_even < 2) || !p_alpha_mask_odd ||
      !p_alpha_mask_even || !p_alpha_values || !p_alpha_value_size) {
    return 0x1000;
  }
  alpha_value_size = *p_alpha_value_size;
  p_a = p_alpha_values;
  p_mo = p_alpha_mask_odd;
  p_me = p_alpha_mask_even;
  is_odd = 1;
  remainder = 720;
  while ((mask_size_odd > 0) && (mask_size_even > 0) && alpha_value_size) {
    if (is_odd) {
      count = (*p_mo) >> 8;
      alpha = (unsigned char)(0xFF & *p_mo);
      p_mo++;
      mask_size_odd -= 2;
    } else {
      count = (*p_me) >> 8;
      alpha = (unsigned char)(0xFF & *p_me);
      p_me++;
      mask_size_even -= 2;
    }
    if (!count)
      count = remainder;
    if (count > alpha_value_size)
      count = alpha_value_size;
    if (count > remainder)
      count = remainder;
    for (i = count; i > 0; i--)
      *(p_a++) = alpha;
    alpha_value_size -= count;
    remainder -= count;
    if (!remainder) {
      remainder = 720;
      is_odd = !is_odd;
    }
  }
  *p_alpha_value_size -= alpha_value_size;
  return 0;
}


x86 assembly (clang, -O0):
<FS460_decode_bitmap_from_alpha_masks>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %ecx,-0x24(%rbp)
mov    %r8,-0x30(%rbp)
mov    %r9d,-0x34(%rbp)
cmpl   $0x10000,-0x24(%rbp)
jg     1175 <FS460_decode_bitmap_from_alpha_masks+0x75>
cmpl   $0x2,-0x24(%rbp)
jl     1175 <FS460_decode_bitmap_from_alpha_masks+0x75>
cmpl   $0x10000,-0x34(%rbp)
jg     1175 <FS460_decode_bitmap_from_alpha_masks+0x75>
cmpl   $0x2,-0x34(%rbp)
jl     1175 <FS460_decode_bitmap_from_alpha_masks+0x75>
cmpq   $0x0,-0x20(%rbp)
je     1175 <FS460_decode_bitmap_from_alpha_masks+0x75>
cmpq   $0x0,-0x30(%rbp)
je     1175 <FS460_decode_bitmap_from_alpha_masks+0x75>
cmpq   $0x0,-0x10(%rbp)
je     1175 <FS460_decode_bitmap_from_alpha_masks+0x75>
cmpq   $0x0,-0x18(%rbp)
jne    1181 <FS460_decode_bitmap_from_alpha_masks+0x81>
movl   $0x1000,-0x4(%rbp)
jmp    131e <FS460_decode_bitmap_from_alpha_masks+0x21e>
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x40(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,-0x58(%rbp)
movl   $0x1,-0x6c(%rbp)
movl   $0x2d0,-0x64(%rbp)
xor    %eax,%eax
cmpl   $0x0,-0x24(%rbp)
mov    %al,-0x6d(%rbp)
jle    11db <FS460_decode_bitmap_from_alpha_masks+0xdb>
xor    %eax,%eax
cmpl   $0x0,-0x34(%rbp)
mov    %al,-0x6d(%rbp)
jle    11db <FS460_decode_bitmap_from_alpha_masks+0xdb>
cmpq   $0x0,-0x40(%rbp)
setne  %al
mov    %al,-0x6d(%rbp)
mov    -0x6d(%rbp),%al
test   $0x1,%al
jne    11eb <FS460_decode_bitmap_from_alpha_masks+0xeb>
jmp    1306 <FS460_decode_bitmap_from_alpha_masks+0x206>
cmpl   $0x0,-0x6c(%rbp)
je     122b <FS460_decode_bitmap_from_alpha_masks+0x12b>
mov    -0x50(%rbp),%rax
movzwl (%rax),%eax
sar    $0x8,%eax
mov    %eax,-0x60(%rbp)
mov    -0x50(%rbp),%rax
movzwl (%rax),%eax
and    $0xff,%eax
mov    %al,-0x59(%rbp)
mov    -0x50(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x50(%rbp)
mov    -0x24(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x24(%rbp)
jmp    125c <FS460_decode_bitmap_from_alpha_masks+0x15c>
mov    -0x58(%rbp),%rax
movzwl (%rax),%eax
sar    $0x8,%eax
mov    %eax,-0x60(%rbp)
mov    -0x58(%rbp),%rax
movzwl (%rax),%eax
and    $0xff,%eax
mov    %al,-0x59(%rbp)
mov    -0x58(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x58(%rbp)
mov    -0x34(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x34(%rbp)
cmpl   $0x0,-0x60(%rbp)
jne    126c <FS460_decode_bitmap_from_alpha_masks+0x16c>
mov    -0x64(%rbp),%eax
mov    %eax,-0x60(%rbp)
movslq -0x60(%rbp),%rax
cmp    -0x40(%rbp),%rax
jle    1281 <FS460_decode_bitmap_from_alpha_masks+0x181>
mov    -0x40(%rbp),%rax
mov    %eax,-0x60(%rbp)
mov    -0x60(%rbp),%eax
cmp    -0x64(%rbp),%eax
jle    1293 <FS460_decode_bitmap_from_alpha_masks+0x193>
mov    -0x64(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x60(%rbp),%eax
mov    %eax,-0x68(%rbp)
cmpl   $0x0,-0x68(%rbp)
jle    12c5 <FS460_decode_bitmap_from_alpha_masks+0x1c5>
mov    -0x59(%rbp),%cl
mov    -0x48(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x48(%rbp)
mov    %cl,(%rax)
mov    -0x68(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x68(%rbp)
jmp    1299 <FS460_decode_bitmap_from_alpha_masks+0x199>
movslq -0x60(%rbp),%rcx
mov    -0x40(%rbp),%rax
sub    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    -0x60(%rbp),%ecx
mov    -0x64(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x64(%rbp)
cmpl   $0x0,-0x64(%rbp)
jne    1301 <FS460_decode_bitmap_from_alpha_masks+0x201>
movl   $0x2d0,-0x64(%rbp)
cmpl   $0x0,-0x6c(%rbp)
setne  %al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x6c(%rbp)
jmp    11b2 <FS460_decode_bitmap_from_alpha_masks+0xb2>
mov    -0x40(%rbp),%rdx
mov    -0x18(%rbp),%rax
mov    (%rax),%rcx
sub    %rdx,%rcx
mov    %rcx,(%rax)
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<FS460_decode_bitmap_from_alpha_masks>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
mov    %r9,0x8(%rsp)
mov    $0x1000,%eax
test   %rsi,%rsi
je     126c <FS460_decode_bitmap_from_alpha_masks+0x15c>
mov    %rdi,%r14
test   %rdi,%rdi
je     126c <FS460_decode_bitmap_from_alpha_masks+0x15c>
test   %r8,%r8
je     126c <FS460_decode_bitmap_from_alpha_masks+0x15c>
test   %rdx,%rdx
je     126c <FS460_decode_bitmap_from_alpha_masks+0x15c>
mov    %ecx,%r15d
lea    -0x2(%r15),%ecx
cmp    $0xfffe,%ecx
ja     126c <FS460_decode_bitmap_from_alpha_masks+0x15c>
mov    0x8(%rsp),%rcx
add    $0xfffffffe,%ecx
cmp    $0xfffe,%ecx
ja     126c <FS460_decode_bitmap_from_alpha_masks+0x15c>
mov    (%rsi),%rbx
test   %rbx,%rbx
je     1261 <FS460_decode_bitmap_from_alpha_masks+0x151>
mov    %rsi,0x20(%rsp)
mov    $0x2d0,%ebp
mov    $0x1,%r12d
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
test   %r12d,%r12d
je     11c0 <FS460_decode_bitmap_from_alpha_masks+0xb0>
lea    0x2(%rdx),%rax
mov    %rax,0x18(%rsp)
add    $0xfffffffe,%r15d
mov    %r8,0x10(%rsp)
jmp    11de <FS460_decode_bitmap_from_alpha_masks+0xce>
nopl   0x0(%rax)
lea    0x2(%r8),%rax
mov    %rax,0x10(%rsp)
mov    0x8(%rsp),%rax
add    $0xfffffffe,%eax
mov    %rax,0x8(%rsp)
mov    %rdx,0x18(%rsp)
mov    %r8,%rdx
movzwl (%rdx),%esi
mov    %esi,%eax
shr    $0x8,%eax
cmp    $0x100,%esi
cmovb  %ebp,%eax
movslq %eax,%r13
cmp    %r13,%rbx
cmovl  %ebx,%r13d
cmp    %ebp,%r13d
cmovg  %ebp,%r13d
test   %r13d,%r13d
jle    121b <FS460_decode_bitmap_from_alpha_masks+0x10b>
mov    %r13d,%edx
mov    %r14,%rdi
call   1030 <memset@plt>
lea    -0x1(%r13),%eax
add    %rax,%r14
add    $0x1,%r14
xor    %eax,%eax
test   %r12d,%r12d
sete   %cl
sub    %r13d,%ebp
jne    1232 <FS460_decode_bitmap_from_alpha_masks+0x122>
mov    %cl,%al
mov    $0x2d0,%ebp
mov    %eax,%r12d
movslq %r13d,%rax
sub    %rax,%rbx
test   %r15d,%r15d
jle    1257 <FS460_decode_bitmap_from_alpha_masks+0x147>
cmpl   $0x0,0x8(%rsp)
jle    1257 <FS460_decode_bitmap_from_alpha_masks+0x147>
mov    0x10(%rsp),%r8
mov    0x18(%rsp),%rdx
test   %rbx,%rbx
jne    11a0 <FS460_decode_bitmap_from_alpha_masks+0x90>
mov    0x20(%rsp),%rsi
mov    (%rsi),%rax
jmp    1264 <FS460_decode_bitmap_from_alpha_masks+0x154>
mov    %rbx,%rax
sub    %rbx,%rax
mov    %rax,(%rsi)
xor    %eax,%eax
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define i32 @FS460_decode_bitmap_from_alpha_masks(i8* writeonly %0, i64* %1, i16* %2, i32 %3, i16* %4, i32 %5) {
%7 = add i32 %3, -2
%8 = icmp ult i32 %7, 65535
%9 = add i32 %5, -2
%10 = icmp ult i32 %9, 65535
%11 = and i1 %8, %10
%12 = icmp ne i16* %2, null
%13 = and i1 %12, %11
%14 = icmp ne i16* %4, null
%15 = and i1 %14, %13
%16 = icmp ne i8* %0, null
%17 = and i1 %16, %15
%18 = icmp ne i64* %1, null
%19 = and i1 %18, %17
br i1 %19, label %20, label %84
20: ; preds = %6
%21 = load i64, i64* %1
%22 = icmp eq i64 %21, 0
br i1 %22, label %80, label %23
23: ; preds = %20, %64
%24 = phi i32 [ %72, %64 ], [ 1, %20 ]
%25 = phi i32 [ %71, %64 ], [ 720, %20 ]
%26 = phi i16* [ %43, %64 ], [ %4, %20 ]
%27 = phi i16* [ %42, %64 ], [ %2, %20 ]
%28 = phi i8* [ %65, %64 ], [ %0, %20 ]
%29 = phi i64 [ %67, %64 ], [ %21, %20 ]
%30 = phi i32 [ %41, %64 ], [ %5, %20 ]
%31 = phi i32 [ %40, %64 ], [ %3, %20 ]
%32 = icmp eq i32 %24, 0
br i1 %32, label %36, label %33
33: ; preds = %23
%34 = getelementptr inbounds i16, i16* %27, i64 1
%35 = add nsw i32 %31, -2
br label %39
36: ; preds = %23
%37 = getelementptr inbounds i16, i16* %26, i64 1
%38 = add nsw i32 %30, -2
br label %39
39: ; preds = %36, %33
%40 = phi i32 [ %35, %33 ], [ %31, %36 ]
%41 = phi i32 [ %30, %33 ], [ %38, %36 ]
%42 = phi i16* [ %34, %33 ], [ %27, %36 ]
%43 = phi i16* [ %26, %33 ], [ %37, %36 ]
%44 = phi i16* [ %27, %33 ], [ %26, %36 ]
%45 = load i16, i16* %44
%46 = lshr i16 %45, 8
%47 = zext i16 %46 to i32
%48 = icmp ult i16 %45, 256
%49 = select i1 %48, i32 %25, i32 %47
%50 = sext i32 %49 to i64
%51 = icmp slt i64 %29, %50
%52 = trunc i64 %29 to i32
%53 = select i1 %51, i32 %52, i32 %49
%54 = icmp sgt i32 %53, %25
%55 = select i1 %54, i32 %25, i32 %53
%56 = icmp sgt i32 %55, 0
br i1 %56, label %57, label %64
57: ; preds = %39
%58 = trunc i16 %45 to i8
%59 = zext i32 %55 to i64
%60 = add nsw i32 %55, -1
%61 = zext i32 %60 to i64
%62 = getelementptr i8, i8* %28, i64 1
%63 = getelementptr i8, i8* %62, i64 %61
br label %64
64: ; preds = %57, %39
%65 = phi i8* [ %28, %39 ], [ %63, %57 ]
%66 = sext i32 %55 to i64
%67 = sub nsw i64 %29, %66
%68 = sub nsw i32 %25, %55
%69 = icmp eq i32 %68, 0
%70 = zext i1 %32 to i32
%71 = select i1 %69, i32 720, i32 %68
%72 = select i1 %69, i32 %70, i32 %24
%73 = icmp sgt i32 %40, 0
%74 = icmp sgt i32 %41, 0
%75 = select i1 %73, i1 %74, i1 false
%76 = icmp ne i64 %67, 0
%77 = select i1 %75, i1 %76, i1 false
br i1 %77, label %23, label %78
78: ; preds = %64
%79 = load i64, i64* %1
br label %80
80: ; preds = %78, %20
%81 = phi i64 [ %21, %20 ], [ %79, %78 ]
%82 = phi i64 [ %21, %20 ], [ %67, %78 ]
%83 = sub nsw i64 %81, %82
store i64 %83, i64* %1
br label %84
84: ; preds = %6, %80
%85 = phi i32 [ 0, %80 ], [ 4096, %6 ]
ret i32 %85
}