jiahuimbzuai/CoQuIR huggingface dataset:
//  [javascript]
var lines = [];
var readline = require('readline');

var rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout,
});

rl.on('line', function (x) {
    lines.push(x);
});

rl.on('close', function () {
    var N = Number(lines[0]);

    var D = Number(lines[1].split(" ")[0])
    var X = Number(lines[1].split(" ")[1])
    lines.shift(); lines.shift();

    var A = lines.map(i => Number(i));
    var ans = X;

    for (var i = 0; i < N; i++) {
        var d = 1; var k = 1;
        while (d <= D) {
            ans += 1;
            d = A[i] * k + 1;
            k++;
        }
    }
    console.log(ans)
});
//  [javascript]
"use strict"

const Main = (inpuut)=>{
const Array= inpuut.split(/\n/)
const N = Array[0]-0
const D = Array[1].split(" ").map((ele)=>{return ele-0})[0]
const X =Array[1].split(" ").map((ele)=>{return ele-0})[1]

let sum = 0

// iが人
//jがAにかかる係数

for (let i=1; i<=N; i+=1){
  const A = Array[i+1]-0

  for(let j=0;A*j+1<=D;j++){
   sum+=1
  }
 
}

console.log(sum+X)
}


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

import (
	"bufio"
	"fmt"
	"io/ioutil"
	"log"
	"os"
	"strconv"
	"strings"
)

const debug = false

func (p *problem) solve() {
	N := p.NextInt()
	line2 := p.NextInts()
	D, X := line2[0], line2[1]
	var eat int
	for i := 0; i < N; i++ {
		m := p.NextInt()
		for j := 0; j < 101; j++ {
			if (m*j + 1) > D {
				break
			}
			eat++
		}
	}
	p.PrintInt(eat + X)
}

func min(x, y int) int {
	if x < y {
		return x
	}
	return y
}

func main() {
	if debug {
		log.SetOutput(os.Stdout)
	} else {
		log.SetOutput(ioutil.Discard)
	}

	p := problem{
		in:  bufio.NewReader(os.Stdin),
		out: bufio.NewWriter(os.Stdout),
	}
	p.solve()

	if err := p.out.Flush(); err != nil {
		panic(err)
	}
}

type problem struct {
	in  *bufio.Reader
	out *bufio.Writer
}

func (p *problem) PrintInt(d int) {
	p.Printf("%d", d)
}

func (p *problem) Printf(format string, a ...interface{}) {
	if _, err := fmt.Fprintf(p.out, format, a...); err != nil {
		panic(err)
	}
}

func (p *problem) NextInt() int {
	return stoi(p.Next())
}

func (p *problem) NextInts() []int {
	line := p.NextSSLine()
	ds := make([]int, len(line))
	for i, s := range line {
		ds[i] = stoi(s)
	}
	return ds
}

func (p *problem) NextSSLine() []string {
	return strings.Split(p.Next(), " ")
}

// Next reads line and return string.
func (p *problem) Next() string {
	var b []byte
	for {
		l, pre, err := p.in.ReadLine()
		if err != nil {
			panic(err)
		}
		b = append(b, l...)
		if !pre {
			break
		}
	}
	return string(b)
}

func stoi(s string) int {
	i, err := strconv.Atoi(s)
	if err != nil {
		fmt.Println(i)
		fmt.Println(err)
	}
	return i
}
//  [go]
package main

import "fmt"

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

        for i := 0; i < n; i++ {
                var a int
                fmt.Scanln(&a)
                for j := 0; j < d; j += a {
                        x++
                }
        }
        fmt.Println(x)
}
//  [go]
package main

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

var sc = bufio.NewScanner(os.Stdin)

func contains(target int, list []int) bool {
	for _, r := range list {
		if target == r {
			return true
		}
	}
	return false
}

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 nextInt64() int64 {
	sc.Scan()

	i, e := strconv.ParseInt(sc.Text(), 10, 64)
	if e != nil {
		panic(e)
	}
	return i
}

