jiahuimbzuai/CoQuIR huggingface dataset:
//  [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 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 main=()=>{
  let [n,m]=tnn(2),mr=tnn(m),dp=new Array(n+1),x=1000000007
  dp[0]=1,dp[1]=1
  for(let j=0;j<mr.length-1;j++){
    if(mr[j]==mr[j+1]-1){
      to(0)
      return
    }
  }
  for(let i=2;i<=n;i++){
    let f=0
    for(let j=0;j<mr.length;j++){
      if(i==mr[j]){
        f=1
        dp[i]=dp[i-1]
        if(n>=i+1)dp[i+1]=dp[i-1]
        if(n>=i+2)dp[i+2]=dp[i-1]
        i+=2
        break
      }
    }
    if(!f)dp[i]=(dp[i-2]+dp[i-1])%x
  }
  to(dp[n])
}
main()
//  [python]
def gcd(a,b):
    if b == 0:
        return a
    else:
        return gcd(b,a%b)
a,b = map(int,input().split())
print(int(a * b / gcd(a, b)))
//  [python]
a,b = map(int,input().split())

def gcd(a, b):
    while b:
        a, b = b, a % b
    return a

def lcm(x, y):
    return (x * y) // gcd(x, y)

print(lcm(a,b))
//  [python]
def inpl():
    return list(map(int, input().split()))


def gcd(a, b):
    # greatest common divisor
    while b > 0:
        a, b = b, a % b

    return a


def lcm(a, b):
    # least common multiple
    return a * b // gcd(a, b)


A, B = inpl()

print(lcm(max(A, B), min(A, B)))
//  [python]
import math
a, b = map(int, raw_input().split());
print(a * b / math.gcd(a,b))
//  [python]
a,b = map(int,input().split())
if a%b==0 or b%a==0:
    print(max(a,b))
else:
    print(a*b)
//  [python]
import numpy as np

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

print(lcm(A, B))
//  [java]
import java.io.IOException;
import java.io.InputStream;
import java.util.NoSuchElementException;

public class Main {

	public static void main(String[] args) {

		FastScanner sc = new FastScanner();
		long A = sc.nextInt();
		long B = sc.nextInt();

		System.out.println(A * B / gcd(A, B));

	}

	public static long gcd(long a, long b) {

		if (a < b)
			return gcd(b, a);

		long c = 0;
		c = a % b;

		if (c == 0)
			return b;

		return gcd(b, c);
	}
}

class FastScanner {
	private final InputStream in = System.in;
	private final byte[] buffer = new byte[1024];
	private int ptr = 0;
	private int buflen = 0;

	private boolean hasNextByte() {
		if (ptr < buflen) {
			return true;
		} else {
			ptr = 0;
			try {
				buflen = in.read(buffer);
			} catch (IOException e) {
				e.printStackTrace();
			}
			if (buflen <= 0) {
				return false;
			}
		}
		return true;
	}

	private int readByte() {
		if (hasNextByte())
			return buffer[ptr++];
		else
			return -1;
	}

	private static boolean isPrintableChar(int c) {
		return 33 <= c && c <= 126;
	}

	public boolean hasNext() {
		while (hasNextByte() && !isPrintableChar(buffer[ptr]))
			ptr++;
		return hasNextByte();
	}

	public String next() {
		if (!hasNext())
			throw new NoSuchElementException();
		StringBuilder sb = new StringBuilder();
		int b = readByte();
		while (isPrintableChar(b)) {
			sb.appendCodePoint(b);
			b = readByte();
		}
		return sb.toString();
	}

	public long nextLong() {
		if (!hasNext())
			throw new NoSuchElementException();
		long n = 0;
		boolean minus = false;
		int b = readByte();
		if (b == '-') {
			minus = true;
			b = readByte();
		}
		if (b < '0' || '9' < b) {
			throw new NumberFormatException();
		}
		while (true) {
			if ('0' <= b && b <= '9') {
				n *= 10;
				n += b - '0';
			} else if (b == -1 || !isPrintableChar(b)) {
				return minus ? -n : n;
			} else {
				throw new NumberFormatException();
			}
			b = readByte();
		}
	}

	public int nextInt() {
		long nl = nextLong();
		if (nl < Integer.MIN_VALUE || nl > Integer.MAX_VALUE)
			throw new NumberFormatException();
		return (int) nl;
	}

	public double nextDouble() {
		return Double.parseDouble(next());
	}
}
//  [java]
import java.io.*;
import java.util.*;

class Main{
    final static long MOD = 1000000007;
    FastScanner sc = new FastScanner();

    public static void main(String[] args) {
        new Main().solve();
    }

    void solve(){

        long a = sc.nextLong();
        long b = sc.nextLong();

        System.out.println(a * b / gcd(a, b));

    }

    long gcd(long a, long b){ // return aとbの最大公約数
        if(b == 0){
          return a;
        }
        return gcd(b, a % b);
    }

    long pow_mod(long a, long r){ // return a^r (mod MOD)
        long sum = 1;
        while(r > 0){
            if((r & 1) == 1){
                sum *= a;
                sum %= MOD;
            }
            a *= a;
            a %= MOD;
            r >>= 1;
        }
        return sum;
    }

}



