import kotlin.math.abs

fun main() {
    val r = System.`in`.bufferedReader()
    //val s = StringBuilder()
    //val n = r.readLine()!!.toInt()
    //val l = r.readLine()!!.split(" ").map { it.toInt() }
    //val n = r.readLine()!!.toInt()
    val (a, b, s) = r.readLine()!!.split(" ").map { it.toLong() }.sorted()
    println(if ((s-a-b)%2==0L && s>= abs(a)+ abs(b)) "Yes" else "No")
}


import kotlin.random.Random.Default.nextLong

val br = System.`in`.bufferedReader()
fun readInt() = br.readLine()!!.toInt()
fun readInts() = br.readLine()!!.split(" ").map { it.toInt() }
fun readLongs() = br.readLine()!!.split(" ").map { it.toLong() }

tailrec fun gcd(a: Long, b: Long): Long = if (b == 0L) a else gcd(b, a % b)

class segTree(
    val leftMost: Int,
    val rightMost: Int,
    var leftChild: segTree? = null,
    var rightChild: segTree? = null,
    var value: Long = 0L,  // can put more data here
    var size: Int = 1,  // should be rightMost - leftMost + 1
    var toProp: Long = 0L
) {

    constructor(tl: Int, tr: Int, a: List<Int>) : this(leftMost = tl, rightMost = tr) {
        if (tl == tr) {
            value = a[tl].toLong()
        } else {
            val mid = (tl + tr) / 2
            leftChild = segTree(tl, mid, a)
            rightChild = segTree(mid + 1, tr, a)
            size = tr - tl + 1
            recalc()
        }
    }

    // can change to other function, not just for sum (also change rangeSum function)
    // function does: combine two child to get parent's data
    fun recalc() {
        if (leftMost == rightMost) return
        else value = leftChild!!.value + rightChild!!.value
    }

    // should not be leaf
    fun prop() {
        leftChild
    }

    fun pointUpdate(index: Int, newVal: Long) {
        if (leftMost == rightMost) {
            value = newVal; return
        } // leaf node, just update value
        if (index <= leftChild!!.rightMost) leftChild!!.pointUpdate(index, newVal)
        else rightChild!!.pointUpdate(index, newVal)
        // child may change, so recalculate value
        recalc()
    }

    fun rangeQuery(l: Int, r: Int): Long {
        // entirely disjoint
        if (l > rightMost || r < leftMost) return 0L
        // covers us
        if (l <= leftMost && rightMost <= r) return value
        // we don't know
        return leftChild!!.rangeQuery(l, r) + rightChild!!.rangeQuery(l, r)
    }
}

// Range update (lazy propagetino),  range sum (log n time)
class Treap(
    var key: Long,  // key
    val priority: Long,  // priority
    val kids: MutableList<Treap?> = MutableList(2) { null },
    var subtreeSize: Long = 0,
    var sum: Long = 0L,  // upper treap use sum
    var toProp: Long = 0L
) {

    // return size of subtree (include this node)
    fun size(t: Treap?) = t?.subtreeSize ?: 0

    // update subtreeSize and sum for this node.  so what is sum,
    private fun recalc(t: Treap?) {
        if (t == null) return
        t.subtreeSize = 1
        t.sum =
            t.key + t.toProp * size(t)  // when should propagate data ???? so size should be 1 because just set it subtreeSize to 1
        t.kids.forEach {
            if (it != null) {
                t.subtreeSize += it.subtreeSize; t.sum += it.key + it.toProp * size(it)
            }
        }
    }

    // when range update, first split treap to three part(mostly), int middle part, update all value with some number by lazy propagation
    private fun prop(t: Treap?) {
        if (t == null || t.toProp == 0L) return
        t.kids.forEach { if (it != null) it.toProp += t.toProp }  // propagate to child
        t.key += t.toProp  // also propagate to itself
        t.toProp = 0L  // clear propagate value after propagate
        recalc(t)  // will sum change ??? : kid may have change value
    }

    private fun split(t: Treap?, nInLeft: Long): List<Treap?> {
        if (t == null) return List(2) { null }
        prop(t) // before make any change, propagate value to child
        if (size(t.kids[0]) >= nInLeft) {  // Treap t(this one) is in right half of treap
            val (left, right) = split(t.kids[0], nInLeft)  // keep split left treap because it has more treap
            t.kids[0] = right
            recalc(t)  // any time make change, should recalculate treap
            return listOf(left, t)  // left should have iInLeft treap in it.
        } else {
            // Treap t(this one) is in left half of treap, t's right child should return [nInLeft - size(t.kids[0]) - 1] treap to make total of nInLeft in first return treap
            // split result can be null when nInLeft = size(t.kids[0]) + 1, right child return null
            val (left, right) = split(t.kids[1], nInLeft - size(t.kids[0]) - 1)
            t.kids[1] = left
            recalc(t)  // any time make change, should recalculate treap
            return listOf(t, right)
        }
    }

    // for insert treap
    fun merge(l: Treap?, r: Treap?): Treap? {
        if (l == null) return r
        if (r == null) return l
        prop(l)  // before use, propagate value
        prop(r)// before use, propagate value
        if (l.priority < r.priority) {  // l should on the top, l's right child become merge result of l's right child and r
            l.kids[1] = merge(l.kids[1], r)
            recalc(l)  // after change, recalculate value
            return l
        } else {
            r.kids[0] = merge(l, r.kids[0])
            recalc(r)  // after change, recalculate value
            return r
        }
    }

    // l and r in 0..n-1 where n is number of treap
    fun rangeAdd(t: Treap?, l: Long, r: Long, toAdd: Long): Treap {
        assert(t != null)
        val (a, b) = split(t, l)
        val (c, d) = split(b, r - l + 1)  // treap become a c d, and c is which  we want to update
        c!!.toProp += toAdd  // c should not be null here
        return merge(a, merge(c, d))!!  // this should not null
    }

    fun rangeSum(t: Treap, l: Long, r: Long): Pair<Treap, Long> {
        // before split, should propagate t's toProp.
        val (a, b) = split(t, l)
        val (c, d) = split(b, r - l + 1)  // treap become a c d, and c is include sum we need
        val rootTreap = merge(a, merge(c, d))
        return Pair(rootTreap!!, c!!.sum)
    }
}

