#include <windows.h>
#include <stdio.h>
#include <stdint.h>
#include <stdbool.h>
#include <math.h>

#define MAX(a, b) ((a) > (b) ? (a) : (b))

bool is_prime(uint64_t number) {
  if (number % 2 == 0) return false;
  for (uint64_t i = 3; i <= (uint64_t)sqrt(number); i+=2) {
    if (number % i == 0) return false;
  }
  return true;
}

void prime_dividers(uint64_t last_numer, uint64_t *primes, size_t *primes_size) {
  uint32_t p_size = 0;
  primes[p_size++] = 2;
  for (uint64_t i = 3; i <= (uint64_t)(sqrt(last_numer)); i+=2) {
    bool prime_status = is_prime(i);
    if (prime_status) {
      primes[p_size++] = i;
    }
  }
  *primes_size = p_size;
}

int main() {
  HANDLE hStdIn = GetStdHandle(STD_INPUT_HANDLE);
  HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);
  uint64_t numbers[3];
  DWORD dwRead, dwWritten;

  BOOL bSuccess = ReadFile(
    hStdIn,
    numbers,
    sizeof(numbers),
    &dwRead,
    NULL
  );

  if (bSuccess && dwRead == sizeof(numbers)) {
    // printf("%d %d %d\n", numbers[0], numbers[1], numbers[2]);
    // fflush(stdout);

    numbers[0] = MAX(3, numbers[0]);
    if ((numbers[0] & 1) == 0) ++numbers[0];

    // printf("Proccess #%d: %lu %lu\n", sp, numbers[0], numbers[1]);

    uint32_t prime_counter = 0;
    uint32_t bro_counter = 0;
    uint64_t prev_prime = 2;
    uint64_t prime_divs[(uint32_t)sqrt(numbers[1])];
    size_t primes_size = 0;
    prime_dividers(numbers[1], prime_divs, &primes_size);

    // uint64_t *results = NULL;
    // uint64_t results[numbers[2]];
    // uint64_t results[2 * (uint32_t)sqrt(numbers[2] + 2)];
    // size_t size = 2 * (uint32_t)sqrt(numbers[2] + 2);
    size_t size = numbers[2] / 2;
    uint64_t *results = (uint64_t*) malloc(size * sizeof(uint64_t));
    if (results == NULL) {
      // Handle memory allocation failure
      perror("malloc failed");
      return 1; // Exit
    }
    // size_t size = 0;
    // size_t max_size = 2 * (uint32_t)sqrt(numbers[2] + 2);
    // results = malloc(max_size * sizeof(uint64_t));
    // if (results == NULL) {
    //   // Failed to allocate memory, can't continue.
    //   return 1;
    // }

    FILE *fptr;
    char filename[50];
    (void)snprintf(filename, sizeof(filename), "%llu.primes", numbers[0]);
    fptr = fopen(filename, "w");
    if (fptr == NULL) {
        printf("Error opening file!\n");
        return 1;
    }
    for (uint64_t i = numbers[0]; i < numbers[1]; i+=2) {
      bool prime_status = true;
      for (size_t j = 0; j < primes_size; ++j) {
        if (prime_divs[j] * prime_divs[j] > i) break;
        if (i % prime_divs[j] == 0) {
          prime_status = false;
          break;
        }
      }
      if (prime_status) {
        if (prev_prime == i - 2) {
          // printf("%lu %lu\n", prev_prime, i);
          if (bro_counter >= size) {
            size_t new_size = size * 2;
            if (new_size < bro_counter) {
              new_size = bro_counter;
            }
            // printf("Resizing needed: total_size (%zu) + elements_read (%zu) > size (%zu)\n", total_size, elements_read, size);
            // printf(" -> New size will be %zu\n", new_size);
            uint64_t* new_results = (uint64_t*) realloc(results, new_size * sizeof(uint64_t));
            if (new_results == NULL) {
              perror("realloc failed");
              free(results); // Free the old memory
              return 1;
            }
            results = new_results;
            size = new_size;
          }
          // printf("After copy: total_size = %zu, size = %zu\n\n", total_size, size);
          results[bro_counter] = i;
          bro_counter++;
          // size++;
          fprintf(fptr, "%lu %lu\n", prev_prime, i);
        }
        prev_prime = i;
        prime_counter++;
      }
    }
    fclose(fptr);

    if (size > 0) {
      WriteFile(hStdOut, results, sizeof(uint64_t) * bro_counter, &dwWritten, NULL);
    }
    free(results);
  }

  return 0;
}