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

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

func solve(sc *scanner, wr *bufio.Writer) {
	cs1 := sc.getString()
	cs2 := sc.getString()

	ans := "YES"
	if cs1[0] != cs2[2] || cs1[1] != cs2[1] || cs1[2] != cs2[0] {
		ans = "NO"
	}
	fmt.Fprintln(wr, ans)
}

func main() {
	sc := newScanner()
	wr := bufio.NewWriter(os.Stdout)
	maxBufSize := int(1e8)
	sc.Buffer(make([]byte, 4096), maxBufSize)
	sc.Split(bufio.ScanWords)

	solve(sc, wr)
	wr.Flush()
}

// input ------------------------
type scanner struct {
	*bufio.Scanner
}

func newScanner() *scanner {
	sc := bufio.NewScanner(os.Stdin)
	return &scanner{sc}
}
func (sc *scanner) getInt() int {
	sc.Scan()
	ret, err := strconv.Atoi(sc.Text())
	if err != nil {
		panic(err)
	}
	return ret
}
func (sc *scanner) getInt2() (int, int) {
	return sc.getInt(), sc.getInt()
}
func (sc *scanner) getInt3() (int, int, int) {
	return sc.getInt(), sc.getInt(), sc.getInt()
}
func (sc *scanner) getInt4() (int, int, int, int) {
	return sc.getInt(), sc.getInt(), sc.getInt(), sc.getInt()
}
func (sc *scanner) getInts(n int) []int {
	ret := make([]int, n)
	for i := range ret {
		ret[i] = sc.getInt()
	}
	return ret
}
func (sc *scanner) getString() string {
	sc.Scan()
	return sc.Text()
}
func (sc *scanner) getRunes() []rune {
	return []rune(sc.getString())
}
func (sc *scanner) getFloat() float64 {
	sc.Scan()
	ret, err := strconv.ParseFloat(sc.Text(), 64)
	if err != nil {
		panic(err)
	}
	return ret
}
func (sc *scanner) getFloats(n int) []float64 {
	ret := make([]float64, n)
	for i := range ret {
		ret[i] = sc.getFloat()
	}
	return ret
}

// math ----------------------------
func sum(ns ...int) int {
	var sum int
	for _, n := range ns {
		sum += n
	}
	return sum
}

func max(ns ...int) int {
	max := ns[0]
	for i := 1; i < len(ns); i++ {
		if max < ns[i] {
			max = ns[i]
		}
	}
	return max
}

func min(ns ...int) int {
	min := ns[0]
	for i := 1; i < len(ns); i++ {
		if min > ns[i] {
			min = ns[i]
		}
	}
	return min
}

func pow(a, b int) int {
	ret := 1
	for b > 0 {
		if b&1 > 0 {
			ret = ret * a
		}
		a = a * a
		b >>= 1
	}
	return ret
}
//  [ruby]
puts gets.chomp.reverse==gets.chomp ? "YES" : "NO"
//  [ruby]
s = gets.chomp
t = gets.chomp.reverse

puts s == t ? "YES" : "NO"
//  [ruby]
input = readlines()

l1 = input.shift.chomp.to_s
l2 = input.shift.chomp.to_s

puts l1 == l2.reverse ? 'YES' : 'NO'
//  [rust]
macro_rules! get {
    ($t:ty) => {
        {
            let mut line: String = String::new();
            std::io::stdin().read_line(&mut line).unwrap();
            line.trim().parse::<$t>().unwrap()
        }
    };
    ($($t:ty),*) => {
        {
            let mut line: String = String::new();
            std::io::stdin().read_line(&mut line).unwrap();
            let mut iter = line.split_whitespace();
            (
                $(iter.next().unwrap().parse::<$t>().unwrap(),)*
            )
        }
    };
    ($t:ty; $n:expr) => {
        (0..$n).map(|_|
            get!($t)
        ).collect::<Vec<_>>()
    };
    ($($t:ty),*; $n:expr) => {
        (0..$n).map(|_|
            get!($($t),*)
        ).collect::<Vec<_>>()
    };
}

fn main() {
    let c1 = get!(String).chars().collect::<Vec<_>>();
    let c2 = get!(String).chars().rev().collect::<Vec<_>>();
    println!("{}", if c1.into_iter().eq(c2.into_iter()) { "YES" } else { "NO" });
}
//  [rust]
#![allow(unused, non_snake_case, dead_code, non_upper_case_globals)]
use std::cmp::*;
use std::collections::*;
use std::mem::*;

fn main() {
    let (r, w, e) = (std::io::stdin(), std::io::stdout(), std::io::stderr());
    let mut io = IO::new(r.lock(), w.lock(), e.lock());
    let c = io.chars();
    let d = io.chars();
    let mut ans = true;
    for i in 0..3 {
        if c[i] != d[2 - i] {
            ans = false;
        }
    }
    io.writeln(if ans { "YES" } else { "NO" });
}

static MX: usize = 1010101;
static MOD: i64 = 1000000007;
static INF: i64 = std::i64::MAX >> 1;
// IO
use std::io::*;
struct IO<R: Read, W: Write, E: Write> {
    Read: R,
    Write: BufWriter<W>,
    Error: BufWriter<E>,
}
impl<R: Read, W: Write, E: Write> IO<R, W, E> {
    fn new(r: R, w: W, e: E) -> IO<R, W, E> {
        IO {
            Read: r,
            Write: BufWriter::new(w),
            Error: BufWriter::new(e),
        }
    }
    fn read<T>(&mut self) -> T
    where
        T: std::str::FromStr,
    {
        let next: String = self
            .Read
            .by_ref()
            .bytes()
            .map(|c| c.unwrap() as char)
            .skip_while(|c| c.is_whitespace())
            .take_while(|c| !c.is_whitespace())
            .collect();
        next.parse().ok().unwrap()
    }
    fn chars(&mut self) -> Vec<char> {
        self.read::<String>().chars().collect()
    }
    fn chari(&mut self) -> Vec<i64> {
        self.chars()
            .iter()
            .map(|&c| (c as u8 - b'0') as i64)
            .collect::<Vec<i64>>()
    }
    fn readn<T: std::str::FromStr>(&mut self, n: usize) -> Vec<T> {
        (0..n).map(|_| self.read::<T>()).collect::<Vec<_>>()
    }
    fn readmat<T: std::str::FromStr>(&mut self, n: usize, m: usize) -> Vec<Vec<T>> {
        (0..n).map(|_| self.readn(m)).collect()
    }
    fn write<S: ToString>(&mut self, val: S) {
        self.Write.write(val.to_string().as_bytes());
    }
    fn writeln<S: ToString>(&mut self, val: S) {
        self.Write.write(val.to_string().as_bytes());
        self.Write.write(b"\n");
    }
    fn debug<S: std::fmt::Debug>(&mut self, val: S) {
        writeln!(self.Error, "(debug) {:?}", &val);
    }
    fn debug2<S: std::fmt::Debug, T: std::fmt::Debug>(&mut self, val1: S, val2: T) {
        writeln!(self.Error, "(debug2) {:?} -> {:?}", val1, val2);
    }
    fn debug3<S: std::fmt::Debug, T: std::fmt::Debug, U: std::fmt::Debug>(
        &mut self,
        val1: S,
        val2: T,
        val3: U,
    ) {
        writeln!(
            self.Error,
            "(debug3) {:?} -> {:?} -> {:?}",
            val1, val2, val3
        );
    }
}
//  [rust]
#![allow(unused_imports)]
use std::io::{stdin, stdout, Read, Write};

