//package abc167.C

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

var reader: BufferedReader = System.`in`.bufferedReader()
var writer: PrintWriter = PrintWriter(System.`out`)

fun next() = reader.readLine()!!
fun nextInt() = next().toInt()
fun nextLong() = next().toLong()
fun nextDouble() = next().toDouble()
fun nextStrings() = next().split(" ")
fun nextInts() = nextStrings().map { it.toInt() }
fun nextLongs() = nextStrings().map { it.toLong() }
fun nextDoubles() = nextStrings().map { it.toDouble() }

fun put(v: Any?) = writer.print(v)
fun puts() = writer.println()
fun puts(v: Any?) = writer.println(v)

var debug = false
fun dp(v: Any?) {
    if (debug) println(v)
}
fun dp() {
    if (debug) println()
}

fun test(case: Int, input: String, expected: String) {
    reader = input.trimIndent().reader().buffered()

    val stringWriter = StringWriter()
    writer = PrintWriter(stringWriter)

    solve()
    writer.flush()

    val actual = stringWriter.toString()

    println("[test $case]")
    if ("${expected}" == actual) {
        println("OK")
    } else {
        println("NG")
        println()
        println("expected: \"${expected}\"")
        println("actual:   \"${actual}\"")
    }
    println()
}

fun main(args: Array<String>) {
    if ((args.size == 1) && (args[0] == "test")) {
        testAll()
    } else {
        solve()
        writer.flush()
    }
}

///////////////////////////////////////////////////////////

fun testAll() {
    debug = true

    test(1,
    """
    3 3 10
    60 2 2 4
    70 8 7 9
    50 2 3 9
    """,
    "120")
    test(2,
    """
    3 3 10
    100 3 1 4
    100 1 5 9
    100 2 6 5
    """,
    "-1")
    test(3,
    """
    8 5 22
    100 3 7 5 3 1
    164 4 5 2 7 8
    334 7 2 7 2 9
    234 4 7 2 8 2
    541 5 4 3 3 6
    235 4 8 6 9 7
    394 3 6 1 6 2
    872 8 4 3 7 2
    """,
    "1067")
}

typealias Book = Pair<Int, List<Int>>

fun buy(X: Int, books: List<Book>, skills: Array<Int>, cost: Int, idx: Int): Int {
    if (idx >= books.size) return Int.MAX_VALUE

    val withoutBookCost = buy(X, books, skills, cost, idx+1)

    val book = books[idx]

    var withBookCost = cost + book.first

    val withBookSkills = skills.copyOf()
    book.second.forEachIndexed { i, skill ->
        withBookSkills[i] += skill
    }

    if (withBookSkills.any { it < X }) {
        withBookCost = buy(X, books, withBookSkills, withBookCost, idx+1)
    }

    return min(withoutBookCost, withBookCost)
}

fun solve() {
    val (N, M, X) = nextInts()

    val books = mutableListOf<Book>()
    repeat(N) {
        val lines = nextInts().toMutableList()
        val C = lines.first()
        books.add(Book(C, lines.subList(1, M+1)))
    }
    books.sortBy { it.first }

    val skills = Array<Int>(M) { 0 }
    val cost = buy(X, books, skills, 0, 0)

    if (cost != Int.MAX_VALUE) {
        put(cost)
    } else {
        put(-1)
    }
}