fun main() {
    val sb = StringBuilder()
    //repeat(readInt()) {
    // special case, use dp,
    // op: << +1/+0, << +1/+0,
    // 10010010...10001
    //   0+0 -> delete
    //   0+1 -> len++
    //   1+0 -> not know
    //   1+1 -> len++
    // 101001   10 101001 001 || 101001 001  || 10 101001
    // first remove right zero
    // then add some number and end with 1
    // then reverse
    // then add some number and end with 1
    // then reverse
    // 前后都加 -》顺序不变 -》 substr 即可
    // 只加后面，反向 substr 并且 刚好是末尾
    // 末尾是0不行，除非刚开始就一样
    var (x, y) = readLongs()
    fun stringToNum(s: String): Long {
        var ans = 0L
        for (i in s.length - 1 downTo 0) {
            if (s[i] == '1') ans += 1 shl (s.length - 1 - i)
        }
        return ans
    }

    var c = x  // plus 0
    while (c % 2 == 0L) c /= 2
    val d = stringToNum(c.toString(2).reversed())  // plus 0 reverse
    val a = (x shl 1) +1  // plus 1
    val b = stringToNum(a.toString(2).reversed())
    fun sub(a: Long, b: Long): Boolean {
        val stra = a.toString(2)
        val strb = b.toString(2)
        if (stra.length>strb.length) return false
        val mid = stra.length
        var check = false
        //println("$stra, $strb")
        for (i in 0.. strb.length-stra.length){  // 1 front
            //println("enter")
            var ans = true
            for (j in 0 until i) if (strb[j]!='1') ans = false
            for (j in i until i+stra.length) if (strb[j]!=stra[j-i]) ans = false
            for (j in i+stra.length until strb.length) if (strb[j]!='1') ans = false
            //if (ans) println("$stra, $strb, strat index $i")
            if (ans) check = true
        }
        return check
    }

    val ans = sub(a, y) || sub(b, y) || sub(c, y) || sub(d, y) || (x == y)

    sb.appendLine(if (ans) "YES" else "NO")

    println(sb)

}


import kotlin.math.*

fun main() {
    val n = readInt()

    val ans = n.toBigInteger().bitLength()

    println(ans)
}

fun readLn() = readLine()!!
fun readInt() = readLn().toInt()
fun readDouble() = readLn().toDouble()
fun readLong() = readLn().toLong()
fun readStrings() = readLn().split(' ')
fun readStringSeq() = readLn().splitToSequence(' ')
fun readInts() = readStrings().map { it.toInt() }
fun readIntSeq() = readStringSeq().map { it.toInt() }
fun readDoubles() = readStrings().map { it.toDouble() }
fun readDoubleSeq() = readStringSeq().map { it.toDouble() }
fun readLongs() = readStrings().map { it.toLong() }
fun readLongSeq() = readStringSeq().map { it.toLong() }

class Output {
    val outputSb = StringBuilder()
    fun print(o: Any?) { outputSb.append(o) }
    fun println() { outputSb.append('\n') }
    fun println(o: Any?) { outputSb.append(o).append('\n') }
    @JvmName("_print") fun Any?.print() = print(this)
    @JvmName("_println") fun Any?.println() = println(this)
    fun nowPrint() { kotlin.io.print(outputSb) }
}
inline fun output(block: Output.()->Unit) { Output().apply(block).nowPrint() }


fun main() {
    val n = readLine()!!.toInt()
    var s = 0L
    var i = 1
    var x = 0
    while(s < n) {
        s+=i
        i*=2
        x++
    }
    println(x)
}


import java.util.*

fun main(args: Array<String>) {
var sc = Scanner(System.`in`)
val x = sc.nextInt()
    var  h = sc.nextInt()
    val m = sc.nextInt()
    if (m%10==7 || h%10 == 7){
        println(0)
        return
    }else {
        var dec = m-x
        var occ = 1
        while (true){

            if (dec%10==7 || h%10 ==7)break
            if (dec<0){
                h--
                if (h <0){
                    h=23
                }
                dec=60+dec
                occ--
            }else  if (dec<60){
                dec-=x
            }else {
                dec+=x-60
            }
            occ++
        }
        println(occ)
    }
}


val M = 1000000007L
val N = 200005
var fact = LongArray(N)
var ifact = LongArray(N)
var t = 0

fun main(args : Array<String>) {
    val (n, m, g) = readLine().toString().split(' ').map { it.toInt() }
    t = g
    init()

    // case when there are no ones
    if (m == 0) {
        val res = if (ok(n)) 1 else 0
        println(res)
        return
    }

    var ans = 0L
    // number of zeroes before first one position
    for (i in 0..n) {
        var k = ok(i + 1)
        if (m == 1 && i == n) k = ok(i)
        if (!k) continue
        ans = (ans + C(n - i + m - 1, m - 1)) % M
    }
    println(ans)
}

fun init() {
    fact[0] = 1L
    ifact[0] = 1L
    for (i in 1..(N - 1)) {
        fact[i] = (fact[i - 1] * i) % M
        ifact[i] = binpow(fact[i], M - 2)
    }
}

fun binpow(n : Long, deg : Long) : Long {
    if (deg == 0L) return 1L
    return if (deg % 2L == 1L) {
        n * binpow(n, deg - 1) % M
    } else {
        val b = binpow(n, deg / 2L)
        b * b % M
    }
}

fun C(n : Int, k : Int) : Long {
    return if (n < k) 0
    else fact[n] * ifact[k] % M * ifact[n - k] % M
}

fun ok(zeroes : Int) = (1 - zeroes % 2 == t)


import java.util.*
import kotlin.collections.HashMap

fun main(args : Array<String>) {
    val input = Scanner(System.`in`)
    var city = HashMap<Int, Int>()

    var j=0
    val n = input.nextInt()
    val u = input.nextInt()
    var sum = u
    if (n < u){
        println(n -1)
    } else {
        for (i in n downTo 1){
            city.put(i, j)
            if (j < u){
                j++
            } else {
                sum += i*1
            }
        }
        println(sum-1)
    }

}


import java.util.*

