jiahuimbzuai/CoQuIR huggingface dataset:
//  [typescript]
import * as fs from "fs";

const input = (fs.readFileSync("/dev/stdin", "utf8") as string).split("\n");
const [a,b,c] = input[0].split(" ").map((x: string): number => +x);

let out = 'No'
if((a < c && c < b) || (b < c && c < a)){
  out = 'Yes'
}

console.log(out);
//  [typescript]
const Main = input=>{                                                               
  const given = input.split(' ')                                                    
  given.forEach((elm,i,arr)=>{arr[i] = Number(elm);});                              
  const AtoC = given[2] - given[0];                                                 
  const CtoB = given[1] - given[2];                                                 

  console.log(Math.sign(AtoC)===Math.sign(CtoB) ? "Yes":"No");                      
};

Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [python]
s = input()
print(s[:3])
//  [python]
s = input()
print(s[0:3])
//  [python]
S = input()

print(S[0:3])
//  [python]
import math
import string
import collections
from collections import Counter
from collections import deque
from decimal import Decimal
import sys
import fractions


def readints():
    return list(map(int, input().split()))


def nCr(n, r):
    return math.factorial(n)//(math.factorial(n-r)*math.factorial(r))


def has_duplicates2(seq):
    seen = []
    for item in seq:
        if not(item in seen):
            seen.append(item)
    return len(seq) != len(seen)


def divisor(n):
    divisor = []
    for i in range(1, n+1):
        if n % i == 0:
            divisor.append(i)
    return divisor


# coordinates
dx = [-1, -1, -1, 0, 0, 1, 1, 1]
dy = [-1, 0, 1, -1, 1, -1, 0, 1]
s = input()
print(s[:3])
//  [python]
# -*- coding: utf-8 -*-
import bisect
import heapq
import math
import random
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul, sub


import sys
# sys.setrecursionlimit(10**6)
# buff_readline = sys.stdin.buffer.readline
buff_readline = sys.stdin.readline
readline = sys.stdin.readline

INF = 2**62-1


def read_int():
    return int(buff_readline())


def read_int_n():
    return list(map(int, buff_readline().split()))


def read_float():
    return float(buff_readline())


def read_float_n():
    return list(map(float, buff_readline().split()))


def read_str():
    return readline().strip()


def read_str_n():
    return readline().strip().split()

def error_print(*args):
    print(*args, file=sys.stderr)


def mt(f):
    import time

    def wrap(*args, **kwargs):
        s = time.time()
        ret = f(*args, **kwargs)
        e = time.time()

        error_print(e - s, 'sec')
        return ret

    return wrap


@mt
def slv(S):
    return S[:3]


def main():
    S = read_str()
    print(slv(S))


if __name__ == '__main__':
    main()
//  [java]
import java.util.*;
import java.io.*;
import java.math.BigInteger;

public class Main {	

	private static void solve(){
		//Implement solution here.
		String S = next();
		for(int i = 0; i < 3; i++) {
			System.out.print(S.charAt(i));
		}
	}
	
	//Switch input source (stdin/file)
	private static BufferedReader br;
	public static void main(String[] args){
		br = new BufferedReader(new InputStreamReader(System.in));
		String debugDataPath = System.getenv("DD_PATH");        
		if(debugDataPath != null){
			try{
				br = new BufferedReader(new InputStreamReader(new FileInputStream(new File(debugDataPath))));
			}catch(Exception e){
				throw new RuntimeException(e);
			}
		}
		boolean hasNext = true;
		while(hasNext){
			solve();	
			try{
				br.mark(1);
				if(br.read() > 0){
					br.reset();			
					System.out.println("---");
				} else {
					hasNext = false;
				}
			}catch(Exception e){
				throw new RuntimeException(e);
			} 
		}
	}

	//Input read utility
	private static StringTokenizer tokenizer = null;
	public static String next() {
		while (tokenizer == null || !tokenizer.hasMoreTokens()) {
			try {
				tokenizer = new StringTokenizer(br.readLine());
			} catch (Exception e) {
				throw new RuntimeException(e);
			}
		}
		return tokenizer.nextToken();
	}
	//Get next single int
	private static int ni() {
		return Integer.parseInt(next());
	}
	//Get next single long
	private static long nl() {
		return Long.parseLong(next());
	}
	//Get next single double
	private static double nd() {
		return Double.parseDouble(next());
	}
	//Get next int array from one line
	private static int[] na(int n) {
		int[] a = new int[n];
		for (int i = 0; i < n; i++)
			a[i] = ni();
		return a;
	}
	//Get next char array from one line
	private static char[] ns() {
		return next().toCharArray();
	}
	//Get next long array from one line
	private static long[] nal(int n) {
		long[] a = new long[n];
		for (int i = 0; i < n; i++)
			a[i] = nl();
		return a;
	}
}
//  [java]
import java.util.*;
import java.io.*;
public class Main {

	public static void main(String[] args) throws Exception{
		int num = 998244353;

		// TODO Auto-generated method stub
 		BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
 		PrintWriter out = new PrintWriter(System.out);
 		String a  = bf.readLine();
 		out.println(a.substring(0, 3));

 		out.close();
 		
 		
 		
 	}
}
 	
 
//StringJoiner sj = new StringJoiner(" "); 
//sj.add(strings)
//sj.toString() gives string of those stuff w spaces or whatever that sequence is
//  [java]
import java.util.Scanner;
class Main{
	public static void main(String[] args){
    	Scanner sc = new Scanner(System.in);
      	String name = sc.next();
      	System.out.println(name.substring(0,3));
    }
}
//  [java]
import java.util.*;
 
class Main{
  public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    
    String s = sc.next();
    String ans = "";
    for(int i=0; i<3; i++){
      ans += s.charAt(i);
    }
    System.out.println(ans);

    sc.close();
  }
}
//  [java]
import java.util.*; 

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

		String nick = sc.next();

		for(int i=0;i<3;i++){
			System.out.print(nick.charAt(i));
		}
		}
	}
