jiahuimbzuai/CoQuIR huggingface dataset:
//  [java]
import java.io.*;
import java.util.*;

public class Main {

    public static void main(String[] args) throws Exception {
        String line = readLine();
        StringTokenizer st = new StringTokenizer(line, " ");
        int a = Integer.parseInt(st.nextToken());
        int b = Integer.parseInt(st.nextToken());
        int x = Integer.parseInt(st.nextToken());
        int sum = a + b;
        if (x > sum) {
            System.out.println("NO");
            return;
        }
        if (x < a) {
            System.out.println("NO");
            return;
        }
        System.out.println("YES");
        return;
    }

    private static String readLine() throws Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        return br.readLine();
    }
}
//  [java]
import java.util.*;
import java.io.*;

class Main{
    public static void main(String[] args){
        FastScanner fsc=new FastScanner();
        int a=fsc.nextInt(), b=fsc.nextInt(), x=fsc.nextInt();
        fsc.close();
        if(a<=x && x<=a+b) System.out.println("YES");
        else System.out.println("NO");
    }
    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.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

class Main {

    public static void main(String[] args) throws Exception {

        try {

            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

            String[] counts = br.readLine().split(" ");
            int catsCount = Integer.parseInt(counts[0]);
            int catsOrDogsCount = Integer.parseInt(counts[1]);
            int hopeCatsCount = Integer.parseInt(counts[2]);

            String isCatsCountPossible = "NO";
            if (catsCount == hopeCatsCount
                    || (catsCount < hopeCatsCount && hopeCatsCount - catsCount <= catsOrDogsCount)) {
                isCatsCountPossible = "YES";
            }

            System.out.println(isCatsCountPossible);
        } catch (IOException | NumberFormatException e) {
            e.printStackTrace();
            System.exit(0);
        } catch (final Exception e) {
            e.printStackTrace();
            System.exit(0);
        }
    }
}
//  [java]
import java.util.Scanner;

public class Main {

	public static String Y = "Yes";
	public static String N = "No";
	public static long MOD = (long) (Math.pow(10, 9) + 7);
	public static Scanner sc = new Scanner(System.in);

	public static void main(String[] args) {

		int a = ni();
		int b = ni();
		int x = ni();

		if (a <= x && x <= b) {
			out("YES");
		} else {
			out("NO");
		}

	}

	/*
	 * 以下メソッド集
	 */

	public static long[] kousokusoinnsuubunkaihairetsu(long n2) {
		long[] d = new long[(int) n2];
		for (int i = 0; i < n2; i++) {
			d[i] = i;
		}
		for (int i = 2; i * i < n2; i++) {
			for (int j = i * i; j < n2; j += i) {
				if (d[j] == j)
					d[j] = i;
			}

		}

		return d;
	}

	public static void permutation(String q, String ans) {
		// Base Case
		if (q.length() <= 1) {
			System.out.println(ans + q);
		}
		// General Case
		else {
			for (int i = 0; i < q.length(); i++) {
				permutation(q.substring(0, i) + q.substring(i + 1),
						ans + q.charAt(i));
			}
		}
	}

	static char[][] same(char[][] c, int h, int w) {

		char[][] a = new char[h][w];
		for (int i = 0; i < h; i++) {
			for (int j = 0; j < w; j++) {
				a[i][j] = c[i][j];
			}
		}
		return a;

	}

	static int countkuro(char[][] c) {

		int count = 0;
		for (char[] cc : c) {
			for (char ccc : cc) {
				if ('#' == ccc) {
					count++;
				}
			}
		}
		return count;
	}

	static void debug() {

		out("---");
	}

	static void debug(Object a) {

		out("-------");
		out(a);
		out("-------");
	}

	static int ketasuu(int n) {

		String str = "" + n;
		return str.length();
	}

	static int account(String str) {

		String target = "2";
		int count = 0;
		int len = str.length();
		for (int i = 0; i < len; i++) {
			if (target.equals(str.substring(i, i + target.length()))) {
				count++;
			}
		}
		return count;
	}

	static int ni() {

		return sc.nextInt();
	}

	static long nl() {

		return sc.nextLong();
	}

	static double nd() {

		return sc.nextDouble();
	}

	static String n() {

		return sc.next();
	}

	static char[] nc() {

		return sc.next().toCharArray();
	}

	static int kaijo(int n) {

		if (n == 0 || n == 1) {
			return 1;
		} else {
			return n * kaijo(n - 1);
		}
	}

	static long kaijo(long n) {

		debug(n);

		if (n == 0l || n == 1l) {
			return 1l;
		} else {
			return n * kaijo(n - 1l);
		}
	}

	static int fib(int n) {

		return (n == 1 || n == 0) ? n : fib(n - 2) + fib(n - 1);
	}

	static long lcm(long m, long n) {

		return m * n / gcd(m, n);
	}

	static int lcm(int m, int n) {

		return m * n / gcd(m, n);
	}

	static long gcd(long a, long b) {

		return (b == 0) ? a : gcd(b, a % b);
	}

	static int gcd(int a, int b) {

		return (b == 0) ? a : gcd(b, a % b);
	}

	static void out(Object obj) {
		System.out.println(obj);
	}

	static void outn(Object obj) {
		System.out.print(obj);
	}

	static double max(double d, double e) {

		return Math.max(d, e);
	}

	static long max(long a, long b) {

		return Math.max(a, b);
	}

	static long min(long d, long e) {

		return Math.min(d, e);
	}

	static int min(int a, int b) {

		return Math.min(a, b);
	}
}

class XY {

	int h;
	int w;
	int d;

