#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*/ memset(char *, char, int);
char *make_time(unsigned long time) {
  static char buf[10];
  unsigned long hr, mn, sec, i0, i1, i2;
  time = (((999L * 3600 + 59L * 60 + 59L) < (time))
              ? (999L * 3600 + 59L * 60 + 59L)
              : (time));
  hr = time / 3600;
  mn = (time - hr * 3600) / 60;
  sec = time - hr * 3600 - mn * 60;
  if (hr != 0) {
    {
      i0 = hr / 100;
      i1 = (hr - i0 * 100) / 10;
      i2 = (hr - i0 * 100 - i1 * 10);
    };
    buf[0] = (i0 == 0) ? ' ' : '0' + i0;
    buf[1] = (i0 == 0 && i1 == 0) ? ' ' : '0' + i1;
    buf[2] = '0' + i2;
    buf[3] = ':';
  } else
    memset(buf, ' ', 4);
  {
    i0 = mn / 100;
    i1 = (mn - i0 * 100) / 10;
    i2 = (mn - i0 * 100 - i1 * 10);
  };
  buf[4] = (i1 + hr == 0) ? ' ' : '0' + i1;
  buf[5] = '0' + i2;
  buf[6] = ':';
  {
    i0 = sec / 100;
    i1 = (sec - i0 * 100) / 10;
    i2 = (sec - i0 * 100 - i1 * 10);
  };
  buf[7] = '0' + i1;
  buf[8] = '0' + i2;
  return buf;
}


