jiahuimbzuai/CoQuIR huggingface dataset:
//  [javascript]
function Main(input){
	input=input.split(/\n/);
	input.forEach(function(e,i,a){a[i]=Number(a[i]);});
	console.log((input[0]<input[1]?input[0]:input[1])+(input[2]<input[3]?input[2]:input[3]));
}
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
function Main(input) {
	// 1行目がinput[0], 2行目がinput[1], …に入る
	input = input.split("\n");
	//文字列から10進数に変換するときはparseIntを使います
	var a = parseInt(input[0], 10);
	var b = parseInt(input[1], 10);
	var c = parseInt(input[2], 10);
	var d = parseInt(input[3], 10);
	//出力
   if (a>=b) {
     var e = b
   } else {
     var e = a
   }
     if (c>=d) {
     var f = d
   } else {
     var f = c
   }
	console.log(e + f);
}
//*この行以降は編集しないでください（標準入出力から一度に読み込み、Mainを呼び出します）
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
function Main(input){
  var inp = input.split('\n');
  var A = parseInt(inp[0].trim());
  var B = parseInt(inp[1].trim());
  var C = parseInt(inp[2].trim());
  var D = parseInt(inp[3].trim());

  var max1 = Math.min(A, B);
  var max2 = Math.min(C, D);
  console.log(max1+max2); 
  
}
Main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [go]
package main

import (
	"fmt"
	"math"
)

func main() {
	var a, b, c, d float64
	fmt.Scan(&a, &b, &c, &d)

	fmt.Println(math.Min(a, b) + math.Min(c, d))
}
//  [go]
package main

import "fmt"

func main() {
	var a, b, c, d int
	fmt.Scan(&a, &b, &c, &d)

	sum := 0
	if a > b {
		sum += b
	} else {
		sum += a
	}
	if c > d {
		sum += d
	} else {
		sum += c
	}

	fmt.Println(sum)
}
//  [go]
package main

import (
	. "fmt"
)

// func init() { Println("----------------------------------------") }

func main() {
    var a, b, c, d int
    Scanf("%d", &a)
    Scanf("%d", &b)
    Scanf("%d", &c)
    Scanf("%d", &d)

    var ans int
    if a > b {
        ans += b
    } else {
        ans += a
    }
    if c > d {
        ans += d
    } else {
        ans += c
    }
    Println(ans)
}
//  [go]
package main

import (
	"fmt"
	"math"
)

func main() {
	// Code for A - Traveling Budget
	var A, B, C, D int
	fmt.Scanf("%d\n%d\n%d\n%d", &A, &B, &C, &D)

	fmt.Println(math.Min(float64(A), float64(B)) + math.Min(float64(C), float64(D)))
}
//  [go]
package main

import (
	"fmt"
	"math"
)

func main() {
	var a, b, c, d float64
	fmt.Scan(&a, &b, &c, &d)

	fmt.Println(math.Min(a, b) + math.Min(c, d))

}
//  [go]
package main

import "fmt"

func main() {
	var a, b, c, d int
	fmt.Scan(&a, &b, &c, &d)

	ans := 0
	if a <= b {
		ans += a
	} else {
		ans += b
	}

	if c <= d {
		ans += c
	} else {
		ans += d
	}
	fmt.Println(ans)
}
//  [ruby]
A = gets.to_i
B = gets.to_i
C = gets.to_i
D = gets.to_i
puts [A,B].min + [C,D].min
//  [ruby]
a,b,c,d=4.times.map{gets.to_i};p [a,b].min + [c,d].min
//  [ruby]
# abc092 A
a = gets.to_i
b = gets.to_i
c = gets.to_i
d = gets.to_i

p [a,b].min + [c,d].min
//  [ruby]
require 'prime'
require 'set'
require 'tsort'
include Math
ALP = ('a'..'z').to_a
INF = 0xffffffffffffffff
def max(a,b);              a > b ? a : b                              end
def min(a,b);              a < b ?  a : b                             end
def swap(a,b);             a, b = b, a                                end
def gif;                   gets.to_i                                  end
def gff;                   gets.to_f                                  end
def gsf;                   gets.chomp                                 end
def gi;                    gets.split.map(&:to_i)                     end
def gf;                    gets.split.map(&:to_f)                     end
def gs;                    gets.chomp.split.map(&:to_s)               end
def gc;                    gets.chomp.split('')                       end
def pr(num);               num.prime_division                         end
def pr?(num);              Prime.prime?(num)                          end
def digit(num);            num.to_s.length                            end
def array(s,ini=nil);      Array.new(s){ini}                          end
def darray(s1,s2,ini=nil); Array.new(s1){Array.new(s2){ini}}          end
def rep(num);              num.times{|i|yield(i)}                     end
def repl(st,en,n=1);       st.step(en,n){|i|yield(i)}                 end
a = []
rep 4 do
    a << gif
end

puts min(a[0],a[1])+min(a[2],a[3])
//  [ruby]
eval"p [%d,%d].min+[%d,%d].min"%`dd`.split
//  [ruby]
a,b,c,d=`dd`.split.map(&:to_i)
p [a,b].min+[c,d].min
//  [rust]
use std::io;
use std::cmp::min;

fn procon_read<T: std::str::FromStr>() ->  Vec<T> {
	let mut buf = String::new();
	io::stdin().read_line(&mut buf).expect("");
	let iter = buf.split_whitespace();
	let mut v: Vec<T> = Vec::new();
	for i in iter {
		v.push(i.parse().ok().unwrap());
	}
	v
}

fn main() {
	let v:Vec<i32> = procon_read();
	let a = v[0];
	let v:Vec<i32> = procon_read();
	let b = v[0];
	let v:Vec<i32> = procon_read();
	let c = v[0];
	let v:Vec<i32> = procon_read();
	let d = v[0];
	let train = min(a, b);
	let bus = min(c, d);
	println!("{}", train+bus);
}
//  [rust]
use std::io::*;
use std::str::FromStr;
use std::cmp::min;

fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let stdin = stdin.lock();
    let token: String = stdin
        .bytes()
        .map(|c| c.expect("filed to read char") as char)
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();
    token.parse().ok().expect("failed to parse token")
}

fn main() {
    let a: u32 = read();
    let b: u32 = read();
    let c: u32 = read();
    let d: u32 = read();
    println!("{}", min(a, b)+min(c, d));
}
//  [rust]
use std::io::*;
use std::str::FromStr;
use std::cmp::min;
/* 
The read function reads a string according to each one. 
*/
fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let stdin = stdin.lock();
    let token: String = stdin
        .bytes()
        .map(|c| c.expect("failed to read char") as char) 
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();
    token.parse().ok().expect("failed to parse token")
}

//main function
fn main() {
    let a:i32 = read();
    let b:i32 = read();
    let c:i32 = read();
    let d:i32 = read();
    println!("{}",min(a,b)+min(c,d));
}
//  [rust]
use proconio::{input, fastout};
use proconio::marker::{Chars};
use proconio::marker::Usize1;
use std::cmp::*;

macro_rules! debug {
      ($($a:expr),*) => {
          eprintln!(concat!($(stringify!($a), " = {:?}, "),*), $($a),*);
    }
}

