jiahuimbzuai/CoQuIR huggingface dataset:
//  [rust]
use std::io::*;
use std::str::FromStr;

//https://qiita.com/tubo28/items/e6076e9040da57368845
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")
}

//https://onlinejudge.u-aizu.ac.jp/solutions/problem/ALDS1_5_B/review/2709881/arsenic28/Rust
trait Joinable {
    fn join(self, sep: &str) -> String;
}

impl<U: ToString, T: Iterator<Item = U>> Joinable for T {
    fn join(self, sep: &str) -> String {
        self.map(|x| x.to_string()).collect::<Vec<_>>().join(sep)
    }
}

fn main() {
    let h: usize = read();
    let w: usize = read();
    let n: usize = read();
    let a: Vec<usize> = (0..n).map(|_| read()).collect();
    let mut grid: Vec<Vec<usize>> = vec![vec![0; w]; h];

    let mut color: Vec<usize> = Vec::new();
    for i in 0..n {
        for _ in 0..a[i] {
            color.push(i + 1);
        }
    }

    let mut k = 0;
    for i in 0..h {
        if i % 2 == 0 {
            for j in 0..w {
                grid[i][j] = color[k];
                k += 1;
            }
        } else {
            for j in (0..w).rev() {
                grid[i][j] = color[k];
                k += 1;
            }
        }
    }

    for i in 0..h {
        println!("{}", grid[i].iter().join(" "));
    }
}
//  [swift]
import Foundation
#if os(OSX) || os(iOS)
    import Darwin
#elseif os(Linux)
    import Glibc
#endif
var H = 0, W = 0, N = 0
withUnsafeMutablePointer(&H){withVaList([COpaquePointer($0)]){vscanf("%d",$0)}}
withUnsafeMutablePointer(&W){withVaList([COpaquePointer($0)]){vscanf("%d",$0)}}
withUnsafeMutablePointer(&N){withVaList([COpaquePointer($0)]){vscanf("%d",$0)}}
var a = [Int].init(count: N+1, repeatedValue: 0)
for i in 1...N {
    withUnsafeMutablePointer(&a[i]){withVaList([COpaquePointer($0)]){vscanf("%d",$0)}}
}
var reverse = false
var p = 1
var line = [String].init(count: W, repeatedValue: "")
for _ in 0..<H {
    var s = ""
    for j in 0..<W {
        if a[p] == 0 {
            p += 1
        }
        let lineCur: Int
        if reverse {
            lineCur = W-j-1
        } else {
            lineCur = j
        }
        line[lineCur] = p.description
        a[p] -= 1
    }
    print(line.joinWithSeparator(" "))
    reverse = !reverse
}
//  [typescript]
"use strict";

main(require("fs").readFileSync("/dev/stdin", "utf8"));

function main(input) {
  const [[h, w], [colorCount], fillCounts] = input.split("\n").map(s => s.split(" ").map(Number));

  // 1次元配列に格納
  let line = [];

  fillCounts.forEach((fillCount, i) => {
    const color = String(i + 1);
    line.push(...new Array(fillCount).fill(color));
  });

  // 偶数列を反転しつつ2次元配列に格納
  const box = (() => {
    const arr = [];
    const i = 0;
    while(line.length !== 0) {
      arr[i] = line.splice(0, w);
      if(i % 2 === 1) {
        arr[i].reverse();
      }
      i++;
    }
    return arr;
  })();

  const ans = box.map(e => e.join(" ")).join("\n"));
  console.log(ans);
}
//  [python]

import sys
import numpy as np
from collections import deque
from itertools import combinations
sys.setrecursionlimit(10**9)


def main():
    S = input()
    x = ""
    for i in range(len(S)):
        x += "x"

    print(x)



if __name__ == "__main__":
  main()
//  [python]
#
import sys
import math
import numpy as np
import itertools

# 文字列を一文字ずつのリストに代入 test は['t', 'e', 's', 't']
m = list(input())


for i in range(len(m)):
    print("x",end="")
print("")
//  [python]
import bisect
import numpy as np
import math
import itertools
def main():
    S = input()
    print("x" * len(S))


    return 0
if __name__ == '__main__':
    main()
//  [java]
import java.io.InputStream;
import java.io.PrintStream;
import java.util.Scanner;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

public class Main {

  public static void main(String[] args) {
    resolve(System.in, System.out);
  }

  static void resolve(InputStream is, PrintStream pw) {
    Scanner sc = new Scanner(is);
    String s = sc.next();
    pw.println(
      IntStream.range(0, s.length())
        .mapToObj(i -> "x")
        .collect(Collectors.joining("")));
  }
}
//  [java]
import java.util.Scanner;
import java.util.stream.IntStream;

public class Main {
	public static void main(String... args) {
		Scanner scan = new Scanner(System.in);
		String str = scan.next();

		IntStream.range(0, str.length()).forEach(x -> System.out.print("x"));
		scan.close();
	}
}
//  [cpp]
#include<bits/stdc++.h>
using namespace std;


#define  SZ(items) (int)items.size()
#define  CLR(a)  memset(a,0,sizeof(a))
#define  SET(a)  memset(a,-1,sizeof(a))
#define  nl "\n";

int dx[] = { 0,0,1,-1,-1,-1,1,1 };
int dy[] = { 1,-1,0,0,-1,1,1,-1 };



template <class T> inline T biton(T n, T pos)
{
    return n | ((T)1 << pos);
}
template <class T> inline T bitoff(T n, T pos)
{
    return n & ~((T)1 << pos);
}
template <class T> inline T ison(T n, T pos)
{
    return (bool)(n & ((T)1 << pos));
}
template <class T> inline T gcd(T a, T b)
{
    while (b)
    {
        a = a % b;
        swap(a, b);
    }
    return a;
}
template <class T> inline T bigmod(T p, T e, T m)
{
    T ret = 1;
    for (; e > 0; e >>= 1)
    {
        if (e & 1)
            ret = (ret * p) % m;
        p = (p * p) % m;
    }
    return (T)ret;
};

#ifdef DEBUG
#define debug(...) __f(#__VA_ARGS__, __VA_ARGS__)
template < typename Arg1 >
void __f(const char* name, Arg1&& arg1)
{
    cerr << name << " is " << arg1 << std::endl;
}
template < typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args)
{
    const char* comma = strchr(names + 1, ',');
    cerr.write(names, comma - names) << " is " << arg1 << " | ";
    __f(comma + 1, args...);
}
#else
#define debug(...)
#endif


void solve()
{
    string s;
    cin>>s;

   cout<<string(s.size(),'x')<<endl;
}

