jiahuimbzuai/CoQuIR huggingface dataset:
//  [cpp]
#include "bits/stdc++.h"

#define REP(i, n, N) for(ll i=(n); i<(N); i++)
#define RREP(i, n, N) for(ll i=(N-1); i>=(n); i--)
#define LREP(lst,itr) for(auto itr = lst.begin(); itr != lst.end(); ++itr)
#define CK(n, a, b) ((a)<=(n)&&(n)<(b))
#define ALL(v) (v).begin(),(v).end()
#define MCP(a, b) memcpy(b,a,sizeof(b))
#define P(s) cout<<(s)<<endl
#define P2(a, b) cout<<(a)<<" "<<(b)<<endl
#define P3(a, b, c) cout<<(a)<<" "<<(b)<<" "<<(c)<<endl
#define V2(T) vector<vector<T>>
typedef long long ll;
using namespace std;
const ll MOD = 1e9 + 7;
const ll INF = 1e18;

int main(){
    ll A, B, K;
    cin >> A >> B >> K;
    if((A-K)>=0){
        P(A-K);
    }else{
        K = max(A+B-K, (ll)0);
        P(K);
    }
    return 0;
}
//  [c]
#include<stdio.h>
int main()
{
long a,b,k;
scanf("%ld %ld %ld",&a,&b,&k);
if(a>=k)
printf("%ld %ld",a-k,b);
else if(a+b<=k)
printf("0 0");
else printf("0 %ld",a+b-k);
    printf("\n");
    return 0;
}
//  [c]
#include <stdio.h>

int main(void)
{

    unsigned long l_havingCookieCountOfTakahashi;
    unsigned long l_havingCookieCountOfAoki;
    unsigned long l_repeatCount;

    scanf("%ld%ld%ld", &l_havingCookieCountOfTakahashi, &l_havingCookieCountOfAoki, &l_repeatCount);

    if (l_havingCookieCountOfTakahashi > l_repeatCount)
    {
        l_havingCookieCountOfTakahashi -= l_repeatCount;
    }
    else if (l_havingCookieCountOfTakahashi == l_repeatCount)
    {
        l_havingCookieCountOfTakahashi = 0;
    }
    else
    {
        l_repeatCount -= l_havingCookieCountOfTakahashi;
        l_havingCookieCountOfTakahashi = 0;
        if (l_repeatCount <= l_havingCookieCountOfAoki)
        {
            l_havingCookieCountOfAoki -= l_repeatCount;
        }
        else
        {
            l_havingCookieCountOfAoki = 0;
        }
    }

    printf("%ld %ld", l_havingCookieCountOfTakahashi, l_havingCookieCountOfAoki);

}
//  [c]
#include<stdio.h>
int main()
{
	long long int a,b,k;
	scanf("%lld %lld %lld",&a,&b,&k);
	if(a>=k)
	{
		printf("%lld %lld",a-k,b);
	}
	else
	{
		if(b+a>=k)
		{		
			printf("0 %lld",b-k+a);
		}
		else
		{
			printf("0 0");
		}
	}
}
//  [c]
#include<stdio.h>