#[fastout]
fn main() {
    input!{
        a: usize,
        b: usize,
        c: usize,
        d: usize,
    }

    println!("{}", min(a,b)+min(c,d));

}
//  [rust]
use proconio::input;
#[allow(unused_imports)]
use proconio::marker::{Bytes, Chars};
#[allow(unused_imports)]
use std::cmp::{min, max};

fn main() {
	input! {
		a: usize,
		b: usize,
		c: usize,
		d: usize,
	}

	println!("{}", min(a,b)+min(c,d));
}
//  [swift]
var i=[Int]();for _ in 0..<4{i+=[Int(readLine()!)!]};print(min(i[0],i[1])+min(i[2],i[3]))
//  [swift]
print(min(Int(readLine()!)!,Int(readLine()!)!)+min(Int(readLine()!)!,Int(readLine()!)!))
//  [swift]
var inpt = [Int]()
for _ in 0..<4 {
    inpt.append(Int(readLine()!)!)
}

let train = min(inpt[0], inpt[1])
let bus = min(inpt[2], inpt[3])

print(train + bus)
//  [typescript]
import * as fs from 'fs';

namespace AtCoder.abc092 {

    export class Program {
        args: string;

        constructor(args: string) {
            this.args = args;
        }

        /**
         * in
         *
         * out
         *
         */
        main(this: Program): void {
            const [a, b, c, d]: number[] = this.args.split('\n').map(Number);

            console.log(Math.min(a, b) + Math.min(c, d));
        }
    }
}

const args = fs.readFileSync('/dev/stdin', 'utf8').trim();
const prg = new AtCoder.abc092.Program(args);
prg.main();
//  [typescript]
import * as fs from 'fs';

namespace AtCoder.abc092 {

    export class Program {

        constructor(private readonly args: string) {
        }

        /**
         * in
         *
         * out
         *
         */
        main(this: Program): void {
            const [a, b, c, d]: number[] = this.args.split('\n').map(Number);

            console.log(Math.min(a, b) + Math.min(c, d));
        }
    }
}

const args = fs.readFileSync('/dev/stdin', 'utf8').trim();
const prg = new AtCoder.abc092.Program(args);
prg.main();
//  [typescript]
const stdin = require('fs').readFileSync('/dev/stdin', 'utf8')

const [a, b, c, d] = stdin.split('\n').map(Number)

const t = a > b ? b : a

const bus = c > d ? d : c

console.log(t+bus)
//  [typescript]
var lines: string[] = [];
var reader: any = require("readline").createInterface({
  input: process.stdin,
  output: process.stdout
});
reader.on("line", function(line: string) {
  lines.push(line);
});

reader.on("close", function() {
  // A B
  var numbers: number[] = lines[0].split(" ").map(x => {
    return Number(x);
  });
  var numA: number = Number(lines[0]);
  var numB: number = Number(lines[1]);
  var numC: number = Number(lines[2]);
  var numD: number = Number(lines[3]);
  var result: number = 0;
  if (numA < numB) {
    result = numA;
  } else {
    result = numB;
  }
  if (numC < numD) {
    result = result + numC;
  } else {
    result = result + numD;
  }

  console.log(result);
});
//  [typescript]
import { readFileSync } from "fs";

const read = () =>
  readFileSync(0, "utf8")
    .split("\n")
    .map((line) => line.split(" "));

const main = (input: string[][]) => {
  const A = Number(input[0][0]);
  const B = Number(input[1][0]);
  const C = Number(input[2][0]);
  const D = Number(input[3][0]);

  return Math.min(A, B) + Math.min(C, D);
};

console.log(main(read()));
//  [typescript]
import * as fs from 'fs';

namespace AtCoder.abc092 {

    export class Program {

        constructor(private args: string) {
            this.args = args;
        }

        /**
         * in
         *
         * out
         *
         */
        main(this: Program): void {
            const [a, b, c, d]: number[] = this.args.split('\n').map(Number);

            console.log(Math.min(a, b) + Math.min(c, d));
        }
    }
}

const args = fs.readFileSync('/dev/stdin', 'utf8').trim();
const prg = new AtCoder.abc092.Program(args);
prg.main();
//  [python]
for _ in range(10**7*5):None
a,b=map(int,input().split())
print('EOvdedn'[a*b%2::2])
//  [python]
# coding: utf-8
# Your code here!
# coding: utf-8
from fractions import gcd 
from functools import reduce
import sys
sys.setrecursionlimit(200000000)
from inspect import currentframe


# my functions here!
#標準エラー出力
def printargs2err(*args):
    names = {id(v):k for k,v in currentframe().f_back.f_locals.items()}
    print(', '.join(names.get(id(arg),'???')+' : '+repr(arg) for arg in args),file=sys.stderr)
def debug(x):
    print(x,file=sys.stderr)
def printglobals():
    for (symbol, value) in globals().items():
        print('symbol="%s"、value=%s' % (symbol, value),file=sys.stderr)
def printlocals():
    for (symbol, value) in locals().items():
        print('symbol="%s"、value=%s' % (symbol, value),file=sys.stderr)
#入力（後でいじる）
def pin(type=int):
    return map(type,input().split())


"""
"""

#solution:
#繰り返し自乗法だよ
#これはnのp乗をmで割ったあまりをだすよ
def modular_w_binary_method (n,m,p):
    ans=1 if n>0 else 0
    while(p>0):
        if p%2==1:
            ans=(ans*n)%m
        n=(n**2)%m
        p//=2
    return ans

#mod上でのaの逆元を出すよ
"""
    フェルマーの小定理より a**(p)%p==a isTrue
    これを利用すれば a**(p-2)%p==a**(-1) isTrue
    元と逆元とをかけてpで割れば1が余るよ！
"""
def modular_inverse(a,prime):
    return(modular_w_binary_method(a,prime,prime-2))


#逆元を使うと容易に頑張れるｃ
def conbination(n,a,mod=10**9+7):
    #cはイラない
    res=1 
    for s in range(a):
        res=(res*(n-s)*(modular_inverse(s+1,mod)))%mod

        
    return res
#操作から作れるものの組み合わせは何個かー＞同じものでも違う方法で構成できるかから考える方法もある
        
#input
def resolve():
    a,b=pin()
    print(["Odd","Even"][(a*b+1)%2])
    return
    #print([["NA","YYMM"],["MMYY","AMBIGUOUS"]][cMMYY][cYYMM])
#if __name__=="__main__":resolve()
"""
#printデバッグ消した？
#前の問題の結果見てないのに次の問題に行くの？
"""
"""
お前カッコ閉じるの忘れてるだろ
"""
import sys
from io import StringIO
import unittest

class TestClass(unittest.TestCase):
    def assertIO(self, input, output):
        stdout, stdin = sys.stdout, sys.stdin
        sys.stdout, sys.stdin = StringIO(), StringIO(input)
        resolve()
        sys.stdout.seek(0)
        out = sys.stdout.read()[:-1]
        sys.stdout, sys.stdin = stdout, stdin
        self.assertEqual(out, output)
    def test_入力例_1(self):
        input = """3 4"""
        output = """Even"""
        self.assertIO(input, output)
    def test_入力例_2(self):
        input = """1 21"""
        output = """Odd"""
        self.assertIO(input, output)

