jiahuimbzuai/CoQuIR huggingface dataset:
//  [c]
#include<stdio.h>
#include<stdlib.h>
#include<math.h>
#include<string.h>
//if(strcmp(s[i],"AC")==0)
//if(s[l]=='#')
/*小文字判定
if((moji>= 'a') && (moji<='z')){
    printf("a\n");
    return 0;
  }
  */

int W_Length(char *str){
	int length = 0;
	while(*str++ != '\0')
		length++;
	return length;
}

void swap(long long int *a, long long int *b){
  int temp;
  temp=*a;
  *a=*b;
  *b=temp;
}
//swap(&a, &b)

double deg(double theta){//deg to theta
return theta*(2*3.14159265359)/360;
}

long long int cmp( const void *p, const void *q ) {
    return *(long long int*)p - *(long long int*)q;
}//ちいさい順
//qsort(a,n,sizeof(long long int),cmp);


int cmp_s(const void * left, const void * right)
{
	char *left_char = (char *)left;
  char *right_char = (char *)right;
  return strcmp(left_char, right_char);
}
//qsort(s,n,sizeof(s[0]),cmp_s);
//char s[n][11]

long long int GCD(long long int a, long long int b){
  long long int L=a,S=b;
  while(1){
    if(S>L){
      L=S+L;
      S=L-S;
      L=L-S;
    }
    if(L%S==0){
      return S;
    }
    L=L%S;
  }
  
}

long long int LCM(long long int a, long long int b){
  return a*b/(GCD(a,b));
}

int main (void)
{
	long long int p[5005],b,c,n,i,min,k,a[210000],max,j=1,t[210000],count=0;
scanf("%lld",&n);
for(i=0;i<n;i++){

  scanf("%lld",&a[i]);
    if(i==0){
   min=a[i]; 
  }
      if(a[i]<=min){
      min=a[i];
      count++;
    }

  
}  
  printf("%lld",count);
return 0;
}
//  [c]
#include<stdio.h>

