jiahuimbzuai/CoQuIR huggingface dataset:
//  [swift]
import Foundation
 
let input_line: String = readLine()!
let split: [String] = input_line.components(separatedBy: " ")
 
let x = Double(split[0])!
let y = Double(split[1])!

if (0.5*y-x>0 && 2*x-0.5*y>0 || 0.5*y-x>0 && 2*x-0.5*y==0 || 0.5*y-x==0 && 2*x-0.5*y>0){
    print("Yes")
}else{
    print("No")
}
//  [swift]
import Foundation
 
let input_line: String = readLine()!
let split: [String] = input_line.components(separatedBy: " ")
 
let x = Double(split[0])!
let y = Double(split[1])!

if (0.5*y-x>=0 && 2*x-0.5*y>=0){
    print("Yes")
}else{
    print("No")
}
//  [typescript]
// import std = require('tstl')

{
  type Print = void | string | number | string[] | number[]
  let outs: Print[] = []

  const main = (): Print => {
    const r = _io()
    const [X, Y] = r.nn()

    // t + k = x
    // t * 2 + k * 2 = x * 2
    // t * 2 + k * 4 = y
    // 2k = y - 2x
    const k = (Y - 2 * X) / 2

    if ((Y - 2 * X) % 2 !== 0) return 'No'
    if (k < 0 || k > X) return 'No'
    // const t = X - k

    return 'Yes'
  }

  const _io = (i = 0) => {
    const str = require('fs').readFileSync('/dev/stdin', 'utf8')
    const lines = str.trim().split('\n')
    const s = () => lines[i++] || ''
    const n = () => Number(s())

    const mn = (v: string[]) => v.map(Number)
    const sp = (v: string) => v.split(' ')

    const ss = () => sp(s())
    const nn = () => mn(ss())
    const nls = () => mn(lines.slice(i))
    const nnls = () => lines.slice(i).map((v) => mn(sp(v)))

    return { lines, s, n, ss, nn, nls, nnls }
  }

  outs.push(main())

  console.log(
    outs
      .map((line) => (typeof line === 'object' ? line.join(' ') : String(line)))
      .join('\n')
  )
}
//  [typescript]
import { readFileSync } from "fs";

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

const main = (input: string[][]) => {
  const [X, Y] = input[0].map(Number);

  for (let i = 0; i <= X; i++) {
    const legCount = i * 2 + (X - i) * 4;

    if (legCount === Y) {
      return "Yes";
    }
  }

  return "No";
};

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

const input = fs.readFileSync('/dev/stdin', 'utf8');
const [x, y] = input.split(' ');


const t2 = ( 4 * x - y );
if (t2 < 0) {
  console.log('No')
} else if (t2 / 2 > x) {
  console.log('No')  
} else {
	console.log( t2 % 2 === 0 ? 'Yes' : 'No' );
}
//  [typescript]
import { readFileSync } from 'fs'
import { reverse } from 'dns'
import { start } from 'repl'
 
let lines: string[] = [];
const reader = require('readline').createInterface({
    input: process.stdin,
    output: process.stdout
});
 
reader.on('line', function (line: string) {
    lines.push(line);
});
reader.on('close', function () {
    let [x, y] = lines[0].split(' ').map( _ => parseInt(_))

    if(y % 2 == 1) {
        console.log('No')
    } else {
        if(x * 4 >= y) {
            console.log('Yes')
        } else {
            console.log('No')
        }
    }

});
//  [typescript]
import { readFileSync } from 'fs'
import { reverse } from 'dns'
import { start } from 'repl'
 
let lines: string[] = [];
const reader = require('readline').createInterface({
    input: process.stdin,
    output: process.stdout
});
 
reader.on('line', function (line: string) {
    lines.push(line);
});
reader.on('close', function () {
    let x = parseInt(lines[0])
    let y = parseInt(lines[1])
    /* let p = lines[1].split(' ').map( _ => parseInt(_)) */

    if(y % 2 == 1) {
        console.log('No')
    } else {
        if(x * 4 >= y) {
            console.log('Yes')
        } else {
            console.log('No')
        }
    }

});
//  [python]
S=list(input())

X=[]
for e in S:
    X.append("x")

print("".join(X))
//  [python]
a = input()
l = len(a)
print("x"*l)
//  [python]
s = input()
answer = ''
for _ in range(len(s)):
    answer += 'x'
print(answer)
//  [python]
s=input()
for i in range(len(s)):
    s[i]="x"
print(s)
//  [python]
s=input()
for i in range(len(s)):
    s[i]=="x"
print(s)
//  [python]
s=input()
for i in range(len(s)):
    s[i].replace("x")
print(s)
//  [java]
import java.io.*; 
import java.lang.*;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

class Main{
public static void main(String[] args){
try{
   BufferedReader reader =
                   new BufferedReader(new InputStreamReader(System.in));
        String b = reader.readLine();
     
    int n = b.length();
  	String ans = "";
  String x = "x";
  	for(int i=0;i<n;i++){
      ans = ans.concat(x);
     
    }
  System.out.println(ans);
}catch(Exception e){}
}
}
//  [java]
import java.util.*;

class Main{
  public static void main(String[] args){
	Scanner sc = new Scanner(System.in);
    
    String abc = sc.next();
    for(int i = 0; i < abc.length; i++){
      System.out.print("x");
    }
    
  }
}
//  [java]
#include<stdio.h>
int main(){
   char S[100];
   scanf("%s",S);
   for(int i=0;S[i]!='\0';i++){
      S[i]='x';
      printf("%c",S[i]);
   }
   printf("\n");
   return 0;
}
//  [java]
import java.util.Scanner;

public class Main{
    public static void main(String[] args){
        Scanner scanner = new Scanner(System.in);

        String S = scanner.next();
        
        for(int i = 1; i <= S.length(); i++){
            System.out.println("x");
        }
	}
}
//  [cpp]
#include <cstdio>
#include <cstring>
using namespace std;
char ch[105];
int main(){
	scanf("%s",ch);
	int len=strlen(ch);
	for (int i=0;i<len;i++){
		printf("x");
	}
	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=998244353;
const long long inf=mod*mod;
const long long d2=(mod+1)/2;
const long double EPS=1e-9;
const long double INF=1e+10;
const long double PI=acos(-1.0);
const int C_SIZE = 3100000;
const int UF_SIZE = 3100000;
namespace{
	long long fact[C_SIZE];
	long long finv[C_SIZE];
	long long inv[C_SIZE];
	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;
	}
}
// ここから編集しろ
char in[112];