	XY(int h, int w, int d) {
		this.h = h;
		this.w = w;
		this.d = d;
	}
}
//  [java]
import java.util.Scanner;

public class Main {
	
	
	public static void main(String[] args) {
		Scanner sc=new Scanner(System.in);
		for(int i=0;i<1;i++) {
			int A=sc.nextInt();
			int B=sc.nextInt();
			int X=sc.nextInt();
			
			if(A+B>=X) {
				System.out.println("YES");
			}else {
				System.out.println("NO");
			}
			
			System.out.println("A");
			
		}
		sc.close();
	}
	
}
//  [java]

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class Main {


    public static void main(String[] args) throws IOException {
        Scanner s = new Scanner(System.in);
        int a = s.nextInt(),b=s.nextInt(),c=s.nextInt();
        if(a==c||a+b>=c) System.out.println("YES");
        else System.out.println("NO");
    }


}


class Scanner
{
    StringTokenizer st;
    BufferedReader br;

    public Scanner(InputStream s){	br = new BufferedReader(new InputStreamReader(s));}

    public String next() throws IOException
    {
        while (st == null || !st.hasMoreTokens())
            st = new StringTokenizer(br.readLine());
        return st.nextToken();
    }

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

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

    public String nextLine() throws IOException {return br.readLine();}

    public double nextDouble() throws IOException
    {
        String x = next();
        StringBuilder sb = new StringBuilder("0");
        double res = 0, f = 1;
        boolean dec = false, neg = false;
        int start = 0;
        if(x.charAt(0) == '-')
        {
            neg = true;
            start++;
        }
        for(int i = start; i < x.length(); i++)
            if(x.charAt(i) == '.')
            {
                res = Long.parseLong(sb.toString());
                sb = new StringBuilder("0");
                dec = true;
            }
            else
            {
                sb.append(x.charAt(i));
                if(dec)
                    f *= 10;
            }
        res += Long.parseLong(sb.toString()) / f;
        return res * (neg?-1:1);
    }

