<file_sep>CC = gcc
CFLAGS = -c -Wall
PROFILE_FLAGS = -fprofile-arcs -ftest-coverage
TST_LIBS = -lcheck -lm -lpthread -lrt -lsubunit
COV_LIBS = -lgcov -coverage
SRC_DIR= src
TST_DIR= tests
SRC_FILES = $(addprefix $(SRC_DIR)/, *.c) 
TST_FILES = $(addprefix $(TST_DIR)/, *.c)
GCOV = gcovr 
GCONV_FLAGS = -s -d


all: coverage

point.o:  $(SRC_FILES) $(addprefix $(SRC_DIR)/, point.h)
	$(CC) $(CFLAGS) $(PROFILE_FLAGS) $(SRC_FILES) 

check_point.o: $(TST_FILES)
	$(CC) $(CFLAGS) $(PROFILE_FLAGS)  $(TST_FILES) 

check_point_tests: point.o check_point.o
	$(CC) point.o check_point.o $(TST_LIBS) $(COV_LIBS) -o check_point_tests

test: check_point_tests
	./check_point_tests

coverage: test
	$(GCOV) $(GCONV_FLAGS)

coverage_report.html: test
	$(GCOV) $(GCONV_FLAGS) -o coverage_report.html

.PHONY: clean all

clean:
	-rm -rf *.o *.html *.gcda *.gcno check_point_tests
<file_sep>#include "mesinkar.h"
#include "mesinkata.h"
#include <stdio.h>

boolean EndKata;
Kata CKata;

void IgnoreBlank(){
    while (CC == BLANK){
        ADV();
    }
}

void STARTKATA(){
    START();
    IgnoreBlank();
    if (CC == MARK){
        EndKata = true;
    } else {
        EndKata = false;
        ADVKATA();
    }
}

void ADVKATA(){
    IgnoreBlank();
    if (CC == MARK && !EndKata){
        EndKata = true;
    } else{
        SalinKata();
        IgnoreBlank();
    }
}

void SalinKata(){
    int i = 0;
    while ((CC != MARK) && (CC != BLANK) && i != NMax) {
        CKata.TabKata[i] = CC;
        ADV();
        i++;
    }
    CKata.Length = (i < NMax) ? i : NMax;
}<file_sep>#include <stdio.h>
#include "arraypos.h"
#include "boolean.h"

void MakeEmpty (TabInt * T){
    IdxType i;
    for(i=IdxMin; i <= IdxMax; i++){
        T->TI[i] = ValUndef;
    }
    return;
}

int NbElmt (TabInt T){
    IdxType i, count=0;
    for(i=IdxMin; i < IdxMax+1; i++){
        if (T.TI[i] != ValUndef){
            count++;
        } else {
            break;
        }
    }
    return count - IdxMin;
}

int MaxNbEl (TabInt T){
    return (IdxMax-IdxMin+1);
}

IdxType GetFirstIdx (TabInt T){
    return IdxMin;
}

IdxType GetLastIdx (TabInt T){
    return IdxMin+NbElmt(T)-1;
}

boolean IsIdxValid (TabInt T, IdxType i){
    return (i >= IdxMin && i <= IdxMax);
}

boolean IsIdxEff (TabInt T, IdxType i){
    return (i >= GetFirstIdx(T) && i <= GetLastIdx(T));
}

boolean IsEmpty (TabInt T){
    return (NbElmt(T) == 0);
}

boolean IsFull (TabInt T){
    return (NbElmt(T) == MaxNbEl(T));
}

void BacaIsi (TabInt * T){

    MakeEmpty(T);
    
    int N;
    while (true){
        scanf("%d\n", &N);
        if (N >= 0 && N <= MaxNbEl(*T)){
            break;
        }
    }

    if (N > 0){
        int i=IdxMin;
        for(i=IdxMin;i < N; i++){
            scanf("%d\n", &(T->TI[i]));
        }
    }

    return;
}

void TulisIsiTab (TabInt T){
    printf("[");
    if (!IsEmpty(T)){
        int i;
        for (i=GetFirstIdx(T); i <= GetLastIdx(T); i++){
            printf("%d", T.TI[i]);
            
            if (i != GetLastIdx(T)){
                printf(",");
            }
        }
    }
    printf("]");
    return;
}