if __name__ == "__main__":
    resolve()
//  [python]
import math
import numpy as np
from operator import mul

# 整数Nを桁ごとのリストにする
# l = [int(x) for x in list(str(N))]

# リストliから重複を削除したリストli_uniqを作成
#li_uniq = []
#for i in li:
#    if x not in li_uniq:
#        li_uniq.append(x)

# 複数行のinput - list版
#list = [list(map(int, input().split())) for i in range(N)]
# 複数行のinput - dictionary版
# key = a, value = b
#for i in range(N):
#    a, b = map(int, input().split())
#    dict[a] = b


a, b = map(int, input().split())

if a%2 == 0 or b%2 == 0:
    print('Even')
else:
    print('Odd')
//  [java]
import java.util.Arrays;
import java.util.List;
import java.util.Scanner;
import java.util.stream.Collectors;

public class Main {

	public static void main(String[] args) {
		try(Scanner sc = new Scanner(System.in)){
			List<Integer> inputList = Arrays.asList(sc.nextLine().split(" ")).stream().map(Integer::parseInt).collect(Collectors.toList());
			if(inputList.get(0)%2 != 0 && inputList.get(1)%2 != 0 ) {
				System.out.println("Odd");
			}else {
				System.out.println("Even");
			}
		}

	}
}
//  [java]
import java.util.*;

class Main {
  public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    int a = sc.nextInt();
    int b = sc.nextInt();
    if (a * b % 2 == 0) {
      System.out.println("Even");
    } else {
      System.out.println("Odd");
    }
  }
}
//  [cpp]
#include <bits/stdc++.h>
using namespace std;
#define int long long
int inf = 10e17;
#define mod 1000000007

bool vis[200005];
vector<int> vec[2000005], v1;
int child[2000005];
int parent[2000005];
int div1[100005];
int min_indx[900005];
int count1 = 0;
int height = 0;
int max_indx[200005];
void dfs(int node)
{

    vis[node] = 1;
    // cout << node << "\n";
    min_indx[count1] = node;
    max_indx[node] = min(max_indx[node], count1);
    count1++;

    //  count1++;
    child[node] = height++;
    for (int i = 0; i < vec[node].size(); i++)
    {
        if (!vis[vec[node][i]])
        {
            dfs(vec[node][i]);
            min_indx[count1] = node;
            max_indx[node] = min(max_indx[node], count1);
            count1++;
        }
    }
    height--;
}

int MAXN = 200005;
int LOGMAXN = (int)log2(200005) + 1;
int M[200005][60];
void process2(int A[], int N)
{
    int i, j;

    //initialize M for the intervals with length 1
    for (i = 0; i < N; i++)
        M[i][0] = i;
    //compute values from smaller to bigger intervals
    for (j = 1; 1 << j <= N; j++)
        for (i = 0; i + (1 << j) - 1 < N; i++)
            if (A[M[i][j - 1]] < A[M[i + (1 << (j - 1))][j - 1]])
                M[i][j] = M[i][j - 1];
            else
                M[i][j] = M[i + (1 << (j - 1))][j - 1];
}
//int parent[200005];
vector<int> vec1;
//bool vis[200005];
//int hei[200005];
int lev[200005];
int dis[200005];
bool cmp(pair<int, int> &a,
         pair<int, int> &b)
{
    return a.second < b.second;
}
int32_t main()
{
    // ios_base::sync_with_stdio(false);
    // cin.tie(NULL);
    //  int t;
    int a, b;
    cin >> a >> b;
    if ((a * b) % 2)
        cout << "Odd"
             << "\n";
    else
    {
        cout << "Even"
             << "\n";
    }

    return 0;
}
//  [cpp]
#include <bits/stdc++.h>
using namespace std;
 
#define rep(i, n) for (int i = (int)(0); i < (int)(n); ++i)
#define reps(i, n) for (int i = (int)(1); i <= (int)(n); ++i)
#define rrep(i, n) for (int i = ((int)(n)-1); i >= 0; i--)
#define rreps(i, n) for (int i = ((int)(n)); i > 0; i--)
#define irep(i, m, n) for (int i = (int)(m); i < (int)(n); ++i)
#define ireps(i, m, n) for (int i = (int)(m); i <= (int)(n); ++i)
#define FOR(e, c) for (auto &e : c)
#define SORT(v, n) sort(v, v + n);
#define vsort(v) sort(v.begin(), v.end());
#define rvisort(v) sort(v.begin(), v.end(), greater<int>());
#define all(v) v.begin(), v.end()
#define mp(n, m) make_pair(n, m);
#define cout(d) cout<<d<<endl;
#define coutd(d) cout<<std::setprecision(10)<<d<<endl;
#define cinline(n) getline(cin,n);
 
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vll = vector<ll>;
using vvll = vector<vll>;
using pii = pair<int, int>;
using vpii = vector<pii>;
using vs = vector<string>;
using vd = vector<double>;
using ul = unsigned long;
 
template<class T, class C> void chmax(T& a, C b){ a>b?:a=b; }
template<class T, class C> void chmin(T& a, C b){ a<b?:a=b; }
 
const int mod=1e9+7;
 
struct mint {
  ll x;
  mint(ll x=0):x(x%mod){}
  mint& operator+=(const mint a) {
    if ((x += a.x) >= mod) x -= mod;
    return *this;
  }
  mint& operator-=(const mint a) {
    if ((x += mod-a.x) >= mod) x -= mod;
    return *this;
  }
  mint& operator*=(const mint a) {
    (x *= a.x) %= mod;
    return *this;
  }
  mint operator+(const mint a) const {
    mint res(*this);
    return res+=a;
  }
  mint operator-(const mint a) const {
    mint res(*this);
    return res-=a;
  }
  mint operator*(const mint a) const {
    mint res(*this);
    return res*=a;
  }
};
 
mint c[4005][4005];
void init() {
  c[0][0] = 1;
  for (int i = 0; i <= 4000; i++) {
    for (int j = 0; j <= i; j++) {
      c[i+1][j] += c[i][j];
      c[i+1][j+1] += c[i][j];
    }
  }
}
mint comb(int n, int k) {
  return c[n][k];
}
 
bool IsPrime(int num)
{
    if (num < 2) return false;
    else if (num == 2) return true;
    else if (num % 2 == 0) return false;
 
    double sqrtNum = sqrt(num);
    for (int i = 3; i <= sqrtNum; i += 2)
    {
        if (num % i == 0)
        {
            return false;
        }
    }
 
    return true;
}
 
map<ll, ll> primeFact(ll n) {
  map<ll, ll> res;
  for (ll i = 2; i * i <= n; i++) {
    while (n % i == 0) {
      res[i]++;
      n /= i;
    }
  }
  if (n != 1) res[n]++;
  return res;
}
 
void printv(vi& v){
  rep(i,v.size()) cout << v[i] << " ";
  cout << endl;
}
void printv(vll& v){
  rep(i,v.size()) cout << v[i] << " ";
  cout << endl;
}
int vtotal(vi& v){
  int total=0;
  rep(i,v.size()) total+=v[i];
  return total;
}
 