fn main() {
    let mut buf = [b'\n'; 8];
    let stdin = stdin();
    let mut handle = stdin.lock();
    handle.read(&mut buf).unwrap();
    if (buf[0] == buf[6]) && (buf[1] == buf[5]) && (buf[2] == buf[4]) {
        stdout().write_all(b"YES").unwrap();
    } else {
        stdout().write_all(b"NO").unwrap();
    };
}
//  [typescript]
import { readFileSync } from "fs";

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

const main = (input: string[][]) => {
  const field = input.slice(0, -1).map((line) => line[0]);

  return field.join("") ===
    field
      .reverse()
      .map((row) => row.split("").reverse().join(""))
      .join("")
    ? "YES"
    : "NO";
};

console.log(main(read()));
//  [typescript]
const stdin = require('fs').readFileSync('/dev/stdin', 'utf8')

const [u, l] = stdin.split('\n')

console.log(u[1] === l[1] && u[0] === l[2] && u[2] === l[0] ? 'YES' : 'NO')
//  [python]

m,d = map(int, input().split())

dates = [i for i in range(1, d+1) if i>=22 and i%10>1]

count=0
for date in dates:
  d1,d2 = str(date)
  d1 = int(d1)
  d2 = int(d2)
  if d1*d2<=m:
    count+=1
print(count)
//  [python]
n,m=map(int,input().split())
ans=0
for i in range(m):
    if i+1 >= 22:
        a=(i+1)//10
        b=(i+1)%10
        if b >= 2 and a*b<=n:
            ans = ans +1
print(ans)
//  [python]


def solve():
    M, D = map(int, input().split())
    count = 0
    for d in range(1, D + 1):
        d1 = d % 10
        d10 = int(d / 10)
        if d1 >= 2 and d10 >= 2 and 0 < d1 * d10 <= M:
            count += 1
    print(count)


if __name__ == '__main__':
    solve()
//  [python]
import numpy as np

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

if D < 22:
    print(0)
    
else:
    d = np.arange(22, D+1)
    m = np.arange(1, M+1)
    ans = 0
    
    for i in d:
        if i % 10 != 1:
            i1 = i % 10
            i10 = i // 10
            if np.any(m==i1*i10):
                ans += 1
                
    print(ans)
//  [python]
# -*- coding: utf-8 -*-
# 
import math
import sys
import itertools
import numpy as np