//2019-02-18
fun main(args: Array<String>) = with(Scanner(System.`in`)) {
  val n = nextInt()
  val v = nextInt()
  var diff = v - (n - 1)
  if (diff >= 0) {
    print(n - 1)
  } else {
    diff *= -1
    print((2 + diff + 1) * diff / 2 + v)
  }
}


fun main() {
    val (a, b) = readLine()!!.split(" ")
    print(if (a == b) a else 1)
}


import java.util.*

fun abs(x: Int) = if (x >= 0) x else -x

fun main(args: Array<String>) = with(Scanner(System.`in`)) {
    val n = nextInt(); val pos = nextInt()
    val l = nextInt(); val r = nextInt()

    val leftToRight = abs(pos - l) + 1 + (1 + r - l) * (if (r != n) 1 else 0)
    val rightToLeft = abs(r - pos) + 1 + (1 + r - l) * (if (l != 1) 1 else 0)

    if (l == 1 && r == n) {
        print(0)
    } else {
        print(minOf(leftToRight, rightToLeft))
    }
}


import java.util.*
import kotlin.system.exitProcess
import kotlin.math.*

private fun readLn() = readLine()!! // string line
private fun readInt() = readLn().toInt() // single int
private fun readStrings() = readLn().split(" ") // list of strings
private fun readInts() = readStrings().map { it.toInt() } // list of ints
private fun readLongs() = readStrings().map { it.toLong() } // list of longs
private fun exit() : Nothing = exitProcess(0)

inline fun <T : Comparable<T> > min(x : T, y : T): T{
    if(x < y){return x;}
    else{return y;}
}

inline fun <T : Comparable<T> > max(x : T, y : T): T{
    if(x > y){return x;}
    else{return y;}
}

fun getid(row : Int): Int{
    val kek = (row - 1)/2;
    return 2 + 3 * kek;
}

fun main(){
    var (a, x, y) = readInts();
    a = a * 2;
    x = x * 2;
    y = y * 2;
    if(y%a == 0){
        println(-1);
        return;
    }
    val row = y/a;
    if(row <= 1){
        if(abs(x) >= a/2){println(-1);}
        else{println(row + 1);}
        return;
    }
    if(row%2 == 0){
        if(x != 0 && abs(x) < a){
            if(x < 0)println(getid(row - 1) + 1);
            else println(getid(row - 1) + 2);
        }
        else{println(-1);}
    }
    else{
        if(abs(x) < a/2){println(getid(row));}
        else{println(-1);}
    }
}


fun main()
{
       println("INTERCAL")
}


import java.io.BufferedReader
import java.io.InputStream
import java.io.InputStreamReader
import java.util.*
import kotlin.math.abs
import kotlin.math.max
import kotlin.math.min

private val MOD = 1_000_000_007L

class Solver(stream: InputStream, private val out: java.io.PrintWriter) {
  fun solve() {
    val N = ni()
    var best = Array(2){LongArray(N + 10)}
    var next = Array(2){LongArray(N + 10)}
    best[0][0] = 1

    for (i in 0 until N) {
      Arrays.fill(next[0], 0)
      Arrays.fill(next[1], 0)
      for (j in 0 .. N) {
        for (s in 0 until 2) { // reflexiveを満たさない
          for (k in 0 until 2) { // 追加するか
            for (l in 0 until 2) { // 連結するか
              if (k == 0 && l == 1) continue
              val nj = if (k == 1 && l == 0) j + 1 else j
              val ns = if (s == 0 && k == 1) 0 else 1
              val c = if (l == 1) j else 1
              next[ns][nj] = (next[ns][nj] + best[s][j] * c) % MOD
            }
          }
        }
      }
      val tmp = best
      best = next
      next = tmp
    }

    debug(best[0])
    debug(best[1])

    out.println(best[1].sum() % MOD)
  }

  private val isDebug = try {
    // なんか本番でエラーでる
    System.getenv("MY_DEBUG") != null
  } catch (t: Throwable) {
    false
  }

  private var tokenizer: StringTokenizer? = null
  private val reader = BufferedReader(InputStreamReader(stream), 32768)
  private fun next(): String {
    while (tokenizer == null || !tokenizer!!.hasMoreTokens()) {
      tokenizer = StringTokenizer(reader.readLine())
    }
    return tokenizer!!.nextToken()
  }

  private fun ni() = next().toInt()
  private fun nl() = next().toLong()
  private fun ns() = next()
  private fun na(n: Int, offset: Int = 0): IntArray {
    return map(n) { ni() + offset }
  }
  private fun nal(n: Int, offset: Int = 0): LongArray {
    val res = LongArray(n)
    for (i in 0 until n) {
      res[i] = nl() + offset
    }
    return res
  }

  private fun na2(n: Int, offset: Int = 0): Array<IntArray> {
    val a  = Array(2){IntArray(n)}
    for (i in 0 until n) {
      for (e in a) {
        e[i] = ni() + offset
      }
    }
    return a
  }

  private inline fun map(n: Int, f: (Int) -> Int): IntArray {
    val res = IntArray(n)
    for (i in 0 until n) {
      res[i] = f(i)
    }
    return res
  }

  private inline fun debug(msg: () -> String) {
    if (isDebug) System.err.println(msg())
  }

  private fun debug(a: LongArray) {
    debug { a.joinToString(" ") }
  }

  private fun debug(a: IntArray) {
    debug { a.joinToString(" ") }
  }

  private fun debug(a: BooleanArray) {
    debug { a.map { if (it) 1 else 0 }.joinToString("") }
  }

  private fun debugDim(A: Array<LongArray>) {
    if (isDebug) {
      for (a in A) {
        debug(a)
      }
    }
  }
  private fun debugDim(A: Array<IntArray>) {
    if (isDebug) {
      for (a in A) {
        debug(a)
      }
    }
  }

  /**
   * 勝手にimport消されるのを防ぎたい
   */
  private fun hoge() {
    min(1, 2)
    max(1, 2)
    abs(-10)
  }
}

fun main() {
  val out = java.io.PrintWriter(System.out)
  Solver(System.`in`, out).solve()
  out.flush()
}


fun main() {
    val (h, w) = readLine()!!.split(' ').map { it.toInt() }
    val cake = List(h) { readLine()!!.map { it == '*' } }
    var i = 0
    var j = 0
    var ans = 0
    while (i + 1 < h || j + 1 < w){
        ans += if (cake[i][j]) 1 else 0
        if (i + 1 == h) {
            j++
        } else {
            if (j + 1 == w) {
                i++
            } else {
                if (cake[i + 1][j]) i++ else j++
            }
        }
    }
    println(ans + if (cake[i][j]) 1 else 0)
}


