jiahuimbzuai/CoQuIR huggingface dataset:
//  [go]
package main

import(
    "fmt"
)

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

    if a%2 == 0 || b%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")
		return
	}
	fmt.Println("Odd")
}
//  [go]
package main

import "fmt"

func main() {
	var a, b int

	fmt.Scanf("%d\n", &a)

	fmt.Scanf("%d\n", &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.Scan(&a,&b)
  if a*b%==1{fmt.Println("Odd")}
  else{fmt.Println("Even")}
}
//  [ruby]
a,b = gets.chomp.split(" ").map(&:to_i)
c = a*b
if c.to_i.even?
  print("Even")
else
  print("Odd")
end
//  [ruby]
a,b = gets.split(" ").map(&:to_i)
if (a * b).even?
  print "Even"
else
  print "Odd"
end
//  [ruby]
a,b = gets.split().map(&:to_i)
puts a * b % 2 == 0 ? 'Even' : 'Odd'
//  [ruby]
a,b = gets.strip.split.map(&:to_i)
puts(a * b).odd? ? 'Odd' : 'Even'
//  [ruby]
a =get
puts a
//  [ruby]
a, b = gets.split(" ").to_i
if a * b % 2 == 0
  print('Even')
else
  print('Odd')
end
//  [rust]
use proconio::input;

fn main() {
    input!{
        a: i32,
        b: i32,
    };
    let ans = if (a * b) % 2 == 0  {
        "Even"
    } else {
        "Odd"
    };
    println!("{}", ans);
}
//  [rust]
/**
 * 標準入力マクロ by https://qiita.com/tanakh/items/0ba42c7ca36cd29d0ac8
 */
macro_rules! input {
    (source = $s:expr, $($r:tt)*) => {
        let mut iter = $s.split_whitespace();
        let mut next = || { iter.next().unwrap() };
        input_inner!{next, $($r)*}
    };
    ($($r:tt)*) => {
        let stdin = std::io::stdin();
        let mut bytes = std::io::Read::bytes(std::io::BufReader::new(stdin.lock()));
        let mut next = move || -> String{
            bytes
                .by_ref()
                .map(|r|r.unwrap() as char)
                .skip_while(|c|c.is_whitespace())
                .take_while(|c|!c.is_whitespace())
                .collect()
        };
        input_inner!{next, $($r)*}
    };
}

macro_rules! input_inner {
    ($next:expr) => {};
    ($next:expr, ) => {};

    ($next:expr, $var:ident : $t:tt $($r:tt)*) => {
        let $var = read_value!($next, $t);
        input_inner!{$next $($r)*}
    };
}

macro_rules! read_value {
    ($next:expr, ( $($t:tt),* )) => {
        ( $(read_value!($next, $t)),* )
    };

    ($next:expr, [ $t:tt ; $len:expr ]) => {
        (0..$len).map(|_| read_value!($next, $t)).collect::<Vec<_>>()
    };

    ($next:expr, chars) => {
        read_value!($next, String).chars().collect::<Vec<char>>()
    };

    ($next:expr, usize1) => {
        read_value!($next, usize) - 1
    };

    ($next:expr, $t:ty) => {
        $next().parse::<$t>().expect("Parse error")
    };
}

fn main() {
    input! {
        a: u32,
        b: u32,
    }
    println!("{}", if a * b % 2 == 0 { "Even" } else { "Odd" });
}
//  [rust]
macro_rules! input {
    (source = $s:expr, $($r:tt)*) => {
        let mut iter = $s.split_whitespace();
        let mut next = || { iter.next().unwrap() };
        input_inner!{next, $($r)*}
    };
    ($($r:tt)*) => {
        let stdin = std::io::stdin();
        let mut bytes = std::io::Read::bytes(std::io::BufReader::new(stdin.lock()));
        let mut next = move || -> String{
            bytes
                .by_ref()
                .map(|r|r.unwrap() as char)
                .skip_while(|c|c.is_whitespace())
                .take_while(|c|!c.is_whitespace())
                .collect()
        };
        input_inner!{next, $($r)*}
    };
}

macro_rules! input_inner {
    ($next:expr) => {};
    ($next:expr, ) => {};

    ($next:expr, $var:ident : $t:tt $($r:tt)*) => {
        let $var = read_value!($next, $t);
        input_inner!{$next $($r)*}
    };
}

macro_rules! read_value {
    ($next:expr, ( $($t:tt),* )) => {
        ( $(read_value!($next, $t)),* )
    };

    ($next:expr, [ $t:tt ; $len:expr ]) => {
        (0..$len).map(|_| read_value!($next, $t)).collect::<Vec<_>>()
    };

    ($next:expr, chars) => {
        read_value!($next, String).chars().collect::<Vec<char>>()
    };

    ($next:expr, usize1) => {
        read_value!($next, usize) - 1
    };

    ($next:expr, $t:ty) => {
        $next().parse::<$t>().expect("Parse error")
    };
}
fn main() {
    input!{
        a: usize,
        b: usize,
    };

    let c = a * b;
    if c % 2 == 0{
        println!("Even");
        return;
    }
    println!("Odd");
}
//  [rust]
fn main() {

    let mut s: String = read();
    s.retain(|c| c != ' ');
    let n: i32 = s.parse().unwrap();

    let mut sqrt_vec = Vec::new();
    for i in 1..1001 {
        sqrt_vec.push(i * i);
    }

    let mut flg: bool = true;

    for i in sqrt_vec {
        if i == n {
            println!("Yes");
            flg = false;
        }
    }

    if flg == true {
        println!("No");
    }
}

fn read<T: std::str::FromStr>() -> T {
    let mut s = String::new();
    std::io::stdin().read_line(&mut s).ok();
    s.trim().parse().ok().unwrap()
}

fn read_vec<T: std::str::FromStr>() -> Vec<T> {
    read::<String>()
        .split_whitespace()
        .map(|e| e.parse().ok().unwrap())
        .collect()
}

fn read_vec2<T: std::str::FromStr>(n: u32) -> Vec<Vec<T>> {
    (0..n).map(|_| read_vec()).collect()
}
//  [rust]
fn main() {
    let a: i32 = read();
    let b: i32 = read();

    let ans = if (a * b) % 2 == 0 { "Even" } else { "Odd" };

    println!("{}", ans);
}

fn read<T: std::str::FromStr>() -> T {
    let mut s = String::new();
    std::io::stdin().read_line(&mut s).ok();
    s.trim().parse().ok().unwrap()
}
//  [rust]
fn main() {

  	let a: i32 = read();
    let b: i32 = read();

    let ans = if (a * b) % 2 == 0 { "Even" } else { "Odd" };

    println!("{}", ans);
}

fn read<T: std::str::FromStr>() -> T {
    let mut s = String::new();
    std::io::stdin().read_line(&mut s).ok();
    s.trim().parse().ok().unwrap()
}
//  [swift]
let arr = readLine()!.characters.split{$0 == " "}.map{Int(String($0))!}
let a = arr[0]
let b = arr[1]
print( (a * b) % 2 > 0 ? "Odd": "Even")
//  [swift]
let arr = readLine()!.characters.split{$0 == " "}.map{Int(String($0))!}
let a = arr[0]
let b = arr[1]
print(a*b % 2 == 0 ? "Even": "Odd")
//  [swift]
import Glibc
extension String: CollectionType {}

var inp = readLine()!.split(" ").map { Int($0)! }
if inp[0]*inp[1]%2==0 {
  print("Even")
} else {
  print("Odd")
}
//  [swift]
let split = readLine()!.componentsSeparatedByString(" ")
let a = Int(split[0])!
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")
}
//  [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]
// inputに入力データ全体が入る
function Main(input) {
	// 1行目がinput[0], 2行目がinput[1], …に入る
	input = input.split("\n");
	let a = input[0].split(" ")[0];
	let b = input[0].split(" ")[1];
	//文字列から10進数に変換するときはparseIntを使います
  	if(a*b%2===0){
      console.log("Even");
    } else {
      console.log("Odd");
    }
}
//*この行以降は編集しないでください（標準入出力から一度に読み込み、Mainを呼び出します）
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [typescript]
function main(input) {
  const [a, b] = input.split(" ")
  const ans = (a * b) % 2 === 0 ? "Even" : "Odd"
  console.log(ans)
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [typescript]
const main = (input: void) => {
  const a: number = input.split(' ')[0];
  const b: number = input.split(' ')[1];

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

main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [typescript]
import * as fs from "fs";
const input = (fs.readFileSync("/dev/stdin", "utf8") as string)
  .split("\n")
  .map(Number);

console.log((input[0] - input[1]) % input[2]);
//  [typescript]
process.stdin.resume();
process.stdin.setEncoding('utf8');

let lines = [];
let reader = require('readline').createInterface({
  input: process.stdin,
  output: process.stdout
});
reader.on('line', (line) => {
  lines.push(line);
});
reader.on('close', () => {
  value=lines[0].split("")
  let sum=value[0]*value[1];
  if(sum%2===0) console.log("Even");
  else if(sum%3===0) console.log("Odd");
  
});
//  [typescript]
function Main(input) {
    input = input.split('\n');
    var [a,b] = input[0].split(' ').map(Number);
    console.log(a * b % 2 === 0 ? 'even' : 'odd');
}

Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [python]
a,b=input().split()
a=int(a)
b=list(b)
b=[int(b[0]),int(b[2]),int(b[3])]
c=(a*b[0]*100+a*b[1]*10+a*b[2])//100
print(c)
//  [python]

a,b = input().split()
a = int(a)
b = float(b)
val = int((b * 1000)) 
new = (a * val)//1000 

#print(b)

print(new)
//  [python]
A, B = input().split()
A = int(A)
B = float(B)
B = round(B*100)
print(A * B//100)
//  [python]
#!/usr/bin/env python3

#import
#import math
#import numpy as np
#= int(input())
#= input()
A, B = map(float, input().split())
A = int(A)
B = int(B * 100)

print(A * B // 100)
//  [python]
import sys


def solve():
    readline = sys.stdin.buffer.readline
    mod = 10 ** 9 + 7
    a, b = list(map(float, readline().split()))
    print(int(a * b))


if __name__ == '__main__':
    solve()
//  [python]
A,B = input().split()
print((int(A)*int(100*float(B)))//100)
//  [java]
import java.util.*;
import java.io.*;
public class Main {
 
	public static void main(String[] args) throws Exception{
		int num = 998244353;
 
		// TODO Auto-generated method stub
 		BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
 		PrintWriter out = new PrintWriter(System.out);
 		StringTokenizer st = new StringTokenizer(bf.readLine());
 		long a = Long.parseLong(st.nextToken());
 		double b = Double.parseDouble(st.nextToken());
 		int c = (int)(b*100.0001);
 		long d = a*(long)(c);
 		out.println((d-((a%100)*(c%100))%100)/((long)(100)));
 		out.close();
 		
 	}
 
}
//  [java]
//master
import java.io.*;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.*;
public class Main {
    static int[][] memo;
    public static void main(String[] args) {
        FastScanner sc = new FastScanner();
        String a = sc.next();
        String b = sc.next();
        BigDecimal ba = new BigDecimal(a);
        BigDecimal bb = new BigDecimal(b); 

        BigDecimal ans = ba.multiply(bb).setScale(0, RoundingMode.DOWN);
        p(ans);

    }

    public static <T> void p(T message) {
        System.out.println(message);
    }

    public static <T> void pe(T message) {
        System.err.println(message);
    }

    public static <T> void pp(T message) {
        System.out.print(message);
    }
    
}
class FastScanner {
    private final InputStream in = System.in;
    private final byte[] buffer = new byte[1024];
    private int ptr = 0;
    private int buflen = 0;
    private boolean hasNextByte() {
        if (ptr < buflen) {
            return true;
        } else {
            ptr = 0;
            try {
                buflen = in.read(buffer);
            } catch (IOException e) {
                e.printStackTrace();
            }
            if (buflen <= 0) {
                return false;
            }
        }
        return true;
    }
 
    private int readByte() {
        if (hasNextByte())
            return buffer[ptr++];
        else
            return -1;
    }
 
    private boolean isPrintableChar(int c) {
        return 33 <= c && c <= 126;
    }
 
    public boolean hasNext() {
        while (hasNextByte() && !isPrintableChar(buffer[ptr]))
            ptr++;
        return hasNextByte();
    }
 
    public String next() {
        if (!hasNext())
            throw new NoSuchElementException();
        StringBuilder sb = new StringBuilder();
        int b = readByte();
        while (isPrintableChar(b)) {
            sb.appendCodePoint(b);
            b = readByte();
        }
        return sb.toString();
    }
 
    public long nextLong() {
        if (!hasNext())
            throw new NoSuchElementException();
        long n = 0;
        boolean minus = false;
        int b = readByte();
        if (b == '-') {
            minus = true;
            b = readByte();
        }
        if (b < '0' || '9' < b) {
            throw new NumberFormatException();
        }
        while (true) {
            if ('0' <= b && b <= '9') {
                n *= 10;
                n += b - '0';
            } else if (b == -1 || !isPrintableChar(b)) {
                return minus ? -n : n;
            } else {
                throw new NumberFormatException();
            }
            b = readByte();
        }
    }
 
    public int nextInt() {
        long nl = nextLong();
        if (nl < Integer.MIN_VALUE || nl > Integer.MAX_VALUE)
            throw new NumberFormatException();
        return (int) nl;
    }
 
    public double nextDouble() {
        return Double.parseDouble(next());
    }
}
//  [java]
import java.util.Scanner;						  
public class Main{
    public static void main(String[] args) {
        Scanner stdIn= new Scanner(System.in);
        int a = stdIn.nextInt();
        double b = stdIn.nextDouble();
        double c=a*b;
        c=c-c%1;
        System.out.printf("%.0f",c);
    }
}
//  [cpp]
#include <cstdio>
#include <cmath>

int main()
{
    size_t a, b;
    int c;
    scanf("%lu %lu.%d", &a, &b, &c);
    size_t prod = a * b;
    prod += a * c / 100;
    printf("%lu", prod);
    return 0;
}
//  [cpp]
#include<cstdio>
#include<algorithm>
#include<cmath>
#include<cstring>
#define ll long long
using namespace std;
const int N=101101;
int T,n,k;
int main(){
	ll a,b,c,d;
	scanf("%lld%lld.%lld",&a,&b,&c);
	d=a*(b*100+c)/100;
	printf("%lld\n",d);
	return 0;
}
//  [cpp]
// #pragma GCC target("avx")  // CPU 処理並列化
// #pragma GCC optimize("O3")  // CPU 処理並列化
// #pragma GCC optimize("unroll-loops")  // 条件処理の呼び出しを減らす
// #define BEGIN_STACK_EXTEND(size) void * stack_extend_memory_ = malloc(size);void * stack_extend_origin_memory_;char * stack_extend_dummy_memory_ = (char*)alloca((1+(int)(((long long)stack_extend_memory_)&127))*16);*stack_extend_dummy_memory_ = 0;asm volatile("mov %%rsp, %%rbx\nmov %%rax, %%rsp":"=b"(stack_extend_origin_memory_):"a"((char*)stack_extend_memory_+(size)-1024));
// #define END_STACK_EXTEND asm volatile("mov %%rax, %%rsp"::"a"(stack_extend_origin_memory_));free(stack_extend_memory_);

#include<stdio.h>
#include<math.h>
#include<algorithm>
#include<queue>
#include<deque>
#include<stack>
#include<string>
#include<string.h>
#include<vector>
#include<set>
#include<map>
#include<bitset>
#include<stdlib.h>
#include<cassert>
#include<time.h>
#include<bitset>
#include<numeric>
#include<unordered_set>
#include<unordered_map>
#include<complex>
using namespace std;
const long long mod=1000000007;
const long long inf=mod*mod;
const long long d2=(mod+1)/2;
const double EPS=1e-11;
const double INF=1e+10;
const double PI=acos(-1.0);
const int C_SIZE = 11100000;
const int UF_SIZE = 3100000;
namespace{
	long long fact[C_SIZE];
	long long finv[C_SIZE];
	long long inv[C_SIZE];
	inline long long Comb(int a,int b){
	 	if(a<b||b<0)return 0;
	 	return fact[a]*finv[b]%mod*finv[a-b]%mod;
	}
	void init_C(int n){
		fact[0]=finv[0]=inv[1]=1;
		for(int i=2;i<n;i++){
			inv[i]=(mod-(mod/i)*inv[mod%i]%mod)%mod;
		}
		for(int i=1;i<n;i++){
			fact[i]=fact[i-1]*i%mod;
			finv[i]=finv[i-1]*inv[i]%mod;
		}
	}
	long long pw(long long a,long long b){
		if(a<0LL)return 0;
		if(b<0LL)return 0;
		long long ret=1;
		while(b){
			if(b%2)ret=ret*a%mod;
			a=a*a%mod;
			b/=2;
		}
		return ret;
	}
	long long pw_mod(long long a,long long b,long long M){
		if(a<0LL)return 0;
		if(b<0LL)return 0;
		long long ret=1;
		while(b){
			if(b%2)ret=ret*a%M;
			a=a*a%M;
			b/=2;
		}
		return ret;
	}
	int pw_mod_int(int a,int b,int M){
		if(a<0)return 0;
		if(b<0)return 0;
		int ret=1;
		while(b){
			if(b%2)ret=(long long)ret*a%M;
			a=(long long)a*a%M;
			b/=2;
		}
		return ret;
	}
	int ABS(int a){return max(a,-a);}
	long long ABS(long long a){return max(a,-a);}
	double ABS(double a){return max(a,-a);}
	int sig(double r) { return (r < -EPS) ? -1 : (r > +EPS) ? +1 : 0; }
	int UF[UF_SIZE];
	void init_UF(int n){
		for(int i=0;i<n;i++)UF[i]=-1;
	}
	int FIND(int a){
		if(UF[a]<0)return a;
		return UF[a]=FIND(UF[a]);
	}
	void UNION(int a,int b){
		a=FIND(a);b=FIND(b);if(a==b)return;
		if(UF[a]>UF[b])swap(a,b);
		UF[a]+=UF[b];UF[b]=a;
	}
}
// ここから編集しろ

int main(){
	long long a;
	double b;
	scanf("%lld%lf",&a,&b);
	int B=100*(b+0.005);
	a*=B;
	a/=100;
	printf("%lld\n",a);
}
//  [cpp]
#include<bits/stdc++.h>
using namespace std ;

// Template START
#define endl "\n"
#define async ios_base::sync_with_stdio(false); cin.tie(NULL);
#define int long long int
#define all(y) y.begin(), y.end()
#define present( x, y ) (x.find( y ) != x.end())
const int mod = (int)1e9 + 7 ;
template<class T>
auto matrix( int r, int c, T v ){
    return vector<vector<T>>( r, vector<T>( c, v ) ) ;
}
template<class T>
auto matrix( int o1, int o2, int o3, T v ){ 
    return vector<vector<vector<T>>>( o1, vector<vector<T>>( o2, vector<T>( o3, v ) ) ) ;
}
#define v vector
int power( int x, int n ){
    if( n == 0 ) return 1 ;
    else if( n & 1 ) return ( x * power( (x*x) % mod, n / 2 ) ) % mod ;
    return power( (x*x) % mod, n / 2 ) % mod ;
}
template<class T> void __print( v<T> &arr ){
    int n = arr.size() ;
    cerr << "[ " ;
    for( int i = 0 ; i < n ; i++ ) {
        cerr << arr[i] ;
        if( i != n - 1 ) cerr << ", " ;
    }
    cerr << " ]" << endl ;
}
template<class T> void __print( T arr[], int n ){ 
    cerr << "[ " ;
    for( int i = 0 ; i < n ; i++ ) {
        cerr << arr[i] ;
        if( i != n - 1 ) cerr << ", " ;
    }
    cerr << " ]" << endl ;
}
#define print(x) cerr << "{ " << #x << " : " << x << " }" ;
#define println(x) cerr << "{ " << #x << " : " << x << " }" ;
// Template END
const int mx = (int)2e5 + 1 ;
class compare {
    // multiset<dataType, compare>
    // priority_queue<dataType, vector<dataType>, compare>
    public :
    // first - ratings, second - number
    bool operator()( const pair<int,int> &a, const pair<int,int> &b ){
        return a.first > b.first ;
    }
} ;

signed main(){
    int a ;
    float b ;
    cin >> a >> b ;
    int x = b * 100 ;
    cout << (int)(( a * b ) / 100) ;
    return 0 ;   
}
//  [cpp]
#include<bits/stdc++.h>
using namespace std ;

// Template START
#define endl "\n"
#define async ios_base::sync_with_stdio(false); cin.tie(NULL);
#define int long long int
#define all(y) y.begin(), y.end()
#define present( x, y ) (x.find( y ) != x.end())
const int mod = (int)1e9 + 7 ;
template<class T>
auto matrix( int r, int c, T v ){
    return vector<vector<T>>( r, vector<T>( c, v ) ) ;
}
template<class T>
auto matrix( int o1, int o2, int o3, T v ){ 
    return vector<vector<vector<T>>>( o1, vector<vector<T>>( o2, vector<T>( o3, v ) ) ) ;
}
#define v vector
int power( int x, int n ){
    if( n == 0 ) return 1 ;
    else if( n & 1 ) return ( x * power( (x*x) % mod, n / 2 ) ) % mod ;
    return power( (x*x) % mod, n / 2 ) % mod ;
}
template<class T> void __print( v<T> &arr ){
    int n = arr.size() ;
    cerr << "[ " ;
    for( int i = 0 ; i < n ; i++ ) {
        cerr << arr[i] ;
        if( i != n - 1 ) cerr << ", " ;
    }
    cerr << " ]" << endl ;
}
template<class T> void __print( T arr[], int n ){ 
    cerr << "[ " ;
    for( int i = 0 ; i < n ; i++ ) {
        cerr << arr[i] ;
        if( i != n - 1 ) cerr << ", " ;
    }
    cerr << " ]" << endl ;
}
#define print(x) cerr << "{ " << #x << " : " << x << " }" ;
#define println(x) cerr << "{ " << #x << " : " << x << " }" ;
// Template END
const int mx = (int)2e5 + 1 ;
class compare {
    // multiset<dataType, compare>
    // priority_queue<dataType, vector<dataType>, compare>
    public :
    // first - ratings, second - number
    bool operator()( const pair<int,int> &a, const pair<int,int> &b ){
        return a.first > b.first ;
    }
} ;

signed main(){
    int a ;
    double b ;
    cin >> a >> b ;
    b *= 100 ;
    cout << (int)(( a * b ) / 100) ;
    return 0 ;   
}
//  [cpp]
#include<bits/stdc++.h>
using namespace std ;

// Template START
#define endl "\n"
#define async ios_base::sync_with_stdio(false); cin.tie(NULL);
#define int long long int
#define all(y) y.begin(), y.end()
#define present( x, y ) (x.find( y ) != x.end())
const int mod = (int)1e9 + 7 ;
template<class T>
auto matrix( int r, int c, T v ){
    return vector<vector<T>>( r, vector<T>( c, v ) ) ;
}
template<class T>
auto matrix( int o1, int o2, int o3, T v ){ 
    return vector<vector<vector<T>>>( o1, vector<vector<T>>( o2, vector<T>( o3, v ) ) ) ;
}
#define v vector
int power( int x, int n ){
    if( n == 0 ) return 1 ;
    else if( n & 1 ) return ( x * power( (x*x) % mod, n / 2 ) ) % mod ;
    return power( (x*x) % mod, n / 2 ) % mod ;
}
template<class T> void __print( v<T> &arr ){
    int n = arr.size() ;
    cerr << "[ " ;
    for( int i = 0 ; i < n ; i++ ) {
        cerr << arr[i] ;
        if( i != n - 1 ) cerr << ", " ;
    }
    cerr << " ]" << endl ;
}
template<class T> void __print( T arr[], int n ){ 
    cerr << "[ " ;
    for( int i = 0 ; i < n ; i++ ) {
        cerr << arr[i] ;
        if( i != n - 1 ) cerr << ", " ;
    }
    cerr << " ]" << endl ;
}
#define print(x) cerr << "{ " << #x << " : " << x << " }" ;
#define println(x) cerr << "{ " << #x << " : " << x << " }" ;
// Template END
const int mx = (int)2e5 + 1 ;
class compare {
    // multiset<dataType, compare>
    // priority_queue<dataType, vector<dataType>, compare>
    public :
    // first - ratings, second - number
    bool operator()( const pair<int,int> &a, const pair<int,int> &b ){
        return a.first > b.first ;
    }
} ;

signed main(){
    int a ;
    float b ;
    cin >> a >> b ;
    b *= 100 ;
    cout << (int)(( a * b ) / 100) ;
    return 0 ;   
}
//  [c]
#include <stdio.h>

int main(void) {
    double b;
    long int ans, a;
    scanf("%ld %lf", &a, &b);
    int c = b * 100+0.0001;
    ans = (long)(a * c) / 100;
    printf("%ld\n", ans);
    return 0;
}
//  [c]
#include <stdio.h>

int main(void) {
    double b;
    long int ans, a;
    scanf("%ld %lf", &a, &b);
    int c = b * 100 + 0.001;
    ans = (long)(a * c) / 100;
    printf("%ld\n", ans);
    return 0;
}
//  [c]
#include <stdio.h>
#include <math.h>

int main(void)
{
    long long a, b2;
    double b;

    scanf("%lld %lf", &a, &b);
    b2 = (long long)round(b * 100.0);

    long long c = a * b2;
    printf("%lld\n", c/100);

    return 0;
}
//  [c]
#include <stdio.h>
int main()
{
	float a, b;
	int m;
	scanf("%f %f", &a, &b);
	m = a * b;
	printf("%d\n", m);
	return 0;
}
//  [c]
#include<bits/stdc++.h>
using namespace std;
using ll=long long int;
int main()
{
    ll a;
    double b;
    cin>>a>>b;
    ll p=a*b;
    cout<<(long long int)(p)<<endl;
}
//  [c]
#include <algorithm>
#include <array>
#include <cassert>
#include <cctype>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <optional>
#include <queue>
#include <set>
#include <string>
#include <string_view>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;

int64_t read_int() {
    int64_t ret = 0, sgn = 1;
    int ch = getchar_unlocked();
    while (isspace(ch)) { ch = getchar_unlocked(); }
    if (ch == '-') { sgn = -1; ch = getchar_unlocked(); }
    for (; isdigit(ch); ch = getchar_unlocked())
        ret = (ret * 10) + (ch - '0');
    ungetc(ch, stdin);
    return sgn * ret;
}

#define REP(i, n) for (int i = 0; i < (int)(n); ++i)
#define FOR(i, a, b) for (int i = (int)(a); i < (int)(b); ++i)
#define ALL(c) (c).begin(), (c).end()

template <typename T> inline void assign_min(T& x, const T& value) noexcept { x = min(x, value); }
template <typename T> inline void assign_max(T& x, const T& value) noexcept { x = max(x, value); }

constexpr char LF = '\n';

//-------------------------------------------------------------------------------------------------

string read_word() {
    string ret;
    int ch = getchar_unlocked();
    while (isspace(ch)) { ch = getchar_unlocked(); }
    for (; ch != EOF && !isspace(ch); ch = getchar_unlocked())
        ret += ch;
    ungetc(ch, stdin);
    return ret;
}

using int128 = __int128_t;

int main() {
    int128 A = read_int();
    string B = read_word();

    int128 C = 0;
    REP(i, B.size()) {
        if (B[i] == '.') continue;
        C = (C * 10) + (B[i] - '0');
    }
    cout << int64_t(A*C/100) << endl;
}
//  [javascript]
function main( args ) {
  const tmp = args.split(' ');
  const A = BigInt(tmp[0]);
  const B = BigInt(tmp[1].replace('.',''))
  console.log((A*B/100n).toString());
}
main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
function Main(input){
  input = input.split(" ");
  var a = BigInt(input[0]);
  var b = BigInt(input[1].split(".").join(""));
  console.log(String(a*b/100n).split("n").join(""));
}Main(require("fs").readFileSync("/dev/stdin", "utf8").trim());
//  [javascript]
const [a, b] = require("fs").readFileSync("/dev/stdin", "utf8").split(" ");
const result = (BigInt(parseInt(a, 10)) * BigInt(parseInt(b.split(".").join(""), 10))).toString().slice(0, -2);
if (result === "") {
  console.log(0);
} else {
  console.log(result);
}
//  [javascript]
const main = (input) => {
  const [_a, _b] = input.trim().split(' ')
  const a = BigInt(_a)
  const b = BigInt(Math.floor(_b*100))

  return console.log(`${a*b / 100n}`.split('n').join(''))
}

process.env.MYTEST
  ? (process.env.MYTEST === 'test' ? test() : main(require('fs').readFileSync('dev/stdin', 'utf8')))
  : main(require('fs').readFileSync('/dev/stdin', 'utf8'))
//  [javascript]
const main = (input) => {
  const [_a, _b] = input.trim().split(' ')
  const a = BigInt(_a)
  const b = BigInt(Math.floor(_b*100))

  if (a === 0n || b === 0n) return console.log(0)
  return console.log(`${a*b/100n}`)
}

process.env.MYTEST
  ? (process.env.MYTEST === 'test' ? test() : main(require('fs').readFileSync('dev/stdin', 'utf8')))
  : main(require('fs').readFileSync('/dev/stdin', 'utf8'))
//  [javascript]
const main = (input) => {
  const [_a, _b] = input.trim().split(' ')
  const a = BigInt(_a)
  const b = BigInt(Math.floor(_b*100))

  return console.log(`${a*b/100n}`)
}

process.env.MYTEST
  ? (process.env.MYTEST === 'test' ? test() : main(require('fs').readFileSync('dev/stdin', 'utf8')))
  : main(require('fs').readFileSync('/dev/stdin', 'utf8'))
//  [go]
package main
import (
  "fmt"
  "math"
)
var(
  a int
  b float64
  c int
)
func main(){
  fmt.Scan(&a,&b)
  c=(a*int(math.Round(b*100)))/100
  fmt.Println(c)
}
//  [go]
package main
import (
    "bufio"
    "fmt"
    "math"
    "os"
    "strconv"
    "strings"
)

var sc = bufio.NewReaderSize(os.Stdin, 1024*1024*10)

func main() {
    list := getStdinArr()
    A, _ := strconv.Atoi(list[0])
    B, _ := strconv.ParseFloat(list[1], 64)
    a := A
    b := int(math.Round(B * 100))
    fmt.Println((a*b)/100)
}


func getStdin() string {
    return readLine()
}
func getStdinInt() int {
    str := getStdin()
    res, _ := strconv.Atoi(str)
    return res
}
func getStdinintArr() []int {
    str := getStdin()
    list := strings.Split(str, " ")
    res := make([]int, len(list))
    for idx, v := range list {
        res[idx], _ = strconv.Atoi(v)
    }
    return res
}
func getStdinArr() []string {
    str := getStdin()
    list := strings.Split(str, " ")
    return list
}
func getStdinIntArr64() []int64 {
    str := getStdin()
    list := strings.Split(str, " ")
    res := make([]int64, len(list))
    for idx, v := range list {
        res[idx], _ = strconv.ParseInt(v, 10, 64)
    }
    return res
}
func readLine() string {
    buf := make([]byte, 0, 0)
    for {
        l, p, e := sc.ReadLine()
        if e != nil {
            panic(e)
        }
        buf = append(buf, l...)
        if !p {
            break
        }
    }
    return string(buf)
}
//  [go]
package main

import "fmt"

func main() {
	var A, B float64
	fmt.Scan(&A, &B)
	a := int64(A)
	b := int64(B * 100)
	fmt.Println(int64(a * b / int64(100)))
}
//  [go]
package main

import "fmt"

func main() {
	var A, B float64
	fmt.Scan(&A, &B)
	a := int64(A)
	b := int64(B * 100)
	fmt.Println(int64(a * b / 100))
}
//  [go]
package main

import "fmt"

func main() {
	var A, B float64
	fmt.Scan(&A, &B)
	a := int(A)
	b := int(B * 100)
	fmt.Println(int(a * b / 100))
}
//  [ruby]
a, b = gets.split
a = a.to_i
b = b.delete(".").to_i
p (a*b)/100
//  [ruby]
a, b = gets.chomp.split(" ")
A = a.to_i
b = b.split(".")
B = b[0].to_i * 100 + b[1].to_i

puts A*B/100
//  [ruby]
a,b=gets.split.map(&:to_f)
a=(a+0.1).floor
b=(b*100+0.1).floor
puts a*b/100
//  [ruby]
a, b = gets.split
an = a.to_i
bn = (b.to_f * 100).to_i

puts an * bn / 100
//  [ruby]
input = gets.split(' ')
a = input[0].to_i
b = input[1].to_f

puts (a * b).to_i
//  [ruby]
a, b = gets.split(" ").map &:to_f
a = a.to_i
b = ((b * 100).floor).to_i
puts (a * b)/100
//  [rust]
#![allow(non_snake_case)]
#![allow(unused_imports)]
 
use proconio::{input, fastout};
use proconio::marker::*;
use whiteread::parse_line;
use std::collections::*;
use num::*;

#[fastout]
fn main() {
    input!{
        a: u64,
        b: f64,
    }

    let b = bigint::BigUint::from_u64((b * 1000.0) as u64).unwrap();
    let a = bigint::BigUint::from_u64(a).unwrap();

    println!("{}", a * b / bigint::BigUint::from_u64(1000).unwrap())
}
//  [rust]
use std::io::stdin;

fn main() {
    let mut is = String::new();
    stdin().read_line(&mut is).ok();
    let mut itr = is.split_whitespace();
    let a = itr.next().unwrap().parse::<i64>().unwrap();
    let b = itr.next().unwrap().chars().fold(0, |pre, i| {
        if i.is_digit(10) {
            pre * 10 + i.to_digit(10).unwrap() as i64
        } else {
            pre
        }
    });

    println!("{}", a * b / 100);
}
//  [rust]
#![allow(non_snake_case)]

use std::io::{stdin, Read};
use std::str::FromStr;
fn read_option<T: FromStr>() -> Option<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()
}
fn read<T: FromStr>() -> T {
    let opt = read_option();
    opt.expect("failed to parse token")
}

fn main() {
    let A: i64 = read();
    let B: String = read();
    let vec: Vec<_> = B.split('.').collect();
    let b: usize = vec[0].parse::<usize>().unwrap() * 100 + vec[1].parse::<usize>().unwrap();
    println!("{}", A * b as i64 / 100);
}
//  [rust]
use proconio::{fastout, input};
#[allow(unused_mut)]
#[fastout]
fn main() {
    input! {
        a: u128,
        b: f64
    }
    println!("{}", (a * ((b * 100.) as u128)) / 100)
}
//  [rust]
use proconio::input;
fn main() {
    input!(a: i128, b: f64);
    let b = (b * 100.0) as i128;
    println!("{}", a * b / 100);
}
//  [rust]
use proconio::input;
fn main() {
    input!(a: i64, b: f64);
    let b = (b * 100.0) as i64;
    println!("{}", a * b / 100);
}
//  [swift]
let inputs = readLine()!.split(separator: " ")
let A = Int(inputs[0])!
let Bs = Array(inputs[1])
let base = Character("0").unicodeScalars.first!.value
let B = 100 * Int(Bs[0].unicodeScalars.first!.value - base) +
        10 * Int(Bs[2].unicodeScalars.first!.value - base) +
        Int(Bs[3].unicodeScalars.first!.value - base)     
print(A * B / 100)
//  [swift]
let AB: [String] = readLine()!.split(separator: " ").map { String($0) }
let A: Int = Int(AB[0])!
let B: Float = Float(AB[1])!
let intB: Int = Int(B * 100 + 0.1)
var res: Int = A * intB / 100
print(res)
//  [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)
    print(Int(result.doubleValue))
}
mainC()
//  [swift]
import Foundation

func mainC() {
    let AB = readLine()!.split(separator: " ")
    let A = Int(AB[0])!
    let B = Double(AB[1])!
    print(Int(floor(Double(A) * B)))
}
mainC()
//  [swift]
func mainC() {
    let AB = readLine()!.split(separator: " ")
    let A = Int(AB[0])!
    let B = Double(AB[1])!
    print(Int(floor(Double(A) * B)))
}
mainC()
//  [typescript]
import * as fs from 'fs';

const readString = (() => {
  const input = fs.readFileSync(0).toString();
  const words = input.split(/[ \n]/);
  let i = 0;
  return () => words[i++] || '';
})();
const readInt = () => parseInt(readString(), 10);
const readNumber = () => +readString();
const readBigInt = () => BigInt(readString());

const gcd = (a: bigint, b: bigint) => {
  const _gcd = (a: bigint, b: bigint): bigint => {
    const q = a % b;
    return q === 0n ? b : _gcd(b, q);
  };
  return a > b ? _gcd(a, b) : _gcd(b, a);
};

const MOD = 1000000007;
const MOD_BIGINT = BigInt(MOD);
class ModBigInt {
  constructor(public v: bigint) {}

  static of(n: number | bigint) {
    return new ModBigInt(ModBigInt.toBigInt(n));
  }

  static toBigInt(other: number | bigint | ModBigInt) {
    if (typeof other === 'bigint') return other;
    if (typeof other === 'number') return BigInt(other);
    return other.v;
  }

  clone = () => new ModBigInt(this.v);
  plus = (other: number | bigint | ModBigInt) => {
    this.v = (this.v + ModBigInt.toBigInt(other)) % MOD_BIGINT;
    return this;
  };
  minus = (other: number | bigint | ModBigInt) => {
    this.v = (this.v + MOD_BIGINT - ModBigInt.toBigInt(other)) % MOD_BIGINT;
    return this;
  };
  multiply = (other: number | bigint | ModBigInt) => {
    this.v = (this.v * ModBigInt.toBigInt(other)) % MOD_BIGINT;
    return this;
  };
  pow = (other: number) => {
    const v = mod(1);
    for (let i = 0; i < other; i++) v.multiply(this.v);
    return v;
  };
}

const mod = ModBigInt.of;

const abs = (a: bigint) => (a > 0n ? a : -a);

(function main() {
  const A = readBigInt();
  const B = BigInt(Math.round(readNumber() * 100));
  console.log(((A * B) / 100n).toString());
})();
//  [typescript]
import * as fs from 'fs';

const input = fs.readFileSync('/dev/stdin', 'utf8');
const [strA, strB] = input.split(' ');
const [strB1, strB2] = strB.split('.');

const a = BigInt(strA);
const b1 = BigInt(strB1);
const b2 = BigInt(strB2);

const result = a * b1 + (a * b2 / 100n);

console.log(result.toString())
//  [python]
import sys
N, M = map(int, raw_input().split())
A = [raw_input() for i in range(N)]
B = [raw_input() for i in range(M)]
for i in range(N):
    if i + M - 1 >= N:
        break
    for j in range(N):
        if j + M - 1 >= N:
            break
        match = True
        for k in range(M):
            for l in range(M):
                if A[i + k][j + l] != B[k][l]:
                    match = False
                    break
            if not match:
                break
        if match:
            print "Yes"
            sys.exit(0)
print "No"
//  [python]
import sys

stdin = sys.stdin
def na(): return map(int, stdin.readline().split())
def ns(): return stdin.readline().strip()

n,m = na()
ba = []
for i in range(n):
    ba.append(ns())
bb = []
for i in range(m):
    bb.append(ns())

for i in range(n-m+1):
    for j in range(n-m+1):
        ok = True
        for k in range(m):
            if ba[i+k][j:j+m] != bb[k]:
                ok = False
                break
        if ok:
            print("Yes")
            sys.exit(0)
print("No")
//  [python]
import sys

N,M = map(int, input().split())

strNs = []
strMs = []

for n in range(N):
	strNs.append(input())
	
for m in range(M):
	strMs.append(input())
	
def check_rest(start_row, start_col):
	for j in range(1,M):
		if strNs[start_row+j][start_col:start_col+M] != strMs[j]:
			return False
	else:
		return True
		

for i in range(N-M+1):
	tmp = strNs[i].find(strMs[0])
	while tmp >= 0:
		if check_rest(i, tmp):
			print("Yes")
			sys.exit()
		elif tmp + M > N:
			break
		else:
			tmp = strNs[i].find(strMs[0],tmp+1)
			
print("No")
//  [python]
N,M = map(int,input().split())
A=[input() for _ in range(N)]
B=[input() for _ in range(M)]

ans="No"

for i in range(N-M+1):
    for j in range(N-M+1):
        flag = True
        for k in range(M):
            for l in range(M):
                if A[i+k][j+l]!=B[k][l]:
                    ans = "No"
                    flag = False
                    break
        if flag:
            ans="Yes"
            break

print(ans)
//  [python]
n, m = map(int, input().split())
a, b = [], []
for i in range(n):
  a.append(input())
for i in range(m):
  b.append(input())
  
ans = False
for i in range(n-m+1):
  for j in range(n-m+1):
    flag = True
    for k in range(m):
      if a[i+k][j:j+m] != b[k]:
        flag = False
    if flag:
      ans = True

if flag:
  print("Yes")
else:
  print("No")
//  [python]
n,m = map(int, input().split())
ma = []
for i in range(n):
  ma.append(input())

t = []
for i in range(m):
  t.append(input())

ly = len(t[0])
lt = m
ans = False
for i in range(n - m + 1):
  for j in range(n - m + 1):
    for k in range(lt):

      if ma[i + k][j : j + ly + 1] != t[k]:
        break
    else:
      ans = True

if ans:
  print("Yes")
else:
  print("No")
//  [java]
import java.util.*;
import java.io.*;
import static java.lang.Math.*;

public class Main {
    public static void main(String[] args) throws Exception {
		Scanner sc = new Scanner(System.in);
		
		// 入力
		int n = sc.nextInt();
		int m = sc.nextInt();
		String[] a = new String[n];
		String[] b = new String[m];
		for(int i = 0; i < n; i++){
		    a[i] = sc.next();
		}
		for(int i = 0; i < m; i++){
		    b[i] = sc.next();
		}
		
		// 計算
		String result = "No";
		for(int i = 0; i < n-m+1; i++){
		    for(int j = 0; j < n-m+1; j++){
		        boolean flg = true;
		        for(int k = 0; k < m; k++){
		            for(int l = 0; l < m; l++){
		                if(a[i+k].charAt(j+l) != b[k].charAt(l)){
		                    flg = false;
		                    break;
		                }
		            }
		            if(!flg) break;
		        }
		        if(flg) result = "Yes";
		    }
		}
		
		
		// 出力
		System.out.println(result);
	}
	
	public static class Scanner {
		private BufferedReader br; private StringTokenizer tok;
		public Scanner(InputStream is) throws IOException { br = new BufferedReader(new InputStreamReader(is));}
		private void getLine() throws IOException { while(!hasNext()) tok = new StringTokenizer(br.readLine());}
		private boolean hasNext() { return tok != null && tok.hasMoreTokens();}
		public String next() throws IOException { getLine(); return tok.nextToken();}
		public int nextInt() throws IOException { return Integer.parseInt(next());}
		public long nextLong() throws IOException { return Long.parseLong(next());}
		public double nextDouble() throws IOException { return Double.parseDouble(next());}
	}
}
//  [java]
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class Main {
    public static void main(String args[]) {
        FastReader sc = new FastReader();
        int n = sc.nextInt();
        int m = sc.nextInt();
        char[][] a = new char[n][n];
        char[][] b = new char[m][m];
        for (int i = 0; i < n; i++) {
            String str = sc.next();
            for (int j = 0; j < n; j++) {
                a[i][j] = str.charAt(j);
            }
        }
        for (int i = 0; i < m; i++) {
            String str = sc.next();
            for (int j = 0; j < m; j++) {
                b[i][j] = str.charAt(j);
            }
        }
        boolean flag = false;
        outer:
        for (int i = 0; i <= n - m; i++) {
            for (int j = 0; j <= n - m; j++) {
                boolean flagTemp = false;
                inner:
                for (int k = 0; k < m; k++) {
                    for (int l = 0; l < m; l++) {
                        if (a[i + k][j + l] != b[k][l]) {
                            break inner;
                        } else if (k == m - 1 && l == m - 1) {
                            flagTemp = true;
                        }
                    }
                }
                if (flagTemp) {
                    flag = true;
                    break outer;
                }
            }
        }
        if (flag) System.out.println("Yes");
        else System.out.println("No");
    }

    static class FastReader
    {
        BufferedReader br;
        StringTokenizer st;

        public FastReader()
        {
            br = new BufferedReader(new
                    InputStreamReader(System.in));
        }

        String next()
        {
            while (st == null || !st.hasMoreElements())
            {
                try
                {
                    st = new StringTokenizer(br.readLine());
                }
                catch (IOException e)
                {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        int nextInt()
        {
            return Integer.parseInt(next());
        }

        long nextLong()
        {
            return Long.parseLong(next());
        }

        double nextDouble()
        {
            return Double.parseDouble(next());
        }

        String nextLine()
        {
            String str = "";
            try
            {
                str = br.readLine();
            }
            catch (IOException e)
            {
                e.printStackTrace();
            }
            return str;
        }
    }
}
//  [java]
import java.util.*;
public class Main {

 public static void main(String[] args) {
  Scanner no=new Scanner(System.in);
  int n=no.nextInt();
  int m=no.nextInt();
  String s[]=new String[n];
  String s1[]=new String[m];
  for(int i=0;i<n;i++){
    s[i]=no.next();
  }
  for(int i=0;i<m;i++){
    s1[i]=no.next();
  }
 /* 3 2
#.#
.#.
#.#
#.
.#*/
  if(m>n){
    System.out.println("NO");
  }
  else{
   boolean t=true;
    int o=0;
    for(int i=0;i<n;i++){
     int g=i;
      for(int j=0;j<m;j++){
        if(g<n&&s[g].contains(s1[j])){
          o++;
          g++;
        }
        else{
          o=0;
        }
      }
      if(o==m){
        System.out.println("YES");
        t=false;
        break;
      }
    }
    if(t){
      System.out.println("NO");
    }
  }
 }

}
//  [java]
import java.util.*;
public class Main {

 public static void main(String[] args) {
  Scanner no=new Scanner(System.in);
  int n=no.nextInt();
  int m=no.nextInt();
  String s[]=new String[n];
  String s1[]=new String[m];
  for(int i=0;i<n;i++){
    s[i]=no.next();
  }
  for(int i=0;i<m;i++){
    s1[i]=no.next();
  }
 /* 3 2
#.#
.#.
#.#
#.
.#*/
  if(m>n){
    System.out.println("NO");
  }
  else{
   boolean t=true;
    int o=0;
    for(int i=0;i<n;i++){
     int g=i;
      for(int j=0;j<m;j++){
        if(s[g].contains(s1[j])){
          o++;
          g++;
        }
        else{
          o=0;
        }
      }
      if(o==m){
        System.out.println("YES");
        t=false;
        break;
      }
    }
    if(t){
      System.out.println("NO");
    }
  }
 }

}
//  [java]
import java.util.*;
import java.io.*;
public class Main{
    public static void main(String[] args){
		Scanner sc = new Scanner(System.in);
		PrintWriter ou = new PrintWriter(System.out);
		int n = Integer.parseInt(sc.next());
		int m = Integer.parseInt(sc.next());
		char[][] p = new char[n][n];
		char[][] q = new char[m][m];
		String s;
		for(int i = 0 ; i < n ; i++){
			s = sc.next();
			for(int j = 0 ; j < n ; j++) p[i][j] = s.charAt(j);
		}
		for(int i = 0 ; i < m ; i++){
			s = sc.next();
			for(int j = 0 ; j < m ; j++) q[i][j] = s.charAt(j);
		}
		sc.close();
		boolean fin = true;
		for(int i = 0 ; i < n - m && fin ; i++){
			for(int j = 0 ; j < n - m && fin ; j++){
				boolean eq = true;
				for(int ii = i ; ii < i + m ; ii++){
					for(int jj = j ; jj < j + m ; jj++){
						if(p[ii][jj] != q[ii - i][jj - j]) eq = false;
					}
				}
				if(eq) fin = false;
			}
		}
		if(fin) ou.println("No");
		else ou.println("Yes");
		ou.flush();
	}
}
//  [cpp]
#include <bits/stdc++.h>
using namespace std;
typedef pair<int,int> P;
typedef long long ll;
typedef long double ld;
const int inf=1e9+7;
const ll longinf=1LL<<60;
#define REP(i,m,n) for(int i=(int)(m) ; i < (int) (n) ; ++i )
#define rep(i,n) REP(i,0,n)
#define F first
#define S second
 
const int mx=200010;
const ll mod=1e9+7;


int main(){
  int n,m;
  cin >> n >> m;
  vector<string> a(n),b(m);
  rep(i,n){ cin>>a[i]; }
  rep(i,m){ cin>>b[i]; }
  
  rep(i,n-m+1){
    int cnt=0;
    auto pos = a[i].find(b[cnt]);
    bool flag=false;
    while(pos!=std::string::npos){
      flag=true;
      rep(j,m){
        if(a[i+j].substr(pos,m)!=b[j]){flag=false; break;}
      }
      if(flag){break;}
      pos = a[i].find(b[cnt],pos+b[cnt].length());
    }
    if(flag){ cout << "Yes" << endl; return 0; }
  }
  
  cout << "No" << endl;
  return 0;
}
//  [cpp]
#include <bits/stdc++.h>

#define all(v) v.begin(), v.end()
#define mp make_pair
#define EPS (int)1e-9
#define PI acos(-1)
#define endl '\n'
#define pb push_back
#define fi first
#define se second

using namespace std;
using ld = long double;
using ll = long long;
using vi = vector<int>;
using pii = pair<int, int>;

const int mod = 1000000007;


int main()
{
	ios_base::sync_with_stdio(0); cin.tie(0);
	int n, m;
	cin >> n >> m;

	vector<vector<char>> a(n, vector<char>(n));
	vector<vector<char>> b(m, vector<char>(m));
	char c;

	for(int i = 0; i < n; i++)
	{
		for(int j = 0; j < n; j++)
		{
			cin >> a[i][j];
		}
	}

	for(int i = 0; i < m; i++)
	{
		for(int j = 0; j < m; j++)
		{
			cin >> b[i][j];
		}
	}

	bool ans = false;


	for(int i = 0; i < n; i++)
	{
		for(int j = 0; j < n; j++)
		{
			if(i+m-1 >= n or j+m-1 >= n)
				continue;
			
			bool flag = true;

			for(int r = 0; r < m; r++)
			{
				for(int c = 0; c < m; c++)
				{
					if(a[i+r][j+c] != b[r][c])
					{
						flag = false;
						break;
					}
				}
				if(!flag)
					break;
			}

			if(flag)
				ans = true;
		}
	}

	if(ans)
		cout << "Yes" << endl;
	else
		cout << "No" << endl;


	return 0;	
}
//  [cpp]
#include <bits/stdc++.h>
using namespace std;

int main(){
    //入力
    int N,M;
    cin >> N >> M;

    vector<string> A(N);
    vector<string> B(M);

    //Aの入力
    for(int i=0;i<N;i++){
        cin >> A.at(i);
    }

    //Bの入力
    for(int i=0;i<M;i++){
        cin >> B.at(i);
    }

    for(int i=0;i<N-M+1;i++){
        for(int j=0;j<N-M+1;j++){
            bool ans=true;
            for(int k=0;k<M;k++){
                for(int l=0;l<M;l++){
                    if(A.at(i+k).at(j+l)!=B.at(k).at(l)){
                        ans=false;
                        break;
                    }
                }
                if(ans==false){
                    break;
                }
            }
            if(ans==true){
                cout << "Yes" << endl;
                return 0;
            }
        }
    }
    cout << "No" << endl;
    return 0;
}
//  [cpp]
#include<bits/stdc++.h>
#define dbug printf("I am here\n");
#define Fast ios_base::sync_with_stdio(false); cin.tie(0);
#define vs           v.size()
#define sot(v)       sort(v.begin(),v.end())
#define rev(v)       reverse(v.begin(),v.end())
#define yes          cout<<"Yes"<<endl
#define no           cout<<"No"<<endl
#define ii           pair<int, int>
#define int          long long
#define ull          unsigned long long
#define pb           push_back
#define mpp          make_pair
#define Okay         0
#define pi           3.14159

const int inf = 1e6;
const int cont = 1e18;
const int mod = 1e9+7;
using namespace std;

void solve(){
    int n, m;
    cin>>n>>m;
    vector<string>a(n), b(m);
    for(string &it:a)cin>>it;
    for(string &it:b)cin>>it;
    bool ans = false;
    for(int i=0; i<=n-m; i++){
        for(int j=0; j<=n-m; j++){
            bool ok = true;
            for(int k=0; k<m; k++){
                if(b[k] != a[k+i].substr(i, m)){
                    ok = false;
                    break;
                }
            }
            if(ok)ans = true;
        }
    }
    if(ans)yes;
    else no;
}

int32_t main() {
    Fast;

    solve();
    return Okay;
}