#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*/ erfasse_zeichenkette(char *, char *, int);
int /*<<< orphan*/ printf(char *);
int /*<<< orphan*/ simuliere_vier_gewinnt(int, int, char *, char *);
int main(void) {
  printf("\n\nDas Spiel \"Vier gewinnt\" wird von zwei Spielern/Spielerinnen "
         "nach folgenden Regeln gespielt:\n\n"
         "Auf einem rechteckigen Spielbrett befinden sich n x m Felder, wobei "
         "n >= 7 und m >= 6 ist:\n\n"
         "|. . . . . . .| 1\n"
         "|. . . . . . .| 2\n"
         "|. . . . . . .| 3\n"
         "|X O . . . . .| .\n"
         "|X X O . . . X| .\n"
         "|X O X O . . O| m\n"
         " 1 2 3 . . . n\n\n"
         "Die Spieler/innen belegen die Felder abwechselnd mit Spielmarken "
         "ihrer “Farbe“. Dabei ist folgende Regel zu beachten:\n"
         "\n"
         "Eine Spielmarke darf nur dann auf ein Feld gesetzt werden, wenn es "
         "leer ist und alle Felder\n"
         "der entsprechenden Spalte, die sich unterhalb des Feldes befinden, "
         "bereits belegt sind.\n"
         "Gewonnen hat, wer zuerst vier Spielmarken der eigenen “Farbe“ "
         "horizontal, vertikal oder diagonal\n"
         "nebeneinander platziert hat.\n\n");
  char *ausgabetext = "Bitte die Breite des Spielfeldes angeben: ";
  int zeilen = 9;
  ausgabetext = "Bitte die Hohe des Spielfeldes angeben: ";
  int spalten = 9;
  int namen_laenge = 21;
  char spieler1[namen_laenge];
  char spieler2[namen_laenge];
  ausgabetext = "Spieler 1, bitte geben Sie ihren Namen ein: ";
  erfasse_zeichenkette(ausgabetext, spieler1, namen_laenge);
  ausgabetext = "Spieler 2, bitte geben Sie ihren Namen ein: ";
  erfasse_zeichenkette(ausgabetext, spieler2, namen_laenge);
  simuliere_vier_gewinnt(zeilen, spalten, spieler1, spieler2);
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
lea    0xec1(%rip),%rdi
call   1040 <printf@plt>
lea    0x11a0(%rip),%rax
mov    %rax,-0x8(%rbp)
movl   $0x9,-0xc(%rbp)
lea    0x11b9(%rip),%rax
mov    %rax,-0x8(%rbp)
movl   $0x9,-0x10(%rbp)
movl   $0x15,-0x14(%rbp)
mov    -0x14(%rbp),%eax
mov    %rsp,%rcx
mov    %rcx,-0x20(%rbp)
mov    %rax,%rcx
add    $0xf,%rcx
and    $0xfffffffffffffff0,%rcx
mov    %rsp,%rsi
sub    %rcx,%rsi
mov    %rsi,-0x40(%rbp)
mov    %rsi,%rsp
mov    %rax,-0x28(%rbp)
mov    -0x14(%rbp),%eax
mov    %rax,%rdx
add    $0xf,%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x38(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x30(%rbp)
lea    0x1184(%rip),%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x14(%rbp),%edx
call   1050 <erfasse_zeichenkette@plt>
mov    -0x38(%rbp),%rsi
lea    0x1196(%rip),%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x14(%rbp),%edx
call   1050 <erfasse_zeichenkette@plt>
mov    -0x40(%rbp),%rdx
mov    -0x38(%rbp),%rcx
mov    -0xc(%rbp),%edi
mov    -0x10(%rbp),%esi
call   1030 <simuliere_vier_gewinnt@plt>
mov    -0x20(%rbp),%rax
mov    %rax,%rsp
xor    %eax,%eax
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %r14
push   %rbx
sub    $0x38,%rsp
lea    0xf1c(%rip),%rdi
call   1040 <puts@plt>
lea    0xeb6(%rip),%rdi
lea    0x20(%rsp),%r14
mov    %r14,%rsi
mov    $0x15,%edx
call   1050 <erfasse_zeichenkette@plt>
lea    0xeca(%rip),%rdi
mov    %rsp,%rbx
mov    %rbx,%rsi
mov    $0x15,%edx
call   1050 <erfasse_zeichenkette@plt>
mov    $0x9,%edi
mov    $0x9,%esi
mov    %r14,%rdx
mov    %rbx,%rcx
call   1030 <simuliere_vier_gewinnt@plt>
xor    %eax,%eax
add    $0x38,%rsp
pop    %rbx
pop    %r14
ret

LLVM IR (-O0):
@.str = [747 x i8] c"\0A\0ADas Spiel \22Vier gewinnt\22 wird von zwei Spielern/Spielerinnen nach folgenden Regeln gespielt:\0A\0AAuf einem rechteckigen Spielbrett befinden sich n x m Felder, wobei n >= 7 und m >= 6 ist:\0A\0A|. . . . . . .| 1\0A|. . . . . . .| 2\0A|. . . . . . .| 3\0A|X O . . . . .| .\0A|X X O . . . X| .\0A|X O X O . . O| m\0A 1 2 3 . . . n\0A\0ADie Spieler/innen belegen die Felder abwechselnd mit Spielmarken ihrer \E2\80\9CFarbe\E2\80\9C. Dabei ist folgende Regel zu beachten:\0A\0AEine Spielmarke darf nur dann auf ein Feld gesetzt werden, wenn es leer ist und alle Felder\0Ader entsprechenden Spalte, die sich unterhalb des Feldes befinden, bereits belegt sind.\0AGewonnen hat, wer zuerst vier Spielmarken der eigenen \E2\80\9CFarbe\E2\80\9C horizontal, vertikal oder diagonal\0Anebeneinander platziert hat.\0A\0A\00"
@.str.1 = [43 x i8] c"Bitte die Breite des Spielfeldes angeben: \00"
@.str.2 = [41 x i8] c"Bitte die Hohe des Spielfeldes angeben: \00"
@.str.3 = [45 x i8] c"Spieler 1, bitte geben Sie ihren Namen ein: \00"
@.str.4 = [45 x i8] c"Spieler 2, bitte geben Sie ihren Namen ein: \00"
define i32 @main() {
%1 = alloca i8*
%2 = alloca i32
%3 = alloca i32
%4 = alloca i32
%5 = alloca i8*
%6 = alloca i64
%7 = alloca i64
%8 = call i32 @printf(i8* getelementptr inbounds ([747 x i8], [747 x i8]* @.str, i64 0, i64 0))
store i8* getelementptr inbounds ([43 x i8], [43 x i8]* @.str.1, i64 0, i64 0), i8** %1
store i32 9, i32* %2
store i8* getelementptr inbounds ([41 x i8], [41 x i8]* @.str.2, i64 0, i64 0), i8** %1
store i32 9, i32* %3
store i32 21, i32* %4
%9 = load i32, i32* %4
%10 = zext i32 %9 to i64
%11 = call i8* @llvm.stacksave()
store i8* %11, i8** %5
%12 = alloca i8, i64 %10
store i64 %10, i64* %6
%13 = load i32, i32* %4
%14 = zext i32 %13 to i64
%15 = alloca i8, i64 %14
store i64 %14, i64* %7
store i8* getelementptr inbounds ([45 x i8], [45 x i8]* @.str.3, i64 0, i64 0), i8** %1
%16 = load i8*, i8** %1
%17 = load i32, i32* %4
%18 = call i32 @erfasse_zeichenkette(i8* %16, i8* %12, i32 %17)
store i8* getelementptr inbounds ([45 x i8], [45 x i8]* @.str.4, i64 0, i64 0), i8** %1
%19 = load i8*, i8** %1
%20 = load i32, i32* %4
%21 = call i32 @erfasse_zeichenkette(i8* %19, i8* %15, i32 %20)
%22 = load i32, i32* %2
%23 = load i32, i32* %3
%24 = call i32 @simuliere_vier_gewinnt(i32 %22, i32 %23, i8* %12, i8* %15)
%25 = load i8*, i8** %5
ret i32 0
}

LLVM IR (-O2):
@.str.3 = [45 x i8] c"Spieler 1, bitte geben Sie ihren Namen ein: \00"
@.str.4 = [45 x i8] c"Spieler 2, bitte geben Sie ihren Namen ein: \00"
@str = [746 x i8] c"\0A\0ADas Spiel \22Vier gewinnt\22 wird von zwei Spielern/Spielerinnen nach folgenden Regeln gespielt:\0A\0AAuf einem rechteckigen Spielbrett befinden sich n x m Felder, wobei n >= 7 und m >= 6 ist:\0A\0A|. . . . . . .| 1\0A|. . . . . . .| 2\0A|. . . . . . .| 3\0A|X O . . . . .| .\0A|X X O . . . X| .\0A|X O X O . . O| m\0A 1 2 3 . . . n\0A\0ADie Spieler/innen belegen die Felder abwechselnd mit Spielmarken ihrer \E2\80\9CFarbe\E2\80\9C. Dabei ist folgende Regel zu beachten:\0A\0AEine Spielmarke darf nur dann auf ein Feld gesetzt werden, wenn es leer ist und alle Felder\0Ader entsprechenden Spalte, die sich unterhalb des Feldes befinden, bereits belegt sind.\0AGewonnen hat, wer zuerst vier Spielmarken der eigenen \E2\80\9CFarbe\E2\80\9C horizontal, vertikal oder diagonal\0Anebeneinander platziert hat.\0A\00"
define i32 @main() {
%1 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([746 x i8], [746 x i8]* @str, i64 0, i64 0))
%2 = alloca [21 x i8]
%3 = alloca [21 x i8]
%4 = getelementptr inbounds [21 x i8], [21 x i8]* %3, i64 0, i64 0
%5 = getelementptr inbounds [21 x i8], [21 x i8]* %2, i64 0, i64 0
%6 = call i32 @erfasse_zeichenkette(i8* getelementptr inbounds ([45 x i8], [45 x i8]* @.str.3, i64 0, i64 0), i8* %5, i32 21)
%7 = call i32 @erfasse_zeichenkette(i8* getelementptr inbounds ([45 x i8], [45 x i8]* @.str.4, i64 0, i64 0), i8* %4, i32 21)
%8 = call i32 @simuliere_vier_gewinnt(i32 9, i32 9, i8* %5, i8* %4)
ret i32 0
}