int main()
{
    ios_base::sync_with_stdio(false);
    cout.setf(ios::fixed);
    cout.precision(10);
    cout.tie(nullptr);
    cin.tie(nullptr);

    int t = 1;

    while (t--)
    {
        solve();
    }

    return 0;
}
//  [cpp]
#include<bits/stdc++.h>
typedef long long ll;
#define dbg          cout<<"Freak"<<endl;
#define dbgg(i)      cout<<i<<endl;
#define N            1e9+7
#define pb           push_back
using namespace std;
ll t;
ll arr[200005];
map<string,string>np;
vector<ll>v,v1;
int main()
{
    ll a,b,c,d,e,f=0,g,i,j,cnt;
    string s1,s2,s3;
    cin>>s1;
    for(i=0;i<s1.size();i++)cout<<'x';
    cout<<endl;

}
//  [c]
#include<stdio.h>
#include<string.h>
int main(){
	char S[256];
	int len;

	scanf("%s", S);
	len = strlen(S);

	char output[256];
	int i;
	for (i = 0; i < len; i++){
		output[i] = 'x';
	}
	output[i] = '\0';

	printf("%s\n", output);

	return 0;
}
//  [c]
main(){system("sed s/[a-z]/x/g");}
//  [c]
#include<stdio.h>
#include<string.h>
int main()
{char s1[100];
scanf("%s",s1);
int l=strlen(s1);
for(int i=0;i<l;i++)
printf("x");
return 0;
}
//  [javascript]
"use strict";
    
const main = arg => {
    arg = arg.trim().split("\n");
    const S = arg[0].split("").map(n=>"x");
    
    console.log(S.join(""));
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [javascript]
'use strict'
const main = arg => {
	const input = arg.trim().split("\n");
	let S = input[0].split(' ')[0]
	console.log(S.replace(/./g, 'x'))
}   
main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [javascript]
"use strict";
var input=require("fs").readFileSync("/dev/stdin","utf8");
var cin=input.split(/ |\n/),cid=0;
function next(a){return a?cin[cid++]:+cin[cid++];}
function nexts(n,a){return a?cin.slice(cid,cid+=n):cin.slice(cid,cid+=n).map(a=>+a);}
function nextm(h,w,a){var r=[],i=0;if(a)for(;i<h;i++)r.push(cin.slice(cid,cid+=w));else for(;i<h;i++)r.push(cin.slice(cid,cid+=w).map(a=>+a));return r;}
function xArray(v){var a=arguments,l=a.length,r="Array(a["+--l+"]).fill().map(x=>{return "+v+";})";while(--l)r="Array(a["+l+"]).fill().map(x=>"+r+")";return eval(r);}

var myOut = main();
if(myOut !== undefined)console.log(myOut);
function main(){
  var s = next(1);
  return Array(s.length).fill("x").join("");
}
//  [go]
package main

import "fmt"

func main() {
	var s string
	fmt.Scan(&s)
	for i:=0; i<len(s); i++{
		fmt.Print("x")
	}
	fmt.Print("\n")
}
//  [ruby]
puts "x"*gets.chomp.length
//  [ruby]
puts 'x'*gets.chomp.size
//  [ruby]
s=gets
i=0
while s[i]!="\n"
  s[i]="x"
  i+=1
end
puts s
//  [rust]
use std::io::{stdin, Read, StdinLock};
use std::str::FromStr;

// reference: http://ir5.hatenablog.com/entry/20171209/1512821837

struct Scanner<'a> {
    cin: StdinLock<'a>,
}
 
impl<'a> Scanner<'a> {
    fn new(cin: StdinLock<'a>) -> Scanner<'a> {
        Scanner { cin: cin }
    }
 
    fn read1<T: FromStr>(&mut self) -> Option<T> {
        let token = self.cin.by_ref().bytes().map(|c| c.unwrap() as char)
            .skip_while(|c| c.is_whitespace())
            .take_while(|c| !c.is_whitespace())
            .collect::<String>();
        token.parse::<T>().ok()
    }
 
    fn read<T: FromStr>(&mut self) -> T {
        self.read1().unwrap()
    }
}

use std::mem;

fn main() {
    let cin = stdin();
    let cin = cin.lock();
    let mut sc = Scanner::new(cin);

    let s: String = sc.read();
    println!("{}", "x".repeat(s.len()));
}
//  [swift]
import Foundation

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

let x = split[0]
let length = x.count
var ans = ""
for i in 0..<length{
    ans += "x"
}
print(ans)
//  [swift]
import Foundation
 
let input_line: String = readLine()!
let split: [String] = input_line.components(separatedBy: " ")
 
let S = split[0]

let count = S.count

var ans = ""

for i in 0..<count{
    ans += "x"
}

print(ans)
//  [swift]
import Foundation
let S = readLine()!
for _ in 0 ..< S.characters.count {
  print("x" , terminator: "")
}
//  [typescript]
import * as fs from 'fs';

const input = fs.readFileSync("/dev/stdin", "utf8").split("\n")[0]
console.log('x'.repeat(input.length))
//  [typescript]
class AtCoder {
  // 入力系
  input=require('fs').readFileSync('/dev/stdin','utf8').split(/[\s]/);
  input_i=-1;
  n(){
    this.input_i++;
    return Number(this.input[this.input_i]);
  }
  nn(n):number[]{
    const a=[];
    for(let i=0;i<n;i++){
      a.push(this.n());
    }
    return a;
  }
  s(){
    this.input_i++;
    return String(this.input[this.input_i]);
  }
  ss(n):string[]{
    const a=[];
    for(let i=0;i<n;i++){
      a.push(this.s());
    }
    return a;
  }

  // コンソール
  o(...a:any){
    console.log(...a);
  }

  // Math
  abs(a:number){
    return Math.abs(a);
  }
  min(...a:number[]){
    return Math.min(...a);
  }
  max(...a:number[]){
    return Math.max(...a);
  }
  floor(a:number){
    return Math.floor(a);
  }
  ceil(a:number){
    return Math.ceil(a);
  }
  round(a:number){
    return Math.round(a);
  }

  // ソート
  asc(ar:number[]){
    const t=[...ar];
    ar.sort((a,b)=>{return a-b});
  }
  desc(ar:number[]){
    const t=[...ar];
    ar.sort((a,b)=>{return b-a});
  }