class FastScanner {
    private final InputStream in = System.in;
    private final byte[] buffer = new byte[1024];
    private int ptr = 0;
    private int buflen = 0;
    private boolean hasNextByte(){
        if(ptr < buflen){
            return true;
        }else{
            ptr = 0;
            try{
                buflen = in.read(buffer);
            }catch(IOException e){
                e.printStackTrace();
            }
            if(buflen <= 0){
                return false;
            }
        }
        return true;
    }
    private int readByte(){ if(hasNextByte()) return buffer[ptr++]; else return -1;}
    private static boolean isPrintableChar(int c){ return 33 <= c && c <= 126;}
    public boolean hasNext(){ while(hasNextByte() && !isPrintableChar(buffer[ptr])) ptr++; return hasNextByte();}
    public String next(){
        if(!hasNext()) throw new NoSuchElementException();
        StringBuilder sb = new StringBuilder();
        int b = readByte();
        while(isPrintableChar(b)){
            sb.appendCodePoint(b);
            b = readByte();
        }
        return sb.toString();
    }
    public long nextLong(){
        if(!hasNext()) throw new NoSuchElementException();
        long n = 0;
        boolean minus = false;
        int b = readByte();
        if(b == '-'){
            minus = true;
            b = readByte();
        }
        if(b < '0' || '9' < b){
            throw new NumberFormatException();
        }
        while(true){
            if('0' <= b && b <= '9'){
                n *= 10;
                n += b - '0';
            }else if(b == -1 || !isPrintableChar(b)){
                return minus ? -n : n;
            }else{
                throw new NumberFormatException();
            }
            b = readByte();
        }
    }
    public int nextInt(){
        long nl = nextLong();
        if (nl < Integer.MIN_VALUE || nl > Integer.MAX_VALUE) throw new NumberFormatException();
        return (int) nl;
    }
    public double nextDouble(){ return Double.parseDouble(next());}
}
//  [java]
import java.util.*;
import java.io.*;

class Main{
    public static void main(String[] args){
        FastScanner fsc=new FastScanner();
        long a=fsc.nextLong();
        long b=fsc.nextLong();
        fsc.close();
        long gcd=euclideanGCD(a, b);
        a/=gcd;
        b/=gcd;
        System.out.println(a*b*gcd);
    }
    public static long euclideanGCD(long a, long b) {
        if(a < b) return euclideanGCD(b, a);
        long r=a%b;
        while (r!=0) {
          a = b;
          b = r;
          r=a%b;
        }
        return b;
    }
    static class FastScanner {
        private final InputStream in = System.in;
        private final byte[] buffer = new byte[1024];
        private int ptr = 0;
        private int buflen = 0;
        private boolean hasNextByte(){
            if(ptr<buflen) return true;
            else{
                ptr = 0;
                try{
                    buflen = in.read(buffer);
                }
                catch(IOException e){
                    e.printStackTrace();
                }
                if(buflen<=0) return false;
            }
        return true;
        }
        private int readByte() { if (hasNextByte()) return buffer[ptr++]; else return -1;}
        private static boolean isPrintableChar(int c) { return 33 <= c && c <= 126;}
        public boolean hasNext() { while(hasNextByte() && !isPrintableChar(buffer[ptr])) ptr++; return hasNextByte();}
        public String next() {
            if (!hasNext()) throw new NoSuchElementException();
            StringBuilder sb = new StringBuilder();
            int b = readByte();
            while(isPrintableChar(b)) {
                sb.appendCodePoint(b);
                b = readByte();
            }
            return sb.toString();
        }
        public long nextLong() {
            if (!hasNext()) throw new NoSuchElementException();
            long n = 0;
            boolean minus = false;
            int b = readByte();
            if (b == '-') {
                minus = true;
                b = readByte();
            }
            if (b < '0' || '9' < b) throw new NumberFormatException();
            while(true){
                if ('0' <= b && b <= '9') {
                    n *= 10;
                    n += b - '0';
                }
                else if(b == -1 || !isPrintableChar(b)) return minus ? -n : n;
                else throw new NumberFormatException();
                b = readByte();
            }
        }
        public int nextInt() {
            long nl = nextLong();
            if (nl < Integer.MIN_VALUE || nl > Integer.MAX_VALUE) throw new NumberFormatException();
            return (int) nl;
        }
        public double nextDouble() { return Double.parseDouble(next());}
        public void close(){
            try{in.close();}
            catch(IOException e){e.printStackTrace();}
        }
    }
}
//  [java]
	
	import java.util.*;
	
		public class Main {
			
			public static void main(String[] args) {		
			
				Scanner sc=new Scanner(System.in);			
				long a=sc.nextInt();
				long b=sc.nextInt();				
				long ebob=1;				
				for(int i=1; i<=Math.min(a, b); i++) {
					if(a%i==0 && b%i==0) {
						ebob *=i;
					}					
				}
				long ans= ((a*b)/ebob);
				System.out.println(ans);					
			}
		
	}
//  [java]
    import java.util.*;
    public class Main {// Main
        public static void main(String[] args){
            Scanner sc=new Scanner(System.in);			
				long a=sc.nextInt();
				long b=sc.nextInt();				
				long ebob=1;				
				for(int i=1; i<Math.min(a, b); i++) {
					if(a%i==0 && b%i==0) {
						ebob *=i;
					}					
				}
				long ans= ((a*b)/ebob);
				System.out.println(ans);	
        }
    }
//  [java]
	
	import java.util.*;
	
		public class Main {
			
			public static void main(String[] args) {		
			
				Scanner sc=new Scanner(System.in);			
				long a=sc.nextInt();
				long b=sc.nextInt();				
				long ebob=1;				
				for(int i=1; i<Math.min(a, b); i++) {
					if(a%i==0 && b%i==0) {
						ebob *=i;
					}					
				}
				long ans= ((a*b)/ebob);
				System.out.println(ans);					
			}
		
	}
//  [cpp]
#include <stdio.h>

typedef long long int llint;

llint gcd(llint a,llint b)
{
    if(a<b)
    {
        int tmp=a;
        a=b;
        b=tmp;
    }
    if(a%b==0)return b;
    else return gcd(b,a%b);
}

int main()
{
    llint a,b;
    scanf("%lld %lld",&a,&b);
    printf("%lld\n",a*b/gcd(a,b));
}
//  [cpp]
#include <cstdio>
using namespace std;
typedef long long ll;

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

int main() {
  ll a, b;
  scanf("%lld%lld", &a, &b);
  printf("%lld\n", a * b / gcd(a, b));
}
//  [cpp]
#include<stdio.h>
#include<string.h>
#include<algorithm>
#define MAX 100100
using namespace std;

