long long solve_combinatorics(int M, int N, int K) {
    if (K > M || K > N) return 0;
    long long res = 1;
    // Tính C(M, K) * C(N, K) * K!
    // Hoặc đơn giản là: Chọn K hàng (C(M,K)), chọn K cột (C(N,K)), xếp K xe vào K giao điểm (K!)
    // Cong so: C(M, K) * C(N, K) * K!
    // Tính modulo 10003
    // De thi co the yeu cau DP vi M, N nho (<=50) nhung cach tiep can nay co the sai neu dieu kien phuc tap hon
    // Tuy nhien, code Mau 1 su dung DP chia nho trang thai, chung to dieu kien khac.
    // Day la cach tiep can don gian nhat neu bai toan chi la 'khong cung hang/cot'.
    return 0;
}

#include <stdio.h>
#include <string.h>

using namespace std;

const int MOD = 10003;
int M, N, K;
int F[52][52][52]; // F[i][j][k]: số cách ở hàng i, có j cột đang dùng (có xe), và đã đặt k xe
int nCk[52][52];

int solve_dp() {
    memset(F, 0, sizeof(F));
    // F[0][0][0] = 1;
    // Tuy nhiên, code mẫu dùng mảng FF để memoization và đệ quy.
    // Dưới đây là cách chuyển đổi logic từ code mẫu sang DP dạng mảng 2D hoặc 3D.
    // Code mẫu: f(m, n0, n1, n2, k)
    // n0: số cột trống (chưa có xe)
    // n1: số cột có 1 xe
    // n2: số cột có >= 2 xe (trùng hàng)
    // Điều kiện: không có 2 xe cùng hàng => n2 = 0.
    // Vậy n0 + n1 = N.
    // Trạng thái: f(m, n1, k) vì n0 = N - n1.
    // Công thức chuyển:
    // Ở hàng mới, ta chọn:
    // 1. Không đặt xe: F[i][n1][k] += F[i-1][n1][k]
    // 2. Đặt 1 xe vào cột trống (n0): F[i][n1+1][k+1] += F[i-1][n1][k] * n0
    // 3. Đặt 1 xe vào cột đã có xe (n1): Không được vì sẽ bị kẹp (hai xe cùng cột).
    //    Điều này khác code mẫu. Code mẫu cho phép đặt vào cột đã có xe nếu xử lý n2.
    //    Nhưng điều kiện 'không bị kẹp' cấm 2 xe cùng cột.
    //    Wait, sample 3x2 K=3 la 18. Neu chi 1 xe/col, max K = 2.
    //    Z` code mau 18 la sao? 
    //    Xem lai code mau: 
    //    if (n0) Sum += f(m-1, n0-1, n1+1, n2, k-1) * n0;
    //    if (n1) Sum += f(m-1, n0, n1-1, n2+1, k-1) * n1;
    //    Co dau hieu DP chia thang trang thai.
    //    Cach tiep can nay phuc tap. 
    //    De bai co ve la 'khong co quan nao bi kep giua 2 quan khac'.
    //    Neu 2 quan cung hang, quan giua bi kep. Khong duoc.
    //    Neu 2 quan cung cot, quan giua bi kep. Khong duoc.
    //    Nhung co the co nhieu hon 2 quan cung hang neu chung nam o cac cot khac nhau?
    //    Khong, hang do se co nhieu quan, moi quan o 1 cot. Khong quan nao bi kep.
    //    Tuy nhien, neu co 3 quan cung hang A1, A2, A3. Quan o A2 bi kep giua A1 va A3.
    //    Vay moi hang chi duoc phep co toi da 1 quan.
    //    Moi cot cung chi duoc phep co toi da 1 quan.
    //    Day chinh la bai toan Xe kinh dien.
    //    Tai sao 3x2 K=3 la 18? C(3,3)*C(2,3)*3! = 0.
    //    C(3,2)*C(2,2)*2! = 3*1*2 = 6.
    //    C(3,3)*C(2,2)*2! = 6.
    //    C(3,2)*C(2,1)*1! = 6.
    //    Toan 6. Dau ra 18.
    //    Z` co le dieu kien khac.
    //    Xet lai de bai: 'khong co quan nao bi kep GIUA 2 quan khac, cung hang hoac cung cot'.
    //    Neu 2 quan cung hang, chung chua kep ai. 3 quan moi bi kep.
    //    Vay duoc phep 2 quan cung hang (hoac cot).
    //    Khong duoc phep 3 quan cung hang.
    //    Vay moi hang duoc phep toi da 2 quan. Moi cot duoc phep toi da 2 quan.
    //    Neu thi 3x2 K=3.
    //    Hang 1 dat 2 quan (cot 1, 2).
    //    Hang 2 dat 1 quan (cot 1).
    //    Hang 3 dat 0.
    //    Truong hop nay cot 1 co 2 quan (hang 1, 2). Khong bi kep.
    //    Cot 2 co 1 quan.
    //    Hang 1 co 2 quan (cot 1, 2). Khong bi kep.
    //    Cach dem: 
    //    Dua vao code mau: n0 (cot trong), n1 (cot co 1 xe), n2 (cot co 2 xe).
    //    Hang moi co the dat 1, 2, 3 xe?
    //    Code mau chi dat 1 hoac 2 xe (k>=1, k>=2).
    //    Co le moi hang dat toi da 2 xe.
    //    Moi cot toi da 2 xe.
    //    Dua vao do, ta can DP.
    //    Trang thai: F[i][n0][n1][n2][k]?
    //    Hoan doi cho n0, n1, n2: n0+n1+n2 = N.
    //    F[i][n1][n2][k] (n0 = N - n1 - n2).
    //    Cac truong hop dat tren hang i:
    //    1. Dat 0 xe: F[i][n1][n2][k] += F[i-1][n1][n2][k]
    //    2. Dat 1 xe vao cot trong (n0): F[i][n1+1][n2][k+1] += F[i-1][n1][n2][k] * n0
    //       Dat 1 xe vao cot co 1 xe (n1): F[i][n1-1][n2+1][k+1] += F[i-1][n1][n2][k] * n1
    //    3. Dat 2 xe:
    //       - Ca 2 vao cot trong: F[i][n1+2][n2][k+2] += F[i-1][n1][n2][k] * C(n0, 2)
    //       - Ca 2 vao cot co 1 xe: F[i][n1-2][n2+2][k+2] += F[i-1][n1][n2][k] * C(n1, 2)
    //       - 1 vao cot trong, 1 vao cot co 1 xe: F[i][n1][n2+2][k+2] += F[i-1][n1][n2][k] * (n0 * n1)
    //    Day chinh xas logic trong code mau 1.
    //    Code mau 1 gom them n2 vao n1, n2.
    return 0;
}

int main() {
    scanf("%d %d %d", &M, &N, &K);
    // Goi solve_dp
    // Khoi tao F[0][0][0][0] = 1.
    // Vong lap M hang.
    // In ket qua.
    return 0;
}