import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Scanner;
import java.util.Vector;
 
class Main {
 
    /**
     * Returns list of all indices where pattern is found in text.
     */
    public static int[] calculateZ(char input[]) {
        int Z[] = new int[input.length];
        int left = 0;
        int right = 0;
        for (int k = 1; k < input.length; k++) {
            if (k > right) {
                left = right = k;
                while (right < input.length && input[right] == input[right - left]) {
                    right++;
                }
                Z[k] = right - left;
                right--;
            } else {
                // we are operating inside box
                int k1 = k - left;
                // if value does not stretches till right bound then just copy it.
                if (Z[k1] < right - k + 1) {
                    Z[k] = Z[k1];
                } else { // otherwise try to see if there are more matches.
                    left = k;
                    while (right < input.length && input[right] == input[right - left]) {
                        right++;
                    }
                    Z[k] = right - left;
                    right--;
                }
            }
        }
        return Z;
    }
 
    /**
     * Returns list of all indices where pattern is found in text.
     */
 
    public static PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));
 
    public static int[] radixSort(int[] f) {
        return radixSort(f, f.length);
    }
 
    public static int[] radixSort(int[] f, int n) {
        int[] to = new int[n];
        {
            int[] b = new int[65537];
            for (int i = 0; i < n; i++)
                b[1 + (f[i] & 0xffff)]++;
            for (int i = 1; i <= 65536; i++)
                b[i] += b[i - 1];
            for (int i = 0; i < n; i++)
                to[b[f[i] & 0xffff]++] = f[i];
            int[] d = f;
            f = to;
            to = d;
        }
        {
            int[] b = new int[65537];
            for (int i = 0; i < n; i++)
                b[1 + (f[i] >>> 16)]++;
            for (int i = 1; i <= 65536; i++)
                b[i] += b[i - 1];
            for (int i = 0; i < n; i++)
                to[b[f[i] >>> 16]++] = f[i];
            int[] d = f;
            f = to;
            to = d;
        }
        return f;
    }
 
    public static void main(String[] args) throws java.lang.Exception {
        // your code goes here
        Scanner ob = new Scanner(System.in);
        int T = ob.nextInt();
        int b = ob.nextInt();
        out.println(T * b);
        out.close();
    }
} import java.io.BufferedOutputStream; BufferedOutputStream java.io import java.io.BufferedReader; BufferedReader java.io import java.io.IOException; IOException java.io import java.io.InputStreamReader; InputStreamReader java.io import java.io.PrintWriter; PrintWriter java.io import java.math.BigInteger; BigInteger java.math import java.util.ArrayList; ArrayList java.util import java.util.Arrays; Arrays java.util import java.util.Collections; Collections java.util import java.util.HashMap; HashMap java.util import java.util.HashSet; HashSet java.util import java.util.Scanner; Scanner java.util import java.util.Vector; Vector java.util class Main {
 
    /**
     * Returns list of all indices where pattern is found in text.
     */
    public static int[] calculateZ(char input[]) {
        int Z[] = new int[input.length];
        int left = 0;
        int right = 0;
        for (int k = 1; k < input.length; k++) {
            if (k > right) {
                left = right = k;
                while (right < input.length && input[right] == input[right - left]) {
                    right++;
                }
                Z[k] = right - left;
                right--;
            } else {
                // we are operating inside box
                int k1 = k - left;
                // if value does not stretches till right bound then just copy it.
                if (Z[k1] < right - k + 1) {
                    Z[k] = Z[k1];
                } else { // otherwise try to see if there are more matches.
                    left = k;
                    while (right < input.length && input[right] == input[right - left]) {
                        right++;
                    }
                    Z[k] = right - left;
                    right--;
                }
            }
        }
        return Z;
    }
 
    /**
     * Returns list of all indices where pattern is found in text.
     */
 
    public static PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));
 
    public static int[] radixSort(int[] f) {
        return radixSort(f, f.length);
    }
 
    public static int[] radixSort(int[] f, int n) {
        int[] to = new int[n];
        {
            int[] b = new int[65537];
            for (int i = 0; i < n; i++)
                b[1 + (f[i] & 0xffff)]++;
            for (int i = 1; i <= 65536; i++)
                b[i] += b[i - 1];
            for (int i = 0; i < n; i++)
                to[b[f[i] & 0xffff]++] = f[i];
            int[] d = f;
            f = to;
            to = d;
        }
        {
            int[] b = new int[65537];
            for (int i = 0; i < n; i++)
                b[1 + (f[i] >>> 16)]++;
            for (int i = 1; i <= 65536; i++)
                b[i] += b[i - 1];
            for (int i = 0; i < n; i++)
                to[b[f[i] >>> 16]++] = f[i];
            int[] d = f;
            f = to;
            to = d;
        }
        return f;
    }
 
    public static void main(String[] args) throws java.lang.Exception {
        // your code goes here
        Scanner ob = new Scanner(System.in);
        int T = ob.nextInt();
        int b = ob.nextInt();
        out.println(T * b);
        out.close();
    }
} Main /**
     * Returns list of all indices where pattern is found in text.
     */
 
    public static PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out)); out new PrintWriter(new BufferedOutputStream(System.out)) /**
     * Returns list of all indices where pattern is found in text.
     */
    public static int[] calculateZ(char input[]) {
        int Z[] = new int[input.length];
        int left = 0;
        int right = 0;
        for (int k = 1; k < input.length; k++) {
            if (k > right) {
                left = right = k;
                while (right < input.length && input[right] == input[right - left]) {
                    right++;
                }
                Z[k] = right - left;
                right--;
            } else {
                // we are operating inside box
                int k1 = k - left;
                // if value does not stretches till right bound then just copy it.
                if (Z[k1] < right - k + 1) {
                    Z[k] = Z[k1];
                } else { // otherwise try to see if there are more matches.
                    left = k;
                    while (right < input.length && input[right] == input[right - left]) {
                        right++;
                    }
                    Z[k] = right - left;
                    right--;
                }
            }
        }
        return Z;
    } calculateZ {
        int Z[] = new int[input.length];
        int left = 0;
        int right = 0;
        for (int k = 1; k < input.length; k++) {
            if (k > right) {
                left = right = k;
                while (right < input.length && input[right] == input[right - left]) {
                    right++;
                }
                Z[k] = right - left;
                right--;
            } else {
                // we are operating inside box
                int k1 = k - left;
                // if value does not stretches till right bound then just copy it.
                if (Z[k1] < right - k + 1) {
                    Z[k] = Z[k1];
                } else { // otherwise try to see if there are more matches.
                    left = k;
                    while (right < input.length && input[right] == input[right - left]) {
                        right++;
                    }
                    Z[k] = right - left;
                    right--;
                }
            }
        }
        return Z;
    } int Z[] = new int[input.length]; Z new int[input.length] input.length input input.length int left = 0; left 0 int right = 0; right 0 for (int k = 1; k < input.length; k++) {
            if (k > right) {
                left = right = k;
                while (right < input.length && input[right] == input[right - left]) {
                    right++;
                }
                Z[k] = right - left;
                right--;
            } else {
                // we are operating inside box
                int k1 = k - left;
                // if value does not stretches till right bound then just copy it.
                if (Z[k1] < right - k + 1) {
                    Z[k] = Z[k1];
                } else { // otherwise try to see if there are more matches.
                    left = k;
                    while (right < input.length && input[right] == input[right - left]) {
                        right++;
                    }
                    Z[k] = right - left;
                    right--;
                }
            }
        } int k = 1; int k = 1; k 1 k < input.length k input.length input input.length k++ k++ k {
            if (k > right) {
                left = right = k;
                while (right < input.length && input[right] == input[right - left]) {
                    right++;
                }
                Z[k] = right - left;
                right--;
            } else {
                // we are operating inside box
                int k1 = k - left;
                // if value does not stretches till right bound then just copy it.
                if (Z[k1] < right - k + 1) {
                    Z[k] = Z[k1];
                } else { // otherwise try to see if there are more matches.
                    left = k;
                    while (right < input.length && input[right] == input[right - left]) {
                        right++;
                    }
                    Z[k] = right - left;
                    right--;
                }
            }
        } {
            if (k > right) {
                left = right = k;
                while (right < input.length && input[right] == input[right - left]) {
                    right++;
                }
                Z[k] = right - left;
                right--;
            } else {
                // we are operating inside box
                int k1 = k - left;
                // if value does not stretches till right bound then just copy it.
                if (Z[k1] < right - k + 1) {
                    Z[k] = Z[k1];
                } else { // otherwise try to see if there are more matches.
                    left = k;
                    while (right < input.length && input[right] == input[right - left]) {
                        right++;
                    }
                    Z[k] = right - left;
                    right--;
                }
            }
        } if (k > right) {
                left = right = k;
                while (right < input.length && input[right] == input[right - left]) {
                    right++;
                }
                Z[k] = right - left;
                right--;
            } else {
                // we are operating inside box
                int k1 = k - left;
                // if value does not stretches till right bound then just copy it.
                if (Z[k1] < right - k + 1) {
                    Z[k] = Z[k1];
                } else { // otherwise try to see if there are more matches.
                    left = k;
                    while (right < input.length && input[right] == input[right - left]) {
                        right++;
                    }
                    Z[k] = right - left;
                    right--;
                }
            } k > right k right {
                left = right = k;
                while (right < input.length && input[right] == input[right - left]) {
                    right++;
                }
                Z[k] = right - left;
                right--;
            } left = right = k left right = k right k while (right < input.length && input[right] == input[right - left]) {
                    right++;
                } right < input.length && input[right] == input[right - left] right < input.length right input.length input input.length input[right] == input[right - left] input[right] input right input[right - left] input right - left right left {
                    right++;
                } right++ right Z[k] = right - left Z[k] Z k right - left right left right-- right {
                // we are operating inside box
                int k1 = k - left;
                // if value does not stretches till right bound then just copy it.
                if (Z[k1] < right - k + 1) {
                    Z[k] = Z[k1];
                } else { // otherwise try to see if there are more matches.
                    left = k;
                    while (right < input.length && input[right] == input[right - left]) {
                        right++;
                    }
                    Z[k] = right - left;
                    right--;
                }
            } int k1 = k - left; k1 k - left k left if (Z[k1] < right - k + 1) {
                    Z[k] = Z[k1];
                } else { // otherwise try to see if there are more matches.
                    left = k;
                    while (right < input.length && input[right] == input[right - left]) {
                        right++;
                    }
                    Z[k] = right - left;
                    right--;
                } Z[k1] < right - k + 1 Z[k1] Z k1 right - k + 1 right - k right k 1 {
                    Z[k] = Z[k1];
                } Z[k] = Z[k1] Z[k] Z k Z[k1] Z k1 { // otherwise try to see if there are more matches.
                    left = k;
                    while (right < input.length && input[right] == input[right - left]) {
                        right++;
                    }
                    Z[k] = right - left;
                    right--;
                } left = k left k while (right < input.length && input[right] == input[right - left]) {
                        right++;
                    } right < input.length && input[right] == input[right - left] right < input.length right input.length input input.length input[right] == input[right - left] input[right] input right input[right - left] input right - left right left {
                        right++;
                    } right++ right Z[k] = right - left Z[k] Z k right - left right left right-- right return Z; Z char input[] input public static int[] radixSort(int[] f) {
        return radixSort(f, f.length);
    } radixSort {
        return radixSort(f, f.length);
    } return radixSort(f, f.length); radixSort(f, f.length) radixSort f f.length f f.length int[] f f public static int[] radixSort(int[] f, int n) {
        int[] to = new int[n];
        {
            int[] b = new int[65537];
            for (int i = 0; i < n; i++)
                b[1 + (f[i] & 0xffff)]++;
            for (int i = 1; i <= 65536; i++)
                b[i] += b[i - 1];
            for (int i = 0; i < n; i++)
                to[b[f[i] & 0xffff]++] = f[i];
            int[] d = f;
            f = to;
            to = d;
        }
        {
            int[] b = new int[65537];
            for (int i = 0; i < n; i++)
                b[1 + (f[i] >>> 16)]++;
            for (int i = 1; i <= 65536; i++)
                b[i] += b[i - 1];
            for (int i = 0; i < n; i++)
                to[b[f[i] >>> 16]++] = f[i];
            int[] d = f;
            f = to;
            to = d;
        }
        return f;
    } radixSort {
        int[] to = new int[n];
        {
            int[] b = new int[65537];
            for (int i = 0; i < n; i++)
                b[1 + (f[i] & 0xffff)]++;
            for (int i = 1; i <= 65536; i++)
                b[i] += b[i - 1];
            for (int i = 0; i < n; i++)
                to[b[f[i] & 0xffff]++] = f[i];
            int[] d = f;
            f = to;
            to = d;
        }
        {
            int[] b = new int[65537];
            for (int i = 0; i < n; i++)
                b[1 + (f[i] >>> 16)]++;
            for (int i = 1; i <= 65536; i++)
                b[i] += b[i - 1];
            for (int i = 0; i < n; i++)
                to[b[f[i] >>> 16]++] = f[i];
            int[] d = f;
            f = to;
            to = d;
        }
        return f;
    } int[] to = new int[n]; to new int[n] n {
            int[] b = new int[65537];
            for (int i = 0; i < n; i++)
                b[1 + (f[i] & 0xffff)]++;
            for (int i = 1; i <= 65536; i++)
                b[i] += b[i - 1];
            for (int i = 0; i < n; i++)
                to[b[f[i] & 0xffff]++] = f[i];
            int[] d = f;
            f = to;
            to = d;
        } int[] b = new int[65537]; b new int[65537] 65537 for (int i = 0; i < n; i++)
                b[1 + (f[i] & 0xffff)]++; int i = 0; int i = 0; i 0 i < n i n i++ i++ i b[1 + (f[i] & 0xffff)]++; b[1 + (f[i] & 0xffff)]++ b[1 + (f[i] & 0xffff)] b 1 + (f[i] & 0xffff) 1 (f[i] & 0xffff) f[i] f i 0xffff for (int i = 1; i <= 65536; i++)
                b[i] += b[i - 1]; int i = 1; int i = 1; i 1 i <= 65536 i 65536 i++ i++ i b[i] += b[i - 1]; b[i] += b[i - 1] b[i] b i b[i - 1] b i - 1 i 1 for (int i = 0; i < n; i++)
                to[b[f[i] & 0xffff]++] = f[i]; int i = 0; int i = 0; i 0 i < n i n i++ i++ i to[b[f[i] & 0xffff]++] = f[i]; to[b[f[i] & 0xffff]++] = f[i] to[b[f[i] & 0xffff]++] to b[f[i] & 0xffff]++ b[f[i] & 0xffff] b f[i] & 0xffff f[i] f i 0xffff f[i] f i int[] d = f; d f f = to f to to = d to d {
            int[] b = new int[65537];
            for (int i = 0; i < n; i++)
                b[1 + (f[i] >>> 16)]++;
            for (int i = 1; i <= 65536; i++)
                b[i] += b[i - 1];
            for (int i = 0; i < n; i++)
                to[b[f[i] >>> 16]++] = f[i];
            int[] d = f;
            f = to;
            to = d;
        } int[] b = new int[65537]; b new int[65537] 65537 for (int i = 0; i < n; i++)
                b[1 + (f[i] >>> 16)]++; int i = 0; int i = 0; i 0 i < n i n i++ i++ i b[1 + (f[i] >>> 16)]++; b[1 + (f[i] >>> 16)]++ b[1 + (f[i] >>> 16)] b 1 + (f[i] >>> 16) 1 (f[i] >>> 16) f[i] f i 16 for (int i = 1; i <= 65536; i++)
                b[i] += b[i - 1]; int i = 1; int i = 1; i 1 i <= 65536 i 65536 i++ i++ i b[i] += b[i - 1]; b[i] += b[i - 1] b[i] b i b[i - 1] b i - 1 i 1 for (int i = 0; i < n; i++)
                to[b[f[i] >>> 16]++] = f[i]; int i = 0; int i = 0; i 0 i < n i n i++ i++ i to[b[f[i] >>> 16]++] = f[i]; to[b[f[i] >>> 16]++] = f[i] to[b[f[i] >>> 16]++] to b[f[i] >>> 16]++ b[f[i] >>> 16] b f[i] >>> 16 f[i] f i 16 f[i] f i int[] d = f; d f f = to f to to = d to d return f; f int[] f f int n n public static void main(String[] args) throws java.lang.Exception {
        // your code goes here
        Scanner ob = new Scanner(System.in);
        int T = ob.nextInt();
        int b = ob.nextInt();
        out.println(T * b);
        out.close();
    } main {
        // your code goes here
        Scanner ob = new Scanner(System.in);
        int T = ob.nextInt();
        int b = ob.nextInt();
        out.println(T * b);
        out.close();
    } Scanner ob = new Scanner(System.in); ob new Scanner(System.in) int T = ob.nextInt(); T ob.nextInt() ob.nextInt ob int b = ob.nextInt(); b ob.nextInt() ob.nextInt ob out.println(T * b) out.println out T * b T b out.close() out.close out String[] args args
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Scanner;
import java.util.Vector;
 