int main(){
	scanf("%s",in);
	for(int i=0;in[i];i++)in[i]='x';
		printf("%s\n",in);
}
//  [cpp]
#include <bits/stdc++.h>
#define rep(i, a, b) for (int i = a; i < b; i++)
using namespace std;

int main() {
    string s;
    cin >> s;

    rep(i, 0, s.length()) cout << "x";
    cout << endl;
    
    return 0;
}
//  [cpp]
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
using ll = long long;

int main() {
  string S;
  cin >> S;

  rep(i, S.size()) cout << 'x' << endl;
  return 0;
}
//  [cpp]
#include <bits/stdc++.h>
using namespace std;
 
int main(){
	string s;
	cin >> s;
	for(int i=0;i<s.size();i++){
     s.at(i) = "x";
    }
	cout << s << endl;
 
}
//  [cpp]
#include <bits/stdc++.h>
using namespace std;

int main(){
	string s;
	cin >> s;
	for(int i=0;i<s.size();i++){
     s.at(i) == "x";
    }
	cout << s << endl;

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

int main(){

int i; 
char s[100]={};

scanf("%s",s);

for(i=1;i<=strlen(s);i++){
  printf("x");
}

return 0;

}
//  [c]
#include<stdio.h>
int main(void){
    char s[100];
    int i=0;
    scanf("%s",s);
    while(s[i]!='\0'){
        i++;
    }
    while(i!=0){
        printf("x");
        i--;
    }
    return 0;
}
//  [c]
#include <stdio.h>
int main(){
    char s[256];
    scanf("%s",s);
    for(int i=0;s[i]!='\0';++i){
        printf("x");
    }
    return 0;
}
//  [c]
main(){for(;~getchar();)putchar('x');}
//  [c]
#include<stdio.h>
int main(){char a[110];int i=0;
scanf("%s",a);while(a[i]!='\0'){puts("x");i++;}}
//  [c]
#include<stdio.h>
int main(){char a[110];i=0;
scanf("%s",a);while(a[i]!='\0'){puts("x");i++;}}
//  [javascript]
'use strict';
function main(input) {
  const arr = input.trim();
  let x = '';

  for (let i = 0; i < arr.length; i ++) {
    x += 'x';
  }
  
  console.log(x);
}

main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
function Main (S) {
  S = S.split("\n")[0];
  var ans = "";
  for (var i = 0; i < S.length; i++) {
    ans += "x";
  }
  console.log(ans);
}

Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
function Main(input) {
  input = input.trim().split('');
  var str ='';
    for(i=0;i<input.length;i++){
    str+= 'x';
    }
  console.log(str);
}

Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
function Main(input) {
	input = input.split("");
  	let result = "";
 	for(let i = 0 ; i < input.length; i++){
		result += "x";
    };
	console.log(result);
}
//*この行以降は編集しないでください（標準入出力から一度に読み込み、Mainを呼び出します）
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
function Main(input) {
	input = input.split("");
  	let result = "";
 	for(let i = 0 ; i<input.length; i++){
		result += "x";
      }
  
	console.log(result);
}
//*この行以降は編集しないでください（標準入出力から一度に読み込み、Mainを呼び出します）
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]

function Main(input) {
	input = input.split("");
  	let result = "";
 	for(let i = 0 ; i<input.length; i++){
        input[i] = "x";
      	result = `${result}${input[i]}`;
      }
  
	console.log(result);
}
//*この行以降は編集しないでください（標準入出力から一度に読み込み、Mainを呼び出します）
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [go]
package main

import (
	"fmt"
)

func main() {
	var s []byte
	fmt.Scan(&s)
	for _ = range s {
		fmt.Print("x")
	}
	fmt.Println()
}
//  [go]
package main

import (
	"fmt"
)

func main() {
	var s string
	fmt.Scan(&s)

	for i := 0; i < len(s); i++ {
		fmt.Print("x")
	}
}
//  [go]
package main

import "fmt"

func main() {
	var s string
	fmt.Scan(&s)
	for i := 0; i < len(s); i++ {
		fmt.Print("x")
	}
}
//  [go]
package main

import (
	"fmt"
	"os"
)

func main() {
	var b [100]byte
	n, _ := os.Stdin.Read(b[:])
	for i := 0; i < n-1; i++ {
		fmt.Print("x")
	}
	fmt.Println()
}
//  [go]
package main

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

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

func next() string {
	sc.Scan()
	return sc.Text()
}
func nextInt() int {
	a, _ := strconv.Atoi(next())
	return a
}
func nextInts(n int) []int {
	ret := make([]int, n)
	for i := 0; i < n; i++ {
		ret[i] = nextInt()
	}
	return ret
}

//var done []bool = make([]bool, 10)
//var memo []int = make([]int, 10)

//func fib(n int) int {
//	fmt.Println(n)
//	if n == 0 {
//		return 0
//	}
//	if n == 1 {
//		return 1
//	}
//	if done[n] {
//		fmt.Println("done" + fmt.Sprint(n))
//		return memo[n]
//	}
//	done[n] = true
//	memo[n] = fib(n-1) + fib(n-2)
//	return memo[n]
//}

var dp []int = make([]int, 10)

func fib(n int) int {
	dp[0] = 0
	dp[1] = 1
	for i := 2; i <= n; i++ {
		dp[i] = dp[i-1] + dp[i-2]
	}
	return dp[n]
}

func main() {
	sc.Split(bufio.ScanWords)
	defer out.Flush() // !!!!coution!!!! you must use Fprint(out, ) not Print()
	a := next()
	r := []rune(a)
	for i := 0; i < len(r); i++ {
		r[i] = "x"
	}
	fmt.Fprint(out, string(r))
}
//  [go]
package main

import (
	"fmt"
	"strings"
)

func main() {
	var S string

	fmt.Scanf("%s", &S)

	fmt.Println(strings.ReplaceAll(S, S, strings.Repeat("x", len(S))))
}
//  [ruby]
s = gets.chomp
ns = s.length

answer = ""
for i in 1..ns do
  answer += "x"
end

print answer
//  [ruby]
s = gets.chomp
ans = ""
s.length.times do
  ans += "x"
end
puts ans
//  [ruby]
string = gets.chomp
after = ''

string.length.times do
    after += 'x'
end

puts(after)
//  [ruby]
s = gets.split("")
str = s.length