//  [cpp]
#include<cstdio>

char s[100];

int main() {
  scanf("%s", s);
  printf("%c%c%c\n", s[0], s[1], s[2]);
}
//  [cpp]
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;

char s[30];

int main(void)
{
	scanf("%s",s+1);
	s[4] = 0;
	printf("%s",s+1);
	return 0;
}
//  [cpp]
#include<cstdio>
#include<cmath>
#include<algorithm>
#include<cstdlib>
#include<cstring>
using namespace std;
inline int read()
{
	int x=0,f=1;char ch=getchar();
	while(ch<'0' || ch>'9'){if(ch=='-')f=-1;ch=getchar();}
	while(ch>='0' && ch<='9')x=x*10+ch-'0',ch=getchar();
	return x*f;
}
int stack[20];
inline void write(int x)
{
	if(x<0){putchar('-');x=-x;}
	if(!x){putchar('0');return;}
	int top=0;
	while(x)stack[++top]=x%10,x/=10;
	while(top)putchar(stack[top--]+'0');
}
inline void pr1(int x){write(x),putchar(' ');}
inline void pr2(int x){write(x),puts("");}
char ss[25];
int main()
{
    //freopen("a.in","r",stdin);
    //freopen("a.out","w",stdout);
    scanf("%s",ss+1);
    printf("%c%c%c",ss[1],ss[2],ss[3]);
    puts("");
    return 0;
}
//  [cpp]
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <cmath>
#include <map>
#include <numeric>
#include <set>
#include <queue>
#include <list>
using namespace std;
typedef long long ll;
const int N = 1e7 + 3;
vector<ll> temp(N, -1);

void sieve() {
	for (ll i = 2; i * i <= N; i++) {
		if (temp[i] == -1) {
			for (ll j = i * i; j <= N; j += i)temp[j] = i;
		}
	}
	return ;
}


void solve() {
	string s; cin >> s;
	cout << s.substr(0, 3);



}

int main() {
	ios_base::sync_with_stdio(false); cin.tie(NULL);
#ifndef ONLINE_JUDGE
	freopen("input.txt", "r", stdin);
	freopen("output.txt", "w", stdout);
#endif

	// int t; cin >> t;
	// while (t--)
	solve();

}
//  [c]
int main(void){
  putchar_unlocked(getchar_unlocked());
  putchar_unlocked(getchar_unlocked());
  putchar_unlocked(getchar_unlocked());
  putchar_unlocked(10);
}
//  [c]
#include<stdio.h>
int main()
{
  char s[50];
  
  scanf("%s",s);
  printf("%.3s",&s);
  
  return 0;
};
//  [c]
#include    <stdio.h>
#include    <string.h>

int main(void)
{
    char    s[21];
    fgets(s, sizeof s, stdin);
    s[3] = '\0';
    printf("%s\n", s);
    return 0;
}
//  [c]
#include<stdio.h>

int main(){
  char name[25];
  scanf("%s",name);
  name[3]='\0';
  printf("%s",name);
}
//  [c]
#include <stdio.h>
int main(void){
    char a[3];
    scanf("%c%c%c",&a[0],&a[1],&a[2]);
    printf("%c%c%c",a[0],a[1],a[2]);
    return 0;
}
//  [c]
#include<stdio.h>
#include<stdlib.h>
#include<math.h>

int main() {
	char s[20];
	scanf("%s", s);
	for (int i = 3; i < 20; i++) {
		s[i] = 0;
	}
	printf("%s", s);

	return 0;
}
//  [javascript]
"use strict";

const main = (arg) => {
  const input = arg.trim().split("\n")[0];
  console.log(input.substr(0, 3));
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [javascript]
function main(input) {
  var name = input;
  console.log(name[0] + name[1] + name[2]);
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [javascript]
"use strict";

const main = arg => {
    const inputList = arg.trim().split("\n");
    // 回答を記述
    const S = inputList[0];
    console.log(S.slice(0, 3))
}

main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [javascript]


function main(input) {
    console.log(input.slice(0,3))
}

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

const main = (INPUT) => {
  const S = INPUT.split('\n')[0]
  console.log(S.slice(0, 3))
}

main(require('fs').readFileSync('/dev/stdin', 'utf8'))
//  [javascript]
process.stdin.resume();
process.stdin.setEncoding('utf8');
                     
var lines = [];
var reader = require('readline').createInterface({
    input: process.stdin,
    output: process.stdout
});
reader.on('line', (line) => {
    // ここで入力を処理する
    lines.push(line);
});
reader.on('close', () => {
    // ここで出力する
  var S = lines[0];
  console.log(S.substring(0,3));
});
//  [go]
package main

import (
	"bufio"
	"fmt"
	"io"
	"math"
	"os"
)

func main() {
	sc := NewScanner(os.Stdin)
	sc.Scan()
	s := sc.Text()
	fmt.Println(string([]rune(s)[:3]))
}

// Scanner is a wrapper of bufio.Scanner which is customized for competitive programing.
type Scanner struct {
	bufio.Scanner
}

// NewScanner is a constructor for Scanner.
func NewScanner(r io.Reader) *Scanner {
	sc := Scanner{*bufio.NewScanner(r)}
	sc.Buffer([]byte{}, math.MaxInt64)
	sc.Split(bufio.ScanWords)
	return &sc
}
//  [go]
package main

import (
	"fmt"
	"strings"
)

// go run ./main.go < in

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

	inputs := strings.Split(a, "")

	for i := 0; i < 3; i++ {
		fmt.Printf("%s", inputs[i])
	}

}
//  [go]
package main

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

const (
	initialBufSize = 1e4
	maxBufSize     = 1e10
)

var sc = bufio.NewScanner(os.Stdin)

func next() string {
	sc.Scan()
	return sc.Text()
}

func nextInt() int {
	sc.Scan()
	i, e := strconv.Atoi(sc.Text())
	if e != nil {
		panic(e)
	}
	return i
}

func nextFloat() float64 {
	sc.Scan()
	i, e := strconv.ParseFloat(sc.Text(), 64)
	if e != nil {
		panic(e)
	}
	return i
}

func main() {
	buf := make([]byte, initialBufSize)
	sc.Buffer(buf, maxBufSize)
	//sc.Split(bufio.ScanWords)

	s := next()
	fmt.Println(s[:3])

}

func intSlicePrint(el ...int) {
	first := true
	for _, v := range el {
		if v < 0 {
			continue
		}
		if !first {
			fmt.Printf(" ")
		}
		fmt.Printf("%v", v)
		first = false
	}
	fmt.Println("")
}

func max(a, b int) int {
	if a > b {
		return a
	}
	return b
}

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

func abs(n int) int {
	if n < 0 {
		return -n
	}
	return n
}
//  [go]
package main

import (
	"fmt"
)

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

	fmt.Println(s[:3])
}
//  [go]
package main

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