func nextF64() float64 {
	sc.Scan()

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

func isInteger(x float64) bool {
	return math.Floor(x) == x
}

func Ave(s []int) int {
	val := 0
	for _, i := range s {
		val += i
	}
	return int(val / len(s))
}
func cal(i int) (sum int) {
	for i != 0 {
		sum += i % 10
		i /= 10
	}
	return
}
func max(a []int) (idx int, val int) {
	max := a[0]
	idx = 0
	for j, i := range a {
		if max < i {
			max = i
			idx = j
		}
	}
	return idx, max
}

func draw(i int, a []int) (l []int) {
	// p = a[i]
	for j := i; j < len(a); j++ {
		if j != len(a)-1 {
			a[j] = a[j+1]
		} else if j == len(a)-1 {
			a = a[:len(a)-1]
		}
	}
	return a
}
func abs(i int64) int64 {
	if i < 0 {
		return -i
	}
	return i
}

func f(n int) int {
	if n%2 == 0 {
		return n / 2
	}
	return 3*n + 1
}

func main() {
	sc.Split(bufio.ScanWords)
	// sc.Buffer([]byte{}, math.MaxInt64)
	// a := make([][]int, 3)
	// for i := 0; i < 3; i++ {
	// 	a[i] = make([]int, 3)
	// }
	// for i := 0; i < 3; i++ {
	// 	for j := 0; j < 3; j++ {
	// 		a[i][j] = nextInt()
	// 	}
	// }
	n := nextInt()
	d := nextInt()
	x := nextInt()

	var a []int
	var cnt int
	for i := 0; i < n; i++ {
		a = append(a, nextInt())
	}

	for _, val := range a {
		for i := 1; i <= d; i += val {
			cnt++
		}
	}
	fmt.Println(cnt + x)
}
//  [ruby]
require 'prime'
require 'set'
require 'tsort'
include Math
ALP = ('a'..'z').to_a
INF = 0xffffffffffffffff
def max(a,b);              a > b ? a : b                              end
def min(a,b);              a < b ?  a : b                             end
def swap(a,b);             a, b = b, a                                end
def gif;                   gets.to_i                                  end
def gff;                   gets.to_f                                  end
def gsf;                   gets.chomp                                 end
def gi;                    gets.split.map(&:to_i)                     end
def gf;                    gets.split.map(&:to_f)                     end
def gs;                    gets.chomp.split.map(&:to_s)               end
def gc;                    gets.chomp.split('')                       end
def pr(num);               num.prime_division                         end
def pr?(num);              Prime.prime?(num)                          end
def digit(num);            num.to_s.length                            end
def array(s,ini=nil);      Array.new(s){ini}                          end
def darray(s1,s2,ini=nil); Array.new(s1){Array.new(s2){ini}}          end
def rep(num);              num.times{|i|yield(i)}                     end
def repl(st,en,n=1);       st.step(en,n){|i|yield(i)}                 end

n = gif
d,x = gi
a = []
rep n do
  a << gif
end

ans = x

a.each do |aa|
  i = 0
  while aa*i+1 <= d
    ans += 1
    i+=1
  end
end
puts ans
//  [ruby]
n=gets.to_i
d,x=gets.split.map(&:to_i)
a=Array.new(n)
n.times do |i|
    a[i]=gets.to_i
end

day=1
count=0
n.times do |i|
    day=1
    while day<=d
        day+=a[i]
        count+=1
    end
end
puts count+x
//  [ruby]
n = gets.chomp.to_i
d, x = gets.chomp.split(" ").map(&:to_i)
count = x
n.times do |i|
    a = gets.chomp.to_i
    count += (d-1) / a
end
puts count + n
//  [rust]
use proconio::{input, fastout};
use proconio::marker::{Chars};
use proconio::marker::Usize1;
use std::cmp::*;

macro_rules! debug {
      ($($a:expr),*) => {
          eprintln!(concat!($(stringify!($a), " = {:?}, "),*), $($a),*);
    }
}

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

    let mut sum = n;
    for i in 0..n {
        sum += (d-1)/a[i];
        debug!(sum);
    }
    println!("{}", sum+x);
}
//  [rust]
use whiteread::parse_line;

fn main() {
    let n: usize = parse_line().unwrap();
    let (d, x): (u32, u32) = parse_line().unwrap();
    let mut cnt: u32 = 0;
    for _ in 0..n {
        let ci: u32;
        let ai: u32 = parse_line().unwrap();
        if d % ai == 0 {
            ci = d / ai;
        } else {
            ci = (d / ai) + 1;
        }
        cnt += ci;
    }
    println!("{}", cnt + x);
}
//  [rust]
use proconio::input;
#[allow(unused_imports)]
use proconio::marker::{Bytes, Chars};
#[allow(unused_imports)]
use std::cmp::{min, max};

fn main() {
	input! {
		n: usize,
		d: usize,
		x: usize,
		a: [usize; n],
	}

	let mut sum = 0;
	for i in 0..n {
		sum += (d-1)/a[i] + 1;
	}
	println!("{}", sum+x);
}
//  [typescript]
import { readFileSync } from "fs";

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

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

  let answer = X;

  for (let i = 2; i < N + 2; i++) {
    const A = Number(input[i][0]);

    let count = 0;

    for (let j = 0; A * j + 1 <= D; j++) {
      count += 1;
    }

    answer += count;
  }

  return answer;
};

console.log(main(read()));
//  [typescript]
var lines: string[] = [];
var reader: any = require("readline").createInterface({
  input: process.stdin,
  output: process.stdout
});
reader.on("line", function(line: string) {
  lines.push(line);
});

reader.on("close", function() {
  // D X
  var numbers: number[] = lines[1].split(" ").map(x => {
    return Number(x);
  });
  var numD: number = Number(numbers[0]);
  var numX: number = Number(numbers[1]);

  var result: number = numX;

  for (var i: number = 2; i < lines.length; i++) {
    result = result + Math.ceil(numD / Number(lines[i]));
  }

  console.log(result);
});
//  [python]
S = list(input())
i = 0
cnt = 0
while i < len(S):
    #print(S)
    if "".join(S[i:i+2]) == "01" or "".join(S[i : i + 2]) == "10":
        if i + 1< len(S):
            S.pop(i + 1)
        S.pop(i)
        cnt += 2
        i = max(0 , i - 1)
    else:
        i += 1
print(cnt)
//  [python]
N = list(input())
N2 = list(map(int,N))

if len(N2) == 1:
  print("0")
  exit()

counter = 0
c = 1

while len(N2) > 0 and c <= len(N2)-1:
  # print(N2,c)
  before = N2[c-1]

  if before == 0 and N2[c] == 1:
    N2.pop(c-1)
    N2.pop(c-1)

    c -= 2
    counter += 2

    if len(N2) == 0:
      break

    if c <= 0:
      before = N2[0]
      c = 1
    else:
      before = N2[c-1]

  elif before == 1 and N2[c] == 0:
    N2.pop(c-1)
    N2.pop(c-1)

    c -= 2
    counter += 2

    if len(N2) == 0:
      break

    if c <= 0:
      before = N2[0]
      c = 1
    else:
      before = N2[c-1]

  else:
    c += 1

print(counter)
//  [python]
s = input()
n = len(s)
a = []
i = 0
ct = 0
for i in range(n):
  a.append(int(s[i]))
i = -1

while ct < 100000000000:
  n = len(a)
  i += 1
  if i >= n-1: break
  if a[i] == 0 and a[i+1] == 1:
    a.pop(i)
    a.pop(i)
    ct += 1
    i -= 2
    if i <= 1: i=-1
    continue
  elif a[i] == 1 and a[i+1] == 0:
    a.pop(i)
    a.pop(i)
    ct += 1
    i -= 2
    if i <= 1 :i = -1
    