  // 自作
  gcd(...arr):number{
    for(let i=0;i<arr.length-1;i++){
      let [x,y]=[arr[i],arr[i+1]];
      while(y){
        [x,y]=[y,x%y];
      }
      arr[i+1]=x;
    }
    return arr[arr.length-1];
  };
  lcm(...arr):number{
    for(let i=0;i<arr.length-1;i++){
      let [x,y]=[arr[i],arr[i+1]];
      while(y){
        [x,y]=[y,x%y];
      }
      arr[i+1]=arr[i]*arr[i+1]/x;
    }
    return arr[arr.length-1];
  };
  isPrime(n:number):boolean{
    if(n < 2) return false;
    const suq=Math.sqrt(n);
    for(let i=2;i<=suq;i++){
      if(n%i==0){
        return false;
      }
    }return true;
  };
  deduplicate(a:any[]):any[]{
    return Array.from(new Set(a));
  };
}

const o = new AtCoder()
let s=o.s()
o.o('x'.repeat(s.length))
//  [typescript]
function Main(input) {
    // const lines = input.split("\n");
    
    console.log(input.replace(/./g, 'x'));
}

Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [python]
N = int(input())
MOD = 10**9+7
if N == 1:
    print(0)
    exit()
ans = 1
dp = [[8, 1, 1, 0] for _ in range(N)]
for i in range(1, N):
    dp[i][0] = dp[i-1][0]*8 % MOD
    dp[i][1] = dp[i-1][1]*9 % MOD+dp[i-1][0]
    dp[i][2] = dp[i-1][1]*9 % MOD+dp[i-1][0]
    dp[i][3] = dp[i-1][3]*10 % MOD+dp[i-1][1]+dp[i-1][1]
print(dp[-1][-1] % MOD)
//  [python]
import numpy as np
from numba import njit

MOD = 1000000007

@njit
def solve(dp, N):
    dp[0, 0] = 8
    dp[0, 1] = 2
    dp[0, 2] = 0
    for i in range(1, N):
        dp[i, 0] = dp[i - 1, 0] * 8 % MOD
        dp[i, 1] = (dp[i - 1, 0] * 2 + dp[i - 1, 1] * 9) % MOD
        dp[i, 2] = (dp[i - 1, 1] + dp[i - 1, 2] * 10) % MOD
    return dp[N - 1, 2]


N = int(input())
dp = np.empty((N, 3), dtype=np.int32)
ans = solve(dp, N)
print(ans)
//  [python]
n = int(input())
if n<2:
    print(0)
    exit()
k=2
mod=10**9+7
framod=[1]
def framod_calc(n, mod, a=1):
    for i in range(1,n+1):
        a=a * i % mod
        framod.append(a)

def permmod(n, k, mod):
    if n<k: return 0
    a=framod[n]
    c=framod[n-k]
    return (a * pow(c, mod-2, mod)) % mod

def combmod(n, k, mod):
    if n<k: return 0
    a=framod[n]
    b=framod[k]
    c=framod[n-k]
    return (a * pow(b, mod-2, mod) * pow(c, mod-2, mod)) % mod

framod_calc(n+1, mod)
ans=0

for i in range(2, n+1):
    ans+=(combmod(n,i,mod)*(pow(2, i, mod)-2))*pow(8, n-i, mod)
    ans%=mod

print(ans)
//  [java]
import java.math.BigInteger;
import java.util.Scanner;

public class Main {


    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();

        BigInteger a = BigInteger.TEN.pow(n);
        BigInteger b = BigInteger.valueOf(9).pow(n).multiply(BigInteger.valueOf(2));
        BigInteger c = BigInteger.valueOf(8).pow(n);
        BigInteger d = BigInteger.TEN.pow(9).add(BigInteger.valueOf(7));

        System.out.println(
                c.subtract(b).add(a).remainder(d)
        );
    }
}
//  [java]
import java.util.*;
 
public class Main {
	public static void main(String args[] ) throws Exception {

		Scanner sc = new Scanner(System.in);
		int n = Integer.valueOf ( sc.nextLine().trim() ) ;

		List<Boolean> list0 = Arrays.asList( false , false ) ;
		
		int mod = 1000000007 ;
		Map<List<Boolean>,Long> map = new HashMap<>() ; 
		map.put( list0 , 1L ) ;
		for ( int j=0 ; j<n ; j++ ) {
			Map<List<Boolean>,Long> map2 = new HashMap<>() ; 
			for ( List<Boolean> list  : map.keySet() ) {

				List<Boolean> list1 = Arrays.asList ( true , list.get(1).booleanValue() ) ;
				long d = map2.getOrDefault( list1 , 0L )  + map.get( list ).longValue() ;
				map2.put( list1 , d % mod ) ;

				list1 = Arrays.asList ( list.get(0).booleanValue() , true ) ;
				d = map2.getOrDefault( list1 , 0L )  + map.get( list ).longValue() ;
				map2.put( list1 , d % mod ) ;

				list1 = list ;
				d = map2.getOrDefault( list1 , 0L )  + map.get( list ).longValue() * 8 ;
				map2.put( list1 , d % mod ) ;

			}
			map = map2 ;
		}
		List<Boolean> list2 = Arrays.asList( true , true ) ;
		long d = map.getOrDefault( list2 , 0L ) ;
		System.out.println( d ) ;
	}
}
//  [cpp]
/*input
1
1

*/
 
/*
                                                    ______________
                                                          |       )
                                                          |   )   /
                                                          |______/
                                                    |     |      \
                                                    |     |   )   \
                                                    |_____|_______)
 
*/
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <cmath>
#include <vector>
#include <set>
#include <map>
#include <unordered_set>
#include <unordered_map>
#include <queue>
#include <ctime>
#include <cassert>
#include <complex>
#include <string>
#include <cstring>
#include <chrono>
#include <random>
#include <queue>
#include <bitset>
#include <iomanip>
#include <fstream>
#include <stack>

using namespace std;
 
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> PII;
typedef pair<ll , ll> PLL;
typedef long double ld;
 
#define pb push_back
#define all(c) c.begin(),c.end()
#define allr(c) c.rbegin(),c.rend()
int mod = 1000000007;
const int inf = 1034567891;
const ll LL_INF = 1234567890123456789ll;
#define PI 3.14159265
#define endl '\n'
#define F first
#define S second
#define debug(x) cout << #x << " = " << x << endl;
#define TRACE
 
#ifdef TRACE
#define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)
template <typename Arg1>
void __f(const char* name, Arg1&& arg1){
  cout << name << " : " << arg1 << endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args){
  const char* comma = strchr(names + 1, ',');cout.write(names, comma - names) << " : " << arg1<<" | ";__f(comma+1, args...);
}
#else
#define trace(...)
#endif
 
#define out(container) for (auto it : container) cout << it << " "; cout << endl;
 
 
template < typename T > T GCD(T a, T b)            { ll t; while(a) { t = a; a = b % a; b = t; } return b; }
template < typename T > string toString(T a)       { return to_string(a); }
template < typename T > void toInt(string s, T &x) { stringstream str(s); str >> x;}
inline int add(int x, int y){ x += y; if(x >= mod) x -= mod; return x;}
inline int sub(int x, int y){ x -= y; if(x < 0) x += mod; return x;}
inline int mul(int x, int y){ return (x * 1ll * y) % mod;}
inline int powr(int a, ll b){
  int x = 1 % mod;
  while(b){
    if(b & 1) x = mul(x, a);
    a = mul(a, a);
    b >>= 1;
  }
  return x;
}
inline int inv(int a){ return powr(a, mod - 2);}

int n;

int dp[1000001][10][2][2];

int fun(int ind, int v, int f1, int f2) {
  if (ind == n) {
    return (f1 && f2);
  }
  if (~dp[ind][v][f1][f2]) return dp[ind][v][f1][f2];
  int ans = 0;
  for (int i = 0; i <= 9; i++) {
    ans = add(ans, fun(ind + 1, i, (f1 || (i == 0)), (f2 || (i == 9))));
  }
  return dp[ind][v][f1][f2] = ans;
}

