#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ putchar(char);
int main(void) {
  {
    {
      {
        {
          {
            {
              {
                {
                  {
                    {
                      {
                        {
                          {
                            {
                              {
                                {
                                  {
                                    {
                                      {
                                        {
                                          {
                                            {
                                              {
                                                int z;
                                                for (
                                                    z = 002354l / 000644l /
                                                        000132l / 000322l /
                                                        000374l;
                                                    z < 000132l;
                                                    putchar(
                                                        z % 011 + z / 011 >
                                                                    002354l /
                                                                        000644l &&
                                                                z % 011 +
                                                                        z / 011 <
                                                                    002354l /
                                                                        000132l &&
                                                                z / 011 <
                                                                    z % 011 +
                                                                        002354l /
                                                                            000322l &&
                                                                z / 011 >
                                                                    z % 011 -
                                                                        002354l /
                                                                            000374l
                                                            ? '*'
                                                            : ' '),
                                                   z % 011 - 011 + 1 ||
                                                        putchar('\n'),
                                                   z++)
                                                  ;
                                                putchar('\n');
                                                {
                                                  {
                                                    {
                                                      {
                                                        {
                                                          {
                                                            {
                                                              {
                                                                {
                                                                  {
                                                                    {
                                                                      return 002354l /
                                                                             000644l /
                                                                             000132l /
                                                                             000322l /
                                                                             000374l;
                                                                    }
                                                                  }
                                                                }
                                                              }
                                                            }
                                                          }
                                                        }
                                                      }
                                                    }
                                                  }
                                                }
                                              }
                                            }
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
movl   $0x0,-0x4(%rbp)
movl   $0x0,-0x8(%rbp)
movslq -0x8(%rbp),%rax
cmp    $0x5a,%rax
jge    1257 <main+0x147>
jmp    1139 <main+0x29>
mov    -0x8(%rbp),%eax
mov    $0x9,%ecx
cltd
idiv   %ecx
mov    %edx,-0x10(%rbp)
mov    -0x8(%rbp),%eax
mov    $0x9,%ecx
cltd
idiv   %ecx
mov    -0x10(%rbp),%edx
add    %eax,%edx
movslq %edx,%rcx
xor    %eax,%eax
cmp    $0x3,%rcx
mov    %al,-0x9(%rbp)
jle    11f7 <main+0xe7>
mov    -0x8(%rbp),%eax
mov    $0x9,%ecx
cltd
idiv   %ecx
mov    %edx,-0x14(%rbp)
mov    -0x8(%rbp),%eax
mov    $0x9,%ecx
cltd
idiv   %ecx
mov    -0x14(%rbp),%edx
add    %eax,%edx
movslq %edx,%rcx
xor    %eax,%eax
cmp    $0xe,%rcx
mov    %al,-0x9(%rbp)
jge    11f7 <main+0xe7>
mov    -0x8(%rbp),%eax
mov    $0x9,%ecx
cltd
idiv   %ecx
movslq %eax,%rcx
mov    -0x8(%rbp),%eax
mov    $0x9,%esi
cltd
idiv   %esi
movslq %edx,%rdx
add    $0x6,%rdx
xor    %eax,%eax
cmp    %rdx,%rcx
mov    %al,-0x9(%rbp)
jge    11f7 <main+0xe7>
mov    -0x8(%rbp),%eax
mov    $0x9,%ecx
cltd
idiv   %ecx
cltq
mov    %rax,-0x20(%rbp)
mov    -0x8(%rbp),%eax
mov    $0x9,%ecx
cltd
idiv   %ecx
mov    -0x20(%rbp),%rax
movslq %edx,%rcx
sub    $0x5,%rcx
cmp    %rcx,%rax
setg   %al
mov    %al,-0x9(%rbp)
mov    -0x9(%rbp),%dl
mov    $0x20,%eax
mov    $0x2a,%ecx
test   $0x1,%dl
cmovne %ecx,%eax
movsbl %al,%edi
call   1030 <putchar@plt>
mov    -0x8(%rbp),%eax
mov    $0x9,%ecx
cltd
idiv   %ecx
mov    %edx,%ecx
sub    $0x9,%ecx
add    $0x1,%ecx
mov    $0x1,%al
cmp    $0x0,%ecx
mov    %al,-0x21(%rbp)
jne    1246 <main+0x136>
mov    $0xa,%edi
call   1030 <putchar@plt>
cmp    $0x0,%eax
setne  %al
mov    %al,-0x21(%rbp)
mov    -0x21(%rbp),%al
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1126 <main+0x16>
mov    $0xa,%edi
call   1030 <putchar@plt>
xor    %eax,%eax
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    $0x6,%ebx
xor    %r14d,%r14d
movabs $0xe38e38e38e38e38f,%r15
38 8e e3
mov    $0x2a,%r12d
mov    $0x20,%r13d
jmp    1151 <main+0x41>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rbx
add    $0x1,%r14
cmp    $0x60,%ebx
je     11e7 <main+0xd7>
movzbl %r14b,%eax
imul   $0x39,%eax,%ecx
shr    $0x9,%ecx
lea    0x0(,%rcx,8),%esi
mov    %r14,%rax
mul    %r15
neg    %sil
lea    (%rcx,%rcx,8),%eax
mov    $0xf8,%cl
sub    %al,%cl
movzbl %cl,%ebp
add    %rbx,%rbp
movzbl %sil,%eax
add    %ebx,%eax
add    $0xfffffffa,%eax
movzbl %al,%ecx
add    $0xfffffffc,%ecx
mov    $0x20,%al
cmp    $0x9,%ecx
ja     11c6 <main+0xb6>
shr    $0x3,%rdx
lea    (%rdx,%rdx,8),%rax
neg    %rax
lea    -0x6(%rbx),%ecx
movzbl %cl,%ecx
imul   $0x39,%ecx,%ecx
shr    $0x9,%ecx
movzbl %cl,%ecx
lea    (%rbx,%rax,1),%rdx
add    %rbx,%rax
add    $0xfffffffffffffff5,%rax
cmp    %rcx,%rax
mov    $0x20,%eax
cmovl  %r12d,%eax
cmp    %rcx,%rdx
cmovbe %r13d,%eax
movzbl %al,%edi
call   1030 <putchar@plt>
cmp    $0x6,%bpl
jne    1140 <main+0x30>
mov    $0xa,%edi
call   1030 <putchar@plt>
jmp    1140 <main+0x30>
mov    $0xa,%edi
call   1030 <putchar@plt>
xor    %eax,%eax
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define i32 @main() {
%1 = alloca i32
%2 = alloca i32
store i32 0, i32* %1
store i32 0, i32* %2
br label %3
3: ; preds = %56, %0
%4 = load i32, i32* %2
%5 = sext i32 %4 to i64
%6 = icmp slt i64 %5, 90
br i1 %6, label %7, label %61
7: ; preds = %3
br label %8
8: ; preds = %7
%9 = load i32, i32* %2
%10 = srem i32 %9, 9
%11 = load i32, i32* %2
%12 = sdiv i32 %11, 9
%13 = add nsw i32 %10, %12
%14 = sext i32 %13 to i64
%15 = icmp sgt i64 %14, 3
br i1 %15, label %16, label %42
16: ; preds = %8
%17 = load i32, i32* %2
%18 = srem i32 %17, 9
%19 = load i32, i32* %2
%20 = sdiv i32 %19, 9
%21 = add nsw i32 %18, %20
%22 = sext i32 %21 to i64
%23 = icmp slt i64 %22, 14
br i1 %23, label %24, label %42
24: ; preds = %16
%25 = load i32, i32* %2
%26 = sdiv i32 %25, 9
%27 = sext i32 %26 to i64
%28 = load i32, i32* %2
%29 = srem i32 %28, 9
%30 = sext i32 %29 to i64
%31 = add nsw i64 %30, 6
%32 = icmp slt i64 %27, %31
br i1 %32, label %33, label %42
33: ; preds = %24
%34 = load i32, i32* %2
%35 = sdiv i32 %34, 9
%36 = sext i32 %35 to i64
%37 = load i32, i32* %2
%38 = srem i32 %37, 9
%39 = sext i32 %38 to i64
%40 = sub nsw i64 %39, 5
%41 = icmp sgt i64 %36, %40
br label %42
42: ; preds = %33, %24, %16, %8
%43 = phi i1 [ false, %24 ], [ false, %16 ], [ false, %8 ], [ %41, %33 ]
%44 = zext i1 %43 to i64
%45 = select i1 %43, i32 42, i32 32
%46 = trunc i32 %45 to i8
%47 = call i32 @putchar(i8 signext %46)
%48 = load i32, i32* %2
%49 = srem i32 %48, 9
%50 = sub nsw i32 %49, 9
%51 = add nsw i32 %50, 1
%52 = icmp ne i32 %51, 0
br i1 %52, label %56, label %53
53: ; preds = %42
%54 = call i32 @putchar(i8 signext 10)
%55 = icmp ne i32 %54, 0
br label %56
56: ; preds = %53, %42
%57 = phi i1 [ true, %42 ], [ %55, %53 ]
%58 = zext i1 %57 to i32
%59 = load i32, i32* %2
%60 = add nsw i32 %59, 1
store i32 %60, i32* %2
br label %3
61: ; preds = %3
%62 = call i32 @putchar(i8 signext 10)
ret i32 0
}

LLVM IR (-O2):
define i32 @main() {
br label %1
1: ; preds = %0, %25
%2 = phi i32 [ 0, %0 ], [ %26, %25 ]
%3 = trunc i32 %2 to i8
%4 = urem i8 %3, 9
%5 = udiv i8 %3, 9
%6 = add nuw nsw i8 %4, %5
%7 = zext i8 %6 to i32
%8 = add nsw i32 %7, -4
%9 = icmp ult i32 %8, 10
br i1 %9, label %10, label %19
10: ; preds = %1
%11 = zext i8 %5 to i64
%12 = zext i8 %4 to i64
%13 = add nuw nsw i64 %12, 6
%14 = icmp ugt i64 %13, %11
%15 = add nsw i64 %12, -5
%16 = icmp slt i64 %15, %11
%17 = select i1 %14, i1 %16, i1 false
%18 = select i1 %17, i8 42, i8 32
br label %19
19: ; preds = %10, %1
%20 = phi i8 [ 32, %1 ], [ %18, %10 ]
%21 = tail call i32 @putchar(i8 signext %20)
%22 = icmp eq i8 %4, 8
br i1 %22, label %23, label %25
23: ; preds = %19
%24 = tail call i32 @putchar(i8 signext 10)
br label %25
25: ; preds = %23, %19
%26 = add nuw nsw i32 %2, 1
%27 = icmp eq i32 %26, 90
br i1 %27, label %28, label %1
28: ; preds = %25
%29 = tail call i32 @putchar(i8 signext 10)
ret i32 0
}