print(ct*2)
//  [java]
import java.util.Scanner;

public class Main {

	public static void main(String[] args) {

		Scanner sc = new Scanner(System.in);

		String S = sc.next();
		int result = 0;
		int one =  0;

		for(int i = 0 ; i < S.length() ; i++){
			result = S.indexOf("1", i);
			if(result != -1){
				one +=1;
				i = result;
			}
		}

		int zero = S.length() - one;
		if(one >= zero){
			System.out.println(2 * zero);
		}else{
			System.out.println(2 * one);
		}

	}

}
//  [java]
import java.util.*;
public class Main {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		String input = sc.next();
		int red = 0;
		int blue = 0;
		while (input.length() != 1) {
			if (input.charAt(0) == '0') {
				red++;
			} else {
				blue++;
			}
			input = input.substring(1);
		}
		if (input.charAt(0) == '0') {
			red++;
		} else {
			blue++;
		}
		int ans = 0;
		if (red > blue) {
			ans = blue * 2;
		} else {
			ans = red * 2;
		}
		System.out.println(ans);
		
	}

}
//  [java]
import java.util.Scanner;
import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        System.out.println(solve(in.nextLine()));
    }
    public static int solve(String S) {
        return Math.min(count(S, "0"), count(S, "1")) * 2;
    }
    public static int count(String s, String sub) {
        int res = 0;
        String cur = new String(s);
        while (true) {
            int pos = cur.indexOf(sub);
            if (pos == -1) {
                return res;
            }
            res++;
            cur = cur.substring(pos + sub.length());
        }
    }
}
//  [cpp]
#include <bits/stdc++.h>
using namespace std;
char a[100001]; 
int k[100001];
int len,l;
int dfs()
{
	int j,i;
	for(i=0;i<len-1;i++)
	{
		if(a[i]!=a[i+1])
		{
			for(j=i+2;j<len;j++)
			{
				a[j-2]=a[j];
			}
			len-=2;
			return 1;
		}
	}
	return 0;
}
int main()
{
	int i,ret=1;
	scanf("%s",a);
	l=len=strlen(a);
	while(ret)
	{
		ret=dfs();
	}
	printf("%d",l-len);
	return 0;
}
//  [cpp]
#include<bits/stdc++.h>

using namespace std;
using ll = long long;
using P = pair<int,int>;
using Pl = pair<ll,ll>;
#define REP(i,n) for(ll i = 0;i < (ll)n;i++)
#define REPD(i,n) for(ll i = (ll)n - 1;i >= 0;i--)
#define ALL(x) (x).begin(),(x).end()
#define FILLl(n,first_dimension_size,value) fill((ll*)n,(ll*)(n+first_dimension_size),value)
#define FILL(n,first_dimension_size,value) fill((int*)n,(int*)(n+first_dimension_size),value)
#define INF (1 << 29)
#define MOD 1000000007
//int dx[4] = {1,0,0,-1};
//int dy[4] = {0,1,-1,0};


int main(){
  
  string s;
  cin >> s;
  int now = s.size()-1,firstsize = s.size();
  bool flag = true;
  if(now == 0)flag = false;
  while(flag){
    if(s[now] != s[now-1]){
      s.erase(s.begin()+now-1,s.begin()+now+1);
      now = s.size()-1;
    }else{
      now--;
    }
    if(now <= 0)flag = false;
  }
  cout << firstsize - s.size() << endl;



  return 0;
}
//  [cpp]
#include<bits/stdc++.h>
#define PI 3.141592653589
using namespace std;
using ll = long long;

template<typename T_char>
T_char ToUpper(T_char cX){return toupper(cX);}

int main(){
  string s;
  cin >> s;
  int n = s.size();

  int cnt = 0;
  bool flag1 = true;
  while(flag1){
    flag1 = false;
    for(int i=0; i<n; ++i){
      if(s[i]=='1' && s[i+1]=='0'){
        cnt += 2;
        s.erase(i,2);
        flag1 = true;
      }

      if(s[i]=='0' && s[i+1]=='1'){
        cnt += 2;
        s.erase(i,2);
        flag1 = true;
      }
    }
      n = s.size();
  }
  cout << cnt << endl;
}
//  [c]
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<math.h>
#define FOR(n) for(int i=0;i<n;i++)
#define FORJ(n) for(int j=0;j<n;j++)
#define PRN(n) printf("%d\n",n)
#define PRF(n) printf("%lf\n",n)
#define PRL(n) printf("%lld\n",n)
#define PRS(s) printf("%s\n",s)
#define PRC(c) printf("%c",c)
#define INF 10000000000
#define mod 1000000007
typedef long long int ll;
ll u(const void *a, const void *b){return *(ll*)a-*(ll*)b;}
ll d(const void *a, const void *b){return *(ll*)b-*(ll*)a;}
ll min(ll a,ll b){
  if(a>b)return b;
  return a;
}
ll max(ll a,ll b){
  if(a>b)return a;
  return b;
}
ll gcd(ll a,ll b){
  if(!b)return a;
  return gcd(b,a%b);
}
ll lcm(ll a,ll b){return a*b/gcd(a,b);}
int kt(ll a){
  int sum=0;
  while(a){
    a/=10;
    sum++;
  }
  return sum;
}
int ks(ll a){
  int sum=0;
  while(a){
    sum+=a%10;
    a/=10;
  }
  return sum;
}
ll f(ll a){
  return a*(a+1)/2;
}
int main(void){
  char s[100001];
  scanf("%s",s);
  int a[2]={0,0};
  FOR(strlen(s))a[s[i]-'0']++;
  PRN(min(a[0],a[1])*2);
  return 0;
}
//  [c]
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<math.h>
#define FOR(n) for(int i=0;i<n;i++)
#define FORJ(n) for(int j=0;j<n;j++)
#define PRN(n) printf("%d\n",n)
#define PRF(n) printf("%lf\n",n)
#define PRL(n) printf("%lld\n",n)
#define PRS(s) printf("%s\n",s)
#define PRC(c) printf("%c",c)
#define mod 1000000007
typedef long long int ll;
int u(const void *a, const void *b){
    return *(ll*)a-*(ll*)b;
}
int d(const void *a, const void *b){
    return *(ll*)b-*(ll*)a;
}
int min(int a,int b){
  if(a>b)return b;
  return a;
}
int max(int a,int b){
  if(a>b)return a;
  return b;
}
ll gcd(ll a,ll b){
  if(!b)return a;
  return gcd(b,a%b);
}
ll lcm(ll a,ll b){return a*b/gcd(a,b);}
int kt(ll a){
  int sum=0;
  while(a){
    a/=10;
    sum++;
  }
  return sum;
}
int ks(ll a){
  int sum=0;
  while(a){
    sum+=a%10;
    a/=10;
  }
  return sum;
}
int dp[10001];
int main(void){
  char s[100001];
  scanf("%s",s);
  int a[2]={0,0};
  FOR(strlen(s))a[s[i]-'0']++;
  PRN(min(a[0],a[1])*2);
  return 0;
}
//  [c]
#include <stdio.h>
#include <math.h>

