object Solution extends App {

  readInt()

  var key: Int = 0
  readLine().foldLeft(Map.empty[Char, Int]){
    case (acc, el) if el.isLower => acc + (el -> (acc.getOrElse(el, 0) + 1))
    case (acc, el) =>
      val lower = el.toLower
      val newValue = acc.getOrElse(lower, 0) - 1
      if (newValue >= 0)
        acc + (lower -> (acc.getOrElse(lower, 0) - 1))
      else {
        key += 1
        acc
      }
  }
  println(key)
}

object CF297A extends App {
  import scala.collection.mutable.HashMap
  import scala.io.{StdIn}

  val n: Int = StdIn.readInt()
  val keysAndRooms: String = StdIn.readLine()
  var acc = 0

  keysAndRooms.toIterable.foreach(solve(new Multiset[Char]))

  print (acc)

  def solve(multiset: Multiset[Char]): (Char) => Unit = {
    (ch: Char) => {
      if(ch.isLower){
        multiset.add(ch.toUpper)
      } else {
        if(multiset.contains(ch)){
          multiset.remove(ch)
        } else{
          acc = acc + 1
        }
      }
    }
  }

  class Multiset[T] {
    val hashMap = new HashMap[T, Int]()

    def add(element: T) = {
      val count = hashMap.getOrElseUpdate(element, 0)
      hashMap+=((element, count+1))
    }

    def contains(element:T ) = {
      hashMap.get(element).nonEmpty
    }

    def remove(element: T) = {
      val count = hashMap.getOrElse(element, 1)
      if (count == 1) {
        hashMap.remove(element)
      } else {
        hashMap+=((element, count-1))
      }
    }
  }

}

object A525 {

  import IO._

  def main(args: Array[String]): Unit = {
    val Array(n) = readInts(1)
    val in = read
    val keys = Array.fill(26)(0)
    var res = 0
    for(i <- 0 until n-1) {
      val k = 2*i
      keys(in(k)-'a') += 1
      val d = 2*i + 1
      if(keys(in(d).toLower-'a') > 0) {
        keys(in(d).toLower-'a') -= 1
      } else {
        res += 1
      }
    }
    println(res)
  }

  object IO {
    @inline def read: String = scala.io.StdIn.readLine

    @inline def tokenizeLine = new java.util.StringTokenizer(read)

    def readInts(n: Int): Array[Int] = {
      val tl = tokenizeLine;
      Array.fill(n)(tl.nextToken.toInt)
    }

    def readLongs(n: Int): Array[Long] = {
      val tl = tokenizeLine;
      Array.fill(n)(tl.nextToken.toLong)
    }

    def readBigs(n: Int): Array[BigInt] = {
      val tl = tokenizeLine;
      Array.fill(n)(BigInt(tl.nextToken))
    }
  }

}

import scala.collection.mutable

/**
 * Created by yangchaozhong on 3/27/15.
 */
object CF525A extends App {
  import scala.collection.mutable.{HashMap}

  import java.util.{Scanner}
  import java.io.{PrintWriter}

  val in = new Scanner(System.in)
  val out = new PrintWriter(System.out)

  def nextInt = in.nextInt
  def nextLong = in.nextLong
  def nextDouble = in.nextDouble
  def nextString = in.next
  def nextLine = in.nextLine

  def solve = {
    val n = nextInt
    val s = nextString
    val map = HashMap[Char, Int]()
    var count = 0
    (1 to (n - 1)).foreach { i =>
      val l = s(i * 2 - 2)
      val r = s(i * 2 - 1).toLower
      if (l != r) {
        if (map.contains(l)) {
          map(l) += 1
        } else {
          map(l) = 1
        }

        if (map.contains(r) && map(r) > 0) {
          map(r) -= 1
        } else {
          count += 1
        }
      }
    }

    out.println(count)
  }

  try {
    solve
  } catch {
    case _: Exception => sys.exit(9999)
  } finally {
    out.flush
    out.close
  }
}

import java.io._
import java.util
import java.util.StringTokenizer
import java.util.TreeMap

import scala.collection.mutable

object A {

  var out: PrintWriter = null
  var br: BufferedReader = null
  var st: StringTokenizer = null

  def main(args: Array[String]): Unit = {
    br = new BufferedReader(new InputStreamReader(System.in))
    out = new PrintWriter(new BufferedOutputStream(System.out))
    solve
    out.close
  }

  def next: String = {
    while (st == null || !st.hasMoreTokens) {
      st = new StringTokenizer(br.readLine)
    }
    return st.nextToken
  }

  def nextInt: Int = return Integer.parseInt(next)

  def nextLong: Long = return java.lang.Long.parseLong(next)

  def nextDouble: Double = return java.lang.Double.parseDouble(next)

  class MultiHashSet[T <% Comparable[T]] {
    val map = new mutable.HashMap[T, Int]()

    def count(x: T): Int = {
      return map.getOrElse(x, 0)
    }

    def add(x: T): Unit = map.put(x, count(x) + 1)

    def remove(x: T): Boolean = {
      val prev = count(x)
      if (prev == 0)
        return false
      if (prev == 1) {
        map.remove(x)
      } else {
        map.put(x, prev - 1)
      }
      return true
    }
  }

  class MultiTreeSet[T <% Comparable[T]] {
    val map = new TreeMap[T, Int]()

    def count(x: T): Int = {
      val res = map.get(x)
      if (res == null)
        return 0
      return res
    }

    def add(x: T): Unit = map.put(x, count(x) + 1)

    def first(): T = return map.firstKey()

    def last(): T = return map.lastKey()

    def remove(x: T): Boolean = {
      val prev = count(x)
      if (prev == 0)
        return false
      if (prev == 1) {
        map.remove(x)
      } else {
        map.put(x, prev - 1)
      }
      return true
    }
  }

  def solve: Int = {
    val n = nextInt
    val map = next.toCharArray
    val size = 2 * n - 2
    val keys = new MultiHashSet[Char]()
    var ans = 0
    for (i <- 0 until size by 2) {
      keys.add(map(i).toUpper)
      if (keys.count(map(i + 1)) > 0) {
        keys.remove(map(i + 1))
      } else {
        ans += 1
      }
    }
    out.println(ans)
    return 0
  }
}

import java.util.Scanner

import scala.collection.mutable

object _525_A extends App {
  lazy val file = getClass.getResourceAsStream(s"${getClass.getSimpleName.head.toString}.in")
  val in = if (submit) new Scanner(System.in) else new Scanner(file)
  while(in.hasNext) {
    println(apply(parseInput))
  }
  /********************************************************************************************************************/
  def submit = true        // THIS MUST BE TRUE WHEN YOU SUBMIT

  type Input = String

  def parseInput: Input = {
    import in._
    nextInt()
    next()
  }

  def apply(line: String) = {
    val keys = mutable.Map.empty[Char, Int] withDefaultValue 0
    var ans = 0
    for {
      element <- line.grouped(2)
      (key, door) = (element(0), element(1))
    } {
      keys(key) = keys(key) + 1
      val requiredKey = door.toLower
      if (keys(requiredKey) > 0) {
        keys(requiredKey) = keys(requiredKey) - 1
      } else {
        ans += 1
      }
    }
    ans
  }
}

import scala.io.StdIn

/**
 * Created by pol on 29/03/15.
 */
object CR297_A extends App {
  val n = StdIn.readInt()
  val s = StdIn.readLine()
  var ans = 0

  var cnt = new Array[Int](255)
  for (i <- 0 until 2 * n - 2) {
    val si = s.charAt(i)
    if (si.isLower) {
      cnt(si) += 1
    } else {
      if (cnt(si.toLower) > 0) {
        cnt(si.toLower) -= 1
      } else {
        ans += 1
      }

    }
  }
  println(ans)
}

object A{
  //import scala.collection.mutable.PriorityQueue
  //import scala.collection.mutable.ArrayBuffer
  import util.control.Breaks._
  import java.io.{PrintWriter,InputStream,BufferedReader,InputStreamReader}
  import java.util.{Locale, Scanner,StringTokenizer}
  class InputReader(val stream:InputStream ) {
    var st:StringTokenizer=new StringTokenizer("")
    val reader=new BufferedReader(new InputStreamReader(stream), 32768);

    def next():String = {
        while (!st.hasMoreTokens()){
          val currentLine = reader.readLine
          st=new StringTokenizer(currentLine)
        }
        return st.nextToken
    }

    def nextInt():Int = {
        return next.toInt
    }

    def nextLong():Long = {
    	return next.toLong
    }
    def nextDouble:Double = {
      return next.toDouble
    }
  }

  def main(args: Array[String]){

    val in = new InputReader(System.in)
    val out = new PrintWriter(System.out)

    def nextInt = in.nextInt
    def nextLong = in.nextLong
    def nextDouble = in.nextDouble
    def nextString = in.next
    //code starts here
    val n=nextInt
    val keys=Array.fill(26)(0)
    val S=nextString
    var count=0
    for(i<-0 until n-1){
      val ki=S(2*i)-'a'
      val Di=S(2*i+1)-'A'
      keys(ki)+=1
      if(keys(Di)>0){
        keys(Di)-=1
      }else{
        count+=1
      }
    }
    out.println(count)
    //code ends here
    out.flush
    out.close
  }
}

object CodeForces extends App {

  def solve = {
    val n = readLine().toInt
    val doorsAndKeys = readLine().toCharArray

    var doorkeyHash = Array.fill[Int](26)(0)
    var keysRequired = 0

    def charHash(c : Char) = c.toLower - 'a'

    for (i <- 0 until 2 * n - 2) {
      val dkHash = charHash(doorsAndKeys(i))
      if (i % 2 == 0) {
        doorkeyHash(dkHash) += 1
      } else {
        if (doorkeyHash(dkHash) > 0) doorkeyHash(dkHash) -= 1
        else keysRequired += 1
      }
    }
    println(keysRequired)
  }

  solve
}

object CodeForces extends App {

  def solve = {
    val n = readLine toInt
    val doorsAndKeys = readLine

    var doorkeyHash = Array.fill[Int](26)(0)

    def charHash(c : Char) = c.toLower - 'a'

    var index = 0
    println(doorsAndKeys.foldLeft(0)((kReq, c) => {
      val dkHash = charHash(doorsAndKeys(index))
      val dkStat = if (index % 2 == 0) 1 else if (doorkeyHash(dkHash) > 0) -1 else 0
      index += 1
      doorkeyHash(dkHash) += dkStat
      kReq + (if (dkStat == 0) 1 else 0)
    }))
  }

  solve
}

/**
 * Created by yangchaozhong on 3/27/15.
 */
object CF525A extends App {
  import java.util.{Scanner}
  import java.io.{PrintWriter}

  val in = new Scanner(System.in)
  val out = new PrintWriter(System.out)

  def nextInt = in.nextInt
  def nextLong = in.nextLong
  def nextDouble = in.nextDouble
  def nextString = in.next
  def nextLine = in.nextLine

  def solve = {
    val n = nextInt
    val s = nextString

    val count = (1 to (n - 1)).map(_ * 2).count(i => s(i - 2) != s(i - 1).toLower)
    out.println(count)
  }

  try {
    solve
  } catch {
    case _: Exception => sys.exit(9999)
  } finally {
    out.flush
    out.close
  }
}


object Main {
  def c_split(n: Int) = if (n % 2 == 1) {
    (1 to n).map{ i =>
      (1 to n).map{ j =>
        1 + (((i - j + (n - 1) / 2) + n) % n ) * n + ((i + j + (n + 1) / 2) % n)
      }
    }
  } else {
    (0 until n).map{ i =>
      (0 until n / 2).flatMap { j =>
        Seq(n * n - i * (n / 2) - j, i * (n / 2) + j + 1)
      }
    }
  }

  def main(args: Array[String]) {
    val n = readInt()
    c_split(n).foreach(tr => println(tr.mkString(" ")))
  }
}

import Array._

object main extends App with fastIO {

  val n = nextInt
  var a = ofDim[Int](n, n)

  for (i <- 0 until n) if ((i & 1) == 0)
    for (j <- 0 until n) a(j)(i) = i * n + j + 1 else
    for (j <- n - 1 to (0, -1)) a(j)(i) = i * n + n - j

  for (i <- 0 until n) println(a(i).mkString(" "))
  flush
}

trait fastIO {
  import java.io._

  val isFile = false
  val input = "io.in"
  val output = "io.out"

  val bf = new BufferedReader(if(isFile) new FileReader(input) else new InputStreamReader(System.in))
  val in = new StreamTokenizer(bf)
  val out = new PrintWriter(if(isFile) new FileWriter(output) else new OutputStreamWriter(System.out))

  def next: String = {
    in.ordinaryChars('0', '9')
    in.wordChars('0', '9')
    in.nextToken
    in.sval
  }

  def nextInt: Int = {
    in.nextToken
    in.nval.toInt
  }

  def nextLong:Long ={
    in.nextToken
    in.nval.toLong
  }

  def nextDouble: Double = {
    in.nextToken
    in.nval.toDouble
  }

  def readLine: String = bf.readLine()
  def println(o:Any) = out.println(o)
  def print(o:Any) = out.print(o)
  def printf(s:String,o:Any*) = out.printf(s,o)
  def flush = out.flush
}

import Array._

object main extends App with fastIO {

  val n = nextInt
  var a = ofDim[Int](n, n)

  var value = 1
  for (i <- 0 until n) {
    if ((i & 1) == 0)
    for (j <- 0 until n) {
      a(j)(i) = value
      value += 1
    } else
    for (j <- n - 1 to (0, -1)) {
      a(j)(i) = value
      value += 1
    }
  }

  for (i <- 0 until n) println(a(i).mkString(" "))
  flush
}

trait fastIO {
  import java.io._

  val isFile = false
  val input = "io.in"
  val output = "io.out"

  val bf = new BufferedReader(if(isFile) new FileReader(input) else new InputStreamReader(System.in))
  val in = new StreamTokenizer(bf)
  val out = new PrintWriter(if(isFile) new FileWriter(output) else new OutputStreamWriter(System.out))

  def next: String = {
    in.ordinaryChars('0', '9')
    in.wordChars('0', '9')
    in.nextToken
    in.sval
  }