# なんこか入力
m,d = map(int, input().split())
answer = 0
for i in range(1,m+1):
    for j in range(1,d+1):
        if j % 10 < 2:
            continue
        if j // 10 < 2:
            continue
        if (j % 10) * (j // 10) == i:
            answer += 1

print(answer)
//  [python]
import math
import sys
import numpy as np
from collections import defaultdict, deque, Counter 
from itertools import accumulate, product, permutations,combinations, combinations_with_replacement
from operator import itemgetter
from bisect import bisect_left,bisect
from heapq import heappop,heappush
from fractions import gcd

max_value = 1000000000
min_value = -1000000000
sys.setrecursionlimit(max_value)

m, d = map(int,input().split())

count = 0
for i in range(1,m+1):
    for j in range(10,d+1):
        first_d = int(str(j)[1])
        second_d = int(str(j)[0])
        if i == first_d * second_d and first_d >= 2 and second_d >= 2:
            count += 1

print(count)
//  [java]
/*
The year is 2050, league is played by less than 100 people. T1 has finally reached Masters,
"Macaiyla I did it!" he yells excitedly. The sound echoes through the empty trailer. Macaiyla left long ago...
 */
import java.io.*;
import java.util.*;
import java.lang.Math;
import java.math.BigInteger;

public class Main {

    static class FastScanner {
        BufferedReader br;
        StringTokenizer st;

        public FastScanner() {
            try {
                br = new BufferedReader(new InputStreamReader(System.in));
                st = new StringTokenizer(br.readLine());
            } catch (Exception e){e.printStackTrace();}
        }

        public String next() {
            if (st.hasMoreTokens()) return st.nextToken();
            try {st = new StringTokenizer(br.readLine());}
            catch (Exception e) {e.printStackTrace();}
            return st.nextToken();
        }

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

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

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

        public String nextLine() {
            String line = "";
            if(st.hasMoreTokens()) line = st.nextToken();
            else try {return br.readLine();}catch(IOException e){e.printStackTrace();}
            while(st.hasMoreTokens()) line += " "+st.nextToken();
            return line;
        }
    }

    public static void main(String[] args) {
        FastScanner sc = new FastScanner();
        PrintWriter pw = new PrintWriter(System.out);
        final int MOD = 1000000007;

        int m = sc.nextInt();
        int d = sc.nextInt();

        int cnt = 0;
        for(int i=12;i<=d;i++) {
            int d1 = i / 10;
            int d10 = i % 10;
            if(d1 >= 2 && d10 >= 2 && d1 * d10 <= m) cnt++;
        }

        pw.println(cnt);
        pw.close();
    }
}

// ceil(a/b) = (a+b-1)/b
// PRO TIP: THE BEST ANSWER IS THE RIGHT ANSWER
//  [java]
/*
Stay innocent, be naive. 
But still dream big. 
Dream big to the point that it is beyond your ability and endeavour to achieve it. 
So dream big and don’t lose your innocence.
*/
import java.util.*;
import java.io.*;

   public class Main
   {
      public static void main(String args[]) throws Exception
      {
         BufferedReader infile = new BufferedReader(new InputStreamReader(System.in));  
         StringTokenizer st = new StringTokenizer(infile.readLine());
         int M = Integer.parseInt(st.nextToken());
         int D = Integer.parseInt(st.nextToken());
         int res = 0;
         for(int m=1; m <= M; m++)
            for(int d=21; d <= D; d++)
            {
               int x = d/10;
               int y = d%10;
               if(x*y == m && x >= 2 && y >= 2)
               {
                  res++;
                  //System.out.println(m+" "+d);
               }
            }
         System.out.println(res);
      }
   }
//  [java]
/*
The year is 2050, league is played by less than 100 people. T1 has finally reached Masters,
"Macaiyla I did it!" he yells excitedly. The sound echoes through the empty trailer. Macaiyla left long ago...
 */
import java.io.*;
import java.util.*;
import java.lang.Math;
import java.math.BigInteger;

public class Main {

    static class FastScanner {
        BufferedReader br;
        StringTokenizer st;

        public FastScanner() {
            try {
                br = new BufferedReader(new InputStreamReader(System.in));
                st = new StringTokenizer(br.readLine());
            } catch (Exception e){e.printStackTrace();}
        }

        public String next() {
            if (st.hasMoreTokens()) return st.nextToken();
            try {st = new StringTokenizer(br.readLine());}
            catch (Exception e) {e.printStackTrace();}
            return st.nextToken();
        }

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

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

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

        public String nextLine() {
            String line = "";
            if(st.hasMoreTokens()) line = st.nextToken();
            else try {return br.readLine();}catch(IOException e){e.printStackTrace();}
            while(st.hasMoreTokens()) line += " "+st.nextToken();
            return line;
        }
    }

    public static void main(String[] args) {
        FastScanner sc = new FastScanner();
        PrintWriter pw = new PrintWriter(System.out);
        final int MOD = 1000000007;

        int m = sc.nextInt();
        int d = sc.nextInt();

        int cnt = 0;
        for(int i=10;i<=d;i++) {
            int d1 = i / 10;
            int d10 = i % 10;
            if(d1 >= 2 && d10 >= 2 && d1 * d10 <= m) cnt++;
        }

        pw.println(cnt);
        pw.close();
    }
}

// ceil(a/b) = (a+b-1)/b
// PRO TIP: THE BEST ANSWER IS THE RIGHT ANSWER
//  [java]
import java.util.*;
public class Main {
	public static void main(String[] args){
		Scanner sc = new Scanner(System.in);
		// 整数の入力
		int m = sc.nextInt();
        int d = sc.nextInt();
        int count = 0;
        String s;
        String ans[] = new String[2];
        int i,j;
      	for(i = 2;i <= m;i++){
          for(j = 22;j <= d;j++){
            s = String.valueOf(j);
            ans = s.split("");
            if(i == Integer.parseInt(ans[0]) * Integer.parseInt(ans[1])
              && Integer.parseInt(ans[0]) >= 2 && Integer.parseInt(ans[1]) >= 2){
             count += 1; 
            }
          }
        }
         System.out.println(count);
    }
}
//  [cpp]
#include<stdio.h>
#define R register
int m,d,ans;
int main(void)
{
	scanf("%d%d",&m,&d);
	for(R int i=4; i<=m; i++)
	{
		for(R int j=22; j<=d; j++)
		{
			int k=j%10,g=j/10;
			if(k>1&&g>1&&k*g==i)
			{
				ans++;
			}
		}
	}
	printf("%d",ans);
	return 0;
}
//  [cpp]
#include <bits/stdc++.h>
using namespace std;
#define rep(i, s, n) for (int i = s; i < n; i++)

int main()
{
	int m,d,a,b,c;

   cin >> m >> d;

   c=0;
   for(int i=1; i<=m; i++){
    for(int j=10; j<=d; j++){
      a=j%10;
      b=j/10;
      if(a*b == i && a>=2 && b>=2){
        c++;
      }
    }
   }

   cout << c << endl;

	return 0;
}
//  [cpp]
//  MONSTER >_<
#include <bits/stdc++.h>
#define SPEED ios::sync_with_stdio(false); cin.tie(0)
#define loop(i,a,b) for(int i=a;i<b;i++)
#define ll long long
#define vi vector<int>
#define vl vector<ll>
#define pii pair<int,int>
#define pll pair<long long int,long long int>
#define dbg(x) cout<<#x<<": "<<x<<endl
#define ff first
#define ss second
#define mp make_pair
#define pb push_back
#define mo 1000000007
#define inf 1e18
#define eps 0.0000000001
#define stp setprecision(20)
#define all(v) v.begin(),v.end()
#define endl '\n'
using namespace std;
//mt19937 rng32(chrono::steady_clock::now().time_since_epoch().count());

#define N  int(2e5)+10

int main()
{    SPEED;

       int m,d;
       cin>>m>>d;int cnt=0;
       loop(i,1,d+1){ 
       	 if(i%10>=2&&(i/10)%10>=2&&(i/10)*(i%10)<=m)cnt++;
	   }cout<<cnt;
}
//  [cpp]
#include <bits/stdc++.h>
using namespace std;
int main()
{
    int m, d;
    cin >> m >> d;
    int c = 0;
    for(int i = 4; i <= m; i++){
        for(int j = 22; j <= d; j++){
            int p = j%10;
            int q = j/10;
            if(p >= 2 and q >= 2){
                if(p*q == i)
                    c++;
            }
        }
    }
    cout << c << "\n";
}
//  [cpp]

#include <iostream>
#include <vector>
#include <array>
#include <set>
#include <cmath>
#include <string>
#include <queue> 
#include <list>
#include <stack>
#include <unordered_map>
#include <algorithm> 
#include <numeric>  
#include <functional>
#include <cassert>
#include <bitset>
#include <cctype>  
#include <iomanip> 
#include <limits>  
// std::numeric_limits<int>::max(), min()
// std::setprecision(X)
// std::islower(), std::isupper(), std::tolower, std::toupper
// std::accumulate(m.begin(), m.end(), 0LL);
// std::sort(begin(),end()) // 0, 1, 2, 3 ,4 (default, less);
// std::priority_queue<int, vector<int>, less<int>> que; // 4, 3, 2, 1 (defualt, less) : 
 
#define  rep(i, n) for(int i = 0; i < (int)(n);    i++)
#define rrep(i, n) for(int i = ((int)(n)-1); i>=0; i++)
#define sz(x) ((int)(x).size())
#define all(x) (x).begin(),(x).end()

template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }
typedef long long ll;

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


int main (void) {
  std::cin.tie(0);  std::ios::sync_with_stdio(false);
  int M, D; std::cin >> M >> D;

  int ans = 0;
  for(int m=1; m<=M; m++) {
    for(int k=2; k<=std::sqrt(m); k++) {
      if ( m % k == 0 ) {
        int d1 = k;
        int d2  = m/k;
        if ( d1 >= 2 && d2 >= 2 && d1 >=0 && d1 <= 9 && d2 >= 0 && d2 <= 9) {
          if ( d1*10 + d2 <= D ) ans++;
          if ( d1 != d2 && d2*10 + d1 <= D ) ans++;
        }
      }
    }
  }
  std::cout << ans << std::endl;
  return 0;
}
//  [c]
#include <stdio.h>

int main(void){

  int m,d;
  scanf("%d %d", &m, &d);
  int count = 0;
  for (int i = 4; i <= m; i++) {
    for (int j = 2; j <= d/10; j++) {
      if (i%j == 0 && j*10+(i/j) <= d && (i/j) >= 2 && (i/j) <= 9) {
        count++;
      }
    }
  }
  printf("%d\n", count);

  return 0;
}
//  [c]
#include <stdio.h>
int main() {
	int m, d, cnt = 0;
	scanf("%d%d", &m, &d);
	for (int i = 1; i <= m; i++) {
		for (int j = 1; j <= d; j++) {
			int d1, d10;
			d1 = j % 10;
			d10 = (j - d1) / 10;
			if (d1 >= 2 && d10 >= 2 && d1 * d10 == i) {
				cnt++;
			}
		}
	}
	printf("%d\n", cnt);
	return 0;
}
//  [c]
#include <stdio.h>