int main(void)
{
	char s[100000];
	int i,cnt[2]={0};
	scanf("%s",s);
	
	for(i=0;i<strlen(s);i++){
		cnt[s[i] - '0']++;
	}
	printf("%d\n",(int)fmin(cnt[0],cnt[1])*2);
	return 0;
}
//  [javascript]
"use strict";
function Main(input) {
    let S = input.split("\n")[0];
    let s = S.split('').map((v) => +v);
    let ans = 0, f = true;
    while (f) {
        f = false;
        for (let n = 0; n < s.length - 1; n++) {
            if (s[n] + s[n+1] == 1) {
                ans += 2;
                s.splice(n, 2);
                n -= 2;
            }
        }
    }
    console.log(ans);
}

Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
"use strict";
function Main(input) {
    let s = input.split("\n")[0].split('').map((v) => +v);
    let ans = 0;
    for (let n = 0; n < s.length - 1; n++) {
        if (s[n] + s[n+1] == 1) {
            ans += 2;
            s.splice(n, 2);
            n -= 2;
        }
    }
    console.log(ans);
}

Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
input = require('fs').readFileSync('/dev/stdin', 'utf8')
lines = input.split('\n')
S = lines.shift().split('')
cnt = 0
p = S[S.length-1]
for (i=S.length- 2; i>=0; i--) {
    if ((p == 0 && S[i] == 1) || (p == 1 && S[i] == 0)) {
        cnt += 2
        S.splice(i, 2)
    }
    p = S[i]
}
console.log(cnt)
//  [go]
package main

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

var rdr = bufio.NewReaderSize(os.Stdin, 400000)

func readLine() string {
	buf := make([]byte, 0, 400000)
	for {
		l, p, e := rdr.ReadLine()
		if e != nil {
			panic(e)
		}
		buf = append(buf, l...)
		if !p {
			break
		}
	}
	return string(buf)
}

func delete(s []rune, i int) []rune {
	s = s[:i]
	n := make([]rune, len(s))
	copy(n, s)
	return n
}
func main() {
	s := readLine()
	ar := []rune{}
	result := 0
	for _, v := range s {
		if len(ar) > 0 && ar[len(ar)-1] != v {
			ar = delete(ar, len(ar)-1)
			result += 2
		} else {
			ar = append(ar, v)
		}
	}
	fmt.Println(result)
}
//  [go]
package main

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

func main() {
	S := nextString()
	rs := []rune(S)
	var cnt int
	for i := 1; i < len(rs); i++ {
		before := rs[i-1]
		if rs[i] != before {
			rs = append(rs[:i], rs[i+1:]...)
			i--
			rs = append(rs[:i], rs[i+1:]...)
			i--
			cnt += 2

			if i <= 0 {
				i = 0
			}
		}
	}

	fmt.Println(cnt)
}

// Input. ----------

var sc = bufio.NewScanner(os.Stdin)

func init() {
	sc.Buffer([]byte{}, math.MaxInt64)
	sc.Split(bufio.ScanWords)
}

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

	return i
}

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

	return f64
}

func nextString() string {
	sc.Scan()
	if err := sc.Err(); err != nil {
		panic(err)
	}

	return sc.Text()
}

// ---------- Input.

// Util. ----------

func abs(x int) int {
	return int(math.Abs(float64(x)))
}

func min(x, y int) int {
	return int(math.Min(float64(x), float64(y)))
}

func max(x, y int) int {
	return int(math.Max(float64(x), float64(y)))
}

// ---------- Util.
//  [go]
package main

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

func main() {
	s := readString()
	S := s

	pop := func(i int) {
		s = s[0:i] + s[i+1:]
	}

	i := 1
	for {
		if i == len(s) {
			break
		}
		if i > 0 && s[i-1] != s[i] {
			pop(i)
			pop(i - 1)
			i = i - 1
			continue
		}
		if i < len(s)-1 && s[i] != s[i+1] {
			pop(i + 1)
			pop(i)
			continue
		}
		i++
	}

	fmt.Println(len(S) - len(s))
}

/*-------------------utilities-------------------*/

func abs(x int) int {
	if x < 0 {
		return -x
	}
	return x
}

func min(x, y int) int {
	if x < y {
		return x
	}
	return y
}

func max(x, y int) int {
	if x > y {
		return x
	}
	return y
}

func chmin(x *int, y int) bool {
	if *x > y {
		*x = y
		return true
	}
	return false
}

func chmax(x *int, y int) bool {
	if *x < y {
		*x = y
		return true
	}
	return false
}

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

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

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