x86 assembly (clang, -O0):
<make_time>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %rdi,-0x8(%rbp)
mov    $0x36ee7f,%eax
cmp    -0x8(%rbp),%rax
jae    1139 <make_time+0x29>
mov    $0x36ee7f,%eax
mov    %rax,-0x40(%rbp)
jmp    1141 <make_time+0x31>
mov    -0x8(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x40(%rbp),%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
mov    $0xe10,%ecx
xor    %edx,%edx
div    %rcx
mov    %rax,-0x10(%rbp)
mov    -0x8(%rbp),%rax
imul   $0xe10,-0x10(%rbp),%rcx
sub    %rcx,%rax
mov    $0x3c,%ecx
xor    %edx,%edx
div    %rcx
mov    %rax,-0x18(%rbp)
mov    -0x8(%rbp),%rax
imul   $0xe10,-0x10(%rbp),%rcx
sub    %rcx,%rax
imul   $0x3c,-0x18(%rbp),%rcx
sub    %rcx,%rax
mov    %rax,-0x20(%rbp)
cmpq   $0x0,-0x10(%rbp)
je     1265 <make_time+0x155>
mov    -0x10(%rbp),%rax
mov    $0x64,%ecx
xor    %edx,%edx
div    %rcx
mov    %rax,-0x28(%rbp)
mov    -0x10(%rbp),%rax
imul   $0x64,-0x28(%rbp),%rcx
sub    %rcx,%rax
mov    $0xa,%ecx
xor    %edx,%edx
div    %rcx
mov    %rax,-0x30(%rbp)
mov    -0x10(%rbp),%rax
imul   $0x64,-0x28(%rbp),%rcx
sub    %rcx,%rax
imul   $0xa,-0x30(%rbp),%rcx
sub    %rcx,%rax
mov    %rax,-0x38(%rbp)
cmpq   $0x0,-0x28(%rbp)
jne    11fb <make_time+0xeb>
mov    $0x20,%eax
mov    %rax,-0x48(%rbp)
jmp    1207 <make_time+0xf7>
mov    -0x28(%rbp),%rax
add    $0x30,%rax
mov    %rax,-0x48(%rbp)
mov    -0x48(%rbp),%rax
mov    %al,0x2e18(%rip)
cmpq   $0x0,-0x28(%rbp)
jne    1235 <make_time+0x125>
cmpq   $0x0,-0x30(%rbp)
jne    1235 <make_time+0x125>
mov    $0x20,%eax
mov    %rax,-0x50(%rbp)
jmp    1241 <make_time+0x131>
mov    -0x30(%rbp),%rax
add    $0x30,%rax
mov    %rax,-0x50(%rbp)
mov    -0x50(%rbp),%rax
mov    %al,0x2ddf(%rip)
mov    -0x38(%rbp),%rax
add    $0x30,%rax
mov    %al,0x2dd2(%rip)
movb   $0x3a,0x2dcc(%rip)
jmp    127b <make_time+0x16b>
lea    0x2dbd(%rip),%rdi
mov    $0x20,%esi
mov    $0x4,%edx
call   1030 <memset@plt>
mov    -0x18(%rbp),%rax
mov    $0x64,%ecx
xor    %edx,%edx
div    %rcx
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
imul   $0x64,-0x28(%rbp),%rcx
sub    %rcx,%rax
mov    $0xa,%ecx
xor    %edx,%edx
div    %rcx
mov    %rax,-0x30(%rbp)
mov    -0x18(%rbp),%rax
imul   $0x64,-0x28(%rbp),%rcx
sub    %rcx,%rax
imul   $0xa,-0x30(%rbp),%rcx
sub    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x30(%rbp),%rax
add    -0x10(%rbp),%rax
cmp    $0x0,%rax
jne    12df <make_time+0x1cf>
mov    $0x20,%eax
mov    %rax,-0x58(%rbp)
jmp    12eb <make_time+0x1db>
mov    -0x30(%rbp),%rax
add    $0x30,%rax
mov    %rax,-0x58(%rbp)
mov    -0x58(%rbp),%rax
mov    %al,0x2d38(%rip)
mov    -0x38(%rbp),%rax
add    $0x30,%rax
mov    %al,0x2d2b(%rip)
movb   $0x3a,0x2d25(%rip)
mov    -0x20(%rbp),%rax
mov    $0x64,%ecx
xor    %edx,%edx
div    %rcx
mov    %rax,-0x28(%rbp)
mov    -0x20(%rbp),%rax
imul   $0x64,-0x28(%rbp),%rcx
sub    %rcx,%rax
mov    $0xa,%ecx
xor    %edx,%edx
div    %rcx
mov    %rax,-0x30(%rbp)
mov    -0x20(%rbp),%rax
imul   $0x64,-0x28(%rbp),%rcx
sub    %rcx,%rax
imul   $0xa,-0x30(%rbp),%rcx
sub    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x30(%rbp),%rax
add    $0x30,%rax
mov    %al,0x2cd4(%rip)
mov    -0x38(%rbp),%rax
add    $0x30,%rax
mov    %al,0x2cc7(%rip)
lea    0x2cb8(%rip),%rax
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<make_time>:
push   %r15
push   %r14
push   %r12
push   %rbx
push   %rax
cmp    $0x36ee7f,%rdi
mov    $0x36ee7f,%esi
cmovb  %rdi,%rsi
mov    %esi,%eax
mov    $0x91a2b3c5,%r15d
imul   %rax,%r15
shr    $0x2b,%r15
imul   $0xfffffffffffff1f0,%r15,%rbx
add    %rsi,%rbx
movabs $0x8888888888888889,%rcx
88 88 88
mov    %rbx,%rax
mul    %rcx
mov    %rdx,%r14
shr    $0x5,%r14
movabs $0xcccccccccccccccd,%r12
cc cc cc
cmp    $0xe10,%rsi
jae    1184 <make_time+0x74>
lea    0x2eb6(%rip),%rdi
mov    $0x20,%esi
mov    $0x4,%edx
call   1030 <memset@plt>
jmp    11f9 <make_time+0xe9>
mov    %esi,%eax
shr    $0x6,%eax
imul   $0x2e9a77,%rax,%rdi
shr    $0x22,%rdi
imul   $0xffffffffffffff9c,%rdi,%rcx
add    %r15,%rcx
mov    %rcx,%rax
mul    %r12
shr    $0x3,%rdx
lea    (%rdx,%rdx,1),%eax
lea    (%rax,%rax,4),%r8d
mov    %ecx,%eax
sub    %r8d,%eax
or     $0x30,%dil
add    $0x30,%dl
cmp    $0xa,%rcx
movzbl %dl,%edx
mov    $0x20,%r8d
mov    %edx,%ecx
cmovb  %r8d,%ecx
cmp    $0x57e40,%rsi
movzbl %dil,%esi
cmovb  %r8d,%esi
mov    %sil,0x2e48(%rip)
cmovae %edx,%ecx
mov    %cl,0x2e40(%rip)
add    $0x30,%al
mov    %al,0x2e39(%rip)
movb   $0x3a,0x2e33(%rip)
imul   $0xffffffffffffffc4,%r14,%rdi
add    %rbx,%rdi
movabs $0xaec33e1f671529a5,%rcx
3e c3 ae
mov    %rbx,%rax
mul    %rcx
shr    $0xc,%rdx
imul   $0xffffffffffffff9c,%rdx,%rsi
add    %r14,%rsi
mov    %rsi,%rax
mul    %r12
shr    $0x3,%rdx
lea    (%rdx,%rdx,1),%eax
lea    (%rax,%rax,4),%eax
sub    %eax,%esi
lea    0x30(%rdx),%eax
add    %r15,%rdx
movzbl %al,%eax
mov    $0x20,%ecx
cmovne %eax,%ecx
mov    %cl,0x2de9(%rip)
lea    0x2dde(%rip),%rcx
add    $0x30,%sil
mov    %sil,0x2dd8(%rip)
movb   $0x3a,0x2dd2(%rip)
mov    %rdi,%rax
shr    $0x2,%rax
movabs $0x28f5c28f5c28f5c3,%rdx
c2 f5 28
mul    %rdx
shr    $0x2,%rdx
imul   $0x64,%edx,%eax
sub    %eax,%edi
imul   $0xcd,%edi,%eax
movzwl %ax,%eax
shr    $0xb,%eax
mov    %eax,%edx
add    %edx,%edx
lea    (%rdx,%rdx,4),%edx
sub    %edx,%edi
or     $0x30,%al
mov    %al,0x2d99(%rip)
add    $0x30,%dil
mov    %dil,0x2d8f(%rip)
mov    %rcx,%rax
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
ret

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

LLVM IR (-O2):
@make_time.buf = internal global [10 x i8] zeroinitializer
define i8* @make_time(i64 %0) {
%2 = icmp ult i64 %0, 3599999
%3 = select i1 %2, i64 %0, i64 3599999
%4 = trunc i64 %3 to i32
%5 = udiv i32 %4, 3600
%6 = zext i32 %5 to i64
%7 = mul nsw i64 %6, -3600
%8 = add nsw i64 %7, %3
%9 = udiv i64 %8, 60
%10 = icmp ult i64 %3, 3600
br i1 %10, label %30, label %11
11: ; preds = %1
%12 = udiv i32 %4, 360000
%13 = zext i32 %12 to i64
%14 = mul nsw i64 %13, -100
%15 = add nsw i64 %14, %6
%16 = udiv i64 %15, 10
%17 = mul i64 %16, -10
%18 = add i64 %17, %15
%19 = icmp ult i64 %3, 360000
%20 = trunc i32 %12 to i8
%21 = or i8 %20, 48
%22 = select i1 %19, i8 32, i8 %21
store i8 %22, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @make_time.buf, i64 0, i64 0)
%23 = icmp ult i64 %15, 10
%24 = select i1 %19, i1 %23, i1 false
%25 = trunc i64 %16 to i8
%26 = add i8 %25, 48
%27 = select i1 %24, i8 32, i8 %26
store i8 %27, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @make_time.buf, i64 0, i64 1)
%28 = trunc i64 %18 to i8
%29 = add i8 %28, 48
store i8 %29, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @make_time.buf, i64 0, i64 2)
store i8 58, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @make_time.buf, i64 0, i64 3)
br label %32
30: ; preds = %1
%31 = tail call i32 @memset(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @make_time.buf, i64 0, i64 0), i8 signext 32, i32 4)
br label %32
32: ; preds = %30, %11
%33 = mul i64 %9, -60
%34 = add i64 %33, %8
%35 = udiv i64 %8, 6000
%36 = mul nsw i64 %35, -100
%37 = add nsw i64 %36, %9
%38 = udiv i64 %37, 10
%39 = mul i64 %38, -10
%40 = add i64 %39, %37
%41 = sub nsw i64 0, %6
%42 = icmp eq i64 %38, %41
%43 = trunc i64 %38 to i8
%44 = add i8 %43, 48
%45 = select i1 %42, i8 32, i8 %44
store i8 %45, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @make_time.buf, i64 0, i64 4)
%46 = trunc i64 %40 to i8
%47 = add i8 %46, 48
store i8 %47, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @make_time.buf, i64 0, i64 5)
store i8 58, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @make_time.buf, i64 0, i64 6)
%48 = urem i64 %34, 100
%49 = trunc i64 %48 to i8
%50 = udiv i8 %49, 10
%51 = zext i8 %50 to i64
%52 = mul nsw i64 %51, -10
%53 = add nsw i64 %52, %48
%54 = or i8 %50, 48
store i8 %54, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @make_time.buf, i64 0, i64 7)
%55 = trunc i64 %53 to i8
%56 = add i8 %55, 48
store i8 %56, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @make_time.buf, i64 0, i64 8)
ret i8* getelementptr inbounds ([10 x i8], [10 x i8]* @make_time.buf, i64 0, i64 0)
}