  def nextInt: Int = {
    in.nextToken
    in.nval.toInt
  }

  def nextLong:Long ={
    in.nextToken
    in.nval.toLong
  }

  def nextDouble: Double = {
    in.nextToken
    in.nval.toDouble
  }

  def readLine: String = bf.readLine()
  def println(o:Any) = out.println(o)
  def print(o:Any) = out.print(o)
  def printf(s:String,o:Any*) = out.printf(s,o)
  def flush = out.flush
}

object runner {
def main(args:Array[String]){
var liner=readInt();
var array=Array.ofDim[Int](liner,liner);
var result="";
for(i<-0 to liner-1){
  for(j<-0 to liner-1){
    if(i%2==1){
      array(i)(j)=(liner)*(i+1)-j;
    }else{
      array(i)(j)=(liner*i)+j+1;
    }
  }
}
for(t<-0 to liner-1){
  for(l<-0 to liner-1){
    result+=array(l)(t).toString+" ";
  }
  result+="\n";
}
println(result);
}
}

import scala.io.StdIn._

object CF_334A_CandyBags {
  def main(args: Array[String]): Unit = {
    val n = readInt()
    val sqn = n * n
    println((((1 to sqn / 2) zip (sqn / 2 + 1 to sqn).reverse)
      .grouped(n / 2)
      .map(_.flatMap(_.productIterator).mkString(" "))).mkString("\n"))
  }
}

object P334A {

  def main(argv: Array[String]) {
    val n = readLine.toInt
    val n2 = n * n
    (0 until n).map(index =>
      println(
	((n * index) / 2 + 1 until (n * (index + 1)) / 2 + 1).foldLeft(
	  List[Int]())((lst, i) => i :: n2 - i + 1 :: lst).mkString(" ")))
  }
}

object CF334A {
    def main(argv: Array[String]) {
        val n = readLine.toInt
        def output(index: Int): Unit = {
            val a = index
            val b = n * n - index + 1
            if (index % (n >> 1) == 0) {
                if (index == (n * n) >> 1) {
                    println(a + " " + b)
                } else {
                    println(a + " " + b)
                    output(index + 1)
                }
            } else {
                print(a + " " + b + " ")
                output(index + 1)
            }
        }
        output(1)
    }
}

object A_CandyBags extends App {
  val n = readLine toLong

  import Ordering.Implicits._, Numeric.Implicits._

  def find[N](k: N, remains: Map[N, (N, List[N])])(implicit num: Numeric[N]): Map[N, List[N]] =
    if (k == num.zero)
      if (remains forall (_._2._1 == num.zero)) remains map {case (i, (r, l)) => (i, l)}
      else throw new ArithmeticException("Not found")
    else remains maxBy (_._2._1) match {
      case (i, (r, l)) if r >= k => find(k - num.one, remains updated(i, (r - k, k :: l)))
      case _ => throw new ArithmeticException("Shit happened k = " + k + " and remains are" + remains)
    }

  find[Long](n * n, 1L to n map (i => (i, (n * (n * n + 1) / 2, Nil))) toMap) map {_._2 mkString " "} foreach println
}

object Solution extends App {
  val in = scala.io.Source.stdin.getLines()
  val n = in.next().toInt
  Range(1, n + 1).foreach { i =>
    println((Range(i, n * n / 2 + 1, n).toList ::: Range(n * n - i + 1, n * n / 2, -n).toList).mkString(" "))
  }
}

object CandyBags {
  def main(args: Array[String]): Unit = {
    val n = readLine().toInt
    // val n = 2
    val res = distribute(n)
    res.map(list => list.mkString(" ")).foreach(println)
  }

  def distribute(n: Int): Seq[Seq[Int]] = {
    (0 until n).map(i => (0, i)).map { case (i, j) =>
      for {
        k <- 0 until n
      } yield(get(i + k, j + k, n))
    }
  }

  def get(x: Int, y: Int, n: Int): Int = {
    val (mx, my) = (x % n, y % n)
    mx * n + my + 1
  }
}

object A334 {

  import IO._
  import collection.{mutable => cu}

  def main(args: Array[String]): Unit = {
    val Array(n) = readInts(1)
    var num = 1
    for(_ <- 1 to n) {
      for(_ <- 1 to n/2) {
        print(num + " ")
        print((n*n)-num+1 + " ")
        num += 1
      }
      println("")
    }
  }

  object IO {
    private val input = new java.io.BufferedReader(new java.io.InputStreamReader(System.in))

    //    private val input = new java.io.BufferedReader(new java.io.InputStreamReader(new java.io.FileInputStream("src/input")))
    @inline def read: String = input.readLine()

    @inline def tokenizeLine = new java.util.StringTokenizer(read)

    def readInt: Int = tokenizeLine.nextToken.toInt

    def readInts(n: Int): Array[Int] = {
      val tl = tokenizeLine
      Array.fill(n)(tl.nextToken.toInt)
    }

    def readLongs(n: Int): Array[Long] = {
      val tl = tokenizeLine
      Array.fill(n)(tl.nextToken.toLong)
    }

    def readBigs(n: Int): Array[BigInt] = {
      val tl = tokenizeLine
      Array.fill(n)(BigInt(tl.nextToken))
    }
  }

}

import java.util.Scanner
import java.io.PrintWriter
import scala.annotation.tailrec
import scala.collection.mutable
import scala.util.Random

object P334A extends App {
  val sc = new Scanner(System.in)
  val out = new PrintWriter(System.out)
  val N = sc.nextInt

 type Bags = List[Int]

  val bags: Bags = List(
      List.range(1, N * N / 2 + 1),
      List.range(N * N / 2 + 1, N * N + 1).reverse
    ).transpose.flatten

  def solve(): Unit = {

    @tailrec
    def loop(acc: List[Bags], bags: Bags): List[Bags] = {
      if (bags.isEmpty) acc
      else loop((bags take N) :: acc, bags drop N)
    }

    loop(List.empty[Bags], bags).foreach { xs =>
      out.println(xs.mkString(" "))
    }
  }

  solve
  out.close
}

import scala.io.StdIn._

object CandyBags extends App {

  def printCandy(line: Int, col: Int): Unit = {
    val st = (col - 1) * n + 1
    val of = (line + col) % n
    print(st + of)
    print(" ")
    if(col != n) {
      printCandy(line, col + 1)
    } else if(line != n) {
      print("\n")
      printCandy(line + 1, 1)
    }
  }

  val n = readInt
  printCandy(1, 1)

}

import annotation.tailrec
import java.io._

object Easy {
  val reader = new BufferedReader(new InputStreamReader(System.in))
  def readInts = reader.readLine().split(" ").map(_.toInt)
  def readInt = reader.readLine().toInt

  val n = readInt
  val k = n / 2
  def ans = ((1 to n * n).take(2 * k * k) zip (1 to n * n).drop(2 * k * k).reverse).flatMap(_.productIterator).grouped(n).map(_.mkString(" ")).mkString("\n")

  def main(args: Array[String]) {
    println(ans)
  }
}

object Main {
  def c_split(n: Int) = if (n % 2 == 1) {
    (1 to n).map{ i =>
      (1 to n).map{ j =>
        1 + (((i - j + (n - 1) / 2) + n) % n ) * n + ((i + j + (n + 1) / 2) % n)
      }
    }
  } else {
    (1 to n).map{ i =>
      (1 to n / 2).flatMap { j =>
        Seq(n * n - i * (n / 2) - j, i * (n / 2) + j)
      }
    }
  }

  def main(args: Array[String]) {
    val n = readInt()
    c_split(n).foreach(tr => println(tr.mkString(" ")))
  }
}

object Main {
  def c_split(n: Int) = if (n % 2 == 1) {
    (1 to n).map{ i =>
      (1 to n).map{ j =>
        1 + (((i - j + (n - 1) / 2) + n) % n ) * n + ((i + j + (n + 1) / 2) % n)
      }
    }
  } else {
    (1 to n).map{ i =>
      (1 to n / 2).flatMap { j =>
        Seq(n * n - i * (n / 2) - j, i * (n / 2) + j + 1)
      }
    }
  }

  def main(args: Array[String]) {
    val n = readInt()
    c_split(n).foreach(tr => println(tr.mkString(" ")))
  }
}


import scala.collection.mutable.Queue

object B extends App {

  @inline def tokenizeLine = new java.util.StringTokenizer(readLine)
  def readInts(n: Int) = { val tl = tokenizeLine; Array.fill(n)(tl.nextToken.toInt) }

  val Array(n, m) = readInts(2)
  val ss = Array.fill(n) { readLine.toCharArray }

  def isEmpty(i: Int, j: Int) = i >= 0 && i < n && j >= 0 && j < m && ss(i)(j) == '.'

  def singleEmptyNeighbour(i: Int, j: Int) = {
    if (isEmpty(i + 1, j) && !isEmpty(i - 1, j) && !isEmpty(i, j - 1) && !isEmpty(i, j + 1)) 1
    else if (!isEmpty(i + 1, j) && isEmpty(i - 1, j) && !isEmpty(i, j - 1) && !isEmpty(i, j + 1)) 2
    else if (!isEmpty(i + 1, j) && !isEmpty(i - 1, j) && isEmpty(i, j - 1) && !isEmpty(i, j + 1)) 3
    else if (!isEmpty(i + 1, j) && !isEmpty(i - 1, j) && !isEmpty(i, j - 1) && isEmpty(i, j + 1)) 4
    else 0
  }

  val q = Queue.empty[(Int, Int)]

  def process(i: Int, j: Int): Unit = {
    if (isEmpty(i, j)) {
      singleEmptyNeighbour(i, j) match {
        case 1 =>
          ss(i)(j) = '^'
          ss(i + 1)(j) = 'v'
          q += ((i + 1, j - 1))
          q += ((i + 1, j + 1))
          q += ((i + 2, j))
        case 2 =>
          ss(i)(j) = 'v'
          ss(i - 1)(j) = '^'
          q += ((i - 1, j - 1))
          q += ((i - 1, j + 1))
          q += ((i - 2, j))
        case 3 =>
          ss(i)(j) = '>'
          ss(i)(j - 1) = '<'
          q += ((i - 1, j - 1))
          q += ((i + 1, j - 1))
          q += ((i, j - 2))
        case 4 =>
          ss(i)(j) = '<'
          ss(i)(j + 1) = '>'
          q += ((i - 1, j + 1))
          q += ((i + 1, j + 1))
          q += ((i, j + 2))
        case 0 =>
      }
    }
  }

  Console.setOut(new java.io.BufferedOutputStream(Console.out))

  for (i <- 0 until n; j <- 0 until m) {
    process(i, j)
    while (q.nonEmpty) {
      val (i, j) = q.dequeue()
      process(i, j)
    }
  }

  if (ss.exists(_.exists(_ == '.'))) println("Not unique")
  else ss.foreach(s => println(s.mkString))

  Console.flush
}

import scala.collection.mutable.Queue

object B extends App {

  @inline def tokenizeLine = new java.util.StringTokenizer(readLine)
  def readInts(n: Int) = { val tl = tokenizeLine; Array.fill(n)(tl.nextToken.toInt) }

  val Array(n, m) = readInts(2)
  val ss = Array.fill(n) { readLine.toCharArray }

  def isEmpty(i: Int, j: Int) = i >= 0 && i < n && j >= 0 && j < m && ss(i)(j) == '.'

  def singleEmptyNeighbour(i: Int, j: Int) = {
    if (isEmpty(i + 1, j) && !isEmpty(i - 1, j) && !isEmpty(i, j - 1) && !isEmpty(i, j + 1)) 1
    else if (!isEmpty(i + 1, j) && isEmpty(i - 1, j) && !isEmpty(i, j - 1) && !isEmpty(i, j + 1)) 2
    else if (!isEmpty(i + 1, j) && !isEmpty(i - 1, j) && isEmpty(i, j - 1) && !isEmpty(i, j + 1)) 3
    else if (!isEmpty(i + 1, j) && !isEmpty(i - 1, j) && !isEmpty(i, j - 1) && isEmpty(i, j + 1)) 4
    else 0
  }

  val q = new java.util.ArrayDeque[(Int, Int)]()

  def process(i: Int, j: Int): Unit = {
    if (isEmpty(i, j)) {
      singleEmptyNeighbour(i, j) match {
        case 1 =>
          ss(i)(j) = '^'
          ss(i + 1)(j) = 'v'
          q.add((i + 1, j - 1))
          q.add((i + 1, j + 1))
          q.add((i + 2, j))
        case 2 =>
          ss(i)(j) = 'v'
          ss(i - 1)(j) = '^'
          q.add((i - 1, j - 1))
          q.add((i - 1, j + 1))
          q.add((i - 2, j))
        case 3 =>
          ss(i)(j) = '>'
          ss(i)(j - 1) = '<'
          q.add((i - 1, j - 1))
          q.add((i + 1, j - 1))
          q.add((i, j - 2))
        case 4 =>
          ss(i)(j) = '<'
          ss(i)(j + 1) = '>'
          q.add((i - 1, j + 1))
          q.add((i + 1, j + 1))
          q.add((i, j + 2))
        case 0 =>
      }
    }
  }

  Console.setOut(new java.io.BufferedOutputStream(Console.out))

  for (i <- 0 until n; j <- 0 until m) {
    process(i, j)
    while (!q.isEmpty) {
      val (i, j) = q.poll()
      process(i, j)
    }
  }

  if (ss.exists(_.exists(_ == '.'))) println("Not unique")
  else ss.foreach(s => println(s.mkString))

  Console.flush
}


object EDU_55_A {
  def solve(input: Vector[Int]): Int = {
    val Seq(n,x,y,d) = input
    // Page y is reachable iff:
        //1 x+kd = y where k can be + or -, and |k| is answer ||
        //2 1+kd = y where k is + ||
        //3 n-kd = y "
    // 1
    if ((y - x)%d == 0)
      math.abs((y - x) / d)
    //2
    else {
      val via1 = if ((y - 1) % d == 0)
      // presses to get back to start
        Some(intCeil(x - 1, d) +
          // presses to get up to place
          intCeil(y - 1, d)) else None
      val viaN = if ((n - y) % d == 0)
        Some(intCeil(n - x, d) +
          intCeil(n - y, d)) else None
      Seq(via1, viaN).flatten match {
        case Seq() => -1
        case Seq(a) => a
        case Seq(a,b) => a min b
      }
    }

  }

