#include <bits/stdc++.h>
using namespace std;
class UnionFind {
    vector<int> parent;
    vector<int> rank;
    vector<int> maxStrength;
    
public:
    UnionFind(int n) {
        parent.resize(n + 1);
        rank.resize(n + 1, 0);
        maxStrength.resize(n + 1);
        for (int i = 1; i <= n; ++i) {
            parent[i] = i;
            maxStrength[i] = i; 
        }
    }

    int find(int u) {
        if (parent[u] != u) {
            parent[u] = find(parent[u]);
        }
        return parent[u];
    }

    void unionSets(int u, int v) {
        int rootU = find(u);
        int rootV = find(v);
        
        if (rootU != rootV) {
            if (rank[rootU] > rank[rootV]) {
                parent[rootV] = rootU;
                maxStrength[rootU] = max(maxStrength[rootU], maxStrength[rootV]);
            } else if (rank[rootU] < rank[rootV]) {
                parent[rootU] = rootV;
                maxStrength[rootV] = max(maxStrength[rootU], maxStrength[rootV]);
            } else {
                parent[rootV] = rootU;
                maxStrength[rootU] = max(maxStrength[rootU], maxStrength[rootV]);
                rank[rootU]++;
            }
        }
    }

    int getMaxStrength(int u) {
        return maxStrength[find(u)];
    }
};

vector<int> networkSums(int n, int e, vector<int>& from, vector<int>& to) {
    UnionFind uf(n);
    vector<int> results;
    int totalSum = 0;
    
    for (int i = 0; i < e; ++i) {
        int u = from[i];
        int v = to[i];
        uf.unionSets(u, v);

        unordered_set<int> uniqueRoots;
        totalSum = 0;
        
        for (int j = 1; j <= n; ++j) {
            uniqueRoots.insert(uf.find(j));
        }
        
        for (int root : uniqueRoots) {
            totalSum += uf.getMaxStrength(root);
        }
        
        results.push_back(totalSum);
    }
    
    return results;
}

def equalize(power):
    power.sort()
    n = len(power)
    median = power[n // 2] if n % 2 == 1 else (power[n // 2 - 1] + power[n // 2]) // 2
    total_time = sum(abs(p - median) for p in power)
    return total_time

def getMinimumTime(requestedServers, transitionTime):
    n = len(requestedServers)
    m = len(transitionTime)
    min_time = 0
    
    for i in range(1, n):
        current = requestedServers[i] - 1  
        previous = requestedServers[i-1] - 1  
        distance = min((current - previous) % m, (previous - current) % m)
        min_time += distance * transitionTime[previous]
    return min_time

#include <vector> 
#include <algorithm> 

int getMinimumTime(const std::vector<int>& requestedServers, const std::vector<int>& transitionTime) { 
    int n = requestedServers.size(); 
    int m = transitionTime.size(); 
    int min_time = 0; 

    for (int i = 1; i < n; i++) { 
        int current = requestedServers[i] - 1;   
        int previous = requestedServers[i - 1] - 1;   
        int distance = std::min((current - previous + m) % m, (previous - current + m) % m); 
        min_time += distance * transitionTime[previous]; 
    } 
     
    return min_time; 
}

import heapq

class GPUAllocator:
    def __init__(self):
        self.available_gpus = []
        self.max_gpu_id = 10**6
        self.next_gpu_id = 1
        self.add_gpus(self.max_gpu_id)

    def add_gpus(self, count):
        for _ in range(count):
            heapq.heappush(self.available_gpus, self.next_gpu_id)
            self.next_gpu_id += 1

    def smallestUnoccupied(self):
        if not self.available_gpus:
            self.add_gpus(100)
        return self.available_gpus[0] if self.available_gpus else -1

# Example usage
allocator = GPUAllocator()
print(allocator.smallestUnoccupied())
print(allocator.smallestUnoccupied())

from collections import defaultdict

def findOptimalResources(arr, k):
    n = len(arr)
    if k > n:
        return -1
    
    window_sum = 0
    max_sum = 0
    unique_elements = defaultdict(int)
    left = 0
    
    for right in range(n):
        window_sum += arr[right]
        unique_elements[arr[right]] += 1
        

        if right - left + 1 > k:
            window_sum -= arr[left]
            unique_elements[arr[left]] -= 1
            if unique_elements[arr[left]] == 0:
                del unique_elements[arr[left]]
            left += 1

        if right - left + 1 == k and len(unique_elements) == k:
            max_sum = max(max_sum, window_sum)
    
    return max_sum if max_sum != 0 else -1

long eqalize(vector<long>power)
{
  int n = power.size();
  sort(power.begin(), power.end());
  long val = 0;
  if (n % 2 == 1) {
    val = power[n / 2];
  }
  else {
    val = (power[(n - 1) / 2] + power[n / 2]) / 2;
  }
  long res = 0;
  for (long i = 0; i < n; ++i)
  {
    res += abs(power[i] - val);
  }
  return res;
}

SELECT 
    ROUND(
        (COUNT(CASE WHEN polygon_name = 'Adarsh Palm Retreat' THEN 1 END) * 100.0) / 
        COUNT(*),
        2
    ) AS order_share
FROM 
    POLYGON
WHERE 
    order_date = '2020-12-31';

SELECT 
    'within 100' AS BUCKET,
    COUNT(*) AS Orders
FROM cuisine_orders
WHERE item_total <= 100

UNION ALL

SELECT 
    'within 150' AS BUCKET,
    COUNT(*) AS Orders
FROM cuisine_orders
WHERE item_total <= 150

UNION ALL

SELECT 
    'within 200' AS BUCKET,
    COUNT(*) AS Orders
FROM cuisine_orders
WHERE item_total <= 200

ORDER BY BUCKET;

def minMoves(h, w, h1, w1):
    if h1 > h or w1 > w:
        return -1
    moves = 0
    while h > h1:
        h = (h + 1) // 2
        moves += 1 
    while w > w1:
        w = (w + 1) // 2
        moves += 1 
    return moves