func permutations(arr []int) [][]int {
	var helper func([]int, int)
	res := [][]int{}

	helper = func(arr []int, n int) {
		if n == 1 {
			tmp := make([]int, len(arr))
			copy(tmp, arr)
			res = append(res, tmp)
		} else {
			for i := 0; i < n; i++ {
				helper(arr, n-1)
				if n%2 == 1 {
					tmp := arr[i]
					arr[i] = arr[n-1]
					arr[n-1] = tmp
				} else {
					tmp := arr[0]
					arr[0] = arr[n-1]
					arr[n-1] = tmp
				}
			}
		}
	}
	helper(arr, len(arr))
	return res
}

func isPrime(n int) bool {
	if n == 1 {
		return false
	}
	for i := 2; i*i <= n; i++ {
		if n%i == 0 {
			return false
		}
	}
	return true
}

func divisor(n int) (res []int) {
	for i := 1; i*i <= n; i++ {
		if n%i == 0 {
			res = append(res, i)
			if i*i != n {
				res = append(res, n/i)
			}
		}
	}
	sort.Ints(res)
	return
}

/*-------------------init-------------------*/

const (
	INF = 1000000000000000000
	MOD = 1e9 + 7

	COMB_MAX = 510000
)

var (
	readString func() string
)

var (
	fac  = [COMB_MAX]int{}
	finv = [COMB_MAX]int{}
	inv  = [COMB_MAX]int{}
)

func init() {
	readString = newReadString(os.Stdin)
}

func combInit() {
	fac[0] = 1
	fac[1] = 1
	finv[0] = 1
	finv[1] = 1
	inv[1] = 1
	for i := 2; i < COMB_MAX; i++ {
		fac[i] = fac[i-1] * i % MOD
		inv[i] = MOD - inv[MOD%i]*(MOD/i)%MOD
		finv[i] = finv[i-1] * inv[i] % MOD
	}
}

/*-------------------inputs-------------------*/

func readi() int {
	return int(readi64())
}

func readi64() int64 {
	i, err := strconv.ParseInt(readString(), 0, 64)
	if err != nil {
		panic(err.Error())
	}
	return i
}

func readf() float64 {
	f, err := strconv.ParseFloat(readString(), 64)
	if err != nil {
		panic(err.Error())
	}
	return f
}

func newReadString(ior io.Reader) func() string {
	r := bufio.NewScanner(ior)
	r.Buffer(make([]byte, 1024), int(1e+11))
	r.Split(bufio.ScanWords)

	return func() string {
		if !r.Scan() {
			panic("Scan failed")
		}
		return r.Text()
	}
}
//  [ruby]
s = gets.strip
len = s.length
while s.sub!("01", "") || s.sub!("10", "")
end
puts len - s.length
//  [ruby]
s = gets.chomp

deleted_cube = 0
while !(index1 = s.index("01")).nil? || !(index2 = s.index("10")).nil?
  index = !index1.nil? ? index1 : index2
  s.slice!(index, 2)
  deleted_cube += 2
end
print("#{deleted_cube}\n")
//  [ruby]
cubes = gets.chomp.to_s
original_length = cubes.length
while true do
  before_length = cubes.length
  cubes.gsub!(/0000000000000000000011111111111111111111/, "")
  cubes.gsub!(/1111111111111111111100000000000000000000/, "")
  cubes.gsub!(/10/, "")
  cubes.gsub!(/01/, "")
  after_length = cubes.length
  break if before_length == after_length