int main()
{
  //init(); // mint初期化
  cin.tie( 0 );
  ios::sync_with_stdio( false );
  int a,b;
  cin>>a>>b;
  string ans="Even";
  if((a*b)%2==1)ans="Odd";
  cout(ans);
  return 0;
}
//  [cpp]
#include <iostream>
#include <string>
#include <sstream>
#include <vector>
#include <set>
#include <unordered_map>
#include <algorithm>

using namespace std;

int main(){
    int a, b;
    cin >> a >> b;
    if (a % 2 != 0 && b % 2 != 0) cout << "Odd";
    else cout << "Even";
    return 0;
}
//  [c]
#include <stdio.h>

int main(void){
    long long int a = 0,b = 0;
    scanf("%d %d",&a,&b);
    long long int tmp = 0;
    for(long long int i = 1;i <= b;i += 1){
        tmp += a;
    }
    for(long long int i = 0;i < 5000 * 10001;i += 1){
        if(tmp == i * 2){
            printf("Even\n");
            return 0;
        }
    }
    printf("Odd\n");
    return 0;
}
//  [c]
#include<stdio.h>
int main()
{
    int a,b,x;
    scanf("%d%d",&a,&b);
    x=a*b;
    if(x%2==0)
        printf("Even\n");
    else if(x%2==1)
        printf("Odd\n");
    return 0;
}
//  [c]
#include <stdio.h>

int main()
 {
    int a,b,p;
    scanf("%d %d",&a,&b);
    p= a*b;
    if (p%2==0)
        printf("Even");
    else
        printf("Odd");

    return 0;
 }
//  [javascript]
function Main(input) {

  input = input.split(" ");
	// input = input.split("\n");
	// tmp = input[1].split(" ");

	// var a = parseInt(input[0], 10);
	// var b = parseInt(tmp[0], 10);
	// var c = parseInt(tmp[1], 10);
	// var s = input[2];

// Convert String to Integer
  var a = ~~input[0];
  var b = ~~input[1];

var AtCoder = function(){};

AtCoder.prototype.check = function(a, b){
  if(a*b%2 == 0){
    console.log("Even");
    return
  }else{
    console.log("Odd");
    return
  }
}
	// console.log('%d %d',N,Q);
  var AtCoder = new AtCoder();
  AtCoder.check(a,b);
}


Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
function main(input) {
    const args = input.split(' ');
    const a = parseInt(args[0], 10);
    const b = parseInt(args[1], 10);

    if ((a * b) % 2 === 0) {
        console.log('Even');
    } else {
        console.log('Odd');
    }
}

main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [javascript]
function Main(input){
  	var input = input.split(" ");
	var a = input[0];
	var b = input[1];

    if(a*b % 2 == 0){
      console.log("Even");
    }else {
      console.log("Odd");
    }
}
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [go]
package main
import (
    "fmt"
)

func main() {
    var x, y int
    fmt.Scan(&x, &y)
    if z := x * y; z % 2 == 0 {
        fmt.Println("Even")
    } else {
        fmt.Println("Odd")
    }
}
//  [go]
package main

import "fmt"

func main() {
	var a, b int
	fmt.Scan(&a, &b)

	if (a*b)%2 == 0 {
		fmt.Println("Even")
	} else {
		fmt.Println("Odd")
	}
}
//  [go]
package main

import "fmt"

func main() {
	var a,b int
	fmt.Scanf("%d %d", &a,&b)

	if a*b%2 == 0 {
		fmt.Println("Even")
	} else {
		fmt.Println("Odd")
	}
}
//  [ruby]
a,b = gets.split.map(&:to_i)
if a*b % 2 == 1
	puts "Odd"
else
	puts "Even"
end
//  [ruby]
a = gets.split.map(&:to_i)

puts a[0] * a[1] % 2 == 0 ? "Even" : "Odd"
//  [ruby]
a,b = gets.split.map(&:to_i)
puts (a * b).odd? ? 'Odd' : 'Even'
//  [rust]
fn solve(a: u16, b: u16) -> String {
    (if a * b % 2 == 0 { "Even" } else { "Odd" }).to_string()
}

fn main() {
    let (a, b) = read_tup2();

    println!("{}", solve(a, b));
}

fn read_tup2<T: std::str::FromStr + Copy>() -> (T, T) {
    let mut s = String::new();
    std::io::stdin().read_line(&mut s).ok();
    let v = s.trim().split_whitespace()
        .map(|c| c.parse().ok().unwrap())
        .collect::<Vec<T>>();
    (v[0], v[1])
}
//  [rust]
#![allow(unused_imports)]
#![allow(dead_code)]
use proconio::input;
use proconio::fastout;
use proconio::marker::*;

fn type_of<T>(_: T) -> String{
    let a = std::any::type_name::<T>();
    return a.to_string();
}

#[fastout]
fn main() {
    input! {
        a:i32,b:i32,
    }
    println!("{}",if a*b%2==0{"Even"}else{"Odd"});
}
//  [swift]
import Foundation
 
let input_line: String = readLine()!
let split: [String] = input_line.components(separatedBy: " ") //ブランクで区切られている場合
 
var a = Int(split[0])!
//String -> Intの型変換はnilが返る可能性があるので、ラップされたOptional<Int>型が返るので強制アンラップ
var b = Int(split[1])!


if ((a * b) % 2 >= 1){
    print("Odd")
}else{
    print("Even")
}
//  [swift]

import Foundation

let input_line: String = readLine()!
let split: [String] = input_line.components(separatedBy: " ") //ブランクで区切られている場合

let a = Int(split[0])!
//String -> Intの型変換はnilが返る可能性があるので、ラップされたOptional<Int>型が返るので強制アンラップ
let b = Int(split[1])!


if a*b % 2 == 0{
    print("Even")
}else{
    print("Odd")
}
//  [swift]
import Foundation

let input_line: String = readLine()!

let split: [String] = input_line.components(separatedBy: " ") //ブランクで区切られている場合

let a = Int(split[0])!
//String -> Intの型変換はnilが返る可能性があるので、ラップされたOptional<Int>型が返るので強制アンラップ
let b = Int(split[1])!

if a*b % 2 == 0{
    print("Even")
}else{
    print("Odd")
}
//  [typescript]
const lines = [];
const reader = require("readline").createInterface({
  input: process.stdin,
  output: process.stdout,
});

reader.on("line", function (line) {
  lines.push(line);
});
reader.on("close", function () {
  const input = (lines[0] as string).split(" ");
  const a = +input[0];
  const b = +input[1];

  const res = (a * b) % 2 === 0 ? "Even" : "Odd";

  console.log(res);
});
//  [typescript]
import * as fs from "fs";

// inputで受け取り配列化する
const [a, b] = fs.readFileSync("/dev/stdin", "utf8").split(" ").map(Number);

const multi = a * b;

if (multi % 2 === 0) {
  console.log("Even");
} else {
  console.log("Odd");
}
//  [typescript]
export default solve;

// =================================================
// ABC086A
// =================================================