  // unintuitive but robust way of getting ceil(a/b) for ints
  def intCeil(a: Int, b: Int) = (a + b - 1) / b

  def main(args: Array[String]) = {
    val io = new IO(System.in)
    val lines = io.int()
    io.nextLine
    1 to lines foreach { _ =>
      println(solve(io.intSeq()))
    }
  }

/// boilerplate utility methods: ///
    import java.util.Scanner
    class IO(sc: Scanner) {
      def this(i: java.io.InputStream) = this(new Scanner(i))
      def this(s: String) = this(new Scanner(s))
      def nextLine = sc.nextLine() // do this if still on previous line before collecting line of data
      def collect[T](f: String => T) = {sc.nextLine().split(" ").toVector.map(f)}
      def intSeq() = collect(_.toInt)
      def doubleSeq() = collect(_.toDouble)
      def int() = sc.nextInt()
      def double() = sc.nextDouble()
    }
}

object Main {
  def main(args: Array[String]): Unit = {
    val s = new Main()
    s.solve()
    s.out.flush()
  }
}

class Main {
  import java.io._
  import java.util.StringTokenizer

  import scala.collection.mutable
  import scala.util.Sorting
  import math.{abs, max, min}
  import mutable.{ArrayBuffer, ListBuffer}
  import scala.reflect.ClassTag

  val MOD = 1000000007
  val out = new PrintWriter(System.out)

  def solve(): Unit = {
    rep(ni()) { _ =>
      val n, x, y = ni() - 1
      val d = ni()
      val one = if (y % d == 0) x / d + (if (x % d > 0) 1 else 0) + y / d else Integer.MAX_VALUE
      val last = if ((n - y) % d == 0) (n - x) / d + (if ((n - x) % d > 0) 1 else 0) + (n - y) / d else Integer.MAX_VALUE
      val direct = if (abs(y - x) % d == 0) abs(y - x) / d else Integer.MAX_VALUE
      val ans = min(one, min(last, direct))
      out.println(if (ans == Integer.MAX_VALUE) -1 else ans)
    }
  }

  class InputReader(val stream: InputStream) {
    private val reader = new BufferedReader(new InputStreamReader(stream), 32768)
    private var tokenizer: StringTokenizer = _

    def next(): String = {
      while (tokenizer == null || !tokenizer.hasMoreTokens)
        tokenizer = new StringTokenizer(reader.readLine)
      tokenizer.nextToken
    }

    def nextInt(): Int = next().toInt
    def nextLong(): Long = next().toLong
    def nextChar(): Char = next().charAt(0)
  }
  val sc = new InputReader(System.in)
  def ni(): Int = sc.nextInt()
  def nl(): Long = sc.nextLong()
  def nc(): Char = sc.nextChar()
  def ns(): String = sc.next()
  def ns(n: Int): Array[Char] = ns().toCharArray
  def na(n: Int, offset: Int = 0): Array[Int] = map(n)(_ => ni() + offset)
  def na2(n: Int, offset: Int = 0): (Array[Int], Array[Int]) = {
    val A1, A2 = Array.ofDim[Int](n)
    rep(n) { i =>
      A1(i) = ni() + offset
      A2(i) = ni() + offset
    }
    (A1, A2)
  }
  def nm(n: Int, m: Int): Array[Array[Int]] = {
    val A = Array.ofDim[Int](n, m)
    rep(n) { i =>
      rep(m) { j =>
        A(i)(j) = ni()
      }
    }
    A
  }
  def nal(n: Int): Array[Long] = map(n)(_ => nl())
  def nm_c(n: Int, m: Int): Array[Array[Char]] = map(n) (_ => ns(m))
  def rep(n: Int, offset: Int = 0)(f: Int => Unit): Unit = {
    var i = offset
    val N = n + offset
    while(i < N) { f(i); i += 1 }
  }
  def rep_r(n: Int, offset: Int = 0)(f: Int => Unit): Unit = {
    var i = n - 1 + offset
    while(i >= offset) { f(i); i -= 1 }
  }

  def map[@specialized A: ClassTag](n: Int, offset: Int = 0)(f: Int => A): Array[A] = {
    val res = Array.ofDim[A](n)
    rep(n)(i => res(i) = f(i + offset))
    res
  }

  def sumL(as: Array[Int]): Long = {
    var s = 0L
    rep(as.length)(i => s += as(i))
    s
  }

  def cumSum(as: Array[Int]) = {
    val cum = Array.ofDim[Int](as.length + 1)
    rep(as.length) { i =>
      cum(i + 1) = cum(i) + as(i)
    }
    cum
  }
}

object EDU_55_A {
  def solve(input: Vector[Int]): Int = {
    val Seq(n,x,y,d) = input
    // Page y is reachable iff:
        //1 x+kd = y where k can be + or -, and |k| is answer ||
        //2 1+kd = y where k is + ||
        //3 n-kd = y " ||
    // 1
    if ((y - x)%d == 0)
      math.abs((y - x) / d)
    //2
    else if ((y - 1) % d == 0)
      // presses to get back to start
      intCeil(x-1, d) +
      // presses to get up to place
        (y - 1) / d
    else if ((n-y) % d == 0)
      intCeil(n - x, d) +
        (n-y)/d
    else -1
  }

  // unintuitive but robust way of getting ceil(a/b) for ints
  def intCeil(a: Int, b: Int) = (a + b - 1) / b

  def main(args: Array[String]) = {
    val io = new IO(System.in)
    val lines = io.int()
    io.nextLine
    1 to lines foreach { _ =>
      println(solve(io.intSeq()))
    }
  }

/// boilerplate utility methods: ///
    import java.util.Scanner
    class IO(sc: Scanner) {
      def this(i: java.io.InputStream) = this(new Scanner(i))
      def this(s: String) = this(new Scanner(s))
      def nextLine = sc.nextLine() // do this if still on previous line before collecting line of data
      def collect[T](f: String => T) = {sc.nextLine().split(" ").toVector.map(f)}
      def intSeq() = collect(_.toInt)
      def doubleSeq() = collect(_.toDouble)
      def int() = sc.nextInt()
      def double() = sc.nextDouble()
    }
}

object EDU_55_A {
  def solve(input: Vector[Int]): Int = {
    val Seq(n,x,y,d) = input
    // Page y is reachable iff:
        //1 x+kd = y where k can be + or -, and |k| is answer ||
        //2 1+kd = y where k is + ||
        //3 n-kd = y "
    // 1
    if ((y - x)%d == 0)
      math.abs((y - x) / d)
    //2
    else {
      val via1 = if ((y - 1) % d == 0)
      // presses to get back to start
        Some(intCeil(x - 1, d) +
          // presses to get up to place
          intCeil(y - 1, d)) else None
      val viaN = if ((n - y) % d == 0)
        Some(intCeil(n - x, d) +
          intCeil(n - y, d)) else None
      Seq(via1, viaN).flatten match {
        case Seq() => -1
        case Seq(a) => a
        case Seq(a,b) => a max b
      }
    }

  }

  // unintuitive but robust way of getting ceil(a/b) for ints
  def intCeil(a: Int, b: Int) = (a + b - 1) / b

  def main(args: Array[String]) = {
    val io = new IO(System.in)
    val lines = io.int()
    io.nextLine
    1 to lines foreach { _ =>
      println(solve(io.intSeq()))
    }
  }

/// boilerplate utility methods: ///
    import java.util.Scanner
    class IO(sc: Scanner) {
      def this(i: java.io.InputStream) = this(new Scanner(i))
      def this(s: String) = this(new Scanner(s))
      def nextLine = sc.nextLine() // do this if still on previous line before collecting line of data
      def collect[T](f: String => T) = {sc.nextLine().split(" ").toVector.map(f)}
      def intSeq() = collect(_.toInt)
      def doubleSeq() = collect(_.toDouble)
      def int() = sc.nextInt()
      def double() = sc.nextDouble()
    }
}

object EDU_55_A {
  def solve(input: Vector[Int]): Int = {
    val Seq(n,x,y,d) = input
    // Page y is reachable iff:
        //1 x+kd = y where k can be + or -, and |k| is answer ||
        //2 1+kd = y where k is + ||
        //3 n-kd = y "
    // 1
    if ((y - x)%d == 0)
      math.abs((y - x) / d)
    //2
    else if ((y - 1) % d == 0)
      // presses to get back to start
      intCeil(x-1, d) +
      // presses to get up to place
       intCeil(y-1,d)
    else if ((n-y) % d == 0)
      intCeil(n - x, d) +
        intCeil(n-y,d)
    else -1
  }

  // unintuitive but robust way of getting ceil(a/b) for ints
  def intCeil(a: Int, b: Int) = (a + b - 1) / b

  def main(args: Array[String]) = {
    val io = new IO(System.in)
    val lines = io.int()
    io.nextLine
    1 to lines foreach { _ =>
      println(solve(io.intSeq()))
    }
  }

/// boilerplate utility methods: ///
    import java.util.Scanner
    class IO(sc: Scanner) {
      def this(i: java.io.InputStream) = this(new Scanner(i))
      def this(s: String) = this(new Scanner(s))
      def nextLine = sc.nextLine() // do this if still on previous line before collecting line of data
      def collect[T](f: String => T) = {sc.nextLine().split(" ").toVector.map(f)}
      def intSeq() = collect(_.toInt)
      def doubleSeq() = collect(_.toDouble)
      def int() = sc.nextInt()
      def double() = sc.nextDouble()
    }
}

object EDU_55_A {
  def solve(input: Vector[Int]): Int = {
    val Seq(n,x,y,d) = input
    // Page y is reachable iff:
        //1 x+kd = y where k can be + or -, and |k| is answer ||
        //2 1+kd = y where k is + ||
        //3 n-kd = y " ||
    // 1
    if ((y - x)%d == 0)
      math.abs((y - x) / d)
    //2
    else if ((y - 1) % d == 0)
      // presses to get back to start
      math.ceil((x - 1)/d.toDouble).toInt +
      // presses to get up to place
        (y - 1) / d
    else if ((n-y) % d == 0)
      math.ceil((n - x)/d.toDouble).toInt +
        (n-y)/d
    else -1
  }

  def main(args: Array[String]) = {
    val io = new IO(System.in)
    val lines = io.int()
    io.nextLine
    1 to lines foreach { _ =>
      println(solve(io.intSeq()))
    }

  }

/// boilerplate utility methods: ///
    import java.util.Scanner
    class IO(sc: Scanner) {
      def this(i: java.io.InputStream) = this(new Scanner(i))
      def this(s: String) = this(new Scanner(s))
      def nextLine = sc.nextLine() // do this if still on previous line before collecting line of data
      def collect[T](f: String => T) = {sc.nextLine().split(" ").toVector.map(f)}
      def intSeq() = collect(_.toInt)
      def doubleSeq() = collect(_.toDouble)
      def int() = sc.nextInt()
      def double() = sc.nextDouble()
    }
}


object _877C extends CodeForcesApp {
  import Utils._, annotation._, collection.{mutable, Searching}, util._, control._, math.Ordering.Implicits._, Searching._