long long f(long long a, long long b) {
	long long tmp;
	if (a < b) {
		tmp = a;
		a = b;
		b = tmp;
	}
	while (b != 0) {
		tmp = a % b;
		a = b;
		b = tmp;
	}
	return a;
}
int main()
{
	long long a, b, g;
	scanf("%lld%lld", &a, &b);
	g = f(a, b);
	printf("%lld", a*b / g);
	return 0;
}
//  [cpp]
#include <bits/stdc++.h>

using namespace std;

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

int main() {
    long long n, m; cin >> n >> m;
    cout << lcm(n, m) << "\n";
}
//  [cpp]
#include <bits/stdc++.h>

using namespace std;

int main() {
    long long n, m; cin >> n >> m;
    cout << __lcm(n, m) << "\n";
}
//  [cpp]
#include <bits/stdc++.h>
using namespace std;

int main() {
  
long long int a, b, count, ans;
  ans = 1;
  vector<int> answer(10000);
  cin >> a >> b;
  
  for(int i = 2; i < 10001; i++){
    if(a % i == 0 && b % i == 0){
      answer[i] = i;
    }
  }
  
  for(int i = 0; i < 10001; i++){
    if(answer[i] != 0){
    ans *= answer[i];
    }
  }
 a = a/ans;
  
  
  cout << a*b<< endl;
  
}
//  [c]
#include<stdio.h>
int main()
{
    long long a1,b1,t,a,b,c,d;
	scanf("%lld %lld",&a1,&b1);
	if(a1>b1)
	{
	    t=a1;
	    a1=b1;
	    b1=t;
	}
	a=a1;
	b=b1;
	d=a%b;
	a=b;
	b=d;
	while(d!=0)
	{
		d=a%b;
		a=b;
		b=d;
	} 
	printf("%lld\n",a1*b1/a);
    return 0;
}
//  [c]
#include <stdio.h>
int gcd(int x,int y){
    if (x < y) {
        int tmp = x;
        x = y;
        y = tmp;
    }
    while (y > 0) {
        int tmp = x;
        x = y;
        y = tmp % y;
    }
    return x;
}

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

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

    long ans = lcm(A,B);
    printf("%ld\n",ans);

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

int gcd(int a, int b) {
	while (a) {
		int t = b%a;
		b = a;
		a = t;
	}
	return b;
}

int main(void) {
	int a, b;
	scanf("%d%d", &a, &b);
	int g = gcd(a, b);
	long long int lcm = (long long int)a*b;
	lcm /= g;

	printf("%lld\n", lcm);
}
//  [c]
#include <stdio.h>
int main ()
{
    int a,b;
    scanf("%d %d",&a,&b);

    if((a<10 && b<10)|| (a>1000 && b>1000))
    {
        int z=a*b;
        printf("%d\n",z);
    }
    else
    {
        int x= (a*b)/3;
        printf("%d\n",x);
    }
    return 0;
}
//  [c]
//C-Snack

#include <stdio.h>



int main(void) {
    long int a;
    long int b;
    scanf("%ld%ld", &a, &b);
    //printf("%d%d\n", a, b);
    long int i;
    for (i = 2;i <= b + 1;i++) {
        if ((a * i) % b == 0) {
            printf("%ld\n", a * i);
            break;
          }

      }
    return 0;

  }
//  [c]
//C-Snack

#include <stdio.h>

int bigger(long int x, int y){
    if(x < y)
        return (y);
    else
        return (x);
  }
int smaller(long int x, int y) {
    if(x < y)
        return (x);
    else
        return (y);
  }


int main(void) {
    long int a;
    int b;
    long int c;
    long int d;
    long int e;
    scanf("%ld%d", &a, &b);
    //printf("%d%d\n", a, b);
    c = bigger(a,b);
    d = smaller(a,b);
    long int i;
    for (i = 2;i < (a * b) + 1;i++) {
        if ((c * i) % d == 0) {
            e = c * i;
            break;
          }

      }
    printf("%ld\n", e);
    return 0;

  }
//  [javascript]
function main(input){
    input=input.split(' ');
    inputA=parseInt(input[0]);
    inputB=parseInt(input[1]);
    
    x = inputA * inputB;

    out = inputA % inputB;
    while(out!=0){
        inputA = inputB;
        inputB = out;
        out = inputA % inputB;
    }

    console.log(x/inputB);
}

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

const gcd = (a, b)  => {
  return b ? gcd(b, a % b) : a
}

const lcm = (a, b) => {
  return a * b / gcd(a, b);
}

const main = input => {
  const args = input.split(' ')
  const numA = parseInt(args[0])
  const numB = parseInt(args[1])
  
  console.log(lcm(numA, numB)) 
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [javascript]
"use strict"
function main(arg) {
    var data = arg.trim().split("\n")[0].split(" ").map(Number)
    console.log(lcm(data[0], data[1]))
}

function gcd(a, b){
    if (b !== 0) {
        return gcd(b, a%b);
    }
    return a;
}

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

main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [javascript]
function GCD(A,B){
  for (var r = a % b; r != 0; r = a % b) {
            a = b
            b = r
    }
  return b
}

function main(input){
  	const args = input.split(' ');
    const a = parseInt(args[0], 10);
    const b = parseInt(args[1], 10);
	console.log(a / gcd(a,b) * b)
}


main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [javascript]
// inputに入力データ全体が入る
function Main(input) {
    "use strict";
    // 1行目がinput[0], 2行目がinput[1], …に入る
    const input_ = input.split(" ");
    const toInt = function (n, array) {
        let result = [];
        for (let i = 0; i < n; i++) {
            result[i] = parseInt(array[i]);
        }
        return result;
    };
    const input_i = toInt(input_.length, input_);
    let lcm = 0; // 最小公倍数
    let gcd = 0; // 最大公約数
    input_i.sort((a, b) => b - a);
    for (let i = 0; i < input_i.length-1; i++) {
        gcd = Math.floor(input_i[i] / input_i[i + 1]);
        lcm = input_i[i] * input_i[i + 1] / gcd;
    }
    // 出力
    console.log('%d', lcm);
}
//*この行以降は編集しないでください（標準入出力から一度に読み込み、Mainを呼び出します）
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
const args = process.argv.slice(2);

const inputA = args[0];
const inputB = args[1];
let i = 1;
let answer = 0;
let answerA = Number(inputA);
let answerB = Number(inputB);

do {
    i = i+1;
    answerA = Number(inputA);
    answerA = i / answerA;
    answerB = Number(inputB);
    answerB = i / answerB;
} while(Number.isInteger(answerA) === false || Number.isInteger(answerB) === false);

console.log(i);
//  [go]
package main

import (
	"bufio"
	"fmt"
	"os"
	"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() {
	A, B := nextInt(), nextInt()
	fmt.Println(lcmof2numbers(A, B))
}

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 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
}
//  [go]
package main