var sc = bufio.NewScanner(os.Stdin)

// 1行読み込み
func nextLine() string {
	sc.Scan()
	return sc.Text()
}

func main() {
	// scannerの挙動を改行区切り → 空白区切りに変更
	sc.Split(bufio.ScanWords)
	name := nextLine()
	fmt.Println(name[0:3])
}
//  [ruby]
s = gets.rstrip
puts s[0, 3]
//  [ruby]
s=gets.split('')
print s[0]+s[1]+s[2]
//  [ruby]
s = gets.chomp
puts s[0, 3]
//  [ruby]
#exec({'RUBY_THREAD_VM_STACK_SIZE'=>'100000000'},'/usr/bin/ruby', $0) if !ENV['RUBY_THREAD_VM_STACK_SIZE']
require 'prime'

def inpf() a=gets.chomp.split(" ").map(&:to_f)end

def inps() a=gets.chomp.split(" ")end

def copy(a) Marshal.load(Marshal.dump(a)) end

def kaijo(n,r = 10**9+7)(n < 2)? 1 : (2..n).inject{|memo,u|memo=(memo*u)%r} end

def na(n,d=0) Array.new(n,d)end

def na2(n,m,d=0) Array.new(n){Array.new(m,d)}end

def na3(n,m,l,d=0) Array.new(n){Array.new(m){Array.new(l,d)}}end

def inp() a=gets.chomp.split(" ").map(&:to_i)end

def r_up(a, b) (a+b-1)/b end

def sum(a) a.inject(:+) end

def big(a,b) return (a>b)? a:b end

def small(a,b) return (a<b)? a:b end

s = gets.chomp
puts s[0..2]
//  [ruby]
getter = -> {
   require 'stringio'
  _in = StringIO.new
  while l = gets
    _in << l
  end
  _in.string
}
puts getter.call[0..2]
//  [ruby]
require 'pp'

s = gets.chomp!
puts s[0,3]
//  [rust]
#![allow(unused_macros)]
#![allow(dead_code)]
#![allow(unused_imports)]

use text_io::*;

fn main() {
    let s: String = read!();
    println!("{}", &s[0..3]);
}
//  [rust]
use proconio::{input, fastout};

macro_rules! echo {
  ($val:expr) => {
    println!("{}", $val);
  }
}

#[fastout]
fn main() {
  input!{
    s: String
  };
  echo!(&s[0..3]);
}
//  [rust]
#![allow(unused)]

use proconio::input;
use proconio::marker::{Bytes, Chars, Usize1};
use std::cmp::{Reverse, min, max};
use itertools::Itertools;

#[proconio::fastout]
fn main() {
    input! {
        s: String,
    }

    println!("{}", &s[0..3]);
}
//  [swift]
func main() {
    let a = String(readLine()!)
    var b = [String]()
    for num in a{
        b.append(String(num))
    }
 
    let iValue = Int.random(in: 0 ... (a.count - 3))
    
    
    let answer = b[iValue] + b[iValue + 1] + b[iValue + 2]
    print(answer)
}
main()
//  [swift]
        let S = readLine()!
        print(S.prefix(3))
//  [swift]
let S = readLine()!
let i = S.index(S.startIndex, offsetBy: 3)
print(S[..<i])





func readInts() -> [Int] {
    readLine()!.split(separator: " ").map { Int($0)! }
}

extension Collection {
    func mapToTuple() -> (Element, Element) {
        var i = makeIterator()
        return (i.next()!, i.next()!)
    }
    func mapToTuple() -> (Element, Element, Element) {
        var i = makeIterator()
        return (i.next()!, i.next()!, i.next()!)
    }
    func mapToTuple() -> (Element, Element, Element, Element) {
        var i = makeIterator()
        return (i.next()!, i.next()!, i.next()!, i.next()!)
    }

    subscript(gen: Index) -> Element {
        _modify { yield &self[index(gen, offsetBy: -1)] }
        _read   { yield self[index(gen, offsetBy: -1)] }
    }
}
//  [swift]
print(String(Array(readLine()!)[..<3]))
//  [swift]
import Foundation

func main(){
    let str = readLine()!
    
    print(str.prefix(3))
}
main()
//  [typescript]
// import std = require('tstl')

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

  const main = (): Print => {
    const r = _io()
    const [S] = r.ss()

    return S.substr(0, 3)
  }

  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]
"use strict";