end
puts original_length - cubes.length
//  [rust]
macro_rules! input {
    (source = $s:expr, $($r:tt)*) => {
        let mut iter = $s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
    ($($r:tt)*) => {
        let s = {
            use std::io::Read;
            let mut s = String::new();
            std::io::stdin().read_to_string(&mut s).unwrap();
            s
        };
        let mut iter = s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
}

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

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

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

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

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

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

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

#[allow(unused_imports)]
use std::{i32, i64, u32, u64, f64};
#[allow(unused_imports)]
use std::cmp::{max, min, Ordering};
#[allow(unused_imports)]
use std::collections::{VecDeque, HashMap, BTreeMap, HashSet, BTreeSet};
#[allow(unused_imports)]
use std::io::{stdout, Write, BufWriter};
#[allow(unused_imports)]
use std::mem::{swap};
//#[allow(unused_imports)]
//use proconio::marker::{Isize1, Usize1, Bytes, Chars};

//#[proconio::fastout]
fn main() {
    input!{
        s: String,
    }
    let mut s = s.chars().map(|c| c.to_digit(10).unwrap()).collect::<Vec<_>>();
    let mut i = 0;
    let mut ans = 0;
    while i + 1 < s.len() {
        if s[i] != s[i + 1] {
            s.remove(i);
            s.remove(i);
            ans += 2;
            i = 0;
            continue;
        }
        i += 1;
    }
    println!("{}", ans);
}
//  [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 s: String = read();
    let str_taishou :Vec<char>  = s.chars().collect();
    let r = delete(str_taishou);
    println!("{}", r);
}

fn delete(mut s: Vec<char>) -> usize{
    let mut i :usize = 0;
    let mut n: usize = 1;
    let start_length = s.len();
    while n < s.len() {
        if s[i] != s[n] {
            s.remove(i);
            s.remove(i);
            i = 0;
            n = 1;
        } else {
            i = i + 1;
            n = n + 1;
        }
    }
    start_length - s.len()
}
//  [rust]
#![allow(non_snake_case)]
#![allow(unused_imports)]
#![allow(dead_code)]
 
use proconio::{input, fastout};
use proconio::marker::*;
use whiteread::parse_line;
use std::collections::*;
use num::*;
use num_traits::*;
use superslice::*;
use std::ops::*;
 
use itertools::Itertools;
use itertools_num::ItertoolsNum;

#[fastout]
fn solve() {
    const MOD: usize = 1_000_000_007;
    const INF: usize = std::usize::MAX;

    input!{
        s: Chars,
    }
    let mut s: VecDeque<char> = VecDeque::from(s);
    let mut leaved = vec![];
    let all_num = s.len();

    loop {
        // dbg!(&s);
        // dbg!(&leaved);
        if (s.len() == 0 && (leaved.iter().all_equal() || leaved.len() == 0)) || s.iter().chain(leaved.iter()).all_equal() { break; }

        let s1 = s.pop_front().unwrap();

        if !leaved.is_empty() {
            let l = leaved.pop().unwrap();
            if l != s1 { continue; }
            leaved.push(l);
        }

        let s2 = s.pop_front().unwrap();

        if s1 != s2 { continue };

        leaved.push(s1);
        s.push_front(s2);
    }

    println!("{}", all_num - s.len() - leaved.len())
}

fn main() {
    solve();
}
//  [typescript]
function Main(input) {
	if(input.length < 2) {
		console.log(0);
		return;
	}

	let result = 0;
	let nums = input.split('').map((n) => (parseInt(n, 10)));
	let n = nums.length;

	for(let i = 0; i < n-1; i++) {
		if(nums[i] + nums[i + 1] === 1) {
			result += 2;
			n -= 2;
			nums.splice(i, 2);
			if(i > 0) {
				i -= 2;
			} else {
				i--;
			}
		}
	}
	console.log(result);
}

Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [typescript]
import fs = require('fs');
const input = fs.readFileSync('/dev/stdin', 'utf8').trim();
const numbers = input.split('').map(Number);

let answer = 0;
for(let i=0; i<numbers.length-1; i++) {
	const n1 = numbers[i+0];
	const n2 = numbers[i+1];

	if(n1+n2 === 1) {
		numbers.splice(i, 2);
		answer += 2;
		i = Math.max(-1, i-2);
	}
}
console.log(answer);
//  [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 gcd=(x,y)=>{while(y){[x,y]=[y,x%y]}return x};
const main=()=>{
  let sr=ts().split(''),c=0
  for(let i=0;i<sr.length-1;i++){
    while(sr[i]=='0'&&sr[i+1]=='1'||sr[i]=='1'&&sr[i+1]=='0'){
      c+=2
      sr.splice(i,2)
      i--
    }
  }
  to(c)
}
main()
//  [python]
#!/usr/bin/env python
# -*- coding: utf-8 -*-

import sys  # {{{
import os
import time
import re
from pydoc import help
import string
import math
from operator import itemgetter
from collections import Counter
from collections import deque
from collections import defaultdict as dd
import fractions
from heapq import heappop, heappush, heapify
import array
from bisect import bisect_left, bisect_right, insort_left, insort_right
from copy import deepcopy as dcopy
import itertools
# }}}

# pre-defined{{{
sys.setrecursionlimit(10**7)
INF = 10**20
GOSA = 1.0 / 10**10
MOD = 10**9+7
ALPHABETS = [chr(i) for i in range(ord('a'), ord('z')+1)]  # can also use string module
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def DP(N, M, first): return [[first] * M for n in range(N)]
def DP3(N, M, L, first): return [[[first] * L for n in range(M)] for _ in range(N)]
from inspect import currentframe
def dump(*args):
    names = {id(v):k for k,v in currentframe().f_back.f_locals.items()}
    print(', '.join(names.get(id(arg),'???')+' => '+repr(arg) for arg in args), file=sys.stderr)
# }}}

def local_input():# {{{
    from pcm.utils import set_stdin
    import sys
    from pathlib import Path
    parentdir = Path(os.path.dirname(__file__)).parent
    inputfile = parentdir.joinpath('test/sample-1.in')
    if len(sys.argv) == 1:
        set_stdin(inputfile)
# }}}

def solve():
    T, X = map(float, input().split())
    print(T/X)
    return 0

if __name__ == "__main__":# {{{
    try:
        local_input()
    except:
        pass
    solve()
# vim: set foldmethod=marker:}}}
//  [python]
a,b = map(float, raw_input().split(' '))
print a/b
//  [python]
from decimal import Decimal
t, x = input().split()
print(Decimal(t)/Decimal(x))
//  [java]
import java.io.*;
import java.util.StringTokenizer;

public class Main {
  private static PrintWriter out;

  public static void main(String[] args) {
    Main main = new Main();
    Runtime.getRuntime().addShutdownHook(new Thread(() -> out.close()));
    try {
      main.run(args);
    } catch (Exception e) {
      e.printStackTrace();
    }
  }

  private void run(String[] arguments) throws Exception {
    MyScanner sc = new MyScanner();
    out = new PrintWriter(new BufferedOutputStream(System.out));

    double T = sc.nextDouble();
    double X = sc.nextDouble();

    double ans = T / X;
    out.println(ans);

    out.close();
  }

  /*          
   * Form: http://codeforces.com/blog/entry/7018
   */
  private class MyScanner {
    BufferedReader br;
    StringTokenizer st;

    MyScanner() {
      br = new BufferedReader(new InputStreamReader(System.in));
    }

    String next() {
      while (st == null || !st.hasMoreElements()) {
        try {
          st = new StringTokenizer(br.readLine());
        } catch (IOException e) {
          e.printStackTrace();
        }
      }
      return st.nextToken();
    }

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

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

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

    String nextLine() {
      String str = "";
      try {
        str = br.readLine();
      } catch (IOException e) {
        e.printStackTrace();
      }
      return str;
    }
  }
}
//  [java]
import java.util.Scanner;
import java.util.stream.Stream;

public class Main {

	public static void main(String[] args) {
		// 初期化
		Scanner sc = new Scanner(System.in);
		// Streamを使用してint配列の作成
		int[] list = Stream.of(sc.nextLine().split(" ")).mapToInt(Integer::parseInt).toArray();

		double T = (double)list[0];
		double X = (double)list[1];

		System.out.println(String.format("%.10f", T/X));
	}

}
//  [java]
import java.util.Scanner;

public class Main {

	public static void main(String[] args) {
		// TODO 自動生成されたメソッド・スタブ

		Scanner sc = new Scanner(System.in);
		//入力表示

		int T =sc.nextInt();
		int X = sc.nextInt();
		
		double ans=(double)T/X;
			System.out.printf("%.10f",ans);
	}
}
//  [cpp]
#include <bits/stdc++.h>

using namespace std;

int main() {
    long double t, x;
    cin >> t >> x;
     cout << fixed << setprecision(9999999) << t / x << endl;;
}
//  [cpp]
#include <bits/stdc++.h>
#define pb push_back
#define Int long long
using namespace std;

const int MAXN=500005;
const long MOD=(long)(1e9+7);
vector<int> adj[MAXN];
vector<pair<int,int>> G[MAXN];

Int N,M,K;
Int B,C,H,W;
Int X,Y,Z;
vector<Int> A;

Int ceilS(Int x,Int y){
    return (x+y-1)/y;
}
using D=long double;

Int perform(Int x){
    return (x*(x+1))/2LL;
}

D getExpectation(D x) {
   return perform(x)/x;
}

int main()
{
    D T,X;
    cin>>X>>T;
    D ans=X/T;
    cout<<ans<<"\n";
}
//  [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 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 t,x;cin>>t>>x;
  double ans=(double)t/x;
  
  coutd(ans);

  return 0;
}
//  [c]
#include<stdio.h>
int main()
{
	float a,x,t;
	scanf("%f %f",&t,&x);
	a=t/x;
	printf("%f\n",a);
	return 0;
}
//  [c]
#include<stdio.h>
int main()
{
	int t,x;

	scanf("%d%d",&t,&x);

	printf("%f",(double)t/x);
	return 0;
}
//  [c]
#include<stdio.h>