int main()
{
    long long int a,b,k;
    scanf("%lld %lld %lld",&a,&b,&k);
    if(k>a){

        b=b-(k-a);
        a=0;

    }
    else if(k<a){
        a=a-k;
        b=b;

    }
    else if(k==a){
        a=0;
        b=b;

    }
    else{
        a=a;
        b=b;


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

int main()
{
    long long int a,b,k;
    scanf("%lld %lld %lld",&a,&b,&k);
    if(k>a){

        b=b-(k-a);
        a=0;

    }
    else if(k<a){
        a=a-k;
        b=b;

    }
    else if(k==a){
        a=0;
        b=b;

    }
    else if(k==0){
        a=a;
        b=b;


    }
    printf("%lld %lld",a,b);
}
//  [c]
#include<stdio.h>
int main()
{
    long long int a,b,k;
    scanf ("%lld",&a);
    scanf ("%lld",&b);
    scanf ("%lld",&k);
    a=a-k;
    k=k-a;
    if (a<0)
    {
        a=0;
    }
    if (k>0 && b>0)
    {
        b=b-k;
        if (b<0)
        {
            b=0;
        }
    }
    printf ("%lld %lld\n",a,b);
}
//  [javascript]
'use strict';
function main(input) {
  const arr = input.trim().split(' ');
  const a = Number(arr[0]);
  const b = Number(arr[1]);
  const c = Number(arr[2]);

  if (a + b < c) {
    console.log('0','0');
  } else if (a < c) {
    console.log(`${0} ${a + b - c}`);
  } else {
    console.log(`${a - c} ${b}`);
  }
  
}

main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
function Main (input) {
  input = input.split("\n")[0].split(" ").map(Number);
  var A = input[0];
  var B = input[1];
  var K = input[2];
  A -= K;
  if (A < 0) {
    B -= Math.abs(A);
    A = 0;
  }
  if (B < 0) {
    B = 0;
  }
  console.log("%d %d", A, B);
}

Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
function Main (input) {
    input = input.split("\n");
    tmp = input[0].split(" ");
    var a = parseInt(tmp[0], 10);
    var b = parseInt(tmp[1], 10);
    var k = parseInt(tmp[2], 10);
    //console.log(input[0]);
    //console.log(a);
    if (a >= k) {
        console.log('%d %d', a - k, b);
    } else if(b>=k-a){
        console.log('%d %d', 0, b - (k - a));
    } else {
        console.log('%d %d', 0, 0);
    }
  }
   
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//ctrl+Dで入力終
//  [javascript]
'use strict';
function main(input) {
  const arr = input.trim().split(' ');
  const a = Number(arr[0]);
  const b = Number(arr[1]);
  const c = Number(arr[2]);

  if (a < c) {
    console.log(`${0} ${a + b - c}`);
  } else if (a + b < c) {
    console.log('0 0');
  } else {
    console.log(`${a - c} ${b}`);
  }
  
}

main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
'use strict';
function main(input) {
  const arr = input.trim().split(' ');
  const a = Number(arr[0]);
  const b = Number(arr[1]);
  const c = Number(arr[2]);

  if (a <= c) {
    console.log(`${0} ${a + b - c}`);
  } else {
    console.log(`${a - c} ${b}`);
  }
  
}

main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
'use strict';
function main(input) {
  const arr = input.trim().split(' ');
  const a = Number(arr[0]);
  const b = Number(arr[1]);
  const c = Number(arr[2]);

  if (a < c) {
    console.log(`${0} ${a + b - c}`);
  } else {
    console.log(`${a - c} ${b}`);
  }
  
}

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

import "fmt"

func main(){
	var A, B, K int64;

	fmt.Scan(&A, &B, &K);

	if A >=1{
		if A - K <= 0 {
			B += A-K
			if B < 0{
				B = 0;
			}
			A = 0;
		}else {
			A -= K;
		}
	}else if B >= 1 {
		if B - K > 0{
			B -= K
		}else {
			B = 0
		}
	}
	fmt.Println(A, B);
}
//  [go]
package main

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

func main() {
	var a, b, k int
	sc.nextInts(&a, &b, &k)
	a, b = max(a-k, 0), max(min(b-(k-a), b), 0)
	fmt.Printf("%d %d\n", a, b)
}

type scanner struct {
	sc *bufio.Scanner
}

var sc *scanner

func init() {
	s := bufio.NewScanner(os.Stdin)
	s.Split(bufio.ScanWords)
	sc = &scanner{sc: s}
}

func (s *scanner) nextInts(ints ...*int) {
	for i := range ints {
		s.sc.Scan()
		*ints[i], _ = strconv.Atoi(s.sc.Text())
	}
}

func (s *scanner) nextStr() string {
	s.sc.Scan()
	return s.sc.Text()
}

func min(a, b int) int {
	if a < b {
		return a
	}
	return b
}

func max(a, b int) int {
	if a > b {
		return a
	}
	return b
}

func abs(a int) int {
	if a < 0 {
		return -a
	}
	return a
}
//  [go]
package main

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

//Util
func nextStr() 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 maxInt(a, b int) int {
	if a > b {
		return a
	} else {
		return b
	}
}

func minInt(a, b int) int {
	if a > b {
		return b
	} else {
		return a
	}
}

func absInt(a int) int {
	if a >= 0 {
		return a
	} else {
		return -a
	}
}

func absFloat64(a float64) float64 {
	if a >= 0 {
		return a
	} else {
		return -a
	}
}

func maxFloat64(a, b float64) float64 {
	if a > b {
		return a
	} else {
		return b
	}
}

func minFloat64(a, b float64) float64 {
	if a > b {
		return b
	} else {
		return a
	}
}

func str2Int(s string) int {
	n, _ := strconv.Atoi(s)
	return n
}

func reverse(s string) string {
	runes := []rune(s)
	for i, j := 0, len(runes)-1; i < j; i, j = i+1, j-1 {
		runes[i], runes[j] = runes[j], runes[i]
	}
	return string(runes)
}

func pow(p, q int) int {
	return int(math.Pow(float64(p), float64(q)))
}

//Main
const (
	initialBufSize = 10000
	maxBufSize     = 1000000
	mod            = 1e9 + 7
)

var (
	sc *bufio.Scanner = func() *bufio.Scanner {
		sc := bufio.NewScanner(os.Stdin)
		buf := make([]byte, initialBufSize)
		sc.Buffer(buf, maxBufSize)
		return sc
	}()
)

var a, b, k int

func main() {
	sc.Split(bufio.ScanWords)
	a, b, k = nextInt(), nextInt(), nextInt()

	fmt.Printf("%d %d\n", maxInt(0, a-k), maxInt(0, minInt(b, b+a-k)))
}
//  [go]
package main

import "fmt"

func main() {
	var a, b, k int
	fmt.Scan(&a, &b, &k)
	for i:=0; i<k; i++{
		if a>=1 {
			a--
		}else if b >=1{
			b--
		}

		if a==0 && b == 0{
			break
		}
	}
	fmt.Println(a, b)
}
//  [go]
package main

import "fmt"

func main() {
	var a, b, k int
	fmt.Scan(&a, &b, &k)
	for i:=0; i<k; i++{
		if a>=1 {
			a--
		}else if b >=1{
			b--
		}
	}
	fmt.Println(a, b)
}
//  [ruby]

a,b,k = gets.split.map(&:to_i)
if a >= k
  puts "#{a-k} #{b}"
elsif (a+b) <= k
  puts "#{0} #{0}"
else
  puts  "#{0} #{b-(k-a)}"
end
//  [ruby]
A, B, K = gets.chomp.split.map(&:to_i)
puts "#{[A-K, 0].max} #{[B, [B+A-K, 0].max].min}"
//  [ruby]
line = gets.split(' ').map(&:to_i)

A = line[0]
B = line[1]
K = line[2]

if K < A then
  tak = A - K
  aok = B
elsif K < A + B then
  tak = 0
  aok = B - (K - A)
else
  tak = 0
  aok = 0
end
  
print tak.to_s + " " + aok.to_s
//  [ruby]
a,b,c=gets.split.map(&:to_i)
if a<c
  c-=a
  a=0
  p c
  if b<c
    b=0
  else
    b-=c
  end
else
  a-=c
end
puts [a,b].join ' '
//  [ruby]
a,b,c=gets.split.map(&:to_i)
if a<c
  a=0
  c-=a
  if b<c
    b=0
  else
    b-=c
  end
else
  a-=c
end
puts [a,b].join ' '
//  [ruby]
a, b, k = gets().chomp.split("\s").map{|x| x.to_i}

ar = a - k
ar = 0 if ar < 0

kr = k - a
br = b - kr
br = 0 if br < 0

puts "#{ar} #{br}"
//  [rust]
fn main() {
    let abk = read_vec::<u64>();
    let mut a = abk[0];
    let b = abk[1];
    let mut k = abk[2];

    if a > k {
        println!("{} {}", a-k, b);
        return
    }

    k -= a;
    a = 0;

    if b > k {
        println!("{} {}", a, b-k);
        return
    }

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

fn read_vec<T: std::str::FromStr>() -> Vec<T> {
    let mut s = String::new();
    std::io::stdin().read_line(&mut s).ok();
    s.trim().split_whitespace().map(|e| e.parse().ok().unwrap()).collect()
}
//  [rust]
macro_rules! input {
    (source = $s:expr, $($r:tt)*) => {
        let mut iter = $s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
    ($($r:tt)*) => {
        let mut 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")
    };
}

fn main(){
    input!{
        v: [u64; 3]
    }
    if v[0] > v[2] {print!("{} {}", v[0]-v[2], v[1])} else if v[0] + v[1] < v[2] {print!("0 0")} else {print!("0 {}",v[1]-(v[2]-v[0]))}
}
//  [rust]
use proconio::{fastout, input};
#[allow(unused_mut)]
#[fastout]
fn main() {
    input! {
        a: usize,
        b: usize,
        k: usize
    }
    if k <= a {
        println!("{} {}", k - a, b);
    } else if k <= a + b {
        println!("{} {}", 0, a + b - k);
    } else {
        println!("0 0")
    }
}
//  [rust]
use proconio::input;

fn main() {
    input! {
        a: usize,
        b: usize,
        k: usize,
    }

    solve(a, b, k);
}

fn solve(a: usize, b: usize, k: usize) {
    if a >= k {
        println!("{} {}", a - k, b);
        return;
    }
    println!("{} {}", 0, std::cmp::max(0, b - (k - a)));
}
//  [rust]
use proconio::{fastout, input};

#[fastout]
fn main() {
    input! {
        a: i128,
        b: i128,
        k: i128
    };

    let mut a = a;
    let mut b = b;
    let mut k = k;

    if a < k && a > 0 {
        k = k - a;
        a = 0;
        if b > 0 {
            b = b - k;
        }
    } else if a > 0 {
        a = k - a;
    } else if b > 0 {
        b = k - b;
    }

    println!("{} {}", a, b)
}
//  [swift]
let arr=readLine()!.characters.split{$0==" "}.map{Int(String($0))!}

var carry = 0
var tak = arr[0] - arr[2]
if( tak < 0 ) {
  carry = tak
  tak = 0
}

var aok = arr[1] + carry
if( aok < 0 ) {
  aok = 0
}
print(tak,aok)
//  [swift]
import Foundation

func readInts() -> [Int] {
    return readLine()!.split(separator: " ").map { Int($0)! }
}

func readStr() -> [String] {
  let str:String = readLine()!
  let arr:[String] = str.components(separatedBy: " ")
  return arr
}

let abk=readInts()
let a=abk[0]
var b=abk[1]
let k=abk[2]
let ak=max(0,a-k)
if(a<k) {b=max(0,a+b-k)}
print("\(ak) \(b)")
//  [swift]
func readInts() -> [Int] {
    return readLine()!.split(separator: " ").map { Int($0)! }
}
let abk=readInts()
var a=abk[0]
var b=abk[1]
var k=abk[2]
var rest=k
if a-k>=0{
  a-=k
}else{
  rest=k-a
  a=0
  if b-rest>=0{
    b-=rest
  }else{
    b=0
  }
}
print(a,b)
//  [swift]
func readInts() -> [Int] {
    return readLine()!.split(separator: " ").map { Int($0)! }
}
let abk=readInts()
var a=abk[0]
var b=abk[1]
var k=abk[2]
for _ in 1...k{
  if a>=1{
    a-=1
  }else if b>=1{
    b-=1
  }
}
print(a,b)
//  [swift]
let arr=readLine()!.characters.split{$0==" "}.map{Int(String($0))!}

var carry = 0
var tak = arr[0] - arr[2]
if( tak < 0 ) {
  carry = tak
  tak = 0
}

var aok = arr[1] + carry
print(tak,aok)
//  [typescript]
import * as fs from "fs";

const input = (fs.readFileSync("/dev/stdin", "utf8") as string).split("\n");
//const n = +input[0];
//const a = [];
//for(let i=0;i<n;i++){
//	a.push(input[i+1].split(" ").map((x:string):number=>+x));
//}

//const [n, m] = input[0].split(" ").map((x: string): number => +x);
//const a = input[1].split(" ").map((x: string): number => +x);


const [a, b, k] = input[0].split(' ').map((x : string) : number => +x);

let kk = k;
if (k <= a){
    console.log(a-k,b);
}else{
    if (k-a <= b){
        console.log(0,b-(k-a));
    }else{
        console.log(0,0);
    }
}
//  [typescript]
export class Main {
  static main(input: string): string {
    const tmp: string[] = input.split("\n");
    const [a, b, k]: number[] = tmp[0].split(" ").map(int => parseInt(int));
    return `${Math.max(a - k, 0)} ${k - a >= 0 ? Math.max(b - (k - a), 0) : b}`;
  }
}
console.log(Main.main(require("fs").readFileSync("/dev/stdin", "utf8")));
//  [typescript]
import * as fs from 'fs';

//in
// 2 3 3
//out
// 0 2

function main(inp: string) {
    let [a, b, k]: number[] = inp.split(' ').map(Number)
    if (k >= a) {
        k = k - a;
        a = 0;
    } else {
        a = a - k;
        k = 0;
    }

    if (k > 0) {
        if (k >= b) {
            b = 0;
        } else {
            b = b - k;
        }
    }

    // Too　late
    // for (let i = 0; i < k; i++) {
    //     if (a > 0) {
    //         a--;
    //         continue
    //     }
    //     if (b > 0) {
    //         b--
    //     }
    // }
    console.log(`${a} ${b}`);
}

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

//in
// 2 3 3
//out
// 0 2

function main(inp: string) {
    let [a, b, k]: number[] = inp.split(' ').map(Number)

    for (let i = 0; i < k; i++) {
        if (a > 0) {
            a--
            continue
        }
        if (b > 0) {
            b--
        }
    }
    console.log(`${a} ${b}`);
}

main(fs.readFileSync('/dev/stdin', 'utf8').trim());
//  [python]
def not_found_minchar(S):
    for o in range(ord('a'), ord('z') + 1):
        if chr(o) not in S:
            return chr(o)
    return "None"

S = raw_input()
print not_found_minchar(S)
//  [python]
s = input()
swi = 0
lst = ["a", "b", "c", "d", "e", "f", "g", "h", \
       "i", "j", "k", "l", "m", "n", "o", "p", \
       "q", "r", "s", "t", "u", "v", "w", "x", "y", "z"]

for i in range(26):
    if (lst[i] in s) == False:
        print(lst[i])
        swi = 1
        break
if swi == 0:
    print("None")
//  [python]
S = input()
ans = None
for letter in "abcdefghijklmnopqrstuvwxyz":
    if letter not in S:
        ans = letter
        break
print(ans)
//  [python]
S = sorted(list(set(list(input()))))
cf = [chr(ord("a")+i) for i in range(26)]

for i in range(len(S)):
    if S[i] != cf[i]:
        print(cf[i])
        exit()
print("None")
//  [python]
s = list(map(str,input()))
s.sort()
cnt = len(list(set(s)))

if cnt != 26:
    x = chr(ord(s[0]) + 1)
    print(x)

else:
    print("None")
//  [python]
s = list(map(str,input()))
s.sort()
cnt = len(list(set(s)))

if cnt == 26:
    print("None")
else:
    x = chr(ord(s[0]) + 1)
    print(x)
//  [java]
import java.io.*;
import java.util.*;

public class Main {
    public static void main(String[] args) throws Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String str = br.readLine();
        boolean array[] = new boolean[26];
        for(int i = 0;i < str.length();i++)
            array[str.charAt(i) - 'a'] = true;
        for(int i = 0;i < 26;i++){
            if(!array[i]){
                System.out.println((char)(i + 97));
                return;
            }
        }
        System.out.println("None");
    }
}
//  [java]
import java.util.*;
import java.io.*;

public class Main {
	
	public static void main(String[] args) throws IOException {
		InputReader in = new InputReader(System.in);
		int alphabets[] = new int[26];
		char arr[] = in.readString().toCharArray();
		for(int i = 0; i<arr.length; i++) {
			alphabets[arr[i]-'a'] = 1;
		}
		for(int i = 0; i<alphabets.length; i++) {
			if(alphabets[i] != 1) {
				System.out.println((char)(97 + i));
				return; 
			}
		}
		System.out.println("None");
	}
}
class InputReader {

	private InputStream stream;
	private byte[] buf = new byte[1024];
	private int curChar;
	private int numChars;
	private SpaceCharFilter filter;

	public InputReader(InputStream stream) {
		this.stream = stream;
	}

	public int read() {
		if (numChars == -1)
			throw new InputMismatchException();
		if (curChar >= numChars) {
			curChar = 0;
			try {
				numChars = stream.read(buf);
			} catch (IOException e) {
				throw new InputMismatchException();
			}
			if (numChars <= 0)
				return -1;
		}
		return buf[curChar++];
	}

	public int readInt() {
		int c = read();
		while (isSpaceChar(c))
			c = read();
		int sgn = 1;
		if (c == '-') {
			sgn = -1;
			c = read();
		}
		int res = 0;
		do {
			if (c < '0' || c > '9')
				throw new InputMismatchException();
			res *= 10;
			res += c - '0';
			c = read();
		} while (!isSpaceChar(c));
		return res * sgn;
	}

	public String readString() {
		int c = read();
		while (isSpaceChar(c))
			c = read();
		StringBuilder res = new StringBuilder();
		do {
			res.appendCodePoint(c);
			c = read();
		} while (!isSpaceChar(c));
		return res.toString();
	}

	public long readLong() {
		int c = read();
		while (isSpaceChar(c)) {
			c = read();
		}
		int sgn = 1;
		if (c == '-') {
			sgn = -1;
			c = read();
		}
		long res = 0;
		do {
			if (c < '0' || c > '9') {
				throw new InputMismatchException();
			}
			res *= 10;
			res += c - '0';
			c = read();
		} while (!isSpaceChar(c));
		return res * sgn;
	}
	
	public boolean isSpaceChar(int c) {
		if (filter != null)
			return filter.isSpaceChar(c);
		return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
	}

	public String next() {
		return readString();
	}

	public interface SpaceCharFilter {
		public boolean isSpaceChar(int ch);
	}
}
//  [java]

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Collections;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.PriorityQueue;
import java.util.Set;
import java.util.StringTokenizer;

public class Main {
  public static void main(String[] args) {
	  FastReader sc = new FastReader();
	  String s = sc.next();
	    int[] charCnt = new int[26];
	  	
	    for (char c: s.toCharArray()) {
	      charCnt[c - 'a']++;
	    }
	    
	    for (int i = 0; i < 26; i++) {
	      if (charCnt[i] == 0) {
	        System.out.println((char)(i + 'a'));
	        System.exit(0);
	      }
	    }
	    
	    System.out.println("None");
	    System.exit(0);
  }
  
  static class FastReader {
    BufferedReader br;
    StringTokenizer st;

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

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

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

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

    String nextLine() {
      String str = "";
        try{
            str = br.readLine();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return str;
      }
  }
}
//  [java]
import java.util.*;
public class Main {

    
    public static void main(String[] args) {
        Scanner input=new Scanner(System.in);
        String s;
        s=input.next();
        char a='a';
        int sum=0;
        int u=('z'-'a');
        boolean k=false;
        boolean m=false;
        char [] arr=new char[s.length()];
        for(int i=0;i<s.length();i++)
            arr[i]=s.charAt(i);
        for(int i=0;i<24;i++)
        {
            a=(char) ('a'+i);
            for(int p=0;p<s.length();p++)
            {
                if(a==arr[p])
                {
                    m=true;
                    break;
                }
            }
            if(m)
            {
                m=false;
                continue;
            }
            else {
                System.out.println(a);
                k=true;
                break;
            }
        }
        if(!k)
            System.out.println("None");
        
    }
    
}
//  [java]
import java.util.Scanner;
import java.util.Set;
import java.util.TreeSet;

public class Main {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		char[]c = sc.next().toCharArray();
		Set<Character>charset =new TreeSet<Character>();
		char[]alp = new char[] {'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z'};
		for (int i = 0; i < c.length; i++) {
			charset.add(c[i]);
		}

		for (int i = 0; i < charset.size(); i++) {
			if (!charset.contains(alp[i])) {
				System.out.println(alp[i]);
				break;
			}else if(i==alp.length-1){
				System.out.println("None");
			}
		}

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

public class Main {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		char[]c = sc.next().toCharArray();
		Set<Character>charset =new TreeSet<Character>();
		char[]alp = new char[] {'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z'};
		for (int i = 0; i < c.length; i++) {
			charset.add(c[i]);
		}

		for (int i = 0; i < c.length; i++) {
			if (c[i] != alp[i]) {
				System.out.println(alp[i]);
				break;
			}else if(i==alp.length-1){
				System.out.println("none");
			}
		}

	}
}
//  [cpp]
//
//  main.cpp
//  Atcoder Beginner Contest 071 B
//
//  Created by luras on 2017/8/20.
//  Copyright © 2017年 luras. All rights reserved.
//

#define ms(x, y) memset(x, y, sizeof(x))
#define mc(x, y) memcpy(x, y, sizeof(x))
#define lson o << 1, l, mid
#define rson o << 1 | 1, mid + 1, r
#define ls o << 1
#define rs o << 1 | 1
#include<stdio.h>
#include<string.h>
#include<math.h>
#include<queue>
#include<map>
#include<stack>
#include<vector>
#include<list>
#include<set>
#include<string>
#include<algorithm>
#pragma comment(linker,"/STACK:102400000,102400000")
template <class T> inline void gmax(T &a, T b){if(b > a) a = b;}
template <class T> inline void gmin(T &a, T b){if(b < a) a = b;}
using namespace std;
const int N = 1e5 + 10, M = 2e6 + 10, Z = 1e9 + 7, maxint = 2147483647, ms1 = 16843009, ms31 = 522133279, ms63 = 1061109567, ms127 = 2139062143;
const double PI = acos(-1.0), eps = 1e-8;
typedef long long LL;
void fre()
{
    freopen("/Users/luras/Desktop/in.txt", "r", stdin);
    freopen("/Users/luras/Desktop/out.txt", "w", stdout);
}
const int INF = 1e9;
int casenum, casei;

char s[N];
int a[30];

int main()
{
    while(~ scanf("%s", s)){
        int len = strlen(s);
        for(int i = 0; i < len; i ++){
            a[s[i] - 'a'] ++;
        }
        for(int i = 0; i < 26; i ++){
            if(a[i] == 0){
                printf("%c\n", i + 'a');
                return 0;
            }
        }
        puts("None");
    }
    return 0;
}

/*
 
 
 题意:
 
 类型:
 
 分析:
 
 优化:
 
 trick:
 
 数据:
 
 Sample Input
 
 Sample Output
 
 
 */
//  [cpp]
#include <iostream>
#include <vector>
#include <set>
#include <algorithm>
#include <list>
#include <cstring>
#include <map>
#include <queue>
#include <ctime>
#include <set>
#include <sstream>
#include <unordered_set>
#include <unordered_map>
#include <cmath>

#define pb push_back
#define mp make_pair
#define ll long long
#define IOS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define ull unsigned long long
#define iloop(a,b) for(ll i = a; i < b; ++i)
#define jloop(a,b) for(ll j = a; j < b; ++j)
#define sz(a) int((a).size()) 
#define pb push_back 
#define all(c) (c).begin(),(c).end() 
#define tr(c,i) for(typeofa((c).begin() i = (c).begin(); i != (c).end(); i++) 
#define present(c,x) ((c).find(x) != (c).end()) 
#define cpresent(c,x) (find(all(c),x) != (c).end()) 
#define p(a) cout << a << "\n";
#define p1(a) cout << a << " ";

#define PI 3.141592653589793
#define MOD (ll)(1e9 + 7)

using namespace std;
typedef vector<int> vi; 
typedef vector<vi> vvi; 
typedef pair<int,int> ii; 

void solve()
{
	string s;
	cin >> s;
	int si = s.length();
	int arr[26];
	memset(arr,0,sizeof(arr));
	iloop(0,si)
	{
		arr[s[i]-'a']++;
	}
	int flag = 0;
	iloop(0,26)
	{
		if(arr[i] == 0) 
		{
			++flag;
			p(char(i+(int)'a'))
			break;
		}
	}
	if(!flag)
		p("None")
}
int main()
{
	bool testing = false;
	IOS
	if(testing)
	{
		freopen("test.txt","rt",stdin);
		int start = clock();
		solve();
		int end = clock();
		cout << "time: " << (end - start)/(double)(CLOCKS_PER_SEC)*1000 << " milliseconds\n";
	}
	else
	{
		solve();
	}
}
//  [cpp]
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <cstring>
#include <cmath>
#include <list>
#define ll long long
using namespace std;
int main()
{
  ios_base::sync_with_stdio(0);
  string str;
  cin >> str;
  int arr[26]={0};
  for(int i=0;i<str.length();i++)
  {
    arr[str[i]-'a']++;
  }
  int index=-1;
  for(int i=0;i<26;i++)
  {
    if(arr[i]==0){
      index=i;
      break;
    }
  }
  if(index==-1)
    cout << "None" << endl;
  else
    cout << char(index+97) << endl;
  return 0;
}
//  [cpp]
#include <bits/stdc++.h>
using namespace std;
#define M 1000000007
long long int power(int a,int b)
{
    if(b==0)
        return 1;
    long long int k=power(a,b/2);
    if(b%2==0)
        return ((k%M)*(k%M))%M;
    else
        return ((k%M)*(k%M)*(a%M))%M;
}
long long int fact(long long int n)
{
    if(n==1 || n==0)
        return 1;
    else
        return ((n%M)*(fact(n-1)%M))%M;

}
int div(int n)
{  int c=0;
    for(int i=1;i<=sqrt(n);i++)
    {
        if(n%i==0)
        {
          if(n/i==i)
            c++;
          else
            c+=2;
        }

    }

    
    return  c;
}
int func(int n)
{
    return (n*(n+1))/2;
}
int main()
{
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
     #ifndef ONLINE_JUDGE
 
    freopen("input.txt","r",stdin);
    freopen("output.txt","w",stdout);
 
   #endif
   
   string str;
   cin>>str;
   set<char> s;
   for(int i=0;i<str.length();i++)
   {
      s.insert(str[i]);
   }
   if(s.size()==26)
    cout<<"None";
  else
  { int i=0;
    
    for(auto it=s.begin();it!=s.end();it++,i++)
    {
        if(*it!=97+i)
        {
            cout<<(char)(97+i);
            return 0;
        }
    }
  }


 return 0;
}
//  [cpp]
#include <bits/stdc++.h>
#define ll long long
#define vi vector<int>
#define e "\n"
#define MaRiaMa { ios::sync_with_stdio(0); cin.tie(0); cout.tie(0); }
#define fix(n) cout << fixed << setprecision(n)
using namespace std;
int main()
{
	MaRiaMa;
	set<char> c;
	int k = 0;
	string s;
	set<char> p;
	cin >> s;
	for (int i = 0; i < 26; i++)
	{
		c.emplace(char(97+i));
	}
	for (int i = 0; i < s.size(); i++)
	{
		p.emplace(s[i]);
	}
	auto l = c.begin();
	for (auto it = p.begin(); it != p.end()&&l != c.end(); it++)
	{
		if (*l != *it)
		{
			cout << *l;
			return 0;
		}
		l++;
	}
	cout << "None";
}
//  [cpp]
#include <bits/stdc++.h>
#define ll long long
#define vi vector<int>
#define e "\n"
#define MaRiaMa { ios::sync_with_stdio(0); cin.tie(0); cout.tie(0); }
#define fix(n) cout << fixed << setprecision(n)
using namespace std;
int main()
{
	MaRiaMa;
	char c[100];
	int k = 0;
	string s;
	set<char> p;
	cin >> s;
	for (int i = 0; i < s.size(); i++)
	{
		p.emplace(s[i]);
	}
	for (auto it = p.begin(); it != p.end(); it++)
	{
		c[k] = *it;
		k++;
	}
	for (int i = 0; i < s.size()-1; i++)
	{
		if (abs(int(c[i]) - int(c[i + 1])) != 1)
		{
			cout << char(c[i]+1);
			return 0;
		}
	}
	cout << "None";
}
//  [c]
#include <stdio.h>
#include <string.h>

int main(void){
   int alpha[26],i,n,t=0;
   char str[100000];

   scanf("%s",str);
   n=strlen(str);

   for(i=0;i<n;i++)
      alpha[str[i]-'a']=1;

   for(i=0;i<26;i++)
      t+=alpha[i];

   if(t==26){printf("None\n"); return 0;}

   for(i=0;i<n;i++)
      if(alpha[i]==0){printf("%c\n",'a'+i); return 0;}
   return 0;
}
//  [c]
#include<stdbool.h>

bool alp[26];
main(c){
        while((c=getchar())!='\n') alp[c-'a'] = true;
        for(int i=0; i<26; i++) if(!alp[i]) {
                putchar(i+'a');
                return 0;
        }
        puts("None");
        return 0;
}
//  [c]
#pragma target("avx")
#pragma optimize("O3")
#include<stdbool.h>

bool alp[26];
char c;

int main(){
        while((c=getchar())!='\n') alp[c-'a'] = true;
        for(int i=0; i<26; i++) if(!alp[i]) {
                putchar(i+'a');
                return 0;
        }
        puts("None");
        return 0;
}
//  [c]
#include <stdio.h>
int main()
{
  char s[100001];
  char a[256] = {0};
  scanf("%s",&s);
  int i = 0;
  while (s[i])
  {
    a[s[i]]++;
    i++;
  }
  i = 0;
  while (i < 256)
  {
    if (i >= 'a' && i <= 'z' && a[i] == 0)
    {
      printf("%c",i);
      return (0);
    }
    i++;
  }
  if (f == 0)
    printf("None");
}
//  [c]
#include <stdio.h>
int main()
{
  char s[100001];
  char a[256] = {0};
  scanf("%s",&s);
  int i = 0;
  while (s[i])
  {
    a[s[i]]++;
    i++;
  }
  i = 0;
  int f = 0;
  while (i < 256)
  {
    if (i >= 'a' && i <= 'z' && a[i] == 0)
    {
      f = 1;
      printf("%c",i);
    }
    i++;
  }
  if (f == 0)
    printf("None");
}
//  [c]
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

typedef long long ll;
typedef int keytype;

int gcd(int a, int b){ return (a % b) ? gcd(b, a % b) : b;}
int lcm(int a, int b){ return (a / gcd(a, b)) * b;}

void quicksort(keytype a[], int first, int last)
{
    int i, j;
    keytype x, t;

    x = a[(first + last) / 2];
    i = first;  j = last;
    for ( ; ; ) {
        while (a[i] < x) i++;
        while (x < a[j]) j--;
        if (i >= j) break;
        t = a[i];  a[i] = a[j];  a[j] = t;
        i++;  j--;
    }
    if (first  < i - 1) quicksort(a, first , i - 1);
    if (j + 1 < last) quicksort(a, j + 1, last);
}

int is_prime(int x){
    if(x <= 1) return 0;
    for(int i = 2; i * i <= x; i++){
        if(x % i == 0) return 0;
    }
    return 1;
}

int is_substr(char s[], char t[], int i){
    int flag = 1;

    if(s[i] == '\0') flag = 0;

    for(int j = 0; j < strlen(t); ++j, ++i){
        if(s[i] != t[j]){
            flag = 0;
            break;
        }
    }
    return flag;
}

// factor list, number of factors, natural number
void factorize(int ftr[], int *num, int n){
    int a = 2, cnt = 0;

    while(n >= a){
        if(n % a == 0){
            n = n / a;
            ftr[cnt++] = a;
        }else{
            a++;
        }
    }
    *num = cnt;
}

void comb(int size1, int size2, int v[size1][size2]){
  for(int i = 0; i < size1; i++){
    v[i][0] = 1;
    v[i][i] = 1;
  }
  for(int k = 1; k < size1; k++){
    for(int j = 1; j < k; j++){
      v[k][j] = (v[k-1][j-1] + v[k-1][j]);
    }
  }
}

int abs_val(int a, int b){
    if(a > b) return a - b;
    else return b - a;
}

int main(){
    char s[100001];

    scanf("%s", s);

    int flag = 0;
    char ans = 0;
    for(int i = 0; i < 25; ++i){
        for(int j = 0; j < strlen(s); ++j){
            if(s[j] == 'a' + i){
                flag = 0;
                break;
            }else{
                flag = 1;
            }
        }
        if(flag == 1){
            ans = 'a' + i;
            break;
        }
    }

    if(ans == 0) puts("None");
    else printf("%c\n", ans);

    return 0;
}
//  [javascript]
"use strict"

function Main(input) {
  input = input.trim();
  let alp = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']
  
  let ret = 'None';
  for(let i=0; i<26; i++){
    if(input.indexOf(alp[i]) === -1){
      ret = alp[i];
      break
    }
  }

  console.log(ret);
}
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
function Main(input){
  var S = input.replace(/\r?\n/g, '');
  var alphabet = 'abcdefghijklmnopqrstuvwxyz';
  var cha = 0;
  for(var i of alphabet){
    if(S.indexOf(i)==-1){
      cha=i;
      break;
    }
  }
  if(cha==''){
    console.log('None');
  }else{
    console.log(cha);
  }
}
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
"use strict";
    
const main = arg => {
    const S  = arg.split("\n")[0].split("");
    const alphabets = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "u", "v", "w", "x", "y", "z"];
    
    for(let i in alphabets) {
        if(S.indexOf(alphabets[i]) == -1) {
            console.log(alphabets[i]);
            return;
        }
    }
    
    console.log("None");
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [javascript]
function Main(input) {
  var s = new Set(input.split("\n")[0]);
  var t = "abcdefghijklmnopqrstuvwxyz"
  for (var i = 0; i < 26; i++) {
    if(!s.has(t[t])) {
      console.log(t[i]);
      return;
    }
  }
  console.log("None");
}
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
function Main(input) {
  var s = input.split("\n")[0];
  for (var i = "a".charCodeAt(0); i <= "z".charCodeAt(0);i++) {
    if(!s.has(String.fromCharCode(i))) {
      console.log(String.fromCharCode(i));
      return;
    }
  }
  console.log("None");
}
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [go]
package main

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

func solution(s string) string {
        var memo [26]int

        for _, r := range s {
                memo[r-'a']++
        }
        for i := range memo {
                if memo[i] == 0 {
                        return string(rune(i + 'a'))
                }
        }
        return "None"
}

func main() {
        var fp *os.File = os.Stdin
        reader := bufio.NewReaderSize(fp, 1024)
        s := readLine(reader)
        fmt.Println(solution(s))
}

func readLine(reader *bufio.Reader) string {
        buf := make([]byte, 0, 1024)

        for {
                l, p, _ := reader.ReadLine()

                buf = append(buf, l...)

                if !p {
                        break
                }
        }
        return string(buf)
}
//  [go]
package main

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

func main() {
	// sc.Split(bufio.ScanWords)
	t := make([]bool, 26)
	s := nextMega()
	for i := range s {
		t[s[i]-'a'] = true
	}
	for i := range t {
		if !t[i] {
			puts(string('a' + i))
			break
		}
		if i == len(t)-1 {
			puts("None")
		}
	}
	wt.Flush()
}

var (
	sc  = bufio.NewScanner(os.Stdin)
	rdr = bufio.NewReaderSize(os.Stdin, 1000000)
	wt  = bufio.NewWriter(os.Stdout)
)

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

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

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

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

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

func nextMega() string {
	buf := make([]byte, 0, 1000000)
	for {
		l, p, _ := rdr.ReadLine()
		buf = append(buf, l...)
		if !p {
			break
		}
	}
	return string(buf)
}

func putf(format string, a ...interface{}) {
	fmt.Fprintf(wt, format, a...)
}

func puts(a ...interface{}) {
	fmt.Fprintln(wt, a...)
}
//  [go]
package main

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

var reader = bufio.NewReader(os.Stdin)

func main() {
	s := nextLine()
	f := make([]bool, 26)
	for _, c := range s {
		f[c-97] = true
	}
	for i, e := range f {
		if !e {
			fmt.Println(string(i + 97))
			return
		}
	}
	fmt.Println("None")
	return
}

func nextLine() string {
	var buf, line []byte
	isPrefix := true
	var err error
	for isPrefix {
		buf, isPrefix, err = reader.ReadLine()
		if err != nil {
			panic(err)
		}
		line = append(line, buf...)
	}
	return string(line)

}
//  [go]
package main

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

var sc = bufio.NewScanner(os.Stdin)

func main() {
	scanInit()

	s := nextStr()

	c := 'a'

	for j := 0; j < 26; j++ {
		found := false
		for i := 0; i < len(s); i++ {
			if s[i] == byte(c) {
				found = true
				break
			}
		}
		if found == false {
			fmt.Println(string(c))
			return
		}
		c++
	}

	fmt.Println("None")

}

// ---- readfunc
func scanInit() {
	const cap = 64 * 1024
	var buf = make([]byte, cap)
	sc.Buffer(buf, cap)
	sc.Split(bufio.ScanWords)
	return
}
func nextInt() int {
	sc.Scan()
	i, e := strconv.Atoi(sc.Text())
	if e != nil {
		panic(e)
	}
	return i
}
func nextStr() string {
	sc.Scan()
	return sc.Text()
}
//  [go]
package main

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

var sc = bufio.NewScanner(os.Stdin)

func main() {
	scanInit()

	s := nextStr()

	c := 'a'

	for i := 0; i < 26; i++ {
		found := false
		for i := 0; i < len(s); i++ {
			if s[i] == byte(c) {
				found = true
				break
			}
		}
		if found == false {
			fmt.Println(string(c))
			return
		}
		c++
	}

	fmt.Println("None")

}

// ---- readfunc
func scanInit() {
	const cap = 64 * 1024
	var buf = make([]byte, cap)
	sc.Buffer(buf, cap)
	sc.Split(bufio.ScanWords)
	return
}
func nextInt() int {
	sc.Scan()
	i, e := strconv.Atoi(sc.Text())
	if e != nil {
		panic(e)
	}
	return i
}
func nextStr() string {
	sc.Scan()
	return sc.Text()
}
//  [go]
package main

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

//Util
func nextStr() 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 maxInt(a, b int) int {
	if a > b {
		return a
	} else {
		return b
	}
}

func minInt(a, b int) int {
	if a > b {
		return b
	} else {
		return a
	}
}

func absInt(a int) int {
	if a >= 0 {
		return a
	} else {
		return -a
	}
}

func absFloat64(a float64) float64 {
	if a >= 0 {
		return a
	} else {
		return -a
	}
}

func maxFloat64(a, b float64) float64 {
	if a > b {
		return a
	} else {
		return b
	}
}

func minFloat64(a, b float64) float64 {
	if a > b {
		return b
	} else {
		return a
	}
}

func str2Int(s string) int {
	n, _ := strconv.Atoi(s)
	return n
}

func reverse(s string) string {
	runes := []rune(s)
	for i, j := 0, len(runes)-1; i < j; i, j = i+1, j-1 {
		runes[i], runes[j] = runes[j], runes[i]
	}
	return string(runes)
}

func pow(p, q int) int {
	return int(math.Pow(float64(p), float64(q)))
}

func isPrime(x int) bool {
	if x == 1 {
		return false
	}
	if x == 2 {
		return true
	}
	if x%2 == 0 {
		return false
	}

	b := true
	rootx := int(math.Sqrt(float64(x)))
	i := 3
	for i <= rootx {
		if x%i == 0 {
			b = false
			break
		}
		i += 2
	}
	return b
}

func PrimeFactors(n int) (pfs []int) {
	// Get the number of 2s that divide n
	for n%2 == 0 {
		pfs = append(pfs, 2)
		n = n / 2
	}

	// n must be odd at this point. so we can skip one element
	// (note i = i + 2)
	for i := 3; i*i <= n; i = i + 2 {
		// while i divides n, append i and divide n
		for n%i == 0 {
			pfs = append(pfs, i)
			n = n / i
		}
	}

	// This condition is to handle the case when n is a prime number
	// greater than 2
	if n > 2 {
		pfs = append(pfs, n)
	}

	return
}

//Main
const (
	initialBufSize = 10000
	maxBufSize     = 1000000
	mod            = 1e9 + 7
)

var (
	sc *bufio.Scanner = func() *bufio.Scanner {
		sc := bufio.NewScanner(os.Stdin)
		buf := make([]byte, initialBufSize)
		sc.Buffer(buf, maxBufSize)
		return sc
	}()
)

var S string

func main() {
	sc.Split(bufio.ScanWords)

	fmt.Scan(&S)
	al := "abcdefghijklmnopqrstuvwxyz"

	sl := strings.Split(S, "")
	sort.Strings(sl)

	//fmt.Println(sl)
	j := 0
	for _, s := range sl {
		if s == string(al[j]) {
			j++
		} else if s > string(al[j]) {
			break
		}
	}
	if j >= len(al) {
		fmt.Println("None")
	} else {
		fmt.Println(string(al[j]))
	}

}
//  [ruby]
s=gets.chomp
a=[*'a'..'z'].select{|c|!s.include?(c)}
puts a.size>0?a[0]:"None"
//  [ruby]
# 英小文字からなる文字列 S が与えられます．
# S に現れない英小文字であって，最も辞書順（アルファベット順）で小さいものを求めてください．
# ただし，S にすべての英小文字が現れる場合は，代わりに None を出力してください．

s = gets.chomp

result = "None"

("a".."z").each do |char|
  unless s.include?(char)
    result = char
    break
  end
end

puts result
//  [ruby]
s = gets
puts ('a'..'z').find{|c| !s.index(c) } || 'None'
//  [ruby]
s=[*?a..?z]
gets.chomp.each_char{|t|s.delete(t)}
puts s.empty? :None : s[0]
//  [ruby]
s=[*?a..?z]
gets.chomp.each_char{|t|s.delete(t)}
puts s[0]
//  [ruby]
s = gets.chomp.chars
#list = {"a" => 0, "b" => 0, "c" => 0, "d" => 0, "e" => 0, "f" => 0, "g" => 0, "h" => 0, "i" => 0, "j" => 0, "k" => 0, "l" => 0, "m" => 0, "n" => 0, "o" => 0, "p" => 0, "q" => 0, "r" => 0, "s" => 0, "t" => 0, "u" => 0, "v" => 0, "w" => 0, "x" => 0, "y" => 0, "z" => 0}
l = "abcdefghijklmnopqrstuvwxyz".chars

s.each do |i|
  l.delete(i)
end

if l.length > 0
  print l.join('')
else
  print "None"
end
//  [rust]
macro_rules! input {
    (source = $s:expr, $($r:tt)*) => {
        let mut iter = $s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
    ($($r:tt)*) => {
        let mut 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 mut $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")
    };
}

// use std::io::{stdout, Write, BufWriter};
//use std::cmp::{max};

const ALPHABETS_L: &'static str = "abcdefghijklmnopqrstuvwxyz";

fn main() {
    input! {
        s: String,
    }

    for c in ALPHABETS_L.chars() {
        if !s.contains(c) {
            println!("{}", c);
            return;
        }
    }
    println!("None");
}
//  [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
    };

    // Rust version 1.15.1, which is used by AtCoder,
    // does not support std::str::FromStr for char
    ($iter:expr, char) => {
        $iter.next().unwrap().chars().next().expect("Parse error")
    };

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

#[allow(unused_imports)]
fn main() {
    use std::cmp::max;
    use std::cmp::min;
    use std::collections::HashMap;

    input!{
        s: chars,
    }
    let mut v = [false; 26];
    for c in s {
        v[c as usize - 'a' as usize] = true;
    }
    for i in 0..26 {
        if v[i] == false {
            println!("{}", char::from((i + 'a' as usize) as u8));
            return;
        }
    }
    println!("None");
}
//  [rust]
use std::io;
use std::cmp;

// read a line(without line feed)
fn read_line() -> String {
    let mut in_str = String::new();
    io::stdin().read_line(&mut in_str).unwrap();
    return in_str.trim().to_string();
}

// read wods on a line
pub fn read_words_in_line() -> Vec<String> {
    let s = read_line();
    return s.split_whitespace().map(|x| x.to_string()).collect::<Vec<String>>()
}

// read type t on a line
pub fn read_t_in_line<T : std::str::FromStr>() -> Vec<T> {
    let mut v : Vec<T> = Vec::new();
    for e in read_words_in_line().iter().map(|x| x.parse::<T>()) {
        if let Ok(r) = e {
            v.push(r);
        }
        else{
            return Vec::new();
        }
    }
    return v;
}

// sort slice
pub fn sort<T : std::cmp::Ord>(slice : &mut [T]) {
    slice.sort();
}
// sort slice by reverse order
pub fn sort_rev<T : std::cmp::Ord>(slice : &mut [T]) {
    slice.sort_by(|x, y| y.cmp(x));
}

pub fn min<T : std::cmp::Ord>(a : T, b : T) -> T{
    return cmp::min(a, b);
}

pub fn max<T : std::cmp::Ord>(a : T, b : T) -> T{
    return cmp::max(a, b);
}

fn main() {

    let s = read_line().into_bytes();
    let mut ary = [0 ; 26];

    for b in s {
        ary[(b - 'a' as u8) as usize] += 1;
    }
    
    let mut ans = -1 as i32;
    for i in 0..26 {
        if ary[i] == 0{
            ans = i as i32;
            break;
        }
    }
    if ans == -1 {
        println!("None");
    }
    else{
        println!("{}", ((ans as u8) + ('a' as u8)) as char);
    }
    
}
//  [rust]
use proconio::{input, fastout};
use proconio::marker::{Chars};
use proconio::marker::Usize1;
use std::cmp::*;
use std::char;

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

#[fastout]
fn main() {
    input!{
        s: Chars,
    }

    let mut alphabet: Vec<usize> = vec![0;30];
    for i in 0..s.len() {
        alphabet[s[i] as usize - 'a' as usize] += 1;
    }
    debug!('a' as usize);
    debug!(alphabet);
    for i in 0..s.len() {
        if alphabet[i]==0 {
            println!("{}", char::from_u32(i as u32 + 'a' as u32).unwrap());
            return;
        }
    }
    println!("None");
}
//  [rust]
#![allow(unused_imports)]
// use itertools::Itertools;
use proconio::{input, marker::*};

fn main() {
    input! {
        s: Chars
    };
    let mut arr = [true; 128];
    for c in s {
        arr[c as usize] = false;
    }
    for i in b'a'..b'z' {
        if arr[i as usize] {
            println!("{}", i as char);
            return;
        }
    }
    println!("None");
}
//  [swift]
import Foundation
let alpha = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m",
             "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z"]

let main = {
  let s = readLine()!
  for c in alpha {
    if !s.contains(c) {
      print(c)
      return
    }
  }
  print("None")
}
main()