import java.util.Scanner

fun main(args : Array<String>) {

    val reader = Scanner(System.`in`)
    var a: Int = reader.nextInt()
    var b: Int = reader.nextInt()
    var x: Int = reader.nextInt()
    var y: Int = reader.nextInt()

    var p1 = 0
    var p2 = 0

    if(a<=x || b<=y){
        print(0)
        print(" ")
        print(0)
    }
    else{
        var a1 = a / x
        var b1 = b / y

        if(a1>=b1){
            p1 = b1 * x
            p2 = b1 * y
        }
        else{
            p1 = a1 * x
            p2 = a1 * y
        }
        print(p1)
        print(" ")
        print(p2)
    }

}


import java.io.*
import java.util.*
import kotlin.*

fun main(vararg args:String) {
    val n = readLine()!!.toInt()
    var b = (Math.sqrt(n.toDouble())).toInt()
    while (n % b != 0)
        b--
    println("$b " + n / b)
}


import java.lang.Integer.min

fun main(args: Array<String>) {
    var t = arrayListOf<String>()
    repeat(8) { t.add(readLine()!!) }
    var (a, b) = 8 to 8
    for (i in 0..7) {
        t.map { it[i] }.foldIndexed(false to 8) { i, acc, c ->
            var (metB, bestB) = acc
            if (c == 'W' && !metB) {
                a = min(a, i)
                bestB = 8
            }
            if (c == 'B') {
                metB = true
                bestB = 7 - i
            }

            metB to bestB
        }.let { b = min(b, it.second) }
    }
    print(if (b < a) "B" else "A")
}


import kotlin.math.sqrt

fun main() {
    val n = readLong()

    val ans = n.factorize().distinct().fold(1L, Long::times)

    println(ans)
}

fun Long.sqrtFloor() = sqrt(toDouble()).toLong()

fun primeSieve(upperLimit: Long): Sequence<Long> = sequence {
    yield(2L)
    val source = (3..upperLimit step 2).toMutableSet()

    while(source.isNotEmpty()) {
        val prime = source.first()
        yield(prime)
        source.remove(prime)
        source.removeAll(prime * prime .. upperLimit step prime)
    }
}

fun Long.factorize() = sequence {
    val sqrt = sqrtFloor()
    var n = this@factorize

    for(p in primeSieve(sqrt)) {
        while(n % p == 0L) {
            yield(p)
            n /= p
        }
    }

    if(n > 1) yield(n)
}

fun readLn() = readLine()!!
fun readInt() = readLn().toInt()
fun readDouble() = readLn().toDouble()
fun readLong() = readLn().toLong()
fun readStrings() = readLn().split(' ')
fun readStringSeq() = readLn().splitToSequence(' ')
fun readInts() = readStrings().map { it.toInt() }
fun readIntSeq() = readStringSeq().map { it.toInt() }
fun readIntArray(size: Int) = readIntSeq().iterator().let { i -> IntArray(size) { i.next() } }
fun readDoubles() = readStrings().map { it.toDouble() }
fun readDoubleSeq() = readStringSeq().map { it.toDouble() }
fun readDoubleArray(size: Int) = readDoubleSeq().iterator().let { i -> DoubleArray(size) { i.next() } }
fun readLongs() = readStrings().map { it.toLong() }
fun readLongSeq() = readStringSeq().map { it.toLong() }
fun readLongArray(size: Int) = readLongSeq().iterator().let { i -> LongArray(size) { i.next() } }

class Output {
    private val sb = StringBuilder()
    fun print(o: Any?) { sb.append(o) }
    fun println() { sb.append('\n') }
    fun println(o: Any?) { sb.append(o).append('\n') }
    @JvmName("_print") fun Any?.print() = print(this)
    @JvmName("_println") fun Any?.println() = println(this)
    fun nowPrint() { kotlin.io.print(sb) }
}
inline fun output(block: Output.()->Unit) { Output().apply(block).nowPrint() }


import java.io.*
import java.util.*

fun <T : Comparable<T>> max(a: T, b: T): T = if (b > a) b else a
fun <T : Comparable<T>> min(a: T, b: T): T = if (b < a) b else a
fun Number.isEven(): Boolean = if (this.toInt() and 1 == 0) true else false
fun Number.isOdd(): Boolean = !this.isEven()

fun main(args: Array<String>) {
    if (args.isNotEmpty()) System.setIn(FileInputStream(args[0]))
    val br = BufferedReader(InputStreamReader(System.`in`))
    val bw = BufferedWriter(OutputStreamWriter(System.out))

    var st = StringTokenizer(br.readLine())
    val str = st.nextToken()
    var hasDigit = false; var hasLower = false; var hasUpper = false
    for (c in str) {
        if (c >= '0' && c <= '9') hasDigit = true
        else if (c >= 'a' && c <= 'z') hasLower = true
        else if (c >= 'A' && c <= 'Z') hasUpper = true
    }
    if (str.length >= 5 && hasDigit && hasLower && hasUpper) bw.write("Correct")
    else bw.write("Too weak")
    bw.newLine()
    bw.flush()
}


fun main() {
    val r = System.`in`.bufferedReader()
    val s = StringBuilder()
    //val n = r.readLine()!!
    var (a, b, c) = r.readLine()!!.split(" ").map { it.toInt() }
    b -= 1
    c %= a

    b += a
    b += c
    b %= a
    b += 1
    println(b)
}


import java.util.*

fun main(args: Array<String>) {
    with(Scanner(System.`in`)) {
        val n = nextLong()
        val m = nextLong()
        val k = nextLong()
        val r = k % (m * n)
        if (r < n) {
            println("${r+1} 1")
        } else {
            val r0 = r - n
            val t0 = r0 / (m-1)
            val t1 = r0 % (m-1)
            if (t0 % 2 == 0L) {
                println("${n-t0} ${2+t1}")
            } else {
                println("${n-t0} ${1+m-1-t1}")
            }
        }
    }
}


import java.io.BufferedInputStream
import java.util.*
import kotlin.collections.HashSet