int main(void){
  int t,x;
  scanf("%d %d",&t,&x);
  printf("%f\n",(double)t/x);
  return 0;
}
//  [javascript]
function main(input) {
    const args = input.split(' ');
    var A = parseInt(args[0], 10);
    var B = parseInt(args[1], 10);

    console.log(A/B);
}

main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [javascript]
const main = input => {
  const [T, X] = input.trim().split(' ').map(x => parseInt(x))
  console.log(T / X)
}
// 標準入力
main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
process.stdin.resume();
process.stdin.setEncoding('utf8');
// Your code here!

process.stdin.on('data',(data)=> {
    var b = data.split(' ').map(d=>Number(d));
    console.log(b[0]/b[1]);
})
//  [go]
package main

import (
	"fmt"
)

func main() {
	var t, x float64
	fmt.Scan(&t, &x)
	fmt.Println(t / x)
}
//  [go]
package main

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

var sc = bufio.NewScanner(os.Stdin)

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

func intScanner() int {
	n, _ := strconv.Atoi(Scanner())
	return n
}

func floatScanner() float64 {
	n, _ := strconv.ParseFloat(Scanner(), 64)
	return n
}
func stringToInt(s string) int {
	n, _ := strconv.Atoi(s)
	return n
}
func stringSliceScanner(n int) []string {
	a := make([]string, n)
	for i := 0; i < n; i++ {
		a[i] = Scanner()
	}
	return a
}
func intSliceScanner(n int) []int {
	a := make([]int, n)
	for i := 0; i < n; i++ {
		a[i] = intScanner()
	}
	return a
}
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 abs(x int) int {
	if x < 0 {
		x = -x
	}
	return x
}

var mod int

func main() {
	mod = 1000000007
	buf := make([]byte, 0)
	sc.Buffer(buf, mod)
	sc.Split(bufio.ScanWords)
	t, x := floatScanner(), floatScanner()
	fmt.Println(t / x)
}
//  [go]
package main
 
import (
	"fmt"
)
 
func main() {
  var t, x float64
  fmt.Scanf("%f %f", &t, &x)

  fmt.Printf("%f\n", t / x)
}
//  [ruby]
#!/usr/bin/env ruby

require 'set'

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

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

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

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

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

def get_int
  gets.chomp.to_i
end

require 'bigdecimal'

T, X = get_ints

puts (BigDecimal(T)/X).to_f
//  [ruby]
T,X = gets.split.map(&:to_f)
puts T / X
//  [ruby]
t, x = gets.chomp.split(" ").map(&:to_i)
puts t / x.to_f
//  [rust]
// use proconio::marker::Chars;
use proconio::{fastout, input};
// use std::cmp::{max, min};

#[fastout]
fn main() {
    input! {
        t: usize,
        x: usize
    };

    println!("{}", t as f64 / x as f64);
}
//  [rust]
#![allow(non_snake_case)]
#![allow(unused_imports)]
use proconio::input;
use std::cmp::max;
use std::cmp::min;
use std::collections::HashMap;
use std::collections::VecDeque;

fn main() {
    input! {
        T: f64,
        X: f64,
    }

    let ans = T / X;
    println!("{}", ans);
}
//  [rust]
#![allow(unused_imports)]

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

fn main() {
    input! {
    a:f64,
    b:f64,
    }
    println!("{}",a/b)
}
//  [swift]
import Foundation
 
let input_line: String = readLine()!
let split: [String] = input_line.components(separatedBy: " ")
 
let t = Double(split[0])!
let x = Double(split[1])!

print(t/x)
//  [typescript]
namespace Coder {
  class Scanner {
    private buffer: string = '';
    private stdinQueue: any = [];