const main = arg => {
  const input = arg.trim().split("\n");
  const S = input[0];
  console.log(S.substring(0,3));
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [python]
import sys
from collections import deque
import bisect
import copy
import heapq
import itertools
import math
import random
input = sys.stdin.readline
sys.setrecursionlimit(1000000)
mod = 10 ** 9 + 7

def read_values(): return map(int, input().split())
def read_index(): return map(lambda x: int(x) - 1, input().split())
def read_list(): return list(read_values())
def read_lists(N): return [read_list() for n in range(N)]


def main():
    K = int(input())
    print("ACL" * K)


if __name__ == "__main__":
    main()
//  [python]
# -*- coding: utf-8 -*-
import bisect
import heapq
import math
import random
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from fractions import Fraction
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations, accumulate
from operator import add, mul, sub, itemgetter, attrgetter


import sys
# sys.setrecursionlimit(10**6)
# readline = sys.stdin.buffer.readline
readline = sys.stdin.readline

INF = 1 << 60


def read_int():
    return int(readline())


def read_int_n():
    return list(map(int, readline().split()))


def read_float():
    return float(readline())


def read_float_n():
    return list(map(float, readline().split()))


def read_str():
    return readline().strip()


def read_str_n():
    return readline().strip().split()


def ep(*args):
    print(*args, file=sys.stderr)


def mt(f):
    import time

    def wrap(*args, **kwargs):
        s = time.perf_counter()
        ret = f(*args, **kwargs)
        e = time.perf_counter()

        ep(e - s, 'sec')
        return ret

    return wrap


@mt
def slv(K):
    return "ACL" * K


def main():
    k = read_int()
    print(slv(k))


if __name__ == '__main__':
    main()
//  [java]
import java.util.*;
import java.math.RoundingMode;
import java.math.BigDecimal;
 
 
public class Main{
	public static void main (String[] args){
		Scanner sc = new Scanner(System.in);
		long n = sc.nextLong();
		String ans = "";
		for(int i = 0; i < n; i++) {
			ans += "ACL";
		}
		System.out.println(ans);
	}
}
//  [java]
import java.util.*;
public class Main{
    public static void main(String[] args){
        Scanner sc= new Scanner(System.in);
        String s ="ACL";
        String t="";
        int n = sc.nextInt();
    	for(int k=1;k<=n;k++){
            t += s;
        }
        System.out.println(t);
    }
}
//  [java]
import java.util.*;
import java.io.*;
public class Main{
    static PrintWriter out;
    static Scanner sc;
    public static void main(String[] args){
        sc=new Scanner(System.in);
        out=new PrintWriter(System.out);

        int t=1;
      //  t=sc.nextInt();
        while(t-->0){
            forEachTestcase();
        }

        out.close();
    }

    static void forEachTestcase(){
        int n=sc.nextInt();
        String ans="";
        String s="ACL";
        for(int i=0;i<n;i++){
            ans+=s;
        }
        System.out.println(ans);
    }

    static class modOpeation{
        static long mod;
        modOpeation(long mod){
            this.mod=mod;
        }
        static long mul(long a,long b){
            a%=mod;
            b%=mod;
            return (a*b)%mod;
        }
        static long add(long a,long b){
            a%=mod;
            b%=mod;
            return (a+b)%mod;
        }
        static long sub(long a,long b){
            a%=mod;
            b%=mod;
            return ((a-b)%mod+mod)%mod;
        }
        static long modPow(long a,long b){
            long ans=1;
            while(b>0){
                if(b%2==1)ans=mul(ans,a);
                a=mul(a,a);
                b>>=1;
            }
            return ans;
        }
        static long modInv(long a){
            return modPow(a,mod-2);
        }
        static long ifact[],fact[];
        static long nCr(int n,int r){
            if(r>n)return 0;
            return mul(fact[n],mul(ifact[r],ifact[n-r]));
        }
        static void initFactorial(int max){
            fact=new long[max];
            ifact=new long[max];
            fact[0]=ifact[0]=1;
            for (int i = 1; i <max ; i++) {
                fact[i]=mul(fact[i-1],i);
                ifact[i]=mul(ifact[i-1],modInv(i));
            }
        }
    }

}
//  [cpp]
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<int, int>;
using pll = pair<ll, ll>;
using vi = vector<int>;
using vvi = vector<vi>;
using vl = vector<ll>;
using vvl = vector<vl>;
using vd = vector<double>;
using vp = vector<P>;
using vs = vector<string>;

#define INF 1000000005
#define mod 1000000007
#define EPS 1e-10
#define rep(i,n) for(int i = 0; i < (n); ++i) /*0からn-1までのrep*/
#define rrep(i,n) for(int i = 1; i <= (n); ++i) /*1からnまでのrep*/
#define drep(i,n) for(int i = (n)-1; i >= 0; --i) /*n-1から0までのrep*/
#define srep(i,s,t) for (int i = s; i < t; ++i) /*sからt-1までのrep*/
#define each(a,b) for(auto& (a): (b)) /*よくわからん*/
#define all(v) (v).begin(),(v).end() /*全選択*/
#define sz(v) (int)(v).size() /*大きさ*/
#define zip(v) sort(all(v)),v.erase(unique(all(v)),v.end()) /*重複削除*/
#define cmx(x,y) x=max(x,y) /*最大値*/
#define cmn(x,y) x=min(x,y) /*最小値*/
#define fi first
#define se second
#define pb push_back //a.push_back(最後に任意の数字を追加); a.pop_back();
#define rev(v) reverse((v).begin(),(v).end());
#define so(v) sort((v).begin(), (v).end()); //sort((v).begin(), (v).end(), greater<int>());
#define yn {puts("Yes");}else{puts("No");}
const double eps = 1e-10;
const ll MOD = 1000000007;
constexpr ll MAX = 5000000;

ll gcd(ll a, ll b) { return b?gcd(b,a%b):a;}
ll lcm(ll a, ll b) { return a/gcd(a,b)*b;}

ll fac[MAX],finv[MAX],inv[MAX];

// テーブルを作る前処理
void COMinit() {
    fac[0] = fac[1] = 1;
    finv[0] = finv[1] = 1;
    inv[1] = 1;
    for (int i = 2; i < MAX; 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;
    }
}
 
// 二項係数計算
long long COM(int n, int k){
    if (n < k) return 0;
    if (n < 0 || k < 0) return 0;
    return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}

int main(){
    COMinit();//COM(n,k) : nCk
    int n;
    cin >> n;
    rep(i,n){
        cout << "ACL";
    }
    return 0;
}
//  [c]
#include <stdio.h>

int main(void){
  
  int k;
  scanf("%d", &k);
  
  for(int i = 0; i < k;i++){
	printf("ACL");
  }
  
  return 0;
}
//  [c]
#include <stdio.h>
#include <string.h>

int main (){
    int i=1,k;
    char vet[16];
    scanf("%d", &k);

    strcpy(vet, "ACL");

    while(i != k ){
        strcat(vet,"ACL");
        k--;
    }
    printf("%s\n", vet);
    return 0;
}
//  [c]
#include<stdio.h>
int main()
{
    int k,i=0;
    scanf("%d",&k);
    while(i<k)
    {
        printf("ACL");
        i++;
    }
    return 0;
}
//  [javascript]
function Main(input) {

    let output = "";

    for(i = 0; i < input[0]; i++){
        output = output + "ACL";
    }

    console.log(output);
}
//*この行以降は編集しないでください（標準入出力から一度に読み込み、Mainを呼び出します）
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
process.stdin.resume();
process.stdin.setEncoding('utf8');

var lines = [];
var reader = require('readline').createInterface({
  input: process.stdin,
  output: process.stdout
});
reader.on('line', (line) => {
  lines.push(line);
});
reader.on('close', () => {
const n = Number(lines[0]);
const str = "ACL";
console.log(str.repeat(n));
});
//  [javascript]
// inputに入力データ全体が入る
function Main(original_input) {
 input = original_input.trim().split("\n");
 var k = parseInt(input[0], 10);
 var str ="";

 for(let i=1; i<k+1; i++){
  str += 'ACL';
 }
 console.log(str);
} 

//*この行以降は編集しないでください（標準入出力から一度に読み込み、Mainを呼び出します）
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [go]
package main

import (
	"fmt"
	"strings"
)

func main() {
	// Code for A - Repeat ACL
	var K int
	fmt.Scan(&K)
	ans := strings.Repeat("ACL", K)
	fmt.Println(ans)
}
//  [go]
package main

import "fmt"

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

	for i := 0; i < k; i++ {
		fmt.Print("ACL")
	}
	fmt.Println()
}
//  [ruby]
# set
k = gets.chomp.to_i
answer = ""
string= "ACL"