fun main(args: Array<String>) {
    val scanner = Scanner(BufferedInputStream(System.`in`))
    //val output = BufferedWriter(OutputStreamWriter(System.`out`))

    //visualize()
    val n = scanner.nextLong()
    val k = scanner.nextLong()
    if(ok(n, k)) print("Yes")
    else print("No")

}

fun ok(n: Long, k: Long): Boolean{
    if(n == k && n == 1L) return true
    if(n <= k) return false
    val set = HashSet<Long>()
    for(i in 1..k){
        val r = n%i
        if(r in set) return false
        set.add(r)
    }
    return true
}

/*
fun visualize(){

    val n = 40

    print("   |")
    for(i in 1..n) print(" %2d".format(i))
    println()
    for(i in 1..(3*n+4)) print("-")
    println()

    for(i in 1..n){
        //if(!isPrime(i)) continue
        print("%2d |".format(i))
        for(j in 1 .. n){
            if(i >= j)
                print(" %2d".format(i%j))
        }
        println()
    }
    println()
}

fun isPrime(x: Int): Boolean{
    var i = 2
    while(i*i <= x){
        if(x%i == 0) return false
        ++i
    }
    return true
}
*/


import java.io.BufferedReader
import java.io.InputStreamReader
import java.util.*

fun main() {
    val tokenizer = BufferedReader(InputStreamReader(System.`in`)).use { StringTokenizer(it.readText()) }
    val n = tokenizer.nextInt()
    val m = tokenizer.nextInt()
    val a = Array(n) { tokenizer.nextInt() }.apply {
        sort()
        reverse()
    }
    if (a.sum() < m)
        println("-1")
    else {
        var l = 1
        var r = n
        while (l < r) {
            val mid = (l + r) / 2
            if (check(a, m, mid))
                r = mid
            else
                l = mid + 1
        }
        println(l)
    }
}

fun check(a: Array<Int>, m: Int, d: Int): Boolean {
    var sum = 0
    for (i in 0 until a.size) {
        val debuff = i / d
        if (a[i] <= debuff)
            break
        sum += a[i] - debuff
    }
    return sum >= m
}

fun StringTokenizer.nextInt() = nextToken().toInt()
fun StringTokenizer.nextLong() = nextToken().toLong()


import java.*
import java.util.*
fun main(args: Array<String>) {
        val `in` = Scanner(System.`in`)
        val n = `in`.nextInt()
        val m = `in`.nextInt()
        var maxIt = 0
        var maxChild = 0
        for (i in 0 until n) {
            val x = `in`.nextInt()
            val it = (x + (m - 1)) / m
            if (it >= maxIt) {
                maxIt = it
                maxChild = i
            }
        }
        println(maxChild + 1)

    }


fun main() {
    val r = System.`in`.bufferedReader()
    val s = StringBuilder()
    //val n = r.readLine()!!.toInt()
    val (n, m) = r.readLine()!!.split(" ").map { it.toInt() }
    val l = r.readLine()!!.split(" ").map { it.toInt() }.map { it / m + if (it % m != 0) 1 else 0 }
    var max = Int.MIN_VALUE
    var ind = -1
    for (i in n-1 downTo 0){
        if (l[i]>max) {
            max = l[i]
            ind = i+1
        }
    }
    println(ind)
}


import kotlin.math.abs
import kotlin.math.max

fun main() {
    solve()
}

private fun solve() {
    val (x1, y1) = readLongs()
    val (x2, y2) = readLongs()
    val a = abs(x2 - x1)
    val b = abs(y2 - y1)
    println(max(a, b))
}

private fun readLn() = readLine()!! // string line
private fun readInt() = readLn().toInt() // single int
private fun readStrings() = readLn().split(" ") // list of strings
private fun readInts() = readStrings().map { it.toInt() } // li
private fun readLongs() = readStrings().map { it.toLong() } // li


import kotlin.math.min

class FactorialCache(size: Int, private val mod: Long) {
  private val list = LongArray(size + 1) { 0 }
  private var current = 1

  init {
    list[0] = 1
    list[1] = 1
  }

  fun get(n: Int): MLong {
    if (current < n) {
      for (i in (current + 1)..n) {
        list[i] = (i * list[i - 1]) % mod
      }
      current = n
    }
    return MLong(list[n])
  }
}

var MOD = 1_000_000_007L

@JvmInline
value class MLong(private val value: Long) {

  operator fun plus(other: MLong): MLong {
    return MLong((value + other.value) % MOD)
  }

  operator fun minus(other: MLong): MLong {
    var ret = (value - other.value) % MOD
    if (ret < 0) {
      ret += MOD
    }
    return MLong(ret)
  }

  operator fun times(other: MLong): MLong {
    return MLong((value * other.value) % MOD)
  }

  fun pow(power: Long): MLong {
    var ret = 1L
    var current = value
    var p = 0
    while (1L shl p < power) {
      if (power and (1L shl p) != 0L) {
        ret = (ret * current) % MOD
      }
      current = (current * current) % MOD
      p++
    }
    return MLong(ret)
  }

  override fun toString() = value.toString()
}

var fact = FactorialCache(100_000, MOD)

fun nck(n: Int, k: Int): MLong {
  return fact.get(n) * (fact.get(n - k) * fact.get(k)).pow(MOD - 2)
}

fun main() {
  var (n, k) = readln().split(" ").map { it.toInt() }

  var ret = MLong(0L)
  for (m in 0..min(n, k)) {
    ret += nck(n, m)
  }
  println(ret)
}


fun main() {
    fun readInts() = readLine()!!.split(" ").map(String::toInt)

    val (watchPerSecond, downloadPerSecond, seconds) = readInts()
    var wait = (seconds * watchPerSecond - seconds * downloadPerSecond) / downloadPerSecond
    if (wait * downloadPerSecond + seconds * downloadPerSecond < watchPerSecond * seconds) wait++
    print(wait)
}


fun main() {
    val r = System.`in`.bufferedReader()
    val s = StringBuilder()
    var n = r.readLine()!!.toInt()
    val v = r.readLine()!!.split(" ").map { it.toInt() }.toIntArray()
    n %= v.sum()
    (1..6).forEach { v[it]+=v[it-1] }
    fun b(x: Int): Int {
        var le = 0
        var ri = 7
        while (le < ri) {
            val mi = le + (ri - le) / 2
            when {
                v[mi] < x -> le = mi + 1
                v[mi] >= x -> ri = mi
            }
        }
        return le % 7 + 1
    }
    println(b(n))
}


