#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 */
double DBL_MAX;
double FLT_MAX;
int INT_MAX;
int INT_MIN;
int /*<<< orphan*/ LONG_MAX;
int /*<<< orphan*/ LONG_MIN;
int SCHAR_MAX;
int SCHAR_MIN;
int SHRT_MAX;
int SHRT_MIN;
int UCHAR_MAX;
int UINT_MAX;
int /*<<< orphan*/ ULONG_MAX;
int USHRT_MAX;
int /*<<< orphan*/ printf(char *, ...);
int main() {
  unsigned char uc;
  signed char sc;
  unsigned short us;
  signed short ss;
  unsigned int ui;
  signed int si;
  unsigned long ul;
  signed long sl;
  unsigned long long ull;
  signed long long sll;
  float fl, fla, fll;
  double db, dba, dbl;
  long double ldb, ldba, ldbl;
  printf("Let's compute the minimums and maximums of each type!\n");
  uc = sc = us = ss = ui = si = ul = sl = sll = ull = 0;
  fl = fla = fll = db = dba = dbl = ldb = ldba = ldbl = 0.0;
  sc++;
  while (sc * 2 > sc) {
    sc = sc * 2 + 1;
  }
  printf("`signed char` maximum: %d\n", sc);
  sc++;
  printf("`signed char` minimum: %d\n", sc);
  uc--;
  printf("`unsigned char` maximum: %u\n", uc);
  ss++;
  while (ss * 2 > ss) {
    ss = ss * 2 + 1;
  }
  printf("`signed short` maximum: %d\n", ss);
  ss++;
  printf("`signed short` minimum: %d\n", ss);
  us--;
  printf("`unsigned short` maximum: %u\n", us);
  si++;
  while (si * 2 > si) {
    si = si * 2 + 1;
  }
  printf("`signed int` maximum: %d\n", si);
  si++;
  printf("`signed int` minimum: %d\n", si);
  ui--;
  printf("`unsigned int` maximum: %u\n", ui);
  sl++;
  while (sl * 2 > sl) {
    sl = sl * 2 + 1;
  }
  printf("`signed long` maximum: %li\n", sl);
  sl++;
  printf("`signed long` minimum: %li\n", sl);
  ul--;
  printf("`unsigned long` maximum: %lu\n", ul);
  sll++;
  while (sll * 2 > sll) {
    sll = sll * 2 + 1;
  }
  printf("`signed long long` maximum: %lli\n", sll);
  sll++;
  printf("`signed long long` minimum: %lli\n", sll);
  ull--;
  printf("`unsigned long long` maximum: %llu\n", ull);
  while (fl == 0.0) {
    fll = fla;
    fla = fla + 1111e28;
    fl = (fl + fla) - fla;
  }
  printf("`float` maximum: %e\n", fll);
  printf("`float` minimum: %e\n", 0 - fll);
  while (db == 0.0) {
    dbl = dba;
    dba = dba + 1111e297;
    db = (db + dba) - dba;
  }
  printf("`double` maximum: %e\n", dbl);
  printf("`double` minimum: %e\n", 0 - dbl);
  printf("\nNow, let's cheat and use the helpful headers!\n");
  printf("`char`s go from %d to %d (unsigned, up to %u)\n", SCHAR_MIN,
         SCHAR_MAX, UCHAR_MAX);
  printf("`short`s go from %d to %d (unsigned, up to %u)\n", SHRT_MIN, SHRT_MAX,
         USHRT_MAX);
  printf("`int`s go from %d to %d (unsigned, up to %u)\n", INT_MIN, INT_MAX,
         UINT_MAX);
  printf("`long`s go from %ld to %ld (unsigned, up to %lu)\n", LONG_MIN,
         LONG_MAX, ULONG_MAX);
  printf("`float`s range from %e to %e\n", 0.0 - FLT_MAX, FLT_MAX);
  printf("`double`s range from %e to %e\n", 0.0 - DBL_MAX, DBL_MAX);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
movl   $0x0,-0x4(%rbp)
lea    0xee7(%rip),%rdi
xor    %eax,%eax
call   1030 <printf@plt>
movq   $0x0,-0x30(%rbp)
movq   $0x0,-0x38(%rbp)
movq   $0x0,-0x28(%rbp)
movq   $0x0,-0x20(%rbp)
movl   $0x0,-0x14(%rbp)
movl   $0x0,-0x10(%rbp)
movw   $0x0,-0xa(%rbp)
movw   $0x0,-0x8(%rbp)
movb   $0x0,-0x6(%rbp)
movb   $0x0,-0x5(%rbp)
fldz
fld    %st(0)
fstpt  -0x90(%rbp)
fld    %st(0)
fstpt  -0x80(%rbp)
fstpt  -0x70(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x60(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x58(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x44(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x40(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x6(%rbp),%al
add    $0x1,%al
mov    %al,-0x6(%rbp)
movsbl -0x6(%rbp),%eax
shl    $0x1,%eax
movsbl -0x6(%rbp),%ecx
cmp    %ecx,%eax
jle    11e1 <main+0xd1>
movsbl -0x6(%rbp),%eax
shl    $0x1,%eax
add    $0x1,%eax
mov    %al,-0x6(%rbp)
jmp    11bc <main+0xac>
movsbl -0x6(%rbp),%esi
lea    0xe5b(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x6(%rbp),%al
add    $0x1,%al
mov    %al,-0x6(%rbp)
movsbl -0x6(%rbp),%esi
lea    0xe5c(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x5(%rbp),%al
add    $0xff,%al
mov    %al,-0x5(%rbp)
movzbl -0x5(%rbp),%esi
lea    0xe5d(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0xa(%rbp),%ax
add    $0x1,%ax
mov    %ax,-0xa(%rbp)
movswl -0xa(%rbp),%eax
shl    $0x1,%eax
movswl -0xa(%rbp),%ecx
cmp    %ecx,%eax
jle    1259 <main+0x149>
movswl -0xa(%rbp),%eax
shl    $0x1,%eax
add    $0x1,%eax
mov    %ax,-0xa(%rbp)
jmp    1233 <main+0x123>
movswl -0xa(%rbp),%esi
lea    0xe36(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0xa(%rbp),%ax
add    $0x1,%ax
mov    %ax,-0xa(%rbp)
movswl -0xa(%rbp),%esi
lea    0xe34(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x8(%rbp),%ax
add    $0xffff,%ax
mov    %ax,-0x8(%rbp)
movzwl -0x8(%rbp),%esi
lea    0xe32(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x1,%eax
cmp    -0x14(%rbp),%eax
jle    12d0 <main+0x1c0>
mov    -0x14(%rbp),%eax
shl    $0x1,%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    12b0 <main+0x1a0>
mov    -0x14(%rbp),%esi
lea    0xe16(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%esi
lea    0xe16(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x10(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x10(%rbp)
mov    -0x10(%rbp),%esi
lea    0xe16(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rax
shl    $0x1,%rax
cmp    -0x28(%rbp),%rax
jle    1348 <main+0x238>
mov    -0x28(%rbp),%rax
shl    $0x1,%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
jmp    1321 <main+0x211>
mov    -0x28(%rbp),%rsi
lea    0xded(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rsi
lea    0xdeb(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x20(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rsi
lea    0xde9(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rax
shl    $0x1,%rax
cmp    -0x38(%rbp),%rax
jle    13c9 <main+0x2b9>
mov    -0x38(%rbp),%rax
shl    $0x1,%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    13a2 <main+0x292>
mov    -0x38(%rbp),%rsi
lea    0xdc2(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rsi
lea    0xdc6(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x30(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rsi
lea    0xdca(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movss  -0x3c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1474 <main+0x364>
jp     1474 <main+0x364>
movss  -0x40(%rbp),%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x40(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xbba(%rip),%xmm1
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x3c(%rbp),%xmm0
addss  -0x40(%rbp),%xmm0
subss  -0x40(%rbp),%xmm0
movss  %xmm0,-0x3c(%rbp)
jmp    1417 <main+0x307>
movss  -0x44(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xd7a(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
xorps  %xmm0,%xmm0
subss  -0x44(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xd75(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
movsd  -0x50(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    14f2 <main+0x3e2>
jp     14f2 <main+0x3e2>
movsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  0xb31(%rip),%xmm0
addsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x50(%rbp),%xmm0
addsd  -0x58(%rbp),%xmm0
subsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
jmp    14a5 <main+0x395>
movsd  -0x60(%rbp),%xmm0
lea    0xd2a(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
xorps  %xmm0,%xmm0
subsd  -0x60(%rbp),%xmm0
lea    0xd2a(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
lea    0xd32(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    0x2a78(%rip),%rax
mov    (%rax),%esi
mov    0x2a67(%rip),%rax
mov    (%rax),%edx
mov    0x2aae(%rip),%rax
mov    (%rax),%ecx
lea    0xd39(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    0x2a37(%rip),%rax
mov    (%rax),%esi
mov    0x2a26(%rip),%rax
mov    (%rax),%edx
mov    0x2a75(%rip),%rax
mov    (%rax),%ecx
lea    0xd3f(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    0x2a3e(%rip),%rax
mov    (%rax),%esi
mov    0x2a4d(%rip),%rax
mov    (%rax),%edx
mov    0x2a3c(%rip),%rax
mov    (%rax),%ecx
lea    0xd46(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    0x2a1d(%rip),%rax
mov    (%rax),%esi
mov    0x29e4(%rip),%rax
mov    (%rax),%edx
mov    0x29b3(%rip),%rax
mov    (%rax),%ecx
lea    0xd4b(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
xorps  %xmm0,%xmm0
mov    0x29e1(%rip),%rax
subsd  (%rax),%xmm0
mov    0x29d6(%rip),%rax
movsd  (%rax),%xmm1
lea    0xd56(%rip),%rdi
mov    $0x2,%al
call   1030 <printf@plt>
xorps  %xmm0,%xmm0
mov    0x2982(%rip),%rax
subsd  (%rax),%xmm0
mov    0x2977(%rip),%rax
movsd  (%rax),%xmm1
lea    0xd4d(%rip),%rdi
mov    $0x2,%al
call   1030 <printf@plt>
xor    %eax,%eax
add    $0x90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %r14
push   %rbx
push   %rax
lea    0x11ee(%rip),%rdi
call   1030 <puts@plt>
lea    0xed9(%rip),%rdi
mov    $0xffffffff,%esi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xee1(%rip),%rdi
xor    %esi,%esi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xeec(%rip),%rdi
mov    $0xff,%esi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xef6(%rip),%rdi
mov    $0xffffffff,%esi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xeff(%rip),%rdi
xor    %esi,%esi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xf0b(%rip),%rdi
mov    $0xffff,%esi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xf16(%rip),%rdi
mov    $0x7fffffff,%esi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xf1d(%rip),%rdi
mov    $0x80000000,%esi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xf24(%rip),%rdi
mov    $0xffffffff,%esi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xf2d(%rip),%rdi
movabs $0x7fffffffffffffff,%r14
ff ff 7f
mov    %r14,%rsi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0x1(%r14),%rbx
lea    0xf2a(%rip),%rdi
mov    %rbx,%rsi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xf35(%rip),%rdi
mov    $0xffffffffffffffff,%rsi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xf3e(%rip),%rdi
mov    %r14,%rsi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xf4f(%rip),%rdi
mov    %rbx,%rsi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xf60(%rip),%rdi
mov    $0xffffffffffffffff,%rsi
xor    %eax,%eax
call   1040 <printf@plt>
xorps  %xmm1,%xmm1
movsd  0xda4(%rip),%xmm2
xorps  %xmm4,%xmm4
xorps  %xmm3,%xmm3
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movaps %xmm4,%xmm5
xorps  %xmm0,%xmm0
cvtss2sd %xmm4,%xmm0
movaps %xmm0,%xmm4
addsd  %xmm2,%xmm4
cvtsd2ss %xmm4,%xmm4
addss  %xmm4,%xmm3
subss  %xmm4,%xmm3
ucomiss %xmm1,%xmm3
jne    1294 <main+0x174>
jnp    1270 <main+0x150>
lea    0xf2c(%rip),%rdi
mov    $0x1,%al
movss  %xmm5,(%rsp)
call   1040 <printf@plt>
xorps  %xmm0,%xmm0
subss  (%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xf22(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
xorps  %xmm4,%xmm4
movsd  0xd3c(%rip),%xmm1
xorpd  %xmm2,%xmm2
xorps  %xmm3,%xmm3
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movapd %xmm2,%xmm0
addsd  %xmm1,%xmm2
addsd  %xmm2,%xmm3
subsd  %xmm2,%xmm3
ucomisd %xmm4,%xmm3
jne    12f8 <main+0x1d8>
jnp    12e0 <main+0x1c0>
lea    0xef2(%rip),%rdi
mov    $0x1,%al
movsd  %xmm0,(%rsp)
call   1040 <printf@plt>
xorps  %xmm0,%xmm0
subsd  (%rsp),%xmm0
lea    0xeed(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
lea    0x1027(%rip),%rdi
call   1030 <puts@plt>
mov    0x2c74(%rip),%rax
mov    (%rax),%esi
mov    0x2c63(%rip),%rax
mov    (%rax),%edx
mov    0x2caa(%rip),%rax
mov    (%rax),%ecx
lea    0xece(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x2c33(%rip),%rax
mov    (%rax),%esi
mov    0x2c22(%rip),%rax
mov    (%rax),%edx
mov    0x2c71(%rip),%rax
mov    (%rax),%ecx
lea    0xed4(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x2c3a(%rip),%rax
mov    (%rax),%esi
mov    0x2c49(%rip),%rax
mov    (%rax),%edx
mov    0x2c38(%rip),%rax
mov    (%rax),%ecx
lea    0xedb(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x2c19(%rip),%rax
mov    (%rax),%esi
mov    0x2be0(%rip),%rax
mov    (%rax),%edx
mov    0x2baf(%rip),%rax
mov    (%rax),%ecx
lea    0xee0(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x2be0(%rip),%rax
movsd  (%rax),%xmm1
xorpd  %xmm0,%xmm0
subsd  %xmm1,%xmm0
lea    0xef1(%rip),%rdi
mov    $0x2,%al
call   1040 <printf@plt>
mov    0x2b87(%rip),%rax
movsd  (%rax),%xmm1
xorpd  %xmm0,%xmm0
subsd  %xmm1,%xmm0
lea    0xeee(%rip),%rdi
mov    $0x2,%al
call   1040 <printf@plt>
xor    %eax,%eax
add    $0x8,%rsp
pop    %rbx
pop    %r14
ret

LLVM IR (-O0):
@.str = [55 x i8] c"Let's compute the minimums and maximums of each type!\0A\00"
@.str.1 = [27 x i8] c"`signed char` maximum: %d\0A\00"
@.str.2 = [27 x i8] c"`signed char` minimum: %d\0A\00"
@.str.3 = [29 x i8] c"`unsigned char` maximum: %u\0A\00"
@.str.4 = [28 x i8] c"`signed short` maximum: %d\0A\00"
@.str.5 = [28 x i8] c"`signed short` minimum: %d\0A\00"
@.str.6 = [30 x i8] c"`unsigned short` maximum: %u\0A\00"
@.str.7 = [26 x i8] c"`signed int` maximum: %d\0A\00"
@.str.8 = [26 x i8] c"`signed int` minimum: %d\0A\00"
@.str.9 = [28 x i8] c"`unsigned int` maximum: %u\0A\00"
@.str.10 = [28 x i8] c"`signed long` maximum: %li\0A\00"
@.str.11 = [28 x i8] c"`signed long` minimum: %li\0A\00"
@.str.12 = [30 x i8] c"`unsigned long` maximum: %lu\0A\00"
@.str.13 = [34 x i8] c"`signed long long` maximum: %lli\0A\00"
@.str.14 = [34 x i8] c"`signed long long` minimum: %lli\0A\00"
@.str.15 = [36 x i8] c"`unsigned long long` maximum: %llu\0A\00"
@.str.16 = [21 x i8] c"`float` maximum: %e\0A\00"
@.str.17 = [21 x i8] c"`float` minimum: %e\0A\00"
@.str.18 = [22 x i8] c"`double` maximum: %e\0A\00"
@.str.19 = [22 x i8] c"`double` minimum: %e\0A\00"
@.str.20 = [48 x i8] c"\0ANow, let's cheat and use the helpful headers!\0A\00"
@.str.21 = [47 x i8] c"`char`s go from %d to %d (unsigned, up to %u)\0A\00"
@SCHAR_MIN = global i32 0
@SCHAR_MAX = global i32 0
@UCHAR_MAX = global i32 0
@.str.22 = [48 x i8] c"`short`s go from %d to %d (unsigned, up to %u)\0A\00"
@SHRT_MIN = global i32 0
@SHRT_MAX = global i32 0
@USHRT_MAX = global i32 0
@.str.23 = [46 x i8] c"`int`s go from %d to %d (unsigned, up to %u)\0A\00"
@INT_MIN = global i32 0
@INT_MAX = global i32 0
@UINT_MAX = global i32 0
@.str.24 = [50 x i8] c"`long`s go from %ld to %ld (unsigned, up to %lu)\0A\00"
@LONG_MIN = global i32 0
@LONG_MAX = global i32 0
@ULONG_MAX = global i32 0
@.str.25 = [30 x i8] c"`float`s range from %e to %e\0A\00"
@FLT_MAX = global double 0.000000e+00
@.str.26 = [31 x i8] c"`double`s range from %e to %e\0A\00"
@DBL_MAX = global double 0.000000e+00
define i32 @main() {
%1 = alloca i32
%2 = alloca i8
%3 = alloca i8
%4 = alloca i16
%5 = alloca i16
%6 = alloca i32
%7 = alloca i32
%8 = alloca i64
%9 = alloca i64
%10 = alloca i64
%11 = alloca i64
%12 = alloca float
%13 = alloca float
%14 = alloca float
%15 = alloca double
%16 = alloca double
%17 = alloca double
%18 = alloca x86_fp80
%19 = alloca x86_fp80
%20 = alloca x86_fp80
store i32 0, i32* %1
%21 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([55 x i8], [55 x i8]* @.str, i64 0, i64 0))
store i64 0, i64* %10
store i64 0, i64* %11
store i64 0, i64* %9
store i64 0, i64* %8
store i32 0, i32* %7
store i32 0, i32* %6
store i16 0, i16* %5
store i16 0, i16* %4
store i8 0, i8* %3
store i8 0, i8* %2
store x86_fp80 0xK00000000000000000000, x86_fp80* %20
store x86_fp80 0xK00000000000000000000, x86_fp80* %19
store x86_fp80 0xK00000000000000000000, x86_fp80* %18
store double 0.000000e+00, double* %17
store double 0.000000e+00, double* %16
store double 0.000000e+00, double* %15
store float 0.000000e+00, float* %14
store float 0.000000e+00, float* %13
store float 0.000000e+00, float* %12
%22 = load i8, i8* %3
%23 = add i8 %22, 1
store i8 %23, i8* %3
br label %24
24: ; preds = %31, %0
%25 = load i8, i8* %3
%26 = sext i8 %25 to i32
%27 = mul nsw i32 %26, 2
%28 = load i8, i8* %3
%29 = sext i8 %28 to i32
%30 = icmp sgt i32 %27, %29
br i1 %30, label %31, label %37
31: ; preds = %24
%32 = load i8, i8* %3
%33 = sext i8 %32 to i32
%34 = mul nsw i32 %33, 2
%35 = add nsw i32 %34, 1
%36 = trunc i32 %35 to i8
store i8 %36, i8* %3
br label %24
37: ; preds = %24
%38 = load i8, i8* %3
%39 = sext i8 %38 to i32
%40 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.str.1, i64 0, i64 0), i32 %39)
%41 = load i8, i8* %3
%42 = add i8 %41, 1
store i8 %42, i8* %3
%43 = load i8, i8* %3
%44 = sext i8 %43 to i32
%45 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.str.2, i64 0, i64 0), i32 %44)
%46 = load i8, i8* %2
%47 = add i8 %46, -1
store i8 %47, i8* %2
%48 = load i8, i8* %2
%49 = zext i8 %48 to i32
%50 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.3, i64 0, i64 0), i32 %49)
%51 = load i16, i16* %5
%52 = add i16 %51, 1
store i16 %52, i16* %5
br label %53
53: ; preds = %60, %37
%54 = load i16, i16* %5
%55 = sext i16 %54 to i32
%56 = mul nsw i32 %55, 2
%57 = load i16, i16* %5
%58 = sext i16 %57 to i32
%59 = icmp sgt i32 %56, %58
br i1 %59, label %60, label %66
60: ; preds = %53
%61 = load i16, i16* %5
%62 = sext i16 %61 to i32
%63 = mul nsw i32 %62, 2
%64 = add nsw i32 %63, 1
%65 = trunc i32 %64 to i16
store i16 %65, i16* %5
br label %53
66: ; preds = %53
%67 = load i16, i16* %5
%68 = sext i16 %67 to i32
%69 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str.4, i64 0, i64 0), i32 %68)
%70 = load i16, i16* %5
%71 = add i16 %70, 1
store i16 %71, i16* %5
%72 = load i16, i16* %5
%73 = sext i16 %72 to i32
%74 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str.5, i64 0, i64 0), i32 %73)
%75 = load i16, i16* %4
%76 = add i16 %75, -1
store i16 %76, i16* %4
%77 = load i16, i16* %4
%78 = zext i16 %77 to i32
%79 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str.6, i64 0, i64 0), i32 %78)
%80 = load i32, i32* %7
%81 = add nsw i32 %80, 1
store i32 %81, i32* %7
br label %82
82: ; preds = %87, %66
%83 = load i32, i32* %7
%84 = mul nsw i32 %83, 2
%85 = load i32, i32* %7
%86 = icmp sgt i32 %84, %85
br i1 %86, label %87, label %91
87: ; preds = %82
%88 = load i32, i32* %7
%89 = mul nsw i32 %88, 2
%90 = add nsw i32 %89, 1
store i32 %90, i32* %7
br label %82
91: ; preds = %82
%92 = load i32, i32* %7
%93 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str.7, i64 0, i64 0), i32 %92)
%94 = load i32, i32* %7
%95 = add nsw i32 %94, 1
store i32 %95, i32* %7
%96 = load i32, i32* %7
%97 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str.8, i64 0, i64 0), i32 %96)
%98 = load i32, i32* %6
%99 = add i32 %98, -1
store i32 %99, i32* %6
%100 = load i32, i32* %6
%101 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str.9, i64 0, i64 0), i32 %100)
%102 = load i64, i64* %9
%103 = add nsw i64 %102, 1
store i64 %103, i64* %9
br label %104
104: ; preds = %109, %91
%105 = load i64, i64* %9
%106 = mul nsw i64 %105, 2
%107 = load i64, i64* %9
%108 = icmp sgt i64 %106, %107
br i1 %108, label %109, label %113
109: ; preds = %104
%110 = load i64, i64* %9
%111 = mul nsw i64 %110, 2
%112 = add nsw i64 %111, 1
store i64 %112, i64* %9
br label %104
113: ; preds = %104
%114 = load i64, i64* %9
%115 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str.10, i64 0, i64 0), i64 %114)
%116 = load i64, i64* %9
%117 = add nsw i64 %116, 1
store i64 %117, i64* %9
%118 = load i64, i64* %9
%119 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str.11, i64 0, i64 0), i64 %118)
%120 = load i64, i64* %8
%121 = add i64 %120, -1
store i64 %121, i64* %8
%122 = load i64, i64* %8
%123 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str.12, i64 0, i64 0), i64 %122)
%124 = load i64, i64* %11
%125 = add nsw i64 %124, 1
store i64 %125, i64* %11
br label %126
126: ; preds = %131, %113
%127 = load i64, i64* %11
%128 = mul nsw i64 %127, 2
%129 = load i64, i64* %11
%130 = icmp sgt i64 %128, %129
br i1 %130, label %131, label %135
131: ; preds = %126
%132 = load i64, i64* %11
%133 = mul nsw i64 %132, 2
%134 = add nsw i64 %133, 1
store i64 %134, i64* %11
br label %126
135: ; preds = %126
%136 = load i64, i64* %11
%137 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.13, i64 0, i64 0), i64 %136)
%138 = load i64, i64* %11
%139 = add nsw i64 %138, 1
store i64 %139, i64* %11
%140 = load i64, i64* %11
%141 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.14, i64 0, i64 0), i64 %140)
%142 = load i64, i64* %10
%143 = add i64 %142, -1
store i64 %143, i64* %10
%144 = load i64, i64* %10
%145 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([36 x i8], [36 x i8]* @.str.15, i64 0, i64 0), i64 %144)
br label %146
146: ; preds = %150, %135
%147 = load float, float* %12
%148 = fpext float %147 to double
%149 = fcmp oeq double %148, 0.000000e+00
br i1 %149, label %150, label %161
150: ; preds = %146
%151 = load float, float* %13
store float %151, float* %14
%152 = load float, float* %13
%153 = fpext float %152 to double
%154 = fadd double %153, 1.111000e+31
%155 = fptrunc double %154 to float
store float %155, float* %13
%156 = load float, float* %12
%157 = load float, float* %13
%158 = fadd float %156, %157
%159 = load float, float* %13
%160 = fsub float %158, %159
store float %160, float* %12
br label %146
161: ; preds = %146
%162 = load float, float* %14
%163 = fpext float %162 to double
%164 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.16, i64 0, i64 0), double %163)
%165 = load float, float* %14
%166 = fsub float 0.000000e+00, %165
%167 = fpext float %166 to double
%168 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.17, i64 0, i64 0), double %167)
br label %169
169: ; preds = %172, %161
%170 = load double, double* %15
%171 = fcmp oeq double %170, 0.000000e+00
br i1 %171, label %172, label %181
172: ; preds = %169
%173 = load double, double* %16
store double %173, double* %17
%174 = load double, double* %16
%175 = fadd double %174, 1.111000e+300
store double %175, double* %16
%176 = load double, double* %15
%177 = load double, double* %16
%178 = fadd double %176, %177
%179 = load double, double* %16
%180 = fsub double %178, %179
store double %180, double* %15
br label %169
181: ; preds = %169
%182 = load double, double* %17
%183 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.18, i64 0, i64 0), double %182)
%184 = load double, double* %17
%185 = fsub double 0.000000e+00, %184
%186 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.19, i64 0, i64 0), double %185)
%187 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([48 x i8], [48 x i8]* @.str.20, i64 0, i64 0))
%188 = load i32, i32* @SCHAR_MIN
%189 = load i32, i32* @SCHAR_MAX
%190 = load i32, i32* @UCHAR_MAX
%191 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([47 x i8], [47 x i8]* @.str.21, i64 0, i64 0), i32 %188, i32 %189, i32 %190)
%192 = load i32, i32* @SHRT_MIN
%193 = load i32, i32* @SHRT_MAX
%194 = load i32, i32* @USHRT_MAX
%195 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([48 x i8], [48 x i8]* @.str.22, i64 0, i64 0), i32 %192, i32 %193, i32 %194)
%196 = load i32, i32* @INT_MIN
%197 = load i32, i32* @INT_MAX
%198 = load i32, i32* @UINT_MAX
%199 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.23, i64 0, i64 0), i32 %196, i32 %197, i32 %198)
%200 = load i32, i32* @LONG_MIN
%201 = load i32, i32* @LONG_MAX
%202 = load i32, i32* @ULONG_MAX
%203 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([50 x i8], [50 x i8]* @.str.24, i64 0, i64 0), i32 %200, i32 %201, i32 %202)
%204 = load double, double* @FLT_MAX
%205 = fsub double 0.000000e+00, %204
%206 = load double, double* @FLT_MAX
%207 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str.25, i64 0, i64 0), double %205, double %206)
%208 = load double, double* @DBL_MAX
%209 = fsub double 0.000000e+00, %208
%210 = load double, double* @DBL_MAX
%211 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str.26, i64 0, i64 0), double %209, double %210)
ret i32 0
}