int main()
{
  ios_base::sync_with_stdio(false);
  cin.tie(NULL);
  
  cin >> n;
  memset(dp, -1, sizeof(dp));
  int ans = fun(0, 0, 0, 0);
  cout << ans << endl;  

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

#define ll long long

void swap (int *x, int *y) {
  int temp;

  temp = *x;
  *x = *y;
  *y = temp;

  return;
}


int gcd(int a, int b){
  int c;

  while (b > 0){
    c = a % b;
    a = b;
    b = c;
  }

  return a;
}

int upll(const void*a, const void*b){
  return*(ll*)a<*(ll*)b?-1:*(ll*)a>*(ll*)b?1:0;
}

int downll(const void*a, const void*b){
  return*(ll*)a<*(ll*)b?1:*(ll*)a>*(ll*)b?-1:0;
}

void sortup(ll*a,int n){
  qsort(a,n,sizeof(ll),upll);
}

void sortdown(ll*a,int n){
  qsort(a,n,sizeof(ll),downll);
}

long int modpow(long int a,long int n,long int mod){
  long int ans=1;
  while(n>0){
    if(n & 1){
      ans=ans*a%mod;
    }
    a=a*a%mod;
    n/=2;
  }
  return ans;
}

long int modinv(long int a,long int mod){
  return modpow(a,mod-2,mod);
}

int max(int a,int b){
  if(a<b){
    return b;
  }
  else{
    return a;
  }
}

int min(int a,int b){
  if(a<b){
    return a;
  }
  else{
    return b;
  }
}

void chmax(int *a,int b){
  if(*a < b){
    *a = b;
  }

  return;
}

void chmin(int *a,int b){
  if(*a > b){
    *a =b;
  }

  return;
}


/****************************************\
| Thank you for viewing my code:)        |
| Written by RedSpica a.k.a. RanseMirage |
| Twitter:@asakaakasaka                  | 
\****************************************/

int main(void){
  int MOD=1e9+7;

  long int n;
  scanf("%ld",&n);

  long int ans=0;

  long int kai[2000000];
  long int rekai[2000000];
  
  kai[0]=1;
  kai[1]=1;
  for(int i=2;i<2000000;i++){
    kai[i]=kai[i-1]*i;
    kai[i]%=MOD;
  }

  
  rekai[0]=1;
  rekai[1]=1;
  for(int i=2;i<2000000;i++){
    rekai[i]=rekai[i-1]*modinv(i,MOD);
    rekai[i]%=MOD;
  }

  for(long int i=2;i<=n;i++){
    long int a=i;//0or9の個数
    long int b=n-i;//それ以外の個数

    long int now=1;
    now=modpow(2,a,MOD)-2+MOD;//aのところの組合せ
    now%=MOD;

    now*=modpow(8,b,MOD);//b
    now%=MOD;

    now*=kai[n];
    now%=MOD;

    now*=rekai[a];
    now%=MOD;

    now*=rekai[b];
    now%=MOD;

    ans+=now;
    ans%=MOD;
  }

  printf("%ld\n",ans);

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

#define MOD_BY 1000000007

int add(int a, int b) {
	return a + b - MOD_BY * (a + b >= MOD_BY);
}

int N;

int memo[1234567][2][2];

int kugyu(int pos, int zero, int nine) {
	int answer = 0;
	int i;
	if (pos >= N) return zero && nine;
	if (memo[pos][zero][nine]) return ~memo[pos][zero][nine];
	for (i = 0; i <= 9; i++) {
		answer = add(answer, kugyu(pos + 1, zero || i == 0, nine || i == 9));
	}
	return ~(memo[pos][zero][nine] = ~answer);
}

int main(void) {
	if (scanf("%d", &N) != 1) return 1;
	printf("%d\n", kugyu(0, 0, 0));
	return 0;
}
//  [c]
#include <stdio.h>
typedef long long ll;
ll mod=1000000007;

ll powmod(ll x,ll y){
  ll res=1;
  for(ll i=0;i<y;i++){
    res=res*x%mod;
  }
  return res;

}


int main(void){
  ll n;
  scanf("%lld",&n);
  ll ans=powmod(10,n)-powmod(9,n)-powmod(9,n)+powmod(8,n);
  ans%=mod;
  ans=(ans+mod)%mod;
  printf("%lld\n",ans);
  return 0;
}
//  [javascript]
'use script';

{
function Main(input) {
 	const N = input;
	const b = BigInt(1000000000+7);

	function x(m){

		let d = BigInt(1);

		for(i=0; i<N; i++){
				d *= BigInt(m)%b;
				d %= b;
		}
		
	return(d)
	}

	let ans = (x(10)-x(9))+(x(10)-x(9))-(x(10)-x(8));
  	
  	for(i=0; i<3; i++){
     if(ans<BigInt(0)){
        ans += b;
      }
    }
  
  	ans %= b;     
  	console.log(ans.toString());
  
	}

Main(require("fs").readFileSync("/dev/stdin", "utf8"));

}
//  [javascript]
const mod = BigInt(10**9 + 7)

const pow = (x, n) => {
  let r = 1n

  for (let i=0; i<n; i++)
    r = r * x % mod

  return r
}

const main = (input) => {
  const n = BigInt(input.trim())

  let a = pow(10n, n)
  let bc = pow(9n, n)
  let d = pow(8n, n)

  const ans = (a-bc-bc+d) % mod
  return console.log(`${(ans + mod) % mod}`)
}

process.env.MYTEST
  ? (process.env.MYTEST === 'test' ? test() : main(require('fs').readFileSync('dev/stdin', 'utf8')))
  : main(require('fs').readFileSync('/dev/stdin', 'utf8'))
//  [javascript]
const mod = 10 ** 9 +7;
function pow (x,y){
    var r = 1;
    for (var i = 0;i < y;  i++) {
        r = r * x % mod;
    }    
    return r;
}
function Main(input) {
    var num = parseInt(input);
    var r = pow(10, num) - (pow(9, num) * 2) + pow(8, num)
    r = r %  mod;
    r = (r + mod ) %  mod;
    console.log(r)
}
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [go]
package main

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

func main() {
	N := nextInt()

	// dp[i][j] は i個の数列で状態jである個数
	// j == 0 0も9も含まない

	dp := make([][]mint, N+10)
	for i := 0; i < len(dp); i++ {
		dp[i] = make([]mint, 4)
	}
	dp[0][0] = 1
	n10 := mint(10)
	n9 := mint(9)
	n8 := mint(8)

	for i := 1; i <= N; i++ {
		dp[i][0] = dp[i-1][0].mul(n8)
		dp[i][1] = dp[i-1][1].mul(n9).add(dp[i-1][0])
		dp[i][2] = dp[i-1][2].mul(n9).add(dp[i-1][0])
		dp[i][3] = dp[i-1][3].mul(n10).add(dp[i-1][1]).add(dp[i-1][2])
	}

	fmt.Println(dp[N][3])
}

type mint int64

var mod = mint(1e9 + 7)

// add は a + bを返します
func (a mint) add(b mint) mint {
	return (a + b) % mod
}

// sub は a - bを返します
func (a mint) sub(b mint) mint {
	return (a - b + mod) % mod
}

// mul は a * bを返します
func (a mint) mul(b mint) mint {
	return (a * (b % mod)) % mod
}

// div は a/bを返します
func (a mint) div(b mint) mint {
	return a.mul(b.inv())
}

// inv は aの逆元を返します
func (a mint) inv() mint {
	// 拡張ユークリッドの互除法
	b := mod
	u := mint(1)
	v := mint(0)
	for b > 0 {
		t := a / b
		a -= t * b
		a, b = b, a
		u -= t * v
		u, v = v, u
	}
	return (u + mod) % mod
}

// pow は a ^ bを返します
func (a mint) pow(b mint) mint {
	ans := mint(1)

	for b != 0 {
		if b&1 == 1 {
			ans = ans.mul(a)
		}
		a = a.mul(a)
		b = b >> 1
	}
	return ans
}

var stdin = initStdin()

func initStdin() *bufio.Scanner {
	bufsize := 1 * 1024 * 1024 // 1 MB
	var stdin = bufio.NewScanner(os.Stdin)
	stdin.Buffer(make([]byte, bufsize), bufsize)
	stdin.Split(bufio.ScanWords)
	return stdin
}

func nextString() string {
	stdin.Scan()
	return stdin.Text()
}

func nextBytes() []byte {
	stdin.Scan()
	return stdin.Bytes()
}

func nextInt() int {
	i, _ := strconv.Atoi(nextString())
	return i
}

func nextInt64() int64 {
	i, _ := strconv.ParseInt(nextString(), 10, 64)
	return i
}

func debug(args ...interface{}) {
	fmt.Fprintln(os.Stderr, args...)
}
//  [go]
package main

import "fmt"

const M = 1000000007

func main() {
	var n int
	fmt.Scan(&n)

	fmt.Println(solve(n))
}

func solve(n int) int64 {
	dp := make([][]int64, n+1)

	for i := 0; i <= n; i++ {
		dp[i] = make([]int64, 4)
	}

	for i := 0; i < 4; i++ {
		dp[0][0] = 1
	}

	for i := 1; i <= n; i++ {
		// put 0
		dp[i][1] = (dp[i][1] + dp[i-1][0] + dp[i-1][1]) % M
		dp[i][3] = (dp[i][3] + dp[i-1][3] + dp[i-1][2]) % M

		// put 9
		dp[i][2] = (dp[i][2] + dp[i-1][2] + dp[i-1][0]) % M
		dp[i][3] = (dp[i][3] + dp[i-1][3] + dp[i-1][1]) % M

		for j := 1; j < 9; j++ {
			for k := 0; k < 4; k++ {
				dp[i][k] = (dp[i][k] + dp[i-1][k]) % M
			}
		}
	}

	return dp[n][3]
}
//  [ruby]
# 桁DP
MOD = 10 ** 9 + 7
length = gets.to_i
# dp[上から i 桁まで][0 を使ったかどうか][9 を使ったかどうか]の出現回数
dp = (length + 1).times.map { 2.times.map { Array.new(2, 0) } }
# 初期化
# dp[0 桁目まで][0 は使っていない][9 は使っていない]の出現回数は 1
dp[0][0][0] = 1

# 桁数分ループする（i は遷移元の桁）
length.times do |i|
  dp_current = dp[i]
  # 最適化のため、事前に 1 行分だけ参照渡しをする
  # dp_next と dp[i + 1] の object_id は同じ
  dp_next = dp[i + 1]
  nonzero_nonnine = dp_current[0][0]
  nonzero_nine = dp_current[0][1]
  zero_nonnine = dp_current[1][0]
  zero_nine = dp_current[1][1]
  dp_next_0 = dp_next[0]
  dp_next_1 = dp_next[1]
  dp_next_0[0] += nonzero_nonnine * 8
  dp_next_0[1] += nonzero_nonnine + nonzero_nine * 9
  dp_next_1[0] += nonzero_nonnine + zero_nonnine * 9
  dp_next_1[1] += nonzero_nine + zero_nonnine + zero_nine * 10
  dp_next_0[0] %= MOD
  dp_next_0[1] %= MOD
  dp_next_1[0] %= MOD
  dp_next_1[1] %= MOD
end

puts dp.last.last.last % MOD
//  [ruby]
class Combinator
  MAX = 1100000 # nCkの最大のnより大きいこと。MODより小さいこと。
  MOD = 1000000007

  def initialize
    @fac = Array.new(MAX)
    @fac[0] = 1
    @fac[1] = 1
    @finv = Array.new(MAX)
    @finv[0] = 1
    @finv[1] = 1
    @inv = Array.new(MAX)
    @inv[1] = 1
    (2..(MAX-1)).each do |i|
      @fac[i] = @fac[i-1]*i%MOD
      @inv[i] = MOD-@inv[MOD%i]*(MOD/i)%MOD
      @finv[i] = @finv[i-1]*@inv[i]%MOD
    end
  end

  def call(all, select)
    return 0 if all < select
    return 0 if all < 0||select < 0
    @fac[all]*(@finv[select]*@finv[all-select]%MOD)%MOD
  end
end
@combinator = Combinator.new

n = gets.to_i
if n < 2
  puts 0
  exit 0
elsif n == 2
  puts 2
  exit 0
end

mod = 1000000007
sum = 0
(2..n).each do |i|
  sum += ((((2.pow(i, mod) - 2) % mod) * 8.pow(n-i, mod)) % mod) * @combinator.call(n, i)
  sum %= mod
end
puts sum
//  [ruby]
MOD = 1_000_000_007
n = gets.to_i

dp = Array.new(n + 1) { Array.new(2) { Array.new(2, 0) }}
dp[0][0][0] = 1

n.times do |i|
  dp[i+1][0][0] = (dp[i][0][0] * 8) % MOD
  dp[i+1][0][1] = (dp[i][0][0] + dp[i][0][1] * 9) % MOD
  dp[i+1][1][0] = (dp[i][0][0] + dp[i][1][0] * 9) % MOD
  dp[i+1][1][1] = (dp[i][1][0] + dp[i][0][1] + dp[i][1][1] * 10) % MOD
end

p dp[n][1][1]
//  [rust]
use proconio::input;

fn main() {
    input! {
        n: usize,
    };
    let mut dp = vec![vec![vec![0_i64; 2]; 2]; n + 1];
    dp[0][0][0] = 1;
    for i in 0..n {
        for j in 0..2 {
            for k in 0..2 {
                for d in 0..=9 {
                    let j_next = if j == 1 || d == 0 { 1 } else { 0 };
                    let k_next = if k == 1 || d == 9 { 1 } else { 0 };
                    dp[i + 1][j_next][k_next] += dp[i][j][k];
                    dp[i + 1][j_next][k_next] %= 1_000_000_007;
                }
            }
        }
    }
    let ans = dp[n][1][1];
    println!("{}", ans);
}
//  [swift]
let N = Int(readLine()!)!
let mod = 1000000007
var dp: [[Int]] = .init(repeating: .init(repeating: 0, count: 4), count: N + 1)
dp[0][2] = 1
for n in 0..<N {
  for k in 0..<4 {
    for m in 0..<10 {
      let newState: Int
      if k == 2 && m == 0 {
        newState = 0
      } else if k == 2 && m == 1 {
        newState = 1
      } else if (k == 0 && m == 9) || (k == 1 && m == 0) {
        newState = 3
      } else {
        newState = k
      }
      dp[n+1][newState] += dp[n][k]
      dp[n+1][newState] %= mod
    }
  }
}
print(dp[N][3])
//  [swift]
import Foundation

let divider = 1000000007

extension Int {
    func pow(_ x: Int) -> Int {
        if x == 0 {
            return 1
        } else {
            return self * self.pow(x - 1) % divider
        }
    }
}

let n = Int(readLine()!)!
let result = (10.pow(n) - 9.pow(n) - 9.pow(n) + 8.pow(n)) % divider
print(result < 0 ? result + divider : result)
//  [typescript]
import * as fs from 'fs';
// main
function main(input: string[]) {
    // param
    let n: number = 0;
    let ans: number = 0;
    // init
    n = Number(input.shift());
    // solve
    let a0 = 1n;
    let an = 8n;
    let a9 = 1n;
    let a09 = 0n;
    for (let nx = 1; nx < n; nx++) {
        let bn = an * 8n;
        let b0 = a0 * 9n + an * 1n;
        let b9 = a9 * 9n + an * 1n;
        let b09 = a09 * 10n + a0 * 1n + a9 * 1n;
        an = bn % 1000000007n;
        a0 = b0 % 1000000007n;
        a9 = b9 % 1000000007n;
        a09 = b09 % 1000000007n;
    }
    ans = Number(a09);
    // answer
    console.log(ans);
}
// entrypoint
function entrypoint() {
    try {
        // linux
        let input = fs.readFileSync("/dev/stdin", "utf8").trim().split("\n");
        console.debug = function () { };
        main(input);
    }
    catch (ex) {
        // windows
        const lines: string[] = [];
        // @ts-ignore
        const reader = require('readline').createInterface({
            // @ts-ignore
            input: process.stdin,
            // @ts-ignore
            output: process.stdout
        });
        reader.on('line', function (line: string) {
            lines.push(line);
        });
        reader.on('close', function () {
            let input = lines;
            main(input);
        });
    }
}
entrypoint();
//  [typescript]
var main = (input: string) => {
    const n: number = parseInt(input);

    let ans = powmod(10, n) - powmod(9, n) - powmod(9, n) + powmod(8, n);
    ans = ans % mod;
    ans = (ans + mod) % mod;
    console.log(ans);
}

let powmod = (radix: number, index: number) {
    let val: number = 1;
    for (let i: number = 0; i < index; i++) {
        val = val * radix % mod;
    }
    return val;
}

const mod = 1000000007;

main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [typescript]
import * as fs from 'fs';
// main
function main(input: string[]) {
    // param
    let n: number = 0;
    let ans: number = 0;
    // init
    n = Number(input.shift());
    // solve
    let a0 = 1;
    let an = 8;
    let a9 = 1;
    let a09 = 0;
    for (let nx = 1; nx < n; nx++) {
        let bn = an * 8;
        let b0 = a0 * 9 + an * 1;
        let b9 = a9 * 9 + an * 1;
        let b09 = a09 * 10 + a0 * 1 + a9 * 1;
        an = bn % 1000000007;
        a0 = b0 % 1000000007;
        a9 = b9 % 1000000007;
        a09 = b09 % 1000000007;
    }
    ans = Number(a09);
    // answer
    console.log(ans);
}
// entrypoint
function entrypoint() {
    try {
        // linux
        let input = fs.readFileSync("/dev/stdin", "utf8").trim().split("\n");
        console.debug = function () { };
        main(input);
    }
    catch (ex) {
        // windows
        const lines: string[] = [];
        // @ts-ignore
        const reader = require('readline').createInterface({
            // @ts-ignore
            input: process.stdin,
            // @ts-ignore
            output: process.stdout
        });
        reader.on('line', function (line: string) {
            lines.push(line);
        });
        reader.on('close', function () {
            let input = lines;
            main(input);
        });
    }
}
entrypoint();
//  [python]
# coding: utf-8
A, B = map(int, input().split())
print(['Yes', 'No'][A % 2 == 0 or B % 2 == 0])
//  [python]
A, B = map(int, input().split())
print('Yes' if A%2==1 and B%2==1 else 'No')
//  [python]
def abc333(A: int, B: int)->bool:
    return (A == 1 or A == 3) and (B == 1 or B == 3)


if __name__ == "__main__":
    A, B = map(int, input().split())
    yes = abc333(A, B)
    print('Yes' if yes else 'No')
//  [python]
import numpy as np
import math

# K = int(input())
# A, B = map(int, input().split())
# A = list(map(int, input().split()))

A, B = map(int, input().split())

if A == 2 or B == 2:
    print('No')
else:
    print('Yes')
//  [python]
a,b = map(int, raw_input().split(' '))
print 'Yes' if (a * b) % 2 else 'No'
//  [python]
#!/usr/bin/env python3
# -*- coding: utf-8 -*-

import array
from bisect import *
from collections import *
import fractions
import heapq 
from itertools import *
import math
import random
import re
import string
import sys

A, B = map(int, input().split())
if (A * B) % 2:
    print('Yes')
else:
    print('No')
//  [java]
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class Main {
  private static class FastScanner {
    private BufferedReader reader = null;
    private StringTokenizer tokenizer = null;

    public FastScanner(InputStream in) {
      reader = new BufferedReader(new InputStreamReader(in));
      tokenizer = null;
    }

    public String next() {
      if (tokenizer == null || !tokenizer.hasMoreTokens()) {
        try {
          tokenizer = new StringTokenizer(reader.readLine());
        } catch (IOException e) {
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }

    public String nextLine() {
      if (tokenizer == null || !tokenizer.hasMoreTokens()) {
        try {
          return reader.readLine();
        } catch (IOException e) {
          throw new RuntimeException(e);
        }
      }

      return tokenizer.nextToken("\n");
    }

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

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

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

    public int[] nextIntArray(int n) {
      int[] a = new int[n];
      for (int i = 0; i < n; i++)
        a[i] = nextInt();
      return a;
    }

    public long[] nextLongArray(int n) {
      long[] a = new long[n];
      for (int i = 0; i < n; i++)
        a[i] = nextLong();
      return a;
    }
  }

  public static void main(String[] args) {
    FastScanner sc = new FastScanner(System.in);
    int a = sc.nextInt();
    int b = sc.nextInt();
    System.out.println((a * b) % 2 == 1 ? "Yes" : "No");
  }
}
//  [java]
import java.io.BufferedReader;
import java.io.InputStreamReader;

public class Main {

  public static void main(String[] args) throws java.io.IOException {
    try (BufferedReader reader = new BufferedReader(new InputStreamReader(System.in))) {
      final String input = reader.readLine();
      System.out.println(input.contains("2") ? "No" : "Yes");
    }
  }

}
//  [java]
import java.io.IOException;
import java.util.InputMismatchException;

public class Main {
	public static void main(String[] args) {
		FasterScanner sc = new FasterScanner();

		int a = sc.nextInt();
		int b = sc.nextInt();

		System.out.println(a*b%2==1?"Yes":"No");

	}

	static int gcd(int a, int b) {
		int temp;
		while (b != 0) {
			temp = a % b;

			a = b;
			b = temp;
		}
		return a;
	}

	public static class FasterScanner {
		private byte[] buf = new byte[1024];
		private int curChar;
		private int numChars;

		public int read() {
			if (numChars == -1)
				throw new InputMismatchException();
			if (curChar >= numChars) {
				curChar = 0;
				try {
					numChars = System.in.read(buf);
				} catch (IOException e) {
					throw new InputMismatchException();
				}
				if (numChars <= 0)
					return -1;
			}
			return buf[curChar++];
		}

		public String nextLine() {
			int c = read();
			while (isSpaceChar(c))
				c = read();
			StringBuilder res = new StringBuilder();
			do {
				res.appendCodePoint(c);
				c = read();
			} while (!isEndOfLine(c));
			return res.toString();
		}

		public String nextString() {
			int c = read();
			while (isSpaceChar(c))
				c = read();
			StringBuilder res = new StringBuilder();
			do {
				res.appendCodePoint(c);
				c = read();
			} while (!isSpaceChar(c));
			return res.toString();
		}

		public long nextLong() {
			int c = read();
			while (isSpaceChar(c))
				c = read();
			int sgn = 1;
			if (c == '-') {
				sgn = -1;
				c = read();
			}
			long res = 0;
			do {
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = read();
			} while (!isSpaceChar(c));
			return res * sgn;
		}

		public int nextInt() {
			int c = read();
			while (isSpaceChar(c))
				c = read();
			int sgn = 1;
			if (c == '-') {
				sgn = -1;
				c = read();
			}
			int res = 0;
			do {
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = read();
			} while (!isSpaceChar(c));
			return res * sgn;
		}

		public int[] nextIntArray(int n) {
			int[] arr = new int[n];
			for (int i = 0; i < n; i++) {
				arr[i] = nextInt();
			}
			return arr;
		}

		public int[] nextIntArray(int n, int offset) {
			int[] arr = new int[n + offset];
			for (int i = 0; i < n; i++) {
				arr[i + offset] = nextInt();
			}
			return arr;
		}

		public long[] nextLongArray(int n) {
			long[] arr = new long[n];
			for (int i = 0; i < n; i++) {
				arr[i] = nextLong();
			}
			return arr;
		}

		public long[] nextLongArray(int n, int offset) {
			long[] arr = new long[n + offset];
			for (int i = 0; i < n; i++) {
				arr[i + offset] = nextLong();
			}
			return arr;
		}

		private boolean isSpaceChar(int c) {
			return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
		}

		private boolean isEndOfLine(int c) {
			return c == '\n' || c == '\r' || c == -1;
		}
	}
}
//  [java]
import java.util.Scanner;

public class Main implements Runnable {

    private static Scanner sc = new Scanner(System.in);

    public static void main(String[] args) {
        new Thread(null, new Main(), "", 128 * 1024 * 1024).start();
    }

    public void run() {
        int a = sc.nextInt(), b = sc.nextInt();
        System.out.println((a % 2 == 0 || b % 2 == 0) ? "No" : "Yes");
    }
}
//  [java]

import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        try (PrintWriter out = new PrintWriter(System.out); Scanner sc = new Scanner(System.in);) {
            Task task = new Task();
            task.solve(sc, out);
            out.flush();

        } catch (Exception e) {
            // DO NOT USE
        }
    }

    static class Task {
        public void solve(Scanner sc, PrintWriter out) {
            // TODO
            int a = nint(sc);
            int b = nint(sc);

            if(a % 2 != 0 && b %2 != 0){
                out.println("Yes");
                return;
            }

            out.println("No");
        }
    }

    // method
    static int nint(Scanner sc) {
        return Integer.parseInt(sc.next());
    }

    static long nlong(Scanner sc) {
        return Long.parseLong(sc.next());
    }

    static double ndouble(Scanner sc) {
        return Double.parseDouble(sc.next());
    }

    static float nfloat(Scanner sc) {
        return Float.parseFloat(sc.next());
    }

    static String nstr(Scanner sc) {
        return sc.next();
    }

    static long[] longLine(Scanner sc, int size) {
        long[] lLine = new long[size];
        for (int i = 0; i < size; i++) {
            lLine[i] = nlong(sc);
        }
        return lLine;
    }

    static int[] intLine(Scanner sc, int size) {
        int[] iLine = new int[size];
        for (int i = 0; i < size; i++) {
            iLine[i] = nint(sc);
        }
        return iLine;
    }

    static String[] strLine(Scanner sc, int size) {
        String[] strLine = new String[size];
        for (int i = 0; i < size; i++) {
            strLine[i] = nstr(sc);
        }
        return strLine;
    }

    static long maxFromList(List<Long> longList) {
        return longList.stream().max(Comparator.naturalOrder()).get();
    }

    static long minFromList(List<Long> longList) {
        return longList.stream().min(Comparator.naturalOrder()).get();
    }

    public static int sumDigits(int n) {
        int sum = 0;
        while (n != 0) {
            sum += n % 10;
            n /= 10;
        }
        return sum;
    }

    public static long sumDigits(long n) {
        long sum = 0;
        while (n != 0) {
            sum += n % 10;
            n /= 10;
        }
        return sum;
    }

    static List<Integer> getIntegerList(Scanner sc, int size) {
        List<Integer> list = new ArrayList<>();
        for (int i = 0; i < size; i++) {
            list.add(nint(sc));
        }
        return list;
    }

    static List<Long> getLongList(Scanner sc, int size) {
        List<Long> list = new ArrayList<>();
        for (int i = 0; i < size; i++) {
            list.add(nlong(sc));
        }
        return list;
    }
}
//  [java]
import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        final Scanner scanner = new Scanner(System.in);
        final int a = scanner.nextInt();
        final int b = scanner.nextInt();
        if ((a * b) % 2 == 0) {
            System.out.println("No");
        } else {
            System.out.println("Yes");
        }
    }

}
//  [cpp]
#include<stdio.h>