for i in 0..str-1
  if s[i] != "x"
    s[i] = "x"
  end
  print(s[i])
end
//  [ruby]
s = gets.to_s
str = s.length

for i in 0..str-1
  print("x")
end
//  [ruby]
s = gets.chomp
puts = "x"*s.size
//  [rust]
use std::io;
use std::str::FromStr;

fn input_char_vec() -> Vec<char> {
    let mut line: String = String::new();
    io::stdin().read_line(&mut line);
    line.trim().chars().collect()
}

fn main() {
    let s = input_char_vec();
    for _ in 0..s.len() {
        print!("x");
    }
    println!();
}
//  [rust]
use std::io::*;
use std::str::*;

fn read<T: FromStr>() -> Option<T> {
    let stdin = stdin();
    let s = stdin
        .bytes()
        .map(|c| c.unwrap() as char)
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect::<String>();
    s.parse::<T>().ok()
}

fn main(){
    let s: String = read().unwrap();
    let n = s.len();
    let mut ss = String::new();
    for _ in 0..n {
        ss.push('x');
    }
    println!("{}", ss);
}
//  [rust]
use text_io::*;
use std::collections::*;
use std::process::exit;

fn main() {
    let a:String = read!();
    let v:Vec<char> = a.chars().collect();
    for i in 0..v.len() {
        println!("x");
    }
}
//  [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 x = split[0]
let length = x.count
var ans = ""
for i in 1...length{
    ans += "x"
}
print(ans)
//  [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 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: " ") //ブランクで区切られている場合

var S = split[0]

print(repeating: "x", count: "S.length")
//  [swift]
import Foundation

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

var S = split[0]

print(repeating: "x", count: "S".length)
//  [typescript]
import * as fs from 'fs'

function main(args: string) {
    // sardine
    // xxxxxxx
    let result: string = '';
    for (let i: number = 1; i < args.length; i++) {
        result = result + 'x';
    }

    console.log(result);
}

main(fs.readFileSync('/dev/stdin', 'utf8'));
//  [typescript]
import * as fs from "fs";

const input = (fs.readFileSync("/dev/stdin", "utf8") as string).split("\n");
//const n = +input[0];
//const a = [];
//for(let i=0;i<n;i++){
//	a.push(input[i+1].split(" ").map((x:string):number=>+x));
//}

//const [n, m] = input[0].split(" ").map((x: string): number => +x);
//const a = input[1].split(" ").map((x: string): number => +x);

const s = input[0];
const ss = s.split('');

const ans = '';

for (let i = 0; i <ss.length; i++){
    ss[i] = 'x';
}

console.log(ss.join(''));
//  [typescript]

"use  strict";
const App7 = (arg: any) => {
  const value: string = arg.trim();
  const valueLength: number = value.length;
  console.log('x'.repeat(valueLength));
}