# main
0.upto(k - 1) do |i|
  answer = "#{answer}#{string}"
end
print ("#{answer}\n")
//  [ruby]
K = gets.to_i
puts 'ACL' * K
//  [ruby]
$><<"ACL"*gets.to_i
//  [swift]
let n = "ACL"
let k = Int(readLine()!)!
var result: String = ""

for i in 0..<k {
	result += n
}
print(result)
//  [swift]
import Foundation

var acl = "ACL"
let n = Int(readLine()!)!
var num=""
for _ in 1...n{
    num += acl
}
print(num)
//  [swift]
import Foundation

let N = Int(readLine()!)!
var ans = ""
for _ in 1...N{
  ans = "ACL" + ans
}
print(ans)
//  [python]
import numpy as np
import sys
input = sys.stdin.readline

def main():

    list = np.array([1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1, 51])
    K = int(input())

    print(list[K-1])

if __name__ == '__main__':
    main()
//  [python]
import numpy as np
K = int(input())
c = np.asarray([1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1, 51])

print(c[K-1])
//  [python]
from sys import stdin
import numpy as np
from operator import itemgetter

K = int(stdin.readline().rstrip().split()[0])
#N, K = [int(x) for x in stdin.readline().rstrip().split()]
#A = [int(x) for x in stdin.readline().rstrip().split()]

MOD = 10**9 + 7

array = [1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1, 51]
print(array[K-1])
//  [java]
import java.util.Arrays;
import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        String str = "1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1, 51";
        int[] iArray = Arrays.stream(str.split(", ")).mapToInt(Integer::parseInt).toArray();

        Scanner sc = new Scanner(System.in);
    	int k = sc.nextInt();
    	System.out.println(iArray[k-1]);
    }
}
//  [java]
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

/**
 * for (int i = 0; i < N; i++) {}
 * System.out.println();
 * HashMap<Integer, Integer> hm = new HashMap<>();
 * int[] s = new int[M];
 * ArrayDeque<Integer> deq = new ArrayDeque<>();
 *
 */
public class Main implements Runnable { //クラス名はMain1

	public static void main(String[] args) {
		Thread.setDefaultUncaughtExceptionHandler((t, e) -> System.exit(1));
		new Thread(null, new Main(), "", 16 * 1024 * 1024).start(); //16MBスタックを確保して実行
	}

	public void run() {
		FastScannerMain1 sc = new FastScannerMain1(System.in);

		try {
			//String S = sc.nextLine().trim();
			int K = sc.nextInt();
			int[] a = { 1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4,
					1, 4, 1, 51 };
			//long l = sc.nextLong();
			//ArrayList<Integer> arr = new ArrayList<Integer>();

			for (int i = 1; i <= a.length; i++) {
				if (i == K) {
					System.out.println(a[i - 1]);
				}
			}

			System.out.println();

		} catch (Exception e) {
			e.printStackTrace();
		}

	}
}

//高速なScanner
class FastScannerMain1 {
	private BufferedReader reader = null;
	private StringTokenizer tokenizer = null;

	public FastScannerMain1(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;
	}
}
//  [cpp]
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
 
int main() {
   int a[]={1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1, 51};
   int k;
   cin>>k;
   cout<<a[k-1]<<endl;
}
//  [c]
#include <stdio.h>

int main()
{
	int K;
	int arr[32] = {1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1, 51};
	scanf("%d", &K);
	printf("%d\n", arr[K-1]);
	return 0;
}
//  [c]
#include <stdio.h>