int main(){


    int a,b,ab;

    scanf("%d %d",&a,&b);

    ab=a*b;

    if(ab%2 == 0)
        printf("No");
    else
        printf("Yes");
        
    return 0;
}
//  [cpp]
#include <stdio.h>
#include <math.h>
#include <stdlib.h>

int main(void)
{
	int a,b;
	scanf("%d %d",&a,&b);

	int flag = 0;
	for(int i=1;i<4;i++)
	{
		if((a*b*i)%2 == 1)
		{
			printf("Yes\n");
			return 0;
		}
	}
printf("No\n");


return 0;
}
//  [cpp]
#include<stdio.h>
#include <string.h>
using namespace std;
int main()
{

  int A_initial,B_initial;
  scanf("%d %d", &A_initial, &B_initial);
  if(A_initial%2==1){
    if(B_initial%2==1){
      printf("Yes\n");
      return 0;
   }
  }

  printf("No\n");
  return 0;
}
//  [cpp]
#include <iostream>

using namespace std;

int main(void)
{
    int A, B;
    int Answer;
    int count = 0;
    
    cin >> A >> B;
    
    for (int i = 1; i < 4; i++) {
        Answer = A*B*i;
        Answer = Answer % 2;        //割り切れたら0
        if (Answer != 0) {
            count += 1;
        }
    }
    
    if (count > 0) {
        cout << "Yes";
    }
    else {
        cout << "No";
    }
    return 0;
}
//  [c]
#include <stdio.h>

