Will parallelization in C have any benefit for me?

int main() {
    clock_t start = clock();

    Seed the PCG RNG
{
    pcg32_random_t rng;
    pcg32_srandom_r(&rng, time(NULL) ^ (intptr_t)&printf, (intptr_t)&rng);

    int lattice[64 * 64];  // Changed to 64x64 lattice

    int num_simulations = 50;
    int num_runs = 5; // Number of runs for each value of XCO

  /*
    SOME ARRAYS DEFINITIONS TO STORAGE DATA LATER ON
  */
	
    double COADSORPTION_PROBABILITY = 0.05;
	
    #pragma omp parallel
    {
        pcg32_random_t local_rng;
        int thread_num = omp_get_thread_num();
        pcg32_srandom_r(&local_rng, time(NULL) ^ thread_num, (intptr_t)&local_rng);
        
        #pragma omp for
        for (int i = 0; i < num_simulations; i++) {
            double XCO = i / (double)(num_simulations - 1);  // This ensures XCO ranges from 0 to 1
            XCO_values[i] = XCO;

            // Arrays to store the results of multiple runs for the same value of XCO
          

            for (int run = 0; run < num_runs; run++) {
                for (int j = 0; j < 64 * 64; j++) {
                    lattice[j] = EMPTY;
                }

                int co2_count = 0, n2_count = 0;

                // Warm-up phase
                for (int t = 0; t < 30000; t++) {
                    for (int k = 0; k < 64 * 64; k++) {
                        double r = ldexp(pcg32_random_r(&local_rng), -32);

                        if (r < XCO) {
                            double r1 = ldexp(pcg32_random_r(&local_rng), -32);
                            add_CO(lattice, &co2_count, COADSORPTION_PROBABILITY, r1);
                        } else {
                            add_NO_dissociate(lattice, &co2_count, &n2_count);                
                        }
                    }
                }

                // Data collection phase
                Coverage sum_coverage = {0};
                double sum_co2_rate = 0, sum_n2_rate = 0;
                int data_points = 0;

                for (int t = 0; t < 50000; t++) {
                    for (int k = 0; k < 64 * 64; k++) {
                        double r = ldexp(pcg32_random_r(&local_rng), -32);

                        if (r < XCO) {
                            double r1 = ldexp(pcg32_random_r(&local_rng), -32);
                            add_CO(lattice, &co2_count, COADSORPTION_PROBABILITY, r1);
                        } else {
                            add_NO_dissociate(lattice, &co2_count, &n2_count);  
                        }
                    }

                    if ((t+1) % 10 == 0) {  // Every 5 MCS (0-based indexing)
                        Coverage current_coverage = calculate_coverage(lattice);
                        sum_coverage.CO_coverage += current_coverage.CO_coverage;
                        sum_coverage.O_coverage += current_coverage.O_coverage;
                        sum_coverage.N_coverage += current_coverage.N_coverage;
                        
                        sum_co2_rate += (double)co2_count / (10 * 64 * 64);
                        sum_n2_rate += (double)n2_count / (10 * 64 * 64);
                        
                        co2_count = 0;  // Reset counters every 5 MCS
                        n2_count = 0;
                        
                        data_points++;
                    }
                }

                // Calculate averages
                co_coverages[run] = sum_coverage.CO_coverage / data_points;
                o_coverages[run] = sum_coverage.O_coverage / data_points;
                n_coverages[run] = sum_coverage.N_coverage / data_points;
                co2_rates[run] = sum_co2_rate / data_points;
                n2_rates[run] = sum_n2_rate / data_points;
            }

            // Calculate the mean and standard deviation of the coverages and rates of production for this value of XCO
            co_coverages_mean[i] = mean(co_coverages, num_runs);
            // OTHER COVERAGES MEANS

            co_coverages_std_dev[i] = std_dev(co_coverages, num_runs);
            // OTHER STANDARD DEVIATIONS
        }
    } // End of OpenMP parallel region

//Print the data in a txt file
    for (int i = 0; i < num_simulations; i++) {
        fprintf(file, "%f\t%f\t%f\t%f\t%f\t%f\t%f\t%f\t%f\t%f\t%f\n", XCO_values[i], co_coverages_mean[i], o_coverages_mean[i], n_coverages_mean[i], co2_rates_mean[i], n2_rates_mean[i], co_coverages_std_dev[i], o_coverages_std_dev[i], n_coverages_std_dev[i], co2_rates_std_dev[i], n2_rates_std_dev[i]);
    }

    fclose(file);
    printf("The results were printed in the file\n");
    clock_t end = clock();
    double cpu_time_used = ((double) (end - start)) / CLOCKS_PER_SEC;
    printf("Total runtime: %f seconds\n", cpu_time_used);

    return EXIT_SUCCESS;
}