TabInt PlusMinusTab (TabInt T1, TabInt T2, boolean plus){
    TabInt result;
    MakeEmpty(&result);
    int i;
    for(i=GetFirstIdx(T1); i <= GetLastIdx(T1); i++){
        if (plus){
            Elmt(result, i) = Elmt(T1, i)+(Elmt(T2, i) != ValUndef ? Elmt(T2, i) : 0);
        } else {
            Elmt(result, i) = Elmt(T1, i)-(Elmt(T2, i) != ValUndef ? Elmt(T2, i) : 0);
        }
    }
    return result;
}

boolean IsEQ (TabInt T1, TabInt T2){
    if (NbElmt(T1) != NbElmt(T2)){
        return false;
    }

    boolean result = (NbElmt(T1) == NbElmt(T2));
    int i;
    for(i=GetFirstIdx(T1); i <= GetLastIdx(T1); i++){
        result = result && (Elmt(T1, i) == Elmt(T2, i));
    }
    return result;
}

IdxType Search1 (TabInt T, ElType X){
    if (IsEmpty(T)){
        return IdxUndef;
    }

    int i,result=IdxUndef;
    for(i=GetFirstIdx(T); i <= GetLastIdx(T); i++){
        if (Elmt(T, i) == X){
            result = i;
            break;
        } 
    }
    return result;
}

boolean SearchB (TabInt T, ElType X){
    if (IsEmpty(T)){
        return false;
    }
    boolean found = false;
    int i;
    for(i=GetFirstIdx(T); i <= GetLastIdx(T); i++){
        if (Elmt(T, i) == X){
            found = true;
            break;
        } 
    }
    return found;
}

void MaxMin (TabInt T, ElType * Max, ElType * Min){
    int nmax, nmin, i;
    nmin = Elmt(T, GetFirstIdx(T));
    nmax = Elmt(T, GetFirstIdx(T));
    for(i=GetFirstIdx(T); i <= GetLastIdx(T); i++){
        if (Elmt(T,i) > nmax){
            nmax = Elmt(T,i);
        } else if (Elmt(T,i) < nmin) {
            nmin = Elmt(T,i);
        }
    }
    *Max = nmax;
    *Min = nmin;
    return;
}

ElType SumTab (TabInt T){
    if (IsEmpty(T)){
        return 0;
    }

    int i,sum = 0;
    for(i=GetFirstIdx(T); i <= GetLastIdx(T); i++){
        sum += Elmt(T,i);
    }
    return sum;
}

int CountX (TabInt T, ElType X){
    if (IsEmpty(T)){
        return 0;
    }
    int i,count=0;
    for(i=GetFirstIdx(T); i <= GetLastIdx(T); i++){
        if(Elmt(T,i) == X){
            count += 1; 
        }
    };
    return count;
}

boolean IsAllGenap (TabInt T){
    boolean genap = true;
    int i = GetFirstIdx(T);
    while(genap && i <= GetLastIdx(T)){
        genap = (genap & (Elmt(T,i)%2 == 0));
        i++;
    }
    return genap;
    }

void Sort (TabInt * T, boolean asc){
    int i, j;
    IdxType key;

    for (i = GetFirstIdx(*T) + 1; i <= GetLastIdx(*T); i++){
        key = Elmt(*T, i);
        j = i-1;
        while (j >= GetFirstIdx(*T) && ((!asc && Elmt(*T,j) < key) || (asc && Elmt(*T,j) > key))){
            Elmt(*T,j+1) = Elmt(*T, j);
            j--;
        }
        Elmt(*T,j+1) = key;
    }
    return;
}

void AddAsLastEl (TabInt * T, ElType X){
    if (!IsFull(*T)) {
        T->TI[(GetLastIdx(*T)+1)] = X;
    }
    return;
}

void DelLastEl (TabInt * T, ElType * X){
    if (IsEmpty(*T)) return;

    *X = T->TI[GetLastIdx(*T)];
    T->TI[GetLastIdx(*T)] = ValUndef;
    return;
}<file_sep>#include "bintree.h"
#include <stdio.h>
#include <stdlib.h>