int main(void)
{
    int a, b;
    
    scanf("%d %d", &a, &b);
    
    if(a == 2 || b == 2) {
        printf("No\n");
    } else {
        printf("Yes\n");
    }
   
    return 0;
}
//  [c]
#include <stdio.h>

int main() {
  int A, B;
  scanf("%d %d", &A, &B);
  if (A % 2 == 1 && B % 2 == 1) {
    printf("Yes\n");
  } else {
    printf("No\n");
  }
  return 0;
}
//  [c]
#include<stdio.h>
int main()
{
    int d;
int a;
    scanf("%d %d", &a ,&d);
if(a*d % 2 == 1) {
 printf("Yes");
} else {
printf("No");
}
    return 0;
}
//  [c]
#include <stdio.h>

int main(void) {
  int A, B, flag = 0;
  scanf("%d %d", &A, &B);

  for(int i=1; i<=3; ++i) {
    if((A*B*i)%2 == 1) {
      flag = 1;
      break;
    }
  }

  if(flag) printf("Yes\n");
  else printf("No\n");

  return 0;
}
//  [c]
#include<stdio.h>
int main()
{
  int a, b,c;
  scanf("%d" ,&a);
  scanf("%d" ,&b);
  
  c= a*b;
  
  if(c%2 == 1)
    printf("Yes");
  
  else
    printf("No");
  
  return 0;
}
//  [c]
#include <stdio.h>

