Использование WinSCP/Putty и получение бессмысленного выходного файла после запуска main.c

У меня есть 3 файла: main.c, makefile и h2o.h. Я использую WinSCP для передачи файлов по SSH и использую Putty для запуска make-файла. Все компилируется и выводится в файл, который я назвал main.txt. Однако этот вывод представляет собой набор бессмысленных символов.

Например: ÿÿ1íI‰С^H‰âHƒäðPTIÇAà @

Когда он должен вывести что-то вроде:

Поток 6 Поступил кислород, ожидание_H: 0, ожидание_H: 0

Поток 7 Вошел водород, ожидание_H: 0, ожидание_H: 0

Есть ли какое-то расшифрование, которое я должен записать, чтобы мой вывод был читабельным?

Я включил свой код для всех трех файлов ниже.

Спасибо

h2o.h:

#include <pthread.h>
#include <semaphore.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

#ifndef NUM_THREADS
#define NUM_THREADS 10
#endif

extern const unsigned int RAND_RANGE;

typedef struct _thread_data_t {
    int tid;//thread id
    int waiting_O;//waiting Oxygen
    int waiting_H;//waiting Hydrogen

} thread_data_t;

make-файл:

all: main.c h2o.h
    gcc -Wall -pthread -std=c99 -o main.txt main.c
    chmod 755 main
clean:
    -rm main

main.c

#include "h2o.h"

//the range of return values for getRandom() function is
//[-RAND_RANGE/2, RAND_RANGE/2]
const unsigned int RAND_RANGE = RAND_MAX>>10;

int waiting_O = 0;//number of oxygen waiting
int waiting_H = 0;//number of hydrogen waiting
sem_t a, b, mutex;
time_t t;
char debug = 0;//used to debug

int getRand();//returns a random int
void *oxygen(void *arg);//thread function for oxygen
void *hydrogen(void *arg);//thread function for hydrogen
void semwait(sem_t *sem);//error-checked semaphore wait
void semsignal(sem_t *sem);//error-checked semaphore signal

int main(int argc, char const *argv[]) {
    pthread_t threads[NUM_THREADS];
    thread_data_t thread_data[NUM_THREADS];
    int errorCheck;//used to error check thread creation

    //seed the random number generator
    srand((unsigned int)time(&t));

    //initialize semaphores
    if (sem_init(&mutex, 0, (unsigned int)1) < 0
        || sem_init(&a, 0, (unsigned int)0) < 0
        || sem_init(&b, 0, (unsigned int)0) < 0) {
        perror("sem_init");
        exit(EXIT_FAILURE);
    }

    if (debug) {
        /*
        * debug mode:
        *   oxygen 1
        *   hydrogen 1
        *   hydrogen 1 
        */
        thread_data[0].tid = 0;
        thread_data[0].waiting_O = 1;
        pthread_create(&threads[0], NULL, oxygen, &thread_data[0]);

        thread_data[1].tid = 1;
        thread_data[1].waiting_H = 1;
        pthread_create(&threads[1], NULL, hydrogen, &thread_data[1]);

        thread_data[2].tid = 2;
        thread_data[2].waiting_H = 1;
        pthread_create(&threads[2], NULL, hydrogen, &thread_data[2]);

        pthread_join(threads[0], NULL);
        pthread_join(threads[1], NULL);
        pthread_join(threads[2], NULL);
    } else {
        for (int i = 0; i < NUM_THREADS; i++) {

            void *thread_func;//the function to call

            thread_data[i].tid = i;//set thread id to current i value

            if (rand()%2 == 0) {//if random amount < 0
                thread_func = hydrogen;//make Oxygen
            } else {//else amount > 0
                thread_func = oxygen;//make hydrogen
            }
            if ((errorCheck = pthread_create(&threads[i], NULL, thread_func, &thread_data[i]))) {
                fprintf(stderr, "error: pthread_create, %d\n", errorCheck);
                return EXIT_FAILURE;
            }
        }


        sleep(1);

        for (int i = 0; i < NUM_THREADS; ++i) {
            if ((errorCheck = pthread_join(threads[i], NULL))) {
                fprintf(stderr, "error: pthread_join, %d\n", errorCheck);
            }
        }
/*
        if ((errorCheck = pthread_join(finalThread, NULL))) {
            fprintf(stderr, "error: pthread_join, %d\n", errorCheck);
        }
        */
    }
    printf("All molecules crossed barrier...CLEANING UP!\n");
    return EXIT_SUCCESS;
}

int getRand() {
    return ((rand() % RAND_RANGE) - RAND_RANGE/2);
}

void *oxygen(void *arg) {
    thread_data_t *data = (thread_data_t *)arg;
    semwait(&mutex);
    //waiting_O = waiting_O + data->amount;
    fflush(stdout);
    printf("Thread: %d oxygen proccess made\twaiting hydrogen: %d waiting oxygen: %d \n ", data->tid, data->waiting_H, data->waiting_O);
        if (data->waiting_H >= 2) {
            for(int i = 0; i<2; i++){
                semsignal(&b);
                printf("Thread %d oxygen released\n", data->tid); //if 2 hydrogen, release oxygen
                fflush(stdout);
            }
            data->waiting_H -=2;//decrease hydrogen count by 2
            semsignal(&mutex);
        } 
        else {
            data->waiting_O += 1;//if no 2 hydrogen, increase oxygen count by 1
            semsignal(&mutex);
            semwait(&a);
            printf("Thread %d oxygen Waits\n", data->tid);
        }
    printf("Thread %d oxygen complete \n", data->tid);
    pthread_exit(NULL);
}

void *hydrogen(void *arg) {
    thread_data_t *data = (thread_data_t *)arg;
    semwait(&mutex);
    fflush(stdout);
    printf("Thread %d hydrogen process made, waiting hydrogen: %d waiting oxygen: %d \n", data->tid, data->waiting_H, data->waiting_O); 
    if (data->waiting_H >= 1 && data->waiting_O >=1) { //if hydrogen 1 and oxygen 1, then can make h20
        for(int i =0; i<2 ;i++){
            semsignal(&b); //signals hydrogen
            printf("Thread %d Hydrogen Released\n", data->tid);
            fflush(stdout);
        }

        data->waiting_H -= 1;
        semsignal(&a);
        data->waiting_O -= 1;
        semsignal(&mutex);
    }
    else {
        data->waiting_H += 1;
        semsignal(&mutex);
        semwait(&b);
        printf("Thread %d Hydrogen Waits \n", data->tid);

    } 
    pthread_exit(NULL);
}

/*
*   Error-checked semaphore wait.
*/
void semwait(sem_t *sem) {
    if (sem_wait(sem) < 0) {
        perror("sem_wait");
        exit(EXIT_FAILURE);
    }
}

/*
*   Error-checked semaphore signal.
*/
void semsignal(sem_t *sem) {
    if (sem_post(sem) < 0) {
        perror("sem_post");
        exit(EXIT_FAILURE);
    }
}