-- Enter your code here. Read input from STDIN. Print output to STDOUT
import Data.List

generateRow :: Int -> Int -> [[Int]] -> [[Int]]
generateRow current max list
    | current >= max = []
    | current == 0 = [[1]] ++ (generateRow (current + 1) max [[1]])
    | current == 1 = [[1,1]] ++ (generateRow (current + 1) max [[1,1]])
    | current < max = do
                      let x = ([[1] ++ (addTogether (last list)) ++ [1]])
                      x ++ (generateRow (current + 1) max x)
                      
addTogether :: [Int] -> [Int]
addTogether x = (zipWith (+) x (tail x))

generateTriangle :: Int -> IO [[Int]]
generateTriangle max = return (generateRow 0 max [])

convertLineToInt :: String -> IO Int
convertLineToInt line = return (read line :: Int)

printTriangle :: [[Int]] -> IO ()
printTriangle x = case x of
                    [] -> return ()
                    (a:b) -> do
                             let y = (intercalate " " (map show a))
                             putStrLn $ y
                             printTriangle b

defmodule Solution do
    def get_next(l) do
        [0] ++ (Enum.zip(l, tl l) |> Enum.map(fn {a, b} -> a+b end)) ++ [0]
    end
    
    def pasc(_, 0), do: []
    def pasc(prev, iter) do
        next = get_next(prev)
        [next] ++ pasc(next, iter-1)
    end
    
    def get_pasc(n), do: [[0, 1, 0]] ++ pasc([0, 1, 0], n)
end

{n, _} = Integer.parse(IO.gets "")
Solution.get_pasc(n-1)
    |> Enum.each(fn row -> 
        Enum.reject(row, &(&1 == 0))
            |> Enum.map(&Integer.to_string(&1) <> " ")
            |> List.to_string() # |> String.trim()
            |> IO.puts()
    end)

    def main(args: Array[String]) {
        val n = StdIn.readInt()
        println("1")
        printPascalTriangle(n, List(1))
    }
    
    @tailrec
    def printPascalTriangle(n: Int, prevRow: List[Int]): Unit = {
        if (prevRow.size < n) {
            val currentRow = 
                1 :: (for (i <- 1 to prevRow.size) yield 
                        prevRow(i - 1) + 
                            (if (i < prevRow.size) prevRow(i) else 0)
                ).toList
            println(currentRow.mkString(" "))
            printPascalTriangle(n, currentRow)
        }
    }

facto n = product [1..n]

printLine :: Int -> Int -> IO ()
printLine vari n
    | vari == 0 = putStr "1 "
    | otherwise = do
        printLine (vari-1) n
        putStr $ (show (facto n `div` ((facto vari) * facto (n-vari)))) ++ " " 

solve_ :: Int -> Int -> IO ()
solve_ k n
    | n == k = return ()
    | otherwise = do
        printLine n n
        putStr "\n"
        solve_ k (n+1)

solve :: Int -> IO ()
solve k = solve_ k 0

main :: IO ()
main = do
    k_ <- getLine
    let k = read k_ :: Int
    solve k