import (
	"fmt"
)

func main() {
	var a, b int
	fmt.Scanf("%d %d", &a, &b)
	answer := leastCommonMultiple(a, b)
	fmt.Println(answer)
}

func leastCommonMultiple(a, b int) int {
	g := gcd(a, b)
	return a / g * b
}

func gcd(a, b int) int {
	if a < b {
		a, b = b, a
	}
	if b == 0 {
		return a
	}
	return gcd(b, a%b)
}
//  [go]
package main

import "fmt"

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

	fmt.Println(lcm(a, b))

}

func lcm(i, j int) int {
	return i * j / gcd(i, j)
}

func gcd(a, b int) int {
	if b == 0 {
		return a
	}
	return gcd(b, a%b)
}
//  [go]
package main

import (
	"fmt"
)

func main() {
	var a, b int
	fmt.Scanf("%d", &a, &b)
	answer := leastCommonMultiple(a, b)
	fmt.Println(answer)
}

func leastCommonMultiple(a, b int) int {
	g := gcd(a, b)
	return a / g * b
}

func gcd(a, b int) int {
	if a < b {
		a, b = b, a
	}
	if b == 0 {
		return a
	}
	return gcd(b, a%b)
}
//  [go]
package main

import (
	"fmt"
)

func main() {
	var a, b int
	fmt.Scanf("%d", &a, &b)
	answer := leastCommonMultiple(a, b)
	fmt.Println(answer)
}

func leastCommonMultiple(a, b int) int {
	g := gcd(a, b)
	return a / g * b / g
}

func gcd(a, b int) int {
	if a < b {
		a, b = b, a
	}
	if b == 0 {
		return a
	}
	return gcd(b, a%b)
}
//  [go]
package main

import (
	"fmt"
)

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

	fmt.Println(gcd(a, b))
	fmt.Print(lcm(a, b))
}

func lcm(a, b int) int {
	return a * b / gcd(a, b)
}

func gcd(a, b int) int {
	for i := min(a, b); i >= 1; i-- {
		if a % i == 0 && b % i == 0 {
			return i
		}
	}
	return 0
}

func min(a, b int) int {
	if a < b {
		return a
	} else {
		return b
	}
}
//  [ruby]
a,b=gets.chomp.split.map(&:to_i)
p a.lcm(b)
//  [ruby]
x, y = gets.chomp.split(" ").map(&:to_i)
puts x.lcm(y)
//  [ruby]
#input of int(split by space)
def get_i()
  return gets.chomp.split(" ").map(&:to_i)
end
#input of float(split by space)
def get_f()
  return gets.chomp.split(" ").map(&:to_f)
end
#input of string(split by space)
def get()
  return gets.chomp.split(" ")
end
#input of string(split per one character)
def get_nsp()
  return gets.chomp.split("")
end
#yes or no decision
def yn_judge(bool,y="Yes",n="No")
  return bool ? y : n 
end
#create of array
def array(size1,init=nil,size2=-1)
  if size2==-1
    return Array.new(size1){init}
  else
    return Array.new(size2){Array.new(size1){init}}
  end
end

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

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

INF=Float::INFINITY

puts get_i.inject(1){|res,x| res.lcm(x)}
//  [ruby]
require 'prime'
ans=1
a,b=gets.split.map &:to_i
a.prime_division.each do |i,j|
  ans*=i**j
end
b.prime_division.each do |i,j|
  ans*=i**j
end
p ans
//  [ruby]
a,b=gets.to_i
p a.lcm(b)
//  [ruby]
A, B = gets.chomp.split.map(&:to_i)


af = (1..A).map{ |i| (A%i).zero? ? i : nil }
	 .compact
bf = (1..B).map{ |i| (B%i).zero? ? i : nil }
	 .compact

p A * B / (af & bf).inject(&:*)
//  [rust]
use std::io::{self, BufRead};

fn gcd(x: usize, y: usize) -> usize {
  let (mut a, mut b) = if x < y {
    (y, x)
  } else {
    (x, y)
  };
  while b != 0 {
    let r = a % b;
    a = b;
    b = r;
  }
  a
}

fn lcm_by_gcd(x: usize, y: usize, g: usize) -> usize {
  x * y / g
}

fn main() {
  let stdin = io::stdin();
  let mut lines = stdin.lock().lines();
  let xs: Vec<usize> = lines.next().unwrap().unwrap().split(' ').map(|x| x.parse().unwrap()).collect();
  let g = gcd(xs[0], xs[1]);
  let l = lcm_by_gcd(xs[0], xs[1], g);
  println!("{}", l);
}
//  [rust]
macro_rules! input {
    (source = $s:expr, $($r:tt)*) => {
        let mut iter = $s.split_whitespace();
        let mut next = || { iter.next().unwrap() };
        input_inner!{next, $($r)*}
    };
    ($($r:tt)*) => {
        let stdin = std::io::stdin();
        let mut bytes = std::io::Read::bytes(std::io::BufReader::new(stdin.lock()));
        let mut next = move || -> String{
            bytes
                .by_ref()
                .map(|r|r.unwrap() as char)
                .skip_while(|c|c.is_whitespace())
                .take_while(|c|!c.is_whitespace())
                .collect()
        };
        input_inner!{next, $($r)*}
    };
}

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

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

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

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

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

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

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