App7(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [typescript]
"use  strict";
const App7 = (arg: any) => {
  const value = arg.trim();
  const nextValue = value.replace(`${value}`, 'x');
  console.log(nextValue);
}

App7(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [typescript]
"use  strict";
const App7 = (arg: any) => {
  const value = arg.trim();
  const nextValue = new RegExp(value, 'x');
  console.log(nextValue);
}

App7(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [typescript]
"use  strict";
const App7 = (arg: any) => {
  const value = arg.trim().split(' ');
  const answerValue = nextValue.join('');
  console.log(answerValue);
}

App7(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [python]
n = int(input())
mod = 10 ** 9 + 7
print((pow(10, n, mod) - pow(9, n, mod) * 2 + pow(8, n, mod)) % mod)
//  [python]
def main():
    n = int(input())
    mod = 10 ** 9 + 7
    ans = pow(10, n, mod)
    ans -= 2 * pow(9, n, mod)
    ans += pow(8, n, mod)
    ans %= mod
    print(ans)


if __name__ == '__main__':
    main()
//  [python]
MOD=10**9+7

def modpow(a,n):
    r=1
    while n > 0:
        if n%2==1:
            r = r*a%MOD
        a = a*a % MOD
        n = n//2
    return r

N=int(input())
a10N=modpow(10,N)
a9N=modpow(9,N)
a8N=modpow(8,N)
ans=a10N-(a8N+2*(a9N-a8N))
ans%=MOD
print(ans)
//  [python]
from heapq import *
import sys
from collections import *
from itertools import *
from decimal import *
import copy
from bisect import *
import math
import numpy as np
import random
sys.setrecursionlimit(4100000)
def gcd(a,b):
    if(a%b==0):return(b)
    return (gcd(b,a%b))
input=lambda :sys.stdin.readline().rstrip()



N=int(input())
mod=10**9+7
dp=[[8,1,1,0] for i in range(N)]#1,2~8,9,both
for i in range(1,N):
    dp[i][0]=dp[i-1][0]*8
    dp[i][1]=dp[i-1][0]+dp[i-1][1]*9
    dp[i][2]=dp[i-1][0]+dp[i-1][2]*9
    dp[i][3]=dp[i-1][1]+dp[i-1][2]+dp[i-1][3]*10
    for n in range(4):
        dp[i][n]%=mod
print(dp[-1][3]%mod)
//  [python]
N = int(input())
mod = 10**9+7

ans = pow(10, N, mod) - 2*pow(9, N, mod) + pow(8, N, mod)
print(ans)
//  [java]
import java.io.*;
import java.lang.*;
import java.util.*;

class Main
{
	public static void main(String args[])throws IOException
	{
		FastReader scn = new FastReader();
		long N = scn.nextLong();
		long M = 1000000007L;

		long a = getPowerModulo(10, N, M);
		long b = getPowerModulo(8, N, M);
		long c = getPowerModulo(9, N, M);

		long ans = (a + b - 2*c)%M;
		if(ans < 0)
			ans = ans + M;

		System.out.println(ans);
	}

	public static long getPowerModulo(long a, long p, long m)
    {   
        if(p==0)
            return 1;
 
        long temp = getPowerModulo(a, p/2, m);
        temp = (temp * temp)%m;
        if(p%2 == 0)
            return temp;
        else
            return (a * temp)%m;
 
    }
	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 sc=new Scanner(System.in);
		long n=sc.nextLong();
		int m=1000000007;
		System.out.println((fastexpo(10,n,m)%m-fastexpo(9,n,m)%m-fastexpo(9,n,m)%m+fastexpo(8,n,m)%m)%m);
	}
	
	static long fastexpo(long x,long y,long modulus){
		if(y==0) return 1;
		if(y==1) return x;
		long R=fastexpo(x,y/2,modulus);
		if(y%2==0) return ((R%modulus)*(R%modulus))%modulus;
		else return ((R%modulus)*(R%modulus)*(x%modulus))%modulus;
	}

}
//  [cpp]
/*  -*- coding: utf-8 -*-
 *
 * c.cc: C - Ubiquity
 */

#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<iostream>
#include<string>
#include<vector>
#include<map>
#include<set>
#include<stack>
#include<list>
#include<queue>
#include<deque>
#include<algorithm>
#include<numeric>
#include<utility>
#include<complex>
#include<functional>
 
using namespace std;

/* constant */

const int MOD = 1000000007;

/* typedef */

typedef long long ll;

/* global variables */

/* subroutines */

int powmod(int a, int n) {  // a^n % MOD
  int pm = 1;
  while (n > 0) {
    if (n & 1) pm = (ll)pm * a % MOD;
    a = (ll)a * a % MOD;
    n >>= 1;
  }
  return pm;
}

/* main */

int main() {
  int n;
  scanf("%d", &n);

  int e10 = powmod(10, n), e9 = MOD - powmod(9, n), e8 = powmod(8, n);
  printf("%lld\n", ((ll)e10 + e9 * 2 + e8) % MOD);
  return 0;
}
//  [cpp]
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i, n) for(i = 0; i < n; i++)
//2D::rep(i,j)rep(j,j)cin>>bin[i][j];
//vector<int> a(n)
#define Graph vector<vector<int>>
#define A1 cout<<"No"<<endl
#define A2 cout<<"Yes"<<endl
#define A3 cout<<ans<<
#define AA(i) cout<<i<<endl;
const int U=2e5+5;
const ll MOD=1000000007;
const int INF = 1001001001;

ll POW(ll n,ll m){
  ll pow = 1;
  while (m>0) {
    if ((m&1) == 1) pow = (pow*n)%MOD;
    m >>= 1;
    n = (n*n)%MOD;
  }
    return pow;
}

int main(){
    ll N; cin >> N;
    ll a = POW(10,N),b = POW(9,N),c=POW(8,N);
    AA((a-(b*2%MOD)+c+MOD)%MOD);
    return 0;
}
//  [cpp]
#include<bits/stdc++.h>
using namespace std;
using ll = long long;
const ll mod = 1e9 + 7;
int gcd(int a,int b)
{
	if(b==0)
	return a;
	
	return gcd(b,a%b);
}
ll power(ll x,ll y)
{
	ll res=1;
	x=x%mod;
	while(y>0)
	{
		if(y&1)
		res=(res*x)%mod;
		
		y=y>>1;
		x=(x*x)%mod;
	}
	return res;
}
struct Matrix{ 
	int a[2][2] = {{0,0},{0,0}};
	Matrix operator *(const Matrix& other){
		Matrix product;
		for(int i=0;i<2;i++){
			for(int j=0;j<2;j++){
				for(int k=0;k<2;k++){
						product.a[i][k] =product.a[i][k] + (ll)a[i][j]*other.a[j][k];
				}
			}
		}
		return product;
	}
};
//int modInverse(int n,int p)
//{
	//return power(n,p-2,p);
//}
int main() {
	// your code goes here
	 ios_base::sync_with_stdio(0);
	 cin.tie(0);
	 ll n;
	 cin>>n;
	 ll ans1 = power(10,n);
	 ll ans2 = power(8,n);
	 ll ans3 = (2*(power(9,n) - ans2 + mod)%mod)%mod;
	 ll ans = ((ans1 - ans2 + mod)%mod - ans3 + mod)%mod;
	 cout<<ans<<'\n';
	 return 0;
}
//  [cpp]
#include<iostream>
using namespace std;

long long int big_mod(long long  b, long long  p, long long m)
{
    long long int power=b%m,re=1;
    while(p!=0)
    {
        if(p%2==1) re=(power*re)%m;
        power=(power*power)%m;
        p/=2;
    }
    return re;
}

int main()
{
    long long int n,ten,eight,nine,re;
    cin >>n;
    ten= big_mod(10,n,1000000007);
    nine= big_mod(9,n,1000000007);
    eight= big_mod(8,n,1000000007);
    re=((ten-((2*nine)%1000000007)+ eight)%1000000007);
    if(re<0) re+=1000000007;
    cout << ((ten-((2*nine)%1000000007)+ eight)%1000000007);
}
//  [cpp]
#include<iostream>
using namespace std;

long long int big_mod(long long  b, long long  p, long long m)
{
    long long int power=b%m,re=1;
    while(p!=0)
    {
        if(p%2==1) re=(power*re)%m;
        power=(power*power)%m;
        p/=2;
    }
    return re;
}

int main()
{
    long long int n,ten,eight,nine;
    cin >>n;
    ten= big_mod(10,n,1000000007);
    nine= big_mod(9,n,1000000007);
    eight= big_mod(8,n,1000000007);
    cout << ((ten-((2*nine)%1000000007)+ eight)%1000000007);
}
//  [cpp]
#include<cstdio>
//#include<iostream>
#include<vector>
#include<string>
#include<cstring>
#include<cmath>
#include<algorithm>
#include<set>
#include<map>
#include<queue>
using namespace std;
typedef long long ll;
const int maxv = 10005;
const int inf = 1e9 + 7;
ll fpow(int x,int y){
	ll res=1;
    for(ll i=0;i<y;i++){
        res=res*x%inf;
    }
    return res;
}
int main(){
	int n;
	scanf("%d",&n);
	ll ans=fpow(10,n)-2*fpow(9,n)+fpow(8,n);
	ans%=inf;
	printf("%lld\n",ans);
	return 0;
}
//  [c]
#include<stdio.h>
//累乗(power)a^n(mod10^9+7)
long long power(long long a,long long n){
  long long count=a,sum=1;
  while(n>0){
    if(n%2==1)
      sum*=count;
    count*=count;
    count%=1000000007;
    sum%=1000000007;
    n/=2;
  }
  return sum;
}

int main(){
  int n;
  scanf("%d",&n);
  long long ans = 0;
  ans = power( 10, n );
  ans -= power( 9 , n );
  ans -= power( 9 , n );
  ans += power( 8 , n );
  while(ans < 0)
    ans += 1000000007;
  printf("%lld\n",ans);
  return 0;
}
//  [c]
#include<unistd.h>
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<stdbool.h>
#include<stdint.h>
#include<time.h>
#include<tgmath.h>
inline int max(int a, int b){return a>b?a:b;}
inline int min(int a, int b){return a>b?b:a;}
long gcd(long a, long b){return b?gcd(b, a%b):a;}

//fast(?) Input
#define buf_sz 1<<24
char buf[buf_sz];
unsigned int nextint(){
	static int idx = 0;
	if(idx == 0)read(0, buf, buf_sz);
	unsigned int res = 0;
	while(idx<buf_sz && buf[idx]<'0' || '9'<buf[idx])idx++;
	while(idx<buf_sz && '0'<=buf[idx] && buf[idx]<='9'){
		res *= 10;
		res += buf[idx++] - '0';
	}if(idx>=buf_sz)exit(1);
	return res;
}

const long mod = 1e9 + 7;
long modpow(long x, long y, long m){
    long res = 1, tmp = x;
    while(y){
        if(y&1) res = res * tmp % m;
        tmp = tmp * tmp % m;
        y >>= 1;
    }
    return res;
}
long pom(long x, long y){return modpow(x, y, mod);}

int main(){
	long N = nextint();
	long ans = pom(10, N) - 2 * pom(9, N) + pom(8, N);
	ans = (mod + ans%mod) % mod;
	printf("%ld\n",ans);
}
//  [c]
#include <stdio.h>
typedef long long ll;
#define rep(i,n) for(int i=0; i<(int)(n); i++)
/////calc (mod MOD)
const ll MOD = 1000000007;
/////nCk (mod MOD) BEGIN/////
//faccal -> n!, k!^(MOD-2)()
//comb -> nCk (mod MOD)
ll mlpow(ll x, ll p) { //(x^p) % MOD
    ll tmp = 1;
    if(p == 0) return 1;
    while(p != 0) {
        if(p & 1) tmp = tmp*x % MOD;
        x = x*x % MOD;
        p = p >> 1;
    }
    return tmp;
}

#define facMAX 2000000
ll fac[facMAX];     //n! (mod MOD)
ll facM2[facMAX];   //(k!)^(MOD-2) (mod MOD)
void faccal(ll up) {
    fac[0] = 1;
    facM2[0] = 1;
    for(int i = 0; i < up + 1; i++){
        fac[i+1] = fac[i] * (i+1) % MOD;
        facM2[i+1] = facM2[i] * mlpow(i+1, MOD-2) % MOD;
    }
}

//nCk = n!*(k!)^(M-2)*((n-k)!)^(M-2)
ll comb(ll n, ll k) {
    if(n == 0 && k == 0) return 1;
    if(n < k || n < 0) return 0;
    ll tmp = (facM2[n-k] * facM2[k]) % MOD;
    return tmp * fac[n] % MOD;
}

int main(){
    ll n; scanf("%lld", &n);
    ll ans = 0;
    if(n > 1){
        ans = mlpow(10, n) + mlpow(8, n);
        ans %= MOD;
        ans += (2*MOD-mlpow(9, n)*2)%MOD;
        ans %= MOD;
    }

    printf("%lld\n", ans);
}
//  [c]
#include<stdio.h>
#include<math.h>

int main(){
        int n;
        scanf("%d", &n);
        long long ans;
        ans=pow(10, n)-pow(9, n)-pow(9, n)+pow(8, n);
        ans=ans%1000000007;

        printf("%d", ans);

        return 0;
}
//  [c]

#include<stdio.h>
 
int main(){
	int n;
	scanf("%d", &n);
	if(n==1) {
		printf("0");
		return 0;
	}
	long long a = 1;
	long long b = 1;
	long long c = 1;
	long long ans;
	for(int i=0; i<n; i++) {
		a *= 10;
		a%=1000000007;
		b *= 9;
		b%=1000000007;
		c *= 8;
		c%=1000000007;
	}
	ans = a - 2 * b + c;
	ans = (ans + 100000007) % 1000000007;
	printf("%lld", ans);
	return 0;
}
//  [c]

#include<stdio.h>
 
int main(){
	int n;
	scanf("%d", &n);
	if(n==1) {
		printf("0");
		return 0;
	}
	int a = 1;
	int b = 1;
	int c = 1;
	int ans;
	for(int i=0; i<n; i++) {
		a *= 10;
		a%=1000000007;
		b *= 9;
		b%=1000000007;
		c *= 8;
		c%=1000000007;
	}
	ans = a - 2 * b + c;
	ans %= 1000000007;
  	ans = (ans + 1000000007) % 1000000007;
	printf("%d", ans);
	return 0;
}
//  [javascript]
"use strict";
var input=require("fs").readFileSync("/dev/stdin","utf8");
var cin=input.split(/ |\n/),cid=0;
function next(){return +cin[cid++];}
function nextstr(){return cin[cid++];}
function nextbig(){return BigInt(cin[cid++]);}
function nexts(n,a){return a?cin.slice(cid,cid+=n):cin.slice(cid,cid+=n).map(a=>+a);}
function nextssort(n,a){return a?cin.slice(cid,cid+=n).map(a=>+a).sort((a,b)=>b-a):cin.slice(cid,cid+=n).map(a=>+a).sort((a,b)=>a-b);}
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 streams=[];function print(s){streams.push(s);}
var mod = 1e9+7;
function mul(){for(var a=arguments,r=a[0],i=a.length;--i;)r=((r>>16)*a[i]%mod*65536+(r&65535)*a[i])%mod;return r;}
var fac=[],finv=[],invs=[],pow2=[];
function fset(n){
  fac.length=n+1,fac[0]=fac[1]=1;
  for(var i=2;i<=n;)fac[i]=mul(fac[i-1],i++);
  finv.length=n+1,finv[0]=finv[1]=1,finv[n]=inv(fac[n]);
  for(i=n;2<i;)finv[i-1]=mul(finv[i],i--);
  //invs.length=n+1,invs[0]=invs[1]=1;
  //for(i=2;i<=n;)invs[i]=mul(fac[i-1],finv[i++]);
  //pow2.length=n+1,pow2[0]=1;
  //for(i=1;i<=n;i++)pow2[i]=pow2[i-1]*2%mod;
}
function inv(b){for(var a=mod,u=0,v=1,t;b;v=t)t=a/b|0,a-=t*b,u-=t*v,t=a,a=b,b=t,t=u,u=v;u%=mod;return u<0?u+mod:u;}
function pow(a,n){for(var r=1;n;a=mul(a,a),n>>=1)if(n&1)r=mul(a,r);return r;}
function ncr(n,r){return mul(fac[n],finv[r],finv[n-r]);}
function npr(n,r){return mul(fac[n],finv[n-r]);}
function mput(n){return (n%mod+mod)%mod;}


var myOut = main();
if(myOut !== undefined)console.log(String(myOut));
if(streams.length)console.log(streams.join("\n"));

function main(){
  var n = next();
  var ans = pow(10,n);
  ans -= pow(9,n);
  ans -= pow(9,n);
  ans += pow(8,n);
  return mput(ans);
}
//  [javascript]
function Main(input) {

	// 1行目がinput[0], 2行目がinput[1], …に入る
	input = input.split("\n");
    
    let N = Number(input[0]);
    
    let pow_10 = myPow(10n,BigInt(N),10n ** 9n + 7n);
    let pow_9 = myPow(9n,BigInt(N),10n ** 9n + 7n);
    let pow_8 = myPow(8n,BigInt(N),10n ** 9n + 7n);
    
    let ans = pow_10 - 2n * pow_9 + pow_8;
    while(ans < 0n) ans += (10n ** 9n + 7n);
    
    console.log(ans.toString());
    
}

function myPow(x, n, m){
  if(n == 0)
    return 1n;
  if(n % 2n == 0)
    return myPow(x * x % m, n / 2n, m);
  else
    return x * myPow(x, n - 1n, m) % m;
}

Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
let inputString = "";
let currentLine = 0;
process.stdin.on("data", (data) => {
  inputString += data;
});
process.stdin.on("end", function () {
  inputString = inputString
    .trim()
    .split("\n")
    .map((str) => str.trim());
  main();
});
function readLine() {
  return inputString[currentLine++];
}

// utils
const MOD = 1e9 + 7;
const mod = (n) => ((n % MOD) + MOD) % MOD;
const add = (a, b) => mod(mod(a) + mod(b));
const sub = (a, b) => mod(mod(a) - mod(b));
function mul() {
  for (var a = arguments, r = a[0], i = a.length; --i; )
    r = ((((r >> 16) * a[i]) % MOD) * 65536 + (r & 65535) * a[i]) % MOD;
  return r;
}
function inv(b) {
  for (var a = MOD, u = 0, v = 1, t; b; v = t)
    (t = (a / b) | 0), (a -= t * b), (u -= t * v), (t = a), (a = b), (b = t), (t = u), (u = v);
  u %= MOD;
  return u < 0 ? u + MOD : u;
}

function main() {
  const n = +readLine();
  let result = add(sub(pow(10, n), mul(2, pow(9, n))), pow(8, n));

  console.log(result);
}

function pow(base, n) {
  if (n === 0) return 1;

  let p = pow(base, Math.floor(n / 2));
  let res = mul(mod(p), mod(p));

  if (n % 2 === 1) {
    res = mul(mod(res), base);
  }

  return res;
}
//  [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);
				d %= b;
		}
		
	return(d)
	}

	let ans = (x(10)-x(9))+(x(10)-x(9))-(x(10)-x(8))%b;
  	console.log(ans.toString());
  
	}

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

}
//  [javascript]
var Main  = function(input){
    const [N] = input.trim().split(' ').map(x => BigInt(x));
    var count=BigInt(0);
    if (N>=2) count = 10n**N-7n**N % BigInt(10^9+7)
    console.log(count.toString(10));
};


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)

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

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"
)