import java.util.*

fun main(args: Array<String>) {

    val scanner = Scanner(System.`in`)

    val n = scanner.nextLine().toInt()

    val a = scanner.nextLine()

    val values = a.split(' ').map { it.toInt() }

    val sum = values.sum()

    if (sum != 0) {
        System.out.println("YES")
        System.out.println(1)
        System.out.println("1 $n")
    } else {

        val countZeros = values.count { it == 0 }
        if (countZeros == values.size) {
            System.out.println("NO")
        } else {

            var currentSum = 0
            var i = 0

            while (currentSum == 0) {
                currentSum += values[i]
                i++
            }

            System.out.println("YES")
            System.out.println(2)
            System.out.println("1 ${i+1}")
            System.out.println("${i+2} ${values.size}")

        }

//        val partsum1 = values.take

    }

}


import java.io.*
import java.util.*
import kotlin.Comparator
import kotlin.math.abs
import kotlin.math.max
import kotlin.math.min
import kotlin.random.Random
import kotlin.system.measureTimeMillis

/**
 * 23.02.2020
 * Main
 *
 * @author Havlong
 * @version v1.0
 */
class LineReader(tempReader: Reader) {
    private val reader = BufferedReader(tempReader)
    fun hasNext() = peek() != -1
    private fun peek(): Int {
        reader.mark(1)
        return reader.read().also { reader.reset() }
    }

    fun skipSpaces() {
        while (Character.isWhitespace(peek()))
            reader.read()
    }

    fun readLine(): String = reader.readLine()
    fun longList() = readLine().split(' ').map(String::toLong)
    fun intList() = readLine().split(' ').map(String::toInt)
}

typealias ML = MutableList<Long>
typealias MI = MutableList<Int>
typealias LL = List<Long>
typealias LLL = List<LL>
typealias PLL = Pair<Long, Long>
typealias PPLL = Pair<Long, PLL>

const val M7 = 1000000007L
const val M9 = 1000000009L
const val MFFT = 998244353L
const val INF = 2000000000000000000L

fun lowerBound(from: Long, to: Long, comparison: (Long) -> Long): Long {
    var left = from
    var right = to + 1
    while (left < right) {
        val mid = (left + right) / 2
        val result = comparison(mid)
        if (result >= 0) {
            right = mid
        } else {
            left = mid + 1
        }
    }
    return left
}

fun upperBound(from: Long, to: Long, comparison: (Long) -> Long): Long {
    var left = from
    var right = to + 1
    while (left < right) {
        val mid = (left + right) / 2
        val result = comparison(mid)
        if (result > 0) {
            right = mid
        } else {
            left = mid + 1
        }
    }
    return left
}

fun <T : Comparable<T>> List<T>.upperBound(key: T, from: Int = 0, to: Int = size - 1): Int {
    return upperBound(from.toLong(), to.toLong()) { this[it.toInt()].compareTo(key).toLong() }.toInt()
}

fun <T : Comparable<T>> List<T>.lowerBound(key: T, from: Int = 0, to: Int = size - 1): Int {
    return lowerBound(from.toLong(), to.toLong()) { this[it.toInt()].compareTo(key).toLong() }.toInt()
}

fun <T : Comparable<T>> Array<T>.upperBound(key: T, from: Int = 0, to: Int = size - 1): Int {
    return upperBound(from.toLong(), to.toLong()) { this[it.toInt()].compareTo(key).toLong() }.toInt()
}

fun <T : Comparable<T>> Array<T>.lowerBound(key: T, from: Int = 0, to: Int = size - 1): Int {
    return lowerBound(from.toLong(), to.toLong()) { this[it.toInt()].compareTo(key).toLong() }.toInt()
}

operator fun <A : Comparable<A>, B : Comparable<B>> Pair<A, B>.compareTo(other: Pair<A, B>): Int {
    return first.compareTo(other.first).let { if (it == 0) second.compareTo(other.second) else it }
}

fun binPow(number: Long, power: Long, mod: Long): Long {
    var result = 1L
    var a = number % mod
    var n = power
    while (n > 0) {
        if (n % 2 != 0L)
            result = (result * a) % mod
        a = (a * a) % mod
        n /= 2
    }
    return result
}

tailrec fun gcd(a: Long, b: Long): Long = if (b == 0L) a else gcd(b, a % b)

fun lcm(a: Long, b: Long) = a * b / gcd(a, b)

fun main(args: Array<String>) {
    if (args.isNotEmpty() && args[0] == "local") {
        val reader = LineReader(FileReader("input.txt"))
        PrintWriter(File("output.txt")).use {
            while (reader.hasNext()) {
                it.println("\n${measureTimeMillis {
                    solve(reader, it)
                }} ms\n")
                reader.skipSpaces()
            }
        }
    } else {
        val reader = LineReader(InputStreamReader(System.`in`))
        PrintWriter(System.out).use { solve(reader, it) }
    }
}

fun solve(reader: LineReader, writer: PrintWriter) {
    val (year, month, day) = reader.readLine().split(':').map(String::toInt)
    val (year2, month2, day2) = reader.readLine().split(':').map(String::toInt)
    val start = Calendar.getInstance().apply { set(year + 400, month, day) }
    val end = Calendar.getInstance().apply { set(year2 + 400, month2, day2) }
    val result = abs(end.timeInMillis - start.timeInMillis + 1) / 1000
    writer.println(result / 3600 / 24)
}


fun main() {
    var nominal: Int = readLine()!!.toInt()
    var greatestDivisor = 2
    while(nominal>1){
        println(nominal)
        while(nominal%greatestDivisor!=0) greatestDivisor++
        nominal/=greatestDivisor
    }
    println(1)
}


fun main() {
    var (a, b) = readLine()!!.split(' ').map { it.toInt() }
    var count = 0L
    for (i in a..b){
        var digit = i.toString()
        for (i in digit){
            when(i){
                '0'->count+=6
                '1'->count+=2
                '2'->count+=5
                '3'->count+=5
                '4'->count+=4
                '5'->count+=5
                '6'->count+=6
                '7'->count+=3
                '8'->count+=7
                '9'->count+=6
            }
        }
    }
    println(count)
}