int main()
{
    int i,n,count=1,max;
    scanf("%d",&n);
    int ara[n];
    for(i=0; i<n; i++)
        scanf("%d",&ara[i]);
    max=ara[0];
    for(i=1; i<n; i++) {
        if(ara[i]<=max) {
            max=ara[i];
            count++;
        }
    }
    printf("%d",count);
}
//  [javascript]
inp = require('fs').readFileSync('/dev/stdin', 'utf8').trim().split('\n')
N = inp.shift() * 1
a = inp.shift().split(' ').map(x => x - 0)
min = a[0]
c = 1
for (i=1;i<N;i++) {
    if (min > a[i]) {
        c++
        min = a[i]
    }
}
console.log(c)
//  [javascript]
function main(input) {
    var N = input[0]-0;
    var list = input[1].split(" ").map(v=>v-0);
    var ans = 0;
    var min = Infinity;
    for(var i=0;i<N;i++){
        if(min>list[i]){
            min = list[i];
            ans++;
        }
    }
    console.log(ans);
}
main(require('fs').readFileSync('/dev/stdin', 'utf8').trim().split("\n"))
//  [javascript]
"use strict"
function main(arg) {
    var data = arg.split("\n")[1].split(" ").map(Number)
    var min_i = 0
    var min_v = data[0]
    var count = 1
    for (var i = 1; i < data.length; i++) {
        // console.log(i)
        if (min_v >= data[i]) {
            // ok
            count++
            min_v = data[i]
        }
    }
    console.log(count)
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [go]
package main

import (
	"fmt"
)

func main() {

	var N, P int
	fmt.Scanf("%d", &N)

	var count int = 0
	var min int = 1000000
	for i := 0; i < N; i++ {
		fmt.Scanf("%d", &P)
		if min > P {
			count++
			min = P
		}
	}

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

import (
	"fmt"
)

func main() {

	var N int
	fmt.Scanf("%d", &N)

	P := make([]int, N)

	var count int = 0
	var min int = 1000000
	for i := 0; i < N; i++ {
		fmt.Scanf("%d", &P[i])
		if min > P[i] {
			count++
			min = P[i]
		}
	}

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

import (
	"fmt"
)

func main() {
	var N int
	fmt.Scan(&N)
	a := make([]int, N)
	amap := make(map[int]int)

	for i := 0; i < N; i++ {
		fmt.Scan(&a[i])
		amap[i] = a[i]
	}

	first := a[0]
	cnt := 1
	for i := 0; i < N; i++ {
		if a[i] < first {
			cnt++
			first = a[i]
		}
	}

	// for i, v1 := range amap {
	// 	for j := i; j < N; j++ {
	// 		if v1 > first {
	// 			continue
	// 		}
	// 		if amap[j] > v1 {
	// 			delete(amap, j)
	// 		}
	// 	}
	// }

	// for i, v1 := range amap {
	// 	j := i
	// 	for {
	// 		if j > len(amap) {
	// 			break
	// 		}
	// 		// if v1 > first {
	// 		// 	j++
	// 		// 	continue
	// 		// }
	// 		if amap[j] > v1 {
	// 			delete(amap, j)
	// 		}
	// 		j++
	// 	}
	// }
	// first := a[0]

	// for i, v1 := range amap {
	// 	for j, v2 := range amap {
	// 		if v1 > first {
	// 			continue
	// 		}
	// 		if j > i && v2 > v1 {
	// 			delete(amap, j)
	// 		}
	// 	}
	// }

	// for i := 0; i < N; i++ {
	// 	elem := a[i]
	// 	for j, v := range amap {
	// 		if elem > first {
	// 			continue
	// 		}
	// 		if j > i && v > elem {
	// 			delete(amap, j)
	// 		}
	// 	}
	// }
	fmt.Println(cnt)
}
//  [ruby]
n = gets.to_i
P_arr = gets.chomp.split.map(&:to_i)
counter = 0
P_max = P_arr.max

n.times do |i|
  if P_max >= P_arr[i]
     counter += 1
     P_max = P_arr[i]
  end
end

p counter
//  [ruby]
n = gets.to_i
P_arr = gets.split.map(&:to_i)
counter = 0
P_max = P_arr.max

n.times do |i|
  if P_max >= P_arr[i]
     counter += 1
     P_max = P_arr[i]
  end
end

p counter
//  [ruby]
n = gets.to_i
p = gets.split.map(&:to_i)
arr = p.map.with_index{|pi,i| [i, pi] }.sort{|a,b| a[1] <=> b[1]}.map{|a|a[0]}
tmp = arr[0]
ans = 1
i = 1
until tmp==0
  if tmp>arr[i]
    ans += 1
    tmp = arr[i]
  end
  i += 1
end
p ans
//  [rust]
use proconio::{fastout, input};

#[fastout]
fn main() {
    input!{
        n:usize,
        m:[i32; n],
    }
    let mut counter = 1;
    for i in 1..n {
        let target = &m[i];
        let mut tc = 0;
        for l in &m[0..i] {
            if target > l {
                tc += 1
            }
        }
        if tc > 0 {
            continue
        }
        counter += 1
    }
    print!("{}",counter)
}
//  [rust]
use text_io::*;
use std::collections::*;
use std::process::exit;

fn main() {
    let mut a:usize = read!();
    let mut b:usize = read!();
    let mut d:usize = 1;
    for i in 0..a-1 {
        let mut c:usize = read!();
        if b>=c {
            b=c;
            d+=1;
        }
    }
    println!("{}",d);
}
//  [typescript]
class AtCoder {
  // 入力系
  input=require('fs').readFileSync('/dev/stdin','utf8').split(/[\s]/);
  input_i=-1;
  n(){
    this.input_i++;
    return Number(this.input[this.input_i]);
  }
  nn(n){
    const a=[];
    for(let i=0;i<n;i++){
      a.push(this.n());
    }
    return a;
  }
  s(){
    this.input_i++;
    return String(this.input[this.input_i]);
  }
  ss(n){
    const a=[];
    for(let i=0;i<n;i++){
      a.push(this.s());
    }
    return a;
  }

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

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

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

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

/* [入力]
  const [H,W]=o.nn(2)
  const [N,M]=o.nn(2)
  const N=o.n()
  const S=o.s()
  const arr1=[]
  for(let i=0;i<N;i++)arr1.push(o.n())
 */

/* [BFS,DFS]
  const [H,W]=o.nn(2),map=new Array(H),save=new Array(H)
  const DH=[0,0,-1,1]
  const DW=[1,-1,0,0]
  for(let i=0;i<H;i++){
    map[i]=o.s().split('')
    save[i]=new Array(W)
    save[i].fill(-1)
  }
  // let queue=[[?,?,1]]
  // save[?][?]=0
  while(queue.length>0){
    let [h,w,c]=queue.shift()
    for(let i=0;i<4;i++){
      if(h+DH[i]<0 || h+DH[i]>=H || w+DW[i]<0 || w+DW[i]>=W){
        continue
      }
      if(map[h+DH[i]][w+DW[i]]==?){
        continue
      }
      if(save[h+DH[i]][w+DW[i]]==-1){
        queue.push([h+DH[i], w+DW[i], c+1])
        save[h+DH[i]][w+DW[i]]=c
      }
    }
  }
*/
const o = new AtCoder()

let n=o.n(),p=o.nn(n),ans=0,p2=[],min=p[0]
for(let i=0;i<n;i++){
  if(p[i]<=min){
    ans++
  }
  min=o.min(min,p[i])
}
o.o(ans)
//  [typescript]
const main = (input) => {
  const lines = input.trim().split("\n")
  const P = lines[1].split(" ").map(str => parseInt(str))

  const result = P.reduce((acc, cur) => {
    if (acc.minNum > cur) {
      return {minNum: cur, count: acc.count + 1};
    }
    return acc;
  }, {minNum: 1000000, count: 0})

  console.log(result.count);
}

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

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

const n = +input[0];

let count = 0;
let min = +input[1];

input.slice(1, n + 1).map(i => {
  if (+i <= min) {
    min = +i;
    count++;
  }
});

console.log(count);
//  [python]
x,a = map(int,input().split())
if x<a:
    print('0')
else:
    print('10')
//  [python]
x,a=map(int,input().split())
if x<a:
    print(0)
else:
    print(10)
//  [python]
X, A = map(int, input().split())

if X < A:
  print(0)
else:
  print(10)
//  [python]
x, a = map(int, input().split())
print('0') if x < a else print('10')
cons = 10 ** 7
def primes(n):
    is_prime = [True] * (n + 1)
    is_prime[0] = False
    is_prime[1] = False
    for i in range(2, int(n**0.5) + 1):
        if not is_prime[i]:
            continue
        for j in range(i * 2, n + 1, i):
            is_prime[j] = False
    return [i for i in range(n + 1) if is_prime[i]]
primes(cons)
//  [python]
# -*- coding: utf-8 -*-
"""
AtCoder A
"""

import sys, math, random
import numpy as np

# N = int(input())
# A = list(map(int,input().split())) # N row 1 column
# A = [int(input()) for _ in range(N)] # 1 row N column
# S = str(input()) # str(input()) == input() -> 'abc'
# S = list(input()) # abc -> ['a','b','c']
# S.replace('ABC','X') # "testABCABC" -> "testXX"
# S=numpp.assaray(S)=="#"
inf = 10**20
eps = 1.0 / 10**10
mod = 10**9+7
dd = [(-1,0),(0,1),(1,0),(0,-1)]
ddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]

def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(): return [list(map(int, l.split())) for l in sys.stdin.readlines()]
def LLS(): return [list(sys.stdin.readline().rstrip()) for _ in sys.stdin.readlines()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()



def main():
    X, A = list(map(int,input().split()))
    if X<A:
        print("0")
    else:
        print("10")

    
    
if __name__ == "__main__":
    main()
//  [python]
# n=int(input())
# a,b=map(int, input().split())
# c=list(map(int, input().split()))
# s=[list(map(int,list(input()))) for i in range(h)]  # 二次元配列入力　二次元マップみたいな入力のとき

# a=100
# b=0.987654321
# print('{0:06d}-{1:6f}'.format(a,b))  # 0埋めのときの出力
# 000100-0.987654

import numpy as np
import math
import copy

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

if x < a:
    print(0)
else:
    print(10)
//  [java]
import java.util.*;
import java.io.*;
import java.lang.reflect.Array;
import java.math.BigInteger;

import static java.lang.Math.*;
import static java.util.Arrays.*;
import static java.util.Collections.*;
 
public class Main{
    static long mod=1000000007;
//    static int dx[]={-1,0,1,0};
//    static int dy[]={0,-1,0,1};

    public static void main(String[] args)   throws Exception, IOException{        
        Reader sc = new Reader(System.in);
        PrintWriter out=new PrintWriter(System.out);

        int x = sc.nextInt();
        int a = sc.nextInt();
           
        out.println(x<a ?0:10);
        out.flush();
    }

    static boolean validpos(int x,int y,int r, int c){
        return x<r && 0<=x && y<c && 0<=y;
    }

    static void db(Object... os){
        System.err.println(Arrays.deepToString(os));
    }
}
//class P {
//    int id, d;
//    P(int  id, int d) {
//        this.id=id;
//        this.d=d;
//    }
//}

//class P implements Comparable<P>{
//    int a,b;
//    double c;
//    P(int a, int b) {
//    	this.b=b;
//    	this.a=a;
//    	this.c=(double)b/a;
//    }
//
//    public int compareTo(P p){
//        return Double.compare(p.c,c);
//    }
//}

class Reader
{ 
    private BufferedReader x;
    private StringTokenizer st;
    
    public Reader(InputStream in)
    {
        x = new BufferedReader(new InputStreamReader(in));
        st = null;
    }
    public String nextString() throws IOException
    {
        while( st==null || !st.hasMoreTokens() )
            st = new StringTokenizer(x.readLine());
        return st.nextToken();
    }
    public int nextInt() throws IOException
    {
        return Integer.parseInt(nextString());
    }
    public int[] nextIntArray(int size) throws IOException{
        int r[] = new int[size];
        for (int i = 0; i < size; i++) {
            r[i] = this.nextInt(); 
        }
        return r;
    }
    public long[] nextLongArray(int size) throws IOException{
        long r[] = new long[size];
        for (int i = 0; i < size; i++) {
            r[i] = this.nextLong(); 
        }
        return r;
    }
    public long nextLong() throws IOException
    {
        return Long.parseLong(nextString());
    }
    public double nextDouble() throws IOException
    {
        return Double.parseDouble(nextString());
    }
}
//  [java]
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;

public class Main {
  public static void main(String[] args) throws IOException {
    BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
    String[] str = in.readLine().split(" ");
    int x = Integer.parseInt(str[0]);
    int a = Integer.parseInt(str[1]);
    System.out.println(x<a?0:10);
  }
}
//  [java]
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author Jaynil
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        ARounding solver = new ARounding();
        solver.solve(1, in, out);
        out.close();
    }

    static class ARounding {
        public void solve(int testNumber, InputReader in, PrintWriter out) {
            int x = in.nextInt();
            int a = in.nextInt();
            if (x < a) out.println(0);
            else out.println(10);
        }

    }

    static class InputReader {
        public BufferedReader reader;
        public StringTokenizer tokenizer;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }

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

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

    }
}
//  [java]
import java.io.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) throws IOException {
        List<String> lines = readLines();
        String line = lines.get(0);
        List<Integer> numbers = Arrays.asList(line.split(" "))
                .stream()
                .map((n) -> Integer.parseInt(n))
                .collect(Collectors.toList());

        System.out.println((numbers.get(0) < numbers.get(1)) ? "0" : "10");
    }

    public static List<String> readLines() throws IOException {
        InputStream in = System.in;
        InputStreamReader reader = new InputStreamReader(in, "utf-8");
        BufferedReader br = new BufferedReader(reader);

        List<String> retList = new ArrayList<>();
        String line = br.readLine();
        while (line != null && !line.isEmpty()) {
            retList.add(line);
            line = br.readLine();
        }

        reader.close();
        br.close();
        return retList;
    }
}
//  [java]
import java.util.*;

