void randomize(std::vector<int> &v) {
    static std::random_device rd{};
    static std::mt19937 gen{rd()};
    static std::uniform_real_distribution<> dis{};

    for (int &i : v) {
        i = dis(gen);
    }
}

static void VectorCreateBench(State &state) {
    for (auto _ : state) {
        std::vector<int> v;
        DoNotOptimize(v);
        (void)v;
    }
}

BENCHMARK(VectorCreateBench);

static void VectorOfRandomNumberBench(State &state) {
    for (auto _ : state) {
        std::vector<int> v;
        v.resize(state.range(0));

        DoNotOptimize(v);
        state.PauseTiming();
        randomize(v);
        state.ResumeTiming();
    }
}

BENCHMARK(VectorOfRandomNumberBench)->Range(1<<4,1<<10);

static void VectorAtBench(State &state) {
    std::vector<int> v;
    DoNotOptimize(v);

    int index = 0;

    for (auto _ : state) {
        state.PauseTiming();
            index++;
            v.resize(state.range(0));
            randomize(v);
            if(index >= state.range(0)) {
                index = 0;
            }
        state.ResumeTiming();
        v.at(index);
    }
}

BENCHMARK(VectorAtBench)->Range(1<<4,1<<10);

static void VectorSquareBracketsBench(State &state) {
    std::vector<int> v;
    DoNotOptimize(v);

    int index = 0;

    for (auto _ : state) {
        state.PauseTiming();
            index++;
            v.resize(state.range(0));
            randomize(v);
            if(index >= state.range(0)) {
                index = 0;
            }
        state.ResumeTiming();
        v[index];
    }
}

BENCHMARK(VectorSquareBracketsBench)->Range(1<<4,1<<10);

static void VectorFrontBench(State &state) {
    std::vector<int> v;
    DoNotOptimize(v);

    for (auto _ : state) {
        state.PauseTiming();
            v.resize(state.range(0));
            randomize(v);
        state.ResumeTiming();
        v.begin();
    }
}

BENCHMARK(VectorFrontBench)->Range(1<<4,1<<10);

static void VectorBackBench(State &state) {
    std::vector<int> v;
    DoNotOptimize(v);

    for (auto _ : state) {
        state.PauseTiming();
            v.resize(state.range(0));
            randomize(v);
        state.ResumeTiming();
        v.back();
    }
}

BENCHMARK(VectorBackBench)->Range(1<<4,1<<10);