#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 berechne_differenz_in_prozent(double, double);
double berechne_durchschnittsverbrauch_l_pro_100km(double, double);
double berechne_kosten_gesamt(double, double);
double berechne_kosten_pro_einheit(double, double);
double berechne_verbrauch_liter_pro_km(double, double);
double erfasse_gleitkomma_zahl(char *, int, int);
int /*<<< orphan*/ printf(char *, ...);
double umrechnung_durchschnittsverbrauch(double);
double umrechnung_euro_in_us_dollar(double, double);
double umrechnung_km_in_land_mi(double);
double umrechnung_l_in_us_gal(double);
double umrechnung_land_mi_in_km(double);
double umrechnung_us_dollar_in_euro(double, double);
int main(void) {
  printf("\nDieses Programm berechnet die Kosten für eine Fahrt, "
         "rechnet diese in angloamerikanische Kennzahlen um und\n"
         "gibt Übersicht über die Durchschnitskosten für bestimmte "
         "Fahrleistungen pro Jahr.\n");
  char *ausgabe_text;
  ausgabe_text = "\nWie viel Kilometer sind Sie mit Ihrem PKW gefahren?\t";
  double strecke_in_km = erfasse_gleitkomma_zahl(ausgabe_text, 0, 1000000);
  ausgabe_text = "Wie viel Liter Benzin haben Sie dabei verbraucht?\t";
  double verbrauch_in_l = erfasse_gleitkomma_zahl(ausgabe_text, 0, 100000);
  double wechselkurs_euro_us_dollar = 1.2372;
  ausgabe_text = "Wie viel Euro kostet ein Liter Benzin?\t\t\t";
  double kosten_liter_in_euro = erfasse_gleitkomma_zahl(ausgabe_text, 0, 20);
  ausgabe_text = "\nWie viel Dollar kostet eine Gallone Benzin in den USA?\t";
  double kosten_gallone_in_us_dollar =
      erfasse_gleitkomma_zahl(ausgabe_text, 0, 20);
  ausgabe_text = "Was ist der aktuelle Wechselkurs von Euro zu Dollar?\t";
  wechselkurs_euro_us_dollar =
      erfasse_gleitkomma_zahl(ausgabe_text, -100000, 100000);
  printf("\n\nAufgrund Ihrer Eingaben habe ich folgende Daten berechnet:\n");
  double verbrauch_liter_pro_km =
      berechne_verbrauch_liter_pro_km(strecke_in_km, verbrauch_in_l);
  double durchschnittsverbrauch_l_pro_100km =
      berechne_durchschnittsverbrauch_l_pro_100km(strecke_in_km,
                                                  verbrauch_in_l);
  double durchschnittsverbrauch_us_mi_pro_gal =
      umrechnung_durchschnittsverbrauch(durchschnittsverbrauch_l_pro_100km);
  printf("\nSie haben %.2lf Liter Benzin pro Kilometer verbraucht.",
         verbrauch_liter_pro_km);
  printf("\nDem entsprechen %.2lf gefahrene Meilen pro Gallone Benzin.",
         durchschnittsverbrauch_us_mi_pro_gal);
  double kosten_fahrt_in_euro =
      berechne_kosten_gesamt(verbrauch_in_l, kosten_liter_in_euro);
  double verbrauch_in_us_gal = umrechnung_l_in_us_gal(verbrauch_in_l);
  double kosten_fahrt_in_us_dollar =
      berechne_kosten_gesamt(verbrauch_in_us_gal, kosten_gallone_in_us_dollar);
  printf("\nBei einem Literpreis von %.2lf Euro hat Sie die Fahrt %.2lf Euro "
         "gekostet.\n",
         kosten_liter_in_euro, kosten_fahrt_in_euro);
  printf("\nBeim Preis von %.2lf Dollar pro Gallone haette Sie die Fahrt in "
         "den USA %.2lf Dollar gekostet.",
         kosten_gallone_in_us_dollar, kosten_fahrt_in_us_dollar);
  double wechselkurs_us_dollar_euro = 0.8141;
  double kosten_fahrt_in_euro_usa = umrechnung_us_dollar_in_euro(
      kosten_fahrt_in_us_dollar, wechselkurs_us_dollar_euro);
  double kosten_differenz = kosten_fahrt_in_euro - kosten_fahrt_in_euro_usa;
  printf(
      "\nBeim Wechselkurs von %.2lf Euro pro Dollar entspricht das %.2lf Euro.",
      wechselkurs_us_dollar_euro, kosten_fahrt_in_euro_usa);
  printf("\nDie Differenz der Kosten fuer die Fahrt in Deutschland und in den "
         "USA betraegt somit %.2lf Euro.\n",
         kosten_differenz);
  double kosten_km_ger_in_euro =
      berechne_kosten_pro_einheit(strecke_in_km, kosten_fahrt_in_euro);
  double kosten_km_usa_in_euro =
      berechne_kosten_pro_einheit(strecke_in_km, kosten_fahrt_in_euro_usa);
  double kosten_differenz_in_prozent = berechne_differenz_in_prozent(
      kosten_km_ger_in_euro, kosten_km_usa_in_euro);
  printf("\nEin Kilometer Ihrer Fahrt hat in Deutschland %.2lf Euro gekostet.",
         kosten_km_ger_in_euro);
  printf("\nEin Kilometer Ihrer Fahrt haette in den USA %.2lf Euro gekostet.\n",
         kosten_km_usa_in_euro);
  printf("\nIn den USA sind die Kosten fuer die Fahrt somit um %.2lf Prozent "
         "geringer.\n",
         kosten_differenz_in_prozent);
  double jahres_fahrleistung = 15000;
  printf("\nUmgerechnet auf eine durchschnittliche Fahrleistung pro Jahr "
         "ergeben sich daraus folgende Werte:\n");
  double jahreskosten_km_ger_euro =
      berechne_kosten_gesamt(jahres_fahrleistung, kosten_km_ger_in_euro);
  double jahreskosten_km_usa_euro =
      berechne_kosten_gesamt(jahres_fahrleistung, kosten_km_usa_in_euro);
  double jahreskosten_km_usa_dollar = umrechnung_euro_in_us_dollar(
      jahreskosten_km_usa_euro, wechselkurs_euro_us_dollar);
  printf("\nGesamtkosten fuer 15000 Kilometer in Deutschland:\t %12.2lf Euro",
         jahreskosten_km_ger_euro);
  printf("\nGesamtkosten fuer 15000 Kilometer in den USA:\t\t %12.2lf Euro",
         jahreskosten_km_usa_euro);
  printf("\nGesamtkosten fuer 15000 Kilometer in den USA:\t\t %12.2lf Dollar\n",
         jahreskosten_km_usa_dollar);
  double strecke_in_us_mi = umrechnung_km_in_land_mi(strecke_in_km);
  double kosten_mi_usa_in_dollar =
      berechne_kosten_pro_einheit(strecke_in_us_mi, kosten_fahrt_in_us_dollar);
  double jahreskosten_mi_usa_dollar =
      berechne_kosten_gesamt(jahres_fahrleistung, kosten_mi_usa_in_dollar);
  double jahreskosten_mi_usa_euro = umrechnung_us_dollar_in_euro(
      jahreskosten_mi_usa_dollar, wechselkurs_us_dollar_euro);
  strecke_in_km = umrechnung_land_mi_in_km(jahres_fahrleistung);
  double jahreskosten_mi_ger_euro =
      berechne_kosten_gesamt(strecke_in_km, kosten_km_ger_in_euro);
  printf("\nGesamtkosten fuer 15000 Meilen in den USA:\t\t %12.2lf Dollar",
         jahreskosten_mi_usa_dollar);
  printf("\nGesamtkosten fuer 15000 Meilen in den USA:\t\t %12.2lf Euro",
         jahreskosten_mi_usa_euro);
  printf("\nGesamtkosten fuer 15000 Meilen in Deutschland:\t\t %12.2lf Euro\n",
         jahreskosten_mi_ger_euro);
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0xe0,%rsp
lea    0xe36(%rip),%rdi
mov    $0x0,%al
call   1090 <printf@plt>
lea    0xeeb(%rip),%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rdi
xor    %esi,%esi
mov    $0xf4240,%edx
call   10e0 <erfasse_gleitkomma_zahl@plt>
movsd  %xmm0,-0x10(%rbp)
lea    0xf01(%rip),%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rdi
xor    %esi,%esi
mov    $0x186a0,%edx
call   10e0 <erfasse_gleitkomma_zahl@plt>
movsd  %xmm0,-0x18(%rbp)
movsd  0xddf(%rip),%xmm0
movsd  %xmm0,-0x20(%rbp)
lea    0xf07(%rip),%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rdi
xor    %esi,%esi
mov    $0x14,%edx
call   10e0 <erfasse_gleitkomma_zahl@plt>
movsd  %xmm0,-0x28(%rbp)
lea    0xf11(%rip),%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rdi
xor    %esi,%esi
mov    $0x14,%edx
call   10e0 <erfasse_gleitkomma_zahl@plt>
movsd  %xmm0,-0x30(%rbp)
lea    0xf2a(%rip),%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rdi
mov    $0xfffe7960,%esi
mov    $0x186a0,%edx
call   10e0 <erfasse_gleitkomma_zahl@plt>
movsd  %xmm0,-0x20(%rbp)
lea    0xf3d(%rip),%rdi
mov    $0x0,%al
call   1090 <printf@plt>
movsd  -0x10(%rbp),%xmm0
movsd  -0x18(%rbp),%xmm1
call   1080 <berechne_verbrauch_liter_pro_km@plt>
movsd  %xmm0,-0x38(%rbp)
movsd  -0x10(%rbp),%xmm0
movsd  -0x18(%rbp),%xmm1
call   10f0 <berechne_durchschnittsverbrauch_l_pro_100km@plt>
movsd  %xmm0,-0x40(%rbp)
movsd  -0x40(%rbp),%xmm0
call   1040 <umrechnung_durchschnittsverbrauch@plt>
movsd  %xmm0,-0x48(%rbp)
movsd  -0x38(%rbp),%xmm0
lea    0xf31(%rip),%rdi
mov    $0x1,%al
call   1090 <printf@plt>
movsd  -0x48(%rbp),%xmm0
lea    0xf56(%rip),%rdi
mov    $0x1,%al
call   1090 <printf@plt>
movsd  -0x18(%rbp),%xmm0
movsd  -0x28(%rbp),%xmm1
call   1050 <berechne_kosten_gesamt@plt>
movsd  %xmm0,-0x50(%rbp)
movsd  -0x18(%rbp),%xmm0
call   1070 <umrechnung_l_in_us_gal@plt>
movsd  %xmm0,-0x58(%rbp)
movsd  -0x58(%rbp),%xmm0
movsd  -0x30(%rbp),%xmm1
call   1050 <berechne_kosten_gesamt@plt>
movsd  %xmm0,-0x60(%rbp)
movsd  -0x28(%rbp),%xmm0
movsd  -0x50(%rbp),%xmm1
lea    0xf43(%rip),%rdi
mov    $0x2,%al
call   1090 <printf@plt>
movsd  -0x30(%rbp),%xmm0
movsd  -0x60(%rbp),%xmm1
lea    0xf78(%rip),%rdi
mov    $0x2,%al
call   1090 <printf@plt>
movsd  0xc95(%rip),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x60(%rbp),%xmm0
movsd  -0x68(%rbp),%xmm1
call   1060 <umrechnung_us_dollar_in_euro@plt>
movsd  %xmm0,-0x70(%rbp)
movsd  -0x50(%rbp),%xmm0
subsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x68(%rbp),%xmm0
movsd  -0x70(%rbp),%xmm1
lea    0xf90(%rip),%rdi
mov    $0x2,%al
call   1090 <printf@plt>
movsd  -0x78(%rbp),%xmm0
lea    0xfc4(%rip),%rdi
mov    $0x1,%al
call   1090 <printf@plt>
movsd  -0x10(%rbp),%xmm0
movsd  -0x50(%rbp),%xmm1
call   10b0 <berechne_kosten_pro_einheit@plt>
movsd  %xmm0,-0x80(%rbp)
movsd  -0x10(%rbp),%xmm0
movsd  -0x70(%rbp),%xmm1
call   10b0 <berechne_kosten_pro_einheit@plt>
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
movsd  -0x88(%rbp),%xmm1
ff
call   10c0 <berechne_differenz_in_prozent@plt>
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
lea    0xfcf(%rip),%rdi
mov    $0x1,%al
call   1090 <printf@plt>
movsd  -0x88(%rbp),%xmm0
ff
lea    0xffc(%rip),%rdi
mov    $0x1,%al
call   1090 <printf@plt>
movsd  -0x90(%rbp),%xmm0
ff
lea    0x1029(%rip),%rdi
mov    $0x1,%al
call   1090 <printf@plt>
movsd  0xbae(%rip),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
lea    0x1058(%rip),%rdi
mov    $0x0,%al
call   1090 <printf@plt>
movsd  -0x98(%rbp),%xmm0
ff
movsd  -0x80(%rbp),%xmm1
call   1050 <berechne_kosten_gesamt@plt>
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
movsd  -0x88(%rbp),%xmm1
ff
call   1050 <berechne_kosten_gesamt@plt>
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0xa8(%rbp),%xmm0
ff
movsd  -0x20(%rbp),%xmm1
call   10d0 <umrechnung_euro_in_us_dollar@plt>
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
lea    0x1054(%rip),%rdi
mov    $0x1,%al
call   1090 <printf@plt>
movsd  -0xa8(%rbp),%xmm0
ff
lea    0x107f(%rip),%rdi
mov    $0x1,%al
call   1090 <printf@plt>
movsd  -0xb0(%rbp),%xmm0
ff
lea    0x10a7(%rip),%rdi
mov    $0x1,%al
call   1090 <printf@plt>
movsd  -0x10(%rbp),%xmm0
call   10a0 <umrechnung_km_in_land_mi@plt>
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0xb8(%rbp),%xmm0
ff
movsd  -0x60(%rbp),%xmm1
call   10b0 <berechne_kosten_pro_einheit@plt>
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
movsd  -0xc0(%rbp),%xmm1
ff
call   1050 <berechne_kosten_gesamt@plt>
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0xc8(%rbp),%xmm0
ff
movsd  -0x68(%rbp),%xmm1
call   1060 <umrechnung_us_dollar_in_euro@plt>
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
call   1030 <umrechnung_land_mi_in_km@plt>
movsd  %xmm0,-0x10(%rbp)
movsd  -0x10(%rbp),%xmm0
movsd  -0x80(%rbp),%xmm1
call   1050 <berechne_kosten_gesamt@plt>
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  -0xc8(%rbp),%xmm0
ff
lea    0x1046(%rip),%rdi
mov    $0x1,%al
call   1090 <printf@plt>
movsd  -0xd0(%rbp),%xmm0
ff
lea    0x106d(%rip),%rdi
mov    $0x1,%al
call   1090 <printf@plt>
movsd  -0xd8(%rbp),%xmm0
ff
lea    0x1092(%rip),%rdi
mov    $0x1,%al
call   1090 <printf@plt>
xor    %eax,%eax
add    $0xe0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
sub    $0x38,%rsp
lea    0x133d(%rip),%rdi
call   1050 <puts@plt>
lea    0xe19(%rip),%rdi
xor    %esi,%esi
mov    $0xf4240,%edx
call   10f0 <erfasse_gleitkomma_zahl@plt>
movsd  %xmm0,0x20(%rsp)
lea    0xe36(%rip),%rdi
xor    %esi,%esi
mov    $0x186a0,%edx
call   10f0 <erfasse_gleitkomma_zahl@plt>
movsd  %xmm0,(%rsp)
lea    0xe51(%rip),%rdi
xor    %esi,%esi
mov    $0x14,%edx
call   10f0 <erfasse_gleitkomma_zahl@plt>
movsd  %xmm0,0x10(%rsp)
lea    0xe62(%rip),%rdi
xor    %esi,%esi
mov    $0x14,%edx
call   10f0 <erfasse_gleitkomma_zahl@plt>
movsd  %xmm0,0x28(%rsp)
lea    0xe82(%rip),%rdi
mov    $0xfffe7960,%esi
mov    $0x186a0,%edx
call   10f0 <erfasse_gleitkomma_zahl@plt>
movsd  %xmm0,0x30(%rsp)
lea    0x1374(%rip),%rdi
call   1050 <puts@plt>
movsd  0x20(%rsp),%xmm0
movsd  (%rsp),%xmm1
call   1090 <berechne_verbrauch_liter_pro_km@plt>
movsd  %xmm0,0x18(%rsp)
movsd  0x20(%rsp),%xmm0
movsd  (%rsp),%xmm1
call   1100 <berechne_durchschnittsverbrauch_l_pro_100km@plt>
call   1040 <umrechnung_durchschnittsverbrauch@plt>
movsd  %xmm0,0x8(%rsp)
lea    0xe5f(%rip),%rdi
movsd  0x18(%rsp),%xmm0
mov    $0x1,%al
call   10a0 <printf@plt>
lea    0xe83(%rip),%rdi
movsd  0x8(%rsp),%xmm0
mov    $0x1,%al
call   10a0 <printf@plt>
movsd  (%rsp),%xmm0
movsd  0x10(%rsp),%xmm1
call   1060 <berechne_kosten_gesamt@plt>
movsd  %xmm0,0x8(%rsp)
movsd  (%rsp),%xmm0
call   1080 <umrechnung_l_in_us_gal@plt>
movsd  0x28(%rsp),%xmm1
call   1060 <berechne_kosten_gesamt@plt>
movsd  %xmm0,0x18(%rsp)
lea    0xe7a(%rip),%rdi
movsd  0x10(%rsp),%xmm0
movsd  0x8(%rsp),%xmm1
mov    $0x2,%al
call   10a0 <printf@plt>
lea    0xead(%rip),%rdi
movsd  0x28(%rsp),%xmm0
movsd  0x18(%rsp),%xmm1
mov    $0x2,%al
call   10a0 <printf@plt>
movsd  0xcbf(%rip),%xmm1
movsd  0x18(%rsp),%xmm0
call   1070 <umrechnung_us_dollar_in_euro@plt>
movapd %xmm0,%xmm1
movsd  %xmm0,0x10(%rsp)
movsd  0x8(%rsp),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rsp)
lea    0xec7(%rip),%rdi
movsd  0xc8c(%rip),%xmm0
mov    $0x2,%al
call   10a0 <printf@plt>
lea    0xef8(%rip),%rdi
movsd  (%rsp),%xmm0
mov    $0x1,%al
call   10a0 <printf@plt>
movsd  0x20(%rsp),%xmm0
movsd  0x8(%rsp),%xmm1
call   10c0 <berechne_kosten_pro_einheit@plt>
movsd  %xmm0,(%rsp)
movsd  0x20(%rsp),%xmm0
movsd  0x10(%rsp),%xmm1
call   10c0 <berechne_kosten_pro_einheit@plt>
movaps %xmm0,%xmm1
movsd  %xmm0,0x8(%rsp)
movsd  (%rsp),%xmm0
call   10d0 <berechne_differenz_in_prozent@plt>
movsd  %xmm0,0x10(%rsp)
lea    0xf08(%rip),%rdi
movsd  (%rsp),%xmm0
mov    $0x1,%al
call   10a0 <printf@plt>
lea    0xf38(%rip),%rdi
movsd  0x8(%rsp),%xmm0
mov    $0x1,%al
call   10a0 <printf@plt>
lea    0xf67(%rip),%rdi
movsd  0x10(%rsp),%xmm0
mov    $0x1,%al
call   10a0 <printf@plt>
lea    0x1217(%rip),%rdi
call   1050 <puts@plt>
movsd  0xbeb(%rip),%xmm0
movsd  (%rsp),%xmm1
call   1060 <berechne_kosten_gesamt@plt>
movsd  %xmm0,0x10(%rsp)
movsd  0xbd3(%rip),%xmm0
movsd  0x8(%rsp),%xmm1
call   1060 <berechne_kosten_gesamt@plt>
movsd  %xmm0,0x28(%rsp)
movsd  0x30(%rsp),%xmm1
call   10e0 <umrechnung_euro_in_us_dollar@plt>
movsd  %xmm0,0x8(%rsp)
lea    0xf52(%rip),%rdi
movsd  0x10(%rsp),%xmm0
mov    $0x1,%al
call   10a0 <printf@plt>
lea    0xf7f(%rip),%rdi
movsd  0x28(%rsp),%xmm0
mov    $0x1,%al
call   10a0 <printf@plt>
lea    0xfa9(%rip),%rdi
movsd  0x8(%rsp),%xmm0
mov    $0x1,%al
call   10a0 <printf@plt>
movsd  0x20(%rsp),%xmm0
call   10b0 <umrechnung_km_in_land_mi@plt>
movsd  0x18(%rsp),%xmm1
call   10c0 <berechne_kosten_pro_einheit@plt>
movaps %xmm0,%xmm1
movsd  0xb54(%rip),%xmm0
call   1060 <berechne_kosten_gesamt@plt>
movsd  %xmm0,0x18(%rsp)
movsd  0xb39(%rip),%xmm1
call   1070 <umrechnung_us_dollar_in_euro@plt>
movsd  %xmm0,0x20(%rsp)
movsd  0xb2e(%rip),%xmm0
call   1030 <umrechnung_land_mi_in_km@plt>
movsd  (%rsp),%xmm1
call   1060 <berechne_kosten_gesamt@plt>
movsd  %xmm0,(%rsp)
lea    0xf7b(%rip),%rdi
movsd  0x18(%rsp),%xmm0
mov    $0x1,%al
call   10a0 <printf@plt>
lea    0xfa4(%rip),%rdi
movsd  0x20(%rsp),%xmm0
mov    $0x1,%al
call   10a0 <printf@plt>
lea    0xfcb(%rip),%rdi
movsd  (%rsp),%xmm0
mov    $0x1,%al
call   10a0 <printf@plt>
xor    %eax,%eax
add    $0x38,%rsp
ret