class Main{
	public static void main(String[] $){
		Scanner s=new Scanner(System.in);
		System.out.println(s.nextInt()<s.nextInt()?0:10);
	}
}
//  [java]
import java.util.Scanner;
import java.util.stream.Stream;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String str  = sc.nextLine();
        String[] astr = str.split(" "); //状況に合わせて
        Boolean flag  = true;
        int[] in_data = Stream.of(astr).mapToInt(x->{
            try{
                return Integer.parseInt(x);
            }
            catch(Exception e){
                e.printStackTrace();
            }
            return 0;
        }).toArray();
        sc.close();
        int x = in_data[0];
        int a = in_data[1];

        if(x < a){
            System.out.println("0");
        }else{
            System.out.println("10");
        }

    }
}
//  [cpp]
#include<cstdio>
int main(){
    int x,y;
    while(~scanf("%d%d",&x,&y)){
        if(x<y){
            printf("0\n");
        //    printf("%d is less than %d, so we should print 0.\n",x,y);
        }
        else{
            printf("10\n");
         //   printf("%d is not less than %d, so we should print 10.\n",x,y);
        }
    }
    return 0;
}
//  [cpp]
#include <iostream>
#include <algorithm>
#include <iomanip>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <numeric>
#include <bitset>
#include <cmath>

static const int MOD = 1000000007;
using ll = long long;
using u32 = uint32_t;
using namespace std;

template<class T> constexpr T INF = ::numeric_limits<T>::max()/32*15+208;

int main() {
    int x, a;
    cin >> x >> a;
    if(x < a) puts("0");
    else puts("10");
    return 0;
}
//  [cpp]
#include <bits/stdc++.h>
using namespace std;

int main() {
  int x, a;
  cin >> x >> a;
  cout << (x < a ? 0 : 10) << endl;
}
//  [cpp]
#include <iostream>
#include <array>
#include <algorithm>
#include <map>
#include <vector>
#include <list>
#include <cmath>
#include <stack>
#include <queue>
#include <climits>
#include <string.h>
#include <cctype>
#include <set>

#define rep(i,n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int, int>;
using namespace std;

template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }

