#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 */
typedef int /*<<< orphan*/ time_t;
struct tm {
  int dummy;
};

/* Variables and functions */
int A_BOLD;
int CHAR_BIT;
int /*<<< orphan*/ COLOR_BLACK;
int /*<<< orphan*/ COLOR_BLUE;
int /*<<< orphan*/ COLOR_GREEN;
int COLOR_PAIR(int);
int /*<<< orphan*/ COLOR_YELLOW;
int /*<<< orphan*/ EXIT_FAILURE;
int /*<<< orphan*/ TRUE;
int /*<<< orphan*/ addstr(char *);
int /*<<< orphan*/ attrset(int);
int /*<<< orphan*/ box(int /*<<< orphan*/, int /*<<< orphan*/,
                       int /*<<< orphan*/);
int /*<<< orphan*/ cbreak();
int /*<<< orphan*/ clear();
int /*<<< orphan*/ curs_set(int /*<<< orphan*/);
int /*<<< orphan*/ echo();
int /*<<< orphan*/ endwin();
int /*<<< orphan*/ exit(int /*<<< orphan*/);
int /*<<< orphan*/ idlok(int /*<<< orphan*/, int /*<<< orphan*/);
int /*<<< orphan*/ init_pair(int, int /*<<< orphan*/, int /*<<< orphan*/);
int /*<<< orphan*/ initscr();
struct tm *localtime(int /*<<< orphan*/ *);
int /*<<< orphan*/ move(int, int);
int /*<<< orphan*/ mvprintw(int, int, char *);
int /*<<< orphan*/ refresh();
int /*<<< orphan*/ scrollok(int /*<<< orphan*/, int /*<<< orphan*/);
int /*<<< orphan*/ sleep(int);
int /*<<< orphan*/ sprintf(char *, char *, char *);
int /*<<< orphan*/ start_color();
int /*<<< orphan*/ stdscr;
int /*<<< orphan*/ strftime(char *, int, char *, struct tm *);
int /*<<< orphan*/ time(int /*<<< orphan*/ *);
int /*<<< orphan*/ uc2bin(char, char *);
int main() {
  struct tm *tm;
  time_t t;
  char m[4][7] = {0};
  char p[CHAR_BIT + 1];
  char s[512];
  int i, j, k;
  initscr();
  cbreak();
  clear();
  scrollok(stdscr, TRUE);
  idlok(stdscr, TRUE);
  echo();
  attrset(A_BOLD);
  box(stdscr, 0, 0);
  start_color();
  init_pair(2, COLOR_YELLOW, COLOR_BLACK);
  attrset(COLOR_PAIR(2) | A_BOLD);
  mvprintw(2, 17, "   10000  100000  100000  10   10000 1000");
  mvprintw(3, 17, "   00     00  00  00  00  00   0     00 00");
  mvprintw(4, 17, "   00     00  00  00  00  00   000   0000");
  mvprintw(5, 17, "   00     00  00  00  00  00   0     00 00");
  mvprintw(6, 17, "   00001  000001  000001  0001 00001 00 001 ");
  mvprintw(7, 17, "      ...:::Binary:Clock:::... ");
  init_pair(1, COLOR_BLUE, COLOR_GREEN);
  curs_set(0);
  m[0][4] = ' ';
  m[0][2] = ' ';
  m[1][0] = ' ';
  m[0][0] = ' ';
  while (1) {
    time(&t);
    tm = localtime(&t);
    if (!tm)
      exit(EXIT_FAILURE);
    strftime(s, sizeof s, "%H%M%S", tm);
    for (i = 0; i < 6; s[i++] -= '0')
      ;
    uc2bin(s[1], p);
    do {
      for (i = 3, k = 4, j = CHAR_BIT - 1; k--; i--, j--)
        m[i][1] = p[j];
    } while (0);
    uc2bin(s[0], p);
    do {
      for (i = 3, k = 2, j = CHAR_BIT - 1; k--; i--, j--)
        m[i][0] = p[j];
    } while (0);
    uc2bin(s[3], p);
    do {
      for (i = 3, k = 4, j = CHAR_BIT - 1; k--; i--, j--)
        m[i][3] = p[j];
    } while (0);
    uc2bin(s[2], p);
    do {
      for (i = 3, k = 3, j = CHAR_BIT - 1; k--; i--, j--)
        m[i][2] = p[j];
    } while (0);
    uc2bin(s[5], p);
    do {
      for (i = 3, k = 4, j = CHAR_BIT - 1; k--; i--, j--)
        m[i][5] = p[j];
    } while (0);
    uc2bin(s[4], p);
    do {
      for (i = 3, k = 3, j = CHAR_BIT - 1; k--; i--, j--)
        m[i][4] = p[j];
    } while (0);
    for (i = 0; i < 4; i++) {
      move(11 + i, 31);
      sprintf(s, "%s", m[i]);
      addstr(s);
    }
    refresh();
    sleep(1);
  }
  endwin();
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x260,%rsp
movl   $0x0,-0x4(%rbp)
xorps  %xmm0,%xmm0
movups %xmm0,-0x24(%rbp)
movaps %xmm0,-0x30(%rbp)
mov    0x2d2c(%rip),%rax
mov    (%rax),%eax
add    $0x1,%eax
mov    %rsp,%rcx
mov    %rcx,-0x38(%rbp)
mov    %rax,%rdx
add    $0xf,%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x258(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x40(%rbp)
mov    $0x0,%al
call   1070 <initscr@plt>
mov    $0x0,%al
call   1050 <cbreak@plt>
mov    $0x0,%al
call   1140 <clear@plt>
mov    0x2d0d(%rip),%rax
mov    (%rax),%edi
mov    0x2cfc(%rip),%rax
mov    (%rax),%esi
call   10f0 <scrollok@plt>
mov    0x2cf6(%rip),%rax
mov    (%rax),%edi
mov    0x2ce5(%rip),%rax
mov    (%rax),%esi
call   10d0 <idlok@plt>
mov    $0x0,%al
call   1040 <echo@plt>
mov    0x2c90(%rip),%rax
mov    (%rax),%edi
call   1100 <attrset@plt>
mov    0x2cca(%rip),%rax
mov    (%rax),%edi
xor    %edx,%edx
mov    %edx,%esi
call   1090 <box@plt>
mov    $0x0,%al
call   1080 <start_color@plt>
mov    0x2c81(%rip),%rax
mov    (%rax),%esi
mov    0x2c98(%rip),%rax
mov    (%rax),%edx
mov    $0x2,%edi
call   1060 <init_pair@plt>
mov    $0x2,%edi
call   10b0 <COLOR_PAIR@plt>
mov    %eax,%edi
mov    0x2c41(%rip),%rax
or     (%rax),%edi
call   1100 <attrset@plt>
mov    $0x2,%edi
mov    $0x11,%esi
lea    0xc89(%rip),%rdx
call   1180 <mvprintw@plt>
mov    $0x3,%edi
mov    $0x11,%esi
lea    0xc9d(%rip),%rdx
call   1180 <mvprintw@plt>
mov    $0x4,%edi
mov    $0x11,%esi
lea    0xcb2(%rip),%rdx
call   1180 <mvprintw@plt>
mov    $0x5,%edi
mov    $0x11,%esi
lea    0xc71(%rip),%rdx
call   1180 <mvprintw@plt>
mov    $0x6,%edi
mov    $0x11,%esi
lea    0xcb0(%rip),%rdx
call   1180 <mvprintw@plt>
mov    $0x7,%edi
mov    $0x11,%esi
lea    0xcc7(%rip),%rdx
call   1180 <mvprintw@plt>
mov    0x2bb7(%rip),%rax
mov    (%rax),%esi
mov    0x2bd6(%rip),%rax
mov    (%rax),%edx
mov    $0x1,%edi
call   1060 <init_pair@plt>
xor    %edi,%edi
call   1150 <curs_set@plt>
movb   $0x20,-0x2c(%rbp)
movb   $0x20,-0x2e(%rbp)
movb   $0x20,-0x29(%rbp)
movb   $0x20,-0x30(%rbp)
jmp    1422 <main+0x1b2>
lea    -0x14(%rbp),%rdi
call   10a0 <time@plt>
lea    -0x14(%rbp),%rdi
call   1030 <localtime@plt>
mov    %rax,-0x10(%rbp)
cmpq   $0x0,-0x10(%rbp)
jne    1451 <main+0x1e1>
mov    0x2b66(%rip),%rax
mov    (%rax),%edi
call   1120 <exit@plt>
lea    -0x240(%rbp),%rdi
mov    -0x10(%rbp),%rcx
mov    $0x200,%esi
lea    0xc64(%rip),%rdx
call   10e0 <strftime@plt>
movl   $0x0,-0x244(%rbp)
cmpl   $0x6,-0x244(%rbp)
jge    14b3 <main+0x243>
jmp    1489 <main+0x219>
mov    -0x244(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x244(%rbp)
cltq
movsbl -0x240(%rbp,%rax,1),%ecx
ff
sub    $0x30,%ecx
mov    %cl,-0x240(%rbp,%rax,1)
jmp    1477 <main+0x207>
mov    -0x258(%rbp),%rsi
movsbl -0x23f(%rbp),%edi
call   1170 <uc2bin@plt>
movl   $0x3,-0x244(%rbp)
movl   $0x4,-0x24c(%rbp)
mov    0x2adf(%rip),%rax
mov    (%rax),%eax
sub    $0x1,%eax
mov    %eax,-0x248(%rbp)
mov    -0x24c(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x24c(%rbp)
cmp    $0x0,%eax
je     154f <main+0x2df>
mov    -0x258(%rbp),%rax
movslq -0x248(%rbp),%rcx
mov    (%rax,%rcx,1),%cl
movslq -0x244(%rbp),%rdx
lea    -0x30(%rbp),%rax
imul   $0x7,%rdx,%rdx
add    %rdx,%rax
mov    %cl,0x1(%rax)
mov    -0x244(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x244(%rbp)
mov    -0x248(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x248(%rbp)
jmp    14ec <main+0x27c>
jmp    1554 <main+0x2e4>
jmp    1559 <main+0x2e9>
mov    -0x258(%rbp),%rsi
movsbl -0x240(%rbp),%edi
call   1170 <uc2bin@plt>
movl   $0x3,-0x244(%rbp)
movl   $0x2,-0x24c(%rbp)
mov    0x2a39(%rip),%rax
mov    (%rax),%eax
sub    $0x1,%eax
mov    %eax,-0x248(%rbp)
mov    -0x24c(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x24c(%rbp)
cmp    $0x0,%eax
je     15f4 <main+0x384>
mov    -0x258(%rbp),%rax
movslq -0x248(%rbp),%rcx
mov    (%rax,%rcx,1),%cl
movslq -0x244(%rbp),%rdx
lea    -0x30(%rbp),%rax
imul   $0x7,%rdx,%rdx
add    %rdx,%rax
mov    %cl,(%rax)
mov    -0x244(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x244(%rbp)
mov    -0x248(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x248(%rbp)
jmp    1592 <main+0x322>
jmp    15f9 <main+0x389>
jmp    15fe <main+0x38e>
mov    -0x258(%rbp),%rsi
movsbl -0x23d(%rbp),%edi
call   1170 <uc2bin@plt>
movl   $0x3,-0x244(%rbp)
movl   $0x4,-0x24c(%rbp)
mov    0x2994(%rip),%rax
mov    (%rax),%eax
sub    $0x1,%eax
mov    %eax,-0x248(%rbp)
mov    -0x24c(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x24c(%rbp)
cmp    $0x0,%eax
je     169a <main+0x42a>
mov    -0x258(%rbp),%rax
movslq -0x248(%rbp),%rcx
mov    (%rax,%rcx,1),%cl
movslq -0x244(%rbp),%rdx
lea    -0x30(%rbp),%rax
imul   $0x7,%rdx,%rdx
add    %rdx,%rax
mov    %cl,0x3(%rax)
mov    -0x244(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x244(%rbp)
mov    -0x248(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x248(%rbp)
jmp    1637 <main+0x3c7>
jmp    169f <main+0x42f>
jmp    16a4 <main+0x434>
mov    -0x258(%rbp),%rsi
movsbl -0x23e(%rbp),%edi
call   1170 <uc2bin@plt>
movl   $0x3,-0x244(%rbp)
movl   $0x3,-0x24c(%rbp)
mov    0x28ee(%rip),%rax
mov    (%rax),%eax
sub    $0x1,%eax
mov    %eax,-0x248(%rbp)
mov    -0x24c(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x24c(%rbp)
cmp    $0x0,%eax
je     1740 <main+0x4d0>
mov    -0x258(%rbp),%rax
movslq -0x248(%rbp),%rcx
mov    (%rax,%rcx,1),%cl
movslq -0x244(%rbp),%rdx
lea    -0x30(%rbp),%rax
imul   $0x7,%rdx,%rdx
add    %rdx,%rax
mov    %cl,0x2(%rax)
mov    -0x244(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x244(%rbp)
mov    -0x248(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x248(%rbp)
jmp    16dd <main+0x46d>
jmp    1745 <main+0x4d5>
jmp    174a <main+0x4da>
mov    -0x258(%rbp),%rsi
movsbl -0x23b(%rbp),%edi
call   1170 <uc2bin@plt>
movl   $0x3,-0x244(%rbp)
movl   $0x4,-0x24c(%rbp)
mov    0x2848(%rip),%rax
mov    (%rax),%eax
sub    $0x1,%eax
mov    %eax,-0x248(%rbp)
mov    -0x24c(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x24c(%rbp)
cmp    $0x0,%eax
je     17e6 <main+0x576>
mov    -0x258(%rbp),%rax
movslq -0x248(%rbp),%rcx
mov    (%rax,%rcx,1),%cl
movslq -0x244(%rbp),%rdx
lea    -0x30(%rbp),%rax
imul   $0x7,%rdx,%rdx
add    %rdx,%rax
mov    %cl,0x5(%rax)
mov    -0x244(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x244(%rbp)
mov    -0x248(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x248(%rbp)
jmp    1783 <main+0x513>
jmp    17eb <main+0x57b>
jmp    17f0 <main+0x580>
mov    -0x258(%rbp),%rsi
movsbl -0x23c(%rbp),%edi
call   1170 <uc2bin@plt>
movl   $0x3,-0x244(%rbp)
movl   $0x3,-0x24c(%rbp)
mov    0x27a2(%rip),%rax
mov    (%rax),%eax
sub    $0x1,%eax
mov    %eax,-0x248(%rbp)
mov    -0x24c(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x24c(%rbp)
cmp    $0x0,%eax
je     188c <main+0x61c>
mov    -0x258(%rbp),%rax
movslq -0x248(%rbp),%rcx
mov    (%rax,%rcx,1),%cl
movslq -0x244(%rbp),%rdx
lea    -0x30(%rbp),%rax
imul   $0x7,%rdx,%rdx
add    %rdx,%rax
mov    %cl,0x4(%rax)
mov    -0x244(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x244(%rbp)
mov    -0x248(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x248(%rbp)
jmp    1829 <main+0x5b9>
jmp    1891 <main+0x621>
jmp    1896 <main+0x626>
movl   $0x0,-0x244(%rbp)
cmpl   $0x4,-0x244(%rbp)
jge    1905 <main+0x695>
mov    -0x244(%rbp),%edi
add    $0xb,%edi
mov    $0x1f,%esi
call   1190 <move@plt>
lea    -0x240(%rbp),%rdi
movslq -0x244(%rbp),%rax
lea    -0x30(%rbp),%rdx
imul   $0x7,%rax,%rax
add    %rax,%rdx
lea    0x7f3(%rip),%rsi
call   1110 <sprintf@plt>
lea    -0x240(%rbp),%rdi
call   1130 <addstr@plt>
mov    -0x244(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x244(%rbp)
jmp    18a0 <main+0x630>
mov    $0x0,%al
call   10c0 <refresh@plt>
mov    $0x1,%edi
call   1160 <sleep@plt>
jmp    141d <main+0x1ad>

x86 assembly (clang, -O2):
<main>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x238,%rsp
xorps  %xmm0,%xmm0
movups %xmm0,-0x44(%rbp)
movaps %xmm0,-0x50(%rbp)
mov    0x2d2a(%rip),%r13
mov    0x0(%r13),%eax
add    $0x1,%eax
mov    %rsp,%rbx
add    $0xf,%rax
and    $0xfffffffffffffff0,%rax
sub    %rax,%rbx
mov    %rbx,%rsp
xor    %eax,%eax
call   1080 <initscr@plt>
xor    %eax,%eax
call   1060 <cbreak@plt>
xor    %eax,%eax
call   1140 <clear@plt>
mov    0x2d1e(%rip),%r15
mov    (%r15),%edi
mov    0x2d0c(%rip),%r14
mov    (%r14),%esi
call   1100 <scrollok@plt>
mov    (%r15),%edi
mov    (%r14),%esi
call   10e0 <idlok@plt>
xor    %eax,%eax
call   1040 <echo@plt>
mov    0x2cab(%rip),%r14
mov    (%r14),%edi
call   1110 <attrset@plt>
mov    (%r15),%edi
xor    %esi,%esi
xor    %edx,%edx
call   10a0 <box@plt>
xor    %eax,%eax
call   1090 <start_color@plt>
mov    0x2ca1(%rip),%rax
mov    (%rax),%esi
mov    0x2cb8(%rip),%rax
mov    (%rax),%edx
mov    $0x2,%edi
call   1070 <init_pair@plt>
mov    $0x2,%edi
call   10c0 <COLOR_PAIR@plt>
or     (%r14),%eax
mov    %eax,%edi
call   1110 <attrset@plt>
lea    0xcb9(%rip),%rdx
mov    $0x2,%edi
mov    $0x11,%esi
call   1180 <mvprintw@plt>
lea    0xccd(%rip),%r14
mov    $0x3,%edi
mov    $0x11,%esi
mov    %r14,%rdx
call   1180 <mvprintw@plt>
lea    0xcdf(%rip),%rdx
mov    $0x4,%edi
mov    $0x11,%esi
call   1180 <mvprintw@plt>
mov    $0x5,%edi
mov    $0x11,%esi
mov    %r14,%rdx
call   1180 <mvprintw@plt>
lea    0xce1(%rip),%rdx
mov    $0x6,%edi
mov    $0x11,%esi
call   1180 <mvprintw@plt>
lea    0xcf8(%rip),%rdx
mov    $0x7,%edi
mov    $0x11,%esi
call   1180 <mvprintw@plt>
mov    0x2bde(%rip),%rax
mov    (%rax),%esi
mov    0x2bfd(%rip),%rax
mov    (%rax),%edx
mov    $0x1,%edi
call   1070 <init_pair@plt>
xor    %edi,%edi
call   1150 <curs_set@plt>
movb   $0x20,-0x4c(%rbp)
movb   $0x20,-0x4e(%rbp)
movb   $0x20,-0x49(%rbp)
movb   $0x20,-0x50(%rbp)
lea    -0x54(%rbp),%r14
mov    %r14,%rdi
call   10b0 <time@plt>
mov    %r14,%rdi
call   1030 <localtime@plt>
test   %rax,%rax
je     163c <main+0x3cc>
lea    -0x260(%rbp),%r14
lea    -0x50(%rbp),%r15
lea    -0x54(%rbp),%r12
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %r14,%rdi
mov    $0x200,%esi
lea    0xc8d(%rip),%rdx
mov    %rax,%rcx
call   10f0 <strftime@plt>
addb   $0xd0,-0x260(%rbp)
movzbl -0x25f(%rbp),%eax
add    $0xd0,%al
mov    %al,-0x25f(%rbp)
addb   $0xd0,-0x25e(%rbp)
addb   $0xd0,-0x25d(%rbp)
addb   $0xd0,-0x25c(%rbp)
addb   $0xd0,-0x25b(%rbp)
movsbl %al,%edi
mov    %rbx,%rsi
call   1170 <uc2bin@plt>
movslq 0x0(%r13),%rax
movzbl -0x1(%rax,%rbx,1),%ecx
mov    %cl,-0x3a(%rbp)
movzbl -0x2(%rax,%rbx,1),%ecx
mov    %cl,-0x41(%rbp)
movzbl -0x3(%rax,%rbx,1),%ecx
mov    %cl,-0x48(%rbp)
movzbl -0x4(%rax,%rbx,1),%eax
mov    %al,-0x4f(%rbp)
movsbl -0x260(%rbp),%edi
mov    %rbx,%rsi
call   1170 <uc2bin@plt>
movslq 0x0(%r13),%rax
movzbl -0x1(%rax,%rbx,1),%ecx
mov    %cl,-0x3b(%rbp)
movzbl -0x2(%rax,%rbx,1),%eax
mov    %al,-0x42(%rbp)
movsbl -0x25d(%rbp),%edi
mov    %rbx,%rsi
call   1170 <uc2bin@plt>
movslq 0x0(%r13),%rax
movzbl -0x1(%rax,%rbx,1),%ecx
mov    %cl,-0x38(%rbp)
movzbl -0x2(%rax,%rbx,1),%ecx
mov    %cl,-0x3f(%rbp)
movzbl -0x3(%rax,%rbx,1),%ecx
mov    %cl,-0x46(%rbp)
movzbl -0x4(%rax,%rbx,1),%eax
mov    %al,-0x4d(%rbp)
movsbl -0x25e(%rbp),%edi
mov    %rbx,%rsi
call   1170 <uc2bin@plt>
movslq 0x0(%r13),%rax
movzbl -0x1(%rax,%rbx,1),%ecx
mov    %cl,-0x39(%rbp)
movzbl -0x2(%rax,%rbx,1),%ecx
mov    %cl,-0x40(%rbp)
movzbl -0x3(%rax,%rbx,1),%eax
mov    %al,-0x47(%rbp)
movsbl -0x25b(%rbp),%edi
mov    %rbx,%rsi
call   1170 <uc2bin@plt>
movslq 0x0(%r13),%rax
movzbl -0x1(%rax,%rbx,1),%ecx
mov    %cl,-0x36(%rbp)
movzbl -0x2(%rax,%rbx,1),%ecx
mov    %cl,-0x3d(%rbp)
movzbl -0x3(%rax,%rbx,1),%ecx
mov    %cl,-0x44(%rbp)
movzbl -0x4(%rax,%rbx,1),%eax
mov    %al,-0x4b(%rbp)
movsbl -0x25c(%rbp),%edi
mov    %rbx,%rsi
call   1170 <uc2bin@plt>
movslq 0x0(%r13),%rax
movzbl -0x1(%rax,%rbx,1),%ecx
mov    %cl,-0x37(%rbp)
movzbl -0x2(%rax,%rbx,1),%ecx
mov    %cl,-0x3e(%rbp)
movzbl -0x3(%rax,%rbx,1),%eax
mov    %al,-0x45(%rbp)
mov    $0xb,%edi
mov    $0x1f,%esi
call   1190 <move@plt>
mov    %r14,%rdi
mov    %r15,%rsi
call   1050 <strcpy@plt>
mov    %r14,%rdi
call   1130 <addstr@plt>
mov    $0xc,%edi
mov    $0x1f,%esi
call   1190 <move@plt>
mov    %r14,%rdi
lea    -0x49(%rbp),%rsi
call   1050 <strcpy@plt>
mov    %r14,%rdi
call   1130 <addstr@plt>
mov    $0xd,%edi
mov    $0x1f,%esi
call   1190 <move@plt>
mov    %r14,%rdi
lea    -0x42(%rbp),%rsi
call   1050 <strcpy@plt>
mov    %r14,%rdi
call   1130 <addstr@plt>
mov    $0xe,%edi
mov    $0x1f,%esi
call   1190 <move@plt>
mov    %r14,%rdi
lea    -0x3b(%rbp),%rsi
call   1050 <strcpy@plt>
mov    %r14,%rdi
call   1130 <addstr@plt>
xor    %eax,%eax
call   10d0 <refresh@plt>
mov    $0x1,%edi
call   1160 <sleep@plt>
mov    %r12,%rdi
call   10b0 <time@plt>
mov    %r12,%rdi
call   1030 <localtime@plt>
test   %rax,%rax
jne    1430 <main+0x1c0>
mov    0x296d(%rip),%rax
mov    (%rax),%edi
call   1120 <exit@plt>

LLVM IR (-O0):
%struct.tm = type { i32 }
@CHAR_BIT = global i32 0
@stdscr = global i32 0
@TRUE = global i32 0
@A_BOLD = global i32 0
@COLOR_YELLOW = global i32 0
@COLOR_BLACK = global i32 0
@.str = [42 x i8] c" 10000 100000 100000 10 10000 1000\00"
@.str.1 = [43 x i8] c" 00 00 00 00 00 00 0 00 00\00"
@.str.2 = [42 x i8] c" 00 00 00 00 00 00 000 0000\00"
@.str.3 = [45 x i8] c" 00001 000001 000001 0001 00001 00 001 \00"
@.str.4 = [32 x i8] c" ...:::Binary:Clock:::... \00"
@COLOR_BLUE = global i32 0
@COLOR_GREEN = global i32 0
@EXIT_FAILURE = global i32 0
@.str.5 = [7 x i8] c"%H%M%S\00"
@.str.6 = [3 x i8] c"%s\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca %struct.tm*
%3 = alloca i32
%4 = alloca [4 x [7 x i8]]
%5 = alloca i8*
%6 = alloca i64
%7 = alloca [512 x i8]
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
store i32 0, i32* %1
%11 = bitcast [4 x [7 x i8]]* %4 to i8*
%12 = load i32, i32* @CHAR_BIT
%13 = add nsw i32 %12, 1
%14 = zext i32 %13 to i64
%15 = call i8* @llvm.stacksave()
store i8* %15, i8** %5
%16 = alloca i8, i64 %14
store i64 %14, i64* %6
%17 = call i32 (...) @initscr()
%18 = call i32 (...) @cbreak()
%19 = call i32 (...) @clear()
%20 = load i32, i32* @stdscr
%21 = load i32, i32* @TRUE
%22 = call i32 @scrollok(i32 %20, i32 %21)
%23 = load i32, i32* @stdscr
%24 = load i32, i32* @TRUE
%25 = call i32 @idlok(i32 %23, i32 %24)
%26 = call i32 (...) @echo()
%27 = load i32, i32* @A_BOLD
%28 = call i32 @attrset(i32 %27)
%29 = load i32, i32* @stdscr
%30 = call i32 @box(i32 %29, i32 0, i32 0)
%31 = call i32 (...) @start_color()
%32 = load i32, i32* @COLOR_YELLOW
%33 = load i32, i32* @COLOR_BLACK
%34 = call i32 @init_pair(i32 2, i32 %32, i32 %33)
%35 = call i32 @COLOR_PAIR(i32 2)
%36 = load i32, i32* @A_BOLD
%37 = or i32 %35, %36
%38 = call i32 @attrset(i32 %37)
%39 = call i32 @mvprintw(i32 2, i32 17, i8* getelementptr inbounds ([42 x i8], [42 x i8]* @.str, i64 0, i64 0))
%40 = call i32 @mvprintw(i32 3, i32 17, i8* getelementptr inbounds ([43 x i8], [43 x i8]* @.str.1, i64 0, i64 0))
%41 = call i32 @mvprintw(i32 4, i32 17, i8* getelementptr inbounds ([42 x i8], [42 x i8]* @.str.2, i64 0, i64 0))
%42 = call i32 @mvprintw(i32 5, i32 17, i8* getelementptr inbounds ([43 x i8], [43 x i8]* @.str.1, i64 0, i64 0))
%43 = call i32 @mvprintw(i32 6, i32 17, i8* getelementptr inbounds ([45 x i8], [45 x i8]* @.str.3, i64 0, i64 0))
%44 = call i32 @mvprintw(i32 7, i32 17, i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.4, i64 0, i64 0))
%45 = load i32, i32* @COLOR_BLUE
%46 = load i32, i32* @COLOR_GREEN
%47 = call i32 @init_pair(i32 1, i32 %45, i32 %46)
%48 = call i32 @curs_set(i32 0)
%49 = getelementptr inbounds [4 x [7 x i8]], [4 x [7 x i8]]* %4, i64 0, i64 0
%50 = getelementptr inbounds [7 x i8], [7 x i8]* %49, i64 0, i64 4
store i8 32, i8* %50
%51 = getelementptr inbounds [4 x [7 x i8]], [4 x [7 x i8]]* %4, i64 0, i64 0
%52 = getelementptr inbounds [7 x i8], [7 x i8]* %51, i64 0, i64 2
store i8 32, i8* %52
%53 = getelementptr inbounds [4 x [7 x i8]], [4 x [7 x i8]]* %4, i64 0, i64 1
%54 = getelementptr inbounds [7 x i8], [7 x i8]* %53, i64 0, i64 0
store i8 32, i8* %54
%55 = getelementptr inbounds [4 x [7 x i8]], [4 x [7 x i8]]* %4, i64 0, i64 0
%56 = getelementptr inbounds [7 x i8], [7 x i8]* %55, i64 0, i64 0
store i8 32, i8* %56
br label %57
57: ; preds = %264, %0
br label %58
58: ; preds = %57
%59 = call i32 @time(i32* %3)
%60 = call %struct.tm* @localtime(i32* %3)
store %struct.tm* %60, %struct.tm** %2
%61 = load %struct.tm*, %struct.tm** %2
%62 = icmp ne %struct.tm* %61, null
br i1 %62, label %66, label %63
63: ; preds = %58
%64 = load i32, i32* @EXIT_FAILURE
%65 = call i32 @exit(i32 %64)
unreachable
66: ; preds = %58
%67 = getelementptr inbounds [512 x i8], [512 x i8]* %7, i64 0, i64 0
%68 = load %struct.tm*, %struct.tm** %2
%69 = call i32 @strftime(i8* %67, i32 512, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.5, i64 0, i64 0), %struct.tm* %68)
store i32 0, i32* %8
br label %70
70: ; preds = %74, %66
%71 = load i32, i32* %8
%72 = icmp slt i32 %71, 6
br i1 %72, label %73, label %83
73: ; preds = %70
br label %74
74: ; preds = %73
%75 = load i32, i32* %8
%76 = add nsw i32 %75, 1
store i32 %76, i32* %8
%77 = sext i32 %75 to i64
%78 = getelementptr inbounds [512 x i8], [512 x i8]* %7, i64 0, i64 %77
%79 = load i8, i8* %78
%80 = sext i8 %79 to i32
%81 = sub nsw i32 %80, 48
%82 = trunc i32 %81 to i8
store i8 %82, i8* %78
br label %70
83: ; preds = %70
%84 = getelementptr inbounds [512 x i8], [512 x i8]* %7, i64 0, i64 1
%85 = load i8, i8* %84
%86 = call i32 @uc2bin(i8 signext %85, i8* %16)
br label %87
87: ; preds = %83
store i32 3, i32* %8
store i32 4, i32* %10
%88 = load i32, i32* @CHAR_BIT
%89 = sub nsw i32 %88, 1
store i32 %89, i32* %9
br label %90
90: ; preds = %103, %87
%91 = load i32, i32* %10
%92 = add nsw i32 %91, -1
store i32 %92, i32* %10
%93 = icmp ne i32 %91, 0
br i1 %93, label %94, label %108
94: ; preds = %90
%95 = load i32, i32* %9
%96 = sext i32 %95 to i64
%97 = getelementptr inbounds i8, i8* %16, i64 %96
%98 = load i8, i8* %97
%99 = load i32, i32* %8
%100 = sext i32 %99 to i64
%101 = getelementptr inbounds [4 x [7 x i8]], [4 x [7 x i8]]* %4, i64 0, i64 %100
%102 = getelementptr inbounds [7 x i8], [7 x i8]* %101, i64 0, i64 1
store i8 %98, i8* %102
br label %103
103: ; preds = %94
%104 = load i32, i32* %8
%105 = add nsw i32 %104, -1
store i32 %105, i32* %8
%106 = load i32, i32* %9
%107 = add nsw i32 %106, -1
store i32 %107, i32* %9
br label %90
108: ; preds = %90
br label %109
109: ; preds = %108
br label %110
110: ; preds = %109
%111 = getelementptr inbounds [512 x i8], [512 x i8]* %7, i64 0, i64 0
%112 = load i8, i8* %111
%113 = call i32 @uc2bin(i8 signext %112, i8* %16)
br label %114
114: ; preds = %110
store i32 3, i32* %8
store i32 2, i32* %10
%115 = load i32, i32* @CHAR_BIT
%116 = sub nsw i32 %115, 1
store i32 %116, i32* %9
br label %117
117: ; preds = %130, %114
%118 = load i32, i32* %10
%119 = add nsw i32 %118, -1
store i32 %119, i32* %10
%120 = icmp ne i32 %118, 0
br i1 %120, label %121, label %135
121: ; preds = %117
%122 = load i32, i32* %9
%123 = sext i32 %122 to i64
%124 = getelementptr inbounds i8, i8* %16, i64 %123
%125 = load i8, i8* %124
%126 = load i32, i32* %8
%127 = sext i32 %126 to i64
%128 = getelementptr inbounds [4 x [7 x i8]], [4 x [7 x i8]]* %4, i64 0, i64 %127
%129 = getelementptr inbounds [7 x i8], [7 x i8]* %128, i64 0, i64 0
store i8 %125, i8* %129
br label %130
130: ; preds = %121
%131 = load i32, i32* %8
%132 = add nsw i32 %131, -1
store i32 %132, i32* %8
%133 = load i32, i32* %9
%134 = add nsw i32 %133, -1
store i32 %134, i32* %9
br label %117
135: ; preds = %117
br label %136
136: ; preds = %135
br label %137
137: ; preds = %136
%138 = getelementptr inbounds [512 x i8], [512 x i8]* %7, i64 0, i64 3
%139 = load i8, i8* %138
%140 = call i32 @uc2bin(i8 signext %139, i8* %16)
br label %141
141: ; preds = %137
store i32 3, i32* %8
store i32 4, i32* %10
%142 = load i32, i32* @CHAR_BIT
%143 = sub nsw i32 %142, 1
store i32 %143, i32* %9
br label %144
144: ; preds = %157, %141
%145 = load i32, i32* %10
%146 = add nsw i32 %145, -1
store i32 %146, i32* %10
%147 = icmp ne i32 %145, 0
br i1 %147, label %148, label %162
148: ; preds = %144
%149 = load i32, i32* %9
%150 = sext i32 %149 to i64
%151 = getelementptr inbounds i8, i8* %16, i64 %150
%152 = load i8, i8* %151
%153 = load i32, i32* %8
%154 = sext i32 %153 to i64
%155 = getelementptr inbounds [4 x [7 x i8]], [4 x [7 x i8]]* %4, i64 0, i64 %154
%156 = getelementptr inbounds [7 x i8], [7 x i8]* %155, i64 0, i64 3
store i8 %152, i8* %156
br label %157
157: ; preds = %148
%158 = load i32, i32* %8
%159 = add nsw i32 %158, -1
store i32 %159, i32* %8
%160 = load i32, i32* %9
%161 = add nsw i32 %160, -1
store i32 %161, i32* %9
br label %144
162: ; preds = %144
br label %163
163: ; preds = %162
br label %164
164: ; preds = %163
%165 = getelementptr inbounds [512 x i8], [512 x i8]* %7, i64 0, i64 2
%166 = load i8, i8* %165
%167 = call i32 @uc2bin(i8 signext %166, i8* %16)
br label %168
168: ; preds = %164
store i32 3, i32* %8
store i32 3, i32* %10
%169 = load i32, i32* @CHAR_BIT
%170 = sub nsw i32 %169, 1
store i32 %170, i32* %9
br label %171
171: ; preds = %184, %168
%172 = load i32, i32* %10
%173 = add nsw i32 %172, -1
store i32 %173, i32* %10
%174 = icmp ne i32 %172, 0
br i1 %174, label %175, label %189
175: ; preds = %171
%176 = load i32, i32* %9
%177 = sext i32 %176 to i64
%178 = getelementptr inbounds i8, i8* %16, i64 %177
%179 = load i8, i8* %178
%180 = load i32, i32* %8
%181 = sext i32 %180 to i64
%182 = getelementptr inbounds [4 x [7 x i8]], [4 x [7 x i8]]* %4, i64 0, i64 %181
%183 = getelementptr inbounds [7 x i8], [7 x i8]* %182, i64 0, i64 2
store i8 %179, i8* %183
br label %184
184: ; preds = %175
%185 = load i32, i32* %8
%186 = add nsw i32 %185, -1
store i32 %186, i32* %8
%187 = load i32, i32* %9
%188 = add nsw i32 %187, -1
store i32 %188, i32* %9
br label %171
189: ; preds = %171
br label %190
190: ; preds = %189
br label %191
191: ; preds = %190
%192 = getelementptr inbounds [512 x i8], [512 x i8]* %7, i64 0, i64 5
%193 = load i8, i8* %192
%194 = call i32 @uc2bin(i8 signext %193, i8* %16)
br label %195
195: ; preds = %191
store i32 3, i32* %8
store i32 4, i32* %10
%196 = load i32, i32* @CHAR_BIT
%197 = sub nsw i32 %196, 1
store i32 %197, i32* %9
br label %198
198: ; preds = %211, %195
%199 = load i32, i32* %10
%200 = add nsw i32 %199, -1
store i32 %200, i32* %10
%201 = icmp ne i32 %199, 0
br i1 %201, label %202, label %216
202: ; preds = %198
%203 = load i32, i32* %9
%204 = sext i32 %203 to i64
%205 = getelementptr inbounds i8, i8* %16, i64 %204
%206 = load i8, i8* %205
%207 = load i32, i32* %8
%208 = sext i32 %207 to i64
%209 = getelementptr inbounds [4 x [7 x i8]], [4 x [7 x i8]]* %4, i64 0, i64 %208
%210 = getelementptr inbounds [7 x i8], [7 x i8]* %209, i64 0, i64 5
store i8 %206, i8* %210
br label %211
211: ; preds = %202
%212 = load i32, i32* %8
%213 = add nsw i32 %212, -1
store i32 %213, i32* %8
%214 = load i32, i32* %9
%215 = add nsw i32 %214, -1
store i32 %215, i32* %9
br label %198
216: ; preds = %198
br label %217
217: ; preds = %216
br label %218
218: ; preds = %217
%219 = getelementptr inbounds [512 x i8], [512 x i8]* %7, i64 0, i64 4
%220 = load i8, i8* %219
%221 = call i32 @uc2bin(i8 signext %220, i8* %16)
br label %222
222: ; preds = %218
store i32 3, i32* %8
store i32 3, i32* %10
%223 = load i32, i32* @CHAR_BIT
%224 = sub nsw i32 %223, 1
store i32 %224, i32* %9
br label %225
225: ; preds = %238, %222
%226 = load i32, i32* %10
%227 = add nsw i32 %226, -1
store i32 %227, i32* %10
%228 = icmp ne i32 %226, 0
br i1 %228, label %229, label %243
229: ; preds = %225
%230 = load i32, i32* %9
%231 = sext i32 %230 to i64
%232 = getelementptr inbounds i8, i8* %16, i64 %231
%233 = load i8, i8* %232
%234 = load i32, i32* %8
%235 = sext i32 %234 to i64
%236 = getelementptr inbounds [4 x [7 x i8]], [4 x [7 x i8]]* %4, i64 0, i64 %235
%237 = getelementptr inbounds [7 x i8], [7 x i8]* %236, i64 0, i64 4
store i8 %233, i8* %237
br label %238
238: ; preds = %229
%239 = load i32, i32* %8
%240 = add nsw i32 %239, -1
store i32 %240, i32* %8
%241 = load i32, i32* %9
%242 = add nsw i32 %241, -1
store i32 %242, i32* %9
br label %225
243: ; preds = %225
br label %244
244: ; preds = %243
br label %245
245: ; preds = %244
store i32 0, i32* %8
br label %246
246: ; preds = %261, %245
%247 = load i32, i32* %8
%248 = icmp slt i32 %247, 4
br i1 %248, label %249, label %264
249: ; preds = %246
%250 = load i32, i32* %8
%251 = add nsw i32 11, %250
%252 = call i32 @move(i32 %251, i32 31)
%253 = getelementptr inbounds [512 x i8], [512 x i8]* %7, i64 0, i64 0
%254 = load i32, i32* %8
%255 = sext i32 %254 to i64
%256 = getelementptr inbounds [4 x [7 x i8]], [4 x [7 x i8]]* %4, i64 0, i64 %255
%257 = getelementptr inbounds [7 x i8], [7 x i8]* %256, i64 0, i64 0
%258 = call i32 @sprintf(i8* %253, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.6, i64 0, i64 0), i8* %257)
%259 = getelementptr inbounds [512 x i8], [512 x i8]* %7, i64 0, i64 0
%260 = call i32 @addstr(i8* %259)
br label %261
261: ; preds = %249
%262 = load i32, i32* %8
%263 = add nsw i32 %262, 1
store i32 %263, i32* %8
br label %246
264: ; preds = %246
%265 = call i32 (...) @refresh()
%266 = call i32 @sleep(i32 1)
br label %57
}

LLVM IR (-O2):
%struct.tm = type { i32 }
@CHAR_BIT = global i32 0
@stdscr = global i32 0
@TRUE = global i32 0
@A_BOLD = global i32 0
@COLOR_YELLOW = global i32 0
@COLOR_BLACK = global i32 0
@.str = [42 x i8] c" 10000 100000 100000 10 10000 1000\00"
@.str.1 = [43 x i8] c" 00 00 00 00 00 00 0 00 00\00"
@.str.2 = [42 x i8] c" 00 00 00 00 00 00 000 0000\00"
@.str.3 = [45 x i8] c" 00001 000001 000001 0001 00001 00 001 \00"
@.str.4 = [32 x i8] c" ...:::Binary:Clock:::... \00"
@COLOR_BLUE = global i32 0
@COLOR_GREEN = global i32 0
@EXIT_FAILURE = global i32 0
@.str.5 = [7 x i8] c"%H%M%S\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca [4 x [7 x i8]]
%3 = alloca [512 x i8]
%4 = bitcast i32* %1 to i8*
%5 = getelementptr inbounds [4 x [7 x i8]], [4 x [7 x i8]]* %2, i64 0, i64 0, i64 0
%6 = load i32, i32* @CHAR_BIT
%7 = add nsw i32 %6, 1
%8 = zext i32 %7 to i64
%9 = alloca i8, i64 %8
%10 = getelementptr inbounds [512 x i8], [512 x i8]* %3, i64 0, i64 0
%11 = tail call i32 (...) @initscr()
%12 = tail call i32 (...) @cbreak()
%13 = tail call i32 (...) @clear()
%14 = load i32, i32* @stdscr
%15 = load i32, i32* @TRUE
%16 = tail call i32 @scrollok(i32 %14, i32 %15)
%17 = load i32, i32* @stdscr
%18 = load i32, i32* @TRUE
%19 = tail call i32 @idlok(i32 %17, i32 %18)
%20 = tail call i32 (...) @echo()
%21 = load i32, i32* @A_BOLD
%22 = tail call i32 @attrset(i32 %21)
%23 = load i32, i32* @stdscr
%24 = tail call i32 @box(i32 %23, i32 0, i32 0)
%25 = tail call i32 (...) @start_color()
%26 = load i32, i32* @COLOR_YELLOW
%27 = load i32, i32* @COLOR_BLACK
%28 = tail call i32 @init_pair(i32 2, i32 %26, i32 %27)
%29 = tail call i32 @COLOR_PAIR(i32 2)
%30 = load i32, i32* @A_BOLD
%31 = or i32 %30, %29
%32 = tail call i32 @attrset(i32 %31)
%33 = tail call i32 @mvprintw(i32 2, i32 17, i8* getelementptr inbounds ([42 x i8], [42 x i8]* @.str, i64 0, i64 0))
%34 = tail call i32 @mvprintw(i32 3, i32 17, i8* getelementptr inbounds ([43 x i8], [43 x i8]* @.str.1, i64 0, i64 0))
%35 = tail call i32 @mvprintw(i32 4, i32 17, i8* getelementptr inbounds ([42 x i8], [42 x i8]* @.str.2, i64 0, i64 0))
%36 = tail call i32 @mvprintw(i32 5, i32 17, i8* getelementptr inbounds ([43 x i8], [43 x i8]* @.str.1, i64 0, i64 0))
%37 = tail call i32 @mvprintw(i32 6, i32 17, i8* getelementptr inbounds ([45 x i8], [45 x i8]* @.str.3, i64 0, i64 0))
%38 = tail call i32 @mvprintw(i32 7, i32 17, i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.4, i64 0, i64 0))
%39 = load i32, i32* @COLOR_BLUE
%40 = load i32, i32* @COLOR_GREEN
%41 = tail call i32 @init_pair(i32 1, i32 %39, i32 %40)
%42 = tail call i32 @curs_set(i32 0)
%43 = getelementptr inbounds [4 x [7 x i8]], [4 x [7 x i8]]* %2, i64 0, i64 0, i64 4
store i8 32, i8* %43
%44 = getelementptr inbounds [4 x [7 x i8]], [4 x [7 x i8]]* %2, i64 0, i64 0, i64 2
store i8 32, i8* %44
%45 = getelementptr inbounds [4 x [7 x i8]], [4 x [7 x i8]]* %2, i64 0, i64 1, i64 0
store i8 32, i8* %45
store i8 32, i8* %5
%46 = call i32 @time(i32* %1)
%47 = call %struct.tm* @localtime(i32* %1)
%48 = icmp eq %struct.tm* %47, null
br i1 %48, label %75, label %49
49: ; preds = %0
%50 = getelementptr inbounds [512 x i8], [512 x i8]* %3, i64 0, i64 1
%51 = getelementptr inbounds [512 x i8], [512 x i8]* %3, i64 0, i64 3
%52 = getelementptr inbounds [512 x i8], [512 x i8]* %3, i64 0, i64 2
%53 = getelementptr inbounds [512 x i8], [512 x i8]* %3, i64 0, i64 5
%54 = getelementptr inbounds [512 x i8], [512 x i8]* %3, i64 0, i64 4
%55 = getelementptr inbounds [4 x [7 x i8]], [4 x [7 x i8]]* %2, i64 0, i64 3, i64 1
%56 = getelementptr inbounds [4 x [7 x i8]], [4 x [7 x i8]]* %2, i64 0, i64 2, i64 1
%57 = getelementptr inbounds [4 x [7 x i8]], [4 x [7 x i8]]* %2, i64 0, i64 1, i64 1
%58 = getelementptr inbounds [4 x [7 x i8]], [4 x [7 x i8]]* %2, i64 0, i64 0, i64 1
%59 = getelementptr inbounds [4 x [7 x i8]], [4 x [7 x i8]]* %2, i64 0, i64 3, i64 0
%60 = getelementptr inbounds [4 x [7 x i8]], [4 x [7 x i8]]* %2, i64 0, i64 2, i64 0
%61 = getelementptr inbounds [4 x [7 x i8]], [4 x [7 x i8]]* %2, i64 0, i64 3, i64 3
%62 = getelementptr inbounds [4 x [7 x i8]], [4 x [7 x i8]]* %2, i64 0, i64 2, i64 3
%63 = getelementptr inbounds [4 x [7 x i8]], [4 x [7 x i8]]* %2, i64 0, i64 1, i64 3
%64 = getelementptr inbounds [4 x [7 x i8]], [4 x [7 x i8]]* %2, i64 0, i64 0, i64 3
%65 = getelementptr inbounds [4 x [7 x i8]], [4 x [7 x i8]]* %2, i64 0, i64 3, i64 2
%66 = getelementptr inbounds [4 x [7 x i8]], [4 x [7 x i8]]* %2, i64 0, i64 2, i64 2
%67 = getelementptr inbounds [4 x [7 x i8]], [4 x [7 x i8]]* %2, i64 0, i64 1, i64 2
%68 = getelementptr inbounds [4 x [7 x i8]], [4 x [7 x i8]]* %2, i64 0, i64 3, i64 5
%69 = getelementptr inbounds [4 x [7 x i8]], [4 x [7 x i8]]* %2, i64 0, i64 2, i64 5
%70 = getelementptr inbounds [4 x [7 x i8]], [4 x [7 x i8]]* %2, i64 0, i64 1, i64 5
%71 = getelementptr inbounds [4 x [7 x i8]], [4 x [7 x i8]]* %2, i64 0, i64 0, i64 5
%72 = getelementptr inbounds [4 x [7 x i8]], [4 x [7 x i8]]* %2, i64 0, i64 3, i64 4
%73 = getelementptr inbounds [4 x [7 x i8]], [4 x [7 x i8]]* %2, i64 0, i64 2, i64 4
%74 = getelementptr inbounds [4 x [7 x i8]], [4 x [7 x i8]]* %2, i64 0, i64 1, i64 4
br label %78
75: ; preds = %78, %0
%76 = load i32, i32* @EXIT_FAILURE
%77 = call i32 @exit(i32 %76)
unreachable
78: ; preds = %49, %78
%79 = phi %struct.tm* [ %47, %49 ], [ %191, %78 ]
%80 = call i32 @strftime(i8* %10, i32 512, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.5, i64 0, i64 0), %struct.tm* %79)
%81 = load i8, i8* %10
%82 = add i8 %81, -48
store i8 %82, i8* %10
%83 = load i8, i8* %50
%84 = add i8 %83, -48
store i8 %84, i8* %50
%85 = load i8, i8* %52
%86 = add i8 %85, -48
store i8 %86, i8* %52
%87 = load i8, i8* %51
%88 = add i8 %87, -48
store i8 %88, i8* %51
%89 = load i8, i8* %54
%90 = add i8 %89, -48
store i8 %90, i8* %54
%91 = load i8, i8* %53
%92 = add i8 %91, -48
store i8 %92, i8* %53
%93 = call i32 @uc2bin(i8 signext %84, i8* %9)
%94 = load i32, i32* @CHAR_BIT
%95 = sext i32 %94 to i64
%96 = add nsw i64 %95, -1
%97 = getelementptr inbounds i8, i8* %9, i64 %96
%98 = load i8, i8* %97
store i8 %98, i8* %55
%99 = add nsw i64 %95, -2
%100 = getelementptr inbounds i8, i8* %9, i64 %99
%101 = load i8, i8* %100
store i8 %101, i8* %56
%102 = add nsw i64 %95, -3
%103 = getelementptr inbounds i8, i8* %9, i64 %102
%104 = load i8, i8* %103
store i8 %104, i8* %57
%105 = add nsw i64 %95, -4
%106 = getelementptr inbounds i8, i8* %9, i64 %105
%107 = load i8, i8* %106
store i8 %107, i8* %58
%108 = load i8, i8* %10
%109 = call i32 @uc2bin(i8 signext %108, i8* %9)
%110 = load i32, i32* @CHAR_BIT
%111 = sext i32 %110 to i64
%112 = add nsw i64 %111, -1
%113 = getelementptr inbounds i8, i8* %9, i64 %112
%114 = load i8, i8* %113
store i8 %114, i8* %59
%115 = add nsw i64 %111, -2
%116 = getelementptr inbounds i8, i8* %9, i64 %115
%117 = load i8, i8* %116
store i8 %117, i8* %60
%118 = load i8, i8* %51
%119 = call i32 @uc2bin(i8 signext %118, i8* %9)
%120 = load i32, i32* @CHAR_BIT
%121 = sext i32 %120 to i64
%122 = add nsw i64 %121, -1
%123 = getelementptr inbounds i8, i8* %9, i64 %122
%124 = load i8, i8* %123
store i8 %124, i8* %61
%125 = add nsw i64 %121, -2
%126 = getelementptr inbounds i8, i8* %9, i64 %125
%127 = load i8, i8* %126
store i8 %127, i8* %62
%128 = add nsw i64 %121, -3
%129 = getelementptr inbounds i8, i8* %9, i64 %128
%130 = load i8, i8* %129
store i8 %130, i8* %63
%131 = add nsw i64 %121, -4
%132 = getelementptr inbounds i8, i8* %9, i64 %131
%133 = load i8, i8* %132
store i8 %133, i8* %64
%134 = load i8, i8* %52
%135 = call i32 @uc2bin(i8 signext %134, i8* %9)
%136 = load i32, i32* @CHAR_BIT
%137 = sext i32 %136 to i64
%138 = add nsw i64 %137, -1
%139 = getelementptr inbounds i8, i8* %9, i64 %138
%140 = load i8, i8* %139
store i8 %140, i8* %65
%141 = add nsw i64 %137, -2
%142 = getelementptr inbounds i8, i8* %9, i64 %141
%143 = load i8, i8* %142
store i8 %143, i8* %66
%144 = add nsw i64 %137, -3
%145 = getelementptr inbounds i8, i8* %9, i64 %144
%146 = load i8, i8* %145
store i8 %146, i8* %67
%147 = load i8, i8* %53
%148 = call i32 @uc2bin(i8 signext %147, i8* %9)
%149 = load i32, i32* @CHAR_BIT
%150 = sext i32 %149 to i64
%151 = add nsw i64 %150, -1
%152 = getelementptr inbounds i8, i8* %9, i64 %151
%153 = load i8, i8* %152
store i8 %153, i8* %68
%154 = add nsw i64 %150, -2
%155 = getelementptr inbounds i8, i8* %9, i64 %154
%156 = load i8, i8* %155
store i8 %156, i8* %69
%157 = add nsw i64 %150, -3
%158 = getelementptr inbounds i8, i8* %9, i64 %157
%159 = load i8, i8* %158
store i8 %159, i8* %70
%160 = add nsw i64 %150, -4
%161 = getelementptr inbounds i8, i8* %9, i64 %160
%162 = load i8, i8* %161
store i8 %162, i8* %71
%163 = load i8, i8* %54
%164 = call i32 @uc2bin(i8 signext %163, i8* %9)
%165 = load i32, i32* @CHAR_BIT
%166 = sext i32 %165 to i64
%167 = add nsw i64 %166, -1
%168 = getelementptr inbounds i8, i8* %9, i64 %167
%169 = load i8, i8* %168
store i8 %169, i8* %72
%170 = add nsw i64 %166, -2
%171 = getelementptr inbounds i8, i8* %9, i64 %170
%172 = load i8, i8* %171
store i8 %172, i8* %73
%173 = add nsw i64 %166, -3
%174 = getelementptr inbounds i8, i8* %9, i64 %173
%175 = load i8, i8* %174
store i8 %175, i8* %74
%176 = call i32 @move(i32 11, i32 31)
%177 = call i8* @strcpy(i8* %10, i8* %5)
%178 = call i32 @addstr(i8* %10)
%179 = call i32 @move(i32 12, i32 31)
%180 = call i8* @strcpy(i8* %10, i8* %45)
%181 = call i32 @addstr(i8* %10)
%182 = call i32 @move(i32 13, i32 31)
%183 = call i8* @strcpy(i8* %10, i8* %60)
%184 = call i32 @addstr(i8* %10)
%185 = call i32 @move(i32 14, i32 31)
%186 = call i8* @strcpy(i8* %10, i8* %59)
%187 = call i32 @addstr(i8* %10)
%188 = call i32 (...) @refresh()
%189 = call i32 @sleep(i32 1)
%190 = call i32 @time(i32* %1)
%191 = call %struct.tm* @localtime(i32* %1)
%192 = icmp eq %struct.tm* %191, null
br i1 %192, label %75, label %78
}