int main() {
    int N; //2^N
    scanf("%d", &N);

    if (N <= 0){
        printf("Jumlah masukan tidak sesuai\n");
        return 0;
    }

    int temp = N;
    while (N%2 == 0){
        N /= 2;
    }
    if (N != 1){
        printf("Jumlah masukan tidak sesuai\n");
        return 0;
    }
    

    int limit = (temp*2)-1;
    BinTree arr[limit];
    int i, j;
    for (i=0;i<temp;i++){
        int X;
        scanf("%d", &X);
        BinTree t = Tree(X,Nil,Nil);
        arr[i] = t;
    }

    j = 0;
    while (temp < limit){
        BinTree t1, t2, t;
        t1 = arr[j];
        t2 = arr[j+1];
        t  = Tree((Akar(t1)+Akar(t2)), t1, t2);
        arr[temp] = t;
        j += 2;
        temp += 1;
    }
    PrintTree(arr[limit-1], 2);
}<file_sep>#include <stdio.h>
#include <stdbool.h>

/*
NIM                 : 13519002
Nama                : <NAME>
Tanggal             : 27 Agustus 2020
Topik praktikum     : Pengenalan C
Deskripsi           : Program IP mahasiswa
*/


/* P r o t o t y p e */
bool IsWithinRange(float x, float min, float max);

/* V a r i a b e l   G l o b a l: tidak perlu ada */

int main(){
    /* Nama yang dipakai */
    int mhsw = 0, lulus = 0;
    float iptotal = 0.0F, ip;
    
    /* Baca */
    while (true){
        scanf("%f", &ip);
        if (ip == -999.0F){
            break;
        } else if (IsWithinRange(ip, 0.0F, 4.0F)) {
            iptotal += ip;
            mhsw += 1;
            if (IsWithinRange(ip, 2.75F, 4.0F)){
                lulus += 1;
            }
        }
    }
    if (mhsw != 0){
        printf("%d\n%d\n%d\n%.2f", mhsw, lulus, mhsw-lulus, (iptotal/mhsw));
    } else {
        printf("Tidak ada data");
    }

}

bool IsWithinRange(float x, float min, float max){
    return ((x >= min) && (x <= max));
}<file_sep>#include <stdio.h>

/*
NIM                 : 13519002
Nama                : <NAME>
Tanggal             : 27 Agustus 2020
Topik praktikum     : Pengenalan C
Deskripsi           : Mengonversi Suhu
*/

/* V a r i a b e l   G l o b a l: tidak perlu ada */

int main(){
    /* Nama yang dipakai */
    float c;
    char suhu;
    
    /* Baca */
    scanf("%f\n %c", &c, &suhu);

    /* Aplikasi Rumus dan Output */
    if (suhu == 'R'){
        printf("%.2f", 0.8F*c);
    } else if (suhu == 'F') {
        printf("%.2f", 1.8F*c+32);
    } else if (suhu == 'K') {
        printf("%.2f", c+273.15F);
    }

}<file_sep>#include "stacklist.h"
#include "boolean.h"
#include <stdio.h>
#include <stdlib.h>

void Alokasi (address *P, infotype X){
    *P = (address) malloc (sizeof(ElmtStack));
    if (*P != Nil){
        Info(*P) = X;
        Next(*P) = Nil;
    }
}

void Dealokasi (address  P){
    free(P);
}

boolean IsEmpty (Stack S){
    return Top(S) == Nil;
}

void CreateEmpty (Stack * S){
    Top(*S) = Nil;
}

void Push (Stack * S, infotype X){
    address A;
    Alokasi(&A, X);
    if (A == Nil) return;

    address first = Top(*S);
    Next(A) = first;
    Top(*S) = A;
}

void Pop (Stack * S, infotype * X){
    *X = InfoTop(*S);

    address deleted = Top(*S);
    Top(*S) = Next(deleted);
}<file_sep>#include "bintree.h"

void InvertBtree(BinTree *P){
    if (!IsTreeEmpty(*P)){
        InvertBtree(&(Left(*P)));
        InvertBtree(&(Right(*P)));
        *P = Tree(Akar(*P), Right(*P), Left(*P));
    }
}<file_sep>#include "listdp.h"
#include "boolean.h"
#include <stdio.h>
#include <stdlib.h>

boolean IsEmpty (List L){
    return (First(L) == Nil) && (Last(L) == Nil);
}

void CreateEmpty (List *L){
    First(*L) = Nil;
    Last(*L) = Nil;
}

address Alokasi (infotype X){
    address result;
    result = (address) malloc (sizeof(ElmtList));
    if (result != Nil){
        Info(result) = X;
        Next(result) = Nil;
        Prev(result) = Nil;
    }
    return result;
}

void Dealokasi (address P){
    free(P);
}

address Search (List L, infotype X){
    address now = First(L);
    while(now != Nil && Info(now)!=X){
        now = Next(now);
    }
    return now;
}

