#include <iostream>
#include <algorithm> // For std::max
#include <vector>

using namespace std;

// Using a slightly larger size to be safe, or use vector based on N
const int MAX_SIZE = 131072; // 2^17
int dist[MAX_SIZE];
int best[MAX_SIZE];

void check(int x) {
    // We don't need to pass arrays if they are global
    while (x > 0) {
        int new_val = max(dist[2 * x] + best[2 * x], dist[2 * x + 1] + best[2 * x + 1]);

        // Pruning optimization: 
        // If the value hasn't changed, ancestors won't change either.
        if (best[x] == new_val) break;

        best[x] = new_val;
        x >>= 1; // Bitwise right shift (same as x = x / 2) but faster
    }
}

int main() {
    // 1. Fast I/O
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);

    int n, m;
    if (!(cin >> n >> m)) return 0;

    int limit = 1 << n; // 2. Bitwise shift for 2^n (O(1) calculation)

    // Initialize arrays
    // We can calculate initial 'best' values bottom-up efficiently
    // But keeping your logic structure for clarity:

    // Fill leaf nodes and dist
    for (int i = 0; i < limit * 2; i++) {
        dist[i] = 1;
        best[i] = 0; // Initialize 0 properly
    }

    // Your logic for initializing 'best' based on depth
    // (Optimized slightly to avoid pow inside loop)
    int i = 1;
    int x = n - 1;
    int next_power_of_2 = 2;

    while (i < limit) {
        if (i == next_power_of_2) {
            x--;
            next_power_of_2 <<= 1; // Multiply by 2
        }
        best[i] = x;
        i++;
    }

    int b, c;
    for (int k = 0; k < m; k++) {
        cin >> b >> c;
        dist[b] = c;

        check(b >> 1); // b >> 1 is b/2

        // 3. Use \n instead of endl
        cout << best[1] << "\n";
    }

    return 0;
}