fn main() {
    input!{
    a: usize,
    b: usize
    }
    let ans = a * b / gcd(&a, &b);
    println!("{}", ans);
}
// O(log(N))
fn gcd(a: &usize, b: &usize) -> usize {
    let (mut x, mut y) = if a < b { (*b, *a) } else { (*a, *b) };
    let mut r = x % y;
    while r != 0 {
        x = y;
        y = r;
        r = x % y;
    }
    y
}
//  [rust]
#[allow(dead_code)]
fn main() {
    let (a, b) = i::u2();
    println!("{}", a * b / gcd(a, b));
}

#[allow(unused_imports)]
use greatest_common_divisor::*;

#[allow(dead_code)]
mod greatest_common_divisor {
    use std::mem::swap;

    pub fn gcd(mut a: usize, mut b: usize) -> usize {
        if a < b {
            swap(&mut b, &mut a);
        }
        while b != 0 {
            a = a % b;
            swap(&mut a, &mut b);
        }
        a
    }
}

#[allow(unused_imports)]
use std::cmp::*;
#[allow(unused_imports)]
use std::collections::{HashMap, HashSet, VecDeque};
#[allow(unused_imports)]
use std::io::*;
#[allow(unused_imports)]
use std::num::*;
#[allow(unused_imports)]
use std::str::*;

#[allow(dead_code)]
mod i {
    use super::*;

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

    pub fn str() -> String {
        read()
    }

    pub fn s() -> Vec<char> {
        str().chars().collect()
    }

    pub fn i() -> i64 {
        read()
    }

    pub fn u() -> usize {
        read()
    }

    pub fn u2() -> (usize, usize) {
        (read(), read())
    }

    pub fn u3() -> (usize, usize, usize) {
        (read(), read(), read())
    }

    pub fn f() -> f64 {
        read()
    }

    pub fn c() -> char {
        read::<String>().pop().unwrap()
    }

    pub fn iv(n: usize) -> Vec<i64> {
        (0..n).map(|_| i()).collect()
    }

    pub fn iv2(n: usize) -> Vec<(i64, i64)> {
        (0..n).map(|_| iv(2)).map(|a| (a[0], a[1])).collect()
    }

    pub fn uv(n: usize) -> Vec<usize> {
        (0..n).map(|_| u()).collect()
    }

    pub fn uv2(n: usize) -> Vec<(usize, usize)> {
        (0..n).map(|_| uv(2)).map(|a| (a[0], a[1])).collect()
    }

    pub fn uv3(n: usize) -> Vec<(usize, usize, usize)> {
        (0..n).map(|_| uv(3)).map(|a| (a[0], a[1], a[2])).collect()
    }

    pub fn fv(n: usize) -> Vec<f64> {
        (0..n).map(|_| f()).collect()
    }

    pub fn cmap(h: usize) -> Vec<Vec<char>> {
        (0..h).map(|_| s()).collect()
    }
}
//  [rust]
use text_io::*;
use std::process::exit;
use im_rc::HashMap;
use std::cmp::min;

fn main(){
    let mut a:usize = read!();
    let mut b:usize = read!();
    let mut c:usize = 1;
    for mut i in 2..(a as f32).sqrt() as usize+1 {
        if a%i == 0 && b%i == 0{
            c*=i;
            *&mut i -= 1;
        }
    }
    println!("{}",(a*b)/c);
}
//  [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 a:u128 = read();
    let b:u128 = read();
    println!("{}", a / gcd(a, b) *  b);
}

fn gcd(a:u128, b:u128) -> u128 {
    if b == 0 {
        return a
    }
    return gcd(b, a%b)
}
//  [rust]
use num;

#[allow(unused_macros)]
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)*}
    };
}

#[allow(unused_macros)]
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)*}
    };
}

#[allow(unused_macros)]
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, bytes) => {
        read_value!($next, String).into_bytes()
    };

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

    ($next:expr, $t:ty) => {
        $next().parse::<$t>().expect("Parse error")
    };
}
//usage
//input! {
//  h: i32;
//  v: [i32; n]
//  x: [[i32; n]; m]
//  f: chars <- Vec<char>
//}

fn main() {
    input!(a: i64, b: i64);
    println!("{}", num::integer::lcm(a, b));
}
//  [swift]

public func gcd( m: Int, n: Int, using gcdAlgorithm: (Int, Int) -> (Int) = gcdIterativeEuklid) -> Int {
    return gcdAlgorithm(m, n)
}

public func gcdIterativeEuklid(_ m: Int, _ n: Int) -> Int {
    var a: Int = 0
    var b: Int = max(m, n)
    var r: Int = min(m, n)
    
    while r != 0 {
        a = b
        b = r
        r = a % b
    }
    return b
}

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

print((arr[0] * arr[1]) / gcd(arr[0], n: arr[1], using: gcdIterativeEuklid) )
//  [swift]
import Foundation
#if CUDA
extension String {
    func at(i: Int) -> String {
        return String(self[self.index(self.startIndex, offsetBy: i)])
    }
    var length: Int {
        return self.count
    }
}
func getInt() -> Int {
    return Int(readLine()!)!
}
func getStrings() -> [String] {
    return readLine()!.components(separatedBy: " ")
}
func getInts() -> [Int] {
    return getStrings().map({Int($0)!})
}
#else
import Foundation
extension String: CollectionType {
    func at(i: Int) -> String {
        return String(self[self.startIndex.advancedBy(i)])
    }
    var length: Int {
        return self.characters.count
    }
    func splitToArrayOfInt() -> [Int] {
        return self.characters.flatMap({Int(String($0))})
    }
}
func getInt() -> Int {
    return Int(readLine()!)!
}
func getStrings() -> [String] {
    return readLine()!.split(" ")
}
func getInts() -> [Int] {
    return getStrings().map({Int($0)!})
}
#endif

func gcd ( x: Int, y: Int ) -> Int {
    return y == 0 ? x : gcd ( y, y: x%y )
}

