package sprint4.tasks

import java.io.BufferedReader
import java.io.InputStreamReader
import java.util.*
import kotlin.math.min

private val coordModifiers =
    buildSet {
        for (x in 0..20)
            for (y in 0..20)
                if (x * x + y * y <= 400) {
                    add(x to y)
                    add(x to -y)
                    add(-x to y)
                    add(-x to -y)
                }
    }.toList()

data class Point(val x: Int, val y: Int)

private infix fun Int.to(other: Int) = Point(this, other)

private fun Point.checkDistance(other: Point): Boolean {
    val (curX, curY) = this
    var i = 0
    return generateSequence {
        if (i >= coordModifiers.size) {
            null
        } else {
            val curModifier = coordModifiers[i++]
            (curX + curModifier.x) to (curY + curModifier.y)
        }
    }
        .any { it.x == other.x && it.y == other.y }
}

fun main2() {
    val buffer = BufferedReader(InputStreamReader(System.`in`))

    val metroStations = buildMap<Int, Point> {
        repeat(buffer.readLine().toInt()) {
            val tokenizer = StringTokenizer(buffer.readLine())
            put(it + 1, tokenizer.nextToken().toInt() to tokenizer.nextToken().toInt())
        }
    }

    buildMap {
        repeat(buffer.readLine().toInt()) {
            val tokenizer = StringTokenizer(buffer.readLine())
            val busStation = tokenizer.nextToken().toInt() to tokenizer.nextToken().toInt()
            metroStations.forEach {
                if (it.value.checkDistance(busStation))
                    compute(it.key) { _, v -> (v ?: 0) + 1 }
            }
        }
    }
        .maxWith(compareBy<Map.Entry<Int, Int>> { it.value }.thenByDescending { it.key })
        .key
        .let(::println)
}

fun main4() {
    val buffer = BufferedReader(InputStreamReader(System.`in`))

    //Запоминаем все станции метро в формате точка=id
    val metroStations = buildMap<Point, Int> {
        repeat(buffer.readLine().toInt()) {
            val tokenizer = StringTokenizer(buffer.readLine())
            put(tokenizer.nextToken().toInt() to tokenizer.nextToken().toInt(), it + 1)
        }
    }

    //Формируем результат: id метро = кол-во автобусных остановок вокруг
    buildMap {
        repeat(buffer.readLine().toInt()) {
            val tokenizer = StringTokenizer(buffer.readLine())
            //Считываем координаты очередной автобусной остановки
            val curX = tokenizer.nextToken().toInt()
            val curY = tokenizer.nextToken().toInt()

            //перебираем все точки в округе 20 около автобусной остановки
            for (modifier in coordModifiers) {
                // проверяемая точка
                val potentialMetroStation = (curX + modifier.x) to (curY + modifier.y)
                // если в ней есть станция метро...
                if (metroStations[potentialMetroStation] != null) {
                    //...то в результирующей мапе для этой станции метро увеличиваем кол-во автобусных остановок
                    compute(metroStations[potentialMetroStation]!!) { _, v -> (v ?: 0) + 1 }
                }
            }
        }
    }
        // берём станцию, у которой максимальное кол-во остановок в округе
        .maxWith(compareBy<Map.Entry<Int, Int>> { it.value }.thenByDescending { it.key })
        .key
        .let(::println)
}

fun main() {
    val buffer = BufferedReader(InputStreamReader(System.`in`))

    //Запоминаем все станции метро в формате точка=id
    val metroStations = buildMap<Point, Int> {
        repeat(buffer.readLine().toInt()) {
            val tokenizer = StringTokenizer(buffer.readLine())
            put(tokenizer.nextToken().toInt() to tokenizer.nextToken().toInt(), it + 1)
        }
    }

    var maxedStation: Pair<Int, Int> = Pair(metroStations.values.first(), 0)

    //Формируем результат: id метро = кол-во автобусных остановок вокруг
    buildMap<Int, Int> {
        repeat(buffer.readLine().toInt()) {
            val tokenizer = StringTokenizer(buffer.readLine())
            //Считываем координаты очередной автобусной остановки
            val curX = tokenizer.nextToken().toInt()
            val curY = tokenizer.nextToken().toInt()

            //перебираем все точки в округе 20 около автобусной остановки
            for (modifier in coordModifiers) {
                // проверяемая точка
                val potentialMetroStation = (curX + modifier.x) to (curY + modifier.y)
                // если в ней есть станция метро...
                val potentialMetroStationId = metroStations[potentialMetroStation]
                if (potentialMetroStationId != null) {
                    val curCount = compute(potentialMetroStationId) { _, v -> (v ?: 0) + 1 }!!
                    maxedStation = when {
                        curCount > maxedStation.second -> Pair(potentialMetroStationId, curCount)
                        curCount == maxedStation.second -> Pair(
                            min(potentialMetroStationId, maxedStation.first),
                            curCount
                        )
                        else -> maxedStation
                    }

                }
            }
        }
    }
    println(maxedStation.first)
}


fun main3() {
    val buffer = BufferedReader(InputStreamReader(System.`in`))

    // ключ -- id станции, значение -- кол-во остановок рядом
    val result = mutableMapOf<Int, Int>()

    // индекс: ключ -- адрес точка, значение -- станции метро, которые близко к ней
    val index = buildMap<Point, MutableList<Int>> {
        repeat(buffer.readLine().toInt()) {
            val metroStationId = it + 1
            //Сначала заполняем результат: кол-во автобусных остановок пока неизвестно, поэтому 0
            result[metroStationId] = 0

            val tokenizer = StringTokenizer(buffer.readLine())
            val curX = tokenizer.nextToken().toInt()
            val curY = tokenizer.nextToken().toInt()

            //Станция метро находится по координатам (curX, curY)
            //Добавляем её в индекс для всех близлежащих точек
            for (modifier in coordModifiers) {
                // текущая обрабатываемая точка
                val indexedPoint = (curX + modifier.x) to (curY + modifier.y)
                compute(indexedPoint) { _, v ->
                    (v ?: mutableListOf()).apply { add(metroStationId) }
                }
            }
        }
    }

    val busStationCount = buffer.readLine().toInt()
    repeat(busStationCount) {
        val tokenizer = StringTokenizer(buffer.readLine())
        val curX = tokenizer.nextToken().toInt()
        val curY = tokenizer.nextToken().toInt()
        index[curX to curY]
            ?.forEach {
                if (result[it] != null)
                    result.compute(it) { _, v -> v!! + 1 }
            }
    }
    result.maxBy { it.value }.key.let(::println)
}