// a と b の最大公約数を返す関数
long long GCD(long long a, long long b) {
	if (b == 0) return a;
	else return GCD(b, a % b);
}

long long gcd(long long a, long long b)
{
	if (a % b == 0)
	{
		return(b);
	}
	else
	{
		return(gcd(b, a % b));
	}
}

long long lcm(long long a, long long b)
{
	return a * b / gcd(a, b);
}

// auto mod int
// https://youtu.be/L8grWxBlIZ4?t=9858
// https://youtu.be/ERZuLAxZffQ?t=4807 : optimize
// https://youtu.be/8uowVvQ_-Mo?t=1329 : division
const int mod = 1000000007;
struct mint {
	ll x; // typedef long long ll;
	mint(ll x = 0) :x((x% mod + mod) % mod) {}
	mint operator-() const { return mint(-x); }
	mint& operator+=(const mint a) {
		if ((x += a.x) >= mod) x -= mod;
		return *this;
	}
	mint& operator-=(const mint a) {
		if ((x += mod - a.x) >= mod) x -= mod;
		return *this;
	}
	mint& operator*=(const mint a) { (x *= a.x) %= mod; return *this; }
	mint operator+(const mint a) const { return mint(*this) += a; }
	mint operator-(const mint a) const { return mint(*this) -= a; }
	mint operator*(const mint a) const { return mint(*this) *= a; }
	mint pow(ll t) const {
		if (!t) return 1;
		mint a = pow(t >> 1);
		a *= a;
		if (t & 1) a *= *this;
		return a;
	}

	// for prime mod
	mint inv() const { return pow(mod - 2); }
	mint& operator/=(const mint a) { return *this *= a.inv(); }
	mint operator/(const mint a) const { return mint(*this) /= a; }
};
istream& operator>>(istream& is, const mint& a) { return is >> a.x; }
ostream& operator<<(ostream& os, const mint& a) { return os << a.x; }

struct combination {
	vector<mint> fact, ifact;
	combination(int n) :fact(n + 1), ifact(n + 1) {
		fact[0] = 1;
		for (int i = 1; i <= n; ++i) fact[i] = fact[i - 1] * i;
		ifact[n] = fact[n].inv();
		for (int i = n; i >= 1; --i) ifact[i - 1] = ifact[i] * i;
	}
	mint operator()(int n, int k) {
		if (k < 0 || k > n) return 0;
		return fact[n] * ifact[k] * ifact[n - k];
	}
} comb(2000005);

mint g(int r, int c) {
	return comb(r + c + 2, r + 1) - 1;
}

bool comp(int i, int j) {
	return i > j;
}

bool compare_by_b(pair<int, int> a, pair<int, int> b) {
	return a.second < b.second;
}


int main()
{
	int x, a;
	cin >> x >> a;
	cout << (x >= a ? 10 : 0);
}
//  [cpp]
//#define _GLIBCXX_DEBUG

#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cmath>
#include<cctype>
#include<math.h>
#include<string>
#include<string.h>
#include<stack>
#include<queue>
#include<vector>
#include<utility>
#include<set>
#include<map>
#include<stdlib.h>
#include<iomanip>
#include<complex>

using namespace std;

#define ll long long
#define ld long double
#define EPS 1e-9
#define INF 1e9
#define LINF (ll)INF*INF
#define MOD 1000000007
#define rep(i,n) for(int i=0;i<(n);i++)
#define loop(i,a,n) for(int i=a;i<(n);i++)
#define all(in) in.begin(),in.end()
#define shosu(x) fixed<<setprecision(x)

#define int ll //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

typedef vector<int> vi;
typedef vector<string> vs;
typedef pair<int,int> pii;
typedef vector<pii> vp;
typedef vector<vi> vvi;

int gcd(int a, int b){if(b==0) return a;return gcd(b,a%b);}
int lcm(int a, int b){return a/gcd(a,b)*b;}


signed main(void) {
    int a,x;
    cin >> x >> a;
    if(x < a)cout << 0 << endl;
    else cout << 10 << endl;
}
//  [cpp]
#include<bits/stdc++.h>
#include<string>
#include<vector>
using namespace std;