LLVM IR (-O2):
@.str.1 = [27 x i8] c"`signed char` maximum: %d\0A\00"
@.str.2 = [27 x i8] c"`signed char` minimum: %d\0A\00"
@.str.3 = [29 x i8] c"`unsigned char` maximum: %u\0A\00"
@.str.4 = [28 x i8] c"`signed short` maximum: %d\0A\00"
@.str.5 = [28 x i8] c"`signed short` minimum: %d\0A\00"
@.str.6 = [30 x i8] c"`unsigned short` maximum: %u\0A\00"
@.str.7 = [26 x i8] c"`signed int` maximum: %d\0A\00"
@.str.8 = [26 x i8] c"`signed int` minimum: %d\0A\00"
@.str.9 = [28 x i8] c"`unsigned int` maximum: %u\0A\00"
@.str.10 = [28 x i8] c"`signed long` maximum: %li\0A\00"
@.str.11 = [28 x i8] c"`signed long` minimum: %li\0A\00"
@.str.12 = [30 x i8] c"`unsigned long` maximum: %lu\0A\00"
@.str.13 = [34 x i8] c"`signed long long` maximum: %lli\0A\00"
@.str.14 = [34 x i8] c"`signed long long` minimum: %lli\0A\00"
@.str.15 = [36 x i8] c"`unsigned long long` maximum: %llu\0A\00"
@.str.16 = [21 x i8] c"`float` maximum: %e\0A\00"
@.str.17 = [21 x i8] c"`float` minimum: %e\0A\00"
@.str.18 = [22 x i8] c"`double` maximum: %e\0A\00"
@.str.19 = [22 x i8] c"`double` minimum: %e\0A\00"
@.str.21 = [47 x i8] c"`char`s go from %d to %d (unsigned, up to %u)\0A\00"
@SCHAR_MIN = global i32 0
@SCHAR_MAX = global i32 0
@UCHAR_MAX = global i32 0
@.str.22 = [48 x i8] c"`short`s go from %d to %d (unsigned, up to %u)\0A\00"
@SHRT_MIN = global i32 0
@SHRT_MAX = global i32 0
@USHRT_MAX = global i32 0
@.str.23 = [46 x i8] c"`int`s go from %d to %d (unsigned, up to %u)\0A\00"
@INT_MIN = global i32 0
@INT_MAX = global i32 0
@UINT_MAX = global i32 0
@.str.24 = [50 x i8] c"`long`s go from %ld to %ld (unsigned, up to %lu)\0A\00"
@LONG_MIN = global i32 0
@LONG_MAX = global i32 0
@ULONG_MAX = global i32 0
@.str.25 = [30 x i8] c"`float`s range from %e to %e\0A\00"
@FLT_MAX = global double 0.000000e+00
@.str.26 = [31 x i8] c"`double`s range from %e to %e\0A\00"
@DBL_MAX = global double 0.000000e+00
@str = [54 x i8] c"Let's compute the minimums and maximums of each type!\00"
@str.27 = [47 x i8] c"\0ANow, let's cheat and use the helpful headers!\00"
define i32 @main() {
%1 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([54 x i8], [54 x i8]* @str, i64 0, i64 0))
%2 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([27 x i8], [27 x i8]* @.str.1, i64 0, i64 0), i32 -1)
%3 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([27 x i8], [27 x i8]* @.str.2, i64 0, i64 0), i32 0)
%4 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([29 x i8], [29 x i8]* @.str.3, i64 0, i64 0), i32 255)
%5 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([28 x i8], [28 x i8]* @.str.4, i64 0, i64 0), i32 -1)
%6 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([28 x i8], [28 x i8]* @.str.5, i64 0, i64 0), i32 0)
%7 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([30 x i8], [30 x i8]* @.str.6, i64 0, i64 0), i32 65535)
%8 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([26 x i8], [26 x i8]* @.str.7, i64 0, i64 0), i32 2147483647)
%9 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([26 x i8], [26 x i8]* @.str.8, i64 0, i64 0), i32 -2147483648)
%10 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([28 x i8], [28 x i8]* @.str.9, i64 0, i64 0), i32 -1)
%11 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([28 x i8], [28 x i8]* @.str.10, i64 0, i64 0), i64 9223372036854775807)
%12 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([28 x i8], [28 x i8]* @.str.11, i64 0, i64 0), i64 -9223372036854775808)
%13 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([30 x i8], [30 x i8]* @.str.12, i64 0, i64 0), i64 -1)
%14 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([34 x i8], [34 x i8]* @.str.13, i64 0, i64 0), i64 9223372036854775807)
%15 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([34 x i8], [34 x i8]* @.str.14, i64 0, i64 0), i64 -9223372036854775808)
%16 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([36 x i8], [36 x i8]* @.str.15, i64 0, i64 0), i64 -1)
br label %17
17: ; preds = %0, %17
%18 = phi float [ 0.000000e+00, %0 ], [ %22, %17 ]
%19 = phi float [ 0.000000e+00, %0 ], [ %24, %17 ]
%20 = fpext float %18 to double
%21 = fadd double %20, 1.111000e+31
%22 = fptrunc double %21 to float
%23 = fadd float %19, %22
%24 = fsub float %23, %22
%25 = fcmp oeq float %24, 0.000000e+00
br i1 %25, label %17, label %26
26: ; preds = %17
%27 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([21 x i8], [21 x i8]* @.str.16, i64 0, i64 0), double %20)
%28 = fsub float 0.000000e+00, %18
%29 = fpext float %28 to double
%30 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([21 x i8], [21 x i8]* @.str.17, i64 0, i64 0), double %29)
br label %31
31: ; preds = %26, %31
%32 = phi double [ 0.000000e+00, %26 ], [ %34, %31 ]
%33 = phi double [ 0.000000e+00, %26 ], [ %36, %31 ]
%34 = fadd double %32, 1.111000e+300
%35 = fadd double %33, %34
%36 = fsub double %35, %34
%37 = fcmp oeq double %36, 0.000000e+00
br i1 %37, label %31, label %38
38: ; preds = %31
%39 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([22 x i8], [22 x i8]* @.str.18, i64 0, i64 0), double %32)
%40 = fsub double 0.000000e+00, %32
%41 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([22 x i8], [22 x i8]* @.str.19, i64 0, i64 0), double %40)
%42 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([47 x i8], [47 x i8]* @str.27, i64 0, i64 0))
%43 = load i32, i32* @SCHAR_MIN
%44 = load i32, i32* @SCHAR_MAX
%45 = load i32, i32* @UCHAR_MAX
%46 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([47 x i8], [47 x i8]* @.str.21, i64 0, i64 0), i32 %43, i32 %44, i32 %45)
%47 = load i32, i32* @SHRT_MIN
%48 = load i32, i32* @SHRT_MAX
%49 = load i32, i32* @USHRT_MAX
%50 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([48 x i8], [48 x i8]* @.str.22, i64 0, i64 0), i32 %47, i32 %48, i32 %49)
%51 = load i32, i32* @INT_MIN
%52 = load i32, i32* @INT_MAX
%53 = load i32, i32* @UINT_MAX
%54 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([46 x i8], [46 x i8]* @.str.23, i64 0, i64 0), i32 %51, i32 %52, i32 %53)
%55 = load i32, i32* @LONG_MIN
%56 = load i32, i32* @LONG_MAX
%57 = load i32, i32* @ULONG_MAX
%58 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([50 x i8], [50 x i8]* @.str.24, i64 0, i64 0), i32 %55, i32 %56, i32 %57)
%59 = load double, double* @FLT_MAX
%60 = fsub double 0.000000e+00, %59
%61 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([30 x i8], [30 x i8]* @.str.25, i64 0, i64 0), double %60, double %59)
%62 = load double, double* @DBL_MAX
%63 = fsub double 0.000000e+00, %62
%64 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([31 x i8], [31 x i8]* @.str.26, i64 0, i64 0), double %63, double %62)
ret i32 0
}