  override def apply(io: IO): io.type = {
    val n = io.read[Int]
    val indices = 1 to n

    def mod(m: Int) = indices.filter(_%2 == m)

    val ans = mod(0) ++ mod(1) ++ mod(0)

    io.write(ans.length).writeLine().writeAll(ans)
  }
}
/****************************[Ignore Template Below]****************************************/
trait CodeForcesApp {
  lazy val isOnlineJudge: Boolean = sys.props.get("ONLINE_JUDGE").exists(_.toBoolean)
  def debug(x: => Any): Unit = if (!isOnlineJudge) println(x)
  def apply(io: IO): io.type
  def main(args: Array[String]): Unit = this(new IO(System.in, System.out)).close()
}
object Utils {
  import scala.collection.mutable, mutable.{Map => Dict}
  implicit class GenericExtensions[A](val a: A) extends AnyVal {
    def in(set: collection.Set[A]): Boolean = set(a)
    def some: Option[A] = Some(a)
    def partialMatch[B](f: PartialFunction[A, B]): Option[B] = f lift a
  }
  implicit class TraversableExtensions[A, C[X] <: Traversable[X]](val t: C[A]) extends AnyVal {
    def onlyElement: A = assuming(t.size == 1)(t.head)
    def groupByIdentifier[K](f: A => K): Map[K, A] = t.groupBy(f).mapValues(_.onlyElement)
    def duplicates(implicit b: C of A): C[A] = {
      val elems = mutable.Set.empty[A]
      (t collect {case i if !elems.add(i) => i}).to[C]
    }
    def sumWith[B](f: A => B)(implicit n: Numeric[B]): B = t.foldLeft(n.zero) {case (p, i) => n.plus(p, f(i))}
    def maxWith[B](f: A => B)(implicit ord: Ordering[B]): Option[B] = t.view.map(f).reduceOption(ord.max)
    def minWith[B](f: A => B)(implicit ord: Ordering[B]): Option[B] = t.view.map(f).reduceOption(ord.min)
    def zipWith[B](f: A => B)(implicit b: C of (A, B)): C[(A, B)] = (t map {i => i -> f(i)}).to[C]
    def mapTo[B](f: A => B)(implicit b: C of (A, B)): Map[A, B] = zipWith(f).toUniqueMap
    def whenNonEmpty[B](f: t.type => B): Option[B] = when(t.nonEmpty)(f(t))  // e.g. grades.whenNonEmpty(_.max)
    def collectFirst[B](f: PartialFunction[A, Option[B]]): Option[B] = t.view collect f collectFirst {case Some(x) => x}
    def toMutableMultiSet: Dict[A, Int] = {
      val c = map[A] to 0
      t.foreach(i => c(i) += 1)
      c
    }
    def toMultiSet: Map[A, Int] = toMutableMultiSet.toMap withDefaultValue 0
    def X[B](s: Traversable[B]): Iterator[(A, B)] = for {a <- t.toIterator; b <- s} yield (a, b)
  }
  implicit class ArrayExtensions[A <: AnyRef](val a: Array[A]) extends AnyVal {
    def sort(from: Int, until: Int)(implicit cmp: Ordering[A]): Unit = java.util.Arrays.sort(a, from, until, cmp) //sort [from, until)
  }
  implicit class ArrayExtensions2[A](val a: Array[A]) extends AnyVal {
    def sort(from: Int, until: Int)(implicit cmp: Ordering[A]): Unit = a.view(from, until).sorted.copyToArray(a, from)
  }
  implicit class SeqExtensions[A, C[X] <: Seq[X]](val s: C[A]) extends AnyVal {
    def isRotationOf(t: Seq[A]): Boolean = s ++ s containsSlice t
  }
  implicit class PairExtensions[A, B](val p: (A, B)) extends AnyVal {
    def key = p._1
    def value = p._2
    def toSeq(implicit ev: A =:= B): Seq[A] = Seq(p._1, p._2.asInstanceOf[A])
  }
  implicit class PairsExtensions[A, B, C[X] <: Traversable[X]](t: C[(A, B)]) {
    def toUniqueMap: Map[A, B] = t.groupByIdentifier(_.key).mapValues(_.value)
    def toMultiMap(implicit b: C of B): Map[A, C[B]] = t.groupBy(_.key).mapValues(_.map(_.value).to[C])
    def swap(implicit b: C of (B, A)): C[(B, A)] = t.map(_.swap).to[C]
  }
  implicit class MapExtensions[K, V, C[X, Y] <: Map[X, Y]](val m: C[K, V]) extends AnyVal {
    def lastKeyOption: Option[K] = m.lastOption.map(_.key)
    def firstKeyOption: Option[K] = m.headOption.map(_.key)
    def invert: Map[V, Set[K]] = m.toSet[(K, V)].swap.toMultiMap
    def mapKeys[K2](f: K => K2): Map[K2, V] = m map {case (k, v) => f(k) -> v}
    def toMutable: Dict[K, V] = Dict.empty[K, V] ++ m
    def mapValuesSafely[V2](f: V => V2): Map[K, V2] = m.mapValues(f).view.force //Hack to get around https://issues.scala-lang.org/browse/SI-4776
  }
  implicit class MutableMapExtensions[K, V](val m: mutable.Map[K, V]) extends AnyVal {
    def removeLast(): Option[(K, V)] = m.lastOption.map(removeNode)
    def removeFirst(): Option[(K, V)] = m.headOption.map(removeNode)
    private def removeNode(kv: (K, V)): (K, V) = {
      m -= kv.key
      kv
    }
  }
  implicit class SetExtensions[A, C[A] <: Set[A]](val s: C[A]) extends AnyVal {
    def notContains(x: A): Boolean = !(s contains x)
    def toMutable = mutable.Set.empty[A] ++ s
  }
  implicit class IterableExtensions[A, C[A] <: Seq[A]](val s: C[A]) extends AnyVal {
    def indicesWhere(f: A => Boolean): Seq[Int] = s.zipWithIndex.collect {case (a, i) if f(a) => i}
    def deleteAtIndex(i: Int, howMany: Int = 1) = s.patch(i, Nil, howMany)
    def insertAtIndex(i: Int, items: Seq[A]) = s.patch(i, items, 0)
    def findWithIndex(f: A => Boolean): Option[(A, Int)] = s.zipWithIndex find {case (a, _) => f(a)}
    def foldUntil[B](z: B)(f: (B, A) => B)(c: B => Boolean): Option[(B, Int)] = s.view.scanLeft(z)(f).findWithIndex(c)
  }
  implicit class BooleanExtensions(val x: Boolean) extends AnyVal {
    def to[A](implicit n: Numeric[A]) = if(x) n.one else n.zero
    def toEnglish = if(x) "Yes" else "No"
  }
  implicit class IntExtensions(val x: Int) extends AnyVal {
    import java.lang.{Integer => JInt}
    def withHighestOneBit: Int = JInt.highestOneBit(x)
    def withLowestOneBit: Int = JInt.lowestOneBit(x)
    def numberOfLeadingZeroes: Int = JInt.numberOfLeadingZeros(x)
    def numberOfTrailingZeroes: Int = JInt.numberOfTrailingZeros(x)
    def bitCount: Int = JInt.bitCount(x)
    def setLowestBits(n: Int): Int = x | (left(n) - 1)
    def clearLowestBits(n: Int): Int = x & left(n, ~0)
    def setBit(i: Int, set: Boolean): Int = if (set) setBit(i) else clearBit(i)
    def setBit(i: Int): Int = x | left(i)
    def clearBit(i: Int): Int = x & ~left(i)
    def toggleBit(i: Int): Int = x ^ left(i)
    def testBit(i: Int): Boolean = ((x >> i) & 1) == 1
    private def left(bits: Int, num: Int = 1) = assuming(bits >= 0 && bits < JInt.SIZE)(num << bits)
    def X(y: Int): Iterator[(Int, Int)] = until(x) X until(y)
  }
  implicit class LongExtensions(val x: Long) extends AnyVal {
    import java.lang.{Long => JLong}
    def withHighestOneBitSet: Long = JLong.highestOneBit(x)
    def withLowestOneBitSet: Long = JLong.lowestOneBit(x)
    def numberOfLeadingZeroes: Int = JLong.numberOfLeadingZeros(x)
    def numberOfTrailingZeroes: Int = JLong.numberOfTrailingZeros(x)
    def bitCount: Int = JLong.bitCount(x)
    def setLowestBits(n: Int): Long = x | (left(n) - 1)
    def clearLowestBits(n: Int): Long = x & left(n, ~0L)
    def setBit(i: Int, set: Boolean): Long = if (set) setBit(i) else clearBit(i)
    def setBit(i: Int): Long = x | left(i)
    def clearBit(i: Int): Long = x & ~left(i)
    def toggleBit(i: Int): Long = x ^ left(i)
    def testBit(i: Int): Boolean = ((x >> i) & 1) == 1
    private def left(bits: Int, num: Long = 1L) = assuming(bits >= 0 && bits < JLong.SIZE)(num << bits)
  }
  implicit class NumericExtensions[A](val x: A)(implicit n: Numeric[A]) {
    import Numeric.Implicits._
    def **(i: Int): A = if (i == 0) n.one else {
      val h = x ** (i/2)
      if (i%2 == 0) h * h else h * h * x
    }
    def distance(y: A) = (x - y).abs()
    def nonNegative: Option[A] = when(n.gteq(x, n.zero))(x)
    def whenNegative(f: => A): A = nonNegative getOrElse f   //e.g. students indexOf "Greg" whenNegative Int.MaxValue
  }
  implicit class IntegralExtensions[A](val x: A)(implicit n: Integral[A]) {
    import scala.collection.immutable.NumericRange, Integral.Implicits._
    def mod(y: A): A = x - ((x / y) * y) //(x/y)*y + (x mod y) == x
    def -->(y: A): NumericRange.Inclusive[A] = NumericRange.inclusive(x, y, if (n.lteq(x, y)) n.one else -n.one)
    def ceilDiv(y: A): A = if (mod(y) == n.zero) x/y else n.one + (x/y)
  }
  implicit def toPoint[A](p: (A, A))(implicit n: Numeric[A]) = new java.awt.geom.Point2D.Double(n.toDouble(p._1), n.toDouble(p._2))
  def desc[A: Ordering]: Ordering[A] = asc[A].reverse  //e.g. students.sortBy(_.height)(desc)
  def asc[A](implicit order: Ordering[A]): Ordering[A] = order
  def map[K] = new {
    def to[V](default: => V): Dict[K, V] = using(_ => default)
    def using[V](f: K => V): Dict[K, V] = new mutable.HashMap[K, V]() {
      override def apply(key: K) = getOrElseUpdate(key, f(key))
    }
  }
  def newMultiMap[K, V] = map[K] to mutable.Set.empty[V]
  def memoize[A, B](f: A => B): A ==> B = map[A] using f
  implicit class FuzzyDouble(val x: Double) extends AnyVal {
    def  >~(y: Double) = x > y + eps
    def >=~(y: Double) = x >= y + eps
    def  ~<(y: Double) = y >=~ x
    def ~=<(y: Double) = y >~ x
    def  ~=(y: Double) = (x distance y) <= eps
  }
  def toPolygon(points: Traversable[(Int, Int)]): java.awt.Polygon = {
    val (xs, ys) = points.unzip
    new java.awt.Polygon(xs.toArray, ys.toArray, points.size)
  }
  def toShape(points: Traversable[(Double, Double)]): java.awt.geom.GeneralPath = {
    val shape = new java.awt.geom.GeneralPath()
    points.headOption foreach {case (x, y) => shape.moveTo(x, y)}
    points.tail foreach {case (x, y) => shape.lineTo(x, y)}
    shape.closePath()
    shape
  }
  def until(until: Int): Range = 0 until until
  def not[A](f: A => Boolean): A => Boolean = {x: A => !f(x)}
  def assuming[A](cond: => Boolean)(f: => A): A = {require(cond); f}
  @inline def when[A](check: Boolean)(f: => A): Option[A] = if (check) f.some else None
  def repeat[U](n: Int)(f: => U): Unit = (1 to n).foreach(_ => f)
  type of[C[_], A] = scala.collection.generic.CanBuild[A, C[A]]
  type ==>[A, B] = collection.Map[A, B]
  val mod: Int = (1e9 + 7).toInt
  val eps: Double = 1e-9
}
/***********************************[Scala I/O]*********************************************/
import Utils._, java.io._, java.util.StringTokenizer

class IO(in: BufferedReader, out: BufferedWriter) extends Iterator[String] with AutoCloseable with Flushable {
  def this(reader: Reader, writer: Writer) = this(new BufferedReader(reader), new BufferedWriter(writer))
  def this(in: InputStream, out: OutputStream) = this(new InputStreamReader(in), new OutputStreamWriter(out))

  private[this] val tokenizers = Iterator.continually(in.readLine()).takeWhile(_ != null).map(new StringTokenizer(_)).buffered
  val printer = new PrintWriter(out, true)

  @inline private[this] def tokenizer() = {
    while(tokenizers.nonEmpty && !tokenizers.head.hasMoreTokens) tokenizers.next()
    when(tokenizers.nonEmpty)(tokenizers.head)
  }

  def read[A](implicit read: IO.Read[A]): A = read.apply(this)
  def read[C[_], A: IO.Read](n: Int)(implicit b: C of A): C[A] = Iterator.fill(n)(read).to[C]

  def readTill(delim: String): String = tokenizer().get.nextToken(delim)
  def readTillEndOfLine(): String = readTill("\n\r")

  def readAll[A: IO.Read]: (Int, Vector[A]) = {
    val data = read[Vector[A]]
    (data.length, data)
  }

  override def next() = tokenizer().get.nextToken()
  override def hasNext = tokenizer().nonEmpty

  def write(obj: Any): this.type = {
    printer.print(obj)
    this
  }
  def writeLine(): this.type = {
    printer.println()
    this
  }
  def writeLine(obj: Any): this.type = {
    printer.println(obj)
    this
  }
  def writeAll(obj: Traversable[Any], separator: String = " "): this.type = write(obj mkString separator)
  def query[A: IO.Read](question: Any): A = writeLine(question).read

  override def flush() = printer.flush()
  def close() = {
    flush()
    in.close()
    printer.close()
  }
}
object IO {
  class Read[A](val apply: IO => A) {
    def map[B](f: A => B): Read[B] = new Read(apply andThen f)
  }
  object Read {
    implicit def collection[C[_], A: Read](implicit b: C of A): Read[C[A]]         = new Read(r => r.read[C, A](r.read[Int]))
    implicit val string                                       : Read[String]       = new Read(_.next())
    implicit val char                                         : Read[Char]         = string.map(_.toTraversable.onlyElement)
    implicit val int                                          : Read[Int]          = string.map(_.toInt)
    implicit val long                                         : Read[Long]         = string.map(_.toLong)
    implicit val bigInt                                       : Read[BigInt]       = string.map(BigInt(_))
    implicit val double                                       : Read[Double]       = string.map(_.toDouble)
    implicit val bigDecimal                                   : Read[BigDecimal]   = string.map(BigDecimal(_))
    implicit def tuple2[A: Read, B: Read]                     : Read[(A, B)]       = new Read(r => (r.read[A], r.read[B]))
    implicit def tuple3[A: Read, B: Read, C: Read]            : Read[(A, B, C)]    = new Read(r => (r.read[A], r.read[B], r.read[C]))
    implicit def tuple4[A: Read, B: Read, C: Read, D: Read]   : Read[(A, B, C, D)] = new Read(r => (r.read[A], r.read[B], r.read[C], r.read[D]))
    implicit val boolean                                      : Read[Boolean]      = string map {s =>
      s.toLowerCase match {
        case "yes" | "true" | "1" => true
        case "no" | "false" | "0" => false
        case _ => s.toBoolean
      }
    }
  }
}

import scala.io.StdIn._
import scala.collection.mutable.ArraySeq

object Codeforces extends App {
  val size = readInt()
  println(size + size / 2)
  val first = 1 to size filter(_ % 2 == 0)
  val second = 1 to size filter (_ % 2 == 1)
  (first ++ second ++ first) foreach(index => print(index.toString + " "))
  /*val beauty = readLine()
  var aCount: Int = 0
  var bCount: Int = 0
  val a = beauty.map(c => {
    if (c == 'a')
      aCount += 1
    aCount
  }).toArray
  val b = beauty.map(c => {
    if (c == 'b')
      bCount += 1
    bCount
  })
  var max: Int = 0
  for (i <- 0 to (beauty.length - 1))
    for (j <- i to (beauty.length - 1)) {
      max = math.max(max, a(i) + (b(j) - b(i)) + (a(a.length - 1) - a(j)))
      println(max)
      //if (i + 1 < beauty.length)
      //  max = math.max(max, a(i) + (b(j) - b(i) + (a(a.length - 1) - a(j))))
    }
  println(max)*/
}