const mod int = 1e9 + 7

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

	a := pow(10, n)
	c0 := sub(a, pow(9, n))
	c9 := c0
	c09 := sub(a, pow(8, n))
	ans := sub(add(c0, c9), c09)
	fmt.Println(ans)
}

func pow(n, k int) int {
	if k == 0 {
		return 1
	} else if k%2 == 1 {
		return pow(n, k-1) * n % mod
	} else {
		t := pow(n, k/2)
		return t * t % mod
	}
}

func add(a, b int) int {
	return (a + b) % mod
}

func sub(a, b int) int {
	return (a + mod - b) % mod
}

func mul(a, b int) int {
	return a % mod * b % mod % mod
}
//  [go]
package main

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

func main() {
	N := ReadInt()
	v := 2 * ModPow(9, N) % Mod
	v = v + Mod - ModPow(8, N)
	v %= Mod
	ans := ModPow(10, N) + Mod - v
	ans %= Mod
	fmt.Println(ans)
}

const Mod = int(1e9) + 7

func ModPow(a, b int) (x int) {
	for x = 1; b > 0; b >>= 1 {
		if b&1 == 1 {
			x = x * a % Mod
		}
		a = a * a % Mod
	}
	return
}

var reader = bufio.NewReader(os.Stdin)

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