LLVM IR (-O0):
@.str = [195 x i8] c"\0ADieses Programm berechnet die Kosten f\C3\BCr eine Fahrt, rechnet diese in angloamerikanische Kennzahlen um und\0Agibt \C3\9Cbersicht \C3\BCber die Durchschnitskosten f\C3\BCr bestimmte Fahrleistungen pro Jahr.\0A\00"
@.str.1 = [54 x i8] c"\0AWie viel Kilometer sind Sie mit Ihrem PKW gefahren?\09\00"
@.str.2 = [51 x i8] c"Wie viel Liter Benzin haben Sie dabei verbraucht?\09\00"
@.str.3 = [42 x i8] c"Wie viel Euro kostet ein Liter Benzin?\09\09\09\00"
@.str.4 = [57 x i8] c"\0AWie viel Dollar kostet eine Gallone Benzin in den USA?\09\00"
@.str.5 = [54 x i8] c"Was ist der aktuelle Wechselkurs von Euro zu Dollar?\09\00"
@.str.6 = [62 x i8] c"\0A\0AAufgrund Ihrer Eingaben habe ich folgende Daten berechnet:\0A\00"
@.str.7 = [56 x i8] c"\0ASie haben %.2lf Liter Benzin pro Kilometer verbraucht.\00"
@.str.8 = [60 x i8] c"\0ADem entsprechen %.2lf gefahrene Meilen pro Gallone Benzin.\00"
@.str.9 = [77 x i8] c"\0ABei einem Literpreis von %.2lf Euro hat Sie die Fahrt %.2lf Euro gekostet.\0A\00"
@.str.10 = [96 x i8] c"\0ABeim Preis von %.2lf Dollar pro Gallone haette Sie die Fahrt in den USA %.2lf Dollar gekostet.\00"
@.str.11 = [71 x i8] c"\0ABeim Wechselkurs von %.2lf Euro pro Dollar entspricht das %.2lf Euro.\00"
@.str.12 = [99 x i8] c"\0ADie Differenz der Kosten fuer die Fahrt in Deutschland und in den USA betraegt somit %.2lf Euro.\0A\00"
@.str.13 = [67 x i8] c"\0AEin Kilometer Ihrer Fahrt hat in Deutschland %.2lf Euro gekostet.\00"
@.str.14 = [67 x i8] c"\0AEin Kilometer Ihrer Fahrt haette in den USA %.2lf Euro gekostet.\0A\00"
@.str.15 = [77 x i8] c"\0AIn den USA sind die Kosten fuer die Fahrt somit um %.2lf Prozent geringer.\0A\00"
@.str.16 = [99 x i8] c"\0AUmgerechnet auf eine durchschnittliche Fahrleistung pro Jahr ergeben sich daraus folgende Werte:\0A\00"
@.str.17 = [65 x i8] c"\0AGesamtkosten fuer 15000 Kilometer in Deutschland:\09 %12.2lf Euro\00"
@.str.18 = [62 x i8] c"\0AGesamtkosten fuer 15000 Kilometer in den USA:\09\09 %12.2lf Euro\00"
@.str.19 = [65 x i8] c"\0AGesamtkosten fuer 15000 Kilometer in den USA:\09\09 %12.2lf Dollar\0A\00"
@.str.20 = [61 x i8] c"\0AGesamtkosten fuer 15000 Meilen in den USA:\09\09 %12.2lf Dollar\00"
@.str.21 = [59 x i8] c"\0AGesamtkosten fuer 15000 Meilen in den USA:\09\09 %12.2lf Euro\00"
@.str.22 = [64 x i8] c"\0AGesamtkosten fuer 15000 Meilen in Deutschland:\09\09 %12.2lf Euro\0A\00"
define i32 @main() {
%1 = alloca i8*
%2 = alloca double
%3 = alloca double
%4 = alloca double
%5 = alloca double
%6 = alloca double
%7 = alloca double
%8 = alloca double
%9 = alloca double
%10 = alloca double
%11 = alloca double
%12 = alloca double
%13 = alloca double
%14 = alloca double
%15 = alloca double
%16 = alloca double
%17 = alloca double
%18 = alloca double
%19 = alloca double
%20 = alloca double
%21 = alloca double
%22 = alloca double
%23 = alloca double
%24 = alloca double
%25 = alloca double
%26 = alloca double
%27 = alloca double
%28 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([195 x i8], [195 x i8]* @.str, i64 0, i64 0))
store i8* getelementptr inbounds ([54 x i8], [54 x i8]* @.str.1, i64 0, i64 0), i8** %1
%29 = load i8*, i8** %1
%30 = call double @erfasse_gleitkomma_zahl(i8* %29, i32 0, i32 1000000)
store double %30, double* %2
store i8* getelementptr inbounds ([51 x i8], [51 x i8]* @.str.2, i64 0, i64 0), i8** %1
%31 = load i8*, i8** %1
%32 = call double @erfasse_gleitkomma_zahl(i8* %31, i32 0, i32 100000)
store double %32, double* %3
store double 1.237200e+00, double* %4
store i8* getelementptr inbounds ([42 x i8], [42 x i8]* @.str.3, i64 0, i64 0), i8** %1
%33 = load i8*, i8** %1
%34 = call double @erfasse_gleitkomma_zahl(i8* %33, i32 0, i32 20)
store double %34, double* %5
store i8* getelementptr inbounds ([57 x i8], [57 x i8]* @.str.4, i64 0, i64 0), i8** %1
%35 = load i8*, i8** %1
%36 = call double @erfasse_gleitkomma_zahl(i8* %35, i32 0, i32 20)
store double %36, double* %6
store i8* getelementptr inbounds ([54 x i8], [54 x i8]* @.str.5, i64 0, i64 0), i8** %1
%37 = load i8*, i8** %1
%38 = call double @erfasse_gleitkomma_zahl(i8* %37, i32 -100000, i32 100000)
store double %38, double* %4
%39 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([62 x i8], [62 x i8]* @.str.6, i64 0, i64 0))
%40 = load double, double* %2
%41 = load double, double* %3
%42 = call double @berechne_verbrauch_liter_pro_km(double %40, double %41)
store double %42, double* %7
%43 = load double, double* %2
%44 = load double, double* %3
%45 = call double @berechne_durchschnittsverbrauch_l_pro_100km(double %43, double %44)
store double %45, double* %8
%46 = load double, double* %8
%47 = call double @umrechnung_durchschnittsverbrauch(double %46)
store double %47, double* %9
%48 = load double, double* %7
%49 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([56 x i8], [56 x i8]* @.str.7, i64 0, i64 0), double %48)
%50 = load double, double* %9
%51 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([60 x i8], [60 x i8]* @.str.8, i64 0, i64 0), double %50)
%52 = load double, double* %3
%53 = load double, double* %5
%54 = call double @berechne_kosten_gesamt(double %52, double %53)
store double %54, double* %10
%55 = load double, double* %3
%56 = call double @umrechnung_l_in_us_gal(double %55)
store double %56, double* %11
%57 = load double, double* %11
%58 = load double, double* %6
%59 = call double @berechne_kosten_gesamt(double %57, double %58)
store double %59, double* %12
%60 = load double, double* %5
%61 = load double, double* %10
%62 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([77 x i8], [77 x i8]* @.str.9, i64 0, i64 0), double %60, double %61)
%63 = load double, double* %6
%64 = load double, double* %12
%65 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([96 x i8], [96 x i8]* @.str.10, i64 0, i64 0), double %63, double %64)
store double 8.141000e-01, double* %13
%66 = load double, double* %12
%67 = load double, double* %13
%68 = call double @umrechnung_us_dollar_in_euro(double %66, double %67)
store double %68, double* %14
%69 = load double, double* %10
%70 = load double, double* %14
%71 = fsub double %69, %70
store double %71, double* %15
%72 = load double, double* %13
%73 = load double, double* %14
%74 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([71 x i8], [71 x i8]* @.str.11, i64 0, i64 0), double %72, double %73)
%75 = load double, double* %15
%76 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([99 x i8], [99 x i8]* @.str.12, i64 0, i64 0), double %75)
%77 = load double, double* %2
%78 = load double, double* %10
%79 = call double @berechne_kosten_pro_einheit(double %77, double %78)
store double %79, double* %16
%80 = load double, double* %2
%81 = load double, double* %14
%82 = call double @berechne_kosten_pro_einheit(double %80, double %81)
store double %82, double* %17
%83 = load double, double* %16
%84 = load double, double* %17
%85 = call double @berechne_differenz_in_prozent(double %83, double %84)
store double %85, double* %18
%86 = load double, double* %16
%87 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([67 x i8], [67 x i8]* @.str.13, i64 0, i64 0), double %86)
%88 = load double, double* %17
%89 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([67 x i8], [67 x i8]* @.str.14, i64 0, i64 0), double %88)
%90 = load double, double* %18
%91 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([77 x i8], [77 x i8]* @.str.15, i64 0, i64 0), double %90)
store double 1.500000e+04, double* %19
%92 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([99 x i8], [99 x i8]* @.str.16, i64 0, i64 0))
%93 = load double, double* %19
%94 = load double, double* %16
%95 = call double @berechne_kosten_gesamt(double %93, double %94)
store double %95, double* %20
%96 = load double, double* %19
%97 = load double, double* %17
%98 = call double @berechne_kosten_gesamt(double %96, double %97)
store double %98, double* %21
%99 = load double, double* %21
%100 = load double, double* %4
%101 = call double @umrechnung_euro_in_us_dollar(double %99, double %100)
store double %101, double* %22
%102 = load double, double* %20
%103 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([65 x i8], [65 x i8]* @.str.17, i64 0, i64 0), double %102)
%104 = load double, double* %21
%105 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([62 x i8], [62 x i8]* @.str.18, i64 0, i64 0), double %104)
%106 = load double, double* %22
%107 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([65 x i8], [65 x i8]* @.str.19, i64 0, i64 0), double %106)
%108 = load double, double* %2
%109 = call double @umrechnung_km_in_land_mi(double %108)
store double %109, double* %23
%110 = load double, double* %23
%111 = load double, double* %12
%112 = call double @berechne_kosten_pro_einheit(double %110, double %111)
store double %112, double* %24
%113 = load double, double* %19
%114 = load double, double* %24
%115 = call double @berechne_kosten_gesamt(double %113, double %114)
store double %115, double* %25
%116 = load double, double* %25
%117 = load double, double* %13
%118 = call double @umrechnung_us_dollar_in_euro(double %116, double %117)
store double %118, double* %26
%119 = load double, double* %19
%120 = call double @umrechnung_land_mi_in_km(double %119)
store double %120, double* %2
%121 = load double, double* %2
%122 = load double, double* %16
%123 = call double @berechne_kosten_gesamt(double %121, double %122)
store double %123, double* %27
%124 = load double, double* %25
%125 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([61 x i8], [61 x i8]* @.str.20, i64 0, i64 0), double %124)
%126 = load double, double* %26
%127 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([59 x i8], [59 x i8]* @.str.21, i64 0, i64 0), double %126)
%128 = load double, double* %27
%129 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.22, i64 0, i64 0), double %128)
ret i32 0
}