void InsVFirst (List *L, infotype X){
    address newfirst = Alokasi(X);
    if (newfirst != Nil){
        if (First(*L) == Nil){
            Last(*L) = newfirst;
        } else {
            Prev(First(*L)) = newfirst;
        }
        Next(newfirst) = First(*L);
        First(*L) = newfirst;
    }
}

void InsVLast (List *L, infotype X){
    address newlast = Alokasi(X);
    if (newlast != Nil){
        if (Last(*L) == Nil){
            First(*L) = newlast;
        } else {
            Next(Last(*L)) = newlast;
        }
        Prev(newlast) = Last(*L);
        Last(*L) = newlast;
    }
}

void DelVFirst (List *L, infotype *X){
    address deleted = First(*L);
    *X = Info(deleted);
    if (First(*L) == Last(*L)){
        First(*L) = Nil;
        Last(*L) = Nil;
        return;
    }
    Prev(Next(deleted)) = Nil;
    First(*L) = Next(deleted);
    Dealokasi(deleted);
}

void DelVLast (List *L, infotype *X){
    address deleted = Last(*L);
    *X = Info(deleted);
    if (First(*L) == Last(*L)){
        First(*L) = Nil;
        Last(*L) = Nil;
        return;
    }
    Next(Prev(deleted)) = Nil;
    Last(*L) = Prev(deleted);
    Dealokasi(deleted);
}

void InsertFirst (List *L, address P){
    address newfirst = P;
    if (First(*L) == Nil){
        Last(*L) = newfirst;
    } else {
        Prev(First(*L)) = newfirst;
    }
    Next(newfirst) = First(*L);
    First(*L) = newfirst;
}

void InsertLast (List *L, address P){
    address newlast = P;
    if (Last(*L) == Nil){
        First(*L) = newlast;
    } else {
        Next(Last(*L)) = newlast;
    }
    Prev(newlast) = Last(*L);
    Last(*L) = newlast;
}

void InsertAfter (List *L, address P, address Prec){
    if (Prec == Last(*L)){
        InsertLast(L, P);
    } else {
        Next(P) = Next(Prec);
        Prev(Next(Prec)) = P;
        Prev(P) = Prec;
        Next(Prec) = P;
    }
}

void InsertBefore (List *L, address P, address Succ){
    if (Succ == First(*L)){
        InsertFirst(L, P);
    } else {
        Prev(P) = Prev(Succ);
        Next(Prev(Succ)) = P;
        Next(P) = Succ;
        Prev(Succ) = P;
    }
}

void DelFirst (List *L, address *P){
    *P = First(*L);
    First(*L) = Next(*P);
    if (First(*L)==Nil){
        Last(*L) = Nil;
    } else {
        Prev(First(*L)) = Nil;
    }
}

void DelLast (List *L, address *P){
    *P = Last(*L);
    Last(*L) = Prev(*P);
    if(Last(*L)==Nil){
        First(*L) = Nil;
    } else {
        Next(Last(*L)) = Nil;
    }
}

void DelAfter (List *L, address *Pdel, address Prec){
    *Pdel = Next(Prec);
    if ((*Pdel) == First(*L)){
        DelFirst(L, Pdel);
    } else if ((*Pdel) == Last(*L)){
        DelLast(L, Pdel);
    } else {
        Prev(Next(*Pdel)) = Prec;
        Next(Prec) = Next(*Pdel);
    }
}

void DelP (List *L, infotype X){
    address cari = Search(*L, X);
    if (cari != Nil){
        if (cari == First(*L)){
            DelFirst(L, &cari);
        } else if (cari == Last(*L)){
            DelLast(L, &cari);
        } else {
            address dummy;
            DelAfter(L, &dummy, Prev(cari));
        }
    }
}

void DelBefore (List *L, address *Pdel, address Succ){
    *Pdel = Prev(Succ);
    if(*Pdel == First(*L)){
        DelFirst(L, Pdel);
    }else{
        DelAfter(L, Pdel, Prev(*Pdel));
    }
}


void PrintForward (List L){
    printf("[");
    if (!IsEmpty(L)){
        address now = First(L);
        while (now != Nil) {
            printf("%d", Info(now));
            now = Next(now);

            if (now != Nil)
                printf(",");
        }
    }
    printf("]");
}