import (
	"fmt"
	"math/big"
)

func main() {
	var n int64
	var m int64 = 1000000007
	fmt.Scan(&n)
	a := big.NewInt(0).Exp(big.NewInt(10), big.NewInt(n), big.NewInt(m))
	b := big.NewInt(0).Exp(big.NewInt(9), big.NewInt(n), big.NewInt(m))
	c := big.NewInt(0).Exp(big.NewInt(8), big.NewInt(n), big.NewInt(m))
	fmt.Println(
		big.NewInt(0).Mod(
			big.NewInt(0).Sub(
				big.NewInt(0).Add(a, c),
				big.NewInt(0).Add(b, b),
			),
			big.NewInt(m),
		).Int64(),
	)
}
//  [go]
package main

import (
	"fmt"
)

const div = 1000000007

func Powmod(x, n int) int {
	res := 1
	for i := 0; i < n; i++ {
		res = (res * x) % div
	}
	return res
}

func main() {
	var n int
	fmt.Scan(&n)
	ans := Powmod(10, n) - 2*Powmod(9, n) + Powmod(8, n)
	ans %= div
	// ans = (ans + div) % div
	fmt.Println(ans)
}
//  [go]
package main

import (
	"fmt"
)

const div = 1000000007

func Powmod(x, n int) int {
	res := 1
	for i := 0; i < n; i++ {
		res = res * x % div
	}
	return res
}

func main() {
	var n int
	fmt.Scan(&n)
	ans := Powmod(10, n) - 2*Powmod(9, n) + Powmod(8, n)
	fmt.Println(int(ans) % div)
}
//  [go]
package main

import (
	"bufio"
	"fmt"
	"math"
	"math/big"
	"os"
	"strconv"
)