    public boolean ready() throws IOException {return br.ready();}


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

int main(void) {
	int a, b, x;

	scanf("%d %d %d", &a, &b, &x);

	if (x >= a && x <= a + b) {
		printf("YES\n");
	}
	else {
		printf("NO\n");
	}
	return 0;
}
//  [cpp]
#include<stdio.h>

int main(){
    int cat, unk, jud;

    scanf("%d%d%d",&cat,&unk, &jud);


    if(cat+unk >= jud && cat <= jud)  puts("YES");
    else       puts("NO");

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

int main(void)
{
 int a,b,x;

 scanf("%d%d%d",&a,&b,&x);
 
 if((a<=x)&&(a+b>=x)) printf("YES\n");

 else printf("NO\n");

 return 0;
}
//  [cpp]
#include<iostream>
using namespace std;
int main()
{

    int a, b, x;
    cin>>a>>b>>x;
  	if(a+b<x) cout<<"NO"<<endl;
  else cout<<"YES"<<endl;

    return 0;
}
//  [cpp]
#include <iostream>
#include<cmath>
#include<math.h>
#include<algorithm>
#include<fstream>
#include<queue>
#include<set>
#include<string>
using namespace std;
void fast(){
	std::ios_base::sync_with_stdio(0);
	cin.tie(NULL);
	cout.tie(0);
}

int main()
{
	fast();

	int a, b, x;
	cin >> a >> b >> x;
	if (x >= a&&x <= b || a == b == x||a==b&&x<b)
		cout << "YES" << endl;
	else
		cout << "NO" << endl;
}
//  [cpp]
#include <iostream>
#include<cmath>
#include<math.h>
#include<algorithm>
#include<fstream>
#include<queue>
#include<set>
#include<string>
using namespace std;
void fast(){
	std::ios_base::sync_with_stdio(0);
	cin.tie(NULL);
	cout.tie(0);
}

int main()
{
	fast();

	int a, b, x;
	cin >> a >> b >> x;
	if (x >= a&&x <= b)
		cout << "YES" << endl;
	else
		cout << "NO" << endl;
}
//  [c]
#include <stdio.h>

int main(void){
	int A,B,X;
	
	scanf("%d",&A);
	scanf("%d",&B);
	scanf("%d",&X);
	
	if(A<=X){
		if(A+B>=X){
		printf("YES");
		}else{
		printf("NO");
		}
	}else{
		printf("NO");
	}
	return 0;}
//  [c]
#include<stdio.h>

int main()
{
    int a,b,x;
    scanf("%d %d %d",&a,&b,&x);

    if(x>(a+b) || x<a){
    printf("NO\n");

    }

else{
printf("YES\n");
}





return 0;

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

typedef long long int int64;

#define MAX(a,b) ((a)>(b)?(a):(b))
#define MIN(a,b) ((a)<(b)?(a):(b))
#define ABS(a,b) ((a)>(0)?(a):-(a))

int main(void){
    int A,B,X;
    scanf("%d %d %d",&A,&B,&X);
    if(A<=X && X<=A+B){
        printf("YES");
    }else{printf("NO");
    }
            
    return 0;
}
//  [c]
#include <stdio.h>

int main(){
  int A,B,X,Y;
  Y=B-X;
    scanf("%d %d %d %d",&A,&B,&X,&Y);
          
          
 if(A+B<X){
            printf("NO\n");
          }else{
            printf("YES\n");
          }
  return 0;
}
//  [c]
#include<stdio.h>
int main()
{
    int a,b,x;
    scanf("%d %d %d",&a,&b,&x);
    if(a>x)
    {
        printf("No");
    }
    else
    {
        if((a+b)>=x)
        {
            printf("YES");
        }
        else
        {
            printf("NO");
        }
    }
return 0;
}
//  [c]
#include<stdio.h>
int main()
{
    int a,b,x;
    scanf("%d %d %d",&a,&b,&x);
    if(a>x)
    {
        printf("No");
    }
    else
    {
        if((a+b)>=x)
        {
            printf("Yes");
        }
        else
        {
            printf("No");
        }
    }
return 0;
}
//  [javascript]
function Main(input) {
  input = input.trim()
 input = input.split(" ").map(Number);
if(input[0]<=input[2]&&input[0]+input[1]>=input[2]){
  console.log("YES")
}else{
  console.log("NO")
}
}Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
inp = require('fs').readFileSync('/dev/stdin', 'utf8').split('\n')
l = inp.shift().split(' ')
A = l[0] * 1
B = l[1] * 1 
X = l[2] * 1 
console.log(A + B >= X && A <= X ? 'YES' : 'NO')
//  [javascript]
'use strict'

const main = (input) => {
    input = input.split(' ').map(i => parseInt(i))
    const A = input[0]
    const B = input[1]
    const X = input[2]
    if(A <= X && X <= A + B){
        console.log('YES')
    }else{
        console.log('NO')
    }
}

main(require('fs').readFileSync('/dev/stdin', 'utf-8'))
//  [javascript]
let [a, b, x] = require("fs").readFileSync("/dev/stdin", "utf8").split(" ").map(Number);
console.log(a < x && x <= a + b ? "YES" : "NO");
//  [javascript]
function main(input) {
  input = input.trim();
  const a = input.split(" ").map(Number);
  const gou = a[0]+a[1];
  if(a[2]>=a[0]&&gou>=a[2]){
    cosole.log("NO");
  }else{
    console.log("YES");
  }
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [javascript]
function main(input) {
  input = input.trim();
  const a = input.split(" ").map(Number);
  const gou = a[0]+a[1];
  if(a[2]>=a[0]&&a[0]+a[1]>=a[2]){
    cosole.log("YES");
  }else{
    console.log("NO");
  }
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [go]
package main

import (
	. "fmt"
)

// func init() { Println("----------------------------------------") }

func main() {
    var a, b, x int
    Scanf("%d %d %d", &a, &b, &x)

    if x < a || a + b < x {
        Println("NO")
    } else {
        Println("YES")
    }
}
//  [go]
package main

import (
	"fmt"
)

func main() {
	var a, b, x int
	fmt.Scan(&a, &b, &x)
	if a+b >= x && a <= x {
		fmt.Println("YES")
	} else {
		fmt.Println("NO")
	}
}
//  [go]
package main

import "fmt"

func main() {
	var A, B, X int

	fmt.Scan(&A, &B, &X)

	if (A+B)-X > 0 {
		fmt.Println("Yes")
	} else {
		fmt.Println("No")
	}

}
//  [go]
package main

import "fmt"


func main() {
	var A, B, X int

	fmt.Scan(&A, &B, &X)

	if (A+B)-X > 0 {
		fmt.Println("Yes")
	} else {
		fmt.Println("No")
	}

}
//  [go]
package main

import (
	"fmt"
)

func main() {
	var (
		d, c, x int
	)

	fmt.Scan(&d, &c, &s)

	if 0 <= (x-d) && (x-d) <= c {
		fmt.Println("YES")
	} else {
		fmt.Println("NO")
	}

}
//  [ruby]
input = gets.chomp.split
a = input[0].to_i
b = input[1].to_i
x = input[2].to_i

if a + b < x || a > x
    puts "NO"
else
    puts "YES"
end
//  [ruby]
a,b,x = gets.split.map &:to_i
if a > x || a+b < x
  puts "NO"
elsif a == x || (a < x && a+b >= x)
  puts "YES"
end
//  [ruby]
a = gets.split(' ').map(&:to_i)
if a[0] > a[2]
    puts("NO")
elsif (a[0] + a[1]-1)> a[2]
    puts("YES")
else
    puts("NO")
end
//  [ruby]
a,b,x = gets.strip.split.map(&:to_i)
if a<=x && x<=a+b
  puts "Yes"
else
  puts "No"
end
//  [ruby]
n,m,x = gets.strip.split.map(&:to_i)
num = gets.strip.split.map(&:to_i)
sd = num.count{|y| y>x}
puts [sd,m-sd].min
//  [ruby]
a, b ,x = gets.chomp.split(" ").map(&:to_i)
if a + b >= x && b <= x
    puts "YES"
else
    puts "NO"
end
//  [rust]
use std::io::*;
use std::str::FromStr;

pub 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: usize = read();
    let b: usize = read();
    let x: usize = read();

    if a <= x && x <= a + b {
        println!("YES");
    } else {
        println!("NO");
    }
}
//  [rust]
use std::io;

fn procon_read<T: std::str::FromStr>() ->  Vec<T> {
	let mut buf = String::new();
	io::stdin().read_line(&mut buf).expect("");
	let iter = buf.split_whitespace();
	let mut v: Vec<T> = Vec::new();
	for i in iter {
		v.push(i.parse().ok().unwrap());
	}
	v
}

fn main() {
	let v:Vec<i32> = procon_read();
	let a = v[0];
	let b = v[1];
	let x = v[2];
	if x - a > b {
		println!("NO");
	}else if x < a {
		println!("NO");
	}else{
		println!("YES");
	}
}
//  [rust]
// Template from https://techracho.bpsinc.jp/jhonda/2019_08_05/78537

// input macro for competive-programming from https://qiita.com/tanakh/items/0ba42c7ca36cd29d0ac8
#[allow(unused_macros)]
macro_rules! input {
    (source = $s:expr, $($r:tt)*) => {
        let mut iter = $s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
}

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

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

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

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

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

    ($iter:expr, bytes) => {
        read_value!($iter, String).into_bytes()
    };

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

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

    println!("{}", solve(&s));
}

macro_rules! test {
    ($($input:expr => $output:expr),* $(,)*) => {
        #[test]
        fn solve_test() {
            $(
                assert_eq!(solve($input), $output);
            )*
        }
    };
}

test! {
// r#"2018 218"# => "Yes",
// r#"2763 0"# => "No",
r#"5 3 2"# => "NO",

}

fn solve(src: &str) -> String {
    input! {
        source = src,
        a: i64,
        b: i64,
        x: i64,
    }

    if x >= a && a + b - x >= 0 {
        "YES"
    } else {
        "NO"
    }.to_string()
}
//  [rust]
use proconio::input;

fn main() {
    input! {
        a: usize,
        b: usize,
        x: usize,
    };
    let ans = (a..=b).contains(&x);
    println!("{}", if ans { "YES" } else { "NO" });
}
//  [rust]
use proconio::{fastout, input};

#[allow(unused_imports)]
use std::cmp::*;
#[allow(unused_imports)]
use std::collections::*;

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

    let mut ans = "";
    if a <= x && x <= b {
        ans = "YES"
    } else {
        ans = "NO"
    }
    println!("{}", ans);
}
//  [rust]
use proconio::input;

fn main() {
  input!{
    mut a : i8,
    mut b : i8,
    mut x : i8
  }
  if x <= a + b && a <= x {
    println!("YES")
  } else {
    println!("NO")
  }
}
//  [swift]
import Glibc
extension String: CollectionType {}

var inp = readLine()!.split(" ").map { Int($0)! }
if inp[0] + inp[1] >= inp[2] && inp[2] >= inp[0] {
  print("YES")
} else {
  print("NO")
}
//  [swift]
let i=readLine()!.characters.split(" ").map{Int(String($0))!};print(i[0]...i[0]+i[1]~=i[2] ?"YES":"NO")
//  [swift]
let i=readLine()!.characters.split(" ").map{Int(String())!};print(i[0]...i[0]+i[1]~=i[2] ?"YES":"NO")
//  [typescript]
const stdin = require('fs').readFileSync('/dev/stdin', 'utf8')

const [a, b, x] = stdin.split('\n')[0].split(' ').map(Number)

let res = 'YES'
if(x > a){
  res = x <= a+b ? 'YES' : 'NO'
} else if (x < a){
  res = 'NO'
}

console.log(res)
//  [typescript]
import * as fs from 'fs';

namespace AtCoder.abc094 {

    export class Program {
        args: string[];

        constructor(args: string[]) {
            this.args = args;
        }

        /**
         * in
         *
         * out
         *
         */
        main(this: Program): void {
            const [a, b, x]: number[] = this.args[0].split(' ').map(Number);
            if (a > x) {
                console.log('NO')
            } else if (a + b < x) {
                console.log('NO');
            } else {
                console.log('YES');
            }
        }
    }
}

const args = fs.readFileSync('/dev/stdin', 'utf8').trim().split('\n');
const prg = new AtCoder.abc094.Program(args);
prg.main();
//  [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 sw=(s,a:any[],op:'=='|'>='|'>'|'<='|'<'='==')=>{for(let i=0;i<a.length;i+=2){if(op==='=='){if(s==a[i])return a[i+1]}else if(op==='>='){if(s>=a[i])return a[i+1]}else if(op==='<='){if(s<=a[i])return a[i+1]}else if(op==='>'){if(s>a[i])return a[i+1]}else if(op==='<'){if(s<a[i])return a[i+1]}}return a[a.length-1];};const or=(a,...b)=>{for(let i=0;i<b.length;i++)if(a==b[i])return true;return false};const maxindex=(...a)=>{return a.indexOf(Math.max.apply(null,a))};const asc=(ar:number[])=>{return ar.sort((a,b)=>{return a-b})};const desc=(ar:number[])=>{return ar.sort((a,b)=>{return b-a})};const ceil=a=>{return Math.ceil(a)};const srin=s=>{const a:string[]=[];rep(s,()=>a.push(sin()));return a};let ssinteger=-1;const ssin=()=>{ssinteger++;return input[0][ssinteger]};
const main = ()=>{
  let [a,b,c]=nrin(3)
  out(a<=c&&a+b>=c?'YES':'NO')
}
main()
//  [typescript]
import * as fs from 'fs';

namespace AtCoder.abc094 {

    export class Program {
        args: string[];

        constructor(args: string[]) {
            this.args = args;
        }

        /**
         * in
         *
         * out
         *
         */
        main(this: Program): void {
            const [a, b, x]: number[] = this.args[0].split('\n').map(Number);
            if (a > x) {
                console.log('NO')
            } else if (a + b < x) {
                console.log('NO');
            } else {
                console.log('YES');
            }
        }
    }
}

const args = fs.readFileSync('/dev/stdin', 'utf8').trim().split('\n');
const prg = new AtCoder.abc094.Program(args);
prg.main();
//  [typescript]
function Main(input: string) {
  const lines: string[] = input.split('\n');
  const params = lines[0].split(' ');

  const a = parseInt(params[0]); // 猫（既知）
  const b = parseInt(params[1]);
  const x = parseInt(params[2]);

  const n = x - a;

  let flag = false;
  for (let i = 1; i <= b; i++) {
    if (i === n) {
      flag = true;
      break
    }
  }

  const msg = flag ? 'YES' : 'NO';
  
  console.log(msg);
}

Main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [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 sw=(s,a:any[],op:'=='|'>='|'>'|'<='|'<'='==')=>{for(let i=0;i<a.length;i+=2){if(op==='=='){if(s==a[i])return a[i+1]}else if(op==='>='){if(s>=a[i])return a[i+1]}else if(op==='<='){if(s<=a[i])return a[i+1]}else if(op==='>'){if(s>a[i])return a[i+1]}else if(op==='<'){if(s<a[i])return a[i+1]}}return a[a.length-1];};const or=(a,...b)=>{for(let i=0;i<b.length;i++)if(a==b[i])return true;return false};const maxindex=(...a)=>{return a.indexOf(Math.max.apply(null,a))};const asc=(ar:number[])=>{return ar.sort((a,b)=>{return a-b})};const desc=(ar:number[])=>{return ar.sort((a,b)=>{return b-a})};const ceil=a=>{return Math.ceil(a)};const srin=s=>{const a:string[]=[];rep(s,()=>a.push(sin()));return a};let ssinteger=-1;const ssin=()=>{ssinteger++;return input[0][ssinteger]};
const main = ()=>{
  let [a,b,c]=nrin(3)
  out(a<=c&&a+b<=c?'YES':'NO')
}
main()
//  [python]
N = int(input())
if N%2==0:print(0.5)
else:
  print((N+1)/2/N)
//  [python]
N = int(input())
print((N-N//2)/N)
//  [python]
n = int(input())
if n%2==0:
  print(0.5)
else:
  a = (n+1)//2
  print(a/n)
//  [python]
n=int(input())

if n%2==0:
    print(1/2)
else:
    print((n-1)/(2*n))
//  [python]
n=float(input())

print((n-n/2)/n if n%2==0 else 0.5000000000)
//  [python]
n=int(input())

print((n-n/2)/n if n%2==0 else 1/2)
//  [java]
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main {

	public static void main(String[] args) throws IOException, Exception{
		BufferedReader st = new BufferedReader(new InputStreamReader(System.in));
		int n = getInt(st);
		double ans = 0;
		if (n == 1) {
			ans = 1;
		} else if(n % 2 == 0) {
			ans = 0.50d;
		} else {
			ans = n/2 + 1;
			ans = ans/n;
		}
		System.out.println(ans);
	}

	private static int getInt(BufferedReader st) throws Exception, IOException {
		int num = Integer.parseInt(st.readLine());
		return num;
	}
}
//  [java]
import java.io.*;

public class Main {
    public static void main(String[] args) throws Exception {
        // 入力
        MyScanner sc = new MyScanner(System.in);
        double N = sc.nextInt();

        // 初期化
        double ans;

        // 主処理
        // 奇数を数える
        int odd_cnt = 0;
        for (int i = 1; i <= N; i++) {
            odd_cnt = i % 2 == 1 ? odd_cnt+1 : odd_cnt;
        }
        // 奇数である確率を計算
        ans = odd_cnt / N;

        // 出力
        System.out.println(ans);
    }

    static class MyScanner {
        BufferedReader br;
        // 標準入力から入力値を取得
        MyScanner(InputStream in) {
            br = new BufferedReader(new InputStreamReader(in));
        }
        // 標準入力を文字列で取得
        public String nextString() throws IOException {
            return br.readLine();
        }
        // 標準入力を文字列の配列で取得
        public String[] nextStringArray() throws IOException {
            return nextString().split(" ");
        }
        // 標準入力を数値で取得
        public int nextInt() throws IOException {
            return Integer.parseInt(nextString());
        }
        // 標準入力を数値の配列で取得
        public int[] nextIntArray() throws IOException {
            String[] strArr = nextStringArray();
            int[] intArr = new int[strArr.length];
            for(int i = 0; i < strArr.length; i++) {
                intArr[i] = Integer.parseInt(strArr[i]);
            }
            return intArr;
        }
        // 標準入力を数値で取得
        public long nextLong() throws IOException {
            return Long.parseLong(nextString());
        }
        // 標準入力を数値の配列で取得
        public long[] nextLongArray() throws IOException {
            String[] strArr = nextStringArray();
            long[] intArr = new long[strArr.length];
            for(int i = 0; i < strArr.length; i++) {
                intArr[i] = Long.parseLong(strArr[i]);
            }
            return intArr;
        }
    }

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

public class Main {
	public static void main(String[] args){
		Scanner stdIn = new Scanner(System.in);
		double N = stdIn.nextDouble();
		double ans = 0;
		if(N % 2 == 0){
			ans = 2.0 / N;
		}
		else{
			ans = ((int)N / 2 + 1) / N;
		}
		System.out.printf("%.10f",ans);

		stdIn.close();
	}
}
//  [java]
import java.util.Scanner;

public class A{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int N = sc.nextInt();
        if(N % 2 == 0){
            System.out.println(0.5);
        }else{
            System.out.println((double) (N + 1) / 2 / N);
        }

    }
}
//  [cpp]
#include <cstdio>
using namespace std;
int N; double t, ans;
int main() {
    scanf("%d", &N);
    t = N/2+N%2;
    printf("%lf\n", t/N);
}
//  [cpp]
#include <stdio.h>

int main(void){
	int num;

	scanf("%d", &num);

	if(num%2 == 0){
		printf("%.10f\n", 0.5);
	}else{
		printf("%.10f\n", ((num+1)/2.0)/num);
	}
	return 0;
}
//  [cpp]
#include <iostream>
#include <cstdio>
using namespace std;

int main() {
  int n;
  cin >> n;
  double odd = (n + 1) / 2;
  printf("%.14f\n", odd / n);
  return 0;
}
//  [cpp]
#include<iostream>
#include<iomanip>
using namespace std;
main()
{
   double x,y,z;
   int n;
   cin>>n;
   if(n%2==0)
   {
       x=2.0/n;
       cout<<fixed<<setprecision(10)<<x<<endl;
   }
   else
    {
        y=(n+1)/2;
        z=y/n;
   cout<<fixed<<setprecision(10)<<z<<endl;
}

return 0;
   }
//  [cpp]
#include<iostream>
#include<iomanip>
using namespace std;
main()
{
   double x,y,z;
   int n;
   cin>>n;
   if(n%2==0)
   {
       x=2.0/n;
       cout<<fixed<<setprecision(10)<<x<<endl;
   }
   else
    {
        y=(n+1)/2;
        z=y/n;
   cout<<fixed<<setprecision(10)<<z<<endl;
}


   }
//  [cpp]
#include<iostream>
#include<iomanip>
using namespace std;
int main()
{
   float x,y;
   int n;
   cin>>n;
   if(n%2==0)
    {
        x=2/n;
   cout<<fixed<<setprecision(10)<<x<<endl;
    }
    else
       {
           y=((n+1)/2);
           y=y/n;

    cout<<fixed<<setprecision(10)<<y<<endl;
       }
//  [c]
#include<stdio.h>

int main(){
	int N;
	scanf("%d",&N);
	double A=N;
	if(N%2==0){
	printf("0.5");
    }else{
    	printf("%f\n",(A+1)/2/A);
    }
    
	return 0;
}
//  [c]
#include <stdio.h>

int main(void) {
  int n;
  scanf("%d", &n);
  
  int i, cnt_odd = 0;
  for (i = 1; i <= n; ++i) {
    if (i % 2) ++cnt_odd;
  }
  
  printf("%lf\n", (double)cnt_odd / n);
  
  return 0;
}
//  [c]
main(n){scanf("%d",&n);printf("%f",-~n/2*1./n);}
//  [c]
#include<stdio.h>

int main(void){
  int a;
  scanf("%d",&a);
  int b=(a+1)/2;
  double c=(double)b/a
  printf("%f\n",c);
  return 0;
}
//  [c]
#include<stdio.h>

int main(void){
  int a;
  scanf("%d",&a);
  printf("%f\n",(a+1)/2/a);
  return 0;
}
//  [c]
#include <stdio.h>
int main(void)
{
  int N;
  scanf ("%d",&N);
  double M;
  M=(double) N;
  if (N%2==0) printf ("%f",1/2);
  else printf ("%f",(((M-1)/2)+1)/M);
//  [javascript]
function main(arg) {
	arg = arg.trim();
  	arg = parseInt(arg, 10);
	console.log(((Math.round(arg/2))/arg).toFixed(9))
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [javascript]
function Main(input) {
    var nums = Number(input);
    var cnt = 0;
    for(var i = 1;i <= nums;i++){
      if(i % 2 !== 0) {
        cnt++;
      }
    }
    console.log(cnt / nums);
 }
 
/* var input = `4`;
Main(input);
 */  
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
'use strict'
const main = input => {
  const z = parseInt(input[0], 10);
  console.log(Math.ceil(z/2)/z);
}
main(require("fs").readFileSync("/dev/stdin", "utf8").split('\n'));
//  [javascript]
function Main(input) {
    
    var data = input.split("\n");
    var n = parseInt(data[0]);
    var ans;
    if(n%2==0){
        ans = 0.5;
    }else{
        ans = (n+1)/2/n;
    }
    
    console.log('%f\n',ans);
}
//（標準入出力から一度に読み込み、Mainを呼び出します）
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
function Main(input) {
    
    var data = input.split("\n")
    var n = parseInt(data[0]);
    var ans;
    if(n%2==0){
        ans = 0.5;
    }else{
        ans = (n+1)/2/n;
    }
    
    console.log('%f\n',ans);
}
//（標準入出力から一度に読み込み、Mainを呼び出します）
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
function Main(input) {
    
    var data = input.split("\n")
    var n = parseInt(data[0]);
    var ans;
    if(n%2==0){
        ans = 0.5;
    }else{
        ans = (n+1)/2/n
    }
    
    console.log('%f\n',ans);
}
//（標準入出力から一度に読み込み、Mainを呼び出します）
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [go]
package main

import "fmt"

func main(){
	var N int ;
	var gu, ki float64
	fmt.Scan(&N);

	for i := 1 ; i <= N ; i++ {
		if i % 2== 0{
			gu++;
		}else {
			ki++;
		}
	}
	fmt.Println(float64(ki / (ki+gu)));
}
//  [go]
package main

import(
  "fmt"
)

func main() {
  var N int
  fmt.Scan(&N)
  if N % 2 == 0 {
    fmt.Println(0.5)
  } else {
    fmt.Println(((float64(N)-float64(1))/float64(2)+float64(1))/float64(N))
  }
}
//  [go]
package main

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

func main() {
	scanner := bufio.NewScanner(os.Stdin)

	scanner.Scan()

	N, err := strconv.Atoi(scanner.Text())
	if err != nil {
		log.Fatal(err)
	}

	if N%2 == 0 {
		fmt.Println(float32((N / 2)) / float32(N))
	} else {
		fmt.Println(float32(((N - 1) / 2)) / float32(N))
	}
}
//  [go]
package main

import "fmt"

func main() {
	var n int
	var r float64

	fmt.Scan(&n)

	if n%2 == 0 {
		r = float64(n / 2)
	} else {
		r = float64((n+1)/2) / float64(n)
	}

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

import "fmt"

func main() {
	var n int
	var r float32

	fmt.Scan(&n)

	if n%2 == 0 {
		r = n / 2
	} else {
		r = float32((n+1)/2) / n
	}

	fmt.Println(r)
}
//  [ruby]
N= gets.strip.to_f

if N%2==0
	puts 0.5
else
	puts ((N+1)/2)/(N)

end
//  [ruby]
N=gets.to_i
puts N.even? ? 0.500000 : (1+N/2)/N.to_f
//  [ruby]
N = gets.to_i
odds = (N.even? ? N/2 : N/2+1)
p odds / N.to_f
//  [ruby]
n=gets.to_i
p (n+1)/2.0/n
//  [ruby]
n=gets.to_f
if n==1
  puts 1.000
elsif n%2==0
  puts 0.5
else
  puts 0.6
end
//  [ruby]
n=gets.to_i
cnt=0
(0...n).each do |i|
  if i%2==1
    cnt=cnt.succ
  end
end
p cnt/n.to_f
//  [rust]
use proconio::input;
use proconio::marker::Chars;
fn main() {
    input!{
        n:usize
    };
    println!("{}", ((n+1)/2) as f32 / n as f32);
}
//  [rust]
use std::io;

fn main() {
	let mut buf = String::new();
	io::stdin().read_line(&mut buf).expect("");
	let n = match buf.trim().parse::<i32>() {
		Ok(n) => n,
		_ => panic!(""),
	};
	let all = n / 2 + n%2;
	println!("{}", all as f32 / n as f32);
}
//  [rust]
#[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)*}
    };
}

#[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, chars) => {
        read_value!($next, String).chars().collect::<Vec<char>>()
    };

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

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

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

fn f(s: &[char]) -> bool {
    let m = s.len();
    for i in 0..m {
        if s[i] != s[m - 1 - i] {
            return false;
        }
    }
    true
}

use std::iter::Iterator;

fn main() {
    input! {
        n : i64
    }

    let mut  num = n / 2;
    if n % 2 == 1 {
        num = num + 1;
    }

    println!("{}", num as f64 / n as f64)




}
//  [rust]
use std::io::Read;

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

    let answer = solve(&buf);

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

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

    let n: usize = iterator.next().unwrap().parse().unwrap();
    let odd: usize = n / 2 + n % 2;
    let ans: u64 = odd as f64 / n as f64;
    return ans.to_string();
}
//  [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! {
    	n:isize
    }
    
    println!("{}", a(n));
}

fn a(n:isize) -> f32 {
match n {
1 => 1.0,
2 => 0.5,
3 => 0.66666666666666666,
_ => if n%2==1 { ((n as f32)+1.0)/2.0/n } else { 0.5 }
}}
//  [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! {
    	n:isize
    }
    
    println!("{}", a(n));
}

fn a(n:isize) -> f32 {
match n {
1 => 1.0,
2 => 0.5,
3 => 0.66666666666666666,
_ => if n%2==1 { (n+1.0)/2.0/n } else { 0.5 }
}}
//  [swift]
import Foundation

let num = Float(readLine()!)!

if num % 2 == 0 {
  print(0.5)
} else {
  let halfNum = Float((num + 1) / 2)
  print(halfNum/num)
}
//  [swift]
let N = Int(readLine()!)!
print(Double(N/2+N%2)/Double(N))
//  [swift]
func readInts() -> [Int] {
    return readLine()!.split(separator: " ").map { Int($0)! }
}
let a = readInts()
let b = a[0]
var c = b/2
if b%2 != 0 { 
  c += 1
}
print(Double(c)/Double(b))
//  [swift]
import Foundation
 
let input_line: String = readLine()!
let split: [String] = input_line.components(separatedBy: " ")
 
var N = Double(split[0])!

if (Int(N)%2==0){
    print(1/2)
}else{
    print((N+1)/(2*N))
}
//  [swift]
import Foundation
 
let input_line: String = readLine()!
let split: [String] = input_line.components(separatedBy: " ")
 
var N = Double(split[0])!

if (Int(N)%2==0){
    print(Double(1/2))
}else{
    print(Double((N+1)/(2*N)))
}
//  [swift]
import Foundation
 
let input_line: String = readLine()!
let split: [String] = input_line.components(separatedBy: " ")
 
var N = Double(split[0])!

if (N%2==0){
    print(Double(1/2))
}else{
    print(Double((N+1)/(2*N)))
}
//  [typescript]
import * as fs from 'fs'
const reader = (s: string) => parseInt(s, 10)

function Main(input: string) {
  const N = reader(input)

  console.log(N % 2 === 0 ? 0.5 : 1 - (N - 1) / 2 / N)
}

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

//in
// 4
//out
// 0.5
const main = (inp: string) => {

    const n = parseInt(inp);

    if (n % 2 === 0) {
        console.log(n / 2 / n);
    } else {
        console.log((n + 1) / 2 / n);
    }
};

main(fs.readFileSync('/dev/stdin', 'utf8').trim());
//  [typescript]
function Main(input) {
  let n = parseInput(input)[0][0];
  console.log(Math.ceil(n/2) / n);
}

function parseInput(input) {
  const lines = input.trim().split('\n');
  return lines.map(line => line.split(' '));
}

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

//in
// 4
//out
// 0.5
const main = (inp: string) => {

    const n = parseInt(inp);

    if (n % 2 === 0) {
        console.log(n / 2);
    } else {
        console.log((n + 1) / 2);
    }
};

main(fs.readFileSync('/dev/stdin', 'utf8').trim());
//  [typescript]
function main(input) {
  const fline: string = input.split('\n')[0];
  const sline: string[] = input.split('\n')[1].split(' ');
  const n: number = parseInt(fline.split(' ')[0], 10);
  const k: number = parseInt(fline.split(' ')[1], 10);
  const h: number[] = sline.map(x => parseInt(x, 10));
  
  let ans: number = 0;
  h.forEach(function(el) {
    if (el >= k) ans += 1;
  });
  console.log(ans);
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [typescript]
import * as fs from 'fs'
const reader = (s: string) => parseInt(s, 10)

function Main(input: string) {
  const N = reader(input)

  console.log(N !== 1 ? 1 - 2 / N : 1)
}

Main(fs.readFileSync('/dev/stdin', 'utf8'))
//  [python]
n,m=map(int,input().split())
a=list(map(int,input().split()))
a.sort(reverse=True)
c=0
while c<m:
  d=a[0]/2
  for i in range(n):
    if a[0]==0:
      c=m
    if a[i]>d:
      a[i]//=2
      c+=1
      if c==m:
        break  
    else:
      a.sort(reverse=True)
      break
print(sum(a))
//  [python]
N,M=map(int,input().split())
*A,=map(int,input().split())
A=sorted(A)

while M:
    A[-1]//=2
    M-=1
    i=-2
    while M and (-N<=i and A[i]>=A[-1]):
        A[i]//=2
        M-=1
        i-=1
    A.sort()

print(sum(A))
//  [python]
n,m = map(int,input().split())
a = sorted(map(int,input().split()))

import bisect

for i in range(m):
    a[-1] //= 2
    
    if 1 < len(a):
        if a[-2] > a[-1]:
            bisect.insort(a,a[-1])
            a = a[:-1]
    
print(sum(a))
//  [python]
n,m = map(int,input().split())
a = sorted(map(int,input().split()))

for i in range(m):
    a[-1] //= 2
    
    if 1 < len(a) and a[-2] > a[-1]:
        a = sorted(a)
    
print(sum(a))
//  [python]
n,m = map(int,input().split())
a = sorted(map(int,input().split()))

for i in range(m):
    a[-1] //= 2
    
    if a[-2] > a[-1]:
        a = sorted(a)
    
print(sum(a))
//  [java]
import java.io.IOException;
import java.io.InputStream;
import java.util.InputMismatchException;
import java.util.PriorityQueue;

public class Main {

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

	static class Task {
		static final long MOD = (long) 1e9 + 7;

		public void solve() {
			Scan sc = new Scan();
			int n = (int) sc.scanLong();
			int m = (int) sc.scanLong();
			PriorityQueue<Integer> pq = new PriorityQueue<>();
			for (int i = 0; i < n; ++i) {
				pq.add(-1 * (int) sc.scanLong());
			}
			for (int i = 0; i < m; ++i) {
				int min = pq.poll();
				min /= 2;
				pq.add(min);
			}
			long res = 0;
			for (int el : pq) {
				res += -1 * el;
			}
			System.out.println(res);
		}
	}

	static class Scan {
		private byte[] buf = new byte[1024];
		private int index;
		private InputStream in;
		private int total;

		public Scan() {
			in = System.in;
		}

		public int scan() {
			if (total < 0)
				throw new InputMismatchException();
			if (index >= total) {
				index = 0;
				try {
					total = in.read(buf);
				} catch (IOException e) {
					throw new RuntimeException(e);
				}
				if (total <= 0)
					return -1;
			}
			return buf[index++];
		}

		public long scanLong() {
			long integer = 0;
			int n = scan();
			while (isWhiteSpace(n))
				n = scan();
			int neg = 1;
			if (n == '-') {
				neg = -1;
				n = scan();
			}
			while (!isWhiteSpace(n)) {
				if (n >= '0' && n <= '9') {
					integer *= 10;
					integer += n - '0';
					n = scan();
				} else
					throw new InputMismatchException();
			}
			return neg * integer;
		}

		public double scanDouble() throws IOException {
			double doub = 0;
			int n = scan();
			while (isWhiteSpace(n))
				n = scan();
			int neg = 1;
			if (n == '-') {
				neg = -1;
				n = scan();
			}
			while (!isWhiteSpace(n) && n != '.') {
				if (n >= '0' && n <= '9') {
					doub *= 10;
					doub += n - '0';
					n = scan();
				} else
					throw new InputMismatchException();
			}
			if (n == '.') {
				n = scan();
				double temp = 1;
				while (!isWhiteSpace(n)) {
					if (n >= '0' && n <= '9') {
						temp /= 10;
						doub += (n - '0') * temp;
						n = scan();
					} else
						throw new InputMismatchException();
				}
			}
			return doub * neg;
		}

		public String scanString() {
			StringBuilder sb = new StringBuilder();
			int n = scan();
			while (isWhiteSpace(n))
				n = scan();
			while (!isWhiteSpace(n)) {
				sb.append((char) n);
				n = scan();
			}
			return sb.toString();
		}

		public char scanChar() {
			int n = scan();
			while (isWhiteSpace(n))
				n = scan();
			return (char) n;
		}

		private boolean isWhiteSpace(int n) {
			if (n == ' ' || n == '\n' || n == '\r' || n == '\t' || n == -1)
				return true;
			return false;
		}
	}
}