import Control.Monad
import Control.Applicative
import Data.Array.ST
import Debug.Trace
--import qualified Data.List as L
import Control.Monad.ST
import Data.STRef
import Data.Array.Unboxed

type Arr s = STUArray s Int Int

main :: IO ()
main = do
  n <- readLn :: IO Int
  unless (n == 0) $ do
    ns <- map read . words <$> getLine :: IO [Int]
    let (key, ans) = solve n ns
   -- trace (show (key, ans)) (return ())
    if ans > (n `div` 2)
      then print key
      else putStrLn "NO COLOR"
    main

solve :: Int -> [Int] -> (Int, Int)
solve n ns = runST $ do
  arr <- newListArray (0, n-1) ns
  quickSort 0 (n-1) arr
  --let arr' = freeze arr :: UArray Int Int
  let mid = (n `div` 2)
  trg <- readArray arr mid
  left <- binarySearch (0, mid) trg arr (>=)
  right <- binarySearch (mid, n) trg arr (<=)
  return (trg, right - left)

binarySearch :: (Int, Int) -> Int -> Arr s ->
                (Int -> Int -> Bool) -> ST s Int
binarySearch (l, r) trg arr p = go l r arr 
  where
    go :: Int -> Int -> Arr s -> ST s Int
    go i j arr
      | i == j = return j
      | otherwise = do
      let mid = (i + j) `div` 2
      mid' <- readArray arr mid
--      trace (show (mid, mid')) (return ())
      if (p trg mid')
        then go i mid  arr
        else go (mid+1) j  arr

quickSort :: Int -> Int -> Arr s -> ST s ()
quickSort l0 r0 arr = go l0 r0 arr
  where
    go :: Int -> Int -> Arr s -> ST s ()
    go l r arr
      | l >= r = return ()
      | otherwise = do
          ref <- newSTRef 0
          mid <- readArray arr ((l + r) `div` 2)
          (i, j) <- while l r mid arr ref
          go l (i-1) arr
          go (j+1) r arr
    swap :: Int -> Int -> STRef s Int -> Arr s -> ST s ()
    swap i j ref arr = do
      readArray arr i >>= writeSTRef ref
      readArray arr j >>= writeArray arr i
      readSTRef ref >>= writeArray arr j
    inc :: Int -> Int -> Arr s -> ST s Int
    inc i mid arr
      | i > r0 = return i
      | otherwise = do
          tmp <- readArray arr i
          if tmp < mid
             then inc (i+1) mid arr
             else return i
    dec :: Int -> Int -> Arr s -> ST s Int
    dec i mid arr
      | i < l0 = return i
      | otherwise = do
          tmp <- readArray arr i
          if tmp > mid
             then dec (i-1) mid arr
             else return i
    while :: Int -> Int -> Int -> Arr s -> STRef s Int -> ST s (Int, Int)
    while i j mid arr ref = do
      i' <- inc i mid arr
      j' <- dec j mid arr
      if (i' < j')
        then do
        swap i' j' ref arr
        while (i+1) (j-1) mid arr ref
      else return (i, j)