import kotlin.math.min

fun main() {
    val n = readLine()!!.toInt()
    var sol = 0
    for (a in 1..n)
        for (b in a..n) {
            val cCandidate = a xor b xor 0
            if (cCandidate in b..min(n, a + b - 1)) sol++
        }
    print(sol)
}


import java.io.PrintWriter
import kotlin.math.min

fun main() {
    io.apply {

        val sum = int
        val k = int
        val wMin = int

        val M = 1000000007

        val dp0 = IntArray(sum + 1)
        val dp1 = IntArray(sum + 1)
        dp0[0] = 1
        for (i in 1..sum) {
            for (j in 1 .. k) {
                if (i - j >= 0) {
                    dp1[i] = (dp1[i] + dp1[i - j]) % M
                    if (j < wMin) {
                        dp0[i] = (dp0[i] + dp0[i - j]) % M
                    } else
                        dp1[i] = (dp1[i] + dp0[i - j]) % M
                }
            }
        }

        cout .. dp1[sum] .. nl

    }.cout.flush()
}

// @formatter:off
private val io = object {
    private val `in` = System.`in`
    private fun ll(): Long {
        var x: Int; var q = false; var n = 0L; do x = `in`.read() while (x < 33); if (x == 45) { q = true; x = `in`.read() }
        do { n = n * 10 - x + 48; x = `in`.read() } while (x > 32); return if (q) n else -n
    }
    val int get() = ll().toInt(); val long get() = ll()
    fun ints(n: Int = int): IntArray { return IntArray(n) { int } }
    fun ints1(n: Int = int): IntArray { return IntArray(n) { int - 1 } }
    val cout = PrintWriter(System.out); val nl = "\n"
    private var buf = CharArray(32)
    private var bufSize = 32
    fun str(expect: Int = 32): String {
        var ix = 0
        var x: Int
        if (bufSize < expect)
            buf = CharArray(expect)
        do x = `in`.read() while (x < 33)
        do {
            if (ix == bufSize) { bufSize *= 2; buf = buf.copyOf(bufSize) }
            buf[ix++] = x.toChar()
            x = `in`.read()
        } while (x > 32)
        return java.lang.String.copyValueOf(buf, 0, ix)
    }
    operator fun PrintWriter.rangeTo(a: Int): PrintWriter { print(a); print(" "); return this }
    operator fun PrintWriter.rangeTo(a: Long): PrintWriter { print(a); print(" "); return this }
    operator fun PrintWriter.rangeTo(a: IntArray): PrintWriter { a.forEach { print(it); print(" ") }; return this }
    operator fun PrintWriter.rangeTo(a: String): PrintWriter { write(a); return this }
} // @formatter:on

/* ----------- */


import kotlin.math.min

fun main() {
    val (n, x, y) = readLine()!!.split(" ").map { it.toLong() }
    fun minChanges(z: Long): Int {
        var z = z
        var res = 0
        while (z > 0L) {
            if (z and 1L == 1L) {
                if (z and 3L == 3L) {
                    z++
                } else {
                    z--
                }
                res++
            }
            z = z shr 1
        }
        return res
    }
    var answer = Long.MAX_VALUE
    for (e in 0..29) {
        answer = min(answer, (e.toLong() * y) + (((n shr e) + minChanges(n % (1L shl e))) * x))
    }
    println(answer)
}


fun nod(a: Long, b: Long): Long =
        if (a % b != 0L) {
            nod(b, a % b)
        } else {
            b
        }

fun main(args: Array<String>) {
    var (a, b, x, y) = readLine()!!.split(" ").map(String::toLong)

    var nodValue = if (x < y) nod(x, y) else nod(y, x)

    if(nodValue != 1L) {
        x /= nodValue
        y /= nodValue
    }
    println(if (a/x > b/y) b/y else a/x)
}


import java.io.*
import java.util.*
fun main(args : Array<String>) = Thread { run() }.start()

fun run() {

    val scanner = Scanner(System.`in`)
    val n = scanner.nextInt()
    val arr1 = IntArray(n) { scanner.nextInt() }
    val arr2 = IntArray(n) { scanner.nextInt() }
    if (arr1.sum() >= arr2.sum())
        println("Yes")
    else
        println("No")

}

class Parser(`in`: InputStream) {
    private val BUFFER_SIZE = 1 shl 16
    private val din: DataInputStream
    private val buffer: ByteArray
    private var bufferPointer: Int = 0
    private var bytesRead: Int = 0

    init {
        din = DataInputStream(`in`)
        buffer = ByteArray(BUFFER_SIZE)
        bytesRead = 0
        bufferPointer = bytesRead
    }

    fun nextString(maxSize: Int): String {
        val ch = ByteArray(maxSize)
        var point = 0
        try {
            var c = read()
            while (c == ' '.toByte() || c == '\n'.toByte() || c == '\r'.toByte())
                c = read()
            while (c != ' '.toByte() && c != '\n'.toByte() && c != '\r'.toByte()) {
                ch[point++] = c
                c = read()
            }
        } catch (e: Exception) {}

        return String(ch, 0, point)
    }

    fun nextInt(): Int {
        var ret = 0
        val neg: Boolean
        try {
            var c = read()
            while (c <= ' '.toByte())
                c = read()
            neg = c == '-'.toByte()
            if (neg)
                c = read()
            do {
                ret = ret * 10 + c - '0'.toInt()
                c = read()
            } while (c > ' '.toByte())

            if (neg) return -ret
        } catch (e: Exception) {}
        return ret
    }

    fun nextLong(): Long {
        var ret: Long = 0
        val neg: Boolean
        try {
            var c = read()
            while (c <= ' '.toByte())
                c = read()
            neg = c == '-'.toByte()
            if (neg)
                c = read()
            do {
                ret = ret * 10 + c - '0'.toLong()
                c = read()
            } while (c > ' '.toByte())

            if (neg) return -ret
        } catch (e: Exception) {}

        return ret
    }

    fun nextDouble(): Double
            = nextString(10000).toDouble()