func powmod(x int64, y int64, m int64) int64 {
	res := new(big.Int).Exp(big.NewInt(x), big.NewInt(y), big.NewInt(m))
	return res.Int64()
}

var (
	scanner = bufio.NewScanner(os.Stdin)
)

func readInt() (read int) {
	scanner.Scan()
	read, err := strconv.Atoi(scanner.Text())
	if err != nil {
		panic(err)
	}
	return
}

const (
	initialBufSize = 2e8
	maxBufSize     = 2e8
)

func main() {

	buf := make([]byte, initialBufSize)
	scanner.Buffer(buf, maxBufSize)
	scanner.Split(bufio.ScanWords)

	n := int64(readInt())

	m := int64(math.Pow10(9)) + 7

	ans := powmod(10, n, m)
	ans -= powmod(9, n, m) * 2
	ans += powmod(8, n, m)

	if ans < 0 {
		ans += m
	}

	fmt.Println(ans % m)
}
//  [ruby]
N = gets.chomp.to_i

waru = 10 ** 9 + 7

puts (10.pow(N, waru) - 2 * (9.pow(N, waru)) + 8.pow(N, waru)) % waru
//  [ruby]
def modpow(a, n, m)
  return 1 if n == 0

  tmp = modpow(a, n / 2, m)
  n % 2 == 0 ? tmp * tmp % m : tmp * tmp * a % m
end

n = gets.chomp.to_i
M = (1e9+7).to_i
puts (modpow(10, n, M) - 2 * modpow(9, n, M) + modpow(8, n, M)) % M
//  [ruby]
class InputLine
  def self.to_s
    gets.chomp
  end

  def self.to_i
    InputLine.to_s.to_i
  end
  
  def self.to_f
    InputLine.to_s.to_f
  end

  def self.to_sa
    InputLine.to_s.split(' ')
  end

  def self.to_ia
    InputLine.to_sa.map(&:to_i)
  end
  
  def self.to_fa
    InputLine.to_sa.map(&:to_f)
  end
end

MOD = 1000000007

def binpow_mod(b, e)
  return 1       if e <= 0
  return b % MOD if e == 1

  p = binpow_mod(b, e >> 1)
  q = (p * p) % MOD
  q = (q * b) % MOD if (e % 2) == 1
  return q
end

def solve(n)
  a = binpow_mod(10, n)
  b = binpow_mod(9,  n)
  c = binpow_mod(8,  n)

  x = (2 * (a + MOD - b)) % MOD
  y = ((a + MOD) - c) % MOD
  return ((x + MOD) - y) % MOD
end

def main(argv)
  n = InputLine.to_i

  puts solve(n).to_s
end

if self.to_s == 'main' then
  main(ARGV)
end
//  [ruby]
n = gets.to_i
a = "9" * n
a = a.to_i
cnt = 0

(0..a).each do |x|
  y = x.to_s.size
  if y < n
    z = n - y
    z.times do
      x = "0" + "#{x}"
    end
  else
    x = x.to_s
  end
  if x.include?("0") && x.include?("9")
    cnt += 1
  end
end

puts cnt % (10 ** 9 + 7)
//  [ruby]
n = gets.to_i

mod = 10**9 + 7

ans = 10.pow(n, mod)
ans -= 9.pow(n, mod) * 2
ans += 8.pow(n, mod)
puts ans
//  [ruby]
N = gets.chomp.to_i

waru = 10 ** 9 + 7

puts 10.pow(N, waru) - 2 * (9.pow(N, waru)) + 8.pow(N, waru)
//  [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 mod_pow(x: i64, y: i64, z: i64) -> i64 {
    if y == 0 {
        1
    } else {
        let h = mod_pow(x, y / 2, z);
        let res = (h * h) % z;
        if y % 2 == 0 {
            res
        } else {
            (res * x) % z
        }
    }
}
fn main() {
    input!{
        N: i64,
    }
    let M:i64 = 1_000_000_007;
    let ans = (M + mod_pow(10, N, M) - (mod_pow(9, N, M) * 2 % M - mod_pow(8, N, M)) % M)%M;
    println!("{}", ans);
}
//  [rust]
use proconio::{fastout, input};
const MOD: i128 = 1_000_000_000 + 7;

#[fastout]
fn main() {
    input! {
        n: usize,
    }

    let mut pow10 = vec![1i128; n + 1];
    for i in 1..=n {
        pow10[i] = pow10[i - 1] * 10 % MOD;
    }

    let mut pow9 = vec![1i128; n + 1];
    for i in 1..=n {
        pow9[i] = pow9[i - 1] * 9 % MOD;
    }

    let mut pow8 = vec![1i128; n + 1];
    for i in 1..=n {
        pow8[i] = pow8[i - 1] * 8 % MOD;
    }

    let ans = (pow10[n] - 2 * pow9[n] + pow8[n] + MOD) % MOD;

    println!("{}", ans);
}
//  [rust]
use proconio::{fastout, input};
const MOD: i128 = 1_000_000_000 + 7;

#[fastout]
fn main() {
    input! {
        n: usize,
    }

    let mut pow10 = vec![1i128; n + 1];
    for i in 1..=n {
        pow10[i] = pow10[i - 1] * 10 % MOD;
    }

    let mut pow9 = vec![1i128; n + 1];
    for i in 1..=n {
        pow9[i] = pow9[i - 1] * 9 % MOD;
    }

    let mut pow8 = vec![1i128; n + 1];
    for i in 1..=n {
        pow8[i] = pow8[i - 1] * 8 % MOD;
    }

    let ans = (pow10[n] - 2 * pow9[n] + pow8[n]) % MOD;

    println!("{}", ans);
}
//  [rust]
use proconio::{fastout, input};
const MOD: isize = 1_000_000_000 + 7;

#[fastout]
fn main() {
    input! {
        n: usize,
    }

    let mut pow10 = vec![1isize; n + 1];
    for i in 1..=n {
        pow10[i] = pow10[i - 1] * 10 % MOD;
    }

    let mut pow9 = vec![1isize; n + 1];
    for i in 1..=n {
        pow9[i] = pow9[i - 1] * 9 % MOD;
    }

    let mut pow8 = vec![1isize; n + 1];
    for i in 1..=n {
        pow8[i] = pow8[i - 1] * 8 % MOD;
    }

    let ans = (pow10[n] - 2 * pow9[n] + pow8[n]) % MOD;

    println!("{}", ans);
}
//  [swift]
let n = Int(readLine()!)!
let mod = 1000000007