// main
function main(lines) {
  console.log(solve(lines));
}

// solver
function solve(lines: string[]): string {
  const { a, b } = parseLines(lines);

  return (a * b) % 2 === 0 ? 'Even' : 'Odd';
}

// helpers
function parseLines(lines: string[]) {
  const [a, b] = lines[0].split(' ').map(s => +s);
  const obj = { a, b };
  debug(obj);
  return obj;
}

// general helpers
function debug(message?: any, ...optionalParams: any[]) {
  if (!!process.env.LOCAL_DEBUG) console.log(message, ...optionalParams);
}

// reader
if (!process.env.LOCAL_DEBUG) {
  const { stdin: input, stdout: output } = process;
  input.resume().setEncoding('utf8');
  const lines = [];
  require('readline')
    .createInterface({ input, output })
    .on('line', line => lines.push(line))
    .on('close', () => main(lines));
}
//  [python]
import sys
sys.setrecursionlimit(1 << 25)
read = sys.stdin.readline
ra = range
enu = enumerate


def mina(*argv, sub=1): return list(map(lambda x: x - sub, argv))
# 受け渡されたすべての要素からsubだけ引く.リストを*をつけて展開しておくこと


def read_a_int(): return int(read())


def read_ints(): return list(map(int, read().split()))


def read_col(H):
    '''H is number of rows
    A列、B列が与えられるようなとき
    ex1)A,B=read_col(H)    ex2) A,=read_col(H) #一列の場合'''
    ret = []
    for _ in range(H):
        ret.append(list(map(int, read().split())))
    return tuple(map(list, zip(*ret)))


def read_tuple(H):
    '''H is number of rows'''
    ret = []
    for _ in range(H):
        ret.append(tuple(map(int, read().split())))
    return ret


def read_matrix(H):
    '''H is number of rows'''
    ret = []
    for _ in range(H):
        ret.append(list(map(int, read().split())))
    return ret
    # return [list(map(int, read().split())) for _ in range(H)] # 内包表記はpypyでは遅いため


MOD = 10**9 + 7
INF = 2**31  # 2147483648 > 10**9
# default import
from collections import defaultdict, Counter, deque
from operator import itemgetter
from itertools import product, permutations, combinations
from bisect import bisect_left, bisect_right  # , insort_left, insort_right
from decimal import Decimal
A, B = input().split()
A = Decimal(int(A))
B = Decimal(B)
print(int(A * B))
//  [python]
import sys
input = lambda: sys.stdin.readline().rstrip()


from decimal import Decimal
a, b = input().split()
a = Decimal(a)
b = Decimal(b)
 
print(int(a*b))
//  [python]

a,b = raw_input().split(' ')

a = int(a)


b0,b1 = b.split('.') if '.' in b else [int(b), 0]
b0 = int(b0)
b1 = int(b1)

print a*b0 + a*b1/100
//  [java]
import java.util.*;

public class Main{
  public static void main(String[] args){
    Scanner scan = new Scanner(System.in);
    long a = scan.nextLong();
    double b = scan.nextDouble();
    if ((a == 0) || (b==0)){
      System.out.println("0");
      return;
    }
    String t = b+"";
    long t2 = 0;
    long t3 = 0;

    long t1 = Integer.parseInt(String.valueOf(t.charAt(0)));
    if (t.length()>=3){
      t2 = Integer.parseInt(String.valueOf(t.charAt(2)));
    }
    if (t.length()>=4){
      t3 = Integer.parseInt(String.valueOf(t.charAt(3)));
    }
    long c = (a*t1*100)+(a*t2*10)+(a*t3);
    String g = c+"";
    if (g.length()<=2){
      System.out.println("0");
      return;
    }

    for (int i=0;i<g.length()-2;i++){
      System.out.print(g.charAt(i));
    }
    System.out.println("");
  }
}
//  [java]
import java.util.Scanner;

class Main {
  public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    long a = sc.nextLong();
    int b = Integer.parseInt(clean(sc.nextLine()));
    sc.close();
    long r = (a * b) / 100;
    System.out.println(r);
  }
  
  private static String clean(String n) {
    int s = n.length();
    String ns = "";
    for(int i = 0; i < s; i++) {
      char c = n.charAt(i);
      if(c != ' ' && c != '.') ns += c;
    }
    return ns;
  }
}
//  [c]
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>

#define rep(i,k,n) for(int (i)=(k);(i)<(n);(i)++)
#define max(a,b) (a)>(b)?(a):(b)
#define min(a,b) (a)<(b)?(a):(b)
#define abs(a) (a)>0 ?(a):-(a)
#define llong long long

int main(){
	llong A; scanf("%lld",&A);
	char s[5]; scanf("%s",s);
	llong ans=0;
	ans += (s[0]-'0')*A*100;
	ans += (s[2]-'0')*A*10;
	ans += (s[3]-'0')*A;
	ans /= 100;
	printf("%lld",ans);
	return 0;
}
//  [c]
#include<stdio.h>
int main()
{
    long long int a,x;
	double  b;
    scanf ("%lld",&a);
    scanf("%lf",&b);
	x=b*100+0.001;
    printf("%lld",a*x/100);
    return 0;
}
//  [c]
#include <stdio.h>
#include <stdlib.h>

int main(void) {
	long long int a;
	float b;
	scanf("%lld %f",&a,&b);
	//printf("%lld\n",a);
	//printf("%lf\n",b);
	printf("%lld",(a*(int)(100*b+0.5))/100);
	return 0;
}
//  [javascript]
function main(input) {
  input = input.split('\n');
  let line = input[0].split(' ');
  let a = BigInt(line[0]);
  let b = BigInt(line[1].replace('.', ''));
  let r = (a * b) / 100n;
  console.log(r + '');
}

main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [javascript]
const main = arg => {
    let input = arg.trim();

    const a = BigInt(input.split(' ')[0]);
    const b = BigInt(input.split(' ')[1].replace('.', ''));
    let ret = a * b / 100n
    
    console.log(String(ret).replace('n', ''));
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [javascript]
function Main(input) {
	input = input.trim().split(" ");
	var A = input[0];
	var B = input[1];
	var a1 = parseInt(A.slice(0, -7),10);
	var a2 = parseInt(A.substr(-7, 7),10);
	var b1 = parseInt(B.trim().split(".")[0]);
	var b2 = parseInt(B.trim().split(".")[1]);
	if (isNaN(a1)) a1 = 0;
	if (isNaN(a2)) a2 = 0;
	if (isNaN(b1)) b1 = 0;
	if (isNaN(b2)) b2 = 0;
	var ANS, ans1, ans2, ansMiddle, tmp;
	
	ans1 = a1 * (b1 * 100 + b2);
	tmp = String(a2 * (b1 * 100 + b2)).slice(0,-2); 
	ansMiddle = parseInt(tmp.slice(0, -5),10);
  	if (isNaN(ansMiddle)) ansMiddle = 0;
	ans2 = parseInt(tmp.substr(-5, 5),10);
	if (isNaN(ans2)) ans2 = 0;
	ans1 = String(ans1 + ansMiddle);
	if (ans1 === '0'){
		ANS = String(ans2);
	} else {

		ANS = ans1 + String(ans2 + 100000).substr(-5,5);
	}	
 	console.log(ANS);	
}   

Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [go]
package main

import (
	"fmt"
	"math"
)

func abs(a int) int {
	if a < 0 {
		return -a
	} else {
		return a
	}
}

func min(nums ...int) int {
	if len(nums) == 0 {
		panic("funciton min() requires at least one argument.")
	}
	res := nums[0]
	for i := 0; i < len(nums); i++ {
		res = int(math.Min(float64(res), float64(nums[i])))
	}
	return res
}

func max(nums ...int) int {
	if len(nums) == 0 {
		panic("funciton max() requires at least one argument.")
	}
	res := nums[0]
	for i := 0; i < len(nums); i++ {
		res = int(math.Max(float64(res), float64(nums[i])))
	}
	return res
}

func main() {
	var a int
	var b float64
	fmt.Scan(&a,&b)
	b=b*100
	bi:=int(math.Round(b))
	fmt.Println(a*bi/100)


}
//  [go]
package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
)