    constructor() {
      process.stdin.resume();
      process.stdin.setEncoding('utf8');
      process.stdin.on(
        'data',
        (chunk): void => {
          this.buffer += chunk;
          while (this.stdinQueue.length > 0) {
            const i = this.buffer.indexOf('\n');
            if (i < 0) {
              break;
            }
            let line = this.buffer.substr(0, i);
            if (line.endsWith('\r')) {
              line = line.slice(0, -1);
            }
            this.buffer = this.buffer.substr(i + 1);
            this.stdinQueue.shift()(line);
          }
        },
      );
    }
    public getLine(): Promise<string> {
      return new Promise((resolve, reject) => {
        const i = this.buffer.indexOf('\n');
        if (i >= 0 && this.stdinQueue.length == 0) {
          let line = this.buffer.substr(0, i);
          if (line.endsWith('\r')) {
            line = line.slice(0, -1);
          }
          this.buffer = this.buffer.substr(i + 1);
          resolve(line);
        } else {
          this.stdinQueue.push(resolve);
        }
      });
    }

    public close(): void {
      process.stdin.pause();
    }
  }

  async function slove() {
    const sc = new Scanner();
    const [t, x] = (await sc.getLine()).split(' ').map((x) => +x);
    console.log((t / x).toFixed(10));
    sc.close();
  }

  slove();
}
//  [typescript]
const input=require('fs').readFileSync('/dev/stdin', 'utf8').split(/[\s]/);const nin=()=>{const r = input[0];input.shift();return Number(r)};const nrin=(n)=>{const a:number[]=[];rep(n,()=>a.push(nin()));return a};const sin=()=>{const r = input[0];input.shift();return String(r)};const out=(...a)=>{console.log(...a)};const floor=(a)=>{return Math.floor(a)};const abs=(a)=>{return Math.abs(a)};const min=(...a)=>{return Math.min(...a)};const max=(...a)=>{return Math.max(...a)};const rep=(n, callback)=>{for(let i = 0;i < n; i++){callback()}};const strrep=(s, i, v)=>{return s.slice(0, i)+v+s.slice(i+1);};const permutation=({result=[],pre=[],post,n=post.length})=>{if(n>0){post.forEach((_,i)=>{const rest=[...post];const elem=rest.splice(i, 1);permutation({result, pre: [...pre,...elem],post:rest,n:n-1})})}else{result.push(pre)}return result}

const main = ()=>{
  let[a,b]=nrin(2);
  out(a/b);
}
main();
//  [typescript]
[T,X]=require('fs').readFileSync('/dev/stdin','utf8').split(' ').map(n=>n|0)
console.log(T/X)
//  [python]
S = raw_input()
print "yes" if len(S) == len(set(S)) else "no"
//  [python]
# coding: utf-8
# Here your code !

s = input()
beforeLength= len(s)
afterLength=len(set(s)) 
if beforeLength==afterLength:
    print("yes")
else:
    print("no")
//  [python]
s = input()
if len(set(s)) == len(s):
  print("yes")
else:
  print("no")
//  [python]
s = raw_input()
print 'yes' if len(s) == len(set(s)) else 'no'
//  [python]
from statistics import mean, median,variance,stdev
import numpy as np
import sys
import math
import fractions
import itertools
import copy

def j(q):
    if q==1: print("yes")
    else:print("no")
    exit(0)


def ct(x,y):
    if (x>y):print("")
    elif (x<y): print("")
    else: print("")

def ip():
    return int(input())


#n = ip()                              #入力整数1つ
#n,k= (int(i) for i in input().split())      #入力整数横2つ
#n,x,y = (int(i) for i in input().split())    #入力整数横3つ
#n,a,b,c= (int(i) for i in input().split())  #入力整数横4つ
#a = [int(i) for i in input().split()]        #入力整数配列
a = input()                                  #入力文字列
#a = input().split()                          #入力文字配列
#n = ip()                      #入力セット(整数改行あり)(1/2)
#a=[ip() for i in range(n)]    #入力セット(整数改行あり)(2/2)

#jの変数はしようできないので注意
#全足しにsum変数使用はsum関数使用できないので注意
b = set()
for i in range(len(a)):
    b.add(a[i])
if len(b) == len(a):
    j(1)
j(0)
//  [python]
from collections import defaultdict
import numpy as np

S = list(map(str, input().rstrip()))

memo = defaultdict(int)

for s in S:
    memo[s] += 1

ans = np.array(list(memo.values()))

print("yes") if np.where(ans>1)[0].shape[0]==0 else print("no")
//  [java]
import java.io.*;
import java.util.*;

public class Main{
  public static void main(String[] args) {
    try(BufferedReader in = new BufferedReader(new InputStreamReader(System.in))){
      String S = in.readLine();
      int len = S.length();
      boolean[] exist = new boolean[26];
      char a = 'a';
      boolean result = true;
      for(int i=0;i<len;i++){
        if(exist[S.charAt(i)-a]){
          result = false;
          break;
        }else{
          exist[S.charAt(i)-a] = true;
        }
      }
      if(result){
        System.out.println("yes");
      }else{
        System.out.println("no");
      }
    }catch(IOException e){
      e.printStackTrace();
    }
  }
}
//  [java]
import java.io.IOException;
import java.io.InputStream;
import java.util.NoSuchElementException;

public class Main {
	private static FastScanner sc = new FastScanner();

	public static void main(String[] args) {
		char[] str = sc.next().toCharArray();
		
		for(int i=0; i<str.length; i++) {
			for(int j=i+1; j<str.length; j++) {
				if(str[i] == str[j]) {
					System.out.println("no");
					return;
				}
			}
		}
		
		System.out.println("yes");
	}

	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;}
        private void skipUnprintable() { while(hasNextByte() && !isPrintableChar(buffer[ptr])) ptr++;}
        public boolean hasNext() { skipUnprintable(); 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() {
            return Long.parseLong(next());
        }
        public int nextInt(){
            return Integer.parseInt(next());
        }
        public double nextDouble(){
            return Double.parseDouble(next());
        }
    }
}