static const int yukati[] = {
	1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1, 51
};

int main(void) {
	int K;
	if (scanf("%d", &K) != 1) return 1;
	if (K < 1 || (int)(sizeof(yukati) / sizeof(*yukati)) < K) {
		puts("f**k");
	} else {
		printf("%d\n", yukati[K - 1]);
	}
	return 0;
}
//  [c]
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

int main(void){
  //数列を格納する文字列str
  //int型の配列seq
  char str[1000] = "1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1, 51";
  int seq[32];
  char *p;
  
  //int型変数 K
  int K;
  char num[1000];

  //Kに値を格納する
  fgets(num, sizeof(num), stdin);
  K = atoi(num);
  
  int i = 1;
  p = strtok(str, ",");
  seq[0] = atoi(p);
  
  //seqに数値を格納していく
  while(p != NULL){
    p = strtok(NULL, ",");
    if(p == NULL){
      break;
    }
    seq[i] = atoi(p);
    i += 1;
  }
  
  printf("%d\n", seq[K - 1]);  
  return 0;
}
//  [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 a = [1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1, 51];
  var k = next();
  return a[k-1];
}
//  [javascript]
// inputに入力データ全体が入る
function Main(input) {
  // 1行目がinput[0], 2行目がinput[1], …に入る
  const K = input;
  var array = [
    1,
    1,
    1,
    2,
    1,
    2,
    1,
    5,
    2,
    2,
    1,
    5,
    1,
    2,
    1,
    14,
    1,
    5,
    1,
    5,
    2,
    2,
    1,
    15,
    2,
    2,
    5,
    4,
    1,
    4,
    1,
    51
  ];

  console.log(array[Number(K)-1]);
}
//*この行以降は編集しないでください（標準入出力から一度に読み込み、Mainを呼び出します）
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
function Main(inp) {
    var input = inp.split('\n');
    var K = Number(input[0]);
    var a = [1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1, 51];
    console.log(a[K - 1]);
}

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

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

func main() {
	sc := NewScanner()
	K := sc.NextInt()

	fmt.Println([]int{1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1, 51}[K-1])
}

type Scanner struct {
	r   *bufio.Reader
	buf []byte
	p   int
}

func NewScanner() *Scanner {
	rdr := bufio.NewReaderSize(os.Stdin, 1000)
	return &Scanner{r: rdr}
}
func (s *Scanner) Next() string {
	s.pre()
	start := s.p
	for ; s.p < len(s.buf); s.p++ {
		if s.buf[s.p] == ' ' {
			break
		}
	}
	result := string(s.buf[start:s.p])
	s.p++
	return result
}
func (s *Scanner) NextLine() string {
	s.pre()
	start := s.p
	s.p = len(s.buf)
	return string(s.buf[start:])
}
func (s *Scanner) NextInt() int {
	v, _ := strconv.Atoi(s.Next())
	return v
}
func (s *Scanner) NextInt64() int64 {
	v, _ := strconv.ParseInt(s.Next(), 10, 64)
	return v
}

func (s *Scanner) NextFloat() float64 {
	v, _ := strconv.ParseFloat(s.Next(), 64)
	return v
}

func (s *Scanner) NextIntArray() []int {
	s.pre()
	start := s.p
	result := []int{}
	for ; s.p < len(s.buf)+1; s.p++ {
		if s.p == len(s.buf) || s.buf[s.p] == ' ' {
			v, _ := strconv.ParseInt(string(s.buf[start:s.p]), 10, 0)
			result = append(result, int(v))
			start = s.p + 1
		}
	}

	return result
}
func (s *Scanner) NextInt64Array() []int64 {
	s.pre()
	start := s.p
	result := []int64{}
	for ; s.p < len(s.buf)+1; s.p++ {
		if s.p == len(s.buf) || s.buf[s.p] == ' ' {
			v, _ := strconv.ParseInt(string(s.buf[start:s.p]), 10, 64)
			result = append(result, v)
			start = s.p + 1
		}
	}
	return result
}

func (s *Scanner) NextMap() map[int]bool {
	s.pre()
	start := s.p
	mp := map[int]bool{}
	for ; s.p < len(s.buf); s.p++ {
		if s.buf[s.p] == ' ' {
			v, _ := strconv.Atoi(string(s.buf[start:s.p]))
			mp[v] = true
			start = s.p + 1
		}
	}
	v, _ := strconv.Atoi(string(s.buf[start:s.p]))
	mp[v] = true

	return mp
}

func (s *Scanner) pre() {
	if s.p >= len(s.buf) {
		s.readLine()
		s.p = 0
	}
}
func (s *Scanner) readLine() {
	s.buf = make([]byte, 0)
	for {
		l, p, e := s.r.ReadLine()
		if e != nil {
			panic(e)
		}
		s.buf = append(s.buf, l...)
		if !p {
			break
		}
	}
}
//  [go]
package main

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

const (
	initialBufSize = 100000
	maxBufSize     = 10000000
)

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

func next() string {
	sc.Scan()
	return sc.Text()
}

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

func puts(a ...interface{}) {
	fmt.Fprintln(wt, a...)
}

func main() {
	sc.Split(bufio.ScanWords)
	sc.Buffer(make([]byte, initialBufSize), maxBufSize)
	defer wt.Flush()

	a := []int{1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1, 51}

	k := nextInt()
	puts(a[k-1])
}
//  [go]
package main

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

func main() {
	v := []int{
		1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1, 51,
	}
	K := ReadInt()
	fmt.Println(v[K-1])
}

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 }
//  [ruby]
a = [1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1, 51]
puts a[gets.to_i-1]
//  [ruby]
#配列作成
s = [1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1, 51]

#標準入力を整数値として取得
K = gets.chomp.to_i

#配列sのK番目を出力
puts s[K-1]
//  [ruby]
n = gets().chomp.to_i

list = [1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1, 51]

puts list[n - 1]
//  [rust]
use std::io;