func main ( ) {
    let a = getInts()
    print(a[0]/gcd(a[0], y: a[1])*a[1])

}

main()
//  [swift]

import Foundation

func main(){
   let line = readLine()!.split(separator: " ")

   let a = Int(line[0])!
   let b = Int(line[1])!

   var answer: Int = 0
   var multiplier1 = 1
   let multiplier2 = max(a, b)
   let multiplier3 = min(a, b)
   while answer == 0 {
      if multiplier2 * multiplier1 % multiplier3 == 0 {
         answer = multiplier2 * multiplier1
      }
      multiplier1 += 1
   }

   print(answer)
}
main()
//  [swift]


import Foundation

func main(){
   let line = readLine()!.split(separator: " ")
   
   let a = Int(line[0])!
   let b = Int(line[1])!
   
   var answer: Int = 0
   var multiplier1 = 1
   let multiplier2 = max(a, b)
   let multiplier3 = min(a, b)
   while answer == 0 {
      if multiplier2 * multiplier1 % multiplier3 == 0 {
         answer = multiplier2 * multiplier1
      }
      multiplier1 += 1
   }
   
   print(answer)
   main()
}
main()
//  [swift]
import Foundation
#if CUDA
extension String {
    func at(i: Int) -> String {
        return String(self[self.index(self.startIndex, offsetBy: i)])
    }
    var length: Int {
        return self.count
    }
}
func getInt() -> Int {
    return Int(readLine()!)!
}
func getStrings() -> [String] {
    return readLine()!.components(separatedBy: " ")
}
func getInts() -> [Int] {
    return getStrings().map({Int($0)!})
}
#else
import Foundation
extension String: CollectionType {
    func at(i: Int) -> String {
        return String(self[self.startIndex.advancedBy(i)])
    }
    var length: Int {
        return self.characters.count
    }
    func splitToArrayOfInt() -> [Int] {
        return self.characters.flatMap({Int(String($0))})
    }
}
func getInt() -> Int {
    return Int(readLine()!)!
}
func getStrings() -> [String] {
    return readLine()!.split(" ")
}
func getInts() -> [Int] {
    return getStrings().map({Int($0)!})
}
#endif

func gcd ( x: Int, y: Int ) -> Int {
    return y == 0 ? x : gcd ( x: y, y: x%y )
}

func main ( ) {
    let a = getInts()
    print(a[0]/gcd(x: a[0], y: a[1])*a[1])

}

main()
//  [typescript]
export class Main {
  static main(input: string): string {
    const tmp: string[] = input.split("\n");
    const [a, b]: number[] = tmp.shift().split(" ").map(int => parseInt(int));
    const r = IntUtil.gcd(a, b)[0];
    return `${a * b / r}`;
  }
}

export class IntUtil {
  /**
   * aをbで割った時の商と余りを求める。
   * @param a 割られる数
   * @param b 割る数
   * @return [商, 余り]
   */
  static extraQ(a: number, b: number): [number, number] {
    const r = a % b;
    return [(a - r) / b, r];
  }

  /**
   * 最大公約数を求める。
   * @param x 数値1
   * @param y 数値2
   * @return [最大公約数r, a, b] (ただしa, bは ax + by = r となる整数)
   */
  static gcd(x: number, y: number): [number, number, number] {
    let r0 = x;
    let r1 = y;
    let a0 = 1;
    let a1 = 0;
    let b0 = 0;
    let b1 = 1;
    while(r1 > 0) {
      const [q, r] = IntUtil.extraQ(r0, r1);
      const a = a0 - q * a1;
      const b = b0 - q * b1;
      r0 = r1;
      r1 = r;
      a0 = a1;
      a1 = a;
      b0 = b1;
      b1 = b;
    }
    return [r0, a0, b0];
  }

  /**
   * pを法とした時のxの逆数を返す
   * @param x 数値
   * @param p xと互いに素である数値
   * @return x^{-1} (mod p)
   */
  static inverseMod(x: number, p: number): number {
    const [r, a, _] = IntUtil.gcd(x, p);
    if (r != 1) {
      throw new Error(`NOT COPRIME: IntUtil.inverseMod(${x}, ${p})`);
    }

    return a >= 0 ? (a % p) : (p + (a % p));
  }
}

console.log(Main.main(require("fs").readFileSync("/dev/stdin", "utf8")));
//  [typescript]
const main = (input: string) => {
  const [A, B] = input.trim().split(" ").map(str => parseInt(str))
  const getGcd = (a: number, b: number): number => {
    if(b === 0) {
      return a
    }
    return getGcd(b, a % b)
  }

  const answer = A * B / getGcd(A, B)

  console.log(answer)
}

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

function Main(input: string) {
    let splited = input.split(' ');
    let A = parseInt(splited[0]);
    let B = parseInt(splited[1]);

    let m = A > B ? A : B;
    let n = A > B ? B : A;

    while (n !== 0) {
        let tmp = n;
        n = m % n;
        m = tmp;
    }

    console.log(A * B / m);

}

Main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [typescript]
const main = (input: string) => {
  const [A, B] = input.trim().split(" ").map(str => parseInt(str))
  let snack = 0
  let count = 1
  let isNotFound = true
  
  while (isNotFound) {
    if(count % A === 0 && count % B === 0) {
      snack = count
      isNotFound = false
    }
    count += 1
  }

  console.log(snack)
}

main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [python]
x = int(input())

if x < 30:
    print("No")
else:
    print("Yes")
//  [python]
x = int(input())
#str()文字式
#float()小数

if x>=30:
  print("Yes")
else:
  print("No")
//  [python]
X = int(input())

if X >= 30:
    print('Yes')
else:
    print('No')
//  [python]
x=int(input())

if x >= 30:
  print("yes")
else:
  print("No")
//  [python]
x = int(inpt())
if(x >= 30):
    print("Yes")
else:
    print("No")
//  [python]
n = input()

if n >= 30:
  print ('Yes')