import scala.io.StdIn._
import scala.collection.mutable.ArraySeq

object Codeforces extends App {
  val size = readInt()
  println(size + 1)
  1 to size foreach(s => {
    val current = size - s + 1
    print(s"$current ")
  })
  print(2)
  /*val beauty = readLine()
  var aCount: Int = 0
  var bCount: Int = 0
  val a = beauty.map(c => {
    if (c == 'a')
      aCount += 1
    aCount
  }).toArray
  val b = beauty.map(c => {
    if (c == 'b')
      bCount += 1
    bCount
  })
  var max: Int = 0
  for (i <- 0 to (beauty.length - 1))
    for (j <- i to (beauty.length - 1)) {
      max = math.max(max, a(i) + (b(j) - b(i)) + (a(a.length - 1) - a(j)))
      println(max)
      //if (i + 1 < beauty.length)
      //  max = math.max(max, a(i) + (b(j) - b(i) + (a(a.length - 1) - a(j))))
    }
  println(max)*/
}


import scala.collection.mutable._

object C extends App {

  def tokenizeLine = new java.util.StringTokenizer(readLine)
  def readInts(n: Int) = { val t = tokenizeLine; Array.fill(n)(t.nextToken.toInt) }

  val next = "DIMAD"

  val Array(n, m) = readInts(2)
  val as = Array.fill(n)(readLine)

  val dd = Array.ofDim[ArrayBuffer[Int]](n * m)
  val cnt = Array.fill(n * m)(0)
  val color = Array.fill[Byte](n * m){ 0 }

  def visit(i: Int, j: Int, d: Int, source: Int) {
    if (as(i)(j) == next(d)) {
      if (d == 3) cnt(source) = 1
      if (d == 4) {
        if (dd(source) == null) dd(source) = ArrayBuffer(i * m + j)
        else dd(source) += (i * m + j)
      } else {
        val d2 = d + 1
        if (i > 0) visit(i - 1, j, d2, source)
        if (i < n - 1) visit(i + 1, j, d2, source)
        if (j > 0) visit(i, j - 1, d2, source)
        if (j < m - 1) visit(i, j + 1, d2, source)
      }
    }
  }

  var i = 0
  while (i < n) {
    var j = 0
    while (j < m) {
      if (as(i)(j) == 'D') visit(i, j, 0, i * m + j)
      j += 1
    }
    i += 1
  }

  def dfs(u: Int): Int = {
    if (color(u) == 1) {
      println("Poor Inna!")
      sys.exit
    }
    if (color(u) > 0 || dd(u) == null) cnt(u)
    else {
      var max = 0
      color(u) = 1
      for (v <- dd(u)) max = Math.max(max, dfs(v))
      color(u) = 2
      cnt(u) = max + 1
      max + 1
    }
  }

  for (u <- dd.indices if dd(u) != null) dfs(u)

  val max = cnt.max
  if (max == 0) println("Poor Dima!") else println(max)
}

import scala.collection.mutable._

object C extends App {

  def tokenizeLine = new java.util.StringTokenizer(readLine)
  def readInts(n: Int) = { val t = tokenizeLine; Array.fill(n)(t.nextToken.toInt) }

  val next = "DIMAD".toCharArray

  val Array(n, m) = readInts(2)
  val as = Array.fill(n)(readLine.toCharArray)

  val dd = Array.ofDim[ArrayBuffer[Int]](n * m)
  val cnt = Array.fill(n * m)(0)
  val color = Array.fill[Byte](n * m){ 0 }

  def visit(i: Int, j: Int, d: Int, source: Int) {
    if (as(i)(j) == next(d)) {
      if (d == 3) cnt(source) = 1
      if (d == 4) {
        if (dd(source) == null) dd(source) = ArrayBuffer(i * m + j)
        else dd(source) += (i * m + j)
      } else {
        val d2 = d + 1
        if (i > 0) visit(i - 1, j, d2, source)
        if (i < n - 1) visit(i + 1, j, d2, source)
        if (j > 0) visit(i, j - 1, d2, source)
        if (j < m - 1) visit(i, j + 1, d2, source)
      }
    }
  }

  var i = 0
  while (i < n) {
    var j = 0
    while (j < m) {
      if (as(i)(j) == 'D') visit(i, j, 0, i * m + j)
      j += 1
    }
    i += 1
  }

  def dfs(u: Int): Int = {
    if (color(u) == 1) {
      println("Poor Inna!")
      sys.exit
    }
    if (color(u) > 0 || dd(u) == null) cnt(u)
    else {
      var max = 0
      color(u) = 1
      for (v <- dd(u)) max = Math.max(max, dfs(v))
      color(u) = 2
      cnt(u) = max + 1
      max + 1
    }
  }

  for (u <- dd.indices if dd(u) != null) dfs(u)

  val max = cnt.max
  if (max == 0) println("Poor Dima!") else println(max)
}

import scala.collection.mutable._

object C extends App {

  def tokenizeLine = new java.util.StringTokenizer(readLine)
  def readInts(n: Int) = { val t = tokenizeLine; Array.fill(n)(t.nextToken.toInt) }

  val next = "DIMAD".toCharArray

  val Array(n, m) = readInts(2)
  val as = Array.fill(n)(readLine.toCharArray)

  val dd = Array.ofDim[ArrayBuffer[Int]](n * m)
  val cnt = Array.fill(n * m)(0)
  val color = Array.fill[Byte](n * m){ 0 }

  def visit(i: Int, j: Int, d: Int, source: Int) {
    if (as(i)(j) == next(d)) {
      if (d == 3) cnt(source) = 1
      if (d == 4) {
        if (dd(source) == null) dd(source) = ArrayBuffer(i * m + j)
        else dd(source) += (i * m + j)
      } else {
        val d2 = d + 1
        if (i > 0) visit(i - 1, j, d2, source)
        if (i < n - 1) visit(i + 1, j, d2, source)
        if (j > 0) visit(i, j - 1, d2, source)
        if (j < m - 1) visit(i, j + 1, d2, source)
      }
    }
  }

  for (i <- 0 until n; j <- 0 until m) if (as(i)(j) == 'D') visit(i, j, 0, i * m + j)

  def dfs(u: Int): Int = {
    if (color(u) == 1) {
      println("Poor Inna!")
      sys.exit
    }
    if (color(u) > 0 || dd(u) == null) cnt(u)
    else {
      var max = 0
      color(u) = 1
      for (v <- dd(u)) max = Math.max(max, dfs(v))
      color(u) = 2
      cnt(u) = max + 1
      max + 1
    }
  }

  for (u <- dd.indices if dd(u) != null) dfs(u)

  val max = cnt.max
  if (max == 0) println("Poor Dima!") else println(max)
}

import scala.collection.mutable._

object C extends App {

  def tokenizeLine = new java.util.StringTokenizer(readLine)
  def readInts(n: Int) = { val t = tokenizeLine; Array.fill(n)(t.nextToken.toInt) }

  val next = "DIMAD"

  val Array(n, m) = readInts(2)
  val as = Array.fill(n)(readLine)

  val dd = Array.ofDim[ArrayBuffer[Int]](n * m)
  val cnt = Array.fill(n * m)(0)
  val color = Array.fill[Byte](n * m){ 0 }

  def visit(i: Int, j: Int, d: Int, source: Int) {
    if (as(i)(j) == next(d)) {
      if (d == 3) cnt(source) = 1
      if (d == 4) {
        if (dd(source) == null) dd(source) = ArrayBuffer(i * m + j)
        else dd(source) += (i * m + j)
      } else {
        val d2 = d + 1
        if (i > 0) visit(i - 1, j, d2, source)
        if (i < n - 1) visit(i + 1, j, d2, source)
        if (j > 0) visit(i, j - 1, d2, source)
        if (j < m - 1) visit(i, j + 1, d2, source)
      }
    }
  }

  for (i <- 0 until n; j <- 0 until m) if (as(i)(j) == 'D') visit(i, j, 0, i * m + j)

  def dfs(u: Int): Int = {
    if (color(u) == 1) {
      println("Poor Inna!")
      sys.exit
    }
    if (color(u) > 0 || dd(u) == null) cnt(u)
    else {
      var max = 0
      color(u) = 1
      for (v <- dd(u)) max = Math.max(max, dfs(v))
      color(u) = 2
      cnt(u) = max + 1
      max + 1
    }
  }

  for (u <- dd.indices if dd(u) != null) dfs(u)

  val max = cnt.max
  if (max == 0) println("Poor Dima!") else println(max)
}

import scala.collection.mutable._

object C extends App {

  def tokenizeLine = new java.util.StringTokenizer(readLine)
  def readInts(n: Int) = { val t = tokenizeLine; Array.fill(n)(t.nextToken.toInt) }

  val next = "DIMAD".toCharArray

  val Array(n, m) = readInts(2)
  val as = Array.fill(n)(readLine.toCharArray)

  val dd = Array.ofDim[ArrayBuffer[Int]](n * m)
  val cnt = Array.fill(n * m)(0)
  val color = Array.fill[Byte](n * m) { 0 }

  def visit(i: Int, j: Int, d: Int, source: Int) {
    if (as(i)(j) == next(d)) {
      if (d == 3) cnt(source) = 1
      if (d == 4) {
        if (dd(source) == null) dd(source) = ArrayBuffer(i * m + j)
        else dd(source) += (i * m + j)
      } else {
        val d2 = d + 1
        if (i > 0) visit(i - 1, j, d2, source)
        if (i < n - 1) visit(i + 1, j, d2, source)
        if (j > 0) visit(i, j - 1, d2, source)
        if (j < m - 1) visit(i, j + 1, d2, source)
      }
    }
  }

  var i = 0
  while (i < n) {
    var j = 0
    while (j < m) {
      if (as(i)(j) == 'D') visit(i, j, 0, i * m + j)
      j += 1
    }
    i += 1
  }

  def dfs(u: Int): Int = {
    if (color(u) == 1) {
      println("Poor Inna!")
      sys.exit
    }
    if (color(u) > 0 || dd(u) == null) cnt(u)
    else {
      var max = 0
      color(u) = 1
      for (v <- dd(u)) max = Math.max(max, dfs(v))
      color(u) = 2
      cnt(u) = max + 1
      max + 1
    }
  }

  var u = 0
  while (u < dd.size) {
    if (dd(u) != null) dfs(u)
    u += 1
  }

  val max = cnt.max
  if (max == 0) println("Poor Dima!") else println(max)
}

import scala.collection.mutable._

object C extends App {

  def tokenizeLine = new java.util.StringTokenizer(readLine)
  def readInts(n: Int) = { val t = tokenizeLine; Array.fill(n)(t.nextToken.toInt) }

  val next = "DIMAD"

  val Array(n, m) = readInts(2)
  val as = Array.fill(n)(readLine)

  val dd = Array.ofDim[ArrayBuffer[Int]](n * m)
  val cnt = Array.fill(n * m)(0)
  val color = Array.fill(n * m){ 0 }

  def visit(i: Int, j: Int, d: Int, source: Int) {
    if (as(i)(j) == next(d)) {
      if (d == 3) cnt(source) = 1
      if (d == 4) {
        if (dd(source) == null) dd(source) = ArrayBuffer(i * m + j)
        else dd(source) += (i * m + j)
      } else {
        val d2 = d + 1
        if (i > 0) visit(i - 1, j, d2, source)
        if (i < n - 1) visit(i + 1, j, d2, source)
        if (j > 0) visit(i, j - 1, d2, source)
        if (j < m - 1) visit(i, j + 1, d2, source)
      }
    }
  }

  var i = 0
  while (i < n) {
    var j = 0
    while (j < m) {
      if (as(i)(j) == 'D') visit(i, j, 0, i * m + j)
      j += 1
    }
    i += 1
  }

  def dfs(u: Int): Int = {
    if (color(u) == 1) {
      println("Poor Inna!")
      sys.exit
    }
    if (color(u) > 0 || dd(u) == null) cnt(u)
    else {
      var max = 0
      color(u) = 1
      for (v <- dd(u)) max = Math.max(max, dfs(v))
      color(u) = 2
      cnt(u) = max + 1
      max + 1
    }
  }

  for (u <- dd.indices if dd(u) != null) dfs(u)

  val max = cnt.max
  if (max == 0) println("Poor Dima!") else println(max)
}

import scala.collection.mutable._

object C extends App {

  def tokenizeLine = new java.util.StringTokenizer(readLine)
  def readInts(n: Int) = { val t = tokenizeLine; Array.fill(n)(t.nextToken.toInt) }

  val next = "DIMAD"

  val Array(n, m) = readInts(2)
  val as = Array.fill(n)(readLine)

  val dd = Array.ofDim[ArrayBuffer[Int]](n * m)
  val cnt = Array.fill(n * m)(0)
  val color = Array.fill[Byte](n * m) { 0 }

  def visit(i: Int, j: Int, d: Int, source: Int) {
    if (as(i)(j) == next(d)) {
      if (d == 3) cnt(source) = 1
      if (d == 4) {
        if (dd(source) == null) dd(source) = ArrayBuffer(i * m + j)
        else dd(source) += (i * m + j)
      } else {
        val d2 = d + 1
        if (i > 0) visit(i - 1, j, d2, source)
        if (i < n - 1) visit(i + 1, j, d2, source)
        if (j > 0) visit(i, j - 1, d2, source)
        if (j < m - 1) visit(i, j + 1, d2, source)
      }
    }
  }

  var i = 0
  while (i < n) {
    var j = 0
    while (j < m) {
      if (as(i)(j) == 'D') visit(i, j, 0, i * m + j)
      j += 1
    }
    i += 1
  }

  def dfs(u: Int): Int = {
    if (color(u) == 1) {
      println("Poor Inna!")
      sys.exit
    }
    if (color(u) > 0 || dd(u) == null) cnt(u)
    else {
      var max = 0
      color(u) = 1
      for (v <- dd(u)) max = Math.max(max, dfs(v))
      color(u) = 2
      cnt(u) = max + 1
      max + 1
    }
  }

  var u = 0
  while (u < dd.size) {
    if (dd(u) != null) dfs(u)
    u += 1
  }

  val max = cnt.max
  if (max == 0) println("Poor Dima!") else println(max)
}

