```cpp
#include <iostream>
#include <vector>
#include <sstream>
#include <string>
#include <algorithm>
#include <stdexcept>
#include <cmath>
#include <limits>
#include <numeric>
#include <unordered_map>
#include <cstdlib>
#include <ctime>

// Custom GCD function since std::gcd is available from C++17
static int gcd_custom(int a, int b) {
    while (b != 0) {
        int temp = a % b;
        a = b;
        b = temp;
    }
    return a;
}

// Method 1: Brute-force search
static void estimate_parameters_brute_force(const std::vector<int>& values, int& a, int& c, int& m) {
    int n = static_cast<int>(values.size());
    int max_val = *std::max_element(values.begin(), values.end());
    for (int prime = max_val + 1;; ++prime) {
        // Check if prime
        bool prime_flag = true;
        if (prime <= 1) continue;
        for (int i = 2; i <= static_cast<int>(std::sqrt(prime)); ++i) {
            if (prime % i == 0) { prime_flag = false; break; }
        }
        if (!prime_flag) continue;
        m = prime;
        break;
    }
    for (int candidate_a = 2; candidate_a < m; ++candidate_a) {
        for (int candidate_c = 0; candidate_c < m; ++candidate_c) {
            bool valid = true;
            for (int i = 0; i < n - 1; ++i) {
                long long temp = static_cast<long long>(candidate_a) * values[i] + candidate_c;
                int next = static_cast<int>(temp % m);
                if (next != values[i + 1]) {
                    valid = false;
                    break;
                }
            }
            if (valid) {
                a = candidate_a;
                c = candidate_c;
                return;
            }
        }
    }
    throw std::runtime_error("Brute-force method failed to find parameters.");
}

// Method 2: Linear regression
static void estimate_parameters_linear_regression(const std::vector<int>& values, int& a, int& c, int& m) {
    int n = static_cast<int>(values.size()) - 1;
    double sum_x = 0.0, sum_y = 0.0, sum_xy = 0.0, sum_x2 = 0.0;
    for (int i = 0; i < n; ++i) {
        sum_x += values[i];
        sum_y += values[i + 1];
        sum_xy += static_cast<double>(values[i]) * values[i + 1];
        sum_x2 += static_cast<double>(values[i]) * values[i];
    }
    double denominator = n * sum_x2 - sum_x * sum_x;
    if (std::abs(denominator) < 1e-10) throw std::runtime_error("Linear regression method failed due to zero denominator.");
    double a_double = (n * sum_xy - sum_x * sum_y) / denominator;
    a = static_cast<int>(std::round(a_double));

    // Find next prime for m
    int max_val = *std::max_element(values.begin(), values.end());
    for (int prime = max_val + 1;; ++prime) {
        bool prime_flag = true;
        if (prime <= 1) continue;
        for (int i = 2; i <= static_cast<int>(std::sqrt(prime)); ++i) {
            if (prime % i == 0) { prime_flag = false; break; }
        }
        if (prime_flag) {
            m = prime;
            break;
        }
    }
    c = static_cast<int>(std::round((values[1] - a_double * values[0])));
    c %= m;
    if (c < 0) c += m;
}

// Method 3: Matrix equations
static void estimate_parameters_matrix(const std::vector<int>& values, int& a, int& c, int& m) {
    int n = static_cast<int>(values.size()) - 1;
    if (n < 2) throw std::runtime_error("Matrix method requires at least 3 values.");
    int delta1 = values[1] - values[0];
    int delta2 = values[2] - values[1];
    if (delta1 == 0) throw std::runtime_error("Matrix method failed due to zero delta.");
    a = delta2 / delta1;

    // Find next prime for m
    int max_val = *std::max_element(values.begin(), values.end());
    for (int prime = max_val + 1;; ++prime) {
        bool prime_flag = true;
        if (prime <= 1) continue;
        for (int i = 2; i <= static_cast<int>(std::sqrt(prime)); ++i) {
            if (prime % i == 0) { prime_flag = false; break; }
        }
        if (prime_flag) {
            m = prime;
            break;
        }
    }
    c = (values[1] - a * values[0]) % m;
    if (c < 0) c += m;
}

// Method 4: Difference method
static void estimate_parameters_difference(const std::vector<int>& values, int& a, int& c, int& m) {
    int n = static_cast<int>(values.size()) - 1;
    std::vector<int> diffs;
    diffs.reserve(n);
    for (int i = 0; i < n; ++i) {
        diffs.push_back(values[i + 1] - values[i]);
    }
    int sum_diff = std::accumulate(diffs.begin(), diffs.end(), 0);
    a = sum_diff / n;

    // Find next prime for m
    int max_val = *std::max_element(values.begin(), values.end());
    for (int prime = max_val + 1;; ++prime) {
        bool prime_flag = true;
        if (prime <= 1) continue;
        for (int i = 2; i <= static_cast<int>(std::sqrt(prime)); ++i) {
            if (prime % i == 0) { prime_flag = false; break; }
        }
        if (prime_flag) {
            m = prime;
            break;
        }
    }
    c = diffs[0] - a * values[0];
    c %= m;
    if (c < 0) c += m;
}

// Method 5: Statistical methods
static void estimate_parameters_statistical(const std::vector<int>& values, int& a, int& c, int& m) {
    int n = static_cast<int>(values.size()) - 1;
    double mean_x = 0.0, mean_y = 0.0, var_x = 0.0, cov_xy = 0.0;
    for (int i = 0; i < n; ++i) mean_x += values[i];
    for (int i = 1; i <= n; ++i) mean_y += values[i];
    mean_x /= n;
    mean_y /= n;
    for (int i = 0; i < n; ++i) {
        var_x += (values[i] - mean_x) * (values[i] - mean_x);
        cov_xy += (values[i] - mean_x) * (values[i + 1] - mean_y);
    }
    if (std::abs(var_x) < 1e-10) throw std::runtime_error("Statistical method failed due to zero variance.");
    double a_double = cov_xy / var_x;
    a = static_cast<int>(std::round(a_double));

    // Find next prime for m
    int max_val = *std::max_element(values.begin(), values.end());
    for (int prime = max_val + 1;; ++prime) {
        bool prime_flag = true;
        if (prime <= 1) continue;
        for (int i = 2; i <= static_cast<int>(std::sqrt(prime)); ++i) {
            if (prime % i == 0) { prime_flag = false; break; }
        }
        if (prime_flag) {
            m = prime;
            break;
        }
    }
    double c_double = mean_y - a_double * mean_x;
    c = static_cast<int>(std::round(c_double)) % m;
    if (c < 0) c += m;
}

// Method 6: GCD-based estimation
static void estimate_parameters_gcd(const std::vector<int>& values, int& a, int& c, int& m) {
    int n = static_cast<int>(values.size());
    std::vector<int> diffs;
    diffs.reserve(n - 1);
    for (int i = 0; i < n - 1; ++i) {
        diffs.push_back(values[i + 1] - values[i]);
    }
    int gcd_val = gcd_custom(diffs[0], diffs[1]);
    for (int i = 2; i < static_cast<int>(diffs.size()); ++i) {
        gcd_val = gcd_custom(gcd_val, diffs[i]);
    }
    m = std::abs(gcd_val);
    if (m == 0) {
        m = 1;
    }
    a = 1; // Assuming a=1 for simplicity
    c = values[1] - a * values[0];
    c %= m;
    if (c < 0) c += m;
}

// Method 7: System of equations
static void estimate_parameters_system(const std::vector<int>& values, int& a, int& c, int& m) {
    if (values.size() < 3) throw std::runtime_error("System method requires at least 3 values.");
    int x0 = values[0], x1 = values[1], x2 = values[2];
    int max_val = std::max({ x0, x1, x2 });
    for (int possible_m = max_val + 1; possible_m <= max_val + 1000; ++possible_m) {
        bool prime_flag = true;
        if (possible_m <= 1) continue;
        for (int i = 2; i <= static_cast<int>(std::sqrt(possible_m)); ++i) {
            if (possible_m % i == 0) { prime_flag = false; break; }
        }
        if (!prime_flag) continue;
        // Solve for a using x1 = (a * x0 + c) mod m
        // and x2 = (a * x1 + c) mod m
        // Subtract: x2 - x1 ≡ a(x1 - x0) mod m
        int delta_x = (x1 - x0) % possible_m;
        if (delta_x < 0) delta_x += possible_m;
        int delta_y = (x2 - x1) % possible_m;
        if (delta_y < 0) delta_y += possible_m;
        int a_candidate = -1;
        // Find a such that (a * delta_x) ≡ delta_y mod m
        // Iterate through possible a
        for (int candidate_a = 0; candidate_a < possible_m; ++candidate_a) {
            if ((static_cast<long long>(candidate_a) * delta_x) % possible_m == delta_y) {
                a_candidate = candidate_a;
                break;
            }
        }
        if (a_candidate == -1) continue;
        int c_candidate = (x1 - a_candidate * x0) % possible_m;
        if (c_candidate < 0) c_candidate += possible_m;
        // Verify the next value
        if ((static_cast<long long>(a_candidate) * x1 + c_candidate) % possible_m != x2) {
            continue;
        }
        // If satisfied, set and return
        a = a_candidate;
        c = c_candidate;
        m = possible_m;
        return;
    }
    throw std::runtime_error("System method failed to find parameters.");
}

// Method 8: Period detection
static void estimate_parameters_period(const std::vector<int>& values, int& a, int& c, int& m) {
    std::unordered_map<int, int> seen;
    int period = 0;
    for (auto val : values) {
        if (seen.find(val) != seen.end()) {
            period = seen[val];
            break;
        }
        seen[val] = period++;
    }
    if (period == 0) {
        m = *std::max_element(values.begin(), values.end()) + 1;
    }
    else {
        m = period;
    }
    if (values.size() < 2) throw std::runtime_error("Period method requires at least 2 values.");
    a = (values[1] - values[0]) % m;
    if (a < 0) a += m;
    c = (values[1] - a * values[0]) % m;
    if (c < 0) c += m;
}

// Method 9: Voting algorithm
static void estimate_parameters_voting(const std::vector<int>& values, int& a, int& c, int& m) {
    if (values.size() < 3) throw std::runtime_error("Voting method requires at least 3 values.");
    std::unordered_map<int, int> a_votes;
    std::unordered_map<int, int> c_votes;
    int n = static_cast<int>(values.size());
    for (int i = 0; i < n - 1; ++i) {
        for (int j = i + 1; j < n; ++j) {
            int delta_x = values[j] - values[i];
            if (delta_x == 0) continue;
            int delta_prev = (i > 0) ? (values[i] - values[i - 1]) : 1; // Avoid division by zero
            if (delta_prev == 0) continue;
            int possible_a = (values[j] - values[i]) / delta_prev;
            a_votes[possible_a]++;
            int possible_c = values[j] - possible_a * values[i];
            c_votes[possible_c]++;
        }
    }
    if (a_votes.empty() || c_votes.empty()) throw std::runtime_error("Voting method failed to find parameters.");
    a = std::max_element(a_votes.begin(), a_votes.end(),
        [](const std::pair<int, int>& p1, const std::pair<int, int>& p2) -> bool {
            return p1.second < p2.second;
        })->first;
    c = std::max_element(c_votes.begin(), c_votes.end(),
        [](const std::pair<int, int>& p1, const std::pair<int, int>& p2) -> bool {
            return p1.second < p2.second;
        })->first;
    m = *std::max_element(values.begin(), values.end()) + 1;
}

// Method 10: Genetic algorithm-based estimation
static void estimate_parameters_genetic(const std::vector<int>& values, int& a, int& c, int& m) {
    struct Individual {
        int a;
        int c;
        int m;
        int fitness;
    };
    auto calculate_fitness = [&](const Individual& ind) -> int {
        int fitness = 0;
        for (size_t i = 0; i < values.size() - 1; ++i) {
            int computed = (static_cast<long long>(ind.a) * values[i] + ind.c) % ind.m;
            if (computed == values[i + 1]) fitness++;
        }
        return fitness;
        };
    // Initialize population
    int population_size = 50;
    std::vector<Individual> population(population_size);
    int max_val = *std::max_element(values.begin(), values.end());
    srand(static_cast<unsigned int>(time(0)));
    for (auto& ind : population) {
        ind.a = rand() % (max_val + 2) + 1;
        ind.c = rand() % (max_val + 2);
        ind.m = max_val + 1 + (rand() % 100);
        ind.fitness = calculate_fitness(ind);
    }
    // Evolution
    int generations = 1000;
    for (int g = 0; g < generations; ++g) {
        // Sort population by fitness
        std::sort(population.begin(), population.end(), [&](const Individual& x, const Individual& y) -> bool {
            return x.fitness > y.fitness;
            });
        // If perfect fitness, return
        if (population[0].fitness == static_cast<int>(values.size()) - 1) {
            a = population[0].a;
            c = population[0].c;
            m = population[0].m;
            return;
        }
        // Selection
        std::vector<Individual> new_population;
        for (int i = 0; i < population_size / 2; ++i) {
            new_population.push_back(population[i]);
        }
        // Crossover
        while (new_population.size() < static_cast<size_t>(population_size)) {
            int parent1 = rand() % (population_size / 2);
            int parent2 = rand() % (population_size / 2);
            Individual child;
            child.a = population[parent1].a;
            child.c = population[parent2].c;
            child.m = population[parent1].m;
            child.fitness = calculate_fitness(child);
            new_population.push_back(child);
        }
        // Mutation
        for (auto& ind : new_population) {
            if (rand() % 100 < 5) {
                ind.a = rand() % (max_val + 2) + 1;
            }
            if (rand() % 100 < 5) {
                ind.c = rand() % (max_val + 2);
            }
            if (rand() % 100 < 5) {
                ind.m = max_val + 1 + (rand() % 100);
            }
            ind.fitness = calculate_fitness(ind);
        }
        population = new_population;
    }
    // After generations, pick the best
    std::sort(population.begin(), population.end(), [&](const Individual& x, const Individual& y) -> bool {
        return x.fitness > y.fitness;
        });
    a = population[0].a;
    c = population[0].c;
    m = population[0].m;
}

// Method 11: Simulated annealing-based estimation
static void estimate_parameters_simulated_annealing(const std::vector<int>& values, int& a, int& c, int& m) {
    struct Parameters {
        int a;
        int c;
        int m;
    };
    auto calculate_fitness = [&](const Parameters& params) -> int {
        int fitness = 0;
        for (size_t i = 0; i < values.size() - 1; ++i) {
            int computed = (static_cast<long long>(params.a) * values[i] + params.c) % params.m;
            if (computed == values[i + 1]) fitness++;
        }
        return fitness;
        };
    // Initialize with random parameters
    int max_val = *std::max_element(values.begin(), values.end());
    Parameters current;
    current.a = rand() % (max_val + 2) + 1;
    current.c = rand() % (max_val + 2);
    current.m = max_val + 1 + (rand() % 100);
    int current_fitness = calculate_fitness(current);
    Parameters best = current;
    int best_fitness = current_fitness;
    double temperature = 100.0;
    double cooling_rate = 0.995;
    while (temperature > 1e-3) {
        // Generate neighbor
        Parameters neighbor = current;
        int choice = rand() % 3;
        if (choice == 0) {
            neighbor.a = rand() % (max_val + 2) + 1;
        }
        else if (choice == 1) {
            neighbor.c = rand() % (max_val + 2);
        }
        else {
            neighbor.m = max_val + 1 + (rand() % 100);
        }
        int neighbor_fitness = calculate_fitness(neighbor);
        int delta = neighbor_fitness - current_fitness;
        if (delta > 0 || (exp(delta / temperature) > ((double)rand() / RAND_MAX))) {
            current = neighbor;
            current_fitness = neighbor_fitness;
            if (current_fitness > best_fitness) {
                best = current;
                best_fitness = current_fitness;
            }
        }
        temperature *= cooling_rate;
    }
    a = best.a;
    c = best.c;
    m = best.m;
}

// Method 12: Autocorrelation-based estimation
static void estimate_parameters_autocorrelation(const std::vector<int>& values, int& a, int& c, int& m) {
    // Compute autocorrelation and estimate a and m
    // This is a heuristic method
    if (values.size() < 2) throw std::runtime_error("Autocorrelation method requires at least 2 values.");
    int max_val = *std::max_element(values.begin(), values.end());
    m = max_val + 1;
    // Estimate a
    a = (values[1] - values[0]) / (values[0] + 1); // Simple heuristic
    c = (values[1] - a * values[0]) % m;
    if (c < 0) c += m;
}

// Method 13: Frequency analysis
static void estimate_parameters_frequency(const std::vector<int>& values, int& a, int& c, int& m) {
    // Analyze frequency of differences to estimate a and c
    std::unordered_map<int, int> freq;
    for (size_t i = 0; i < values.size() - 1; ++i) {
        int diff = values[i + 1] - values[i];
        freq[diff]++;
    }
    int most_common_diff = 0;
    int max_freq = 0;
    for (auto& [key, val] : freq) {
        if (val > max_freq) {
            max_freq = val;
            most_common_diff = key;
        }
    }
    a = 1;
    c = most_common_diff;
    m = *std::max_element(values.begin(), values.end()) + 1;
}

// Method 14: Least squares modulo m
static void estimate_parameters_least_squares(const std::vector<int>& values, int& a, int& c, int& m) {
    // Apply least squares considering modulo m
    // This is an approximation method
    // Assume m is known or guess
    int max_val = *std::max_element(values.begin(), values.end());
    m = max_val + 1;
    double a_sum = 0.0, c_sum = 0.0;
    int n = static_cast<int>(values.size()) - 1;
    for (int i = 0; i < n; ++i) {
        a_sum += values[i] * values[i + 1];
        c_sum += values[i + 1];
    }
    double a_double = a_sum / (n * (max_val * max_val));
    a = static_cast<int>(std::round(a_double));
    c = static_cast<int>(std::round(static_cast<double>(c_sum) / n)) % m;
    if (c < 0) c += m;
}

// Method 15: Hidden Markov Model-based estimation
static void estimate_parameters_hmm(const std::vector<int>& values, int& a, int& c, int& m) {
    // Placeholder for HMM-based method
    // Implementing HMM is complex; use brute-force as fallback
    // For demonstration, we'll call the brute-force method
    // In practical scenarios, a proper HMM implementation should be used
    // Here, we simply throw an exception to indicate it's not implemented
    throw std::runtime_error("Hidden Markov Model-based estimation is not implemented. Using brute-force as fallback.");
}

// Additional utility methods

static bool is_prime(int number) {
    if (number <= 1) return false;
    if (number <= 3) return true;
    if (number % 2 == 0 || number % 3 == 0) return false;
    for (int i = 5; i * i <= number; i += 6) {
        if (number % i == 0 || number % (i + 2) == 0) return false;
    }
    return true;
}

static int next_prime_custom(int start) {
    int prime = start;
    while (true) {
        if (is_prime(prime)) return prime;
        ++prime;
    }
}

static std::vector<int> collect_user_input() {
    std::vector<int> values;
    while (true) {
        std::cout << "Enter values separated by commas: ";
        std::string input;
        std::getline(std::cin, input);
        std::stringstream ss(input);
        std::string value;
        bool has_error = false;
        std::vector<int> temp_values;
        while (std::getline(ss, value, ',')) {
            value.erase(std::remove_if(value.begin(), value.end(), ::isspace), value.end());
            try {
                if (value.empty()) throw std::invalid_argument("Empty value");
                temp_values.push_back(std::stoi(value));
            }
            catch (const std::invalid_argument&) {
                std::cout << "Invalid value: \"" << value << "\" is not a number." << std::endl;
                has_error = true;
                break;
            }
            catch (const std::out_of_range&) {
                std::cout << "Number \"" << value << "\" is out of range." << std::endl;
                has_error = true;
                break;
            }
        }
        if (!has_error && !temp_values.empty()) {
            values = temp_values;
            break;
        }
        else if (!has_error) {
            std::cout << "Input cannot be empty." << std::endl;
        }
        std::cout << "Please try again.\n" << std::endl;
    }
    return values;
}

// Method dispatcher
static void estimate_parameters(const std::vector<int>& values, int& a, int& c, int& m, int method) {
    switch (method) {
    case 1:
        estimate_parameters_brute_force(values, a, c, m);
        break;
    case 2:
        estimate_parameters_linear_regression(values, a, c, m);
        break;
    case 3:
        estimate_parameters_matrix(values, a, c, m);
        break;
    case 4:
        estimate_parameters_difference(values, a, c, m);
        break;
    case 5:
        estimate_parameters_statistical(values, a, c, m);
        break;
    case 6:
        estimate_parameters_gcd(values, a, c, m);
        break;
    case 7:
        estimate_parameters_system(values, a, c, m);
        break;
    case 8:
        estimate_parameters_period(values, a, c, m);
        break;
    case 9:
        estimate_parameters_voting(values, a, c, m);
        break;
    case 10:
        estimate_parameters_genetic(values, a, c, m);
        break;
    case 11:
        estimate_parameters_simulated_annealing(values, a, c, m);
        break;
    case 12:
        estimate_parameters_autocorrelation(values, a, c, m);
        break;
    case 13:
        estimate_parameters_frequency(values, a, c, m);
        break;
    case 14:
        estimate_parameters_least_squares(values, a, c, m);
        break;
    case 15:
        estimate_parameters_hmm(values, a, c, m);
        break;
    default:
        throw std::invalid_argument("Invalid method selected.");
    }
}

static std::vector<int> generate_lcg(int a, int c, int m, int seed, int count) {
    if (m <= 0) throw std::invalid_argument("Modulus m must be positive.");
    if (count <= 0) throw std::invalid_argument("Count must be positive.");
    std::vector<int> lcg_values;
    lcg_values.reserve(static_cast<size_t>(count));
    int x = seed;
    for (int i = 0; i < count; ++i) {
        long long temp = static_cast<long long>(a) * x + c;
        x = static_cast<int>(temp % m);
        lcg_values.push_back(x);
    }
    return lcg_values;
}

static bool validate_generated_values(const std::vector<int>& original, const std::vector<int>& generated) {
    if (original.size() != generated.size() || original.empty()) return false;
    int m = *std::max_element(generated.begin(), generated.end()) + 1;
    std::vector<int> counts(static_cast<size_t>(m), 0);
    for (const int num : generated) {
        if (num >= m) return false;
        counts[static_cast<size_t>(num)]++;
    }
    double expected_frequency = static_cast<double>(generated.size()) / m;
    const double tolerance = 0.10;
    for (const int count : counts) {
        if (std::abs(count - expected_frequency) > expected_frequency * tolerance) return false;
    }
    return true;
}

int main() {
    try {
        std::vector<int> values = collect_user_input();
        std::cout << "\nSelect parameter estimation method:\n";
        std::cout << "1. Brute-force search\n";
        std::cout << "2. Linear regression\n";
        std::cout << "3. Matrix equations\n";
        std::cout << "4. Difference method\n";
        std::cout << "5. Statistical methods\n";
        std::cout << "6. GCD-based estimation\n";
        std::cout << "7. System of equations\n";
        std::cout << "8. Period detection\n";
        std::cout << "9. Voting algorithm\n";
        std::cout << "10. Genetic algorithm\n";
        std::cout << "11. Simulated annealing\n";
        std::cout << "12. Autocorrelation-based estimation\n";
        std::cout << "13. Frequency analysis\n";
        std::cout << "14. Least squares modulo m\n";
        std::cout << "15. Hidden Markov Model-based estimation\n";
        std::cout << "Enter choice (1-15): ";
        int choice;
        if (!(std::cin >> choice)) throw std::invalid_argument("Invalid input.");
        std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
        if (choice < 1 || choice >15) throw std::invalid_argument("Choice must be between 1 and 15.");
        int a, c, m;
        estimate_parameters(values, a, c, m, choice);
        std::cout << "\nEstimated parameters LCG:\n";
        std::cout << "a = " << a << ", c = " << c << ", m = " << m << "\n" << std::endl;
        std::vector<int> generated_values = generate_lcg(a, c, m, values[0], static_cast<int>(values.size()));
        std::cout << "Generated Numbers:\n";
        for (const int v : generated_values) std::cout << v << " ";
        std::cout << "\n" << std::endl;
        bool is_valid = validate_generated_values(values, generated_values);
        std::cout << "Validation Result: " << (is_valid ? "Successful" : "Unsuccessful") << std::endl;
    }
    catch (const std::exception& e) {
        std::cerr << "\nError: " << e.what() << std::endl;
        return 1;
    }
    return 0;
}
```
Исправь ошибки
Серьезность	Код	Описание	Проект	Файл	Строка	Состояние подавления	Подробности
Ошибка (активно)	E0040	требуется идентификатор	LCGRegen	C:\Users\Admin\source\repos\LCGRegen\LCGRegen.cpp	462		
Ошибка (активно)	E0020	идентификатор "key" не определен	LCGRegen	C:\Users\Admin\source\repos\LCGRegen\LCGRegen.cpp	462		
Ошибка (активно)	E0017	требуется квадратная скобка "]"	LCGRegen	C:\Users\Admin\source\repos\LCGRegen\LCGRegen.cpp	462		
Ошибка (активно)	E0020	идентификатор "val" не определен	LCGRegen	C:\Users\Admin\source\repos\LCGRegen\LCGRegen.cpp	463		
Сообщение	lnt-arithmetic-overflow	Часть выражения может быть переполнена перед присвоением более широкому типу.	LCGRegen	C:\Users\Admin\source\repos\LCGRegen\LCGRegen.cpp	45		
Сообщение	lnt-arithmetic-overflow	Часть выражения может быть переполнена перед присвоением более широкому типу.	LCGRegen	C:\Users\Admin\source\repos\LCGRegen\LCGRegen.cpp	66		
Сообщение	lnt-arithmetic-overflow	Часть выражения может быть переполнена перед присвоением более широкому типу.	LCGRegen	C:\Users\Admin\source\repos\LCGRegen\LCGRegen.cpp	67		
Сообщение	lnt-arithmetic-overflow	Часть выражения может быть переполнена перед присвоением более широкому типу.	LCGRegen	C:\Users\Admin\source\repos\LCGRegen\LCGRegen.cpp	125		
Сообщение	lnt-arithmetic-overflow	Часть выражения может быть переполнена перед присвоением более широкому типу.	LCGRegen	C:\Users\Admin\source\repos\LCGRegen\LCGRegen.cpp	158		
Сообщение	lnt-arithmetic-overflow	Часть выражения может быть переполнена перед присвоением более широкому типу.	LCGRegen	C:\Users\Admin\source\repos\LCGRegen\LCGRegen.cpp	186		
Сообщение	lnt-arithmetic-overflow	Часть выражения может быть переполнена перед присвоением более широкому типу.	LCGRegen	C:\Users\Admin\source\repos\LCGRegen\LCGRegen.cpp	188		
Сообщение	lnt-arithmetic-overflow	Часть выражения может быть переполнена перед присвоением более широкому типу.	LCGRegen	C:\Users\Admin\source\repos\LCGRegen\LCGRegen.cpp	282		
Сообщение	lnt-uninitialized-local	Локальная переменная не инициализирована.	LCGRegen	C:\Users\Admin\source\repos\LCGRegen\LCGRegen.cpp	352		
Сообщение	lnt-uninitialized-local	Локальная переменная не инициализирована.	LCGRegen	C:\Users\Admin\source\repos\LCGRegen\LCGRegen.cpp	400		
Сообщение	lnt-arithmetic-overflow	Часть выражения может быть переполнена перед присвоением более широкому типу.	LCGRegen	C:\Users\Admin\source\repos\LCGRegen\LCGRegen.cpp	483		
Сообщение	lnt-arithmetic-overflow	Часть выражения может быть переполнена перед присвоением более широкому типу.	LCGRegen	C:\Users\Admin\source\repos\LCGRegen\LCGRegen.cpp	484