func main() {
	A, B := ReadInt(), ReadString()
	b1, _ := strconv.Atoi(B[:len(B)-3])
	b2, _ := strconv.Atoi(B[len(B)-2:])
	fmt.Println(A*b1 + A*b2/100)
}

var reader = bufio.NewReader(os.Stdin)

func Scan(a ...interface{}) {
	if _, err := fmt.Fscan(reader, a...); err != nil {
		panic(err)
	}
}
func ReadInt() (i int)       { Scan(&i); return }
func ReadString() (s string) { Scan(&s); return }
func ReadInts(n int) []int {
	v := make([]int, n)
	for i := 0; i < n; i++ {
		Scan(&v[i])
	}
	return v
}
//  [ruby]
require 'bigdecimal'

A,B = gets.split
puts (BigDecimal(A)*BigDecimal(B)).to_i
//  [ruby]
require 'bigdecimal'

ab = gets.chomp.split(" ")

a = ab[0]
b = ab[1]

puts (BigDecimal(a)*BigDecimal(b)).floor
//  [ruby]
require 'bigdecimal'

a_as_str, b_as_str = gets.chomp.split(/ /)
a = a_as_str.to_i
b = BigDecimal(b_as_str)

puts a * (b * 100).to_i / 100
//  [swift]
import Foundation

let line = readLine()!.components(separatedBy: " ").map { Decimal(string: $0)! }
let A = line[0]
let B = line[1]
let C = NSDecimalNumber(decimal: A * B)
print(C.stringValue.components(separatedBy: ".").first!)
//  [swift]
import Foundation


func solution() -> String {
   let AB = readLine()!.components(separatedBy: " ")
   let A = NSDecimalNumber(string: AB[0])
   let B = NSDecimalNumber(string: AB[1])
   
   let A_B = A.multiplying(by: B)
   
   let behaviors:NSDecimalNumberHandler = NSDecimalNumberHandler(
      roundingMode: .down,
      scale: 0,
      raiseOnExactness: false,
      raiseOnOverflow: false,
      raiseOnUnderflow: false,
      raiseOnDivideByZero: false
   )
   
   
   let result = A_B.rounding(accordingToBehavior: behaviors)
   
   
   return result.stringValue
}

print(solution())
//  [swift]
import Foundation

func mainC() {
    let AB = readLine()!.split(separator: " ")
    let nsA = NSDecimalNumber(string: String(AB[0]))
    let nsB = NSDecimalNumber(string: String(AB[1]))

    let result = nsA.multiplying(by: nsB).stringValue

    if let index = result.firstIndex(of: ".") {
        print(result.prefix(upTo: index))
    } else {
        print(result)
    }
}
mainC()
//  [typescript]
import * as fs from 'fs'
import {debug} from '../../../util'

const input = fs.readFileSync('/dev/stdin', 'utf8').trim()

const output = (x: string | number | boolean): void => console.log(x)
const splitLine = (string: string): string[] => string.split('\n')
const splitBlank = (string: string): string[] => string.split(' ')
const toNumbers = (array: string[]): number[] => array.map(v => Number(v))
const range = (end: number, start :number = 0): number[] => [...Array(end - start)].map((v, i) => i + start)

// debug(input)

/* ここから */
const [str1, str2] = splitBlank(input)
const A = BigInt(str1)
const B = BigInt(Math.round(Number(str2) * 100))

// console.log(A, B)

// @ts-ignore
const ans = (A * B) / 100n

console.log(ans.toString())
//  [python]
N,M = map(int,input().split())
A = [input() for i in range(N)]
B = [input() for i in range(M)]

dxy = []
for y in range(M) :
    for x in range(M) :
        dxy.append((x,y))
flag = 0
for y in range(N) :
    for x in range(N) :
        if A[y][x] == B[0][0] and flag == 0 :
            counter = 0
            for dx,dy in dxy :
                nx = x+dx
                ny = y+dy
                if (0 <= nx <= N-1) and (0 <= ny <= N-1) and flag == 0 :
                    if A[ny][nx] == B[dy][dx] :
                        counter += 1
                if counter == M**2 :
                    flag = 1
if flag == 1 :
    print("Yes")
else :
    print("No")
//  [python]
import numpy as np
import sys

if __name__=="__main__":
   N, M = list(map(int, input().replace("\n","").split(" ")))
   a = [list(map(int, list(input().replace("\n","").replace(".", "1").replace("#", "0")))) for i in range(N)]
   a = np.array(a)
   b = [list(map(int, list(input().replace("\n","").replace(".", "1").replace("#", "0")))) for i in range(M)]
   b = np.array(b)


   for i in range(N - M + 1):
       for j in	range(N - M + 1):
           if((a[i:i+M,j:j+M] == b).all()):
               print("Yes")
               sys.exit(0)
   print("No")
//  [python]
N, M = map(int, input().split())
A = [list(input()) for _ in range(N)]
B = [list(input()) for _ in range(M)]

for i in range(N):
    for j in range(N):
        flg = True
        for k in range(M):
            for l in range(M):
                try:
                    if A[i+k][j+l] != B[k][l]:
                        flg = False
                except IndexError:
                    flg = False
        if flg:
            print("Yes")
            exit()

print("No")
//  [java]
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Scanner;
import java.util.stream.Stream;