import scala.collection.mutable._

object C extends App {

  def tokenizeLine = new java.util.StringTokenizer(readLine)
  def readInts(n: Int) = { val t = tokenizeLine; Array.fill(n)(t.nextToken.toInt) }

  val next = "DIMAD"

  val Array(n, m) = readInts(2)
  val dd = Array.ofDim[ArrayBuffer[Int]](n * m)
  val as = Array.fill(n)(readLine)
  val cnt = Array.fill(n * m)(0)

  def visit(i: Int, j: Int, d: Int, source: Int) {
    if (as(i)(j) == next(d)) {
      if (d == 3) cnt(source) = 1
      if (d == 4) {
        if (dd(source) == null) dd(source) = ArrayBuffer(i * m + j)
        else dd(source) += (i * m + j)
      } else {
        val d2 = d + 1
        if (i > 0) visit(i - 1, j, d2, source)
        if (i < n - 1) visit(i + 1, j, d2, source)
        if (j > 0) visit(i, j - 1, d2, source)
        if (j < m - 1) visit(i, j + 1, d2, source)
      }
    }
  }

  def dists() {
    var u = 0
    while (u < dd.length) {
      if (dd(u) != null) {
        var vi = 0
        while (vi < dd(u).length) {
          val v = dd(u)(vi)
          if (cnt(v) > 0 && cnt(v) < cnt(u) + 1) cnt(v) = cnt(u) + 1
          vi += 1
        }
      }
      u += 1
    }
  }

  var i = 0
  while (i < n) {
    var j = 0
    while (j < m) {
      if (as(i)(j) == 'D') visit(i, j, 0, i * m + j)
      j += 1
    }
    i += 1
  }

  dists()
  dists()
  val max = cnt.max
  dists()

  if (max == cnt.max) {
    if (max == 0) println("Poor Dima!") else println(max)
  } else println("Poor Inna!")
}

import scala.collection.mutable._

object C extends App {

  def tokenizeLine = new java.util.StringTokenizer(readLine)
  def readInts(n: Int) = { val t = tokenizeLine; Array.fill(n)(t.nextToken.toInt) }

  val next = "DIMAD"

  val Array(n, m) = readInts(2)
  val dd = Array.ofDim[ArrayBuffer[Int]](n * m)
  val as = Array.fill(n)(readLine)
  val cnt = Array.fill(n * m)(0)

  def visit(i: Int, j: Int, d: Int, source: Int) {
    if (as(i)(j) == next(d)) {
      if (d == 3) cnt(source) = 1
      if (d == 4) {
        if (dd(source) == null) dd(source) = ArrayBuffer(i * m + j)
        else dd(source) += (i * m + j)
      } else {
        val d2 = d + 1
        if (i > 0) visit(i - 1, j, d2, source)
        if (i < n - 1) visit(i + 1, j, d2, source)
        if (j > 0) visit(i, j - 1, d2, source)
        if (j < m - 1) visit(i, j + 1, d2, source)
      }
    }
  }

  def dists() {
    var u = 0
    while (u < dd.length) {
      if (dd(u) != null) {
        var vi = 0
        while (vi < dd(u).length) {
          val v = dd(u)(vi)
          if (cnt(v) > 0 && cnt(v) < cnt(u) + 1) cnt(v) = cnt(u) + 1
          vi += 1
        }
      }
      u += 1
    }
  }

  var i = 0
  while (i < n) {
    var j = 0
    while (j < m) {
      if (as(i)(j) == 'D') visit(i, j, 0, i * m + j)
      j += 1
    }
    i += 1
  }

  dists()
  val max = cnt.max
  dists()

  if (max == cnt.max) {
    if (max == 0) println("Poor Dima!") else println(max)
  } else println("Poor Inna!")
}


object Main {
  def main(args: Array[String]): Unit = {
    val s = new Main()
    s.solve()
    s.out.flush()
  }
}

class Main {
  import java.io._
  import java.util.StringTokenizer

  import scala.collection.mutable
  import scala.util.Sorting
  import math.{abs, max, min}
  import mutable.{ArrayBuffer, ListBuffer}
  import scala.reflect.ClassTag

  val MOD = 1000000007
  val out = new PrintWriter(System.out)

  def solve(): Unit = {
    val b, k = ni()
    val A = na(k)
    val even = if (b % 2 == 0) {
      A(k - 1) % 2 == 0
    } else {
      A.map(_ & 1).sum % 2 == 0
    }

    if (even) out.println("even")
    else out.println("odd")
  }

  def debug(as: Array[Boolean]): Unit = {
    System.err.println(as.map(x => if(x) "1" else "0").mkString)
  }

  def debug(as: Array[Int]): Unit = {
    System.err.println(as.mkString(" "))
  }

  def debug(as: Array[Long]): Unit = {
    System.err.println(as.mkString(" "))
  }

  def debug(s: String): Unit = {
    System.err.println(s)
  }

  def debug(num: Long): Unit = {
    System.err.println(num)
  }

  class InputReader(val stream: InputStream) {
    private val reader = new BufferedReader(new InputStreamReader(stream), 32768)
    private var tokenizer: StringTokenizer = _

    def next(): String = {
      while (tokenizer == null || !tokenizer.hasMoreTokens)
        tokenizer = new StringTokenizer(reader.readLine)
      tokenizer.nextToken
    }

    def nextInt(): Int = next().toInt
    def nextLong(): Long = next().toLong
    def nextChar(): Char = next().charAt(0)
  }
  val sc = new InputReader(System.in)
  def ni(): Int = sc.nextInt()
  def nl(): Long = sc.nextLong()
  def nc(): Char = sc.nextChar()
  def ns(): String = sc.next()
  def ns(n: Int): Array[Char] = ns().toCharArray
  def na(n: Int, offset: Int = 0): Array[Int] = map(n)(_ => ni() + offset)
  def na2(n: Int, offset: Int = 0): (Array[Int], Array[Int]) = {
    val A1, A2 = Array.ofDim[Int](n)
    REP(n) { i =>
      A1(i) = ni() + offset
      A2(i) = ni() + offset
    }
    (A1, A2)
  }
  def nm(n: Int, m: Int): Array[Array[Int]] = {
    val A = Array.ofDim[Int](n, m)
    REP(n) { i =>
      REP(m) { j =>
        A(i)(j) = ni()
      }
    }
    A
  }
  def nal(n: Int): Array[Long] = map(n)(_ => nl())
  def nm_c(n: Int, m: Int): Array[Array[Char]] = map(n) (_ => ns(m))
  def REP(n: Int, offset: Int = 0)(f: Int => Unit): Unit = {
    var i = offset
    val N = n + offset
    while(i < N) { f(i); i += 1 }
  }
  def REP_r(n: Int, offset: Int = 0)(f: Int => Unit): Unit = {
    var i = n - 1 + offset
    while(i >= offset) { f(i); i -= 1 }
  }

  def map[@specialized A: ClassTag](n: Int, offset: Int = 0)(f: Int => A): Array[A] = {
    val res = Array.ofDim[A](n)
    REP(n)(i => res(i) = f(i + offset))
    res
  }

  def sumL(as: Array[Int]): Long = {
    var s = 0L
    REP(as.length)(i => s += as(i))
    s
  }

  def cumSum(as: Array[Int]) = {
    val cum = Array.ofDim[Long](as.length + 1)
    REP(as.length) { i =>
      cum(i + 1) = cum(i) + as(i)
    }
    cum
  }
}

object A extends App {

  @inline def tokenizeLine = new java.util.StringTokenizer(scala.io.StdIn.readLine)
  def readInts(n: Int) = { val tl = tokenizeLine; Array.fill(n)(tl.nextToken.toInt) }
  def readLongs(n: Int) = { val tl = tokenizeLine; Array.fill(n)(tl.nextToken.toLong) }
  def readBigs(n: Int) = { val tl = tokenizeLine; Array.fill(n)(BigInt(tl.nextToken)) }

  val Array(b, k) = readInts(2)
  val as = readInts(k)

  var p = 0L
  var kk = 1L

  for (a <- as.reverse) {
    val x = kk * a % 2
    p = (p + x) % 2
    kk = kk * b % 2
  }

  println(if (p == 0) "even" else "odd")

  Console.flush
}

object Main {
  def main(args: Array[String]): Unit = {
    val s = new Main()
    s.solve()
    s.out.flush()
  }
}

class Main {
  import java.io._
  import java.util.StringTokenizer

  import scala.collection.mutable
  import scala.util.Sorting
  import math.{abs, max, min}
  import mutable.{ArrayBuffer, ListBuffer}
  import scala.reflect.ClassTag

  val MOD = 1000000007
  val out = new PrintWriter(System.out)

  def solve(): Unit = {
    val b, k = ni()
    val A = na(k)
    val even = if (b % 2 == 0) {
      A(k - 1) % b == 0
    } else {
      A.map(_ & 1).sum % 2 == 0
    }

    if (even) out.println("even")
    else out.println("odd")
  }

  def debug(as: Array[Boolean]): Unit = {
    System.err.println(as.map(x => if(x) "1" else "0").mkString)
  }

  def debug(as: Array[Int]): Unit = {
    System.err.println(as.mkString(" "))
  }

  def debug(as: Array[Long]): Unit = {
    System.err.println(as.mkString(" "))
  }

  def debug(s: String): Unit = {
    System.err.println(s)
  }

  def debug(num: Long): Unit = {
    System.err.println(num)
  }

  class InputReader(val stream: InputStream) {
    private val reader = new BufferedReader(new InputStreamReader(stream), 32768)
    private var tokenizer: StringTokenizer = _

    def next(): String = {
      while (tokenizer == null || !tokenizer.hasMoreTokens)
        tokenizer = new StringTokenizer(reader.readLine)
      tokenizer.nextToken
    }

    def nextInt(): Int = next().toInt
    def nextLong(): Long = next().toLong
    def nextChar(): Char = next().charAt(0)
  }
  val sc = new InputReader(System.in)
  def ni(): Int = sc.nextInt()
  def nl(): Long = sc.nextLong()
  def nc(): Char = sc.nextChar()
  def ns(): String = sc.next()
  def ns(n: Int): Array[Char] = ns().toCharArray
  def na(n: Int, offset: Int = 0): Array[Int] = map(n)(_ => ni() + offset)
  def na2(n: Int, offset: Int = 0): (Array[Int], Array[Int]) = {
    val A1, A2 = Array.ofDim[Int](n)
    REP(n) { i =>
      A1(i) = ni() + offset
      A2(i) = ni() + offset
    }
    (A1, A2)
  }
  def nm(n: Int, m: Int): Array[Array[Int]] = {
    val A = Array.ofDim[Int](n, m)
    REP(n) { i =>
      REP(m) { j =>
        A(i)(j) = ni()
      }
    }
    A
  }
  def nal(n: Int): Array[Long] = map(n)(_ => nl())
  def nm_c(n: Int, m: Int): Array[Array[Char]] = map(n) (_ => ns(m))
  def REP(n: Int, offset: Int = 0)(f: Int => Unit): Unit = {
    var i = offset
    val N = n + offset
    while(i < N) { f(i); i += 1 }
  }
  def REP_r(n: Int, offset: Int = 0)(f: Int => Unit): Unit = {
    var i = n - 1 + offset
    while(i >= offset) { f(i); i -= 1 }
  }

  def map[@specialized A: ClassTag](n: Int, offset: Int = 0)(f: Int => A): Array[A] = {
    val res = Array.ofDim[A](n)
    REP(n)(i => res(i) = f(i + offset))
    res
  }

  def sumL(as: Array[Int]): Long = {
    var s = 0L
    REP(as.length)(i => s += as(i))
    s
  }

  def cumSum(as: Array[Int]) = {
    val cum = Array.ofDim[Long](as.length + 1)
    REP(as.length) { i =>
      cum(i + 1) = cum(i) + as(i)
    }
    cum
  }
}

object Main {
  def main(args: Array[String]): Unit = {
    val s = new Main()
    s.solve()
    s.out.flush()
  }
}

class Main {
  import java.io._
  import java.util.StringTokenizer

  import scala.collection.mutable
  import scala.util.Sorting
  import math.{abs, max, min}
  import mutable.{ArrayBuffer, ListBuffer}
  import scala.reflect.ClassTag

  val MOD = 1000000007
  val out = new PrintWriter(System.out)

  def solve(): Unit = {
    val b, k = ni()
    val A = na(k)
    val even = if (b % 2 == 0) {
      k % b == 0
    } else {
      A.map(_ & 1).sum % 2 == 0
    }

    if (even) out.println("even")
    else out.println("odd")
  }

  def debug(as: Array[Boolean]): Unit = {
    System.err.println(as.map(x => if(x) "1" else "0").mkString)
  }

  def debug(as: Array[Int]): Unit = {
    System.err.println(as.mkString(" "))
  }

  def debug(as: Array[Long]): Unit = {
    System.err.println(as.mkString(" "))
  }

  def debug(s: String): Unit = {
    System.err.println(s)
  }

  def debug(num: Long): Unit = {
    System.err.println(num)
  }

  class InputReader(val stream: InputStream) {
    private val reader = new BufferedReader(new InputStreamReader(stream), 32768)
    private var tokenizer: StringTokenizer = _

    def next(): String = {
      while (tokenizer == null || !tokenizer.hasMoreTokens)
        tokenizer = new StringTokenizer(reader.readLine)
      tokenizer.nextToken
    }

