#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 */
scalar_t__ IsGregorianDays(int, int, int);
double CalculateJulianDay(int year, int month, int day, int hour, int minute,
                          double second) {
  if (month <= 2) {
    month += 12;
    year -= 1;
  }
  int B = -2;
  if (IsGregorianDays(year, month, day)) {
    B = year / 400 - year / 100;
  }
  double a = 365.25 * year;
  double b = 30.6001 * (month + 1);
  return (int)a + (int)b + B + 1720996.5 + day + hour / 24.0 + minute / 1440.0 +
         second / 86400.0;
}


x86 assembly (clang, -O0):
<CalculateJulianDay>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %edx,-0xc(%rbp)
mov    %ecx,-0x10(%rbp)
mov    %r8d,-0x14(%rbp)
movsd  %xmm0,-0x20(%rbp)
cmpl   $0x2,-0x8(%rbp)
jg     1149 <CalculateJulianDay+0x39>
mov    -0x8(%rbp),%eax
add    $0xc,%eax
mov    %eax,-0x8(%rbp)
mov    -0x4(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x4(%rbp)
movl   $0xfffffffe,-0x24(%rbp)
mov    -0x4(%rbp),%edi
mov    -0x8(%rbp),%esi
mov    -0xc(%rbp),%edx
call   1030 <IsGregorianDays@plt>
cmp    $0x0,%rax
je     118b <CalculateJulianDay+0x7b>
mov    -0x4(%rbp),%eax
mov    $0x190,%ecx
cltd
idiv   %ecx
mov    %eax,-0x3c(%rbp)
mov    -0x4(%rbp),%eax
mov    $0x64,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x3c(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x24(%rbp)
cvtsi2sdl -0x4(%rbp),%xmm1
movsd  0xe90(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x30(%rbp)
mov    -0x8(%rbp),%eax
add    $0x1,%eax
cvtsi2sd %eax,%xmm1
movsd  0xe6d(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
cvttsd2si -0x30(%rbp),%eax
cvttsd2si -0x38(%rbp),%ecx
add    %ecx,%eax
add    -0x24(%rbp),%eax
cvtsi2sd %eax,%xmm0
movsd  0xe41(%rip),%xmm1
addsd  %xmm1,%xmm0
cvtsi2sdl -0xc(%rbp),%xmm1
addsd  %xmm1,%xmm0
cvtsi2sdl -0x10(%rbp),%xmm1
movsd  0xe1f(%rip),%xmm2
divsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
cvtsi2sdl -0x14(%rbp),%xmm1
movsd  0xe02(%rip),%xmm2
divsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  -0x20(%rbp),%xmm1
movsd  0xde5(%rip),%xmm2
divsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<CalculateJulianDay>:
push   %rbp
push   %r15
push   %r14
push   %r12
push   %rbx
sub    $0x10,%rsp
movaps %xmm0,(%rsp)
mov    %r8d,%r15d
mov    %ecx,%r14d
mov    %edx,%r12d
mov    %edi,%ebp
lea    0xc(%rsi),%ebx
xor    %eax,%eax
cmp    $0x3,%esi
setl   %al
cmovge %esi,%ebx
sub    %eax,%ebp
mov    %ebp,%edi
mov    %ebx,%esi
call   1030 <IsGregorianDays@plt>
test   %rax,%rax
je     1178 <CalculateJulianDay+0x68>
movslq %ebp,%rax
imul   $0x51eb851f,%rax,%rcx
mov    %rcx,%rdx
shr    $0x3f,%rdx
sar    $0x27,%rcx
add    %edx,%ecx
imul   $0xffffffffae147ae1,%rax,%rax
mov    %rax,%rdx
shr    $0x3f,%rdx
sar    $0x25,%rax
add    %edx,%eax
add    %ecx,%eax
jmp    117d <CalculateJulianDay+0x6d>
mov    $0xfffffffe,%eax
add    $0x1,%ebx
movd   %ebp,%xmm0
movd   %ebx,%xmm1
punpckldq %xmm1,%xmm0
cvtdq2pd %xmm0,%xmm0
mulpd  0xe68(%rip),%xmm0
cvttpd2dq %xmm0,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%ecx
add    %eax,%ecx
xorps  %xmm0,%xmm0
cvtsi2sd %ecx,%xmm0
addsd  0xe66(%rip),%xmm0
xorps  %xmm1,%xmm1
cvtsi2sd %r12d,%xmm1
cvtsi2sd %r15d,%xmm2
addsd  %xmm0,%xmm1
movapd (%rsp),%xmm3
unpcklpd %xmm2,%xmm3
xorps  %xmm2,%xmm2
cvtsi2sd %r14d,%xmm2
divsd  0xe44(%rip),%xmm2
divpd  0xe24(%rip),%xmm3
addsd  %xmm1,%xmm2
movapd %xmm3,%xmm0
unpckhpd %xmm3,%xmm0
addsd  %xmm2,%xmm0
addsd  %xmm3,%xmm0
add    $0x10,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define double @CalculateJulianDay(i32 %0, i32 %1, i32 %2, i32 %3, i32 %4, double %5) {
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca double
%13 = alloca i32
%14 = alloca double
%15 = alloca double
store i32 %0, i32* %7
store i32 %1, i32* %8
store i32 %2, i32* %9
store i32 %3, i32* %10
store i32 %4, i32* %11
store double %5, double* %12
%16 = load i32, i32* %8
%17 = icmp sle i32 %16, 2
br i1 %17, label %18, label %23
18: ; preds = %6
%19 = load i32, i32* %8
%20 = add nsw i32 %19, 12
store i32 %20, i32* %8
%21 = load i32, i32* %7
%22 = sub nsw i32 %21, 1
store i32 %22, i32* %7
br label %23
23: ; preds = %18, %6
store i32 -2, i32* %13
%24 = load i32, i32* %7
%25 = load i32, i32* %8
%26 = load i32, i32* %9
%27 = call i64 @IsGregorianDays(i32 %24, i32 %25, i32 %26)
%28 = icmp ne i64 %27, 0
br i1 %28, label %29, label %35
29: ; preds = %23
%30 = load i32, i32* %7
%31 = sdiv i32 %30, 400
%32 = load i32, i32* %7
%33 = sdiv i32 %32, 100
%34 = sub nsw i32 %31, %33
store i32 %34, i32* %13
br label %35
35: ; preds = %29, %23
%36 = load i32, i32* %7
%37 = sitofp i32 %36 to double
%38 = fmul double 3.652500e+02, %37
store double %38, double* %14
%39 = load i32, i32* %8
%40 = add nsw i32 %39, 1
%41 = sitofp i32 %40 to double
%42 = fmul double 3.060010e+01, %41
store double %42, double* %15
%43 = load double, double* %14
%44 = fptosi double %43 to i32
%45 = load double, double* %15
%46 = fptosi double %45 to i32
%47 = add nsw i32 %44, %46
%48 = load i32, i32* %13
%49 = add nsw i32 %47, %48
%50 = sitofp i32 %49 to double
%51 = fadd double %50, 0x413A42A480000000
%52 = load i32, i32* %9
%53 = sitofp i32 %52 to double
%54 = fadd double %51, %53
%55 = load i32, i32* %10
%56 = sitofp i32 %55 to double
%57 = fdiv double %56, 2.400000e+01
%58 = fadd double %54, %57
%59 = load i32, i32* %11
%60 = sitofp i32 %59 to double
%61 = fdiv double %60, 1.440000e+03
%62 = fadd double %58, %61
%63 = load double, double* %12
%64 = fdiv double %63, 8.640000e+04
%65 = fadd double %62, %64
ret double %65
}

LLVM IR (-O2):
define double @CalculateJulianDay(i32 %0, i32 %1, i32 %2, i32 %3, i32 %4, double %5) {
%7 = icmp slt i32 %1, 3
%8 = add nsw i32 %1, 12
%9 = select i1 %7, i32 %8, i32 %1
%10 = sext i1 %7 to i32
%11 = add nsw i32 %10, %0
%12 = tail call i64 @IsGregorianDays(i32 %11, i32 %9, i32 %2)
%13 = icmp eq i64 %12, 0
br i1 %13, label %18, label %14
14: ; preds = %6
%15 = sdiv i32 %11, 400
%16 = sdiv i32 %11, -100
%17 = add nsw i32 %16, %15
br label %18
18: ; preds = %14, %6
%19 = phi i32 [ %17, %14 ], [ -2, %6 ]
%20 = add nsw i32 %9, 1
%21 = insertelement <2 x i32> poison, i32 %11, i64 0
%22 = insertelement <2 x i32> %21, i32 %20, i64 1
%23 = sitofp <2 x i32> %22 to <2 x double>
%24 = fmul <2 x double> %23, <double 3.652500e+02, double 3.060010e+01>
%25 = fptosi <2 x double> %24 to <2 x i32>
%26 = shufflevector <2 x i32> %25, <2 x i32> poison, <2 x i32> <i32 1, i32 undef>
%27 = add nsw <2 x i32> %26, %25
%28 = extractelement <2 x i32> %27, i64 0
%29 = add nsw i32 %28, %19
%30 = sitofp i32 %29 to double
%31 = fadd double %30, 0x413A42A480000000
%32 = sitofp i32 %2 to double
%33 = fadd double %31, %32
%34 = sitofp i32 %3 to double
%35 = fdiv double %34, 2.400000e+01
%36 = fadd double %35, %33
%37 = sitofp i32 %4 to double
%38 = insertelement <2 x double> poison, double %5, i64 0
%39 = insertelement <2 x double> %38, double %37, i64 1
%40 = fdiv <2 x double> %39, <double 8.640000e+04, double 1.440000e+03>
%41 = extractelement <2 x double> %40, i64 1
%42 = fadd double %41, %36
%43 = extractelement <2 x double> %40, i64 0
%44 = fadd double %43, %42
ret double %44
}