public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int[] in = Stream.of(sc.nextLine().split(" ")).mapToInt(Integer::parseInt).toArray();
		
		List<List<String>> A = new ArrayList<>();
		List<List<String>> B = new ArrayList<>();
		
		for (int i = 0; i < in[0]; i++) {
			List<String> a = Arrays.asList(sc.nextLine().split(""));
			A.add(a);
		}
		
		for (int i = 0; i < in[1]; i++) {
			List<String> b = Arrays.asList(sc.nextLine().split(""));
			B.add(b);
		}
		
		boolean exist = false;
		for (int y = 0; y < A.size(); y++) {
			for (int x = 0; x < A.get(y).size(); x++) {
				if(y+B.size()-1 >= A.size() || x+B.size()-1 >= A.size()) continue;
				
				boolean match = true;
				for (int i = 0; i < B.size(); i++) {
					for (int j = 0; j < B.get(i).size(); j++) {
						if (!(A.get(y+i).get(x+j).equals(B.get(i).get(j)))) match = false;
					}
				}
				if(match) exist = true;
			}
		}	
		
		System.out.println(exist ? "Yes" : "No");		
	}
}
//  [cpp]
#include<iostream>
using namespace std;
int main(){
	int n,m,i,j,k,l,f,x,y;
	string a[55],b[55];
	cin >> n >> m;
	for(i=0;i<n;i++){
		cin >> a[i];
	}
	for(i=0;i<m;i++){
		cin >> b[i];
	}
	int flag=0;
	for(x=0;flag==0,x<=n-m;x++){
		for(y=0;flag==0,y<=n-m;y++){
			for(i=0;flag==0,i<m,i+x<n;i++){
				for(j=0;flag==0,j<m,j+y<n;j++){
					for(f=0,k=0;f==0,k<m;k++){
						for(l=0;f==0,l<m;l++){
							if(a[i+x+k][j+y+l]!=b[k][l]){
								f=1;
							}
						}
					}
					if(f==0){
						flag=1;
					}
				}
			}
		}
	}

	if(flag)
		cout << "Yes" << endl;
	else
		cout << "No" << endl;
	return 0;
}
//  [cpp]
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for(int i = 0; i < (int)(n); i++)

int m, n;
char a[100][100], b[100][100];

int main(){
  cin >> n >> m;
  rep(i, n){
    cin >> a[i];
    //cerr << a[i] << endl;
  }
  rep(i, m){
    cin >> b[i];
  }
  string res = "No";
  rep(i, n - m + 1){
    rep(j, n - m + 1){
      bool flag = true;
      for(int k = 0; k < m; k++){
        for(int l = 0; l < m; l++){
          if(a[i + k][j + l] != b[k][l]){
            flag = false;
            cerr <<k <<" "<< l<<endl;
          }
        }
      }
      if(flag){
        res = "Yes";
      }
    }
  }
  cout << res << endl;
  return 0;
}
//  [cpp]
#include <iostream>
#include <vector>
#include <complex>

using namespace std;
typedef complex<double> C;

void fft(vector<C> &f, int n, int dir) {
	if (n == 1) return;
	vector<C> f0, f1;
	for(int i = 0; i < n; i++) {
		if (i % 2 == 0) {
			f0.push_back(f[i]);
		} else {
			f1.push_back(f[i]);
		}
	}
	fft(f0, n / 2, dir);
	fft(f1, n / 2, dir);
	C zeta = polar(1.0, 2 * M_PI * dir / n);
	C now = C(1.0);
	for(int i = 0; i < n; i++) {
		f[i] = f0[i % (n / 2)] + now * f1[i % (n / 2)];
		now *= zeta;
	}
}

inline int getMinimumPowerOf2(int size) {
	int n = 1;
	while(n < size) n <<= 1;
	return n;
}

void fft2d(vector<vector<C> > &A, int dir = 1) {
	for(int i = 0; i < A.size(); i++) {
		vector<C> f;
		for(int j = 0; j < A[i].size(); j++) {
			f.push_back(A[i][j]);
		}
		fft(f, f.size(), dir);
		for (int j = 0; j < f.size(); j++) {
			A[i][j] = f[j];
		}
	}
	for(int j = 0; j < A[0].size(); j++) {
		vector<C> f;
		for(int i = 0; i < A.size(); i++) {
			f.push_back(A[i][j]);
		}
		fft(f, f.size(), dir);
		for (int i = 0; i < f.size(); i++) {
			A[i][j] = f[i];
		}
	}
}

vector<vector<C> > comb2d(vector<vector<C> > A, vector<vector<C> > B) {
	int n = getMinimumPowerOf2(A.size() + B.size()), m = getMinimumPowerOf2(A[0].size() + B[0].size());
	A.resize(n);
	B.resize(n);
	for (int i = 0; i < A.size(); i++) {
		A[i].resize(m);
	}
	for (int i = 0; i < B.size(); i++) {
		B[i].resize(m);
	}
	fft2d(A);
	fft2d(B);
	vector<vector<C> > ret(n, vector<C>(m, 0));
	for(int i = 0; i < n; i++) {
		for(int j = 0; j < n; j++) {
			ret[i][j] = A[i][j] * B[i][j];
		}
	}
	fft2d(ret, -1);
	for(int i = 0; i < n; i++) {
		for(int j = 0; j < n; j++) {
			ret[i][j] /= n * m;
		}
	}
	return ret;
}



int main() {
	int N, M;
	char chars[] = {'#', '.'};
	int num_chars = sizeof(chars);

	cin >> N >> M;
	vector<string> A(N), B(M);
	for (int i = 0; i < N; i++) {
		cin >> A[i];
	}
	for (int i = 0; i < M; i++) {
		cin >> B[i];
	}
	int n = getMinimumPowerOf2(N + M);
	vector<vector<C> > score(n, vector<C>(n, C(0)));
	for (int c = 0; c < num_chars; c++) {
		vector<vector<C> > cA, cB;
		for (int i = 0; i < N; i++) {
			cA.push_back(vector<C>());
			for (int j = 0; j < N; j++) {
				cA[i].push_back(C(A[i][j] == chars[c]));
			}
		}
		for (int i = 0; i < M; i++) {
			cB.push_back(vector<C>());
			for (int j = 0; j < M; j++) {
				cB[i].push_back(C(B[i][j] == chars[c]));
			}
		}
		vector<vector<C> > ret = comb2d(cA, cB);
		for (int i = 0; i < score.size(); i++) {
			for (int j = 0; j < score[0].size(); j++) {
				score[i][j] += ret[i][j];
			}
		}
	}
	bool flag = false;
	for (int i = 0; i < score.size(); i++) {
		for (int j = 0; j < score[0].size(); j++) {
			if ((int)(real(score[i][j]) + 0.1) == M * M) {
				flag = true;
				break;
			}
		}
		if (flag) break;
	}

	if (flag) {
		cout << "Yes" << endl;
	} else {
		cout << "No" << endl;
	}

	return 0;
}
//  [c]
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>

int descending_compare(const void *a, const void *b){
    if (*(int*)a > *(int*)b){
        return -1;
    }else if (*(int*)a == *(int*)b){
        return 0;
    }else{
        return 1;
    }
}

int ascending_compare(const void *a, const void *b){
    if (*(int*)a < *(int*)b){
        return -1;
    }else if (*(int*)a == *(int*)b){
        return 0;
    }else{
        return 1;
    }
}


int lower_bound(int *a, int n, int key){
    int left, mid, right;
    left = 0, right = n;
    mid = (left + right)/2;
    while ((left+1 != mid || mid+1 != right) && mid != left){
        if (key > a[mid]){
            left = mid;
        }else{
            right = mid+1;
        }
        mid = (left + right)/2;
    }
    if (a[left] >= key)return left;
    if (a[mid] >= key)return mid;
    if (a[right] >= key)return right;
    return n;
}