    def nextInt(): Int = next().toInt
    def nextLong(): Long = next().toLong
    def nextChar(): Char = next().charAt(0)
  }
  val sc = new InputReader(System.in)
  def ni(): Int = sc.nextInt()
  def nl(): Long = sc.nextLong()
  def nc(): Char = sc.nextChar()
  def ns(): String = sc.next()
  def ns(n: Int): Array[Char] = ns().toCharArray
  def na(n: Int, offset: Int = 0): Array[Int] = map(n)(_ => ni() + offset)
  def na2(n: Int, offset: Int = 0): (Array[Int], Array[Int]) = {
    val A1, A2 = Array.ofDim[Int](n)
    REP(n) { i =>
      A1(i) = ni() + offset
      A2(i) = ni() + offset
    }
    (A1, A2)
  }
  def nm(n: Int, m: Int): Array[Array[Int]] = {
    val A = Array.ofDim[Int](n, m)
    REP(n) { i =>
      REP(m) { j =>
        A(i)(j) = ni()
      }
    }
    A
  }
  def nal(n: Int): Array[Long] = map(n)(_ => nl())
  def nm_c(n: Int, m: Int): Array[Array[Char]] = map(n) (_ => ns(m))
  def REP(n: Int, offset: Int = 0)(f: Int => Unit): Unit = {
    var i = offset
    val N = n + offset
    while(i < N) { f(i); i += 1 }
  }
  def REP_r(n: Int, offset: Int = 0)(f: Int => Unit): Unit = {
    var i = n - 1 + offset
    while(i >= offset) { f(i); i -= 1 }
  }

  def map[@specialized A: ClassTag](n: Int, offset: Int = 0)(f: Int => A): Array[A] = {
    val res = Array.ofDim[A](n)
    REP(n)(i => res(i) = f(i + offset))
    res
  }

  def sumL(as: Array[Int]): Long = {
    var s = 0L
    REP(as.length)(i => s += as(i))
    s
  }

  def cumSum(as: Array[Int]) = {
    val cum = Array.ofDim[Long](as.length + 1)
    REP(as.length) { i =>
      cum(i + 1) = cum(i) + as(i)
    }
    cum
  }
}


object B {
  import InOut._
  def main(args: Array[String]): Unit = {

    for (_ <- 1 to nextInt) {
      val n = nextInt
      val as = nextLongs(n)
      var res = 0
      val lim = 2 * n
      var i = 0
      while (i < as.length) {
        val a1 = as(i)
        var a2 = a1 + 1
        var aa = a1 * a2
        while (a2 <= lim) {
          val j = aa - (i + 1) - 1
//          println(a1, a2, j)
          if (j >= 0 && j < as.length && as(j.toInt) == a2) {
//            println(i + 1, j + 1)
            res += 1
          }
          a2 += 1
          aa += a1
          if (j > as.length + 10) {
            a2 = lim + 1
          }
        }

        i += 1
      }

      out.println(res)
    }

    out.flush()
  }

  final object InOut {
    val in = new java.io.BufferedReader(new java.io.InputStreamReader(System.in))
    val out = new java.io.PrintWriter(System.out, false)
    private[this] var tokenizer: java.util.StringTokenizer = _
    def nextToken: String = {
      while (tokenizer == null || !tokenizer.hasMoreTokens)
        tokenizer = new java.util.StringTokenizer(in.readLine)
      tokenizer.nextToken
    }
    def nextInt = Integer.parseInt(nextToken)
    def nextLong = java.lang.Long.parseLong(nextToken)
    def nextBig = BigInt(nextToken)
    def nextInts(n: Int) = Array.fill(n) { nextInt }
    def nextLongs(n: Int) = Array.fill(n) { nextLong }
    def nextBigs(n: Int) = Array.fill(n) { nextBig }
    def nextLine = in.readLine
  }
}

object B extends App {
  import scala.io.StdIn._
  import scala.collection.mutable.TreeSet

  val t = readInt()

  (0 until t).foreach { _ =>
    val n  = readInt()
    val an = readLine().split(" ").map(_.toInt)
    val in = {
      val in = Array.fill(2 * n + 1)(0)
      an.indices.foreach { i => in(an(i)) = i }
      in
    }

    val ans = an.indices.foldLeft(0) { case (count, i) =>
      val ai = an(i)
      (((2 * i + 1) / ai) to ((n + i + 1) / ai)).foldLeft(count) { case (count, aj) =>
        val j = in(aj)
        if (j >= i + 1 && ai * aj == i + j + 2) count + 1
        else count
      }
    }

    println(ans)
  }
}

object B extends App {
  import scala.io.StdIn._

  val t = readInt()

  (0 until t).foreach { _ =>
    val n  = readInt()
    val an = readLine().split(" ").map(_.toInt)
    val in = {
      val in = Array.fill(2 * n + 1)(0)
      an.indices.foreach(i => in(an(i)) = i)
      in
    }

    val ans = an.indices.foldLeft(0) { case (count, i) =>
      val ai = an(i)
      count + (((2 * i + 1) / ai) to ((n + i + 1) / ai)).count { aj =>
        val j = in(aj)
        j >= i + 1 && ai * aj == i + j + 2
      }
    }

    println(ans)
  }
}

object B {
  import InOut._
  def main(args: Array[String]): Unit = {

    for (_ <- 1 to nextInt) {
      val n = nextInt
      val as = nextLongs(n)
      var res = 0
      val lim = 2 * n
      var i = 0
      while (i < as.length) {
        val a1 = as(i)
        var a2 = a1
        var aa = a1 * a1
        while (a2 <= lim) {
          val j = aa - (i + 1) - 1
//          println(a1, a2, j)
          if (j >= 0 && j < as.length && as(j.toInt) == a2) {
//            println(i + 1, j + 1)
            res += 1
          }
          a2 += 1
          aa += a1
          if (j > as.length + 10) {
            a2 = lim + 1
          }
        }

        i += 1
      }

      out.println(res)
    }

    out.flush()
  }

  final object InOut {
    val in = new java.io.BufferedReader(new java.io.InputStreamReader(System.in))
    val out = new java.io.PrintWriter(System.out, false)
    private[this] var tokenizer: java.util.StringTokenizer = _
    def nextToken: String = {
      while (tokenizer == null || !tokenizer.hasMoreTokens)
        tokenizer = new java.util.StringTokenizer(in.readLine)
      tokenizer.nextToken
    }
    def nextInt = Integer.parseInt(nextToken)
    def nextLong = java.lang.Long.parseLong(nextToken)
    def nextBig = BigInt(nextToken)
    def nextInts(n: Int) = Array.fill(n) { nextInt }
    def nextLongs(n: Int) = Array.fill(n) { nextLong }
    def nextBigs(n: Int) = Array.fill(n) { nextBig }
    def nextLine = in.readLine
  }
}

object B {
  import InOut._
  def main(args: Array[String]): Unit = {

    for (_ <- 1 to nextInt) {
      val n = nextInt
      val as = nextLongs(n)
      var res = 0
      val lim = 2 * n
      var i = 0
      while (i < as.length) {
        val a1 = as(i)
        var a2 = a1
        var aa = a1 * a1
        while (aa <= lim) {
          val j = aa - (i + 1) - 1
//          println(a1, a2, j)
          if (j >= 0 && j < as.length && as(j.toInt) == a2) {
//            println(i + 1, j + 1)
            res += 1
          }
          a2 += 1
          aa += a1
        }

        i += 1
      }

      out.println(res)
    }

    out.flush()
  }

  final object InOut {
    val in = new java.io.BufferedReader(new java.io.InputStreamReader(System.in))
    val out = new java.io.PrintWriter(System.out, false)
    private[this] var tokenizer: java.util.StringTokenizer = _
    def nextToken: String = {
      while (tokenizer == null || !tokenizer.hasMoreTokens)
        tokenizer = new java.util.StringTokenizer(in.readLine)
      tokenizer.nextToken
    }
    def nextInt = Integer.parseInt(nextToken)
    def nextLong = java.lang.Long.parseLong(nextToken)
    def nextBig = BigInt(nextToken)
    def nextInts(n: Int) = Array.fill(n) { nextInt }
    def nextLongs(n: Int) = Array.fill(n) { nextLong }
    def nextBigs(n: Int) = Array.fill(n) { nextBig }
    def nextLine = in.readLine
  }
}

object B {
  import InOut._
  def main(args: Array[String]): Unit = {

    for (_ <- 1 to nextInt) {
      val n = nextInt
      val as = nextInts(n)
      var res = 0
      val lim = 2 * n
      var i = 0
      while (i < as.length) {
        val a1 = as(i)
        var a2 = a1
        var aa = a1 * a1
        while (aa <= lim) {
          val j = aa - (i + 1) - 1
//          println(a1, a2, j)
          if (j >= 0 && j < as.length && as(j) == a2) {
//            println(i + 1, j + 1)
            res += 1
          }
          a2 += 1
          aa += a1
        }

        i += 1
      }

      out.println(res)
    }

    out.flush()
  }

  final object InOut {
    val in = new java.io.BufferedReader(new java.io.InputStreamReader(System.in))
    val out = new java.io.PrintWriter(System.out, false)
    private[this] var tokenizer: java.util.StringTokenizer = _
    def nextToken: String = {
      while (tokenizer == null || !tokenizer.hasMoreTokens)
        tokenizer = new java.util.StringTokenizer(in.readLine)
      tokenizer.nextToken
    }
    def nextInt = Integer.parseInt(nextToken)
    def nextLong = java.lang.Long.parseLong(nextToken)
    def nextBig = BigInt(nextToken)
    def nextInts(n: Int) = Array.fill(n) { nextInt }
    def nextLongs(n: Int) = Array.fill(n) { nextLong }
    def nextBigs(n: Int) = Array.fill(n) { nextBig }
    def nextLine = in.readLine
  }
}


import scala.io.StdIn._

object A extends App {

  val t = readInt()
  1 to t foreach { _ =>
    val n = readInt()
    println((1 to n map (_ => 1)).mkString(" "))
  }

}

import scala.io.StdIn._

object A {

	def main(args: Array[String]) {
		val t = readInt()
		1 to t foreach { _ =>
			val n = readInt()
			println((1 to n map (_ => 1)).mkString(" "))
		}
	}
}

object ProblemA extends App {
  import java.io.{BufferedReader, InputStreamReader, PrintWriter}
  import java.util.StringTokenizer
  val in = new FastScanner(new BufferedReader(new InputStreamReader(System.in)))
  val out = new PrintWriter(System.out)

  class FastScanner(val in: BufferedReader) {
    var st: StringTokenizer = _;

    def nextToken(): String = {
      while (st == null || !st.hasMoreTokens) {
        st = new StringTokenizer(in.readLine);
      }
      return st.nextToken();
    }

    def nextInt(): Integer = {
      Integer.parseInt(nextToken());
    }

    def nextLong(): Long = {
      nextToken().toLong;
    }

    def nextDouble(): Double = {
      nextToken().toDouble;
    }
  }

  val t = in.nextInt()
  for (_ <- 1 to t) {
    val n = in.nextInt()
    val res = (1 to n).map(_ => 1).mkString(" ")
    println(res)
  }
}

object CodeforcesRound655a {

  import java.io.{BufferedReader, PrintStream}

  import scala.io.Source

  def main(args: Array[String]): Unit = {
    exec(Source.stdin.bufferedReader, System.out)
  }

  def exec(implicit
           reader: BufferedReader,
           writer: PrintStream): Unit = {
    val t: Int = rl_int
    (1 to t).foreach(_ => test())
  }

  def test()
          (implicit
           reader: BufferedReader,
           writer: PrintStream): Unit = {
    val n = rl_int
    writer.println(Array.fill(n)(1).mkString(" "))
  }

  def sqr(a: Long): Long = a * a

  def rl(implicit reader: BufferedReader): String = reader.readLine
  def rll(implicit reader: BufferedReader): Array[String] = reader.readLine.split(' ')

  def rl_bool(implicit reader: BufferedReader): Boolean = rl.toBoolean
  def rl_byte(implicit reader: BufferedReader): Byte = rl.toByte
  def rl_short(implicit reader: BufferedReader): Short = rl.toShort
  def rl_int(implicit reader: BufferedReader): Int = rl.toInt
  def rl_long(implicit reader: BufferedReader): Long = rl.toLong
  def rl_float(implicit reader: BufferedReader): Float = rl.toFloat
  def rl_double(implicit reader: BufferedReader): Double = rl.toDouble

  def rll_bool(implicit reader: BufferedReader): Array[Boolean] = rll.map(_.toBoolean)
  def rll_byte(implicit reader: BufferedReader): Array[Byte] = rll.map(_.toByte)
  def rll_short(implicit reader: BufferedReader): Array[Short] = rll.map(_.toShort)
  def rll_int(implicit reader: BufferedReader): Array[Int] = rll.map(_.toInt)
  def rll_long(implicit reader: BufferedReader): Array[Long] = rll.map(_.toLong)
  def rll_float(implicit reader: BufferedReader): Array[Float] = rll.map(_.toFloat)
  def rll_double(implicit reader: BufferedReader): Array[Double] = rll.map(_.toDouble)

}

object _1372A extends CodeForcesApp {
  import Utils._, annotation._, collection.{mutable, Searching}, util._, control._, math.Ordering.Implicits._, Searching._, Math._

  override def solve(io: IO) = io.repeat {
    val n = io.read[Int]
    val ans = Seq.fill(n)(1)
    io.writeAll(ans)
  }
}
/****************************[Ignore Template Below]****************************************/
trait CodeForcesApp {
  lazy val isOnlineJudge: Boolean = sys.props.get("ONLINE_JUDGE").exists(_.toBoolean)
  def debug(x: => Any): Unit = if (!isOnlineJudge) println(x)
  def solve(io: IO): Any
  def main(args: Array[String]): Unit = {
    val io = new IO(System.in, System.out)
    try solve(io) finally io.close()
  }
}
/****************************[Scala Collection Utils]****************************************/
object Utils {
  import scala.collection.mutable

  type of[C[_], A] = scala.collection.generic.CanBuild[A, C[A]]

  def when[A](check: Boolean)(f: => A): Option[A] = if (check) Some(f) else None

  def repeat[U](n: Int)(f: => U): Unit = (1 to n).foreach(_ => f)

  val charToInt: Char => Int = Character.getNumericValue
  val intToChar: Int => Char = Character.forDigit(_, 10)

  implicit class GenericExtensions[A](a: A) {
    def partialMatch[B](f: PartialFunction[A, B]): Option[B] = f lift a
  }