int main(void) {
    int m;
    int d;

    scanf("%d %d", &m, &d);

    int cnt = 0;
    for(int i = 1; i <= m; i++) {
        for(int j = 10; j <= d; j++) {
            int oneRank = j % 10;
            int tenRank = j / 10;

            if(oneRank < 2 || tenRank < 2) {
                continue;
            }

            if(i == oneRank * tenRank) {
                cnt++;
            }
        }
    }

    printf("%d", cnt);

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

int main(){
    int i,j,d1,d2;
    int M,D;
    int cnt = 0;
    scanf("%d %d",&M,&D);
    // d1 = D % 10;
    // d2 = D / 10;
    for(i=4;i<=M;i++){
        for(j=22;j<=D;j++){
            d1 = j % 10;
            d2 = j / 10;
            if(((d1>=2)&&(d2>=2)) && d1*d2==i) cnt++;
        }
    }
    printf("%d\n",cnt);
    return 0;
}
//  [c]
#include <stdio.h>

int main(){
  int M,D,S=0;
  scanf("%d %d",&M,&D);
  for(int i=1;i<=M;i++){
    for(int j=22;j<=D;j++){
      int d1=j%10;
      int d2=(j/10)%10;
      if(d1>=2 && d2>=2 && i==d1*d2){
        S++;
      }
    }
  }
  printf("%d\n",S);
  return 0;
}
//  [c]
#include <stdio.h>

int main(void) {
	int M, D;
	int i, j, kaunto = 0;
	if (scanf("%d%d", &M, &D) != 2) return 1;
	for (i = 1; i <= M; i++) {
		for (j = 10; j <= D && j < 100; j++) {
			int one = j % 10, ten = j / 10;
			if (one >= 2 && ten >= 2 && one * ten == i) kaunto++;
		}
	}
	printf("%d\n", kaunto);
	return 0;
}
//  [javascript]
function Main(input) {
    const args = input.split(' ');
    const m = parseInt(args[0], 10);
    const d = parseInt(args[1], 10);
    var count = 0;
    for(var i = 1; i <= m; i++){
        for(var j = 20; j <= d; j++){
            var d1 = j % 10;
            var d10 = (j-d1) / 10;
            if(d1 * d10 == i && d1 >= 2){
                count++;
            }
        }
    }
    
    console.log(count);
}
//*この行以降は編集しないでください（標準入出力から一度に読み込み、Mainを呼び出します）
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
module.exports=function(r){var e={};function t(n){if(e[n])return e[n].exports;var o=e[n]={i:n,l:!1,exports:{}};return r[n].call(o.exports,o,o.exports,t),o.l=!0,o.exports}return t.m=r,t.c=e,t.d=function(r,e,n){t.o(r,e)||Object.defineProperty(r,e,{enumerable:!0,get:n})},t.r=function(r){"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(r,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(r,"__esModule",{value:!0})},t.t=function(r,e){if(1&e&&(r=t(r)),8&e)return r;if(4&e&&"object"==typeof r&&r&&r.__esModule)return r;var n=Object.create(null);if(t.r(n),Object.defineProperty(n,"default",{enumerable:!0,value:r}),2&e&&"string"!=typeof r)for(var o in r)t.d(n,o,function(e){return r[e]}.bind(null,o));return n},t.n=function(r){var e=r&&r.__esModule?function(){return r.default}:function(){return r};return t.d(e,"a",e),e},t.o=function(r,e){return Object.prototype.hasOwnProperty.call(r,e)},t.p="",t(t.s=0)}([function(r,e,t){t(1)(t(2).readFileSync("/dev/stdin","UTF-8"))},function(r,e){function t(r,e){return function(r){if(Array.isArray(r))return r}(r)||function(r,e){var t=[],n=!0,o=!1,u=void 0;try{for(var i,f=r[Symbol.iterator]();!(n=(i=f.next()).done)&&(t.push(i.value),!e||t.length!==e);n=!0);}catch(r){o=!0,u=r}finally{try{n||null==f.return||f.return()}finally{if(o)throw u}}return t}(r,e)||function(){throw new TypeError("Invalid attempt to destructure non-iterable instance")}()}r.exports=function(r){for(var e=t(r.split("\n")[0].split(" ").map(function(r){return Number(r)}),2),n=e[0],o=e[1],u=0,i=1;i<=n;i++)for(var f=20;f<=o;f++){var l=Math.floor(f/10),a=Math.floor(f%10);a>=2&&i==a*l&&(u+=1)}console.log(u)}},function(r,e){r.exports=require("fs")}]);
//  [javascript]
function Main(input) {
  input = input.split("\n");
  tmp = input[0].split(" ");
  var answer = 0;
  var count = 0;
  var p = new Array();
  var number = new Array();
  for(var i=22;i<Number(tmp[1])+1;i++){
    if(i%10!=1){
      number[count] = String(i).split("");
      p[count] = number[count][0]*number[count][1];
    }
    count++;
    if(i%10==1){
      count--;
    }
  }
  for(var j=0;j<p.length;j++){
    if(p[j]<=tmp[0] && p[j]!=0){
      answer++;
    }
  }
  console.log(answer);
}
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
'use strict'

const main = input => {
	const args = input.split('\n').map(arg => arg.split(' '))
	const M = parseInt(args[0][0], 10)
	const D = parseInt(args[0][1], 10)
	let cnt = 0

	for (let m = 1; m <= M; m++) {
		for (let j = 1; j <= D; j++) {
			const d1 = j % 10
			const d10 = Math.floor(j / 10)

			if (d1 >= 2 && d10 >= 2 && (d1 * d10 === m)) {
				cnt++
			}
		}
	}

	console.log(cnt)
}

main(require('fs').readFileSync('/dev/stdin', 'utf8'))
//  [javascript]
function Main(input) {
  var maxM = parseInt(input.split(" ")[0]);
  var maxD = parseInt(input.split(" ")[1]);
  var output = 0;
  if(maxD < 22){
     console.log(output);
    return;
     }
  for(var i = 1; i <= maxM; i++){
    for(var j = 22; j <= maxD; j++){
      var tmp10 = parseInt(j.toString().split("")[0]);
      var tmp1 = parseInt(j.toString().split("")[1]);
      if(tmp1 <= 1){
         continue;
         }
      if(i == tmp10 * tmp1){
         output++;
         }
    }
  }
  console.log(output);
}

Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
function Main(input) {
	input = input.split("\n");
	const input1 = input[0].split(" ")
	const M = parseInt(input1[0])
	const D = parseInt(input1[1])
	const s = []
	for(i=1; i <= D; i++){
		d1 = i % 10;
		d10 = Math.floor(i / 10);
		if(d1 >= 2 && d10 >= 2){
			s.push(d1 * d10)
		}
	}
  	
	const res = s.filter(d => d <= M)
	console.log(res.length)
}
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [go]
package main

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

const (
	initialBufSize = 1e4
	maxBufSize     = 1e6 + 7
)

var buf []byte = make([]byte, maxBufSize)
var sc = bufio.NewScanner(os.Stdin)

func init() {
	sc.Split(bufio.ScanWords)
	sc.Buffer(buf, maxBufSize)
}

func main() {
	M, D := nextInt(), nextInt()
	ans := 0
	// if M < 4 || D < 22 {
	// 	fmt.Println(0)
	// 	return
	// }
	for i := 4; i <= M; i++ {
		for j := 22; j <= D; j++ {
			d1 := j % 10
			d10 := (j / 10) % 10
			if d1 >= 2 && d10 >= 2 && i == d1*d10 {
				ans++
			}
		}
	}
	fmt.Println(ans)
}

func nextLine() 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 abs(a int) int {
	if a > 0 {
		return a
	} else {
		return -a
	}
}

func pow(p, q int) int {
	res := p
	if q == 0 {
		return 1
	}
	for i := 0; i < q-1; i++ {
		res *= p
	}
	return res
}

func MinOf(vars ...int) int {
	min := vars[0]
	for _, i := range vars {
		if min > i {
			min = i
		}
	}
	return min
}

func MaxOf(vars ...int) int {
	max := vars[0]
	for _, i := range vars {
		if max < i {
			max = i
		}
	}
	return max
}

func gcdof2numbers(a int, b int) int {
	if b == 0 {
		return a
	}
	return gcdof2numbers(b, a%b)
}

func lcmof2numbers(a int, b int) int {
	return a / gcdof2numbers(a, b) * b
}

// マイナスの場合は考慮していない
func fuctorial(a int) int {
	if a == 1 || a == 0 {
		return 1
	} else {
		return fuctorial(a-1) * a
	}
}

func NextPermutation(x sort.Interface) bool {
	n := x.Len() - 1
	if n < 1 {
		return false
	}
	j := n - 1
	for ; !x.Less(j, j+1); j-- {
		if j == 0 {
			return false
		}
	}
	l := n
	for !x.Less(j, l) {
		l--
	}
	x.Swap(j, l)
	for k, l := j+1, n; k < l; {
		x.Swap(k, l)
		k++
		l--
	}
	return true
}

// 素因数分解したmapを返す
func primeFuctorize(n int) map[int]int {
	pf := map[int]int{}
	for i := 2; i*i <= n; i++ {
		for n%i == 0 {
			pf[i]++
			n /= i
		}
	}
	if n != 1 {
		pf[n]++
	}
	return pf
}
//  [go]
package main

import "fmt"

func main() {
	var M, D int
	fmt.Scan(&M, &D)
	ans := 0
	for m := 1; m <= M; m++ {
		for d := 1; d <= D; d++ {
			var d10, d1 int
			d10 = d / 10
			d1 = d % 10
			if d1 >= 2 && d10 >= 2 && m == (d10*d1) {
				ans++
			}
		}
	}
	fmt.Println(ans)
}
//  [go]
package main

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

var sc = bufio.NewScanner(os.Stdin)

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

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

func nextFloat64() float64 {
	f, _ := strconv.ParseFloat(next(), 64)
	return f
}

func nextInts(n int) []int {
	slice := make([]int, n)
	for i := 0; i < n; i++ {
		slice[i] = nextInt()
	}
	return slice
}

func takahashi(m, d int) int {
	ret := 0
	for i := 22; i <= d; i++ {
		if (i%10) >= 2 && m == (i/10)*(i%10) {
			ret++
		}
	}
	return ret
}

func main() {
	sc.Split(bufio.ScanWords)
	m, d := nextInt(), nextInt()
	ans := 0
	for i := 1; i <= m; i++ {
		ans += takahashi(i, d)
	}
	fmt.Println(ans)
}
//  [go]
package main

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

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

func init() {}
func ru() (n int) {
	sc.Scan()
	if err := sc.Err(); err != nil {
		panic(err)
	}
	for _, v := range sc.Bytes() {
		n = n*10 + int(v-48)
	}
	return
}
func ri() (n int) {
	sc.Scan()
	if err := sc.Err(); err != nil {
		panic(err)
	}
	b := sc.Bytes()
	neg := false
	if b[0] == 45 {
		neg = true
	}
	for _, v := range b {
		n = n*10 + int(v-48)
	}
	if neg {
		n = -n
	}
	return
}
func rs() string {
	sc.Scan()
	if err := sc.Err(); err != nil {
		panic(err)
	}
	return sc.Text()
}
func rb() []byte {
	sc.Scan()
	if err := sc.Err(); err != nil {
		panic(err)
	}
	return sc.Bytes()
}
func pf(format string, a ...interface{}) {
	if _, err := fmt.Fprintf(bw, format, a...); err != nil {
		panic(err)
	}
}
func pln(a ...interface{}) {
	if _, err := fmt.Fprintln(bw, a...); err != nil {
		panic(err)
	}
}
func pall(a []int) {
	for _, v := range a {
		fmt.Fprintln(bw, v)
	}
}
func pallol(a []int) {
	s := fmt.Sprint(a)
	if _, err := fmt.Fprintln(bw, s[1:len(s)-1]); err != nil {
		panic(err)
	}
}
func debug(a ...interface{}) {
	s := fmt.Sprint(a)
	if _, err := fmt.Fprintln(os.Stderr, s[1:len(s)-1]); err != nil {
		panic(err)
	}
}
func isEven(n int) bool            { return n&1 == 0 }
func isOdd(n int) bool             { return n&1 == 1 }
func swap(a int, b int) (int, int) { return b, a }
func fill(a []int, val int) {
	for i := 0; i < len(a); i++ {
		a[i] = val
	}
	return
}
func abs(x int) int {
	if x < 0 {
		return -x
	}
	return x
}
func larger(a, b int) int {
	if a > b {
		return a
	}
	return b
}
func smaller(a, b int) int {
	if a < b {
		return a
	}
	return b
}
func largest(a, b, c int) (lgst int) {
	if a > b {
		lgst = a
	} else {
		lgst = b
	}
	if c > lgst {
		lgst = c
	}
	return
}
func smallerst(a, b, c int) (slst int) {
	if a < b {
		slst = a
	} else {
		slst = b
	}
	if c < slst {
		slst = c
	}
	return
}
func max(a []int) (idx, val int) {
	if len(a) == 0 {
		panic("func max requires at least one argument")
	}
	val = a[0]
	for i, aa := range a {
		if aa > val {
			idx, val = i, aa
		}
	}
	return
}
func min(a []int) (idx, val int) {
	if len(a) == 0 {
		panic("func min requires at least one argument")
	}
	val = a[0]
	for i, aa := range a {
		if aa < val {
			idx, val = i, aa
		}
	}
	return
}
func sum(a []int) int {
	res := 0
	for _, v := range a {
		res += v
	}
	return res
}

func sigma(x int) int     { return x * (x + 1) / 2 }
func powInt(a, b int) int { return int(math.Pow(float64(a), float64(b))) }
func main() {
	sc.Split(bufio.ScanWords)
	sc.Buffer(make([]byte, 1e7), 1e7)
	solve()
	bw.Flush()
}

const (
	inf = 1 << 60
	mod = 1e9 + 7
)

type pair struct{ a, b int }
type point struct{ x, y int }

func solve() {
	m, d := ri(), ri()
	ans := 0
	for month := 1; month <= m; month++ {
		for day := 1; day <= d; day++ {
			if day < 10 {
				continue
			}
			d1 := day % 10
			d2 := day / 10
			if d1 >= 2 && d2 >= 2 && d1*d2 == month {
				ans++
			}
		}
	}

	pln(ans)
}
//  [go]
package main

import "fmt"

func main() {
	var M, D int
	fmt.Scan(&M, &D)
	c := 0
	for m := 1; m <= M; m++ {
		for d := 2; d <= D; d++ {
			d1 := d % 10
			d10 := d / 10
			if m == d1*d10 && d1 >= 2 && d10 >= 2 {
				c++
			}
		}
	}
	fmt.Println(c)
}
//  [go]
package main

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

var sc = bufio.NewScanner(os.Stdin)

func Scan() string {
	sc.Scan()
	return sc.Text()
}
func iScan() int {
	n, _ := strconv.Atoi(Scan())
	return n
}
func fScan() float64 {
	n, _ := strconv.ParseFloat(Scan(), 64)
	return n
}
func stringToInt(s string) int {
	n, _ := strconv.Atoi(s)
	return n
}
func SScan(n int) []string {
	a := make([]string, n)
	for i := 0; i < n; i++ {
		a[i] = Scan()
	}
	return a
}
func iSScan(n int) []int {
	a := make([]int, n)
	for i := 0; i < n; i++ {
		a[i] = iScan()
	}
	return a
}
func abs(x int) int {
	if x < 0 {
		x = -x
	}
	return x
}
func larger(a, b int) int {
	if a < b {
		return b
	} else {
		return a
	}
}
func smaller(a, b int) int {
	if a > b {
		return b
	} else {
		return a
	}
}
func max(a []int) int {
	x := a[0]
	for i := 0; i < len(a); i++ {
		if x < a[i] {
			x = a[i]
		}
	}
	return x
}
func min(a []int) int {
	x := a[0]
	for i := 0; i < len(a); i++ {
		if x > a[i] {
			x = a[i]
		}
	}
	return x
}
func sum(a []int) int {
	x := 0
	for _, v := range a {
		x += v
	}
	return x
}

var mod int = 1000000007

func main() {
	buf := make([]byte, 0)
	sc.Buffer(buf, mod)
	sc.Split(bufio.ScanWords)
	m, d := iScan(), iScan()
	ans := 0
	for i := 22; i <= d; i++ {
		if (i%10)*(i/10) <= m && (i%10) > 1 {
			ans++
		}
	}
	fmt.Println(ans)
}
//  [ruby]
m, d = gets.chomp.split.map(&:to_i)
cnt = 0
(4..m).each do |i|
  (2..[Math::sqrt(i).to_i, 9].min).each do |j|
    next if i % j != 0
    k = i / j
    next if k > 9 || k < 2
    cnt += 1 if 10 * j + k <= d
    cnt += 1 if 10 * k + j <= d && j != k
  end
end
puts cnt
//  [ruby]
m,d=gets.split.map &:to_i
p (1..d).count{|i|x,y=i/10,i%10;x*y<=m&&x>=2&&y>=2}
//  [ruby]
m,d=gets.split.map &:to_i
p [*1..d].count{|i|x,y=i/10,i%10;(x*y)<=m and x>=2 and y>=2}
//  [ruby]
f = readline.split(" ")
M = f[0].to_i
N = f[1].to_i


i = 22
j = 4
ans = 0

while j < M+1 
  while i < N+1
    Z = i.to_s
    D = Z.split("")
    d_1 = D[0].to_i
    d_2 = D[1].to_i
    if   d_1 != 0 
      if d_2 != 0
        if d_1 != 1
          if d_2 != 1
            if j == d_1 * d_2
               ans += 1
    end
          end
        end
      end
    end
            
    i +=1
  end
  i = 22
  j += 1
end

puts ans
//  [ruby]
m,d = gets.split.map(&:to_i)
if d < 22
  puts 0
  exit
end
count = 0
(1..m).each do |month|
  (22..d).each do |i|
    d10,d1 = i.to_s.split("").map(&:to_i)
    next if d10 < 2 || d1 < 2
    count += 1 if d10 * d1 == month
  end
end
puts count
//  [ruby]
m, d = gets.chomp.split(' ').map(&:to_i)
def check(m, d)
  d1, d2 = sprintf('%02d', d).split('').map(&:to_i)
  d1 >= 2 && d2 >= 2 && d1 * d2 == m
end
count = 0
1.upto(m) do |i|
  1.upto(d) do |j|
    count += 1 if check(i, j)
  end
end
puts count
//  [rust]
use std::cmp::*;
use std::io::*;

fn main() {
    let mut s: String = String::new();
    stdin().read_to_string(&mut s).ok();
    let mut itr = s.trim().split_whitespace();
    let m: usize = itr.next().unwrap().parse().unwrap();
    let d: usize = itr.next().unwrap().parse().unwrap();
    let mut ans = 0;
    for i in 1..m + 1 {
        for j in 1..d + 1 {
            let d1 = j / 10;
            let d2 = j % 10;
            if d1 >= 2 && d2 >= 2 && i == d1 * d2 {
                ans += 1;
            }
        }
    }
    println!("{}", ans);
}
//  [rust]
#![allow(unused_imports)]
#![allow(dead_code)]
#![macro_use]
use std::io::prelude::*;
use std::cmp::{max, min};
use std::collections::BinaryHeap;

const MOD: i64 = 1e9 as i64 + 7;

macro_rules! input {
    (source = $s:expr, $($r:tt)*) => {
        let mut iter = $s.split_whitespace();
        let mut next = || { iter.next().unwrap() };
        input_inner!{next, $($r)*}
    };
    ($($r:tt)*) => {
        let stdin = std::io::stdin();
        let mut bytes = std::io::Read::bytes(std::io::BufReader::new(stdin.lock()));
        let mut next = move || -> String{
            bytes
                .by_ref()
                .map(|r|r.unwrap() as char)
                .skip_while(|c|c.is_whitespace())
                .take_while(|c|!c.is_whitespace())
                .collect()
        };
        input_inner!{next, $($r)*}
    };
}

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

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

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

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

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

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

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

fn main() {
    input! {
        m: usize,
        d: usize,
    }
    let mut ans = 0;
    for i in 22..d + 1{
        let d1 = i % 10;
        let d10 = i / 10;
        if d1 < 2{
            continue;
        }
        if d1 * d10 <= m{
            ans += 1;
        }
    }
    println!("{}", ans);
}
//  [rust]
#![allow(unused_imports)]
#![allow(dead_code)]
use std::io::prelude::*;
use std::cmp::{max, min};
use std::collections::BinaryHeap;

const MOD: i64 = 1e9 as i64 + 7; 

fn main(){
    let m: usize = read(); 
    let d: usize = read();
    let mut ans = 0;
    for i in 2..m + 1{
        for j in 11..d + 1{
            let d1 = j % 10;
            let d10 = (j / 10) as usize;
            if d1 <= 1 || d10 <= 1{
                continue;
            }
            if i == d1 * d10{
                ans += 1;
            }
        }
    }
    println!("{}", ans);
}

fn read<T>() -> T
where
    T: std::str::FromStr,
{
    let stdin = std::io::stdin();
    let token: String = stdin
        .lock()
        .bytes()
        .map(|c| c.unwrap() as char)
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();
    token.parse().ok().unwrap()
}
//  [rust]
macro_rules! input {
    (source = $s:expr, $($r:tt)*) => {
        let mut iter = $s.split_whitespace();
        let mut next = || { iter.next().unwrap() };
        input_inner!{next, $($r)*}
    };
    ($($r:tt)*) => {
        let stdin = std::io::stdin();
        let mut bytes = std::io::Read::bytes(std::io::BufReader::new(stdin.lock()));
        let mut next = move || -> String {
            bytes
                .by_ref()
                .map(|r| r.unwrap() as char)
                .skip_while(|c| c.is_whitespace())
                .take_while(|c| !c.is_whitespace())
                .collect()
        };
        input_inner!{next, $($r)*}
    };
}

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

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

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

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

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

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

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

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

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

#[allow(unused_imports)]
use std::cmp::{min, max};

fn main() {
    input!{
        m: usize,
        d: usize
    }
    let mut ans = 0;
    for i in 22..d + 1 {
        let a = i / 10;
        let b = i % 10;
        if a >= 2 && b >= 2 && a * b <= m {
            ans += 1;
        }
    }
    println!("{}", ans);
}
//  [rust]
use std::io::Read;

fn main() {
    let mut buf = String::new();
    std::io::stdin().read_to_string(&mut buf).unwrap();

    let answer = solve(&buf);

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

fn solve(input: &str) -> String {
    let mut iterator = input.split_whitespace();

    let m: usize = iterator.next().unwrap().parse().unwrap();
    let d: usize = iterator.next().unwrap().parse().unwrap();

    let mut ans: usize = 0;
    for i in 1..=m {
        for j in 1..=d {
            let d10 = j / 10;
            let d1 = j % 10;
            if d10 < 2 || d1 < 2 {
                continue;
            }
            if d1 * d10 == i {
                ans += 1;
            }
        }
    }
    ans.to_string()
}
//  [swift]
import CoreFoundation

func is_prime( n:Int) -> Bool {
  var r : Int
  if ( n == 1 || n == 2 || n == 3 ) { return true }
  if ( n < 2 || n%2 == 0 ) { return false }
  if ( n < 9 ) { return true }
  if ( n%3 == 0 ) { return false }

  r = Int( sqrt( Double(n) ) )
  var f : Int  = 5
  while ( f <= r ) {
    //print ( "\t", f )
    if ( n%f == 0 ) { return true }
    if ( n%(f+2) == 0 ) { return false }
    f += 6
  }
  return true
}

func unittest( ) -> Void {
  print( is_prime(3) )
  print( is_prime(2) )
  print( is_prime(4) )
  print( is_prime(5) )
  print( is_prime(7) )
}

//unittest()

let arr=readLine()!.characters.split{$0==" "}.map{Int(String($0))!}

let m = arr[0]
let d = arr[1]

var i = 0; var j = 0
var range : [Int] = []
for i in 1...m {
	range.append(i)
}

var NewRange = range.filter{ !is_prime($0) } 
//print(NewRange)

var o = 0
i = 0
for i in range {
  //print( i )
  if( d < 22 ) {
    continue
  }
  for j in 22...d {
    var d_ten = j / 10
    var d_one = j % 10
    if( d_one < 2 || d_ten < 2 ) {
      continue
    }
    if( ( d_ten * d_one ) == i ) {
      o += 1
      //print( i, d_ten, d_one )
    }
  }
}

print( o )
//  [typescript]
function Main(input: string) {
  // 1行目がinput[0], 2行目がinput[1], …に入る
  const args = input.split(" ");

  const M: number = parseInt(args[0], 10);
  const D: number = parseInt(args[1], 10);
  if (D < 22) return console.log(0);

  let count: number = 0;
  for (let i = 2; i <= 9; i++) {
    // 10
    for (let j = 2; j <= 9; j++) {
      // 1
      const today = i * 10 + j;

      if (today <= D) {
        if (i * j <= M) {
          count += 1;
        }
      }
    }
  }
  console.log(count);
}

//*この行以降は編集しないでください（標準入出力から一度に読み込み、Mainを呼び出します）
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [typescript]
import * as fs from "fs";
const input = (fs.readFileSync("/dev/stdin", "utf8") as string).split("\n");
const [M, D] = input[0].split(" ").map((x: string): number => +x);
var ret = 0;
for (var m = 1; m <= M; m++) {
    for (var d = 1; d <= D; d++) {
        var d1 = Math.floor(d / 10);
        var d2 = d % 10;
        // console.error(`${d1}, ${d2}, == ${m}`);
        if(d1 >= 2 && d2 >= 2 && d1 * d2 == m){
            ret += 1;
        }
    }
}

console.log(ret);
//  [typescript]
const Main = (input) {
  const [m, d] = input.split(" ").map(n => Number(n));
  let count = 0;
  for (let i = 1; i <= m; i++) {
    for (let p = 2; p <= (d / 10); p++) {
      if (Number.isInteger(i / p)
          && i / p < 10
          && i / p >= 2
          && (i / p) + (p * 10) <= d ) {
        count++;
      }
    }
  }
  console.log(count);
}
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [typescript]
const input=require('fs').readFileSync('/dev/stdin','utf8').split(/[\s]/);let input_i=-1;const tn=():number=>{input_i++;return Number(input[input_i])};const tnn=(n:number):number[]=>{const a=[];for(let i=0;i<n;i++){a.push(tn())}return a};const ts=():string=>{input_i++;return String(input[input_i])};const tss=(n:number):string[]=>{const a=[];for(let i=0;i<n;i++){a.push(ts())}return a};const to=(...arg)=>{console.log(...arg)};const abs=(a)=>{return Math.abs(a)};const min=(...a)=>{return Math.min(...a)};const max=(...a)=>{return Math.max(...a)};const floor=(a)=>{return Math.floor(a)};const ceil=(a)=>{return Math.ceil(a)};const asc=(ar:number[])=>{const t=[...ar];return ar.sort((a,b)=>{return a-b})};const desc=(ar:number[])=>{const t=[...ar];return t.sort((a,b)=>{return b-a})};const sw=(a,arr:any[],op:'=='|'>='|'>'|'<='|'<'='==')=>{for(let i=0;i<arr.length-1;i+=2){if(eval(a+op+arr[i])){return arr[i+1]}}return arr[arr.length-1]};const near=(n:number,arr:number[]):number=>{let ne=arr[0],ni=0;for(let i=1;i<arr.length;i++){if(Math.abs(n-ne)>Math.abs(n-arr[i])){ne=arr[i];ni=i}}return ni};const deduplicate=(a:any[]):any[]=>{return Array.from(new Set(a))};const gcd=(x,y)=>{while(y){[x,y]=[y,x%y]}return x};const sum=(arr)=>{return arr.reduce((a,b)=>a+b);};
const main=()=>{
  let [m,d]=tnn(2),ans=0
  for(let k=1;k<=m;k++){
    for(let i=22;i<=d;i++){
      if(k==Number(String(i)[0])*Number(String(i)[1])&&Number(String(i)[1])>=2)ans++
    }
  }
  to(ans)
}
main()
//  [python]
import numpy as np

a = list(map(int,input().split()))
print(np.max(a) * 9 + np.sum(a))
//  [python]
import numpy as np
import math

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

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

largest = max([A, B, C])
total = largest * 9 + A + B + C
print(total)
//  [python]
import sys
import numpy as np

a, b, c =list(map(int, sys.stdin.readline().strip().split(" ")))

i = np.argmax([a, b, c])
l = [a, b, c]
m = l[i]
l.pop(i)
print(m*10 + l[0] + l[1])
//  [java]
import java.io.*;
import java.math.*;
import java.util.*;

class Main {
    private static final Scanner sc = new Scanner(System.in);

    public static void main(String[] args) {
        int[] nums = Arrays.stream(sc.nextLine().split(" +")).mapToInt(Integer::parseInt).toArray();
        Arrays.sort(nums);
        System.out.println(nums[0]+nums[1]+10*nums[2]);
        sc.close();
    }
}
//  [java]
import java.util.*;
public class Main {
	public static void main(String[] args){
	Scanner sc = new Scanner(System.in);
	int[] intArray = Arrays.stream(sc.nextLine().split(" ")) //" "で区切ってString配列へ
    .mapToInt(Integer::parseInt) //数値にして
	.toArray(); //配列へ
		//計算
		if (intArray[0] >= intArray[1] && intArray[0] >= intArray[2]){
			// 出力
			System.out.println(intArray[0]*10 + intArray[1] + intArray[2]);
		}else if(intArray[1] >= intArray[0] && intArray[1] >= intArray[2]){
			// 出力
			System.out.println(intArray[1]*10 + intArray[0] + intArray[2]);
		}else{
			// 出力
			System.out.println(intArray[2]*10 + intArray[1] + intArray[0]);
		}

	}
}
//  [cpp]
#include <iostream>
#include <cstdio>
using namespace std;
int main()
{
	int a,b,c;
	cin>>a>>b>>c;
	cout<<max(a+b*10+c,max(a+c*10+b,max(b+a*10+c,max(b+c*10+a,max(c+a*10+b,c+b*10+a)))));
}
//  [cpp]
#include <bits/stdc++.h>
using namespace std;
 
#define rep(i, n) for (int i = (int)(0); i < (int)(n); ++i)
#define reps(i, n) for (int i = (int)(1); i <= (int)(n); ++i)
#define rrep(i, n) for (int i = ((int)(n)-1); i >= 0; i--)
#define rreps(i, n) for (int i = ((int)(n)); i > 0; i--)
#define irep(i, m, n) for (int i = (int)(m); i < (int)(n); ++i)
#define ireps(i, m, n) for (int i = (int)(m); i <= (int)(n); ++i)
#define FOR(e, c) for (auto &e : c)
#define SORT(v, n) sort(v, v + n);
#define vsort(v) sort(v.begin(), v.end());
#define rvisort(v) sort(v.begin(), v.end(), greater<int>());
#define all(v) v.begin(), v.end()
#define mp(n, m) make_pair(n, m);
#define cout(d) cout<<d<<endl;
#define coutd(d) cout<<std::setprecision(10)<<d<<endl;
#define cinline(n) getline(cin,n);
 
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vll = vector<ll>;
using vvll = vector<vll>;
using pii = pair<int, int>;
using vpii = vector<pii>;
using vs = vector<string>;
using vd = vector<double>;
using ul = unsigned long;
 
template<class T, class C> void chmax(T& a, C b){ a>b?:a=b; }
template<class T, class C> void chmin(T& a, C b){ a<b?:a=b; }
 
const int mod=1e9+7;
 
struct mint {
  ll x;
  mint(ll x=0):x(x%mod){}
  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 {
    mint res(*this);
    return res+=a;
  }
  mint operator-(const mint a) const {
    mint res(*this);
    return res-=a;
  }
  mint operator*(const mint a) const {
    mint res(*this);
    return res*=a;
  }
};
 
mint c[4005][4005];
void init() {
  c[0][0] = 1;
  for (int i = 0; i <= 4000; i++) {
    for (int j = 0; j <= i; j++) {
      c[i+1][j] += c[i][j];
      c[i+1][j+1] += c[i][j];
    }
  }
}
mint comb(int n, int k) {
  return c[n][k];
}
 
bool IsPrime(int num)
{
    if (num < 2) return false;
    else if (num == 2) return true;
    else if (num % 2 == 0) return false;
 
    double sqrtNum = sqrt(num);
    for (int i = 3; i <= sqrtNum; i += 2)
    {
        if (num % i == 0)
        {
            return false;
        }
    }
 
    return true;
}
 
map<ll, ll> primeFact(ll n) {
  map<ll, ll> res;
  for (ll i = 2; i * i <= n; i++) {
    while (n % i == 0) {
      res[i]++;
      n /= i;
    }
  }
  if (n != 1) res[n]++;
  return res;
}
 
void printv(vi& v){
  rep(i,v.size()) cout << v[i] << " ";
  cout << endl;
}
void printv(vll& v){
  rep(i,v.size()) cout << v[i] << " ";
  cout << endl;
}
int vtotal(vi& v){
  int total=0;
  rep(i,v.size()) total+=v[i];
  return total;
}
 
int main()
{
  //init(); // mint初期化
  cin.tie( 0 );
  ios::sync_with_stdio( false );
 
  int a,b,c;
  cin>>a>>b>>c;
  int l=a;
  if(l<b)l=b;
  if(l<c)l=c;
  int ans=l*9+a+b+c;
  cout(ans);
  return 0;
}