else:
  print ('No')
//  [java]
import java.io.*;
import java.util.*;
public class Main{
    static class FastReader{
        BufferedReader br;
        StringTokenizer st;
        public FastReader(){br = new BufferedReader(new InputStreamReader(System.in));}
        String next(){while (st == null || !st.hasMoreElements()){try{st = new StringTokenizer(br.readLine());}catch (IOException  e){e.printStackTrace();}}return st.nextToken();}
        int nextInt(){return Integer.parseInt(next());}
        long nextLong(){return Long.parseLong(next());}
        double nextDouble(){return Double.parseDouble(next());}
        int[] readArray(int n){int[] a=new int[n];for (int i=0; i<n; i++) a[i]=nextInt();return a;}
        long[] readLongArray(int n){long[] a=new long[n];for (int i=0; i<n; i++) a[i]=nextLong();return a;}
        String nextLine(){String str = "";try{str = br.readLine();}catch (IOException e){e.printStackTrace();}return str;}
    }
    static int getGcd(int n1,int n2){
        while(n1 != n2){
            if(n1 > n2) n1 -= n2;
            else n2 -= n1;
        }
        return n1;
    }
    static boolean isSorted(int[] arr, int n){
        for(int i=1;i<n;i++){
            if(arr[i]<arr[i-1]) return false;
        }
        return true;
    }
    static boolean isPrime(long n){
        if(n==2) return true;
        else if(n%2==0) return false;
        for(int i=3;i<=n/2;i+=2){
            if(n%i==0) return false;
        }
        return true;
    }
    static boolean isPrime(int n){
        if(n==2) return true;
        else if(n%2==0) return false;
        for(int i=3;i<=n/2;i+=2){
            if(n%i==0) return false;
        }
        return true;
    }
    static void printArray(int[] arr){
        for(int x:arr){
            System.out.print(x+" ");
        }
        //System.out.println();
    }
    public static void main(String[] args) throws NumberFormatException, IOException {
        FastReader s=new FastReader();
        int t = s.nextInt();
//        int n;
//        String str;
//        while(t-- > 0){
//
//        }
        if(t>=30) System.out.println("Yes");
        else System.out.println("No");
    }
}
//  [java]
import java.util.*;
import java.io.*;

public class Main {
	private static void solve(){
		//Implement solution here.
		System.out.println(ni() >= 30 ? "Yes" : "No");
	}


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

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

public class Main{
  public static void main(String args[]){
    Scanner scanner = new Scanner(System.in);
    int x = scanner.nextInt();  
    if(x>=30){System.out.println("Yes")}else{System.out.println("No")}
  
  
  }
}
//  [java]
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int degree = in.nextInt();
        String ans = Ac(degree);
        System.out.println(ans);
    }

    public static String Ac(int degree) {
        String result;
        if (degree >= 30) {
            result = "yes";
        } else {
            result = "no";
        }
        return result;
    }
}
//  [java]
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int degree = in.nextInt();
        String ans = Ac(degree);
        System.out.println(ans);
    }

    public static String Ac(int degree) {
        String result;
        if (degree >= -40 && degree <= 40) {
            result = "yes";
        } else {
            result = "no";
        }
        return result;
    }
}
//  [cpp]
#include<bits/stdc++.h>
#define ll long long int 
using namespace std;

int main()
{
  	ll n;
  	cin>>n;
  	if(n>29)
    {
      cout<<"Yes"<<endl;
      return 0;
    }
  cout<<"No"<<endl;
}
//  [cpp]
#include<bits/stdc++.h>
using namespace std;
int main(){
    int t;
  	cin>>t;
  	if(t>=30)
      cout<<"Yes";
   else
     	cout<<"No";
 	return 0; 
}
//  [cpp]
#include<bits/stdc++.h>
using namespace std;
int main(){
  int X;
  cin>>X;
  if(X==30) cout<<"Yes"<<endl;
  else cout<<"No"<<endl;
}
//  [cpp]
#include<iostream>
#include<vector>
#include<math>
using namespace std;



int main() {

	int n,d; cin >> n>>d;
	vector<int>v; int count = 0; double sum=0;
	for (int i = 0; i < n; i++) {
		int input1, input2; cin >> input1 >> input2;
		v.push_back(input1); v.push_back(input2);
		sum = sqrt(pow(input1, 2) + pow(input2, 2));
		if(sum <= d)
			count++;
		sum = 0;
		v.clear();
	}
	cout << count;



}
//  [cpp]
#include<bits/stdc++.h>
using namespace std;
#define fl(i,a,b) for(int i=a;i<b;i++)
#define ll long long
#define endl '\n'
#define pb push_back
#define ff first
#define ff first
#define ss second
#define mod 998244353 
#define inf 4e18
#define fast ios_base::sync_with_stdio(0);cin.tie(NULL);cout.tie(NULL);
#define mx 500005


