Как ускорить код? Оптимизировать?

#include <iostream>
#include <vector>
 
using namespace std;
 
int main() {
    long long N, K, Q;
    cin >> N >> K >> Q;
    
    vector<int> perm(N);
    for (long long i = 0; i < N; ++i) {
        perm[i] = i + 1;
    }
 
    for (long long k_iter = 0; k_iter < K; ++k_iter) {
        long long k;
        cin >> k;
        long long block_len = 1 << k;
        vector<int> new_perm(N);
        for (long long i = 0; i < N; i += block_len * 2) {
            for (long long j = 0; j < block_len; ++j) {
                new_perm[i + j + block_len] = perm[i + j];
                new_perm[i + j] = perm[i + j + block_len];
            }
        }
        perm = new_perm;
    }
 
    for (long long q_iter = 0; q_iter < Q; ++q_iter) {
        long long q;
        cin >> q;
        cout << perm[q - 1] << endl;
    }
 
    return 0;
}

#include <iostream>
#include <vector>
#include <sstream>
#include <algorithm>
#include <iterator>
#include <numeric>
#include <cstring>
using namespace std;
 
struct Block{
    char* start;
    size_t size;
};
// block size must be equal
// buf size must be not less then block
void swap_block(Block lhs, Block rhs, char* buf){
    if (lhs.start == rhs.start)
        return;
    memcpy(buf, lhs.start, lhs.size);
    memcpy(lhs.start, rhs.start, lhs.size);
    memcpy(rhs.start, buf, rhs.size);
}
int main()
{
    unsigned i_exp;             // N = 2^i
    unsigned int elements_c;    // N - количество элементов в последовательности (перестановке)
    unsigned int operations_c;  // Q - количество операций
    unsigned int positions_c;   // K - количество позиций выборки
    cin >> i_exp >> operations_c >> positions_c;
    elements_c = (1u << i_exp);
    
    vector<int> seq(elements_c);
    iota(seq.begin(), seq.end(), 1);
    
    // test sequence
    // copy(seq.begin(), seq.end(), ostream_iterator<int>(cout, " "));
    for(size_t i = 0; i != operations_c; ++i){
        unsigned int block_size;
        cin >> block_size;
        // block size (in elements)
        // cout << "Block size : " << (1u << block_size) << " elements" << endl ;
        unsigned int blocks = elements_c / (1u << block_size);
        block_size = (1 << block_size) * sizeof(decltype(seq)::value_type);
        // cout << "Blocks : " << blocks << endl;
        char *seq_begin = reinterpret_cast<char*>(&seq[0]);
        char *buf = new char[block_size];
        for(size_t j = 0; j < blocks/2; ++j)
            swap_block(Block{seq_begin + j*2*block_size, block_size}, Block{seq_begin + (j*2+1)*block_size, block_size}, buf);
        delete [] buf;
        // test sequence after swap
        // copy(seq.begin(), seq.end(), ostream_iterator<int>(cout, " "));
        // cout << endl;
    }
 
    for(size_t i = 0; i != positions_c; ++i){    
        unsigned int pos;
        cin >> pos;
        cout << seq[pos-1] << endl;
    }
}