void PrintBackward (List L){
    printf("[");
    if (!IsEmpty(L)){
        address now = Last(L);
        while (now != Nil) {
            printf("%d", Info(now));
            now = Prev(now);

            if (now != Nil)
                printf(",");
        }
    }
    printf("]");
}<file_sep>#include <stdio.h>
#include <stdbool.h>

/*
NIM                 : 13519002
Nama                : <NAME>
Tanggal             : 27 Agustus 2020
Topik praktikum     : Pengenalan C
Deskripsi           : Program Beasiswa
*/

/* V a r i a b e l   G l o b a l: tidak perlu ada */

int main(){
    /* Nama yang dipakai */
    float ip, pot;
    
    /* Baca */
    scanf("%f\n%f", &ip, &pot);

    /* Aplikasi */
    if (ip >= 3.5F){
        printf("%d", 4);
    } else if (ip < 3.5F && pot < 1.0F){
        printf("%d", 1);
    } else if (pot >= 1.0F && pot < 5.0F && ip < 3.5){
        if (ip < 2.0F){
            printf("%d", 2);
        } else {
            printf("%d", 3);
        }
    } else {
        printf("%d", 0);
    }

}<file_sep>#include "queuelist.h"
#include "boolean.h"
#include <stdio.h>
#include <stdlib.h>

void Alokasi (address *P, infotype X){
    *P = (address) malloc (sizeof(ElmtQueue));
    if (*P != Nil){
        Info(*P) = X;
        Next(*P) = Nil;
    }
}

void Dealokasi (address  P){
    free(P);
}

boolean IsEmpty (Queue Q){
    return Head(Q) == Nil && Tail(Q) == Nil;
}

int NbElmt(Queue Q){
    int n = 0;
    if (!IsEmpty(Q)){
        address now = Head(Q);
        while (now != Nil){
            n++;
            now = Next(now);
        }
    }
    return n;
}

void CreateEmpty(Queue * Q){
    Head(*Q) = Nil;
    Tail(*Q) = Nil;
}

void Enqueue (Queue * Q, infotype X){
    address A;
    Alokasi(&A, X);
    if (A == Nil) return;

    if (IsEmpty(*Q)){
        Head(*Q) = A;
        Tail(*Q) = A;
    } else {
        Next(A) = Nil;
        Next(Tail(*Q)) = A;
        Tail(*Q) = A;
    }
}

void Dequeue(Queue * Q, infotype * X){
    *X = InfoHead(*Q);
    Head(*Q) = Next(Head(*Q));
    if (Head(*Q) == Nil){
        Tail(*Q) = Nil;
    }
}
<file_sep>#include <stdio.h>
#include <stdlib.h>
#include "boolean.h"
#include "listsirkuler.h"

boolean IsEmpty (List L){
    return First(L) == Nil;
}

void CreateEmpty (List *L){
    First(*L) = Nil;
}

address Alokasi (infotype X){
    address P;
    P = (address) malloc (sizeof(ElmtList));
    if (P != Nil){
        Info(P) = X;
        Next(P) = Nil;
    }
    return P;
}

void Dealokasi (address P){
    free(P);
}

address Search (List L, infotype X){
    address P = First(L);
    if (P == Nil) return Nil;

    while(Next(P) != First(L) && Info(P) != X){
        P = Next(P);
    }

    if (Info(P) == X) return P;

    return Nil;
}

void InsVFirst (List *L, infotype X){
    address P = Alokasi(X);
    if (P != Nil){
        if (IsEmpty(*L)){
            First(*L) = P;
            Next(P) = P;
            
        } else {

            address Q = First(*L);
            Next(P) = First(*L);

            while(Next(Q) != First(*L)){
                Q = Next(Q);
            }

            Next(Q) = P;
            First(*L) = P;
        }
    }
}

void InsVLast (List *L, infotype X){
    InsVFirst(L, X);
    First(*L) = Next(First(*L));
}


void DelVFirst (List *L, infotype * X){
    First(*L) = Next(First(*L));
    DelVLast(L, X);
}

void DelVLast (List *L, infotype * X){
    address P;
    address Q = First(*L);

    while (Next(Next(Q)) != First(*L)){
        Q = Next(Q);
    }

    P = Next(Q);
    *X = Info(P);

    if (Next(Q) == First(*L)){
        CreateEmpty(L);
    } else {
        Next(Q) = First(*L);
    }

    Dealokasi(P);
}