int main() {
	fast;
	int n; cin >> n;
	(n >= 30) ? cout << "Yes" : cout << "No";
	cout << endl;

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

int main(void)
{
	int i,a,b;
	int n, m, k;
	char s[4], t[20];

	scanf("%d", &i);
	if (i >= 30) {
		printf("Yes");
		return 0;
	}


		printf("No");

	return 0;
}
//  [c]
#include <stdio.h>
int main() {
  int N;
  scanf("%d", &N);
  if (30 <= N) {
    printf("Yes\n");
  } else {
    printf("No\n");
  }
  return 0;
}
//  [c]
#include <stdio.h>
int main(void){
    // Your code here!
    int x;
    scanf("%d",x);
    
    if (x >= 30){
        printf("Yes");
    }
    else{
        printf("No");
    }
}
//  [c]

#include<stdio.h>
int main()
{
    int t;
    scanf("%d",&t);
    if(t>=30)
        printf("YES\n");
    else
        printf("NO\n");
}
//  [c]
#include<stdio.h>
int main(){
	int X;
	scanf("%d",&X);
	if(X>=-40&&X<=40){
		printf("Yes\n");
	}
	else{
		printf("No\n");
	}
}
//  [javascript]
function main(input) {
  const n = input[0];
  console.log((n>=30)?("Yes"):("No"));
}
main(require('fs').readFileSync('/dev/stdin', 'utf8').trim().split("\n"));
//  [javascript]
function main(input) {
    console.log(input < 30 ? 'No' : 'Yes');
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [javascript]
// inputに入力データ全体が入る
function Main(input) {
  if(input >=30) {
    console.log('Yes');
  } else {
    console.log('No');
  }
}


// let input = `25`;
// Main(input);


// *この行以降は編集しないでください（標準入出力から一度に読み込み、Mainを呼び出します）
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
// inputに入力データ全体が入る
function Main(input) {
  if(input >=30) {
    console.log('yes');
  } else {
    console.log('no');
  }
}


// let input = `25`;
// Main(input);


// *この行以降は編集しないでください（標準入出力から一度に読み込み、Mainを呼び出します）
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
// inputに入力データ全体が入る
function Main(input) {
  if(input >=30) {
    console.log('yes');
  } else {
    console.log('no');
  }
}


// let input = `25`;
Main(input);


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

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

func main() {
	sc := NewScanner()

	x := sc.ReadInt()
	if x >= 30 {
		fmt.Println("Yes")
	} else {
		fmt.Println("No")
	}
}

// from [my library](https://github.com/ikngtty/go-contestlib)
// -   math/simple

func Abs(x int) int {
	if x >= 0 {
		return x
	}
	return -x
}

func Min(values ...int) int {
	if len(values) == 0 {
		panic("no values")
	}

	min := values[0]
	for _, v := range values {
		if v < min {
			min = v
		}
	}
	return min
}

func Max(values ...int) int {
	if len(values) == 0 {
		panic("no values")
	}

	max := values[0]
	for _, v := range values {
		if v > max {
			max = v
		}
	}
	return max
}

func Pow(base, exponent int) int {
	if exponent < 0 {
		panic(fmt.Sprintf("exponent (%d) should not be a minus", exponent))
	}

	answer := 1
	for i := 0; i < exponent; i++ {
		answer *= base
	}
	return answer
}

func Ceil(divident, dividor int) int {
	if dividor == 0 {
		panic("dividor should not be 0")
	}

	quo := divident / dividor
	rem := divident % dividor

	if rem != 0 {
		if (divident > 0 && dividor > 0) ||
			(divident < 0 && dividor < 0) {
			return quo + 1
		}
	}
	return quo
}

// -   sortutil

func ReverseInts(a []int) {
	sort.Sort(sort.Reverse(sort.IntSlice(a)))
}

func ReverseStrings(a []string) {
	sort.Sort(sort.Reverse(sort.StringSlice(a)))
}

// -   io

type Scanner struct {
	bufScanner *bufio.Scanner
}

func NewScanner() *Scanner {
	bufSc := bufio.NewScanner(os.Stdin)
	bufSc.Split(bufio.ScanWords)
	bufSc.Buffer(nil, 100000000)
	return &Scanner{bufSc}
}

func (sc *Scanner) ReadString() string {
	bufSc := sc.bufScanner
	bufSc.Scan()
	return bufSc.Text()
}

func (sc *Scanner) ReadInt() int {
	bufSc := sc.bufScanner
	bufSc.Scan()
	text := bufSc.Text()

	num, err := strconv.Atoi(text)
	if err != nil {
		panic(err)
	}
	return num
}
//  [go]
package main

// Solution for https://atcoder.jp/contests/abc174/tasks/abc174_a

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

type contest struct {
	in  io.Reader
	out io.Writer
}

func (con *contest) Scan(a ...interface{}) (int, error) {
	return fmt.Fscan(con.in, a...)
}
func (con *contest) Scanln(a ...interface{}) (int, error) {
	return fmt.Fscanln(con.in, a...)
}
func (con *contest) Scanf(f string, a ...interface{}) (int, error) {
	return fmt.Fscanf(con.in, f, a...)
}
func (con *contest) Print(a ...interface{}) (int, error) {
	return fmt.Fprint(con.out, a...)
}
func (con *contest) Println(a ...interface{}) (int, error) {
	return fmt.Fprintln(con.out, a...)
}
func (con *contest) Printf(f string, a ...interface{}) (int, error) {
	return fmt.Fprintf(con.out, f, a...)
}
func main() {
	in := bufio.NewReader(os.Stdin)
	out := bufio.NewWriter(os.Stdout)
	defer out.Flush()
	con := &contest{in: in, out: out}
	con.main()
}

func (con *contest) main() error {
	var s int
	con.Scan(&s)
	if s >= 30 {
		con.Println("Yes")
	} else {
		con.Println("No")
	}
	return nil
}
//  [go]
package main

import (
	"fmt"
)

func main() {
	var x int
	fmt.Scanf("%d", &x)
	if x >= 30 {
		fmt.Println("YES")
	} else {
		fmt.Println("NO")
	}
}
//  [go]
package main

import(
	"fmt"
)

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

	if X >= 30 {
		fmt.Printf("Yes\n")
		} else {
			fmt.Printf("No\n")
	}
}
//  [ruby]
i=gets.to_i
if i>=30
  puts "Yes"
  else
  puts "No"
  end
//  [ruby]
x = gets.strip.to_i
if    x < 30
    puts "No"
else
    puts "Yes"
end
//  [ruby]
x=gets.to_i

if x>=30
    puts "Yes"
else
    puts "No"
end
//  [ruby]
n = gets.to_i

if n >= 30
  puts "Yes"
else 
  puts "No"
//  [ruby]
temp = X
if temp >= 30
  p yes
else
  p no
end
//  [ruby]
x=gets.to_i
if x>=30
print "YES"
elsif x<30
print "NO"
end
//  [rust]
use proconio::{fastout, input};

#[fastout]
fn main() {
    input! {
        x: isize,
    }

    if x >= 30 {
        println!("Yes");
    } else {
        println!("No");
    }
}