fn main() {
    let target_vec: Vec<i64> = vec![
        1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4,
        1, 51,
    ];

    let mut buffer = String::new();

    io::stdin().read_line(&mut buffer).unwrap();
    let index = buffer.trim().parse::<usize>().unwrap();
    println!("{}", target_vec[index - 1]);
}
//  [rust]
macro_rules! input {
    (source = $s:expr, $($r:tt)*) => {
        let mut iter = $s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
    ($($r:tt)*) => {
        let mut s = {
            use std::io::Read;
            let mut s = String::new();
            std::io::stdin().read_to_string(&mut s).unwrap();
            s
        };
        let mut iter = s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
}

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

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

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

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

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

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

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

// x ** n % mods を求める
pub fn mod_pow(x: i64, n: i64, mods: i64) -> i64 {
    if n == 0 {
        return 1;
    }
    let mut res = mod_pow(x * x % mods, n / 2, mods);
    if n % 2 == 1 {
        res = res * x % mods;
    }
    return res;
}

// (1/n) % mods を求める
pub fn mod_inv(n: i64, mods: i64) -> i64 {
    return mod_pow(n, mods-2, mods);
}

// nCk % mods を求める
pub fn mod_comb(n: i64, k: i64, mods: i64) -> i64 {
    let sum1 = (n-k+1..n+1).fold(1, |ac, x| ac * x % mods);
    let sum2 = (1..k+1).fold(1, |ac, x| ac * x % mods);
    return sum1 * mod_inv(sum2, mods) % mods;
}


fn main() {
    input!{
        k: usize,
    }
    let a: [i32; 32] = [1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1, 51];
    println!("{}", a[k-1]);
}
//  [rust]
#![allow(unused_imports)]

use text_io::*;
use proconio::*;
use std::collections::*;
use itertools::Itertools;
use std::process::exit;
use std::cmp::*;
use num::*;
use num::integer::Roots;

fn main() {
    input! {
    a:usize,
    }
    let v=[1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1, 51];
    {println!("{}",v[a-1])}
}
//  [swift]
import Foundation
 
let a=Int(readLine()!)!
var array = [1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1, 51
]
print(array[a-1]) //5
//  [swift]
import Foundation

let array = [1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1, 51
]
let input_line=Int(readLine()!)!

print(array[input_line-1])
//  [typescript]
import * as fs from "fs"


function Main(input: any) {
    const args = [1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1, 51]
    console.log(args[input as number - 1])
}

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

const k = +fs.readFileSync("/dev/stdin", "utf8");

const list = [1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1, 51];

const result = list[k - 1];
console.log(result);
//  [python]
import math
import numpy as np
import sys
input = sys.stdin.readline
def IL(): return list(map(int,input().split()))
def SL(): return input().split()
def I(): return int(sys.stdin.readline())
def S(): return input()

l = S()[:-1]
rel = S()[-2::-1]

if l == rel:
    print("YES")
else:
	print("NO")
//  [python]
a,b = raw_input(), raw_input()
print ('Yes' if a == b[::-1] else 'No').upper()
//  [python]
s=list(input())
t=list(input())
if s[::-1]==t:
  print("YES")
else: print("NO")
//  [java]
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.Serializable;
import java.lang.reflect.Field;
import java.nio.charset.StandardCharsets;
import java.util.List;
import java.util.stream.Collectors;

public class Main {

	public final static String YES = "YES";
	public final static String NO = "NO";

	public static void main(String[] args) {

		Main myself = new Main();
		myself.execute();

	}

	/**
	 * 実処理メソッド
	 */
	public void execute() {

		final List<String> lines = readStdin();

		final InputData inputData = parse(lines);

		System.out.print(inputData.isSameOnRotateing180() ? YES : NO);

	}

	/**
	 * @return
	 */
	private List<String> readStdin() {
		List<String> lines = new BufferedReader(new InputStreamReader(System.in, StandardCharsets.UTF_8)).lines()
				.collect(Collectors.toList());
		return lines;
	}

	/**
	 * @param inputlines
	 * @return
	 */
	private InputData parse(List<String> inputlines) {

		InputData data = new InputData();

		String firstLine = inputlines.get(0);
		String secondLine = inputlines.get(1);

		data.c11 = firstLine.charAt(0);
		data.c12 = firstLine.charAt(1);
		data.c13 = firstLine.charAt(2);

		data.c21 = secondLine.charAt(0);
		data.c22 = secondLine.charAt(1);
		data.c23 = secondLine.charAt(2);

		return data;
	}

	/**
	 * 
	 *
	 */
	private class InputData implements Serializable {

		/**
		 * 
		 */
		private static final long serialVersionUID = -6938809350516466787L;

		/**
		 * 
		 */
		public char c11;

		/**
		 * 
		 */
		public char c12;

		/**
		 * 
		 */
		public char c13;

		/**
		 * 
		 */
		public char c21;

		/**
		 * 
		 */
		public char c22;

		/**
		 * 
		 */
		public char c23;

		/*
		 * (non-Javadoc)
		 * 
		 * @see java.lang.Object#toString()
		 */
		public boolean isSameOnRotateing180() {

			return c11 == c23 && c12 == c22 && c13 == c21;
		}

	}

}
//  [java]
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;


public class Main {

	/**
	 * @param args
	 * @throws IOException 
	 */
	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		String str1 = br.readLine();
		String str2 = br.readLine();
		
		if(str1.charAt(0) == str2.charAt(2) && str1.charAt(1) == str2.charAt(1)
				&& str1.charAt(2) == str2.charAt(0)){
			System.out.println("YES");
		}
		else {
			System.out.println("NO");
		}
		
	}

}
//  [cpp]
#include<cstdio>
#include<cmath>
#include<cstdlib>
#include<cstring>
#include<algorithm>
using namespace std;

int main()
{
    char a[2][3];
    for(int i=0;i<2;i++)
    {
    		scanf("%s",a[i]);
	}
	int n=1;
	for(int i=0,j=2;i<=2,j>=0;i++,j--)
	{
	    if(a[0][i] != a[1][j])
        {
            n=0;
            break;
        }
	}
	if(n)
		printf("YES\n");
	else
		printf("NO\n");
	return 0;
}
//  [cpp]
#include <iostream>
using namespace std;

int main() {
	string s1,s2;
	cin>>s1>>s2;
	for(int i=0;i<3;i++)
	if(s1[i]!=s2[2-i])
	{
		cout<<"NO";
		return 0;
	}
	cout<<"YES";
	
	return 0;
}
//  [cpp]
#include<iostream>
#include <string> // string, to_string, stoi
#include <vector> // vector
#include <algorithm> // min, max, swap, sort, reverse, lower_bound, upper_bound
#include <utility> // pair, make_pair
#include <tuple> // tuple, make_tuple
#include <cstdint> // int64_t, int*_t
#include <cstdio> // printf
#include <map> // map
#include <queue> // queue, priority_queue
#include <set> // set
#include <stack> // stack
#include <deque> // deque
#include <unordered_map> // unordered_map
#include <unordered_set> // unordered_set
#include <bitset> // bitset
#include <cctype> // isupper, islower, isdigit, toupper, tolower
#include <iomanip>//setprecision
#include<math.h>
#include <functional>
#include<climits>
using namespace std;
#define ll  long long 
#define rep(i, n)        for(ll i=0; i<(ll)(n); ++i)
#define mod 1000000007
  vector<ll>to[1000005];
   ll dp[2000000];
 int gcd(int a, int b)
{
  if (a%b == 0)
{
return(b);
}
else
{
return(gcd(b,a%b));
}
}
int main(){
  string a,b;cin>>a>>b;
  reverse(a.begin(),a.end());
  if(a==b)cout<<"YES";
  else cout<<"NO";
}
//  [c]
#include<stdio.h>
#include<string.h>
int main(){
  char a[4],b[4];
  scanf("%s %s",&a,&b);
  if((a[0]==b[2])&&(a[1]==b[1])&&(a[2]==b[0]))
    printf("YES");
  else
    printf("NO");
  
  return 0;
}
//  [c]
#include<stdio.h>
#include<string.h>
int main()
{
   char s[10];
   char t[10];
   scanf("%s%s",&s,&t);
   int i,j,len,count=0;
   for(i=0,j=strlen(t)-1;i<strlen(s);i++,j--)
   {
       if(s[i]==t[j])
        count++;
   }
   if(count==strlen(s))
   {
       printf("YES");
   }
   else{printf("NO");}
}
//  [c]
#include<stdio.h>
int main(void)
{
  char s1[5];
  char s2[5];
  scanf("%s %s",s1,s2);
  for(int i=0;i<3;i++){
    if(s1[i]!=s2[2-i]){
      puts("NO");
      return 0;
    }
  }

  puts("YES");
  return 0;
}
//  [javascript]
(function() {
    'use strict';

    var lines = [];
    require('readline').createInterface({
      input: process.stdin,
      output: process.stdout
    }).on('line', function(line) {
      lines.push(line);
    });
    process.stdin.on('end', function() {
      //lines.forEach(function(line) {
        //var tokens = line.split(' ').map(Number);
        //    console.log(tokens[0] + ' ' + tokens[1]);
      //}
      //)
      ;

    // ToDo start
      var C1 = lines[0]
      var C2 = lines[1]

      if(C1[0]==C2[2] && C1[1]==C2[1] && C1[2]==C2[0]) {
          console.log("YES")
        }else {
            console.log("NO")
        }
      
//      console.log( Math.pow(parseInt(lines[0]),2) - parseInt(lines[1])  )
    // ToDo end

    });


})();
//  [javascript]
process.stdin.resume();
process.stdin.setEncoding('utf8');

var g_input = '';
process.stdin.on('data', function(chunk) {
    g_input += chunk;
});

process.stdin.on('end', function() {
    Main(g_input.split(/\r?\n/));
});

function Main(input) {

    var c = new Array(2);
    for (var i = 0; i < c.length; i++) {
        c[i] = input[i];
    }

    var ans = true;
    for (var i = 0; i < c[0].length; i++) {
        if (c[0].charAt(i) != c[1].charAt(c[1].length - i - 1)) {
            ans = false;
            break;
        }
    }

    if (ans) {
        console.log('YES');
    }
    else {
        console.log('NO');
    }

    return 0;
}
//  [javascript]
const main = input => {
  const grid = input.trim().split('\n')
  for (let i = 0; i < 3; i++) {
    if (grid[0].charAt(i) !== grid[1].charAt(3 - 1 - i)) {
      console.log('NO')
      return
    }
  }
  console.log('YES')
}
// 標準入力
main(require("fs").readFileSync("/dev/stdin", "utf8"))
//  [go]
package main

import (
	"fmt"
)

func main() {
  var C1, C2 string 
  fmt.Scanf("%s", &C1)
  fmt.Scanf("%s", &C2)
  
  ans := "YES"
  for i := 0; i < len(C1); i++ {
    if C1[i] != C2[len(C2)-1-i] {
      ans = "NO"
      break;
    }
  }

  fmt.Printf("%s\n",ans)
}
//  [go]
package main

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

func main() {
	c1, c2 := ReadString(), ReadString()

	if reverse(c1) == c2 && c1 == reverse(c2) {
		fmt.Println("YES")
	} else {
		fmt.Println("NO")
	}
}

func reverse(s string) string {
	t := []byte(s)
	t[0], t[2] = t[2], t[0]
	return string(t)
}

var reader = bufio.NewReader(os.Stdin)

func Scan(a ...interface{}) {
	if _, err := fmt.Fscan(reader, a...); err != nil {
		panic(err)
	}
}
func ReadString() (s string) { Scan(&s); return }