import Data.List (find, sortBy)
import Data.Maybe (fromJust)
import Data.Ord (comparing)

type Credit = Int
type Price = Int

pairs :: [a] -> [(a, a)]
pairs [] = []
pairs [x] = []
pairs (x:xs) = map (\e -> (x, e)) xs ++ pairs xs

solve :: (Credit, [Price]) -> (Int, Int)
solve (c, items) = (fst i, fst j)
    where (i, j) = fromJust
                 . find (\((_, p1), (_, p2)) -> p1 + p2 == c)
                 . pairs
                 . takeWhile (\(_, p) -> p < c)
                 . sortBy (comparing snd)
                 . zip [1..]
                 $ items


render :: Int -> (Int, Int) -> String
render caseNo (a, b) = "Case #" ++ show caseNo ++ ": " ++ show a ++ " " ++ show b

parse :: [String] -> [(Credit, [Price])]
parse (c:_:prices:rest) = (read c, map read (words prices)) : parse rest
parse _ = []

run :: [String] -> [String]
run (_:xs) = zipWith render [1..] . map solve . parse $ xs

main :: IO ()
main = interact (unlines . run . lines)