    private fun fillBuffer() {
        try {
            bytesRead = din.read(buffer, 0, BUFFER_SIZE)
        } catch (e: Exception) {}
        if (bytesRead == -1) buffer[0] = -1
    }

    private fun read(): Byte {
        if (bufferPointer == bytesRead) fillBuffer()
        return buffer[bufferPointer++]
    }
}
class Scanner(s: InputStream) {
    var st: StringTokenizer? = null
    var br: BufferedReader = BufferedReader(InputStreamReader(s))
    @Throws(IOException::class)
    operator fun next(): String {
        while (st == null || !st!!.hasMoreTokens())
            st = StringTokenizer(br.readLine())
        return st!!.nextToken()
    }
    @Throws(IOException::class)
    fun nextInt(): Int {
        return Integer.parseInt(next())
    }
    @Throws(IOException::class)
    fun nextLong(): Long {
        return java.lang.Long.parseLong(next())
    }
    @Throws(IOException::class)
    fun nextLine(): String {
        return br.readLine()
    }
    @Throws(IOException::class)
    fun nextDouble(): Double {
        return java.lang.Double.parseDouble(next())
    }
    @Throws(IOException::class)
    fun ready(): Boolean {
        return br.ready()
    }
}
fun IntArray.print() {
    println(Arrays.toString(this))
}
fun Array<IntArray>.print() {
    for (i in this)
        i.print()
}
fun LongArray.print() {
    println(Arrays.toString(this))
}
fun Array<LongArray>.print() {
    for (i in this)
        i.print()
}
fun BooleanArray.print() {
    println(Arrays.toString(this))
}
fun nod(a: Long, b: Long): Long {
    var a1 = a
    var b1 = b
    while (a1 != 0L && b1 != 0L) {
        if (a1 < b1)
            b1 %= a1
        else
            a1 %= b1
    }
    return a1 + b1
}
fun nok(a: Long, b: Long): Long = a * b / nod(a, b)
fun min(a: Char, b: Char): Int {
    if (a < b)
        return a.toInt()
    return b.toInt()
}
fun max(a: Char, b: Char): Int {
    if (a > b)
        return a.toInt()
    return b.toInt()
}


import java.lang.Long.max
import java.util.*
import java.math.*

fun readLn()=readLine()!!
fun readInt()=readLn().toInt()
fun readInts()=readLn().split(" ").map{it.toInt()}
fun readLong()=readLn().toLong()
fun readLongs()=readLn().split(" ").map{it.toLong()}

val out=mutableListOf<String>()
fun printLine(s:String){out.add(s)}
fun output(){println(out.joinToString("\n"))}

val mod=998244353L
fun mul(x:Long,y:Long):Long=x*y%mod
fun add(x:Long,y:Long):Long{
    val z=x+y
    if(z>=mod)return z-mod
    else return z
}
fun sub(x:Long,y:Long):Long{
    val z=x-y
    if(z<0L)return z+mod
    else return z
}
fun pw(_x:Long,_k:Long):Long{
    var ans=1L
    var k=_k
    var x=_x
    while(k>0){
        if(k%2L==1L)ans=mul(ans,x)
        x=mul(x,x)
        k/=2L
    }
    return ans;
}

fun main(){
    var (n,k)=readLongs()
    var F=LongArray((n+1).toInt()){1}
    var I=LongArray((n+1).toInt()){1}
    for(i in 1..n)F[i.toInt()]=mul(F[(i-1).toInt()],i)
    for(i in 2..n)I[i.toInt()]=mul((mod-mod/i),I[(mod%i).toInt()])
    for(i in 1..n)I[i.toInt()]=mul(I[i.toInt()],I[(i-1).toInt()])
    fun binom(n:Long,k:Long):Long{
        return mul(F[n.toInt()],mul(I[(n-k).toInt()],I[k.toInt()]))
    }
    if(k>=n)printLine("0")
    else{
        var m=n-k
        var ans=0L
        var bsz=0L
        for(i in m downTo 1){
            bsz=binom(n-i,m-i)
            var now=mul(mul(binom(n,i),pw(i,n)),bsz)
            if((m-i)%2L==0L){
                ans=add(ans,now)
            }else{
                ans=sub(ans,now)
            }
        }
        if(k!=0L)ans=mul(ans,2)
        printLine("$ans")
    }
    output()
}


class MisterBReader(val c: Int,
                    val v0: Int,
                    val v1: Int,
                    val a: Int,
                    val l: Int
) {
    var v = v0
    var readedPages = 0

    fun getDaysToRead() : Int {
        var days = 1
        readedPages += v
        while(readedPages < c) {
            readedPages -= l
            v = when {
                v >= v1 -> v
                v + a > v1 -> v1
                else -> v + a
            }
            readedPages += v
            days++
        }
        return days
    }
}

fun main(args: Array<String>) {
    val(c, v0, v1, a, l) = readLine()!!.split(' ').map(String::toInt)
    println(MisterBReader(c, v0, v1, a, l).getDaysToRead())
}


import java.util.*

fun main(args: Array<String>) {

    var sc = Scanner(System.`in`)
    var n = sc.nextInt()
    var x=0
    var max = 0
    for (i in 0 .. n-1){
        x=sc.nextInt()
        max= maxOf(x,max)
    }
    max = maxOf(0,max-25)
    println(max)
}


import java.io.BufferedReader
import java.io.File
import java.io.PrintWriter

fun main(args: Array<String>) {
    val onlineJudge = System.getProperty("ONLINE_JUDGE") == "true"
    val input = if (onlineJudge) System.`in`.bufferedReader() else File("input.txt").bufferedReader()
    val output = if (onlineJudge) PrintWriter(System.out.writer(), true) else PrintWriter(File("output.txt"))

    solve(input, output)

    output.flush()
    output.close()
}

private fun solve(input: BufferedReader, output: PrintWriter) {
    val line = input.readLine()
    val c = line[0]
    val n = line[1]

    val top = when {
        n == '1' -> 0
        c == 'a' || c == 'h' -> 2
        else -> 3
    }

    val bottom = when {
        n == '8' -> 0
        c == 'a' || c == 'h' -> 2
        else -> 3
    }

    val leftRight = when {
        c == 'a' || c == 'h' -> 1
        else -> 2
    }

    output.println(top + bottom + leftRight)
}