LLVM IR (-O2):
@.str.1 = [54 x i8] c"\0AWie viel Kilometer sind Sie mit Ihrem PKW gefahren?\09\00"
@.str.2 = [51 x i8] c"Wie viel Liter Benzin haben Sie dabei verbraucht?\09\00"
@.str.3 = [42 x i8] c"Wie viel Euro kostet ein Liter Benzin?\09\09\09\00"
@.str.4 = [57 x i8] c"\0AWie viel Dollar kostet eine Gallone Benzin in den USA?\09\00"
@.str.5 = [54 x i8] c"Was ist der aktuelle Wechselkurs von Euro zu Dollar?\09\00"
@.str.7 = [56 x i8] c"\0ASie haben %.2lf Liter Benzin pro Kilometer verbraucht.\00"
@.str.8 = [60 x i8] c"\0ADem entsprechen %.2lf gefahrene Meilen pro Gallone Benzin.\00"
@.str.9 = [77 x i8] c"\0ABei einem Literpreis von %.2lf Euro hat Sie die Fahrt %.2lf Euro gekostet.\0A\00"
@.str.10 = [96 x i8] c"\0ABeim Preis von %.2lf Dollar pro Gallone haette Sie die Fahrt in den USA %.2lf Dollar gekostet.\00"
@.str.11 = [71 x i8] c"\0ABeim Wechselkurs von %.2lf Euro pro Dollar entspricht das %.2lf Euro.\00"
@.str.12 = [99 x i8] c"\0ADie Differenz der Kosten fuer die Fahrt in Deutschland und in den USA betraegt somit %.2lf Euro.\0A\00"
@.str.13 = [67 x i8] c"\0AEin Kilometer Ihrer Fahrt hat in Deutschland %.2lf Euro gekostet.\00"
@.str.14 = [67 x i8] c"\0AEin Kilometer Ihrer Fahrt haette in den USA %.2lf Euro gekostet.\0A\00"
@.str.15 = [77 x i8] c"\0AIn den USA sind die Kosten fuer die Fahrt somit um %.2lf Prozent geringer.\0A\00"
@.str.17 = [65 x i8] c"\0AGesamtkosten fuer 15000 Kilometer in Deutschland:\09 %12.2lf Euro\00"
@.str.18 = [62 x i8] c"\0AGesamtkosten fuer 15000 Kilometer in den USA:\09\09 %12.2lf Euro\00"
@.str.19 = [65 x i8] c"\0AGesamtkosten fuer 15000 Kilometer in den USA:\09\09 %12.2lf Dollar\0A\00"
@.str.20 = [61 x i8] c"\0AGesamtkosten fuer 15000 Meilen in den USA:\09\09 %12.2lf Dollar\00"
@.str.21 = [59 x i8] c"\0AGesamtkosten fuer 15000 Meilen in den USA:\09\09 %12.2lf Euro\00"
@.str.22 = [64 x i8] c"\0AGesamtkosten fuer 15000 Meilen in Deutschland:\09\09 %12.2lf Euro\0A\00"
@str = [194 x i8] c"\0ADieses Programm berechnet die Kosten f\C3\BCr eine Fahrt, rechnet diese in angloamerikanische Kennzahlen um und\0Agibt \C3\9Cbersicht \C3\BCber die Durchschnitskosten f\C3\BCr bestimmte Fahrleistungen pro Jahr.\00"
@str.23 = [61 x i8] c"\0A\0AAufgrund Ihrer Eingaben habe ich folgende Daten berechnet:\00"
@str.24 = [98 x i8] c"\0AUmgerechnet auf eine durchschnittliche Fahrleistung pro Jahr ergeben sich daraus folgende Werte:\00"
define i32 @main() {
%1 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([194 x i8], [194 x i8]* @str, i64 0, i64 0))
%2 = tail call double @erfasse_gleitkomma_zahl(i8* getelementptr inbounds ([54 x i8], [54 x i8]* @.str.1, i64 0, i64 0), i32 0, i32 1000000)
%3 = tail call double @erfasse_gleitkomma_zahl(i8* getelementptr inbounds ([51 x i8], [51 x i8]* @.str.2, i64 0, i64 0), i32 0, i32 100000)
%4 = tail call double @erfasse_gleitkomma_zahl(i8* getelementptr inbounds ([42 x i8], [42 x i8]* @.str.3, i64 0, i64 0), i32 0, i32 20)
%5 = tail call double @erfasse_gleitkomma_zahl(i8* getelementptr inbounds ([57 x i8], [57 x i8]* @.str.4, i64 0, i64 0), i32 0, i32 20)
%6 = tail call double @erfasse_gleitkomma_zahl(i8* getelementptr inbounds ([54 x i8], [54 x i8]* @.str.5, i64 0, i64 0), i32 -100000, i32 100000)
%7 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([61 x i8], [61 x i8]* @str.23, i64 0, i64 0))
%8 = tail call double @berechne_verbrauch_liter_pro_km(double %2, double %3)
%9 = tail call double @berechne_durchschnittsverbrauch_l_pro_100km(double %2, double %3)
%10 = tail call double @umrechnung_durchschnittsverbrauch(double %9)
%11 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([56 x i8], [56 x i8]* @.str.7, i64 0, i64 0), double %8)
%12 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([60 x i8], [60 x i8]* @.str.8, i64 0, i64 0), double %10)
%13 = tail call double @berechne_kosten_gesamt(double %3, double %4)
%14 = tail call double @umrechnung_l_in_us_gal(double %3)
%15 = tail call double @berechne_kosten_gesamt(double %14, double %5)
%16 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([77 x i8], [77 x i8]* @.str.9, i64 0, i64 0), double %4, double %13)
%17 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([96 x i8], [96 x i8]* @.str.10, i64 0, i64 0), double %5, double %15)
%18 = tail call double @umrechnung_us_dollar_in_euro(double %15, double 8.141000e-01)
%19 = fsub double %13, %18
%20 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([71 x i8], [71 x i8]* @.str.11, i64 0, i64 0), double 8.141000e-01, double %18)
%21 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([99 x i8], [99 x i8]* @.str.12, i64 0, i64 0), double %19)
%22 = tail call double @berechne_kosten_pro_einheit(double %2, double %13)
%23 = tail call double @berechne_kosten_pro_einheit(double %2, double %18)
%24 = tail call double @berechne_differenz_in_prozent(double %22, double %23)
%25 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([67 x i8], [67 x i8]* @.str.13, i64 0, i64 0), double %22)
%26 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([67 x i8], [67 x i8]* @.str.14, i64 0, i64 0), double %23)
%27 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([77 x i8], [77 x i8]* @.str.15, i64 0, i64 0), double %24)
%28 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([98 x i8], [98 x i8]* @str.24, i64 0, i64 0))
%29 = tail call double @berechne_kosten_gesamt(double 1.500000e+04, double %22)
%30 = tail call double @berechne_kosten_gesamt(double 1.500000e+04, double %23)
%31 = tail call double @umrechnung_euro_in_us_dollar(double %30, double %6)
%32 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([65 x i8], [65 x i8]* @.str.17, i64 0, i64 0), double %29)
%33 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([62 x i8], [62 x i8]* @.str.18, i64 0, i64 0), double %30)
%34 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([65 x i8], [65 x i8]* @.str.19, i64 0, i64 0), double %31)
%35 = tail call double @umrechnung_km_in_land_mi(double %2)
%36 = tail call double @berechne_kosten_pro_einheit(double %35, double %15)
%37 = tail call double @berechne_kosten_gesamt(double 1.500000e+04, double %36)
%38 = tail call double @umrechnung_us_dollar_in_euro(double %37, double 8.141000e-01)
%39 = tail call double @umrechnung_land_mi_in_km(double 1.500000e+04)
%40 = tail call double @berechne_kosten_gesamt(double %39, double %22)
%41 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([61 x i8], [61 x i8]* @.str.20, i64 0, i64 0), double %37)
%42 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([59 x i8], [59 x i8]* @.str.21, i64 0, i64 0), double %38)
%43 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([64 x i8], [64 x i8]* @.str.22, i64 0, i64 0), double %40)
ret i32 0
}