int main(){
    
    int x,a;
    cin>>x>>a;

    if(x <a) cout<<0<<endl;
    else cout<<10<<endl;

    
    

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

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

int main(){
 int X,A;
 scanf("%d %d", &X, &A);
  if(X<A){
   printf("0\n");
  }else{
   printf("10\n");
  }
 return 0;
}
//  [c]
#include<stdio.h>
int main(void)
{
	int x,a;
	scanf("%d %d",&x,&a);
	if(x<a){
		printf("0\n");
	}
	if(x>=a){
		printf("10\n");
	}
	return 0;
}
//  [c]
#include <stdio.h>
#include <stdlib.h>

int main()
{
    int X,A;
    scanf("%d%d",&X,&A);
    if(X>=0&&X<=9&&A>=0&&A<=9)
    {
        if(X<A)
            printf("0");
        else
            printf("10");
    }
}
//  [javascript]
function Main(input) {
    ar = input[0].split(" ");
    var x = Number(ar[0]);
    var a = Number(ar[1]);
    if (x < a) {
        console.log("0");
    }
    else {
        console.log("10");
    }
}
Main(require("fs").readFileSync("/dev/stdin", "utf8").split("\n"));
//  [javascript]
function main(input) {                                                                           
    const args = input.split(' ');                                                               
    const x = parseInt(args[0], 10);                                                             
    const a = parseInt(args[1], 10);                                                             
                                                                                                 
    if (x < a) {                                                                                 
        console.log('0');                                                                        
    } else {                                                                                     
        console.log('10');                                                                       
    }                                                                                            
}                                                                                                
                                                                                                 
main(require('fs').readFileSync('/dev/stdin', 'utf8'))
//  [javascript]
// inputに入力データ全体が入る
function Main(input) {
	input = input.split(" "); // 1行目がinput[0], 2行目がinput[1], …に入る
	// ここに処理を書く
	var X = input[0];
	var A = input[1];
	var result = 0

	try {
		checkNumber(Number(X), Number(A))
		}
		catch (e) {
			console.log("エラー内容："　+ e);
		}
	
	// console.logは標準出力に1行出力します (自動的に最後に改行が入ります)
	// console.log(result);
}

function checkNumber (X, A) {
	
		if ((Number(X)>=0 && Number(X)<=9) || (Number(A)>=0 && Number(A)<=9)) {
			if (X<A) {
				result = 0
			} else if (X>=A) {
				result = 10
			}
		} else {
			throw "Invalid"
		}
	
	console.log(result);
}

// ※この行以降は編集しない (標準入力から一度に読み込みMainを呼び出します)
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
module.exports=function(t){var e={};function n(r){if(e[r])return e[r].exports;var i=e[r]={i:r,l:!1,exports:{}};return t[r].call(i.exports,i,i.exports,n),i.l=!0,i.exports}return n.m=t,n.c=e,n.d=function(t,e,r){n.o(t,e)||Object.defineProperty(t,e,{enumerable:!0,get:r})},n.r=function(t){"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(t,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(t,"__esModule",{value:!0})},n.t=function(t,e){if(1&e&&(t=n(t)),8&e)return t;if(4&e&&"object"==typeof t&&t&&t.__esModule)return t;var r=Object.create(null);if(n.r(r),Object.defineProperty(r,"default",{enumerable:!0,value:t}),2&e&&"string"!=typeof t)for(var i in t)n.d(r,i,function(e){return t[e]}.bind(null,i));return r},n.n=function(t){var e=t&&t.__esModule?function(){return t.default}:function(){return t};return n.d(e,"a",e),e},n.o=function(t,e){return Object.prototype.hasOwnProperty.call(t,e)},n.p="",n(n.s=0)}([function(t,e,n){"use strict";var r=n(1),i=new(n(2))(r.readFileSync("/dev/stdin","utf8").split(/\s+/g));n(4)(i)},function(t,e){t.exports=require("fs")},function(t,e,n){"use strict";var r=n(3);t.exports=class{constructor(t){this.inp=new r(t)}n(){return this.inp.deq()}ni(){return parseInt(this.inp.deq(),10)}add(t){this.inp.enq(t)}}},function(t,e,n){"use strict";t.exports=class{constructor(){var t=arguments.length>0&&void 0!==arguments[0]?arguments[0]:[];this.size=t.length,this.items=t,this.ind=0}enq(t){this.size+=1,this.items.push(t)}deq(){var t=this.items[this.ind];return this.size-=1,this.ind+=1,t}}},function(t,e,n){"use strict";t.exports=function(t){t.ni()<t.ni()?console.log(0):console.log(10)}}]);
//  [javascript]
'use strict'

const INF = 900719925474099;
function mapint(temp){
    return temp.split(' ').map((v)=>parseInt(v));
}
function lower_bound(d,a,b,e){for(var c;1<b-a;)d[c=0|(a+b)/2]<e?a=c:b=c;return d[a]<e?b:a};
const MOD = 1000000007;

function Main(input){
    let temp = input.trim();
    let temp2 = mapint(temp);
    let x = temp2[0];
    let a = temp2[1];

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

	input = input.split(" ");
	
	var X = parseInt(input[0]);
	var A = parseInt(input[1]);
	
	if(X<A){
	    console.log("0");
	}else{
	    console.log("10");
	}
	
}

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

import (
	"fmt"
)

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

	ans := 10
	if x < a {
		ans = 0
	}

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

import (
  "fmt"
)

func main() {
  var x, a int
  fmt.Scan(&x, &a)
  ans := 0
  if x >= a {
    ans = 10
  }
  fmt.Println(ans)
}
//  [go]
package main

import (
	"fmt"
)

var (
	finv, inv, fac [MAX]int
)

func COM(n, k int) int {
	if n < k {
		return 0
	}
	if n < 0 || k < 0 {
		return 0
	}
	return fac[n] * (finv[k] * finv[n-k] % MOD) % MOD
}

func init() {
	fac[0] = 1
	fac[1] = 1
	finv[0] = 1
	finv[1] = 1
	inv[1] = 1
	for 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
	}
}

const (
	MOD = 998244353
	MAX = 510000
)

func ModAdd(a, b int64) int64 {
	return (a + b) % MOD
}

func ModMul(a, b int64) int64 {
	return a * b % MOD
}

func ModSub(a, b int64) int64 {
	r := (a%MOD - b%MOD) % MOD
	if r < 0 {
		r += MOD
	}
	return r
}

func ModDiv(a, b int64) int64 {
	return a % MOD * ModInv(b) % MOD
}

func ModPow(a, n int64) int64 {
	var r int64 = 1
	for n > 0 {
		if n&1 == 1 {
			r = r * a % MOD
		}
		a = a * a % MOD
		n >>= 1
	}
	return r
}

func ModInv(a int64) int64 {
	var b, u, v int64 = MOD, 1, 0
	for b > 0 {
		t := a / b
		a -= t * b
		a, b = b, a
		u -= t * v
		u, v = v, u
	}
	u %= MOD
	if u < 0 {
		u += MOD
	}
	return u
}

type Q struct {
	value int
	index int
	A, B  int
}

type QS []*Q

func (p QS) Len() int           { return len(p) }
func (p QS) Less(i, j int) bool { return p[i].value > p[j].value }
func (pq QS) Swap(i, j int) {
	pq[i], pq[j] = pq[j], pq[i]
	pq[i].index = i
	pq[j].index = j
}

func (pq *QS) Push(x interface{}) {
	n := len(*pq)
	item := x.(*Q)
	item.index = n
	*pq = append(*pq, item)
}

func (pq *QS) Pop() interface{} {
	old := *pq
	n := len(old)
	item := old[n-1]
	old[n-1] = nil  // avoid memory leak
	item.index = -1 // for safety
	*pq = old[0 : n-1]
	return item
}

func FactoredPrimeNumber(num int) map[int]int {
	m := map[int]int{}
	return factor(m, num, 2)
}

func factor(result map[int]int, num, pnum int) map[int]int {
	if pnum*pnum > num {
		if num != 1 {
			result[num] += 1
		}
		return result
	}

	if num%pnum == 0 {
		num /= pnum
		result[pnum]++
	} else {
		pnum++
	}
	return factor(result, num, pnum)
}

func GCD(a, b int64) int64 {
	if b == 0 {
		return a
	}
	return GCD(b, a%b)
}

func LCM(a, b int64) int64 {
	return a * b / GCD(a, b)
}

func main() {
	var X, A int
	fmt.Scanf("%d %d\n", &X, &A)

	if X < A {
		fmt.Println(0)
	} else {
		fmt.Println(10)
	}
}

func Reverse(runes []rune) []rune {
	for i, j := 0, len(runes)-1; i < j; i, j = i+1, j-1 {
		runes[i], runes[j] = runes[j], runes[i]
	}
	return runes
}
//  [go]
package main

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

var mod = 1000000007

func main() {
	r := bufio.NewReader(os.Stdin)
	var x, a int
	fmt.Fscan(r, &x)
	fmt.Fscan(r, &a)

	if x < a {
		fmt.Println(0)
	} else {
		fmt.Println(10)
	}
}
//  [go]
package main

import (
  "fmt"
)

func main() {
  var x, a int
  fmt.Scanf("%d %d", &x, &a)
  
  ans := 10
  if x < a {
    ans = 0
  }
    
  fmt.Printf("%d\n", ans)
}
//  [ruby]
x,a=gets.split.map(&:to_i)
puts x<a ? 0:10
//  [ruby]
x,a=gets.split(" ").map{|n|n.to_i}
if x<a then
  puts 0
else
  puts 10
end
//  [ruby]
# frozen_string_literal: true

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

if x < a
  puts 0
elsif x >= a
  puts 10
end
//  [ruby]
#!/usr/bin/env ruby

require 'set'

class Hash
  def push(key, value)
    self[key] = [] if self[key] == nil
    self[key].push(value)
  end
end

class Array
  def lower_bound(value)
    left = -1;
    right = self.length;
    while left + 1 < right
      mid = left + (right - left) / 2;
      if self[mid] >= value
        right = mid
      else
        left = mid
      end
    end
    right
  end

  def unique
    res = [self.first]
    each_cons(2) do |a, b|
      if a != b
        res.push(b)
      end
    end
    res
  end
end

def get_ints
  gets.chomp.split.map(&:to_i)
end

def get_ints_minus_one
  get_ints.map { |x| x - 1 }
end

def get_int
  gets.chomp.to_i
end

X, A = get_ints

if X < A
  puts '0'
else
  puts '10'
end
//  [ruby]
x, a = gets.chomp.split(" ").map(&:to_i)
if x >= a 
    puts "10"
else
    puts "0"
end
//  [ruby]
x,a = gets.chomp.split.map(&:to_i)

puts x<a ? "0" : "10"
//  [rust]
use std::io::*;
use std::str::FromStr;

fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let stdin = stdin.lock();
    let token: String = stdin
        .bytes()
        .map(|c| c.expect("failed to read char") as char) 
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();
    token.parse().ok().expect("failed to parse token")
}
  
fn main() {
	let x: i32 = read();
    let a: i32 = read();
    
    if x < a {
    	println!(0);
    } else {
    	println!(10);
    }
}
//  [rust]
use std::io::*;
use std::str::FromStr;

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

fn main() {
    let x: u32 = read();
    let a: u32 = read();
    let ans = if x < a { 0 } else { 10 };
    println!("{}", ans);
}
//  [rust]
fn main() {
    let (r, w) = (std::io::stdin(), std::io::stdout());
    let mut sc = IO::new(r.lock(), w.lock());

    let x: i32 = sc.read();
    let a: i32 = sc.read();
    if x < a {
        println!("0");
    } else {
        println!("10");
    }
}

pub struct IO<R, W: std::io::Write>(R, std::io::BufWriter<W>);

impl<R: std::io::Read, W: std::io::Write> IO<R, W> {
    pub fn new(r: R, w: W) -> IO<R, W> {
        IO(r, std::io::BufWriter::new(w))
    }
    pub fn write<S: ToString>(&mut self, s: S) {
        use std::io::Write;
        self.1.write(s.to_string().as_bytes()).unwrap();
    }
    pub fn read<T: std::str::FromStr>(&mut self) -> T {
        use std::io::Read;
        let buf = self
            .0
            .by_ref()
            .bytes()
            .map(|b| b.unwrap())
            .skip_while(|&b| b == b' ' || b == b'\n' || b == b'\r' || b == b'\t')
            .take_while(|&b| b != b' ' && b != b'\n' && b != b'\r' && b != b'\t')
            .collect::<Vec<_>>();
        unsafe { std::str::from_utf8_unchecked(&buf) }
            .parse()
            .ok()
            .expect("Parse error.")
    }
    pub fn vec<T: std::str::FromStr>(&mut self, n: usize) -> Vec<T> {
        (0..n).map(|_| self.read()).collect()
    }
    pub fn chars(&mut self) -> Vec<char> {
        self.read::<String>().chars().collect()
    }
}
//  [rust]
#![allow(unused, non_snake_case, dead_code, non_upper_case_globals)]
use {
    proconio::{marker::*, *},
    std::{cmp::*, collections::*, mem::*},
};

#[fastout]
fn main() {
    input! {//
        x:usize,a:usize,
    }
    if x < a {
        println!("{}", 0);
    } else {
        println!("{}", 10);
    }
}
//  [rust]
#![allow(unused_imports)]

use proconio::{input, fastout};
use proconio::marker::*;
use std::cmp::min;

#[fastout]
fn main() {
    input! {
    x: usize,
    a: usize
    }
    let ans = if x < a {0} else {10};
    println!("{}", ans);
}
//  [rust]
use proconio::input;


fn solve(x: i32, a: i32) {
    if x < a {
        println!("0");
    }
    else {
        println!("10");
    }
}


fn main() {
    input! {
        x: i32,
        a: i32,
    }

    solve(x, a);
}
//  [swift]
func readInts() -> [Int] {
    return readLine()!.split(separator: " ").map { Int($0)! }
}

func main() {
    let xa = readInts()
    if xa[0] < xa[1] {
        print("0")
    } else {
        print("10")
    }
}

main()
//  [swift]
let i=readLine()!.characters.split(" ").map{Int(String($0))!}
print(i[0]<i[1] ?0:10)
//  [swift]
let arr=readLine()!.characters.split{$0==" "}.map{Int(String($0))!}
let x = arr[0]
let a = arr[1]

var o: Int
if( x >= a ) { o = 10 }
else { o = 0 }
print( o )
//  [swift]
import Foundation
import CoreFoundation

#if swift(>=4.0)
extension String {
    func split(by separator: String) -> [String] {
        return self.components(separatedBy: separator)
    }
    func toArray() -> [String] {
        return self.map{String($0)}
    }
}
func exponentiate(_ lhs: Int, _ rhs: Int) -> Int {
    return (0..<rhs).reduce(1){i,_ in i*lhs}
}
#else
extension String {
    func split(by separator: String) -> [String] {
        return self.componentsSeparatedByString(separator)
    }
    var count: Int {
        return self.characters.count
    }
    func toArray() -> [String] {
        return self.characters.map{String($0)}
    }
    func uppercased() -> String {
        return self.uppercaseString
    }
    func lowercased() -> String {
        return self.lowercaseString
    }
}
//extension Array where Element == String {
//    func joined(separator separator: String) -> String {
//        return self.joinWithSeparator(separator)
//    }
//}
extension Array where Element: Comparable {
    func max() -> Element? {
        return self.maxElement()
    }
    func min() -> Element? {
        return self.minElement()
    }
    func sorted() -> Array {
        return self.sort()
    }
    mutating func sort() {
        self.sortInPlace()
    }
}
extension Array {
    func reversed() -> Array {
        return self.reverse()
    }
    func enumerated() -> EnumerateSequence<[Element]> {
        return self.enumerate()
    }
    init(repeating: Element, count: Int) {
        self.init(count: count, repeatedValue: repeating)
    }
}
func stride<T: Strideable>(from start: T, to end: T, by stride: T.Stride) -> StrideTo<T> {
    return start.stride(to: end, by: stride)
}
func exponentiate(lhs: Int, _ rhs: Int) -> Int {
    return (0..<rhs).reduce(1){i,_ in i*lhs}
}
#endif
func readInt() -> Int? {
    return Int(readLine()!)
}
func readStringSplit(by separator: String) -> [String] {
    return readLine()!.split(by: separator)
}
func readIntSplit(by separator: String) -> [Int] {
    return readLine()!.split(by: separator).map{Int($0)!}
}
//func gcd(x: Int, _ y: Int) -> Int {
//    if y == 0 {
//        return x
//    } else {
//        return gcd(y, x%y)
//    }
//}
//func lcm(x: Int, _ y: Int) -> Int {
//    return x * y / gcd(x, y)
//}

/*************** テストスペース ***************/

//arr.sort{$0.0==$1.0 ? $0.1<$1.1 : $0.0<$1.0}  // 2つの条件に優先順位をつけてソート

/*************** メインプログラム ***************/

let input = readIntSplit(by: " ")
let (X, A) = (input[0], input[1])
print(X<A ? 0 : 10)
//  [swift]
import Foundation
 
let input_line = readLine()!
 
let split = input_line.componentsSeparatedByString(" ") //components(separatedBy:)と実質同じ
let X = Int(split[0])!
let A = Int(split[1])!
 
if X < A {
    print(0)
} else  {
    print(10)
}
//  [swift]
let inp = readLine()!.split(separator: " ").map { Int($0)! }

let X = inp[0]
let A = inp[1]

print(X < A ? "0" : "10")
//  [typescript]
import * as fs from 'fs';

//in
// 3 5
//out
// 0
const main = (inp: string) => {
    const [x, a]: number[] = inp.split(' ').map(Number);

    if (x < a) {
        console.log(0);
    } else {
        console.log(10);
    }
};

main(fs.readFileSync('/dev/stdin', 'utf8').trim());
//  [typescript]
'use strict'
const main = (input: string) => {
    const [x, a] = input.split(' ').map(Number)
    console.log(x < a ? 0 : 10)
}
main(require('fs').readFileSync('/dev/stdin', 'utf8').trim())
//  [typescript]
import * as fs from "fs";

const input = (fs.readFileSync("/dev/stdin", "utf8") as string).split("\n");
const [x, a] = input[0].split(" ").map((x: string): number => +x);
if(x<a) console.log(0);
else console.log(10);
//  [typescript]
"use strict";

const main = arg => {
  const input = arg.trim().split("\n");
  const X = parseInt(input[0].split(" ")[0]);
  const A = parseInt(input[0].split(" ")[1]);
  if (X >= A) {
    console.log(10);
  } else {
    console.log(0);
  }
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [typescript]
import { stringLiteral } from "@babel/types"

// general helpers
const debug = (message?: any, ...optionalParams: any[]) => {
  if (process.env.LOCAL_DEBUG === '1') console.log(message, ...optionalParams)
}

// helpers
const parseLines = (
  lines: string[]
): { X: number, A: number } => {
  const [X, A] = lines[0].split(' ').map(line => +line)
  const obj = { X, A }
  debug(obj)
  return obj
}
// solver
export const solve = (lines: string[]): string => {
  const { X, A } = parseLines(lines)
  if (X < A) {
    return '0'
  } else {
    return '10'
  }
}

// main
const main = (lines: string[]) => {
  console.log(solve(lines))
}

// exec main function for submit
if (process.env.LOCAL_DEBUG !== '1') {
  const { stdin: input, stdout: output } = process
  input.resume()
  input.setEncoding('utf8')
  const lines: string[] = []
  require('readline')
    .createInterface({ input, output })
    .on('line', (line: string) => lines.push(line))
    .on('close', () => main(lines))
}
//  [typescript]
import * as fs from 'fs'

const process = (na: number[]): string => {
  const [x, a] = na
  if (x < a) {
    return '0'
  }
  return '10'
}

const Main = (input: string): string => {
  const a: string[] = input.split(' ')
  const na: number[] = a.map((e) => parseInt(e))

  const res = process(na) + ''
  console.log(res)
  return res
}
Main(fs.readFileSync("/dev/stdin", "utf8"))
//  [python]
import numpy as np
N, M = map(int, input().split())

frag = True
A = np.zeros(N)
for i in range(N):
    A[i] = -1
for i in range(M):
    si,ci = map(int, input().split())
    if A[si-1] != -1 and A[si-1] != ci:
        frag = False
    elif si == 1 and ci == 0 and N != 1:
        frag = False
    else:
        A[si-1] = ci

ans = 0
for i in range(N):
    if A[N-i-1] == -1:
        A[N-i-1] = 0
    ans += A[N-i-1]*(10**i)
    
if ans == 0 and N == 1:
    pass
elif ans < 10**(N-1):
    ans += 10**(N-1)
    
if frag:
    print(int(ans))
else:
    print(-1)
//  [python]
#
# 　　  ⋀_⋀　 
#　　  (･ω･)  
# .／ Ｕ ∽ Ｕ＼
#  │＊　合　＊│
#  │＊　格　＊│ 
#  │＊　祈　＊│ 
#  │＊　願　＊│ 
#  │＊　　　＊│ 
#      ￣
#
import sys
sys.setrecursionlimit(10**6)
input=sys.stdin.readline
from math import floor,sqrt,factorial,hypot,log #log2ないｙｐ
from heapq import heappop, heappush, heappushpop
from collections import Counter,defaultdict,deque
from itertools import accumulate,permutations,combinations,product,combinations_with_replacement
from bisect import bisect_left,bisect_right
from copy import deepcopy
from fractions import gcd
from random import randint
def ceil(a,b): return (a+b-1)//b
inf=float('inf')
mod = 10**9+7
def pprint(*A): 
    for a in A:     print(*a,sep='\n')
def INT_(n): return int(n)-1
def MI(): return map(int,input().split())
def MF(): return map(float, input().split())
def MI_(): return map(INT_,input().split())
def LI(): return list(MI())
def LI_(): return [int(x) - 1 for x in input().split()]
def LF(): return list(MF())
def LIN(n:int): return [I() for _ in range(n)]
def LLIN(n: int): return [LI() for _ in range(n)]
def LLIN_(n: int): return [LI_() for _ in range(n)]
def LLI(): return [list(map(int, l.split() )) for l in input()]
def I(): return int(input())
def F(): return float(input())
def ST(): return input().replace('\n', '')
def main():
    N,M=MI()
    ans = [-1]*N
    for i in range(M):
        j,x = MI()
        j-=1
        if ans[j]!=-1 and ans[j]!=x:
            print(-1)
            return
        ans[j]=x
    
    if ans[0] == 0 and N!=1:
        print(-1)
        return
    if ans[0] == -1 and N==1:
        print(0)
        return
    non_zero = False
    for i in range(N):
        if ans[i]==-1:
            if non_zero:
                ans[i]=0
            else:
                ans[i]=1
                non_zero = True
        else:
            non_zero = True
    print(*ans,sep="")
if __name__ == '__main__':
    main()
//  [python]
from __future__ import print_function

import sys

import re
import array
import copy
import functools
import operator

import math
import string
import fractions
from fractions import Fraction
from fractions import gcd
# fractions.gcd() を用いること
# math.log2()はatcoderでは対応していない．留意せよ．

import collections
import itertools
import bisect

import random
import time

import heapq
from heapq import heappush
from heapq import heappop
from heapq import heappushpop
from heapq import heapify
from heapq import heapreplace
from queue import PriorityQueue as pq
from queue import Queue

from itertools import accumulate

from collections import deque
from collections import Counter

from operator import mul
from functools import reduce

input = sys.stdin.readline


def eprint(*args, **kwargs):
    print(*args, file=sys.stderr, **kwargs)
    return


def lcm(n, m):
    return int(n * m / gcd(n, m))


def coprimize(p, q):
    common = fractions.gcd(p, q)
    return (p // common, q // common)


def combinations_count(n, r):
    r = min(r, n - r)
    numer = reduce(mul, range(n, n - r, -1), 1)
    denom = reduce(mul, range(1, r + 1), 1)
    return numer // denom


def main():
    # input
    n, m = map(int, input().strip().split())

    # input and variables initialization
    dict_x = {}
    for i in range(m):
        s_temp, m_temp = map(int, input().strip().split())
        s_temp -= 1
        m_temp = str(m_temp)
        if s_temp in dict_x and dict_x[s_temp] != m_temp:
            print(-1)
            return
        else:
            dict_x[s_temp] = m_temp

    # main process
    for x in range(0 if n == 1 else 10**(n-1), 10**(n)):
        # variables initialization
        S = str(x)
        failure_flag = 0

        # for all i, if i is in dict_x then S[i] == dict_x[i]
        for i in range(n):
            if i in dict_x and S[i] != dict_x[i]:
                failure_flag = 1
            else:
                pass

        #
        if failure_flag == 0:
            print(x)
            return
        else:
            pass


    print(-1)
    return


if __name__ == '__main__':
    main()
//  [java]
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.stream.IntStream;
import java.util.stream.Stream;

public class Main {

	public static void main(String[] args) {
		try (Stream<String> lines = new BufferedReader(new InputStreamReader(System.in)).lines()) {
			new Main().exec(lines.toArray(String[]::new));
		}
	}

	void exec(String[] args) {
		int N = Integer.parseInt(args[0].split(" ")[0]);
		Map<Integer, Set<Integer>> map = new HashMap<>();
		IntStream
			.range(1, args.length)
			.mapToObj(i -> Stream
				.of(args[i].split(" "))
				.map(Integer::valueOf)
				.toArray(Integer[]::new))
			.forEach(is -> map.computeIfAbsent(is[0], i -> new HashSet<>()).add(is[1]));
		int[] a = IntStream
			.rangeClosed(1, N)
			.map(i -> !map.containsKey(i) ? -1 : map.get(i).size() != 1 ? 10 : map.get(i).toArray(new Integer[1])[0])
			.toArray();
		System.out.println(N > 1 && a[0] == 0 || IntStream.of(a).anyMatch(i -> i > 9) ? -1 : IntStream
			.range(0, N)
			.map(i -> (int)(Math.max(a[i], N > 1 && i == 0 ? 1 : 0) * Math.pow(10, N - i - 1)))
			.sum());
	}

}