void InsertFirst (List *L, address P){
    if (IsEmpty(*L)){
        
        First(*L) = P;
        Next(P) = P;
    } else {
        address Q = First(*L);
        Next(P) = First(*L);
        while (Next(Q) != First(*L)){
            Q = Next(Q);
        }

        Next(Q) = P;
        First(*L) = P;
    }
}

void InsertLast (List *L, address P){
    InsertFirst(L, P);
    First(*L) = Next(P);
}

void InsertAfter (List *L, address P, address Prec){
    address Q = First(*L);
    First(*L) = Next(Prec);

    InsertFirst(L, P);
    First(*L) = Q;
}

void DelFirst (List *L, address *P){
    First(*L) = Next(First(*L));
    DelLast(L, P);
}

void DelLast (List *L, address *P){
    address R = First(*L);
    address Q = R;

    while (Next(Next(Q)) != R){
        Q = Next(Q);
    }

    *P = Next(Q);

    if (Next(Q) == R){
        CreateEmpty(L);
    } else {
        Next(Q) = R;
    }
}

void DelAfter (List *L, address *Pdel, address Prec){
    address P = First(*L);
    First(*L) = Next(Next(Prec));

    DelLast(L, Pdel);
    First(*L) = P;
}

void DelP (List *L, infotype X){
    if(!IsEmpty(*L)){
        address Prec = First(*L);
        address dummy;

        if(Info(Prec) == X){
            DelFirst(L, &dummy);

        } else {
            while (Next(Prec) != First(*L) && Info(Next(Prec)) != X){
                Prec = Next(Prec);
            }

            if (Next(Prec) != First(*L)){
                DelAfter(L, &dummy, Prec);
            }
        }
    }
}

void PrintInfo (List L){
    printf("[");
    if (!IsEmpty(L)){
        address P = First(L);
        printf("%d", Info(P));

        while (Next(P) != First(L)){
            P = Next(P);
            printf(",%d", Info(P));
        }
    }
    printf("]");
}
<file_sep>#include <stdio.h>
#include <stdbool.h>

/*
NIM                 : 13519002
Nama                : <NAME>
Tanggal             : 27 Agustus 2020
Topik praktikum     : Pengenalan C
Deskripsi           : Gambar Belah Ketupat
*/


/* P r o t o t y p e */
bool IsValid(int x);
void GambarBelahKetupat(int x);

/* V a r i a b e l   G l o b a l: tidak perlu ada */

int main(){
    /* Nama yang dipakai */
    int n;
    
    /* Baca */
    scanf("%d", &n);
    if (IsValid(n) != true) {
        printf("Masukan tidak valid");
        return 0;
    }
    GambarBelahKetupat(n);

}

bool IsValid(int x){
    return ((x % 2 == 1) && (x > 0));
}

void GambarBelahKetupat(int x){
    if (x == 1){
        printf("*");
        return;
    }
    int i,j;

    for(i = 1; i <= x; i++) {
        if (i % 2 == 0) continue;
        for(j = 1; j <= (x-i)/2; j++)
            printf(" ");

        for(j = 1; j <= i; j++)
            printf("*");

        printf("\n");
    }
    for(i = 1; i <= x; i++) {
        if (i % 2 == 1) continue;
        for(j = 1; j <= i/2; j++)
            printf(" ");

        for(j = 1; j <= x-i; j++)
            printf("*");


        printf("\n");
    }
}<file_sep>#include "garis.h"
#include "point.h"
#include <stdio.h>

int main(){
    GARIS garis, garis2;
    BacaGARIS(&garis);
    TulisGARIS(garis);printf("\n");
    BacaGARIS(&garis2);
    TulisGARIS(garis2);printf("\n");
    if (IsTegakLurus(garis, garis2)) printf("yes");printf("\n");
    return 0;
}<file_sep>#include <stdio.h>

/*
NIM                 : 13519002
Nama                : <NAME>
Tanggal             : 27 Agustus 2020
Topik praktikum     : Pengenalan C
Deskripsi           : Nilai maksimal 3 bilangan
*/

/* P r o t o t y p e */
int maks(int a, int b);

/* V a r i a b e l   G l o b a l: tidak perlu ada */
int main(){
    /* Nama yang dipakai */
    int bil1, bil2, bil3, bilmaks;
    
    /* Baca */
    scanf("%d\n%d\n%d", &bil1, &bil2, &bil3);

    /* Maksimum */
    bilmaks = maks(maks(bil1, bil2), bil3);

    /* Output */
    printf("%d", bilmaks);

}

int maks(int a, int b){
    return ((a > b) ? a : b);
}