int main(){
  int A,B;
  scanf("%d %d",&A,&B);
  if(A%2==0||B%2==0){
    printf("No\n");
  }else{
    printf("Yes\n");
  }
  return 0;
}
//  [javascript]
function Main(input) {
  input = input.trim()
  input = input.split(" ")
  if((input[0]*input[1])%2==0) console.log("No")
  else  console.log("Yes")
}Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
inp = require('fs').readFileSync('/dev/stdin', 'utf8').split('\n')
l = inp.shift().split(' ')
A = l[0] * 1
B = l[1] * 1
console.log((A % 2 && B % 2) ? 'Yes' : 'No')
//  [javascript]
function main(input) {
  const A = parseInt(input.split(" ")[0], 10);
  const B = parseInt(input.split(" ")[1], 10);
  if(A%2==0||B%2==0){
    console.log("No");
  }else{
    console.log("Yes");
  }
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [javascript]
// parameter "input" gets all data
function Main(input) {
	// the first line is assigned to input[0], the second line is assigned to input[1] similarly.
	var ab = input.split(' ');
	a = parseInt(ab[0]);
	b = parseInt(ab[1]);

	console.log((a*b)%2==0?'No':'Yes');
}
// Don't edit this line!
//Main(require("fs").readFileSync(__dirname+'/in.txt', "utf8"));
Main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [javascript]
function Main(input) {
  input = input.split("\n");
  var a = parseInt(input[0].split(" ")[0]);
  var b = parseInt(input[0].split(" ")[1]);
  var ans ="Yes";
  if(a%2==0||b%2==0){
    ans="No";
  }

  console.log('%s', ans);
}
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
var int = x=>parseInt(x,10);var spln = x=>x.split(/\n/g);var spsp = x=>x.split(/\s/g);
function main(input) {
  if(input.includes('2')){
    console.log('No');
  }else{
   console.log('Yes') 
  }
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [go]
package main

import (
	"fmt"
)

func main() {
	var a, b int
	fmt.Scan(&a, &b)
	if a%2 != 0 && b%2 != 0 {
		fmt.Println("Yes")
	} else {
		fmt.Println("No")
	}
}
//  [go]
package main

import "fmt"

func main() {
	var A, B int
	fmt.Scan(&A, &B)
	if (A*B)%2 != 0 {
		fmt.Println("Yes")
	} else {
		fmt.Println("No")
	}
}
//  [go]
package main

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

var sc, wr = bufio.NewScanner(os.Stdin), bufio.NewWriter(os.Stdout)

func scanString() string   { sc.Scan(); return sc.Text() }
func scanRunes() []rune    { return []rune(scanString()) }
func scanInt() int         { a, _ := strconv.Atoi(scanString()); return a }
func scanInt64() int64     { a, _ := strconv.ParseInt(scanString(), 10, 64); return a }
func scanFloat64() float64 { a, _ := strconv.ParseFloat(scanString(), 64); return a }

func scanInts(n int) []int {
	res := make([]int, n)
	for i := 0; i < n; i++ {
		res[i] = scanInt()
	}
	return res
}

func debug(a ...interface{}) {
	if os.Getenv("ONLINE_JUDGE") == "false" {
		fmt.Fprintln(os.Stderr, a...)
	}
}

func abs(a int) int {
	if a < 0 {
		return -a
	}
	return a
}
func min(a, b int) int {
	if a < b {
		return a
	}
	return b
}
func max(a, b int) int {
	if a > b {
		return a
	}
	return b
}

//•*¨*•.¸¸♪main•*¨*•.¸¸♪(　-ω-)ノ　(　・ω・)
func main() {
	defer wr.Flush()
	sc.Split(bufio.ScanWords)
	sc.Buffer(make([]byte, 10000), 1001001)

	a, b := scanInt(), scanInt()
	if a*b%2 == 1 {
		fmt.Fprintln(wr, "Yes")
	} else {
		fmt.Fprintln(wr, "No")
	}
}
//  [ruby]
a,b=gets.split.map(&:to_i);puts (a * b * 1).odd? ? "Yes" : "No"
//  [ruby]
a,b = gets.split.map(&:to_i)
puts a.odd? && b.odd? ? "Yes" : "No"
//  [ruby]
# frozen_string_literal: true

a, b = gets.split.map(&:to_i)

puts a == 2 || b == 2 ? :No : :Yes
//  [ruby]
a, b = gets.chomp.split.map(&:to_i)
1.upto(3) do |i|
	if a * b * i % 2 == 1
		puts "Yes"
		exit
	end
end
puts "No"
//  [ruby]
a, b = gets.chomp.split(" ").map(&:to_i)
ans = a * b
(1..3).each do |i|
    ans = ans * i
    if ans % 2 != 0
        puts "Yes"
        exit
    end
end
puts "No"
//  [ruby]
A, B = gets.chomp.split.map(&:to_i)
if [A, B].include?(2)
  puts "No"
else
  puts "Yes"
end
//  [rust]
use std::io::Read;

fn main() {
    let mut buf = String::new();

    std::io::stdin().read_to_string(&mut buf).unwrap();

    let mut iter = buf.split_whitespace();
    let a: usize = iter.next().unwrap().parse().unwrap();
    let b: usize = iter.next().unwrap().parse().unwrap();

    println!("{}", if a * b % 2 == 1 { "Yes" } else { "No" });
}