var ten = 1
var nine = 1
var eight = 1
for _ in 1...n {
    ten *= 10
    ten %= mod

    nine *= 9
    nine %= mod

    eight *= 8
    eight %= mod
}

let result = (ten - eight - ((nine - eight) * 2)) % mod
if result >= 0 {
    print(result)
} else {
    print(mod + result)
}
//  [swift]

let n = Int(readLine()!)!
let devider = 1000_000_000 + 7

func powerOfTwo(num: Int, multiply: Int) -> Int {
    var result = 1
    for _ in 0..<num {
        result = (result * multiply) % devider
    }
    return result
}

let universe = powerOfTwo(num: n, multiply: 10)
let nWithoutZero = powerOfTwo(num: n, multiply: 9)
let nWithoutNine = powerOfTwo(num: n, multiply: 9)
let nWIthoutZeroAndNine = powerOfTwo(num: n, multiply: 8)

if n == 1 {
    print(0)
} else {
    let ans = (universe - nWithoutZero - nWithoutNine + nWIthoutZeroAndNine) % devider
    print((ans+devider)%devider)
}
//  [typescript]
import { readFileSync } from "fs";

// eslint-disable-next-line @typescript-eslint/no-unused-vars
const range = (n: number | bigint) => [...Array(Number(n))].map((_, i) => i);
// eslint-disable-next-line @typescript-eslint/no-unused-vars
const tuple = <T extends unknown[]>(...ts: T) => ts;
// eslint-disable-next-line @typescript-eslint/no-unused-vars
const [cin, nCin, bCin] = (() => {
  const inputs = readFileSync("/dev/stdin", "utf-8").split(/[\n|\s]+/);
  let count = 0;
  const cin = () => inputs[count++];
  return tuple(
    cin,
    () => Number(cin()),
    () => BigInt(cin())
  );
})();
// eslint-disable-next-line @typescript-eslint/no-unused-vars
const isNumber = (x: unknown): x is number => typeof x === "number";
// eslint-disable-next-line @typescript-eslint/no-unused-vars
const isBigint = (x: unknown): x is bigint => typeof x === "bigint";
type NumberOrBigintOrElse<T> = number | bigint extends T
  ? undefined
  : T extends number
  ? number
  : T extends bigint
  ? bigint
  : undefined;
// eslint-disable-next-line @typescript-eslint/no-unused-vars
const max = <T extends number | bigint>(...ts: T[]) =>
  (ts.length === 0
    ? undefined
    : isNumber(ts[0])
    ? Math.max(...(ts as number[]))
    : (ts as bigint[]).reduce((acc, t) =>
        acc >= t ? acc : t
      )) as NumberOrBigintOrElse<T>;
// eslint-disable-next-line @typescript-eslint/no-unused-vars
const min = <T extends number | bigint>(...ts: T[]) =>
  (ts.length === 0
    ? undefined
    : isNumber(ts[0])
    ? Math.min(...(ts as number[]))
    : (ts as bigint[]).reduce((acc, t) =>
        acc <= t ? acc : t
      )) as NumberOrBigintOrElse<T>;
// eslint-disable-next-line @typescript-eslint/no-unused-vars
const abs = <T extends number | bigint>(t: T) =>
  (isNumber(t)
    ? Math.abs(t)
    : isBigint(t)
    ? t >= 0n
      ? t
      : -t
    : undefined) as NumberOrBigintOrElse<T>;

/**
 * Program
 */

const P = 10n ** 9n + 7n;
const addP = (x: bigint, y: bigint) => ((x % P) + (y % P)) % P;
const subP = (x: bigint, y: bigint) => ((x % P) - (y % P) + P) % P;
const prodP = (x: bigint, y: bigint) => ((x % P) * (y % P)) % P;
const pow = (x: bigint, n: bigint): bigint => {
  let tmpN = n;
  const isEvens: boolean[] = [];
  while (tmpN !== 1n) {
    isEvens.push(tmpN % 2n === 0n);
    tmpN /= 2n;
  }
  return isEvens.reduceRight((acc, b) => {
    const tmp = prodP(acc, acc);
    return b ? tmp : prodP(x, tmp);
  }, x);
};
const getAns = (N: bigint): string =>
  addP(subP(pow(10n, N), prodP(2n, pow(9n, N))), pow(8n, N)).toString();
{
  const N = bCin();
  const ans = getAns(N);
  console.log(ans);
}
//  [typescript]
"use strict"
let fs = require('fs');
let input = fs.readFileSync("/dev/stdin", "utf8").split(/\n/);

const N = +input[0];
const MOD = 10 ** 9 + 7;

const PowMod = (x: number, n: number) => {
  let det = 1;
  for (let i = 0; i < n; i++) det = det * x % MOD;
  return det;
}

console.log((PowMod(10, N) - PowMod(9, N) - PowMod(9, N) + PowMod(8, N)) % MOD);
//  [typescript]
import { readFileSync } from 'fs'
import { reverse } from 'dns'
import { start } from 'repl'
 
let lines: string[] = [];
const reader = require('readline').createInterface({
    input: process.stdin,
    output: process.stdout
});
 
reader.on('line', function (line: string) {
    lines.push(line);
});
reader.on('close', function () {
    let n = lines[0].split(' ').map( _ => parseInt(_))
    let ten = 1
    let nine = 1
    let eight = 1
    const amari = 1000000007
    
    for(let i = 0; i < n[0]; i++) {
        ten *= 10
        ten %= amari
        nine *= 9
        nine %= amari
        eight *= 8
        eight %= amari
    }

    let ans = ten - nine + eight
    ans = (ans + amari - nine) % amari

    console.log(ans)
});
//  [python]
A,B,X=map(int,input().split())
print('YNEOS'[not A<=X<=A+B::2])
//  [python]
a, b, x = map(int, input().split())
if x < a:
    print("NO")
else:
    if a + b >= x:
        print("YES")
    else:
        print("NO")
//  [python]
A, B, X = list(map(int, input().split()))

if A <= X <= (A+B):
    print('YES')
else:
    print('NO')
//  [python]
a,b,x = map(int,input().split())
if x - a < 0:
    print("No")
else:
    print(("NO","YES")[x-a<=b])
//  [python]
a,b,x = map(int,input().split())
print(("NO","YES")[x-a<=b])
//  [python]
a,b,x = map(int,input().split())
print(("No","Yes")[x-a<=b])