//greatest common divisor
unsigned long  gcd(unsigned long x, unsigned long y){
    if (y == 0){ 
        return x;
    }else if (x > y){
        return gcd(y, x % y);
    }else{
        return gcd(x, y % x);
    }
}



long long factorial(int x){
    long long rtn = 1;
    int i;
    for (i = x; i > 1; i--){
        rtn = (rtn*i);
    }
    return rtn;
}
char pic[55][55];
char temp[55][55];
int n, m;

int find_pic(int x, int y){
    int flag = 1;
    for (int i = 0; i < m; i++){
        for (int j = 0; j < m; j++){
            if ((x+i > n && y+j > n) || (pic[x+i][y+j] != temp[i][j])) flag = 0;
        }
    }
    return flag;
}



int main(void){
    scanf("%d %d", &n, &m);
    for (int i = 0; i < n; i++){
        for (int j = 0; j < n; j++){
            scanf(" %c", &pic[i][j]);
        }
    }
    for (int i = 0; i < m; i++){
        for (int j = 0; j < m; j++){
            scanf(" %c", &temp[i][j]);
        }
    }

    for (int i = 0; i < n; i++){
        for (int j = 0; j < n; j++){
            if (find_pic(i, j)){
                printf("Yes\n");
                return 0;
            }
        }
    }
    printf("No\n");
    return 0;

}
//  [c]
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <stdint.h> // int64_t

#define max(a,b) ((a) > (b) ? (a) : (b))
#define min(a,b) ((a) > (b) ? (b) : (a))

int get_int2(int *a1, int *a2) {
  scanf("%d %d", a1, a2);
  return 0;
}

int get_str(char *str, int size)
{
    char format[100];
    if (size == 0)
        return 0;
    snprintf(format, sizeof(format), "%%%ds", size);
    scanf(format, str);
    return 0;
}

#define NUM_MAX 50

enum type {
    TYPE_WHITE = '.',
    TYPE_BLACK = '#',
};

struct point2d {
    int x;
    int y;
};

int main(void) {
    int as, bs;
    static char amap[NUM_MAX*2+1][NUM_MAX*2+1];
    static char bmap[NUM_MAX*2+1][NUM_MAX*2+1];
    // assume that as >= bs
    get_int2(&as, &bs);
    int flag = 0;
    int i, j;
    for(i = 0; i < as; i++) {
        get_str(amap[i], as);
    }
    for(i = 0; i < bs; i++) {
        get_str(bmap[i], bs);
    }

    int k1, k2;
    for(i = 0; i < as; i++) {
        for(j = 0; j < as; j++) {
            int ok = 1;
            for(k1 = 0; k1 < bs; k1++) {
                for(k2 = 0; k2 < bs; k2++) {
                    struct point2d ap = {i+k1, j+k2};
                    ok &= (amap[ap.x][ap.y] == bmap[k1][k2]);
                }
            }
            if(ok) { flag = 1; goto finish; }
        }
    }
finish:
    printf("%s\n", flag ? "Yes" : "No");
    return 0;
}
//  [c]
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>


int descending_compare(const void *a, const void *b){
    if (*(int*)a > *(int*)b){
        return -1;
    }else if (*(int*)a == *(int*)b){
        return 0;
    }else{
        return 1;
    }
}

int ascending_compare(const void *a, const void *b){
    if (*(int*)a < *(int*)b){
        return -1;
    }else if (*(int*)a == *(int*)b){
        return 0;
    }else{
        return 1;
    }
}


int lower_bound(int *a, int n, int key){
    int left, mid, right;
    left = 0, right = n;
    mid = (left + right)/2;
    while ((left+1 != mid || mid+1 != right) && mid != left){
        if (key > a[mid]){
            left = mid;
        }else{
            right = mid+1;
        }
        mid = (left + right)/2;
    }
    if (a[left] >= key)return left;
    if (a[mid] >= key)return mid;
    if (a[right] >= key)return right;
    return n;
}

//greatest common divisor
unsigned long  gcd(unsigned long x, unsigned long y){
    if (y == 0){ 
        return x;
    }else if (x > y){
        return gcd(y, x % y);
    }else{
        return gcd(x, y % x);
    }
}



long long factorial(int x){
    long long rtn = 1;
    int i;
    for (i = x; i > 1; i--){
        rtn = (rtn*i);
    }
    return rtn;
}

int pic[100][100];
int tmp[100][100];
int n, m;

int check(int x, int y){
    int flag = 1;
    for (int i = 0; i < m; i++){
        for (int j = 0; j < m; j++){
            if (tmp[i][j] != pic[x+i][y+j]){
                flag = 0;
            }
        }
    }
    return flag;
}

int main(void){
    scanf("%d %d", &n, &m);
    for (int i = 0; i < n; i++){
        for (int j = 0; j < n; j++){
            scanf(" %c", &pic[i][j]);
        }
    }
    for (int i = 0; i < m; i++){
        for (int j = 0; j < m; j++){
            scanf(" %c", &tmp[i][j]);
        }
    }
    for (int i = 0; i < n; i++){
        for (int j = 0; j < n; j++){
            if (check(i, j)){
                printf("Yes\n");
                return 0;
            }
        }
    }
    printf("No\n");
    return 0;

    
}
//  [javascript]
function Main(input) {
  input = input.split("\n");
  nm = input[0].split(" ");
  n = parseInt(nm[0]);
  m = parseInt(nm[1]);
  t = [];
  for (var i = 0; i < m; i++) {
    r = [];
    // console.log(input[i+ n]);
    for (var j = 0; j < m; j++) {
      // console.log(input[i + 1 + n]);
      r.push(input[i + 1 + n][j]);
    }
    // console.log(r);
    t.push(r);
  }
  // console.log(t);
  yes = false;
  loop0: for (var i = 0; i < n - m + 1; i++) {
    for (var j = 0; j < n - m + 1; j++) {
      // console.log(input[i + 1][j]);
      loop1: for (var k = 0; k < m; k++) {
        for (var l = 0; l < m; l++) {
          if (input[i + 1 + k][j + l] != t[k][l]) {
            break loop1;
          }
        }
//        console.log(i, j);
        if (k == m - 1) {
          yes = true;
          break loop0;
        }
      }
      // console.log(input[i + 1][j]);
    }
  }
  if (yes) {
    console.log("Yes");
  } else {
    console.log("No");
  }
  // console.log(input);
}

Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
'use strict';

const input = require('fs').readFileSync('/dev/stdin', 'utf8').trim().split('\n');
const NM = input[0].split(' ').map(Number);
const N = NM[0];
const M = NM[1];
const As = input.slice(1, N + 1);
const Bs = input.slice(N + 1, N + M + 1);

for (let ax = 0; ax < N - M + 1; ax++) {
    for (let ay = 0; ay < N - M + 1; ay++) {
        let flag = true;
        for (let bx = 0; bx < M; bx++) {
            for (let by = 0; by < M; by++) {
                if (As[ax + bx][ay + by] !== Bs[bx][by]) {
                    flag = false;
                    break;
                }
            }
            if (!flag) break;
        }

        if (flag) {
            console.log('Yes');
            process.exit(0);
        }
    }
}
console.log('No');