#include "koala.h"
#include "bits/stdc++.h"
using namespace std;

int minValue(int N, int W) {
    vector<int> A(N, 0);
    A[0] = 1;
    vector<int> B(N);
    playRound(A.data(), B.data());
    for (int i = 0; i < N; i++) {
        if (B[i] <= A[i]) {
            return i;
        }
    }
}

int maxValue(int N, int W) {
    vector<int> A(N, 1);
    vector<int> B(N);

    playRound(A.data(), B.data());
    // debug(B);
    playRound(B.data(), A.data());
    for (int i = 0; i < N; i++) {
        if (A[i] == 3) {
            A[i] = 4;
        } else {
            A[i] = 0;
        }
    }
    // debug(A);
    playRound(A.data(), B.data());
    // debug(B);
    for (int i = 0; i < N; i++) {
        if (B[i] == 5) {
            B[i] = 11;
        } else {
            B[i] = 0;
        }
    }
    playRound(B.data(), A.data());
    // debug(A);

    for (int i = 0; i < N; i++) {
        if (A[i] == 12) {
            return i;
        }
    }

    return 0;
}

int greaterValue(int N, int W) {
    vector<int> B(N);
    vector<int> R(N);
	int l = 1, r = 9;
	while (l != r) {
		int mid = (l + r) / 2;
		B[0] = B[1] = mid;
		playRound(B.data(), R.data());

		if (R[0] > mid && R[1] > mid) l = mid + 1;
		else if (R[0] <= mid && R[1] <= mid) r = mid - 1;
		else return (R[0] < R[1]);
	}
	B[0] = B[1] = l;
	playRound(B.data(), R.data());
	return (R[0] < R[1]);
}

int B[100];
int R[100];

void split(vector<int> v, int N, int W, int *P, int l = 1, int r = 100) {
	if (l == r) P[v[0]] = l;
	else {
		int x = min((int)sqrt(2 * l), W / (r - l + 1));

		fill(B, B + N, 0);
		for (int i : v) B[i] = x;

		playRound(B, R);
		vector<int> less, greater;
		for (int i : v)
			if (R[i] > x) greater.push_back(i);
			else less.push_back(i);

		split(less, N, W, P, l, l + less.size() - 1);
		split(greater, N, W, P, r - greater.size() + 1, r);
	}
}

void allValues(int N, int W, int *P) {
    if (W == 2*N) {
        struct x {
            int i;
            x(int i) : i(i) {}

            bool operator<(const x &other) const {
                memset(A, 0, sizeof(A));
                memset(B, 0, sizeof(B));
                A[i] = 100;
                A[other.i] = 100;
                playRound(A, B);
                return B[other.i] > 100;
            };
        };

        vector<x> a;
        for (int i = 0; i < N; i++) {
            a.emplace_back(i);
        }

        stable_sort(a.begin(), a.end());

        for (int i = 0; i < N; i++) {
            P[a[i].i] = i + 1;
        }
    } else {
        vector<int> v;
		for (int i = 0; i < N; i++) v.push_back(i);
		split(v, N, W, P);
    }
}

implementer.cpp: In function ‘void grader()’:
implementer.cpp:138:11: warning: ignoring return value of ‘int fscanf(FILE*, const char*, ...)’ declared with attribute ‘warn_unused_result’ [-Wunused-result]
  138 |     fscanf(fin, "%d %d %d",&F,&G,&maxQueries);
      |     ~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
implementer.cpp: In function ‘void runGame(int)’:
implementer.cpp:89:11: warning: ignoring return value of ‘int fscanf(FILE*, const char*, ...)’ declared with attribute ‘warn_unused_result’ [-Wunused-result]
   89 |     fscanf(fin,"%d %d",&N,&W);
      |     ~~~~~~^~~~~~~~~~~~~~~~~~~
implementer.cpp:91:15: warning: ignoring return value of ‘int fscanf(FILE*, const char*, ...)’ declared with attribute ‘warn_unused_result’ [-Wunused-result]
   91 |         fscanf(fin,"%d",&P[i]);
      |         ~~~~~~^~~~~~~~~~~~~~~~
answer.code: In member function ‘bool allValues(int, int, int*)::x::operator<(const allValues(int, int, int*)::x&) const’:
answer.code:100:24: error: ‘A’ was not declared in this scope
  100 |                 memset(A, 0, sizeof(A));
      |                        ^
answer.code: In function ‘int minValue(int, int)’:
answer.code:15:1: warning: control reaches end of non-void function [-Wreturn-type]
   15 | }
      | ^