#include <chrono>
#include <cstdint>
#include <iostream>
#include <thread>
#include <vector>
#include <weaver.h>

using std::chrono::nanoseconds;
using std::chrono::steady_clock;

int init() {
        int n = 0;
        std::cin >> n;
        return n;
}

int main() {
        std::vector<steady_clock::time_point> send_time;
        std::vector<steady_clock::time_point> recv_time;
        std::vector<uint64_t> received;

        int n = init();
        if (n <= 0) {
                std::cerr << "n must be positive\n";
                return 1;
        }

        received.resize(n);
        send_time.resize(n);
        recv_time.resize(n);

        THWeaver::EndpointQueue<uint64_t, 10> queue;
        queue.init();

        std::thread producer([&]() {
                for (int i = 0; i < n; ++i) {
                        while (queue.send(static_cast<uint64_t>(i + 1)) !=
                               THWeaver::EndpointQueueSendResult::Ok) {
                        }
                        send_time[i] = steady_clock::now();
                }
        });

        std::thread consumer([&]() {
                for (int i = 0; i < n; ++i) {
                        uint64_t value = 0;
                        while (queue.recv(value) !=
                               THWeaver::EndpointQueueRecvResult::Ok) {
                        }
                        recv_time[i] = steady_clock::now();
                        received[i] = value;
                }
        });

        producer.join();
        consumer.join();

        for (int i = 0; i < n; ++i) {
                uint64_t expected = static_cast<uint64_t>(i + 1);
                if (received[i] != expected) {
                        std::cerr << "mismatch at " << i << ": expected "
                                  << expected << ", got " << received[i]
                                  << "\n";
                        return 1;
                }
        }

        for (int i = 0; i < n; ++i) {
                nanoseconds duration = std::chrono::duration_cast<nanoseconds>(
                        recv_time[i] - send_time[i]);
                std::cout << (i + 1) << "," << duration.count() << "\n";
        }

        return 0;
}