  implicit class TraversableExtensions[A, C[X] <: Traversable[X]](t: C[A]) {
    def zipWith[B](f: A => B)(implicit b: C of (A, B)): C[(A, B)] = (t map {i => i -> f(i)}).to[C]

    def whenNonEmpty[B](f: t.type => B): Option[B] = when(t.nonEmpty)(f(t))  // e.g. grades.whenNonEmpty(_.max)

    def toMultiSet(withDefaultZero: Boolean): Map[A, Int] = {
      val freqTable = t.groupBy(identity).mapValues(_.size)
      if (withDefaultZero) freqTable.withDefaultValue(0) else freqTable
    }
  }

  implicit class PairExtensions[A, B](p: (A, B)) {
    def key = p._1
    def value = p._2
    def toSeq(implicit ev: B =:= A): Seq[A] = Seq(p.key, ev(p.value))
  }

  implicit class PairsExtensions[A, B, C[X] <: Traversable[X]](t: C[(A, B)]) {
    def toMultiMap(implicit b: C of B): Map[A, C[B]] = t.groupBy(_.key).mapValues(_.map(_.value).to[C]).withDefaultValue(b().result())
  }

  implicit class MapExtensions[K, V, C[X, Y] <: Map[X, Y]](m: C[K, V]) {
    def toMutable: mutable.Map[K, V] = mutable.Map.empty[K, V] ++ m
  }

  implicit class SetExtensions[A, C[A] <: Set[A]](s: C[A]) {
    def notContains(x: A): Boolean = !(s contains x)
    def toMutable = mutable.Set.empty[A] ++ s
  }

  implicit class IterableExtensions[A, C[A] <: Seq[A]](s: C[A]) {
    def indicesWhere(f: A => Boolean): Seq[Int] = s.zipWithIndex.collect {case (a, i) if f(a) => i}
    def deleteAtIndex(i: Int, howMany: Int = 1) = s.patch(i, Nil, howMany)
    def insertAtIndex(i: Int, items: Seq[A]) = s.patch(i, items, 0)
    def findWithIndex(f: A => Boolean): Option[(A, Int)] = s.zipWithIndex find {case (a, _) => f(a)}
  }

  implicit class BooleanExtensions(x: Boolean) {
    def to[A](implicit n: Numeric[A]) = if(x) n.one else n.zero
    def toEnglish = if(x) "Yes" else "No"
  }

  implicit class IntExtensions(val x: Int) extends AnyVal {
    @inline def isEven = x%2 == 0
    @inline def isOdd = x%2 == 1
  }

  def desc[A](implicit order: Ordering[A]): Ordering[A] = order.reverse  //e.g. students.sortBy(_.height)(desc)

  def map[K] = new {
    def to[V](default: => V): mutable.Map[K, V] = using(_ => default)
    def using[V](f: K => V): mutable.Map[K, V] = new mutable.HashMap[K, V]() {
      override def apply(key: K) = getOrElseUpdate(key, f(key))
    }
  }

  def newMultiMap[K, V] = map[K] to mutable.Set.empty[V]

  def memoize[A, B](f: A => B): A => B = map[A] using f
}
/***********************************[Scala I/O]*********************************************/
import java.io._, java.util.StringTokenizer
import scala.collection.generic.CanBuild

class IO(in: BufferedReader, out: BufferedWriter) extends Iterator[String] with AutoCloseable with Flushable {
  def this(reader: Reader, writer: Writer) = this(new BufferedReader(reader), new BufferedWriter(writer))
  def this(in: InputStream, out: OutputStream) = this(new InputStreamReader(in), new OutputStreamWriter(out))

  private[this] val tokenizers = Iterator.continually(in.readLine()).takeWhile(_ != null).map(new StringTokenizer(_)).buffered
  val printer = new PrintWriter(out, true)

  @inline private[this] def tokenizer() = {
    while(tokenizers.nonEmpty && !tokenizers.head.hasMoreTokens) tokenizers.next()
    tokenizers.headOption
  }

  def read[A](implicit read: IO.Read[A]): A = read.apply(this)
  def read[C[_], A: IO.Read](n: Int)(implicit b: CanBuild[A, C[A]]): C[A] = Iterator.fill(n)(read).to[C]
  def readTill(delim: String): String = tokenizer().get.nextToken(delim)
  def readTillEndOfLine(): String = readTill("\n\r")

  override def next() = tokenizer().get.nextToken()
  override def hasNext = tokenizer().nonEmpty

  def write(obj: Any*): this.type = writeAll(obj)
  def writeLine(obj: Any*): this.type = {if (obj.isEmpty) printer.println() else obj.foreach(printer.println); this}
  def writeAll(obj: Traversable[Any], separator: String = " "): this.type = {printer.print(obj.mkString(separator)); this}
  def query[A: IO.Read](question: Any): A = writeLine(question).read

  def repeat(f: => Unit): Unit = Utils.repeat(read[Int]){f; writeLine()}

  override def flush() = printer.flush()
  def close() = {
    flush()
    in.close()
    printer.close()
  }
}
object IO {
  class Read[A](val apply: IO => A) {
    def map[B](f: A => B): Read[B] = new Read(apply andThen f)
  }
  object Read {
    implicit def collection[C[_], A: Read](implicit b: CanBuild[A, C[A]]) : Read[C[A]]         = new Read(r => r.read[C, A](r.read[Int]))
    implicit val string                                                   : Read[String]       = new Read(_.next())
    implicit val int                                                      : Read[Int]          = string.map(_.toInt)
    implicit val long                                                     : Read[Long]         = string.map(_.toLong)
    implicit val bigInt                                                   : Read[BigInt]       = string.map(BigInt(_))
    implicit val double                                                   : Read[Double]       = string.map(_.toDouble)
    implicit val bigDecimal                                               : Read[BigDecimal]   = string.map(BigDecimal(_))
    implicit def tuple2[A: Read, B: Read]                                 : Read[(A, B)]       = new Read(r => (r.read[A], r.read[B]))
    implicit def tuple3[A: Read, B: Read, C: Read]                        : Read[(A, B, C)]    = new Read(r => (r.read[A], r.read[B], r.read[C]))
    implicit def tuple4[A: Read, B: Read, C: Read, D: Read]               : Read[(A, B, C, D)] = new Read(r => (r.read[A], r.read[B], r.read[C], r.read[D]))
    implicit val boolean                                                  : Read[Boolean]      = string map {s =>
      s.toLowerCase match {
        case "yes" | "true" | "1" => true
        case "no" | "false" | "0" => false
        case _ => s.toBoolean
      }
    }
  }
}

object _1372A extends CodeForcesApp {
  import Utils._, annotation._, collection.{mutable, Searching}, util._, control._, math.Ordering.Implicits._, Searching._, Math._

  override def solve(io: IO) = io.repeat {
    val n = io.read[Int]
    val ans = Seq.tabulate(n)(i => 2*i + 1)
    io.writeAll(ans)
  }
}
/****************************[Ignore Template Below]****************************************/
trait CodeForcesApp {
  lazy val isOnlineJudge: Boolean = sys.props.get("ONLINE_JUDGE").exists(_.toBoolean)
  def debug(x: => Any): Unit = if (!isOnlineJudge) println(x)
  def solve(io: IO): Any
  def main(args: Array[String]): Unit = {
    val io = new IO(System.in, System.out)
    try solve(io) finally io.close()
  }
}
/****************************[Scala Collection Utils]****************************************/
object Utils {
  import scala.collection.mutable

  type of[C[_], A] = scala.collection.generic.CanBuild[A, C[A]]

  def when[A](check: Boolean)(f: => A): Option[A] = if (check) Some(f) else None

  def repeat[U](n: Int)(f: => U): Unit = (1 to n).foreach(_ => f)

  val charToInt: Char => Int = Character.getNumericValue
  val intToChar: Int => Char = Character.forDigit(_, 10)

  implicit class GenericExtensions[A](a: A) {
    def partialMatch[B](f: PartialFunction[A, B]): Option[B] = f lift a
  }

  implicit class TraversableExtensions[A, C[X] <: Traversable[X]](t: C[A]) {
    def zipWith[B](f: A => B)(implicit b: C of (A, B)): C[(A, B)] = (t map {i => i -> f(i)}).to[C]

    def whenNonEmpty[B](f: t.type => B): Option[B] = when(t.nonEmpty)(f(t))  // e.g. grades.whenNonEmpty(_.max)

    def toMultiSet(withDefaultZero: Boolean): Map[A, Int] = {
      val freqTable = t.groupBy(identity).mapValues(_.size)
      if (withDefaultZero) freqTable.withDefaultValue(0) else freqTable
    }
  }

  implicit class PairExtensions[A, B](p: (A, B)) {
    def key = p._1
    def value = p._2
    def toSeq(implicit ev: B =:= A): Seq[A] = Seq(p.key, ev(p.value))
  }

  implicit class PairsExtensions[A, B, C[X] <: Traversable[X]](t: C[(A, B)]) {
    def toMultiMap(implicit b: C of B): Map[A, C[B]] = t.groupBy(_.key).mapValues(_.map(_.value).to[C]).withDefaultValue(b().result())
  }

  implicit class MapExtensions[K, V, C[X, Y] <: Map[X, Y]](m: C[K, V]) {
    def toMutable: mutable.Map[K, V] = mutable.Map.empty[K, V] ++ m
  }

  implicit class SetExtensions[A, C[A] <: Set[A]](s: C[A]) {
    def notContains(x: A): Boolean = !(s contains x)
    def toMutable = mutable.Set.empty[A] ++ s
  }

  implicit class IterableExtensions[A, C[A] <: Seq[A]](s: C[A]) {
    def indicesWhere(f: A => Boolean): Seq[Int] = s.zipWithIndex.collect {case (a, i) if f(a) => i}
    def deleteAtIndex(i: Int, howMany: Int = 1) = s.patch(i, Nil, howMany)
    def insertAtIndex(i: Int, items: Seq[A]) = s.patch(i, items, 0)
    def findWithIndex(f: A => Boolean): Option[(A, Int)] = s.zipWithIndex find {case (a, _) => f(a)}
  }

  implicit class BooleanExtensions(x: Boolean) {
    def to[A](implicit n: Numeric[A]) = if(x) n.one else n.zero
    def toEnglish = if(x) "Yes" else "No"
  }

  implicit class IntExtensions(val x: Int) extends AnyVal {
    @inline def isEven = x%2 == 0
    @inline def isOdd = x%2 == 1
  }

  def desc[A](implicit order: Ordering[A]): Ordering[A] = order.reverse  //e.g. students.sortBy(_.height)(desc)

  def map[K] = new {
    def to[V](default: => V): mutable.Map[K, V] = using(_ => default)
    def using[V](f: K => V): mutable.Map[K, V] = new mutable.HashMap[K, V]() {
      override def apply(key: K) = getOrElseUpdate(key, f(key))
    }
  }

  def newMultiMap[K, V] = map[K] to mutable.Set.empty[V]

  def memoize[A, B](f: A => B): A => B = map[A] using f
}
/***********************************[Scala I/O]*********************************************/
import java.io._, java.util.StringTokenizer
import scala.collection.generic.CanBuild

class IO(in: BufferedReader, out: BufferedWriter) extends Iterator[String] with AutoCloseable with Flushable {
  def this(reader: Reader, writer: Writer) = this(new BufferedReader(reader), new BufferedWriter(writer))
  def this(in: InputStream, out: OutputStream) = this(new InputStreamReader(in), new OutputStreamWriter(out))

  private[this] val tokenizers = Iterator.continually(in.readLine()).takeWhile(_ != null).map(new StringTokenizer(_)).buffered
  val printer = new PrintWriter(out, true)

  @inline private[this] def tokenizer() = {
    while(tokenizers.nonEmpty && !tokenizers.head.hasMoreTokens) tokenizers.next()
    tokenizers.headOption
  }

  def read[A](implicit read: IO.Read[A]): A = read.apply(this)
  def read[C[_], A: IO.Read](n: Int)(implicit b: CanBuild[A, C[A]]): C[A] = Iterator.fill(n)(read).to[C]
  def readTill(delim: String): String = tokenizer().get.nextToken(delim)
  def readTillEndOfLine(): String = readTill("\n\r")

  override def next() = tokenizer().get.nextToken()
  override def hasNext = tokenizer().nonEmpty

  def write(obj: Any*): this.type = writeAll(obj)
  def writeLine(obj: Any*): this.type = {if (obj.isEmpty) printer.println() else obj.foreach(printer.println); this}
  def writeAll(obj: Traversable[Any], separator: String = " "): this.type = {printer.print(obj.mkString(separator)); this}
  def query[A: IO.Read](question: Any): A = writeLine(question).read

  def repeat(f: => Unit): Unit = Utils.repeat(read[Int]){f; writeLine()}

  override def flush() = printer.flush()
  def close() = {
    flush()
    in.close()
    printer.close()
  }
}
object IO {
  class Read[A](val apply: IO => A) {
    def map[B](f: A => B): Read[B] = new Read(apply andThen f)
  }
  object Read {
    implicit def collection[C[_], A: Read](implicit b: CanBuild[A, C[A]]) : Read[C[A]]         = new Read(r => r.read[C, A](r.read[Int]))
    implicit val string                                                   : Read[String]       = new Read(_.next())
    implicit val int                                                      : Read[Int]          = string.map(_.toInt)
    implicit val long                                                     : Read[Long]         = string.map(_.toLong)
    implicit val bigInt                                                   : Read[BigInt]       = string.map(BigInt(_))
    implicit val double                                                   : Read[Double]       = string.map(_.toDouble)
    implicit val bigDecimal                                               : Read[BigDecimal]   = string.map(BigDecimal(_))
    implicit def tuple2[A: Read, B: Read]                                 : Read[(A, B)]       = new Read(r => (r.read[A], r.read[B]))
    implicit def tuple3[A: Read, B: Read, C: Read]                        : Read[(A, B, C)]    = new Read(r => (r.read[A], r.read[B], r.read[C]))
    implicit def tuple4[A: Read, B: Read, C: Read, D: Read]               : Read[(A, B, C, D)] = new Read(r => (r.read[A], r.read[B], r.read[C], r.read[D]))
    implicit val boolean                                                  : Read[Boolean]      = string map {s =>
      s.toLowerCase match {
        case "yes" | "true" | "1" => true
        case "no" | "false" | "0" => false
        case _ => s.toBoolean
      }
    }
  }
}