class Main {
 
    /**
     * Returns list of all indices where pattern is found in text.
     */
    public static int[] calculateZ(char input[]) {
        int Z[] = new int[input.length];
        int left = 0;
        int right = 0;
        for (int k = 1; k < input.length; k++) {
            if (k > right) {
                left = right = k;
                while (right < input.length && input[right] == input[right - left]) {
                    right++;
                }
                Z[k] = right - left;
                right--;
            } else {
                // we are operating inside box
                int k1 = k - left;
                // if value does not stretches till right bound then just copy it.
                if (Z[k1] < right - k + 1) {
                    Z[k] = Z[k1];
                } else { // otherwise try to see if there are more matches.
                    left = k;
                    while (right < input.length && input[right] == input[right - left]) {
                        right++;
                    }
                    Z[k] = right - left;
                    right--;
                }
            }
        }
        return Z;
    }
 
    /**
     * Returns list of all indices where pattern is found in text.
     */
 
    public static PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));
 
    public static int[] radixSort(int[] f) {
        return radixSort(f, f.length);
    }
 
    public static int[] radixSort(int[] f, int n) {
        int[] to = new int[n];
        {
            int[] b = new int[65537];
            for (int i = 0; i < n; i++)
                b[1 + (f[i] & 0xffff)]++;
            for (int i = 1; i <= 65536; i++)
                b[i] += b[i - 1];
            for (int i = 0; i < n; i++)
                to[b[f[i] & 0xffff]++] = f[i];
            int[] d = f;
            f = to;
            to = d;
        }
        {
            int[] b = new int[65537];
            for (int i = 0; i < n; i++)
                b[1 + (f[i] >>> 16)]++;
            for (int i = 1; i <= 65536; i++)
                b[i] += b[i - 1];
            for (int i = 0; i < n; i++)
                to[b[f[i] >>> 16]++] = f[i];
            int[] d = f;
            f = to;
            to = d;
        }
        return f;
    }
 
    public static void main(String[] args) throws java.lang.Exception {
        // your code goes here
        Scanner ob = new Scanner(System.in);
        int T = ob.nextInt();
        int b = ob.nextInt();
        out.println(T * b);
        out.close();
    }
}